backupdrill 2.2.0 → 2.2.2

package/dist/backup.d.ts

@@ -1,13 +1,5 @@
 import type { BackupConfig } from "./config.js";
 import type { Manifest } from "./manifest.js";
-/**
- * Parse the major version out of `pg_dump --version` output.
- *
- * MUST tolerate a trailing vendor suffix: Homebrew/macOS prints `pg_dump (PostgreSQL) 17.2`, but
- * Debian/PGDG (what the deployed worker image uses) prints
- * `pg_dump (PostgreSQL) 17.10 (Debian 17.10-1.pgdg120+1)`. Anchoring the match to end-of-string
- * therefore breaks in production while passing on a dev Mac. Anchor on the `(PostgreSQL)` marker
- * instead, falling back to the first dotted version token for non-standard builds.
- */
-export declare function parsePgDumpMajor(raw: string): number | null;
+import { parsePgDumpMajor } from "./pgbin.js";
+export { parsePgDumpMajor };
 export declare function runBackup(config: BackupConfig): Promise<Manifest>;

package/dist/backup.js

@@ -11,6 +11,11 @@ import { renderRecoveryDoc } from "./recovery-doc.js";
 import { projectRefOf, refFromStorageEndpoint, assertNoHostOverride } from "./restore-engine.js";
 import { log } from "./log.js";
 import { TOOL_VERSION } from "./version.js";
+import { parsePgDumpMajor } from "./pgbin.js";
+import { relationBytes } from "./estimate.js";
+import { dumpPartSizeFor } from "./part-size.js";
+// 解析函数搬到了 pgbin(演练与恢复都要读 pg_restore 版本,放这里会成环);保留旧出口
+export { parsePgDumpMajor };
 import { dumpUrlFor, connectPg, isSupabaseHost } from "./supabase-ca.js";
 import { libpqChildEnv, urlSslModeOf } from "./restore-engine.js";
 const execFileAsync = promisify(execFile);
@@ -18,19 +23,6 @@ function majorOf(serverVersionNum) {
     // server_version_num: 150004 → 15,  170002 → 17
     return Math.floor(serverVersionNum / 10000);
 }
-/**
- * Parse the major version out of `pg_dump --version` output.
- *
- * MUST tolerate a trailing vendor suffix: Homebrew/macOS prints `pg_dump (PostgreSQL) 17.2`, but
- * Debian/PGDG (what the deployed worker image uses) prints
- * `pg_dump (PostgreSQL) 17.10 (Debian 17.10-1.pgdg120+1)`. Anchoring the match to end-of-string
- * therefore breaks in production while passing on a dev Mac. Anchor on the `(PostgreSQL)` marker
- * instead, falling back to the first dotted version token for non-standard builds.
- */
-export function parsePgDumpMajor(raw) {
-    const match = raw.match(/\(PostgreSQL\)\s+(\d+)/) ?? raw.match(/(\d+)(?:\.\d+)+/);
-    return match ? Number(match[1]) : null;
-}
 async function pgDumpVersion(bin) {
     try {
         const { stdout } = await execFileAsync(bin, ["--version"]);
@@ -76,6 +68,15 @@ async function inspectDatabase(databaseUrl, schemas) {
          join pg_namespace n on n.oid = e.extnamespace
         where e.extname <> 'plpgsql'
         order by e.extname`);
+        // 量体积失败不该让备份失败:分片退回保底值,200 GiB 以内的转储照常上传
+        let measuredBytes = null;
+        try {
+            measuredBytes = await relationBytes(client, schemas);
+        }
+        catch (error) {
+            log.warn(`Could not measure database size (${error.message}); ` +
+                `uploading with the baseline part size, which fits a dump of up to 200 GiB.`);
+        }
         return {
             serverVersion: version.rows[0].server_version,
             serverVersionNum: Number(versionNum.rows[0].server_version_num),
@@ -85,6 +86,7 @@ async function inspectDatabase(databaseUrl, schemas) {
                 estimatedRows: Number(r.estimated_rows),
             })),
             extensions: extensions.rows,
+            relationBytes: measuredBytes,
         };
     }
     finally {
@@ -92,7 +94,7 @@ async function inspectDatabase(databaseUrl, schemas) {
     }
 }
 /** 流式跑 pg_dump,边写 S3 边算 sha256 与字节数。返回校验和与大小。 */
-async function dumpToS3(config, s3, key, pgDumpBin) {
+async function dumpToS3(config, s3, key, pgDumpBin, partSize) {
     const hash = createHash("sha256");
     let bytes = 0;
     const meter = new Transform({
@@ -134,6 +136,7 @@ async function dumpToS3(config, s3, key, pgDumpBin) {
     });
     const upload = new Upload({
         client: s3,
+        partSize,
         params: {
             Bucket: config.storage.bucket,
             Key: key,
@@ -198,7 +201,7 @@ export async function runBackup(config) {
     const base = `${config.storage.prefix}/${config.projectName}/${timestamp}`;
     const dumpKey = `${base}/dump.pgcustom`;
     log.step(`Dumping → s3://${config.storage.bucket}/${dumpKey}`);
-    const { bytes, sha256 } = await dumpToS3(config, s3, dumpKey, pgDumpBin);
+    const { bytes, sha256 } = await dumpToS3(config, s3, dumpKey, pgDumpBin, dumpPartSizeFor(db.relationBytes));
     log.ok(`Database dumped (${(bytes / 1024 / 1024).toFixed(1)} MB, sha256 ${sha256.slice(0, 12)}…)`);
     // Storage 文件同步(源配置存在才做;否则只备数据库)
     let storageResult = null;

package/dist/drill.js

@@ -7,6 +7,7 @@ import { parseManifest } from "./manifest.js";
 import { targetClient, resolveSnapshot, getObjectText, downloadToFile, hashObject, } from "./snapshots.js";
 import { SANDBOX_MANAGED_ERROR, classifyBlocks, finalizePass, installExtensions, quoteIdent, restoreDatabaseArtifact, installSandboxShim, } from "./restore-engine.js";
 import { connectPg } from "./supabase-ca.js";
+import { localPgRestoreMajor, restoreToolBreaksOnTarget, sandboxMajorFor } from "./pgbin.js";
 import { log } from "./log.js";
 const execFileAsync = promisify(execFile);
 // Storage 校验默认抽样上限(避免每次演练重下全部文件产生大量 egress);超限如实记录
@@ -31,10 +32,10 @@ export function sampleStorageFiles(files, n) {
 /**
  * 沙箱镜像选择:alpine 镜像只带 contrib 扩展,装不了 pgvector——含 vector 列的
  * 备份在裸镜像里恢复必然硬崩("type vector does not exist")。manifest 记录了
- * vector 时换用 pgvector 官方镜像(同 major),其余维持轻量 alpine。
+ * vector 时换用 pgvector 官方镜像(同 major),其余维持轻量 alpine。major 由调用方给出
+ * (sandboxMajorFor:源库与本机 pg_restore 取大者),不一定等于源库版本。
  */
-function sandboxImage(manifest) {
-    const major = parseInt(manifest.database.serverVersion, 10);
+function sandboxImage(manifest, major) {
     const hasVector = (manifest.database.extensions ?? []).some((e) => e.name === "vector");
     return hasVector ? `pgvector/pgvector:pg${major}` : `postgres:${major}-alpine`;
 }
@@ -432,9 +433,25 @@ export async function drillDump(dumpPath, manifest, snapshot, preChecks = [], op
     }
     const checks = [...preChecks];
     await opts.supervision?.observe({ phase: "sandbox" });
-    const pg = await startEphemeralPostgres(sandboxImage(manifest), parseInt(manifest.database.serverVersion, 10), opts.supervision?.resourceName);
+    const sourceMajor = parseInt(manifest.database.serverVersion, 10);
+    const toolMajor = await localPgRestoreMajor();
+    const sandboxMajor = sandboxMajorFor(sourceMajor, toolMajor);
+    const pg = await startEphemeralPostgres(sandboxImage(manifest, sandboxMajor), sandboxMajor, opts.supervision?.resourceName);
     let pass = false; // 异常路径视为失败,供 finally 决定 --keep 是否保留沙箱
     try {
+        if (sandboxMajor !== sourceMajor) {
+            // 报告里写明沙箱比源库新以及原因:读报告的人要知道这次证明的是
+            // "能恢复进 PostgreSQL N",而不是同版本
+            checks.push({
+                name: "sandbox version",
+                pass: true,
+                detail: `restored into PostgreSQL ${sandboxMajor} (source is ${sourceMajor}): ` +
+                    (toolMajor !== null && restoreToolBreaksOnTarget(toolMajor, sourceMajor)
+                        ? `pg_restore ${toolMajor} sends SET transaction_timeout, which PostgreSQL ${sourceMajor} rejects`
+                        : `output of pg_restore ${toolMajor} is only guaranteed to load into PostgreSQL ${toolMajor} or newer`) +
+                    `; restoring into a newer major version is supported`,
+            });
+        }
         // 旧 manifest(≤0.1.1)没有 extensions 字段 → 不装任何扩展,行为与从前一致
         const extensions = manifest.database.extensions ?? [];
         const unavailable = await installExtensions(pg.connString, extensions);

package/dist/estimate.d.ts

@@ -1,3 +1,4 @@
+import type { Client } from "pg";
 import type { BackupConfig } from "./config.js";
 /**
  * Supabase egress 定价(2026-07-10 经核实,来源见 README「Egress & cost」)。
@@ -11,6 +12,13 @@ export interface EgressPricing {
     planLabel: string;
     hardCap: boolean;
 }
+/**
+ * 要转储的 schema 里所有表的磁盘占用。pg_total_relation_size 含索引+TOAST,是 egress
+ * 上界(真实转储经压缩、不含索引,更小)。备份也拿它估转储体积来定分片大小。
+ * 直接传 relid 而不是按名字转 regclass:统计视图读出来之后表被并发删掉,
+ * 按名字转会报错,按 oid 查只会得到 NULL。
+ */
+export declare function relationBytes(client: Client, schemas: string[]): Promise<number>;
 export interface EgressProjection {
     dbBytes: number;
     storageBytes: number;

package/dist/estimate.js

@@ -4,17 +4,22 @@ import { connectPg } from "./supabase-ca.js";
 // 超出这个月度成本就该提醒用户"备份的 egress 账单快赶上订阅费了"
 const SUBSCRIPTION_FLOOR_USD = 19;
 const GB = 1024 * 1024 * 1024;
+/**
+ * 要转储的 schema 里所有表的磁盘占用。pg_total_relation_size 含索引+TOAST,是 egress
+ * 上界(真实转储经压缩、不含索引,更小)。备份也拿它估转储体积来定分片大小。
+ * 直接传 relid 而不是按名字转 regclass:统计视图读出来之后表被并发删掉,
+ * 按名字转会报错,按 oid 查只会得到 NULL。
+ */
+export async function relationBytes(client, schemas) {
+    const res = await client.query(`select coalesce(sum(pg_total_relation_size(relid)), 0)::bigint as bytes
+       from pg_stat_user_tables
+      where schemaname = any($1::text[])`, [schemas]);
+    return Number(res.rows[0].bytes);
+}
 async function measureDbBytes(databaseUrl, schemas) {
     const client = await connectPg(databaseUrl);
     try {
-        // pg_total_relation_size 含索引+TOAST,是 egress 上界(真实转储经压缩、不含索引,更小)
-        const res = await client.query(`select coalesce(
-                sum(pg_total_relation_size(format('%I.%I', schemaname, relname)::regclass)),
-                0
-              )::bigint as bytes
-         from pg_stat_user_tables
-        where schemaname = any($1::text[])`, [schemas]);
-        return Number(res.rows[0].bytes);
+        return await relationBytes(client, schemas);
     }
     finally {
         await client.end();

package/dist/part-size.d.ts

@@ -0,0 +1,4 @@
+/** 能把 expectedBytes 装进 10,000 片的最小分片大小,按 MiB 取整,不低于 5 MiB。 */
+export declare function partSizeFor(expectedBytes: number): number;
+/** 数据库转储的分片大小:按估算体积 × 2 算,不低于 200 GiB 转储所需;量不出体积就用保底。 */
+export declare function dumpPartSizeFor(relationBytes: number | null): number;

package/dist/part-size.js

@@ -0,0 +1,27 @@
+// S3 / R2 / B2 的分片上传都限 10,000 片,除最后一片外每片至少 5 MiB。
+// lib-storage 只有在知道总长度时才会自己放大分片;长度未知的流(pg_dump、
+// 没传长度的 Storage 拷贝)一律按 5 MiB 切,单个对象最多约 48.8 GiB,
+// 再大就在上传途中报 "Exceeded 10000 parts" 失败。
+const MAX_PARTS = 10_000;
+const MIB = 1024 * 1024;
+const GIB = 1024 * MIB;
+const MIN_PART_BYTES = 5 * MIB;
+// 转储体积事先不知道,只能拿表的磁盘占用(含索引与 TOAST)去估。pg_dump 的
+// custom 格式默认 gzip 压缩,实测转储只有磁盘占用的零头(LZ4 TOAST 的重复文本
+// 约 0.16 倍、jsonb 约 0.53 倍);已压缩的 bytea 会以 hex 导出再 gzip,略大于 1 倍。
+// 所以按 2 倍留余量。
+const DUMP_SIZE_HEADROOM = 2;
+// 估算总有失准的时候(比如 pg_dump 没带 zlib、转储不压缩,重复文本能膨胀上百倍),
+// 所以分片再设一个保底:按 200 GiB 的转储算,也就是付费最高档每项目 100 GB 的
+// 2 倍。这样托管服务里任何套餐允许的转储都传得完,和估算准不准无关。
+// 代价是每次上传最多多占几十 MiB 内存(21 MiB 一片,lib-storage 默认并发 4 片)。
+const BASELINE_DUMP_BYTES = 200 * GIB;
+/** 能把 expectedBytes 装进 10,000 片的最小分片大小,按 MiB 取整,不低于 5 MiB。 */
+export function partSizeFor(expectedBytes) {
+    const neededBytes = Math.ceil(Math.max(0, expectedBytes) / MAX_PARTS);
+    return Math.max(MIN_PART_BYTES, Math.ceil(neededBytes / MIB) * MIB);
+}
+/** 数据库转储的分片大小:按估算体积 × 2 算,不低于 200 GiB 转储所需;量不出体积就用保底。 */
+export function dumpPartSizeFor(relationBytes) {
+    return partSizeFor(Math.max(BASELINE_DUMP_BYTES, (relationBytes ?? 0) * DUMP_SIZE_HEADROOM));
+}

package/dist/pgbin.d.ts

@@ -5,3 +5,36 @@
  * 绝不能把 pg_dump 当恢复器执行。
  */
 export declare function resolvePgRestoreBin(): string;
+/**
+ * Parse the major version out of `pg_dump --version` output.
+ *
+ * MUST tolerate a trailing vendor suffix: Homebrew/macOS prints `pg_dump (PostgreSQL) 17.2`, but
+ * Debian/PGDG (what the deployed worker image uses) prints
+ * `pg_dump (PostgreSQL) 17.10 (Debian 17.10-1.pgdg120+1)`. Anchoring the match to end-of-string
+ * therefore breaks in production while passing on a dev Mac. Anchor on the `(PostgreSQL)` marker
+ * instead, falling back to the first dotted version token for non-standard builds.
+ */
+export declare function parsePgDumpMajor(raw: string): number | null;
+/** 本地 pg_restore 主版本(拿不到 → null,由调用方决定 fail-open 还是 fail-closed)。 */
+export declare function localPgRestoreMajor(): Promise<number | null>;
+/**
+ * pg_restore 17 起每次恢复都先发 `SET transaction_timeout = 0`,这个参数 PostgreSQL 17
+ * 才有,恢复进 16 及更老的服务端第一句就报 unrecognized configuration parameter。
+ * 上游定性为设计如此(pgsql-bugs 2024-10),不会修,只能绕开。
+ */
+export declare function restoreToolBreaksOnTarget(toolMajor: number, targetMajor: number): boolean;
+/**
+ * 恢复前的工具/目标版本闸:返回拒绝理由,可放行时返回 null。dry-run 与正式恢复共用,
+ * 保证两条路径的判定和给用户的出路一字不差。出路有两条:目标升到 17+;或当归档
+ * 本身只需要 ≤16 的 pg_restore(旧版 pg_dump 写的)时,换一个与目标同版本的旧客户端。
+ */
+export declare function restoreToolTargetBlocker(toolMajor: number, targetMajor: number, requiredMajor: number): string | null;
+/**
+ * 演练沙箱的主版本:源库与本机 pg_restore 取大者。pg_dump/pg_restore 的输出只保证能进
+ * 与工具同版本或更新的服务端(官方文档原话:不保证能载入更老的主版本)——除了
+ * restoreToolBreaksOnTarget 这条已知的,还有新版 pg_dump 生成旧服务端不认识的语法
+ * (交叉审查实测:pg_dump 18 导 PG17 的继承表)。往更新的主版本恢复是官方支持的方向,
+ * 反过来要求用户装与源库同版本的旧工具行不通(旧 pg_restore 读不了新 pg_dump 的归档)。
+ * 拿不到工具版本时退回源版本。
+ */
+export declare function sandboxMajorFor(sourceMajor: number, toolMajor: number | null): number;

package/dist/pgbin.js

@@ -1,3 +1,6 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
 /**
  * pg_restore 二进制解析:显式 BACKUPDRILL_PG_RESTORE 最高优先;否则从
  * BACKUPDRILL_PG_DUMP 同目录推导。推导未命中(结果仍含 pg_dump 或与原值相同,
@@ -15,3 +18,60 @@ export function resolvePgRestoreBin() {
     }
     return "pg_restore";
 }
+/**
+ * Parse the major version out of `pg_dump --version` output.
+ *
+ * MUST tolerate a trailing vendor suffix: Homebrew/macOS prints `pg_dump (PostgreSQL) 17.2`, but
+ * Debian/PGDG (what the deployed worker image uses) prints
+ * `pg_dump (PostgreSQL) 17.10 (Debian 17.10-1.pgdg120+1)`. Anchoring the match to end-of-string
+ * therefore breaks in production while passing on a dev Mac. Anchor on the `(PostgreSQL)` marker
+ * instead, falling back to the first dotted version token for non-standard builds.
+ */
+export function parsePgDumpMajor(raw) {
+    const match = raw.match(/\(PostgreSQL\)\s+(\d+)/) ?? raw.match(/(\d+)(?:\.\d+)+/);
+    return match ? Number(match[1]) : null;
+}
+/** 本地 pg_restore 主版本(拿不到 → null,由调用方决定 fail-open 还是 fail-closed)。 */
+export async function localPgRestoreMajor() {
+    try {
+        const { stdout } = await execFileAsync(resolvePgRestoreBin(), ["--version"]);
+        return parsePgDumpMajor(stdout.trim());
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * pg_restore 17 起每次恢复都先发 `SET transaction_timeout = 0`,这个参数 PostgreSQL 17
+ * 才有,恢复进 16 及更老的服务端第一句就报 unrecognized configuration parameter。
+ * 上游定性为设计如此(pgsql-bugs 2024-10),不会修,只能绕开。
+ */
+export function restoreToolBreaksOnTarget(toolMajor, targetMajor) {
+    return toolMajor >= 17 && targetMajor < 17;
+}
+/**
+ * 恢复前的工具/目标版本闸:返回拒绝理由,可放行时返回 null。dry-run 与正式恢复共用,
+ * 保证两条路径的判定和给用户的出路一字不差。出路有两条:目标升到 17+;或当归档
+ * 本身只需要 ≤16 的 pg_restore(旧版 pg_dump 写的)时,换一个与目标同版本的旧客户端。
+ */
+export function restoreToolTargetBlocker(toolMajor, targetMajor, requiredMajor) {
+    if (!restoreToolBreaksOnTarget(toolMajor, targetMajor))
+        return null;
+    const olderClient = requiredMajor <= targetMajor
+        ? ` or point BACKUPDRILL_PG_RESTORE at a pg_restore ${targetMajor} (this archive only needs v${requiredMajor})`
+        : "";
+    return (`local pg_restore is v${toolMajor}, which sends SET transaction_timeout — a setting PostgreSQL ` +
+        `${targetMajor} does not have, so the restore would fail on its first statement. ` +
+        `Create the target on PostgreSQL 17 or newer${olderClient}.`);
+}
+/**
+ * 演练沙箱的主版本:源库与本机 pg_restore 取大者。pg_dump/pg_restore 的输出只保证能进
+ * 与工具同版本或更新的服务端(官方文档原话:不保证能载入更老的主版本)——除了
+ * restoreToolBreaksOnTarget 这条已知的,还有新版 pg_dump 生成旧服务端不认识的语法
+ * (交叉审查实测:pg_dump 18 导 PG17 的继承表)。往更新的主版本恢复是官方支持的方向,
+ * 反过来要求用户装与源库同版本的旧工具行不通(旧 pg_restore 读不了新 pg_dump 的归档)。
+ * 拿不到工具版本时退回源版本。
+ */
+export function sandboxMajorFor(sourceMajor, toolMajor) {
+    return toolMajor === null ? sourceMajor : Math.max(sourceMajor, toolMajor);
+}

package/dist/restore.js

@@ -10,22 +10,9 @@ import { restoreDatabaseArtifact, installExtensions, projectRefOf, refFromStorag
 import { verifyRestored } from "./drill.js";
 import { restoreStorage, planStorageRestore, } from "./storage-restore.js";
 import { connectPg } from "./supabase-ca.js";
-import { resolvePgRestoreBin } from "./pgbin.js";
+import { localPgRestoreMajor, restoreToolTargetBlocker } from "./pgbin.js";
 import { parsePgDumpMajor } from "./backup.js";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
 import { log } from "./log.js";
-const execFileAsync = promisify(execFile);
-/** 本地 pg_restore 主版本(拿不到 → null,由引擎自己的报错兜底)。 */
-async function localPgRestoreMajor() {
-    try {
-        const { stdout } = await execFileAsync(resolvePgRestoreBin(), ["--version"]);
-        return parsePgDumpMajor(stdout.trim());
-    }
-    catch {
-        return null;
-    }
-}
 /** 归档可读性要求:pg_restore 必须 ≥ max(写入工具版本, 源服务端版本)——格式跟随写入工具。 */
 export function requiredRestoreToolMajor(manifest) {
     return Math.max(parsePgDumpMajor(manifest.database.pgDumpVersion) ?? 0, parseInt(manifest.database.serverVersion, 10) || 0);
@@ -272,6 +259,13 @@ async function dryRunPreflight(config, manifest, targetUrl, storageTarget) {
             else {
                 log.ok(`pg_restore tool: local v${toolMajor} ≥ archive requirement v${requiredMajor}`);
             }
+            const toolTargetBlocker = toolMajor !== null && Number.isFinite(targetMajor)
+                ? restoreToolTargetBlocker(toolMajor, targetMajor, requiredMajor)
+                : null;
+            if (toolTargetBlocker) {
+                blockers.push(`local pg_restore v${toolMajor} cannot restore into PostgreSQL ${targetMajor}`);
+                log.error(`pg_restore tool: ${toolTargetBlocker}`);
+            }
             const extensions = db.extensions ?? [];
             if (extensions.length) {
                 const available = await client.query(`select name from pg_available_extensions where name = any($1::text[])`, [extensions.map((e) => e.name)]);
@@ -447,6 +441,11 @@ export async function runRestore(config, opts) {
                     `(archive format follows the writing tool). Install postgresql client ${requiredMajor}+ ` +
                     `and/or point BACKUPDRILL_PG_RESTORE at it.`);
             }
+            // 工具/目标版本闸:pg_restore 17+ 恢复进 ≤16 的目标第一句就失败。在下载与装扩展
+            // 之前拦下,别等恢复到一半才炸;旧 pg_restore 又读不了新归档,所以唯一出路是新目标
+            const toolTargetBlocker = restoreToolTargetBlocker(toolMajor, targetMajor, requiredMajor);
+            if (toolTargetBlocker)
+                throw new Error(toolTargetBlocker);
             log.step("Downloading dump…");
             const dumpPath = join(workdir, "dump.pgcustom");
             const { sha256 } = await downloadToFile(s3, config.storage.bucket, manifest.dump.key, dumpPath);

package/dist/storage.js

@@ -4,6 +4,7 @@ import { pipeline } from "node:stream/promises";
 import { S3Client, ListBucketsCommand, ListObjectsV2Command, GetObjectCommand, } from "@aws-sdk/client-s3";
 import { Upload } from "@aws-sdk/lib-storage";
 import { log } from "./log.js";
+import { partSizeFor } from "./part-size.js";
 /**
  * Supabase Storage 通过 S3 兼容端点访问(endpoint 形如
  * https://<ref>.storage.supabase.co/storage/v1/s3)。这里的凭据是"读取源"的密钥,
@@ -104,6 +105,8 @@ export async function syncStorage(cfg, target) {
             const copy = pipeline(body, meter);
             const upload = new Upload({
                 client: target.client,
+                // Body 是流,lib-storage 不知道长度,会固定按 5 MiB 切;用响应里的长度算分片
+                partSize: partSizeFor(got.ContentLength ?? obj.size),
                 params: {
                     Bucket: target.bucket,
                     Key: `${target.base}/storage/${bucket}/${obj.key}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backupdrill",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Open-source CLI to back up a Supabase project — Postgres database and Storage files — to your own S3/R2/B2 bucket, with a checksummed manifest.",
   "type": "module",
   "bin": {