beatrina 0.8.7 → 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,15 +243,15 @@ 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[["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[["CARMAR_USER_COLUMNS"]] <- Sys.getenv("COLUMNS", "")
+    clean_env[["BEATRINA_USER_COLUMNS"]] <- Sys.getenv("COLUMNS", "")
     clean_env[["COLUMNS"]] <- "100000"
-    clean_env[["CARMAR_WORKER_DIR"]] <- dirname(normalizePath(worker_path, mustWork = FALSE))
+    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")) {
@@ -289,12 +289,12 @@ 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)))
-    width_boot <- 'local({ cols <- Sys.getenv("CARMAR_USER_COLUMNS"); Sys.unsetenv("CARMAR_USER_COLUMNS"); if (nzchar(cols)) Sys.setenv(COLUMNS = cols) else Sys.unsetenv("COLUMNS") })'
+    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)
@@ -362,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) }
       }

package/kernel/latex.R

@@ -1,6 +1,6 @@
 # latex.R — LaTeX compile decisions and diagnostics for the existing Jobs plane.
 # Used by the supervisor's job spec and the isolated job-run.R child.
-# Origin: carmar-latex-plugin/host/workbench.mjs compilerSpec and
+# Origin: beatrina-latex-plugin/host/workbench.mjs compilerSpec and
 # parseCompilerDiagnostics; SHA-256 fd168f3c2a70d5f010542b8c080e9173d03cb4e8e40862e7d957731f2fee519b
 # Captured argv and observed log results: test/fixtures/latex/compiler.json.
 # These are prototype inputs to review, not a validated engine contract.
@@ -32,6 +32,7 @@
 LATEX_ENGINES <- c("tectonic", "latexmk", "pdflatex", "xelatex", "lualatex")
 LATEX_TIMEOUT <- 180L
 LATEX_DIAGNOSTIC_MAX <- 500L
+LATEX_SOURCE_READ_MAX <- 4e6         # a source file consulted for a column
 LATEX_CITATION_MAX <- 100L
 # TeX's max_print_line: a log line of exactly this width has been hard-wrapped
 # and continues on the next line, with no marker (LEARNINGS 2026-09-07).
@@ -58,7 +59,7 @@ latex_compile <- function(target, engine, timeout, job_id, run_streaming, emit,
   # looks for it; it is replaced only by a successful run, atomically, so a
   # failed compile leaves the previous PDF exactly where it was.
   stem <- sub("\\.[^.]+$", "", basename(target))
-  output <- file.path(dirname(target), ".carmar-latex", stem)
+  output <- file.path(dirname(target), ".beatrina-latex", stem)
   if (!dir.exists(output)) dir.create(output, recursive = TRUE, showWarnings = FALSE)
   if (!dir.exists(output)) stop("Cannot create the LaTeX build folder.", call. = FALSE)
   spec <- latex_argv(found$engine, target, output, fetch = fetch)
@@ -98,8 +99,12 @@ latex_compile <- function(target, engine, timeout, job_id, run_streaming, emit,
   # Parsed once and used twice: the pane gets the rows, and the failure
   # sentence gets to say what is in the pane rather than pointing at the log.
   diagnostics <- latex_log_diagnostics(diagnostic_lines, target)
+  # `engine`: which compiler said this. A FAILED compile emits no `output`
+  # frame, which was the only place the engine was named — so the one moment
+  # an explanation needs it ("this needs XeLaTeX", "Tectonic has no biber") was
+  # the moment it was unknown (docs/latex-ai-hardening-plan.md Stage 3).
   emit(list(type = "job", event = "diagnostics", rows = I(diagnostics),
-    root = target, truncated = isTRUE(result$truncated)))
+    root = target, truncated = isTRUE(result$truncated), engine = found$engine))
   # What could be DONE about it, sent as a fact beside the rows rather than
   # left for the page to read out of the hint's prose. Emitted before either
   # `stop()` below, because the frame has to reach the browser whichever way
@@ -174,9 +179,9 @@ latex_options <- function(opts = list()) {
   # else — absent, "1", "yes", NA — is off. An option that means "reach the
   # network" must never be arrived at by coercion.
   fetch <- isTRUE(opts$fetch)
-  c(CARMAR_LATEX_ENGINE = engine, CARMAR_LATEX_TIMEOUT = as.character(timeout),
-    CARMAR_LATEX_FETCH = if (fetch) "1" else "",
-    CARMAR_LATEX_IDENTITY = if (is.null(identity)) "" else jsonlite::toJSON(identity, auto_unbox = TRUE, digits = NA))
+  c(BEATRINA_LATEX_ENGINE = engine, BEATRINA_LATEX_TIMEOUT = as.character(timeout),
+    BEATRINA_LATEX_FETCH = if (fetch) "1" else "",
+    BEATRINA_LATEX_IDENTITY = if (is.null(identity)) "" else jsonlite::toJSON(identity, auto_unbox = TRUE, digits = NA))
 }
 
 #' Is this a usable executable file?
@@ -195,9 +200,9 @@ latex_discover <- function(engine = "auto", lookup = Sys.which, getenv = Sys.get
   engines <- if (engine == "auto") LATEX_ENGINES else engine
   result <- NULL
   Find(function(name) {
-    override <- getenv(paste0("CARMAR_", toupper(name)))
+    override <- getenv(paste0("BEATRINA_", toupper(name)))
     if (nzchar(override)) {
-      if (!usable(override)) stop(sprintf("CARMAR_%s does not name an executable file.", toupper(name)), call. = FALSE)
+      if (!usable(override)) stop(sprintf("BEATRINA_%s does not name an executable file.", toupper(name)), call. = FALSE)
       result <<- list(engine = name, binary = override)
       return(TRUE)
     }
@@ -209,7 +214,7 @@ latex_discover <- function(engine = "auto", lookup = Sys.which, getenv = Sys.get
     result <<- list(engine = name, binary = hit)
     TRUE
   }, engines)
-  if (is.null(result)) stop(sprintf("%s was not found. Install a TeX engine or set its CARMAR_<ENGINE> binary path.",
+  if (is.null(result)) stop(sprintf("%s was not found. Install a TeX engine or set its BEATRINA_<ENGINE> binary path.",
     if (engine == "auto") "A LaTeX engine" else engine), call. = FALSE)
   result
 }
@@ -223,7 +228,7 @@ latex_discover <- function(engine = "auto", lookup = Sys.which, getenv = Sys.get
 #' instruction to go and use a terminal. That is a policy misapplied to its
 #' engine rather than a policy doing its job.
 #'
-#' So the promise is restated as the one CarmaR already keeps everywhere else
+#' So the promise is restated as the one Beatrina already keeps everywhere else
 #' (spike/cite.R's style repository): the kernel reaches the network only when
 #' the person pressed something that said so. `fetch` is that press. It is
 #' never a default, never a setting, and never sticky — it is passed for ONE
@@ -265,7 +270,7 @@ latex_argv <- function(engine, target, output, fetch = FALSE) {
 #' The sentence a person can act on, for a missing asset under either engine.
 #'
 #' Tectonic and a local TeX fail the same way for different reasons, so this is
-#' the one place that difference is worded. CarmaR compiles offline by design
+#' the one place that difference is worded. Beatrina compiles offline by design
 #' (`--only-cached`, so the kernel never touches the network), which means a
 #' Tectonic failure is almost always "not fetched yet" and the fix is one
 #' command; a local TeX failure is "not installed" and the fix is the
@@ -284,7 +289,7 @@ latex_missing_hint <- function(what, engine, target, plural = FALSE) {
     # There is one now (latex_argv's `fetch`, offered by the failure panel), so
     # the sentence points at what is on screen and keeps the command for
     # somebody who would rather, or whose page is not showing the panel.
-    sprintf(paste0("%s %s not in Tectonic's package cache. CarmaR compiles offline, so nothing was ",
+    sprintf(paste0("%s %s not in Tectonic's package cache. Beatrina compiles offline, so nothing was ",
       "downloaded: use Fetch and compile below to get %s for one compile, or run ",
       "tectonic \"%s\" in a terminal (in %s)."),
       what, are, if (isTRUE(plural)) "them" else "it", basename(target), dirname(target))
@@ -294,7 +299,7 @@ latex_missing_hint <- function(what, engine, target, plural = FALSE) {
   }
 }
 
-#' What CarmaR could DO about this failure, as a fact rather than a sentence.
+#' What Beatrina could DO about this failure, as a fact rather than a sentence.
 #'
 #' The hint below is prose for a person; this is the same reading of the same
 #' log for the PAGE, because a page that decides whether to offer a button by
@@ -303,7 +308,7 @@ latex_missing_hint <- function(what, engine, target, plural = FALSE) {
 #' split the export backends make over one parse tree.
 #'
 #' Only ONE fix is machine-actionable today: missing packages under Tectonic,
-#' which CarmaR can fetch for this compile. A local TeX distribution's missing
+#' which Beatrina can fetch for this compile. A local TeX distribution's missing
 #' package is not — installing it is the distribution's business, not a button
 #' this program is entitled to press.
 #'
@@ -396,9 +401,13 @@ latex_failure_hint <- function(lines, engine, target, diagnostics = list()) {
   errors <- Filter(function(row) identical(row$severity, "error"), diagnostics)
   if (length(errors)) {
     first <- errors[[1L]]
-    return(sprintf("%s in Problems; the first is %s line %d: %s",
+    # A diagnostic may legitimately carry no line (a summary the compiler did
+    # not place). `sprintf("%d", NA_integer_)` prints "line NA", so the file is
+    # named on its own instead.
+    where <- if (is.na(first$line)) basename(first$path) else sprintf("%s line %d", basename(first$path), first$line)
+    return(sprintf("%s in Problems; the first is %s: %s",
       if (length(errors) == 1L) "1 error is listed" else sprintf("%d errors are listed", length(errors)),
-      basename(first$path), first$line, sub("[.]+$", "", first$message)))
+      where, sub("[.]+$", "", first$message)))
   }
   "See the compile log."
 }
@@ -407,9 +416,73 @@ latex_failure_hint <- function(lines, engine, target, diagnostics = list()) {
 #' @param lines Compiler stdout or log lines.
 #' @param root Absolute root source path.
 #' @return Bounded diagnostic records; browser conversion owns UTF-16 offsets.
+#' Severity of a compiler message.
+#'
+#' The engine's own `error:`/`warning:` prefix is authoritative when present.
+#' Without one, only a LEADING LaTeX warning marker counts — an error whose text
+#' merely contains the word "warning" is still an error, and `grepl("warning",
+#' message)` made one of those a warning.
+#' @param prefix The `error`/`warning` token the engine printed, or "".
+#' @param message The message text.
+#' @return `"warning"` or `"error"`.
+latex_severity <- function(prefix, message) {
+  prefix <- tolower(trimws(paste0(prefix, "")))
+  if (identical(prefix, "warning")) return("warning")
+  if (identical(prefix, "error")) return("error")
+  if (grepl("^(?:LaTeX|Package[^:]*|Class[^:]*|pdfTeX|Font)[[:space:]]+[Ww]arning:", paste0(message, ""), perl = TRUE)) "warning" else "error"
+}
+
+#' The 1-based CODE POINT column an `l.N` echo points at, or NA.
+#'
+#' TeX prints the text it had consumed when it stopped:
+#'
+#'     l.4 \\undefinedcontrolsequence
+#'                                  <- the remainder, padded into place
+#'
+#' The obvious move is to measure that echo, and it is wrong: the echo is LOSSY.
+#' Measured against a real tectonic 0.15.0 log, a source `\U1D538` (one code
+#' point, two UTF-16 units) is written to the log as `\UD538`, one unit — so a
+#' column counted in the echo is short by one unit per astral character and
+#' lands inside a surrogate pair.
+#'
+#' So the echo is only ever a HINT, and a column is returned only when the hint
+#' is an EXACT prefix of the genuine source line. When TeX wrapped the echo, or
+#' mangled a character, or the file cannot be read, the answer is NA — which is
+#' what this function returned for every input before it existed, and remains
+#' the honest answer. A column that cannot be justified is worse than none.
+#' @param echo The text after `l.N `.
+#' @param source_line The genuine line, or NA.
+#' @return A 1-based code-point column, or `NA_integer_`.
+latex_echo_column <- function(echo, source_line) {
+  if (!latex_scalar(echo) || !nzchar(echo) || !latex_scalar(source_line)) return(NA_integer_)
+  if (!startsWith(source_line, echo)) return(NA_integer_)
+  nchar(echo, type = "chars") + 1L
+}
+
 latex_log_diagnostics <- function(lines, root) {
   stopifnot(is.character(lines), latex_scalar(root))
   rows <- list(); seen <- character(); pending <- NULL; stack <- list()
+  # Scoped to THIS call on purpose: a cache outliving one compile would compute
+  # a column from the text as it was before the edit that triggered the rebuild.
+  source_cache <- new.env(parent = emptyenv())
+  source_line <- function(path, line) {
+    if (!is.finite(line) || line < 1L) return(NA_character_)
+    if (is.null(source_cache[[path]])) {
+      # Unreadable, absent, oversized or binary: no column. This is the
+      # documented safe outcome, not a swallowed failure — the diagnostic is
+      # still reported, with its line and without a column.
+      value <- if (file.exists(path) && !dir.exists(path) && file.size(path) <= LATEX_SOURCE_READ_MAX) {
+        tryCatch({
+          text <- readLines(path, warn = FALSE)
+          Encoding(text) <- "UTF-8"
+          text
+        }, error = function(e) character())
+      } else character()
+      assign(path, value, envir = source_cache)
+    }
+    text <- source_cache[[path]]
+    if (line > length(text)) NA_character_ else text[[line]]
+  }
   current <- function() {
     files <- Filter(function(value) !is.null(value) && nzchar(value), stack)
     if (length(files)) files[[length(files)]] else root
@@ -420,32 +493,57 @@ latex_log_diagnostics <- function(lines, root) {
     if (!file.exists(file) && file.exists(paste0(file, ".tex"))) file <- paste0(file, ".tex")
     normalizePath(file, mustWork = FALSE)
   }
-  add <- function(file, line, message, severity = "error", col = NA_integer_) {
+  # The log lines AROUND a finding, bounded: the message names the error, but
+  # TeX says what it was reading (`l.12 \badcommand`) and what it did about it
+  # on the lines that follow, and that is the evidence an explanation needs.
+  # `from`..`to` are indices into `lines`; at most 8 lines and 600 characters,
+  # so 200 rows cannot turn a frame into the log.
+  excerpt <- function(from, to) {
+    if (is.na(from) || is.na(to)) return("")
+    span <- lines[seq.int(max(1L, from), min(length(lines), max(from, to)))]
+    span <- utils::head(span[nzchar(trimws(span))], 8L)
+    substr(paste(span, collapse = "\n"), 1L, 600L)
+  }
+  add <- function(file, line, message, severity = "error", col = NA_integer_,
+                  from = NA_integer_, to = NA_integer_) {
     file <- resolve_file(file)
     key <- paste(file, line, col, sub("[.]+$", "", trimws(message)), sep = "\r")
     if (!key %in% seen && length(rows) < LATEX_DIAGNOSTIC_MAX) {
       seen <<- c(seen, key)
       rows[[length(rows) + 1L]] <<- list(path = file, line = as.integer(line), col = col,
-        message = trimws(message), severity = severity, source = "LaTeX compiler")
+        message = trimws(message), severity = severity, source = "LaTeX compiler",
+        log = excerpt(from, to))
     }
   }
-  lapply(lines, function(line) {
+  lapply(seq_along(lines), function(i) {
+    line <- lines[[i]]
     # file-line-error and Tectonic include the file explicitly, including drives.
     hit <- regmatches(line, regexec("^(?:(error|warning):[[:space:]]*)?(.+?):([0-9]+):(?:([0-9]+):)?[[:space:]]*(.+)$", line, perl = TRUE))[[1L]]
     if (length(hit) && (nzchar(hit[[2]]) || grepl("\\.(tex|sty|cls|bib)$", hit[[3]]) || file.exists(resolve_file(hit[[3]])))) {
-      add(hit[[3]], as.integer(hit[[4]]), hit[[6]], if (grepl("warning", paste(hit[[2]], hit[[6]]), ignore.case = TRUE)) "warning" else "error",
-        if (nzchar(hit[[5]])) as.integer(hit[[5]]) else NA_integer_)
+      add(hit[[3]], as.integer(hit[[4]]), hit[[6]], latex_severity(hit[[2]], hit[[6]]),
+        if (nzchar(hit[[5]])) as.integer(hit[[5]]) else NA_integer_, from = i, to = i + 4L)
       pending <<- NULL; return(NULL)
     }
-    if (startsWith(line, "!")) { pending <<- list(file = current(), message = trimws(sub("^!", "", line))); return(NULL) }
-    location <- regmatches(line, regexec("^l\\.([0-9]+)[[:space:]]", line, perl = TRUE))[[1L]]
+    if (startsWith(line, "!")) { pending <<- list(file = current(), message = trimws(sub("^!", "", line)), at = i); return(NULL) }
+    location <- regmatches(line, regexec("^l\\.([0-9]+)[[:space:]](.*)$", line, perl = TRUE))[[1L]]
     if (length(location) && !is.null(pending)) {
-      add(pending$file, as.integer(location[[2]]), pending$message); pending <<- NULL; return(NULL)
+      at_line <- as.integer(location[[2]])
+      # The echo is a hint; the genuine source line is the authority. NA unless
+      # the two agree exactly — see latex_echo_column().
+      col <- latex_echo_column(location[[3]], source_line(resolve_file(pending$file), at_line))
+      add(pending$file, at_line, pending$message, col = col, from = pending$at, to = i + 2L)
+      pending <<- NULL; return(NULL)
     }
     warning <- regmatches(line, regexec("(?:LaTeX|Package .+) Warning: (.+?)(?: on input line ([0-9]+))?\\.?$", line, perl = TRUE))[[1L]]
-    if (length(warning)) { add(current(), if (nzchar(warning[[3]])) as.integer(warning[[3]]) else 1L, warning[[2]], "warning"); return(NULL) }
+    # A message with no `on input line` has NO line, and saying 1 is inventing
+    # one. "LaTeX Warning: There were undefined references." is about the
+    # document, not about its first line, and a reader sent to line 1 has been
+    # sent somewhere the compiler never pointed. NA travels as a file-level
+    # diagnostic (lib/latex-diagnostics.js anchors it at the top of the file and
+    # marks it `fileLevel`), so nothing is lost and nothing is claimed.
+    if (length(warning)) { add(current(), if (nzchar(warning[[3]])) as.integer(warning[[3]]) else NA_integer_, warning[[2]], "warning"); return(NULL) }
     if (grepl("^error:", line) && !grepl("^error: (halted on|unexpectedly halted)", line)) {
-      add(current(), 1L, sub("^error:[[:space:]]*", "", line)); return(NULL)
+      add(current(), NA_integer_, sub("^error:[[:space:]]*", "", line)); return(NULL)
     }
     # Track log parentheses, including anonymous parentheses, so a closing
     # package group returns !/l.N diagnostics to the including source.
@@ -840,7 +938,7 @@ latex_preview <- function(source, path, buffers = list(), timeout_ms = LATEX_PRE
   }
   bin <- find_pandoc()
   if (!nzchar(bin)) {
-    return(list(ok = FALSE, error = "pandoc is not installed, or CarmaR could not find it. Compile still works; only the live preview needs pandoc."))
+    return(list(ok = FALSE, error = "pandoc is not installed, or Beatrina could not find it. Compile still works; only the live preview needs pandoc."))
   }
   dir <- if (latex_scalar(path) && file.exists(path)) dirname(normalizePath(path, winslash = "/", mustWork = TRUE)) else ""
   keep <- list()
@@ -865,7 +963,7 @@ latex_preview <- function(source, path, buffers = list(), timeout_ms = LATEX_PRE
   # for the same reason. pandoc emits the figure paths unchanged either way —
   # this function resolves them itself, against the ROOT's directory rather
   # than the scratch one, which is what makes the temp file harmless here.
-  input <- tempfile("carmar-preview-", fileext = ".tex")
+  input <- tempfile("beatrina-preview-", fileext = ".tex")
   on.exit(unlink(input), add = TRUE)
   writeLines(expanded, input, useBytes = TRUE)
   Sys.chmod(input, "0600")
@@ -885,8 +983,8 @@ latex_preview <- function(source, path, buffers = list(), timeout_ms = LATEX_PRE
   if (!identical(as.integer(ran$status), 0L)) {
     first <- strsplit(ran$stderr %||% "", "\n", fixed = TRUE)[[1L]][1L] %||% ""
     # pandoc names the file it was reading, and that file is our scratch copy.
-    # Printing "/var/folders/.../carmar-preview-8b42.tex (line 2, column 2)"
-    # at a person tells them nothing and looks like a fault in CarmaR; the
+    # Printing "/var/folders/.../beatrina-preview-8b42.tex (line 2, column 2)"
+    # at a person tells them nothing and looks like a fault in Beatrina; the
     # line and column are the useful half, so the path becomes the document's
     # own name. An unclosed group is the ORDINARY state of a document being
     # typed, which is why this path is a reported note and not a failure —