appfunnel 0.11.0 → 0.13.0

package/dist/index.js

@@ -231,49 +231,21 @@ async function fetchStorePrices(projectId, storeId, options) {
   const data = await response.json();
   return data.data || [];
 }
-async function publishBuild(projectId, funnelId, manifest, assets, options, promote) {
-  const formData = new FormData();
-  formData.set("manifest", JSON.stringify(manifest));
-  if (funnelId) {
-    formData.set("funnelId", funnelId);
-  }
-  if (promote) {
-    formData.set("promote", "true");
-  }
-  for (const asset of assets) {
-    formData.append(
-      "assets",
-      new Blob([new Uint8Array(asset.content)], { type: asset.contentType }),
-      asset.path
-    );
-  }
-  try {
-    const response = await apiFetch(`/project/${projectId}/headless/publish`, {
-      ...options,
-      method: "POST",
-      body: formData
-    });
-    return await response.json();
-  } catch (err) {
-    if (err instanceof CLIError && err.code === "API_ERROR") {
-      if (err.statusCode === 413) {
-        throw new CLIError(
-          "BUNDLE_TOO_LARGE",
-          err.message,
-          "Reduce page bundle sizes. Check for large dependencies."
-        );
-      }
-      if (err.statusCode === 409) {
-        throw new CLIError(
-          "FUNNEL_NOT_HEADLESS",
-          err.message,
-          "Remove funnelId from config to create a new headless funnel."
-        );
-      }
-      throw new CLIError("PUBLISH_FAILED", err.message);
-    }
-    throw err;
-  }
+async function publishInit(projectId, body, options) {
+  const response = await apiFetch(`/project/${projectId}/headless/publish-init`, {
+    ...options,
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+  return await response.json();
+}
+async function publishFinalize(projectId, body, options) {
+  const response = await apiFetch(`/project/${projectId}/headless/publish-finalize`, {
+    ...options,
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+  return await response.json();
 }
 var DEFAULT_API_BASE2;
 var init_api = __esm({
@@ -455,6 +427,12 @@ async function initCommand(nameArg) {
     const { renameSync } = await import("fs");
     renameSync(gitignoreSrc, join2(dir, ".gitignore"));
   }
+  const readmePath = join2(dir, "README.md");
+  if (existsSync(readmePath)) {
+    let readme = readFileSync2(readmePath, "utf-8");
+    readme = readme.replace("__NAME__", name);
+    writeFileSync2(readmePath, readme);
+  }
   const configPath = join2(dir, "appfunnel.config.ts");
   if (existsSync(configPath)) {
     let config = readFileSync2(configPath, "utf-8");
@@ -485,7 +463,7 @@ ${itemsStr},
     }
     writeFileSync2(configPath, config);
   }
-  const sdkVersion = `^${"0.11.0"}`;
+  const sdkVersion = `^${"0.13.0"}`;
   writeFileSync2(
     join2(dir, "package.json"),
     JSON.stringify(
@@ -731,7 +709,7 @@ var init_config = __esm({
 import { readFileSync as readFileSync4 } from "fs";
 import { join as join4 } from "path";
 function checkVersionCompatibility(cwd) {
-  const cliVersion = "0.11.0";
+  const cliVersion = "0.13.0";
   const sdkVersion = getSdkVersion(cwd);
   const [cliMajor, cliMinor] = cliVersion.split(".").map(Number);
   const [sdkMajor, sdkMinor] = sdkVersion.split(".").map(Number);
@@ -1448,6 +1426,386 @@ var init_dev = __esm({
   }
 });
 
+// src/lib/computeFlow.ts
+function computeFunnelFlow(pages, initialPageKey) {
+  const allPageKeys = new Set(Object.keys(pages));
+  if (allPageKeys.size === 0) {
+    return { initialPageKey, segments: [], terminalPageKeys: [], unreachablePageKeys: [] };
+  }
+  function getTargets(pageKey) {
+    const routes = pages[pageKey]?.routes || [];
+    const seen = /* @__PURE__ */ new Set();
+    const targets = [];
+    for (const route of routes) {
+      if (allPageKeys.has(route.to) && !seen.has(route.to)) {
+        seen.add(route.to);
+        targets.push(route.to);
+      }
+    }
+    return targets;
+  }
+  const reachable = /* @__PURE__ */ new Set();
+  {
+    const queue = [];
+    if (allPageKeys.has(initialPageKey)) {
+      reachable.add(initialPageKey);
+      queue.push(initialPageKey);
+    }
+    while (queue.length > 0) {
+      const pageKey = queue.shift();
+      for (const target of getTargets(pageKey)) {
+        if (!reachable.has(target)) {
+          reachable.add(target);
+          queue.push(target);
+        }
+      }
+    }
+  }
+  const unreachablePageKeys = [];
+  const terminalPageKeys = [];
+  for (const pageKey of allPageKeys) {
+    if (!reachable.has(pageKey)) {
+      unreachablePageKeys.push(pageKey);
+      continue;
+    }
+    if (getTargets(pageKey).length === 0) {
+      terminalPageKeys.push(pageKey);
+    }
+  }
+  function bfsForward(start) {
+    const dist = /* @__PURE__ */ new Map();
+    dist.set(start, 0);
+    const queue = [start];
+    while (queue.length > 0) {
+      const current2 = queue.shift();
+      const d = dist.get(current2);
+      for (const target of getTargets(current2)) {
+        if (!dist.has(target)) {
+          dist.set(target, d + 1);
+          queue.push(target);
+        }
+      }
+    }
+    return dist;
+  }
+  function findConvergence(armStarts) {
+    if (armStarts.length === 0) return null;
+    const armReachable = armStarts.map((s) => bfsForward(s));
+    const armStartSet = new Set(armStarts);
+    let candidates = /* @__PURE__ */ new Set();
+    for (const key of armReachable[0].keys()) {
+      if (!armStartSet.has(key)) candidates.add(key);
+    }
+    for (let i = 1; i < armReachable.length; i++) {
+      const reachSet = new Set(armReachable[i].keys());
+      candidates = new Set([...candidates].filter((k) => reachSet.has(k)));
+    }
+    if (candidates.size === 0) return null;
+    let bestPage = null;
+    let bestMinDist = Infinity;
+    for (const pageKey of candidates) {
+      const minDist = Math.min(...armReachable.map((r) => r.get(pageKey) ?? Infinity));
+      if (minDist < bestMinDist) {
+        bestMinDist = minDist;
+        bestPage = pageKey;
+      }
+    }
+    return bestPage;
+  }
+  function walkArm(start, convergence, globalVisited2) {
+    if (convergence === null) {
+      const pages2 = [];
+      let current2 = start;
+      while (true) {
+        if (globalVisited2.has(current2)) break;
+        globalVisited2.add(current2);
+        pages2.push(current2);
+        const targets = getTargets(current2);
+        if (targets.length === 0) break;
+        const next = targets.find((t) => !globalVisited2.has(t));
+        if (!next) break;
+        current2 = next;
+      }
+      return pages2;
+    }
+    const parent = /* @__PURE__ */ new Map();
+    parent.set(start, null);
+    const queue = [start];
+    let found = false;
+    while (queue.length > 0 && !found) {
+      const current2 = queue.shift();
+      for (const target of getTargets(current2)) {
+        if (!parent.has(target)) {
+          parent.set(target, current2);
+          if (target === convergence) {
+            found = true;
+            break;
+          }
+          queue.push(target);
+        }
+      }
+    }
+    if (!found) {
+      const pages2 = [];
+      let current2 = start;
+      while (true) {
+        if (globalVisited2.has(current2)) break;
+        globalVisited2.add(current2);
+        pages2.push(current2);
+        const targets = getTargets(current2);
+        if (targets.length === 0) break;
+        const next = targets.find((t) => !globalVisited2.has(t));
+        if (!next) break;
+        current2 = next;
+      }
+      return pages2;
+    }
+    const path = [];
+    let node = convergence;
+    while (node !== null && node !== start) {
+      path.unshift(node);
+      node = parent.get(node) ?? null;
+    }
+    path.unshift(start);
+    if (path[path.length - 1] === convergence) {
+      path.pop();
+    }
+    for (const p of path) {
+      globalVisited2.add(p);
+    }
+    return path;
+  }
+  if (!allPageKeys.has(initialPageKey)) {
+    return { initialPageKey, segments: [], terminalPageKeys, unreachablePageKeys };
+  }
+  const segments = [];
+  const globalVisited = /* @__PURE__ */ new Set();
+  let current = initialPageKey;
+  let sharedPages = [];
+  while (current !== null && !globalVisited.has(current)) {
+    const targets = getTargets(current);
+    if (targets.length === 0) {
+      sharedPages.push(current);
+      globalVisited.add(current);
+      break;
+    }
+    const uniqueTargets = [...new Set(targets)];
+    if (uniqueTargets.length === 1) {
+      sharedPages.push(current);
+      globalVisited.add(current);
+      current = uniqueTargets[0];
+      continue;
+    }
+    sharedPages.push(current);
+    globalVisited.add(current);
+    segments.push({ type: "shared", pageKeys: [...sharedPages] });
+    sharedPages = [];
+    const convergence = findConvergence(uniqueTargets);
+    const arms = [];
+    for (const armStart of uniqueTargets) {
+      const armPages = walkArm(armStart, convergence, globalVisited);
+      arms.push({ pageKeys: armPages });
+    }
+    segments.push({ type: "branch", sourcePageKey: current, arms });
+    if (convergence !== null && !globalVisited.has(convergence)) {
+      current = convergence;
+    } else {
+      current = null;
+    }
+  }
+  if (sharedPages.length > 0) {
+    segments.push({ type: "shared", pageKeys: sharedPages });
+  }
+  return { initialPageKey, segments, terminalPageKeys, unreachablePageKeys };
+}
+var init_computeFlow = __esm({
+  "src/lib/computeFlow.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/routes.ts
+var routes_exports = {};
+__export(routes_exports, {
+  routesCommand: () => routesCommand
+});
+import pc7 from "picocolors";
+async function routesCommand() {
+  const cwd = process.cwd();
+  const s = spinner("Analyzing pages...");
+  const config = await loadConfig(cwd);
+  const pageKeys = scanPages(cwd);
+  const pages = await extractPageDefinitions(cwd, pageKeys);
+  s.stop();
+  const flow = computeFunnelFlow(pages, config.initialPageKey);
+  console.log();
+  console.log(`  ${pc7.bold(config.name)}`);
+  console.log(`  ${pc7.dim(`${pageKeys.length} pages`)}`);
+  console.log();
+  renderFlow(flow, pages);
+}
+function renderFlow(flow, pages) {
+  const indent = "  ";
+  for (let i = 0; i < flow.segments.length; i++) {
+    const segment = flow.segments[i];
+    if (segment.type === "shared") {
+      for (let j = 0; j < segment.pageKeys.length; j++) {
+        const key = segment.pageKeys[j];
+        const page = pages[key];
+        const isStart = key === flow.initialPageKey;
+        const isTerminal = flow.terminalPageKeys.includes(key);
+        printPageBox(indent, key, page, isStart, isTerminal);
+        const isLastInSegment = j === segment.pageKeys.length - 1;
+        const hasNextSegment = i < flow.segments.length - 1;
+        if ((!isLastInSegment || hasNextSegment) && !isTerminal) {
+          printArrow(indent);
+        }
+      }
+    } else {
+      renderBranch(indent, segment, pages, flow);
+      if (i < flow.segments.length - 1) {
+        printArrow(indent);
+      }
+    }
+  }
+  if (flow.unreachablePageKeys.length > 0) {
+    console.log();
+    console.log(`  ${pc7.yellow("\u26A0")} ${pc7.yellow("Unreachable pages:")}`);
+    for (const key of flow.unreachablePageKeys) {
+      const page = pages[key];
+      console.log(`    ${pc7.dim("\u2022")} ${key}${page?.name ? pc7.dim(` (${page.name})`) : ""}`);
+    }
+  }
+  console.log();
+}
+function formatPageLabel(key, page, isStart, isTerminal) {
+  const name = page?.name || key;
+  const type = page?.type;
+  const badges = [];
+  if (isStart) badges.push(pc7.green("start"));
+  if (isTerminal) badges.push(pc7.red("end"));
+  if (type && type !== "default") badges.push(pc7.magenta(type));
+  const label = key === name.toLowerCase().replace(/\s+/g, "-") ? name : `${name} ${pc7.dim(`(${key})`)}`;
+  const badgeStr = badges.length > 0 ? " " + badges.map((b) => pc7.dim("[") + b + pc7.dim("]")).join(" ") : "";
+  return label + badgeStr;
+}
+function printPageBox(indent, key, page, isStart, isTerminal) {
+  const label = formatPageLabel(key, page, isStart, isTerminal);
+  const rawLen = stripAnsi(label).length;
+  const boxWidth = Math.max(rawLen + 2, 20);
+  const padding = boxWidth - rawLen - 2;
+  console.log(`${indent}\u250C${H.repeat(boxWidth)}\u2510`);
+  console.log(`${indent}\u2502 ${label}${" ".repeat(padding)} \u2502`);
+  console.log(`${indent}\u2514${H.repeat(boxWidth)}\u2518`);
+}
+function printArrow(indent) {
+  console.log(`${indent}     ${V}`);
+  console.log(`${indent}     \u25BC`);
+}
+function renderBranch(indent, segment, pages, flow) {
+  const arms = segment.arms;
+  const colWidths = arms.map((arm) => {
+    const maxNameLen = Math.max(
+      ...arm.pageKeys.map((key) => {
+        const page = pages[key];
+        const name = page?.name || key;
+        const type = page?.type;
+        const typeLen = type && type !== "default" ? ` [${type}]`.length : 0;
+        return name.length + typeLen;
+      }),
+      8
+    );
+    return maxNameLen + 4;
+  });
+  let splitLine = "";
+  for (let a = 0; a < arms.length; a++) {
+    const mid = Math.floor(colWidths[a] / 2);
+    if (a === 0) {
+      splitLine += " ".repeat(mid) + "\u251C" + H.repeat(colWidths[a] - mid - 1);
+    } else if (a === arms.length - 1) {
+      splitLine += H.repeat(mid) + "\u2524" + " ".repeat(colWidths[a] - mid - 1);
+    } else {
+      splitLine += H.repeat(mid) + "\u252C" + H.repeat(colWidths[a] - mid - 1);
+    }
+    if (a < arms.length - 1) splitLine += H.repeat(3);
+  }
+  console.log(`${indent}${splitLine}`);
+  let pipeLine = "";
+  for (let a = 0; a < arms.length; a++) {
+    const mid = Math.floor(colWidths[a] / 2);
+    pipeLine += " ".repeat(mid) + V + " ".repeat(colWidths[a] - mid - 1);
+    if (a < arms.length - 1) pipeLine += "   ";
+  }
+  console.log(`${indent}${pipeLine}`);
+  const maxDepth = Math.max(...arms.map((a) => a.pageKeys.length));
+  for (let row = 0; row < maxDepth; row++) {
+    let line = "";
+    for (let a = 0; a < arms.length; a++) {
+      const key = arms[a].pageKeys[row];
+      const mid = Math.floor(colWidths[a] / 2);
+      if (key) {
+        const page = pages[key];
+        const name = page?.name || key;
+        const type = page?.type;
+        const typeBadge = type && type !== "default" ? " " + pc7.magenta(`[${type}]`) : "";
+        const display = name + typeBadge;
+        const displayLen = stripAnsi(display).length;
+        const truncated = displayLen > colWidths[a] - 2 ? name.slice(0, colWidths[a] - 5) + "..." : display;
+        const truncLen = stripAnsi(truncated).length;
+        const leftPad = mid - Math.floor(truncLen / 2);
+        const rightPad = colWidths[a] - leftPad - truncLen;
+        line += " ".repeat(Math.max(0, leftPad)) + pc7.bold(truncated) + " ".repeat(Math.max(0, rightPad));
+      } else {
+        line += " ".repeat(colWidths[a]);
+      }
+      if (a < arms.length - 1) line += "   ";
+    }
+    console.log(`${indent}${line}`);
+    if (row < maxDepth - 1) {
+      let connector = "";
+      for (let a = 0; a < arms.length; a++) {
+        const mid = Math.floor(colWidths[a] / 2);
+        const hasMore = row + 1 < arms[a].pageKeys.length;
+        if (hasMore) {
+          connector += " ".repeat(mid) + "\u25BC" + " ".repeat(colWidths[a] - mid - 1);
+        } else {
+          connector += " ".repeat(colWidths[a]);
+        }
+        if (a < arms.length - 1) connector += "   ";
+      }
+      console.log(`${indent}${connector}`);
+    }
+  }
+  let mergeLine = "";
+  for (let a = 0; a < arms.length; a++) {
+    const mid = Math.floor(colWidths[a] / 2);
+    if (a === 0) {
+      mergeLine += " ".repeat(mid) + "\u251C" + H.repeat(colWidths[a] - mid - 1);
+    } else if (a === arms.length - 1) {
+      mergeLine += H.repeat(mid) + "\u2524" + " ".repeat(colWidths[a] - mid - 1);
+    } else {
+      mergeLine += H.repeat(mid) + "\u2534" + H.repeat(colWidths[a] - mid - 1);
+    }
+    if (a < arms.length - 1) mergeLine += H.repeat(3);
+  }
+  console.log(`${indent}${mergeLine}`);
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+var H, V;
+var init_routes = __esm({
+  "src/commands/routes.ts"() {
+    "use strict";
+    init_logger();
+    init_config();
+    init_pages();
+    init_computeFlow();
+    H = "\u2500";
+    V = "\u2502";
+  }
+});
+
 // src/commands/build.ts
 var build_exports = {};
 __export(build_exports, {
@@ -1456,7 +1814,7 @@ __export(build_exports, {
 import { resolve as resolve3, join as join9 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 import { readFileSync as readFileSync8, writeFileSync as writeFileSync5, statSync, readdirSync as readdirSync4 } from "fs";
-import pc7 from "picocolors";
+import pc8 from "picocolors";
 async function buildCommand() {
   const cwd = process.cwd();
   requireAuth();
@@ -1570,6 +1928,7 @@ async function buildCommand() {
     responses: config.responses || {},
     queryParams: { ...BUILTIN_QUERY_PARAMS, ...config.queryParams },
     data: config.data || {},
+    user: BUILTIN_USER_VARS,
     products: config.products || {},
     defaultLocale: config.defaultLocale,
     assets,
@@ -1579,20 +1938,20 @@ async function buildCommand() {
   console.log();
   success("Build complete");
   console.log();
-  console.log(`  ${pc7.dim("Output:")}  dist/`);
-  console.log(`  ${pc7.dim("Pages:")}   ${pageKeys.length}`);
-  console.log(`  ${pc7.dim("Size:")}    ${formatSize(totalSize)}`);
+  console.log(`  ${pc8.dim("Output:")}  dist/`);
+  console.log(`  ${pc8.dim("Pages:")}   ${pageKeys.length}`);
+  console.log(`  ${pc8.dim("Size:")}    ${formatSize(totalSize)}`);
   console.log();
   for (const asset of assets) {
     const sizeStr = formatSize(asset.size);
     const isOver = asset.size > MAX_PAGE_SIZE;
-    console.log(`  ${isOver ? pc7.yellow("!") : pc7.dim("\xB7")} ${pc7.dim(asset.path)} ${isOver ? pc7.yellow(sizeStr) : pc7.dim(sizeStr)}`);
+    console.log(`  ${isOver ? pc8.yellow("!") : pc8.dim("\xB7")} ${pc8.dim(asset.path)} ${isOver ? pc8.yellow(sizeStr) : pc8.dim(sizeStr)}`);
   }
   console.log();
   if (totalSize > MAX_TOTAL_SIZE) {
     console.log(formatWarning(
       "BUNDLE_TOO_LARGE",
-      `Total bundle size (${formatSize(totalSize)}) exceeds the 2MB limit.`,
+      `Total bundle size (${formatSize(totalSize)}) exceeds the 10MB limit.`,
       "This will be rejected on publish. Reduce dependencies or code-split."
     ));
     console.log();
@@ -1701,7 +2060,7 @@ function getSdkVersion2(cwd) {
     return "0.0.0";
   }
 }
-var MAX_TOTAL_SIZE, MAX_PAGE_SIZE, BUILTIN_QUERY_PARAMS;
+var MAX_TOTAL_SIZE, MAX_PAGE_SIZE, BUILTIN_QUERY_PARAMS, BUILTIN_USER_VARS;
 var init_build = __esm({
   "src/commands/build.ts"() {
     "use strict";
@@ -1714,7 +2073,7 @@ var init_build = __esm({
     init_html();
     init_errors();
     init_errors();
-    MAX_TOTAL_SIZE = 2 * 1024 * 1024;
+    MAX_TOTAL_SIZE = 10 * 1024 * 1024;
     MAX_PAGE_SIZE = 500 * 1024;
     BUILTIN_QUERY_PARAMS = {
       utm_source: { type: "string" },
@@ -1723,6 +2082,14 @@ var init_build = __esm({
       utm_content: { type: "string" },
       utm_term: { type: "string" }
     };
+    BUILTIN_USER_VARS = {
+      email: { type: "string" },
+      name: { type: "string" },
+      dateOfBirth: { type: "string" },
+      gender: { type: "string" },
+      stripeCustomerId: { type: "string" },
+      paddleCustomerId: { type: "string" }
+    };
   }
 });
 
@@ -1755,10 +2122,22 @@ __export(publish_exports, {
 });
 import { resolve as resolve4, join as join11 } from "path";
 import { readFileSync as readFileSync10, existsSync as existsSync6 } from "fs";
-import pc8 from "picocolors";
-function getMimeType(path) {
-  const ext = path.substring(path.lastIndexOf("."));
-  return MIME_TYPES[ext] || "application/octet-stream";
+import { execSync } from "child_process";
+import pc9 from "picocolors";
+import select3 from "@inquirer/select";
+function tryGit(command, cwd) {
+  try {
+    return execSync(command, { cwd, stdio: ["pipe", "pipe", "ignore"] }).toString().trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getGitMetadata(cwd) {
+  const commitSha = tryGit("git rev-parse HEAD", cwd);
+  if (!commitSha) return {};
+  const branch = tryGit("git rev-parse --abbrev-ref HEAD", cwd);
+  const message = tryGit("git log -1 --pretty=%s", cwd);
+  return { commitSha, branch, message };
 }
 function formatSize2(bytes) {
   if (bytes < 1024) return `${bytes}B`;
@@ -1790,7 +2169,7 @@ async function publishCommand(options) {
   const manifest = JSON.parse(readFileSync10(manifestPath, "utf-8"));
   const assets = manifest.assets || [];
   const s = spinner("Preparing assets...");
-  const assetPayloads = [];
+  const assetBuffers = [];
   let totalBytes = 0;
   for (let i = 0; i < assets.length; i++) {
     const asset = assets[i];
@@ -1803,45 +2182,133 @@ async function publishCommand(options) {
         "Run 'appfunnel build' to regenerate."
       );
     }
-    const content = readFileSync10(fullPath);
-    totalBytes += content.length;
-    assetPayloads.push({
-      path: asset.path,
-      content,
-      contentType: getMimeType(asset.path)
+    const body = readFileSync10(fullPath);
+    totalBytes += body.length;
+    assetBuffers.push({ path: asset.path, body, size: body.length });
+    s.text = `Preparing assets... ${i + 1}/${assets.length} ${pc9.dim(`(${formatSize2(totalBytes)})`)}`;
+  }
+  s.stop();
+  const MAX_TOTAL_SIZE2 = 10 * 1024 * 1024;
+  if (totalBytes > MAX_TOTAL_SIZE2) {
+    throw new CLIError(
+      "BUNDLE_TOO_LARGE",
+      `Total bundle size (${formatSize2(totalBytes)}) exceeds the ${formatSize2(MAX_TOTAL_SIZE2)} limit.`,
+      "Reduce page bundle sizes. Check for large dependencies."
+    );
+  }
+  info(`${assets.length} assets prepared ${pc9.dim(`(${formatSize2(totalBytes)})`)}`);
+  let promote = options?.promote ?? false;
+  if (!promote) {
+    promote = await select3({
+      message: "Publish as the new active version?",
+      choices: [
+        { name: "Yes", value: true },
+        { name: "No", value: false }
+      ]
+    });
+  }
+  const git = getGitMetadata(cwd);
+  const initSpinner = spinner("Initializing publish...");
+  let initResult;
+  try {
+    initResult = await publishInit(
+      projectId,
+      {
+        manifest,
+        funnelId: config.funnelId || void 0,
+        promote,
+        commitSha: git.commitSha,
+        branch: git.branch,
+        message: git.message,
+        triggeredBy: creds.email || void 0
+      },
+      { token: creds.token }
+    );
+  } catch (err) {
+    initSpinner.stop();
+    if (err instanceof CLIError && err.code === "API_ERROR") {
+      if (err.statusCode === 413) {
+        throw new CLIError(
+          "BUNDLE_TOO_LARGE",
+          err.message,
+          "Reduce page bundle sizes. Check for large dependencies."
+        );
+      }
+      if (err.statusCode === 409) {
+        throw new CLIError(
+          "FUNNEL_NOT_HEADLESS",
+          err.message,
+          "Remove funnelId from config to create a new headless funnel."
+        );
+      }
+      throw new CLIError("PUBLISH_FAILED", err.message);
+    }
+    throw err;
+  }
+  initSpinner.stop();
+  info(`Build ${pc9.dim(initResult.buildId)} initialized`);
+  const uploadSpinner = spinner(`Uploading 0/${assets.length} assets...`);
+  const uploadInfoMap = new Map(initResult.assets.map((a) => [a.path, a]));
+  let uploaded = 0;
+  let uploadedBytes = 0;
+  const uploadAsset = async (asset) => {
+    const info2 = uploadInfoMap.get(asset.path);
+    if (!info2) {
+      throw new CLIError("PUBLISH_FAILED", `No upload URL for asset: ${asset.path}`);
+    }
+    const response = await fetch(info2.uploadUrl, {
+      method: "PUT",
+      body: new Uint8Array(asset.body),
+      headers: {
+        "Content-Type": info2.contentType
+      }
     });
-    s.text = `Preparing assets... ${i + 1}/${assets.length} ${pc8.dim(`(${formatSize2(totalBytes)})`)}`;
+    if (!response.ok) {
+      throw new CLIError(
+        "PUBLISH_FAILED",
+        `Failed to upload ${asset.path}: ${response.status} ${response.statusText}`
+      );
+    }
+    uploaded++;
+    uploadedBytes += asset.size;
+    uploadSpinner.text = `Uploading ${uploaded}/${assets.length} assets... ${pc9.dim(`(${formatSize2(uploadedBytes)}/${formatSize2(totalBytes)})`)}`;
+  };
+  const queue = [...assetBuffers];
+  const workers = [];
+  for (let i = 0; i < Math.min(UPLOAD_CONCURRENCY, queue.length); i++) {
+    workers.push((async () => {
+      while (queue.length > 0) {
+        const asset = queue.shift();
+        await uploadAsset(asset);
+      }
+    })());
   }
-  s.text = `Uploading ${assets.length} assets ${pc8.dim(`(${formatSize2(totalBytes)})`)}`;
-  const result = await publishBuild(
+  await Promise.all(workers);
+  uploadSpinner.stop();
+  info(`${assets.length} assets uploaded ${pc9.dim(`(${formatSize2(totalBytes)})`)}`);
+  const finalizeSpinner = spinner("Finalizing publish...");
+  const result = await publishFinalize(
     projectId,
-    config.funnelId || "",
-    manifest,
-    assetPayloads,
-    { token: creds.token },
-    options?.promote
+    { buildId: initResult.buildId, funnelId: initResult.funnelId },
+    { token: creds.token }
   );
-  s.stop();
-  if (result.created && result.funnelId) {
-    patchConfigFunnelId(cwd, result.funnelId);
+  finalizeSpinner.stop();
+  if (initResult.created && initResult.funnelId) {
+    patchConfigFunnelId(cwd, initResult.funnelId);
     info(`Funnel created \u2014 funnelId added to appfunnel.config.ts`);
   }
   console.log();
   success(result.activated ? "Published and activated" : "Published successfully");
   console.log();
-  console.log(`  ${pc8.dim("Build ID:")}   ${result.buildId}`);
-  if (result.funnelId && !config.funnelId) {
-    console.log(`  ${pc8.dim("Funnel:")}     ${result.funnelId}`);
-  }
-  console.log(`  ${pc8.dim("Dashboard:")}  ${pc8.cyan(result.dashboardUrl)}`);
-  console.log(`  ${pc8.dim("Assets:")}     ${assets.length} files ${pc8.dim(`(${formatSize2(totalBytes)})`)}`);
-  if (!result.activated) {
-    console.log();
-    console.log(`  ${pc8.dim("Tip:")} Use ${pc8.cyan("--promote")} to activate immediately, or promote from the dashboard.`);
+  console.log(`  ${pc9.dim("Build ID:")}   ${result.buildId}`);
+  if (initResult.funnelId && !config.funnelId) {
+    console.log(`  ${pc9.dim("Funnel:")}     ${initResult.funnelId}`);
   }
+  console.log(`  ${pc9.dim("Dashboard:")}  ${pc9.cyan(result.dashboardUrl)}`);
+  console.log(`  ${pc9.dim("Assets:")}     ${assets.length} files ${pc9.dim(`(${formatSize2(totalBytes)})`)}`);
   console.log();
 }
-var MIME_TYPES;
+var UPLOAD_CONCURRENCY;
 var init_publish = __esm({
   "src/commands/publish.ts"() {
     "use strict";
@@ -1852,26 +2319,16 @@ var init_publish = __esm({
     init_api();
     init_errors();
     init_config_patch();
-    MIME_TYPES = {
-      ".js": "application/javascript",
-      ".css": "text/css",
-      ".html": "text/html",
-      ".json": "application/json",
-      ".svg": "image/svg+xml",
-      ".png": "image/png",
-      ".jpg": "image/jpeg",
-      ".woff2": "font/woff2",
-      ".woff": "font/woff"
-    };
+    UPLOAD_CONCURRENCY = 10;
   }
 });
 
 // src/index.ts
 init_errors();
 import { Command } from "commander";
-import pc9 from "picocolors";
+import pc10 from "picocolors";
 var program = new Command();
-program.name("appfunnel").description("Build and publish headless AppFunnel projects").version("0.11.0");
+program.name("appfunnel").description("Build and publish headless AppFunnel projects").version("0.13.0");
 program.command("init").argument("[name]", "Project directory name").description("Create a new AppFunnel project").action(async (name) => {
   const { initCommand: initCommand2 } = await Promise.resolve().then(() => (init_init(), init_exports));
   await initCommand2(name);
@@ -1888,6 +2345,10 @@ program.command("dev").description("Start the development server").option("-p, -
   const { devCommand: devCommand2 } = await Promise.resolve().then(() => (init_dev(), dev_exports));
   await devCommand2({ port: parseInt(options.port, 10) });
 });
+program.command("routes").description("Visualize the funnel page flow").action(async () => {
+  const { routesCommand: routesCommand2 } = await Promise.resolve().then(() => (init_routes(), routes_exports));
+  await routesCommand2();
+});
 program.command("build").description("Build the funnel for production").action(async () => {
   const { buildCommand: buildCommand2 } = await Promise.resolve().then(() => (init_build(), build_exports));
   await buildCommand2();
@@ -1906,9 +2367,9 @@ async function main() {
       console.error(formatError(err));
       process.exit(1);
     }
-    console.error(`${pc9.red("ERROR")}: ${err instanceof Error ? err.message : String(err)}`);
+    console.error(`${pc10.red("ERROR")}: ${err instanceof Error ? err.message : String(err)}`);
     if (err instanceof Error && err.stack) {
-      console.error(pc9.dim(err.stack));
+      console.error(pc10.dim(err.stack));
     }
     process.exit(1);
   }