@vosjs/cli 0.35.0 → 0.36.0

package/dist/{chunk-VQXOM2NU.js → chunk-MIZWK5AN.js}

@@ -3876,9 +3876,9 @@ function proposeTransitions(input, kind) {
   for (const step of steps) {
     if (!step.navigated || step.skipped) continue;
     const name = step.id ?? String(step.step);
-    const wait = step.do === "wait";
-    const outEnd = round3(wait ? step.tStart : step.tEnd);
-    const inStart = round3(wait ? step.tEnd : step.tEnd + STEP_SETTLE_SECONDS);
+    const wait2 = step.do === "wait";
+    const outEnd = round3(wait2 ? step.tStart : step.tEnd);
+    const inStart = round3(wait2 ? step.tEnd : step.tEnd + STEP_SETTLE_SECONDS);
     const segs = doc.segments;
     if (segs.some(
       (s) => !s.media && Math.abs(s.out - outEnd) < 0.05 && s !== segs.at(-1)
@@ -6165,8 +6165,8 @@ async function clockMotion(dur, at2, clock) {
     await at2(easeInOutCubic(Math.min(1, elapsed / dur)));
     samples++;
     const next = start + Math.ceil((clock.now() - start) / MOTION_TICK_MS) * MOTION_TICK_MS;
-    const wait = Math.min(next, start + dur) - clock.now();
-    if (wait > 0) await clock.sleep(wait);
+    const wait2 = Math.min(next, start + dur) - clock.now();
+    if (wait2 > 0) await clock.sleep(wait2);
   }
   await at2(1);
   return samples + 1;
@@ -6176,8 +6176,8 @@ async function clockTyping(chars, delay, type, clock) {
   for (let i = 0; i < chars.length; i++) {
     await type(chars[i], i);
     const due = start + (i + 1) * delay;
-    const wait = due - clock.now();
-    if (wait > 0 && i < chars.length - 1) await clock.sleep(wait);
+    const wait2 = due - clock.now();
+    if (wait2 > 0 && i < chars.length - 1) await clock.sleep(wait2);
   }
 }
 function askedMs(step) {
@@ -7385,7 +7385,7 @@ async function cmdMove(argv) {
   });
   const key = requireCredential(strFlag(flags, "key"));
   const folderId = toRef === "none" ? null : resolveFolder(await listFolders(origin, key), toRef).id;
-  let failed = 0;
+  let failed2 = 0;
   const moved = [];
   for (const raw of positionals) {
     const id = parseVosId(raw);
@@ -7400,28 +7400,28 @@ async function cmdMove(argv) {
       continue;
     }
     if (asVos.status === 404) {
-      const asAsset = await apiJson(origin, `/api/assets/${id}`, {
+      const asAsset2 = await apiJson(origin, `/api/assets/${id}`, {
         method: "PATCH",
         key,
         body: { folderId }
       });
-      if (asAsset.status === 200) {
+      if (asAsset2.status === 200) {
         moved.push({ id, kind: "asset" });
         r.log(`moved asset ${id}`);
         continue;
       }
-      failed++;
-      r.log(apiError(`move ${id}`, asAsset));
+      failed2++;
+      r.log(apiError(`move ${id}`, asAsset2));
       continue;
     }
-    failed++;
+    failed2++;
     r.log(apiError(`move ${id}`, asVos));
   }
   r.done(
-    { moved, failed, folderId },
-    `moved ${moved.length}/${positionals.length} into ${toRef === "none" ? "the top level" : toRef}${failed ? ` \u2014 ${failed} failed` : ""}`
+    { moved, failed: failed2, folderId },
+    `moved ${moved.length}/${positionals.length} into ${toRef === "none" ? "the top level" : toRef}${failed2 ? ` \u2014 ${failed2} failed` : ""}`
   );
-  return failed ? EXIT_ERROR : EXIT_OK;
+  return failed2 ? EXIT_ERROR : EXIT_OK;
 }
 function recipeLine(filename, body) {
   const h = recipeHints(body);
@@ -7567,6 +7567,144 @@ async function cmdFolder(argv) {
   }
 }
 
+// src/plugin/uploadAsset.ts
+var SINGLE_SHOT_MAX_BYTES = 32 * 1024 * 1024;
+var PART_ATTEMPTS = 3;
+function planParts(totalBytes, partBytes) {
+  if (totalBytes <= 0 || partBytes <= 0) return [];
+  const parts = [];
+  for (let start = 0; start < totalBytes; start += partBytes) {
+    parts.push({
+      partNumber: parts.length + 1,
+      start,
+      end: Math.min(start + partBytes, totalBytes)
+    });
+  }
+  return parts;
+}
+function failed(what, r) {
+  const detail = typeof r.body.error === "string" ? r.body.error : "";
+  return new Error(`${what} (${r.status})${detail ? `: ${detail}` : ""}`);
+}
+function asAsset(body) {
+  return {
+    id: String(body.id),
+    url: String(body.url),
+    size: typeof body.size === "number" ? body.size : 0,
+    reused: body.reused === true
+  };
+}
+function transient(status) {
+  return status >= 500 || status === 429;
+}
+var wait = (ms) => new Promise((r) => setTimeout(r, ms));
+async function uploadAsset(target, bytes, opts) {
+  return bytes.length > SINGLE_SHOT_MAX_BYTES ? uploadInParts(target, bytes, opts) : uploadWhole(target, bytes, opts);
+}
+async function uploadWhole(target, bytes, opts) {
+  const res = await apiJson(target.origin, "/api/assets/recording", {
+    method: "POST",
+    key: target.key,
+    headers: {
+      "Content-Type": opts.contentType,
+      "Content-Length": String(bytes.length),
+      "X-Filename": opts.filename,
+      "X-Content-Hash": opts.contentHash,
+      ...opts.durationSeconds && opts.durationSeconds > 0 ? { "X-Content-Duration": opts.durationSeconds.toFixed(3) } : {}
+    },
+    raw: bytes
+  });
+  if (res.status !== 201 && res.status !== 200)
+    throw failed("upload failed", res);
+  return asAsset(res.body);
+}
+async function uploadInParts(target, bytes, opts) {
+  const begun = await apiJson(
+    target.origin,
+    "/api/assets/recording/multipart",
+    {
+      method: "POST",
+      key: target.key,
+      body: {
+        filename: opts.filename,
+        contentType: opts.contentType,
+        size: bytes.length,
+        contentHash: opts.contentHash,
+        ...opts.durationSeconds && opts.durationSeconds > 0 ? { durationSeconds: opts.durationSeconds } : {}
+      }
+    }
+  );
+  if (begun.status !== 201 && begun.status !== 200) {
+    throw failed("upload failed", begun);
+  }
+  if (begun.body.reused === true || typeof begun.body.url === "string") {
+    return asAsset(begun.body);
+  }
+  const uploadId = String(begun.body.id);
+  const partBytes = Number(begun.body.partBytes);
+  if (!Number.isFinite(partBytes) || partBytes <= 0) {
+    throw new Error("upload failed: the platform returned no part size");
+  }
+  const parts = planParts(bytes.length, partBytes);
+  const etags = [];
+  try {
+    for (const part of parts) {
+      const chunk2 = bytes.subarray(part.start, part.end);
+      let sent = null;
+      for (let attempt = 1; attempt <= PART_ATTEMPTS; attempt++) {
+        try {
+          sent = await apiJson(
+            target.origin,
+            `/api/assets/recording/multipart/${uploadId}/parts/${part.partNumber}`,
+            {
+              method: "PUT",
+              key: target.key,
+              headers: {
+                "Content-Type": "application/octet-stream",
+                "Content-Length": String(chunk2.length)
+              },
+              raw: chunk2
+            }
+          );
+        } catch (networkError) {
+          if (attempt === PART_ATTEMPTS) throw networkError;
+          await wait(500 * 2 ** (attempt - 1));
+          continue;
+        }
+        if (sent.status === 200) break;
+        if (!transient(sent.status) || attempt === PART_ATTEMPTS) {
+          throw failed(`part ${part.partNumber} failed`, sent);
+        }
+        await wait(500 * 2 ** (attempt - 1));
+      }
+      if (!sent || sent.status !== 200) {
+        throw new Error(`part ${part.partNumber} failed`);
+      }
+      etags.push({
+        partNumber: Number(sent.body.partNumber),
+        etag: String(sent.body.etag)
+      });
+      opts.onPart?.(etags.length, parts.length);
+    }
+    const sealed = await apiJson(
+      target.origin,
+      `/api/assets/recording/multipart/${uploadId}/complete`,
+      { method: "POST", key: target.key, body: { parts: etags } }
+    );
+    if (sealed.status !== 201 && sealed.status !== 200) {
+      throw failed("upload failed", sealed);
+    }
+    return asAsset(sealed.body);
+  } catch (err) {
+    await apiJson(
+      target.origin,
+      `/api/assets/recording/multipart/${uploadId}`,
+      { method: "DELETE", key: target.key }
+    ).catch(() => void 0);
+    throw err;
+  }
+}
+
 // src/plugin/sync.ts
 function apiContext(flags) {
   return {
@@ -7649,31 +7787,25 @@ async function pushTake(dir, flags, r) {
   const bytes = await readFile13(take.paths.recording);
   const hash = createHash("sha256").update(bytes).digest("hex");
   r.log(`uploading recording (${Math.round(bytes.length / 1024)} kB)\u2026`);
-  const upload = await api(ctx, "/assets/recording", {
-    method: "POST",
-    headers: {
-      "Content-Type": "video/webm",
-      "Content-Length": String(bytes.length),
-      "X-Filename": RECORDING_NAME,
-      "X-Content-Hash": hash,
+  let upload;
+  try {
+    upload = await uploadAsset(ctx, new Uint8Array(bytes), {
+      filename: RECORDING_NAME,
+      contentType: "video/webm",
+      contentHash: hash,
       // The take's length so the server holds it to the plan's cap.
-      ...take.meta.durationMs > 0 ? { "X-Content-Duration": (take.meta.durationMs / 1e3).toFixed(3) } : {}
-    },
-    raw: new Uint8Array(bytes)
-  });
-  if (upload.status !== 201 && upload.status !== 200) {
+      ...take.meta.durationMs > 0 ? { durationSeconds: take.meta.durationMs / 1e3 } : {},
+      onPart: (done, total) => r.log(`  part ${done}/${total}`)
+    });
+  } catch (e) {
     throw new Error(
-      `recording upload failed (${upload.status}): ${String(upload.json.error ?? "")}`
+      `recording upload failed: ${e instanceof Error ? e.message : String(e)}`
     );
   }
-  const assetId = String(upload.json.id);
-  const assetUrl = String(upload.json.url);
-  r.event({
-    event: "recording",
-    assetId,
-    reused: upload.json.reused === true
-  });
-  if (upload.json.reused === true) r.log("  recording already hosted \u2014 reused");
+  const assetId = upload.id;
+  const assetUrl = upload.url;
+  r.event({ event: "recording", assetId, reused: upload.reused });
+  if (upload.reused) r.log("  recording already hosted \u2014 reused");
   const docForPush = structuredClone(take.doc);
   docForPush.source.videoKey = assetUrl;
   if (docForPush.source.camKey && !/^(https?:)?\//.test(docForPush.source.camKey)) {
@@ -7693,24 +7825,21 @@ async function pushTake(dir, flags, r) {
     const media = await readFile13(file);
     const mediaHash = createHash("sha256").update(media).digest("hex");
     const type = mediaContentType(file);
-    const put = await api(ctx, "/assets/recording", {
-      method: "POST",
-      headers: {
-        "Content-Type": type,
-        "Content-Length": String(media.length),
-        "X-Filename": basename(file),
-        "X-Content-Hash": mediaHash
-      },
-      raw: new Uint8Array(media)
-    });
-    if (put.status !== 201 && put.status !== 200) {
+    let put;
+    try {
+      put = await uploadAsset(ctx, new Uint8Array(media), {
+        filename: basename(file),
+        contentType: type,
+        contentHash: mediaHash
+      });
+    } catch (e) {
       throw new Error(
-        `${ref.where} upload failed (${put.status}): ${String(put.json.error ?? "")}`
+        `${ref.where} upload failed: ${e instanceof Error ? e.message : String(e)}`
       );
     }
-    ref.set(String(put.json.url));
+    ref.set(put.url);
     r.log(
-      `  ${ref.where}: ${ref.key} \u2192 asset ${String(put.json.id)}${put.json.reused === true ? " (reused)" : ""}`
+      `  ${ref.where}: ${ref.key} \u2192 asset ${put.id}${put.reused ? " (reused)" : ""}`
     );
   }
   const lowered = lowerToComposition3(docForPush);
@@ -11246,4 +11375,4 @@ export {
   convertAgentBrowser,
   run
 };
-//# sourceMappingURL=chunk-VQXOM2NU.js.map
+//# sourceMappingURL=chunk-MIZWK5AN.js.map