NEWS

---

ravepipeline 0.2.0.14

• Added RAVEPipelineAnalysis, a small class for writing one analysis as plain functions (input, shiny server, preprocess, analyze, visualize) that the RAVE dashboard or a pipeline runs. The analysis never stores a pipeline: its inputs are saved to and restored from the pipeline settings analysis_inputs_<name>, prerequisite targets are declared with set_preprocess(), and options are set through options or set_option(). When a pipeline is compiled, each analysis defined in its R/shared-*.R scripts becomes the pipeline target analysis_results_<name>, and run() runs an analysis with a pipeline, optionally rendering its visualization as an HTML fragment
• The logger works without shiny installed; it used to print "Cannot log the following call" instead of the message
• PipelineTools$fork() no longer replaces the pipeline root of the session with the folder of the fork, which dropped any root set earlier
• Fixed two long-standing faults in the internal program finder on Linux. It raised invalid 'file' argument when the program was absent and the machine had no Homebrew, and it reported every installed program as missing when one was found. Both affected vscode_bridge_status() and install_vscode_extension(), as well as the discovery of npm and pandoc. macOS and Windows take other branches and were never affected
• Added start_job(method = "vscode_task"), which runs a background job as a native editor task in VSCode and Positron, so the job appears in the terminal panel with a name, live output, and a stop button — the counterpart of the RStudio Jobs pane. This closes a long-standing gap in Positron, where start_job() silently fell back to callr because RStudio's job API is absent. The method falls back to callr whenever the editor integration is unavailable, so it is safe to request anywhere
• Added install_vscode_extension(), uninstall_vscode_extension(), and vscode_bridge_status() to manage and diagnose the companion editor extension, whose sources ship in inst/vscode
• Added vscode_notify(), which raises a VSCode or Positron notification from R through the companion extension, optionally with buttons whose answer is returned to R. It returns at once when no editor window is listening, so it is safe to call anywhere
• A job started with start_job(method = "vscode_task") is now always shown as RAVE-Task [ID: name], rather than whatever name was passed. The name is also the task's identity, so two jobs sharing one now reuse a single terminal instead of opening a new one for every run; a name still in use by a running task is suffixed so both jobs run. A job left unnamed gets a terminal that closes itself once the job ends, whether it succeeded or not, so name any job whose output is worth reading afterwards
• A job started with start_job(method = "rs_job") or start_job(method = "vscode_task") now streams its console output to the RStudio Jobs pane or the editor terminal while it runs, rather than redirecting everything into a log file the caller only sees afterwards. The log file is still written in full, so resolve_job() and the ravepipeline.log_maxline option are unaffected. Jobs run through callr or mirai are unchanged, neither having a console the output could reach
• A saved rave-brain now keeps its electrode prototypes: where each shaft or grid was placed and which channels its contacts carry. They used to be dropped on save and rebuilt from the bare templates on read, so electrodes placed but not yet finalized, such as those staged by the electrode localization module, were lost whenever the brain was read back from a pipeline
• A report from a pipeline that ships report_styles.css no longer links that style sheet by a relative path. rmarkdown runs pandoc in the intermediate folder, where the file is missing, so every such report logged "Could not fetch resource report_styles.css" and kept a link that browsers could not load. The style sheet was, and still is, embedded through the report's own dependency, so reports look the same
• A background job that cannot load its packages no longer leaves start_job() waiting forever. When a package in packages could not be loaded, including ravepipeline itself while it was being reinstalled, the job's error handler failed too: the job stayed "initialized" for good and its error was lost behind could not find function "save_job_status". The job now fails, and resolve_job() raises the original error
• A callr or mirai job whose process ends without reporting a result, for example because it was killed or crashed, is now reported as failed, with the exit status and the last output of the process. start_job(), resolve_job(), lapply_jobs(), and promises from as.promise() used to wait for it forever, or until timeout and then call it still running. A job interrupted with Ctrl+C now fails with "The job was interrupted", and a promise for a job that was removed now rejects instead of never settling
• When lapply_jobs() fails, it now stops the workers still running; they used to carry on in the background
• A callr job is still stopped once nothing holds the object start_job() returned, but it is now reported as failed rather than running forever to whoever checks it by a bare identifier. Keep that object while the job runs: c(), unlist(), as.character(), and indexing return a plain string without the process it holds
• resolve_job() with a finite timeout no longer keeps a processor core busy while it waits on a job that started more than timeout seconds earlier
• start_job() and parallel lapply_jobs() now accept a function whose body is a single value, such as function() 42, which failed with "argument is not a function or language object". A primitive such as sum is still refused, now with a message saying how to wrap it

ravepipeline 0.2.0 (2026-08-22)

• Unified how rave-brain objects are saved and restored: the reference-hook serializers (rave_serialize_impl, used by the default target format, background jobs, and the file-map cache) and the rave-brain target format now share one implementation instead of two that had drifted apart. A brain written by either route comes back with its electrodes (including whether contacts were spheres or prototypes), surfaces, surface annotations, atlases, and streamlines. A brain built outside ravecore — such as threeBrain::threeBrain(path = ...) — is now restored from its own path rather than looked up as a nonexistent RAVE subject, while a brain built by ravecore still resolves its subject directory through ravecore, so moving the data directory does not break it
• Added serialization support for merged brains (multi-rave-brain) to rave_serialize_impl and rave_unserialize_impl; previously only the rave-brain target format handled them
• Serialized brains now record the threeBrain version that wrote them, so parameter lists saved by earlier versions are still read back through a dedicated compatibility path

ravepipeline 0.1.1

• Added define_preference, use_preference, reset_preference, and remove_preference methods to the PipelineTools class: a preference is declared once with a domain, storage type, default, and optional validator, then read and written by its short name instead of its full key. Declared defaults are lazy, so the preference store only holds values that have been explicitly changed, and a revised default reaches anyone who never overrode it. reset_preference drops the stored value and keeps the declaration, so reads fall back to the default; remove_preference deletes both, leaving the preference undeclared
• Declaring a preference is now skipped when it is already up to date, so a module can declare on every launch without touching the disk. Each declaration records a version — the module's, or this package's for global preferences, whose metadata is shared across pipelines — and is only rewritten when that version moves. Revising a default, validator, getter, or type therefore takes effect on a version bump, or immediately with force = TRUE, which logs a warning and is meant for development rather than production
• Preferences gain an optional getter that maps the stored value to whatever the caller should receive, for instance turning a palette name into the colors themselves. use_preference applies it by default and tags the result with the value it was derived from in a preference_value attribute; pass apply_getter = FALSE to read the raw stored value instead
• Added define_preference_multichoice and define_preference_logical, which declare a preference restricted to a fixed set of choices, or a TRUE/FALSE flag, building the validator so that a declaration only needs the choices or the default. define_preference_multichoice takes partial_match, in which case a unique abbreviation is accepted, stored as it was given, and expanded to the full choice on read
• KEY_MISSING is now exported, so that a wrapper around use_preference can take it as the "no value supplied" default and forward it unchanged to read the preference instead of writing it
• Added DISCRETE_COLORMAPS and CONTINUOUS_COLORMAPS, the built-in qualitative and continuous color palettes, along with define_preference_discrete_colormap and define_preference_continuous_colormap, which declare a palette preference validated against the matching table and resolve it to the colors on read
• Building a pipeline now estimates and reports the size of each target as it is built, so unexpectedly large intermediate objects are easier to spot
• RAVEFileArray serialization now carries the file array signature header entries alongside the file base and mode, so downstream caches can see them
• Added pkg_available_reports and pkg_build_report, which list and render the R Markdown reports a package ships under its inst/reports directory. A report is named by its path relative to that directory without the extension, so reports may be grouped into sub-folders, and the name is matched ignoring case. A shared common.css and a per-report <report>_styles.css are picked up automatically and attached to the rendered document

ravepipeline 0.1.0 (2026-05-30)

• Added pipeline_plot_data to help dispatch plot methods defined from within a pipeline, keeping plot logic encapsulated inside the pipeline script
• Added pipeline_translate_settings, pipeline_export_wizard, and pipeline_import_wizard for translating and migrating settings between pipeline versions or modules
• Added import_settings method to the PipelineTools class for importing external settings directly into a pipeline instance; fixed an edge case where the internal settings map was a fastmap2 instead of a plain list
• Pipeline subset operator (pipeline[[...]]) now reads from settings.yaml when the pipeline has not yet been evaluated, providing access to default inputs before a run
• pipeline_get_preferences gains a modes argument for type-mode validation; stored values whose mode() does not match are treated as missing and ifnotfound is returned instead
• Added html_embed_write and html_embed_read to embed and recover arbitrary R objects as hidden data inside HTML documents
• JSON serialization sanitizes inputs before passing them to jsonlite, preventing conversion errors for types that jsonlite cannot encode
• pandoc discovery is now more robust and integrated into RAVE options; fixed RSTUDIO_PANDOC not being set in some environments; fixed pandoc not found on certain systems
• Pipeline reports no longer force toc and code_folding; these can now be customized by the caller; distill is used as an optional report style when the package is available, with rmarkdown as the fallback
• Added a callback argument to pipeline report generation for post-processing hooks; start_job gains log-streaming support so outputs always stream to the console; fixed a log-set bug when the job result is NULL and changed the default behavior to not attach the log file
• lapply_jobs now evaluates the worker function in the runtime_env environment so global helper functions defined in the same script can reference each other correctly
• PipelineTools$run_as_task enables running a pipeline as a shiny ExtendedTask, allowing non-blocking pipeline execution inside a Shiny app without blocking the session; pipelines also support early cancellation
• Added MCP helper utilities (docs_package_help_topics, docs_help_page, docs_package_implementation, search_package_info) for use with rave-pipelines repository tooling
• Pipeline templates are updated to match the latest shidashi framework changes; a timestamp is written on template updates; Python sub-module presence is verified before import
• ravepipeline_finalize_installation is now exported for post-install setup
• Miscellaneous fixes: corrected detect_generic_land() lookup, tightened embedding metadata accuracy, and removed obsolete vignettes

ravepipeline 0.0.3 (2025-09-10)

• Removed raveio from templates
• Internally, rs_job considers Positron-IDE
• Fixed incorrect path issue when the report working directory and output folder are identical
• Using distill for default report style, if available
• Added SVG plots to allow image overlays
• Added base64URI; using base64enc for more general base64 converter
• Fixed a bug where lapply_jobs callback fail to run due to zero-length messages
• Job processes are killed by default when the job is removed
• start_job uses callr for maximized consistency by default
• During @unmarshal, the package is loaded by default
• Pipeline serialization has been implemented
• Stores process handlers in the job ID to avoid the process to be shut down accidentally by garbage collector
• Fixed pipeline paths, added behavior for subjects
• Pipeline report has more allowed tweaks (theme, style, parameter)
• Implemented serialization for brain object

ravepipeline 0.0.2

• with_rave_parallel with one worker no longer runs in background, though users can force enabling this
• Added comparisons to RAVESerializable objects, allowing comparisons of two R6 objects inheriting this class
• Added RAVEFileArray to wrap against FileArray, allowing file-arrays to be serialized faster when running with mirai
• Added lapply_jobs, allowing down-stream packages to use it for looping with similar behaviors to lapply, while giving users options to parallel computing the results with with_rave_parallel
• Added RAVESerializable class for mirai, allowing for fast serialization when running lapply_jobs
• cat2 is no longer used as logging system and used logger instead
• Added rave_progress to replace dipsaus; removed dependencies on dipsaus
• Migrated logger from ravedash so this function can be used by ravecore and other depending packages
• Added print method to background jobs
• Added mirai as the optional background engine to run jobs
• Pipeline evaluation will have RAVE_PIPELINE_ACTIVE environment set to "true" to allow fast compile and debugging
• pipeline$read once disabled by targets during evaluation can now runs again with hacks
• Pipeline attach method also mounts shared environment for debugging
• Implemented pipeline reporting functions
• Added start_job to start background jobs, which can be converted into promises
• Make sure installing new snippets overwrites existing scripts
• Unset reporters for older versions of targets
• Fixed lazy evaluation issues
• Fixed a bug introduced by targets version 1.11.1 where use-after-free of cli progress crashes the pipeline run, the newer versions of that package has fixed it too
• Added optional functions to handle old raveio calls
• Removed questions once asked
• save yaml format now sort native lists with sorted=TRUE
• Removed call_pkg_fun for rstudioapi and use the package functions directly to avoid messing up with sys.call()
• Fixed entrace
• Added pipeline collections

ravepipeline 0.0.1 (2025-03-13)

• Initial CRAN submission.