deepspace 0.12.0 → 0.14.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/cli.ts
-import { defineCommand as defineCommand14, runMain, runCommand } from "citty";
+import { defineCommand as defineCommand14, runMain, runCommand, renderUsage } from "citty";
 import { sync as spawnSync8 } from "cross-spawn";
 import { readFileSync as readFileSync28, existsSync as existsSync26 } from "fs";
 import { dirname as dirname10, join as join24 } from "path";
@@ -44,6 +44,13 @@ import * as p2 from "@clack/prompts";
 import { isAbsolute } from "path";
 
 // src/cli/lib/cli-format.ts
+var ANSI_RE = /\[[0-9;]*m/g;
+function stripAnsi(s) {
+  return s.replace(ANSI_RE, "");
+}
+function forTerminal(s) {
+  return process.stdout.isTTY ? s : stripAnsi(s);
+}
 function shQuote(s) {
   return `'${s.replace(/'/g, "'\\''")}'`;
 }
@@ -176,7 +183,10 @@ var API_ERROR_HINTS = {
   test_account_cannot_be_collaborator: "Test accounts cannot be added as collaborators. Use a real DeepSpace account.",
   user_not_found: "No DeepSpace user with that email. They need to log in to DeepSpace at least once (`deepspace auth login`, or sign in to any app) before they can be referenced by email.",
   insufficient_credits: "Out of credits. Inviting a new collaborator by email sends them a transactional email billed to your account \u2014 top up your credits and try again.",
-  invite_email_failed: "The invite email could not be sent. You were not charged \u2014 please try again in a moment."
+  // "Try again" alone sends callers into a loop when the address itself is the
+  // problem — the send is what failed, and an undeliverable address fails the
+  // same way every time.
+  invite_email_failed: "The invite itself was not created and the charge was voided \u2014 nothing to undo. Retrying helps only if the send was transient; check the address is real and deliverable first. An email is needed ONLY for someone with no DeepSpace account yet: an existing user is added instantly, so having them sign in once and re-running this skips email entirely. If a retry now reports `already_invited` with no email sent, cancel the stuck invite (`deepspace app collaborators cancel <email>`) and invite again."
 };
 function formatCliError(err) {
   const message = err instanceof Error ? err.message : String(err);
@@ -222,6 +232,18 @@ function wrapCommandErrors(cmd) {
 }
 
 // src/cli/lib/command-suggestions.ts
+function splitTokenPath(token, table) {
+  const parts = token.trim().split(/\s+/);
+  if (parts.length < 2) return null;
+  let node = table;
+  for (const part of parts) {
+    const next = node?.[part];
+    if (!next) return null;
+    node = next.subCommands;
+  }
+  return parts;
+}
+var DESTRUCTIVE_VERBS = /* @__PURE__ */ new Set(["rm", "delete", "remove", "drop", "clear", "undeploy", "kill"]);
 function editDistance(a, b) {
   const left = a.toLowerCase();
   const right = b.toLowerCase();
@@ -263,12 +285,15 @@ function findUnknownCommand(argv, rootCommands) {
     if (!table || token.startsWith("-")) return null;
     const command = table[token];
     if (!command) {
-      const relativeSuggestion = closestCommandPath(token, table);
+      const split = splitTokenPath(token, table);
+      const relativeSuggestion = split ?? closestCommandPath(token, table);
       if (!relativeSuggestion) return null;
       return {
         attemptedPath: ["deepspace", ...accepted, token],
         helpPath: ["deepspace", ...accepted],
-        suggestion: ["deepspace", ...accepted, ...relativeSuggestion]
+        suggestion: ["deepspace", ...accepted, ...relativeSuggestion],
+        executable: !DESTRUCTIVE_VERBS.has(relativeSuggestion.at(-1) ?? ""),
+        ...split ? { quotedToken: true } : {}
       };
     }
     accepted.push(token);
@@ -2544,16 +2569,31 @@ function formatSchemaLintFindings(findings) {
 }
 
 // src/cli/lib/port.ts
-import { createServer } from "net";
+import { createServer, Socket } from "net";
 var DEFAULT_PORT = 5173;
-function checkPortAvailable(port, host = "0.0.0.0") {
+function isPortListening(port, host, timeoutMs = 500) {
+  const target2 = host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
   return new Promise((resolve19) => {
-    const srv = createServer();
-    srv.once("error", () => resolve19(false));
-    srv.once("listening", () => srv.close(() => resolve19(true)));
-    srv.listen(port, host);
+    const socket = new Socket();
+    const done = (listening) => {
+      socket.destroy();
+      resolve19(listening);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.once("connect", () => done(true));
+    socket.once("timeout", () => done(false));
+    socket.once("error", () => done(false));
+    socket.connect(port, target2);
   });
 }
+async function waitForPortListening(port, host, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await isPortListening(port, host)) return true;
+    await new Promise((resolve19) => setTimeout(resolve19, 250));
+  }
+  return false;
+}
 function resolvePort(arg) {
   const raw = arg ?? process.env.DEEPSPACE_PORT;
   if (!raw) return DEFAULT_PORT;
@@ -2565,6 +2605,8 @@ function resolvePort(arg) {
 }
 
 // src/cli/commands/dev.ts
+var DEFAULT_DEV_HOST = "0.0.0.0";
+var READINESS_TIMEOUT_MS = 12e4;
 var DEPLOY_URL = process.env.DEEPSPACE_DEPLOY_URL ?? PLATFORM_URLS.deploy;
 function noAppDirMessage(start, children) {
   const lines = [`No wrangler.toml found at or above ${start}.`];
@@ -2600,6 +2642,11 @@ var dev_default = defineDeepspaceCommand({
       type: "string",
       description: `Port to bind (default ${DEFAULT_PORT}, or $DEEPSPACE_PORT)`,
       required: false
+    },
+    host: {
+      type: "string",
+      description: `Interface to bind (default ${DEFAULT_DEV_HOST} \u2014 reachable from outside a container)`,
+      required: false
     }
   },
   async run({ args }) {
@@ -2608,6 +2655,7 @@ var dev_default = defineDeepspaceCommand({
     };
     preflightNodeVersion("dev start");
     const wranglerEnv = typeof args.env === "string" && args.env.trim() ? args.env.trim() : void 0;
+    const host = typeof args.host === "string" && args.host.trim() ? args.host.trim() : DEFAULT_DEV_HOST;
     const start = resolve7(args.dir ?? ".");
     const appDir = findAppDir(start);
     if (!appDir) {
@@ -2671,6 +2719,7 @@ var dev_default = defineDeepspaceCommand({
     say(`Logged in as ${payload.name ?? payload.email}`);
     if (wranglerEnv) say(`Wrangler env: ${wranglerEnv}`);
     say(`Port: ${port}`);
+    if (host !== DEFAULT_DEV_HOST) say(`Host: ${host}`);
     let generatedSecretsCache;
     const appIdForSecrets = readAppId(appDir, wranglerEnv);
     if (appIdForSecrets) {
@@ -2698,7 +2747,7 @@ var dev_default = defineDeepspaceCommand({
       { sharedDevVarsCache }
     );
     preflightWindowsWorkerd(appDir);
-    if (!await checkPortAvailable(port)) {
+    if (await isPortListening(port, host)) {
       const killArgv = port === DEFAULT_PORT ? ["deepspace", "dev", "kill"] : ["deepspace", "dev", "kill", "--port", String(port)];
       const killCmd = killArgv.join(" ");
       wranglerConfig.cleanup();
@@ -2709,12 +2758,34 @@ Free it with \`${killCmd}\`, or start on another port: \`deepspace dev start --p
         { extra: { port } }
       );
     }
+    const url = `http://${host === DEFAULT_DEV_HOST ? "localhost" : host}:${port}`;
     say("Starting dev server...\n");
-    const vite = spawn("npx", ["vite", "--port", String(port), "--strictPort", "--host"], {
-      cwd: appDir,
-      stdio: "inherit",
-      env: wranglerViteEnv(process.env, wranglerConfig, { DEEPSPACE_PORT: String(port) })
-    });
+    const vite = spawn(
+      "npx",
+      ["vite", "--port", String(port), "--strictPort", "--host", host],
+      {
+        cwd: appDir,
+        stdio: "inherit",
+        env: wranglerViteEnv(process.env, wranglerConfig, { DEEPSPACE_PORT: String(port) })
+      }
+    );
+    if (args.json) {
+      void waitForPortListening(port, host, READINESS_TIMEOUT_MS).then((ready) => {
+        console.log(
+          JSON.stringify(
+            ready ? { ok: true, ready: true, url, port, host, appDir } : {
+              ok: false,
+              code: "dev_server_not_ready",
+              error: `The dev server did not answer on ${url} within ${READINESS_TIMEOUT_MS / 1e3}s.`,
+              url,
+              port,
+              host,
+              appDir
+            }
+          )
+        );
+      });
+    }
     let stopping = false;
     const stop = () => {
       stopping = true;
@@ -2736,7 +2807,7 @@ Free it with \`${killCmd}\`, or start on another port: \`deepspace dev start --p
         extra: { port, appDir, exitCode: code }
       });
     }
-    return { data: { port, appDir, wranglerEnv: wranglerEnv ?? null } };
+    return { data: { port, host, url, appDir, wranglerEnv: wranglerEnv ?? null } };
   }
 });
 
@@ -3725,6 +3796,133 @@ import * as p12 from "@clack/prompts";
 import { defineCommand as defineCommand3 } from "citty";
 import { resolve as resolve12 } from "path";
 
+// src/cli/lib/edge-propagation.ts
+var NOT_SERVING = ["Assets have not yet deployed", "No app configured"];
+var RELEASE_STAMP_PATH = "/.well-known/deepspace/release.json";
+async function waitForLiveRelease(url, releaseStamp, timeoutMs) {
+  return releaseStamp ? waitForReleaseStamp(url, releaseStamp, timeoutMs) : waitForEdgePropagation(url, timeoutMs);
+}
+async function waitForReleaseStamp(url, releaseStamp, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let attempt = 0;
+  let streak = 0;
+  while (Date.now() < deadline) {
+    attempt++;
+    try {
+      const probe = new URL(RELEASE_STAMP_PATH, url);
+      probe.searchParams.set("probe", `${Date.now()}-${attempt}`);
+      const response = await fetch(probe, { redirect: "manual" });
+      const body = await response.json().catch(() => null);
+      if (response.ok && body?.release === releaseStamp) {
+        streak++;
+        if (streak >= 3) return true;
+        await new Promise((resolve19) => setTimeout(resolve19, 1500));
+        continue;
+      }
+      streak = 0;
+    } catch {
+      streak = 0;
+    }
+    const waitMs = Math.min(8e3, 1e3 * 2 ** (attempt - 1));
+    await new Promise((resolve19) => setTimeout(resolve19, waitMs));
+  }
+  return false;
+}
+async function waitForEdgePropagation(url, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let attempt = 0;
+  let streak = 0;
+  while (Date.now() < deadline) {
+    attempt++;
+    try {
+      const response = await fetch(url, { redirect: "manual" });
+      const body = await response.text();
+      if (!NOT_SERVING.some((marker) => body.includes(marker))) {
+        streak++;
+        if (streak >= 3) return true;
+        await new Promise((resolve19) => setTimeout(resolve19, 1500));
+        continue;
+      }
+      streak = 0;
+    } catch {
+      streak = 0;
+    }
+    const waitMs = Math.min(8e3, 1e3 * 2 ** (attempt - 1));
+    await new Promise((resolve19) => setTimeout(resolve19, waitMs));
+  }
+  return false;
+}
+
+// src/shared/app-files.ts
+var MAX_APP_FILE_BYTES = 1024 * 1024 * 1024;
+var MAX_UPLOAD_REQUEST_BYTES = 25 * 1024 * 1024;
+var UPLOAD_PART_BYTES = 20 * 1024 * 1024;
+var MAX_UPLOAD_PARTS = Math.ceil(MAX_APP_FILE_BYTES / UPLOAD_PART_BYTES);
+var MAX_BASE64_UPLOAD_BYTES = Math.floor(MAX_UPLOAD_REQUEST_BYTES * 3 / 4);
+function planUploadParts(totalBytes, partSize) {
+  const parts = [];
+  for (let start = 0; start < totalBytes; start += partSize) {
+    parts.push({
+      partNumber: parts.length + 1,
+      start,
+      end: Math.min(start + partSize, totalBytes)
+    });
+  }
+  return parts;
+}
+var APP_STORAGE_LIMIT_BYTES = {
+  test: 0,
+  free: 128 * 1024 * 1024,
+  starter: 512 * 1024 * 1024,
+  premium: 2 * 1024 * 1024 * 1024,
+  admin: 10 * 1024 * 1024 * 1024
+};
+var MAX_DEPLOY_ASSET_FILE_BYTES = 25 * 1024 * 1024;
+var DANGEROUS_MIME_TYPES = /* @__PURE__ */ new Set([
+  "text/html",
+  "application/xhtml+xml",
+  "image/svg+xml",
+  "application/xml",
+  "text/xml",
+  "application/javascript",
+  "text/javascript",
+  "application/ecmascript",
+  "text/ecmascript"
+]);
+function activeContentMessage(mimeType) {
+  return `${mimeType} is not accepted: the files API serves your app's own origin, so stored HTML/SVG/JavaScript would execute there with your users' sessions. Ship it as a build asset under \`public/\` instead, where it is served as part of your app rather than as user-uploaded content.`;
+}
+function formatBytes(bytes) {
+  if (bytes >= 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GiB`;
+  if (bytes >= 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MiB`;
+  if (bytes >= 1024) return `${Math.round(bytes / 1024)} KiB`;
+  return `${bytes} B`;
+}
+function encodeKeyPath(key) {
+  return key.split("/").map(encodeURIComponent).join("/");
+}
+function oversizeMessage(bytes, limit = MAX_APP_FILE_BYTES) {
+  return `That file is ${formatBytes(bytes)}; the limit is ${formatBytes(limit)} per file.`;
+}
+function describeFilesFailure(status3, body) {
+  const trimmed = body.trim();
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed.error) return parsed.error;
+    } catch {
+    }
+  }
+  if (status3 === 413) {
+    return `The upload is too large. Files are limited to ${formatBytes(MAX_APP_FILE_BYTES)}, and one request may carry ${formatBytes(MAX_UPLOAD_REQUEST_BYTES)} \u2014 a larger request is rejected by the network before the app receives it.`;
+  }
+  if (status3 === 411) return "The upload did not declare its length.";
+  if (status3 === 401 || status3 === 403) return "Not authorized to write these files.";
+  if (status3 === 415) return "That file type is not accepted.";
+  if (status3 >= 500) return `The files service failed (HTTP ${status3}). Retry shortly.`;
+  return `Upload failed (HTTP ${status3}).`;
+}
+
 // src/cli/commands/deploy/build.ts
 import * as p6 from "@clack/prompts";
 import { execSync as execSync2 } from "child_process";
@@ -4044,7 +4242,14 @@ var RESERVED_RUN_WORKER_FIRST = /* @__PURE__ */ new Set([
   "/_documentation",
   "/_documentation/*",
   "/_documentation-root",
-  "/_documentation-root/*"
+  "/_documentation-root/*",
+  // Agent-protocol paths: the worker must see them so they cannot fall through
+  // to the SPA shell (templates/base/src/server/http-routes.ts reserves them).
+  "/llms.txt",
+  "/llms-full.txt",
+  "/.well-known/mcp",
+  "/.well-known/mcp.json",
+  "/.well-known/mcp/*"
 ]);
 async function buildDeployBundle(options) {
   const { appDir, appName, envName, sharedDevVarsCache, output, spinner: spinner2 } = options;
@@ -4178,6 +4383,12 @@ function resolveDeployRunWorkerFirst(config) {
   const routes = extractRunWorkerFirst(config);
   return routes;
 }
+function oversizedAssetRefusal(assets) {
+  const tooBig = assets.find((asset) => asset.size > MAX_DEPLOY_ASSET_FILE_BYTES);
+  if (!tooBig) return null;
+  return `${tooBig.path} is ${formatBytes(tooBig.size)}; the per-file limit for deploy assets is ${formatBytes(MAX_DEPLOY_ASSET_FILE_BYTES)}. ${LARGE_MEDIA_HOME}`;
+}
+var LARGE_MEDIA_HOME = "Large media belongs in your app files (`deepspace app files put`), not in the deploy bundle \u2014 move it out of `public/` and reference it at runtime.";
 function collectAssets(dir) {
   const assets = [];
   const walk = (currentDir, prefix) => {
@@ -4670,37 +4881,6 @@ function repoApi(deployUrl, token, appId) {
   };
 }
 
-// src/shared/app-files.ts
-var MAX_APP_FILE_BYTES = 25 * 1024 * 1024;
-function formatBytes(bytes) {
-  if (bytes >= 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MiB`;
-  if (bytes >= 1024) return `${Math.round(bytes / 1024)} KiB`;
-  return `${bytes} B`;
-}
-function encodeKeyPath(key) {
-  return key.split("/").map(encodeURIComponent).join("/");
-}
-function oversizeMessage(bytes) {
-  return `That file is ${formatBytes(bytes)}; the limit is ${formatBytes(MAX_APP_FILE_BYTES)} per file.`;
-}
-function describeFilesFailure(status3, body) {
-  const trimmed = body.trim();
-  if (trimmed.startsWith("{")) {
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (parsed.error) return parsed.error;
-    } catch {
-    }
-  }
-  if (status3 === 413) {
-    return `The file is too large to upload. The limit is ${formatBytes(MAX_APP_FILE_BYTES)} per file; larger uploads are rejected by the network before the app receives them.`;
-  }
-  if (status3 === 401 || status3 === 403) return "Not authorized to write these files.";
-  if (status3 === 415) return "That file type is not accepted.";
-  if (status3 >= 500) return `The files service failed (HTTP ${status3}). Retry shortly.`;
-  return `Upload failed (HTTP ${status3}).`;
-}
-
 // src/cli/lib/vc-remote.ts
 import { existsSync as existsSync17 } from "fs";
 import { tmpdir } from "os";
@@ -4913,10 +5093,11 @@ function pushToSpace(cwd, token, refspec, opts = {}) {
 var OVERSIZED_PUSH_RE = /too large|exceeds|\bLFS\b/i;
 var SERVER_OBJECT_CAP_BYTES = 20 * 1024 * 1024;
 var SERVER_PACK_CAP_BYTES = 32 * 1024 * 1024;
+var PUSH_CEILINGS = `${formatBytes(SERVER_OBJECT_CAP_BYTES)} per file, ${formatBytes(SERVER_PACK_CAP_BYTES)} per push`;
 var OVERSIZED_PUSH_FIX = `Find the offending object with \`git rev-list --objects --all | git cat-file --batch-check='%(objecttype) %(objectsize) %(rest)' | sort -k2 -n | tail\`.`;
 function removeFromHistoryAdvice(path) {
   const file = path ? shQuote(path) : "<file>";
-  return `Media belongs in the app's files rather than Git history \u2014 \`deepspace app files put ${file}\` stores it in the app's own allocation and serves it over HTTP. Then get it out of the push: add it to .gitignore, and drop it from the commits that carry it \u2014 if those commits are still local, \`git reset --soft <last pushed commit>\` and re-commit without the file. \`git rm --cached\` plus a new commit is NOT sufficient on its own: the blob stays reachable from the earlier commit and the push is rejected the same way. If it already reached pushed history, rewrite it out (\`git filter-repo --path ${file} --invert-paths\`).`;
+  return `Media belongs in the app's files rather than Git history \u2014 \`deepspace app files put ${file}\` stores it in the app's own allocation and serves it over HTTP. Then get it out of both the push and the bundle, in this order: (1) move it OUT of \`public/\` \u2014 .gitignore keeps it out of Git but not out of the deploy bundle, which uploads every file under \`public/\`; (2) if the commits that carry it are still local, \`git reset --soft <last pushed commit>\`, then \`git restore --staged ${file}\` \u2014 reset --soft moves HEAD only and leaves the file staged, so skipping this step re-commits the same blob; (3) commit what remains, then push \u2014 if git says "nothing to commit", that commit held only the file, so skip straight to the push and "Everything up-to-date" means you are done. If it already reached pushed history, rewrite it out instead (\`git filter-repo --path ${file} --invert-paths\`).`;
 }
 function fixForObjects(objects) {
   if (objects.length === 0) return `${OVERSIZED_PUSH_FIX} ${removeFromHistoryAdvice(null)}`;
@@ -5402,7 +5583,7 @@ async function deployBuiltBundle(options) {
     );
   }
   if (body.onBehalfOfOwner) {
-    p10.log.warn(`Deployed on behalf of owner ${body.onBehalfOfOwner}`);
+    p10.log.warn("This release is attributed to the app's owner, not to your account.");
   }
   if (body.staleBaseGuard === "skipped") {
     p10.log.warn(
@@ -5483,10 +5664,11 @@ async function uploadDeployAssets(options) {
     p10.log.info(`Assets: ${byHash.size} file(s), all already uploaded`);
     return;
   }
-  const missingBytes = missing.reduce((total, asset) => total + asset.size, 0);
+  const missingBytes = missing.reduce((total2, asset) => total2 + asset.size, 0);
   p10.log.info(
     `Assets: ${byHash.size} file(s), uploading ${missing.length} (${Math.ceil(missingBytes / 1024)} KiB); the rest are already stored`
   );
+  const total = missing.length;
   let uploaded = 0;
   const next = () => missing.pop();
   const worker = async () => {
@@ -5515,7 +5697,7 @@ async function uploadDeployAssets(options) {
         );
       }
       uploaded++;
-      spinner2.message(`Uploading assets \u2014 ${uploaded}/${uploaded + missing.length}...`);
+      spinner2.message(`Uploading assets \u2014 ${uploaded}/${total}...`);
     }
   };
   try {
@@ -5746,7 +5928,11 @@ var DEPLOY_URL3 = process.env.DEEPSPACE_DEPLOY_URL ?? PLATFORM_URLS.deploy;
 var deploy_default = defineCommand3({
   meta: {
     name: "deploy",
-    description: "Build and deploy your DeepSpace app"
+    // The per-file ceiling belongs in --help: it was previously discoverable
+    // only by hitting it, after the build and the push had already run. The
+    // per-deploy total is deliberately absent — it is env-configurable, so any
+    // number stated here would be wrong for some environment.
+    description: `Build and deploy your DeepSpace app (assets: ${formatBytes(MAX_DEPLOY_ASSET_FILE_BYTES)} per file)`
   },
   args: {
     dir: {
@@ -5842,6 +6028,20 @@ var deploy_default = defineCommand3({
       output
     });
     const sourceState = await getAppSource(DEPLOY_URL3, token, appId);
+    const spinner2 = createSpinner();
+    const bundle = await buildDeployBundle({
+      appDir,
+      appName,
+      envName,
+      sharedDevVarsCache: secretsCache.linked !== null,
+      output,
+      spinner: spinner2
+    });
+    const oversized = oversizedAssetRefusal(bundle.assets);
+    if (oversized) {
+      spinner2.stop("Deploy failed");
+      output.die(oversized, "assets_too_large");
+    }
     const repository = await syncDeployRepository({
       deployUrl: DEPLOY_URL3,
       appDir,
@@ -5852,15 +6052,6 @@ var deploy_default = defineCommand3({
       output,
       sourceState
     });
-    const spinner2 = createSpinner();
-    const bundle = await buildDeployBundle({
-      appDir,
-      appName,
-      envName,
-      sharedDevVarsCache: secretsCache.linked !== null,
-      output,
-      spinner: spinner2
-    });
     const secrets = prepareDeploySecrets({
       appDir,
       envName,
@@ -5886,7 +6077,7 @@ var deploy_default = defineCommand3({
     });
     if (body.url) {
       spinner2.message("Waiting for edge propagation...");
-      const ready = await waitForAssetsReady(body.url, 9e4);
+      const ready = await waitForLiveRelease(body.url, body.releaseStamp, 9e4);
       if (!ready) {
         spinner2.stop("Deployed (edge propagation still in progress after 90s)");
         p12.log.warn(
@@ -5951,30 +6142,6 @@ function blankSelectorRefusal(args) {
 function staleBaseGuardFields(body) {
   return body.staleBaseGuard === "skipped" ? { staleBaseGuard: "skipped" } : {};
 }
-async function waitForAssetsReady(url, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  let attempt = 0;
-  let streak = 0;
-  while (Date.now() < deadline) {
-    attempt++;
-    try {
-      const response = await fetch(url, { redirect: "manual" });
-      const body = await response.text();
-      if (!body.includes("Assets have not yet deployed") && !body.includes("No app configured")) {
-        streak++;
-        if (streak >= 3) return true;
-        await new Promise((resolve19) => setTimeout(resolve19, 1500));
-        continue;
-      }
-      streak = 0;
-    } catch {
-      streak = 0;
-    }
-    const waitMs = Math.min(8e3, 1e3 * 2 ** (attempt - 1));
-    await new Promise((resolve19) => setTimeout(resolve19, waitMs));
-  }
-  return false;
-}
 function errorMessage6(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -6014,6 +6181,19 @@ function requireAppIdArg(explicit) {
   }
   return id;
 }
+function liveAppUrl(app2) {
+  return app2.status === "active" && app2.deployedAt !== null ? app2.url : null;
+}
+async function listApps(deployUrl, token) {
+  const { apps } = await apiFetch(deployUrl, token, "/api/apps");
+  if (!Array.isArray(apps)) {
+    throw new InputError(
+      `The deploy service at ${deployUrl} returned an unexpected response shape for the app list \u2014 check DEEPSPACE_DEPLOY_URL (is this the service the app lives on?).`,
+      "invalid_response"
+    );
+  }
+  return apps;
+}
 function matchAppSelector(apps, selector) {
   const byId = apps.find((app2) => app2.appId === selector);
   if (byId) return byId.appId;
@@ -6023,14 +6203,7 @@ function matchAppSelector(apps, selector) {
 }
 async function resolveAppSelector(deployUrl, token, selector) {
   if (STRICT_APP_ID_RE.test(selector)) return selector;
-  const { apps } = await apiFetch(deployUrl, token, "/api/apps");
-  if (!Array.isArray(apps)) {
-    throw new InputError(
-      `The deploy service at ${deployUrl} returned an unexpected response shape for the app list \u2014 check DEEPSPACE_DEPLOY_URL (is this the service the app lives on?).`,
-      "invalid_response"
-    );
-  }
-  const id = matchAppSelector(apps, selector);
+  const id = matchAppSelector(await listApps(deployUrl, token), selector);
   if (id) return id;
   const shared = await resolveAppIdByName(deployUrl, token, selector);
   if (shared) return shared;
@@ -6113,7 +6286,7 @@ function assertAppTargetResolvable(appArg, options = {}) {
 async function warnIfPhantomApp(deployUrl, token, appId, explicit) {
   if (!explicit || !STRICT_APP_ID_RE.test(explicit.trim())) return;
   try {
-    const { apps } = await apiFetch(deployUrl, token, "/api/apps");
+    const apps = await listApps(deployUrl, token);
     if (!apps.some((app2) => app2.appId === appId)) {
       process.stderr.write(
         `warning: ${appId} is not among your apps. If it exists and you have access (collaborator/admin), the server will use it; if it doesn't exist, this will register it as a NEW app under your account \u2014 check the id if that's not what you meant (a subdomain name also works with -a).
@@ -6227,7 +6400,6 @@ var whoami_default = defineDeepspaceCommand({
     if (!args.json) {
       console.log(`Name:       ${payload.name ?? "(none)"}`);
       console.log(`Email:      ${payload.email ?? "(none)"}`);
-      console.log(`UserID:     ${payload.sub ?? "(none)"}`);
       console.log(`Type:       ${accountType}`);
       if (payload.iss) console.log(`Issuer:     ${payload.iss}`);
       console.log(`Dashboard:  ${DASHBOARD_URL}`);
@@ -6259,7 +6431,7 @@ var apps_default = defineDeepspaceCommand({
   },
   async run({ args }) {
     const token = await ensureToken();
-    const { apps } = await apiFetch(DEPLOY_URL5, token, "/api/apps");
+    const apps = await listApps(DEPLOY_URL5, token);
     if (!args.json) {
       if (!apps.length) {
         console.log("No apps yet. Create one with `npx create-deepspace <name>` and `deepspace deploy`.");
@@ -6267,16 +6439,18 @@ var apps_default = defineDeepspaceCommand({
         const rows = [...apps].sort(
           (left, right) => Number(right.status !== "undeployed") - Number(left.status !== "undeployed")
         );
+        const roleOf = (a) => a.role ?? "owner";
+        const roleWidth = Math.max(4, ...rows.map((a) => roleOf(a).length));
         const nameWidth = Math.max(4, ...rows.map((a) => (a.name ?? "\u2014").length));
         const statusWidth = Math.max(6, ...rows.map((a) => a.status.length));
         const idWidth = Math.max(6, ...rows.map((a) => a.appId.length));
         console.log(
-          `${"NAME".padEnd(nameWidth)}  ${"STATUS".padEnd(statusWidth)}  ${"APP ID".padEnd(idWidth)}  URL`
+          `${"NAME".padEnd(nameWidth)}  ${"STATUS".padEnd(statusWidth)}  ${"ROLE".padEnd(roleWidth)}  ${"APP ID".padEnd(idWidth)}  URL`
         );
         for (const a of rows) {
-          const url = a.url ?? "(not deployed)";
+          const url = liveAppUrl(a) ?? "(not deployed)";
           console.log(
-            `${(a.name ?? "\u2014").padEnd(nameWidth)}  ${a.status.padEnd(statusWidth)}  ${a.appId.padEnd(idWidth)}  ${url}`
+            `${(a.name ?? "\u2014").padEnd(nameWidth)}  ${a.status.padEnd(statusWidth)}  ${roleOf(a).padEnd(roleWidth)}  ${a.appId.padEnd(idWidth)}  ${url}`
           );
         }
       }
@@ -7989,11 +8163,16 @@ var CONTENT_TYPES = {
   ".css": "text/css",
   ".csv": "text/csv",
   ".gif": "image/gif",
+  ".htm": "text/html",
+  ".html": "text/html",
   ".ico": "image/x-icon",
   ".jpeg": "image/jpeg",
   ".jpg": "image/jpeg",
+  ".js": "text/javascript",
   ".json": "application/json",
   ".md": "text/markdown",
+  ".mjs": "text/javascript",
+  ".svg": "image/svg+xml",
   ".mp3": "audio/mpeg",
   ".mp4": "video/mp4",
   ".otf": "font/otf",
@@ -8039,7 +8218,10 @@ async function request(baseUrl, token, path, init = {}) {
   throw new ApiError(
     describeFilesFailure(res.status, text2),
     res.status,
-    code ?? (res.status === 413 ? "file_too_large" : res.status >= 500 ? "server_error" : "http_error"),
+    // Same slug the worker emits for the same condition — the edge cutting an
+    // oversized request short is not a different failure from the worker
+    // refusing it, and two codes made it look like one.
+    code ?? (res.status === 413 ? "too_large" : res.status >= 500 ? "server_error" : "http_error"),
     path
   );
 }
@@ -8072,31 +8254,96 @@ Content-Type: ${contentType}\r
     contentType: `multipart/form-data; boundary=${boundary}`
   };
 }
-async function uploadAppFile(baseUrl, token, appId, localPath, key) {
+async function uploadAppFile(baseUrl, token, appId, localPath, key, onProgress) {
   const path = filesPath(appId, `/upload?key=${encodeKeyPath(key)}`);
   const size = statSync(localPath).size;
   if (size > MAX_APP_FILE_BYTES) {
-    throw new ApiError(oversizeMessage(size), 0, "file_too_large", path);
+    throw new ApiError(oversizeMessage(size), 0, "too_large", path);
   }
-  const { blob, contentType } = await multipartBody(
-    localPath,
-    basename3(localPath),
-    contentTypeFor(localPath)
-  );
+  const declaredType = contentTypeFor(localPath);
+  if (DANGEROUS_MIME_TYPES.has(declaredType)) {
+    throw new ApiError(activeContentMessage(declaredType), 0, "active_content", path);
+  }
+  if (size > UPLOAD_PART_BYTES) {
+    return uploadInParts(baseUrl, token, appId, localPath, key, size, onProgress);
+  }
+  const { blob, contentType } = await multipartBody(localPath, basename3(localPath), declaredType);
   const res = await request(baseUrl, token, path, {
     method: "POST",
     headers: { "Content-Type": contentType },
     body: blob
   });
   const body = await readJson(res, path);
-  return { key: body.key, name: body.name, size };
+  onProgress?.(size, size, 1, 1);
+  return { key: body.key, name: body.name, size, parts: 1 };
+}
+function isRetryable(err) {
+  if (!(err instanceof ApiError)) return false;
+  return err.status === 0 || err.status === 429 || err.status >= 500;
+}
+async function uploadInParts(baseUrl, token, appId, localPath, key, size, onProgress) {
+  const contentType = contentTypeFor(localPath);
+  const initPath = filesPath(appId, `/multipart?key=${encodeKeyPath(key)}`);
+  const session = await readJson(
+    await request(baseUrl, token, initPath, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: basename3(localPath), mimeType: contentType, size })
+    }),
+    initPath
+  );
+  const query = `uploadKey=${encodeKeyPath(session.uploadKey)}&uploadId=${encodeURIComponent(session.uploadId)}`;
+  if (!Number.isSafeInteger(session.partSize) || session.partSize < 1) {
+    throw new ApiError(
+      `The platform advertised an unusable part size (${session.partSize}).`,
+      0,
+      "invalid_response",
+      initPath
+    );
+  }
+  const plan = planUploadParts(size, session.partSize);
+  const file = await openAsBlob(localPath, { type: contentType });
+  const uploaded = [];
+  try {
+    for (const part of plan) {
+      const partPath = filesPath(appId, `/multipart/part?${query}&partNumber=${part.partNumber}`);
+      const send = () => request(baseUrl, token, partPath, {
+        method: "PUT",
+        body: file.slice(part.start, part.end, contentType)
+      });
+      const res = await send().catch(async (err) => {
+        if (!isRetryable(err)) throw err;
+        return send();
+      });
+      uploaded.push(await readJson(res, partPath));
+      onProgress?.(part.end, size, part.partNumber, plan.length);
+    }
+    const completePath = filesPath(appId, `/multipart/complete?${query}`);
+    const body = await readJson(
+      await request(baseUrl, token, completePath, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ parts: uploaded })
+      }),
+      completePath
+    );
+    return { key: body.key, name: body.name, size, parts: plan.length };
+  } catch (err) {
+    await request(baseUrl, token, filesPath(appId, `/multipart?${query}`), {
+      method: "DELETE"
+    }).catch(() => void 0);
+    throw err;
+  }
 }
 async function listAppFiles(baseUrl, token, appId, query) {
   const path = filesPath(appId, `?${query}`);
   return readJson(await request(baseUrl, token, path), path);
 }
 async function deleteAppFile(baseUrl, token, appId, key) {
-  await request(baseUrl, token, filesPath(appId, `/${encodeKeyPath(key)}`), { method: "DELETE" });
+  const path = filesPath(appId, `/${encodeKeyPath(key)}`);
+  const res = await request(baseUrl, token, path, { method: "DELETE" });
+  const body = await readJson(res, path);
+  return { existed: body.existed !== false };
 }
 async function downloadAppFile(baseUrl, token, appId, key, destination) {
   const path = filesPath(appId, `/${encodeKeyPath(key)}`);
@@ -8156,7 +8403,10 @@ function servedPath(key) {
   return `/api/files/${encodeKeyPath(key)}?scope=app`;
 }
 var put = defineDeepspaceCommand({
-  meta: { name: "put", description: "Upload a file to the app\u2019s files" },
+  meta: {
+    name: "put",
+    description: `Upload a file to the app\u2019s files (${formatBytes(MAX_APP_FILE_BYTES)} per file)`
+  },
   args: {
     file: { type: "positional", description: "Local file to upload", required: true },
     key: { type: "string", description: "Key to store it under (default: the file name)" },
@@ -8169,12 +8419,42 @@ var put = defineDeepspaceCommand({
     }
     const key = requireKey(args.key ?? basename4(localPath));
     const { token, appId } = await target(args.app);
-    const result = await uploadAppFile(PLATFORM_URL, token, appId, localPath, key);
+    const spinner2 = args.json ? null : createSpinner();
+    let started = false;
+    const result = await uploadAppFile(
+      PLATFORM_URL,
+      token,
+      appId,
+      localPath,
+      key,
+      (sent, total, part, parts) => {
+        if (parts === 1 || !spinner2) return;
+        if (!started) {
+          spinner2.start(`Uploading ${key} in ${parts} parts`);
+          started = true;
+        }
+        spinner2.message(
+          `${key} \u2014 part ${part}/${parts} (${formatBytes(sent)} of ${formatBytes(total)})`
+        );
+      }
+    ).finally(() => {
+      if (started) spinner2?.stop();
+    });
     if (!args.json) {
-      console.log(`\u2713 ${key} (${formatBytes(result.size)})`);
+      const how = result.parts > 1 ? ` in ${result.parts} parts` : "";
+      console.log(`\u2713 ${key} (${formatBytes(result.size)})${how}`);
       console.log(`  Served from your app at ${servedPath(result.key)}`);
     }
-    return { data: { appId, key, storedKey: result.key, size: result.size, path: servedPath(result.key) } };
+    return {
+      data: {
+        appId,
+        key,
+        storedKey: result.key,
+        size: result.size,
+        parts: result.parts,
+        path: servedPath(result.key)
+      }
+    };
   }
 });
 var list3 = defineDeepspaceCommand({
@@ -8215,8 +8495,14 @@ var list3 = defineDeepspaceCommand({
         const more = limit < MAX_LIST_LIMIT ? "raise --limit or narrow with --prefix" : "narrow with --prefix";
         if (result.truncated) console.log(`(truncated at ${limit} \u2014 ${more})`);
       }
+      if (result.storage) {
+        const { usedBytes, limitBytes } = result.storage;
+        console.log(
+          limitBytes === void 0 ? `Storage: ${formatBytes(usedBytes)} used (limit unavailable right now)` : `Storage: ${formatBytes(usedBytes)} of ${formatBytes(limitBytes)} used`
+        );
+      }
     }
-    return { data: { appId, files, truncated: result.truncated } };
+    return { data: { appId, files, truncated: result.truncated, storage: result.storage ?? null } };
   }
 });
 var get = defineDeepspaceCommand({
@@ -8244,7 +8530,13 @@ var rm = defineDeepspaceCommand({
   async run({ args }) {
     const key = requireKey(String(args.key));
     const { token, appId } = await target(args.app);
-    await deleteAppFile(PLATFORM_URL, token, appId, key);
+    const { existed } = await deleteAppFile(PLATFORM_URL, token, appId, key);
+    if (!existed) {
+      throw new Refusal(
+        `No file at ${key} \u2014 nothing was deleted. Check the key with \`deepspace app files list\`.`,
+        "file_not_found"
+      );
+    }
     if (!args.json) console.log(`\u2713 deleted ${key}`);
     return { data: { appId, key, deleted: true } };
   }
@@ -8338,7 +8630,7 @@ var add = defineDeepspaceCommand({
       }
       if (!args.json) {
         console.log(
-          `\u2713 Invite sent to ${res.email} (expires ${expires}). They become a collaborator when they sign in.`
+          `\u2713 Invite sent to ${res.email} (expires ${expires}). They accept it from the emailed link, or by signing in and running \`deepspace app collaborators accept ${app2}\`.`
         );
       }
       return { data: { ...res } };
@@ -8407,9 +8699,56 @@ var cancel3 = defineDeepspaceCommand({
     return { data: { cancelled: found } };
   }
 });
+var invites = defineDeepspaceCommand({
+  meta: { name: "invites", description: "List invites waiting for you" },
+  async run({ args }) {
+    const token = await ensureToken();
+    const { invites: invites2 } = await api2(
+      token,
+      "/api/app-collaborators/invites/mine"
+    );
+    if (!args.json) {
+      if (!invites2.length) {
+        console.log("No pending invites for your email.");
+      } else {
+        for (const invite of invites2) {
+          console.log(
+            `${invite.appId}  invited by ${invite.invitedByName}  (expires ${new Date(invite.expiresAt).toLocaleDateString()})`
+          );
+        }
+        console.log("Accept one with `deepspace app collaborators accept <app-id>`.");
+      }
+    }
+    return { data: { invites: invites2 } };
+  }
+});
+var accept = defineDeepspaceCommand({
+  meta: { name: "accept", description: "Accept an invite to collaborate on an app" },
+  args: {
+    app: { type: "positional", description: "App id (see `collaborators invites`)", required: true }
+  },
+  async run({ args }) {
+    const appId = String(args.app);
+    const token = await ensureToken();
+    const res = await api2(
+      token,
+      `/api/app-collaborators/invites/${encodeURIComponent(appId)}/accept`,
+      { method: "POST" }
+    );
+    if (!args.json) {
+      console.log(
+        res.alreadyMember ? `\u2022 You already have access to ${res.appId}.` : `\u2713 You can now deploy ${res.appId}.`
+      );
+    }
+    return {
+      data: { ...res },
+      action: cliAction("deepspace", "pull", "--app", res.appId)
+    };
+  }
+});
 var collaborators_default = defineCommand7({
   meta: { name: "collaborators", description: "Manage who can deploy your app" },
-  subCommands: { list: list4, add, remove, cancel: cancel3 }
+  subCommands: { list: list4, add, remove, cancel: cancel3, invites, accept }
 });
 
 // src/cli/commands/transfer.ts
@@ -8494,7 +8833,7 @@ var status2 = defineDeepspaceCommand({
     return { data: { app: app2, transfer } };
   }
 });
-var accept = defineDeepspaceCommand({
+var accept2 = defineDeepspaceCommand({
   meta: { name: "accept", description: "Accept a transfer offered to you" },
   args: {
     app: { type: "string", alias: "a", description: "App id of the offered app", required: true }
@@ -8535,7 +8874,7 @@ var cancel4 = defineDeepspaceCommand({
 });
 var transfer_default = defineCommand8({
   meta: { name: "transfer", description: "Transfer app ownership to another user" },
-  subCommands: { offer, status: status2, accept, cancel: cancel4 }
+  subCommands: { offer, status: status2, accept: accept2, cancel: cancel4 }
 });
 
 // src/cli/commands/integrations.ts
@@ -9795,24 +10134,36 @@ var status_default = defineCommand11({
             const failure = statusRemoteFailure(error);
             lines.push([label, failure.human]);
             json[key] = failure.json;
-          }, reportRelease2 = function(rel) {
+          }, reportLive2 = function(rel, entry) {
+            if (rel === null) {
+              lines.push(["Live", "never deployed"]);
+              json.live = null;
+              return;
+            }
             const byYou = userId !== null && rel.actor === userId;
-            lines.push([
-              "Live",
-              `release #${rel.seq} (${rel.kind} of ${rel.commitOid?.slice(0, 10) ?? "unknown source"}, ${timeAgo(rel.createdAt)}${byYou ? ", by you" : ""})` + (rel.url ? ` \xB7 ${rel.url}` : "")
-            ]);
-            json.live = {
+            const release2 = `release #${rel.seq} (${rel.kind} of ${rel.commitOid?.slice(0, 10) ?? "unknown source"}, ${timeAgo(rel.createdAt)}${byYou ? ", by you" : ""})`;
+            const details = {
               seq: rel.seq,
               kind: rel.kind,
               commitOid: rel.commitOid,
               createdAt: rel.createdAt,
-              url: rel.url,
               byYou,
               source: rel.source,
               sourceRevision: rel.sourceRevision
             };
+            if (!entry) {
+              lines.push(["Live", `${release2} \xB7 serving state not visible from your account`]);
+              json.live = { ...details, serving: null, url: null };
+              return;
+            }
+            const url = liveAppUrl(entry);
+            lines.push([
+              "Live",
+              url ? `${release2} \xB7 ${url}` : `not serving \u2014 ${entry.status}, last ${release2}`
+            ]);
+            json.live = { ...details, serving: url !== null, url };
           };
-          var reportWorkspace = reportWorkspace2, reportRemoteFailure = reportRemoteFailure2, reportRelease = reportRelease2;
+          var reportWorkspace = reportWorkspace2, reportRemoteFailure = reportRemoteFailure2, reportLive = reportLive2;
           const api4 = repoApi(deployBaseUrl(), token, appId);
           const sourceResult = await observeRemote(getAppSource(deployBaseUrl(), token, appId));
           const source = sourceResult.ok ? sourceResult.value.source : null;
@@ -9832,10 +10183,11 @@ var status_default = defineCommand11({
             lines.push(["Source", "unclaimed \xB7 next normal deploy defaults to DeepSpace"]);
             json.source = null;
           }
-          const [refsResult, wsResult, releaseResult] = await Promise.all([
+          const [refsResult, wsResult, releaseResult, appsResult] = await Promise.all([
             githubSource ? Promise.resolve({ ok: true, value: null }) : observeRemote(api4.getRefs()),
             facts.workspaceId && !githubSource ? observeRemote(api4.getWorkspace(facts.workspaceId).then((r) => r.view)) : Promise.resolve({ ok: true, value: null }),
-            observeRemote(api4.latestRelease().then((r) => r.release))
+            observeRemote(api4.latestRelease().then((r) => r.release)),
+            observeRemote(listApps(deployBaseUrl(), token))
           ]);
           if (facts.workspaceId) {
             if (githubSource) {
@@ -9864,12 +10216,8 @@ var status_default = defineCommand11({
             }
           }
           if (!releaseResult.ok) reportRemoteFailure2("Live", "live", releaseResult.error);
-          else if (releaseResult.value === null) {
-            lines.push(["Live", "never deployed"]);
-            json.live = null;
-          } else {
-            reportRelease2(releaseResult.value);
-          }
+          else if (!appsResult.ok) reportRemoteFailure2("Live", "live", appsResult.error);
+          else reportLive2(releaseResult.value, appsResult.value.find((a) => a.appId === appId));
         }
         spinner2?.stop("Cloud state checked.");
       }
@@ -9912,7 +10260,7 @@ function workspaceBranchPushRefusal(branch) {
 var push_default = defineDeepspaceCommand({
   meta: {
     name: "push",
-    description: "Push local git commits to the app's cloud repo"
+    description: `Push local git commits to the app's cloud repo (${PUSH_CEILINGS})`
   },
   args: {
     branch: {
@@ -10493,6 +10841,27 @@ var clone_default = defineDeepspaceCommand({
 
 // src/cli/commands/releases.ts
 import * as p21 from "@clack/prompts";
+
+// src/cli/lib/actor-labels.ts
+var API_URL9 = process.env.DEEPSPACE_API_URL ?? PLATFORM_URLS.api;
+async function actorLabels(token, appId) {
+  const labels = /* @__PURE__ */ new Map();
+  try {
+    const { sub, email } = decodeJwtPayload(token);
+    if (sub && email) labels.set(sub, `${email} (you)`);
+  } catch {
+  }
+  try {
+    const { collaborators } = await apiFetch(API_URL9, token, `/api/app-collaborators/${encodeURIComponent(appId)}`);
+    for (const c of collaborators) {
+      if (!labels.has(c.userId)) labels.set(c.userId, c.emailDisplay);
+    }
+  } catch {
+  }
+  return labels;
+}
+
+// src/cli/commands/releases.ts
 var DEPLOY_URL12 = process.env.DEEPSPACE_DEPLOY_URL ?? PLATFORM_URLS.deploy;
 var releases_default = defineDeepspaceCommand({
   meta: {
@@ -10535,11 +10904,12 @@ var releases_default = defineDeepspaceCommand({
       if (releases.length === 0) {
         p21.log.info("No releases yet \u2014 the history starts with the next `deepspace deploy`.");
       } else {
+        const actors = await actorLabels(token, appId);
         for (const r of releases) {
           const source = r.commitOid ? `commit ${r.commitOid.slice(0, 10)}` : "(no source recorded)";
           const rollback = r.rollbackAvailable ? "rollback available" : "rollback unavailable";
           console.log(
-            `#${r.seq}  ${r.id}  ${r.kind.padEnd(8)}  ${r.createdAt}  ${r.actor}  ${source}  ${rollback}`
+            `#${r.seq}  ${r.id}  ${r.kind.padEnd(8)}  ${r.createdAt}  ${actors.get(r.actor) ?? r.actor}  ${source}  ${rollback}`
           );
         }
         p21.log.info(
@@ -10662,10 +11032,20 @@ Re-run with --allow-do-deletion to accept the data loss.`,
         "invalid_response"
       );
     }
-    spinner2?.stop(`Rolled back to ${result.rolledBackTo ?? releaseId}.`);
+    let edgePropagating = false;
+    if (result.url) {
+      spinner2?.message("Waiting for edge propagation...");
+      edgePropagating = !await waitForLiveRelease(result.url, result.releaseStamp, 9e4);
+    }
+    spinner2?.stop(
+      edgePropagating ? `Rolled back to ${result.rolledBackTo ?? releaseId} (edge propagation still in progress after 90s).` : `Rolled back to ${result.rolledBackTo ?? releaseId}.`
+    );
     const doClassGuard = result.doClassGuard === "unverified" ? "unverified" : void 0;
     if (!args.json) {
-      if (result.url) p22.log.success(`Live at: ${result.url}`);
+      if (result.url) {
+        if (edgePropagating) p22.log.warn(`URL: ${result.url} (accepted; serving not yet verified)`);
+        else p22.log.success(`Live at: ${result.url}`);
+      }
       if (result.bundleRetained === false) {
         p22.log.warn(
           "The rollback is live, but its bundle was concurrently retired and is not available for a future rollback."
@@ -10689,6 +11069,7 @@ Re-run with --allow-do-deletion to accept the data loss.`,
         url: result.url ?? null,
         versionId: result.versionId ?? null,
         wranglerEnv: wranglerEnv ?? null,
+        ...edgePropagating ? { edgePropagating: true } : {},
         ...doClassGuard ? { doClassGuard } : {}
       }
     };
@@ -11573,27 +11954,6 @@ var syncWorkspaceCommand = defineDeepspaceCommand({
 
 // src/cli/commands/workspace/list.ts
 import * as p28 from "@clack/prompts";
-
-// src/cli/lib/actor-labels.ts
-var API_URL9 = process.env.DEEPSPACE_API_URL ?? PLATFORM_URLS.api;
-async function actorLabels(token, appId) {
-  const labels = /* @__PURE__ */ new Map();
-  try {
-    const { sub, email } = decodeJwtPayload(token);
-    if (sub && email) labels.set(sub, `${email} (you)`);
-  } catch {
-  }
-  try {
-    const { collaborators } = await apiFetch(API_URL9, token, `/api/app-collaborators/${encodeURIComponent(appId)}`);
-    for (const c of collaborators) {
-      if (!labels.has(c.userId)) labels.set(c.userId, c.emailDisplay);
-    }
-  } catch {
-  }
-  return labels;
-}
-
-// src/cli/commands/workspace/list.ts
 function withWorkspaceOverlaps(views, overlapsById) {
   return views.map((view) => ({
     ...view,
@@ -13363,7 +13723,7 @@ function commandTree() {
   return main.subCommands ?? {};
 }
 function unknownCommandMessage(unknown) {
-  return `Unknown command: ${unknown.attemptedPath.join(" ")} \u2014 did you mean \`${unknown.suggestion.join(" ")}\`?`;
+  return `Unknown command: ${humanCommand(unknown.attemptedPath)} \u2014 did you mean \`${humanCommand(unknown.suggestion)}\`?` + (unknown.quotedToken ? " The whole command arrived as one quoted argument; pass each word separately." : "");
 }
 function assertKnownCommandPath(argv) {
   const unknown = findUnknownCommand(argv, commandTree());
@@ -13372,7 +13732,7 @@ function assertKnownCommandPath(argv) {
     `${unknownCommandMessage(unknown)}
 Run \`${unknown.helpPath.join(" ")} --help\` for the command list.`
   );
-  printAction({ cwd: process.cwd(), argv: unknown.suggestion });
+  if (unknown.executable) printAction({ cwd: process.cwd(), argv: unknown.suggestion });
   process.exit(1);
 }
 var rawArgs = process.argv.slice(2);
@@ -13394,7 +13754,7 @@ if (rawArgs.includes("--json") && !wantsHelp) {
         ok: false,
         code: "unknown_command",
         error: unknownCommandMessage(unknown),
-        action: { cwd: process.cwd(), argv: unknown.suggestion }
+        ...unknown.executable ? { action: { cwd: process.cwd(), argv: unknown.suggestion } } : {}
       })
     );
     process.exit(1);
@@ -13403,16 +13763,20 @@ if (rawArgs.includes("--json") && !wantsHelp) {
     stopActiveSpinner();
     const cittyCode = err instanceof Error && err.name === "CLIError" ? err.code : void 0;
     const code = cittyCode === "EARG" ? "missing_argument" : cittyCode === "E_UNKNOWN_COMMAND" ? "unknown_command" : cittyCode === "E_NO_COMMAND" ? "no_command" : errorCode(err);
-    const message = (err instanceof Error ? err.message : String(err)).replace(
-      // eslint-disable-next-line no-control-regex
-      /\u001b\[[0-9;]*m/g,
-      ""
-    );
+    const message = stripAnsi(err instanceof Error ? err.message : String(err));
     console.log(JSON.stringify({ ok: false, error: message, ...code ? { code } : {} }));
     process.exit(1);
   });
 } else {
   assertKnownCommandPath(rawArgs);
-  runMain(wrapCommandErrors(main));
+  runMain(wrapCommandErrors(main), {
+    showUsage: async (cmd, parent) => {
+      try {
+        console.log(forTerminal(await renderUsage(cmd, parent)) + "\n");
+      } catch (error) {
+        console.error(error);
+      }
+    }
+  });
 }
 //# sourceMappingURL=cli.js.map