naro-cli 0.15.0 → 0.16.0

package/README.md

@@ -180,7 +180,7 @@ naro storage bucket update avatars --private | --file-size-limit none | --allowe
 naro storage bucket update docs --public   (asks first: anyone with an object's URL can download it)
 naro storage bucket list | empty <name> | remove <name> [--empty]   (empty and remove ask first)
 naro storage ls naro://avatars/u1 [--recursive]
-naro storage cp ./me.png naro://avatars/u1/me.png [--upsert]   Up to 50 MiB, with the service key
+naro storage cp ./me.png naro://avatars/u1/me.png [--upsert]   Up to the object limit, under 4 GiB (over 50 MiB in parts), with the service key
 naro storage cp naro://docs/team-1/plan.pdf ./                  Replaces a local file of the same name
 naro storage rm naro://avatars/u1/old.png [--recursive]   (asks first)
 naro storage rm naro://avatars/u1/ --recursive   Everything under u1/; written u1, an object u1 too
@@ -793,13 +793,43 @@ An `--update-check` you give replaces the default: without
 
 ## Release notes
 
+### 0.16.0
+
+- `naro storage cp` uploads a file up to the object limit, under 4 GiB. Over
+  50 MiB it goes in parts, four at a time, and a part that fails is sent again
+  (up to three more times) before the upload stops. The 50 MiB refusal before
+  any request is gone: the worker judges the size when the upload starts, and a
+  file over the bucket's or the plan's limit answers `413 OBJECT_TOO_LARGE`
+  before a byte is sent. An upload in parts must finish within 24 hours of its
+  start (R2 ends unfinished multipart uploads after a day). A big upload prints its progress on stderr: one line
+  rewritten in place at a terminal, a line every 10% otherwise
+  (`↑ 312 MiB / 1.2 GiB (26%)`), and nothing with `--json`.
+- Ctrl-C during an upload (or a TERM, or the terminal closing) stops it:
+  `Stopping the upload…` on stderr, the upload is called off — one in parts on
+  the backend too, so its name and the space it reserved are free at once
+  rather than locked for about an hour — and the run ends with the signal. A
+  second Ctrl-C ends it at once, without waiting for the call-off. A process
+  killed outright, or a network lost, still leaves the name locked until the
+  lock runs out.
+- A file of 4 GiB or more is refused before any request
+  (`VALIDATION_FAILED`): Node reads its size modulo 4 GiB (4 GiB + 1 KiB reads
+  as 1 KiB), and the upload would send only that much and report success.
+  Uploading one needs a change in naro-js that is not there yet.
+- A download is written to disk as it arrives, to a hidden `.naro-partial`
+  file that replaces the destination once it is whole, instead of being held in
+  memory first.
+- `naro storage` says `50 MiB per request (larger files go in parts)`, and
+  that uploads stopped over the storage limit reopen usually within an hour and
+  a half: R2 reports the bucket's size 30 minutes to about an hour and a half
+  late.
+
 ### 0.15.0
 
 - `naro storage` shows the Storage meter's day between `Used:` and `Buckets:`:
   `Today (UTC):` has the write operations (R2 Class A) against the daily limit
   and the reads, `Measured:` the bucket size R2 reported and when R2 measured
-  it (R2 reports the size 30–45 minutes late, and the meter reads it every 15
-  minutes). A `✗` line
+  it (R2 reports the size 30 minutes to about an hour and a half late, and the
+  meter reads it every 15 minutes). A `✗` line
   says uploads are stopped, over the storage limit until objects are deleted
   or over the day's write operations until 00:00 UTC (downloads still work);
   a `⚠` line warns from 80% of the storage limit or of the day's write
@@ -872,7 +902,8 @@ An `--update-check` you give replaces the default: without
   (public or private, the largest file, the types taken), and `ls`, `cp`
   and `rm` work on `naro://<bucket>/<path>` with the project's service key
   (`NARO_SERVICE_KEY`, or fetched with a warning) — the bytes go to the
-  project's backend, not through naro. One upload is 50 MiB at most.
+  project's backend, not through naro. One request carries 50 MiB at most; a
+  larger file goes in parts since 0.16.0 (under 4 GiB).
   `bucket update --public`, `empty`, `remove` and `rm` ask first; without a
   terminal they need `--yes` (`CONFIRMATION_REQUIRED` otherwise, nothing
   sent).

package/dist/{chunk-6WJ3QQ5Y.js → chunk-XNT7SINN.js}

@@ -26,6 +26,7 @@ function artifactUrlKey(kind, name) {
   return `${kind}/${name}`;
 }
 var ARTIFACT_URL_BATCH_SIZE = 100;
+var ARTIFACT_UPLOAD_CONCURRENCY = 8;
 function parseArtifactPutUrls(payload) {
   if (typeof payload !== "object" || payload === null) return null;
   const { urls, disabled } = payload;
@@ -37,28 +38,55 @@ function parseArtifactPutUrls(payload) {
   }
   return resolved;
 }
+async function eachWithLimit(items, limit, work) {
+  let next = 0;
+  const lanes = Array.from(
+    { length: Math.min(limit, items.length) },
+    async () => {
+      while (next < items.length) {
+        const item = items[next];
+        next += 1;
+        await work(item);
+      }
+    }
+  );
+  await Promise.all(lanes);
+}
 async function uploadArtifactFiles(artifact, ports) {
   const entries = artifactUploadEntries(artifact);
   let proxied = 0;
   for (let index = 0; index < entries.length; index += ARTIFACT_URL_BATCH_SIZE) {
     const batch = entries.slice(index, index + ARTIFACT_URL_BATCH_SIZE);
     const urls = await ports.resolvePutUrls(batch);
-    for (const entry of batch) {
+    const viaProxy = [];
+    await eachWithLimit(batch, ARTIFACT_UPLOAD_CONCURRENCY, async (entry) => {
       const url2 = urls?.get(artifactUrlKey(entry.kind, entry.file.name));
       if (!url2) {
-        proxied += 1;
-        await ports.putProxied(entry);
-        continue;
+        viaProxy.push(entry);
+        return;
       }
       try {
         await ports.putSigned(url2, entry);
       } catch {
-        proxied += 1;
-        await ports.putProxied(entry);
+        viaProxy.push(entry);
       }
+    });
+    for (const entry of viaProxy) {
+      proxied += 1;
+      await ports.putProxied(entry);
     }
   }
-  return { proxied, total: entries.length };
+  const bytes = entries.reduce(
+    (total, entry) => total + entry.file.data.byteLength,
+    0
+  );
+  return { proxied, total: entries.length, bytes };
+}
+function artifactUploadSummary(report, elapsedMs) {
+  const kilobytes = Math.ceil(report.bytes / 1e3);
+  const size = kilobytes >= 1e3 ? `${(report.bytes / 1e6).toFixed(1)} MB` : `${String(kilobytes)} kB`;
+  const files = report.total === 1 ? "file" : "files";
+  return `Uploaded ${String(report.total)} artifact ${files} (${size}) in ${(elapsedMs / 1e3).toFixed(1)} s.`;
 }
 
 // ../../packages/build/src/cache.ts
@@ -100,6 +128,7 @@ async function reportUnavailable(scope, ports, observer) {
     "Build cache is unavailable - this build runs uncached and saves nothing for the next one."
   );
 }
+var UNKNOWN_PAX_KEYWORD = /^tar: Ignoring unknown extended header keyword /;
 async function restoreCache(args) {
   const { scope, key, targetDir, ports, observer } = args;
   const urls = await ports.transport.resolveUrls(scope, key);
@@ -132,7 +161,9 @@ async function restoreCache(args) {
       stage: STAGE[scope],
       errorCode: ERROR_CODE[scope]
     },
-    observer
+    {
+      onLog: (entry) => UNKNOWN_PAX_KEYWORD.test(entry.message) ? void 0 : observer.onLog(entry)
+    }
   );
   await log(observer, scope, "INFO", `Restored ${scope} cache (${key}).`);
   return true;
@@ -160,7 +191,14 @@ async function saveCache(args) {
   await ports.runCommand(
     {
       command: "tar",
-      args: ["--zstd", "-cf", archive, "-C", sourceDir, "."],
+      // --no-xattrs: macOS bsdtar would store extended attributes that the
+      // build container's GNU tar warns about per file (UNKNOWN_PAX_KEYWORD).
+      // GNU tar 1.27+ and bsdtar 3.x both take it.
+      args: ["--no-xattrs", "--zstd", "-cf", archive, "-C", sourceDir, "."],
+      // macOS can also write the same metadata as AppleDouble `._name` files,
+      // which GNU tar restores as ordinary files (PR #114 review; not seen on
+      // bsdtar 3.5.3 here). GNU tar ignores the variable.
+      env: { COPYFILE_DISABLE: "1" },
       cwd: sourceDir,
       timeoutMs: 12e4,
       stage: STAGE[scope],
@@ -257,6 +295,9 @@ var PHASES = [
 ];
 var ACTIVE_STATUSES = new Set(PHASES);
 
+// ../../packages/core/src/deployment-stall.ts
+var STALL_WINDOW_MS = 10 * 6e4;
+
 // ../../packages/core/src/deployment-strategy.ts
 var MIN_SUPPORTED_NEXT_MAJOR = 15;
 
@@ -15254,7 +15295,8 @@ function cacheEnv(dir) {
   return {
     npm_config_store_dir: dir,
     npm_config_cache: dir,
-    YARN_CACHE_FOLDER: dir
+    YARN_CACHE_FOLDER: dir,
+    YARN_ENABLE_GLOBAL_CACHE: "0"
   };
 }
 function withSharedCache(spec, dir) {
@@ -15313,7 +15355,8 @@ async function detectPackageManager(root) {
         "install",
         modern ? "--immutable" : "--frozen-lockfile"
       ],
-      // Berry takes no install-time cache flag; YARN_CACHE_FOLDER covers it.
+      // Berry takes no install-time cache flag; cacheEnv covers it
+      // (YARN_CACHE_FOLDER with the global cache switched off).
       cacheArgs: (dir) => modern ? [] : ["--cache-folder", dir],
       addArgs: (specs) => ["yarn", "add", ...specs]
     };
@@ -18446,22 +18489,31 @@ function createLogBatcher(options) {
   let buffer = [];
   let timer = null;
   let pending = null;
+  let sending = Promise.resolve();
   function disarm() {
     if (timer === null) return;
     clearTimeout(timer);
     timer = null;
   }
+  function surfacePending() {
+    if (pending === null) return;
+    const { error: error51 } = pending;
+    pending = null;
+    throw error51;
+  }
   async function flush() {
     disarm();
-    if (pending !== null) {
-      const { error: error51 } = pending;
-      pending = null;
-      throw error51;
+    surfacePending();
+    if (buffer.length === 0) {
+      await sending;
+      surfacePending();
+      return;
     }
-    if (buffer.length === 0) return;
     const batch = buffer;
     buffer = [];
-    await options.send(batch);
+    const send = sending.then(() => options.send(batch));
+    sending = send.catch(() => void 0);
+    await send;
   }
   function arm() {
     if (timer !== null || !options.intervalMs) return;
@@ -21080,6 +21132,10 @@ var CATALOG = {
     status: 404,
     message: ({ bucket, path }) => `Object ${storageName(path)} was not found in bucket ${storageName(bucket)}.`
   },
+  UPLOAD_NOT_FOUND: {
+    status: 404,
+    message: ({ upload }) => `Upload ${storageName(upload)} was not found or has expired.`
+  },
   INVALID_CONTENT_TYPE: {
     status: 400,
     message: ({ type }) => `Content-Type ${storageName(type)} is not a media type like image/png.`
@@ -21094,7 +21150,7 @@ var CATALOG = {
   },
   OBJECT_TOO_LARGE: {
     status: 413,
-    message: (vars) => "single" in vars ? "Uploads over 50 MiB are not supported yet." : `The object is ${String(vars.size)} bytes; bucket ${storageName(vars.bucket)} takes objects up to ${String(vars.max)} bytes.`
+    message: (vars) => "single" in vars ? "Uploads over 50 MiB go in parts: use the multipart upload." : `The object is ${String(vars.size)} bytes; bucket ${storageName(vars.bucket)} takes objects up to ${String(vars.max)} bytes.`
   },
   MIME_TYPE_NOT_ALLOWED: {
     status: 415,
@@ -25840,7 +25896,7 @@ function claimUpload(i) {
   const nonce = nonceOf(i.nonce);
   return compose(
     [
-      `INSERT INTO ${STORAGE_OBJECTS_TABLE} (id, bucket_id, name, owner, owner_id, metadata, version, parent, size, status, lock_id, lock_expires_at) SELECT ?, ?, ?, ?, ?, ?, NULL, ?, ?, 'uploading', ?, ? WHERE CASE WHEN NOT EXISTS (SELECT 1 FROM ${STORAGE_BUCKETS_TABLE} WHERE id = ? AND ${LIVE_BUCKET}) THEN ${marker("bucket", nonce)} WHEN (`,
+      `INSERT INTO ${STORAGE_OBJECTS_TABLE} (id, bucket_id, name, owner, owner_id, metadata, version, parent, size, status, lock_id, lock_expires_at, pending) SELECT ?, ?, ?, ?, ?, ?, NULL, ?, ?, 'uploading', ?, ?, ? WHERE CASE WHEN NOT EXISTS (SELECT 1 FROM ${STORAGE_BUCKETS_TABLE} WHERE id = ? AND ${LIVE_BUCKET}) THEN ${marker("bucket", nonce)} WHEN (`,
       i.check,
       `) <> 1 THEN 0 WHEN EXISTS (SELECT 1 FROM ${STORAGE_OBJECTS_TABLE} WHERE bucket_id = ? AND name = ? AND status = 'ready') THEN ${marker("exists", nonce)} WHEN EXISTS (SELECT 1 FROM ${STORAGE_OBJECTS_TABLE} WHERE bucket_id = ? AND name = ?) THEN ${marker("busy", nonce)} WHEN ${PROJECT_BYTES} + ? > ? THEN ${marker("quota", nonce)} ELSE 1 END RETURNING id`
     ],
@@ -25856,6 +25912,7 @@ function claimUpload(i) {
         i.size,
         i.lockId,
         i.expiresAt,
+        i.pending ?? null,
         i.bucket
       ],
       [i.bucket, i.name, i.bucket, i.name, i.size, i.limitBytes]
@@ -25879,6 +25936,13 @@ function overwriteCheckRow(i) {
 }
 function claimOverwrite(i) {
   const nonce = nonceOf(i.nonce);
+  const room = i.inParts ? {
+    sql: `${PROJECT_BYTES} + ? > ?`,
+    values: [i.size, i.limitBytes]
+  } : {
+    sql: `? > o.size AND ${PROJECT_BYTES} + ? - o.size > ?`,
+    values: [i.size, i.size, i.limitBytes]
+  };
   return compose(
     [
       `UPDATE ${STORAGE_OBJECTS_TABLE} AS o SET lock_id = ?, lock_expires_at = ?, pending = ? WHERE o.bucket_id = ? AND o.name = ? AND CASE WHEN NOT (`,
@@ -25886,17 +25950,14 @@ function claimOverwrite(i) {
       // The row's own bucket (`o.bucket_id`), so no value is bound for it.
       `) THEN ${marker("hidden", nonce)} WHEN NOT EXISTS (SELECT 1 FROM ${STORAGE_BUCKETS_TABLE} AS b WHERE b.id = o.bucket_id AND b.${LIVE_BUCKET}) THEN ${marker("bucket", nonce)} WHEN o.status <> 'ready' OR o.lock_id IS NOT NULL THEN ${marker("busy", nonce)} WHEN NOT (`,
       i.updateUsing,
-      `) THEN ${marker("denied", nonce)} WHEN ? > o.size AND ${PROJECT_BYTES} + ? - o.size > ? THEN ${marker("quota", nonce)} ELSE (`,
+      `) THEN ${marker("denied", nonce)} WHEN ${room.sql} THEN ${marker("quota", nonce)} ELSE (`,
       i.check,
       // RETURNING names the columns bare: it does not see the UPDATE's
       // alias (SQLite 3.53: `no such column: o.id`), and the table is the
       // only one there.
       ") END RETURNING id, version, size, owner, owner_id, created_at"
     ],
-    [
-      [i.lockId, i.expiresAt, i.pending, i.bucket, i.name],
-      [i.size, i.size, i.limitBytes]
-    ]
+    [[i.lockId, i.expiresAt, i.pending, i.bucket, i.name], room.values]
   );
 }
 function claimDelete(i) {
@@ -27075,6 +27136,17 @@ function formatRedirectEntry(entry) {
   return entry.path === "/" ? entry.origin : `${entry.origin}${entry.path}`;
 }
 
+// ../../packages/data-core/src/storage-multipart.ts
+var MiB = 1024 * 1024;
+var MULTIPART_PART_SIZES = [16 * MiB, 32 * MiB, 64 * MiB];
+var MAX_MULTIPART_PARTS = 1e4;
+var MAX_MULTIPART_BYTES = 64 * MiB * MAX_MULTIPART_PARTS;
+var MULTIPART_LOCK_MS = 60 * 60 * 1e3;
+var MULTIPART_PART_EXTEND_BELOW_MS = 30 * 60 * 1e3;
+var MULTIPART_COMPLETE_LOCK_MS = 15 * 60 * 1e3;
+var UUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+var UPLOAD_ID = new RegExp(`^(${UUID})\\.(${UUID})$`);
+
 // ../../packages/data-core/src/system-sql.ts
 async function convertLegacyPolicies(db, found) {
   const rows = rowsOf(await db.prepare(POLICY_SQL.list).all());
@@ -28203,7 +28275,9 @@ function manifest(artifact) {
   };
 }
 async function uploadArtifact(artifact, opts) {
-  await uploadArtifactFiles(artifact, uploadPorts(opts));
+  const started = Date.now();
+  const report = await uploadArtifactFiles(artifact, uploadPorts(opts));
+  const uploadSummary = artifactUploadSummary(report, Date.now() - started);
   const response = await authed(opts, "/artifacts/complete", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -28214,7 +28288,8 @@ async function uploadArtifact(artifact, opts) {
     throw new Error("Control plane did not return an artifact key.");
   return {
     artifactKey: payload.artifactKey,
-    previewUrl: typeof payload.previewUrl === "string" ? payload.previewUrl : null
+    previewUrl: typeof payload.previewUrl === "string" ? payload.previewUrl : null,
+    uploadSummary
   };
 }
 
@@ -28290,7 +28365,8 @@ function eventsObserver(cp3, deploymentId, token, fetchImpl = fetch, logIngestUr
       await flushLogs();
       await post({ type: "metadata", metadata: rest }).catch(() => {
       });
-    }
+    },
+    flush: flushLogs
   };
 }
 function slugify2(value) {
@@ -28485,12 +28561,19 @@ async function deployDirectory(sourceDir, options, log2) {
       { details: { deploymentId: ctx.deploymentId }, cause: error51 }
     );
   }
-  await uploadArtifact(artifact, {
+  const { uploadSummary } = await uploadArtifact(artifact, {
     controlPlaneUrl: cpUrl,
     deploymentId: ctx.deploymentId,
     callbackToken: ctx.callbackToken,
     ...options.fetch ? { fetch: options.fetch } : {}
   });
+  log2(`\u25B8 ${uploadSummary}`);
+  await observer.onLog({
+    level: "INFO",
+    stage: "DEPLOYING",
+    message: uploadSummary
+  });
+  await observer.flush();
   log2("\u25B8 publishing worker");
   const detail = await waitForFinish(client, ctx, log2);
   const url2 = deploymentUrl(detail, ctx, production);
@@ -28568,7 +28651,6 @@ export {
   parseCacheControl,
   STORAGE_OBJECTS_TABLE,
   systemTablePredicate,
-  dataError,
   SCHEMA_SQL,
   tableNames,
   snapshotFromRows,

package/dist/deploy.d.ts

@@ -21,7 +21,10 @@ export interface DeployBuildExecutor {
 export declare function parseDotenv(text: string): Record<string, string>;
 /** Reads the first of .env.local / .env.production / .env in a directory. */
 export declare function readProjectEnv(dir: string): Record<string, string>;
-export declare function eventsObserver(cp: string, deploymentId: string, token: string, fetchImpl?: typeof fetch, logIngestUrl?: string): BuildObserver;
+export declare function eventsObserver(cp: string, deploymentId: string, token: string, fetchImpl?: typeof fetch, logIngestUrl?: string): BuildObserver & {
+    /** Sends what is buffered now; never throws. */
+    flush(): Promise<void>;
+};
 export declare function slugify(value: string): string;
 export interface DeployOptions {
     name?: string | undefined;

package/dist/deploy.js

@@ -5,7 +5,7 @@ import {
   parseDotenv,
   readProjectEnv,
   slugify
-} from "./chunk-6WJ3QQ5Y.js";
+} from "./chunk-XNT7SINN.js";
 import "./chunk-K3NQKI34.js";
 export {
   deployDirectory,

package/dist/index.js

@@ -26,7 +26,6 @@ import {
   controlPlaneUrl,
   countLintedTables,
   createAuthClient,
-  dataError,
   deployDirectory,
   detectGitInfo,
   ensureGitignoreHasNaro,
@@ -83,7 +82,7 @@ import {
   toNaroError,
   unreadablePolicyComment,
   writeProjectLink
-} from "./chunk-6WJ3QQ5Y.js";
+} from "./chunk-XNT7SINN.js";
 import "./chunk-K3NQKI34.js";
 
 // src/args.ts
@@ -289,6 +288,13 @@ var Output = class {
     this.streams.stderr(`${message}
 `);
   }
+  /**
+   * Text on stderr exactly as given, with no line break added: a progress
+   * line a terminal rewrites in place (`\r…`). Never stdout, in either mode.
+   */
+  progress(text) {
+    this.streams.stderr(text);
+  }
   /** Extra diagnostics, only with --debug. */
   debugLog(message) {
     if (this.debug) this.streams.stderr(`[debug] ${message}
@@ -5337,7 +5343,7 @@ function meterLines(info) {
   }
   if (today.bytesBlocked)
     lines.push(
-      today.measuredBytes === null ? `\u2717 Uploads are stopped: the bucket is at the storage limit of ${binarySize(limits.bytes)}. Delete objects; uploads reopen after the next measurement (usually within an hour).` : `\u2717 Uploads are stopped: R2 holds ${binarySize(today.measuredBytes, 2)} of ${binarySize(limits.bytes)}. Delete objects; uploads reopen after the next measurement (usually within an hour).`
+      today.measuredBytes === null ? `\u2717 Uploads are stopped: the bucket is at the storage limit of ${binarySize(limits.bytes)}. Delete objects; uploads reopen after the next measurement (usually within an hour and a half).` : `\u2717 Uploads are stopped: R2 holds ${binarySize(today.measuredBytes, 2)} of ${binarySize(limits.bytes)}. Delete objects; uploads reopen after the next measurement (usually within an hour and a half).`
     );
   if (today.opsBlocked)
     lines.push(
@@ -5362,7 +5368,7 @@ function storageLines(info) {
   const { limits, usage } = info;
   return [
     `Storage:     on (R2 bucket ${printable(info.bucket ?? "unknown")})`,
-    `Limits:      ${binarySize(limits.bytes)} in all, ${binarySize(limits.objectBytes)} per object, ${binarySize(limits.singleUploadBytes)} per upload`,
+    `Limits:      ${binarySize(limits.bytes)} in all, ${binarySize(limits.objectBytes)} per object, ${binarySize(limits.singleUploadBytes)} per request (larger files go in parts)`,
     usage === null ? "Used:        not known yet: the backend is not ready (`naro backend` shows where it got to)" : `Used:        ${binarySize(usage.bytes)} in ${count(usage.objects, "object")}`,
     ...meterLines(info),
     info.buckets.length === 0 ? "Buckets:     none yet (`naro storage bucket create <name>` makes one)" : `Buckets:     ${String(info.buckets.length)}`,
@@ -5549,6 +5555,12 @@ function requestTimeout(ms) {
     message: `The Naro backend did not answer within ${String(Math.round(ms / 1e3))} seconds. Check the network and try again.`
   };
 }
+function uploadAborted() {
+  return {
+    code: "ABORTED",
+    message: "The upload was stopped before it finished."
+  };
+}
 function invalidResponse(status) {
   return {
     code: "INVALID_RESPONSE",
@@ -5714,6 +5726,12 @@ async function send(config, options) {
     credentials: "omit"
   };
   if (options.body !== void 0) init.body = options.body;
+  const { signal } = options;
+  if (signal?.aborted) return { error: uploadAborted(), status: null };
+  const controller = signal ? new AbortController() : null;
+  const stop = () => controller?.abort();
+  if (controller) init.signal = controller.signal;
+  signal?.addEventListener("abort", stop);
   let response;
   try {
     const fetchImpl = config.fetch ?? globalThis.fetch;
@@ -5722,26 +5740,34 @@ async function send(config, options) {
       init
     );
   } catch (error2) {
-    return { error: networkError(error2) };
+    return {
+      error: signal?.aborted ? uploadAborted() : networkError(error2),
+      status: null
+    };
+  } finally {
+    signal?.removeEventListener("abort", stop);
   }
-  if (response.status >= 200 && response.status < 300)
-    return { error: null, response };
+  const { status } = response;
+  if (status >= 200 && status < 300) return { error: null, response };
   let text;
   try {
     text = await response.text();
   } catch (error2) {
-    return { error: networkError(error2) };
+    return { error: networkError(error2), status: null };
   }
   let body;
   if (text.trim() !== "") {
     try {
       body = JSON.parse(text);
     } catch {
-      return { error: invalidResponse(response.status) };
+      return { error: invalidResponse(status), status };
     }
   }
-  const error = errorFromBody(response.status, body) ?? invalidResponse(response.status);
-  return { error: await settled(config, error, response.headers, token) };
+  const error = errorFromBody(status, body) ?? invalidResponse(status);
+  return {
+    error: await settled(config, error, response.headers, token),
+    status
+  };
 }
 var RETRY_AFTER_CODES = /* @__PURE__ */ new Set([
   "RATE_LIMITED",
@@ -7312,10 +7338,176 @@ var TableBuilder = class {
     });
   }
 };
+function fail(error) {
+  return { data: null, error };
+}
+var isUploadResult = (value) => isRecord(value) && typeof value.id === "string" && typeof value.path === "string" && typeof value.fullPath === "string";
+function dataOf2(status, body, guard) {
+  if (isRecord(body) && Object.hasOwn(body, "data") && guard(body.data))
+    return { data: body.data, error: null };
+  return fail(invalidResponse(status));
+}
+async function readJson(response, guard) {
+  let text;
+  try {
+    text = await response.text();
+  } catch (error) {
+    return fail(networkError(error));
+  }
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    return fail(invalidResponse(response.status));
+  }
+  return dataOf2(response.status, body, guard);
+}
+var ROUTE = "/storage/upload/multipart";
+var CONCURRENCY = 4;
+var ATTEMPTS = 4;
+var BACKOFF_MS = [1e3, 2e3, 4e3];
+var UPLOAD_ID = /^[\w-][\w.-]*$/;
+var positive = (value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+var planFor = (size) => (value) => isRecord(value) && typeof value.uploadId === "string" && UPLOAD_ID.test(value.uploadId) && positive(value.partSize) && positive(value.partCount) && (value.partCount - 1) * value.partSize < size && value.partCount * value.partSize >= size;
+var partAnswer = (n) => (value) => isRecord(value) && value.partNumber === n && typeof value.etag === "string" && value.etag !== "";
+var retryable = (error, status) => error.code === "NETWORK_ERROR" || error.code === "OBJECT_RATE_LIMITED" || status !== null && status >= 500 && error.code !== "STORAGE_QUOTA_EXCEEDED";
+function waitAfter(error, attempt22) {
+  const after = isRecord(error.details) ? error.details.retryAfter : void 0;
+  if (typeof after === "number") return after * 1e3;
+  if (error.code === "OBJECT_RATE_LIMITED") return 1e3;
+  return BACKOFF_MS[attempt22 - 1] ?? 4e3;
+}
+var sleepFor = (ms, signal) => new Promise((done) => {
+  if (signal?.aborted) {
+    done();
+    return;
+  }
+  const end = () => {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", end);
+    done();
+  };
+  const timer = setTimeout(end, ms);
+  signal?.addEventListener("abort", end);
+});
+async function uploadInParts(a) {
+  const { signal } = a;
+  const sleep2 = a.sleep ?? sleepFor;
+  if (signal?.aborted) return fail(uploadAborted());
+  const started = await call(a.http, {
+    method: a.method,
+    path: ROUTE,
+    body: {
+      bucket: a.bucket,
+      path: a.path,
+      size: a.size,
+      contentType: a.contentType,
+      cacheControl: a.cacheControl,
+      // PUT always replaces: the worker refuses `upsert` on it.
+      ...a.method === "POST" && a.upsert ? { upsert: true } : {}
+    },
+    withToken: true
+  });
+  if (started.error !== null) return fail(started.error);
+  const plan = dataOf2(
+    started.answer.status,
+    started.answer.body,
+    planFor(a.size)
+  );
+  if (plan.error !== null) return fail(plan.error);
+  const { uploadId, partSize, partCount } = plan.data;
+  const base = `${ROUTE}/${uploadId}`;
+  const progress = (sentBytes2) => {
+    if (signal?.aborted) return;
+    try {
+      const result = a.onProgress?.(sentBytes2, a.size);
+      if (isThenable(result)) result.then(void 0, () => void 0);
+    } catch {
+    }
+  };
+  const callOff = async () => {
+    await call(a.http, { method: "DELETE", path: base, withToken: true }).catch(
+      () => void 0
+    );
+  };
+  const etags = [];
+  const failure = {
+    error: signal?.aborted ? uploadAborted() : null
+  };
+  let next = 1;
+  let sentBytes = 0;
+  const onAbort = () => {
+    failure.error ??= uploadAborted();
+  };
+  const tryPart = async (n, bytes) => {
+    const sent = await send(a.http, {
+      method: "PUT",
+      path: `${base}/${String(n)}`,
+      headers: { "content-type": "application/octet-stream" },
+      body: bytes,
+      withToken: true,
+      signal
+    });
+    if (sent.error !== null) return sent;
+    const read = await readJson(sent.response, partAnswer(n));
+    if (read.error !== null)
+      return { error: read.error, status: sent.response.status };
+    return { etag: read.data.etag };
+  };
+  const sendPart = async (n) => {
+    const from = (n - 1) * partSize;
+    const to = Math.min(from + partSize, a.size);
+    const bytes = a.body instanceof Uint8Array ? a.body.subarray(from, to) : a.body.slice(from, to);
+    for (let attempt22 = 1; ; attempt22 += 1) {
+      const tried = await tryPart(n, bytes);
+      if ("etag" in tried) {
+        etags[n - 1] = tried.etag;
+        sentBytes += to - from;
+        progress(sentBytes);
+        return null;
+      }
+      if (attempt22 === ATTEMPTS || failure.error !== null || !retryable(tried.error, tried.status))
+        return tried.error;
+      await sleep2(waitAfter(tried.error, attempt22), signal);
+      if (failure.error !== null) return tried.error;
+    }
+  };
+  const worker = async () => {
+    while (failure.error === null && next <= partCount) {
+      const n = next;
+      next += 1;
+      const error = await sendPart(n);
+      if (error !== null) failure.error ??= error;
+    }
+  };
+  signal?.addEventListener("abort", onAbort);
+  await Promise.all(
+    Array.from({ length: Math.min(CONCURRENCY, partCount) }, worker)
+  );
+  signal?.removeEventListener("abort", onAbort);
+  if (failure.error !== null) {
+    await callOff();
+    return fail(failure.error);
+  }
+  const completed = await call(a.http, {
+    method: "POST",
+    path: `${base}/complete`,
+    body: {
+      parts: etags.map((etag, i) => ({ partNumber: i + 1, etag }))
+    },
+    withToken: true
+  });
+  if (completed.error !== null) {
+    if (completed.answer !== null && completed.error.code !== "INVALID_RESPONSE")
+      await callOff();
+    return fail(completed.error);
+  }
+  return dataOf2(completed.answer.status, completed.answer.body, isUploadResult);
+}
+var isThenable = (value) => typeof value === "object" && value !== null && typeof value.then === "function";
 var MAX_SINGLE_UPLOAD_BYTES2 = 52428800;
 var STORAGE_MESSAGES = {
   bucket: "The bucket name is not valid.",
-  tooLarge: "Uploads over 50 MiB are not supported yet.",
   request: "The storage request is not valid.",
   body: "upload takes a Blob, File, ArrayBuffer, typed array or string."
 };
@@ -7340,9 +7532,6 @@ function invalidPath(reason) {
     message: `The object path is not valid: it ${reason}.`
   };
 }
-function objectTooLarge() {
-  return { code: "OBJECT_TOO_LARGE", message: STORAGE_MESSAGES.tooLarge };
-}
 function encodePath(path) {
   if (typeof path !== "string" || path === "")
     return { ok: false, error: invalidPath("is empty") };
@@ -7379,6 +7568,16 @@ function encodeBucket(bucket) {
     };
   return { ok: true, encoded: encodeURIComponent(bucket) };
 }
+function objectRoute(bucket, path) {
+  const encodedBucket = encodeBucket(bucket);
+  if (!encodedBucket.ok) return encodedBucket;
+  const encodedPath = encodePath(path);
+  if (!encodedPath.ok) return encodedPath;
+  return {
+    ok: true,
+    encoded: `${encodedBucket.encoded}/${encodedPath.encoded}`
+  };
+}
 var isArrayBuffer = (value) => Object.prototype.toString.call(value) === "[object ArrayBuffer]";
 function isDetached(buffer) {
   if (!isArrayBuffer(buffer)) return false;
@@ -7459,36 +7658,12 @@ function payloadOf(body, contentType) {
   };
 }
 var SIGNED_PREFIX = "/_naro/v1/storage/object/sign/";
-function fail(error) {
-  return { data: null, error };
-}
-var isUploadResult = (value) => isRecord(value) && typeof value.id === "string" && typeof value.path === "string" && typeof value.fullPath === "string";
 var isFileObject = (value) => isRecord(value) && typeof value.id === "string" && typeof value.name === "string" && isRecord(value.metadata);
 var isEntry2 = (value) => isRecord(value) && typeof value.name === "string" && (value.id === null || isFileObject(value));
 var isSigned = (value) => isRecord(value) && typeof value.signedUrl === "string" && value.signedUrl.startsWith(SIGNED_PREFIX);
 function listOf(guard) {
   return (value) => Array.isArray(value) && value.every(guard);
 }
-function dataOf2(status, body, guard) {
-  if (isRecord(body) && Object.hasOwn(body, "data") && guard(body.data))
-    return { data: body.data, error: null };
-  return fail(invalidResponse(status));
-}
-async function readJson(response, guard) {
-  let text;
-  try {
-    text = await response.text();
-  } catch (error) {
-    return fail(networkError(error));
-  }
-  let body;
-  try {
-    body = JSON.parse(text);
-  } catch {
-    return fail(invalidResponse(response.status));
-  }
-  return dataOf2(response.status, body, guard);
-}
 var StorageFileApi = class {
   #http;
   #auth;
@@ -7500,14 +7675,9 @@ var StorageFileApi = class {
   }
   /** `/storage/object/<route><bucket>/<path>`, or the refusal no request needs. */
   #objectPath(route2, path) {
-    const bucket = encodeBucket(this.#bucket);
-    if (!bucket.ok) return bucket;
-    const name = encodePath(path);
-    if (!name.ok) return name;
-    return {
-      ok: true,
-      path: `/storage/object/${route2}${bucket.encoded}/${name.encoded}`
-    };
+    const target = objectRoute(this.#bucket, path);
+    if (!target.ok) return target;
+    return { ok: true, path: `/storage/object/${route2}${target.encoded}` };
   }
   /** `/storage/object/<route><bucket>`, for the routes that take names in the body. */
   #bucketPath(route2) {
@@ -7529,8 +7699,24 @@ var StorageFileApi = class {
     const cache = `max-age=${options.cacheControl ?? "3600"}`;
     const unreadable = headerProblem(options.contentType, cache);
     if (unreadable !== null) return fail(unreadable);
-    if (payload.size > MAX_SINGLE_UPLOAD_BYTES2) return fail(objectTooLarge());
+    const { signal } = options;
+    if (signal?.aborted) return fail(uploadAborted());
     await this.#auth.ready();
+    if (payload.size > MAX_SINGLE_UPLOAD_BYTES2)
+      return uploadInParts({
+        http: this.#http,
+        method,
+        bucket: this.#bucket,
+        path,
+        // No copy: a Blob stays lazy, a Uint8Array is viewed, an ArrayBuffer wrapped.
+        body: isArrayBuffer(payload.body) ? new Uint8Array(payload.body) : payload.body,
+        size: payload.size,
+        contentType: payload.type,
+        cacheControl: cache,
+        upsert,
+        ...options.onProgress ? { onProgress: options.onProgress } : {},
+        signal
+      });
     const headers = {
       "content-type": payload.type,
       "cache-control": cache
@@ -7541,7 +7727,9 @@ var StorageFileApi = class {
       path: target.path,
       headers,
       body: payload.body,
-      withToken: true
+      withToken: true,
+      // The fetch stops with the body: the worker undoes its claim at once.
+      signal
     });
     if (sent.error !== null) return fail(sent.error);
     return readJson(sent.response, isUploadResult);
@@ -7787,6 +7975,7 @@ var CP_USAGE = "Usage: naro storage cp <from> <to> (one side naro://<bucket>/<pa
 var RM_USAGE = "Usage: naro storage rm naro://<bucket>/<path>\u2026 [--recursive] [--yes]";
 var LS_USAGE = "Usage: naro storage ls [naro://<bucket>[/<prefix>]] [--recursive]";
 var BACKEND_OFF_MESSAGE = "The backend is turned off for this project. Turn it on with `naro backend enable` first.";
+var FOUR_GIB = 4294967296;
 var PAGE = 1e3;
 var MAX_OFFSET = 1e5;
 var TRUNCATED_WARNING = `\u26A0 A folder's listing stopped at ${(MAX_OFFSET + PAGE).toLocaleString("en-US")} entries, as far as the API's offset reaches; there may be more.`;
@@ -7889,7 +8078,8 @@ async function objects(context) {
       { cause: error }
     );
   }
-  return { projectId, storage: naro.storage };
+  const url = new URL(backend.url.trim().replace(/\/+$/, "")).origin;
+  return { projectId, storage: naro.storage, url, serviceKey };
 }
 function isFolder(entry) {
   return entry.id === null;
@@ -7982,33 +8172,56 @@ async function storageLs(context) {
   );
 }
 var INTERRUPTS = ["SIGINT", "SIGTERM", "SIGHUP"];
-function removeOnInterrupt(partial) {
-  const stop = () => {
+function endWith(signal) {
+  try {
+    process.kill(process.pid, signal);
+  } catch {
+    process.exit(1);
+  }
+}
+function onInterrupt(onSignal) {
+  for (const signal of INTERRUPTS) process.on(signal, onSignal);
+  return () => {
     for (const signal of INTERRUPTS) process.off(signal, onSignal);
   };
-  function onSignal(signal) {
+}
+function removeOnInterrupt(partial) {
+  const stop = onInterrupt((signal) => {
     stop();
     try {
       rmSync2(partial, { force: true });
     } catch {
     }
-    try {
-      process.kill(process.pid, signal);
-    } catch {
-      process.exit(1);
-    }
-  }
-  for (const signal of INTERRUPTS) process.on(signal, onSignal);
+    endWith(signal);
+  });
   return stop;
 }
-async function writeAtomically(blob, destination) {
+function stopOnInterrupt(onFirst) {
+  const controller = new AbortController();
+  let caught = null;
+  const stop = onInterrupt((signal) => {
+    if (caught !== null) {
+      stop();
+      endWith(signal);
+      return;
+    }
+    caught = signal;
+    onFirst();
+    controller.abort();
+  });
+  return {
+    signal: controller.signal,
+    settle: () => {
+      stop();
+      return caught;
+    }
+  };
+}
+async function writeAtomically(bytes, destination) {
   const partial = join6(dirname3(destination), `.${randomUUID()}.naro-partial`);
   const stopListening = removeOnInterrupt(partial);
   try {
-    await pipeline2(
-      Readable.fromWeb(blob.stream()),
-      createWriteStream2(partial, { flags: "wx" })
-    );
+    await pipeline2(bytes, createWriteStream2(partial, { flags: "wx" }));
     await rename(partial, destination);
   } catch (error) {
     await rm(partial, { force: true }).catch(() => void 0);
@@ -8017,6 +8230,34 @@ async function writeAtomically(blob, destination) {
     stopListening();
   }
 }
+function progressReporter(output, total) {
+  const tty = process.stderr.isTTY === true;
+  let lastTenth = -1;
+  let lastLength = 0;
+  let open = false;
+  return {
+    report(sent) {
+      const percent2 = Math.floor(sent / total * 100);
+      const line = `\u2191 ${binarySize(sent)} / ${binarySize(total)} (${String(percent2)}%)`;
+      if (tty) {
+        open = sent !== total;
+        output.progress(`\r${line.padEnd(lastLength)}${open ? "" : "\n"}`);
+        lastLength = line.length;
+        return;
+      }
+      const tenth = Math.floor(percent2 / 10);
+      if (tenth === lastTenth && sent !== total) return;
+      lastTenth = tenth;
+      output.progress(`${line}
+`);
+    },
+    close() {
+      if (!open) return;
+      open = false;
+      output.progress("\n");
+    }
+  };
+}
 async function upload(context, local, target) {
   const file = resolve5(context.cwd, local);
   const info = await stat(file).catch(() => null);
@@ -8035,32 +8276,49 @@ async function upload(context, local, target) {
       "VALIDATION_FAILED",
       `${printable(local)} is not a regular file.`
     );
-  if (info.size > MAX_SINGLE_UPLOAD_BYTES)
-    throw new NaroError(
-      "OBJECT_TOO_LARGE",
-      dataError("OBJECT_TOO_LARGE", { single: true }).message
-    );
   const { cacheControl } = context.flags;
   if (cacheControl !== void 0 && !isMaxAge(cacheControl))
     throw new NaroError("VALIDATION_FAILED", CACHE_CONTROL_RULE);
   const path = target.path === "" || target.path.endsWith("/") ? `${target.path}${basename2(file)}` : target.path;
-  const { projectId, storage } = await objects(context);
   const body = await openAsBlob(file);
+  if (body.size !== info.size)
+    throw new NaroError(
+      "VALIDATION_FAILED",
+      info.size >= FOUR_GIB ? `${printable(local)} is ${binarySize(info.size)}, but Node reads it as ${binarySize(body.size)}: naro storage cp cannot upload a file of 4 GiB or more yet.` : `${printable(local)} changed while it was being opened (${binarySize(info.size)}, then ${binarySize(body.size)}). Run the copy again once nothing is writing to it.`
+    );
+  const { projectId, storage } = await objects(context);
   const contentType = context.flags.contentType ?? typeFor(file);
-  const result = unwrap(
-    await storage.from(target.bucket).upload(path, body, {
+  const progress = body.size > MAX_SINGLE_UPLOAD_BYTES && !context.output.json ? progressReporter(context.output, body.size) : void 0;
+  const interrupt = stopOnInterrupt(() => {
+    progress?.close();
+    context.output.progress("Stopping the upload\u2026\n");
+  });
+  let answer;
+  let caught;
+  try {
+    answer = await storage.from(target.bucket).upload(path, body, {
       ...contentType === void 0 ? {} : { contentType },
       ...cacheControl === void 0 ? {} : { cacheControl },
-      upsert: context.flags.upsert === true
-    })
-  );
-  const to = `${NARO_SCHEME}${target.bucket}/${path}`;
-  context.output.result(
-    { projectId, from: local, to, bytes: body.size, id: result.id },
-    [
-      `\u2705 Uploaded ${printable(local)} \u2192 ${printable(to)} (${binarySize(body.size)})`
-    ]
-  );
+      upsert: context.flags.upsert === true,
+      ...progress === void 0 ? {} : { onProgress: progress.report },
+      signal: interrupt.signal
+    });
+  } finally {
+    progress?.close();
+    caught = interrupt.settle();
+  }
+  try {
+    const result = unwrap(answer);
+    const to = `${NARO_SCHEME}${target.bucket}/${path}`;
+    context.output.result(
+      { projectId, from: local, to, bytes: body.size, id: result.id },
+      [
+        `\u2705 Uploaded ${printable(local)} \u2192 ${printable(to)} (${binarySize(body.size)})`
+      ]
+    );
+  } finally {
+    if (caught !== null) endWith(caught);
+  }
 }
 var WINDOWS_DEVICE = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i;
 var MAX_FILE_NAME_BYTES = 255;
@@ -8073,6 +8331,62 @@ function savedAs(path) {
     );
   return name;
 }
+var NETWORK_MESSAGE = "The request did not reach the Naro backend. Check the url and the network.";
+async function failureOf(response) {
+  const { status } = response;
+  const invalid = {
+    code: "INVALID_RESPONSE",
+    message: `The server did not answer like a Naro backend (HTTP ${String(status)}).`,
+    details: { status }
+  };
+  let text;
+  try {
+    text = await response.text();
+  } catch {
+    return { code: "NETWORK_ERROR", message: NETWORK_MESSAGE };
+  }
+  let body;
+  if (text.trim() !== "") {
+    try {
+      body = JSON.parse(text);
+    } catch {
+      return invalid;
+    }
+  }
+  const error = typeof body === "object" && body !== null && "error" in body ? body.error : void 0;
+  if (typeof error !== "object" || error === null) return invalid;
+  const { code, message, details } = error;
+  if (typeof code !== "string" || code === "" || typeof message !== "string")
+    return invalid;
+  return details === void 0 ? { code, message } : { code, message, details };
+}
+async function getObject(url, serviceKey) {
+  let response;
+  try {
+    response = await fetch(url, {
+      headers: { apikey: serviceKey },
+      redirect: "error"
+    });
+  } catch {
+    throw new NaroError("NETWORK_ERROR", NETWORK_MESSAGE);
+  }
+  if (response.ok) return response;
+  return unwrap({ data: null, error: await failureOf(response) });
+}
+async function* chunksOf2(response, received) {
+  if (response.body === null) return;
+  try {
+    for await (const chunk2 of Readable.fromWeb(
+      response.body
+    )) {
+      const bytes = chunk2;
+      received.bytes += bytes.byteLength;
+      yield bytes;
+    }
+  } catch {
+    throw new NaroError("NETWORK_ERROR", NETWORK_MESSAGE);
+  }
+}
 async function download(context, source, local) {
   if (source.path === "" || source.path.endsWith("/"))
     throw new NaroError(
@@ -8088,14 +8402,20 @@ async function download(context, source, local) {
       "VALIDATION_FAILED",
       `Cannot save to ${printable(local)}: its folder does not exist.`
     );
-  const { projectId, storage } = await objects(context);
-  const blob = unwrap(await storage.from(source.bucket).download(source.path));
-  await writeAtomically(blob, destination);
+  const route2 = objectRoute(source.bucket, source.path);
+  if (!route2.ok) throw new NaroError(route2.error.code, route2.error.message);
+  const { projectId, url, serviceKey } = await objects(context);
+  const response = await getObject(
+    `${url}/_naro/v1/storage/object/${route2.encoded}`,
+    serviceKey
+  );
+  const received = { bytes: 0 };
+  await writeAtomically(chunksOf2(response, received), destination);
   const from = `${NARO_SCHEME}${source.bucket}/${source.path}`;
   context.output.result(
-    { projectId, from, to: destination, bytes: blob.size },
+    { projectId, from, to: destination, bytes: received.bytes },
     [
-      `\u2705 Downloaded ${printable(from)} \u2192 ${printable(destination)} (${binarySize(blob.size)})`
+      `\u2705 Downloaded ${printable(from)} \u2192 ${printable(destination)} (${binarySize(received.bytes)})`
     ]
   );
 }
@@ -8388,8 +8708,9 @@ Usage:
   naro storage ls [naro://<bucket>[/<prefix>]] [--recursive]
                                      The buckets, or the folders and objects under a prefix
   naro storage cp <from> <to> [--upsert] [--content-type <t>] [--cache-control <seconds>]
-                                     One file between this machine and naro://<bucket>/<path>, 50 MiB at most,
+                                     One file between this machine and naro://<bucket>/<path>, up to the object limit (over 50 MiB in parts),
                                      with the project's service key (NARO_SERVICE_KEY, or fetched with a warning).
+                                     A big upload shows its progress on stderr; a file of 4 GiB or more cannot be uploaded yet.
                                      A download replaces a local file of the same name
   naro storage rm naro://<bucket>/<path>\u2026 [--recursive]
                                      Remove objects; --recursive removes what is under a folder (asks first):

package/dist/output.d.ts

@@ -21,6 +21,11 @@ export declare class Output {
      * whose stdout is the deliverable itself (`naro gen types > db.d.ts`).
      */
     warn(message: string): void;
+    /**
+     * Text on stderr exactly as given, with no line break added: a progress
+     * line a terminal rewrites in place (`\r…`). Never stdout, in either mode.
+     */
+    progress(text: string): void;
     /** Extra diagnostics, only with --debug. */
     debugLog(message: string): void;
     /**

package/dist/upload.d.ts

@@ -8,4 +8,6 @@ export interface UploadOptions {
 export declare function uploadArtifact(artifact: DeploymentArtifact, opts: UploadOptions): Promise<{
     artifactKey: string;
     previewUrl: string | null;
+    /** How many files, how big and how long the upload took. */
+    uploadSummary: string;
 }>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "naro-cli",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "type": "module",
   "bin": {
     "naro": "./dist/index.js"
@@ -33,12 +33,12 @@
     "tsx": "4.23.12",
     "typescript": "7.0.2",
     "vitest": "3.2.7",
-    "naro-js": "0.3.0",
+    "naro-js": "0.4.0",
     "@next-deploy/core": "0.1.0",
     "@next-deploy/data-core": "0.1.0",
     "@next-deploy/sdk": "0.1.0",
-    "@next-deploy/config": "0.1.0",
-    "@next-deploy/build": "0.1.0"
+    "@next-deploy/build": "0.1.0",
+    "@next-deploy/config": "0.1.0"
   },
   "scripts": {
     "build": "tsup && pnpm build:types",