naro-cli 0.14.0 → 0.16.0

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-U7AZSAFS.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}
@@ -5272,7 +5278,7 @@ function parseSize(text) {
     throw new NaroError("VALIDATION_FAILED", SIZE_MESSAGE);
   return bytes;
 }
-function binarySize(bytes) {
+function binarySize(bytes, decimals = 1) {
   const units = ["B", "KiB", "MiB", "GiB", "TiB"];
   let value = bytes;
   let unit = 0;
@@ -5280,7 +5286,7 @@ function binarySize(bytes) {
     value /= 1024;
     unit += 1;
   }
-  const shown = unit === 0 ? String(value) : String(Number(value.toFixed(1)));
+  const shown = unit === 0 ? String(value) : String(Number(value.toFixed(decimals)));
   return `${shown} ${units[unit] ?? "B"}`;
 }
 function count(n, noun) {
@@ -5308,6 +5314,51 @@ function bucketLine(bucket) {
   const line = `  ${cells.join("  ")}`;
   return bucket.deletingAt === null ? line : `${line}  (being removed: \`naro storage bucket remove ${name} --empty\` finishes it)`;
 }
+var WARN_PERCENT = 80;
+function utcClock(iso) {
+  const at = new Date(iso);
+  return Number.isNaN(at.getTime()) ? null : at.toISOString().slice(11, 16);
+}
+function warnedPercent(value, limit) {
+  if (limit === null || !(limit > 0)) return null;
+  const percent2 = Math.floor(value * 100 / limit);
+  return percent2 >= WARN_PERCENT ? percent2 : null;
+}
+function meterLines(info) {
+  const { today, limits } = info;
+  if (today === null) return [];
+  const reads = count(today.classBOps, "read");
+  const writes = today.classAOps.toLocaleString("en-US");
+  const dailyOps = limits.dailyOps?.toLocaleString("en-US") ?? null;
+  const lines = [
+    dailyOps === null ? `Today (UTC): ${writes} write operations, ${reads}` : `Today (UTC): ${writes} of ${dailyOps} write operations, ${reads}`
+  ];
+  if (today.measuredBytes === null)
+    lines.push("Measured:    not yet (the meter reads R2 every 15 minutes)");
+  else {
+    const time = today.measuredAt === null ? null : utcClock(today.measuredAt);
+    lines.push(
+      `Measured:    ${binarySize(today.measuredBytes, 2)} in R2${time === null ? "" : ` at ${time} UTC`}`
+    );
+  }
+  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 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(
+      dailyOps === null ? "\u2717 Uploads are stopped until 00:00 UTC: today's write operations are used. Downloads still work." : `\u2717 Uploads are stopped until 00:00 UTC: today's ${dailyOps} write operations are used. Downloads still work.`
+    );
+  const storage = today.bytesBlocked || today.measuredBytes === null ? null : warnedPercent(today.measuredBytes, limits.bytes);
+  if (storage !== null)
+    lines.push(`\u26A0 ${String(storage)}% of the storage limit is used.`);
+  const operations = today.opsBlocked ? null : warnedPercent(today.classAOps, limits.dailyOps);
+  if (operations !== null)
+    lines.push(
+      `\u26A0 ${String(operations)}% of today's write operations are used.`
+    );
+  return lines;
+}
 function storageLines(info) {
   if (!info.enabled)
     return [
@@ -5317,8 +5368,9 @@ 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)}`,
     ...info.buckets.map(bucketLine)
   ];
@@ -5503,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",
@@ -5668,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;
@@ -5676,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",
@@ -7266,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."
 };
@@ -7294,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") };
@@ -7333,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;
@@ -7413,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;
@@ -7454,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) {
@@ -7483,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
@@ -7495,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);
@@ -7741,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.`;
@@ -7843,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;
@@ -7936,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);
@@ -7971,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);
@@ -7989,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;
@@ -8027,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(
@@ -8042,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)})`
     ]
   );
 }
@@ -8328,7 +8694,7 @@ Usage:
                                      naro_insert, naro_update, naro_delete (shorthand for CREATE POLICY)
   naro policy remove <table>         Drop every policy on it: back to deny (asks first)
 
-  naro storage [status]              Naro Storage: on or off, limits, what is stored, the buckets
+  naro storage [status]              Naro Storage: on or off, limits, what is stored, today's operations, the buckets
   naro storage enable                Turn Storage on: the project's R2 bucket, bound to its backend
                                      (safe to re-run; applies a plan change's limits)
   naro storage bucket list           The buckets: public or private, objects, bytes, limits
@@ -8342,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):