@backblaze-labs/b2-sdk 0.1.0

package/dist/sync/scanners/b2.d.ts

@@ -0,0 +1,20 @@
+import { Bucket } from '../../bucket.js';
+import { B2SyncPath, SyncFolder } from '../types.js';
+/**
+ * Scans a B2 bucket (optionally filtered by prefix) and yields {@link B2SyncPath} entries
+ * sorted by file name. Hidden files are excluded. All versions are fetched and grouped.
+ */
+export declare class B2Folder implements SyncFolder {
+    readonly type: "b2";
+    private readonly bucket;
+    private readonly prefix;
+    /**
+     * Creates a new B2Folder for the given bucket and optional prefix.
+     * @param bucket - The B2 bucket to scan.
+     * @param prefix - Optional key prefix to restrict the scan scope.
+     */
+    constructor(bucket: Bucket, prefix?: string);
+    /** Lists all file versions in the bucket, groups by name, and yields the latest visible version. */
+    scan(): AsyncGenerator<B2SyncPath>;
+}
+//# sourceMappingURL=b2.d.ts.map

package/dist/sync/scanners/b2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"b2.d.ts","sourceRoot":"","sources":["../../../src/sync/scanners/b2.js"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAE7C,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAEzD;;;GAGG;AACH,qBAAa,QAAS,YAAW,UAAU;IACzC,QAAQ,CAAC,IAAI,EAAG,IAAI,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAE/B;;;;OAIG;gBACS,MAAM,EAAE,MAAM,EAAE,MAAM,SAAK;IAKvC,oGAAoG;IAC7F,IAAI,IAAI,cAAc,CAAC,UAAU,CAAC;CA+C1C"}

package/dist/sync/scanners/b2.js

@@ -0,0 +1,57 @@
+import { FileAction } from "../../types/file.js";
+class B2Folder {
+  type = "b2";
+  bucket;
+  prefix;
+  /**
+   * Creates a new B2Folder for the given bucket and optional prefix.
+   * @param bucket - The B2 bucket to scan.
+   * @param prefix - Optional key prefix to restrict the scan scope.
+   */
+  constructor(bucket, prefix = "") {
+    this.bucket = bucket;
+    this.prefix = prefix;
+  }
+  /** Lists all file versions in the bucket, groups by name, and yields the latest visible version. */
+  async *scan() {
+    const grouped = /* @__PURE__ */ new Map();
+    let startFileName;
+    let startFileId;
+    while (true) {
+      const listing = await this.bucket.listFileVersions({
+        ...this.prefix !== "" ? { prefix: this.prefix } : {},
+        ...startFileName !== void 0 ? { startFileName } : {},
+        ...startFileId !== void 0 ? { startFileId } : {}
+      });
+      for (const fv of listing.files) {
+        const existing = grouped.get(fv.fileName);
+        if (existing) {
+          existing.push(fv);
+        } else {
+          grouped.set(fv.fileName, [fv]);
+        }
+      }
+      if (!listing.nextFileName) break;
+      startFileName = listing.nextFileName;
+      startFileId = listing.nextFileId;
+    }
+    const sorted = [...grouped.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+    for (const [fileName, versions] of sorted) {
+      versions.sort((a, b) => b.uploadTimestamp - a.uploadTimestamp);
+      const selected = versions[0];
+      if (!selected || selected.action === FileAction.Hide) continue;
+      const relativePath = this.prefix !== "" ? fileName.slice(this.prefix.length) : fileName;
+      yield {
+        relativePath,
+        modTimeMillis: selected.uploadTimestamp,
+        size: selected.contentLength,
+        selectedVersion: selected,
+        allVersions: versions
+      };
+    }
+  }
+}
+export {
+  B2Folder
+};
+//# sourceMappingURL=b2.js.map

package/dist/sync/scanners/b2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"b2.js","sources":["../../../src/sync/scanners/b2.ts"],"sourcesContent":["import type { Bucket } from '../../bucket.ts'\nimport { FileAction, type FileVersion } from '../../types/file.ts'\nimport type { B2SyncPath, SyncFolder } from '../types.ts'\n\n/**\n * Scans a B2 bucket (optionally filtered by prefix) and yields {@link B2SyncPath} entries\n * sorted by file name. Hidden files are excluded. All versions are fetched and grouped.\n */\nexport class B2Folder implements SyncFolder {\n  readonly type = 'b2' as const\n  private readonly bucket: Bucket\n  private readonly prefix: string\n\n  /**\n   * Creates a new B2Folder for the given bucket and optional prefix.\n   * @param bucket - The B2 bucket to scan.\n   * @param prefix - Optional key prefix to restrict the scan scope.\n   */\n  constructor(bucket: Bucket, prefix = '') {\n    this.bucket = bucket\n    this.prefix = prefix\n  }\n\n  /** Lists all file versions in the bucket, groups by name, and yields the latest visible version. */\n  async *scan(): AsyncGenerator<B2SyncPath> {\n    const grouped = new Map<string, FileVersion[]>()\n\n    let startFileName: string | undefined\n    let startFileId: string | undefined\n\n    while (true) {\n      const listing = await this.bucket.listFileVersions({\n        ...(this.prefix !== '' ? { prefix: this.prefix } : {}),\n        ...(startFileName !== undefined ? { startFileName } : {}),\n        ...(startFileId !== undefined\n          ? { startFileId: startFileId as import('../../types/ids.ts').FileId }\n          : {}),\n      })\n\n      for (const fv of listing.files) {\n        const existing = grouped.get(fv.fileName)\n        if (existing) {\n          existing.push(fv)\n        } else {\n          grouped.set(fv.fileName, [fv])\n        }\n      }\n\n      if (!listing.nextFileName) break\n      startFileName = listing.nextFileName\n      startFileId = listing.nextFileId as string | undefined\n    }\n\n    const sorted = [...grouped.entries()].sort((a, b) => a[0].localeCompare(b[0]))\n\n    for (const [fileName, versions] of sorted) {\n      versions.sort((a, b) => b.uploadTimestamp - a.uploadTimestamp)\n      const selected = versions[0]\n      if (!selected || selected.action === FileAction.Hide) continue\n\n      const relativePath = this.prefix !== '' ? fileName.slice(this.prefix.length) : fileName\n\n      yield {\n        relativePath,\n        modTimeMillis: selected.uploadTimestamp,\n        size: selected.contentLength,\n        selectedVersion: selected,\n        allVersions: versions,\n      }\n    }\n  }\n}\n"],"names":[],"mappings":";AAQO,MAAM,SAA+B;AAAA,EACjC,OAAO;AAAA,EACC;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOjB,YAAY,QAAgB,SAAS,IAAI;AACvC,SAAK,SAAS;AACd,SAAK,SAAS;AAAA,EAChB;AAAA;AAAA,EAGA,OAAO,OAAmC;AACxC,UAAM,8BAAc,IAAA;AAEpB,QAAI;AACJ,QAAI;AAEJ,WAAO,MAAM;AACX,YAAM,UAAU,MAAM,KAAK,OAAO,iBAAiB;AAAA,QACjD,GAAI,KAAK,WAAW,KAAK,EAAE,QAAQ,KAAK,OAAA,IAAW,CAAA;AAAA,QACnD,GAAI,kBAAkB,SAAY,EAAE,cAAA,IAAkB,CAAA;AAAA,QACtD,GAAI,gBAAgB,SAChB,EAAE,gBACF,CAAA;AAAA,MAAC,CACN;AAED,iBAAW,MAAM,QAAQ,OAAO;AAC9B,cAAM,WAAW,QAAQ,IAAI,GAAG,QAAQ;AACxC,YAAI,UAAU;AACZ,mBAAS,KAAK,EAAE;AAAA,QAClB,OAAO;AACL,kBAAQ,IAAI,GAAG,UAAU,CAAC,EAAE,CAAC;AAAA,QAC/B;AAAA,MACF;AAEA,UAAI,CAAC,QAAQ,aAAc;AAC3B,sBAAgB,QAAQ;AACxB,oBAAc,QAAQ;AAAA,IACxB;AAEA,UAAM,SAAS,CAAC,GAAG,QAAQ,QAAA,CAAS,EAAE,KAAK,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC;AAE7E,eAAW,CAAC,UAAU,QAAQ,KAAK,QAAQ;AACzC,eAAS,KAAK,CAAC,GAAG,MAAM,EAAE,kBAAkB,EAAE,eAAe;AAC7D,YAAM,WAAW,SAAS,CAAC;AAC3B,UAAI,CAAC,YAAY,SAAS,WAAW,WAAW,KAAM;AAEtD,YAAM,eAAe,KAAK,WAAW,KAAK,SAAS,MAAM,KAAK,OAAO,MAAM,IAAI;AAE/E,YAAM;AAAA,QACJ;AAAA,QACA,eAAe,SAAS;AAAA,QACxB,MAAM,SAAS;AAAA,QACf,iBAAiB;AAAA,QACjB,aAAa;AAAA,MAAA;AAAA,IAEjB;AAAA,EACF;AACF;"}

package/dist/sync/scanners/local.cjs

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const promises = require("node:fs/promises");
+const node_path = require("node:path");
+class LocalFolder {
+  type = "local";
+  /** Absolute path to the local root directory. */
+  root;
+  /**
+   * Creates a new LocalFolder for the given root directory.
+   * @param root - Absolute path to the local directory to scan.
+   */
+  constructor(root) {
+    this.root = root;
+  }
+  /** Recursively walks the directory and yields files sorted by relative path. */
+  async *scan() {
+    const collected = [];
+    await this.walk(this.root, collected);
+    collected.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+    for (const entry of collected) {
+      yield entry;
+    }
+  }
+  /**
+   * Recursively collects files from {@link dir} into {@link out}.
+   * @param dir - Absolute path of the directory to scan.
+   * @param out - Accumulator array that receives discovered file entries.
+   */
+  async walk(dir, out) {
+    let entries;
+    try {
+      entries = await promises.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = node_path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await this.walk(fullPath, out);
+      } else if (entry.isFile()) {
+        try {
+          const s = await promises.stat(fullPath);
+          const rel = node_path.relative(this.root, fullPath).split(node_path.sep).join("/");
+          out.push({
+            relativePath: rel,
+            absolutePath: fullPath,
+            modTimeMillis: Math.floor(s.mtimeMs),
+            size: s.size
+          });
+        } catch {
+        }
+      }
+    }
+  }
+}
+exports.LocalFolder = LocalFolder;
+//# sourceMappingURL=local.cjs.map

package/dist/sync/scanners/local.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.cjs","sources":["../../../src/sync/scanners/local.ts"],"sourcesContent":["import { readdir, stat } from 'node:fs/promises'\nimport { join, relative, sep } from 'node:path'\nimport type { LocalSyncPath, SyncFolder } from '../types.ts'\n\n/**\n * Scans a local directory tree and yields {@link LocalSyncPath} entries\n * sorted by relative path. Unreadable files and directories are silently skipped.\n */\nexport class LocalFolder implements SyncFolder {\n  readonly type = 'local' as const\n  /** Absolute path to the local root directory. */\n  readonly root: string\n\n  /**\n   * Creates a new LocalFolder for the given root directory.\n   * @param root - Absolute path to the local directory to scan.\n   */\n  constructor(root: string) {\n    this.root = root\n  }\n\n  /** Recursively walks the directory and yields files sorted by relative path. */\n  async *scan(): AsyncGenerator<LocalSyncPath> {\n    const collected: LocalSyncPath[] = []\n    await this.walk(this.root, collected)\n    collected.sort((a, b) => a.relativePath.localeCompare(b.relativePath))\n    for (const entry of collected) {\n      yield entry\n    }\n  }\n\n  /**\n   * Recursively collects files from {@link dir} into {@link out}.\n   * @param dir - Absolute path of the directory to scan.\n   * @param out - Accumulator array that receives discovered file entries.\n   */\n  private async walk(dir: string, out: LocalSyncPath[]): Promise<void> {\n    let entries: import('node:fs').Dirent[]\n    try {\n      entries = await readdir(dir, { withFileTypes: true })\n    } catch {\n      return\n    }\n\n    for (const entry of entries) {\n      const fullPath = join(dir, entry.name)\n      if (entry.isDirectory()) {\n        await this.walk(fullPath, out)\n      } else if (entry.isFile()) {\n        try {\n          const s = await stat(fullPath)\n          const rel = relative(this.root, fullPath).split(sep).join('/')\n          out.push({\n            relativePath: rel,\n            absolutePath: fullPath,\n            modTimeMillis: Math.floor(s.mtimeMs),\n            size: s.size,\n          })\n        } catch {\n          // skip unreadable files\n        }\n      }\n    }\n  }\n}\n"],"names":["readdir","join","stat","relative","sep"],"mappings":";;;;AAQO,MAAM,YAAkC;AAAA,EACpC,OAAO;AAAA;AAAA,EAEP;AAAA;AAAA;AAAA;AAAA;AAAA,EAMT,YAAY,MAAc;AACxB,SAAK,OAAO;AAAA,EACd;AAAA;AAAA,EAGA,OAAO,OAAsC;AAC3C,UAAM,YAA6B,CAAA;AACnC,UAAM,KAAK,KAAK,KAAK,MAAM,SAAS;AACpC,cAAU,KAAK,CAAC,GAAG,MAAM,EAAE,aAAa,cAAc,EAAE,YAAY,CAAC;AACrE,eAAW,SAAS,WAAW;AAC7B,YAAM;AAAA,IACR;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAc,KAAK,KAAa,KAAqC;AACnE,QAAI;AACJ,QAAI;AACF,gBAAU,MAAMA,SAAAA,QAAQ,KAAK,EAAE,eAAe,MAAM;AAAA,IACtD,QAAQ;AACN;AAAA,IACF;AAEA,eAAW,SAAS,SAAS;AAC3B,YAAM,WAAWC,UAAAA,KAAK,KAAK,MAAM,IAAI;AACrC,UAAI,MAAM,eAAe;AACvB,cAAM,KAAK,KAAK,UAAU,GAAG;AAAA,MAC/B,WAAW,MAAM,UAAU;AACzB,YAAI;AACF,gBAAM,IAAI,MAAMC,SAAAA,KAAK,QAAQ;AAC7B,gBAAM,MAAMC,UAAAA,SAAS,KAAK,MAAM,QAAQ,EAAE,MAAMC,UAAAA,GAAG,EAAE,KAAK,GAAG;AAC7D,cAAI,KAAK;AAAA,YACP,cAAc;AAAA,YACd,cAAc;AAAA,YACd,eAAe,KAAK,MAAM,EAAE,OAAO;AAAA,YACnC,MAAM,EAAE;AAAA,UAAA,CACT;AAAA,QACH,QAAQ;AAAA,QAER;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;;"}

package/dist/sync/scanners/local.d.cts

@@ -0,0 +1,24 @@
+import { LocalSyncPath, SyncFolder } from '../types.js';
+/**
+ * Scans a local directory tree and yields {@link LocalSyncPath} entries
+ * sorted by relative path. Unreadable files and directories are silently skipped.
+ */
+export declare class LocalFolder implements SyncFolder {
+    readonly type: "local";
+    /** Absolute path to the local root directory. */
+    readonly root: string;
+    /**
+     * Creates a new LocalFolder for the given root directory.
+     * @param root - Absolute path to the local directory to scan.
+     */
+    constructor(root: string);
+    /** Recursively walks the directory and yields files sorted by relative path. */
+    scan(): AsyncGenerator<LocalSyncPath>;
+    /**
+     * Recursively collects files from {@link dir} into {@link out}.
+     * @param dir - Absolute path of the directory to scan.
+     * @param out - Accumulator array that receives discovered file entries.
+     */
+    private walk;
+}
+//# sourceMappingURL=local.d.ts.map

package/dist/sync/scanners/local.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.d.ts","sourceRoot":"","sources":["../../../src/sync/scanners/local.js"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAE5D;;;GAGG;AACH,qBAAa,WAAY,YAAW,UAAU;IAC5C,QAAQ,CAAC,IAAI,EAAG,OAAO,CAAS;IAChC,iDAAiD;IACjD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IAErB;;;OAGG;gBACS,IAAI,EAAE,MAAM;IAIxB,gFAAgF;IACzE,IAAI,IAAI,cAAc,CAAC,aAAa,CAAC;IAS5C;;;;OAIG;YACW,IAAI;CA4BnB"}

package/dist/sync/scanners/local.d.ts

@@ -0,0 +1,24 @@
+import { LocalSyncPath, SyncFolder } from '../types.js';
+/**
+ * Scans a local directory tree and yields {@link LocalSyncPath} entries
+ * sorted by relative path. Unreadable files and directories are silently skipped.
+ */
+export declare class LocalFolder implements SyncFolder {
+    readonly type: "local";
+    /** Absolute path to the local root directory. */
+    readonly root: string;
+    /**
+     * Creates a new LocalFolder for the given root directory.
+     * @param root - Absolute path to the local directory to scan.
+     */
+    constructor(root: string);
+    /** Recursively walks the directory and yields files sorted by relative path. */
+    scan(): AsyncGenerator<LocalSyncPath>;
+    /**
+     * Recursively collects files from {@link dir} into {@link out}.
+     * @param dir - Absolute path of the directory to scan.
+     * @param out - Accumulator array that receives discovered file entries.
+     */
+    private walk;
+}
+//# sourceMappingURL=local.d.ts.map

package/dist/sync/scanners/local.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.d.ts","sourceRoot":"","sources":["../../../src/sync/scanners/local.js"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAE5D;;;GAGG;AACH,qBAAa,WAAY,YAAW,UAAU;IAC5C,QAAQ,CAAC,IAAI,EAAG,OAAO,CAAS;IAChC,iDAAiD;IACjD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IAErB;;;OAGG;gBACS,IAAI,EAAE,MAAM;IAIxB,gFAAgF;IACzE,IAAI,IAAI,cAAc,CAAC,aAAa,CAAC;IAS5C;;;;OAIG;YACW,IAAI;CA4BnB"}

package/dist/sync/scanners/local.js

@@ -0,0 +1,58 @@
+import { readdir, stat } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+class LocalFolder {
+  type = "local";
+  /** Absolute path to the local root directory. */
+  root;
+  /**
+   * Creates a new LocalFolder for the given root directory.
+   * @param root - Absolute path to the local directory to scan.
+   */
+  constructor(root) {
+    this.root = root;
+  }
+  /** Recursively walks the directory and yields files sorted by relative path. */
+  async *scan() {
+    const collected = [];
+    await this.walk(this.root, collected);
+    collected.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+    for (const entry of collected) {
+      yield entry;
+    }
+  }
+  /**
+   * Recursively collects files from {@link dir} into {@link out}.
+   * @param dir - Absolute path of the directory to scan.
+   * @param out - Accumulator array that receives discovered file entries.
+   */
+  async walk(dir, out) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await this.walk(fullPath, out);
+      } else if (entry.isFile()) {
+        try {
+          const s = await stat(fullPath);
+          const rel = relative(this.root, fullPath).split(sep).join("/");
+          out.push({
+            relativePath: rel,
+            absolutePath: fullPath,
+            modTimeMillis: Math.floor(s.mtimeMs),
+            size: s.size
+          });
+        } catch {
+        }
+      }
+    }
+  }
+}
+export {
+  LocalFolder
+};
+//# sourceMappingURL=local.js.map

package/dist/sync/scanners/local.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.js","sources":["../../../src/sync/scanners/local.ts"],"sourcesContent":["import { readdir, stat } from 'node:fs/promises'\nimport { join, relative, sep } from 'node:path'\nimport type { LocalSyncPath, SyncFolder } from '../types.ts'\n\n/**\n * Scans a local directory tree and yields {@link LocalSyncPath} entries\n * sorted by relative path. Unreadable files and directories are silently skipped.\n */\nexport class LocalFolder implements SyncFolder {\n  readonly type = 'local' as const\n  /** Absolute path to the local root directory. */\n  readonly root: string\n\n  /**\n   * Creates a new LocalFolder for the given root directory.\n   * @param root - Absolute path to the local directory to scan.\n   */\n  constructor(root: string) {\n    this.root = root\n  }\n\n  /** Recursively walks the directory and yields files sorted by relative path. */\n  async *scan(): AsyncGenerator<LocalSyncPath> {\n    const collected: LocalSyncPath[] = []\n    await this.walk(this.root, collected)\n    collected.sort((a, b) => a.relativePath.localeCompare(b.relativePath))\n    for (const entry of collected) {\n      yield entry\n    }\n  }\n\n  /**\n   * Recursively collects files from {@link dir} into {@link out}.\n   * @param dir - Absolute path of the directory to scan.\n   * @param out - Accumulator array that receives discovered file entries.\n   */\n  private async walk(dir: string, out: LocalSyncPath[]): Promise<void> {\n    let entries: import('node:fs').Dirent[]\n    try {\n      entries = await readdir(dir, { withFileTypes: true })\n    } catch {\n      return\n    }\n\n    for (const entry of entries) {\n      const fullPath = join(dir, entry.name)\n      if (entry.isDirectory()) {\n        await this.walk(fullPath, out)\n      } else if (entry.isFile()) {\n        try {\n          const s = await stat(fullPath)\n          const rel = relative(this.root, fullPath).split(sep).join('/')\n          out.push({\n            relativePath: rel,\n            absolutePath: fullPath,\n            modTimeMillis: Math.floor(s.mtimeMs),\n            size: s.size,\n          })\n        } catch {\n          // skip unreadable files\n        }\n      }\n    }\n  }\n}\n"],"names":[],"mappings":";;AAQO,MAAM,YAAkC;AAAA,EACpC,OAAO;AAAA;AAAA,EAEP;AAAA;AAAA;AAAA;AAAA;AAAA,EAMT,YAAY,MAAc;AACxB,SAAK,OAAO;AAAA,EACd;AAAA;AAAA,EAGA,OAAO,OAAsC;AAC3C,UAAM,YAA6B,CAAA;AACnC,UAAM,KAAK,KAAK,KAAK,MAAM,SAAS;AACpC,cAAU,KAAK,CAAC,GAAG,MAAM,EAAE,aAAa,cAAc,EAAE,YAAY,CAAC;AACrE,eAAW,SAAS,WAAW;AAC7B,YAAM;AAAA,IACR;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAc,KAAK,KAAa,KAAqC;AACnE,QAAI;AACJ,QAAI;AACF,gBAAU,MAAM,QAAQ,KAAK,EAAE,eAAe,MAAM;AAAA,IACtD,QAAQ;AACN;AAAA,IACF;AAEA,eAAW,SAAS,SAAS;AAC3B,YAAM,WAAW,KAAK,KAAK,MAAM,IAAI;AACrC,UAAI,MAAM,eAAe;AACvB,cAAM,KAAK,KAAK,UAAU,GAAG;AAAA,MAC/B,WAAW,MAAM,UAAU;AACzB,YAAI;AACF,gBAAM,IAAI,MAAM,KAAK,QAAQ;AAC7B,gBAAM,MAAM,SAAS,KAAK,MAAM,QAAQ,EAAE,MAAM,GAAG,EAAE,KAAK,GAAG;AAC7D,cAAI,KAAK;AAAA,YACP,cAAc;AAAA,YACd,cAAc;AAAA,YACd,eAAe,KAAK,MAAM,EAAE,OAAO;AAAA,YACnC,MAAM,EAAE;AAAA,UAAA,CACT;AAAA,QACH,QAAQ;AAAA,QAER;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;"}

package/dist/sync/synchronizer.cjs

@@ -0,0 +1,203 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const source = require("../streams/source.cjs");
+const ids = require("../types/ids.cjs");
+const concurrency = require("../upload/concurrency.cjs");
+const defaults = require("../util/defaults.cjs");
+const toError = require("../util/to-error.cjs");
+const index$1 = require("./actions/index.cjs");
+const pairing = require("./pairing.cjs");
+const index = require("./policies/index.cjs");
+function resolveDirection(source2, dest) {
+  if (source2.type === "local" && dest.type === "b2") return "local-to-b2";
+  if (source2.type === "b2" && dest.type === "local") return "b2-to-local";
+  if (source2.type === "b2" && dest.type === "b2") return "b2-to-b2";
+  throw new Error(`Unsupported sync direction: ${source2.type} to ${dest.type}`);
+}
+async function* synchronize(config) {
+  const { source: source2, dest, options } = config;
+  const direction = resolveDirection(source2, dest);
+  const dryRun = options.dryRun ?? false;
+  const concurrency$1 = options.concurrency ?? defaults.DEFAULT_TRANSFER_CONCURRENCY;
+  const keepDays = options.keepDays ?? 0;
+  const compareThreshold = options.compareThreshold ?? 0;
+  const nowMillis = Date.now();
+  const factory = createActionFactory(config);
+  const actions = [];
+  for await (const pair of pairing.zipFolders(source2, dest)) {
+    if (options.signal?.aborted) return;
+    for (const action of index.generateActions(
+      pair,
+      direction,
+      options.compareMode,
+      options.keepMode,
+      keepDays,
+      nowMillis,
+      factory,
+      compareThreshold
+    )) {
+      actions.push(action);
+    }
+    yield { type: "compare", path: (pair[0] ?? pair[1])?.relativePath ?? "", size: 0 };
+  }
+  const sem = new concurrency.Semaphore(concurrency$1);
+  const results = [];
+  const errors = [];
+  const promises = actions.map(async (action) => {
+    await sem.acquire();
+    try {
+      if (options.signal?.aborted) return;
+      const event = await action.execute(dryRun);
+      results.push(event);
+    } catch (err) {
+      const errorValue = toError.toError(err);
+      errors.push(errorValue);
+      results.push({
+        type: "error",
+        path: action.relativePath,
+        size: 0,
+        message: errorValue.message
+      });
+    } finally {
+      sem.release();
+    }
+  });
+  await Promise.all(promises);
+  for (const event of results) {
+    yield event;
+  }
+  if (errors.length > 0) {
+    yield {
+      type: "error",
+      path: "",
+      size: 0,
+      message: `${errors.length} action(s) failed`
+    };
+  }
+}
+function assertBucket(bucket, context) {
+  if (!bucket) throw new Error(`Bucket required for ${context} actions`);
+}
+function createActionFactory(config) {
+  const upConfig = config;
+  const downConfig = config;
+  const destBucket = upConfig.bucket ?? downConfig.bucket;
+  const bucketIsLocked = destBucket?.info?.fileLockConfiguration?.value?.isFileLockEnabled ?? false;
+  const factory = {
+    upload(source$1) {
+      const bucket = upConfig.bucket;
+      const prefix = upConfig.prefix ?? "";
+      assertBucket(bucket, "upload");
+      return new index$1.UploadAction(
+        source$1.relativePath,
+        source$1.absolutePath,
+        source$1.size,
+        async (absPath, relPath) => {
+          const { readFile } = await import("node:fs/promises");
+          const data = await readFile(absPath);
+          await bucket.upload({
+            fileName: `${prefix}${relPath}`,
+            source: new source.BufferSource(new Uint8Array(data))
+          });
+        }
+      );
+    },
+    download(source2) {
+      const bucket = downConfig.bucket;
+      const root = downConfig.dest?.type === "local" ? downConfig.dest.root : "";
+      assertBucket(bucket, "download");
+      return new index$1.DownloadAction(source2.relativePath, source2.size, async (relPath) => {
+        const result = await bucket.download(source2.selectedVersion.fileName);
+        const reader = result.body.getReader();
+        let combined;
+        try {
+          const chunks = [];
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            chunks.push(value);
+          }
+          let total = 0;
+          for (const c of chunks) total += c.byteLength;
+          combined = new Uint8Array(total);
+          let offset = 0;
+          for (const c of chunks) {
+            combined.set(c, offset);
+            offset += c.byteLength;
+          }
+        } finally {
+          reader.releaseLock();
+        }
+        const { mkdir, writeFile } = await import("node:fs/promises");
+        const { dirname, join } = await import("node:path");
+        const destPath = join(root, relPath);
+        await mkdir(dirname(destPath), { recursive: true });
+        await writeFile(destPath, combined);
+      });
+    },
+    copy(source2, destPath) {
+      const bucket = upConfig.bucket;
+      assertBucket(bucket, "copy");
+      return new index$1.CopyAction(source2.relativePath, source2.size, async () => {
+        await bucket.copyFile({
+          sourceFileId: source2.selectedVersion.fileId,
+          fileName: destPath
+        });
+      });
+    },
+    hide(path) {
+      const bucket = upConfig.bucket ?? downConfig.bucket;
+      assertBucket(bucket, "hide");
+      return new index$1.HideAction(path, async (relPath) => {
+        const prefix = upConfig.prefix ?? "";
+        await bucket.hideFile(`${prefix}${relPath}`);
+      });
+    },
+    deleteRemote(path) {
+      const bucket = upConfig.bucket ?? downConfig.bucket;
+      assertBucket(bucket, "delete");
+      const b2FileName = path.selectedVersion.fileName;
+      return new index$1.DeleteRemoteAction(
+        path.relativePath,
+        path.selectedVersion.fileId,
+        async (fileId) => {
+          await bucket.deleteFileVersion(b2FileName, ids.fileId(fileId));
+        }
+      );
+    },
+    deleteLocal(path) {
+      return new index$1.DeleteLocalAction(path.relativePath, path.absolutePath, async (absPath) => {
+        const { unlink } = await import("node:fs/promises");
+        await unlink(absPath);
+      });
+    },
+    removeOrphan(dest) {
+      return bucketIsLocked ? factory.hide(dest.relativePath) : factory.deleteRemote(dest);
+    }
+  };
+  return factory;
+}
+exports.synchronize = synchronize;
+//# sourceMappingURL=synchronizer.cjs.map

package/dist/sync/synchronizer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"synchronizer.cjs","sources":["../../src/sync/synchronizer.ts"],"sourcesContent":["import type { Bucket } from '../bucket.ts'\nimport { BufferSource } from '../streams/source.ts'\nimport { fileId as fileIdOf } from '../types/ids.ts'\nimport { Semaphore } from '../upload/concurrency.ts'\nimport { DEFAULT_TRANSFER_CONCURRENCY } from '../util/defaults.ts'\nimport { toError } from '../util/to-error.ts'\nimport type { SyncAction } from './actions/index.ts'\nimport {\n  CopyAction,\n  DeleteLocalAction,\n  DeleteRemoteAction,\n  DownloadAction,\n  HideAction,\n  UploadAction,\n} from './actions/index.ts'\nimport { zipFolders } from './pairing.ts'\nimport type { ActionFactory } from './policies/index.ts'\nimport { generateActions } from './policies/index.ts'\nimport type {\n  B2SyncPath,\n  LocalSyncPath,\n  SyncDirection,\n  SyncEvent,\n  SyncFolder,\n  SyncOptions,\n} from './types.ts'\n\n/** Base configuration for a sync operation. */\nexport interface SynchronizerConfig {\n  /** The folder to read files from. */\n  readonly source: SyncFolder\n  /** The folder to write files to. */\n  readonly dest: SyncFolder\n  /** Options controlling comparison, deletion policy, and concurrency. */\n  readonly options: SyncOptions\n}\n\n/** A sync folder constrained to the local filesystem. */\nexport interface LocalSyncFolder extends SyncFolder {\n  /** Discriminant identifying a local folder. */\n  readonly type: 'local'\n  /** Absolute filesystem path to the local root directory. */\n  readonly root: string\n}\n\n/** A sync folder constrained to a B2 bucket prefix. */\nexport interface B2SyncFolder extends SyncFolder {\n  /** Discriminant identifying a B2 folder. */\n  readonly type: 'b2'\n}\n\n/** Configuration for a local-to-B2 sync (upload direction). */\nexport interface SynchronizerUpConfig extends SynchronizerConfig {\n  /** Local source folder. */\n  readonly source: LocalSyncFolder\n  /** B2 destination folder. */\n  readonly dest: B2SyncFolder\n  /** The target B2 bucket. */\n  readonly bucket: Bucket\n  /** Key prefix for uploaded files in the bucket. */\n  readonly prefix: string\n}\n\n/** Configuration for a B2-to-local sync (download direction). */\nexport interface SynchronizerDownConfig extends SynchronizerConfig {\n  /** B2 source folder. */\n  readonly source: B2SyncFolder\n  /** Local destination folder. */\n  readonly dest: LocalSyncFolder\n  /** The source B2 bucket. */\n  readonly bucket: Bucket\n}\n\n/**\n * Infers the sync direction from the source and destination folder types.\n * @param source - The folder to read files from.\n * @param dest - The folder to write files to.\n *\n * @returns The resolved sync direction based on folder types.\n *\n * @throws When the source and destination folder types form an unsupported combination.\n */\nfunction resolveDirection(source: SyncFolder, dest: SyncFolder): SyncDirection {\n  if (source.type === 'local' && dest.type === 'b2') return 'local-to-b2'\n  if (source.type === 'b2' && dest.type === 'local') return 'b2-to-local'\n  if (source.type === 'b2' && dest.type === 'b2') return 'b2-to-b2'\n  throw new Error(`Unsupported sync direction: ${source.type} to ${dest.type}`)\n}\n\n/**\n * Runs a full sync operation: scans both folders, pairs files, generates actions,\n * and executes them with bounded concurrency. Yields {@link SyncEvent} entries for\n * each comparison and action result.\n *\n * @param config - The synchronizer configuration (source, dest, options, and optional bucket).\n */\nexport async function* synchronize(config: SynchronizerConfig): AsyncGenerator<SyncEvent> {\n  const { source, dest, options } = config\n  const direction = resolveDirection(source, dest)\n  const dryRun = options.dryRun ?? false\n  const concurrency = options.concurrency ?? DEFAULT_TRANSFER_CONCURRENCY\n  const keepDays = options.keepDays ?? 0\n  const compareThreshold = options.compareThreshold ?? 0\n  const nowMillis = Date.now()\n\n  const factory = createActionFactory(config)\n\n  const actions: SyncAction[] = []\n\n  for await (const pair of zipFolders(source, dest)) {\n    if (options.signal?.aborted) return\n\n    for (const action of generateActions(\n      pair,\n      direction,\n      options.compareMode,\n      options.keepMode,\n      keepDays,\n      nowMillis,\n      factory,\n      compareThreshold,\n    )) {\n      actions.push(action)\n    }\n\n    yield { type: 'compare', path: (pair[0] ?? pair[1])?.relativePath ?? '', size: 0 }\n  }\n\n  const sem = new Semaphore(concurrency)\n  const results: SyncEvent[] = []\n  const errors: Error[] = []\n\n  const promises = actions.map(async (action) => {\n    await sem.acquire()\n    try {\n      if (options.signal?.aborted) return\n      const event = await action.execute(dryRun)\n      results.push(event)\n    } catch (err) {\n      const errorValue = toError(err)\n      errors.push(errorValue)\n      results.push({\n        type: 'error',\n        path: action.relativePath,\n        size: 0,\n        message: errorValue.message,\n      })\n    } finally {\n      sem.release()\n    }\n  })\n\n  await Promise.all(promises)\n\n  for (const event of results) {\n    yield event\n  }\n\n  if (errors.length > 0) {\n    yield {\n      type: 'error',\n      path: '',\n      size: 0,\n      message: `${errors.length} action(s) failed`,\n    }\n  }\n}\n\n/**\n * Narrowing assertion that a `Bucket` is present for an action that requires\n * it. Throws with a consistent, context-tagged message when the configured\n * direction did not supply one (e.g. `b2-to-local` direction asking for an\n * upload action).\n *\n * Uses TypeScript's `asserts` signature so call-site flow narrows\n * `bucket` from `Bucket | undefined` to `Bucket` after the check, without\n * requiring a separate `if (!bucket) throw ...` line per action factory.\n *\n * @param bucket - The (possibly missing) bucket reference.\n * @param context - Short verb describing the action being constructed\n *   (e.g. `'upload'`, `'download'`). Surfaced in the error message.\n *\n * @throws `Error` when `bucket` is `undefined` or `null`.\n */\nfunction assertBucket(bucket: Bucket | undefined, context: string): asserts bucket is Bucket {\n  if (!bucket) throw new Error(`Bucket required for ${context} actions`)\n}\n\n/**\n * Creates a configured sync engine wired to the bucket and paths in the given config.\n *\n * For sync operations that may need to remove destination-only files (the\n * `keepMode: 'delete'` policy), the factory reads the destination\n * bucket's cached `fileLockConfiguration` once so `removeOrphan` can\n * dispatch to either `hide` (locked buckets) or `deleteFileVersion`\n * (vanilla buckets) without a per-file branch. The cache is whatever\n * `client.listBuckets()` or `client.createBucket()` returned — callers\n * who flipped lock state mid-sync (rare) should refresh before\n * synchronize().\n *\n * @param config - The synchronizer configuration containing source, destination, and options.\n *\n * @returns An action factory bound to the provided configuration.\n */\nfunction createActionFactory(config: SynchronizerConfig): ActionFactory {\n  const upConfig = config as Partial<SynchronizerUpConfig>\n  const downConfig = config as Partial<SynchronizerDownConfig>\n\n  const destBucket = upConfig.bucket ?? downConfig.bucket\n  // Defensive optional chain on `info`: synchronizer tests use Bucket\n  // mocks that don't populate this field. Real `Bucket` instances always\n  // do (constructor parameter).\n  const bucketIsLocked = destBucket?.info?.fileLockConfiguration?.value?.isFileLockEnabled ?? false\n\n  const factory: ActionFactory = {\n    upload(source: LocalSyncPath): SyncAction {\n      const bucket = upConfig.bucket\n      const prefix = upConfig.prefix ?? ''\n      assertBucket(bucket, 'upload')\n\n      return new UploadAction(\n        source.relativePath,\n        source.absolutePath,\n        source.size,\n        async (absPath, relPath) => {\n          const { readFile } = await import('node:fs/promises')\n          const data = await readFile(absPath)\n          await bucket.upload({\n            fileName: `${prefix}${relPath}`,\n            source: new BufferSource(new Uint8Array(data)),\n          })\n        },\n      )\n    },\n\n    download(source: B2SyncPath): SyncAction {\n      const bucket = downConfig.bucket\n      const root =\n        downConfig.dest?.type === 'local' ? (downConfig.dest as { root: string }).root : ''\n      assertBucket(bucket, 'download')\n\n      return new DownloadAction(source.relativePath, source.size, async (relPath) => {\n        const result = await bucket.download(source.selectedVersion.fileName)\n        const reader = result.body.getReader()\n        let combined: Uint8Array\n        try {\n          const chunks: Uint8Array[] = []\n          while (true) {\n            const { done, value } = await reader.read()\n            if (done) break\n            chunks.push(value)\n          }\n          let total = 0\n          for (const c of chunks) total += c.byteLength\n          combined = new Uint8Array(total)\n          let offset = 0\n          for (const c of chunks) {\n            combined.set(c, offset)\n            offset += c.byteLength\n          }\n        } finally {\n          // Release the body stream's reader lock so a downstream\n          // writeFile failure doesn't strand the response stream half-\n          // open with the upstream HTTP connection still pumping.\n          reader.releaseLock()\n        }\n\n        const { mkdir, writeFile } = await import('node:fs/promises')\n        const { dirname, join } = await import('node:path')\n        const destPath = join(root, relPath)\n        await mkdir(dirname(destPath), { recursive: true })\n        await writeFile(destPath, combined)\n      })\n    },\n\n    copy(source: B2SyncPath, destPath: string): SyncAction {\n      const bucket = upConfig.bucket\n      assertBucket(bucket, 'copy')\n\n      return new CopyAction(source.relativePath, source.size, async () => {\n        await bucket.copyFile({\n          sourceFileId: source.selectedVersion.fileId,\n          fileName: destPath,\n        })\n      })\n    },\n\n    hide(path: string): SyncAction {\n      const bucket = upConfig.bucket ?? downConfig.bucket\n      assertBucket(bucket, 'hide')\n\n      return new HideAction(path, async (relPath) => {\n        const prefix = upConfig.prefix ?? ''\n        await bucket.hideFile(`${prefix}${relPath}`)\n      })\n    },\n\n    deleteRemote(path: B2SyncPath): SyncAction {\n      const bucket = upConfig.bucket ?? downConfig.bucket\n      assertBucket(bucket, 'delete')\n\n      // Bug fix: `DeleteRemoteAction` invokes the closure with\n      // `relativePath` (the scanner-stripped name relative to the sync\n      // prefix), but B2 stores files under the FULL name including the\n      // prefix. Use the FileVersion's authoritative `fileName` — the\n      // actual B2 key — rather than reconstructing it via prefix\n      // concat. Without this, syncs with a non-empty destination\n      // prefix (e.g. `'site/'`) failed orphan deletion with\n      // `file_not_present`.\n      const b2FileName = path.selectedVersion.fileName\n      return new DeleteRemoteAction(\n        path.relativePath,\n        path.selectedVersion.fileId as string,\n        async (fileId) => {\n          await bucket.deleteFileVersion(b2FileName, fileIdOf(fileId))\n        },\n      )\n    },\n\n    deleteLocal(path: LocalSyncPath): SyncAction {\n      return new DeleteLocalAction(path.relativePath, path.absolutePath, async (absPath) => {\n        const { unlink } = await import('node:fs/promises')\n        await unlink(absPath)\n      })\n    },\n\n    removeOrphan(dest: B2SyncPath): SyncAction {\n      // Locked buckets: `b2_delete_file_version` is blocked or stacks\n      // hide markers under retention; a hide is the safe choice.\n      // Vanilla buckets: plain delete is the right move — hide markers\n      // would just litter the version history.\n      return bucketIsLocked ? factory.hide(dest.relativePath) : factory.deleteRemote(dest)\n    },\n  }\n\n  return factory\n}\n"],"names":["source","concurrency","DEFAULT_TRANSFER_CONCURRENCY","zipFolders","generateActions","Semaphore","toError","UploadAction","BufferSource","DownloadAction","CopyAction","HideAction","DeleteRemoteAction","fileIdOf","DeleteLocalAction"],"mappings":"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"}

package/dist/sync/synchronizer.d.cts

@@ -0,0 +1,52 @@
+import { Bucket } from '../bucket.js';
+import { SyncEvent, SyncFolder, SyncOptions } from './types.js';
+/** Base configuration for a sync operation. */
+export interface SynchronizerConfig {
+    /** The folder to read files from. */
+    readonly source: SyncFolder;
+    /** The folder to write files to. */
+    readonly dest: SyncFolder;
+    /** Options controlling comparison, deletion policy, and concurrency. */
+    readonly options: SyncOptions;
+}
+/** A sync folder constrained to the local filesystem. */
+export interface LocalSyncFolder extends SyncFolder {
+    /** Discriminant identifying a local folder. */
+    readonly type: 'local';
+    /** Absolute filesystem path to the local root directory. */
+    readonly root: string;
+}
+/** A sync folder constrained to a B2 bucket prefix. */
+export interface B2SyncFolder extends SyncFolder {
+    /** Discriminant identifying a B2 folder. */
+    readonly type: 'b2';
+}
+/** Configuration for a local-to-B2 sync (upload direction). */
+export interface SynchronizerUpConfig extends SynchronizerConfig {
+    /** Local source folder. */
+    readonly source: LocalSyncFolder;
+    /** B2 destination folder. */
+    readonly dest: B2SyncFolder;
+    /** The target B2 bucket. */
+    readonly bucket: Bucket;
+    /** Key prefix for uploaded files in the bucket. */
+    readonly prefix: string;
+}
+/** Configuration for a B2-to-local sync (download direction). */
+export interface SynchronizerDownConfig extends SynchronizerConfig {
+    /** B2 source folder. */
+    readonly source: B2SyncFolder;
+    /** Local destination folder. */
+    readonly dest: LocalSyncFolder;
+    /** The source B2 bucket. */
+    readonly bucket: Bucket;
+}
+/**
+ * Runs a full sync operation: scans both folders, pairs files, generates actions,
+ * and executes them with bounded concurrency. Yields {@link SyncEvent} entries for
+ * each comparison and action result.
+ *
+ * @param config - The synchronizer configuration (source, dest, options, and optional bucket).
+ */
+export declare function synchronize(config: SynchronizerConfig): AsyncGenerator<SyncEvent>;
+//# sourceMappingURL=synchronizer.d.ts.map

package/dist/sync/synchronizer.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synchronizer.d.ts","sourceRoot":"","sources":["../../src/sync/synchronizer.js"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAkB1C,OAAO,KAAK,EAIV,SAAS,EACT,UAAU,EACV,WAAW,EACZ,MAAM,YAAY,CAAA;AAEnB,+CAA+C;AAC/C,MAAM,WAAW,kBAAkB;IACjC,qCAAqC;IACrC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;IAC3B,oCAAoC;IACpC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,wEAAwE;IACxE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAA;CAC9B;AAED,yDAAyD;AACzD,MAAM,WAAW,eAAgB,SAAQ,UAAU;IACjD,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,uDAAuD;AACvD,MAAM,WAAW,YAAa,SAAQ,UAAU;IAC9C,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;CACpB;AAED,+DAA+D;AAC/D,MAAM,WAAW,oBAAqB,SAAQ,kBAAkB;IAC9D,2BAA2B;IAC3B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAA;IAChC,6BAA6B;IAC7B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,4BAA4B;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,mDAAmD;IACnD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED,iEAAiE;AACjE,MAAM,WAAW,sBAAuB,SAAQ,kBAAkB;IAChE,wBAAwB;IACxB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;IAC7B,gCAAgC;IAChC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;IAC9B,4BAA4B;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAkBD;;;;;;GAMG;AACH,wBAAuB,WAAW,CAAC,MAAM,EAAE,kBAAkB,GAAG,cAAc,CAAC,SAAS,CAAC,CAsExF"}

package/dist/sync/synchronizer.d.ts

@@ -0,0 +1,52 @@
+import { Bucket } from '../bucket.js';
+import { SyncEvent, SyncFolder, SyncOptions } from './types.js';
+/** Base configuration for a sync operation. */
+export interface SynchronizerConfig {
+    /** The folder to read files from. */
+    readonly source: SyncFolder;
+    /** The folder to write files to. */
+    readonly dest: SyncFolder;
+    /** Options controlling comparison, deletion policy, and concurrency. */
+    readonly options: SyncOptions;
+}
+/** A sync folder constrained to the local filesystem. */
+export interface LocalSyncFolder extends SyncFolder {
+    /** Discriminant identifying a local folder. */
+    readonly type: 'local';
+    /** Absolute filesystem path to the local root directory. */
+    readonly root: string;
+}
+/** A sync folder constrained to a B2 bucket prefix. */
+export interface B2SyncFolder extends SyncFolder {
+    /** Discriminant identifying a B2 folder. */
+    readonly type: 'b2';
+}
+/** Configuration for a local-to-B2 sync (upload direction). */
+export interface SynchronizerUpConfig extends SynchronizerConfig {
+    /** Local source folder. */
+    readonly source: LocalSyncFolder;
+    /** B2 destination folder. */
+    readonly dest: B2SyncFolder;
+    /** The target B2 bucket. */
+    readonly bucket: Bucket;
+    /** Key prefix for uploaded files in the bucket. */
+    readonly prefix: string;
+}
+/** Configuration for a B2-to-local sync (download direction). */
+export interface SynchronizerDownConfig extends SynchronizerConfig {
+    /** B2 source folder. */
+    readonly source: B2SyncFolder;
+    /** Local destination folder. */
+    readonly dest: LocalSyncFolder;
+    /** The source B2 bucket. */
+    readonly bucket: Bucket;
+}
+/**
+ * Runs a full sync operation: scans both folders, pairs files, generates actions,
+ * and executes them with bounded concurrency. Yields {@link SyncEvent} entries for
+ * each comparison and action result.
+ *
+ * @param config - The synchronizer configuration (source, dest, options, and optional bucket).
+ */
+export declare function synchronize(config: SynchronizerConfig): AsyncGenerator<SyncEvent>;
+//# sourceMappingURL=synchronizer.d.ts.map

package/dist/sync/synchronizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synchronizer.d.ts","sourceRoot":"","sources":["../../src/sync/synchronizer.js"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAkB1C,OAAO,KAAK,EAIV,SAAS,EACT,UAAU,EACV,WAAW,EACZ,MAAM,YAAY,CAAA;AAEnB,+CAA+C;AAC/C,MAAM,WAAW,kBAAkB;IACjC,qCAAqC;IACrC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;IAC3B,oCAAoC;IACpC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,wEAAwE;IACxE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAA;CAC9B;AAED,yDAAyD;AACzD,MAAM,WAAW,eAAgB,SAAQ,UAAU;IACjD,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,uDAAuD;AACvD,MAAM,WAAW,YAAa,SAAQ,UAAU;IAC9C,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;CACpB;AAED,+DAA+D;AAC/D,MAAM,WAAW,oBAAqB,SAAQ,kBAAkB;IAC9D,2BAA2B;IAC3B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAA;IAChC,6BAA6B;IAC7B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,4BAA4B;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,mDAAmD;IACnD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED,iEAAiE;AACjE,MAAM,WAAW,sBAAuB,SAAQ,kBAAkB;IAChE,wBAAwB;IACxB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;IAC7B,gCAAgC;IAChC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;IAC9B,4BAA4B;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAkBD;;;;;;GAMG;AACH,wBAAuB,WAAW,CAAC,MAAM,EAAE,kBAAkB,GAAG,cAAc,CAAC,SAAS,CAAC,CAsExF"}