beatrina 0.8.6 → 0.9.43

package/kernel/kernel.R

@@ -15,14 +15,14 @@ suppressPackageStartupMessages(library(jsonlite))
 #' framework build RStudio uses, 1241 packages including tna and TraMineR) sat
 #' unused. An IDE that cannot see your packages is not your IDE.
 #'
-#' Order: an explicit `CARMAR_RSCRIPT`, then the macOS framework R, then PATH.
+#' Order: an explicit `BEATRINA_RSCRIPT`, then the macOS framework R, then PATH.
 #'
 #' @return Path to an Rscript binary.
 #' `explicit` is an argument rather than only an env read so serve.R can pass
 #' the RESOLVED value (a user's rscript_path from settings, or the env var when
 #' a deployment set one). Defaulting to the env var keeps every existing call
 #' correct without changing it.
-detect_rscript <- function(explicit = Sys.getenv("CARMAR_RSCRIPT", "")) {
+detect_rscript <- function(explicit = Sys.getenv("BEATRINA_RSCRIPT", "")) {
   if (nzchar(explicit) && file.exists(explicit)) return(explicit)
   # The same ladder tools/app/launch.sh walks, and for the same reason: this
   # process may itself have been started by a Finder launch, whose PATH is
@@ -66,7 +66,7 @@ detect_r_binary <- function(rscript) {
 #'
 #' Command-line R promotes itself to a foreground LaunchServices application
 #' when its Aqua/AppKit support initializes. On macOS 26 that gives every
-#' document worker a generic `exec` Dock tile. A packaged CarmaR kernel carries
+#' document worker a generic `exec` Dock tile. A packaged Beatrina kernel carries
 #' a tiny native library beside kernel.R; calling it before worker.R is
 #' sourced registers this process as BackgroundOnly first. Distributions may
 #' carry either an architecture-specific marker (R packages) or one universal
@@ -92,10 +92,10 @@ macos_background_boot <- function(worker_path,
   # R_checkActivityEx, wedging the whole session at 0% CPU with Stop unable to
   # reach it. Foreground R, which is what RStudio runs, never does this. So a
   # visible Dock icon is the price of a kernel that answers; set
-  # CARMAR_MARK_BACKGROUND=1 to restore Dock hiding once a transform that does
+  # BEATRINA_MARK_BACKGROUND=1 to restore Dock hiding once a transform that does
   # not wedge the console read is found.
-  if (!identical(Sys.getenv("CARMAR_MARK_BACKGROUND", "0"), "1")) return("")
-  marker <- Sys.getenv("CARMAR_BACKGROUND_LIBRARY", "")
+  if (!identical(Sys.getenv("BEATRINA_MARK_BACKGROUND", "0"), "1")) return("")
+  marker <- Sys.getenv("BEATRINA_BACKGROUND_LIBRARY", "")
   if (!nzchar(marker)) {
     suffix <- if (grepl("^(aarch64|arm64)", arch, ignore.case = TRUE)) {
       "arm64"
@@ -105,8 +105,8 @@ macos_background_boot <- function(worker_path,
     beside <- dirname(worker_path)
     candidates <- c(
       if (nzchar(suffix)) file.path(
-        beside, paste0("carmar-background-", suffix, ".dylib")),
-      file.path(beside, "carmar-background.dylib"))
+        beside, paste0("beatrina-background-", suffix, ".dylib")),
+      file.path(beside, "beatrina-background.dylib"))
     found <- candidates[file.exists(candidates)]
     marker <- if (length(found)) found[[1L]] else candidates[[1L]]
   }
@@ -116,7 +116,7 @@ macos_background_boot <- function(worker_path,
   # already background-only; the call still causes the early LaunchServices
   # registration we need. Classification, not that legacy status code, is the
   # contract, so the result is intentionally ignored.
-  sprintf('local({dyn.load(%s);.C("carmar_mark_background",result=integer(1));invisible(NULL)})',
+  sprintf('local({dyn.load(%s);.C("beatrina_mark_background",result=integer(1));invisible(NULL)})',
           marker)
 }
 
@@ -127,7 +127,7 @@ macos_background_boot <- function(worker_path,
 #'   if absent; user code cannot guess it, so it cannot forge a frame.
 #' @return A kernel handle: list(proc, sentinel, buffer).
 #' @param env_extra Named character vector of environment variables to add for
-#'   the worker — e.g. `c(CARMAR_ROOT = "/srv/project")`, which confines every
+#'   the worker — e.g. `c(BEATRINA_ROOT = "/srv/project")`, which confines every
 #'   file command to that subtree. Managed deployments set it; tests set it to
 #'   prove the confinement holds.
 #' A UTF-8 character locale, whatever the launcher handed us.
@@ -243,19 +243,21 @@ kernel_start <- function(worker_path, sentinel = NULL, rscript = detect_rscript(
     # The worker cannot read argv for these — `R --interactive` takes no
     # script argument, the worker is booted by a sys.source line fed through
     # stdin below — so they travel in the environment instead.
-    clean_env[["CARMAR_SENTINEL"]] <- sentinel
-    clean_env[["CARMAR_CMD_TAG"]] <- cmdtag
-    clean_env[["CARMAR_WORKER_MODE"]] <- "interactive"
-    clean_env[["CARMAR_WORKER_DIR"]] <- dirname(normalizePath(worker_path, mustWork = FALSE))
+    clean_env[["BEATRINA_SENTINEL"]] <- sentinel
+    clean_env[["BEATRINA_CMD_TAG"]] <- cmdtag
+    clean_env[["BEATRINA_WORKER_MODE"]] <- "interactive"
+    # readline's screen width: at 80 a long command line echoes as "<" + tail with
+    # no cmdtag (Linux; host/engine-r.mjs has the measurement). The boot line gives
+    # user code back its own COLUMNS.
+    clean_env[["BEATRINA_USER_COLUMNS"]] <- Sys.getenv("COLUMNS", "")
+    clean_env[["COLUMNS"]] <- "100000"
+    clean_env[["BEATRINA_WORKER_DIR"]] <- dirname(normalizePath(worker_path, mustWork = FALSE))
   }
   spawn_bin <- if (identical(mode, "interactive")) r_binary else rscript
   spawn_args <- if (identical(mode, "interactive")) {
     # --no-echo suppresses the "> " prompt; the input ECHO it does not suppress
     # is scrubbed in kernel_poll by the cmdtag / pending-echo machinery.
-    # --no-readline FIRST: R ignores it after --interactive, and with readline
-    # R echoes each line read — on Linux as a scrolled "<" + tail that carries no
-    # cmdtag (host/engine-r.mjs has the measurement).
-    c("--no-readline", "--interactive", "--no-echo", "--no-save", "--no-restore", "--no-site-file")
+    c("--interactive", "--no-echo", "--no-save", "--no-restore", "--no-site-file")
   } else {
     # --vanilla, NOT --no-init-file: the user's .Rprofile/.Renviron are part of
     # their R (library paths, repos, options). Only history and saved workspaces
@@ -287,12 +289,13 @@ kernel_start <- function(worker_path, sentinel = NULL, rscript = detect_rscript(
     # rationale (parse the ~2,000-line file in one pass instead of feeding it
     # through the REPL reader). worker.R itself is sourced, not the shim —
     # the shim's only job was resolving its own directory from --file=,
-    # which CARMAR_WORKER_DIR now carries.
+    # which BEATRINA_WORKER_DIR now carries.
     real_worker <- file.path(dirname(worker_path), "worker.R")
     if (!file.exists(real_worker)) real_worker <- worker_path
     worker_boot <- sprintf('sys.source("%s", envir = globalenv(), keep.source = FALSE)',
                            encodeString(normalizePath(real_worker)))
-    boot <- paste(Filter(nzchar, c(macos_background_boot(worker_path), worker_boot)),
+    width_boot <- 'local({ cols <- Sys.getenv("BEATRINA_USER_COLUMNS"); Sys.unsetenv("BEATRINA_USER_COLUMNS"); if (nzchar(cols)) Sys.setenv(COLUMNS = cols) else Sys.unsetenv("COLUMNS") })'
+    boot <- paste(Filter(nzchar, c(width_boot, macos_background_boot(worker_path), worker_boot)),
                   collapse = ";")
     kernel_console(k, boot)
   }
@@ -359,7 +362,7 @@ kernel_command <- function(k, json) {
     return(kernel_write(k, paste0(json, "\n")))
   }
   if (nchar(json, type = "bytes") > MAX_CONSOLE_LINE) {
-    spill <- tempfile("carmar-cmd-", fileext = ".json")
+    spill <- tempfile("beatrina-cmd-", fileext = ".json")
     writeLines(json, spill, useBytes = TRUE)
     Sys.chmod(spill, mode = "0600")
     json <- toJSON(list(type = "cmdfile", path = spill), auto_unbox = TRUE)

package/kernel/knitr-run.R

@@ -6,7 +6,7 @@ KNIT_DOCS <- new.env(parent = emptyenv())
 KNIT_BASE <- NULL
 KNIT_CAPTURE <- NULL
 KNIT_PROTOCOL <- FALSE
-KNIT_MARKER <- "CARMAR_KNIT_OUTPUT_V1:"
+KNIT_MARKER <- "BEATRINA_KNIT_OUTPUT_V1:"
 
 run_document_cell <- function(id, source, document, dims = NULL, srcname = NULL) {
   KNIT_PROTOCOL <<- TRUE
@@ -161,17 +161,38 @@ run_document_cell <- function(id, source, document, dims = NULL, srcname = NULL)
       # Errors/interruption never become successful cached results.
       chunk_options$error <- FALSE
       chunk_options$engine <- "R"
-      chunk_options$carmar.adapter <- 1L
-      chunk_options$carmar.document <- if (is.character(document$cacheId) && length(document$cacheId) == 1L && nzchar(document$cacheId)) document$cacheId else document$id
-      chunk_options$carmar.setup <- setup_key
-      chunk_options$carmar.cwd <- getwd()
+      chunk_options$beatrina.adapter <- 1L
+      chunk_options$beatrina.document <- if (is.character(document$cacheId) && length(document$cacheId) == 1L && nzchar(document$cacheId)) document$cacheId else document$id
+      chunk_options$beatrina.setup <- setup_key
+      # A document saved on disk keeps its cache BESIDE it and keys it by its
+      # folder — where knitr and RStudio put `cache/` — not by wherever R's
+      # working directory happens to be. The window runs in the session's
+      # directory and `beatrina knit` in the document's, so keying by getwd()
+      # meant the two never shared one cached chunk (2026-09-19). A document
+      # with no file (an Untitled draft, the page's own notebook) keeps getwd().
+      doc_dir <- if (is.character(document$cacheId) && length(document$cacheId) == 1L &&
+                     nzchar(document$cacheId) && file.exists(document$cacheId) && !dir.exists(document$cacheId))
+        dirname(normalizePath(document$cacheId)) else ""
+      chunk_options$beatrina.cwd <- if (nzchar(doc_dir)) doc_dir else getwd()
+      if (nzchar(doc_dir)) {
+        cache_prefix <- chunk_options$cache.path %||% opts$cache.path %||% "cache/"
+        if (is.character(cache_prefix) && length(cache_prefix) == 1L && nzchar(cache_prefix) &&
+            !grepl("^(/|~|[A-Za-z]:[/\\\\])", cache_prefix))
+          chunk_options$cache.path <- file.path(doc_dir, cache_prefix)
+      }
       # Selection runs are native, uncached, but still inherit setup defaults.
       if (isTRUE(document$selection)) chunk_options$cache <- FALSE
+      # One run that evaluates even though the cache holds this chunk, and
+      # refreshes the cache with what it produces: knitr's own cache.rebuild,
+      # for this run only (the page sets `rebuild` per submission, never in
+      # the header). A "cached" outcome means the code did not execute, so
+      # nothing it does to the session happened; this is the way to make it.
+      if (isTRUE(document$rebuild)) chunk_options$cache.rebuild <- TRUE
       if (!is.null(dims$format) && identical(dims$format, "svg")) chunk_options$dev <- "svg"
       # Local options are a public knitr template, not opts_chunk globals.
       # Code reading opts_chunk sees document defaults; opts_current sees its
       # effective local options. A local override never leaks to the next cell.
-      knitr::opts_template$set(.carmar_interactive = chunk_options)
+      knitr::opts_template$set(.beatrina_interactive = chunk_options)
       merged <- modifyList(opts, chunk_options, keep.null = TRUE)
       if (!is.language(merged$eval) && (!is.logical(merged$eval) || length(merged$eval) != 1L || is.na(merged$eval)))
         stop("Interactive eval must be TRUE or FALSE. Use a full knitr render for expression-index selections.")
@@ -195,9 +216,9 @@ run_document_cell <- function(id, source, document, dims = NULL, srcname = NULL)
           auto_unbox = TRUE, null = "null", na = "null", digits = NA))))
       })
       # Source stays the REAL chunk source so knitr discovers/cache-restores
-      # the correct R objects. The evaluator hook retains CarmaR's native path.
+      # the correct R objects. The evaluator hook retains Beatrina's native path.
       fence <- paste(rep("`", max(3L, max(nchar(regmatches(source, gregexpr("`+", source))[[1L]]), 0L) + 1L)), collapse = "")
-      input <- paste0(fence, "{r ", label, ", opts.label='.carmar_interactive'}\n", source, "\n", fence, "\n")
+      input <- paste0(fence, "{r ", label, ", opts.label='.beatrina_interactive'}\n", source, "\n", fence, "\n")
       output <- withCallingHandlers(knitr::knit(text = input, envir = globalenv(), quiet = TRUE),
         message = function(m) {
           # The native traceback already names the real chunk/source. knitr's
@@ -206,6 +227,20 @@ run_document_cell <- function(id, source, document, dims = NULL, srcname = NULL)
           if (grepl("^\\s*Quitting from", conditionMessage(m))) invokeRestart("muffleMessage")
         })
       if (!evaluated && identical(output, input)) stop("knitr did not recognize the generated R chunk fence.")
+      # A rebuild rewrites the chunk's lazy-load database IN PLACE (same
+      # label, same hash, same file name). R keeps the bytes of every .rdb it
+      # has fetched from in a process-wide cache keyed by file name, so the
+      # next cache hit would index the fresh .rdx into the STALE bytes and
+      # every restored object would fail with "lazy-load database … is
+      # corrupt" (reproduced with plain knitr, 2026-09-17). Flushing that
+      # cache for the rewritten files is the only remedy R offers; base does
+      # not export it, tools:::makeLazyLoadDB calls the same internal.
+      if (evaluated && isTRUE(document$rebuild)) {
+        stem <- paste0(merged$cache.path %||% "cache/", label, "_")
+        rdb <- list.files(dirname(stem), full.names = TRUE,
+          pattern = paste0("^", gsub("([][{}()+*^$|\\\\?.])", "\\\\\\1", basename(stem)), "[0-9a-f]+\\.rdb$"))
+        invisible(lapply(rdb, \(f) .Internal(lazyLoadDBflush(normalizePath(f)))))
+      }
       cache_hit <- !evaluated && !identical(merged$eval, FALSE)
       if (!evaluated && identical(merged$eval, FALSE)) {
         terminal$status <- "skipped"
@@ -213,7 +248,13 @@ run_document_cell <- function(id, source, document, dims = NULL, srcname = NULL)
         terminal$reason <- terminal$message
       }
       if (cache_hit && startsWith(trimws(output), KNIT_MARKER)) {
-        payload <- substring(trimws(output), nchar(KNIT_MARKER) + 1L)
+        # `last` is NOT redundant: substring()'s default last is 1000000L, so the
+        # two-argument form cut every payload over 1 MB mid-quantum and the
+        # replay died with "Error in base64 decode". One 11x10in figure is
+        # enough (PNG -> base64 -> JSON -> base64 is ~1.85x). Same trap as the
+        # payload slice in kernel.R.
+        stored <- trimws(output)
+        payload <- substring(stored, nchar(KNIT_MARKER) + 1L, nchar(stored))
         restored <- jsonlite::fromJSON(rawToChar(jsonlite::base64_dec(payload)), simplifyVector = FALSE)
         for (frame in restored) { frame$id <- id; emit(frame) }
       }