create-vidra-app 0.2.0 → 0.2.2

package/dist/cli.js

@@ -368,6 +368,7 @@ import { execFileSync as execFileSync3 } from "child_process";
 import prompts from "prompts";
 var DOTNET = process.platform === "win32" ? "dotnet.exe" : "dotnet";
 var MAUI_DOCS = "https://learn.microsoft.com/dotnet/maui/get-started/installation";
+var INSTALL_NET_10_FIX = "Install the .NET 10 SDK \u2014 https://dotnet.microsoft.com/download";
 var bufToStr = (v) => v == null ? "" : Buffer.isBuffer(v) ? v.toString() : v;
 var run = (cmd, args) => {
   try {
@@ -386,107 +387,179 @@ var run = (cmd, args) => {
     };
   }
 };
-var hasNet10Sdk = (listSdksOutput) => listSdksOutput.split(/\r?\n/).some((line) => /^10\./.test(line.trim()));
-var newestNet10Sdk = (listSdksOutput) => listSdksOutput.split(/\r?\n/).map((line) => line.trim().split(/\s+/)[0]).filter((v) => /^10\./.test(v)).sort(
+var splitLines = (text) => text.split(/\r?\n/);
+var matchesAny = (text, patterns) => patterns.some((pattern) => pattern.test(text));
+var NET_10_VERSION = /^10\./;
+var WORKLOAD_SET_VERSION_LINE = /Workload version:\s*([\w.-]+)/i;
+var MAUI_WORKLOAD = /\bmaui\b/i;
+var COMMAND_LINE_TOOLS_PATH = /CommandLineTools/i;
+var hasNet10Sdk = (listSdksOutput) => splitLines(listSdksOutput).some((line) => NET_10_VERSION.test(line.trim()));
+var newestNet10Sdk = (listSdksOutput) => splitLines(listSdksOutput).map((line) => line.trim().split(/\s+/)[0]).filter((version) => NET_10_VERSION.test(version)).sort(
   (a, b) => a.localeCompare(b, void 0, { numeric: true, sensitivity: "base" })
 ).pop();
-var outputMentionsMaui = (workloadListOutput) => /\bmaui\b/i.test(workloadListOutput);
-var looksLikeMissingWorkload = (output) => [
+var outputMentionsMaui = (workloadListOutput) => MAUI_WORKLOAD.test(workloadListOutput);
+var workloadSetVersion = (workloadListOutput) => workloadListOutput.match(WORKLOAD_SET_VERSION_LINE)?.[1];
+var MIN_MACCATALYST_WATCH_WORKLOAD_SET = [10, 0, 203];
+var MIN_MACCATALYST_WATCH_SDK = [10, 0, 300];
+var meetsMinimumVersion = (version, minimum) => {
+  const segments = version.split(".").map((s) => Number.parseInt(s, 10));
+  if (segments.slice(0, minimum.length).some(Number.isNaN)) return false;
+  for (let i = 0; i < minimum.length; i++) {
+    const segment = segments[i] ?? 0;
+    if (segment !== minimum[i]) return segment > minimum[i];
+  }
+  return true;
+};
+var workloadSetSupportsCSharpHotReload = (version) => meetsMinimumVersion(version, MIN_MACCATALYST_WATCH_WORKLOAD_SET);
+var sdkSupportsCSharpHotReload = (version) => meetsMinimumVersion(version, MIN_MACCATALYST_WATCH_SDK);
+var macCatalystHotReloadBlocker = () => {
+  const sdkRes = run(DOTNET, ["--version"]);
+  if (!sdkRes.found) return null;
+  const sdkVersion = sdkRes.stdout.trim();
+  if (sdkVersion && !sdkSupportsCSharpHotReload(sdkVersion)) {
+    return {
+      reason: `C# hot reload needs the .NET SDK 10.0.300+ \u2014 found ${sdkVersion}`,
+      fix: INSTALL_NET_10_FIX
+    };
+  }
+  const res = run(DOTNET, ["workload", "list"]);
+  if (!res.found) return null;
+  const version = workloadSetVersion(res.stdout);
+  if (!version || workloadSetSupportsCSharpHotReload(version)) return null;
+  return {
+    reason: `C# hot reload needs workload set 10.0.203+ \u2014 found ${version}`,
+    fix: "dotnet workload update"
+  };
+};
+var MISSING_WORKLOAD_SIGNATURES = [
   /NETSDK1147/i,
   /workloads?\s+must\s+be\s+installed/i,
   /maui-maccatalyst/i,
   /maui-windows/i,
   /to\s+install\s+the\s+.*workload/i
-].some((re) => re.test(output));
-var looksLikeMissingXcode = (output) => [
+];
+var MISSING_XCODE_SIGNATURES = [
   /valid\s+Xcode\s+installation\s+was\s+not\s+found/i,
   /could\s+not\s+find\s+a\s+valid\s+Xcode\s+app\s+bundle/i,
   /macios-missing-xcode/i
-].some((re) => re.test(output));
+];
+var OUTDATED_XCODE_SIGNATURES = [
+  /error\s+MT0180/i,
+  /requires\s+the\s+MacCatalyst\s+\S+\s+SDK\s+\(shipped\s+with\s+Xcode/i
+];
+var looksLikeMissingWorkload = (output) => matchesAny(output, MISSING_WORKLOAD_SIGNATURES);
+var looksLikeMissingXcode = (output) => matchesAny(output, MISSING_XCODE_SIGNATURES);
+var looksLikeXcodeTooOld = (output) => matchesAny(output, OUTDATED_XCODE_SIGNATURES);
 var checkDotnetSdk = () => {
+  const name = ".NET SDK";
   const res = run(DOTNET, ["--list-sdks"]);
   if (!res.found) {
     return {
-      name: ".NET SDK",
+      name,
       status: "missing",
       detail: "`dotnet` was not found on your PATH",
-      fix: "Install the .NET 10 SDK \u2014 https://dotnet.microsoft.com/download"
+      fix: INSTALL_NET_10_FIX
     };
   }
   if (!res.ok && !res.stdout) {
-    return {
-      name: ".NET SDK",
-      status: "unknown",
-      detail: "could not run `dotnet --list-sdks`"
-    };
+    return { name, status: "unknown", detail: "could not run `dotnet --list-sdks`" };
   }
   if (hasNet10Sdk(res.stdout)) {
     const newest = newestNet10Sdk(res.stdout);
-    return {
-      name: ".NET SDK",
-      status: "ok",
-      detail: newest ? `found ${newest}` : "found 10.x"
-    };
+    return { name, status: "ok", detail: newest ? `found ${newest}` : "found 10.x" };
   }
   return {
-    name: ".NET SDK",
+    name,
     status: "missing",
     detail: "no 10.x SDK installed",
-    fix: "Install the .NET 10 SDK \u2014 https://dotnet.microsoft.com/download"
+    fix: INSTALL_NET_10_FIX
+  };
+};
+var checkMauiWorkload = (workloadList) => {
+  const name = ".NET MAUI workload";
+  if (!workloadList) {
+    return { name, status: "unknown", detail: "requires the .NET SDK first" };
+  }
+  if (!workloadList.found) {
+    return { name, status: "unknown", detail: "could not query workloads" };
+  }
+  if (outputMentionsMaui(workloadList.stdout)) {
+    return { name, status: "ok", detail: "installed" };
+  }
+  return {
+    name,
+    status: "missing",
+    detail: "not installed",
+    fix: "dotnet workload install maui"
   };
 };
-var checkMauiWorkload = (dotnetOk) => {
-  if (!dotnetOk) {
+var checkCSharpHotReload = (workloadList) => {
+  const name = "C# hot reload";
+  if (!workloadList) {
+    return { name, status: "unknown", detail: "requires the .NET SDK first" };
+  }
+  if (process.platform !== "darwin") {
+    return { name, status: "ok", detail: "dotnet watch supported" };
+  }
+  const sdkVersion = run(DOTNET, ["--version"]).stdout.trim();
+  if (sdkVersion && !sdkSupportsCSharpHotReload(sdkVersion)) {
     return {
-      name: ".NET MAUI workload",
+      name,
       status: "unknown",
-      detail: "requires the .NET SDK first"
+      detail: `SDK ${sdkVersion} \u2014 its dotnet-watch crashes Mac Catalyst apps on launch (needs 10.0.300+) \u2014 vidra dev falls back to a classic launch`,
+      fix: INSTALL_NET_10_FIX
     };
   }
-  const res = run(DOTNET, ["workload", "list"]);
-  if (!res.found) {
+  const version = workloadSetVersion(workloadList.stdout);
+  if (!version) {
     return {
-      name: ".NET MAUI workload",
+      name,
       status: "unknown",
-      detail: "could not query workloads"
+      detail: "could not read the workload set version"
     };
   }
-  if (outputMentionsMaui(res.stdout)) {
-    return { name: ".NET MAUI workload", status: "ok", detail: "installed" };
+  if (workloadSetSupportsCSharpHotReload(version)) {
+    return { name, status: "ok", detail: `workload set ${version}` };
   }
   return {
-    name: ".NET MAUI workload",
-    status: "missing",
-    detail: "not installed",
-    fix: "dotnet workload install maui"
+    name,
+    status: "unknown",
+    detail: `workload set ${version} predates Mac Catalyst dotnet-watch support (needs 10.0.203+) \u2014 vidra dev falls back to a classic launch`,
+    fix: "dotnet workload update"
   };
 };
 var checkXcode = () => {
+  const name = "Xcode";
   const res = run("xcode-select", ["-p"]);
   if (!res.found || !res.ok) {
     return {
-      name: "Xcode",
+      name,
       status: "missing",
       detail: "not found",
       fix: "Install Xcode from the App Store"
     };
   }
   const devDir = res.stdout.trim();
-  if (/CommandLineTools/i.test(devDir)) {
+  if (COMMAND_LINE_TOOLS_PATH.test(devDir)) {
     return {
-      name: "Xcode",
+      name,
       status: "missing",
       detail: "only Command Line Tools detected (Mac Catalyst needs full Xcode)",
       fix: "Install Xcode, then: sudo xcode-select -s /Applications/Xcode.app"
     };
   }
-  return { name: "Xcode", status: "ok", detail: devDir };
+  return { name, status: "ok", detail: devDir };
 };
 var isMauiWorkloadInstalled = () => outputMentionsMaui(run(DOTNET, ["workload", "list"]).stdout);
 var isInteractive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
 var collectRequirements = (opts = {}) => {
   const dotnet = checkDotnetSdk();
-  const reqs = [dotnet, checkMauiWorkload(dotnet.status === "ok")];
+  const workloadList = dotnet.status === "ok" ? run(DOTNET, ["workload", "list"]) : null;
+  const reqs = [
+    dotnet,
+    checkMauiWorkload(workloadList),
+    checkCSharpHotReload(workloadList)
+  ];
   if (opts.includeXcode ?? process.platform === "darwin") {
     reqs.push(checkXcode());
   }
@@ -508,7 +581,7 @@ var printRequirements = (reqs) => {
         detail: r.detail ? dim(r.detail) : void 0
       })
     );
-    if (r.status === "missing" && r.fix) {
+    if (r.status !== "ok" && r.fix) {
       console.log(fixLine(r.fix));
     }
   }
@@ -645,6 +718,23 @@ var printWorkloadHint = () => {
   console.error(fixLine("vidra doctor", "check:"));
   console.error();
 };
+var printXcodeTooOldHint = () => {
+  console.error();
+  console.error(
+    row({
+      glyph: "manual",
+      label: "your Xcode is older than the SDK this MAUI workload set expects."
+    })
+  );
+  console.error(
+    `      ${dim("\u2022")} ${dim("update Xcode (App Store), then")} ${lime("sudo xcodebuild -runFirstLaunch")}`
+  );
+  console.error(
+    `      ${dim("\u2022")} ${dim("or pin the workloads to your Xcode's era:")} ${lime("dotnet workload update --version <set>")}`
+  );
+  console.error(fixLine("vidra doctor", "check:"));
+  console.error();
+};
 var printXcodeHint = () => {
   console.error();
   console.error(
@@ -948,6 +1038,7 @@ var POLL_INTERVAL_MS = 500;
 var POLL_TIMEOUT_MS = 3e4;
 var NPM_COMMAND = process.platform === "win32" ? "npm.cmd" : "npm";
 var DOTNET_COMMAND = process.platform === "win32" ? "dotnet.exe" : "dotnet";
+var WATCH_OUTPUT_TAIL_CHARS = 8192;
 var TARGETS2 = {
   macos: {
     name: "macos",
@@ -958,12 +1049,13 @@ var TARGETS2 = {
     framework: "net10.0-windows10.0.19041.0"
   }
 };
-var devCommand = (argv) => startSession(argv, { vite: true });
-var runCommand = (argv) => startSession(argv, { vite: false });
+var devCommand = (argv) => startSession(argv, { vite: true, hotReloadDefault: true });
+var runCommand = (argv) => startSession(argv, { vite: false, hotReloadDefault: false });
 var startSession = async (argv, opts) => {
   const args = parseArgs(["_", "_", ...argv]);
   const targetName = args["target"] || detectPlatform();
   const verbose = !!args["verbose"];
+  let hotReload = opts.hotReloadDefault && !args["no-hot-reload"];
   const viteUrl = process.env.VIDRA_DEV_URL || "http://localhost:5173";
   const target = TARGETS2[targetName];
   if (!target) {
@@ -981,16 +1073,68 @@ var startSession = async (argv, opts) => {
   if (!await ensureMauiWorkload({ csprojPath: project.csprojPath })) {
     process.exit(1);
   }
-  const session = new DevSession(project, target, viteUrl, verbose, opts);
+  if (hotReload && target.name === "macos") {
+    const blocker = macCatalystHotReloadBlocker();
+    if (blocker) {
+      hotReload = false;
+      console.log();
+      console.log(
+        row({
+          glyph: "manual",
+          detail: `${dim(blocker.reason + "; using a classic launch")}`
+        })
+      );
+      console.log(fixLine(blocker.fix));
+    }
+  }
+  const session = new DevSession(project, target, viteUrl, verbose, {
+    vite: opts.vite,
+    hotReload
+  });
   await session.run();
 };
+var buildDotnetWatchArgs = (opts) => [
+  "watch",
+  "--project",
+  opts.csprojPath,
+  // Never prompt on rude edits (our stdio is piped, so a prompt would hang);
+  // paired with DOTNET_WATCH_RESTART_ON_RUDE_EDIT for older SDKs.
+  "--non-interactive",
+  ...opts.verbose ? ["--verbose"] : [],
+  "run",
+  "-f",
+  opts.framework,
+  "-c",
+  opts.buildConfig,
+  // Launch the Mac Catalyst app by exec'ing the binary rather than `open -a`,
+  // so the environment (VIDRA_DEV_URL, DOTNET_STARTUP_HOOKS) propagates and
+  // stdout streams back. Ignored by targets that don't define the property.
+  ...opts.targetName === "macos" ? ["--property:RunWithOpen=false"] : []
+];
+var dotnetWatchEnv = (devUrl) => ({
+  VIDRA_DEV_URL: devUrl,
+  DOTNET_WATCH_RESTART_ON_RUDE_EDIT: "1",
+  DOTNET_WATCH_SUPPRESS_EMOJIS: "1",
+  DOTNET_WATCH_SUPPRESS_LAUNCH_BROWSER: "1"
+});
+var HOST_READY_SENTINEL = "[vidra] host ready";
+var classifyWatchLine = (line) => {
+  if (/waiting for a file to change/i.test(line)) return "appWaiting";
+  if (/fix the error to continue/i.test(line)) return "buildBlocked";
+  if (line.includes(HOST_READY_SENTINEL)) return "appStarted";
+  if (/\bwatch\b/i.test(line) && /\b(?:started|launched)\b/i.test(line)) {
+    return "appStarted";
+  }
+  return null;
+};
 var DevSession = class {
-  constructor(project, target, viteUrl, verbose, options = {}) {
+  constructor(project, target, viteUrl, verbose, options) {
     this.project = project;
     this.target = target;
     this.viteUrl = viteUrl;
     this.verbose = verbose;
-    this.vite = options.vite ?? true;
+    this.vite = options.vite;
+    this.hotReload = options.hotReload;
   }
   project;
   target;
@@ -999,7 +1143,19 @@ var DevSession = class {
   children = [];
   buildConfig = process.env.VIDRA_BUILD_CONFIG || "Debug";
   vite;
+  hotReload;
   shuttingDown = false;
+  // Watch-mode state: `watchChild` is the `dotnet watch` process (a process
+  // group leader on unix, so shutdown can signal it and the app it launched
+  // together); `watchReady` flips once the app has started at least once.
+  watchChild;
+  watchReady = false;
+  watchOutputTail = "";
+  endSession = () => {
+  };
+  sessionDone = new Promise((resolve) => {
+    this.endSession = resolve;
+  });
   async run() {
     this.installSignalHandlers();
     console.log();
@@ -1007,9 +1163,8 @@ var DevSession = class {
     console.log(kv("project", this.project.projectName));
     console.log(kv("target", this.target.framework));
     console.log();
-    let vite;
     if (this.vite) {
-      vite = this.startVite();
+      this.startVite();
       try {
         await waitForServer(this.viteUrl, POLL_TIMEOUT_MS);
       } catch (error) {
@@ -1028,19 +1183,22 @@ var DevSession = class {
         )
       );
     }
-    const host = this.target.name === "macos" ? this.launchMacosHost() : this.launchWindowsHost();
+    this.launchHost();
+    const hostDirLabel = `src/${path6.basename(this.project.hostDir)}`;
     if (this.vite) {
       console.log(
         taggedRow(
           "active",
           null,
-          `${lime("hot reload active")} ${dim("\u2014 edit ui/src and save")}`
+          this.hotReload ? `${lime("hot reload active")} ${dim(`\u2014 edit ui/src or ${hostDirLabel} and save`)}` : `${lime("hot reload active")} ${dim("\u2014 edit ui/src and save")}`
         )
       );
       console.log();
       console.log(
         footer(
-          `${dim("watching")} ${value("ui/")} ${dim(
+          this.hotReload ? `${dim("watching")} ${value("ui/")} ${dim("\xB7")} ${value(`${hostDirLabel}/`)} ${dim(
+            "\xB7 hot reload on save \xB7 ctrl-c to stop"
+          )}` : `${dim("watching")} ${value("ui/")} ${dim(
             "\xB7 hot reload on save \xB7 ctrl-c to stop"
           )}`
         )
@@ -1052,7 +1210,7 @@ var DevSession = class {
       );
     }
     console.log();
-    await waitForExit(...vite ? [vite, host] : [host]);
+    await this.sessionDone;
   }
   installSignalHandlers() {
     process.on("SIGINT", () => {
@@ -1072,6 +1230,181 @@ var DevSession = class {
     });
     return this.registerChild(vite, "ui", "Vite dev server");
   }
+  launchHost() {
+    if (this.hotReload) {
+      return this.launchHostWithWatch();
+    }
+    return this.target.name === "macos" ? this.launchMacosHost() : this.launchWindowsHost();
+  }
+  // --- dotnet watch launch (C# hot reload) -----------------------------------
+  launchHostWithWatch() {
+    console.log(
+      taggedRow(
+        "active",
+        "host",
+        `${dim("dotnet watch \u2014 building")} ${value(this.target.framework)} ${dim("\u2026")}`
+      )
+    );
+    const watch = spawn2(
+      DOTNET_COMMAND,
+      buildDotnetWatchArgs({
+        csprojPath: this.project.csprojPath,
+        framework: this.target.framework,
+        buildConfig: this.buildConfig,
+        verbose: this.verbose,
+        targetName: this.target.name
+      }),
+      {
+        cwd: this.project.root,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, ...dotnetWatchEnv(this.viteUrl) },
+        // Unix: make dotnet watch its own process-group leader so shutdown can
+        // SIGTERM the group — taking down both watch and the app it launched.
+        // Windows cleanup goes through `taskkill /T` instead.
+        detached: process.platform !== "win32"
+      }
+    );
+    this.watchChild = watch;
+    this.children.push(watch);
+    const notSentinel = (line) => !line.includes(HOST_READY_SENTINEL);
+    prefixStream(watch.stdout, "host", notSentinel);
+    prefixStream(watch.stderr, "host", notSentinel);
+    scanStream(watch.stdout, (line) => this.onWatchLine(line));
+    scanStream(watch.stderr, (line) => this.onWatchLine(line));
+    watch.on("exit", (code, signal) => {
+      if (this.shuttingDown) return;
+      if (this.watchReady) {
+        const failed = code !== null && code !== 0 || signal !== null;
+        if (failed) {
+          console.error(
+            "\n" + row({
+              glyph: "error",
+              detail: dim(
+                `dotnet watch exited with ${signal ? `signal ${signal}` : `code ${code}`}`
+              )
+            })
+          );
+        }
+        this.shutdown(code ?? (signal ? 1 : 0));
+        return;
+      }
+      this.fallBackToClassicLaunch(code, signal);
+    });
+    watch.on("error", (error) => {
+      if (this.shuttingDown) return;
+      console.error(
+        "\n" + row({
+          glyph: "error",
+          detail: dim(`failed to start dotnet watch: ${error.message}`)
+        })
+      );
+      this.shutdown(1);
+    });
+    return watch;
+  }
+  onWatchLine(line) {
+    this.watchOutputTail = (this.watchOutputTail + line + "\n").slice(
+      -WATCH_OUTPUT_TAIL_CHARS
+    );
+    const event = classifyWatchLine(line);
+    if (event === "appStarted" && !this.watchReady) {
+      this.watchReady = true;
+      console.log(
+        taggedRow(
+          "done",
+          "host",
+          `${dim("launched")} ${value(this.project.projectName)} ${dim("\u2014 C# hot reload active")}`
+        )
+      );
+      return;
+    }
+    if (event !== "appWaiting" && event !== "buildBlocked" || this.shuttingDown) {
+      return;
+    }
+    if (this.watchReady) {
+      console.log(
+        taggedRow(
+          "manual",
+          "host",
+          dim("app not running \u2014 save a C# file to relaunch, or ctrl-c to stop")
+        )
+      );
+      return;
+    }
+    if (!/Build FAILED/i.test(this.watchOutputTail)) {
+      console.log(
+        taggedRow(
+          "manual",
+          "host",
+          dim(
+            "app exited before it was ready \u2014 save a C# file to relaunch, or ctrl-c to stop"
+          )
+        )
+      );
+      return;
+    }
+    if (looksLikeMissingWorkload(this.watchOutputTail)) printWorkloadHint();
+    else if (looksLikeXcodeTooOld(this.watchOutputTail)) printXcodeTooOldHint();
+    else if (looksLikeMissingXcode(this.watchOutputTail)) printXcodeHint();
+    console.log(
+      taggedRow(
+        "manual",
+        "host",
+        dim("build failed \u2014 fix the error and save to retry, or ctrl-c to stop")
+      )
+    );
+  }
+  /**
+   * `dotnet watch` exited before the app ever started — typically an SDK or
+   * MAUI workload set that predates `dotnet run`/`dotnet watch` support for
+   * this target. Explain why, then launch the host the classic way (one
+   * build + direct spawn) so the dev session still works, minus C# hot reload.
+   */
+  fallBackToClassicLaunch(code, signal) {
+    console.log();
+    console.log(
+      taggedRow(
+        "manual",
+        "host",
+        `${dim("C# hot reload unavailable \u2014 dotnet watch exited with")} ${value(
+          signal ? `signal ${signal}` : `code ${code ?? "unknown"}`
+        )}`
+      )
+    );
+    if (looksLikeMissingWorkload(this.watchOutputTail)) {
+      printWorkloadHint();
+    } else if (looksLikeXcodeTooOld(this.watchOutputTail)) {
+      printXcodeTooOldHint();
+    } else if (looksLikeMissingXcode(this.watchOutputTail)) {
+      printXcodeHint();
+    } else {
+      console.log(
+        footer(
+          dim(
+            "C# hot reload needs the .NET 10.0.203+ workload set (Mac Catalyst dotnet-watch support) \u2014 try:"
+          )
+        )
+      );
+      console.log(fixLine("dotnet workload update"));
+      if (!this.verbose) {
+        console.log(footer(dim("re-run with --verbose for the full watch log.")));
+      }
+    }
+    console.log(
+      taggedRow(
+        "active",
+        "host",
+        dim("falling back to a classic launch (frontend hot reload still active)\u2026")
+      )
+    );
+    console.log();
+    if (this.target.name === "macos") {
+      this.launchMacosHost();
+    } else {
+      this.launchWindowsHost();
+    }
+  }
+  // --- classic launch (one build + direct spawn) ------------------------------
   // Builds the MAUI host as a discrete step (a plain `dotnet build`, never
   // MSBuild's `-t:Run`) so the per-OS launch paths can spawn the produced
   // binary directly. `-t:Run` shells out in ways that break for both locally
@@ -1194,8 +1527,9 @@ var DevSession = class {
   }
   registerChild(child, tag2, label) {
     this.children.push(child);
-    prefixStream(child.stdout, tag2);
-    prefixStream(child.stderr, tag2);
+    const include = tag2 === "host" ? (line) => !line.includes(HOST_READY_SENTINEL) : void 0;
+    prefixStream(child.stdout, tag2, include);
+    prefixStream(child.stderr, tag2, include);
     child.on("exit", (code, signal) => {
       if (this.shuttingDown) return;
       if (tag2 === "ui") {
@@ -1238,8 +1572,9 @@ var DevSession = class {
     if (this.shuttingDown) return;
     this.shuttingDown = true;
     for (const child of this.children) {
-      killChild(child);
+      killChild(child, { processGroup: child === this.watchChild });
     }
+    this.endSession();
     process.exit(exitCode);
   }
 };
@@ -1257,19 +1592,32 @@ var ensureTargetMatchesHostOs = (targetName) => {
     process.exit(1);
   }
 };
-var prefixStream = (stream, tag2) => {
+var prefixStream = (stream, tag2, include = () => true) => {
   if (!stream) return;
   const prefix = streamPrefix(tag2);
   stream.on("data", (chunk) => {
     const lines = chunk.toString().split("\n");
     for (const line of lines) {
-      if (line.length > 0) {
+      if (line.length > 0 && include(line)) {
         process.stdout.write(`${prefix} ${line}
 `);
       }
     }
   });
 };
+var scanStream = (stream, onLine) => {
+  if (!stream) return;
+  let pending = "";
+  stream.on("data", (chunk) => {
+    pending += chunk.toString();
+    const lines = pending.split("\n");
+    pending = lines.pop() ?? "";
+    for (const line of lines) onLine(line);
+  });
+  stream.on("end", () => {
+    if (pending) onLine(pending);
+  });
+};
 var waitForServer = (url, timeoutMs) => {
   const { hostname, port, pathname } = new URL(url);
   const start = Date.now();
@@ -1301,14 +1649,6 @@ var waitForServer = (url, timeoutMs) => {
     poll();
   });
 };
-var waitForExit = (...children) => {
-  return new Promise((resolve) => {
-    const resolveOnce = () => resolve();
-    for (const child of children) {
-      child.once("exit", resolveOnce);
-    }
-  });
-};
 var findMacAppBundle = (hostDir, framework, buildConfig) => {
   const outputDir = path6.join(hostDir, "bin", buildConfig, framework);
   return findAppBundleRecursive(outputDir);
@@ -1362,7 +1702,7 @@ var findFileRecursive = (dir, match) => {
   }
   return null;
 };
-var killChild = (child) => {
+var killChild = (child, opts = {}) => {
   if (!child.pid || child.exitCode !== null) return;
   if (process.platform === "win32") {
     try {
@@ -1374,6 +1714,13 @@ var killChild = (child) => {
     }
     return;
   }
+  if (opts.processGroup) {
+    try {
+      process.kill(-child.pid, "SIGTERM");
+      return;
+    } catch {
+    }
+  }
   child.kill("SIGTERM");
 };
 var printMacLaunchHint = () => {
@@ -1411,7 +1758,7 @@ var printHelp = () => {
     ${lime("vidra")} ${dim("<command> [options]")}
 
   ${dim("commands")}
-${cmd("dev", "start vite + the native host (hot reload)")}
+${cmd("dev", "start vite + the native host (UI + C# hot reload)")}
 ${cmd("run", "launch the native host only")}
 ${cmd("build", "build & package for distribution")}
 ${cmd("doctor", "check your environment")}
@@ -1419,6 +1766,7 @@ ${cmd("help", "show this message")}
 
   ${dim("examples")}
 ${ex("dev --target windows", "run the windows host")}
+${ex("dev --no-hot-reload", "skip dotnet watch, classic launch")}
 ${ex("build --plan", "preview the build, run nothing")}
 ${ex("build --target macos", "build & package a macOS DMG")}
 ${ex("doctor", "verify .NET SDK + MAUI workload")}

package/dist/index.js

@@ -174,6 +174,7 @@ import { execFileSync } from "child_process";
 import prompts from "prompts";
 var DOTNET = process.platform === "win32" ? "dotnet.exe" : "dotnet";
 var MAUI_DOCS = "https://learn.microsoft.com/dotnet/maui/get-started/installation";
+var INSTALL_NET_10_FIX = "Install the .NET 10 SDK \u2014 https://dotnet.microsoft.com/download";
 var bufToStr = (v) => v == null ? "" : Buffer.isBuffer(v) ? v.toString() : v;
 var run = (cmd, args) => {
   try {
@@ -192,41 +193,37 @@ var run = (cmd, args) => {
     };
   }
 };
-var hasNet10Sdk = (listSdksOutput) => listSdksOutput.split(/\r?\n/).some((line) => /^10\./.test(line.trim()));
-var newestNet10Sdk = (listSdksOutput) => listSdksOutput.split(/\r?\n/).map((line) => line.trim().split(/\s+/)[0]).filter((v) => /^10\./.test(v)).sort(
+var splitLines = (text) => text.split(/\r?\n/);
+var NET_10_VERSION = /^10\./;
+var MAUI_WORKLOAD = /\bmaui\b/i;
+var hasNet10Sdk = (listSdksOutput) => splitLines(listSdksOutput).some((line) => NET_10_VERSION.test(line.trim()));
+var newestNet10Sdk = (listSdksOutput) => splitLines(listSdksOutput).map((line) => line.trim().split(/\s+/)[0]).filter((version) => NET_10_VERSION.test(version)).sort(
   (a, b) => a.localeCompare(b, void 0, { numeric: true, sensitivity: "base" })
 ).pop();
-var outputMentionsMaui = (workloadListOutput) => /\bmaui\b/i.test(workloadListOutput);
+var outputMentionsMaui = (workloadListOutput) => MAUI_WORKLOAD.test(workloadListOutput);
 var checkDotnetSdk = () => {
+  const name = ".NET SDK";
   const res = run(DOTNET, ["--list-sdks"]);
   if (!res.found) {
     return {
-      name: ".NET SDK",
+      name,
       status: "missing",
       detail: "`dotnet` was not found on your PATH",
-      fix: "Install the .NET 10 SDK \u2014 https://dotnet.microsoft.com/download"
+      fix: INSTALL_NET_10_FIX
     };
   }
   if (!res.ok && !res.stdout) {
-    return {
-      name: ".NET SDK",
-      status: "unknown",
-      detail: "could not run `dotnet --list-sdks`"
-    };
+    return { name, status: "unknown", detail: "could not run `dotnet --list-sdks`" };
   }
   if (hasNet10Sdk(res.stdout)) {
     const newest = newestNet10Sdk(res.stdout);
-    return {
-      name: ".NET SDK",
-      status: "ok",
-      detail: newest ? `found ${newest}` : "found 10.x"
-    };
+    return { name, status: "ok", detail: newest ? `found ${newest}` : "found 10.x" };
   }
   return {
-    name: ".NET SDK",
+    name,
     status: "missing",
     detail: "no 10.x SDK installed",
-    fix: "Install the .NET 10 SDK \u2014 https://dotnet.microsoft.com/download"
+    fix: INSTALL_NET_10_FIX
   };
 };
 var isMauiWorkloadInstalled = () => outputMentionsMaui(run(DOTNET, ["workload", "list"]).stdout);
@@ -332,7 +329,7 @@ var VIDRA_REPO_ROOT = path2.resolve(CLI_ROOT, "..", "..", "..");
 var LOCAL_FEED_DIR = path2.join(VIDRA_REPO_ROOT, "dist", "packages");
 var LOCAL_CLI_DIR = CLI_ROOT;
 var LOCAL_SDK_DIR = path2.join(VIDRA_REPO_ROOT, "src", "sdk", "vidra-js");
-var VIDRA_VERSION = "0.2.0";
+var VIDRA_VERSION = "0.2.2";
 var SDK_VERSION = "0.1.0";
 var main = async () => {
   console.log();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-vidra-app",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Scaffold a new Vidra application (React + .NET MAUI)",
   "type": "module",
   "bin": {

package/templates/react-vite/README.md

@@ -30,7 +30,22 @@ exact command to fix anything that's missing.
 npm run dev
 ```
 
-This starts the Vite dev server and launches the native host for the current OS.
+This starts the Vite dev server and launches the native host for the current OS
+under `dotnet watch`. Both sides of the app hot reload:
+
+- **UI**: edit anything in `ui/src` — Vite HMR updates the WebView instantly.
+- **C#**: edit the host (for example `OnTickAsync` in `MainPage.cs`) — supported
+  edits apply to the running app in seconds, and the UI flashes a
+  "C# reloaded" badge. Edits hot reload can't express (new fields, changed
+  signatures, …) trigger an automatic rebuild and relaunch.
+
+C# hot reload needs a recent toolchain (on macOS, the .NET 10.0.203+ workload
+set — run `npm run doctor` to check). When unavailable, `vidra dev` falls back
+to a one-shot build and launch. To skip `dotnet watch` explicitly:
+
+```bash
+npx vidra dev --no-hot-reload
+```
 
 To target a specific desktop platform explicitly:
 

package/templates/react-vite/src/{{projectName}}.Host/MainPage.cs

@@ -14,15 +14,20 @@ public class MainPage : VidraPage
         using var timer = new PeriodicTimer(TimeSpan.FromSeconds(10));
         while (await timer.WaitForNextTickAsync())
         {
-            try
-            {
-                var count = await Bridge.CallJsAsync<int>("counter.increment");
-                System.Diagnostics.Debug.WriteLine($"[MainPage] Counter is now {count}");
-            }
-            catch (Exception ex)
-            {
-                System.Diagnostics.Debug.WriteLine($"[MainPage] Counter increment failed: {ex.Message}");
-            }
+            await OnTickAsync();
+        }
+    }
+
+    private async Task OnTickAsync()
+    {
+        try
+        {
+            var count = await Bridge.CallJsAsync<int>("counter.increment");
+            System.Diagnostics.Debug.WriteLine($"[MainPage] Counter is now {count}");
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"[MainPage] Counter increment failed: {ex.Message}");
         }
     }
 }

package/templates/react-vite/ui/src/App.tsx

@@ -19,7 +19,9 @@ const App = () => {
   const [windowSupport, setWindowSupport] = useState<WindowSupport | null>(null);
   const [caps, setCaps] = useState<Record<string, string[]> | null>(null);
   const [count, setCount] = useState(0);
+  const [csReloaded, setCsReloaded] = useState<string | null>(null);
   const countRef = useRef(0);
+  const reloadFlashTimer = useRef<number | undefined>(undefined);
 
   useEffect(() => {
     const unsubscribeCounter = vidra.handle<void, number>("counter.increment", () => {
@@ -28,6 +30,20 @@ const App = () => {
       return countRef.current;
     });
 
+    // Emitted by the native host when `vidra dev` hot reloads edited C#.
+    const unsubscribeHotReloaded = vidra.on<{ updatedTypes?: string[] }>(
+      "vidra.hotReloaded",
+      (data) => {
+        const typeName = data?.updatedTypes?.[0]?.split(".").pop();
+        setCsReloaded(typeName ? `C# reloaded · ${typeName}` : "C# reloaded");
+        window.clearTimeout(reloadFlashTimer.current);
+        reloadFlashTimer.current = window.setTimeout(
+          () => setCsReloaded(null),
+          2500,
+        );
+      },
+    );
+
     const unsubscribeResized = appWindow.onResized((windowInfo) => {
       setWindowSummary(`Window resized: ${describeWindow(windowInfo)}`);
     });
@@ -47,8 +63,10 @@ const App = () => {
 
     return () => {
       unsubscribeCounter();
+      unsubscribeHotReloaded();
       unsubscribeResized();
       unsubscribeStateChanged();
+      window.clearTimeout(reloadFlashTimer.current);
     };
   }, []);
 
@@ -200,6 +218,12 @@ const App = () => {
             <span className="dot" />
             React + .NET MAUI
           </span>
+          {csReloaded && (
+            <span className="badge reload-badge">
+              <span className="dot" />
+              {csReloaded}
+            </span>
+          )}
           <h1 className="title">{{appTitle}}</h1>
           <p className="tagline">
             A cross-platform desktop app with a native bridge.

package/templates/react-vite/ui/src/index.css

@@ -146,6 +146,22 @@ body::before {
   box-shadow: 0 0 0 3px var(--dot-glow);
 }
 
+/* Flashes when the native host hot reloads edited C# (vidra.hotReloaded). */
+.reload-badge {
+  margin-left: 0.5rem;
+  color: var(--accent);
+  background: var(--accent-soft);
+  border-color: var(--accent-border);
+  animation: reload-pop 0.25s cubic-bezier(0.2, 0.7, 0.2, 1) both;
+}
+
+@keyframes reload-pop {
+  from {
+    opacity: 0;
+    transform: scale(0.9);
+  }
+}
+
 .title {
   margin-top: 1.1rem;
   font-size: clamp(2.4rem, 6vw, 3.4rem);