truecanvas 0.6.5 → 0.6.6

package/dist/cli.js

@@ -14,7 +14,7 @@ import {
   readPackage,
   runScript,
   startHub
-} from "./chunk-FJO64PGM.js";
+} from "./chunk-S5PJFVUC.js";
 import {
   CHUNK,
   decodeFrame,
@@ -22,7 +22,7 @@ import {
   responseHeaders,
   safePath,
   viewerHtml
-} from "./chunk-7KJVGN4O.js";
+} from "./chunk-O6YS366Z.js";
 import {
   DEVICES,
   Workspace,
@@ -52,6 +52,7 @@ import {
   detectPm,
   findByPath,
   findNode,
+  nodeBin,
   parseCanvas,
   run,
   toolEnv
@@ -70,15 +71,15 @@ import {
 } from "./chunk-C4SATRZT.js";
 
 // src/cli/index.ts
-import { spawn } from "child_process";
-import fs9 from "fs";
-import path11 from "path";
+import { spawn as spawn2 } from "child_process";
+import fs10 from "fs";
+import path12 from "path";
 import { parseArgs } from "util";
 
 // src/server/http.ts
 import http from "http";
-import fs6 from "fs";
-import path8 from "path";
+import fs7 from "fs";
+import path9 from "path";
 import { randomUUID } from "crypto";
 import { fileURLToPath } from "url";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -86,7 +87,7 @@ import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import launchEditor from "launch-editor";
 
 // src/server/mcp.ts
-import path3 from "path";
+import path4 from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 
@@ -284,6 +285,7 @@ async function replaceAsync(input, re, fn) {
 }
 
 // src/share/publish.ts
+import { createHash } from "crypto";
 import fs2 from "fs";
 import os from "os";
 import path2 from "path";
@@ -341,36 +343,57 @@ async function publishSnapshot(site, dir, manifest, opts = {}) {
   for (const f of manifest.frames) for (const p of [f.html, f.image]) files.push({ local: path2.join(dir, p), remote: `${manifest.id}/${p}` });
   const skipped = [];
   let uploaded = 0;
-  const queue2 = [...files];
-  const worker = async () => {
-    for (let f = queue2.shift(); f; f = queue2.shift()) {
-      const body = fs2.readFileSync(f.local);
-      if (body.length > MAX_FILE) {
-        skipped.push(f.remote);
-        continue;
+  const fitting = files.filter((f) => {
+    if (fs2.statSync(f.local).size <= MAX_FILE) return true;
+    skipped.push(f.remote);
+    return false;
+  });
+  if (can.includes("batch")) {
+    uploaded += await sendBatches(site, base, fitting.map((f) => ({ local: f.local, path: f.remote, type: contentType(f.local) })));
+  } else {
+    const queue2 = [...fitting];
+    const worker = async () => {
+      for (let f = queue2.shift(); f; f = queue2.shift()) {
+        await request(site, "PUT", `${base}/files`, fs2.readFileSync(f.local), { "x-path": f.remote, "content-type": contentType(f.local) });
+        uploaded++;
       }
-      await request(site, "PUT", `${base}/files`, body, { "x-path": f.remote, "content-type": contentType(f.local) });
-      uploaded++;
-    }
-  };
-  await Promise.all(Array.from({ length: 4 }, worker));
+    };
+    await Promise.all(Array.from({ length: 4 }, worker));
+  }
   if (skipped.some((s) => s.endsWith(".html"))) throw new Error(`A frame is too large to upload (over 4.4 MB): ${skipped.filter((s) => s.endsWith(".html")).join(", ")}`);
   if (opts.live && "dir" in opts.live) {
     const liveDir = opts.live.dir;
-    const liveFiles = walk(liveDir);
-    const pending = [...liveFiles];
-    const liveWorker = async () => {
-      for (let rel = pending.shift(); rel; rel = pending.shift()) {
-        const body = fs2.readFileSync(path2.join(liveDir, rel));
-        if (body.length > MAX_FILE) {
-          skipped.push(`live/${rel}`);
-          continue;
-        }
-        await request(site, "PUT", `${base}/live/files?version=${manifest.id}`, body, { "x-path": rel, "content-type": contentType(rel) });
-        uploaded++;
+    const liveFiles = walk(liveDir).filter((rel) => {
+      if (fs2.statSync(path2.join(liveDir, rel)).size <= MAX_FILE) return true;
+      skipped.push(`live/${rel}`);
+      return false;
+    });
+    if (can.includes("live-blobs")) {
+      const hashes = /* @__PURE__ */ new Map();
+      for (const rel of liveFiles) hashes.set(rel, createHash("sha256").update(fs2.readFileSync(path2.join(liveDir, rel))).digest("hex"));
+      const { missing } = await request(site, "POST", `${base}/live/manifest?version=${manifest.id}`, { files: Object.fromEntries(hashes) });
+      const byHash = new Map([...hashes].map(([rel, hash]) => [hash, rel]));
+      const pending = missing.map((h) => byHash.get(h)).filter(Boolean);
+      if (can.includes("batch")) uploaded += await sendBatches(site, base, pending.map((rel) => ({ local: path2.join(liveDir, rel), hash: hashes.get(rel) })));
+      else {
+        const blobWorker = async () => {
+          for (let rel = pending.shift(); rel; rel = pending.shift()) {
+            await request(site, "PUT", `${base}/live/blobs`, fs2.readFileSync(path2.join(liveDir, rel)), { "x-hash": hashes.get(rel), "content-type": "application/octet-stream" });
+            uploaded++;
+          }
+        };
+        await Promise.all(Array.from({ length: 6 }, blobWorker));
       }
-    };
-    await Promise.all(Array.from({ length: 6 }, liveWorker));
+    } else {
+      const pending = [...liveFiles];
+      const liveWorker = async () => {
+        for (let rel = pending.shift(); rel; rel = pending.shift()) {
+          await request(site, "PUT", `${base}/live/files?version=${manifest.id}`, fs2.readFileSync(path2.join(liveDir, rel)), { "x-path": rel, "content-type": contentType(rel) });
+          uploaded++;
+        }
+      };
+      await Promise.all(Array.from({ length: 6 }, liveWorker));
+    }
   }
   const change = {
     ...opts.password !== void 0 ? { password: opts.password } : {},
@@ -389,6 +412,35 @@ async function publishSnapshot(site, dir, manifest, opts = {}) {
   const invited = opts.invite?.length ? await inviteTo(site, share.slug, opts.invite) : [];
   return { url: done.url, version: manifest.id, versions: done.versions, uploaded, skipped, password, live: done.live ?? null, access, invited };
 }
+async function sendBatches(site, base, items) {
+  const LIMIT = 4 * 1024 * 1024;
+  const batches = [];
+  let current = [];
+  let size = 0;
+  for (const item of items) {
+    const n = fs2.statSync(item.local).size;
+    if (current.length && (size + n > LIMIT || current.length >= 150)) {
+      batches.push(current);
+      current = [];
+      size = 0;
+    }
+    current.push(item);
+    size += n;
+  }
+  if (current.length) batches.push(current);
+  const send = async (batch) => {
+    const bodies = batch.map((i) => fs2.readFileSync(i.local));
+    const head = Buffer.from(JSON.stringify({ files: batch.map((i, k) => ({ path: i.path, hash: i.hash, type: i.type, size: bodies[k].length })) }));
+    const len = Buffer.alloc(4);
+    len.writeUInt32BE(head.length);
+    await request(site, "POST", `${base}/files/batch`, Buffer.concat([len, head, ...bodies]), { "content-type": "application/octet-stream" });
+  };
+  const queue2 = [...batches];
+  await Promise.all(Array.from({ length: 3 }, async () => {
+    for (let b = queue2.shift(); b; b = queue2.shift()) await send(b);
+  }));
+  return items.length;
+}
 async function inviteTo(site, slug, emails) {
   const res = await request(site, "POST", `/api/shares/${slug}/invites`, { emails });
   return res.invited;
@@ -414,6 +466,21 @@ async function updateAccess(site, project, canvas, change) {
   const share = await request(site, "GET", `/api/shares/${found.slug}`);
   return { url: `${site.url}/s/${found.slug}`, access: access ?? share.access ?? null, invited };
 }
+async function linkInfo(site, project, canvas) {
+  const found = await request(site, "GET", `/api/shares?project=${encodeURIComponent(project)}&canvas=${encodeURIComponent(canvas)}`);
+  if (!found.slug) return null;
+  const share = await request(site, "GET", `/api/shares/${found.slug}`);
+  const last = share.versions?.at(-1);
+  return {
+    url: `${site.url}/s/${found.slug}`,
+    title: share.title ?? canvas,
+    access: share.access ?? null,
+    password: !!share.password,
+    versions: share.versions?.length ?? 0,
+    updatedAt: last?.createdAt ?? null,
+    live: !!last?.live
+  };
+}
 async function deleteShare(site, project, canvas) {
   const found = await request(site, "GET", `/api/shares?project=${encodeURIComponent(project)}&canvas=${encodeURIComponent(canvas)}`);
   if (!found.slug) return false;
@@ -485,6 +552,114 @@ function contentType(file) {
   return types[ext] ?? "application/octet-stream";
 }
 
+// src/share/export.ts
+import { spawn } from "child_process";
+import fs3 from "fs";
+import path3 from "path";
+var SKIP = /* @__PURE__ */ new Set(["node_modules", ".next", ".git", ".truecanvas", "out", ".turbo", ".vercel", ".swc", "pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lock", "bun.lockb"]);
+var CONFIGS = ["next.config.ts", "next.config.mts", "next.config.mjs", "next.config.js", "next.config.cjs"];
+function canExport(config) {
+  return config.framework === "next" || config.framework === "vite";
+}
+async function exportSite(config) {
+  const root = config.root;
+  if (config.framework === "vite") {
+    const out = path3.join(root, "node_modules", ".cache", "truecanvas", "live-export");
+    const cleanup2 = () => fs3.rmSync(out, { recursive: true, force: true });
+    try {
+      await run2(root, bin(root, "vite", "bin/vite.js"), ["build", "--outDir", out, "--emptyOutDir"]);
+      return { dir: out, cleanup: cleanup2 };
+    } catch (err) {
+      cleanup2();
+      throw err;
+    }
+  }
+  const work = path3.join(root, ".truecanvas", "live-export");
+  fs3.rmSync(work, { recursive: true, force: true });
+  fs3.mkdirSync(work, { recursive: true });
+  const ignore = path3.join(root, ".truecanvas", ".gitignore");
+  if (!fs3.existsSync(ignore)) fs3.writeFileSync(ignore, "# Truecanvas: generated files\n*\n");
+  const cleanup = () => fs3.rmSync(work, { recursive: true, force: true });
+  try {
+    copyProject(config, work);
+    wrapConfig(work);
+    await run2(work, bin(root, "next", "dist/bin/next"), ["build"]);
+    const out = path3.join(work, "out");
+    if (!fs3.existsSync(path3.join(out, "index.html"))) throw new Error("The build finished without a static site (no out/index.html).");
+    return { dir: out, cleanup };
+  } catch (err) {
+    cleanup();
+    throw err;
+  }
+}
+function copyProject(config, work) {
+  const root = config.root;
+  const leaveOut = new Set([config.routeDir, config.canvasDir].map((p) => path3.normalize(p)));
+  for (const name of fs3.readdirSync(root)) {
+    if (SKIP.has(name) || leaveOut.has(name)) continue;
+    fs3.cpSync(path3.join(root, name), path3.join(work, name), {
+      recursive: true,
+      filter: (src) => path3.basename(src) !== "node_modules" && !leaveOut.has(path3.normalize(path3.relative(root, src)))
+    });
+  }
+  const appDir = path3.join(work, config.appDir);
+  fs3.rmSync(path3.join(appDir, "api"), { recursive: true, force: true });
+  for (const dir of [work, path3.join(work, "src")]) for (const f of ["middleware.ts", "middleware.js", "proxy.ts", "proxy.js"]) fs3.rmSync(path3.join(dir, f), { force: true });
+}
+function wrapConfig(work) {
+  const found = CONFIGS.find((f) => fs3.existsSync(path3.join(work, f)));
+  const ts = found ? /\.m?ts$/.test(found) : true;
+  let imports = "const base = {};";
+  if (found) {
+    const renamed = `next.config.truecanvas-base${path3.extname(found)}`;
+    fs3.renameSync(path3.join(work, found), path3.join(work, renamed));
+    imports = `import base from "./${renamed}";`;
+  }
+  const body = `// @ts-nocheck
+// Generated by Truecanvas: the project's config, built as a static site for a share link.
+${imports}
+export default async function config(phase, ctx) {
+  let c = base;
+  if (typeof c === "function") c = await c(phase, ctx);
+  const { rewrites, redirects, headers, ...rest } = c ?? {};
+  return { ...rest, output: "export", typescript: { ...rest.typescript, ignoreBuildErrors: true }, images: { ...rest.images, unoptimized: true } };
+}
+`;
+  fs3.writeFileSync(path3.join(work, ts ? "next.config.ts" : "next.config.mjs"), body);
+}
+function bin(root, pkg, file) {
+  const p = path3.join(root, "node_modules", pkg, file);
+  if (!fs3.existsSync(p)) throw new Error(`Couldn't find ${pkg} in ${path3.join(root, "node_modules")}. Install the project's dependencies first.`);
+  return p;
+}
+function run2(cwd, script, args) {
+  return new Promise((resolve, reject) => {
+    const env = toolEnv({ NODE_ENV: "production", NEXT_TELEMETRY_DISABLED: "1" });
+    const node = nodeBin();
+    if (!node) return reject(new Error("Couldn't find Node.js to build the app."));
+    const child = spawn(node, [script, ...args], { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    const log = [];
+    const keep = (b) => {
+      for (const line of b.toString().split("\n")) if (line.trim()) log.push(line);
+      if (log.length > 40) log.splice(0, log.length - 40);
+    };
+    child.stdout.on("data", keep);
+    child.stderr.on("data", keep);
+    const timer = setTimeout(() => child.kill("SIGTERM"), 15 * 6e4);
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) return resolve();
+      const tail = log.filter((l) => !/^\s*(▲|✓|○|ƒ|●|Route|Creating|Collecting|Generating|Finalizing|Linting|Compiled)/.test(l)).slice(-6).join("\n");
+      reject(new Error(`The app couldn't be built as a static site:
+${tail || `exit code ${code}`}`));
+    });
+  });
+}
+
 // src/server/mcp.ts
 var INSTRUCTIONS = `Truecanvas is a design canvas whose layers are the project's real React components.
 A canvas is a .tsx file (canvas/<name>.canvas.tsx) with <Frame> artboards; every edit you make is written to that file as clean TSX and appears live in the user's editor window.
@@ -1111,13 +1286,14 @@ ${msgs}`;
         ...canvasArg,
         frames: z.array(z.string()).optional().describe("Frame names to share; omit for all."),
         title: z.string().optional().describe('Title the client sees, e.g. "Homepage, round 2".'),
-        live: z.string().optional().describe('A live version clients open with "View live": the https URL where the app runs, or a static build folder (Next `out/`, Vite `dist/`, relative to the project) that the review site hosts.'),
+        live: z.string().optional().describe("Another real site to use: the https URL where the app runs, or a static build folder (Next `out/`, Vite `dist/`, relative to the project). Usually omitted: the app is built as static pages automatically."),
+        frozen: z.boolean().optional().describe("Leave the real site out (frozen frames only). By default the app is built as static pages so clients scroll and click the actual pages."),
         invite: z.array(z.string()).optional().describe("Emails of people to invite (the client). Each gets an email with a link that signs them in and opens the design. Only invite addresses the user gave you."),
         access: z.enum(["invited", "password", "public"]).optional().describe("Who can open the link: invited people (the default for new links on review sites with sign-in), a password (the user gives it to you), or anyone with the link. Existing links keep theirs unless this is set."),
         password: z.string().optional().describe(`The link's password, with access "password".`)
       }
     },
-    async ({ canvas, frames, title, live, invite, access, password }) => {
+    async ({ canvas, frames, title, live, frozen, invite, access, password }) => {
       try {
         const c2 = resolveCanvas(canvas);
         presence(c2, "looking", "Preparing a share link");
@@ -1129,14 +1305,24 @@ ${msgs}`;
         ].filter(Boolean);
         const site = reviewSite();
         if (!site) return text([`\u2713 Snapshot ready (${manifest.frames.length} frames). No review site is set up, so this is a local preview: ${preview}`, "To get client links, the user runs `npx truecanvas share setup`.", ...notes].join("\n"));
-        const liveSite = live ? /^https?:\/\//.test(live) ? { url: live } : { dir: path3.resolve(ws.config.root, live) } : void 0;
-        const published = await publishSnapshot(site, dir, manifest, { title, live: liveSite, access, password, invite: invite?.length ? parseEmails(invite) : void 0 });
+        let liveSite = live ? /^https?:\/\//.test(live) ? { url: live } : { dir: path4.resolve(ws.config.root, live) } : void 0;
+        let built = null;
+        if (!liveSite && !frozen && canExport(ws.config) && (await siteFeatures(site).catch(() => [])).includes("live-files")) {
+          presence(c2, "looking", "Building the real site");
+          try {
+            built = await exportSite(ws.config);
+            liveSite = { dir: built.dir };
+          } catch (err) {
+            notes.push(`The real site couldn't be built, so this version has frozen frames only: ${err.message}`);
+          }
+        }
+        const published = await publishSnapshot(site, dir, manifest, { title, live: liveSite, access, password, invite: invite?.length ? parseEmails(invite) : void 0 }).finally(() => built?.cleanup());
         const who = published.access === "invited" ? ", invited people only" : published.access === "public" ? ", anyone with the link" : published.password ? ", password protected" : "";
         return text(
           [
             `\u2713 Shared ${manifest.frames.length} frame(s): ${published.url}`,
             `Version ${published.versions} of this link${who}.`,
-            published.live ? `Live version: ${published.live}` : "",
+            published.live ? "The real site is included: clients scroll and click the actual pages." : "",
             ...published.invited.map((i) => i.error ? `Couldn't email ${i.email}: ${i.error}` : `Invited ${i.email} (emailed a sign-in link).`),
             published.access === "invited" && !published.invited.length ? "Only invited people and the studio can open it: share again with `invite` to invite the client." : "",
             ...notes
@@ -1354,13 +1540,13 @@ ${out.out.slice(-1500)}`));
 
 // src/server/thumbnails.ts
 import crypto2 from "crypto";
-import fs3 from "fs";
-import path4 from "path";
+import fs4 from "fs";
+import path5 from "path";
 var Thumbnails = class _Thumbnails {
   constructor(ws, shots) {
     this.ws = ws;
     this.shots = shots;
-    this.dir = path4.join(ws.config.root, "node_modules", ".cache", "truecanvas", "thumbs");
+    this.dir = path5.join(ws.config.root, "node_modules", ".cache", "truecanvas", "thumbs");
   }
   ws;
   shots;
@@ -1386,8 +1572,8 @@ var Thumbnails = class _Thumbnails {
   key(spec, props) {
     let stamp = "";
     try {
-      const file = spec.library ? path4.join(this.ws.config.root, "node_modules", spec.library, "package.json") : path4.join(this.ws.config.root, spec.file);
-      stamp = String(fs3.statSync(file).mtimeMs);
+      const file = spec.library ? path5.join(this.ws.config.root, "node_modules", spec.library, "package.json") : path5.join(this.ws.config.root, spec.file);
+      stamp = String(fs4.statSync(file).mtimeMs);
     } catch {
       stamp = "0";
     }
@@ -1398,14 +1584,14 @@ var Thumbnails = class _Thumbnails {
     const spec = this.ws.catalog.get(name);
     if (!spec) throw new Error(`Unknown component ${name}`);
     const props = _Thumbnails.previewProps(spec, preset);
-    const file = path4.join(this.dir, `${name}-${this.key(spec, props)}.png`);
-    if (fs3.existsSync(file)) return fs3.readFileSync(file);
+    const file = path5.join(this.dir, `${name}-${this.key(spec, props)}.png`);
+    if (fs4.existsSync(file)) return fs4.readFileSync(file);
     const job = this.queue.then(async () => {
-      if (fs3.existsSync(file)) return fs3.readFileSync(file);
+      if (fs4.existsSync(file)) return fs4.readFileSync(file);
       const url = `${this.ws.config.appUrl}/truecanvas/__preview?component=${encodeURIComponent(name)}&props=${encodeURIComponent(JSON.stringify(props))}`;
       const png = await this.shots.element(url, { width: 640, height: 480 });
-      fs3.mkdirSync(this.dir, { recursive: true });
-      fs3.writeFileSync(file, png);
+      fs4.mkdirSync(this.dir, { recursive: true });
+      fs4.writeFileSync(file, png);
       return png;
     });
     this.queue = job.catch(() => void 0);
@@ -1414,14 +1600,14 @@ var Thumbnails = class _Thumbnails {
 };
 
 // src/server/screenshot.ts
-import fs4 from "fs";
+import fs5 from "fs";
 import os2 from "os";
-import path5 from "path";
+import path6 from "path";
 function findChromium() {
   if (process.env.TRUECANVAS_CHROME) return process.env.TRUECANVAS_CHROME;
-  const cache2 = process.env.PLAYWRIGHT_BROWSERS_PATH || (process.platform === "win32" ? path5.join(process.env.LOCALAPPDATA ?? path5.join(os2.homedir(), "AppData", "Local"), "ms-playwright") : process.platform === "darwin" ? path5.join(os2.homedir(), "Library", "Caches", "ms-playwright") : path5.join(os2.homedir(), ".cache", "ms-playwright"));
-  if (fs4.existsSync(cache2)) {
-    const shells = fs4.readdirSync(cache2).filter((d) => d.startsWith("chromium_headless_shell-")).sort().reverse();
+  const cache2 = process.env.PLAYWRIGHT_BROWSERS_PATH || (process.platform === "win32" ? path6.join(process.env.LOCALAPPDATA ?? path6.join(os2.homedir(), "AppData", "Local"), "ms-playwright") : process.platform === "darwin" ? path6.join(os2.homedir(), "Library", "Caches", "ms-playwright") : path6.join(os2.homedir(), ".cache", "ms-playwright"));
+  if (fs5.existsSync(cache2)) {
+    const shells = fs5.readdirSync(cache2).filter((d) => d.startsWith("chromium_headless_shell-")).sort().reverse();
     for (const d of shells) {
       for (const sub of [
         "chrome-headless-shell-linux64/chrome-headless-shell",
@@ -1431,14 +1617,14 @@ function findChromium() {
         "chrome-headless-shell-win64/chrome-headless-shell.exe",
         "chrome-win/headless_shell.exe"
       ]) {
-        const p = path5.join(cache2, d, sub);
-        if (fs4.existsSync(p)) return p;
+        const p = path6.join(cache2, d, sub);
+        if (fs5.existsSync(p)) return p;
       }
     }
   }
   const programFiles = [process.env.PROGRAMFILES, process.env["PROGRAMFILES(X86)"], process.env.LOCALAPPDATA].filter(Boolean);
   for (const p of [
-    ...programFiles.flatMap((dir) => [path5.join(dir, "Google", "Chrome", "Application", "chrome.exe"), path5.join(dir, "Microsoft", "Edge", "Application", "msedge.exe")]),
+    ...programFiles.flatMap((dir) => [path6.join(dir, "Google", "Chrome", "Application", "chrome.exe"), path6.join(dir, "Microsoft", "Edge", "Application", "msedge.exe")]),
     "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
     "/usr/bin/chromium-browser",
     "/usr/bin/chromium",
@@ -1447,7 +1633,7 @@ function findChromium() {
     "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
     "/Applications/Chromium.app/Contents/MacOS/Chromium"
   ]) {
-    if (fs4.existsSync(p)) return p;
+    if (fs5.existsSync(p)) return p;
   }
   return void 0;
 }
@@ -1665,9 +1851,9 @@ ${root.outerHTML}`, css, canvases, height };
 var appRun = { state: "external", log: [] };
 
 // src/server/review.ts
-import fs5 from "fs";
-import path6 from "path";
-import { createHash } from "crypto";
+import fs6 from "fs";
+import path7 from "path";
+import { createHash as createHash2 } from "crypto";
 var actorName = (e) => e.actor.kind === "agent" ? e.actor.name : e.actor.kind === "file" ? "code editor" : "you";
 async function versionAt(ws, canvas, ref) {
   const rel = ws.relFile(canvas);
@@ -1683,14 +1869,14 @@ async function versionAt(ws, canvas, ref) {
 }
 var readNow = (ws, file) => {
   try {
-    return fs5.readFileSync(path6.join(ws.config.root, file), "utf8");
+    return fs6.readFileSync(path7.join(ws.config.root, file), "utf8");
   } catch {
     return null;
   }
 };
 async function reviewPage(ws, canvas, ref, since) {
   const rel = ws.relFile(canvas);
-  const exists = fs5.existsSync(ws.file(canvas));
+  const exists = fs6.existsSync(ws.file(canvas));
   const old = await versionAt(ws, canvas, ref);
   if (!exists && old.source === null) return null;
   const now = exists ? ws.read(canvas) : null;
@@ -1760,7 +1946,7 @@ function renderFrame(ws, shots, canvas, frame, side, ref) {
 async function render(ws, shots, canvas, frame, side, ref) {
   let source;
   let files = {};
-  if (side === "after") source = fs5.existsSync(ws.file(canvas)) ? ws.read(canvas) : null;
+  if (side === "after") source = fs6.existsSync(ws.file(canvas)) ? ws.read(canvas) : null;
   else {
     const old = await versionAt(ws, canvas, ref);
     source = old.source;
@@ -1771,12 +1957,12 @@ async function render(ws, shots, canvas, frame, side, ref) {
   const f = doc.frames.find((x) => x.frameName === frame);
   if (!f) return null;
   const linkedNow = f.page ? [f.page, ...layoutFiles(ws.config, f.page)].map((x) => readNow(ws, x) ?? "").join("\0") : "";
-  const key = createHash("sha1").update([canvas, frame, side, source, JSON.stringify(files), side === "after" ? linkedNow : ""].join("\0")).digest("hex");
+  const key = createHash2("sha1").update([canvas, frame, side, source, JSON.stringify(files), side === "after" ? linkedNow : ""].join("\0")).digest("hex");
   const hit = cache.get(key);
   if (hit) return hit;
   let name = canvas;
   const snapshot = `${canvas}.${side === "before" ? "base" : "now"}`;
-  if (side === "before" || !fs5.existsSync(ws.file(canvas))) name = writeCompare(ws.config, canvas, source, files, snapshot);
+  if (side === "before" || !fs6.existsSync(ws.file(canvas))) name = writeCompare(ws.config, canvas, source, files, snapshot);
   try {
     const device = findDevice(f.device);
     const png = await shots.frame({ canvas: name, frame, width: f.width, height: f.height, theme: f.theme ?? "light", scale: Math.min(2, Math.max(0.4, 1e3 / f.width)), mobile: device ? device.kind !== "desktop" : false, jpeg: true, maxHeight: 6e3 });
@@ -1811,7 +1997,7 @@ function prDesignSection(pages, images) {
 }
 
 // src/share/sync.ts
-import path7 from "path";
+import path8 from "path";
 var EVERY = 2e4;
 var LOOKUP_EVERY = 5 * 6e4;
 var CommentSync = class {
@@ -1863,7 +2049,7 @@ var CommentSync = class {
   async slugOf(site, canvas) {
     const known = this.links.get(canvas);
     if (known && (known.slug || Date.now() - known.at < LOOKUP_EVERY)) return known.slug;
-    const project = path7.basename(this.ws.config.root);
+    const project = path8.basename(this.ws.config.root);
     const res = await call(site, "GET", `/api/shares?project=${encodeURIComponent(project)}&canvas=${encodeURIComponent(canvas)}`);
     this.links.set(canvas, { slug: res.slug, at: Date.now() });
     return res.slug;
@@ -2091,8 +2277,8 @@ var LiveSession = class {
   }
   // ---------- the tunnel ----------
   /** The app URL for a tunneled path, or null if it would leave the app. */
-  target(path12, ws = false) {
-    const safe = safePath(path12);
+  target(path13, ws = false) {
+    const safe = safePath(path13);
     if (!safe) return null;
     const url = new URL(safe, this.app);
     if (url.origin !== this.app.origin) return null;
@@ -2217,8 +2403,8 @@ var LiveSession = class {
       }
     });
   }
-  openRelay(id, path12, protocols) {
-    const target = this.target(path12, true);
+  openRelay(id, path13, protocols) {
+    const target = this.target(path13, true);
     if (!target) {
       this.send({ t: "ws-close", id, code: 1008, reason: "Not part of the app" });
       return;
@@ -2335,17 +2521,23 @@ var MIME = {
   ".ico": "image/x-icon"
 };
 async function startServer(ws) {
+  let shareStep = null;
   const { config } = ws;
   const editorDir = fileURLToPath(new URL("./editor/", import.meta.url));
   const shots = new Screenshotter(config.appUrl);
   let prCache = null;
   const thumbs = new Thumbnails(ws, shots);
   const hub = process.env.TRUECANVAS_HUB_URL;
-  const commentSync = new CommentSync(
-    ws,
-    hub ? (e) => void fetch(`${hub}/api/hub/notify`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ path: config.root, ...e }), signal: AbortSignal.timeout(5e3) }).catch(() => {
-    }) : void 0
-  );
+  const clients = /* @__PURE__ */ new Set();
+  const commentSync = new CommentSync(ws, (e) => {
+    const data2 = `data: ${JSON.stringify({ type: "client-comment", ...e })}
+
+`;
+    for (const res of clients) res.write(data2);
+    if (hub)
+      void fetch(`${hub}/api/hub/notify`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ path: config.root, ...e }), signal: AbortSignal.timeout(5e3) }).catch(() => {
+      });
+  });
   commentSync.start();
   const syncRegistry = () => ws.catalog.load().then((list) => syncComponentRegistry(config, list)).catch(() => {
   });
@@ -2353,7 +2545,6 @@ async function startServer(ws) {
   const origin = `http://localhost:${config.port}`;
   const allowedHosts = /* @__PURE__ */ new Set([`localhost:${config.port}`, `127.0.0.1:${config.port}`]);
   const allowedOrigins = /* @__PURE__ */ new Set([origin, `http://127.0.0.1:${config.port}`]);
-  const clients = /* @__PURE__ */ new Set();
   const broadcast = (e) => {
     const data2 = `data: ${JSON.stringify(e)}
 
@@ -2367,7 +2558,7 @@ async function startServer(ws) {
 `;
     for (const res of clients) res.write(data2);
   };
-  const sessions = new Sessions(path8.basename(config.root), config.appUrl, {
+  const sessions = new Sessions(path9.basename(config.root), config.appUrl, {
     onEvent: (canvas, e) => {
       if (e.t === "comments") void commentSync.syncAll();
       else sendRaw({ type: "room", canvas, event: e });
@@ -2429,7 +2620,7 @@ async function startServer(ws) {
           appUrl: config.appUrl,
           framework: config.framework,
           root: config.root,
-          projectName: path8.basename(config.root),
+          projectName: path9.basename(config.root),
           canvases: ws.canvases(),
           darkMode: config.darkMode,
           agents: [...ws.agents.values()],
@@ -2579,7 +2770,7 @@ async function startServer(ws) {
           for (const file of [f.page, ...layoutFiles(config, f.page)]) {
             const old = await ws.git.show(ref, file);
             if (old === null) continue;
-            const now = fs6.existsSync(path8.join(config.root, file)) ? fs6.readFileSync(path8.join(config.root, file), "utf8") : null;
+            const now = fs7.existsSync(path9.join(config.root, file)) ? fs7.readFileSync(path9.join(config.root, file), "utf8") : null;
             if (old !== now) {
               files[file] = old;
               touched.add(f.frameName);
@@ -2709,26 +2900,53 @@ async function startServer(ws) {
       }
       case "POST /api/open-file": {
         const { file } = await readJson(req);
-        const abs = path8.resolve(config.root, file);
-        const rel = path8.relative(config.root, abs);
-        if (rel.startsWith("..") || path8.isAbsolute(rel)) return json(res, 400, { error: "Outside project." });
+        const abs = path9.resolve(config.root, file);
+        const rel = path9.relative(config.root, abs);
+        if (rel.startsWith("..") || path9.isAbsolute(rel)) return json(res, 400, { error: "Outside project." });
         launchEditor(abs, config.editor);
         return json(res, 200, { ok: true });
       }
       case "GET /api/share/status": {
         const site = reviewSite();
         const features = site ? await siteFeatures(site).catch(() => []) : [];
-        return json(res, 200, { site: site ? site.url : null, features });
+        return json(res, 200, { site: site ? site.url : null, features, realSite: canExport(config) && features.includes("live-files") });
       }
+      case "GET /api/share/link": {
+        const canvas = url.searchParams.get("canvas") ?? "";
+        assertCanvasName(canvas);
+        const site = reviewSite();
+        return json(res, 200, { link: site ? await linkInfo(site, path9.basename(config.root), canvas).catch(() => null) : null });
+      }
+      case "GET /api/share/progress":
+        return json(res, 200, { step: shareStep });
       case "POST /api/share/snapshot": {
-        const { canvas, frames, local, title, password, live, access, invite } = await readJson(req);
+        const { canvas, frames, local, title, password, live, access, invite, realSite } = await readJson(req);
         assertCanvasName(canvas);
-        const { dir, manifest } = await createSnapshot(ws, shots, canvas, { frames });
-        const preview = `${origin}/share/${encodeURIComponent(canvas)}/${manifest.id}/`;
         const site = local ? null : reviewSite();
-        const published = site ? await publishSnapshot(site, dir, manifest, { title, password, live, access, invite: invite?.length ? parseEmails(invite) : void 0 }) : null;
-        if (published) commentSync.forget(canvas);
-        return json(res, 200, { manifest, preview, published });
+        let built = null;
+        let realSiteError = null;
+        try {
+          shareStep = "Rendering every frame through your app";
+          const { dir, manifest } = await createSnapshot(ws, shots, canvas, { frames });
+          const preview = `${origin}/share/${encodeURIComponent(canvas)}/${manifest.id}/`;
+          let liveSite = live;
+          if (site && !live && realSite !== false && canExport(config) && (await siteFeatures(site).catch(() => [])).includes("live-files")) {
+            shareStep = "Building the real site";
+            try {
+              built = await exportSite(config);
+              liveSite = { dir: built.dir };
+            } catch (err) {
+              realSiteError = err.message;
+            }
+          }
+          if (site) shareStep = `Uploading to ${site.url.replace(/^https?:\/\//, "")}`;
+          const published = site ? await publishSnapshot(site, dir, manifest, { title, password, live: liveSite, access, invite: invite?.length ? parseEmails(invite) : void 0 }) : null;
+          if (published) commentSync.forget(canvas);
+          return json(res, 200, { manifest, preview, published, realSiteError });
+        } finally {
+          built?.cleanup();
+          shareStep = null;
+        }
       }
       // live sessions: clients follow the canvas live on its link (editor button, CLI, MCP, desktop tray)
       case "GET /api/session":
@@ -2770,24 +2988,24 @@ async function startServer(ws) {
     return json(res, 404, { error: `No route ${route}` });
   }
   function serveStatic(res, pathname) {
-    let file = path8.join(editorDir, pathname === "/" ? "index.html" : pathname);
-    if (!inside(editorDir, file) || !fs6.existsSync(file) || fs6.statSync(file).isDirectory()) file = path8.join(editorDir, "index.html");
-    if (!fs6.existsSync(file)) {
+    let file = path9.join(editorDir, pathname === "/" ? "index.html" : pathname);
+    if (!inside(editorDir, file) || !fs7.existsSync(file) || fs7.statSync(file).isDirectory()) file = path9.join(editorDir, "index.html");
+    if (!fs7.existsSync(file)) {
       res.writeHead(500, { "content-type": "text/plain" });
       return res.end("Editor bundle missing. Run `pnpm build` in packages/truecanvas.");
     }
-    const ext = path8.extname(file);
+    const ext = path9.extname(file);
     const immutable = pathname.startsWith("/assets/");
     res.writeHead(200, { "content-type": MIME[ext] ?? "application/octet-stream", "cache-control": immutable ? "public, max-age=31536000, immutable" : "no-cache" });
-    fs6.createReadStream(file).on("error", () => res.destroy()).pipe(res);
+    fs7.createReadStream(file).on("error", () => res.destroy()).pipe(res);
   }
   function serveShare(res, rest) {
     const root = sharesDir(config.root);
-    let file = path8.join(root, decodeURIComponent(rest));
-    if (rest.endsWith("/")) file = path8.join(file, "index.html");
-    if (!inside(root, file) || !fs6.existsSync(file) || fs6.statSync(file).isDirectory()) return json(res, 404, { error: "Not found" });
-    res.writeHead(200, { "content-type": MIME[path8.extname(file)] ?? "application/octet-stream", "cache-control": "no-cache", "x-content-type-options": "nosniff", "access-control-allow-origin": "*" });
-    fs6.createReadStream(file).on("error", () => res.destroy()).pipe(res);
+    let file = path9.join(root, decodeURIComponent(rest));
+    if (rest.endsWith("/")) file = path9.join(file, "index.html");
+    if (!inside(root, file) || !fs7.existsSync(file) || fs7.statSync(file).isDirectory()) return json(res, 404, { error: "Not found" });
+    res.writeHead(200, { "content-type": MIME[path9.extname(file)] ?? "application/octet-stream", "cache-control": "no-cache", "x-content-type-options": "nosniff", "access-control-allow-origin": "*" });
+    fs7.createReadStream(file).on("error", () => res.destroy()).pipe(res);
   }
   const server = http.createServer(async (req, res) => {
     try {
@@ -2807,8 +3025,8 @@ async function startServer(ws) {
       else res.end();
     }
   });
-  const canvasDir = path8.join(config.root, config.canvasDir);
-  fs6.mkdirSync(canvasDir, { recursive: true });
+  const canvasDir = path9.join(config.root, config.canvasDir);
+  fs7.mkdirSync(canvasDir, { recursive: true });
   const pending = /* @__PURE__ */ new Map();
   const onCanvasFile = (filename) => {
     if (!filename) return;
@@ -2833,7 +3051,7 @@ async function startServer(ws) {
   const watchCanvasDir = () => {
     let ino = null;
     try {
-      ino = fs6.statSync(canvasDir).ino;
+      ino = fs7.statSync(canvasDir).ino;
     } catch {
       ino = null;
     }
@@ -2842,21 +3060,21 @@ async function startServer(ws) {
     canvasWatcher = null;
     watchedIno = ino;
     if (ino === null) return;
-    canvasWatcher = fs6.watch(canvasDir, (_event, filename) => onCanvasFile(filename));
+    canvasWatcher = fs7.watch(canvasDir, (_event, filename) => onCanvasFile(filename));
     canvasWatcher.on("error", () => {
       canvasWatcher?.close();
       canvasWatcher = null;
     });
-    for (const f of fs6.readdirSync(canvasDir)) onCanvasFile(f);
+    for (const f of fs7.readdirSync(canvasDir)) onCanvasFile(f);
   };
   watchCanvasDir();
   setInterval(watchCanvasDir, 2e3).unref();
-  const appDirAbs = path8.join(config.root, config.appDir);
-  if (config.framework === "next" && fs6.existsSync(appDirAbs)) {
+  const appDirAbs = path9.join(config.root, config.appDir);
+  if (config.framework === "next" && fs7.existsSync(appDirAbs)) {
     const appPending = /* @__PURE__ */ new Map();
-    const appWatcher = fs6.watch(appDirAbs, { recursive: true }, (_event, filename) => {
+    const appWatcher = fs7.watch(appDirAbs, { recursive: true }, (_event, filename) => {
       if (!filename || !/(^|[\\/])(page|layout)\.[jt]sx$/.test(filename) || /^truecanvas[\\/]/.test(filename)) return;
-      const rel = path8.join(config.appDir, filename).split(path8.sep).join("/");
+      const rel = path9.join(config.appDir, filename).split(path9.sep).join("/");
       clearTimeout(appPending.get(rel));
       appPending.set(
         rel,
@@ -2873,9 +3091,9 @@ async function startServer(ws) {
   }
   let catalogTimer;
   for (const dir of componentRoots(config.components)) {
-    const abs = path8.join(config.root, dir);
-    if (!fs6.existsSync(abs)) continue;
-    const componentWatcher = fs6.watch(abs, { recursive: true }, () => {
+    const abs = path9.join(config.root, dir);
+    if (!fs7.existsSync(abs)) continue;
+    const componentWatcher = fs7.watch(abs, { recursive: true }, () => {
       clearTimeout(catalogTimer);
       catalogTimer = setTimeout(() => {
         ws.catalog.invalidate();
@@ -2911,8 +3129,8 @@ function dedent(code, col) {
   return code.split("\n").map((l, i) => i > 0 && l.startsWith(pad) ? l.slice(col) : l).join("\n");
 }
 function inside(dir, file) {
-  const rel = path8.relative(dir, file);
-  return !!rel && !rel.startsWith("..") && !path8.isAbsolute(rel);
+  const rel = path9.relative(dir, file);
+  return !!rel && !rel.startsWith("..") && !path9.isAbsolute(rel);
 }
 
 // src/server/stdio.ts
@@ -2954,9 +3172,9 @@ async function runStdioBridge(mcpUrl) {
 import { createRequire } from "module";
 
 // src/hub/desktop.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import os3 from "os";
-import path9 from "path";
+import path10 from "path";
 var ICON = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1024 1024">
   <defs>
     <linearGradient id="bg" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#ff9466"/><stop offset="1" stop-color="#ea6a3c"/></linearGradient>
@@ -2970,15 +3188,15 @@ var ICON = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1024 1024">
   <path fill="#f6f5f1" fill-rule="evenodd" d="M236 236h552v168H236z M428 316h168v472H428z"/>
 </svg>
 `;
-var data = () => process.env.XDG_DATA_HOME ?? path9.join(os3.homedir(), ".local", "share");
+var data = () => process.env.XDG_DATA_HOME ?? path10.join(os3.homedir(), ".local", "share");
 function installDesktop(cli, port) {
-  const dir = path9.join(data(), "truecanvas");
-  fs7.mkdirSync(dir, { recursive: true });
-  const icon = path9.join(dir, "icon.svg");
-  fs7.writeFileSync(icon, ICON);
-  const launcher = path9.join(dir, "launch.sh");
+  const dir = path10.join(data(), "truecanvas");
+  fs8.mkdirSync(dir, { recursive: true });
+  const icon = path10.join(dir, "icon.svg");
+  fs8.writeFileSync(icon, ICON);
+  const launcher = path10.join(dir, "launch.sh");
   const url = `http://localhost:${port}`;
-  fs7.writeFileSync(
+  fs8.writeFileSync(
     launcher,
     `#!/bin/sh
 # Truecanvas launcher: start the hub if needed, then open its window.
@@ -2987,7 +3205,7 @@ CLI=${JSON.stringify(cli)}
 URL=${JSON.stringify(url)}
 LOG="\${XDG_STATE_HOME:-$HOME/.local/state}/truecanvas-hub.log"
 # apps started from the desktop don't get your shell's PATH: next, pnpm and npx need it
-export PATH=${JSON.stringify([path9.dirname(process.execPath), ...(process.env.PATH ?? "").split(path9.delimiter)].filter((p, i, a) => p && a.indexOf(p) === i).join(path9.delimiter))}
+export PATH=${JSON.stringify([path10.dirname(process.execPath), ...(process.env.PATH ?? "").split(path10.delimiter)].filter((p, i, a) => p && a.indexOf(p) === i).join(path10.delimiter))}
 mkdir -p "$(dirname "$LOG")"
 
 if ! curl -sf "$URL/api/hub/state" >/dev/null 2>&1; then
@@ -2996,7 +3214,7 @@ if ! curl -sf "$URL/api/hub/state" >/dev/null 2>&1; then
   while [ $i -lt 60 ] && ! curl -sf "$URL/api/hub/state" >/dev/null 2>&1; do sleep 0.25; i=$((i+1)); done
 fi
 
-PROFILE=${JSON.stringify(path9.join(dir, "window"))}
+PROFILE=${JSON.stringify(path10.join(dir, "window"))}
 for b in google-chrome google-chrome-stable chromium-browser chromium brave-browser microsoft-edge; do
   if command -v "$b" >/dev/null 2>&1; then
     exec "$b" --app="$URL" --class=Truecanvas --user-data-dir="$PROFILE" --no-first-run --no-default-browser-check
@@ -3006,10 +3224,10 @@ exec xdg-open "$URL"
 `,
     { mode: 493 }
   );
-  const apps = path9.join(data(), "applications");
-  fs7.mkdirSync(apps, { recursive: true });
-  const desktop = path9.join(apps, "truecanvas.desktop");
-  fs7.writeFileSync(
+  const apps = path10.join(data(), "applications");
+  fs8.mkdirSync(apps, { recursive: true });
+  const desktop = path10.join(apps, "truecanvas.desktop");
+  fs8.writeFileSync(
     desktop,
     `[Desktop Entry]
 Type=Application
@@ -3025,11 +3243,11 @@ StartupWMClass=Truecanvas
 StartupNotify=true
 `
   );
-  let command = path9.join(os3.homedir(), ".local", "bin", "truecanvas");
-  const ours = !fs7.existsSync(command) || fs7.readFileSync(command, "utf8").includes("# truecanvas wrapper");
+  let command = path10.join(os3.homedir(), ".local", "bin", "truecanvas");
+  const ours = !fs8.existsSync(command) || fs8.readFileSync(command, "utf8").includes("# truecanvas wrapper");
   if (ours) {
-    fs7.mkdirSync(path9.dirname(command), { recursive: true });
-    fs7.writeFileSync(command, `#!/bin/sh
+    fs8.mkdirSync(path10.dirname(command), { recursive: true });
+    fs8.writeFileSync(command, `#!/bin/sh
 # truecanvas wrapper (installed by \`truecanvas desktop\`)
 exec ${JSON.stringify(process.execPath)} ${JSON.stringify(cli)} "$@"
 `, { mode: 493 });
@@ -3037,19 +3255,19 @@ exec ${JSON.stringify(process.execPath)} ${JSON.stringify(cli)} "$@"
   return { desktop, launcher, icon, command };
 }
 function launcherPath() {
-  const p = path9.join(data(), "truecanvas", "launch.sh");
-  return fs7.existsSync(p) ? p : null;
+  const p = path10.join(data(), "truecanvas", "launch.sh");
+  return fs8.existsSync(p) ? p : null;
 }
 function uninstallDesktop() {
   const removed = [];
-  const cmd = path9.join(os3.homedir(), ".local", "bin", "truecanvas");
-  if (fs7.existsSync(cmd) && fs7.readFileSync(cmd, "utf8").includes("# truecanvas wrapper")) {
-    fs7.rmSync(cmd);
+  const cmd = path10.join(os3.homedir(), ".local", "bin", "truecanvas");
+  if (fs8.existsSync(cmd) && fs8.readFileSync(cmd, "utf8").includes("# truecanvas wrapper")) {
+    fs8.rmSync(cmd);
     removed.push(cmd);
   }
-  for (const f of [path9.join(data(), "applications", "truecanvas.desktop"), path9.join(data(), "truecanvas")]) {
-    if (fs7.existsSync(f)) {
-      fs7.rmSync(f, { recursive: true, force: true });
+  for (const f of [path10.join(data(), "applications", "truecanvas.desktop"), path10.join(data(), "truecanvas")]) {
+    if (fs8.existsSync(f)) {
+      fs8.rmSync(f, { recursive: true, force: true });
       removed.push(f);
     }
   }
@@ -3062,8 +3280,8 @@ import { createInterface } from "readline/promises";
 
 // src/cli/doctor.ts
 import { execFile } from "child_process";
-import fs8 from "fs";
-import path10 from "path";
+import fs9 from "fs";
+import path11 from "path";
 var major = (v) => v ? Number(/(\d+)(?:\.(\d+))?/.exec(v)?.[1] ?? 0) : 0;
 function has(cmd, args, cwd) {
   return new Promise((resolve) => execFile(cmd, args, { cwd, timeout: 8e3 }, (err, stdout, stderr) => resolve(err ? null : `${stdout}${stderr}`)));
@@ -3090,7 +3308,7 @@ async function doctor(root, cliVersion) {
   const tw = depVersion(root, "tailwindcss");
   add(tw ? { label: "Tailwind CSS", status: "ok", detail: tw } : { label: "Tailwind CSS", status: "warn", detail: "not installed", fix: "Optional, but the layout and style controls write Tailwind classes" });
   const config = loadConfig(root);
-  if (config.framework === "next") add(fs8.existsSync(path10.join(root, config.appDir)) ? { label: "App Router", status: "ok", detail: config.appDir } : { label: "App Router", status: "fail", detail: `no ${config.appDir}/`, fix: "Truecanvas renders through the App Router (app/ or src/app/)" });
+  if (config.framework === "next") add(fs9.existsSync(path11.join(root, config.appDir)) ? { label: "App Router", status: "ok", detail: config.appDir } : { label: "App Router", status: "fail", detail: `no ${config.appDir}/`, fix: "Truecanvas renders through the App Router (app/ or src/app/)" });
   const tc = installedIn(root);
   if (!tc.declared) add({ label: "Truecanvas in the project", status: "fail", detail: "not a dependency", fix: "npx truecanvas  (sets it up)" });
   else if (!tc.installed) add({ label: "Truecanvas in the project", status: "fail", detail: "declared but not installed", fix: `${pm} install` });
@@ -3099,15 +3317,15 @@ async function doctor(root, cliVersion) {
   const wrapped = configStatus(root, config.framework);
   const configLabel = config.framework === "vite" ? "vite.config" : "next.config";
   const uses = config.framework === "vite" ? "has the truecanvas() plugin" : "uses withTruecanvas()";
-  add(wrapped.wrapped ? { label: configLabel, status: "ok", detail: `${path10.basename(wrapped.file)} ${uses}` } : { label: configLabel, status: "fail", detail: wrapped.file ? "Truecanvas not enabled" : "missing", fix: "npx truecanvas init" });
+  add(wrapped.wrapped ? { label: configLabel, status: "ok", detail: `${path11.basename(wrapped.file)} ${uses}` } : { label: configLabel, status: "fail", detail: wrapped.file ? "Truecanvas not enabled" : "missing", fix: "npx truecanvas init" });
   const scripts = pkg.scripts ?? {};
   const script = Object.entries(scripts).find(([, v]) => v.includes("truecanvas"));
   add(script ? { label: "Start script", status: "ok", detail: runScript(pm, script[0]) } : { label: "Start script", status: "warn", detail: "none", fix: 'npx truecanvas init  (adds "canvas": "truecanvas dev")' });
-  const ignore = fs8.existsSync(path10.join(root, ".gitignore")) ? fs8.readFileSync(path10.join(root, ".gitignore"), "utf8") : "";
+  const ignore = fs9.existsSync(path11.join(root, ".gitignore")) ? fs9.readFileSync(path11.join(root, ".gitignore"), "utf8") : "";
   add(ignore.includes(config.routeDir) ? { label: "Generated route ignored", status: "ok" } : { label: "Generated route ignored", status: "warn", detail: `${config.routeDir}/ isn't in .gitignore`, fix: "npx truecanvas init" });
   add(hasAgentConfig(root) ? { label: "Agents", status: "ok", detail: ".mcp.json lists Truecanvas" } : { label: "Agents", status: "warn", detail: "not connected for this project", fix: "npx truecanvas connect  (then commit .mcp.json)" });
   const chrome = findChromium();
-  add(chrome ? { label: "Screenshots", status: "ok", detail: path10.basename(chrome) } : { label: "Screenshots", status: "warn", detail: "no Chromium found", fix: "npx playwright install chromium-headless-shell  (or install Chrome)" });
+  add(chrome ? { label: "Screenshots", status: "ok", detail: path11.basename(chrome) } : { label: "Screenshots", status: "warn", detail: "no Chromium found", fix: "npx playwright install chromium-headless-shell  (or install Chrome)" });
   const git = await has("git", ["rev-parse", "--is-inside-work-tree"], root);
   add(git ? { label: "Git", status: "ok" } : { label: "Git", status: "warn", detail: "not a repository", fix: "git init  (branches, history, comments and compare use git)" });
   const gh = await has("gh", ["auth", "status"], root);
@@ -3134,7 +3352,8 @@ Usage
   truecanvas desktop   Add Truecanvas to your app launcher (Linux); "desktop remove" undoes it
   truecanvas share [canvas]  Share a canvas as a link for clients (needs truecanvas running).
                        --password <p>, --no-password, --revoke, --restore, --delete, --title <t>, --local (preview only),
-                       --live <url|dir>: a live version clients open with "View live" (where the app runs, or a static build)
+                       The real site (your app built as static pages) is included, so clients click the actual pages;
+                       --frozen leaves it out, --live <url|dir> uses another one (where the app runs, or a static build)
                        --invite <emails>: invite people by email (they sign in with a link; new links are invited-only)
                        --access invited|password|public: who can open the link
                        --link-only: with --invite or --access, change the link without a new version
@@ -3235,6 +3454,7 @@ async function main() {
       delete: { type: "boolean" },
       token: { type: "string" },
       live: { type: "string" },
+      frozen: { type: "boolean" },
       invite: { type: "string", multiple: true },
       access: { type: "string" },
       "link-only": { type: "boolean" },
@@ -3259,9 +3479,9 @@ async function main() {
     }
     if (!await ensureSetup(root2, pkgDir, version, yes)) return;
     if (await openInWindow(root2, values.port ? Number(values.port) : hubPort())) return;
-    const local = path11.join(root2, "node_modules", "truecanvas", "dist", "cli.js");
-    if (fs9.existsSync(local) && fs9.realpathSync(local) !== fs9.realpathSync(cli)) {
-      const child = spawn(process.execPath, [local, "dev", ...process.argv.slice(2).filter((a) => a !== "start" && a !== "-y" && a !== "--yes")], { stdio: "inherit" });
+    const local = path12.join(root2, "node_modules", "truecanvas", "dist", "cli.js");
+    if (fs10.existsSync(local) && fs10.realpathSync(local) !== fs10.realpathSync(cli)) {
+      const child = spawn2(process.execPath, [local, "dev", ...process.argv.slice(2).filter((a) => a !== "start" && a !== "-y" && a !== "--yes")], { stdio: "inherit" });
       for (const sig of ["SIGINT", "SIGTERM"]) process.on(sig, () => child.kill(sig));
       child.on("exit", (code) => process.exit(code ?? 0));
       return;
@@ -3342,7 +3562,7 @@ async function main() {
     return;
   }
   const root = process.cwd();
-  if (!fs9.existsSync(path11.join(root, "package.json"))) {
+  if (!fs10.existsSync(path12.join(root, "package.json"))) {
     console.error("Run truecanvas from your app's root (no package.json here).");
     process.exit(1);
   }
@@ -3352,7 +3572,7 @@ async function main() {
     const report = initProject(config);
     ws.ensureRoute();
     console.log(`
-  ${c.accent("\u25C6")} ${c.bold("Truecanvas")} is set up in ${c.bold(path11.basename(root))}
+  ${c.accent("\u25C6")} ${c.bold("Truecanvas")} is set up in ${c.bold(path12.basename(root))}
 `);
     for (const line of report.done) console.log(`  ${c.green("\u2713")} ${line}`);
     console.log(`  ${c.green("\u2713")} Canvas folder ${c.bold(config.canvasDir)} and dev route ${c.bold(config.routeDir)}`);
@@ -3384,7 +3604,7 @@ async function main() {
         console.error(site ? "Name the canvas: truecanvas share <canvas> --delete" : `No review site yet: ${c.accent("npx truecanvas share setup")}`);
         process.exit(1);
       }
-      const done = await deleteShare(site, path11.basename(root), canvas);
+      const done = await deleteShare(site, path12.basename(root), canvas);
       console.log(done ? `  ${c.green("\u2713")} Deleted the link of ${canvas}, with its versions and comments.` : `  ${canvas} has no link.`);
       return;
     }
@@ -3395,7 +3615,7 @@ async function main() {
         process.exit(1);
       }
       const change = { ...values.revoke ? { revoked: true } : values.restore ? { revoked: false } : {}, ...values["no-password"] ? { password: null } : {} };
-      const url = await updateShare(site, path11.basename(root), canvas, change);
+      const url = await updateShare(site, path12.basename(root), canvas, change);
       console.log(`  ${c.green("\u2713")} ${values.revoke ? "Link revoked" : values.restore ? "Link restored" : "Password removed"}: ${url}`);
       return;
     }
@@ -3418,7 +3638,7 @@ async function main() {
         process.exit(1);
       }
       try {
-        const done = await updateAccess(site, path11.basename(root), canvas, { access, password: values.password, invite });
+        const done = await updateAccess(site, path12.basename(root), canvas, { access, password: values.password, invite });
         console.log(`  ${c.green("\u2713")} ${done.url} ${c.dim(`(${accessLabel(done.access)})`)}`);
         printInvited(done.invited);
       } catch (err) {
@@ -3440,8 +3660,8 @@ async function main() {
     const publish = !values.local && !!reviewSite();
     console.log(`  ${c.dim(`Rendering ${canvas} through your app${publish ? " and publishing it" : ""}\u2026`)}`);
     const password = values.password;
-    const live = values.live ? /^https?:\/\//.test(values.live) ? { url: values.live } : { dir: path11.resolve(values.live) } : void 0;
-    if (live && "dir" in live && !fs9.existsSync(path11.join(live.dir, "index.html"))) {
+    const live = values.live ? /^https?:\/\//.test(values.live) ? { url: values.live } : { dir: path12.resolve(values.live) } : void 0;
+    if (live && "dir" in live && !fs10.existsSync(path12.join(live.dir, "index.html"))) {
       console.error(`  ${c.red("\u2717")} No index.html in ${live.dir}. Pass a static build folder (Next \`out/\`, Vite \`dist/\`) or the URL where the app runs.`);
       process.exit(1);
     }
@@ -3452,7 +3672,7 @@ async function main() {
     const res = await fetch(`${base}/api/share/snapshot`, {
       method: "POST",
       headers: { "content-type": "application/json", origin: base },
-      body: JSON.stringify({ canvas, local: !publish, title: values.title, password, live, access, invite })
+      body: JSON.stringify({ canvas, local: !publish, title: values.title, password, live, access, invite, realSite: !values.frozen })
     });
     const body = await res.json();
     if (!res.ok) {
@@ -3460,14 +3680,16 @@ async function main() {
       process.exit(1);
     }
     const { manifest, published } = body;
-    console.log(`  ${c.green("\u2713")} ${manifest.frames.length} frame${manifest.frames.length === 1 ? "" : "s"} frozen: no scripts, no API calls.`);
+    console.log(`  ${c.green("\u2713")} ${manifest.frames.length} frame${manifest.frames.length === 1 ? "" : "s"} rendered.`);
     if (manifest.external.length) console.log(`  ${c.yellow("!")} While rendering, the app called ${manifest.external.join(", ")}. Whatever it showed is in the snapshot: use sample data for client links.`);
     if (manifest.missing.length) console.log(`  ${c.yellow("!")} ${manifest.missing.length} asset${manifest.missing.length === 1 ? "" : "s"} couldn't be fetched.`);
     if (published?.skipped.length) console.log(`  ${c.yellow("!")} Left out (over 4.4 MB): ${published.skipped.join(", ")}`);
     if (published) {
       const who = published.access ? `, ${accessLabel(published.access)}` : published.password ? ", password protected" : "";
       console.log(`  ${c.green("\u2713")} Shared: ${c.bold(published.url)} ${c.dim(`(version ${published.versions}${who})`)}`);
-      if (published.live) console.log(`  ${c.green("\u2713")} Live: ${published.live} ${c.dim(published.access !== "public" && (published.access || published.password) ? "(opens from the link's View live button)" : "")}`);
+      if (published.live) console.log(`  ${c.green("\u2713")} Real site included: clients scroll and click the actual pages.`);
+      if (body.realSiteError) console.log(`  ${c.yellow("!")} The real site couldn't be built, so this version has frozen frames only:
+${c.dim(body.realSiteError.replace(/^/gm, "    "))}`);
       printInvited(published.invited);
       if (published.access === "invited" && !published.invited.length) console.log(`  ${c.dim("Only invited people and your studio can open it. Invite someone:")} ${c.accent(`npx truecanvas share ${canvas} --invite name@client.com --link-only`)}`);
       console.log("");
@@ -3571,12 +3793,12 @@ async function openWindow(cli, port) {
   const url = `http://localhost:${port}`;
   const launcher = launcherPath();
   if (launcher) {
-    spawn(launcher, [], { stdio: "ignore", detached: true }).unref();
+    spawn2(launcher, [], { stdio: "ignore", detached: true }).unref();
     return console.log(`${c.accent("\u25C6")} Opening Truecanvas\u2026`);
   }
   const up = await fetch(`${url}/api/hub/state`, { signal: AbortSignal.timeout(1500) }).then((r) => r.ok).catch(() => false);
   if (!up) {
-    spawn(process.execPath, [cli, "hub", "--port", String(port), "--no-open"], { stdio: "ignore", detached: true }).unref();
+    spawn2(process.execPath, [cli, "hub", "--port", String(port), "--no-open"], { stdio: "ignore", detached: true }).unref();
     for (let i = 0; i < 40 && !await fetch(`${url}/api/hub/state`).then((r) => r.ok).catch(() => false); i++) await new Promise((r) => setTimeout(r, 250));
   }
   openBrowser(url);
@@ -3589,7 +3811,7 @@ async function openInWindow(root, port) {
   const post = (route, body) => fetch(`${hub}${route}`, { method: "POST", headers: { "content-type": "application/json", origin: hub }, body: JSON.stringify(body) }).catch(() => null);
   await post("/api/hub/add", { path: root });
   await post("/api/hub/open", { path: root, focus: "1" });
-  console.log(`${c.accent("\u25C6")} Opened ${c.bold(path11.basename(root))} in the Truecanvas window ${c.dim(`(${hub})`)}.`);
+  console.log(`${c.accent("\u25C6")} Opened ${c.bold(path12.basename(root))} in the Truecanvas window ${c.dim(`(${hub})`)}.`);
   return true;
 }
 async function prompt(question) {
@@ -3613,7 +3835,7 @@ async function ensureSetup(root, pkgDir, version, yes, force = false) {
   const tc = installedIn(root);
   const wrapped = configStatus(root).wrapped;
   if (tc.declared && tc.installed && wrapped && !force) return true;
-  const name = readPackage(root)?.name ?? path11.basename(root);
+  const name = readPackage(root)?.name ?? path12.basename(root);
   if (!yes) {
     if (!process.stdin.isTTY) {
       console.error(`Truecanvas isn't set up in ${name} yet. Run again with --yes to set it up.`);
@@ -3684,10 +3906,10 @@ function startApp(root, appUrl, framework) {
   const port = new URL(appUrl).port || (framework === "vite" ? "5173" : "3000");
   const devArgs = framework === "vite" ? ["--port", port, "--strictPort", "--host", "127.0.0.1"] : ["dev", "-p", port, "-H", "127.0.0.1"];
   const pkg = framework === "vite" ? "vite" : "next";
-  const bin = binScript(root, pkg);
-  const [cmd, args] = bin ? [process.execPath, [bin, ...devArgs]] : [process.platform === "win32" ? "npx.cmd" : "npx", [pkg, ...devArgs]];
+  const bin2 = binScript(root, pkg);
+  const [cmd, args] = bin2 ? [process.execPath, [bin2, ...devArgs]] : [process.platform === "win32" ? "npx.cmd" : "npx", [pkg, ...devArgs]];
   const label = framework === "vite" ? "vite" : "next";
-  const child = spawn(cmd, args, { cwd: root, env: toolEnv(process.env.NO_COLOR ? {} : { FORCE_COLOR: "1" }), stdio: ["ignore", "pipe", "pipe"], shell: !bin && process.platform === "win32" });
+  const child = spawn2(cmd, args, { cwd: root, env: toolEnv(process.env.NO_COLOR ? {} : { FORCE_COLOR: "1" }), stdio: ["ignore", "pipe", "pipe"], shell: !bin2 && process.platform === "win32" });
   child.on("error", (err) => console.error(`  ${c.dim(`${label} \u2502`)} couldn't start ${pkg}: ${err.message}`));
   const prefix = c.dim(`${label} \u2502 `);
   for (const stream of [child.stdout, child.stderr]) {
@@ -3709,24 +3931,24 @@ function startApp(root, appUrl, framework) {
 }
 function binScript(root, pkg) {
   try {
-    const req = createRequire(path11.join(root, "package.json"));
+    const req = createRequire(path12.join(root, "package.json"));
     const manifest = req.resolve(`${pkg}/package.json`);
-    const { bin } = JSON.parse(fs9.readFileSync(manifest, "utf8"));
-    const rel = typeof bin === "string" ? bin : bin?.[pkg];
-    return rel ? path11.join(path11.dirname(manifest), rel) : null;
+    const { bin: bin2 } = JSON.parse(fs10.readFileSync(manifest, "utf8"));
+    const rel = typeof bin2 === "string" ? bin2 : bin2?.[pkg];
+    return rel ? path12.join(path12.dirname(manifest), rel) : null;
   } catch {
     return null;
   }
 }
 function stopTree(child, signal) {
-  if (process.platform === "win32" && child.pid) spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" }).on("error", () => {
+  if (process.platform === "win32" && child.pid) spawn2("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" }).on("error", () => {
   });
   else child.kill(signal);
 }
 function openBrowser(url) {
   const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
   try {
-    spawn(cmd, [url], { stdio: "ignore", detached: true, shell: process.platform === "win32" }).on("error", () => {
+    spawn2(cmd, [url], { stdio: "ignore", detached: true, shell: process.platform === "win32" }).on("error", () => {
     }).unref();
   } catch {
   }