beatrina 0.9.83 → 1.0.0

package/kernel/check/acceptance.mjs

@@ -12,6 +12,10 @@
 //   kept · readline() · file ops and completion while R is busy · Force Stop ·
 //   the terminal · Python and JavaScript chunks when those engines exist.
 //
+// WITH NO R (plans/getting_rid_of_R.md Stage 2) the host is still judged —
+// startup, the document (save, open, list), the terminal, the other engines —
+// and every R area is reported SKIP with the reason, never counted as a pass.
+//
 // Usage
 //   node tools/beatrina/acceptance.mjs                         # this checkout's host
 //   node tools/beatrina/acceptance.mjs --installed             # the installed beatrina package's host
@@ -61,17 +65,44 @@ if (!session.announced) {
   record("startup", "the supervisor announces a URL", "fail", session.log().split("\n").slice(-6).join(" | "));
   await shutdown(1);
 }
-const { frames, until, ready, page } = session;
-if (!ready) { record("startup", "R announces ready", "fail", session.log().slice(-400)); await shutdown(1); }
-record("startup", `R ready (${ready.r || "?"}, worker mode ${ready.mode || "?"})`, "pass", "", session.startupMs, { r: ready.r, mode: ready.mode });
+const { frames, until, ready, page, hostReady, noR } = session;
+if (!ready && !noR) { record("startup", "R announces ready", "fail", session.log().slice(-400)); await shutdown(1); }
+if (noR) {
+  record("startup", "the host is ready with no R (host-ready)", hostReady ? "pass" : "fail", "", session.startupMs);
+  record("startup", "R", "skip", `R is not available: ${noR}. Every R area below is skipped, not passed.`);
+} else {
+  record("startup", `R ready (${ready.r || "?"}, worker mode ${ready.mode || "?"})`, "pass", "", session.startupMs, { r: ready.r, mode: ready.mode });
+}
+/** An R area runs only when R does; otherwise it is ONE skip line with the reason. */
+const wantR = (area) => {
+  if (!want(area)) return false;
+  if (noR) { record(area, `${area} (needs R)`, "skip", noR); return false; }
+  return true;
+};
 
 let seq = 0;
 const text = (id) => session.text(id);
 const run = (source, opts = {}) => session.run(source, opts);
-const engines = Array.isArray(ready.engines) ? ready.engines : ["r"];
+const announced = ready || hostReady;
+const engines = Array.isArray(announced.engines) ? announced.engines : ["r"];
+
+// ── the document: what a person does with no engine at all ──────────────────
+if (want("document")) {
+  const doc = path.join(scratch, "chapter.qmd");
+  const body = "---\ntitle: Acceptance\n---\n\n# Method\n\nWords, saved by the host [@key].\n";
+  const w = await session.ask("writefile", { path: doc, text: body });
+  record("document", "Save writes a .qmd", w.reply && !w.reply.error && fs.readFileSync(doc, "utf8") === body ? "pass" : "fail",
+    w.reply ? (w.reply.error || "") : "no reply", w.ms);
+  const rd = await session.ask("readfile", { path: doc });
+  record("document", "Open reads it back, byte for byte", rd.reply && rd.reply.text === body ? "pass" : "fail",
+    rd.reply ? (rd.reply.error || "") : "no reply", rd.ms);
+  const ls = await session.ask("files", { path: scratch });
+  record("document", "the file browser lists it", ls.reply && !ls.reply.error && JSON.stringify(ls.reply).includes("chapter.qmd") ? "pass" : "fail",
+    ls.reply ? (ls.reply.error || "") : "no reply", ls.ms);
+}
 
 // ── run ──────────────────────────────────────────────────────────────────────
-if (want("run")) {
+if (wantR("run")) {
   const r = await run('keep <- 42; cat("keep=", keep, "\\n")');
   record("run", "a chunk runs and prints", r.done?.status === "ok" && /keep= 42/.test(r.out()) ? "pass" : "fail", r.out().trim(), r.ms);
   const warm = [];
@@ -109,7 +140,7 @@ async function stopCase(label, source, { engine, probe, expect, after = 900, kee
   record("stop", `${label}: interrupted with the session kept, ${REPEAT - misses.length}/${REPEAT}`, misses.length ? "fail" : "pass",
     summary, lat.length ? median(lat) : null, { series: lat, misses: misses.length, repeat: REPEAT });
 }
-if (want("stop")) {
+if (wantR("stop")) {
   const probe = 'cat("keep=", exists("keep") && keep == 42, "\\n")';
   await run("keep <- 42");
   const keep = "keep <- 42";
@@ -119,7 +150,7 @@ if (want("stop")) {
 }
 
 // ── readline ─────────────────────────────────────────────────────────────────
-if (want("readline")) {
+if (wantR("readline")) {
   const id = `r${++seq}`;
   const from = frames.length;
   page.send({ type: "exec", id, source: 'ans <- readline("Your name: "); cat("hello", ans, "\\n")' });
@@ -135,7 +166,7 @@ if (want("readline")) {
 
 // ── while busy ───────────────────────────────────────────────────────────────
 const ask = (type, payload, ms) => session.ask(type, payload, ms);
-if (want("busy")) {
+if (wantR("busy")) {
   fs.writeFileSync(path.join(scratch, "note.txt"), "hello");
   const id = `b${++seq}`;
   const from = frames.length;
@@ -160,7 +191,7 @@ if (want("busy")) {
 }
 
 // ── force stop ───────────────────────────────────────────────────────────────
-if (want("force")) {
+if (wantR("force")) {
   await run("keep <- 42");
   const id = `f${++seq}`;
   const from = frames.length;
@@ -179,7 +210,7 @@ if (want("force")) {
 // R dies under a running chunk (kill -9, as a segfault or the OOM killer would):
 // the chunk must END with a sentence, the page must be told, and a fresh R must
 // answer — never a spinner that waits for a process that is gone.
-if (want("crash")) {
+if (wantR("crash")) {
   const probe = await run('cat("pid=", Sys.getpid(), "\\n")');
   const pid = Number((probe.out().match(/pid= (\d+)/) || [])[1]);
   const id = `c${++seq}`;
@@ -211,7 +242,7 @@ function rssKb(pid) {
   const v = Number(String(r.stdout).trim());
   return Number.isFinite(v) && v > 0 ? v : null;
 }
-if (want("memory")) {
+if (wantR("memory")) {
   const rounds = Math.max(4, Number(argv.memoryRounds || 8));
   const samples = [];
   await run("df <- data.frame(id = seq_len(5000), x = rnorm(5000), g = sample(letters, 5000, TRUE))");
@@ -251,7 +282,7 @@ for (const [engine, setup, probe, sleeper] of [
   ["js", "globalThis.keepJs = 42; console.log('js keep', keepJs)", "console.log('js keep', keepJs)", "for (let i = 0; i < 1e13; i++) {}\nconsole.log('after-stop')"],
 ]) {
   if (!want(engine)) continue;
-  const row = Array.isArray(ready.engine_status) ? ready.engine_status.find((e) => e.engine === engine) : null;
+  const row = Array.isArray(announced.engine_status) ? announced.engine_status.find((e) => e.engine === engine) : null;
   if (!engines.includes(engine)) { record(engine, `${engine} chunks`, "skip", row ? row.detail || "engine not available" : "this host has no such engine"); continue; }
   const first = await run(setup, { engine, ms: 120000 });
   record(engine, `a ${engine} chunk runs (first run starts the engine)`, first.done?.status === "ok" && /keep 42/.test(first.out()) ? "pass" : "fail", first.out().trim() || first.done?.message || "", first.ms);

package/kernel/check/knit-file.mjs

@@ -1,3 +1,29 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+
+// lib/engine-labels.js
+var KNOWN_ENGINES, BY_KEY, AUTHORING_ENGINES;
+var init_engine_labels = __esm({
+  "lib/engine-labels.js"() {
+    KNOWN_ENGINES = Object.freeze([
+      Object.freeze({ key: "r", label: "R" }),
+      Object.freeze({ key: "python", label: "Python" }),
+      Object.freeze({ key: "js", label: "JavaScript" }),
+      Object.freeze({ key: "bash", label: "Bash" }),
+      Object.freeze({ key: "sql", label: "SQL" })
+    ]);
+    BY_KEY = new Map(KNOWN_ENGINES.map((e) => [e.key, e.label]));
+    AUTHORING_ENGINES = Object.freeze(KNOWN_ENGINES.map((e) => e.key));
+  }
+});
+
 // tools/beatrina/knit-file.mjs
 import fs from "node:fs";
 import path from "node:path";
@@ -4467,7 +4493,10 @@ var BEATRINA_CSS = `
 .cn-root .beatrina-md-tool:focus-visible{outline:0;box-shadow:var(--cn-focus-ring);}
 .cn-root .beatrina-md-tool.is-cite{color:var(--cn-accent);}
 .cn-root .beatrina-md-tool-label{font:600 var(--cn-fs-sm) var(--cn-font);}
-.cn-root .beatrina-md-bar-sp{flex:0 0 4px;}
+/* width as well as flex-basis: WebKit leaves a basis-only item out of the bar's max-content
+   width, so the bar came out 4 px short at every fold level and folded everything behind \u22EE
+   (Beatrina's window, 2026-09-23). */
+.cn-root .beatrina-md-bar-sp{flex:0 0 4px;width:4px;}
 .cn-root .beatrina-md-count{
   font-size:var(--cn-fs-sm);opacity:.55;font-variant-numeric:tabular-nums;margin-right:2px;
 }
@@ -10637,6 +10666,14 @@ var BEATRINA_CSS = `
 @media(max-width:760px){
   .cn-root.has-ai-left{padding-left:0;}
   .cn-root.has-ai-right{padding-right:0;}
+  /* \u2026and so a docked pane is a SHEET over the whole window, not a 400 px
+     slab over the right half of the words. Reserving its width at this size
+     would leave a column of ~260 px; overlaying half the text left every line
+     cut off under it (journey windows, 720 px, 2026-09-24). One or the other
+     is on screen; \xD7 gives the document back. !important beats the inline
+     left/right/width ai-shell.js writes for the wide layout. */
+  .cn-root .beatrina-ai-panel.is-side{left:0 !important;right:0 !important;width:auto !important;}
+  .cn-root .beatrina-ai-panel.is-side .beatrina-ai-sedge{display:none;}
 }
 
 .cn-root .beatrina-aiw-convbtn{flex:0 0 auto;width:24px;height:24px;
@@ -11777,7 +11814,7 @@ body:has(.cn-root[data-beatrina-mode="writing"] > .beatrina-writing-bar){--beatr
   box-shadow:0 -1px 0 var(--cn-border,#e3e3e3);
 }
 .beatrina-dock[hidden]{display:none;}
-.beatrina-dock[data-mode="bottom"]{left:0;right:0;bottom:0;flex-direction:column;}
+.beatrina-dock[data-mode="bottom"]{left:var(--beatrina-ai-edge-left,0px);right:var(--beatrina-ai-edge-right,0px);bottom:0;flex-direction:column;}
 .beatrina-dock[data-mode="right"]{
   top:0;right:0;bottom:0;flex-direction:row;
   box-shadow:-1px 0 0 var(--cn-border,#e3e3e3);
@@ -14905,7 +14942,8 @@ ${out}</div>
     if (!ctx.rawUrls && !safeImageSrc(url)) {
       return `<span class="beatrina-md-badsrc">[image: ${alt || "unsupported source"}]</span>`;
     }
-    let out = `<img src="${attrValue(encodeHref(url))}" alt="${alt}"`;
+    const local = ctx.localImages && /^(?![a-z][a-z0-9+.-]*:|\/\/|#)/i.test(url.trim());
+    let out = local ? `<img data-local-src="${attrValue(url)}" alt="${alt}"` : `<img src="${attrValue(encodeHref(url))}" alt="${alt}"`;
     if (node2.title) out += ` title="${attrValue(node2.title)}"`;
     if (!ctx.spec) out += ' class="beatrina-md-img" loading="lazy"';
     return ctx.spec ? `${out} />` : `${out}>`;
@@ -14994,6 +15032,7 @@ function toHtml(tree, opts = {}) {
     // survived a JSON round-trip or a parsed query, does not open it.
     rawHtml: opts.allowDangerousHtml === true,
     rawUrls: opts.allowDangerousProtocol === true,
+    localImages: opts.localImages === true,
     gfm: opts.gfm !== false,
     softBreak: typeof opts.softBreak === "string" ? opts.softBreak : "\n",
     state: opts.state || {},
@@ -18697,17 +18736,6 @@ function citeStyleOf(notebook) {
   };
 }
 
-// lib/engine-labels.js
-var KNOWN_ENGINES = Object.freeze([
-  Object.freeze({ key: "r", label: "R" }),
-  Object.freeze({ key: "python", label: "Python" }),
-  Object.freeze({ key: "js", label: "JavaScript" }),
-  Object.freeze({ key: "bash", label: "Bash" }),
-  Object.freeze({ key: "sql", label: "SQL" })
-]);
-var BY_KEY = new Map(KNOWN_ENGINES.map((e) => [e.key, e.label]));
-var AUTHORING_ENGINES = Object.freeze(KNOWN_ENGINES.map((e) => e.key));
-
 // lib/doc-mode.js
 var MODES = Object.freeze(["development", "writing", "latex"]);
 var MODE_KEY = "beatrina-mode";
@@ -19671,6 +19699,10 @@ ${references}
 `;
 }
 
+// lib/chunk-meta.js
+init_engine_labels();
+init_engine_labels();
+
 // src/r-kernel.js
 function normalizeTable(frame) {
   const rows = Array.isArray(frame.rows) ? frame.rows : frame.rows ? [frame.rows] : [];

package/kernel/check/session.mjs

@@ -143,8 +143,14 @@ export function freePort() {
 }
 
 /**
- * Start a supervisor on `port`, open a page socket, and wait for R's ready.
- * @returns {Promise<object>} the session: frames, until, text, run, ask, ready, startupMs, log, shutdown
+ * Start a supervisor on `port`, open a page socket, and wait for it to be ready.
+ *
+ * A host that speaks the handshake sends `host-ready` first (plans/
+ * getting_rid_of_R.md K2). When its R row says R is NOT coming — absent, or
+ * failed to start — there is no R `ready` to wait for, and the session is the
+ * HOST: `ready` stays null, `hostReady` is the frame, `noR` says why. An older
+ * host sends no host-ready and is waited on for R's ready, as before.
+ * @returns {Promise<object>} the session: frames, until, text, run, ask, ready, hostReady, noR, startupMs, log, shutdown
  */
 export async function startSession({ command, port, cwd, env = {}, readyMs = 90000, logFile = "" }) {
   const t0 = Date.now();
@@ -214,7 +220,7 @@ export async function startSession({ command, port, cwd, env = {}, readyMs = 900
       else { try { process.kill(child.pid, "SIGKILL"); } catch { /* gone */ } }
     }
   };
-  const session = { child, port, announced, page: null, frames: [], ready: null, startupMs: null, log: () => hostLog, shutdown };
+  const session = { child, port, announced, page: null, frames: [], ready: null, hostReady: null, noR: "", startupMs: null, log: () => hostLog, shutdown };
   if (!announced) return session;
 
   const page = await openSocket(port, `http://127.0.0.1:${port}`);
@@ -250,7 +256,16 @@ export async function startSession({ command, port, cwd, env = {}, readyMs = 900
     const reply = await session.until((f) => f.id === id && f.type !== "stdout" && f.type !== "stderr", ms, from);
     return { reply, ms: Date.now() - t };
   };
-  session.ready = await session.until((f) => f.type === "ready", readyMs);
+  // host-ready is the first frame on open, or never (an older host): a short wait decides.
+  session.hostReady = await session.until((f) => f.type === "host-ready" || f.type === "ready", 15000);
+  if (session.hostReady && session.hostReady.type === "ready") { session.ready = session.hostReady; session.hostReady = null; }
+  const rRow = session.hostReady && Array.isArray(session.hostReady.engine_status)
+    ? session.hostReady.engine_status.find((e) => e.engine === "r") : null;
+  if (session.hostReady && (!rRow || !rRow.available || rRow.error)) {
+    session.noR = (rRow && (rRow.error || rRow.detail)) || "this host has no R engine";
+  } else if (!session.ready) {
+    session.ready = await session.until((f) => f.type === "ready", readyMs);
+  }
   session.startupMs = Date.now() - t0;
   return session;
 }

package/kernel/kernel-version

@@ -1 +1 @@
-0.9.83
+1.0.0

package/lib/engine-labels.js

@@ -118,6 +118,8 @@ export function versionMenuLabel(engine) {
  */
 export function kernelLanguage(info) {
   const declared = info && typeof info.language === "string" ? info.language.trim() : "";
+  // A host running no default engine (host-ready) runs no language: "".
+  if (!declared && info && info.host_only) return "";
   return declared ? engineKey(declared) : DEFAULT_ENGINE;
 }
 
@@ -154,6 +156,8 @@ export function kernelVersion(info) {
  * has always shown for a listener that named no version.
  */
 export function kernelDisplay(info) {
+  // The HOST is attached and no engine is its own (plans/getting_rid_of_R.md K2).
+  if (!kernelLanguage(info) && info) return "Beatrina";
   const label = engineLabel(kernelLanguage(info));
   const version = kernelVersion(info);
   return version ? `${label} ${version}` : `${label} session`;
@@ -216,6 +220,8 @@ export function reportedEngines(info) {
     if (row && !rows.some((seen) => seen.name === row.name)) rows.push(row);
   });
   if (!rows.length) return [];
+  // A host with no language of its own adds none.
+  if (!language) return rows;
   // The kernel's own language is always one of its engines — a session that
   // would not run its own language is not a thing, and a list that omitted it
   // would strand every chunk in the notebook.
@@ -239,7 +245,7 @@ export function reportedEngines(info) {
  */
 export function declaredEngines(info) {
   const language = kernelLanguage(info);
-  const out = [language];
+  const out = language ? [language] : [];
   reportedEngines(info).forEach((row) => { if (!out.includes(row.name)) out.push(row.name); });
   return out;
 }

package/menu/Beatrina Menu.app/Contents/Info.plist

@@ -6,8 +6,8 @@
   <key>CFBundleExecutable</key><string>Beatrina Menu</string>
   <key>CFBundleIdentifier</key><string>me.saqr.beatrina.menu</string>
   <key>CFBundlePackageType</key><string>APPL</string>
-  <key>CFBundleShortVersionString</key><string>0.9.83</string>
-  <key>CFBundleVersion</key><string>0.9.83</string>
+  <key>CFBundleShortVersionString</key><string>1.0.0</string>
+  <key>CFBundleVersion</key><string>1.0.0</string>
   <key>LSMinimumSystemVersion</key><string>13.0</string>
   <!-- Menu bar only: no Dock tile, no window, nothing to close by accident. -->
   <key>LSUIElement</key><true/>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beatrina",
-  "version": "0.9.83",
+  "version": "1.0.0",
   "description": "Beatrina is a modern, powerful, feature-rich integrated development environment (IDE) for R, Python, and JavaScript.",
   "type": "module",
   "bin": {
@@ -23,9 +23,10 @@
     "failsafe",
     "lib",
     "menu",
+    "app",
     "build-info.json",
-    "beatrina_V0.9.83.html",
-    "beatrina_V0.9.83.html.inputs.json",
+    "beatrina_V1.0.0.html",
+    "beatrina_V1.0.0.html.inputs.json",
     "README.md",
     "LICENSE",
     "NOTICES"