beatrina 0.9.83 → 1.0.1

package/beatrina_V1.0.1.html.inputs.json

@@ -0,0 +1 @@
+{"schema":1,"sources":"bb6f92def208844cdcdae81c15aa6b467805474f5af7643329a02082f7832f82","artifact":"09e3f48d132de6ca4045edb229ca8e00f44bda89ff95dcab69ed5b7790da6092"}

package/bin/beatrina.mjs

@@ -111,7 +111,13 @@ if (args.command === "python") {
   process.exit(0);
 }
 
-const rscript = detectRscript(process.env.BEATRINA_RSCRIPT || "");
+// R is OPTIONAL (plans/getting_rid_of_R.md): with none, Beatrina opens, edits, saves and recovers,
+// and an R chunk says why it cannot run. BEATRINA_NO_R=1 is the host's own switch, honoured here so
+// the command and the host agree on whether there is an R.
+const { readEnv } = await import("../host/env-names.mjs");
+const rscript = readEnv(process.env, "NO_R") === "1" ? "" : detectRscript(process.env.BEATRINA_RSCRIPT || "");
+const R_ABSENT = "not found — optional: documents open, edit, save and recover; R chunks say why they cannot run. "
+  + "Install R from https://cran.r-project.org to run them.";
 
 if (args.command === "doctor") {
   const rows = [["Beatrina", `${pkg.version} (${root})`], ["Node.js", `${process.version} at ${process.execPath}`]];
@@ -126,7 +132,13 @@ if (args.command === "doctor") {
         : compareVersions(latest, pkg.version) > 0 ? `Beatrina ${latest} is available (this is ${pkg.version}) — run: beatrina upgrade`
           : `${pkg.version} is the newest`]);
   }
-  if (!rscript) rows.push(["R", "NOT FOUND — install R from https://cran.r-project.org"]);
+  // The HOST is the floor: this Node, this package's host and page. R is one engine among three.
+  const [nodeMajor] = process.versions.node.split(".").map(Number);
+  const hostFile = path.join(root, "host", "main.mjs");
+  const hostProblem = nodeMajor < 22 ? `Node ${process.version} is too old — Beatrina needs Node 22 or newer`
+    : !fs.existsSync(hostFile) ? `this package has no host (${hostFile})` : "";
+  rows.splice(2, 0, ["Host", hostProblem ? `NOT USABLE — ${hostProblem}` : "ready — documents open, edit, save and recover with or without R"]);
+  if (!rscript) rows.push(["R (optional)", process.env.BEATRINA_NO_R === "1" ? "switched off (BEATRINA_NO_R=1)" : R_ABSENT]);
   else {
     rows.push(["R", rscript]);
     let missing = [];
@@ -147,7 +159,7 @@ if (args.command === "doctor") {
     rows.push(["Sessions", sessionsRow(await listSessions(), pkg.version)]);
   }
   if (process.platform === "darwin") {
-    // What Finder does with a .qmd, .Rmd, .carmd, and which Beatrina.app copies Launch Services
+    // What Finder does with a .qmd, .Rmd, .carmd, and which Beatrina Note.app copies Launch Services
     // knows — asked of Launch Services itself (finder.mjs); "not checked" without a Swift toolchain.
     const { finderRows, lsQuery } = await import("./finder.mjs");
     const { BUNDLE_ID, DOC_TYPES } = await import("./shortcut.mjs");
@@ -159,12 +171,15 @@ if (args.command === "doctor") {
   rows.push(["node-pty (optional)", pty]);
   const width = Math.max(...rows.map((r) => r[0].length));
   for (const [k, v] of rows) console.log(`${k.padEnd(width)}  ${v}`);
-  process.exit(rscript ? 0 : 1);
+  // Healthy means the HOST is usable; no R is a healthy state (K13).
+  process.exit(hostProblem ? 1 : 0);
 }
 
 if (args.command === "check") {
   // The acceptance check (tools/beatrina/acceptance.mjs, staged as check/) against THIS package's host.
-  if (!rscript) fail("the check needs R and none was found. Install R from https://cran.r-project.org.");
+  // With no R the check runs its no-R lane: the host, the document and the other engines are
+  // judged, and every R area is reported SKIP with the reason (tools/beatrina/acceptance.mjs).
+  if (!rscript) console.error("beatrina: no R here — running the no-R acceptance lane; R areas are skipped, not passed.");
   const os = await import("node:os");
   const { spawn } = await import("node:child_process");
   const scratch = fs.mkdtempSync(path.join(os.tmpdir(), "beatrina-check-"));
@@ -172,7 +187,7 @@ if (args.command === "check") {
   const junit = process.env.BEATRINA_CHECK_JUNIT || path.join(scratch, "acceptance.xml");
   const code = await new Promise((resolve) => {
     const child = spawn(process.execPath, [path.join(root, "kernel", "check", "acceptance.mjs"), `--host=${path.join(root, "host", "main.mjs")}`, `--junit=${junit}`],
-      { stdio: "inherit", env: { ...process.env, BEATRINA_RSCRIPT: rscript } });
+      { stdio: "inherit", env: { ...process.env, ...(rscript ? { BEATRINA_RSCRIPT: rscript } : { BEATRINA_NO_R: "1" }) } });
     child.on("exit", (c) => resolve(c ?? 1));
     child.on("error", () => resolve(1));
   });
@@ -183,7 +198,7 @@ if (args.command === "check") {
     let build = { version: pkg.version, commit: "", dirty: false };
     try { build = { ...build, ...JSON.parse(fs.readFileSync(path.join(root, "build-info.json"), "utf8")) }; } catch { /* a package without one */ }
     try {
-      const sent = await postJunitRun({ url, token, xml: fs.readFileSync(junit), body: runBody({ build, rVersion: rVersionOf(rscript), label: `beatrina check on ${process.platform}` }) });
+      const sent = await postJunitRun({ url, token, xml: fs.readFileSync(junit), body: runBody({ build, rVersion: rscript ? rVersionOf(rscript) : "", label: `beatrina check on ${process.platform}${rscript ? "" : " (no R)"}` }) });
       console.log(`Sent to Prova: run ${sent.runId} — pass ${sent.counts?.pass ?? "?"} fail ${sent.counts?.fail ?? "?"} skip ${sent.counts?.skip ?? "?"} → ${sent.url}`);
     } catch (e) { console.error(`beatrina: the results were not sent to Prova: ${e.message}`); }
   } else if (url || token) console.error("beatrina: to send results to Prova give both --prova <url> and --token <token>.");
@@ -191,6 +206,141 @@ if (args.command === "check") {
   process.exit(code);
 }
 
+if (args.command === "app") {
+  // Beatrina (desktop/tauri): Beatrina in a window of its own. It ships INSIDE this package (app/),
+  // so no Rust and no download; npm does not quarantine what it installs, so an unsigned build opens
+  // without a Gatekeeper refusal. It records WHICH Node and WHICH Beatrina to start (appRecordFile),
+  // because an app started from Finder or a desktop menu has no shell PATH to find either with.
+  const os = await import("node:os");
+  const { spawn, spawnSync } = await import("node:child_process");
+  const home = os.homedir();
+  const record = (file) => {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify({ node: process.execPath, root, version: pkg.version })}\n`);
+  };
+  if (process.platform === "darwin") {
+    // The app's own bundle id (desktop/tauri tauri.conf.json) — not Beatrina Note's.
+    const APP_BUNDLE_ID = "me.saqr.beatrina.desktop";
+    const source = path.join(root, "app", "Beatrina.app");
+    if (!fs.existsSync(source)) fail("this Beatrina package does not carry Beatrina. `beatrina` opens the notebook in your browser instead.");
+    const target = path.join(home, "Applications", "Beatrina.app");
+    const support = path.join(home, "Library", "Application Support", "Beatrina");
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.mkdirSync(support, { recursive: true });
+    // TWO apps carry the name on a Mac: Beatrina (this window) and Beatrina Note (the older door
+    // that opens the notebook in the browser — upgrade:local, `beatrina shortcut`). The door used to
+    // be ~/Applications/Beatrina.app; it is MOVED to "Beatrina Note.app", never overwritten or deleted.
+    // They are told apart by their executable, not their bundle id: this window's is "beatrina"
+    // (earlier builds "beatrina-app"); anything else there is a door — upgrade:local's ("Beatrina")
+    // or an older `beatrina shortcut` applet ("applet").
+    const executableOf = (app) => {
+      const r = spawnSync("/usr/libexec/PlistBuddy", ["-c", "Print :CFBundleExecutable", path.join(app, "Contents", "Info.plist")], { encoding: "utf8" });
+      return r.status === 0 ? r.stdout.trim() : "";
+    };
+    const keep = (app, name) => {
+      const kept = path.join(support, name);
+      fs.rmSync(kept, { recursive: true, force: true });
+      fs.renameSync(app, kept);
+    };
+    if (fs.existsSync(target) && !["beatrina", "beatrina-app"].includes(executableOf(target))) {
+      const web = path.join(home, "Applications", "Beatrina Note.app");
+      if (!fs.existsSync(web)) { fs.renameSync(target, web); console.log(`Moved the browser door to ${web}`); }
+      else keep(target, "Beatrina Note.duplicate.app");   // a second door: one is enough in ~/Applications
+    }
+    // This window under its first name (BeatrinaApp.app, 2026-09-23..24) goes: one generation is kept.
+    const legacy = path.join(home, "Applications", "BeatrinaApp.app");
+    if (fs.existsSync(legacy)) keep(legacy, "Beatrina.previous.app");
+    // The one it replaces is kept (one generation), outside ~/Applications so Finder shows one app.
+    if (fs.existsSync(target)) keep(target, "Beatrina.previous.app");
+    const copied = spawnSync("ditto", [source, target]);
+    if (copied.status !== 0) fail(`Beatrina could not be installed into ${target}.`);
+    record(path.join(support, "app.json"));
+    // Registered, and made the DEFAULT for the notebook documents: the app is the main way to
+    // open them (owner, 2026-09-24: "the app reigns overall"); Beatrina Note stays on right-click
+    // ▸ Open With. Running `beatrina app` is the choice, so it is not asked again. Read back from
+    // Launch Services when there is a Swift toolchain to ask with, never inferred.
+    // BEATRINA_NO_REGISTER=1 keeps a test's scratch copy out of Launch Services — its defaults are
+    // per user, not per HOME, and a test must never change the real ones.
+    console.log(`Installed Beatrina ${pkg.version} → ${target}`);
+    if (readEnv(process.env, "NO_REGISTER") !== "1") {
+      spawnSync("/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister", ["-f", target]);
+      const { DOC_TYPES, setDefaultHandler } = await import("./shortcut.mjs");
+      const set = setDefaultHandler(DOC_TYPES, APP_BUNDLE_ID);
+      const exts = DOC_TYPES.map((t) => t.ext);
+      const { defaultFor, lsQuery } = await import("./finder.mjs");
+      const after = lsQuery({ exts, bundleIds: [APP_BUNDLE_ID] });
+      const now = after ? defaultFor(after, APP_BUNDLE_ID, exts) : null;
+      if (set.failed) console.log(`Beatrina could not be made the default for every notebook type (${set.out}).`);
+      else if (!now) console.log(`Finder opens ${exts.map((e) => `.${e}`).join(", ")} with Beatrina (not read back: no Swift toolchain).`);
+      else console.log(`Finder opens ${now.map((e) => `.${e}`).join(", ")} with Beatrina${now.length < exts.length ? ` — not yet ${exts.filter((e) => !now.includes(e)).map((e) => `.${e}`).join(", ")}` : ""}.`);
+    }
+    if (args.open) spawnSync("open", [target]);
+    process.exit(0);
+  }
+  if (process.platform === "linux") {
+    // One binary per architecture (app/linux-<arch>/beatrina), a desktop entry so the
+    // applications menu and "Open With" know it, and the record under XDG config — the
+    // path desktop/tauri/src-tauri/src/main.rs reads (record_file).
+    const source = path.join(root, "app", `linux-${process.arch}`, "beatrina");
+    if (!fs.existsSync(source)) fail(`this Beatrina package carries no Beatrina for linux-${process.arch}. \`beatrina\` opens the notebook in your browser, and the browser can install it as an app.`);
+    const xdg = (name, fallback) => (process.env[name] && path.isAbsolute(process.env[name]) ? process.env[name] : path.join(home, fallback));
+    const binary = path.join(xdg("XDG_DATA_HOME", ".local/share"), "beatrina", "beatrina");
+    fs.mkdirSync(path.dirname(binary), { recursive: true });
+    const staged = `${binary}.new`;
+    fs.copyFileSync(source, staged);
+    fs.chmodSync(staged, 0o755);
+    if (fs.existsSync(binary)) fs.renameSync(binary, `${binary}.previous`);
+    fs.renameSync(staged, binary);
+    const icon = path.join(root, "app", "beatrina.png");
+    const iconTarget = path.join(path.dirname(binary), "beatrina.png");
+    if (fs.existsSync(icon)) fs.copyFileSync(icon, iconTarget);
+    const apps = path.join(xdg("XDG_DATA_HOME", ".local/share"), "applications");
+    fs.mkdirSync(apps, { recursive: true });
+    const entry = path.join(apps, "beatrina.desktop");
+    fs.writeFileSync(entry, [
+      "[Desktop Entry]", "Type=Application", "Name=Beatrina", "Comment=Beatrina in a window of its own",
+      `Exec="${binary}" %f`, ...(fs.existsSync(iconTarget) ? [`Icon=${iconTarget}`] : []), "Terminal=false",
+      "Categories=Office;Education;", "MimeType=text/markdown;text/x-quarto;text/x-r-markdown;", "",
+    ].join("\n"));
+    record(path.join(xdg("XDG_CONFIG_HOME", ".config"), "beatrina", "app.json"));
+    // The first build installed as "beatrina-app" (2026-09-24, one night): its files go, so the
+    // menu shows one Beatrina.
+    fs.rmSync(path.join(xdg("XDG_DATA_HOME", ".local/share"), "beatrina-app"), { recursive: true, force: true });
+    fs.rmSync(path.join(apps, "beatrina-app.desktop"), { force: true });
+    spawnSync("update-desktop-database", [apps], { stdio: "ignore" });
+    // The window's engine is the system's WebKitGTK; say so plainly if it is missing, rather
+    // than let the first launch die with a loader error nobody can read.
+    const ldd = spawnSync("ldd", [binary], { encoding: "utf8" });
+    const lacking = String(ldd.stdout || "").split("\n").filter((l) => /not found/.test(l)).map((l) => l.trim().split(" ")[0]);
+    console.log(`Installed Beatrina ${pkg.version} → ${binary}`);
+    if (lacking.length) {
+      console.log(`It needs libraries this system does not have: ${lacking.join(", ")}.`);
+      console.log("On Debian/Ubuntu: sudo apt install libwebkit2gtk-4.1-0 — then run `beatrina app` again.");
+      process.exit(1);
+    }
+    if (args.open) spawn(binary, [], { detached: true, stdio: "ignore" }).unref();
+    process.exit(0);
+  }
+  if (process.platform === "win32" && process.arch === "x64") {
+    // The package carries Tauri's NSIS installer (app/win-x64/Beatrina-setup.exe). Run silently
+    // (/S) it installs for this user only, with no administrator prompt, into
+    // %LOCALAPPDATA%\Beatrina, with a Start menu entry and the .qmd/.Rmd/.carmd associations;
+    // the record goes where the app reads it (%APPDATA%\Beatrina\app.json — main.rs record_file).
+    const setup = path.join(root, "app", "win-x64", "Beatrina-setup.exe");
+    if (!fs.existsSync(setup)) fail("this Beatrina package does not carry Beatrina for Windows. `beatrina` opens the notebook in your browser, and the browser can install it as an app.");
+    const localAppData = process.env.LOCALAPPDATA || path.join(home, "AppData", "Local");
+    const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+    const installed = path.join(localAppData, "Beatrina", "beatrina.exe");
+    const ran = spawnSync(setup, ["/S"], { stdio: "ignore", windowsHide: true });
+    if (ran.status !== 0 || !fs.existsSync(installed)) fail(`the Beatrina installer did not finish (exit ${ran.status}); run it by hand: ${setup}`);
+    record(path.join(appData, "Beatrina", "app.json"));
+    console.log(`Installed Beatrina ${pkg.version} → ${installed}`);
+    if (args.open) spawn(installed, [], { detached: true, stdio: "ignore" }).unref();
+    process.exit(0);
+  }
+  fail("Beatrina is not available for this system yet. `beatrina` opens the notebook in your browser, and the browser can install it as an app (Install / Add to Dock).");
+}
+
 if (args.command === "shortcut") {
   const { makeShortcut, removeMenu } = await import("./shortcut.mjs");
   try {
@@ -240,7 +390,6 @@ if (args.fromApp) {
     if (delivered === "refused") alert(`The running Beatrina session could not open ${file}.`);
     process.exit(0);
   }
-  if (!rscript) { alert("Beatrina needs R. Install R from https://cran.r-project.org, then open Beatrina again."); process.exit(1); }
   // The session starts DETACHED (it must outlive this process), but this
   // process no longer exits the moment it has spawned it: it waits, bounded,
   // for the session's own announcement, and a child that dies first is SAID
@@ -277,9 +426,46 @@ if (args.fromApp) {
   process.exit(1);
 }
 
-if (!rscript) fail("Beatrina needs R and none was found. Install R from https://cran.r-project.org, or set BEATRINA_RSCRIPT to your Rscript.");
-let missing;
-try { missing = missingRPackages(rscript); } catch (e) { fail(e.message); }
+// BEATRINA, THE APP, WHEN IT IS INSTALLED (owner, 2026-09-24: "the app reigns overall"). A person
+// typing `beatrina [file]` gets the window, which starts and supervises its own session; the
+// browser is `beatrina --browser`. Only when a PERSON asked — an interactive terminal — and never
+// when the command line asks for the session itself (--port, --no-open): a script or a test that
+// runs `beatrina` wants the session it asked for, not a window. BEATRINA_NO_APP=1 turns it off.
+{
+  const os = await import("node:os");
+  const home = os.homedir();
+  const xdgData = process.env.XDG_DATA_HOME && path.isAbsolute(process.env.XDG_DATA_HOME) ? process.env.XDG_DATA_HOME : path.join(home, ".local", "share");
+  const installedApp = () => {
+    if (process.platform === "darwin") {
+      const app = path.join(home, "Applications", "Beatrina.app");
+      return fs.existsSync(path.join(app, "Contents", "MacOS", "beatrina")) ? app : "";
+    }
+    if (process.platform === "linux") { const bin = path.join(xdgData, "beatrina", "beatrina"); return fs.existsSync(bin) ? bin : ""; }
+    if (process.platform === "win32") {
+      const exe = path.join(process.env.LOCALAPPDATA || path.join(home, "AppData", "Local"), "Beatrina", "beatrina.exe");
+      return fs.existsSync(exe) ? exe : "";
+    }
+    return "";
+  };
+  const person = Boolean(process.stdout.isTTY) && readEnv(process.env, "NO_APP") !== "1";
+  const app = person && args.open && !args.browser && !args.port ? installedApp() : "";
+  const file = args.file ? path.resolve(args.file) : "";
+  if (app && (!file || fs.existsSync(file))) {
+    const { spawn, spawnSync } = await import("node:child_process");
+    if (process.platform === "darwin") {
+      const r = spawnSync("open", ["-a", app, ...(file ? [file] : [])], { stdio: "inherit" });
+      if (r.status !== 0) fail(`Beatrina (the app) did not open — try: beatrina --browser${file ? ` "${args.file}"` : ""}`);
+    } else {
+      spawn(app, file ? [file] : [], { detached: true, stdio: "ignore" }).unref();
+    }
+    console.log(`Opened ${file ? path.basename(file) : "Beatrina"} in Beatrina. For the browser instead: beatrina --browser${file ? ` "${args.file}"` : ""}`);
+    process.exit(0);
+  }
+}
+
+if (!rscript) console.error(`beatrina: R ${process.env.BEATRINA_NO_R === "1" ? "is switched off (BEATRINA_NO_R=1): documents open, edit, save and recover; R chunks say why they cannot run." : R_ABSENT}`);
+let missing = [];
+if (rscript) { try { missing = missingRPackages(rscript); } catch (e) { fail(e.message); } }
 if (missing.length) {
   const yes = args.yes || process.env.BEATRIX_YES === "1" ? true
     : await ask(`R is missing ${missing.join(", ")}, which Beatrina needs. Install from CRAN now?`);
@@ -307,7 +493,7 @@ if (!process.env.BEATRIX_APP_ID) {
   const { listSessions } = await import("./sessions.mjs");
   await pruneKeptPages(await listSessions());
 }
-process.env.BEATRINA_RSCRIPT = rscript;
+if (rscript) process.env.BEATRINA_RSCRIPT = rscript;
 if (args.port) process.env.BEATRINA_PORT = args.port;
 else process.env.BEATRINA_PORT ||= "4848";
 if (args.file) {
@@ -332,6 +518,8 @@ let started = forced
 if (started.announced) followChild(started.child);
 else {
   if (started.refused) process.exit(started.code ?? 2);
+  // The failsafe is the R supervisor, so with no R there is none: say why the host did not start.
+  if (!rscript) fail(`Beatrina could not start: ${started.reason}.`);
   // The failsafe: the R supervisor, with the reason said here and on the page.
   console.error(`beatrina: ${started.reason}. Starting the R supervisor instead (failsafe mode).`);
   let needed;

package/bin/cli.mjs

@@ -8,7 +8,9 @@ export const REQUIRED_R_PACKAGES = Object.freeze(["jsonlite", "knitr", "evaluate
 
 export const USAGE = `beatrina — R, Python and JavaScript notebooks on your own computer
 
-  beatrina [file]     start a session and open the notebook (Ctrl+C stops it)
+  beatrina [file]     open the notebook in Beatrina, the app, when it is installed (\`beatrina app\`);
+                      otherwise start a session and open it in the browser (Ctrl+C stops it).
+                      --browser: the browser even when the app is installed
   beatrina status     list running sessions: port, process, uptime, document (--json for scripts and the menu)
   beatrina stop       stop the running session (--port <n> for one of several, --all for every one)
   beatrina doctor     show what Beatrina found: Node, R, R packages, Python, and whether npm has a newer Beatrina
@@ -17,6 +19,8 @@ export const USAGE = `beatrina — R, Python and JavaScript notebooks on your ow
                       environment with ipykernel, pandas and matplotlib; --minimal installs ipykernel only)
   beatrina check      run the acceptance check on this machine (a private session on a spare port);
                       --prova <url> --token <t> (or PROVA_URL / PROVA_TOKEN) sends the results to Prova
+  beatrina app        install Beatrina — Beatrina in a window of its own, no browser — and open it
+                      (--no-open installs only). macOS, Linux and Windows (x64).
   beatrina shortcut   add a Beatrina icon, and "Open With ▸ Beatrina" for .qmd and .Rmd files
                       (--default also makes it the default app for them; safe to run again — it repairs
                       a second registered copy). On macOS, --menu also installs the Beatrina menu-bar
@@ -41,18 +45,19 @@ export const USAGE = `beatrina — R, Python and JavaScript notebooks on your ow
                       running session, or start one in the background (--new: start another regardless)
   --version, --help`;
 
-export const COMMANDS = Object.freeze(["doctor", "shortcut", "status", "stop", "check", "upgrade", "python", "knit"]);
+export const COMMANDS = Object.freeze(["doctor", "shortcut", "status", "stop", "check", "upgrade", "python", "knit", "app"]);
 /** What `beatrina python` can be asked to do. */
 export const PYTHON_VERBS = Object.freeze(["setup"]);
 
 /** Parse the command line. */
 export function parseArgs(argv) {
-  const out = { command: "run", file: "", port: "", open: true, yes: false, help: false, version: false, fromApp: false, makeDefault: false, dir: "", all: false, prova: "", token: "", json: false, new: false, menu: false, noMenu: false, login: false, run: true, echo: true, out: "", width: "" };
+  const out = { command: "run", file: "", port: "", open: true, browser: false, yes: false, help: false, version: false, fromApp: false, makeDefault: false, dir: "", all: false, prova: "", token: "", json: false, new: false, menu: false, noMenu: false, login: false, run: true, echo: true, out: "", width: "" };
   for (let i = 0; i < argv.length; i += 1) {
     const a = argv[i];
     if (a === "--help" || a === "-h") out.help = true;
     else if (a === "--version" || a === "-v") out.version = true;
     else if (a === "--no-open") out.open = false;
+    else if (a === "--browser") out.browser = true;
     else if (a === "--no-run") out.run = false;
     else if (a === "--no-echo") out.echo = false;
     else if (a === "--out") out.out = argv[++i] || "";

package/bin/finder.mjs

@@ -56,7 +56,7 @@ export const defaultFor = (answer, bundleId, exts) => (answer ? exts.filter((e)
  * one), then the app's registered copies (one path, or the copies to repair with `beatrina shortcut`).
  * @returns {[string, string][]}
  */
-export function finderRows(answer, { bundleId, exts, appName = "Beatrina" }) {
+export function finderRows(answer, { bundleId, exts, appName = "Beatrina Note" }) {
   if (!answer) return [...exts.map((e) => [`Finder opens .${e}`, NO_TOOLCHAIN]), [`${appName}.app`, NO_TOOLCHAIN]];
   const rows = exts.map((e) => {
     const row = answer.ext.find((x) => x.ext === e);

package/bin/shortcut.mjs

@@ -2,7 +2,7 @@
 //
 // After `npm install -g beatrina`, one `beatrina shortcut` makes Beatrina an
 // ordinary desktop app:
-//   · macOS  — ~/Applications/Beatrina.app (an AppleScript applet: no terminal
+//   · macOS  — ~/Applications/Beatrina Note.app (an AppleScript applet: no terminal
 //     window), declaring .qmd and .Rmd so Finder's "Open With" offers it, and
 //     registered with Launch Services;
 //   · Windows — a Start-menu shortcut and "Open with" entries for .qmd/.Rmd under
@@ -25,7 +25,7 @@ import { defaultFor, lsQuery, registeredPaths } from "./finder.mjs";
 
 export const BUNDLE_ID = "me.saqr.beatrina";
 // beatrina-names: keep-start — the other product's identities, reclaimed from, are named here on purpose.
-// Each type is EXPORTED by Beatrina.app as its own UTI (UTExportedTypeDeclarations) and named in its
+// Each type is EXPORTED by Beatrina Note.app as its own UTI (UTExportedTypeDeclarations) and named in its
 // document types (LSItemContentTypes): Launch Services sets a default handler per UTI, and an app that
 // only lists an extension has no UTI of its own to be the default FOR — the first --default answered
 // -50 (paramErr) for exactly that reason, and .qmd stayed with the app that had declared it (CarmaR).
@@ -90,7 +90,7 @@ export function documentTypesXml() {
     + `<key>CFBundleTypeExtensions</key>${extensionsXml(t)}</dict>`).join("")}</array>`;
 }
 
-/** The UTIs Beatrina.app exports for those types (UTExportedTypeDeclarations), as plutil-insertable XML. */
+/** The UTIs Beatrina Note.app exports for those types (UTExportedTypeDeclarations), as plutil-insertable XML. */
 export function exportedTypesXml() {
   return `<array>${DOC_TYPES.map((t) => `<dict><key>UTTypeIdentifier</key><string>${t.uti}</string>`
     + `<key>UTTypeDescription</key><string>${t.name}</string>`
@@ -143,7 +143,7 @@ export function unregisterCopy(stale, resolveTo, { lsregister = LSREGISTER } = {
 }
 
 /** Point every UTI a type can carry at `bundleId` (the JXA bridge is the only writer; 0 is success). */
-function setDefaultHandler(types, bundleId) {
+export function setDefaultHandler(types, bundleId) {
   // Beatrina's own UTI for each type, CarmaR's legacy one, and whatever UTI Launch Services currently   (beatrina-names: keep)
   // resolves the extension to (another app's declaration, or a dynamic one) — all pointed at Beatrina,
   // so a .qmd opens here whichever identity the system had attached to it.
@@ -157,7 +157,7 @@ function setDefaultHandler(types, bundleId) {
 }
 
 function macShortcut({ cli, dir, port, makeDefault, noOpen, bundleId }) {
-  const app = path.join(dir || path.join(os.homedir(), "Applications"), "Beatrina.app");
+  const app = path.join(dir || path.join(os.homedir(), "Applications"), "Beatrina Note.app");
   const exts = DOC_TYPES.map((t) => t.ext);
   // Before anything changes: what Finder does today (finder.mjs, read-only) — which extensions
   // Beatrina is already the default for, so a rebuild puts that choice back rather than losing it,
@@ -166,30 +166,30 @@ function macShortcut({ cli, dir, port, makeDefault, noOpen, bundleId }) {
   const wasDefault = DOC_TYPES.filter((t) => defaultFor(before, bundleId, [t.ext]).length);
   fs.mkdirSync(path.dirname(app), { recursive: true });
   fs.rmSync(app, { recursive: true, force: true });
-  const src = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "beatrina-app-")), "Beatrina.applescript");
+  const src = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "beatrina-app-")), "Beatrina Note.applescript");
   fs.writeFileSync(src, appleScriptSource(launchCommand({ cli, port, noOpen })));
   run("osacompile", ["-o", app, src]);
   const plist = path.join(app, "Contents", "Info.plist");
   run("plutil", ["-replace", "CFBundleIdentifier", "-string", bundleId, plist]);
-  run("plutil", ["-replace", "CFBundleName", "-string", "Beatrina", plist]);
+  run("plutil", ["-replace", "CFBundleName", "-string", "Beatrina Note", plist]);
   run("plutil", ["-replace", "CFBundleDocumentTypes", "-xml", documentTypesXml(), plist]);
   run("plutil", ["-replace", "UTExportedTypeDeclarations", "-xml", exportedTypesXml(), plist]);
   run("plutil", ["-replace", "CFBundleURLTypes", "-xml", urlTypesXml(), plist]);
   run("codesign", ["--force", "--sign", "-", app]);        // the plist changed after osacompile signed it
   const said = [];
   // Idempotent: every OTHER copy registered under this id is unregistered before this one is
-  // registered. Launch Services picks between copies at its own discretion — an older Beatrina.app
+  // registered. Launch Services picks between copies at its own discretion — an older Beatrina Note.app
   // dragged somewhere, a scratch build a killed test left behind, a folder that no longer exists —
   // so which copy a double-click reaches is its choice until there is one.
   if (fs.existsSync(LSREGISTER)) {
     for (const stale of registeredPaths(before, bundleId).filter((p) => path.resolve(p) !== path.resolve(app))) {
       const done = unregisterCopy(stale, app);
-      said.push(done.ok ? `Unregistered another copy of Beatrina.app at ${stale}${done.gone ? " (a folder that no longer exists)" : ""}.`
-        : `Could not unregister the copy of Beatrina.app at ${stale} (${done.detail}); Finder may still pick it.`);
+      said.push(done.ok ? `Unregistered another copy of Beatrina Note.app at ${stale}${done.gone ? " (a folder that no longer exists)" : ""}.`
+        : `Could not unregister the copy of Beatrina Note.app at ${stale} (${done.detail}); Finder may still pick it.`);
     }
     run(LSREGISTER, ["-f", app]);
   }
-  said.push(`Beatrina.app is in ${path.dirname(app)}. Double-click it, or right-click a .qmd and choose Open With ▸ Beatrina.`);
+  said.push(`Beatrina Note.app is in ${path.dirname(app)}. Double-click it, or right-click a .qmd and choose Open With ▸ Beatrina Note.`);
   // The default: every type with --default; otherwise only the types Beatrina was already the
   // default for (a rebuild is not a choice — "never by surprise"), re-asserted because a fresh
   // registration can lose it.
@@ -254,7 +254,7 @@ function linuxShortcut({ cli, port, makeDefault }) {
 // ── the menu (docs/launch-menu-plan.md M2) ──────────────────────────────────
 // `Beatrina Menu.app` ships in the npm package at menu/ (tools/app/build-helper.sh --product
 // beatrina; a binary and an Info.plist, nothing of its own inside). `beatrina shortcut --menu`
-// copies it beside Beatrina.app, writes the exact command line the applet bakes to
+// copies it beside Beatrina Note.app, writes the exact command line the applet bakes to
 // Contents/Resources/beatrina-command (an absolute Node and CLI path: a menu-bar process has no
 // PATH), registers it and opens it; --login adds a LaunchAgent with RunAtLoad and NO KeepAlive (a
 // menu, not a daemon — helper-agent.sh's "additive and explicit" rule); --no-menu removes both.
@@ -323,7 +323,7 @@ function installMenu({ cli, dir, login, noOpen, menuSource }) {
 
 /**
  * `beatrina shortcut --no-menu`: the login agent, the running menu and the bundle, gone. Nothing
- * else changes — Beatrina.app, the file types and the sessions are untouched.
+ * else changes — Beatrina Note.app, the file types and the sessions are untouched.
  */
 export function removeMenu({ dir = "", platform = process.platform } = {}) {
   if (platform !== "darwin") return { said: ["The menu-bar item is macOS only; nothing to remove."] };
@@ -339,13 +339,13 @@ export function removeMenu({ dir = "", platform = process.platform } = {}) {
     said.push(`Removed ${menuApp}.`);
   }
   if (!said.length) said.push("No Beatrina menu was installed; nothing to remove.");
-  said.push("Beatrina.app, the file types and any running session are as they were.");
+  said.push("Beatrina Note.app, the file types and any running session are as they were.");
   return { said };
 }
 
 /**
  * Make the icon (and, with makeDefault, the default .qmd app; with menu, the menu-bar item).
- * BEATRINA_BUNDLE_ID substitutes the bundle id (the suites build a scratch Beatrina.app under a
+ * BEATRINA_BUNDLE_ID substitutes the bundle id (the suites build a scratch Beatrina Note.app under a
  * scratch id, so the one in ~/Applications is never a second copy of theirs).
  */
 export function makeShortcut({ cli, dir = "", port = "", makeDefault = false, noOpen = false, platform = process.platform,

package/build-info.json

@@ -1 +1 @@
-{"version":"0.9.83","commit":"9d7ed5ae63cb367b7fd428d71041c44cf91fdbb5","dirty":false}
+{"version":"1.0.1","commit":"f97df507a6083f9b9c2ba603d7c7055f67b29057","dirty":false}

package/host/engine-node-job.mjs

@@ -0,0 +1,35 @@
+// engine-node-job.mjs — a job child written in Node, on the same framed wire as
+// spike/job-run.R (plans/getting_rid_of_R.md Stage 3).
+//
+// host/planes/jobs.mjs drives a job through a StdioEngine: sentinel-framed
+// control frames on stdout, everything else streamed as output, the process
+// group signalled on Stop. That machinery does not care which language the
+// child is written in, so a job that needs no R — rendering a prose document
+// through Quarto — runs host/jobs/render-child.mjs under the Node that already
+// runs the host, with nothing else changed.
+
+import fs from "node:fs";
+import { StdioEngine } from "./engine-stdio.mjs";
+import { mirrorEnv } from "./env-names.mjs";
+
+export class NodeJobEngine extends StdioEngine {
+  /**
+   * @param {Object} opts
+   * @param {string} opts.workerPath  the child script
+   * @param {Record<string,string>} [opts.env]
+   * @param {string} [opts.cwd]
+   */
+  constructor({ workerPath, env = {}, cwd, platform = process.platform } = {}) {
+    super({ language: "node", workerPath, env, cwd, platform });
+    if (!workerPath || !fs.existsSync(workerPath)) throw new Error(`NodeJobEngine: no child at ${workerPath}`);
+    this.mode = "batch";
+  }
+
+  get label() { return "Job"; }
+  get canInput() { return false; }
+  get canDebug() { return false; }
+
+  spawnPlan() {
+    return { bin: process.execPath, args: [this.workerPath], env: mirrorEnv({ BEATRINA_WORKER_MODE: "batch" }) };
+  }
+}