From da31527b6c1ba3cb12280515489407cfbbb44f2f Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Mon, 9 Mar 2026 23:22:32 -0700
Subject: [PATCH 01/47] docs: add documentation for R and VS Code IPC
 mechanisms

---
 session.md | 650 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 650 insertions(+)
 create mode 100644 session.md

diff --git a/session.md b/session.md
new file mode 100644
index 00000000..7f6cc950
--- /dev/null
+++ b/session.md
@@ -0,0 +1,650 @@
+# R and VS Code Inter-Process Communication (IPC)
+
+The communication between the R session and VS Code involves two primary mechanisms:
+
+1. **R to VS Code (Asynchronous)**: File-based IPC mechanisms used to push data or trigger UI actions in VS Code. It uses specific pairs of data/log and lock files:
+   - **Command Dispatch:** `request.log` and `request.lock`
+   - **Workspace State:** `workspace.json` and `workspace.lock`
+   - **Static Plots:** `plot.png` and `plot.lock`
+2. **VS Code to R (Synchronous)**: HTTP Server IPC where R runs a local `httpuv` server that VS Code queries.
+
+Here are the relevant code snippets for each mechanism.
+
+---
+
+## 1. R to VS Code (File-based IPC)
+
+When R wants to push data or trigger UI actions in VS Code, it writes a payload or image to a temporary file and updates a corresponding lock file to notify VS Code's file system watcher.
+
+### 1.1 Command Dispatch (`request.log`)
+
+The base function used to send requests from R is `request()`. It writes the command and arguments to `request_file` and updates `request_lock_file` with a timestamp.
+
+#### R Component ([`R/session/vsc.R`](R/session/vsc.R))
+
+```r
+get_timestamp <- function() {
+    sprintf("%.6f", Sys.time())
+}
+
+request <- function(command, ...) {
+    obj <- list(
+        time = Sys.time(),
+        pid = pid,
+        wd = wd,
+        command = command,
+        ...
+    )
+    jsonlite::write_json(obj, request_file,
+        auto_unbox = TRUE, null = "null", force = TRUE
+    )
+    cat(get_timestamp(), file = request_lock_file)
+}
+```
+
+R uses this core `request` function to send 8 distinct types of commands to VS Code. Below are snippets representing how each command is triggered from R:
+
+**1. webview**: Opens a local HTML file in a VS Code Webview panel (e.g., for htmlwidgets). [-> `show_webview`](R/session/vsc.R#L729)
+
+```r
+show_webview <- function(url, title, ..., viewer) {
+    if (file.exists(url)) {
+        file <- normalizePath(url, "/", mustWork = TRUE)
+        request("webview", file = file, title = title, viewer = viewer, ...)
+    }
+}
+```
+
+**2. browser**: Opens an external URL or help page via VS Code. [-> `request_browser`](R/session/vsc.R#L675)
+
+```r
+request_browser <- function(url, title, ..., viewer) {
+    request("browser", url = url, title = title, ..., viewer = viewer)
+}
+```
+
+**3. dataview**: Opens the built-in VS Code data viewer (triggered by `View()`).
+
+```r
+# Inside dataview handler for a table/dataframe
+file <- tempfile(tmpdir = tempdir, fileext = ".json")
+jsonlite::write_json(data, file, na = "string", null = "null", auto_unbox = TRUE, force = TRUE)
+request("dataview", source = "table", type = "json",
+    title = title, file = file, viewer = viewer, uuid = uuid
+)
+```
+
+**4. httpgd**: Notifies VS Code that an `httpgd` plot graphics device is ready.
+
+```r
+.vsc$request("httpgd", url = httpgd::hgd_url())
+```
+
+**5. attach**: Called when the R session starts and attaches to VS Code, providing session metadata and the `SessionServer` credentials. [-> `attach`](R/session/vsc.R#L639)
+
+```r
+attach <- function() {
+    request("attach",
+        version = sprintf("%s.%s", R.version$major, R.version$minor),
+        tempdir = tempdir,
+        info = list(...)
+    )
+}
+```
+
+**6. detach**: Called when the R session is closing to clean up resources.
+
+```r
+reg.finalizer(.GlobalEnv, function(e) .vsc$request("detach"), onexit = TRUE)
+```
+
+**7. help**: Opens the help documentation panel inside VS Code.
+
+```r
+request(command = "help", requestPath = requestPath, viewer = viewer)
+```
+
+**8. rstudioapi**: Emulates an `rstudioapi` request synchronously. It waits for VS Code to respond using a `response.lock` polling mechanism.
+
+```r
+request_response <- function(command, ...) {
+    request(command, ..., sd = dir_session)
+    wait_start <- Sys.time()
+    while (!get_response_lock()) {
+        # Loop and sleep waiting for VS Code to reply
+    }
+}
+# (Dispatches to request_response with command = "rstudioapi")
+```
+
+#### TypeScript Component ([`src/session.ts`](src/session.ts))
+
+VS Code uses `fs.watch` to monitor the `request.lock` file. When modified, it reads `request.log` and dispatches the command.
+
+```typescript
+export function startRequestWatcher(sessionStatusBarItem: StatusBarItem): void {
+    requestFile = path.join(homeExtDir(), 'request.log');
+    requestLockFile = path.join(homeExtDir(), 'request.lock');
+    requestTimeStamp = 0;
+    
+    // Watch the lock file for changes
+    fs.watch(requestLockFile, {}, () => {
+        void updateRequest(sessionStatusBarItem);
+    });
+}
+```
+
+Inside `updateRequest`, the JSON payload is parsed and the specific `command` is passed to its respective handler function. Here is a detailed breakdown of how each command is resolved in VS Code:
+
+**1. `webview` Handler**
+
+```typescript
+case 'webview': {
+    if (request.file && request.title && request.viewer !== undefined) {
+        await showWebView(request.file, request.title, request.viewer);
+    }
+    break;
+}
+```
+
+**Detail (`showWebView` [-> src/session.ts#L313](src/session.ts#L313)):**
+This handles local HTML content, most notably interactive `htmlwidgets`.
+
+```typescript
+export async function showWebView(file: string, title: string, viewer: string | boolean): Promise<void> {
+    if (viewer === false) {
+        void env.openExternal(Uri.file(file));
+    } else {
+        const dir = path.dirname(file);
+        const webviewDir = extensionContext.asAbsolutePath('html/session/webview/');
+        const panel = window.createWebviewPanel('webview', title,
+            { preserveFocus: true, viewColumn: ViewColumn[String(viewer) as keyof typeof ViewColumn] },
+            {
+                enableScripts: true, enableFindWidget: true, retainContextWhenHidden: true,
+                localResourceRoots: [Uri.file(dir), Uri.file(webviewDir)],
+            });
+        panel.iconPath = new UriIcon('globe');
+        panel.webview.html = await getWebviewHtml(panel.webview, file, title, dir, webviewDir);
+    }
+}
+```
+
+1. **Fallback to OS Browser**: If `viewer` is explicitly `false`, it bypasses VS Code and opens the file in the OS's default external browser via `env.openExternal(Uri.file(file))`.
+2. **Creating the Panel**: Otherwise, `showWebView()` uses the VS Code API `window.createWebviewPanel()` to instantiate a native panel.
+3. **Security and Access**: It explicitly restricts file system access by setting `localResourceRoots`. It only allows the webview to read assets from two places: the directory containing the HTML file itself (so local CSS/JS dependencies can load), and the extension's `html/session/webview/` directory.
+4. **HTML Injection**: It calls `getWebviewHtml()` ([-> src/session.ts#L651](src/session.ts#L651)), which reads the target HTML file into a string. Crucially, it uses a regular expression to rewrite all relative `href` and `src` paths into secure `vscode-webview-resource://` URIs by prepending `webview.asWebviewUri(Uri.file(dir))`. Finally, it wraps the content with a Content Security Policy (CSP) and injects a custom `observer.js` script to handle layout updates, before assigning the final string to `panel.webview.html`.
+
+**2. `browser` Handler**
+
+```typescript
+case 'browser': {
+    if (request.url && request.title && request.viewer !== undefined) {
+        await showBrowser(request.url, request.title, request.viewer);
+    }
+    break;
+}
+```
+
+**Detail (`showBrowser` [-> src/session.ts#L225](src/session.ts#L225)):**
+This handles external URLs and active R servers (like the R help server).
+
+```typescript
+export async function showBrowser(url: string, title: string, viewer: string | boolean): Promise<void> {
+    const uri = Uri.parse(url);
+    if (viewer === false) {
+        void env.openExternal(uri);
+    } else {
+        const externalUri = await env.asExternalUri(uri);
+        const panel = window.createWebviewPanel('browser', title,
+            { preserveFocus: true, viewColumn: ViewColumn[String(viewer) as keyof typeof ViewColumn] },
+            { enableFindWidget: true, enableScripts: true, retainContextWhenHidden: true });
+        
+        // event listeners for activeBrowserPanel omitted for brevity
+        
+        panel.iconPath = new UriIcon('globe');
+        panel.webview.html = getBrowserHtml(externalUri); // Injects <iframe src="${uri}" width="100%" height="100%" />
+    }
+}
+```
+
+1. **URI Translation**: It uses `env.asExternalUri(uri)` on the requested URL. This is a critical step because if the VS Code session is running remotely (e.g., via SSH, GitHub Codespaces, or Dev Containers), this VS Code API automatically sets up an encrypted port-forwarding tunnel so the local IDE can access the remote R HTTP server securely.
+2. **Creating the Panel**: Like `webview`, it creates a `WebviewPanel` titled "browser".
+3. **State Management**: It attaches event listeners to track the active browser state (`activeBrowserPanel` and `activeBrowserUri`). This allows the extension to provide fallback commands like `refreshBrowser` or `openExternalBrowser` on the currently viewed page.
+4. **Iframe Embedding**: Instead of reading file contents, `getBrowserHtml()` simply generates a lightweight HTML template containing a fullscreen `<iframe src="${uri}" width="100%" height="100%" />` element. This embeds the live web page directly inside the IDE panel.
+
+**3. `dataview` Handler**
+
+```typescript
+case 'dataview': {
+    if (request.source && request.type && request.file && request.title && request.viewer !== undefined) {
+        await showDataView(request.source, request.type, request.title, request.file, request.viewer);
+    }
+    break;
+}
+```
+
+**Detail (`showDataView` [-> src/session.ts#L337](src/session.ts#L337)):**
+Activated by calling `View()` on an R object (like a `data.frame` or `list`).
+
+```typescript
+export async function showDataView(source: string, type: string, title: string, file: string, viewer: string): Promise<void> {
+    if (source === 'table') {
+        const panel = window.createWebviewPanel('dataview', title,
+            { preserveFocus: true, viewColumn: ViewColumn[viewer as keyof typeof ViewColumn] },
+            { enableScripts: true, enableFindWidget: true, retainContextWhenHidden: true, localResourceRoots: [Uri.file(resDir)] });
+        panel.iconPath = new UriIcon('open-preview');
+        panel.webview.html = await getTableHtml(panel.webview, file);
+    } else if (source === 'list') {
+        // similar to table, but calls getListHtml
+    } else {
+        // Fallback for raw text 'object'
+        await commands.executeCommand('vscode.open', Uri.file(file), {
+            preserveFocus: true, preview: true, viewColumn: ViewColumn[viewer as keyof typeof ViewColumn],
+        });
+    }
+}
+```
+
+1. **Data Source - Table**: If the source is `'table'`, `showDataView()` creates a webview panel and gives it access to the extension's `dist/resources` folder. It reads the temporary `.json` data file dumped by R and passes the raw JSON into `getTableHtml()`. This function injects the data into an HTML template bundled with `ag-grid-community`, rendering a rich, interactive, sortable, filterable, and paginated data table interface purely via JavaScript.
+2. **Data Source - List**: If the source is `'list'`, it takes a similar approach but uses `getListHtml()`, rendering the data as a collapsible JSON tree view.
+3. **Fallback - Virtual Document**: If the object was too complex to serialize to JSON and R fell back to an `'object'` representation text file (`txt`), it skips the Webview entirely. Instead, it reads the file and opens it natively inside the IDE as a read-only Virtual Document using `vscode.open` and a custom document provider.
+
+**4. `httpgd` Handler**
+
+```typescript
+case 'httpgd': {
+    if (request.url) {
+        await globalHttpgdManager?.showViewer(request.url);
+    }
+    break;
+}
+```
+
+**Detail (`httpgd` [-> src/plotViewer/index.ts#L72](src/plotViewer/index.ts#L72)):**
+Triggered when an R script opens an `httpgd` graphics device (a modern SVG/HTML-based plotting device for R).
+
+1. **Intercepting the URL**: R tells VS Code the exact local URL/port where the `httpgd` server is streaming the plots.
+2. **Delegation to Manager**: The session handler passes this URL to the `globalHttpgdManager` (an instance of `HttpgdManager` defined in `src/plotViewer/index.ts`).
+3. **Viewer Instantiation**: The manager parses the URL, extracting the host and security token. It searches to see if a viewer for that host already exists. If not, it instantiates a new `HttpgdViewer`.
+4. **Webview Rendering**: The `HttpgdViewer` spins up a dedicated `WebviewPanel`. Instead of just embedding the plot as a static image, it loads a full React-based frontend application (bundled in the extension's resources) into the webview. This frontend connects directly to the R `httpgd` server via WebSockets to provide a live, interactive, resizable plot viewer with history tracking and export capabilities.
+
+**5. `attach` Handler**
+
+```typescript
+case 'attach': {
+    if (!request.tempdir || !request.wd) return;
+    // Update local variables
+    rVer = String(request.version);
+    pid = String(request.pid);
+    sessionDir = path.join(request.tempdir, 'vscode-R');
+
+    // UI Updates
+    sessionStatusBarItem.text = `R ${rVer}: ${pid}`;
+    sessionStatusBarItem.show();
+    await setContext('rSessionActive', true);
+
+    if (request.server) {
+        server = request.server;
+    }
+    void watchProcess(pid).then((v: string) => { void cleanupSession(v); });
+    break;
+}
+```
+
+**Detail (`attach`):**
+This is the foundational bootstrapping command. When R starts and sources the VS Code initialization script, it fires this payload.
+
+1. **State Initialization**: It caches critical session metadata into global variables: the active Process ID (`pid`), the R version (`rVer`), and the temporary session directory (`sessionDir`).
+2. **Status Bar Integration**: It updates the VS Code Status Bar at the bottom of the screen (e.g., displaying "R 4.3: 12345") to give the user visual confirmation that the IDE is hooked into the R terminal.
+3. **Context Switching**: It sets the VS Code context key `rSessionActive` to `true`. This enables context-aware menus, shortcuts, and features that should only be visible when R is running.
+4. **Synchronous IPC Setup**: Critically, it extracts the `request.server` object (which contains the `{httpuv}` host, port, and auth token) and saves it to the exported `server` variable, fully enabling the Synchronous HTTP IPC channel.
+5. **Process Monitoring**: It initiates `watchProcess(pid)` ([-> src/session.ts#L862](src/session.ts#L862)). This sets up an OS-level listener (using `process.kill(pid, 0)` checks or equivalent) to continuously monitor if the R process is alive. If the terminal is killed or R crashes, the watcher resolves, immediately triggering `cleanupSession()`.
+
+**6. `detach` Handler**
+
+```typescript
+case 'detach': {
+    if (request.pid) {
+        await cleanupSession(request.pid);
+    }
+    break;
+}
+```
+
+**Detail (`detach` / `cleanupSession` [-> src/session.ts#L845](src/session.ts#L845)):**
+Triggered explicitly by R's `.GlobalEnv` finalizer when the session is closing cleanly, or triggered forcefully by the `watchProcess` monitor if R crashes.
+
+1. **State Verification**: `cleanupSession(pidArg)` first checks if the `pid` trying to detach matches the currently tracked `pid`. This prevents race conditions if multiple R terminals are open.
+2. **UI Teardown**: It resets the status bar text to "R: (not attached)".
+3. **Data Clearing**: It aggressively clears the cached data. It sets `server = undefined` (cutting off HTTP IPC), empties the `workspaceData` (global environment variables, loaded namespaces), and commands the UI Workspace Viewer to refresh (effectively blanking out the variable explorer).
+4. **Addin Purging**: It calls `purgeAddinPickerItems()`, clearing out any cached RStudio Addins that were registered by that specific R session.
+
+**7. `help` Handler**
+
+```typescript
+case 'help': {
+    if (globalRHelp && request.requestPath) {
+        await globalRHelp.showHelpForPath(request.requestPath, request.viewer);
+    }
+    break;
+}
+```
+
+**Detail (`help` [-> src/helpViewer/index.ts#L587](src/helpViewer/index.ts#L587)):**
+Activated when you use `?function` or `help()` in R.
+
+1. **Delegation**: It passes the specific help path to the `globalRHelp` provider (an instance of `RHelp` from `src/helpViewer/index.ts`).
+2. **Internal Server Hook**: VS Code doesn't just open a dumb browser. R's internal dynamic help server (which handles parsing `.Rd` files to HTML) is running in the background. The `globalRHelp` manager constructs the correct URL targeting R's internal help port.
+3. **Custom Webview**: It opens a custom `HelpPanel` webview. This webview does not just display the HTML; it intercepts internal link clicks. If you click a link to another package's documentation, the webview intercepts the navigation event, prevents a full page reload, and requests the new content via the VS Code IPC, resulting in a much faster, app-like navigation experience for R help files.
+
+**8. `rstudioapi` Handler**
+
+```typescript
+case 'rstudioapi': {
+    if (request.action && request.args && request.sd) {
+        await dispatchRStudioAPICall(request.action, request.args, request.sd);
+    }
+    break;
+}
+```
+
+**Detail (`rstudioapi` [-> src/rstudioapi.ts#L22](src/rstudioapi.ts#L22)):**
+This is a complex bridge that allows R scripts (or packages that depend on `{rstudioapi}`) to natively control the VS Code editor, mimicking RStudio IDE behaviors.
+
+1. **Synchronous Blocking in R**: When R calls an `rstudioapi` function, the R process writes the request to `request.log` and then enters an infinite `while` loop, aggressively polling for the existence of a `response.log` file. R is completely blocked at this point.
+2. **Action Dispatching**: VS Code receives the request and passes it to `dispatchRStudioAPICall()` (in `src/rstudioapi.ts`). This function contains a large `switch` statement handling RStudio API actions like:
+    - `active_editor_context`: Gets the currently selected text and cursor position using VS Code's `window.activeTextEditor`.
+    - `insert_or_modify_text`: Applies a `WorkspaceEdit` using the VS Code API to programmatically type code into the editor.
+    - `navigate_to_file`: Uses `vscode.open` to jump the user's cursor to a specific file and line.
+3. **Unblocking R**: Once the VS Code API task completes, the handler MUST resolve the blocking loop. It does this by calling `writeResponse(data, sd)` or `writeSuccessResponse(sd)`. This function writes the requested data (or a simple boolean `true`) into a `response.log` file located in the session directory, and creates a `response.lock` file.
+4. **Resumption**: R's polling loop detects the lock file, reads the response data, breaks the loop, and returns the data back to the original `{rstudioapi}` function call.
+
+### 1.2 Workspace State (`workspace.json`)
+
+To populate the VS Code Workspace Viewer (Variable Explorer), R continuously monitors the `.GlobalEnv` and serializes its structure whenever it changes.
+
+#### R Component
+
+R maintains an `update_workspace` function that compares the current `.GlobalEnv` against a cached `globalenv_cache`. It calls `inspect_env` to extract metadata (type, class, size, dimensions, and a string preview using `capture_str()`) for all variables. This structured list is serialized via `jsonlite::write_json()` to `workspace.json`, and `workspace.lock` is updated with a timestamp.
+
+```r
+update_workspace <- function(...) {
+    tryCatch({
+        data <- list(
+            globalenv = if (show_globalenv) inspect_env(.GlobalEnv, globalenv_cache) else NULL
+        )
+        jsonlite::write_json(data, workspace_file, force = TRUE, pretty = FALSE)
+        cat(get_timestamp(), file = workspace_lock_file)
+    }, error = message)
+    TRUE
+}
+```
+
+#### TypeScript Component
+
+VS Code watches `workspace.lock` inside `updateSessionWatcher()`. When it detects a change, it reads the newly updated `workspace.json`, parses it into the global `workspaceData` object, and triggers a refresh event on the `workspaceViewer`. The tree view in VS Code then natively renders the updated variables and their properties.
+
+```typescript
+async function updateWorkspace() {
+    const lockContent = await fs.readFile(workspaceLockFile, 'utf8');
+    const newTimeStamp = Number.parseFloat(lockContent);
+    if (newTimeStamp !== workspaceTimeStamp) {
+        workspaceTimeStamp = newTimeStamp;
+        if (fs.existsSync(workspaceFile)) {
+            const content = await fs.readFile(workspaceFile, 'utf8');
+            workspaceData = JSON.parse(content) as WorkspaceData;
+            void rWorkspace?.refresh(); // Refreshes the Workspace Viewer Tree
+        }
+    }
+}
+```
+
+### 1.3 Static Plotting (`plot.png`)
+
+For users not using the modern `httpgd` device, R can be configured to produce static plots that are automatically displayed in VS Code.
+
+#### R Component
+
+R configures a custom `options(device = ...)` that initializes a null PDF device (to capture drawing operations silently). It overrides graphics hooks (`setHook("plot.new", ...)` and `rebind(".External.graphics", ...)`). When a plot is fully drawn, the `update_plot` function renders it using `png()` to a temporary `plot.png` file, then updates `plot.lock` with a timestamp.
+
+```r
+update_plot <- function(...) {
+    if (plot_updated && check_null_dev()) {
+        plot_updated <<- FALSE
+        record <- recordPlot()
+        if (length(record[[1L]])) {
+            dev_args <- getOption("vsc.dev.args")
+            do.call(png, c(list(filename = plot_file), dev_args))
+            on.exit({
+                dev.off()
+                cat(get_timestamp(), file = plot_lock_file)
+            })
+            replayPlot(record)
+        }
+    }
+    TRUE
+}
+```
+
+#### TypeScript Component
+
+Similar to the workspace watcher, VS Code monitors `plot.lock`. When modified, it uses the VS Code native API `vscode.open` to display the updated `plot.png` file in a built-in image viewer panel.
+
+```typescript
+async function updatePlot() {
+    const lockContent = await fs.readFile(plotLockFile, 'utf8');
+    const newTimeStamp = Number.parseFloat(lockContent);
+    if (newTimeStamp !== plotTimeStamp) {
+        plotTimeStamp = newTimeStamp;
+        if (fs.existsSync(plotFile) && fs.statSync(plotFile).size > 0) {
+            void commands.executeCommand('vscode.open', Uri.file(plotFile), {
+                preserveFocus: true,
+                preview: true,
+                viewColumn: ViewColumn[(config().get<string>('session.viewers.viewColumn.plot') || 'Two') as keyof typeof ViewColumn],
+            });
+        }
+    }
+}
+```
+
+---
+
+## 2. VS Code to R (Synchronous HTTP IPC)
+
+For synchronous querying (e.g., fetching hover information, workspace variables, or autocomplete suggestions), the file-based IPC is too slow and chaotic. Instead, VS Code acts as an HTTP client sending POST requests directly to an internal HTTP server hosted by the R process.
+
+### R Component (`R/session/vsc.R`)
+
+Upon attaching to the VS Code terminal, R initializes a background HTTP server using the `{httpuv}` package.
+
+1. **Security and Bootstrapping**: It generates a secure, randomized `token` and binds to a `randomPort()` on `127.0.0.1`. It passes these credentials back to VS Code via the initial file-based `"attach"` request.
+2. **Request Routing**: The `httpuv` server listens for HTTP POST requests. When a request arrives, it validates the `HTTP_AUTHORIZATION` header against its secret token.
+3. **JSON Payload parsing**: It parses the body of the request (which is sent as JSON from VS Code) to figure out the `type` of request.
+4. **Request Handlers**: It routes the execution to specific functions defined in `request_handlers`.
+    - `hover`: Evaluates an expression (like a variable name the user is hovering over) in the `.GlobalEnv` and uses `capture_str()` to return a formatted string representation of the object's structure.
+    - `complete`: Handles autocompletion logic. For example, if the user types `df$`, the server intercepts the `$` trigger, evaluates `df`, and uses `.DollarNames` to return a list of all column names and their data types back to VS Code.
+
+```r
+        # Bootstrapping the Session Server
+        host <- "127.0.0.1"
+        port <- httpuv::randomPort()
+        token <- sprintf("%d:%d:%.6f", pid, port, Sys.time())
+        
+        request_handlers <- list(
+            hover = function(expr, ...) {
+                tryCatch({
+                    expr <- parse(text = expr, keep.source = FALSE)[[1]]
+                    obj <- eval(expr, .GlobalEnv)
+                    list(str = capture_str(obj))
+                }, error = function(e) NULL)
+            },
+            complete = function(expr, trigger, ...) {
+                # Logic to handle '$' or '@' triggers and return available names/slots
+                # ...
+            }
+        )
+
+        server <- httpuv::startServer(host, port,
+            list(
+                onHeaders = function(req) {
+                    # Validate auth token
+                    if (!identical(req[["HTTP_AUTHORIZATION"]], token)) {
+                        return(list(status = 401L, headers = list("Content-Type" = "text/plain"), body = "Unauthorized"))
+                    }
+                    # ...
+                },
+                call = function(req) {
+                    content <- req$rook.input$read_lines()
+                    request <- jsonlite::fromJSON(content, simplifyVector = FALSE)
+                    
+                    # Route to internal request handlers based on type (e.g., 'hover', 'complete')
+                    handler <- request_handlers[[request$type]]
+                    response <- if (is.function(handler)) do.call(handler, request)
+
+                    list(
+                        status = 200L,
+                        headers = list("Content-Type" = "application/json"),
+                        body = jsonlite::toJSON(response, auto_unbox = TRUE, force = TRUE)
+                    )
+                }
+            )
+        )
+        attr(server, "token") <- token
+        options(vsc.server = server)
+```
+
+### TypeScript Component (`src/session.ts` and `src/completions.ts`)
+
+Once VS Code receives the `"attach"` payload from R, it globally caches the `SessionServer` details. It then exposes a `sessionRequest` helper function for various UI Language Providers.
+
+**The `sessionRequest` Function (`src/session.ts`)**:
+This is a wrapper around `node-fetch`. It sends an HTTP POST request to `http://${server.host}:${server.port}`, stringifies the requested data into the JSON body, and critically, attaches the `server.token` to the `Authorization` header. It then awaits the JSON response.
+
+```typescript
+export interface SessionServer {
+    host: string;
+    port: number;
+    token: string;
+}
+
+export let server: SessionServer | undefined;
+
+// Function called by language features (hover, completion, etc.)
+export async function sessionRequest(server: SessionServer, data: any): Promise<any> {
+    try {
+        const response = await fetch(`http://${server.host}:${server.port}`, {
+            agent: httpAgent, // Keep-alive agent
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                Authorization: server.token
+            },
+            body: JSON.stringify(data),
+            follow: 0,
+            timeout: 500, // Very short timeout for snappiness
+        });
+
+        if (!response.ok) throw new Error(`Error! status: ${response.status}`);
+        return response.json();
+    } catch (error) {
+        console.log('error: ', error);
+    }
+}
+```
+
+**Implementation in Language Providers (`src/completions.ts`)**:
+When a user interacts with the editor (like hovering over a word or typing `$` to trigger completions), VS Code's extension API fires its respective provider events. These providers intercept the event, parse the text, and use `sessionRequest()` to ask the R HTTP server for live execution context.
+
+**1. Hover Provider (`type: 'hover'`):** [-> src/completions.ts#L34](src/completions.ts#L34)
+When you hover your mouse over a variable (e.g., `my_data`) in the editor:
+
+- **VS Code (Request)**: The `HoverProvider` in `src/completions.ts` uses a regex to grab the word under the cursor. It sends a JSON payload to the HTTP server: `{ "type": "hover", "expr": "my_data" }`.
+- **R (Processing)**: The `hover` handler inside `vsc.R`'s `request_handlers` takes over. It uses `parse(text = expr)` to turn the string into an R expression, and `eval(expr, .GlobalEnv)` to safely evaluate it in the global workspace. It then passes the resulting object into a custom `capture_str()` function (a wrapper around R's native `str()` function) to generate a concise, human-readable structural summary of the object.
+- **R (Response)**: It returns `{ "str": "data.frame': 3 obs. of  2 variables:\n $ x: num 1 2 3\n $ y: chr 'a' 'b' 'c'" }`.
+- **VS Code (Rendering)**: The Hover Provider receives this JSON, extracts the `.str` property, and wraps it in a `vscode.MarkdownString` formatted as an R code block (` ```r `). This is what pops up in the IDE as the hover tooltip.
+
+```typescript
+export class HoverProvider implements vscode.HoverProvider {
+    async provideHover(document: vscode.TextDocument, position: vscode.Position): Promise<vscode.Hover | null> {
+        // ... (Environment and Rmd checks omitted) ...
+
+        let hoverRange = document.getWordRangeAtPosition(position);
+        let hoverText = null;
+
+        if (session.server) {
+            const exprRegex = /([a-zA-Z0-9._$@ ])+(?<![@$])/;
+            hoverRange = document.getWordRangeAtPosition(position, exprRegex)?.with({ end: hoverRange?.end });
+            const expr = document.getText(hoverRange);
+            const response = await session.sessionRequest(session.server, {
+                type: 'hover',
+                expr: expr
+            });
+
+            if (response) {
+                hoverText = response.str;
+            }
+        } // ...
+
+        if (hoverText) {
+            return new vscode.Hover(`\`\`\`\n${hoverText}\n\`\`\``, hoverRange);
+        }
+        return null;
+    }
+}
+```
+
+**2. Completion Provider (`type: 'complete'`):** [-> src/completions.ts#L133](src/completions.ts#L133)
+When you type a trigger character like `$` (for lists/dataframes) or `@` (for S4 objects), you expect to see the internal properties of that object.
+
+- **VS Code (Request)**: If you type `df$`, the `CompletionItemProvider` grabs the `df` preceding the cursor and sends: `{ "type": "complete", "expr": "df", "trigger": "$" }`.
+- **R (Processing)**: The `complete` handler in `vsc.R` evaluates `df`. If it evaluates successfully, it checks the `trigger`:
+  - If `trigger == "$"`, it uses R's internal `.DollarNames(obj)` (for objects) or `names(obj)` (for recursive lists) to get an array of available property names.
+  - If `trigger == "@"`, it uses `slotNames(obj)` to get the S4 slot names.
+  - It then loops over those names. For each property (e.g., a specific column in a dataframe), it determines its `typeof()` and uses `try_capture_str()` to get a preview of its contents.
+- **R (Response)**: It returns a JSON array of `RObjectElement` items: `[ { "name": "col_A", "type": "double", "str": "num [1:10] 1.5 2.1..." }, ... ]`.
+- **VS Code (Rendering)**: The Completion Provider receives this array and passes it to `getCompletionItemsFromElements()` ([-> src/completions.ts#L221](src/completions.ts#L221)). This helper function loops over the R items and converts them into native VS Code `vscode.CompletionItem` objects.
+  - `e.name` becomes the label shown in the dropdown list.
+  - `e.type` determines the icon (e.g., if it's a "closure" or "builtin", it gets a Function icon $f(x)$, otherwise it gets a Variable/Field icon).
+  - `e.str` is wrapped in a Markdown code block and attached to `item.documentation`, so when you highlight a column name in the dropdown, a side-panel shows you a preview of the data inside that column.
+  - Finally, the provider returns these items, and VS Code renders the native Intellisense UI.
+
+```typescript
+export class LiveCompletionItemProvider implements vscode.CompletionItemProvider {
+    async provideCompletionItems(
+        document: vscode.TextDocument,
+        position: vscode.Position,
+        token: vscode.CancellationToken,
+        completionContext: vscode.CompletionContext
+    ): Promise<vscode.CompletionItem[]> {
+        const items: vscode.CompletionItem[] = [];
+        // ... (Environment and Rmd checks omitted) ...
+        const trigger = completionContext.triggerCharacter;
+
+        if (trigger === undefined) {
+            // ... Populate from workspaceData.globalenv (fallback) ...
+        } else if(trigger === '$' || trigger === '@') {
+            const symbolPosition = new vscode.Position(position.line, position.character - 1);
+            if (session.server) {
+                const re = /([a-zA-Z0-9._$@ ])+(?<![@$])/;
+                const exprRange = document.getWordRangeAtPosition(symbolPosition, re)?.with({ end: symbolPosition });
+                const expr = document.getText(exprRange);
+                
+                // Request live completions from R via HTTP
+                const response: RObjectElement[] = await session.sessionRequest(session.server, {
+                    type: 'complete',
+                    expr: expr,
+                    trigger: completionContext.triggerCharacter
+                });
+
+                if (response) {
+                    items.push(...getCompletionItemsFromElements(response, '[session]'));
+                }
+            } // ...
+        }
+        
+        // ...
+        return items;
+    }
+}
+```

From fcfbf20f3e1acac0e715ebe5d0c4dc57cffd44bf Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Wed, 11 Mar 2026 01:03:37 -0700
Subject: [PATCH 02/47] feat: introduce vscr package for modern R IPC

---
 vscr/DESCRIPTION  | 16 ++++++++++
 vscr/NAMESPACE    |  7 +++++
 vscr/R/dispatch.R | 26 ++++++++++++++++
 vscr/R/handlers.R | 79 +++++++++++++++++++++++++++++++++++++++++++++++
 vscr/R/hooks.R    | 56 +++++++++++++++++++++++++++++++++
 vscr/R/server.R   | 62 +++++++++++++++++++++++++++++++++++++
 vscr/R/utils.R    | 27 ++++++++++++++++
 vscr/R/zzz.R      | 30 ++++++++++++++++++
 8 files changed, 303 insertions(+)
 create mode 100644 vscr/DESCRIPTION
 create mode 100644 vscr/NAMESPACE
 create mode 100644 vscr/R/dispatch.R
 create mode 100644 vscr/R/handlers.R
 create mode 100644 vscr/R/hooks.R
 create mode 100644 vscr/R/server.R
 create mode 100644 vscr/R/utils.R
 create mode 100644 vscr/R/zzz.R

diff --git a/vscr/DESCRIPTION b/vscr/DESCRIPTION
new file mode 100644
index 00000000..794eede9
--- /dev/null
+++ b/vscr/DESCRIPTION
@@ -0,0 +1,16 @@
+Package: vscr
+Type: Package
+Title: Modern VS Code R IPC Server
+Version: 0.1.0
+Author: Gemini
+Maintainer: Gemini <gemini@example.com>
+Description: Implements a high-performance HTTP and WebSocket server for R to VS Code Inter-Process Communication, replacing legacy file-system watchers.
+License: MIT
+Encoding: UTF-8
+LazyData: true
+Imports: 
+    httpuv,
+    jsonlite,
+    utils,
+    methods
+RoxygenNote: 7.2.3
\ No newline at end of file
diff --git a/vscr/NAMESPACE b/vscr/NAMESPACE
new file mode 100644
index 00000000..2cf6d8a1
--- /dev/null
+++ b/vscr/NAMESPACE
@@ -0,0 +1,7 @@
+# Generated by roxygen2: do not edit by hand
+
+export(notify_vscode)
+export(request_rstudioapi)
+import(httpuv)
+import(jsonlite)
+import(utils)
\ No newline at end of file
diff --git a/vscr/R/dispatch.R b/vscr/R/dispatch.R
new file mode 100644
index 00000000..8e6f4807
--- /dev/null
+++ b/vscr/R/dispatch.R
@@ -0,0 +1,26 @@
+#' Notify VS Code via WebSocket
+#' 
+#' Pushes an event instantly to the VS Code extension via the active WebSocket connection.
+#'
+#' @param command A string representing the action (e.g., "dataview", "plot_updated")
+#' @param payload A list containing the arguments for the command
+#' @export
+notify_vscode <- function(command, payload = list()) {
+  if (is.null(.vscr_env$ws)) {
+    return(FALSE) # No active client connected
+  }
+  
+  msg <- list(
+    command = command,
+    payload = payload,
+    time = format(Sys.time(), "%Y-%m-%d %H:%M:%OS6")
+  )
+  
+  # Push instantly over the websocket
+  tryCatch({
+    .vscr_env$ws$send(jsonlite::toJSON(msg, auto_unbox = TRUE, null = "null", force = TRUE))
+    return(TRUE)
+  }, error = function(e) {
+    return(FALSE)
+  })
+}
\ No newline at end of file
diff --git a/vscr/R/handlers.R b/vscr/R/handlers.R
new file mode 100644
index 00000000..bbbcc843
--- /dev/null
+++ b/vscr/R/handlers.R
@@ -0,0 +1,79 @@
+# Handlers for VS Code Pull Requests (HTTP GET/POST)
+
+get_workspace_data <- function() {
+  env <- .GlobalEnv
+  all_names <- ls(env)
+  
+  objs <- lapply(all_names, function(name) {
+    obj <- env[[name]]
+    list(
+      class = class(obj),
+      type = typeof(obj),
+      length = length(obj),
+      # Create a concise string representation
+      str = paste0(utils::capture.output(utils::str(obj, max.level = 0, give.attr = FALSE)), collapse = "\n")
+    )
+  })
+  names(objs) <- all_names
+  
+  list(
+    globalenv = objs,
+    search = search()[-1],
+    loaded_namespaces = loadedNamespaces()
+  )
+}
+
+handle_hover <- function(expr_str) {
+  tryCatch({
+    expr <- parse(text = expr_str, keep.source = FALSE)[[1]]
+    obj <- eval(expr, .GlobalEnv)
+    str_preview <- paste0(utils::capture.output(utils::str(obj, max.level = 0, give.attr = FALSE)), collapse = "\n")
+    list(str = str_preview)
+  }, error = function(e) NULL)
+}
+
+handle_complete <- function(expr_str, trigger) {
+  obj <- tryCatch({
+    expr <- parse(text = expr_str, keep.source = FALSE)[[1]]
+    eval(expr, .GlobalEnv)
+  }, error = function(e) NULL)
+
+  if (is.null(obj)) {
+    return(NULL)
+  }
+
+  if (trigger == "$") {
+    nms <- if (is.object(obj)) {
+      .DollarNames(obj, pattern = "")
+    } else if (is.recursive(obj)) {
+      names(obj)
+    } else {
+      NULL
+    }
+    
+    if (is.null(nms)) return(NULL)
+    
+    return(lapply(nms, function(n) {
+      item <- obj[[n]]
+      list(
+        name = n, 
+        type = typeof(item), 
+        str = paste0(class(item), collapse = ", ")
+      )
+    }))
+  }
+
+  if (trigger == "@" && methods::isS4(obj)) {
+    nms <- methods::slotNames(obj)
+    return(lapply(nms, function(n) {
+      item <- methods::slot(obj, n)
+      list(
+        name = n, 
+        type = typeof(item), 
+        str = paste0(class(item), collapse = ", ")
+      )
+    }))
+  }
+  
+  NULL
+}
\ No newline at end of file
diff --git a/vscr/R/hooks.R b/vscr/R/hooks.R
new file mode 100644
index 00000000..bf2fe628
--- /dev/null
+++ b/vscr/R/hooks.R
@@ -0,0 +1,56 @@
+register_hooks <- function() {
+  
+  # 1. Override View() to push data directly via WebSocket
+  rebind("View", function(x, title = deparse(substitute(x))) {
+    # Dump to a temporary file locally so the payload size over WS isn't massive
+    file_path <- tempfile(fileext = ".json")
+    jsonlite::write_json(as.data.frame(x), file_path, auto_unbox = TRUE, null = "null", na = "string")
+    
+    notify_vscode("dataview", list(
+      title = title,
+      file = file_path,
+      source = "table",
+      type = "json"
+    ))
+  }, ns = "utils")
+  
+  # 2. Static Plot Hook
+  # Instead of relying on plot.lock file watchers, we tell VS Code a new plot is ready to fetch.
+  setHook("plot.new", function(...) {
+    notify_vscode("plot_updated", list(url = "/plot/latest.png"))
+  }, "replace")
+  
+  setHook("grid.newpage", function(...) {
+    notify_vscode("plot_updated", list(url = "/plot/latest.png"))
+  }, "replace")
+}
+
+#' Emulate rstudioapi synchronously but without blocking the R Event Loop
+#'
+#' @param action String of the rstudioapi action
+#' @param args List of arguments
+#' @export
+request_rstudioapi <- function(action, args = list()) {
+  req_id <- basename(tempfile("req_"))
+  
+  # Send request via websocket
+  notify_vscode("rstudioapi", list(
+    req_id = req_id,
+    action = action,
+    args = args
+  ))
+  
+  # NON-BLOCKING WAIT:
+  # Process HTTP/WS events in the background while blocking the R console execution
+  # This prevents the R event loop from locking up.
+  while (is.null(.vscr_env$pending_responses[[req_id]])) {
+    httpuv::service() 
+    Sys.sleep(0.05)
+  }
+  
+  # Retrieve and clean up response
+  response <- .vscr_env$pending_responses[[req_id]]
+  .vscr_env$pending_responses[[req_id]] <- NULL
+  
+  return(response)
+}
\ No newline at end of file
diff --git a/vscr/R/server.R b/vscr/R/server.R
new file mode 100644
index 00000000..d787f064
--- /dev/null
+++ b/vscr/R/server.R
@@ -0,0 +1,62 @@
+vscr_app <- function() {
+  list(
+    # --- HTTP HANDLER (The "Pull" API) ---
+    call = function(req) {
+      # 1. Authentication Check
+      auth_header <- req$HTTP_AUTHORIZATION
+      if (is.null(auth_header) || auth_header != .vscr_env$token) {
+        return(list(status = 401L, headers = list("Content-Type" = "text/plain"), body = "Unauthorized"))
+      }
+
+      path <- req$PATH_INFO
+      
+      # 2. Routing
+      if (path == "/workspace" && req$REQUEST_METHOD == "GET") {
+        # Lazy workspace evaluation - only done when VS Code asks!
+        return(json_response(get_workspace_data()))
+      } 
+      else if (path == "/plot/latest.png" && req$REQUEST_METHOD == "GET") {
+        # Serve plot from memory/temp, not disk syncing
+        if (file.exists(.vscr_env$latest_plot_path)) {
+          return(list(
+            status = 200L,
+            headers = list("Content-Type" = "image/png"),
+            body = readBin(.vscr_env$latest_plot_path, "raw", file.info(.vscr_env$latest_plot_path)$size)
+          ))
+        } else {
+          return(list(status = 404L, headers = list("Content-Type" = "text/plain"), body = "Plot not found"))
+        }
+      } 
+      else if (path == "/rpc/hover" && req$REQUEST_METHOD == "POST") {
+        body <- jsonlite::fromJSON(req$rook.input$read_lines())
+        return(json_response(handle_hover(body$expr)))
+      }
+      else if (path == "/rpc/complete" && req$REQUEST_METHOD == "POST") {
+        body <- jsonlite::fromJSON(req$rook.input$read_lines())
+        return(json_response(handle_complete(body$expr, body$trigger)))
+      }
+
+      list(status = 404L, headers = list("Content-Type" = "text/plain"), body = "Not Found")
+    },
+
+    # --- WEBSOCKET HANDLER (The "Push" API) ---
+    onWSOpen = function(ws) {
+      # Bind the active websocket to our environment
+      .vscr_env$ws <- ws
+      
+      ws$onMessage(function(binary, message) {
+        # Handle messages COMING FROM VS Code (e.g., rstudioapi responses)
+        payload <- tryCatch(jsonlite::fromJSON(message), error = function(e) NULL)
+        
+        if (!is.null(payload) && !is.null(payload$type) && payload$type == "rstudioapi_response") {
+           # Store response to unblock the wait loop
+           .vscr_env$pending_responses[[payload$req_id]] <- payload$data
+        }
+      })
+      
+      ws$onClose(function() {
+        .vscr_env$ws <- NULL
+      })
+    }
+  )
+}
\ No newline at end of file
diff --git a/vscr/R/utils.R b/vscr/R/utils.R
new file mode 100644
index 00000000..5890ac97
--- /dev/null
+++ b/vscr/R/utils.R
@@ -0,0 +1,27 @@
+# Helper to format HTTP JSON responses
+json_response <- function(data) {
+  list(
+    status = 200L,
+    headers = list("Content-Type" = "application/json"),
+    body = jsonlite::toJSON(data, auto_unbox = TRUE, null = "null", force = TRUE)
+  )
+}
+
+# Helper to safely hijack and override R internal functions
+rebind <- function(sym, value, ns) {
+  if (is.character(ns)) {
+    Recall(sym, value, getNamespace(ns))
+    pkg <- paste0("package:", ns)
+    if (pkg %in% search()) {
+      Recall(sym, value, as.environment(pkg))
+    }
+  } else if (is.environment(ns)) {
+    if (bindingIsLocked(sym, ns)) {
+      unlockBinding(sym, ns)
+      on.exit(lockBinding(sym, ns))
+    }
+    assign(sym, value, ns)
+  } else {
+    stop("ns must be a string or environment")
+  }
+}
\ No newline at end of file
diff --git a/vscr/R/zzz.R b/vscr/R/zzz.R
new file mode 100644
index 00000000..8a4f249b
--- /dev/null
+++ b/vscr/R/zzz.R
@@ -0,0 +1,30 @@
+.vscr_env <- new.env(parent = emptyenv())
+
+.onLoad <- function(libname, pkgname) {
+  # Initialize state
+  .vscr_env$server <- NULL
+  .vscr_env$ws <- NULL
+  .vscr_env$token <- paste0(sample(c(letters, 0:9), 32, replace = TRUE), collapse = "")
+  .vscr_env$pending_responses <- list()
+  
+  # Temporary file for static plot serving
+  .vscr_env$latest_plot_path <- file.path(tempdir(), "vscr_plot.png")
+  
+  # Start the httpuv server on a random port
+  port <- httpuv::randomPort()
+  .vscr_env$server <- httpuv::startServer("127.0.0.1", port, app = vscr_app())
+  
+  # Print the connection string to the console.
+  # The VS Code extension's terminal tracker intercepts this to connect the WebSocket.
+  cat(sprintf("\n[vscr] VSCODE_IPC_SERVER=ws://127.0.0.1:%d?token=%s\n", port, .vscr_env$token))
+  
+  # Register runtime hooks
+  register_hooks()
+}
+
+.onUnload <- function(libpath) {
+  if (!is.null(.vscr_env$server)) {
+    notify_vscode("detach", list(pid = Sys.getpid()))
+    .vscr_env$server$stop()
+  }
+}
\ No newline at end of file

From 101858cbd7ea8e31cce26d64bc84d0da6aa59b64 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Wed, 11 Mar 2026 08:27:51 -0700
Subject: [PATCH 03/47] feat: enhance sess package and export register_hooks

---
 {vscr => sess}/DESCRIPTION  |   2 +-
 {vscr => sess}/NAMESPACE    |   2 +
 {vscr => sess}/R/dispatch.R |   6 +-
 {vscr => sess}/R/handlers.R |   0
 sess/R/hooks.R              | 106 ++++++++++++++++++++++++++++++++++++
 {vscr => sess}/R/server.R   |  59 +++++++++++++++++---
 {vscr => sess}/R/utils.R    |   0
 sess/R/zzz.R                |   1 +
 vscr/R/hooks.R              |  56 -------------------
 vscr/R/zzz.R                |  30 ----------
 10 files changed, 164 insertions(+), 98 deletions(-)
 rename {vscr => sess}/DESCRIPTION (96%)
 rename {vscr => sess}/NAMESPACE (77%)
 rename {vscr => sess}/R/dispatch.R (87%)
 rename {vscr => sess}/R/handlers.R (100%)
 create mode 100644 sess/R/hooks.R
 rename {vscr => sess}/R/server.R (54%)
 rename {vscr => sess}/R/utils.R (100%)
 create mode 100644 sess/R/zzz.R
 delete mode 100644 vscr/R/hooks.R
 delete mode 100644 vscr/R/zzz.R

diff --git a/vscr/DESCRIPTION b/sess/DESCRIPTION
similarity index 96%
rename from vscr/DESCRIPTION
rename to sess/DESCRIPTION
index 794eede9..9b80eb6a 100644
--- a/vscr/DESCRIPTION
+++ b/sess/DESCRIPTION
@@ -1,4 +1,4 @@
-Package: vscr
+Package: sess
 Type: Package
 Title: Modern VS Code R IPC Server
 Version: 0.1.0
diff --git a/vscr/NAMESPACE b/sess/NAMESPACE
similarity index 77%
rename from vscr/NAMESPACE
rename to sess/NAMESPACE
index 2cf6d8a1..43d64485 100644
--- a/vscr/NAMESPACE
+++ b/sess/NAMESPACE
@@ -1,7 +1,9 @@
 # Generated by roxygen2: do not edit by hand
 
 export(notify_vscode)
+export(register_hooks)
 export(request_rstudioapi)
+export(sess_app)
 import(httpuv)
 import(jsonlite)
 import(utils)
\ No newline at end of file
diff --git a/vscr/R/dispatch.R b/sess/R/dispatch.R
similarity index 87%
rename from vscr/R/dispatch.R
rename to sess/R/dispatch.R
index 8e6f4807..5b925d8f 100644
--- a/vscr/R/dispatch.R
+++ b/sess/R/dispatch.R
@@ -6,7 +6,7 @@
 #' @param payload A list containing the arguments for the command
 #' @export
 notify_vscode <- function(command, payload = list()) {
-  if (is.null(.vscr_env$ws)) {
+  if (is.null(.sess_env$ws)) {
     return(FALSE) # No active client connected
   }
   
@@ -18,9 +18,9 @@ notify_vscode <- function(command, payload = list()) {
   
   # Push instantly over the websocket
   tryCatch({
-    .vscr_env$ws$send(jsonlite::toJSON(msg, auto_unbox = TRUE, null = "null", force = TRUE))
+    .sess_env$ws$send(jsonlite::toJSON(msg, auto_unbox = TRUE, null = "null", force = TRUE))
     return(TRUE)
   }, error = function(e) {
     return(FALSE)
   })
-}
\ No newline at end of file
+}
diff --git a/vscr/R/handlers.R b/sess/R/handlers.R
similarity index 100%
rename from vscr/R/handlers.R
rename to sess/R/handlers.R
diff --git a/sess/R/hooks.R b/sess/R/hooks.R
new file mode 100644
index 00000000..5d32ee17
--- /dev/null
+++ b/sess/R/hooks.R
@@ -0,0 +1,106 @@
+#' Register hooks for VS Code IPC
+#'
+#' @export
+register_hooks <- function() {
+  
+  # 1. Override View() to push data directly via WebSocket
+  rebind("View", function(x, title = deparse(substitute(x))) {
+    # Dump to a temporary file locally so the payload size over WS isn't massive
+    file_path <- tempfile(fileext = ".json")
+    jsonlite::write_json(as.data.frame(x), file_path, auto_unbox = TRUE, null = "null", na = "string")
+    
+    notify_vscode("dataview", list(
+      title = title,
+      file = file_path,
+      source = "table",
+      type = "json"
+    ))
+  }, ns = "utils")
+  
+  # 2. Browser & Webview Options
+  show_browser <- function(url, title = url, ...) {
+    notify_vscode("browser", list(url = url, title = title))
+  }
+  
+  show_webview <- function(url, title = "WebView", ...) {
+    # If the URL is a local file, normalize its path for the webview
+    if (file.exists(url)) {
+      url <- normalizePath(url, "/", mustWork = TRUE)
+    }
+    notify_vscode("webview", list(file = url, title = title))
+  }
+  
+  options(
+    browser = show_browser,
+    viewer = show_webview,
+    page_viewer = show_webview,
+    help_type = "html"
+  )
+
+  # 3. Help System Interception
+  rebind("print.help_files_with_topic", function(x, ...) {
+    if (length(x) >= 1 && is.character(x)) {
+        file <- x[1]
+        pkgname <- basename(dirname(dirname(file)))
+        requestPath <- paste0("/library/", pkgname, "/html/", basename(file), ".html")
+        notify_vscode("help", list(requestPath = requestPath))
+    }
+    invisible(x)
+  }, ns = "utils")
+  
+  rebind("print.hsearch", function(x, ...) {
+    if (length(x) >= 1) {
+        requestPath <- paste0("/doc/html/Search?pattern=", tools:::escapeAmpersand(x$pattern))
+        notify_vscode("help", list(requestPath = requestPath))
+    }
+    invisible(x)
+  }, ns = "utils")
+
+  # 4. httpgd or Static Plot Hook
+  use_httpgd <- isTRUE(getOption("vsc.use_httpgd", FALSE))
+  if (use_httpgd && requireNamespace("httpgd", quietly = TRUE)) {
+    options(device = function(...) {
+        httpgd::hgd(silent = TRUE)
+        notify_vscode("httpgd", list(url = httpgd::hgd_url()))
+    })
+  } else {
+    # Default to static plot capturing
+    setHook("plot.new", function(...) {
+      notify_vscode("plot_updated", list(url = "/plot/latest.png"))
+    }, "replace")
+    
+    setHook("grid.newpage", function(...) {
+      notify_vscode("plot_updated", list(url = "/plot/latest.png"))
+    }, "replace")
+  }
+}
+
+#' Emulate rstudioapi synchronously but without blocking the R Event Loop
+#'
+#' @param action String of the rstudioapi action
+#' @param args List of arguments
+#' @export
+request_rstudioapi <- function(action, args = list()) {
+  req_id <- basename(tempfile("req_"))
+  
+  # Send request via websocket
+  notify_vscode("rstudioapi", list(
+    req_id = req_id,
+    action = action,
+    args = args
+  ))
+  
+  # NON-BLOCKING WAIT:
+  # Process HTTP/WS events in the background while blocking the R console execution
+  # This prevents the R event loop from locking up.
+  while (is.null(.sess_env$pending_responses[[req_id]])) {
+    httpuv::service() 
+    Sys.sleep(0.05)
+  }
+  
+  # Retrieve and clean up response
+  response <- .sess_env$pending_responses[[req_id]]
+  .sess_env$pending_responses[[req_id]] <- NULL
+  
+  return(response)
+}
\ No newline at end of file
diff --git a/vscr/R/server.R b/sess/R/server.R
similarity index 54%
rename from vscr/R/server.R
rename to sess/R/server.R
index d787f064..0fb1dbba 100644
--- a/vscr/R/server.R
+++ b/sess/R/server.R
@@ -1,10 +1,30 @@
-vscr_app <- function() {
-  list(
+#' Start the VS Code R IPC Server
+#' 
+#' @export
+sess_app <- function() {
+  
+  on.exit({
+    if (!is.null(.sess_env$server)) {
+      notify_vscode("detach", list(pid = Sys.getpid()))
+      .sess_env$server$stop()
+    }
+  })
+
+  # Initialize state
+  .sess_env$server <- NULL
+  .sess_env$ws <- NULL
+  .sess_env$token <- paste0(sample(c(letters, 0:9), 32, replace = TRUE), collapse = "")
+  .sess_env$pending_responses <- list()
+  
+  # Temporary file for static plot serving
+  .sess_env$latest_plot_path <- file.path(tempdir(), "sess_plot.png")
+  
+  app_handlers <- list(
     # --- HTTP HANDLER (The "Pull" API) ---
     call = function(req) {
       # 1. Authentication Check
       auth_header <- req$HTTP_AUTHORIZATION
-      if (is.null(auth_header) || auth_header != .vscr_env$token) {
+      if (is.null(auth_header) || auth_header != .sess_env$token) {
         return(list(status = 401L, headers = list("Content-Type" = "text/plain"), body = "Unauthorized"))
       }
 
@@ -17,11 +37,11 @@ vscr_app <- function() {
       } 
       else if (path == "/plot/latest.png" && req$REQUEST_METHOD == "GET") {
         # Serve plot from memory/temp, not disk syncing
-        if (file.exists(.vscr_env$latest_plot_path)) {
+        if (file.exists(.sess_env$latest_plot_path)) {
           return(list(
             status = 200L,
             headers = list("Content-Type" = "image/png"),
-            body = readBin(.vscr_env$latest_plot_path, "raw", file.info(.vscr_env$latest_plot_path)$size)
+            body = readBin(.sess_env$latest_plot_path, "raw", file.info(.sess_env$latest_plot_path)$size)
           ))
         } else {
           return(list(status = 404L, headers = list("Content-Type" = "text/plain"), body = "Plot not found"))
@@ -42,7 +62,20 @@ vscr_app <- function() {
     # --- WEBSOCKET HANDLER (The "Push" API) ---
     onWSOpen = function(ws) {
       # Bind the active websocket to our environment
-      .vscr_env$ws <- ws
+      .sess_env$ws <- ws
+      
+      # Send the attach handshake immediately upon connection
+      notify_vscode("attach", list(
+        version = sprintf("%s.%s", R.version$major, R.version$minor),
+        pid = Sys.getpid(),
+        tempdir = tempdir(),
+        wd = getwd(),
+        info = list(
+            command = commandArgs()[[1L]],
+            version = R.version.string,
+            start_time = format(Sys.time())
+        )
+      ))
       
       ws$onMessage(function(binary, message) {
         # Handle messages COMING FROM VS Code (e.g., rstudioapi responses)
@@ -50,13 +83,23 @@ vscr_app <- function() {
         
         if (!is.null(payload) && !is.null(payload$type) && payload$type == "rstudioapi_response") {
            # Store response to unblock the wait loop
-           .vscr_env$pending_responses[[payload$req_id]] <- payload$data
+           .sess_env$pending_responses[[payload$req_id]] <- payload$data
         }
       })
       
       ws$onClose(function() {
-        .vscr_env$ws <- NULL
+        .sess_env$ws <- NULL
       })
     }
   )
+
+  # Start the httpuv server on a random port
+  port <- httpuv::randomPort()
+  .sess_env$server <- httpuv::startServer("127.0.0.1", port, app = app_handlers)
+  
+  # Print the connection string to the console.
+  cat(sprintf("\n[sess] VSCODE_IPC_SERVER=ws://127.0.0.1:%d?token=%s\n", port, .sess_env$token))
+  
+  # Register runtime hooks
+  register_hooks()
 }
\ No newline at end of file
diff --git a/vscr/R/utils.R b/sess/R/utils.R
similarity index 100%
rename from vscr/R/utils.R
rename to sess/R/utils.R
diff --git a/sess/R/zzz.R b/sess/R/zzz.R
new file mode 100644
index 00000000..9e70877a
--- /dev/null
+++ b/sess/R/zzz.R
@@ -0,0 +1 @@
+.sess_env <- new.env(parent = emptyenv())
diff --git a/vscr/R/hooks.R b/vscr/R/hooks.R
deleted file mode 100644
index bf2fe628..00000000
--- a/vscr/R/hooks.R
+++ /dev/null
@@ -1,56 +0,0 @@
-register_hooks <- function() {
-  
-  # 1. Override View() to push data directly via WebSocket
-  rebind("View", function(x, title = deparse(substitute(x))) {
-    # Dump to a temporary file locally so the payload size over WS isn't massive
-    file_path <- tempfile(fileext = ".json")
-    jsonlite::write_json(as.data.frame(x), file_path, auto_unbox = TRUE, null = "null", na = "string")
-    
-    notify_vscode("dataview", list(
-      title = title,
-      file = file_path,
-      source = "table",
-      type = "json"
-    ))
-  }, ns = "utils")
-  
-  # 2. Static Plot Hook
-  # Instead of relying on plot.lock file watchers, we tell VS Code a new plot is ready to fetch.
-  setHook("plot.new", function(...) {
-    notify_vscode("plot_updated", list(url = "/plot/latest.png"))
-  }, "replace")
-  
-  setHook("grid.newpage", function(...) {
-    notify_vscode("plot_updated", list(url = "/plot/latest.png"))
-  }, "replace")
-}
-
-#' Emulate rstudioapi synchronously but without blocking the R Event Loop
-#'
-#' @param action String of the rstudioapi action
-#' @param args List of arguments
-#' @export
-request_rstudioapi <- function(action, args = list()) {
-  req_id <- basename(tempfile("req_"))
-  
-  # Send request via websocket
-  notify_vscode("rstudioapi", list(
-    req_id = req_id,
-    action = action,
-    args = args
-  ))
-  
-  # NON-BLOCKING WAIT:
-  # Process HTTP/WS events in the background while blocking the R console execution
-  # This prevents the R event loop from locking up.
-  while (is.null(.vscr_env$pending_responses[[req_id]])) {
-    httpuv::service() 
-    Sys.sleep(0.05)
-  }
-  
-  # Retrieve and clean up response
-  response <- .vscr_env$pending_responses[[req_id]]
-  .vscr_env$pending_responses[[req_id]] <- NULL
-  
-  return(response)
-}
\ No newline at end of file
diff --git a/vscr/R/zzz.R b/vscr/R/zzz.R
deleted file mode 100644
index 8a4f249b..00000000
--- a/vscr/R/zzz.R
+++ /dev/null
@@ -1,30 +0,0 @@
-.vscr_env <- new.env(parent = emptyenv())
-
-.onLoad <- function(libname, pkgname) {
-  # Initialize state
-  .vscr_env$server <- NULL
-  .vscr_env$ws <- NULL
-  .vscr_env$token <- paste0(sample(c(letters, 0:9), 32, replace = TRUE), collapse = "")
-  .vscr_env$pending_responses <- list()
-  
-  # Temporary file for static plot serving
-  .vscr_env$latest_plot_path <- file.path(tempdir(), "vscr_plot.png")
-  
-  # Start the httpuv server on a random port
-  port <- httpuv::randomPort()
-  .vscr_env$server <- httpuv::startServer("127.0.0.1", port, app = vscr_app())
-  
-  # Print the connection string to the console.
-  # The VS Code extension's terminal tracker intercepts this to connect the WebSocket.
-  cat(sprintf("\n[vscr] VSCODE_IPC_SERVER=ws://127.0.0.1:%d?token=%s\n", port, .vscr_env$token))
-  
-  # Register runtime hooks
-  register_hooks()
-}
-
-.onUnload <- function(libpath) {
-  if (!is.null(.vscr_env$server)) {
-    notify_vscode("detach", list(pid = Sys.getpid()))
-    .vscr_env$server$stop()
-  }
-}
\ No newline at end of file

From 9a39cfa7bc262eb058281a82249fc33254e9347d Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Wed, 11 Mar 2026 08:29:11 -0700
Subject: [PATCH 04/47] feat: introduce generic sess package for modern R IPC

---
 sess/DESCRIPTION  |   6 +-
 sess/NAMESPACE    |   2 +-
 sess/R/dispatch.R |  16 +++---
 sess/R/handlers.R |   4 +-
 sess/R/hooks.R    |  51 ++++++++++++-----
 sess/R/server.R   |  72 +++++++++++++----------
 sess/R/utils.R    |  27 ++++++++-
 sess/README.md    | 142 ++++++++++++++++++++++++++++++++++++++++++++++
 8 files changed, 257 insertions(+), 63 deletions(-)
 create mode 100644 sess/README.md

diff --git a/sess/DESCRIPTION b/sess/DESCRIPTION
index 9b80eb6a..2133c620 100644
--- a/sess/DESCRIPTION
+++ b/sess/DESCRIPTION
@@ -1,10 +1,10 @@
 Package: sess
 Type: Package
-Title: Modern VS Code R IPC Server
+Title: Modern R IPC Server
 Version: 0.1.0
 Author: Gemini
 Maintainer: Gemini <gemini@example.com>
-Description: Implements a high-performance HTTP and WebSocket server for R to VS Code Inter-Process Communication, replacing legacy file-system watchers.
+Description: Implements a high-performance HTTP and WebSocket server for R Inter-Process Communication, replacing legacy file-system watchers. This package provides a generic protocol for IDEs and other clients to communicate with an R session.
 License: MIT
 Encoding: UTF-8
 LazyData: true
@@ -13,4 +13,4 @@ Imports:
     jsonlite,
     utils,
     methods
-RoxygenNote: 7.2.3
\ No newline at end of file
+RoxygenNote: 7.2.3
diff --git a/sess/NAMESPACE b/sess/NAMESPACE
index 43d64485..ddd5e356 100644
--- a/sess/NAMESPACE
+++ b/sess/NAMESPACE
@@ -1,6 +1,6 @@
 # Generated by roxygen2: do not edit by hand
 
-export(notify_vscode)
+export(notify_client)
 export(register_hooks)
 export(request_rstudioapi)
 export(sess_app)
diff --git a/sess/R/dispatch.R b/sess/R/dispatch.R
index 5b925d8f..9e2695b9 100644
--- a/sess/R/dispatch.R
+++ b/sess/R/dispatch.R
@@ -1,19 +1,19 @@
-#' Notify VS Code via WebSocket
+#' Notify the client via WebSocket (JSON-RPC 2.0 Notification)
 #' 
-#' Pushes an event instantly to the VS Code extension via the active WebSocket connection.
+#' Pushes an event instantly to the client extension via the active WebSocket connection.
 #'
-#' @param command A string representing the action (e.g., "dataview", "plot_updated")
-#' @param payload A list containing the arguments for the command
+#' @param method A string representing the action (e.g., "dataview", "plot_updated")
+#' @param params A list containing the arguments for the command
 #' @export
-notify_vscode <- function(command, payload = list()) {
+notify_client <- function(method, params = list()) {
   if (is.null(.sess_env$ws)) {
     return(FALSE) # No active client connected
   }
   
   msg <- list(
-    command = command,
-    payload = payload,
-    time = format(Sys.time(), "%Y-%m-%d %H:%M:%OS6")
+    jsonrpc = "2.0",
+    method = method,
+    params = params
   )
   
   # Push instantly over the websocket
diff --git a/sess/R/handlers.R b/sess/R/handlers.R
index bbbcc843..28293b28 100644
--- a/sess/R/handlers.R
+++ b/sess/R/handlers.R
@@ -1,4 +1,4 @@
-# Handlers for VS Code Pull Requests (HTTP GET/POST)
+# Handlers for the client Pull Requests (HTTP GET/POST)
 
 get_workspace_data <- function() {
   env <- .GlobalEnv
@@ -44,7 +44,7 @@ handle_complete <- function(expr_str, trigger) {
 
   if (trigger == "$") {
     nms <- if (is.object(obj)) {
-      .DollarNames(obj, pattern = "")
+      utils::.DollarNames(obj, pattern = "")
     } else if (is.recursive(obj)) {
       names(obj)
     } else {
diff --git a/sess/R/hooks.R b/sess/R/hooks.R
index 5d32ee17..60c17028 100644
--- a/sess/R/hooks.R
+++ b/sess/R/hooks.R
@@ -1,4 +1,4 @@
-#' Register hooks for VS Code IPC
+#' Register hooks for the client IPC
 #'
 #' @export
 register_hooks <- function() {
@@ -9,7 +9,7 @@ register_hooks <- function() {
     file_path <- tempfile(fileext = ".json")
     jsonlite::write_json(as.data.frame(x), file_path, auto_unbox = TRUE, null = "null", na = "string")
     
-    notify_vscode("dataview", list(
+    notify_client("dataview", list(
       title = title,
       file = file_path,
       source = "table",
@@ -19,7 +19,7 @@ register_hooks <- function() {
   
   # 2. Browser & Webview Options
   show_browser <- function(url, title = url, ...) {
-    notify_vscode("browser", list(url = url, title = title))
+    notify_client("browser", list(url = url, title = title))
   }
   
   show_webview <- function(url, title = "WebView", ...) {
@@ -27,7 +27,7 @@ register_hooks <- function() {
     if (file.exists(url)) {
       url <- normalizePath(url, "/", mustWork = TRUE)
     }
-    notify_vscode("webview", list(file = url, title = title))
+    notify_client("webview", list(file = url, title = title))
   }
   
   options(
@@ -43,7 +43,7 @@ register_hooks <- function() {
         file <- x[1]
         pkgname <- basename(dirname(dirname(file)))
         requestPath <- paste0("/library/", pkgname, "/html/", basename(file), ".html")
-        notify_vscode("help", list(requestPath = requestPath))
+        notify_client("help", list(requestPath = requestPath))
     }
     invisible(x)
   }, ns = "utils")
@@ -51,7 +51,7 @@ register_hooks <- function() {
   rebind("print.hsearch", function(x, ...) {
     if (length(x) >= 1) {
         requestPath <- paste0("/doc/html/Search?pattern=", tools:::escapeAmpersand(x$pattern))
-        notify_vscode("help", list(requestPath = requestPath))
+        notify_client("help", list(requestPath = requestPath))
     }
     invisible(x)
   }, ns = "utils")
@@ -61,16 +61,20 @@ register_hooks <- function() {
   if (use_httpgd && requireNamespace("httpgd", quietly = TRUE)) {
     options(device = function(...) {
         httpgd::hgd(silent = TRUE)
-        notify_vscode("httpgd", list(url = httpgd::hgd_url()))
+        notify_client("httpgd", list(url = httpgd::hgd_url()))
     })
   } else {
     # Default to static plot capturing
+    options(device = function(...) {
+      png(.sess_env$latest_plot_path, width = 800, height = 600, res = 72)
+    })
+
     setHook("plot.new", function(...) {
-      notify_vscode("plot_updated", list(url = "/plot/latest.png"))
+      notify_client("plot_updated")
     }, "replace")
     
     setHook("grid.newpage", function(...) {
-      notify_vscode("plot_updated", list(url = "/plot/latest.png"))
+      notify_client("plot_updated")
     }, "replace")
   }
 }
@@ -83,12 +87,24 @@ register_hooks <- function() {
 request_rstudioapi <- function(action, args = list()) {
   req_id <- basename(tempfile("req_"))
   
-  # Send request via websocket
-  notify_vscode("rstudioapi", list(
-    req_id = req_id,
-    action = action,
-    args = args
-  ))
+  # Send JSON-RPC 2.0 Request via websocket
+  msg <- list(
+    jsonrpc = "2.0",
+    id = req_id,
+    method = "rstudioapi",
+    params = list(
+        action = action,
+        args = args
+    )
+  )
+
+  if (!is.null(.sess_env$ws)) {
+    tryCatch({
+        .sess_env$ws$send(jsonlite::toJSON(msg, auto_unbox = TRUE, null = "null", force = TRUE))
+    }, error = function(e) return(NULL))
+  } else {
+    return(NULL)
+  }
   
   # NON-BLOCKING WAIT:
   # Process HTTP/WS events in the background while blocking the R console execution
@@ -102,5 +118,10 @@ request_rstudioapi <- function(action, args = list()) {
   response <- .sess_env$pending_responses[[req_id]]
   .sess_env$pending_responses[[req_id]] <- NULL
   
+  # Handle JSON-RPC Errors if any
+  if (inherits(response, "json_rpc_error")) {
+    stop(sprintf("JSON-RPC Error [%d]: %s", response$code, response$message))
+  }
+  
   return(response)
 }
\ No newline at end of file
diff --git a/sess/R/server.R b/sess/R/server.R
index 0fb1dbba..845512d3 100644
--- a/sess/R/server.R
+++ b/sess/R/server.R
@@ -1,11 +1,11 @@
-#' Start the VS Code R IPC Server
+#' Start the client R IPC Server
 #' 
 #' @export
 sess_app <- function() {
   
   on.exit({
     if (!is.null(.sess_env$server)) {
-      notify_vscode("detach", list(pid = Sys.getpid()))
+      notify_client("detach", list(pid = Sys.getpid()))
       .sess_env$server$stop()
     }
   })
@@ -31,30 +31,36 @@ sess_app <- function() {
       path <- req$PATH_INFO
       
       # 2. Routing
-      if (path == "/workspace" && req$REQUEST_METHOD == "GET") {
-        # Lazy workspace evaluation - only done when VS Code asks!
-        return(json_response(get_workspace_data()))
-      } 
-      else if (path == "/plot/latest.png" && req$REQUEST_METHOD == "GET") {
-        # Serve plot from memory/temp, not disk syncing
-        if (file.exists(.sess_env$latest_plot_path)) {
-          return(list(
-            status = 200L,
-            headers = list("Content-Type" = "image/png"),
-            body = readBin(.sess_env$latest_plot_path, "raw", file.info(.sess_env$latest_plot_path)$size)
-          ))
-        } else {
-          return(list(status = 404L, headers = list("Content-Type" = "text/plain"), body = "Plot not found"))
+      if (path == "/rpc" && req$REQUEST_METHOD == "POST") {
+        # JSON-RPC 2.0 Implementation
+        body <- tryCatch(jsonlite::fromJSON(req$rook.input$read_lines()), error = function(e) NULL)
+        
+        if (is.null(body) || is.null(body$method)) {
+          return(json_rpc_error(NULL, -32600, "Invalid Request"))
         }
+
+        # Dispatch method
+        res <- switch(body$method,
+          "workspace" = get_workspace_data(),
+          "hover" = handle_hover(body$params$expr),
+          "completion" = handle_complete(body$params$expr, body$params$trigger),
+          "plot_latest" = {
+            if (file.exists(.sess_env$latest_plot_path)) {
+              raw_img <- readBin(.sess_env$latest_plot_path, "raw", file.info(.sess_env$latest_plot_path)$size)
+              list(data = as.character(jsonlite::base64_enc(raw_img)))
+            } else {
+              list(data = NULL)
+            }
+          },
+          NULL
+        )
+
+        if (is.null(res)) {
+          return(json_rpc_error(body$id, -32601, "Method not found"))
+        }
+
+        return(json_rpc_response(body$id, res))
       } 
-      else if (path == "/rpc/hover" && req$REQUEST_METHOD == "POST") {
-        body <- jsonlite::fromJSON(req$rook.input$read_lines())
-        return(json_response(handle_hover(body$expr)))
-      }
-      else if (path == "/rpc/complete" && req$REQUEST_METHOD == "POST") {
-        body <- jsonlite::fromJSON(req$rook.input$read_lines())
-        return(json_response(handle_complete(body$expr, body$trigger)))
-      }
 
       list(status = 404L, headers = list("Content-Type" = "text/plain"), body = "Not Found")
     },
@@ -64,8 +70,8 @@ sess_app <- function() {
       # Bind the active websocket to our environment
       .sess_env$ws <- ws
       
-      # Send the attach handshake immediately upon connection
-      notify_vscode("attach", list(
+      # Send the attach handshake immediately upon connection (JSON-RPC Notification)
+      notify_client("attach", list(
         version = sprintf("%s.%s", R.version$major, R.version$minor),
         pid = Sys.getpid(),
         tempdir = tempdir(),
@@ -78,12 +84,16 @@ sess_app <- function() {
       ))
       
       ws$onMessage(function(binary, message) {
-        # Handle messages COMING FROM VS Code (e.g., rstudioapi responses)
+        # Handle JSON-RPC 2.0 messages COMING FROM the client
         payload <- tryCatch(jsonlite::fromJSON(message), error = function(e) NULL)
         
-        if (!is.null(payload) && !is.null(payload$type) && payload$type == "rstudioapi_response") {
-           # Store response to unblock the wait loop
-           .sess_env$pending_responses[[payload$req_id]] <- payload$data
+        if (!is.null(payload) && !is.null(payload$id)) {
+           # It's a Response (to our RStudio API request)
+           if (!is.null(payload$result)) {
+             .sess_env$pending_responses[[as.character(payload$id)]] <- payload$result
+           } else if (!is.null(payload$error)) {
+             .sess_env$pending_responses[[as.character(payload$id)]] <- structure(payload$error, class = "json_rpc_error")
+           }
         }
       })
       
@@ -98,7 +108,7 @@ sess_app <- function() {
   .sess_env$server <- httpuv::startServer("127.0.0.1", port, app = app_handlers)
   
   # Print the connection string to the console.
-  cat(sprintf("\n[sess] VSCODE_IPC_SERVER=ws://127.0.0.1:%d?token=%s\n", port, .sess_env$token))
+  cat(sprintf("\n[sess] SESS_IPC_SERVER=ws://127.0.0.1:%d?token=%s\n", port, .sess_env$token))
   
   # Register runtime hooks
   register_hooks()
diff --git a/sess/R/utils.R b/sess/R/utils.R
index 5890ac97..dedc91c4 100644
--- a/sess/R/utils.R
+++ b/sess/R/utils.R
@@ -1,9 +1,30 @@
-# Helper to format HTTP JSON responses
-json_response <- function(data) {
+# Helper to format JSON-RPC 2.0 Responses
+json_rpc_response <- function(id, result) {
   list(
     status = 200L,
     headers = list("Content-Type" = "application/json"),
-    body = jsonlite::toJSON(data, auto_unbox = TRUE, null = "null", force = TRUE)
+    body = jsonlite::toJSON(list(
+      jsonrpc = "2.0",
+      id = id,
+      result = result
+    ), auto_unbox = TRUE, null = "null", force = TRUE)
+  )
+}
+
+# Helper to format JSON-RPC 2.0 Errors
+json_rpc_error <- function(id, code, message, data = NULL) {
+  list(
+    status = 200L, # JSON-RPC typically returns 200 even for errors
+    headers = list("Content-Type" = "application/json"),
+    body = jsonlite::toJSON(list(
+      jsonrpc = "2.0",
+      id = id,
+      error = list(
+        code = code,
+        message = message,
+        data = data
+      )
+    ), auto_unbox = TRUE, null = "null", force = TRUE)
   )
 }
 
diff --git a/sess/README.md b/sess/README.md
new file mode 100644
index 00000000..cd894b02
--- /dev/null
+++ b/sess/README.md
@@ -0,0 +1,142 @@
+# `sess`: Modern R IPC Server Protocol
+
+The `sess` package provides a high-performance, token-authenticated IPC (Inter-Process Communication) mechanism between R and a client (such as an IDE or editor extension). It uses a hybrid **Push (WebSocket)** and **Pull (HTTP)** architecture to replace legacy file-based watchers.
+
+## 1. Connection Handshake
+
+When `sess::sess_app()` is started, it prints a connection string to the R console:
+```text
+[sess] SESS_IPC_SERVER=ws://127.0.0.1:PORT?token=TOKEN
+```
+A client can intercept this string or be configured with the port and token to establish a connection.
+
+- **Port**: Randomly assigned by `httpuv::randomPort()`.
+- **Token**: A random 32-character alphanumeric string generated per session.
+
+## 2. Communication Channels
+
+`sess` uses a hybrid architecture following the **JSON-RPC 2.0** specification for all structured data exchange.
+
+### WebSocket (Push API)
+The WebSocket is used for instantaneous events pushed from R to the client as **JSON-RPC Notifications** (no `id`).
+
+**Notification Format:**
+```json
+{
+  "jsonrpc": "2.0",
+  "method": "method_name",
+  "params": { ... }
+}
+```
+
+#### Common Methods
+- **`attach`**: Sent immediately upon connection. Includes PID, R version, and session metadata.
+- **`detach`**: Sent when the R session is shutting down.
+- **`dataview`**: Triggered by `View()`. Params include a temporary JSON file path containing the data.
+- **`plot_updated`**: Notifies that a new static plot is available. The client should request the `plot_latest` method.
+- **`httpgd`**: Provides a URL for an `httpgd` live plot server.
+- **`help`**: Requests the client to display an R help page.
+- **`browser` / `webview`**: Requests the client to open a URL or local HTML file.
+
+---
+
+### HTTP (Pull API)
+The Pull API allows the client to query state using **JSON-RPC Requests** sent via `POST` to the `/rpc` endpoint. All HTTP requests must include the `Authorization` header set to the session token.
+
+#### Endpoints
+
+| Endpoint | Method | Description |
+| :--- | :--- | :--- |
+| `/rpc` | `POST` | The primary JSON-RPC 2.0 entry point. Requires `Authorization: <token>` header. |
+
+#### JSON-RPC Request Format
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "method_name",
+  "params": { ... }
+}
+```
+
+#### Available Methods
+
+**`workspace`**
+Returns object metadata from the Global Environment.
+- **Request Params**: None.
+- **Response Result**:
+  ```json
+  {
+    "globalenv": {
+      "my_df": { "class": "data.frame", "type": "list", "length": 5, "str": "data.frame: 32 obs. of 11 variables:" }
+    },
+    "search": ["package:stats", "package:graphics"],
+    "loaded_namespaces": ["sess", "httpuv"]
+  }
+  ```
+
+**`plot_latest`**
+Returns the most recent static plot captured by the R session.
+- **Request Params**: None.
+- **Response Result**: `{"data": "iVBORw0KGgoAAAANSUhEUgA..."}` (base64 encoded PNG string). Returns `{"data": null}` if no plot exists.
+
+**`hover`**
+- **Request Params**: `{"expr": "head(mtcars)"}`
+- **Response Result**: `{"str": " 'data.frame': 6 obs. of 11 variables: ..."}`
+
+**`completion`**
+- **Request Params**: `{"expr": "mtcars", "trigger": "$"}`
+- **Response Result**:
+  ```json
+  [
+    { "name": "mpg", "type": "double", "str": "numeric" },
+    { "name": "cyl", "type": "double", "str": "numeric" }
+  ]
+  ```
+
+---
+
+## 3. Synchronous RStudio API Emulation
+
+The `request_rstudioapi()` function allows R to call client-side functions synchronously by sending a **JSON-RPC Request** (with an `id`) over the WebSocket:
+
+1. R sends a request with `method: "rstudioapi"`.
+2. R enters a `while` loop that calls `httpuv::service()`.
+3. The client processes the action and sends back a **JSON-RPC Response** (with the same `id`) via the WebSocket.
+4. R retrieves the `result` (or `error`) and returns it.
+
+## 4. Hook Registration
+
+By default, the package does not inject hooks into the R session on load. Calling `sess::sess_app()` will start the server and automatically call `sess::register_hooks()` to enable features like automatic `View()` interception or plot redirection.
+
+If you need to manually register hooks without starting the full app environment (or re-register them if they were overridden), you can call:
+```r
+sess::register_hooks()
+```
+This rebinds internal functions (like `utils::View`) and sets `options()` for browsers, viewers, and devices to route through the IPC server.
+
+## 5. Comparison with Legacy IPC
+
+The `sess` package replaces the legacy file-based IPC mechanism with a modern, in-memory hybrid architecture using **JSON-RPC 2.0**.
+
+| Feature | Legacy IPC (File-based) | Modern IPC (`sess`) |
+| :--- | :--- | :--- |
+| **Command Dispatch** | `request.log` + `request.lock` | **WS Notification** (JSON-RPC) |
+| **Workspace State** | `workspace.json` + `workspace.lock` | **HTTP RPC `workspace`** (On-demand) |
+| **Static Plots** | `plot.png` + `plot.lock` | **WS Notification** + **HTTP RPC `plot_latest`** |
+| **Client Queries** | Custom HTTP Server payload | **HTTP RPC** (JSON-RPC 2.0) |
+| **Transport Reliability**| OS-level File System Watchers | **WebSocket & HTTP streams** |
+| **Protocol Standard** | Ad-hoc JSON formats | **JSON-RPC 2.0** |
+
+### Architectural Shifts
+
+1. **Elimination of File Watchers**: The legacy system relied heavily on OS-level file system watchers (`fs.watch`) monitoring lock files to trigger client updates. This approach could be unreliable or slow across different platforms, network drives, and remote container environments. `sess` replaces this entirely with persistent WebSocket connections for instantaneous, reliable event pushing.
+2. **On-Demand vs. Eager Evaluation**: Previously, R would eagerly evaluate and serialize the entire Global Environment to `workspace.json` frequently (e.g., via task callbacks), incurring significant continuous disk I/O and processing overhead. `sess` shifts this to a "Pull" model. The client requests the workspace state only when needed, significantly reducing R's background workload.
+3. **Unified Standard**: Instead of maintaining separate, disparate mechanisms for command logs, JSON dumps, and custom HTTP query payloads, `sess` unifies all structured communication under the ubiquitous **JSON-RPC 2.0** standard.
+
+### Responsiveness and the Event Loop
+
+Because R is fundamentally single-threaded, both IPC mechanisms are constrained by the R event loop, but they surface this limitation differently to the client:
+
+- **The "Busy" State**: If R is executing a long-running computation, the `httpuv` server running inside the session cannot process incoming HTTP requests (such as a request for `/rpc` `workspace` or `completion`). 
+- **Active vs. Passive Waiting**: In the legacy system, the client passively waited for `workspace.lock` to change, effectively ignoring the busy state until the operation completed. With the `sess` HTTP RPC model, the client actively requests data. Therefore, the client *must* implement short, aggressive timeouts (e.g., 500ms) for these HTTP requests. If a timeout occurs, the client gracefully interprets this as "R is busy" and can display a loading state without locking up the IDE's UI thread.

From 437ac1e21fba761e259e1aa281546b19505acdcf Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Wed, 11 Mar 2026 12:18:04 -0700
Subject: [PATCH 05/47] docs: expand detailed mapping of IPC mechanisms in
 README

---
 sess/README.md | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/sess/README.md b/sess/README.md
index cd894b02..b34e1c35 100644
--- a/sess/README.md
+++ b/sess/README.md
@@ -128,6 +128,24 @@ The `sess` package replaces the legacy file-based IPC mechanism with a modern, i
 | **Transport Reliability**| OS-level File System Watchers | **WebSocket & HTTP streams** |
 | **Protocol Standard** | Ad-hoc JSON formats | **JSON-RPC 2.0** |
 
+### Detailed Mapping: Legacy to Modern
+
+**1. Command Dispatch (e.g., `View()`, `browser()`, `help()`)**
+- **Old Approach:** R intercepted commands and appended custom JSON structures to a `request.log` file, then updated the timestamp on a `request.lock` file. The client OS file watcher detected the `.lock` file change, read the `.log` file, and processed the pending commands.
+- **New Approach (`sess`):** R directly pushes an instantaneous **JSON-RPC Notification** (e.g., `method: "dataview"`, `method: "help"`) over the persistent WebSocket connection. The client receives and processes the payload instantly, bypassing disk I/O and file system watchers entirely.
+
+**2. Workspace State (Global Environment)**
+- **Old Approach:** An R task callback ran after every top-level console execution, eagerly evaluating and serializing the entire Global Environment to a `workspace.json` file, followed by touching a `workspace.lock` file. The client watched for the lock file change to read the JSON file. This caused constant overhead and disk writes, even when the client's workspace pane was hidden.
+- **New Approach (`sess`):** Adopts a "Pull" architecture. The workspace is *only* evaluated and serialized when the client explicitly sends an **HTTP POST Request** to `/rpc` with `method: "workspace"`. This happens on-demand (e.g., when the UI pane is visible), saving significant R processing time and disk I/O.
+
+**3. Static Plots**
+- **Old Approach:** Plotting commands (via custom devices or hooks) generated a `plot.png` file on disk and updated a `plot.lock` file. The client watcher noticed the lock change, read the new PNG file from disk, and displayed it.
+- **New Approach (`sess`):** When a new plot is generated to a temporary file, R sends a lightweight **JSON-RPC Notification** (`method: "plot_updated"`) via the WebSocket. The client then pulls the actual image data by sending an **HTTP POST Request** to `/rpc` (`method: "plot_latest"`), which returns the base64-encoded image over the network stream.
+
+**4. Client Queries (Hover, Completion)**
+- **Old Approach:** The legacy architecture sometimes ran a rudimentary local HTTP server inside R that accepted custom HTTP GET/POST queries with ad-hoc URL paths (`/hover`, `/completion`) and custom JSON body structures.
+- **New Approach (`sess`):** Unified under the **JSON-RPC 2.0** standard. The client sends structured requests with strict `id` and `params` formatting to the single `/rpc` HTTP endpoint, receiving standardized JSON-RPC responses.
+
 ### Architectural Shifts
 
 1. **Elimination of File Watchers**: The legacy system relied heavily on OS-level file system watchers (`fs.watch`) monitoring lock files to trigger client updates. This approach could be unreliable or slow across different platforms, network drives, and remote container environments. `sess` replaces this entirely with persistent WebSocket connections for instantaneous, reliable event pushing.

From 1ba085eea3943f253d3824897f1b285a835ef6ac Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Wed, 11 Mar 2026 12:57:38 -0700
Subject: [PATCH 06/47] feat: add generic rstudioapi emulation and configurable
 options to sess_app

---
 sess/R/hooks.R      |  16 ++-
 sess/R/rstudioapi.R | 289 ++++++++++++++++++++++++++++++++++++++++++++
 sess/R/server.R     |   6 +-
 3 files changed, 307 insertions(+), 4 deletions(-)
 create mode 100644 sess/R/rstudioapi.R

diff --git a/sess/R/hooks.R b/sess/R/hooks.R
index 60c17028..fd580fd8 100644
--- a/sess/R/hooks.R
+++ b/sess/R/hooks.R
@@ -1,7 +1,9 @@
 #' Register hooks for the client IPC
 #'
+#' @param use_rstudioapi Logical. Enable rstudioapi emulation.
+#' @param use_httpgd Logical. Enable httpgd plot device if available.
 #' @export
-register_hooks <- function() {
+register_hooks <- function(use_rstudioapi = TRUE, use_httpgd = FALSE) {
   
   # 1. Override View() to push data directly via WebSocket
   rebind("View", function(x, title = deparse(substitute(x))) {
@@ -57,7 +59,6 @@ register_hooks <- function() {
   }, ns = "utils")
 
   # 4. httpgd or Static Plot Hook
-  use_httpgd <- isTRUE(getOption("vsc.use_httpgd", FALSE))
   if (use_httpgd && requireNamespace("httpgd", quietly = TRUE)) {
     options(device = function(...) {
         httpgd::hgd(silent = TRUE)
@@ -77,6 +78,17 @@ register_hooks <- function() {
       notify_client("plot_updated")
     }, "replace")
   }
+
+  # 5. rstudioapi hooks
+  if (use_rstudioapi) {
+    setHook(packageEvent("rstudioapi", "onLoad"), function(...) {
+      patch_rstudioapi()
+    }, action = "append")
+    
+    if ("rstudioapi" %in% loadedNamespaces()) {
+        patch_rstudioapi()
+    }
+  }
 }
 
 #' Emulate rstudioapi synchronously but without blocking the R Event Loop
diff --git a/sess/R/rstudioapi.R b/sess/R/rstudioapi.R
new file mode 100644
index 00000000..e3679a07
--- /dev/null
+++ b/sess/R/rstudioapi.R
@@ -0,0 +1,289 @@
+getActiveDocumentContext <- function() {
+    editor_context <- request_rstudioapi("active_editor_context", args = list())
+    make_rs_document_context(editor_context)
+}
+
+getSourceEditorContext <- getActiveDocumentContext
+
+verifyAvailable <- function(version_needed = NULL) {
+    if (is.null(version_needed)) TRUE else FALSE
+}
+
+isAvailable <- function(version_needed = NULL, child_ok) {
+    verifyAvailable(version_needed)
+}
+
+insertText <- function(location, text, id = NULL) {
+    if (missing(text) && is.character(location) && length(location) == 1) {
+        return(invisible(request_rstudioapi("replace_text_in_current_selection", args = list(text = location, id = id))))
+    } else if (missing(location)) {
+        return(invisible(request_rstudioapi("replace_text_in_current_selection", args = list(text = text, id = id))))
+    } else if (is.null(location) && missing(text)) {
+        return(invisible(NULL))
+    }
+
+    normalised_location <- normalise_pos_or_range_arg(location)
+    normalised_text <- normalise_text_arg(text, length(normalised_location))
+    
+    query <- mapply(function(location, text) {
+        list(
+            operation = if (rstudioapi::is.document_range(location)) "modifyRange" else "insertText",
+            location = location,
+            text = text
+        )
+    }, normalised_location, normalised_text, SIMPLIFY = FALSE)
+
+    invisible(request_rstudioapi("insert_or_modify_text", args = list(query = query, id = id)))
+}
+
+modifyRange <- insertText
+
+readPreference <- function(name, default) default
+readRStudioPreference <- readPreference
+
+.sess_rstudioapi_env <- environment()
+
+hasFun <- function(name, version_needed = NULL, ...) {
+    if (!is.null(version_needed)) return(FALSE)
+    obj <- .sess_rstudioapi_env[[name]]
+    is.function(obj) && !identical(obj, .sess_not_yet_implemented)
+}
+
+findFun <- function(name, version_needed = NULL, ...) {
+    if (!is.null(version_needed)) stop("the generic IPC client does not support used of 'version_needed'.")
+    if (hasFun(name, version_needed = version_needed, ...)) {
+        .sess_rstudioapi_env[[name]]
+    } else {
+        stop("Cannot find function '", name, "'")
+    }
+}
+
+showDialog <- function(title, message, url = "") {
+    message <- sprintf("%s: %s \n%s", title, message, url)
+    invisible(request_rstudioapi("show_dialog", args = list(message = message)))
+}
+
+navigateToFile <- function(file, line = -1L, column = -1L) {
+    invisible(request_rstudioapi("navigate_to_file", args = list(file = normalizePath(file), line = line, column = column)))
+}
+
+setSelectionRanges <- function(ranges, id = NULL) {
+    ranges_or_positions <- normalise_pos_or_range_arg(ranges)
+    ranges <- lapply(ranges_or_positions, function(location) {
+        if (rstudioapi::is.document_position(location)) rstudioapi::document_range(location, location) else location
+    })
+    invisible(request_rstudioapi("set_selection_ranges", args = list(ranges = ranges, id = id)))
+}
+
+setCursorPosition <- setSelectionRanges
+
+documentSave <- function(id = NULL) invisible(request_rstudioapi("document_save", args = list(id = id)))
+
+getActiveProject <- function() {
+    path_object <- request_rstudioapi("get_project_path", args = list())
+    if (is.null(path_object$path)) stop("No folder for active document.")
+    path_object$path
+}
+
+.sess_document_context <- function(id = NULL) request_rstudioapi("document_context", args = list(id = id))
+
+documentId <- function(allowConsole = TRUE) .sess_document_context()$id$external
+documentPath <- function(id = NULL) .sess_document_context(id)$id$path
+
+documentSaveAll <- function() invisible(request_rstudioapi("document_save_all", args = list()))
+
+documentNew <- function(text, type = c("r", "rmarkdown", "sql"), position = rstudioapi::document_position(0, 0), execute = FALSE) {
+    if (!rstudioapi::is.document_position((position))) stop("DocumentNew requires a document_position object")
+    if (length(text) != 1 || !is.character(text)) stop("text for DocumentNew must be a length one character vector.")
+    invisible(request_rstudioapi("document_new", args = list(text = text, type = type, position = position)))
+}
+
+setDocumentContents <- function(text, id = NULL) {
+    whole_document_range <- rstudioapi::document_range(
+        rstudioapi::document_position(0, 0),
+        rstudioapi::document_position(Inf, Inf)
+    )
+    insertText(whole_document_range, text, id)
+}
+
+restartSession <- function() invisible(request_rstudioapi("restart_r", args = list()))
+
+viewer <- function(url, height = NULL) {
+    notify_client("browser", list(url = url, title = "Viewer"))
+}
+
+getVersion <- function() numeric_version("0")
+
+versionInfo <- function() list(citation = "", mode = "generic-ipc", version = numeric_version("0"), release_name = "generic-ipc")
+
+sendToConsole <- function(code, execute = TRUE, echo = TRUE, focus = FALSE) {
+    if (!echo) stop("rstudioapi::sendToConsole only supports echo = TRUE in the generic IPC client.")
+    code_to_run <- paste0(code, collapse = "\n")
+    invisible(request_rstudioapi("send_to_console", args = list(code = code_to_run, execute = execute, focus = focus)))
+}
+
+.sess_not_yet_implemented <- function(...) stop("This {rstudioapi} function is not currently implemented for generic IPC.")
+
+# Add missing helpers from rstudioapi_util
+make_rs_range <- function(sess_selection) {
+    rstudioapi::document_range(
+        start = rstudioapi::document_position(row = sess_selection$start$line + 1, column = sess_selection$start$character + 1),
+        end = rstudioapi::document_position(row = sess_selection$end$line + 1, column = sess_selection$end$character + 1)
+    )
+}
+
+extract_document_ranges <- function(sess_selections) lapply(sess_selections, make_rs_range)
+
+to_content_lines <- function(contents, ranges) {
+    content_lines <- strsplit(contents, "\n|\r\n|\r$")[[1]]
+    range_end_row <- unlist(lapply(ranges, function(range) range$end["row"]))
+    last_row <- max(range_end_row)
+    if (last_row == length(content_lines) + 1) content_lines <- c(content_lines, "")
+    content_lines
+}
+
+extract_range_text <- function(range, content_lines) {
+    if (!range_has_text(range)) return("")
+    content_rows <- content_lines[(range$start["row"]):(range$end["row"])]
+    content_rows[length(content_rows)] <- substring(content_rows[length(content_rows)], 1, range$end["column"] - 1)
+    content_rows[1] <- substring(content_rows[1], range$start["column"])
+    paste0(content_rows, collapse = "\n")
+}
+
+range_has_text <- function(range) (range$end["row"] - range$start["row"]) + (range$end["column"] - range$start["column"]) > 0
+
+make_rs_document_selection <- function(ranges, range_texts) {
+    selection_data <- mapply(function(range, text) list(range = range, text = text), ranges, range_texts, SIMPLIFY = FALSE)
+    structure(selection_data, class = "document_selection")
+}
+
+make_rs_document_context <- function(sess_editor_context) {
+    document_ranges <- extract_document_ranges(sess_editor_context$selection)
+    content_lines <- to_content_lines(sess_editor_context$contents, document_ranges)
+    document_range_texts <- lapply(document_ranges, extract_range_text, content_lines)
+    document_selection <- make_rs_document_selection(document_ranges, document_range_texts)
+    structure(list(id = sess_editor_context$id$external, path = sess_editor_context$path, contents = content_lines, selections = document_selection), class = "document_context")
+}
+
+is_positionable <- function(p) is.numeric(p) && length(p) == 2
+is_rangable <- function(r) is.numeric(r) && length(r) == 4
+
+normalise_pos_or_range_arg <- function(location) {
+    if (rstudioapi::is.document_position(location)) {
+        list(location)
+    } else if (is_positionable(location)) {
+        list(rstudioapi::as.document_position(location))
+    } else if (rstudioapi::is.document_range(location)) {
+        list(location)
+    } else if (is_rangable(location)) {
+        list(rstudioapi::as.document_range(location))
+    } else if (is.list(location)) {
+        lapply(location, function(a_location) {
+            if (rstudioapi::is.document_position(a_location) || rstudioapi::is.document_range(a_location)) a_location
+            else if (is_positionable(a_location)) rstudioapi::as.document_position(a_location)
+            else if (is_rangable((a_location))) rstudioapi::as.document_range(a_location)
+            else stop("object in location list was not a document_position or document_range")
+        })
+    } else stop("location object was not a document_position or document_range")
+}
+
+normalise_text_arg <- function(text, location_length) {
+    if (length(text) == location_length) text
+    else if (length(text) == 1 && location_length > 1) rep(text, location_length)
+    else stop("text vector needs to be of length 1 or the same length as location list")
+}
+
+namespace_has <- function(obj, namespace) {
+    attempt <- try(getFromNamespace(obj, namespace), silent = TRUE)
+    !inherits(attempt, "try-error")
+}
+
+patch_rstudioapi <- function() {
+    overrides <- list(
+        getActiveDocumentContext = getActiveDocumentContext,
+        getSourceEditorContext = getSourceEditorContext,
+        insertText = insertText,
+        modifyRange = modifyRange,
+        showDialog = showDialog,
+        navigateToFile = navigateToFile,
+        setSelectionRanges = setSelectionRanges,
+        setCursorPosition = setCursorPosition,
+        documentSave = documentSave,
+        getActiveProject = getActiveProject,
+        documentId = documentId,
+        documentPath = documentPath,
+        documentSaveAll = documentSaveAll,
+        documentNew = documentNew,
+        setDocumentContents = setDocumentContents,
+        restartSession = restartSession,
+        viewer = viewer,
+        getVersion = getVersion,
+        versionInfo = versionInfo,
+        sendToConsole = sendToConsole,
+        hasFun = hasFun,
+        findFun = findFun,
+        isAvailable = isAvailable,
+        verifyAvailable = verifyAvailable,
+        readPreference = readPreference,
+        readRStudioPreference = readRStudioPreference,
+        
+        getConsoleEditorContext = .sess_not_yet_implemented,
+        sourceMarkers = .sess_not_yet_implemented,
+        documentClose = .sess_not_yet_implemented,
+        showPrompt = .sess_not_yet_implemented,
+        showQuestion = .sess_not_yet_implemented,
+        updateDialog = .sess_not_yet_implemented,
+        openProject = .sess_not_yet_implemented,
+        initializeProject = .sess_not_yet_implemented,
+        addTheme = .sess_not_yet_implemented,
+        applyTheme = .sess_not_yet_implemented,
+        convertTheme = .sess_not_yet_implemented,
+        getThemeInfo = .sess_not_yet_implemented,
+        getThemes = .sess_not_yet_implemented,
+        removeTheme = .sess_not_yet_implemented,
+        jobAdd = .sess_not_yet_implemented,
+        jobAddOutput = .sess_not_yet_implemented,
+        jobAddProgress = .sess_not_yet_implemented,
+        jobRemove = .sess_not_yet_implemented,
+        jobRunScript = .sess_not_yet_implemented,
+        jobSetProgress = .sess_not_yet_implemented,
+        jobSetState = .sess_not_yet_implemented,
+        jobSetStatus = .sess_not_yet_implemented,
+        launcherGetInfo = .sess_not_yet_implemented,
+        launcherAvailable = .sess_not_yet_implemented,
+        launcherGetJobs = .sess_not_yet_implemented,
+        launcherConfig = .sess_not_yet_implemented,
+        launcherContainer = .sess_not_yet_implemented,
+        launcherControlJob = .sess_not_yet_implemented,
+        launcherGetJob = .sess_not_yet_implemented,
+        launcherHostMount = .sess_not_yet_implemented,
+        launcherNfsMount = .sess_not_yet_implemented,
+        launcherPlacementConstraint = .sess_not_yet_implemented,
+        launcherResourceLimit = .sess_not_yet_implemented,
+        launcherSubmitJob = .sess_not_yet_implemented,
+        launcherSubmitR = .sess_not_yet_implemented,
+        previewRd = .sess_not_yet_implemented,
+        previewSql = .sess_not_yet_implemented,
+        writePreference = .sess_not_yet_implemented,
+        writeRStudioPreference = .sess_not_yet_implemented,
+        getPersistentValue = .sess_not_yet_implemented,
+        setPersistentValue = .sess_not_yet_implemented,
+        savePlotAsImage = .sess_not_yet_implemented,
+        createProjectTemplate = .sess_not_yet_implemented,
+        hasColourConsole = .sess_not_yet_implemented,
+        bugReport = .sess_not_yet_implemented,
+        buildToolsCheck = .sess_not_yet_implemented,
+        buildToolsInstall = .sess_not_yet_implemented,
+        buildToolsExec = .sess_not_yet_implemented,
+        dictionariesPath = .sess_not_yet_implemented,
+        userDictionariesPath = .sess_not_yet_implemented,
+        executeCommand = .sess_not_yet_implemented,
+        translateLocalUrl = .sess_not_yet_implemented
+    )
+
+    for (name in names(overrides)) {
+        if (exists(name, envir = asNamespace("rstudioapi"), inherits = FALSE)) {
+            rebind(name, overrides[[name]], "rstudioapi")
+        }
+    }
+}
diff --git a/sess/R/server.R b/sess/R/server.R
index 845512d3..18688c2c 100644
--- a/sess/R/server.R
+++ b/sess/R/server.R
@@ -1,7 +1,9 @@
 #' Start the client R IPC Server
 #' 
+#' @param use_rstudioapi Logical. Should the rstudioapi emulation layer be enabled? Defaults to TRUE.
+#' @param use_httpgd Logical. Should httpgd be used for plotting if available? Defaults to FALSE.
 #' @export
-sess_app <- function() {
+sess_app <- function(use_rstudioapi = TRUE, use_httpgd = FALSE) {
   
   on.exit({
     if (!is.null(.sess_env$server)) {
@@ -111,5 +113,5 @@ sess_app <- function() {
   cat(sprintf("\n[sess] SESS_IPC_SERVER=ws://127.0.0.1:%d?token=%s\n", port, .sess_env$token))
   
   # Register runtime hooks
-  register_hooks()
+  register_hooks(use_rstudioapi = use_rstudioapi, use_httpgd = use_httpgd)
 }
\ No newline at end of file

From 79653e97a7620ef3dae88098a36442a1e525126e Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Wed, 11 Mar 2026 13:44:18 -0700
Subject: [PATCH 07/47] refactor: unify IPC dispatch and improve rstudioapi
 emulation correctness

- Centralize WebSocket communication in ipc_send (dispatch.R)
- Correct 1-indexed to 0-indexed coordinate conversion for rstudioapi
- Fix document_context structure and document-selection classes
- Add page_viewer and documentClose to emulation layer
- Update README with coordinate handling details
---
 sess/DESCRIPTION    |  3 +-
 sess/R/dispatch.R   | 77 +++++++++++++++++++++++++++++------
 sess/R/hooks.R      | 47 ----------------------
 sess/R/rstudioapi.R | 98 +++++++++++++++++++++++++++++++++++----------
 sess/README.md      |  6 ++-
 5 files changed, 147 insertions(+), 84 deletions(-)

diff --git a/sess/DESCRIPTION b/sess/DESCRIPTION
index 2133c620..d69f4443 100644
--- a/sess/DESCRIPTION
+++ b/sess/DESCRIPTION
@@ -12,5 +12,6 @@ Imports:
     httpuv,
     jsonlite,
     utils,
-    methods
+    methods,
+    rstudioapi
 RoxygenNote: 7.2.3
diff --git a/sess/R/dispatch.R b/sess/R/dispatch.R
index 9e2695b9..ede937ee 100644
--- a/sess/R/dispatch.R
+++ b/sess/R/dispatch.R
@@ -1,26 +1,77 @@
-#' Notify the client via WebSocket (JSON-RPC 2.0 Notification)
-#' 
-#' Pushes an event instantly to the client extension via the active WebSocket connection.
+#' Send a message to the client via WebSocket (JSON-RPC 2.0)
 #'
-#' @param method A string representing the action (e.g., "dataview", "plot_updated")
-#' @param params A list containing the arguments for the command
-#' @export
-notify_client <- function(method, params = list()) {
+#' This is the internal workhorse for both Notifications and Requests.
+#'
+#' @param method String. The JSON-RPC method.
+#' @param params List. The parameters for the method.
+#' @param request Logical. If TRUE, sends a Request and waits for a Response.
+#' @return The result of the request if request=TRUE, otherwise TRUE if sent.
+#' @keywords internal
+ipc_send <- function(method, params = list(), request = FALSE) {
   if (is.null(.sess_env$ws)) {
-    return(FALSE) # No active client connected
+    return(invisible(FALSE))
   }
-  
+
   msg <- list(
     jsonrpc = "2.0",
     method = method,
     params = params
   )
-  
-  # Push instantly over the websocket
+
+  req_id <- NULL
+  if (request) {
+    req_id <- basename(tempfile("req_"))
+    msg$id <- req_id
+  }
+
+  # Push over the websocket
   tryCatch({
     .sess_env$ws$send(jsonlite::toJSON(msg, auto_unbox = TRUE, null = "null", force = TRUE))
-    return(TRUE)
   }, error = function(e) {
-    return(FALSE)
+    warning("Failed to send IPC message: ", e$message)
+    return(invisible(FALSE))
   })
+
+  if (!request) {
+    return(invisible(TRUE))
+  }
+
+  # NON-BLOCKING WAIT:
+  # Process HTTP/WS events in the background while blocking the R console execution
+  # This prevents the R event loop from locking up.
+  while (is.null(.sess_env$pending_responses[[req_id]])) {
+    httpuv::service() 
+    Sys.sleep(0.01)
+  }
+
+  # Retrieve and clean up response
+  response <- .sess_env$pending_responses[[req_id]]
+  .sess_env$pending_responses[[req_id]] <- NULL
+
+  # Handle JSON-RPC Errors if any
+  if (inherits(response, "json_rpc_error")) {
+    stop(sprintf("JSON-RPC Error [%d]: %s", response$code, response$message))
+  }
+
+  return(response)
+}
+
+#' Notify the client via WebSocket (JSON-RPC 2.0 Notification)
+#'
+#' Pushes an event instantly to the client extension via the active WebSocket connection.
+#'
+#' @param method A string representing the action (e.g., "dataview", "plot_updated")
+#' @param params A list containing the arguments for the command
+#' @export
+notify_client <- function(method, params = list()) {
+  ipc_send(method, params, request = FALSE)
+}
+
+#' Emulate rstudioapi synchronously but without blocking the R Event Loop
+#'
+#' @param action String of the rstudioapi action
+#' @param args List of arguments
+#' @export
+request_rstudioapi <- function(action, args = list()) {
+  ipc_send("rstudioapi", list(action = action, args = args), request = TRUE)
 }
diff --git a/sess/R/hooks.R b/sess/R/hooks.R
index fd580fd8..3072de88 100644
--- a/sess/R/hooks.R
+++ b/sess/R/hooks.R
@@ -89,51 +89,4 @@ register_hooks <- function(use_rstudioapi = TRUE, use_httpgd = FALSE) {
         patch_rstudioapi()
     }
   }
-}
-
-#' Emulate rstudioapi synchronously but without blocking the R Event Loop
-#'
-#' @param action String of the rstudioapi action
-#' @param args List of arguments
-#' @export
-request_rstudioapi <- function(action, args = list()) {
-  req_id <- basename(tempfile("req_"))
-  
-  # Send JSON-RPC 2.0 Request via websocket
-  msg <- list(
-    jsonrpc = "2.0",
-    id = req_id,
-    method = "rstudioapi",
-    params = list(
-        action = action,
-        args = args
-    )
-  )
-
-  if (!is.null(.sess_env$ws)) {
-    tryCatch({
-        .sess_env$ws$send(jsonlite::toJSON(msg, auto_unbox = TRUE, null = "null", force = TRUE))
-    }, error = function(e) return(NULL))
-  } else {
-    return(NULL)
-  }
-  
-  # NON-BLOCKING WAIT:
-  # Process HTTP/WS events in the background while blocking the R console execution
-  # This prevents the R event loop from locking up.
-  while (is.null(.sess_env$pending_responses[[req_id]])) {
-    httpuv::service() 
-    Sys.sleep(0.05)
-  }
-  
-  # Retrieve and clean up response
-  response <- .sess_env$pending_responses[[req_id]]
-  .sess_env$pending_responses[[req_id]] <- NULL
-  
-  # Handle JSON-RPC Errors if any
-  if (inherits(response, "json_rpc_error")) {
-    stop(sprintf("JSON-RPC Error [%d]: %s", response$code, response$message))
-  }
-  
-  return(response)
 }
\ No newline at end of file
diff --git a/sess/R/rstudioapi.R b/sess/R/rstudioapi.R
index e3679a07..27dcd5bb 100644
--- a/sess/R/rstudioapi.R
+++ b/sess/R/rstudioapi.R
@@ -6,10 +6,11 @@ getActiveDocumentContext <- function() {
 getSourceEditorContext <- getActiveDocumentContext
 
 verifyAvailable <- function(version_needed = NULL) {
-    if (is.null(version_needed)) TRUE else FALSE
+    if (is.null(version_needed)) return(TRUE)
+    getVersion() >= numeric_version(version_needed)
 }
 
-isAvailable <- function(version_needed = NULL, child_ok) {
+isAvailable <- function(version_needed = NULL, child_ok = FALSE) {
     verifyAvailable(version_needed)
 }
 
@@ -28,7 +29,7 @@ insertText <- function(location, text, id = NULL) {
     query <- mapply(function(location, text) {
         list(
             operation = if (rstudioapi::is.document_range(location)) "modifyRange" else "insertText",
-            location = location,
+            location = serialize_location(location),
             text = text
         )
     }, normalised_location, normalised_text, SIMPLIFY = FALSE)
@@ -44,13 +45,19 @@ readRStudioPreference <- readPreference
 .sess_rstudioapi_env <- environment()
 
 hasFun <- function(name, version_needed = NULL, ...) {
-    if (!is.null(version_needed)) return(FALSE)
+    if (!is.null(version_needed)) {
+        if (!verifyAvailable(version_needed)) return(FALSE)
+    }
     obj <- .sess_rstudioapi_env[[name]]
     is.function(obj) && !identical(obj, .sess_not_yet_implemented)
 }
 
 findFun <- function(name, version_needed = NULL, ...) {
-    if (!is.null(version_needed)) stop("the generic IPC client does not support used of 'version_needed'.")
+    if (!is.null(version_needed)) {
+        if (!verifyAvailable(version_needed)) {
+             stop("the generic IPC client does not support used of 'version_needed' > 0.")
+        }
+    }
     if (hasFun(name, version_needed = version_needed, ...)) {
         .sess_rstudioapi_env[[name]]
     } else {
@@ -63,8 +70,12 @@ showDialog <- function(title, message, url = "") {
     invisible(request_rstudioapi("show_dialog", args = list(message = message)))
 }
 
-navigateToFile <- function(file, line = -1L, column = -1L) {
-    invisible(request_rstudioapi("navigate_to_file", args = list(file = normalizePath(file), line = line, column = column)))
+navigateToFile <- function(file, line = 1L, column = 1L) {
+    invisible(request_rstudioapi("navigate_to_file", args = list(
+        file = normalizePath(file), 
+        line = line - 1L, 
+        column = column - 1L
+    )))
 }
 
 setSelectionRanges <- function(ranges, id = NULL) {
@@ -72,7 +83,8 @@ setSelectionRanges <- function(ranges, id = NULL) {
     ranges <- lapply(ranges_or_positions, function(location) {
         if (rstudioapi::is.document_position(location)) rstudioapi::document_range(location, location) else location
     })
-    invisible(request_rstudioapi("set_selection_ranges", args = list(ranges = ranges, id = id)))
+    sess_ranges <- lapply(ranges, serialize_range)
+    invisible(request_rstudioapi("set_selection_ranges", args = list(ranges = sess_ranges, id = id)))
 }
 
 setCursorPosition <- setSelectionRanges
@@ -81,8 +93,7 @@ documentSave <- function(id = NULL) invisible(request_rstudioapi("document_save"
 
 getActiveProject <- function() {
     path_object <- request_rstudioapi("get_project_path", args = list())
-    if (is.null(path_object$path)) stop("No folder for active document.")
-    path_object$path
+    path_object$path # Should be NULL if no project is open
 }
 
 .sess_document_context <- function(id = NULL) request_rstudioapi("document_context", args = list(id = id))
@@ -92,15 +103,15 @@ documentPath <- function(id = NULL) .sess_document_context(id)$id$path
 
 documentSaveAll <- function() invisible(request_rstudioapi("document_save_all", args = list()))
 
-documentNew <- function(text, type = c("r", "rmarkdown", "sql"), position = rstudioapi::document_position(0, 0), execute = FALSE) {
+documentNew <- function(text = "", type = c("r", "rmarkdown", "sql"), position = rstudioapi::document_position(1, 1), execute = FALSE) {
     if (!rstudioapi::is.document_position((position))) stop("DocumentNew requires a document_position object")
     if (length(text) != 1 || !is.character(text)) stop("text for DocumentNew must be a length one character vector.")
-    invisible(request_rstudioapi("document_new", args = list(text = text, type = type, position = position)))
+    invisible(request_rstudioapi("document_new", args = list(text = text, type = match.arg(type), position = serialize_pos(position))))
 }
 
 setDocumentContents <- function(text, id = NULL) {
     whole_document_range <- rstudioapi::document_range(
-        rstudioapi::document_position(0, 0),
+        rstudioapi::document_position(1, 1),
         rstudioapi::document_position(Inf, Inf)
     )
     insertText(whole_document_range, text, id)
@@ -109,7 +120,11 @@ setDocumentContents <- function(text, id = NULL) {
 restartSession <- function() invisible(request_rstudioapi("restart_r", args = list()))
 
 viewer <- function(url, height = NULL) {
-    notify_client("browser", list(url = url, title = "Viewer"))
+    notify_client("webview", list(file = url, title = "Viewer"))
+}
+
+page_viewer <- function(url, title = NULL) {
+    notify_client("browser", list(url = url, title = if (is.null(title)) "Page Viewer" else title))
 }
 
 getVersion <- function() numeric_version("0")
@@ -117,11 +132,15 @@ getVersion <- function() numeric_version("0")
 versionInfo <- function() list(citation = "", mode = "generic-ipc", version = numeric_version("0"), release_name = "generic-ipc")
 
 sendToConsole <- function(code, execute = TRUE, echo = TRUE, focus = FALSE) {
-    if (!echo) stop("rstudioapi::sendToConsole only supports echo = TRUE in the generic IPC client.")
+    if (!echo) warning("rstudioapi::sendToConsole echo = FALSE is not supported in the generic IPC client.")
     code_to_run <- paste0(code, collapse = "\n")
     invisible(request_rstudioapi("send_to_console", args = list(code = code_to_run, execute = execute, focus = focus)))
 }
 
+documentClose <- function(id = NULL, save = TRUE) {
+    invisible(request_rstudioapi("document_close", args = list(id = id, save = save)))
+}
+
 .sess_not_yet_implemented <- function(...) stop("This {rstudioapi} function is not currently implemented for generic IPC.")
 
 # Add missing helpers from rstudioapi_util
@@ -136,6 +155,7 @@ extract_document_ranges <- function(sess_selections) lapply(sess_selections, mak
 
 to_content_lines <- function(contents, ranges) {
     content_lines <- strsplit(contents, "\n|\r\n|\r$")[[1]]
+    if (length(ranges) == 0) return(content_lines)
     range_end_row <- unlist(lapply(ranges, function(range) range$end["row"]))
     last_row <- max(range_end_row)
     if (last_row == length(content_lines) + 1) content_lines <- c(content_lines, "")
@@ -144,17 +164,29 @@ to_content_lines <- function(contents, ranges) {
 
 extract_range_text <- function(range, content_lines) {
     if (!range_has_text(range)) return("")
-    content_rows <- content_lines[(range$start["row"]):(range$end["row"])]
-    content_rows[length(content_rows)] <- substring(content_rows[length(content_rows)], 1, range$end["column"] - 1)
+    start_row <- range$start["row"]
+    end_row <- range$end["row"]
+    if (start_row > length(content_lines)) return("")
+    
+    content_rows <- content_lines[start_row:min(end_row, length(content_lines))]
+    
+    # Adjust end
+    if (end_row <= length(content_lines)) {
+        content_rows[length(content_rows)] <- substring(content_rows[length(content_rows)], 1, range$end["column"] - 1)
+    }
+    
+    # Adjust start
     content_rows[1] <- substring(content_rows[1], range$start["column"])
+    
     paste0(content_rows, collapse = "\n")
 }
 
 range_has_text <- function(range) (range$end["row"] - range$start["row"]) + (range$end["column"] - range$start["column"]) > 0
 
 make_rs_document_selection <- function(ranges, range_texts) {
-    selection_data <- mapply(function(range, text) list(range = range, text = text), ranges, range_texts, SIMPLIFY = FALSE)
-    structure(selection_data, class = "document_selection")
+    mapply(function(range, text) {
+        structure(list(range = range, text = text), class = "document_selection")
+    }, ranges, range_texts, SIMPLIFY = FALSE)
 }
 
 make_rs_document_context <- function(sess_editor_context) {
@@ -162,7 +194,12 @@ make_rs_document_context <- function(sess_editor_context) {
     content_lines <- to_content_lines(sess_editor_context$contents, document_ranges)
     document_range_texts <- lapply(document_ranges, extract_range_text, content_lines)
     document_selection <- make_rs_document_selection(document_ranges, document_range_texts)
-    structure(list(id = sess_editor_context$id$external, path = sess_editor_context$path, contents = content_lines, selections = document_selection), class = "document_context")
+    structure(list(
+        id = sess_editor_context$id$external, 
+        path = sess_editor_context$path, 
+        contents = content_lines, 
+        selection = document_selection
+    ), class = "document_context")
 }
 
 is_positionable <- function(p) is.numeric(p) && length(p) == 2
@@ -193,6 +230,24 @@ normalise_text_arg <- function(text, location_length) {
     else stop("text vector needs to be of length 1 or the same length as location list")
 }
 
+serialize_pos <- function(pos) {
+    list(line = pos[["row"]] - 1, character = pos[["column"]] - 1)
+}
+
+serialize_range <- function(range) {
+    list(start = serialize_pos(range$start), end = serialize_pos(range$end))
+}
+
+serialize_location <- function(location) {
+    if (rstudioapi::is.document_position(location)) {
+        serialize_pos(location)
+    } else if (rstudioapi::is.document_range(location)) {
+        serialize_range(location)
+    } else {
+        location
+    }
+}
+
 namespace_has <- function(obj, namespace) {
     attempt <- try(getFromNamespace(obj, namespace), silent = TRUE)
     !inherits(attempt, "try-error")
@@ -217,9 +272,11 @@ patch_rstudioapi <- function() {
         setDocumentContents = setDocumentContents,
         restartSession = restartSession,
         viewer = viewer,
+        page_viewer = page_viewer,
         getVersion = getVersion,
         versionInfo = versionInfo,
         sendToConsole = sendToConsole,
+        documentClose = documentClose,
         hasFun = hasFun,
         findFun = findFun,
         isAvailable = isAvailable,
@@ -229,7 +286,6 @@ patch_rstudioapi <- function() {
         
         getConsoleEditorContext = .sess_not_yet_implemented,
         sourceMarkers = .sess_not_yet_implemented,
-        documentClose = .sess_not_yet_implemented,
         showPrompt = .sess_not_yet_implemented,
         showQuestion = .sess_not_yet_implemented,
         updateDialog = .sess_not_yet_implemented,
diff --git a/sess/README.md b/sess/README.md
index b34e1c35..60f8fc02 100644
--- a/sess/README.md
+++ b/sess/README.md
@@ -96,15 +96,17 @@ Returns the most recent static plot captured by the R session.
 
 ---
 
-## 3. Synchronous RStudio API Emulation
+3. Synchronous RStudio API Emulation
 
 The `request_rstudioapi()` function allows R to call client-side functions synchronously by sending a **JSON-RPC Request** (with an `id`) over the WebSocket:
 
 1. R sends a request with `method: "rstudioapi"`.
 2. R enters a `while` loop that calls `httpuv::service()`.
-3. The client processes the action and sends back a **JSON-RPC Response** (with the same `id`) via the WebSocket.
+3. The client processes the action and sends back a **JSON-RPC Response** (with the same id) via the WebSocket.
 4. R retrieves the `result` (or `error`) and returns it.
 
+**Coordinate Handling**: The emulation layer automatically converts between R (1-indexed) and IPC (0-indexed) coordinates. Locations and ranges sent to the client are 0-indexed, while data received from the client (e.g., in `document_context`) is converted back to 1-indexed R objects.
+
 ## 4. Hook Registration
 
 By default, the package does not inject hooks into the R session on load. Calling `sess::sess_app()` will start the server and automatically call `sess::register_hooks()` to enable features like automatic `View()` interception or plot redirection.

From 4e037788e08b705c7a00ff5af58832a4f05c90fd Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Wed, 11 Mar 2026 13:47:08 -0700
Subject: [PATCH 08/47] refactor: flatten RStudio API JSON-RPC message
 structure

- Remove 'rstudioapi/' prefix and action/args nesting
- Actions now serve directly as JSON-RPC method names
- Update README.md to reflect the simplified IPC protocol
---
 sess/R/dispatch.R | 2 +-
 sess/README.md    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/sess/R/dispatch.R b/sess/R/dispatch.R
index ede937ee..859cbf63 100644
--- a/sess/R/dispatch.R
+++ b/sess/R/dispatch.R
@@ -73,5 +73,5 @@ notify_client <- function(method, params = list()) {
 #' @param args List of arguments
 #' @export
 request_rstudioapi <- function(action, args = list()) {
-  ipc_send("rstudioapi", list(action = action, args = args), request = TRUE)
+  ipc_send(action, args, request = TRUE)
 }
diff --git a/sess/README.md b/sess/README.md
index 60f8fc02..45ad845c 100644
--- a/sess/README.md
+++ b/sess/README.md
@@ -100,7 +100,7 @@ Returns the most recent static plot captured by the R session.
 
 The `request_rstudioapi()` function allows R to call client-side functions synchronously by sending a **JSON-RPC Request** (with an `id`) over the WebSocket:
 
-1. R sends a request with `method: "rstudioapi"`.
+1. R sends a request with `method` set to the action name (e.g., `"active_editor_context"`).
 2. R enters a `while` loop that calls `httpuv::service()`.
 3. The client processes the action and sends back a **JSON-RPC Response** (with the same id) via the WebSocket.
 4. R retrieves the `result` (or `error`) and returns it.

From 68436230a9a745f15299cab33092daf734b10333 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Wed, 11 Mar 2026 13:47:40 -0700
Subject: [PATCH 09/47] refactor: rename request_rstudioapi to request_client

- Rename function to reflect generic IPC capability
- Update all call sites in rstudioapi.R
- Update NAMESPACE export and README.md documentation
---
 sess/NAMESPACE      |  2 +-
 sess/R/dispatch.R   |  6 +++---
 sess/R/rstudioapi.R | 30 +++++++++++++++---------------
 sess/README.md      |  2 +-
 4 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/sess/NAMESPACE b/sess/NAMESPACE
index ddd5e356..ec11fc0c 100644
--- a/sess/NAMESPACE
+++ b/sess/NAMESPACE
@@ -2,7 +2,7 @@
 
 export(notify_client)
 export(register_hooks)
-export(request_rstudioapi)
+export(request_client)
 export(sess_app)
 import(httpuv)
 import(jsonlite)
diff --git a/sess/R/dispatch.R b/sess/R/dispatch.R
index 859cbf63..b3a70785 100644
--- a/sess/R/dispatch.R
+++ b/sess/R/dispatch.R
@@ -67,11 +67,11 @@ notify_client <- function(method, params = list()) {
   ipc_send(method, params, request = FALSE)
 }
 
-#' Emulate rstudioapi synchronously but without blocking the R Event Loop
+#' Emulate rstudioapi (or any client action) synchronously but without blocking the R Event Loop
 #'
-#' @param action String of the rstudioapi action
+#' @param action String of the action name
 #' @param args List of arguments
 #' @export
-request_rstudioapi <- function(action, args = list()) {
+request_client <- function(action, args = list()) {
   ipc_send(action, args, request = TRUE)
 }
diff --git a/sess/R/rstudioapi.R b/sess/R/rstudioapi.R
index 27dcd5bb..822e5780 100644
--- a/sess/R/rstudioapi.R
+++ b/sess/R/rstudioapi.R
@@ -1,5 +1,5 @@
 getActiveDocumentContext <- function() {
-    editor_context <- request_rstudioapi("active_editor_context", args = list())
+    editor_context <- request_client("active_editor_context", args = list())
     make_rs_document_context(editor_context)
 }
 
@@ -16,9 +16,9 @@ isAvailable <- function(version_needed = NULL, child_ok = FALSE) {
 
 insertText <- function(location, text, id = NULL) {
     if (missing(text) && is.character(location) && length(location) == 1) {
-        return(invisible(request_rstudioapi("replace_text_in_current_selection", args = list(text = location, id = id))))
+        return(invisible(request_client("replace_text_in_current_selection", args = list(text = location, id = id))))
     } else if (missing(location)) {
-        return(invisible(request_rstudioapi("replace_text_in_current_selection", args = list(text = text, id = id))))
+        return(invisible(request_client("replace_text_in_current_selection", args = list(text = text, id = id))))
     } else if (is.null(location) && missing(text)) {
         return(invisible(NULL))
     }
@@ -34,7 +34,7 @@ insertText <- function(location, text, id = NULL) {
         )
     }, normalised_location, normalised_text, SIMPLIFY = FALSE)
 
-    invisible(request_rstudioapi("insert_or_modify_text", args = list(query = query, id = id)))
+    invisible(request_client("insert_or_modify_text", args = list(query = query, id = id)))
 }
 
 modifyRange <- insertText
@@ -67,11 +67,11 @@ findFun <- function(name, version_needed = NULL, ...) {
 
 showDialog <- function(title, message, url = "") {
     message <- sprintf("%s: %s \n%s", title, message, url)
-    invisible(request_rstudioapi("show_dialog", args = list(message = message)))
+    invisible(request_client("show_dialog", args = list(message = message)))
 }
 
 navigateToFile <- function(file, line = 1L, column = 1L) {
-    invisible(request_rstudioapi("navigate_to_file", args = list(
+    invisible(request_client("navigate_to_file", args = list(
         file = normalizePath(file), 
         line = line - 1L, 
         column = column - 1L
@@ -84,29 +84,29 @@ setSelectionRanges <- function(ranges, id = NULL) {
         if (rstudioapi::is.document_position(location)) rstudioapi::document_range(location, location) else location
     })
     sess_ranges <- lapply(ranges, serialize_range)
-    invisible(request_rstudioapi("set_selection_ranges", args = list(ranges = sess_ranges, id = id)))
+    invisible(request_client("set_selection_ranges", args = list(ranges = sess_ranges, id = id)))
 }
 
 setCursorPosition <- setSelectionRanges
 
-documentSave <- function(id = NULL) invisible(request_rstudioapi("document_save", args = list(id = id)))
+documentSave <- function(id = NULL) invisible(request_client("document_save", args = list(id = id)))
 
 getActiveProject <- function() {
-    path_object <- request_rstudioapi("get_project_path", args = list())
+    path_object <- request_client("get_project_path", args = list())
     path_object$path # Should be NULL if no project is open
 }
 
-.sess_document_context <- function(id = NULL) request_rstudioapi("document_context", args = list(id = id))
+.sess_document_context <- function(id = NULL) request_client("document_context", args = list(id = id))
 
 documentId <- function(allowConsole = TRUE) .sess_document_context()$id$external
 documentPath <- function(id = NULL) .sess_document_context(id)$id$path
 
-documentSaveAll <- function() invisible(request_rstudioapi("document_save_all", args = list()))
+documentSaveAll <- function() invisible(request_client("document_save_all", args = list()))
 
 documentNew <- function(text = "", type = c("r", "rmarkdown", "sql"), position = rstudioapi::document_position(1, 1), execute = FALSE) {
     if (!rstudioapi::is.document_position((position))) stop("DocumentNew requires a document_position object")
     if (length(text) != 1 || !is.character(text)) stop("text for DocumentNew must be a length one character vector.")
-    invisible(request_rstudioapi("document_new", args = list(text = text, type = match.arg(type), position = serialize_pos(position))))
+    invisible(request_client("document_new", args = list(text = text, type = match.arg(type), position = serialize_pos(position))))
 }
 
 setDocumentContents <- function(text, id = NULL) {
@@ -117,7 +117,7 @@ setDocumentContents <- function(text, id = NULL) {
     insertText(whole_document_range, text, id)
 }
 
-restartSession <- function() invisible(request_rstudioapi("restart_r", args = list()))
+restartSession <- function() invisible(request_client("restart_r", args = list()))
 
 viewer <- function(url, height = NULL) {
     notify_client("webview", list(file = url, title = "Viewer"))
@@ -134,11 +134,11 @@ versionInfo <- function() list(citation = "", mode = "generic-ipc", version = nu
 sendToConsole <- function(code, execute = TRUE, echo = TRUE, focus = FALSE) {
     if (!echo) warning("rstudioapi::sendToConsole echo = FALSE is not supported in the generic IPC client.")
     code_to_run <- paste0(code, collapse = "\n")
-    invisible(request_rstudioapi("send_to_console", args = list(code = code_to_run, execute = execute, focus = focus)))
+    invisible(request_client("send_to_console", args = list(code = code_to_run, execute = execute, focus = focus)))
 }
 
 documentClose <- function(id = NULL, save = TRUE) {
-    invisible(request_rstudioapi("document_close", args = list(id = id, save = save)))
+    invisible(request_client("document_close", args = list(id = id, save = save)))
 }
 
 .sess_not_yet_implemented <- function(...) stop("This {rstudioapi} function is not currently implemented for generic IPC.")
diff --git a/sess/README.md b/sess/README.md
index 45ad845c..dc956c1f 100644
--- a/sess/README.md
+++ b/sess/README.md
@@ -98,7 +98,7 @@ Returns the most recent static plot captured by the R session.
 
 3. Synchronous RStudio API Emulation
 
-The `request_rstudioapi()` function allows R to call client-side functions synchronously by sending a **JSON-RPC Request** (with an `id`) over the WebSocket:
+The `request_client()` function allows R to call client-side functions synchronously by sending a **JSON-RPC Request** (with an `id`) over the WebSocket:
 
 1. R sends a request with `method` set to the action name (e.g., `"active_editor_context"`).
 2. R enters a `while` loop that calls `httpuv::service()`.

From 4c0cc56eaa8838ed48637d78f867f8859dc841ef Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Wed, 11 Mar 2026 13:59:29 -0700
Subject: [PATCH 10/47] docs: list all methods for notify_client and
 request_client in README

- Document all Push API notification methods (attach, detach, etc.)

- Document all Pull API / RStudio API emulation methods (active_editor_context, etc.)
---
 sess/README.md | 34 +++++++++++++++++++++++++++-------
 1 file changed, 27 insertions(+), 7 deletions(-)

diff --git a/sess/README.md b/sess/README.md
index dc956c1f..4b9e42dd 100644
--- a/sess/README.md
+++ b/sess/README.md
@@ -29,14 +29,16 @@ The WebSocket is used for instantaneous events pushed from R to the client as **
 }
 ```
 
-#### Common Methods
+#### Client Notifications (`notify_client` Methods)
+The following methods are sent as notifications from R to the client:
 - **`attach`**: Sent immediately upon connection. Includes PID, R version, and session metadata.
-- **`detach`**: Sent when the R session is shutting down.
+- **`detach`**: Sent when the R session is shutting down (params: `pid`).
 - **`dataview`**: Triggered by `View()`. Params include a temporary JSON file path containing the data.
-- **`plot_updated`**: Notifies that a new static plot is available. The client should request the `plot_latest` method.
-- **`httpgd`**: Provides a URL for an `httpgd` live plot server.
-- **`help`**: Requests the client to display an R help page.
-- **`browser` / `webview`**: Requests the client to open a URL or local HTML file.
+- **`plot_updated`**: Notifies that a new static plot is available. The client should request the `plot_latest` method via HTTP.
+- **`httpgd`**: Provides a URL for an `httpgd` live plot server (params: `url`).
+- **`help`**: Requests the client to display an R help page (params: `requestPath`).
+- **`browser`**: Requests the client to open a URL (params: `url`, `title`).
+- **`webview`**: Requests the client to open a local HTML file or URL in a webview (params: `file`, `title`).
 
 ---
 
@@ -96,7 +98,7 @@ Returns the most recent static plot captured by the R session.
 
 ---
 
-3. Synchronous RStudio API Emulation
+## 3. Synchronous RStudio API Emulation
 
 The `request_client()` function allows R to call client-side functions synchronously by sending a **JSON-RPC Request** (with an `id`) over the WebSocket:
 
@@ -107,6 +109,24 @@ The `request_client()` function allows R to call client-side functions synchrono
 
 **Coordinate Handling**: The emulation layer automatically converts between R (1-indexed) and IPC (0-indexed) coordinates. Locations and ranges sent to the client are 0-indexed, while data received from the client (e.g., in `document_context`) is converted back to 1-indexed R objects.
 
+### Client Request Methods (`request_client`)
+Below are all the JSON-RPC methods sent from R to the client to emulate RStudio API functionality:
+
+- **`active_editor_context`**: Requests the current context of the active editor.
+- **`replace_text_in_current_selection`**: Replaces text in the current selection (params: `text`, `id`).
+- **`insert_or_modify_text`**: Inserts or modifies text at specific locations (params: `query`, `id`).
+- **`show_dialog`**: Displays a message dialog to the user (params: `message`).
+- **`navigate_to_file`**: Opens and navigates to a specific file, line, and column (params: `file`, `line`, `column`).
+- **`set_selection_ranges`**: Sets the cursor or selection ranges in the editor (params: `ranges`, `id`).
+- **`document_save`**: Saves the specified document (params: `id`).
+- **`get_project_path`**: Retrieves the current project path.
+- **`document_context`**: Retrieves the context of a specific document (params: `id`).
+- **`document_save_all`**: Saves all open documents.
+- **`document_new`**: Creates a new document with specified text and type (params: `text`, `type`, `position`).
+- **`restart_r`**: Requests the client to restart the R session.
+- **`send_to_console`**: Sends code to the console for execution (params: `code`, `execute`, `focus`).
+- **`document_close`**: Closes the specified document (params: `id`, `save`).
+
 ## 4. Hook Registration
 
 By default, the package does not inject hooks into the R session on load. Calling `sess::sess_app()` will start the server and automatically call `sess::register_hooks()` to enable features like automatic `View()` interception or plot redirection.

From e9529a8261a0d967f8fb21bc3db21cb91324cd66 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Wed, 11 Mar 2026 14:03:33 -0700
Subject: [PATCH 11/47] docs: redo README and update rstudioapi methods

- Combined WebSocket notifications and synchronous requests into one section

- Updated Comparison with Legacy IPC to reflect synchronous rstudio api requests via WS

- Change restartSession and sendToConsole to use notify_client
---
 sess/R/rstudioapi.R |  6 ++--
 sess/README.md      | 85 ++++++++++++++++++++++++---------------------
 2 files changed, 49 insertions(+), 42 deletions(-)

diff --git a/sess/R/rstudioapi.R b/sess/R/rstudioapi.R
index 822e5780..e71575db 100644
--- a/sess/R/rstudioapi.R
+++ b/sess/R/rstudioapi.R
@@ -117,7 +117,7 @@ setDocumentContents <- function(text, id = NULL) {
     insertText(whole_document_range, text, id)
 }
 
-restartSession <- function() invisible(request_client("restart_r", args = list()))
+restartSession <- function(command = "", clean = FALSE) invisible(notify_client("restart_r", params = list(command = command, clean = clean)))
 
 viewer <- function(url, height = NULL) {
     notify_client("webview", list(file = url, title = "Viewer"))
@@ -131,10 +131,10 @@ getVersion <- function() numeric_version("0")
 
 versionInfo <- function() list(citation = "", mode = "generic-ipc", version = numeric_version("0"), release_name = "generic-ipc")
 
-sendToConsole <- function(code, execute = TRUE, echo = TRUE, focus = FALSE) {
+sendToConsole <- function(code, execute = TRUE, echo = TRUE, focus = FALSE, animate = FALSE) {
     if (!echo) warning("rstudioapi::sendToConsole echo = FALSE is not supported in the generic IPC client.")
     code_to_run <- paste0(code, collapse = "\n")
-    invisible(request_client("send_to_console", args = list(code = code_to_run, execute = execute, focus = focus)))
+    invisible(notify_client("send_to_console", params = list(code = code_to_run, execute = execute, focus = focus, animate = animate)))
 }
 
 documentClose <- function(id = NULL, save = TRUE) {
diff --git a/sess/README.md b/sess/README.md
index 4b9e42dd..6a4d66a6 100644
--- a/sess/README.md
+++ b/sess/README.md
@@ -17,7 +17,11 @@ A client can intercept this string or be configured with the port and token to e
 
 `sess` uses a hybrid architecture following the **JSON-RPC 2.0** specification for all structured data exchange.
 
-### WebSocket (Push API)
+### WebSocket (Push & Synchronous API)
+
+The WebSocket connection serves two main purposes: instantaneous pushing of events from R to the client via notifications, and allowing R to synchronously call client-side methods (such as emulating the RStudio API).
+
+#### 1. Client Notifications (`notify_client`)
 The WebSocket is used for instantaneous events pushed from R to the client as **JSON-RPC Notifications** (no `id`).
 
 **Notification Format:**
@@ -29,7 +33,6 @@ The WebSocket is used for instantaneous events pushed from R to the client as **
 }
 ```
 
-#### Client Notifications (`notify_client` Methods)
 The following methods are sent as notifications from R to the client:
 - **`attach`**: Sent immediately upon connection. Includes PID, R version, and session metadata.
 - **`detach`**: Sent when the R session is shutting down (params: `pid`).
@@ -39,6 +42,34 @@ The following methods are sent as notifications from R to the client:
 - **`help`**: Requests the client to display an R help page (params: `requestPath`).
 - **`browser`**: Requests the client to open a URL (params: `url`, `title`).
 - **`webview`**: Requests the client to open a local HTML file or URL in a webview (params: `file`, `title`).
+- **`restart_r`**: Requests the client to restart the R session (params: `command`, `clean`).
+- **`send_to_console`**: Sends code to the console for execution without blocking the R session (params: `code`, `execute`, `focus`, `animate`).
+
+#### 2. Synchronous Client Requests (`request_client`)
+
+The `request_client()` function allows R to call client-side functions synchronously by sending a **JSON-RPC Request** (with an `id`) over the WebSocket. This is primarily used to emulate the RStudio API:
+
+1. R sends a request with `method` set to the action name (e.g., `"active_editor_context"`).
+2. R enters a `while` loop that calls `httpuv::service()`.
+3. The client processes the action and sends back a **JSON-RPC Response** (with the same id) via the WebSocket.
+4. R retrieves the `result` (or `error`) and returns it.
+
+**Coordinate Handling**: The emulation layer automatically converts between R (1-indexed) and IPC (0-indexed) coordinates. Locations and ranges sent to the client are 0-indexed, while data received from the client (e.g., in `document_context`) is converted back to 1-indexed R objects.
+
+Below are all the JSON-RPC methods sent from R to the client to emulate RStudio API functionality:
+
+- **`active_editor_context`**: Requests the current context of the active editor.
+- **`replace_text_in_current_selection`**: Replaces text in the current selection (params: `text`, `id`).
+- **`insert_or_modify_text`**: Inserts or modifies text at specific locations (params: `query`, `id`).
+- **`show_dialog`**: Displays a message dialog to the user (params: `message`).
+- **`navigate_to_file`**: Opens and navigates to a specific file, line, and column (params: `file`, `line`, `column`).
+- **`set_selection_ranges`**: Sets the cursor or selection ranges in the editor (params: `ranges`, `id`).
+- **`document_save`**: Saves the specified document (params: `id`).
+- **`get_project_path`**: Retrieves the current project path.
+- **`document_context`**: Retrieves the context of a specific document (params: `id`).
+- **`document_save_all`**: Saves all open documents.
+- **`document_new`**: Creates a new document with specified text and type (params: `text`, `type`, `position`).
+- **`document_close`**: Closes the specified document (params: `id`, `save`).
 
 ---
 
@@ -98,36 +129,7 @@ Returns the most recent static plot captured by the R session.
 
 ---
 
-## 3. Synchronous RStudio API Emulation
-
-The `request_client()` function allows R to call client-side functions synchronously by sending a **JSON-RPC Request** (with an `id`) over the WebSocket:
-
-1. R sends a request with `method` set to the action name (e.g., `"active_editor_context"`).
-2. R enters a `while` loop that calls `httpuv::service()`.
-3. The client processes the action and sends back a **JSON-RPC Response** (with the same id) via the WebSocket.
-4. R retrieves the `result` (or `error`) and returns it.
-
-**Coordinate Handling**: The emulation layer automatically converts between R (1-indexed) and IPC (0-indexed) coordinates. Locations and ranges sent to the client are 0-indexed, while data received from the client (e.g., in `document_context`) is converted back to 1-indexed R objects.
-
-### Client Request Methods (`request_client`)
-Below are all the JSON-RPC methods sent from R to the client to emulate RStudio API functionality:
-
-- **`active_editor_context`**: Requests the current context of the active editor.
-- **`replace_text_in_current_selection`**: Replaces text in the current selection (params: `text`, `id`).
-- **`insert_or_modify_text`**: Inserts or modifies text at specific locations (params: `query`, `id`).
-- **`show_dialog`**: Displays a message dialog to the user (params: `message`).
-- **`navigate_to_file`**: Opens and navigates to a specific file, line, and column (params: `file`, `line`, `column`).
-- **`set_selection_ranges`**: Sets the cursor or selection ranges in the editor (params: `ranges`, `id`).
-- **`document_save`**: Saves the specified document (params: `id`).
-- **`get_project_path`**: Retrieves the current project path.
-- **`document_context`**: Retrieves the context of a specific document (params: `id`).
-- **`document_save_all`**: Saves all open documents.
-- **`document_new`**: Creates a new document with specified text and type (params: `text`, `type`, `position`).
-- **`restart_r`**: Requests the client to restart the R session.
-- **`send_to_console`**: Sends code to the console for execution (params: `code`, `execute`, `focus`).
-- **`document_close`**: Closes the specified document (params: `id`, `save`).
-
-## 4. Hook Registration
+## 3. Hook Registration
 
 By default, the package does not inject hooks into the R session on load. Calling `sess::sess_app()` will start the server and automatically call `sess::register_hooks()` to enable features like automatic `View()` interception or plot redirection.
 
@@ -137,7 +139,7 @@ sess::register_hooks()
 ```
 This rebinds internal functions (like `utils::View`) and sets `options()` for browsers, viewers, and devices to route through the IPC server.
 
-## 5. Comparison with Legacy IPC
+## 4. Comparison with Legacy IPC
 
 The `sess` package replaces the legacy file-based IPC mechanism with a modern, in-memory hybrid architecture using **JSON-RPC 2.0**.
 
@@ -146,7 +148,8 @@ The `sess` package replaces the legacy file-based IPC mechanism with a modern, i
 | **Command Dispatch** | `request.log` + `request.lock` | **WS Notification** (JSON-RPC) |
 | **Workspace State** | `workspace.json` + `workspace.lock` | **HTTP RPC `workspace`** (On-demand) |
 | **Static Plots** | `plot.png` + `plot.lock` | **WS Notification** + **HTTP RPC `plot_latest`** |
-| **Client Queries** | Custom HTTP Server payload | **HTTP RPC** (JSON-RPC 2.0) |
+| **RStudio API (Sync)**| `request.log` + `response.lock` | **WS Request** (JSON-RPC) |
+| **Client Queries** | Internal HTTP Server (`httpuv`) | **HTTP RPC** (JSON-RPC 2.0) |
 | **Transport Reliability**| OS-level File System Watchers | **WebSocket & HTTP streams** |
 | **Protocol Standard** | Ad-hoc JSON formats | **JSON-RPC 2.0** |
 
@@ -156,23 +159,27 @@ The `sess` package replaces the legacy file-based IPC mechanism with a modern, i
 - **Old Approach:** R intercepted commands and appended custom JSON structures to a `request.log` file, then updated the timestamp on a `request.lock` file. The client OS file watcher detected the `.lock` file change, read the `.log` file, and processed the pending commands.
 - **New Approach (`sess`):** R directly pushes an instantaneous **JSON-RPC Notification** (e.g., `method: "dataview"`, `method: "help"`) over the persistent WebSocket connection. The client receives and processes the payload instantly, bypassing disk I/O and file system watchers entirely.
 
-**2. Workspace State (Global Environment)**
+**2. Synchronous RStudio API Emulation**
+- **Old Approach:** R wrote a command to `request.log`, and then entered a blocking `while` loop aggressively polling for the creation of a `response.lock` file by the client.
+- **New Approach (`sess`):** R sends a **JSON-RPC Request** over the WebSocket with an `id`. It enters a `while` loop calling `httpuv::service()`, maintaining a responsive background state, and waits for a corresponding **JSON-RPC Response** with the matching `id` over the same WebSocket.
+
+**3. Workspace State (Global Environment)**
 - **Old Approach:** An R task callback ran after every top-level console execution, eagerly evaluating and serializing the entire Global Environment to a `workspace.json` file, followed by touching a `workspace.lock` file. The client watched for the lock file change to read the JSON file. This caused constant overhead and disk writes, even when the client's workspace pane was hidden.
 - **New Approach (`sess`):** Adopts a "Pull" architecture. The workspace is *only* evaluated and serialized when the client explicitly sends an **HTTP POST Request** to `/rpc` with `method: "workspace"`. This happens on-demand (e.g., when the UI pane is visible), saving significant R processing time and disk I/O.
 
-**3. Static Plots**
+**4. Static Plots**
 - **Old Approach:** Plotting commands (via custom devices or hooks) generated a `plot.png` file on disk and updated a `plot.lock` file. The client watcher noticed the lock change, read the new PNG file from disk, and displayed it.
 - **New Approach (`sess`):** When a new plot is generated to a temporary file, R sends a lightweight **JSON-RPC Notification** (`method: "plot_updated"`) via the WebSocket. The client then pulls the actual image data by sending an **HTTP POST Request** to `/rpc` (`method: "plot_latest"`), which returns the base64-encoded image over the network stream.
 
-**4. Client Queries (Hover, Completion)**
-- **Old Approach:** The legacy architecture sometimes ran a rudimentary local HTTP server inside R that accepted custom HTTP GET/POST queries with ad-hoc URL paths (`/hover`, `/completion`) and custom JSON body structures.
+**5. Client Queries (Hover, Completion)**
+- **Old Approach:** R ran an internal `httpuv` server using custom JSON structures and ad-hoc request types (like `{ "type": "hover" }`).
 - **New Approach (`sess`):** Unified under the **JSON-RPC 2.0** standard. The client sends structured requests with strict `id` and `params` formatting to the single `/rpc` HTTP endpoint, receiving standardized JSON-RPC responses.
 
 ### Architectural Shifts
 
 1. **Elimination of File Watchers**: The legacy system relied heavily on OS-level file system watchers (`fs.watch`) monitoring lock files to trigger client updates. This approach could be unreliable or slow across different platforms, network drives, and remote container environments. `sess` replaces this entirely with persistent WebSocket connections for instantaneous, reliable event pushing.
 2. **On-Demand vs. Eager Evaluation**: Previously, R would eagerly evaluate and serialize the entire Global Environment to `workspace.json` frequently (e.g., via task callbacks), incurring significant continuous disk I/O and processing overhead. `sess` shifts this to a "Pull" model. The client requests the workspace state only when needed, significantly reducing R's background workload.
-3. **Unified Standard**: Instead of maintaining separate, disparate mechanisms for command logs, JSON dumps, and custom HTTP query payloads, `sess` unifies all structured communication under the ubiquitous **JSON-RPC 2.0** standard.
+3. **Unified Standard**: Instead of maintaining separate, disparate mechanisms for command logs, lock-file polling loops, JSON dumps, and custom HTTP query payloads, `sess` unifies all structured communication under the ubiquitous **JSON-RPC 2.0** standard across WebSocket and HTTP transports.
 
 ### Responsiveness and the Event Loop
 

From f14b2671ad054722e9a33b17fcfa54064e3f8537 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Wed, 11 Mar 2026 19:58:54 -0700
Subject: [PATCH 12/47] feat: migrate R session IPC to modern sess package

- Remove legacy file-based watchers (request.log, workspace.json, etc.)
- Establish WebSocket (Push) and HTTP (Pull) connection directly to R's sess server
- Refactor sessionRequest to use JSON-RPC 2.0 payloads via /rpc endpoint
- Directly dispatch RStudio API emulation commands via WebSocket instead of polling
---
 .vscode/launch.json         |   4 +-
 R/{session => }/profile.R   |  10 +-
 R/session/init.R            | 104 ----
 R/session/rstudioapi.R      | 315 ------------
 R/session/rstudioapi_util.R | 258 ----------
 R/session/vsc.R             | 941 ------------------------------------
 package.json                |   6 +-
 sess/R/dispatch.R           |   3 +-
 sess/R/hooks.R              |   2 +-
 sess/R/server.R             |  24 +-
 src/completions.ts          |   9 +-
 src/extension.ts            |   1 -
 src/languageService.ts      |   4 +-
 src/rTerminal.ts            |  29 +-
 src/rstudioapi.ts           |  71 +--
 src/session.ts              | 410 +++++++++-------
 16 files changed, 278 insertions(+), 1913 deletions(-)
 rename R/{session => }/profile.R (75%)
 delete mode 100644 R/session/init.R
 delete mode 100644 R/session/rstudioapi.R
 delete mode 100644 R/session/rstudioapi_util.R
 delete mode 100644 R/session/vsc.R

diff --git a/.vscode/launch.json b/.vscode/launch.json
index 977a9881..e15cf371 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -15,6 +15,7 @@
       "outFiles": [
         "${workspaceFolder}/out/src/**/*.js"
       ],
+      "sourceMaps": true,
     },
     {
       "name": "Launch Extension (--disable-extensions)",
@@ -28,6 +29,7 @@
       "outFiles": [
         "${workspaceFolder}/out/src/**/*.js"
       ],
+      "sourceMaps": true,
     },
     {
       "name": "Extension Tests",
@@ -44,4 +46,4 @@
       "preLaunchTask": "npm: pretest"
     }
   ]
-}
+}
\ No newline at end of file
diff --git a/R/session/profile.R b/R/profile.R
similarity index 75%
rename from R/session/profile.R
rename to R/profile.R
index dafdf298..a316445e 100644
--- a/R/session/profile.R
+++ b/R/profile.R
@@ -24,10 +24,6 @@ local({
     invisible()
 })
 
-# Run vscode initializer
-local({
-    init_file <- Sys.getenv("VSCODE_INIT_R")
-    if (nzchar(init_file)) {
-        source(init_file, chdir = TRUE, local = TRUE)
-    }
-})
+if (requireNamespace("sess", quietly = TRUE)) {
+    sess::sess_app()
+}
diff --git a/R/session/init.R b/R/session/init.R
deleted file mode 100644
index 410263c2..00000000
--- a/R/session/init.R
+++ /dev/null
@@ -1,104 +0,0 @@
-# This file is executed with its containing directory as wd
-
-# Remember the working directory (should be extension subfolder that contains this script)
-dir_init <- getwd()
-
-
-# This function is run at the beginning of R's startup sequence
-# Code that is meant to be run at the end of the startup should go in `init_last`
-init_first <- function() {
-    # return early if not a vscode term session
-    if (
-        !interactive()
-        || Sys.getenv("RSTUDIO") != ""
-        || Sys.getenv("TERM_PROGRAM") != "vscode"
-    ) {
-        return()
-    }
-
-    # check required packages
-    required_packages <- c("jsonlite", "rlang")
-    missing_packages <- required_packages[
-        !vapply(required_packages, requireNamespace,
-            logical(1L), quietly = TRUE
-        )
-    ]
-
-    if (length(missing_packages)) {
-        message(
-            "VSCode R Session Watcher requires ",
-            toString(missing_packages), ". ",
-            "Please install manually in order to use VSCode-R."
-        )
-    } else {
-        # Initialize vsc utils after loading other default packages
-        assign(".First.sys", init_last, envir = globalenv())
-    }
-}
-
-old.First.sys <- .First.sys
-
-# Overwrite for `.First.sys`
-# Is used to make sure that all default packages are loaded first
-# Will be assigned to and called from the global environment,
-# Will be run with wd being the user's working directory (!)
-init_last <- function() {
-    old.First.sys()
-
-    # cleanup previous version
-    removeTaskCallback("vscode-R")
-    options(vscodeR = NULL)
-    .vsc.name <- "tools:vscode"
-    if (.vsc.name %in% search()) {
-        detach(.vsc.name, character.only = TRUE)
-    }
-
-    # Source vsc utils in new environmeent
-    .vsc <- new.env()
-    source(file.path(dir_init, "vsc.R"), local = .vsc)
-
-    # attach functions that are meant to be called by the user/vscode
-    exports <- local({
-        .vsc <- .vsc
-        .vsc.attach <- .vsc$attach
-        .vsc.view <- .vsc$show_dataview
-        .vsc.browser <- .vsc$show_browser
-        .vsc.viewer <- .vsc$show_viewer
-        .vsc.page_viewer <- .vsc$show_page_viewer
-        View <- .vsc.view
-        environment()
-    })
-    attach(exports, name = .vsc.name, warn.conflicts = FALSE)
-
-    # overwrite S3 bindings from other packages
-    suppressWarnings({
-        if (!identical(getOption("vsc.helpPanel", "Two"), FALSE)) {
-            # Overwrite print function for results of `?`
-            .vsc$.S3method(
-                "print",
-                "help_files_with_topic",
-                .vsc$print.help_files_with_topic
-            )
-            # Overwrite print function for results of `??`
-            .vsc$.S3method(
-                "print",
-                "hsearch",
-                .vsc$print.hsearch
-            )
-        }
-        # Further S3 overwrites can go here
-        # ...
-    })
-
-    # remove this function from globalenv()
-    suppressWarnings(
-        rm(".First.sys", envir = globalenv())
-    )
-
-    # Attach to vscode
-    exports$.vsc.attach()
-
-    invisible()
-}
-
-init_first()
diff --git a/R/session/rstudioapi.R b/R/session/rstudioapi.R
deleted file mode 100644
index 60ea4358..00000000
--- a/R/session/rstudioapi.R
+++ /dev/null
@@ -1,315 +0,0 @@
-getActiveDocumentContext <- function() {
-    # In RStudio this returns either a document context for either the active
-    # source editor or active console.
-    # In VSCode this only ever returns the active (or last active) text editor.
-    # This is because it is currently not possible to tell in VSCode whether
-    # a text editor or terminal has focus. The concept of active is different.
-    # It means currently using or most recently used, and applies to text
-    # editors and terminals separately.
-    # This shoudln't be much of a limitation as the only context returned for
-    # the console was the current selection, so it is not very useful.
-    editor_context <- rstudioapi_call("active_editor_context")
-
-    make_rs_document_context(editor_context)
-}
-
-getSourceEditorContext <- getActiveDocumentContext
-
-verifyAvailable <- function(version_needed = NULL) {
-    if (is.null(version_needed)) TRUE else FALSE
-}
-
-isAvailable <- function(version_needed = NULL, child_ok) {
-    verifyAvailable(version_needed)
-}
-
-insertText <- function(location, text, id = NULL) {
-
-    ## insertText also supports insertText("text"), insertText(text = "text"),
-    ## allowing the location parameter to be used for the text when
-    ## text itself is null.
-    ## This is dispatched as a separate request type
-    if (missing(text) && is.character(location) && length(location) == 1) {
-        ## handling insertText("text")
-        return(invisible(
-            rstudioapi_call("replace_text_in_current_selection",
-                text = location,
-                id = id
-            )
-        ))
-    } else if (missing(location)) {
-        ## handling insertText(text = "text")
-        return(invisible(rstudioapi_call(
-            "replace_text_in_current_selection",
-            text = text,
-            id = id
-        )))
-    } else if (is.null(location) && missing(text)) {
-        ## handling insertText(NULL)
-        return(invisible(NULL))
-    }
-
-    ## ensure normalised_location is a list containing a possible mix of
-    ## document_position and document_range objects
-    normalised_location <- normalise_pos_or_range_arg(location)
-    normalised_text <- normalise_text_arg(text, length(normalised_location))
-    ## Having normalised we are guaranteed these are the same length.
-    ## Package up all the edits in a query to send to VSCode in an object
-    ## This is done so the edits can be applied in a single edit object, which
-    ## is hopefull closest to RStudio behaviour.
-    query <-
-        mapply(function(location, text) {
-            list(
-                operation = if (rstudioapi::is.document_range(location)) {
-                    "modifyRange"
-                } else {
-                    "insertText"
-                },
-                location = location,
-                text = text
-            )
-        },
-        normalised_location,
-        normalised_text,
-        SIMPLIFY = FALSE
-        )
-
-    invisible(
-        rstudioapi_call("insert_or_modify_text", query = query, id = id)
-    )
-}
-
-modifyRange <- insertText
-
-readPreference <- function(name, default) {
-    ## in future we could map some rstudio preferences to vscode settings.
-    ## since the caller must provide a default this should work.
-    default
-}
-
-readRStudioPreference <- readPreference
-
-.vsc_rstudioapi_env <- environment()
-
-hasFun <- function(name, version_needed = NULL, ...) {
-    if (!is.null(version_needed)) {
-        return(FALSE)
-    }
-
-    obj <- .vsc_rstudioapi_env[[name]]
-    is.function(obj) && !identical(obj, .vsc_not_yet_implemented)
-}
-
-findFun <- function(name, version_needed = NULL, ...) {
-    if (!is.null(version_needed)) {
-        stop("VSCode does not support used of 'version_needed'.")
-    }
-
-    if (hasFun(name, version_needed = version_needed, ...)) {
-        .vsc_rstudioapi_env[[name]]
-    } else {
-        stop("Cannot find function '", name, "'")
-    }
-}
-
-showDialog <- function(title, message, url = "") {
-    message <- sprintf("%s: %s \n%s", title, message, url)
-    invisible(
-        rstudioapi_call("show_dialog", message = message)
-    )
-}
-
-navigateToFile <- function(file, line = -1L, column = -1L) {
-    # normalise path since relative paths don't work as URIs in VSC
-    invisible(
-        rstudioapi_call(
-            "navigate_to_file",
-            file = normalizePath(file),
-            line = line,
-            column = column
-        )
-    )
-}
-
-setSelectionRanges <- function(ranges, id = NULL) {
-    ranges_or_positions <- normalise_pos_or_range_arg(ranges)
-
-    ranges <- lapply(ranges_or_positions, function(location) {
-        if (rstudioapi::is.document_position(location)) {
-            rstudioapi::document_range(location, location)
-        } else {
-            location
-        }
-    })
-
-    invisible(
-        rstudioapi_call("set_selection_ranges", ranges = ranges, id = id)
-    )
-}
-
-setCursorPosition <- setSelectionRanges
-
-documentSave <- function(id = NULL) {
-    invisible(
-        rstudioapi_call("document_save", id = id)
-    )
-}
-
-getActiveProject <- function() {
-    path_object <- rstudioapi_call("get_project_path")
-    if (is.null(path_object$path)) {
-        stop(
-            "No folder for active document. ",
-            "Is it unsaved? Try saving and run addin again."
-        )
-    }
-    path_object$path
-}
-
-.vsc_document_context <- function(id = NULL) {
-    doc_context <- rstudioapi_call("document_context", id = id)
-    doc_context
-}
-
-documentId <- function(allowConsole = TRUE) document_context()$id$external
-
-documentPath <- function(id = NULL) document_context(id)$id$path
-
-documentSaveAll <- function() {
-    invisible(
-        rstudioapi_call("document_save_all")
-    )
-}
-
-documentNew <- function(text,
-                        type = c("r", "rmarkdown", "sql"),
-                        position = rstudioapi::document_position(0, 0),
-                        execute = FALSE) {
-    if (!rstudioapi::is.document_position((position))) {
-        stop("DocumentNew requires a document_position object")
-    }
-    if (length(text) != 1 || !is.character(text)) {
-        stop("text for DocumentNew must be a length one character vector.")
-    }
-    if (execute) {
-        message(
-            "VSCode {rstudioapi} emulation does not support ",
-            " executing documents upon creation"
-        )
-    }
-
-    invisible(
-        rstudioapi_call(
-            "document_new",
-            text = text,
-            type = type,
-            position = position
-        )
-    )
-}
-
-setDocumentContents <- function(text, id = NULL) {
-    whole_document_range <-
-        rstudioapi::document_range(
-            rstudioapi::document_position(0, 0),
-            rstudioapi::document_position(Inf, Inf)
-        )
-    insertText(whole_document_range, text, id)
-}
-
-restartSession <- function() {
-    invisible(
-        rstudioapi_call("restart_r")
-    )
-}
-
-viewer <- function(url, height = NULL) {
-    # cant bind to this directly because it's not created when the binding is
-    # made.
-    .vsc.viewer(url)
-}
-
-getVersion <- function() {
-    numeric_version("0")
-}
-
-versionInfo <- function() {
-    list(
-        citation = "",
-        mode = "vscode",
-        version = numeric_version("0"),
-        release_name = "vscode"
-    )
-}
-
-sendToConsole <- function(code, execute = TRUE, echo = TRUE, focus = FALSE) {
-    if (!echo) {
-        stop("rstudioapi::sendToConsole only supports echo = TRUE in VSCode.")
-    }
-
-    code_to_run <- paste0(code, collapse = "\n")
-    invisible(
-        rstudioapi_call("send_to_console", code = code_to_run, execute = execute, focus = focus)
-    )
-}
-
-
-# Unimplemented API calls that will error if called.
-
-.vsc_not_yet_implemented <- function(...) {
-    stop("This {rstudioapi} function is not currently implemented for VSCode.")
-}
-
-
-getConsoleEditorContext <- .vsc_not_yet_implemented
-sourceMarkers <- .vsc_not_yet_implemented
-documentClose <- .vsc_not_yet_implemented
-showPrompt <- .vsc_not_yet_implemented
-showQuestion <- .vsc_not_yet_implemented
-updateDialog <- .vsc_not_yet_implemented
-openProject <- .vsc_not_yet_implemented
-initializeProject <- .vsc_not_yet_implemented
-addTheme <- .vsc_not_yet_implemented
-applyTheme <- .vsc_not_yet_implemented
-convertTheme <- .vsc_not_yet_implemented
-getThemeInfo <- .vsc_not_yet_implemented
-getThemes <- .vsc_not_yet_implemented
-removeTheme <- .vsc_not_yet_implemented
-jobAdd <- .vsc_not_yet_implemented
-jobAddOutput <- .vsc_not_yet_implemented
-jobAddProgress <- .vsc_not_yet_implemented
-jobRemove <- .vsc_not_yet_implemented
-jobRunScript <- .vsc_not_yet_implemented
-jobSetProgress <- .vsc_not_yet_implemented
-jobSetState <- .vsc_not_yet_implemented
-jobSetStatus <- .vsc_not_yet_implemented
-launcherGetInfo <- .vsc_not_yet_implemented
-launcherAvailable <- .vsc_not_yet_implemented
-launcherGetJobs <- .vsc_not_yet_implemented
-launcherConfig <- .vsc_not_yet_implemented
-launcherContainer <- .vsc_not_yet_implemented
-launcherControlJob <- .vsc_not_yet_implemented
-launcherGetJob <- .vsc_not_yet_implemented
-launcherHostMount <- .vsc_not_yet_implemented
-launcherNfsMount <- .vsc_not_yet_implemented
-launcherPlacementConstraint <- .vsc_not_yet_implemented
-launcherResourceLimit <- .vsc_not_yet_implemented
-launcherSubmitJob <- .vsc_not_yet_implemented
-launcherSubmitR <- .vsc_not_yet_implemented
-previewRd <- .vsc_not_yet_implemented
-previewSql <- .vsc_not_yet_implemented
-writePreference <- .vsc_not_yet_implemented
-writeRStudioPreference <- .vsc_not_yet_implemented
-getPersistentValue <- .vsc_not_yet_implemented
-setPersistentValue <- .vsc_not_yet_implemented
-savePlotAsImage <- .vsc_not_yet_implemented
-createProjectTemplate <- .vsc_not_yet_implemented
-hasColourConsole <- .vsc_not_yet_implemented
-bugReport <- .vsc_not_yet_implemented
-buildToolsCheck <- .vsc_not_yet_implemented
-buildToolsInstall <- .vsc_not_yet_implemented
-buildToolsExec <- .vsc_not_yet_implemented
-dictionariesPath <- .vsc_not_yet_implemented
-userDictionariesPath <- .vsc_not_yet_implemented
-executeCommand <- .vsc_not_yet_implemented
-translateLocalUrl <- .vsc_not_yet_implemented
diff --git a/R/session/rstudioapi_util.R b/R/session/rstudioapi_util.R
deleted file mode 100644
index da5fe0ff..00000000
--- a/R/session/rstudioapi_util.R
+++ /dev/null
@@ -1,258 +0,0 @@
-rstudioapi_call <- function(action, ...) {
-    request_response("rstudioapi", action = action, args = list(...))
-}
-
-rstudioapi_patch_hook <- function(api_env) {
-    patch_rstudioapi_fn <-
-        function(old, new) {
-            if (namespace_has(old, "rstudioapi")) {
-                assignInNamespace(
-                    x = old,
-                    value = new,
-                    ns = "rstudioapi"
-                )
-            }
-        }
-    ## make assignments to functions found in api_env namespace
-    ## that have function with the same name in {rstudioapi} namespace
-    api_list <- as.list(api_env)
-    mapply(
-        patch_rstudioapi_fn,
-        names(api_list),
-        api_list
-    )
-}
-
-make_rs_range <- function(vsc_selection) {
-    # vscode positions are zero indexed
-    # rstudioapi is one indexed
-    rstudioapi::document_range(
-        start = rstudioapi::document_position(
-            row = vsc_selection$start$line + 1,
-            column = vsc_selection$start$character + 1
-        ),
-        end = rstudioapi::document_position(
-            row = vsc_selection$end$line + 1,
-            column = vsc_selection$end$character + 1
-        )
-    )
-}
-
-extract_document_ranges <- function(vsc_selections) {
-    lapply(vsc_selections, make_rs_range)
-}
-
-to_content_lines <- function(contents, ranges) {
-    content_lines <- strsplit(contents, "\n|\r\n|\r$")[[1]]
-
-
-    # edge case handling: The cursor is at the start of a new empty line,
-    # and that line is the final line.
-    range_end_row <- unlist(lapply(ranges, function(range) range$end["row"]))
-    last_row <- max(range_end_row)
-    if (last_row == length(content_lines) + 1) {
-        content_lines <- c(content_lines, "")
-    }
-
-    content_lines
-}
-
-
-extract_range_text <- function(range, content_lines) {
-    if (!range_has_text(range)) {
-        return("")
-    }
-
-    content_rows <-
-        content_lines[(range$start["row"]):(range$end["row"])]
-    content_rows[length(content_rows)] <-
-        substring(
-            content_rows[length(content_rows)],
-            1,
-            range$end["column"] - 1
-            # it's a minus 1 here because the selection end point is the number
-            # of the first unselected column. I.e. range 1 - 2 is all of
-            # columns >= 1 and < 2, which is column 1.
-        )
-    content_rows[1] <-
-        substring(
-            content_rows[1],
-            range$start["column"]
-        )
-
-    paste0(content_rows, collapse = "\n")
-}
-
-range_has_text <- function(range) {
-    (range$end["row"] - range$start["row"]) +
-        (range$end["column"] - range$start["column"]) > 0
-}
-
-make_rs_document_selection <- function(ranges, range_texts) {
-    selection_data <-
-        mapply(
-            function(range, text) {
-                list(
-                    range = range,
-                    text = text
-                )
-            },
-            ranges,
-            range_texts,
-            SIMPLIFY = FALSE
-        )
-    structure(selection_data,
-        class = "document_selection"
-    )
-}
-
-make_rs_document_context <-
-    function(vsc_editor_context) {
-        document_ranges <-
-            extract_document_ranges(vsc_editor_context$selection)
-        content_lines <-
-            to_content_lines(vsc_editor_context$contents, document_ranges)
-        document_range_texts <-
-            lapply(
-                document_ranges,
-                extract_range_text,
-                content_lines
-            )
-        document_selection <-
-            make_rs_document_selection(
-                document_ranges,
-                document_range_texts
-            )
-
-        structure(list(
-            id = vsc_editor_context$id$external,
-            path = vsc_editor_context$path,
-            contents = content_lines,
-            selections = document_selection
-        ),
-        class = "document_context"
-        )
-    }
-
-is_positionable <- function(p) is.numeric(p) && length(p) == 2
-
-is_rangable <- function(r) is.numeric(r) && length(r) == 4
-
-normalise_pos_or_range_arg <- function(location) {
-    # This is necessary due to the loose constraints of the location argument
-    # in rstudioapi::insertText and rstudioapi::modifyRange. These
-    # functions can take single vectors coerable to postition or range OR a
-    # list where each element may be a location, range, or a vector coercable
-    # to such. I prefer to normalise the argument to a list of either formal
-    # positions or ranges.
-    if (rstudioapi::is.document_position(location)) {
-        list(location)
-    } else if (is_positionable(location)) {
-        list(rstudioapi::as.document_position(location))
-    } else if (rstudioapi::is.document_range(location)) {
-        list(location)
-    } else if (is_rangable(location)) {
-        list(rstudioapi::as.document_range(location))
-    } else if (is.list(location)) {
-        lapply(
-            location,
-            function(a_location) {
-                if (rstudioapi::is.document_position(a_location) || rstudioapi::is.document_range(a_location)) {
-                    a_location
-                } else if (is_positionable(a_location)) {
-                    rstudioapi::as.document_position(a_location)
-                } else if (is_rangable((a_location))) {
-                    rstudioapi::as.document_range(a_location)
-                } else {
-                    stop(
-                        "object in location list was not a",
-                        " document_position or document_range"
-                    )
-                }
-            }
-        )
-    } else {
-        stop("location object was not a document_position or document_range")
-    }
-}
-
-normalise_text_arg <- function(text, location_length) {
-    if (length(text) == location_length) {
-        text
-    } else if (length(text) == 1 && location_length > 1) {
-        rep(text, location_length)
-    } else {
-        stop(
-            "text vector needs to be of length 1 or",
-            " the same length as location list"
-        )
-    }
-}
-
-update_addin_registry <- function(addin_registry) {
-    pkgs <- .packages(all.available = TRUE)
-    addin_files <- vapply(pkgs, function(pkg) {
-        system.file("rstudio/addins.dcf", package = pkg)
-    }, character(1L))
-    addin_files <- addin_files[file.exists(addin_files)]
-    addin_descriptions <-
-        mapply(
-            function(package, package_dcf) {
-                addin_description_names <-
-                    c(
-                        "name",
-                        "description",
-                        "binding",
-                        "interactive",
-                        "package"
-                    )
-                description_result <-
-                    tryCatch({
-                        addin_description <-
-                            as.data.frame(read.dcf(package_dcf),
-                                stringsAsFactors = FALSE
-                            )
-
-                        if (ncol(addin_description) < 4) {
-                            NULL
-                        }
-                        ## if less than 4 columns it's malformed
-                        ## a NULL will be ignored in the rbind
-
-                        addin_description$package <- package
-                        names(addin_description) <- addin_description_names
-
-                        addin_description[, addin_description_names]
-                        ## this filters out any extra columns
-                    },
-                    error = function(cond) {
-                        message(
-                            "addins.dcf file for ", package,
-                            " could not be read from R library. ",
-                            "The RStudio addin picker will not ",
-                            "contain it's addins"
-                        )
-
-                        NULL
-                    }
-                    )
-
-                description_result
-            },
-            names(addin_files),
-            addin_files,
-            SIMPLIFY = FALSE
-        )
-    addin_descriptions_flat <-
-        do.call(
-            function(...) rbind(..., make.row.names = FALSE),
-            addin_descriptions
-        )
-
-    jsonlite::write_json(addin_descriptions_flat, addin_registry, pretty = TRUE)
-}
-
-namespace_has <- function(obj, namespace) {
-    attempt <- try(getFromNamespace(obj, namespace), silent = TRUE)
-    !inherits(attempt, "try-error")
-}
diff --git a/R/session/vsc.R b/R/session/vsc.R
deleted file mode 100644
index 5ab46139..00000000
--- a/R/session/vsc.R
+++ /dev/null
@@ -1,941 +0,0 @@
-pid <- Sys.getpid()
-wd <- getwd()
-tempdir <- tempdir()
-homedir <- Sys.getenv(
-    if (.Platform$OS.type == "windows") "USERPROFILE" else "HOME"
-)
-dir_watcher <- Sys.getenv("VSCODE_WATCHER_DIR", file.path(homedir, ".vscode-R"))
-request_file <- file.path(dir_watcher, "request.log")
-request_lock_file <- file.path(dir_watcher, "request.lock")
-settings_file <- file.path(dir_watcher, "settings.json")
-user_options <- names(options())
-
-logger <- if (getOption("vsc.debug", FALSE)) {
-    function(...) cat(..., "\n", sep = "")
-} else {
-    function(...) invisible()
-}
-
-load_settings <- function() {
-    if (!file.exists(settings_file)) {
-        return(FALSE)
-    }
-
-    setting <- function(x, ...) {
-        switch(EXPR = x, ..., x)
-    }
-
-    mapping <- quote(list(
-        vsc.use_webserver = session$useWebServer,
-        vsc.use_httpgd = plot$useHttpgd,
-        vsc.show_object_size = workspaceViewer$showObjectSize,
-        vsc.rstudioapi = session$emulateRStudioAPI,
-        vsc.str.max.level = setting(session$levelOfObjectDetail, Minimal = 0, Normal = 1, Detailed = 2),
-        vsc.object_length_limit = session$objectLengthLimit,
-        vsc.object_timeout = session$objectTimeout,
-        vsc.globalenv = session$watchGlobalEnvironment,
-        vsc.plot = setting(session$viewers$viewColumn$plot, Disable = FALSE),
-        vsc.dev.args = plot$devArgs,
-        vsc.browser = setting(session$viewers$viewColumn$browser, Disable = FALSE),
-        vsc.viewer = setting(session$viewers$viewColumn$viewer, Disable = FALSE),
-        vsc.page_viewer = setting(session$viewers$viewColumn$pageViewer, Disable = FALSE),
-        vsc.row_limit = session$data$rowLimit,
-        vsc.view = setting(session$viewers$viewColumn$view, Disable = FALSE),
-        vsc.helpPanel = setting(session$viewers$viewColumn$helpPanel, Disable = FALSE)
-    ))
-
-    vsc_settings <- tryCatch(jsonlite::read_json(settings_file), error = function(e) {
-        message("Error occurs when reading VS Code settings: ", conditionMessage(e))
-    })
-
-    if (is.null(vsc_settings)) {
-        return(FALSE)
-    }
-
-    ops <- eval(mapping, vsc_settings)
-
-    # exclude options set by user on startup
-    r_options <- ops[!(names(ops) %in% user_options)]
-
-    options(r_options)
-}
-
-load_settings()
-
-if (is.null(getOption("help_type"))) {
-    options(help_type = "html")
-}
-
-use_webserver <- isTRUE(getOption("vsc.use_webserver", FALSE))
-if (use_webserver) {
-    if (requireNamespace("httpuv", quietly = TRUE)) {
-        request_handlers <- list(
-            hover = function(expr, ...) {
-                tryCatch({
-                    expr <- parse(text = expr, keep.source = FALSE)[[1]]
-                    obj <- eval(expr, .GlobalEnv)
-                    list(str = capture_str(obj))
-                }, error = function(e) NULL)
-            },
-
-            complete = function(expr, trigger, ...) {
-                obj <- tryCatch({
-                    expr <- parse(text = expr, keep.source = FALSE)[[1]]
-                    eval(expr, .GlobalEnv)
-                }, error = function(e) NULL)
-
-                if (is.null(obj)) {
-                    return(NULL)
-                }
-
-                if (trigger == "$") {
-                    names <- if (is.object(obj)) {
-                        .DollarNames(obj, pattern = "")
-                    } else if (is.recursive(obj)) {
-                        names(obj)
-                    } else {
-                        NULL
-                    }
-
-                    result <- lapply(names, function(name) {
-                        item <- obj[[name]]
-                        list(
-                            name = name,
-                            type = typeof(item),
-                            str = try_capture_str(item)
-                        )
-                    })
-                    return(result)
-                }
-
-                if (trigger == "@" && isS4(obj)) {
-                    names <- slotNames(obj)
-                    result <- lapply(names, function(name) {
-                        item <- slot(obj, name)
-                        list(
-                            name = name,
-                            type = typeof(item),
-                            str = try_capture_str(item)
-                        )
-                    })
-                    return(result)
-                }
-            }
-        )
-
-        server <- getOption("vsc.server")
-        if (!is.null(server) && server$isRunning()) {
-            host <- server$getHost()
-            port <- server$getPort()
-            token <- attr(server, "token")
-        } else {
-            host <- "127.0.0.1"
-            port <- httpuv::randomPort()
-            token <- sprintf("%d:%d:%.6f", pid, port, Sys.time())
-            server <- httpuv::startServer(host, port,
-                list(
-                    onHeaders = function(req) {
-                        logger("http request ",
-                            req[["REMOTE_ADDR"]], ":",
-                            req[["REMOTE_PORT"]], " ",
-                            req[["REQUEST_METHOD"]], " ",
-                            req[["HTTP_USER_AGENT"]]
-                        )
-
-                        if (!nzchar(req[["REMOTE_ADDR"]]) || identical(req[["REMOTE_PORT"]], "0")) {
-                            return(NULL)
-                        }
-
-                        if (!identical(req[["HTTP_AUTHORIZATION"]], token)) {
-                            return(list(
-                                status = 401L,
-                                headers = list(
-                                    "Content-Type" = "text/plain"
-                                ),
-                                body = "Unauthorized"
-                            ))
-                        }
-
-                        if (!identical(req[["HTTP_CONTENT_TYPE"]], "application/json")) {
-                            return(list(
-                                status = 400L,
-                                headers = list(
-                                    "Content-Type" = "text/plain"
-                                ),
-                                body = "Bad request"
-                            ))
-                        }
-                    },
-                    call = function(req) {
-                        content <- req$rook.input$read_lines()
-                        request <- jsonlite::fromJSON(content, simplifyVector = FALSE)
-                        handler <- request_handlers[[request$type]]
-                        response <- if (is.function(handler)) do.call(handler, request)
-
-                        list(
-                            status = 200L,
-                            headers = list(
-                                "Content-Type" = "application/json"
-                            ),
-                            body = jsonlite::toJSON(response, auto_unbox = TRUE, force = TRUE)
-                        )
-                    }
-                )
-            )
-            attr(server, "token") <- token
-            options(vsc.server = server)
-        }
-    } else {
-        message("{httpuv} is required to use WebServer from the session watcher.")
-        use_webserver <- FALSE
-    }
-}
-
-get_timestamp <- function() {
-    sprintf("%.6f", Sys.time())
-}
-
-scalar <- function(x) {
-    class(x) <- c("scalar", class(x))
-    x
-}
-
-request <- function(command, ...) {
-    obj <- list(
-        time = Sys.time(),
-        pid = pid,
-        wd = wd,
-        command = command,
-        ...
-    )
-    jsonlite::write_json(obj, request_file,
-        auto_unbox = TRUE, null = "null", force = TRUE
-    )
-    cat(get_timestamp(), file = request_lock_file)
-}
-
-try_catch_timeout <- function(expr, timeout = Inf, ...) {
-    expr <- substitute(expr)
-    envir <- parent.frame()
-    setTimeLimit(timeout, transient = TRUE)
-    on.exit(setTimeLimit())
-    tryCatch(eval(expr, envir), ...)
-}
-
-capture_str <- function(object, max.level = getOption("vsc.str.max.level", 0)) {
-    paste0(utils::capture.output(
-        utils::str(object,
-            max.level = max.level,
-            give.attr = FALSE,
-            vec.len = 1
-        )
-    ), collapse = "\n")
-}
-
-try_capture_str <- function(object, max.level = getOption("vsc.str.max.level", 0)) {
-    tryCatch(
-        capture_str(object, max.level = max.level),
-        error = function(e) {
-            paste0(class(object), collapse = ", ")
-        }
-    )
-}
-
-rebind <- function(sym, value, ns) {
-    if (is.character(ns)) {
-        Recall(sym, value, getNamespace(ns))
-        pkg <- paste0("package:", ns)
-        if (pkg %in% search()) {
-            Recall(sym, value, as.environment(pkg))
-        }
-    } else if (is.environment(ns)) {
-        if (bindingIsLocked(sym, ns)) {
-            unlockBinding(sym, ns)
-            on.exit(lockBinding(sym, ns))
-        }
-        assign(sym, value, ns)
-    } else {
-        stop("ns must be a string or environment")
-    }
-}
-
-address <- function(x) {
-    info <- utils::capture.output(.Internal(inspect(x, 0L, 0L)))
-    sub("@([a-z0-9]+)\\s+.+", "\\1", info[[1]])
-}
-
-globalenv_cache <- new.env(parent = emptyenv())
-
-inspect_env <- function(env, cache) {
-    all_names <- ls(env)
-    rm(list = setdiff(names(globalenv_cache), all_names), envir = cache)
-    is_active <- vapply(all_names, bindingIsActive, logical(1), USE.NAMES = TRUE, env)
-    is_promise <- rlang::env_binding_are_lazy(env, all_names[!is_active])
-    show_object_size <- getOption("vsc.show_object_size", FALSE)
-    object_length_limit <- getOption("vsc.object_length_limit", 2000)
-    object_timeout <- getOption("vsc.object_timeout", 50) / 1000
-    str_max_level <- getOption("vsc.str.max.level", 0)
-    objs <- lapply(all_names, function(name) {
-        if (isTRUE(is_promise[name])) {
-            info <- list(
-                class = "promise",
-                type = scalar("promise"),
-                length = scalar(0L),
-                str = scalar("(promise)")
-            )
-        } else if (isTRUE(is_active[name])) {
-            info <- list(
-                class = "active_binding",
-                type = scalar("active_binding"),
-                length = scalar(0L),
-                str = scalar("(active-binding)")
-            )
-        } else {
-            obj <- env[[name]]
-
-            info <- list(
-                class = class(obj),
-                type = scalar(typeof(obj)),
-                length = scalar(length(obj))
-            )
-
-            if (show_object_size) {
-                addr <- address(obj)
-                cobj <- cache[[name]]
-                if (is.null(cobj) || cobj$address != addr || cobj$length != info$length) {
-                    cache[[name]] <- cobj <- list(
-                        address = addr,
-                        length = length(obj),
-                        size = unclass(object.size(obj))
-                    )
-                }
-                info$size <- scalar(cobj$size)
-            }
-
-            if (length(obj) > object_length_limit) {
-                info$str <- scalar(trimws(try_capture_str(obj, 0)))
-            } else {
-                info_str <- NULL
-                if (str_max_level > 0) {
-                    info_str <- try_catch_timeout(
-                        capture_str(obj, str_max_level),
-                        timeout = object_timeout,
-                        error = function(e) NULL
-                    )
-                }
-                if (is.null(info_str)) {
-                    info_str <- try_capture_str(obj, 0)
-                }
-                info$str <- scalar(trimws(info_str))
-                obj_names <- if (is.object(obj)) {
-                    .DollarNames(obj, pattern = "")
-                } else if (is.recursive(obj)) {
-                    names(obj)
-                } else {
-                    NULL
-                }
-
-                if (length(obj_names)) {
-                    info$names <- obj_names
-                }
-            }
-
-            if (isS4(obj)) {
-                info$slots <- slotNames(obj)
-            }
-
-            if (!is.null(dim(obj))) {
-                info$dim <- dim(obj)
-            }
-        }
-        info
-    })
-    names(objs) <- all_names
-    objs
-}
-
-dir_session <- file.path(tempdir, "vscode-R")
-dir.create(dir_session, showWarnings = FALSE, recursive = TRUE)
-
-removeTaskCallback("vsc.workspace")
-show_globalenv <- isTRUE(getOption("vsc.globalenv", TRUE))
-workspace_file <- file.path(dir_session, "workspace.json")
-workspace_lock_file <- file.path(dir_session, "workspace.lock")
-file.create(workspace_lock_file, showWarnings = FALSE)
-
-update_workspace <- function(...) {
-    tryCatch({
-        data <- list(
-            search = search()[-1],
-            loaded_namespaces = loadedNamespaces(),
-            globalenv = if (show_globalenv) inspect_env(.GlobalEnv, globalenv_cache) else NULL
-        )
-        jsonlite::write_json(data, workspace_file, force = TRUE, pretty = FALSE)
-        cat(get_timestamp(), file = workspace_lock_file)
-    }, error = message)
-    TRUE
-}
-update_workspace()
-addTaskCallback(update_workspace, name = "vsc.workspace")
-
-removeTaskCallback("vsc.plot")
-use_httpgd <- identical(getOption("vsc.use_httpgd", FALSE), TRUE)
-show_plot <- !identical(getOption("vsc.plot", "Two"), FALSE)
-if (use_httpgd && "httpgd" %in% .packages(all.available = TRUE)) {
-    options(device = function(...) {
-        httpgd::hgd(
-            silent = TRUE
-        )
-        .vsc$request("httpgd", url = httpgd::hgd_url())
-    })
-} else if (use_httpgd) {
-    message("Install package `httpgd` to use vscode-R with httpgd!")
-} else if (show_plot) {
-    plot_file <- file.path(dir_session, "plot.png")
-    plot_lock_file <- file.path(dir_session, "plot.lock")
-    file.create(plot_file, plot_lock_file, showWarnings = FALSE)
-
-    plot_updated <- FALSE
-    null_dev_id <- c(pdf = 2L)
-    null_dev_size <- c(7 + pi, 7 + pi)
-
-    check_null_dev <- function() {
-        identical(dev.cur(), null_dev_id) &&
-            identical(dev.size(), null_dev_size)
-    }
-
-    new_plot <- function() {
-        if (check_null_dev()) {
-            plot_updated <<- TRUE
-        }
-    }
-
-    options(
-        device = function(...) {
-            pdf(NULL,
-                width = null_dev_size[[1L]],
-                height = null_dev_size[[2L]],
-                bg = "white")
-            dev.control(displaylist = "enable")
-        }
-    )
-
-    update_plot <- function(...) {
-        tryCatch({
-            if (plot_updated && check_null_dev()) {
-                plot_updated <<- FALSE
-                record <- recordPlot()
-                if (length(record[[1L]])) {
-                    dev_args <- getOption("vsc.dev.args")
-                    do.call(png, c(list(filename = plot_file), dev_args))
-                    on.exit({
-                        dev.off()
-                        cat(get_timestamp(), file = plot_lock_file)
-                    })
-                    replayPlot(record)
-                }
-            }
-        }, error = message)
-        TRUE
-    }
-
-    setHook("plot.new", new_plot, "replace")
-    setHook("grid.newpage", new_plot, "replace")
-
-    rebind(".External.graphics", function(...) {
-        out <- .Primitive(".External.graphics")(...)
-        if (check_null_dev()) {
-            plot_updated <<- TRUE
-        }
-        out
-    }, "base")
-
-    update_plot()
-    addTaskCallback(update_plot, name = "vsc.plot")
-}
-
-show_view <- !identical(getOption("vsc.view", "Two"), FALSE)
-if (show_view) {
-    get_column_def <- function(name, field, value) {
-        filter <- TRUE
-        tooltip <- sprintf(
-            "%s, class: [%s], type: %s",
-            name,
-            toString(class(value)),
-            typeof(value)
-        )
-        if (is.numeric(value)) {
-            type <- "numericColumn"
-            if (is.null(attr(value, "class"))) {
-                filter <- "agNumberColumnFilter"
-            }
-        } else if (inherits(value, "Date")) {
-            type <- "dateColumn"
-            filter <- "agDateColumnFilter"
-        } else {
-            type <- "textColumn"
-            filter <- "agTextColumnFilter"
-        }
-        list(
-            headerName = name,
-            headerTooltip = tooltip,
-            field = field,
-            type = type,
-            filter = filter
-        )
-    }
-
-    dataview_table <- function(data) {
-        if (is.matrix(data)) {
-            data <- as.data.frame.matrix(data)
-        }
-
-        if (is.data.frame(data)) {
-            .nrow <- nrow(data)
-            .colnames <- colnames(data)
-            if (is.null(.colnames)) {
-                .colnames <- sprintf("V%d", seq_len(ncol(data)))
-            } else {
-                .colnames <- trimws(.colnames)
-            }
-            if (.row_names_info(data) > 0L) {
-                rownames <- rownames(data)
-                rownames(data) <- NULL
-            } else {
-                rownames <- seq_len(.nrow)
-            }
-            .colnames <- c("(row)", .colnames)
-            fields <- sprintf("x%d", seq_along(.colnames))
-            data <- c(list(" " = rownames), .subset(data))
-            names(data) <- fields
-            class(data) <- "data.frame"
-            attr(data, "row.names") <- .set_row_names(.nrow)
-            columns <- .mapply(get_column_def,
-                list(.colnames, fields, data),
-                NULL
-            )
-            list(
-                columns = columns,
-                data = data
-            )
-        } else {
-            stop("data must be a data.frame or a matrix")
-        }
-    }
-
-    show_dataview <- function(x, title, uuid = NULL,
-                              viewer = getOption("vsc.view", "Two"),
-                              row_limit = abs(getOption("vsc.row_limit", 0))) {
-        as_truncated_data <- function(.data) {
-            .nrow <- nrow(.data)
-            if (row_limit != 0 && row_limit < .nrow) {
-                title <<- sprintf("%s (limited to %d/%d)", title, row_limit, .nrow)
-                .data <- utils::head(.data, n = row_limit)
-            }
-            return(.data)
-        }
-
-        if (missing(title)) {
-            sub <- substitute(x)
-            title <- deparse(sub, nlines = 1)
-        }
-        if (inherits(x, "ArrowTabular")) {
-            x <- as_truncated_data(x)
-            x <- as.data.frame(x)
-        }
-        if (is.environment(x)) {
-            all_names <- ls(x)
-            is_active <- vapply(all_names, bindingIsActive, logical(1), USE.NAMES = TRUE, x)
-            is_promise <- rlang::env_binding_are_lazy(x, all_names[!is_active])
-            x <- lapply(all_names, function(name) {
-                if (isTRUE(is_promise[name])) {
-                    data.frame(
-                        class = "promise",
-                        type = "promise",
-                        length = 0L,
-                        size = 0L,
-                        value = "(promise)",
-                        stringsAsFactors = FALSE,
-                        check.names = FALSE
-                    )
-                } else if (isTRUE(is_active[name])) {
-                    data.frame(
-                        class = "active_binding",
-                        type = "active_binding",
-                        length = 0L,
-                        size = 0L,
-                        value = "(active-binding)",
-                        stringsAsFactors = FALSE,
-                        check.names = FALSE
-                    )
-                } else {
-                    obj <- x[[name]]
-                    data.frame(
-                        class = paste0(class(obj), collapse = ", "),
-                        type = typeof(obj),
-                        length = length(obj),
-                        size = as.integer(object.size(obj)),
-                        value = trimws(try_capture_str(obj, 0)),
-                        stringsAsFactors = FALSE,
-                        check.names = FALSE
-                    )
-                }
-            })
-            names(x) <- all_names
-            if (length(x)) {
-                x <- do.call(rbind, x)
-            } else {
-                x <- data.frame(
-                    class = character(),
-                    type = character(),
-                    length = integer(),
-                    size = integer(),
-                    value = character(),
-                    stringsAsFactors = FALSE,
-                    check.names = FALSE
-                )
-            }
-        }
-        if (is.data.frame(x) || is.matrix(x)) {
-            x <- as_truncated_data(x)
-            data <- dataview_table(x)
-            file <- tempfile(tmpdir = tempdir, fileext = ".json")
-            jsonlite::write_json(data, file, na = "string", null = "null", auto_unbox = TRUE, force = TRUE)
-            request("dataview", source = "table", type = "json",
-                title = title, file = file, viewer = viewer, uuid = uuid
-            )
-        } else if (is.list(x)) {
-            tryCatch({
-                file <- tempfile(tmpdir = tempdir, fileext = ".json")
-                jsonlite::write_json(x, file, na = "string", null = "null", auto_unbox = TRUE, force = TRUE)
-                request("dataview", source = "list", type = "json",
-                    title = title, file = file, viewer = viewer, uuid = uuid
-                )
-            }, error = function(e) {
-                file <- file.path(tempdir, paste0(make.names(title), ".txt"))
-                text <- utils::capture.output(print(x))
-                writeLines(text, file)
-                request("dataview", source = "object", type = "txt",
-                    title = title, file = file, viewer = viewer, uuid = uuid
-                )
-            })
-        } else {
-            file <- file.path(tempdir, paste0(make.names(title), ".R"))
-            if (is.primitive(x)) {
-                code <- utils::capture.output(print(x))
-            } else {
-                code <- deparse(x)
-            }
-            writeLines(code, file)
-            request("dataview", source = "object", type = "R",
-                title = title, file = file, viewer = viewer, uuid = uuid
-            )
-        }
-    }
-
-    rebind("View", show_dataview, "utils")
-}
-
-attach <- function() {
-    load_settings()
-    if (rstudioapi_enabled()) {
-        rstudioapi_util_env$update_addin_registry(addin_registry)
-    }
-    request("attach",
-        version = sprintf("%s.%s", R.version$major, R.version$minor),
-        tempdir = tempdir,
-        info = list(
-            command = commandArgs()[[1L]],
-            version = R.version.string,
-            start_time = format(file.info(tempdir)$ctime)
-        ),
-        plot_url = if (identical(names(dev.cur()), "httpgd")) httpgd::hgd_url(),
-        server = if (use_webserver) list(
-            host = host,
-            port = port,
-            token = token
-        ) else NULL
-    )
-}
-
-path_to_uri <- function(path) {
-    if (length(path) == 0) {
-        return(character())
-    }
-    path <- path.expand(path)
-    if (.Platform$OS.type == "windows") {
-        prefix <- "file:///"
-        path <- gsub("\\", "/", path, fixed = TRUE)
-    } else {
-        prefix <- "file://"
-    }
-    paste0(prefix, utils::URLencode(path))
-}
-
-request_browser <- function(url, title, ..., viewer) {
-    # Printing URL with specific port triggers
-    # auto port-forwarding under remote development
-    message("Browsing ", url)
-    request("browser", url = url, title = title, ..., viewer = viewer)
-}
-
-show_browser <- function(url, title = url, ...,
-                         viewer = getOption("vsc.browser", "Active")) {
-    proxy_uri <- Sys.getenv("VSCODE_PROXY_URI")
-    if (nzchar(proxy_uri)) {
-        is_base_path <- grepl("\\:\\d+$", url)
-        url <- sub("^https?\\://(127\\.0\\.0\\.1|localhost)(\\:)?",
-            sub("\\{\\{?port\\}\\}?/?", "", proxy_uri), url
-        )
-        if (is_base_path) {
-            url <- paste0(url, "/")
-        }
-    }
-    if (grepl("^https?\\://(127\\.0\\.0\\.1|localhost)(\\:\\d+)?", url)) {
-        request_browser(url = url, title = title, ..., viewer = viewer)
-    } else if (grepl("^https?\\://", url)) {
-        message(
-            if (nzchar(proxy_uri)) {
-                "VSCode is not running on localhost but on a remote server.\n"
-            } else {
-                "VSCode WebView only supports showing local http content.\n"
-            },
-            "Opening in external browser..."
-        )
-        request_browser(url = url, title = title, ..., viewer = FALSE)
-    } else {
-        path <- sub("^file\\://", "", url)
-        if (file.exists(path)) {
-            path <- normalizePath(path, "/", mustWork = TRUE)
-            if (grepl("\\.html?$", path, ignore.case = TRUE)) {
-                message(
-                    "VSCode WebView has restricted access to local file.\n",
-                    "Opening in external browser..."
-                )
-                request_browser(url = path_to_uri(path),
-                    title = title, ..., viewer = FALSE
-                )
-            } else {
-                request("dataview", source = "object", type = "txt",
-                    title = title, file = path, viewer = viewer
-                )
-            }
-        } else {
-            stop("File not exists")
-        }
-    }
-}
-
-show_webview <- function(url, title, ..., viewer) {
-    if (!is.character(url)) {
-        real_url <- NULL
-        temp_viewer <- function(url, ...) {
-            real_url <<- url
-        }
-        op <- options(viewer = temp_viewer, page_viewer = temp_viewer)
-        on.exit(options(op))
-        print(url)
-        if (is.character(real_url)) {
-            url <- real_url
-        } else {
-            stop("Invalid object")
-        }
-    }
-    proxy_uri <- Sys.getenv("VSCODE_PROXY_URI")
-    if (nzchar(proxy_uri)) {
-        is_base_path <- grepl("\\:\\d+$", url)
-        url <- sub("^https?\\://(127\\.0\\.0\\.1|localhost)(\\:)?",
-            sub("\\{\\{?port\\}\\}?/?", "", proxy_uri), url
-        )
-        if (is_base_path) {
-            url <- paste0(url, "/")
-        }
-    }
-    if (grepl("^https?\\://(127\\.0\\.0\\.1|localhost)(\\:\\d+)?", url)) {
-        request_browser(url = url, title = title, ..., viewer = viewer)
-    } else if (grepl("^https?\\://", url)) {
-        message(
-            if (nzchar(proxy_uri)) {
-                "VSCode is not running on localhost but on a remote server.\n"
-            } else {
-                "VSCode WebView only supports showing local http content.\n"
-            },
-            "Opening in external browser..."
-        )
-        request_browser(url = url, title = title, ..., viewer = FALSE)
-    } else if (file.exists(url)) {
-        file <- normalizePath(url, "/", mustWork = TRUE)
-        request("webview", file = file, title = title, viewer = viewer, ...)
-    } else {
-        stop("File not exists")
-    }
-}
-
-show_viewer <- function(url, title = NULL, ...,
-                        viewer = getOption("vsc.viewer", "Two")) {
-    if (is.null(title)) {
-        expr <- substitute(url)
-        if (is.character(url)) {
-            title <- "Viewer"
-        } else {
-            title <- deparse(expr, nlines = 1)
-        }
-    }
-    show_webview(url = url, title = title, ..., viewer = viewer)
-}
-
-show_page_viewer <- function(url, title = NULL, ...,
-                             viewer = getOption("vsc.page_viewer", "Active")) {
-    if (is.null(title)) {
-        expr <- substitute(url)
-        if (is.character(url)) {
-            title <- "Page Viewer"
-        } else {
-            title <- deparse(expr, nlines = 1)
-        }
-    }
-    show_webview(url = url, title = title, ..., viewer = viewer)
-}
-
-options(
-    browser = show_browser,
-    viewer = show_viewer,
-    page_viewer = show_page_viewer
-)
-
-# rstudioapi
-rstudioapi_enabled <- function() {
-    isTRUE(getOption("vsc.rstudioapi", TRUE))
-}
-
-if (rstudioapi_enabled()) {
-    response_timeout <- 5
-    response_lock_file <- file.path(dir_session, "response.lock")
-    response_file <- file.path(dir_session, "response.log")
-    file.create(response_lock_file, showWarnings = FALSE)
-    file.create(response_file, showWarnings = FALSE)
-    addin_registry <- file.path(dir_session, "addins.json")
-    # This is created in attach()
-
-    get_response_timestamp <- function() {
-        readLines(response_lock_file)
-    }
-    # initialise the reponse timestamp to empty string
-    response_time_stamp <- ""
-
-    get_response_lock <- function() {
-        lock_time_stamp <- get_response_timestamp()
-        if (isTRUE(lock_time_stamp != response_time_stamp)) {
-            response_time_stamp <<- lock_time_stamp
-            TRUE
-        } else {
-            FALSE
-        }
-    }
-
-    request_response <- function(command, ...) {
-        request(command, ..., sd = dir_session)
-        wait_start <- Sys.time()
-        while (!get_response_lock()) {
-            if ((Sys.time() - wait_start) > response_timeout) {
-                stop(
-                    "Did not receive a response from VSCode-R API within ",
-                    response_timeout, " seconds."
-                )
-            }
-            Sys.sleep(0.1)
-        }
-        jsonlite::read_json(response_file)
-    }
-
-    rstudioapi_util_env <- new.env()
-    rstudioapi_env <- new.env(parent = rstudioapi_util_env)
-    source(file.path(dir_init, "rstudioapi_util.R"), local = rstudioapi_util_env)
-    source(file.path(dir_init, "rstudioapi.R"), local = rstudioapi_env)
-    setHook(
-        packageEvent("rstudioapi", "onLoad"),
-        function(...) {
-            rstudioapi_util_env$rstudioapi_patch_hook(rstudioapi_env)
-        }
-    )
-    if ("rstudioapi" %in% loadedNamespaces()) {
-        # if the rstudioapi is already loaded, for example via a call to
-        # library(tidyverse) in the user's profile, we need to shim it now.
-        # There's no harm in having also registered the hook in this case. It can
-        # work in the event that the namespace is unloaded and reloaded.
-        rstudioapi_util_env$rstudioapi_patch_hook(rstudioapi_env)
-    }
-
-}
-
-print.help_files_with_topic <- function(h, ...) {
-    viewer <- getOption("vsc.helpPanel", "Two")
-    if (!identical(FALSE, viewer) && length(h) >= 1 && is.character(h)) {
-        file <- h[1]
-        path <- dirname(file)
-        dirpath <- dirname(path)
-        pkgname <- basename(dirpath)
-        requestPath <- paste0(
-            "/library/",
-            pkgname,
-            "/html/",
-            basename(file),
-            ".html"
-        )
-        request(command = "help", requestPath = requestPath, viewer = viewer)
-    } else {
-        utils:::print.help_files_with_topic(h, ...)
-    }
-    invisible(h)
-}
-
-print.hsearch <- function(x, ...) {
-    viewer <- getOption("vsc.helpPanel", "Two")
-    if (!identical(FALSE, viewer) && length(x) >= 1) {
-        requestPath <- paste0(
-            "/doc/html/Search?pattern=",
-            tools:::escapeAmpersand(x$pattern),
-            paste0("&fields.", x$fields, "=1",
-                collapse = ""
-            ),
-            if (!is.null(x$agrep)) paste0("&agrep=", x$agrep),
-            if (!x$ignore.case) "&ignore.case=0",
-            if (!identical(
-                x$types,
-                getOption("help.search.types")
-            )) {
-                paste0("&types.", x$types, "=1",
-                    collapse = ""
-                )
-            },
-            if (!is.null(x$package)) {
-                paste0(
-                    "&package=",
-                    paste(x$package, collapse = ";")
-                )
-            },
-            if (!identical(x$lib.loc, .libPaths())) {
-                paste0(
-                    "&lib.loc=",
-                    paste(x$lib.loc, collapse = ";")
-                )
-            }
-        )
-        request(command = "help", requestPath = requestPath, viewer = viewer)
-    } else {
-        utils:::print.hsearch(x, ...)
-    }
-    invisible(x)
-}
-
-# a copy of .S3method(), since this function is new in R 4.0
-.S3method <- function(generic, class, method) {
-    if (missing(method)) {
-        method <- paste(generic, class, sep = ".")
-    }
-    method <- match.fun(method)
-    registerS3method(generic, class, method, envir = parent.frame())
-    invisible(NULL)
-}
-
-reg.finalizer(.GlobalEnv, function(e) .vsc$request("detach"), onexit = TRUE)
diff --git a/package.json b/package.json
index fa2f24f3..f87934a1 100644
--- a/package.json
+++ b/package.json
@@ -2024,7 +2024,8 @@
     "git-cliff": "^2.8.0",
     "mocha": "^11.1.0",
     "sinon": "^15.0.1",
-    "typescript": "^4.7.2"
+    "typescript": "^4.7.2",
+    "@types/ws": "^8.5.5"
   },
   "dependencies": {
     "ag-grid-community": "^31.3.2",
@@ -2040,7 +2041,8 @@
     "node-fetch": "^2.6.7",
     "vscode-languageclient": "^9.0.1",
     "vsls": "^1.0.4753",
-    "winreg": "^1.2.4"
+    "winreg": "^1.2.4",
+    "ws": "^8.13.0"
   },
   "extensionDependencies": [
     "REditorSupport.r-syntax"
diff --git a/sess/R/dispatch.R b/sess/R/dispatch.R
index b3a70785..ca829119 100644
--- a/sess/R/dispatch.R
+++ b/sess/R/dispatch.R
@@ -25,8 +25,9 @@ ipc_send <- function(method, params = list(), request = FALSE) {
   }
 
   # Push over the websocket
+  payload <- jsonlite::toJSON(msg, auto_unbox = TRUE, null = "null", force = TRUE)
   tryCatch({
-    .sess_env$ws$send(jsonlite::toJSON(msg, auto_unbox = TRUE, null = "null", force = TRUE))
+    .sess_env$ws$send(payload)
   }, error = function(e) {
     warning("Failed to send IPC message: ", e$message)
     return(invisible(FALSE))
diff --git a/sess/R/hooks.R b/sess/R/hooks.R
index 3072de88..f1411e9e 100644
--- a/sess/R/hooks.R
+++ b/sess/R/hooks.R
@@ -3,7 +3,7 @@
 #' @param use_rstudioapi Logical. Enable rstudioapi emulation.
 #' @param use_httpgd Logical. Enable httpgd plot device if available.
 #' @export
-register_hooks <- function(use_rstudioapi = TRUE, use_httpgd = FALSE) {
+register_hooks <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
   
   # 1. Override View() to push data directly via WebSocket
   rebind("View", function(x, title = deparse(substitute(x))) {
diff --git a/sess/R/server.R b/sess/R/server.R
index 18688c2c..1fdb4334 100644
--- a/sess/R/server.R
+++ b/sess/R/server.R
@@ -1,21 +1,16 @@
 #' Start the client R IPC Server
 #' 
 #' @param use_rstudioapi Logical. Should the rstudioapi emulation layer be enabled? Defaults to TRUE.
-#' @param use_httpgd Logical. Should httpgd be used for plotting if available? Defaults to FALSE.
+#' @param use_httpgd Logical. Should httpgd be used for plotting if available? Defaults to TRUE
 #' @export
-sess_app <- function(use_rstudioapi = TRUE, use_httpgd = FALSE) {
+sess_app <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
   
-  on.exit({
-    if (!is.null(.sess_env$server)) {
-      notify_client("detach", list(pid = Sys.getpid()))
-      .sess_env$server$stop()
-    }
-  })
-
   # Initialize state
   .sess_env$server <- NULL
   .sess_env$ws <- NULL
-  .sess_env$token <- paste0(sample(c(letters, 0:9), 32, replace = TRUE), collapse = "")
+  
+  env_token <- Sys.getenv("SESS_TOKEN")
+  .sess_env$token <- if (nzchar(env_token)) env_token else paste0(sample(c(letters, 0:9), 32, replace = TRUE), collapse = "")
   .sess_env$pending_responses <- list()
   
   # Temporary file for static plot serving
@@ -84,7 +79,7 @@ sess_app <- function(use_rstudioapi = TRUE, use_httpgd = FALSE) {
             start_time = format(Sys.time())
         )
       ))
-      
+
       ws$onMessage(function(binary, message) {
         # Handle JSON-RPC 2.0 messages COMING FROM the client
         payload <- tryCatch(jsonlite::fromJSON(message), error = function(e) NULL)
@@ -105,8 +100,9 @@ sess_app <- function(use_rstudioapi = TRUE, use_httpgd = FALSE) {
     }
   )
 
-  # Start the httpuv server on a random port
-  port <- httpuv::randomPort()
+  # Start the httpuv server on a specific or random port
+  env_port <- Sys.getenv("SESS_PORT")
+  port <- if (nzchar(env_port)) as.integer(env_port) else httpuv::randomPort()
   .sess_env$server <- httpuv::startServer("127.0.0.1", port, app = app_handlers)
   
   # Print the connection string to the console.
@@ -114,4 +110,4 @@ sess_app <- function(use_rstudioapi = TRUE, use_httpgd = FALSE) {
   
   # Register runtime hooks
   register_hooks(use_rstudioapi = use_rstudioapi, use_httpgd = use_httpgd)
-}
\ No newline at end of file
+}
diff --git a/src/completions.ts b/src/completions.ts
index 17546f42..f9a365c8 100644
--- a/src/completions.ts
+++ b/src/completions.ts
@@ -52,8 +52,8 @@ export class HoverProvider implements vscode.HoverProvider {
             hoverRange = document.getWordRangeAtPosition(position, exprRegex)?.with({ end: hoverRange?.end });
             const expr = document.getText(hoverRange);
             const response = await session.sessionRequest(session.server, {
-                type: 'hover',
-                expr: expr
+                method: 'hover',
+                params: { expr: expr }
             });
 
             if (response) {
@@ -171,9 +171,8 @@ export class LiveCompletionItemProvider implements vscode.CompletionItemProvider
                 const exprRange = document.getWordRangeAtPosition(symbolPosition, re)?.with({ end: symbolPosition });
                 const expr = document.getText(exprRange);
                 const response: RObjectElement[] = await session.sessionRequest(session.server, {
-                    type: 'complete',
-                    expr: expr,
-                    trigger: completionContext.triggerCharacter
+                    method: 'completion',
+                    params: { expr: expr, trigger: completionContext.triggerCharacter }
                 });
 
                 if (response) {
diff --git a/src/extension.ts b/src/extension.ts
index 67a07ea0..ba2d5b88 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -236,7 +236,6 @@ export async function activate(context: vscode.ExtensionContext): Promise<apiImp
             sessionStatusBarItem.tooltip = 'Click to attach active terminal.';
             sessionStatusBarItem.show();
             context.subscriptions.push(sessionStatusBarItem);
-            void session.startRequestWatcher(sessionStatusBarItem);
         }
 
         // track active text editor
diff --git a/src/languageService.ts b/src/languageService.ts
index 43b14e72..7b336f21 100644
--- a/src/languageService.ts
+++ b/src/languageService.ts
@@ -46,7 +46,9 @@ export class LanguageService implements Disposable {
                     client.outputChannel.show();
                 }
             }
-            void client.stop();
+            if (client.needsStop()) {
+                void client.stop();
+            }
         });
         return childProcess;
     }
diff --git a/src/rTerminal.ts b/src/rTerminal.ts
index a71ee7e5..0883223b 100644
--- a/src/rTerminal.ts
+++ b/src/rTerminal.ts
@@ -114,6 +114,21 @@ export async function runFromLineToEnd(): Promise<void>  {
     await runTextInTerm(text);
 }
 
+import * as net from 'net';
+import * as crypto from 'crypto';
+import { startSessionWatcher } from './session';
+
+export async function getFreePort(): Promise<number> {
+    return new Promise<number>((resolve, reject) => {
+        const srv = net.createServer();
+        srv.listen(0, '127.0.0.1', () => {
+            const port = (srv.address() as net.AddressInfo).port;
+            srv.close(() => resolve(port));
+        });
+        srv.on('error', reject);
+    });
+}
+
 export async function makeTerminalOptions(): Promise<vscode.TerminalOptions> {
     const workspaceFolderPath = getCurrentWorkspaceFolder()?.uri.fsPath;
     const termPath = await getRterm();
@@ -124,14 +139,15 @@ export async function makeTerminalOptions(): Promise<vscode.TerminalOptions> {
         shellArgs: shellArgs,
         cwd: workspaceFolderPath,
     };
-    const newRprofile = extensionContext.asAbsolutePath(path.join('R', 'session', 'profile.R'));
-    const initR = extensionContext.asAbsolutePath(path.join('R', 'session','init.R'));
+    const newRprofile = extensionContext.asAbsolutePath(path.join('R', 'profile.R'));
     if (config().get<boolean>('sessionWatcher')) {
+        const port = await getFreePort();
+        const token = crypto.randomBytes(16).toString('hex');
         termOptions.env = {
             R_PROFILE_USER_OLD: process.env.R_PROFILE_USER,
             R_PROFILE_USER: newRprofile,
-            VSCODE_INIT_R: initR,
-            VSCODE_WATCHER_DIR: homeExtDir()
+            SESS_PORT: port.toString(),
+            SESS_TOKEN: token
         };
     }
     return termOptions;
@@ -149,6 +165,11 @@ export async function createRTerm(preserveshow?: boolean): Promise<boolean> {
     }
     rTerm = vscode.window.createTerminal(termOptions);
     rTerm.show(preserveshow);
+    
+    if (termOptions.env?.SESS_PORT && termOptions.env?.SESS_TOKEN) {
+        startSessionWatcher(Number(termOptions.env.SESS_PORT), termOptions.env.SESS_TOKEN);
+    }
+    
     return true;
 }
 
diff --git a/src/rstudioapi.ts b/src/rstudioapi.ts
index ac4d738e..72e47405 100644
--- a/src/rstudioapi.ts
+++ b/src/rstudioapi.ts
@@ -19,76 +19,7 @@ import { config } from './util';
 
 let lastActiveTextEditor: TextEditor;
 
-export async function dispatchRStudioAPICall(action: string, args: any, sd: string): Promise<void> {
-
-    switch (action) {
-        case 'active_editor_context': {
-            await writeResponse(activeEditorContext(), sd);
-            break;
-        }
-        case 'insert_or_modify_text': {
-            await insertOrModifyText(args.query, args.id);
-            await writeSuccessResponse(sd);
-            break;
-        }
-        case 'replace_text_in_current_selection': {
-            await replaceTextInCurrentSelection(args.text, args.id);
-            await writeSuccessResponse(sd);
-            break;
-        }
-        case 'show_dialog': {
-            showDialog(args.message);
-            await writeSuccessResponse(sd);
-            break;
-        }
-        case 'navigate_to_file': {
-            await navigateToFile(args.file, args.line, args.column);
-            await writeSuccessResponse(sd);
-            break;
-        }
-        case 'set_selection_ranges': {
-            await setSelections(args.ranges, args.id);
-            await writeSuccessResponse(sd);
-            break;
-        }
-        case 'document_save': {
-            await documentSave(args.id);
-            await writeSuccessResponse(sd);
-            break;
-        }
-        case 'document_save_all': {
-            await documentSaveAll();
-            await writeSuccessResponse(sd);
-            break;
-        }
-        case 'get_project_path': {
-            await writeResponse(projectPath(), sd);
-            break;
-        }
-        case 'document_context': {
-            await writeResponse(await documentContext(args.id), sd);
-            break;
-        }
-        case 'document_new': {
-            await documentNew(args.text, args.type, args.position);
-            await writeSuccessResponse(sd);
-            break;
-        }
-        case 'restart_r': {
-            await restartRTerminal();
-            await writeSuccessResponse(sd);
-            break;
-        }
-        case 'send_to_console': {
-            await sendCodeToRTerminal(args.code, args.execute, args.focus);
-            await writeSuccessResponse(sd);
-            break;
-        }
-        default:
-            console.error(`[dispatchRStudioAPICall] Unsupported action: ${action}`);
-    }
-
-}
+// dispatchRStudioAPICall removed
 
 //rstudioapi
 export function activeEditorContext() {
diff --git a/src/session.ts b/src/session.ts
index b5959019..61880d48 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -7,10 +7,10 @@ import { Agent } from 'http';
 import fetch from 'node-fetch';
 import { commands, StatusBarItem, Uri, ViewColumn, Webview, window, workspace, env, WebviewPanelOnDidChangeViewStateEvent, WebviewPanel } from 'vscode';
 
-import { runTextInTerm } from './rTerminal';
+import { runTextInTerm, restartRTerminal } from './rTerminal';
 import { FSWatcher } from 'fs-extra';
 import { config, readContent, setContext, UriIcon } from './util';
-import { purgeAddinPickerItems, dispatchRStudioAPICall } from './rstudioapi';
+import { purgeAddinPickerItems } from './rstudioapi';
 
 import { IRequest } from './liveShare/shareSession';
 import { homeExtDir, rWorkspace, globalRHelp, globalHttpgdManager, extensionContext, sessionStatusBarItem } from './extension';
@@ -83,25 +83,59 @@ export function deploySessionWatcher(extensionPath: string): void {
     });
 }
 
-export function startRequestWatcher(sessionStatusBarItem: StatusBarItem): void {
-    console.info('[startRequestWatcher] Starting');
-    requestFile = path.join(homeExtDir(), 'request.log');
-    requestLockFile = path.join(homeExtDir(), 'request.lock');
-    requestTimeStamp = 0;
-    responseTimeStamp = 0;
-    if (!fs.existsSync(requestLockFile)) {
-        fs.createFileSync(requestLockFile);
-    }
-    fs.watch(requestLockFile, {}, () => {
-        void updateRequest(sessionStatusBarItem);
-    });
-    console.info('[startRequestWatcher] Done');
+import * as WebSocket from 'ws';
+
+let wsClient: WebSocket.WebSocket | undefined;
+
+export function startSessionWatcher(port: number, token: string): void {
+    console.info(`[startSessionWatcher] Connecting to ws://127.0.0.1:${port}?token=${token}`);
+    
+    let retries = 0;
+    const connect = () => {
+        const url = `ws://127.0.0.1:${port}?token=${token}`;
+        const ws = new WebSocket.WebSocket(url);
+        
+        ws.on('open', () => {
+            console.info('[startSessionWatcher] Connected');
+            wsClient = ws;
+            server = { host: '127.0.0.1', port, token };
+            retries = 0;
+        });
+        
+        ws.on('message', (data: WebSocket.Data) => {
+            void (async () => {
+                try {
+                    const message = JSON.parse(data.toString()) as Record<string, unknown>;
+                    if (!message.id) {
+                        await handleNotification(message);
+                    } else {
+                        await handleRequest(message, ws);
+                    }                } catch (e) {
+                    console.error('[startSessionWatcher] Error handling message', e);
+                }
+            })();
+        });
+        
+        ws.on('close', () => {
+            console.info('[startSessionWatcher] Disconnected');
+            wsClient = undefined;
+        });
+        
+        ws.on('error', (err: Error) => {
+            if (retries < 10 && !wsClient) {
+                retries++;
+                setTimeout(connect, 500);
+            }
+        });
+    };
+    
+    connect();
 }
 
 export function attachActive(): void {
     if (config().get<boolean>('sessionWatcher')) {
         console.info('[attachActive]');
-        void runTextInTerm('.vsc.attach()');
+        void runTextInTerm('if (requireNamespace("sess", quietly = TRUE)) sess::sess_app()');
         if (isLiveShare() && shareWorkspace) {
             rHostService?.notifyRequest(requestFile, true);
         }
@@ -145,47 +179,16 @@ function writeSettings() {
 
 function updateSessionWatcher() {
     console.info(`[updateSessionWatcher] PID: ${pid}`);
-    console.info('[updateSessionWatcher] Create workspaceWatcher');
-    workspaceFile = path.join(sessionDir, 'workspace.json');
-    workspaceLockFile = path.join(sessionDir, 'workspace.lock');
-    workspaceTimeStamp = 0;
-    if (workspaceWatcher !== undefined) {
-        workspaceWatcher.close();
-    }
-    if (fs.existsSync(workspaceLockFile)) {
-        workspaceWatcher = fs.watch(workspaceLockFile, {}, () => {
-            void updateWorkspace();
-        });
-        void updateWorkspace();
-    } else {
-        console.info('[updateSessionWatcher] workspaceLockFile not found');
-    }
-
-    console.info('[updateSessionWatcher] Create plotWatcher');
-    plotFile = path.join(sessionDir, 'plot.png');
-    plotLockFile = path.join(sessionDir, 'plot.lock');
-    plotTimeStamp = 0;
-    if (plotWatcher !== undefined) {
-        plotWatcher.close();
-    }
-    if (fs.existsSync(plotLockFile)) {
-        plotWatcher = fs.watch(plotLockFile, {}, () => {
-            void updatePlot();
-        });
-        void updatePlot();
-    } else {
-        console.info('[updateSessionWatcher] plotLockFile not found');
-    }
     console.info('[updateSessionWatcher] Done');
 }
 
 async function updatePlot() {
-    console.info(`[updatePlot] ${plotFile}`);
-    const lockContent = await fs.readFile(plotLockFile, 'utf8');
-    const newTimeStamp = Number.parseFloat(lockContent);
-    if (newTimeStamp !== plotTimeStamp) {
-        plotTimeStamp = newTimeStamp;
-        if (fs.existsSync(plotFile) && fs.statSync(plotFile).size > 0) {
+    if (!server) {return;}
+    try {
+        const response = await sessionRequest(server, { jsonrpc: '2.0', id: 1, method: 'plot_latest' });
+        if (response && (response as Record<string, unknown>).data) {
+            const plotFile = path.join(sessionDir, 'plot.png');
+            fs.writeFileSync(plotFile, Buffer.from((response as Record<string, unknown>).data as string, 'base64'));
             void commands.executeCommand('vscode.open', Uri.file(plotFile), {
                 preserveFocus: true,
                 preview: true,
@@ -195,30 +198,26 @@ async function updatePlot() {
             if (isLiveShare()) {
                 void rHostService?.notifyPlot(plotFile);
             }
-        } else {
-            console.info('[updatePlot] File not found');
         }
+    } catch (e) {
+        console.error(e);
     }
 }
 
-async function updateWorkspace() {
-    console.info(`[updateWorkspace] ${workspaceFile}`);
-
-    const lockContent = await fs.readFile(workspaceLockFile, 'utf8');
-    const newTimeStamp = Number.parseFloat(lockContent);
-    if (newTimeStamp !== workspaceTimeStamp) {
-        workspaceTimeStamp = newTimeStamp;
-        if (fs.existsSync(workspaceFile)) {
-            const content = await fs.readFile(workspaceFile, 'utf8');
-            workspaceData = JSON.parse(content) as WorkspaceData;
+export async function updateWorkspace() {
+    if (!server) {return;}
+    try {
+        const response = await sessionRequest(server, { jsonrpc: '2.0', id: 1, method: 'workspace' });
+        if (response) {
+            workspaceData = response as WorkspaceData;
             void rWorkspace?.refresh();
             console.info('[updateWorkspace] Done');
             if (isLiveShare()) {
                 rHostService?.notifyWorkspace(workspaceData);
             }
-        } else {
-            console.info('[updateWorkspace] File not found');
         }
+    } catch (e) {
+        console.error(e);
     }
 }
 
@@ -715,129 +714,159 @@ function isFromWorkspace(dir: string) {
 }
 
 export async function writeResponse(responseData: Record<string, unknown>, responseSessionDir: string): Promise<void> {
-
-    const responseFile = path.join(responseSessionDir, 'response.log');
-    const responseLockFile = path.join(responseSessionDir, 'response.lock');
-    if (!fs.existsSync(responseFile) || !fs.existsSync(responseLockFile)) {
-        throw ('Received a request from R for response' +
-            'to a session directiory that does not contain response.log or response.lock: ' +
-            responseSessionDir);
-    }
-    const responseString = JSON.stringify(responseData);
-    console.info('[writeResponse] Started');
-    console.info(`[writeResponse] responseData ${responseString}`);
-    console.info(`[writeRespnse] responseFile: ${responseFile}`);
-    await fs.writeFile(responseFile, responseString);
-    responseTimeStamp = Date.now();
-    await fs.writeFile(responseLockFile, `${responseTimeStamp}\n`);
+    // Deprecated
 }
 
 export async function writeSuccessResponse(responseSessionDir: string): Promise<void> {
-    await writeResponse({ result: true }, responseSessionDir);
+    // Deprecated
 }
 
-type ISessionRequest = {
-    plot_url?: string,
-    server?: SessionServer
-} & IRequest;
-
-async function updateRequest(sessionStatusBarItem: StatusBarItem) {
-    console.info('[updateRequest] Started');
-    console.info(`[updateRequest] requestFile: ${requestFile}`);
-
-    const lockContent = await fs.readFile(requestLockFile, 'utf8');
-    const newTimeStamp = Number.parseFloat(lockContent);
-    if (newTimeStamp !== requestTimeStamp) {
-        requestTimeStamp = newTimeStamp;
-        const requestContent = await fs.readFile(requestFile, 'utf8');
-        console.info(`[updateRequest] request: ${requestContent}`);
-        const request = JSON.parse(requestContent) as ISessionRequest;
-        if (request.wd && isFromWorkspace(request.wd)) {
-            if (request.uuid === null || request.uuid === undefined || request.uuid === UUID) {
-                switch (request.command) {
-                    case 'help': {
-                        if (globalRHelp && request.requestPath) {
-                            console.log(request.requestPath);
-                            await globalRHelp.showHelpForPath(request.requestPath, request.viewer);
-                        }
-                        break;
-                    }
-                    case 'httpgd': {
-                        if (request.url) {
-                            await globalHttpgdManager?.showViewer(request.url);
-                        }
-                        break;
-                    }
-                    case 'attach': {
-                        if (!request.tempdir || !request.wd) {
-                            return;
-                        }
-                        rVer = String(request.version);
-                        pid = String(request.pid);
-                        info = request.info;
-                        sessionDir = path.join(request.tempdir, 'vscode-R');
-                        workingDir = request.wd;
-                        console.info(`[updateRequest] attach PID: ${pid}`);
-                        sessionStatusBarItem.text = `R ${rVer}: ${pid}`;
-                        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions, @typescript-eslint/no-unsafe-member-access
-                        sessionStatusBarItem.tooltip = `${info?.version}\nProcess ID: ${pid}\nCommand: ${info?.command}\nStart time: ${info?.start_time}\nClick to attach to active terminal.`;
-                        sessionStatusBarItem.show();
-                        updateSessionWatcher();
-
-                        if (request.server) {
-                            server = request.server;
-                        }
-
-                        purgeAddinPickerItems();
-                        await setContext('rSessionActive', true);
-                        if (request.plot_url) {
-                            await globalHttpgdManager?.showViewer(request.plot_url);
-                        }
-                        void watchProcess(pid).then((v: string) => {
-                            void cleanupSession(v);
-                        });
-                        break;
-                    }
-                    case 'detach': {
-                        if (request.pid) {
-                            await cleanupSession(request.pid);
-                        }
-                        break;
-                    }
-                    case 'browser': {
-                        if (request.url && request.title && request.viewer !== undefined) {
-                            await showBrowser(request.url, request.title, request.viewer);
-                        }
-                        break;
-                    }
-                    case 'webview': {
-                        if (request.file && request.title && request.viewer !== undefined) {
-                            await showWebView(request.file, request.title, request.viewer);
-                        }
-                        break;
-                    }
-                    case 'dataview': {
-                        if (request.source && request.type && request.file && request.title && request.viewer !== undefined) {
-                            await showDataView(request.source,
-                                request.type, request.title, request.file, request.viewer);
-                        }
-                        break;
-                    }
-                    case 'rstudioapi': {
-                        if (request.action && request.args && request.sd) {
-                            await dispatchRStudioAPICall(request.action, request.args, request.sd);
-                        }
-                        break;
-                    }
-                    default:
-                        console.error(`[updateRequest] Unsupported command: ${request.command}`);
-                }
+import * as rstudioapi from './rstudioapi';
+
+async function handleNotification(message: Record<string, unknown>) {
+    const method = String(message.method);
+    const params = (message.params as Record<string, unknown>) || {};
+    
+    switch (method) {
+        case 'attach': {
+            if (!params.tempdir || !params.wd) {return;}
+            rVer = String(params.version);
+            pid = String(params.pid);
+            info = params.info;
+            sessionDir = path.join(String(params.tempdir), 'vscode-R');
+            workingDir = String(params.wd);
+            console.info(`[startSessionWatcher] attach PID: ${pid}`);
+            if (sessionStatusBarItem) {
+                sessionStatusBarItem.text = `R ${rVer}: ${pid}`;
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/restrict-template-expressions
+                sessionStatusBarItem.tooltip = `${info?.version}\nProcess ID: ${pid}\nCommand: ${info?.command}\nStart time: ${info?.start_time}\nClick to attach to active terminal.`;
+                sessionStatusBarItem.show();
             }
-        } else {
-            console.info(`[updateRequest] Ignored request outside workspace`);
+            purgeAddinPickerItems();
+            await setContext('rSessionActive', true);
+            if (params.plot_url) {
+                await globalHttpgdManager?.showViewer(String(params.plot_url));
+            }
+            void watchProcess(pid).then((v: string) => { void cleanupSession(v); });
+            break;
+        }
+        case 'detach': {
+            if (params.pid) {
+                await cleanupSession(String(params.pid));
+            }
+            break;
         }
-        if (isLiveShare()) {
-            void rHostService?.notifyRequest(requestFile);
+        case 'help': {
+            if (globalRHelp && params.requestPath) {
+                await globalRHelp.showHelpForPath(String(params.requestPath), params.viewer);
+            }
+            break;
+        }
+        case 'httpgd': {
+            if (params.url) {
+                await globalHttpgdManager?.showViewer(String(params.url));
+            }
+            break;
+        }
+        case 'browser': {
+            if (params.url && params.title && params.viewer !== undefined) {
+                await showBrowser(String(params.url), String(params.title), params.viewer as string | boolean);
+            }
+            break;
+        }
+        case 'webview': {
+            if (params.file && params.title && params.viewer !== undefined) {
+                await showWebView(String(params.file), String(params.title), params.viewer as string | boolean);
+            }
+            break;
+        }
+        case 'dataview': {
+            if (params.source && params.type && params.file && params.title && params.viewer !== undefined) {
+                await showDataView(String(params.source), String(params.type), String(params.title), String(params.file), String(params.viewer));
+            }
+            break;
+        }
+        case 'plot_updated': {
+            void updatePlot();
+            break;
+        }
+        case 'restart_r': {
+            await restartRTerminal();
+            break;
+        }
+        case 'send_to_console': {
+            await rstudioapi.sendCodeToRTerminal(String(params.code), Boolean(params.execute), Boolean(params.focus));
+            break;
+        }
+        default:
+            console.error(`[startSessionWatcher] Unsupported notification method: ${method}`);
+    }
+}
+
+async function handleRequest(message: Record<string, unknown>, ws: WebSocket.WebSocket) {
+    if (message.method) {
+        const method = String(message.method);
+        const params = (message.params as Record<string, unknown>) || {};
+        let result: unknown = null;
+        let error: unknown = null;
+        
+        try {
+            switch (method) {
+                case 'active_editor_context':
+                    result = rstudioapi.activeEditorContext();
+                    break;
+                case 'insert_or_modify_text':
+                    await rstudioapi.insertOrModifyText(params.query as any[], String(params.id));
+                    result = true;
+                    break;
+                case 'replace_text_in_current_selection':
+                    await rstudioapi.replaceTextInCurrentSelection(String(params.text), String(params.id));
+                    result = true;
+                    break;
+                case 'show_dialog':
+                    rstudioapi.showDialog(String(params.message));
+                    result = true;
+                    break;
+                case 'navigate_to_file':
+                    await rstudioapi.navigateToFile(String(params.file), Number(params.line), Number(params.column));
+                    result = true;
+                    break;
+                case 'set_selection_ranges':
+                    await rstudioapi.setSelections(params.ranges as number[][], String(params.id));
+                    result = true;
+                    break;
+                case 'document_save':
+                    await rstudioapi.documentSave(String(params.id));
+                    result = true;
+                    break;
+                case 'document_save_all':
+                    await rstudioapi.documentSaveAll();
+                    result = true;
+                    break;
+                case 'get_project_path':
+                    result = rstudioapi.projectPath();
+                    break;
+                case 'document_context':
+                    result = await rstudioapi.documentContext(String(params.id));
+                    break;
+                case 'document_new':
+                    await rstudioapi.documentNew(String(params.text), String(params.type), params.position as number[]);
+                    result = true;
+                    break;
+                default:
+                    throw new Error(`Unsupported method: ${method}`);
+            }
+        } catch (e) {
+            error = { code: -32603, message: String(e) };
+        }
+        
+        if (ws.readyState === ws.OPEN) {
+            ws.send(JSON.stringify({
+                jsonrpc: '2.0',
+                id: message.id,
+                result: result,
+                error: error
+            }));
         }
     }
 }
@@ -881,10 +910,14 @@ async function watchProcess(pid: string): Promise<string> {
     return pid;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export async function sessionRequest(server: SessionServer, data: any): Promise<any> {
+export async function sessionRequest(server: SessionServer, data: Record<string, unknown>): Promise<unknown> {
     try {
-        const response = await fetch(`http://${server.host}:${server.port}`, {
+        const payload = data.jsonrpc ? data : {
+            jsonrpc: '2.0',
+            id: Math.floor(Math.random() * 1000000),
+            ...data
+        };
+        const response = await fetch(`http://${server.host}:${server.port}/rpc`, {
             agent: httpAgent,
             method: 'POST',
             headers: {
@@ -892,7 +925,7 @@ export async function sessionRequest(server: SessionServer, data: any): Promise<
                 Accept: 'application/json',
                 Authorization: server.token
             },
-            body: JSON.stringify(data),
+            body: JSON.stringify(payload),
             follow: 0,
             timeout: 500,
         });
@@ -901,7 +934,8 @@ export async function sessionRequest(server: SessionServer, data: any): Promise<
             throw new Error(`Error! status: ${response.status}`);
         }
 
-        return response.json();
+        const res = await response.json() as Record<string, unknown>;
+        return res.result !== undefined ? res.result : res;
     } catch (error) {
         if (error instanceof Error) {
             console.log('error message: ', error.message);

From 41c34b959968cdd77aa3a6a0468decb24ae9d45c Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Wed, 11 Mar 2026 21:57:47 -0700
Subject: [PATCH 13/47] feat: enhance R data viewer and hook registration

- Improve View() hook with support for Arrow tables and lists
- Add alignment and title support to data viewer webview
- Update session hooks to respect viewer options
- Disable Gemini extension in debug mode
---
 .vscode/launch.json |   3 +-
 sess/R/hooks.R      | 206 ++++++++++++++++++++++++++++++++++++--------
 sess/R/server.R     |  43 +++++----
 session.md          |   4 +-
 src/session.ts      |  32 ++++---
 5 files changed, 219 insertions(+), 69 deletions(-)

diff --git a/.vscode/launch.json b/.vscode/launch.json
index e15cf371..41ef5781 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -10,7 +10,8 @@
       "request": "launch",
       "runtimeExecutable": "${execPath}",
       "args": [
-        "--extensionDevelopmentPath=${workspaceFolder}"
+        "--extensionDevelopmentPath=${workspaceFolder}",
+        "--disable-extension", "google.geminicodeassist"
       ],
       "outFiles": [
         "${workspaceFolder}/out/src/**/*.js"
diff --git a/sess/R/hooks.R b/sess/R/hooks.R
index f1411e9e..48b610af 100644
--- a/sess/R/hooks.R
+++ b/sess/R/hooks.R
@@ -1,68 +1,206 @@
+dataview_data_type <- function(x) {
+  if (is.numeric(x)) {
+    if (is.null(attr(x, "class"))) {
+      "num"
+    } else {
+      "num-fmt"
+    }
+  } else if (inherits(x, "Date")) {
+    "date"
+  } else {
+    "string"
+  }
+}
+
+dataview_table <- function(data) {
+  if (is.data.frame(data)) {
+    nrow <- nrow(data)
+    colnames <- colnames(data)
+    if (is.null(colnames)) {
+      colnames <- sprintf("(X%d)", seq_len(ncol(data)))
+    } else {
+      colnames <- trimws(colnames)
+    }
+    if (.row_names_info(data) > 0L) {
+      rownames <- rownames(data)
+      rownames(data) <- NULL
+    } else {
+      rownames <- seq_len(nrow)
+    }
+    data <- c(list(" " = rownames), .subset(data))
+    colnames <- c(" ", colnames)
+    types <- vapply(data, dataview_data_type,
+      character(1L),
+      USE.NAMES = FALSE
+    )
+    data <- vapply(data, function(x) {
+      trimws(format(x))
+    }, character(nrow), USE.NAMES = FALSE)
+    dim(data) <- c(length(rownames), length(colnames))
+  } else if (is.matrix(data)) {
+    if (is.factor(data)) {
+      data <- format(data)
+    }
+    types <- rep(dataview_data_type(data), ncol(data))
+    colnames <- colnames(data)
+    colnames(data) <- NULL
+    if (is.null(colnames)) {
+      colnames <- sprintf("(X%d)", seq_len(ncol(data)))
+    } else {
+      colnames <- trimws(colnames)
+    }
+    rownames <- rownames(data)
+    rownames(data) <- NULL
+    data <- trimws(format(data))
+    if (is.null(rownames)) {
+      types <- c("num", types)
+      rownames <- seq_len(nrow(data))
+    } else {
+      types <- c("string", types)
+      rownames <- trimws(rownames)
+    }
+    dim(data) <- c(length(rownames), length(colnames))
+    colnames <- c(" ", colnames)
+    data <- cbind(rownames, data)
+  } else {
+    stop("data must be data.frame or matrix")
+  }
+  columns <- .mapply(function(title, type, index) {
+    class <- if (type == "string") "text-left" else "text-right"
+    list(
+      headerName = jsonlite::unbox(title),
+      field = jsonlite::unbox(as.character(index - 1L)),
+      cellClass = jsonlite::unbox(class),
+      type = jsonlite::unbox(if (type == "date") "dateColumn" else type)
+    )
+  }, list(colnames, types, seq_along(colnames)), NULL)
+  list(columns = columns, data = data)
+}
+
 #' Register hooks for the client IPC
 #'
 #' @param use_rstudioapi Logical. Enable rstudioapi emulation.
 #' @param use_httpgd Logical. Enable httpgd plot device if available.
 #' @export
 register_hooks <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
-  
   # 1. Override View() to push data directly via WebSocket
-  rebind("View", function(x, title = deparse(substitute(x))) {
+  show_dataview <- function(x, title = deparse(substitute(x))) {
+    # make sure title is computed.
+    force(title)
     # Dump to a temporary file locally so the payload size over WS isn't massive
     file_path <- tempfile(fileext = ".json")
-    jsonlite::write_json(as.data.frame(x), file_path, auto_unbox = TRUE, null = "null", na = "string")
-    
-    notify_client("dataview", list(
-      title = title,
-      file = file_path,
-      source = "table",
-      type = "json"
-    ))
-  }, ns = "utils")
-  
+
+    row_limit <- abs(getOption("sess.row_limit", 100))
+
+    as_truncated_data <- function(.data) {
+      .nrow <- nrow(.data)
+      if (row_limit != 0 && row_limit < .nrow) {
+        title <<- sprintf("%s (limited to %d/%d)", title, row_limit, .nrow)
+        .data <- utils::head(.data, n = row_limit)
+      }
+      return(.data)
+    }
+
+    if (inherits(x, "ArrowTabular")) {
+      x <- as_truncated_data(x)
+      x <- as.data.frame(x)
+    }
+
+    if (is.data.frame(x) || is.matrix(x)) {
+      x <- as_truncated_data(x)
+      data <- dataview_table(x)
+      jsonlite::write_json(
+        data, file_path,
+        matrix = "rowmajor", auto_unbox = TRUE, null = "null", na = "string"
+      )
+
+      notify_client("dataview", list(
+        title = title,
+        file = file_path,
+        source = "table",
+        type = "json",
+        viewer = getOption("sess.dataview", "Two")
+      ))
+    } else if (is.list(x)) {
+      jsonlite::write_json(x, file_path, auto_unbox = TRUE, null = "null", na = "string")
+      notify_client("dataview", list(
+        title = title,
+        file = file_path,
+        source = "list",
+        type = "json",
+        viewer = getOption("sess.dataview", "Two")
+      ))
+    } else {
+      code <- if (is.primitive(x)) utils::capture.output(print(x)) else deparse(x)
+      file_path <- tempfile(fileext = ".R")
+      writeLines(code, file_path)
+      notify_client("dataview", list(
+        title = title,
+        file = file_path,
+        source = "object",
+        type = "R",
+        viewer = getOption("sess.dataview", "Two")
+      ))
+    }
+  }
+  rebind("View", show_dataview, ns = "utils")
+
   # 2. Browser & Webview Options
   show_browser <- function(url, title = url, ...) {
-    notify_client("browser", list(url = url, title = title))
+    notify_client("browser", list(url = url, title = title, viewer = getOption("sess.browser", "Active")))
   }
-  
+
   show_webview <- function(url, title = "WebView", ...) {
     # If the URL is a local file, normalize its path for the webview
     if (file.exists(url)) {
       url <- normalizePath(url, "/", mustWork = TRUE)
     }
-    notify_client("webview", list(file = url, title = title))
+    notify_client("webview", list(file = url, title = title, viewer = getOption("sess.webview", "Two")))
   }
-  
+
+  show_page_viewer <- function(url, title = "Page Viewer", ...) {
+    if (file.exists(url)) {
+      url <- normalizePath(url, "/", mustWork = TRUE)
+    }
+    notify_client("webview", list(file = url, title = title, viewer = getOption("sess.page_viewer", "Active")))
+  }
+
   options(
     browser = show_browser,
     viewer = show_webview,
-    page_viewer = show_webview,
+    page_viewer = show_page_viewer,
     help_type = "html"
   )
 
   # 3. Help System Interception
-  rebind("print.help_files_with_topic", function(x, ...) {
+  sess_print.help_files_with_topic <- function(x, ...) {
     if (length(x) >= 1 && is.character(x)) {
-        file <- x[1]
-        pkgname <- basename(dirname(dirname(file)))
-        requestPath <- paste0("/library/", pkgname, "/html/", basename(file), ".html")
-        notify_client("help", list(requestPath = requestPath))
+      file <- x[1]
+      pkgname <- basename(dirname(dirname(file)))
+      requestPath <- paste0("/library/", pkgname, "/html/", basename(file), ".html")
+      notify_client("help", list(requestPath = requestPath, viewer = getOption("sess.helpPanel", "Two")))
+    } else {
+      utils:::print.help_files_with_topic(x, ...)
     }
     invisible(x)
-  }, ns = "utils")
-  
-  rebind("print.hsearch", function(x, ...) {
+  }
+  registerS3method("print", "help_files_with_topic", sess_print.help_files_with_topic, envir = asNamespace("utils"))
+
+  sess_print.hsearch <- function(x, ...) {
     if (length(x) >= 1) {
-        requestPath <- paste0("/doc/html/Search?pattern=", tools:::escapeAmpersand(x$pattern))
-        notify_client("help", list(requestPath = requestPath))
+      requestPath <- paste0("/doc/html/Search?pattern=", tools:::escapeAmpersand(x$pattern))
+      notify_client("help", list(requestPath = requestPath, viewer = getOption("sess.helpPanel", "Two")))
+    } else {
+      utils:::print.hsearch(x, ...)
     }
     invisible(x)
-  }, ns = "utils")
+  }
 
   # 4. httpgd or Static Plot Hook
   if (use_httpgd && requireNamespace("httpgd", quietly = TRUE)) {
     options(device = function(...) {
-        httpgd::hgd(silent = TRUE)
-        notify_client("httpgd", list(url = httpgd::hgd_url()))
+      httpgd::hgd(silent = TRUE)
+      notify_client("httpgd", list(url = httpgd::hgd_url()))
     })
   } else {
     # Default to static plot capturing
@@ -73,7 +211,7 @@ register_hooks <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
     setHook("plot.new", function(...) {
       notify_client("plot_updated")
     }, "replace")
-    
+
     setHook("grid.newpage", function(...) {
       notify_client("plot_updated")
     }, "replace")
@@ -84,9 +222,9 @@ register_hooks <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
     setHook(packageEvent("rstudioapi", "onLoad"), function(...) {
       patch_rstudioapi()
     }, action = "append")
-    
+
     if ("rstudioapi" %in% loadedNamespaces()) {
-        patch_rstudioapi()
+      patch_rstudioapi()
     }
   }
-}
\ No newline at end of file
+}
diff --git a/sess/R/server.R b/sess/R/server.R
index 1fdb4334..47ac5df8 100644
--- a/sess/R/server.R
+++ b/sess/R/server.R
@@ -1,21 +1,20 @@
 #' Start the client R IPC Server
-#' 
+#'
 #' @param use_rstudioapi Logical. Should the rstudioapi emulation layer be enabled? Defaults to TRUE.
 #' @param use_httpgd Logical. Should httpgd be used for plotting if available? Defaults to TRUE
 #' @export
 sess_app <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
-  
   # Initialize state
   .sess_env$server <- NULL
   .sess_env$ws <- NULL
-  
+
   env_token <- Sys.getenv("SESS_TOKEN")
   .sess_env$token <- if (nzchar(env_token)) env_token else paste0(sample(c(letters, 0:9), 32, replace = TRUE), collapse = "")
   .sess_env$pending_responses <- list()
-  
+
   # Temporary file for static plot serving
   .sess_env$latest_plot_path <- file.path(tempdir(), "sess_plot.png")
-  
+
   app_handlers <- list(
     # --- HTTP HANDLER (The "Pull" API) ---
     call = function(req) {
@@ -26,12 +25,12 @@ sess_app <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
       }
 
       path <- req$PATH_INFO
-      
+
       # 2. Routing
       if (path == "/rpc" && req$REQUEST_METHOD == "POST") {
         # JSON-RPC 2.0 Implementation
         body <- tryCatch(jsonlite::fromJSON(req$rook.input$read_lines()), error = function(e) NULL)
-        
+
         if (is.null(body) || is.null(body$method)) {
           return(json_rpc_error(NULL, -32600, "Invalid Request"))
         }
@@ -57,7 +56,7 @@ sess_app <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
         }
 
         return(json_rpc_response(body$id, res))
-      } 
+      }
 
       list(status = 404L, headers = list("Content-Type" = "text/plain"), body = "Not Found")
     },
@@ -66,7 +65,7 @@ sess_app <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
     onWSOpen = function(ws) {
       # Bind the active websocket to our environment
       .sess_env$ws <- ws
-      
+
       # Send the attach handshake immediately upon connection (JSON-RPC Notification)
       notify_client("attach", list(
         version = sprintf("%s.%s", R.version$major, R.version$minor),
@@ -74,26 +73,26 @@ sess_app <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
         tempdir = tempdir(),
         wd = getwd(),
         info = list(
-            command = commandArgs()[[1L]],
-            version = R.version.string,
-            start_time = format(Sys.time())
+          command = commandArgs()[[1L]],
+          version = R.version.string,
+          start_time = format(Sys.time())
         )
       ))
 
       ws$onMessage(function(binary, message) {
         # Handle JSON-RPC 2.0 messages COMING FROM the client
         payload <- tryCatch(jsonlite::fromJSON(message), error = function(e) NULL)
-        
+
         if (!is.null(payload) && !is.null(payload$id)) {
-           # It's a Response (to our RStudio API request)
-           if (!is.null(payload$result)) {
-             .sess_env$pending_responses[[as.character(payload$id)]] <- payload$result
-           } else if (!is.null(payload$error)) {
-             .sess_env$pending_responses[[as.character(payload$id)]] <- structure(payload$error, class = "json_rpc_error")
-           }
+          # It's a Response (to our RStudio API request)
+          if (!is.null(payload$result)) {
+            .sess_env$pending_responses[[as.character(payload$id)]] <- payload$result
+          } else if (!is.null(payload$error)) {
+            .sess_env$pending_responses[[as.character(payload$id)]] <- structure(payload$error, class = "json_rpc_error")
+          }
         }
       })
-      
+
       ws$onClose(function() {
         .sess_env$ws <- NULL
       })
@@ -104,10 +103,10 @@ sess_app <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
   env_port <- Sys.getenv("SESS_PORT")
   port <- if (nzchar(env_port)) as.integer(env_port) else httpuv::randomPort()
   .sess_env$server <- httpuv::startServer("127.0.0.1", port, app = app_handlers)
-  
+
   # Print the connection string to the console.
   cat(sprintf("\n[sess] SESS_IPC_SERVER=ws://127.0.0.1:%d?token=%s\n", port, .sess_env$token))
-  
+
   # Register runtime hooks
   register_hooks(use_rstudioapi = use_rstudioapi, use_httpgd = use_httpgd)
 }
diff --git a/session.md b/session.md
index 7f6cc950..fe4df63c 100644
--- a/session.md
+++ b/session.md
@@ -233,9 +233,9 @@ export async function showDataView(source: string, type: string, title: string,
             { preserveFocus: true, viewColumn: ViewColumn[viewer as keyof typeof ViewColumn] },
             { enableScripts: true, enableFindWidget: true, retainContextWhenHidden: true, localResourceRoots: [Uri.file(resDir)] });
         panel.iconPath = new UriIcon('open-preview');
-        panel.webview.html = await getTableHtml(panel.webview, file);
+        panel.webview.html = await getTableHtml(panel.webview, file, title);
     } else if (source === 'list') {
-        // similar to table, but calls getListHtml
+        // similar to table, but calls getListHtml(panel.webview, file, title)
     } else {
         // Fallback for raw text 'object'
         await commands.executeCommand('vscode.open', Uri.file(file), {
diff --git a/src/session.ts b/src/session.ts
index 61880d48..faf59f22 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -352,7 +352,7 @@ export async function showDataView(source: string, type: string, title: string,
                 retainContextWhenHidden: true,
                 localResourceRoots: [Uri.file(resDir)],
             });
-        const content = await getTableHtml(panel.webview, file);
+        const content = await getTableHtml(panel.webview, file, title);
         panel.iconPath = new UriIcon('open-preview');
         panel.webview.html = content;
     } else if (source === 'list') {
@@ -367,7 +367,7 @@ export async function showDataView(source: string, type: string, title: string,
                 retainContextWhenHidden: true,
                 localResourceRoots: [Uri.file(resDir)],
             });
-        const content = await getListHtml(panel.webview, file);
+        const content = await getListHtml(panel.webview, file, title);
         panel.iconPath = new UriIcon('open-preview');
         panel.webview.html = content;
     } else {
@@ -387,7 +387,7 @@ export async function showDataView(source: string, type: string, title: string,
     console.info('[showDataView] Done');
 }
 
-export async function getTableHtml(webview: Webview, file: string): Promise<string> {
+export async function getTableHtml(webview: Webview, file: string, title: string): Promise<string> {
     resDir = isGuestSession ? guestResDir : resDir;
     const pageSize = config().get<number>('session.data.pageSize', 500);
     const content = await readContent(file, 'utf8');
@@ -397,6 +397,7 @@ export async function getTableHtml(webview: Webview, file: string): Promise<stri
 <head>
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>${title}</title>
     <style media="only screen">
     html, body {
         height: 100%;
@@ -488,6 +489,14 @@ export async function getTableHtml(webview: Webview, file: string): Promise<stri
     [class*="vscode"] input[class^=ag-] {
         border-color: var(--vscode-notificationCenter-border) !important;
     }
+
+    [class*="vscode"] .text-left {
+        text-align: left;
+    }
+
+    [class*="vscode"] .text-right {
+        text-align: right;
+    }
     </style>
     <script src="${String(webview.asWebviewUri(Uri.file(path.join(resDir, 'ag-grid-community.min.noStyle.js'))))}"></script>
     <link href="${String(webview.asWebviewUri(Uri.file(path.join(resDir, 'ag-grid.min.css'))))}" rel="stylesheet">
@@ -574,7 +583,7 @@ export async function getTableHtml(webview: Webview, file: string): Promise<stri
 `;
 }
 
-export async function getListHtml(webview: Webview, file: string): Promise<string> {
+export async function getListHtml(webview: Webview, file: string, title: string): Promise<string> {
     resDir = isGuestSession ? guestResDir : resDir;
     const content = await readContent(file, 'utf8');
 
@@ -584,6 +593,7 @@ export async function getListHtml(webview: Webview, file: string): Promise<strin
 <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>${title}</title>
     <script src="${String(webview.asWebviewUri(Uri.file(path.join(resDir, 'jquery.min.js'))))}"></script>
     <script src="${String(webview.asWebviewUri(Uri.file(path.join(resDir, 'jquery.json-viewer.js'))))}"></script>
     <link href="${String(webview.asWebviewUri(Uri.file(path.join(resDir, 'jquery.json-viewer.css'))))}" rel="stylesheet">
@@ -727,6 +737,8 @@ async function handleNotification(message: Record<string, unknown>) {
     const method = String(message.method);
     const params = (message.params as Record<string, unknown>) || {};
     
+    console.info(`[handleNotification] method: ${method}, params: ${JSON.stringify(params)}`);
+
     switch (method) {
         case 'attach': {
             if (!params.tempdir || !params.wd) {return;}
@@ -750,12 +762,12 @@ async function handleNotification(message: Record<string, unknown>) {
             void watchProcess(pid).then((v: string) => { void cleanupSession(v); });
             break;
         }
-        case 'detach': {
-            if (params.pid) {
-                await cleanupSession(String(params.pid));
-            }
-            break;
-        }
+        // case 'detach': {
+        //     if (params.pid) {
+        //         await cleanupSession(String(params.pid));
+        //     }
+        //     break;
+        // }
         case 'help': {
             if (globalRHelp && params.requestPath) {
                 await globalRHelp.showHelpForPath(String(params.requestPath), params.viewer);

From 1312329b33c3aee40caaf6af291d2bb088a29a0b Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Wed, 11 Mar 2026 23:09:22 -0700
Subject: [PATCH 14/47] restore: R/session/ files and fix browser rendering

- Restore legacy R/session/ files for backward compatibility
- Fix browser rendering issues by using simpleBrowser.show in showBrowser
---
 R/session/init.R            | 104 ++++
 R/session/profile.R         |  33 ++
 R/session/rstudioapi.R      | 315 ++++++++++++
 R/session/rstudioapi_util.R | 258 ++++++++++
 R/session/vsc.R             | 941 ++++++++++++++++++++++++++++++++++++
 src/session.ts              |  75 +--
 6 files changed, 1661 insertions(+), 65 deletions(-)
 create mode 100644 R/session/init.R
 create mode 100644 R/session/profile.R
 create mode 100644 R/session/rstudioapi.R
 create mode 100644 R/session/rstudioapi_util.R
 create mode 100644 R/session/vsc.R

diff --git a/R/session/init.R b/R/session/init.R
new file mode 100644
index 00000000..410263c2
--- /dev/null
+++ b/R/session/init.R
@@ -0,0 +1,104 @@
+# This file is executed with its containing directory as wd
+
+# Remember the working directory (should be extension subfolder that contains this script)
+dir_init <- getwd()
+
+
+# This function is run at the beginning of R's startup sequence
+# Code that is meant to be run at the end of the startup should go in `init_last`
+init_first <- function() {
+    # return early if not a vscode term session
+    if (
+        !interactive()
+        || Sys.getenv("RSTUDIO") != ""
+        || Sys.getenv("TERM_PROGRAM") != "vscode"
+    ) {
+        return()
+    }
+
+    # check required packages
+    required_packages <- c("jsonlite", "rlang")
+    missing_packages <- required_packages[
+        !vapply(required_packages, requireNamespace,
+            logical(1L), quietly = TRUE
+        )
+    ]
+
+    if (length(missing_packages)) {
+        message(
+            "VSCode R Session Watcher requires ",
+            toString(missing_packages), ". ",
+            "Please install manually in order to use VSCode-R."
+        )
+    } else {
+        # Initialize vsc utils after loading other default packages
+        assign(".First.sys", init_last, envir = globalenv())
+    }
+}
+
+old.First.sys <- .First.sys
+
+# Overwrite for `.First.sys`
+# Is used to make sure that all default packages are loaded first
+# Will be assigned to and called from the global environment,
+# Will be run with wd being the user's working directory (!)
+init_last <- function() {
+    old.First.sys()
+
+    # cleanup previous version
+    removeTaskCallback("vscode-R")
+    options(vscodeR = NULL)
+    .vsc.name <- "tools:vscode"
+    if (.vsc.name %in% search()) {
+        detach(.vsc.name, character.only = TRUE)
+    }
+
+    # Source vsc utils in new environmeent
+    .vsc <- new.env()
+    source(file.path(dir_init, "vsc.R"), local = .vsc)
+
+    # attach functions that are meant to be called by the user/vscode
+    exports <- local({
+        .vsc <- .vsc
+        .vsc.attach <- .vsc$attach
+        .vsc.view <- .vsc$show_dataview
+        .vsc.browser <- .vsc$show_browser
+        .vsc.viewer <- .vsc$show_viewer
+        .vsc.page_viewer <- .vsc$show_page_viewer
+        View <- .vsc.view
+        environment()
+    })
+    attach(exports, name = .vsc.name, warn.conflicts = FALSE)
+
+    # overwrite S3 bindings from other packages
+    suppressWarnings({
+        if (!identical(getOption("vsc.helpPanel", "Two"), FALSE)) {
+            # Overwrite print function for results of `?`
+            .vsc$.S3method(
+                "print",
+                "help_files_with_topic",
+                .vsc$print.help_files_with_topic
+            )
+            # Overwrite print function for results of `??`
+            .vsc$.S3method(
+                "print",
+                "hsearch",
+                .vsc$print.hsearch
+            )
+        }
+        # Further S3 overwrites can go here
+        # ...
+    })
+
+    # remove this function from globalenv()
+    suppressWarnings(
+        rm(".First.sys", envir = globalenv())
+    )
+
+    # Attach to vscode
+    exports$.vsc.attach()
+
+    invisible()
+}
+
+init_first()
diff --git a/R/session/profile.R b/R/session/profile.R
new file mode 100644
index 00000000..dafdf298
--- /dev/null
+++ b/R/session/profile.R
@@ -0,0 +1,33 @@
+# Source the original .Rprofile
+local({
+    try_source <- function(file) {
+        if (file.exists(file)) {
+            source(file)
+            TRUE
+        } else {
+            FALSE
+        }
+    }
+
+    r_profile <- Sys.getenv("R_PROFILE_USER_OLD")
+    Sys.setenv(
+        R_PROFILE_USER_OLD = "",
+        R_PROFILE_USER = r_profile
+    )
+
+    if (nzchar(r_profile)) {
+        try_source(r_profile)
+    } else {
+        try_source(".Rprofile") || try_source(file.path("~", ".Rprofile"))
+    }
+
+    invisible()
+})
+
+# Run vscode initializer
+local({
+    init_file <- Sys.getenv("VSCODE_INIT_R")
+    if (nzchar(init_file)) {
+        source(init_file, chdir = TRUE, local = TRUE)
+    }
+})
diff --git a/R/session/rstudioapi.R b/R/session/rstudioapi.R
new file mode 100644
index 00000000..60ea4358
--- /dev/null
+++ b/R/session/rstudioapi.R
@@ -0,0 +1,315 @@
+getActiveDocumentContext <- function() {
+    # In RStudio this returns either a document context for either the active
+    # source editor or active console.
+    # In VSCode this only ever returns the active (or last active) text editor.
+    # This is because it is currently not possible to tell in VSCode whether
+    # a text editor or terminal has focus. The concept of active is different.
+    # It means currently using or most recently used, and applies to text
+    # editors and terminals separately.
+    # This shoudln't be much of a limitation as the only context returned for
+    # the console was the current selection, so it is not very useful.
+    editor_context <- rstudioapi_call("active_editor_context")
+
+    make_rs_document_context(editor_context)
+}
+
+getSourceEditorContext <- getActiveDocumentContext
+
+verifyAvailable <- function(version_needed = NULL) {
+    if (is.null(version_needed)) TRUE else FALSE
+}
+
+isAvailable <- function(version_needed = NULL, child_ok) {
+    verifyAvailable(version_needed)
+}
+
+insertText <- function(location, text, id = NULL) {
+
+    ## insertText also supports insertText("text"), insertText(text = "text"),
+    ## allowing the location parameter to be used for the text when
+    ## text itself is null.
+    ## This is dispatched as a separate request type
+    if (missing(text) && is.character(location) && length(location) == 1) {
+        ## handling insertText("text")
+        return(invisible(
+            rstudioapi_call("replace_text_in_current_selection",
+                text = location,
+                id = id
+            )
+        ))
+    } else if (missing(location)) {
+        ## handling insertText(text = "text")
+        return(invisible(rstudioapi_call(
+            "replace_text_in_current_selection",
+            text = text,
+            id = id
+        )))
+    } else if (is.null(location) && missing(text)) {
+        ## handling insertText(NULL)
+        return(invisible(NULL))
+    }
+
+    ## ensure normalised_location is a list containing a possible mix of
+    ## document_position and document_range objects
+    normalised_location <- normalise_pos_or_range_arg(location)
+    normalised_text <- normalise_text_arg(text, length(normalised_location))
+    ## Having normalised we are guaranteed these are the same length.
+    ## Package up all the edits in a query to send to VSCode in an object
+    ## This is done so the edits can be applied in a single edit object, which
+    ## is hopefull closest to RStudio behaviour.
+    query <-
+        mapply(function(location, text) {
+            list(
+                operation = if (rstudioapi::is.document_range(location)) {
+                    "modifyRange"
+                } else {
+                    "insertText"
+                },
+                location = location,
+                text = text
+            )
+        },
+        normalised_location,
+        normalised_text,
+        SIMPLIFY = FALSE
+        )
+
+    invisible(
+        rstudioapi_call("insert_or_modify_text", query = query, id = id)
+    )
+}
+
+modifyRange <- insertText
+
+readPreference <- function(name, default) {
+    ## in future we could map some rstudio preferences to vscode settings.
+    ## since the caller must provide a default this should work.
+    default
+}
+
+readRStudioPreference <- readPreference
+
+.vsc_rstudioapi_env <- environment()
+
+hasFun <- function(name, version_needed = NULL, ...) {
+    if (!is.null(version_needed)) {
+        return(FALSE)
+    }
+
+    obj <- .vsc_rstudioapi_env[[name]]
+    is.function(obj) && !identical(obj, .vsc_not_yet_implemented)
+}
+
+findFun <- function(name, version_needed = NULL, ...) {
+    if (!is.null(version_needed)) {
+        stop("VSCode does not support used of 'version_needed'.")
+    }
+
+    if (hasFun(name, version_needed = version_needed, ...)) {
+        .vsc_rstudioapi_env[[name]]
+    } else {
+        stop("Cannot find function '", name, "'")
+    }
+}
+
+showDialog <- function(title, message, url = "") {
+    message <- sprintf("%s: %s \n%s", title, message, url)
+    invisible(
+        rstudioapi_call("show_dialog", message = message)
+    )
+}
+
+navigateToFile <- function(file, line = -1L, column = -1L) {
+    # normalise path since relative paths don't work as URIs in VSC
+    invisible(
+        rstudioapi_call(
+            "navigate_to_file",
+            file = normalizePath(file),
+            line = line,
+            column = column
+        )
+    )
+}
+
+setSelectionRanges <- function(ranges, id = NULL) {
+    ranges_or_positions <- normalise_pos_or_range_arg(ranges)
+
+    ranges <- lapply(ranges_or_positions, function(location) {
+        if (rstudioapi::is.document_position(location)) {
+            rstudioapi::document_range(location, location)
+        } else {
+            location
+        }
+    })
+
+    invisible(
+        rstudioapi_call("set_selection_ranges", ranges = ranges, id = id)
+    )
+}
+
+setCursorPosition <- setSelectionRanges
+
+documentSave <- function(id = NULL) {
+    invisible(
+        rstudioapi_call("document_save", id = id)
+    )
+}
+
+getActiveProject <- function() {
+    path_object <- rstudioapi_call("get_project_path")
+    if (is.null(path_object$path)) {
+        stop(
+            "No folder for active document. ",
+            "Is it unsaved? Try saving and run addin again."
+        )
+    }
+    path_object$path
+}
+
+.vsc_document_context <- function(id = NULL) {
+    doc_context <- rstudioapi_call("document_context", id = id)
+    doc_context
+}
+
+documentId <- function(allowConsole = TRUE) document_context()$id$external
+
+documentPath <- function(id = NULL) document_context(id)$id$path
+
+documentSaveAll <- function() {
+    invisible(
+        rstudioapi_call("document_save_all")
+    )
+}
+
+documentNew <- function(text,
+                        type = c("r", "rmarkdown", "sql"),
+                        position = rstudioapi::document_position(0, 0),
+                        execute = FALSE) {
+    if (!rstudioapi::is.document_position((position))) {
+        stop("DocumentNew requires a document_position object")
+    }
+    if (length(text) != 1 || !is.character(text)) {
+        stop("text for DocumentNew must be a length one character vector.")
+    }
+    if (execute) {
+        message(
+            "VSCode {rstudioapi} emulation does not support ",
+            " executing documents upon creation"
+        )
+    }
+
+    invisible(
+        rstudioapi_call(
+            "document_new",
+            text = text,
+            type = type,
+            position = position
+        )
+    )
+}
+
+setDocumentContents <- function(text, id = NULL) {
+    whole_document_range <-
+        rstudioapi::document_range(
+            rstudioapi::document_position(0, 0),
+            rstudioapi::document_position(Inf, Inf)
+        )
+    insertText(whole_document_range, text, id)
+}
+
+restartSession <- function() {
+    invisible(
+        rstudioapi_call("restart_r")
+    )
+}
+
+viewer <- function(url, height = NULL) {
+    # cant bind to this directly because it's not created when the binding is
+    # made.
+    .vsc.viewer(url)
+}
+
+getVersion <- function() {
+    numeric_version("0")
+}
+
+versionInfo <- function() {
+    list(
+        citation = "",
+        mode = "vscode",
+        version = numeric_version("0"),
+        release_name = "vscode"
+    )
+}
+
+sendToConsole <- function(code, execute = TRUE, echo = TRUE, focus = FALSE) {
+    if (!echo) {
+        stop("rstudioapi::sendToConsole only supports echo = TRUE in VSCode.")
+    }
+
+    code_to_run <- paste0(code, collapse = "\n")
+    invisible(
+        rstudioapi_call("send_to_console", code = code_to_run, execute = execute, focus = focus)
+    )
+}
+
+
+# Unimplemented API calls that will error if called.
+
+.vsc_not_yet_implemented <- function(...) {
+    stop("This {rstudioapi} function is not currently implemented for VSCode.")
+}
+
+
+getConsoleEditorContext <- .vsc_not_yet_implemented
+sourceMarkers <- .vsc_not_yet_implemented
+documentClose <- .vsc_not_yet_implemented
+showPrompt <- .vsc_not_yet_implemented
+showQuestion <- .vsc_not_yet_implemented
+updateDialog <- .vsc_not_yet_implemented
+openProject <- .vsc_not_yet_implemented
+initializeProject <- .vsc_not_yet_implemented
+addTheme <- .vsc_not_yet_implemented
+applyTheme <- .vsc_not_yet_implemented
+convertTheme <- .vsc_not_yet_implemented
+getThemeInfo <- .vsc_not_yet_implemented
+getThemes <- .vsc_not_yet_implemented
+removeTheme <- .vsc_not_yet_implemented
+jobAdd <- .vsc_not_yet_implemented
+jobAddOutput <- .vsc_not_yet_implemented
+jobAddProgress <- .vsc_not_yet_implemented
+jobRemove <- .vsc_not_yet_implemented
+jobRunScript <- .vsc_not_yet_implemented
+jobSetProgress <- .vsc_not_yet_implemented
+jobSetState <- .vsc_not_yet_implemented
+jobSetStatus <- .vsc_not_yet_implemented
+launcherGetInfo <- .vsc_not_yet_implemented
+launcherAvailable <- .vsc_not_yet_implemented
+launcherGetJobs <- .vsc_not_yet_implemented
+launcherConfig <- .vsc_not_yet_implemented
+launcherContainer <- .vsc_not_yet_implemented
+launcherControlJob <- .vsc_not_yet_implemented
+launcherGetJob <- .vsc_not_yet_implemented
+launcherHostMount <- .vsc_not_yet_implemented
+launcherNfsMount <- .vsc_not_yet_implemented
+launcherPlacementConstraint <- .vsc_not_yet_implemented
+launcherResourceLimit <- .vsc_not_yet_implemented
+launcherSubmitJob <- .vsc_not_yet_implemented
+launcherSubmitR <- .vsc_not_yet_implemented
+previewRd <- .vsc_not_yet_implemented
+previewSql <- .vsc_not_yet_implemented
+writePreference <- .vsc_not_yet_implemented
+writeRStudioPreference <- .vsc_not_yet_implemented
+getPersistentValue <- .vsc_not_yet_implemented
+setPersistentValue <- .vsc_not_yet_implemented
+savePlotAsImage <- .vsc_not_yet_implemented
+createProjectTemplate <- .vsc_not_yet_implemented
+hasColourConsole <- .vsc_not_yet_implemented
+bugReport <- .vsc_not_yet_implemented
+buildToolsCheck <- .vsc_not_yet_implemented
+buildToolsInstall <- .vsc_not_yet_implemented
+buildToolsExec <- .vsc_not_yet_implemented
+dictionariesPath <- .vsc_not_yet_implemented
+userDictionariesPath <- .vsc_not_yet_implemented
+executeCommand <- .vsc_not_yet_implemented
+translateLocalUrl <- .vsc_not_yet_implemented
diff --git a/R/session/rstudioapi_util.R b/R/session/rstudioapi_util.R
new file mode 100644
index 00000000..da5fe0ff
--- /dev/null
+++ b/R/session/rstudioapi_util.R
@@ -0,0 +1,258 @@
+rstudioapi_call <- function(action, ...) {
+    request_response("rstudioapi", action = action, args = list(...))
+}
+
+rstudioapi_patch_hook <- function(api_env) {
+    patch_rstudioapi_fn <-
+        function(old, new) {
+            if (namespace_has(old, "rstudioapi")) {
+                assignInNamespace(
+                    x = old,
+                    value = new,
+                    ns = "rstudioapi"
+                )
+            }
+        }
+    ## make assignments to functions found in api_env namespace
+    ## that have function with the same name in {rstudioapi} namespace
+    api_list <- as.list(api_env)
+    mapply(
+        patch_rstudioapi_fn,
+        names(api_list),
+        api_list
+    )
+}
+
+make_rs_range <- function(vsc_selection) {
+    # vscode positions are zero indexed
+    # rstudioapi is one indexed
+    rstudioapi::document_range(
+        start = rstudioapi::document_position(
+            row = vsc_selection$start$line + 1,
+            column = vsc_selection$start$character + 1
+        ),
+        end = rstudioapi::document_position(
+            row = vsc_selection$end$line + 1,
+            column = vsc_selection$end$character + 1
+        )
+    )
+}
+
+extract_document_ranges <- function(vsc_selections) {
+    lapply(vsc_selections, make_rs_range)
+}
+
+to_content_lines <- function(contents, ranges) {
+    content_lines <- strsplit(contents, "\n|\r\n|\r$")[[1]]
+
+
+    # edge case handling: The cursor is at the start of a new empty line,
+    # and that line is the final line.
+    range_end_row <- unlist(lapply(ranges, function(range) range$end["row"]))
+    last_row <- max(range_end_row)
+    if (last_row == length(content_lines) + 1) {
+        content_lines <- c(content_lines, "")
+    }
+
+    content_lines
+}
+
+
+extract_range_text <- function(range, content_lines) {
+    if (!range_has_text(range)) {
+        return("")
+    }
+
+    content_rows <-
+        content_lines[(range$start["row"]):(range$end["row"])]
+    content_rows[length(content_rows)] <-
+        substring(
+            content_rows[length(content_rows)],
+            1,
+            range$end["column"] - 1
+            # it's a minus 1 here because the selection end point is the number
+            # of the first unselected column. I.e. range 1 - 2 is all of
+            # columns >= 1 and < 2, which is column 1.
+        )
+    content_rows[1] <-
+        substring(
+            content_rows[1],
+            range$start["column"]
+        )
+
+    paste0(content_rows, collapse = "\n")
+}
+
+range_has_text <- function(range) {
+    (range$end["row"] - range$start["row"]) +
+        (range$end["column"] - range$start["column"]) > 0
+}
+
+make_rs_document_selection <- function(ranges, range_texts) {
+    selection_data <-
+        mapply(
+            function(range, text) {
+                list(
+                    range = range,
+                    text = text
+                )
+            },
+            ranges,
+            range_texts,
+            SIMPLIFY = FALSE
+        )
+    structure(selection_data,
+        class = "document_selection"
+    )
+}
+
+make_rs_document_context <-
+    function(vsc_editor_context) {
+        document_ranges <-
+            extract_document_ranges(vsc_editor_context$selection)
+        content_lines <-
+            to_content_lines(vsc_editor_context$contents, document_ranges)
+        document_range_texts <-
+            lapply(
+                document_ranges,
+                extract_range_text,
+                content_lines
+            )
+        document_selection <-
+            make_rs_document_selection(
+                document_ranges,
+                document_range_texts
+            )
+
+        structure(list(
+            id = vsc_editor_context$id$external,
+            path = vsc_editor_context$path,
+            contents = content_lines,
+            selections = document_selection
+        ),
+        class = "document_context"
+        )
+    }
+
+is_positionable <- function(p) is.numeric(p) && length(p) == 2
+
+is_rangable <- function(r) is.numeric(r) && length(r) == 4
+
+normalise_pos_or_range_arg <- function(location) {
+    # This is necessary due to the loose constraints of the location argument
+    # in rstudioapi::insertText and rstudioapi::modifyRange. These
+    # functions can take single vectors coerable to postition or range OR a
+    # list where each element may be a location, range, or a vector coercable
+    # to such. I prefer to normalise the argument to a list of either formal
+    # positions or ranges.
+    if (rstudioapi::is.document_position(location)) {
+        list(location)
+    } else if (is_positionable(location)) {
+        list(rstudioapi::as.document_position(location))
+    } else if (rstudioapi::is.document_range(location)) {
+        list(location)
+    } else if (is_rangable(location)) {
+        list(rstudioapi::as.document_range(location))
+    } else if (is.list(location)) {
+        lapply(
+            location,
+            function(a_location) {
+                if (rstudioapi::is.document_position(a_location) || rstudioapi::is.document_range(a_location)) {
+                    a_location
+                } else if (is_positionable(a_location)) {
+                    rstudioapi::as.document_position(a_location)
+                } else if (is_rangable((a_location))) {
+                    rstudioapi::as.document_range(a_location)
+                } else {
+                    stop(
+                        "object in location list was not a",
+                        " document_position or document_range"
+                    )
+                }
+            }
+        )
+    } else {
+        stop("location object was not a document_position or document_range")
+    }
+}
+
+normalise_text_arg <- function(text, location_length) {
+    if (length(text) == location_length) {
+        text
+    } else if (length(text) == 1 && location_length > 1) {
+        rep(text, location_length)
+    } else {
+        stop(
+            "text vector needs to be of length 1 or",
+            " the same length as location list"
+        )
+    }
+}
+
+update_addin_registry <- function(addin_registry) {
+    pkgs <- .packages(all.available = TRUE)
+    addin_files <- vapply(pkgs, function(pkg) {
+        system.file("rstudio/addins.dcf", package = pkg)
+    }, character(1L))
+    addin_files <- addin_files[file.exists(addin_files)]
+    addin_descriptions <-
+        mapply(
+            function(package, package_dcf) {
+                addin_description_names <-
+                    c(
+                        "name",
+                        "description",
+                        "binding",
+                        "interactive",
+                        "package"
+                    )
+                description_result <-
+                    tryCatch({
+                        addin_description <-
+                            as.data.frame(read.dcf(package_dcf),
+                                stringsAsFactors = FALSE
+                            )
+
+                        if (ncol(addin_description) < 4) {
+                            NULL
+                        }
+                        ## if less than 4 columns it's malformed
+                        ## a NULL will be ignored in the rbind
+
+                        addin_description$package <- package
+                        names(addin_description) <- addin_description_names
+
+                        addin_description[, addin_description_names]
+                        ## this filters out any extra columns
+                    },
+                    error = function(cond) {
+                        message(
+                            "addins.dcf file for ", package,
+                            " could not be read from R library. ",
+                            "The RStudio addin picker will not ",
+                            "contain it's addins"
+                        )
+
+                        NULL
+                    }
+                    )
+
+                description_result
+            },
+            names(addin_files),
+            addin_files,
+            SIMPLIFY = FALSE
+        )
+    addin_descriptions_flat <-
+        do.call(
+            function(...) rbind(..., make.row.names = FALSE),
+            addin_descriptions
+        )
+
+    jsonlite::write_json(addin_descriptions_flat, addin_registry, pretty = TRUE)
+}
+
+namespace_has <- function(obj, namespace) {
+    attempt <- try(getFromNamespace(obj, namespace), silent = TRUE)
+    !inherits(attempt, "try-error")
+}
diff --git a/R/session/vsc.R b/R/session/vsc.R
new file mode 100644
index 00000000..5ab46139
--- /dev/null
+++ b/R/session/vsc.R
@@ -0,0 +1,941 @@
+pid <- Sys.getpid()
+wd <- getwd()
+tempdir <- tempdir()
+homedir <- Sys.getenv(
+    if (.Platform$OS.type == "windows") "USERPROFILE" else "HOME"
+)
+dir_watcher <- Sys.getenv("VSCODE_WATCHER_DIR", file.path(homedir, ".vscode-R"))
+request_file <- file.path(dir_watcher, "request.log")
+request_lock_file <- file.path(dir_watcher, "request.lock")
+settings_file <- file.path(dir_watcher, "settings.json")
+user_options <- names(options())
+
+logger <- if (getOption("vsc.debug", FALSE)) {
+    function(...) cat(..., "\n", sep = "")
+} else {
+    function(...) invisible()
+}
+
+load_settings <- function() {
+    if (!file.exists(settings_file)) {
+        return(FALSE)
+    }
+
+    setting <- function(x, ...) {
+        switch(EXPR = x, ..., x)
+    }
+
+    mapping <- quote(list(
+        vsc.use_webserver = session$useWebServer,
+        vsc.use_httpgd = plot$useHttpgd,
+        vsc.show_object_size = workspaceViewer$showObjectSize,
+        vsc.rstudioapi = session$emulateRStudioAPI,
+        vsc.str.max.level = setting(session$levelOfObjectDetail, Minimal = 0, Normal = 1, Detailed = 2),
+        vsc.object_length_limit = session$objectLengthLimit,
+        vsc.object_timeout = session$objectTimeout,
+        vsc.globalenv = session$watchGlobalEnvironment,
+        vsc.plot = setting(session$viewers$viewColumn$plot, Disable = FALSE),
+        vsc.dev.args = plot$devArgs,
+        vsc.browser = setting(session$viewers$viewColumn$browser, Disable = FALSE),
+        vsc.viewer = setting(session$viewers$viewColumn$viewer, Disable = FALSE),
+        vsc.page_viewer = setting(session$viewers$viewColumn$pageViewer, Disable = FALSE),
+        vsc.row_limit = session$data$rowLimit,
+        vsc.view = setting(session$viewers$viewColumn$view, Disable = FALSE),
+        vsc.helpPanel = setting(session$viewers$viewColumn$helpPanel, Disable = FALSE)
+    ))
+
+    vsc_settings <- tryCatch(jsonlite::read_json(settings_file), error = function(e) {
+        message("Error occurs when reading VS Code settings: ", conditionMessage(e))
+    })
+
+    if (is.null(vsc_settings)) {
+        return(FALSE)
+    }
+
+    ops <- eval(mapping, vsc_settings)
+
+    # exclude options set by user on startup
+    r_options <- ops[!(names(ops) %in% user_options)]
+
+    options(r_options)
+}
+
+load_settings()
+
+if (is.null(getOption("help_type"))) {
+    options(help_type = "html")
+}
+
+use_webserver <- isTRUE(getOption("vsc.use_webserver", FALSE))
+if (use_webserver) {
+    if (requireNamespace("httpuv", quietly = TRUE)) {
+        request_handlers <- list(
+            hover = function(expr, ...) {
+                tryCatch({
+                    expr <- parse(text = expr, keep.source = FALSE)[[1]]
+                    obj <- eval(expr, .GlobalEnv)
+                    list(str = capture_str(obj))
+                }, error = function(e) NULL)
+            },
+
+            complete = function(expr, trigger, ...) {
+                obj <- tryCatch({
+                    expr <- parse(text = expr, keep.source = FALSE)[[1]]
+                    eval(expr, .GlobalEnv)
+                }, error = function(e) NULL)
+
+                if (is.null(obj)) {
+                    return(NULL)
+                }
+
+                if (trigger == "$") {
+                    names <- if (is.object(obj)) {
+                        .DollarNames(obj, pattern = "")
+                    } else if (is.recursive(obj)) {
+                        names(obj)
+                    } else {
+                        NULL
+                    }
+
+                    result <- lapply(names, function(name) {
+                        item <- obj[[name]]
+                        list(
+                            name = name,
+                            type = typeof(item),
+                            str = try_capture_str(item)
+                        )
+                    })
+                    return(result)
+                }
+
+                if (trigger == "@" && isS4(obj)) {
+                    names <- slotNames(obj)
+                    result <- lapply(names, function(name) {
+                        item <- slot(obj, name)
+                        list(
+                            name = name,
+                            type = typeof(item),
+                            str = try_capture_str(item)
+                        )
+                    })
+                    return(result)
+                }
+            }
+        )
+
+        server <- getOption("vsc.server")
+        if (!is.null(server) && server$isRunning()) {
+            host <- server$getHost()
+            port <- server$getPort()
+            token <- attr(server, "token")
+        } else {
+            host <- "127.0.0.1"
+            port <- httpuv::randomPort()
+            token <- sprintf("%d:%d:%.6f", pid, port, Sys.time())
+            server <- httpuv::startServer(host, port,
+                list(
+                    onHeaders = function(req) {
+                        logger("http request ",
+                            req[["REMOTE_ADDR"]], ":",
+                            req[["REMOTE_PORT"]], " ",
+                            req[["REQUEST_METHOD"]], " ",
+                            req[["HTTP_USER_AGENT"]]
+                        )
+
+                        if (!nzchar(req[["REMOTE_ADDR"]]) || identical(req[["REMOTE_PORT"]], "0")) {
+                            return(NULL)
+                        }
+
+                        if (!identical(req[["HTTP_AUTHORIZATION"]], token)) {
+                            return(list(
+                                status = 401L,
+                                headers = list(
+                                    "Content-Type" = "text/plain"
+                                ),
+                                body = "Unauthorized"
+                            ))
+                        }
+
+                        if (!identical(req[["HTTP_CONTENT_TYPE"]], "application/json")) {
+                            return(list(
+                                status = 400L,
+                                headers = list(
+                                    "Content-Type" = "text/plain"
+                                ),
+                                body = "Bad request"
+                            ))
+                        }
+                    },
+                    call = function(req) {
+                        content <- req$rook.input$read_lines()
+                        request <- jsonlite::fromJSON(content, simplifyVector = FALSE)
+                        handler <- request_handlers[[request$type]]
+                        response <- if (is.function(handler)) do.call(handler, request)
+
+                        list(
+                            status = 200L,
+                            headers = list(
+                                "Content-Type" = "application/json"
+                            ),
+                            body = jsonlite::toJSON(response, auto_unbox = TRUE, force = TRUE)
+                        )
+                    }
+                )
+            )
+            attr(server, "token") <- token
+            options(vsc.server = server)
+        }
+    } else {
+        message("{httpuv} is required to use WebServer from the session watcher.")
+        use_webserver <- FALSE
+    }
+}
+
+get_timestamp <- function() {
+    sprintf("%.6f", Sys.time())
+}
+
+scalar <- function(x) {
+    class(x) <- c("scalar", class(x))
+    x
+}
+
+request <- function(command, ...) {
+    obj <- list(
+        time = Sys.time(),
+        pid = pid,
+        wd = wd,
+        command = command,
+        ...
+    )
+    jsonlite::write_json(obj, request_file,
+        auto_unbox = TRUE, null = "null", force = TRUE
+    )
+    cat(get_timestamp(), file = request_lock_file)
+}
+
+try_catch_timeout <- function(expr, timeout = Inf, ...) {
+    expr <- substitute(expr)
+    envir <- parent.frame()
+    setTimeLimit(timeout, transient = TRUE)
+    on.exit(setTimeLimit())
+    tryCatch(eval(expr, envir), ...)
+}
+
+capture_str <- function(object, max.level = getOption("vsc.str.max.level", 0)) {
+    paste0(utils::capture.output(
+        utils::str(object,
+            max.level = max.level,
+            give.attr = FALSE,
+            vec.len = 1
+        )
+    ), collapse = "\n")
+}
+
+try_capture_str <- function(object, max.level = getOption("vsc.str.max.level", 0)) {
+    tryCatch(
+        capture_str(object, max.level = max.level),
+        error = function(e) {
+            paste0(class(object), collapse = ", ")
+        }
+    )
+}
+
+rebind <- function(sym, value, ns) {
+    if (is.character(ns)) {
+        Recall(sym, value, getNamespace(ns))
+        pkg <- paste0("package:", ns)
+        if (pkg %in% search()) {
+            Recall(sym, value, as.environment(pkg))
+        }
+    } else if (is.environment(ns)) {
+        if (bindingIsLocked(sym, ns)) {
+            unlockBinding(sym, ns)
+            on.exit(lockBinding(sym, ns))
+        }
+        assign(sym, value, ns)
+    } else {
+        stop("ns must be a string or environment")
+    }
+}
+
+address <- function(x) {
+    info <- utils::capture.output(.Internal(inspect(x, 0L, 0L)))
+    sub("@([a-z0-9]+)\\s+.+", "\\1", info[[1]])
+}
+
+globalenv_cache <- new.env(parent = emptyenv())
+
+inspect_env <- function(env, cache) {
+    all_names <- ls(env)
+    rm(list = setdiff(names(globalenv_cache), all_names), envir = cache)
+    is_active <- vapply(all_names, bindingIsActive, logical(1), USE.NAMES = TRUE, env)
+    is_promise <- rlang::env_binding_are_lazy(env, all_names[!is_active])
+    show_object_size <- getOption("vsc.show_object_size", FALSE)
+    object_length_limit <- getOption("vsc.object_length_limit", 2000)
+    object_timeout <- getOption("vsc.object_timeout", 50) / 1000
+    str_max_level <- getOption("vsc.str.max.level", 0)
+    objs <- lapply(all_names, function(name) {
+        if (isTRUE(is_promise[name])) {
+            info <- list(
+                class = "promise",
+                type = scalar("promise"),
+                length = scalar(0L),
+                str = scalar("(promise)")
+            )
+        } else if (isTRUE(is_active[name])) {
+            info <- list(
+                class = "active_binding",
+                type = scalar("active_binding"),
+                length = scalar(0L),
+                str = scalar("(active-binding)")
+            )
+        } else {
+            obj <- env[[name]]
+
+            info <- list(
+                class = class(obj),
+                type = scalar(typeof(obj)),
+                length = scalar(length(obj))
+            )
+
+            if (show_object_size) {
+                addr <- address(obj)
+                cobj <- cache[[name]]
+                if (is.null(cobj) || cobj$address != addr || cobj$length != info$length) {
+                    cache[[name]] <- cobj <- list(
+                        address = addr,
+                        length = length(obj),
+                        size = unclass(object.size(obj))
+                    )
+                }
+                info$size <- scalar(cobj$size)
+            }
+
+            if (length(obj) > object_length_limit) {
+                info$str <- scalar(trimws(try_capture_str(obj, 0)))
+            } else {
+                info_str <- NULL
+                if (str_max_level > 0) {
+                    info_str <- try_catch_timeout(
+                        capture_str(obj, str_max_level),
+                        timeout = object_timeout,
+                        error = function(e) NULL
+                    )
+                }
+                if (is.null(info_str)) {
+                    info_str <- try_capture_str(obj, 0)
+                }
+                info$str <- scalar(trimws(info_str))
+                obj_names <- if (is.object(obj)) {
+                    .DollarNames(obj, pattern = "")
+                } else if (is.recursive(obj)) {
+                    names(obj)
+                } else {
+                    NULL
+                }
+
+                if (length(obj_names)) {
+                    info$names <- obj_names
+                }
+            }
+
+            if (isS4(obj)) {
+                info$slots <- slotNames(obj)
+            }
+
+            if (!is.null(dim(obj))) {
+                info$dim <- dim(obj)
+            }
+        }
+        info
+    })
+    names(objs) <- all_names
+    objs
+}
+
+dir_session <- file.path(tempdir, "vscode-R")
+dir.create(dir_session, showWarnings = FALSE, recursive = TRUE)
+
+removeTaskCallback("vsc.workspace")
+show_globalenv <- isTRUE(getOption("vsc.globalenv", TRUE))
+workspace_file <- file.path(dir_session, "workspace.json")
+workspace_lock_file <- file.path(dir_session, "workspace.lock")
+file.create(workspace_lock_file, showWarnings = FALSE)
+
+update_workspace <- function(...) {
+    tryCatch({
+        data <- list(
+            search = search()[-1],
+            loaded_namespaces = loadedNamespaces(),
+            globalenv = if (show_globalenv) inspect_env(.GlobalEnv, globalenv_cache) else NULL
+        )
+        jsonlite::write_json(data, workspace_file, force = TRUE, pretty = FALSE)
+        cat(get_timestamp(), file = workspace_lock_file)
+    }, error = message)
+    TRUE
+}
+update_workspace()
+addTaskCallback(update_workspace, name = "vsc.workspace")
+
+removeTaskCallback("vsc.plot")
+use_httpgd <- identical(getOption("vsc.use_httpgd", FALSE), TRUE)
+show_plot <- !identical(getOption("vsc.plot", "Two"), FALSE)
+if (use_httpgd && "httpgd" %in% .packages(all.available = TRUE)) {
+    options(device = function(...) {
+        httpgd::hgd(
+            silent = TRUE
+        )
+        .vsc$request("httpgd", url = httpgd::hgd_url())
+    })
+} else if (use_httpgd) {
+    message("Install package `httpgd` to use vscode-R with httpgd!")
+} else if (show_plot) {
+    plot_file <- file.path(dir_session, "plot.png")
+    plot_lock_file <- file.path(dir_session, "plot.lock")
+    file.create(plot_file, plot_lock_file, showWarnings = FALSE)
+
+    plot_updated <- FALSE
+    null_dev_id <- c(pdf = 2L)
+    null_dev_size <- c(7 + pi, 7 + pi)
+
+    check_null_dev <- function() {
+        identical(dev.cur(), null_dev_id) &&
+            identical(dev.size(), null_dev_size)
+    }
+
+    new_plot <- function() {
+        if (check_null_dev()) {
+            plot_updated <<- TRUE
+        }
+    }
+
+    options(
+        device = function(...) {
+            pdf(NULL,
+                width = null_dev_size[[1L]],
+                height = null_dev_size[[2L]],
+                bg = "white")
+            dev.control(displaylist = "enable")
+        }
+    )
+
+    update_plot <- function(...) {
+        tryCatch({
+            if (plot_updated && check_null_dev()) {
+                plot_updated <<- FALSE
+                record <- recordPlot()
+                if (length(record[[1L]])) {
+                    dev_args <- getOption("vsc.dev.args")
+                    do.call(png, c(list(filename = plot_file), dev_args))
+                    on.exit({
+                        dev.off()
+                        cat(get_timestamp(), file = plot_lock_file)
+                    })
+                    replayPlot(record)
+                }
+            }
+        }, error = message)
+        TRUE
+    }
+
+    setHook("plot.new", new_plot, "replace")
+    setHook("grid.newpage", new_plot, "replace")
+
+    rebind(".External.graphics", function(...) {
+        out <- .Primitive(".External.graphics")(...)
+        if (check_null_dev()) {
+            plot_updated <<- TRUE
+        }
+        out
+    }, "base")
+
+    update_plot()
+    addTaskCallback(update_plot, name = "vsc.plot")
+}
+
+show_view <- !identical(getOption("vsc.view", "Two"), FALSE)
+if (show_view) {
+    get_column_def <- function(name, field, value) {
+        filter <- TRUE
+        tooltip <- sprintf(
+            "%s, class: [%s], type: %s",
+            name,
+            toString(class(value)),
+            typeof(value)
+        )
+        if (is.numeric(value)) {
+            type <- "numericColumn"
+            if (is.null(attr(value, "class"))) {
+                filter <- "agNumberColumnFilter"
+            }
+        } else if (inherits(value, "Date")) {
+            type <- "dateColumn"
+            filter <- "agDateColumnFilter"
+        } else {
+            type <- "textColumn"
+            filter <- "agTextColumnFilter"
+        }
+        list(
+            headerName = name,
+            headerTooltip = tooltip,
+            field = field,
+            type = type,
+            filter = filter
+        )
+    }
+
+    dataview_table <- function(data) {
+        if (is.matrix(data)) {
+            data <- as.data.frame.matrix(data)
+        }
+
+        if (is.data.frame(data)) {
+            .nrow <- nrow(data)
+            .colnames <- colnames(data)
+            if (is.null(.colnames)) {
+                .colnames <- sprintf("V%d", seq_len(ncol(data)))
+            } else {
+                .colnames <- trimws(.colnames)
+            }
+            if (.row_names_info(data) > 0L) {
+                rownames <- rownames(data)
+                rownames(data) <- NULL
+            } else {
+                rownames <- seq_len(.nrow)
+            }
+            .colnames <- c("(row)", .colnames)
+            fields <- sprintf("x%d", seq_along(.colnames))
+            data <- c(list(" " = rownames), .subset(data))
+            names(data) <- fields
+            class(data) <- "data.frame"
+            attr(data, "row.names") <- .set_row_names(.nrow)
+            columns <- .mapply(get_column_def,
+                list(.colnames, fields, data),
+                NULL
+            )
+            list(
+                columns = columns,
+                data = data
+            )
+        } else {
+            stop("data must be a data.frame or a matrix")
+        }
+    }
+
+    show_dataview <- function(x, title, uuid = NULL,
+                              viewer = getOption("vsc.view", "Two"),
+                              row_limit = abs(getOption("vsc.row_limit", 0))) {
+        as_truncated_data <- function(.data) {
+            .nrow <- nrow(.data)
+            if (row_limit != 0 && row_limit < .nrow) {
+                title <<- sprintf("%s (limited to %d/%d)", title, row_limit, .nrow)
+                .data <- utils::head(.data, n = row_limit)
+            }
+            return(.data)
+        }
+
+        if (missing(title)) {
+            sub <- substitute(x)
+            title <- deparse(sub, nlines = 1)
+        }
+        if (inherits(x, "ArrowTabular")) {
+            x <- as_truncated_data(x)
+            x <- as.data.frame(x)
+        }
+        if (is.environment(x)) {
+            all_names <- ls(x)
+            is_active <- vapply(all_names, bindingIsActive, logical(1), USE.NAMES = TRUE, x)
+            is_promise <- rlang::env_binding_are_lazy(x, all_names[!is_active])
+            x <- lapply(all_names, function(name) {
+                if (isTRUE(is_promise[name])) {
+                    data.frame(
+                        class = "promise",
+                        type = "promise",
+                        length = 0L,
+                        size = 0L,
+                        value = "(promise)",
+                        stringsAsFactors = FALSE,
+                        check.names = FALSE
+                    )
+                } else if (isTRUE(is_active[name])) {
+                    data.frame(
+                        class = "active_binding",
+                        type = "active_binding",
+                        length = 0L,
+                        size = 0L,
+                        value = "(active-binding)",
+                        stringsAsFactors = FALSE,
+                        check.names = FALSE
+                    )
+                } else {
+                    obj <- x[[name]]
+                    data.frame(
+                        class = paste0(class(obj), collapse = ", "),
+                        type = typeof(obj),
+                        length = length(obj),
+                        size = as.integer(object.size(obj)),
+                        value = trimws(try_capture_str(obj, 0)),
+                        stringsAsFactors = FALSE,
+                        check.names = FALSE
+                    )
+                }
+            })
+            names(x) <- all_names
+            if (length(x)) {
+                x <- do.call(rbind, x)
+            } else {
+                x <- data.frame(
+                    class = character(),
+                    type = character(),
+                    length = integer(),
+                    size = integer(),
+                    value = character(),
+                    stringsAsFactors = FALSE,
+                    check.names = FALSE
+                )
+            }
+        }
+        if (is.data.frame(x) || is.matrix(x)) {
+            x <- as_truncated_data(x)
+            data <- dataview_table(x)
+            file <- tempfile(tmpdir = tempdir, fileext = ".json")
+            jsonlite::write_json(data, file, na = "string", null = "null", auto_unbox = TRUE, force = TRUE)
+            request("dataview", source = "table", type = "json",
+                title = title, file = file, viewer = viewer, uuid = uuid
+            )
+        } else if (is.list(x)) {
+            tryCatch({
+                file <- tempfile(tmpdir = tempdir, fileext = ".json")
+                jsonlite::write_json(x, file, na = "string", null = "null", auto_unbox = TRUE, force = TRUE)
+                request("dataview", source = "list", type = "json",
+                    title = title, file = file, viewer = viewer, uuid = uuid
+                )
+            }, error = function(e) {
+                file <- file.path(tempdir, paste0(make.names(title), ".txt"))
+                text <- utils::capture.output(print(x))
+                writeLines(text, file)
+                request("dataview", source = "object", type = "txt",
+                    title = title, file = file, viewer = viewer, uuid = uuid
+                )
+            })
+        } else {
+            file <- file.path(tempdir, paste0(make.names(title), ".R"))
+            if (is.primitive(x)) {
+                code <- utils::capture.output(print(x))
+            } else {
+                code <- deparse(x)
+            }
+            writeLines(code, file)
+            request("dataview", source = "object", type = "R",
+                title = title, file = file, viewer = viewer, uuid = uuid
+            )
+        }
+    }
+
+    rebind("View", show_dataview, "utils")
+}
+
+attach <- function() {
+    load_settings()
+    if (rstudioapi_enabled()) {
+        rstudioapi_util_env$update_addin_registry(addin_registry)
+    }
+    request("attach",
+        version = sprintf("%s.%s", R.version$major, R.version$minor),
+        tempdir = tempdir,
+        info = list(
+            command = commandArgs()[[1L]],
+            version = R.version.string,
+            start_time = format(file.info(tempdir)$ctime)
+        ),
+        plot_url = if (identical(names(dev.cur()), "httpgd")) httpgd::hgd_url(),
+        server = if (use_webserver) list(
+            host = host,
+            port = port,
+            token = token
+        ) else NULL
+    )
+}
+
+path_to_uri <- function(path) {
+    if (length(path) == 0) {
+        return(character())
+    }
+    path <- path.expand(path)
+    if (.Platform$OS.type == "windows") {
+        prefix <- "file:///"
+        path <- gsub("\\", "/", path, fixed = TRUE)
+    } else {
+        prefix <- "file://"
+    }
+    paste0(prefix, utils::URLencode(path))
+}
+
+request_browser <- function(url, title, ..., viewer) {
+    # Printing URL with specific port triggers
+    # auto port-forwarding under remote development
+    message("Browsing ", url)
+    request("browser", url = url, title = title, ..., viewer = viewer)
+}
+
+show_browser <- function(url, title = url, ...,
+                         viewer = getOption("vsc.browser", "Active")) {
+    proxy_uri <- Sys.getenv("VSCODE_PROXY_URI")
+    if (nzchar(proxy_uri)) {
+        is_base_path <- grepl("\\:\\d+$", url)
+        url <- sub("^https?\\://(127\\.0\\.0\\.1|localhost)(\\:)?",
+            sub("\\{\\{?port\\}\\}?/?", "", proxy_uri), url
+        )
+        if (is_base_path) {
+            url <- paste0(url, "/")
+        }
+    }
+    if (grepl("^https?\\://(127\\.0\\.0\\.1|localhost)(\\:\\d+)?", url)) {
+        request_browser(url = url, title = title, ..., viewer = viewer)
+    } else if (grepl("^https?\\://", url)) {
+        message(
+            if (nzchar(proxy_uri)) {
+                "VSCode is not running on localhost but on a remote server.\n"
+            } else {
+                "VSCode WebView only supports showing local http content.\n"
+            },
+            "Opening in external browser..."
+        )
+        request_browser(url = url, title = title, ..., viewer = FALSE)
+    } else {
+        path <- sub("^file\\://", "", url)
+        if (file.exists(path)) {
+            path <- normalizePath(path, "/", mustWork = TRUE)
+            if (grepl("\\.html?$", path, ignore.case = TRUE)) {
+                message(
+                    "VSCode WebView has restricted access to local file.\n",
+                    "Opening in external browser..."
+                )
+                request_browser(url = path_to_uri(path),
+                    title = title, ..., viewer = FALSE
+                )
+            } else {
+                request("dataview", source = "object", type = "txt",
+                    title = title, file = path, viewer = viewer
+                )
+            }
+        } else {
+            stop("File not exists")
+        }
+    }
+}
+
+show_webview <- function(url, title, ..., viewer) {
+    if (!is.character(url)) {
+        real_url <- NULL
+        temp_viewer <- function(url, ...) {
+            real_url <<- url
+        }
+        op <- options(viewer = temp_viewer, page_viewer = temp_viewer)
+        on.exit(options(op))
+        print(url)
+        if (is.character(real_url)) {
+            url <- real_url
+        } else {
+            stop("Invalid object")
+        }
+    }
+    proxy_uri <- Sys.getenv("VSCODE_PROXY_URI")
+    if (nzchar(proxy_uri)) {
+        is_base_path <- grepl("\\:\\d+$", url)
+        url <- sub("^https?\\://(127\\.0\\.0\\.1|localhost)(\\:)?",
+            sub("\\{\\{?port\\}\\}?/?", "", proxy_uri), url
+        )
+        if (is_base_path) {
+            url <- paste0(url, "/")
+        }
+    }
+    if (grepl("^https?\\://(127\\.0\\.0\\.1|localhost)(\\:\\d+)?", url)) {
+        request_browser(url = url, title = title, ..., viewer = viewer)
+    } else if (grepl("^https?\\://", url)) {
+        message(
+            if (nzchar(proxy_uri)) {
+                "VSCode is not running on localhost but on a remote server.\n"
+            } else {
+                "VSCode WebView only supports showing local http content.\n"
+            },
+            "Opening in external browser..."
+        )
+        request_browser(url = url, title = title, ..., viewer = FALSE)
+    } else if (file.exists(url)) {
+        file <- normalizePath(url, "/", mustWork = TRUE)
+        request("webview", file = file, title = title, viewer = viewer, ...)
+    } else {
+        stop("File not exists")
+    }
+}
+
+show_viewer <- function(url, title = NULL, ...,
+                        viewer = getOption("vsc.viewer", "Two")) {
+    if (is.null(title)) {
+        expr <- substitute(url)
+        if (is.character(url)) {
+            title <- "Viewer"
+        } else {
+            title <- deparse(expr, nlines = 1)
+        }
+    }
+    show_webview(url = url, title = title, ..., viewer = viewer)
+}
+
+show_page_viewer <- function(url, title = NULL, ...,
+                             viewer = getOption("vsc.page_viewer", "Active")) {
+    if (is.null(title)) {
+        expr <- substitute(url)
+        if (is.character(url)) {
+            title <- "Page Viewer"
+        } else {
+            title <- deparse(expr, nlines = 1)
+        }
+    }
+    show_webview(url = url, title = title, ..., viewer = viewer)
+}
+
+options(
+    browser = show_browser,
+    viewer = show_viewer,
+    page_viewer = show_page_viewer
+)
+
+# rstudioapi
+rstudioapi_enabled <- function() {
+    isTRUE(getOption("vsc.rstudioapi", TRUE))
+}
+
+if (rstudioapi_enabled()) {
+    response_timeout <- 5
+    response_lock_file <- file.path(dir_session, "response.lock")
+    response_file <- file.path(dir_session, "response.log")
+    file.create(response_lock_file, showWarnings = FALSE)
+    file.create(response_file, showWarnings = FALSE)
+    addin_registry <- file.path(dir_session, "addins.json")
+    # This is created in attach()
+
+    get_response_timestamp <- function() {
+        readLines(response_lock_file)
+    }
+    # initialise the reponse timestamp to empty string
+    response_time_stamp <- ""
+
+    get_response_lock <- function() {
+        lock_time_stamp <- get_response_timestamp()
+        if (isTRUE(lock_time_stamp != response_time_stamp)) {
+            response_time_stamp <<- lock_time_stamp
+            TRUE
+        } else {
+            FALSE
+        }
+    }
+
+    request_response <- function(command, ...) {
+        request(command, ..., sd = dir_session)
+        wait_start <- Sys.time()
+        while (!get_response_lock()) {
+            if ((Sys.time() - wait_start) > response_timeout) {
+                stop(
+                    "Did not receive a response from VSCode-R API within ",
+                    response_timeout, " seconds."
+                )
+            }
+            Sys.sleep(0.1)
+        }
+        jsonlite::read_json(response_file)
+    }
+
+    rstudioapi_util_env <- new.env()
+    rstudioapi_env <- new.env(parent = rstudioapi_util_env)
+    source(file.path(dir_init, "rstudioapi_util.R"), local = rstudioapi_util_env)
+    source(file.path(dir_init, "rstudioapi.R"), local = rstudioapi_env)
+    setHook(
+        packageEvent("rstudioapi", "onLoad"),
+        function(...) {
+            rstudioapi_util_env$rstudioapi_patch_hook(rstudioapi_env)
+        }
+    )
+    if ("rstudioapi" %in% loadedNamespaces()) {
+        # if the rstudioapi is already loaded, for example via a call to
+        # library(tidyverse) in the user's profile, we need to shim it now.
+        # There's no harm in having also registered the hook in this case. It can
+        # work in the event that the namespace is unloaded and reloaded.
+        rstudioapi_util_env$rstudioapi_patch_hook(rstudioapi_env)
+    }
+
+}
+
+print.help_files_with_topic <- function(h, ...) {
+    viewer <- getOption("vsc.helpPanel", "Two")
+    if (!identical(FALSE, viewer) && length(h) >= 1 && is.character(h)) {
+        file <- h[1]
+        path <- dirname(file)
+        dirpath <- dirname(path)
+        pkgname <- basename(dirpath)
+        requestPath <- paste0(
+            "/library/",
+            pkgname,
+            "/html/",
+            basename(file),
+            ".html"
+        )
+        request(command = "help", requestPath = requestPath, viewer = viewer)
+    } else {
+        utils:::print.help_files_with_topic(h, ...)
+    }
+    invisible(h)
+}
+
+print.hsearch <- function(x, ...) {
+    viewer <- getOption("vsc.helpPanel", "Two")
+    if (!identical(FALSE, viewer) && length(x) >= 1) {
+        requestPath <- paste0(
+            "/doc/html/Search?pattern=",
+            tools:::escapeAmpersand(x$pattern),
+            paste0("&fields.", x$fields, "=1",
+                collapse = ""
+            ),
+            if (!is.null(x$agrep)) paste0("&agrep=", x$agrep),
+            if (!x$ignore.case) "&ignore.case=0",
+            if (!identical(
+                x$types,
+                getOption("help.search.types")
+            )) {
+                paste0("&types.", x$types, "=1",
+                    collapse = ""
+                )
+            },
+            if (!is.null(x$package)) {
+                paste0(
+                    "&package=",
+                    paste(x$package, collapse = ";")
+                )
+            },
+            if (!identical(x$lib.loc, .libPaths())) {
+                paste0(
+                    "&lib.loc=",
+                    paste(x$lib.loc, collapse = ";")
+                )
+            }
+        )
+        request(command = "help", requestPath = requestPath, viewer = viewer)
+    } else {
+        utils:::print.hsearch(x, ...)
+    }
+    invisible(x)
+}
+
+# a copy of .S3method(), since this function is new in R 4.0
+.S3method <- function(generic, class, method) {
+    if (missing(method)) {
+        method <- paste(generic, class, sep = ".")
+    }
+    method <- match.fun(method)
+    registerS3method(generic, class, method, envir = parent.frame())
+    invisible(NULL)
+}
+
+reg.finalizer(.GlobalEnv, function(e) .vsc$request("detach"), onexit = TRUE)
diff --git a/src/session.ts b/src/session.ts
index faf59f22..c82e686d 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -63,9 +63,7 @@ let plotLockFile: string;
 let plotTimeStamp: number;
 let workspaceWatcher: FSWatcher;
 let plotWatcher: FSWatcher;
-let activeBrowserPanel: WebviewPanel | undefined;
 let activeBrowserUri: Uri | undefined;
-let activeBrowserExternalUri: Uri | undefined;
 
 export function deploySessionWatcher(extensionPath: string): void {
     console.info(`[deploySessionWatcher] extensionPath: ${extensionPath}`);
@@ -227,78 +225,25 @@ export async function showBrowser(url: string, title: string, viewer: string | b
     if (viewer === false) {
         void env.openExternal(uri);
     } else {
-        const externalUri = await env.asExternalUri(uri);
-        const panel = window.createWebviewPanel(
-            'browser',
-            title,
-            {
-                preserveFocus: true,
-                viewColumn: ViewColumn[String(viewer) as keyof typeof ViewColumn],
-            },
-            {
-                enableFindWidget: true,
-                enableScripts: true,
-                retainContextWhenHidden: true,
-            });
+        const viewColumn = ViewColumn[String(viewer) as keyof typeof ViewColumn];
+        await commands.executeCommand('simpleBrowser.show', url, {
+            preserveFocus: true,
+            viewColumn: viewColumn,
+        });
         if (isHost()) {
             await shareBrowser(url, title);
         }
-        panel.onDidChangeViewState((e: WebviewPanelOnDidChangeViewStateEvent) => {
-            if (e.webviewPanel.active) {
-                activeBrowserPanel = panel;
-                activeBrowserUri = uri;
-                activeBrowserExternalUri = externalUri;
-            } else {
-                activeBrowserPanel = undefined;
-                activeBrowserUri = undefined;
-                activeBrowserExternalUri = undefined;
-            }
-            void commands.executeCommand('setContext', 'r.browser.active', e.webviewPanel.active);
-        });
-        panel.onDidDispose(() => {
-            activeBrowserPanel = undefined;
-            activeBrowserUri = undefined;
-            activeBrowserExternalUri = undefined;
-            if (isHost()) {
-                closeBrowser(url);
-            }
-            void commands.executeCommand('setContext', 'r.browser.active', false);
-        });
-        panel.iconPath = new UriIcon('globe');
-        panel.webview.html = getBrowserHtml(externalUri);
+        activeBrowserUri = uri;
     }
     console.info('[showBrowser] Done');
 }
 
-function getBrowserHtml(uri: Uri): string {
-    return `
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <style>
-    html, body {
-        height: 100%;
-        padding: 0;
-        overflow: hidden;
-    }
-    </style>
-</head>
-<body>
-    <iframe src="${uri.toString(true)}" width="100%" height="100%" frameborder="0" />
-</body>
-</html>
-`;
-}
-
 export function refreshBrowser(): void {
     console.log('[refreshBrowser]');
-    if (activeBrowserPanel) {
-        activeBrowserPanel.webview.html = '';
-        if (activeBrowserExternalUri) {
-            activeBrowserPanel.webview.html = getBrowserHtml(activeBrowserExternalUri);
-        }
+    if (activeBrowserUri) {
+        void commands.executeCommand('simpleBrowser.show', activeBrowserUri.toString(true), {
+            preserveFocus: true,
+        });
     }
 }
 

From a8908d4b1f00967ee27dae5392ffebf7e349b1f3 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Wed, 11 Mar 2026 23:10:25 -0700
Subject: [PATCH 15/47] chore: add TODO to unify browser and webview viewers in
 R hooks

---
 sess/R/hooks.R | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/sess/R/hooks.R b/sess/R/hooks.R
index 48b610af..072750a5 100644
--- a/sess/R/hooks.R
+++ b/sess/R/hooks.R
@@ -145,7 +145,8 @@ register_hooks <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
   }
   rebind("View", show_dataview, ns = "utils")
 
-  # 2. Browser & Webview Options
+  # 2. Browser & Webview Options 
+  # TODO: unify the viewers and let client to choose how to show
   show_browser <- function(url, title = url, ...) {
     notify_client("browser", list(url = url, title = title, viewer = getOption("sess.browser", "Active")))
   }

From 042477881bf7114e538affddd4c229fba720b9f4 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Wed, 11 Mar 2026 23:48:10 -0700
Subject: [PATCH 16/47] Redesign session connection to use workspaceState for
 robust persistence and PID mapping

---
 src/extension.ts |   2 +
 src/rTerminal.ts |  13 +++-
 src/session.ts   | 174 ++++++++++++++++++++++++++++++++++++++++-------
 3 files changed, 163 insertions(+), 26 deletions(-)

diff --git a/src/extension.ts b/src/extension.ts
index ba2d5b88..8a66c707 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -157,6 +157,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<apiImp
 
     // keep track of terminals
     context.subscriptions.push(vscode.window.onDidCloseTerminal(rTerminal.deleteTerminal));
+    context.subscriptions.push(vscode.window.onDidChangeActiveTerminal(session.switchSessionByTerminal));
 
     // start language service
     if (util.config().get<boolean>('lsp.enabled')) {
@@ -227,6 +228,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<apiImp
         if (!rShare.isGuestSession) {
             console.info('Initialize session watcher');
             void session.deploySessionWatcher(context.extensionPath);
+            void session.discoverSessions();
 
             // create status bar item that contains info about the session watcher
             console.info('Create sessionStatusBarItem');
diff --git a/src/rTerminal.ts b/src/rTerminal.ts
index 0883223b..b02d36e3 100644
--- a/src/rTerminal.ts
+++ b/src/rTerminal.ts
@@ -9,7 +9,7 @@ import { extensionContext, homeExtDir } from './extension';
 import * as util from './util';
 import * as selection from './selection';
 import { getSelection } from './selection';
-import { cleanupSession } from './session';
+import { cleanupSession, saveSessionState, clearSessionState, updateSessionTerminalId } from './session';
 import { config, delay, getRterm, getCurrentWorkspaceFolder } from './util';
 import { rGuestService, isGuestSession } from './liveShare';
 import * as fs from 'fs';
@@ -167,7 +167,15 @@ export async function createRTerm(preserveshow?: boolean): Promise<boolean> {
     rTerm.show(preserveshow);
     
     if (termOptions.env?.SESS_PORT && termOptions.env?.SESS_TOKEN) {
-        startSessionWatcher(Number(termOptions.env.SESS_PORT), termOptions.env.SESS_TOKEN);
+        const port = Number(termOptions.env.SESS_PORT);
+        const token = termOptions.env.SESS_TOKEN;
+        startSessionWatcher(port, token);
+        void rTerm.processId.then((pid) => {
+            if (pid) {
+                saveSessionState(pid, port, token);
+                updateSessionTerminalId(port, pid);
+            }
+        });
     }
     
     return true;
@@ -187,6 +195,7 @@ export function deleteTerminal(term: vscode.Terminal): void {
         if (config().get<boolean>('sessionWatcher')) {
             void term.processId.then((v) => {
                 if (v) {
+                    clearSessionState(v);
                     void cleanupSession(v.toString());
                 }
             });
diff --git a/src/session.ts b/src/session.ts
index c82e686d..6dcd802b 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -5,6 +5,7 @@ import * as os from 'os';
 import * as path from 'path';
 import { Agent } from 'http';
 import fetch from 'node-fetch';
+import * as vscode from 'vscode';
 import { commands, StatusBarItem, Uri, ViewColumn, Webview, window, workspace, env, WebviewPanelOnDidChangeViewStateEvent, WebviewPanel } from 'vscode';
 
 import { runTextInTerm, restartRTerminal } from './rTerminal';
@@ -41,6 +42,22 @@ export interface SessionServer {
     token: string;
 }
 
+export class Session {
+    public server: SessionServer;
+    public ws: WebSocket;
+    public pid: string;
+    public rVer: string;
+    public info: any;
+    public sessionDir: string;
+    public workingDir: string;
+    public workspaceData: WorkspaceData;
+
+    constructor(server: SessionServer, ws: WebSocket) {
+        this.server = server;
+        this.ws = ws;
+    }
+}
+
 export let workspaceData: WorkspaceData;
 let resDir: string;
 export let requestFile: string;
@@ -56,6 +73,9 @@ let info: any;
 const httpAgent = new Agent({ keepAlive: true });
 export let server: SessionServer | undefined;
 export let workspaceFile: string;
+
+const sessions = new Map<string, Session>();
+export let activeSession: Session | undefined;
 let workspaceLockFile: string;
 let workspaceTimeStamp: number;
 let plotFile: string;
@@ -81,31 +101,53 @@ export function deploySessionWatcher(extensionPath: string): void {
     });
 }
 
-import * as WebSocket from 'ws';
+import WebSocket from "ws";
 
-let wsClient: WebSocket.WebSocket | undefined;
+let wsClient: WebSocket | undefined;
+const activeConnections = new Map<number, WebSocket>();
 
-export function startSessionWatcher(port: number, token: string): void {
+export function startSessionWatcher(port: number, token: string, terminalPid?: number): void {
+    if (activeConnections.has(port)) {
+        console.info(`[startSessionWatcher] Already connected to port ${port}`);
+        const ws = activeConnections.get(port);
+        if (ws?.readyState === WebSocket.OPEN) {
+            wsClient = ws;
+            if (terminalPid) {
+                (ws as any)._terminalPid = terminalPid;
+            }
+            server = { host: '127.0.0.1', port, token };
+            return;
+        } else {
+            activeConnections.delete(port);
+        }
+    }
+    
     console.info(`[startSessionWatcher] Connecting to ws://127.0.0.1:${port}?token=${token}`);
     
     let retries = 0;
     const connect = () => {
         const url = `ws://127.0.0.1:${port}?token=${token}`;
-        const ws = new WebSocket.WebSocket(url);
+        const ws = new WebSocket(url);
         
         ws.on('open', () => {
             console.info('[startSessionWatcher] Connected');
             wsClient = ws;
+            (ws as any)._port = port;
+            (ws as any)._token = token;
+            if (terminalPid) {
+                (ws as any)._terminalPid = terminalPid;
+            }
+            activeConnections.set(port, ws);
             server = { host: '127.0.0.1', port, token };
             retries = 0;
         });
         
-        ws.on('message', (data: WebSocket.Data) => {
+        ws.on('message', (data: any) => {
             void (async () => {
                 try {
                     const message = JSON.parse(data.toString()) as Record<string, unknown>;
                     if (!message.id) {
-                        await handleNotification(message);
+                        await handleNotification(message, ws);
                     } else {
                         await handleRequest(message, ws);
                     }                } catch (e) {
@@ -116,11 +158,16 @@ export function startSessionWatcher(port: number, token: string): void {
         
         ws.on('close', () => {
             console.info('[startSessionWatcher] Disconnected');
-            wsClient = undefined;
+            if (activeConnections.get(port) === ws) {
+                activeConnections.delete(port);
+                if (wsClient === ws) {
+                    wsClient = undefined;
+                }
+            }
         });
         
         ws.on('error', (err: Error) => {
-            if (retries < 10 && !wsClient) {
+            if (retries < 10 && !activeConnections.has(port)) {
                 retries++;
                 setTimeout(connect, 500);
             }
@@ -130,6 +177,34 @@ export function startSessionWatcher(port: number, token: string): void {
     connect();
 }
 
+export function saveSessionState(pid: number, port: number, token: string): void {
+    const sessionsMap = extensionContext.workspaceState.get<Record<string, { port: number, token: string }>>('r.sessions', {});
+    sessionsMap[String(pid)] = { port, token };
+    void extensionContext.workspaceState.update('r.sessions', sessionsMap);
+}
+
+export function clearSessionState(pid: number): void {
+    const sessionsMap = extensionContext.workspaceState.get<Record<string, { port: number, token: string }>>('r.sessions', {});
+    delete sessionsMap[String(pid)];
+    void extensionContext.workspaceState.update('r.sessions', sessionsMap);
+}
+
+export function discoverSessions(): void {
+    const persistedSessions = extensionContext.workspaceState.get<Record<string, { port: number, token: string }>>('r.sessions', {});
+    
+    void (async () => {
+        // Scan existing terminals
+        for (const terminal of window.terminals) {
+            const pidArg = await terminal.processId;
+            if (pidArg && persistedSessions[String(pidArg)]) {
+                const sessionData = persistedSessions[String(pidArg)];
+                console.info(`[discoverSessions] Found R session for PID ${pidArg} in workspaceState: ws://127.0.0.1:${sessionData.port}?token=${sessionData.token}`);
+                startSessionWatcher(sessionData.port, sessionData.token);
+            }
+        }
+    })();
+}
+
 export function attachActive(): void {
     if (config().get<boolean>('sessionWatcher')) {
         console.info('[attachActive]');
@@ -678,35 +753,86 @@ export async function writeSuccessResponse(responseSessionDir: string): Promise<
 
 import * as rstudioapi from './rstudioapi';
 
-async function handleNotification(message: Record<string, unknown>) {
+export async function activateSession(session: Session): Promise<void> {
+    activeSession = session;
+    wsClient = session.ws;
+    server = session.server;
+    pid = session.pid;
+    rVer = session.rVer;
+    info = session.info;
+    sessionDir = session.sessionDir;
+    workingDir = session.workingDir;
+    
+    if (sessionStatusBarItem) {
+        sessionStatusBarItem.text = `R ${rVer}: ${pid}`;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/restrict-template-expressions
+        sessionStatusBarItem.tooltip = `${info?.version}\nProcess ID: ${pid}\nCommand: ${info?.command}\nStart time: ${info?.start_time}\nClick to attach to active terminal.`;
+        sessionStatusBarItem.show();
+    }
+    await setContext('rSessionActive', true);
+    rWorkspace?.refresh();
+}
+
+export async function switchSessionByTerminal(terminal: vscode.Terminal | undefined): Promise<void> {
+    if (!terminal) {
+        return;
+    }
+    const terminalPid = await terminal.processId;
+    if (terminalPid) {
+        // Try to find a session that matches this terminal PID
+        const session = sessions.get(String(terminalPid));
+        if (session) {
+            await activateSession(session);
+        }
+    }
+}
+
+export function updateSessionTerminalId(port: number, terminalPid: number): void {
+    const ws = activeConnections.get(port);
+    if (ws) {
+        (ws as any)._terminalPid = terminalPid;
+    }
+}
+
+async function handleNotification(message: Record<string, unknown>, ws: WebSocket) {
     const method = String(message.method);
     const params = (message.params as Record<string, unknown>) || {};
-    
+
     console.info(`[handleNotification] method: ${method}, params: ${JSON.stringify(params)}`);
 
     switch (method) {
         case 'attach': {
             if (!params.tempdir || !params.wd) {return;}
-            rVer = String(params.version);
-            pid = String(params.pid);
-            info = params.info;
-            sessionDir = path.join(String(params.tempdir), 'vscode-R');
-            workingDir = String(params.wd);
-            console.info(`[startSessionWatcher] attach PID: ${pid}`);
-            if (sessionStatusBarItem) {
-                sessionStatusBarItem.text = `R ${rVer}: ${pid}`;
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/restrict-template-expressions
-                sessionStatusBarItem.tooltip = `${info?.version}\nProcess ID: ${pid}\nCommand: ${info?.command}\nStart time: ${info?.start_time}\nClick to attach to active terminal.`;
-                sessionStatusBarItem.show();
+            const rPid = String(params.pid);
+            const terminalPid = (ws as any)._terminalPid ? String((ws as any)._terminalPid) : rPid;
+            
+            let session = sessions.get(terminalPid);
+            if (!session) {
+                session = new Session({ host: '127.0.0.1', port: (ws as any)._port, token: (ws as any)._token }, ws);
+                sessions.set(terminalPid, session);
+                // Also map R PID if it's different
+                if (rPid !== terminalPid) {
+                    sessions.set(rPid, session);
+                }
             }
+            session.rVer = String(params.version);
+            session.pid = rPid;
+            session.info = params.info;
+            session.sessionDir = path.join(String(params.tempdir), 'vscode-R');
+            session.workingDir = String(params.wd);
+
+            // Switch active session
+            await activateSession(session);
+
+            console.info(`[startSessionWatcher] attach R PID: ${rPid}, terminal PID: ${terminalPid}`);
             purgeAddinPickerItems();
-            await setContext('rSessionActive', true);
             if (params.plot_url) {
                 await globalHttpgdManager?.showViewer(String(params.plot_url));
             }
-            void watchProcess(pid).then((v: string) => { void cleanupSession(v); });
+            void watchProcess(rPid).then((v: string) => { void cleanupSession(v); });
             break;
         }
+
         // case 'detach': {
         //     if (params.pid) {
         //         await cleanupSession(String(params.pid));
@@ -760,7 +886,7 @@ async function handleNotification(message: Record<string, unknown>) {
     }
 }
 
-async function handleRequest(message: Record<string, unknown>, ws: WebSocket.WebSocket) {
+async function handleRequest(message: Record<string, unknown>, ws: WebSocket) {
     if (message.method) {
         const method = String(message.method);
         const params = (message.params as Record<string, unknown>) || {};

From 2dc1aafc22033970472a0ab23ca488a69a2bca79 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 12:26:05 -0700
Subject: [PATCH 17/47] Move 0/1 index conversion to VS Code and improve R
 robustness

---
 R/session/rstudioapi_util.R |  29 ++++++--
 sess/R/rstudioapi.R         | 132 +++++++++++++++++++++++++-----------
 src/rstudioapi.ts           |  10 ++-
 3 files changed, 120 insertions(+), 51 deletions(-)

diff --git a/R/session/rstudioapi_util.R b/R/session/rstudioapi_util.R
index da5fe0ff..c7b767d0 100644
--- a/R/session/rstudioapi_util.R
+++ b/R/session/rstudioapi_util.R
@@ -24,22 +24,37 @@ rstudioapi_patch_hook <- function(api_env) {
 }
 
 make_rs_range <- function(vsc_selection) {
-    # vscode positions are zero indexed
-    # rstudioapi is one indexed
+    if (is.null(vsc_selection$start$line) && !is.null(vsc_selection[["start.line"]])) {
+        start_line <- vsc_selection[["start.line"]]
+        start_character <- vsc_selection[["start.character"]]
+        end_line <- vsc_selection[["end.line"]]
+        end_character <- vsc_selection[["end.character"]]
+    } else {
+        start_line <- vsc_selection$start$line
+        start_character <- vsc_selection$start$character
+        end_line <- vsc_selection$end$line
+        end_character <- vsc_selection$end$character
+    }
     rstudioapi::document_range(
         start = rstudioapi::document_position(
-            row = vsc_selection$start$line + 1,
-            column = vsc_selection$start$character + 1
+            row = start_line,
+            column = start_character
         ),
         end = rstudioapi::document_position(
-            row = vsc_selection$end$line + 1,
-            column = vsc_selection$end$character + 1
+            row = end_line,
+            column = end_character
         )
     )
 }
 
 extract_document_ranges <- function(vsc_selections) {
-    lapply(vsc_selections, make_rs_range)
+    if (is.data.frame(vsc_selections)) {
+        lapply(seq_len(nrow(vsc_selections)), function(i) {
+            make_rs_range(as.list(vsc_selections[i, , drop = FALSE]))
+        })
+    } else {
+        lapply(vsc_selections, make_rs_range)
+    }
 }
 
 to_content_lines <- function(contents, ranges) {
diff --git a/sess/R/rstudioapi.R b/sess/R/rstudioapi.R
index e71575db..1cacf7b2 100644
--- a/sess/R/rstudioapi.R
+++ b/sess/R/rstudioapi.R
@@ -6,7 +6,9 @@ getActiveDocumentContext <- function() {
 getSourceEditorContext <- getActiveDocumentContext
 
 verifyAvailable <- function(version_needed = NULL) {
-    if (is.null(version_needed)) return(TRUE)
+    if (is.null(version_needed)) {
+        return(TRUE)
+    }
     getVersion() >= numeric_version(version_needed)
 }
 
@@ -25,7 +27,7 @@ insertText <- function(location, text, id = NULL) {
 
     normalised_location <- normalise_pos_or_range_arg(location)
     normalised_text <- normalise_text_arg(text, length(normalised_location))
-    
+
     query <- mapply(function(location, text) {
         list(
             operation = if (rstudioapi::is.document_range(location)) "modifyRange" else "insertText",
@@ -46,7 +48,9 @@ readRStudioPreference <- readPreference
 
 hasFun <- function(name, version_needed = NULL, ...) {
     if (!is.null(version_needed)) {
-        if (!verifyAvailable(version_needed)) return(FALSE)
+        if (!verifyAvailable(version_needed)) {
+            return(FALSE)
+        }
     }
     obj <- .sess_rstudioapi_env[[name]]
     is.function(obj) && !identical(obj, .sess_not_yet_implemented)
@@ -55,7 +59,7 @@ hasFun <- function(name, version_needed = NULL, ...) {
 findFun <- function(name, version_needed = NULL, ...) {
     if (!is.null(version_needed)) {
         if (!verifyAvailable(version_needed)) {
-             stop("the generic IPC client does not support used of 'version_needed' > 0.")
+            stop("the generic IPC client does not support used of 'version_needed' > 0.")
         }
     }
     if (hasFun(name, version_needed = version_needed, ...)) {
@@ -72,9 +76,9 @@ showDialog <- function(title, message, url = "") {
 
 navigateToFile <- function(file, line = 1L, column = 1L) {
     invisible(request_client("navigate_to_file", args = list(
-        file = normalizePath(file), 
-        line = line - 1L, 
-        column = column - 1L
+        file = normalizePath(file),
+        line = line,
+        column = column
     )))
 }
 
@@ -96,10 +100,10 @@ getActiveProject <- function() {
     path_object$path # Should be NULL if no project is open
 }
 
-.sess_document_context <- function(id = NULL) request_client("document_context", args = list(id = id))
+document_context <- function(id = NULL) request_client("document_context", args = list(id = id))
 
-documentId <- function(allowConsole = TRUE) .sess_document_context()$id$external
-documentPath <- function(id = NULL) .sess_document_context(id)$id$path
+documentId <- function(allowConsole = TRUE) document_context()$id$external
+documentPath <- function(id = NULL) document_context(id)$id$path
 
 documentSaveAll <- function() invisible(request_client("document_save_all", args = list()))
 
@@ -145,59 +149,95 @@ documentClose <- function(id = NULL, save = TRUE) {
 
 # Add missing helpers from rstudioapi_util
 make_rs_range <- function(sess_selection) {
+    if (is.null(sess_selection$start$line) && !is.null(sess_selection[["start.line"]])) {
+        start_line <- sess_selection[["start.line"]]
+        start_character <- sess_selection[["start.character"]]
+        end_line <- sess_selection[["end.line"]]
+        end_character <- sess_selection[["end.character"]]
+    } else {
+        start_line <- sess_selection$start$line
+        start_character <- sess_selection$start$character
+        end_line <- sess_selection$end$line
+        end_character <- sess_selection$end$character
+    }
     rstudioapi::document_range(
-        start = rstudioapi::document_position(row = sess_selection$start$line + 1, column = sess_selection$start$character + 1),
-        end = rstudioapi::document_position(row = sess_selection$end$line + 1, column = sess_selection$end$character + 1)
+        start = rstudioapi::document_position(row = start_line, column = start_character),
+        end = rstudioapi::document_position(row = end_line, column = end_character)
     )
 }
 
-extract_document_ranges <- function(sess_selections) lapply(sess_selections, make_rs_range)
+extract_document_ranges <- function(sess_selections) {
+    if (is.data.frame(sess_selections)) {
+        lapply(seq_len(nrow(sess_selections)), function(i) {
+            make_rs_range(as.list(sess_selections[i, , drop = FALSE]))
+        })
+    } else {
+        lapply(sess_selections, make_rs_range)
+    }
+}
 
 to_content_lines <- function(contents, ranges) {
     content_lines <- strsplit(contents, "\n|\r\n|\r$")[[1]]
-    if (length(ranges) == 0) return(content_lines)
+
+    if (length(ranges) == 0) {
+        return(content_lines)
+    }
+
     range_end_row <- unlist(lapply(ranges, function(range) range$end["row"]))
-    last_row <- max(range_end_row)
-    if (last_row == length(content_lines) + 1) content_lines <- c(content_lines, "")
+    last_row <- max(range_end_row, na.rm = TRUE)
+    if (is.finite(last_row) && last_row == length(content_lines) + 1) {
+        content_lines <- c(content_lines, "")
+    }
+
     content_lines
 }
 
 extract_range_text <- function(range, content_lines) {
-    if (!range_has_text(range)) return("")
+    if (!range_has_text(range)) {
+        return("")
+    }
     start_row <- range$start["row"]
     end_row <- range$end["row"]
-    if (start_row > length(content_lines)) return("")
-    
+    if (start_row > length(content_lines)) {
+        return("")
+    }
+
     content_rows <- content_lines[start_row:min(end_row, length(content_lines))]
-    
+
     # Adjust end
     if (end_row <= length(content_lines)) {
         content_rows[length(content_rows)] <- substring(content_rows[length(content_rows)], 1, range$end["column"] - 1)
     }
-    
+
     # Adjust start
     content_rows[1] <- substring(content_rows[1], range$start["column"])
-    
+
     paste0(content_rows, collapse = "\n")
 }
 
 range_has_text <- function(range) (range$end["row"] - range$start["row"]) + (range$end["column"] - range$start["column"]) > 0
 
 make_rs_document_selection <- function(ranges, range_texts) {
-    mapply(function(range, text) {
-        structure(list(range = range, text = text), class = "document_selection")
-    }, ranges, range_texts, SIMPLIFY = FALSE)
+    structure(
+        mapply(
+            function(range, text) {
+                list(range = range, text = text)
+            }, ranges, range_texts,
+            SIMPLIFY = FALSE
+        ),
+        class = "document_selection"
+    )
 }
 
-make_rs_document_context <- function(sess_editor_context) {
-    document_ranges <- extract_document_ranges(sess_editor_context$selection)
-    content_lines <- to_content_lines(sess_editor_context$contents, document_ranges)
+make_rs_document_context <- function(editor_context) {
+    document_ranges <- extract_document_ranges(editor_context$selection)
+    content_lines <- to_content_lines(editor_context$contents, document_ranges)
     document_range_texts <- lapply(document_ranges, extract_range_text, content_lines)
     document_selection <- make_rs_document_selection(document_ranges, document_range_texts)
     structure(list(
-        id = sess_editor_context$id$external, 
-        path = sess_editor_context$path, 
-        contents = content_lines, 
+        id = editor_context$id$external,
+        path = editor_context$path,
+        contents = content_lines,
         selection = document_selection
     ), class = "document_context")
 }
@@ -216,22 +256,33 @@ normalise_pos_or_range_arg <- function(location) {
         list(rstudioapi::as.document_range(location))
     } else if (is.list(location)) {
         lapply(location, function(a_location) {
-            if (rstudioapi::is.document_position(a_location) || rstudioapi::is.document_range(a_location)) a_location
-            else if (is_positionable(a_location)) rstudioapi::as.document_position(a_location)
-            else if (is_rangable((a_location))) rstudioapi::as.document_range(a_location)
-            else stop("object in location list was not a document_position or document_range")
+            if (rstudioapi::is.document_position(a_location) || rstudioapi::is.document_range(a_location)) {
+                a_location
+            } else if (is_positionable(a_location)) {
+                rstudioapi::as.document_position(a_location)
+            } else if (is_rangable((a_location))) {
+                rstudioapi::as.document_range(a_location)
+            } else {
+                stop("object in location list was not a document_position or document_range")
+            }
         })
-    } else stop("location object was not a document_position or document_range")
+    } else {
+        stop("location object was not a document_position or document_range")
+    }
 }
 
 normalise_text_arg <- function(text, location_length) {
-    if (length(text) == location_length) text
-    else if (length(text) == 1 && location_length > 1) rep(text, location_length)
-    else stop("text vector needs to be of length 1 or the same length as location list")
+    if (length(text) == location_length) {
+        text
+    } else if (length(text) == 1 && location_length > 1) {
+        rep(text, location_length)
+    } else {
+        stop("text vector needs to be of length 1 or the same length as location list")
+    }
 }
 
 serialize_pos <- function(pos) {
-    list(line = pos[["row"]] - 1, character = pos[["column"]] - 1)
+    as.numeric(c(pos[["row"]], pos[["column"]]))
 }
 
 serialize_range <- function(range) {
@@ -283,7 +334,6 @@ patch_rstudioapi <- function() {
         verifyAvailable = verifyAvailable,
         readPreference = readPreference,
         readRStudioPreference = readRStudioPreference,
-        
         getConsoleEditorContext = .sess_not_yet_implemented,
         sourceMarkers = .sess_not_yet_implemented,
         showPrompt = .sess_not_yet_implemented,
diff --git a/src/rstudioapi.ts b/src/rstudioapi.ts
index 72e47405..1c63b246 100644
--- a/src/rstudioapi.ts
+++ b/src/rstudioapi.ts
@@ -29,12 +29,16 @@ export function activeEditorContext() {
     // path
     // contents
     // selection - a list of selections
-    const currentDocument = getLastActiveTextEditor().document;
+    const currentEditor = getLastActiveTextEditor();
+    const currentDocument = currentEditor.document;
     return {
-        id: currentDocument.uri,
+        id: { external: currentDocument.uri.toString() },
         contents: currentDocument.getText(),
         path: currentDocument.fileName,
-        selection: getLastActiveTextEditor().selections
+        selection: currentEditor.selections.map(s => ({
+            start: { line: s.start.line + 1, character: s.start.character + 1 },
+            end: { line: s.end.line + 1, character: s.end.character + 1 }
+        }))
     };
 }
 

From 8b714f4adcec97a997e8ff6d566f59e73bead232 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 12:32:43 -0700
Subject: [PATCH 18/47] Update sess/README.md and implement document_close on
 client

---
 sess/README.md    | 70 ++++++++++++++++-------------------------------
 src/rstudioapi.ts | 15 ++++++++++
 src/session.ts    |  4 +++
 3 files changed, 42 insertions(+), 47 deletions(-)

diff --git a/sess/README.md b/sess/README.md
index 6a4d66a6..95aac043 100644
--- a/sess/README.md
+++ b/sess/README.md
@@ -40,23 +40,22 @@ The following methods are sent as notifications from R to the client:
 - **`plot_updated`**: Notifies that a new static plot is available. The client should request the `plot_latest` method via HTTP.
 - **`httpgd`**: Provides a URL for an `httpgd` live plot server (params: `url`).
 - **`help`**: Requests the client to display an R help page (params: `requestPath`).
-- **`browser`**: Requests the client to open a URL (params: `url`, `title`).
-- **`webview`**: Requests the client to open a local HTML file or URL in a webview (params: `file`, `title`).
+- **`browser`**: Requests the client to open a URL (params: `url`, `title`, `viewer`).
+- **`webview`**: Requests the client to open a local HTML file or URL in a webview (params: `file`, `title`, `viewer`).
 - **`restart_r`**: Requests the client to restart the R session (params: `command`, `clean`).
 - **`send_to_console`**: Sends code to the console for execution without blocking the R session (params: `code`, `execute`, `focus`, `animate`).
 
 #### 2. Synchronous Client Requests (`request_client`)
 
-The `request_client()` function allows R to call client-side functions synchronously by sending a **JSON-RPC Request** (with an `id`) over the WebSocket. This is primarily used to emulate the RStudio API:
+The `request_client()` function allows R to call client-side functions synchronously by sending a **JSON-RPC Request** (with an `id`) over the WebSocket. This is primarily used to emulate the RStudio API.
 
-1. R sends a request with `method` set to the action name (e.g., `"active_editor_context"`).
-2. R enters a `while` loop that calls `httpuv::service()`.
-3. The client processes the action and sends back a **JSON-RPC Response** (with the same id) via the WebSocket.
-4. R retrieves the `result` (or `error`) and returns it.
+**Coordinate Handling**: The `sess` protocol uses **1-indexed** coordinates for all rows (lines) and columns (characters) on the wire. This aligns with R's internal representation. The client (e.g., VS Code extension) is responsible for converting these to its internal 0-indexed representation if necessary.
 
-**Coordinate Handling**: The emulation layer automatically converts between R (1-indexed) and IPC (0-indexed) coordinates. Locations and ranges sent to the client are 0-indexed, while data received from the client (e.g., in `document_context`) is converted back to 1-indexed R objects.
+**Serialization Format**:
+- **Position**: A numeric array `[row, column]`.
+- **Range**: An object `{ "start": [row, column], "end": [row, column] }`.
 
-Below are all the JSON-RPC methods sent from R to the client to emulate RStudio API functionality:
+Below are the JSON-RPC methods sent from R to the client to emulate RStudio API functionality:
 
 - **`active_editor_context`**: Requests the current context of the active editor.
 - **`replace_text_in_current_selection`**: Replaces text in the current selection (params: `text`, `id`).
@@ -129,15 +128,21 @@ Returns the most recent static plot captured by the R session.
 
 ---
 
-## 3. Hook Registration
+## 3. Hook Registration & Options
 
 By default, the package does not inject hooks into the R session on load. Calling `sess::sess_app()` will start the server and automatically call `sess::register_hooks()` to enable features like automatic `View()` interception or plot redirection.
 
-If you need to manually register hooks without starting the full app environment (or re-register them if they were overridden), you can call:
-```r
-sess::register_hooks()
-```
-This rebinds internal functions (like `utils::View`) and sets `options()` for browsers, viewers, and devices to route through the IPC server.
+### Intercepted Functions
+- **`utils::View()`**: Redirects data to the client's data viewer. Supports `data.frame`, `matrix`, `list`, and `ArrowTabular` objects.
+- **`browser()`**, **`viewer()`**, **`page_viewer()`**: Redirects URLs and HTML files to the client's browser or webview.
+- **Help System**: Intercepts help topic printing to route HTML help to the client.
+
+### Global Options
+- **`sess.row_limit`**: Limits the number of rows sent to the data viewer (default: 100). Set to 0 for no limit.
+- **`sess.dataview`**: Target viewer column for data (default: `"Two"`).
+- **`sess.browser`**: Target viewer for browser (default: `"Active"`).
+- **`sess.webview`**: Target viewer for webview (default: `"Two"`).
+- **`sess.helpPanel`**: Target viewer for help (default: `"Two"`).
 
 ## 4. Comparison with Legacy IPC
 
@@ -153,37 +158,8 @@ The `sess` package replaces the legacy file-based IPC mechanism with a modern, i
 | **Transport Reliability**| OS-level File System Watchers | **WebSocket & HTTP streams** |
 | **Protocol Standard** | Ad-hoc JSON formats | **JSON-RPC 2.0** |
 
-### Detailed Mapping: Legacy to Modern
-
-**1. Command Dispatch (e.g., `View()`, `browser()`, `help()`)**
-- **Old Approach:** R intercepted commands and appended custom JSON structures to a `request.log` file, then updated the timestamp on a `request.lock` file. The client OS file watcher detected the `.lock` file change, read the `.log` file, and processed the pending commands.
-- **New Approach (`sess`):** R directly pushes an instantaneous **JSON-RPC Notification** (e.g., `method: "dataview"`, `method: "help"`) over the persistent WebSocket connection. The client receives and processes the payload instantly, bypassing disk I/O and file system watchers entirely.
-
-**2. Synchronous RStudio API Emulation**
-- **Old Approach:** R wrote a command to `request.log`, and then entered a blocking `while` loop aggressively polling for the creation of a `response.lock` file by the client.
-- **New Approach (`sess`):** R sends a **JSON-RPC Request** over the WebSocket with an `id`. It enters a `while` loop calling `httpuv::service()`, maintaining a responsive background state, and waits for a corresponding **JSON-RPC Response** with the matching `id` over the same WebSocket.
-
-**3. Workspace State (Global Environment)**
-- **Old Approach:** An R task callback ran after every top-level console execution, eagerly evaluating and serializing the entire Global Environment to a `workspace.json` file, followed by touching a `workspace.lock` file. The client watched for the lock file change to read the JSON file. This caused constant overhead and disk writes, even when the client's workspace pane was hidden.
-- **New Approach (`sess`):** Adopts a "Pull" architecture. The workspace is *only* evaluated and serialized when the client explicitly sends an **HTTP POST Request** to `/rpc` with `method: "workspace"`. This happens on-demand (e.g., when the UI pane is visible), saving significant R processing time and disk I/O.
-
-**4. Static Plots**
-- **Old Approach:** Plotting commands (via custom devices or hooks) generated a `plot.png` file on disk and updated a `plot.lock` file. The client watcher noticed the lock change, read the new PNG file from disk, and displayed it.
-- **New Approach (`sess`):** When a new plot is generated to a temporary file, R sends a lightweight **JSON-RPC Notification** (`method: "plot_updated"`) via the WebSocket. The client then pulls the actual image data by sending an **HTTP POST Request** to `/rpc` (`method: "plot_latest"`), which returns the base64-encoded image over the network stream.
-
-**5. Client Queries (Hover, Completion)**
-- **Old Approach:** R ran an internal `httpuv` server using custom JSON structures and ad-hoc request types (like `{ "type": "hover" }`).
-- **New Approach (`sess`):** Unified under the **JSON-RPC 2.0** standard. The client sends structured requests with strict `id` and `params` formatting to the single `/rpc` HTTP endpoint, receiving standardized JSON-RPC responses.
-
 ### Architectural Shifts
 
-1. **Elimination of File Watchers**: The legacy system relied heavily on OS-level file system watchers (`fs.watch`) monitoring lock files to trigger client updates. This approach could be unreliable or slow across different platforms, network drives, and remote container environments. `sess` replaces this entirely with persistent WebSocket connections for instantaneous, reliable event pushing.
-2. **On-Demand vs. Eager Evaluation**: Previously, R would eagerly evaluate and serialize the entire Global Environment to `workspace.json` frequently (e.g., via task callbacks), incurring significant continuous disk I/O and processing overhead. `sess` shifts this to a "Pull" model. The client requests the workspace state only when needed, significantly reducing R's background workload.
-3. **Unified Standard**: Instead of maintaining separate, disparate mechanisms for command logs, lock-file polling loops, JSON dumps, and custom HTTP query payloads, `sess` unifies all structured communication under the ubiquitous **JSON-RPC 2.0** standard across WebSocket and HTTP transports.
-
-### Responsiveness and the Event Loop
-
-Because R is fundamentally single-threaded, both IPC mechanisms are constrained by the R event loop, but they surface this limitation differently to the client:
-
-- **The "Busy" State**: If R is executing a long-running computation, the `httpuv` server running inside the session cannot process incoming HTTP requests (such as a request for `/rpc` `workspace` or `completion`). 
-- **Active vs. Passive Waiting**: In the legacy system, the client passively waited for `workspace.lock` to change, effectively ignoring the busy state until the operation completed. With the `sess` HTTP RPC model, the client actively requests data. Therefore, the client *must* implement short, aggressive timeouts (e.g., 500ms) for these HTTP requests. If a timeout occurs, the client gracefully interprets this as "R is busy" and can display a loading state without locking up the IDE's UI thread.
+1. **Elimination of File Watchers**: Replaces unreliable OS-level file system watchers with persistent WebSocket connections for instantaneous event pushing.
+2. **On-Demand Evaluation**: Evaluations of the Global Environment are now performed only when requested by the client ("Pull" model), reducing R's background workload.
+3. **Unified Standard**: Unifies all structured communication under the **JSON-RPC 2.0** standard across WebSocket and HTTP transports.
diff --git a/src/rstudioapi.ts b/src/rstudioapi.ts
index 1c63b246..76e1181b 100644
--- a/src/rstudioapi.ts
+++ b/src/rstudioapi.ts
@@ -153,6 +153,21 @@ export async function documentSaveAll(): Promise<void> {
     await workspace.saveAll();
 }
 
+export async function documentClose(id: string, save: boolean): Promise<void> {
+    const target = findTargetUri(id);
+    const targetDocument = await workspace.openTextDocument(target);
+    if (save) {
+        await targetDocument.save();
+    }
+    // VS Code doesn't have a direct "close document" API that takes a Document.
+    // We have to show it and then execute the close editor command, 
+    // or use more complex workbench commands.
+    const editor = await window.showTextDocument(targetDocument, { preserveFocus: true, preview: true });
+    if (editor) {
+        await commands.executeCommand('workbench.action.closeActiveEditor');
+    }
+}
+
 // TODO: very similar to ./utils.getCurrentWorkspaceFolder()
 export function projectPath(): { path: string | undefined; } {
 
diff --git a/src/session.ts b/src/session.ts
index 6dcd802b..1941ab92 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -936,6 +936,10 @@ async function handleRequest(message: Record<string, unknown>, ws: WebSocket) {
                     await rstudioapi.documentNew(String(params.text), String(params.type), params.position as number[]);
                     result = true;
                     break;
+                case 'document_close':
+                    await rstudioapi.documentClose(String(params.id), Boolean(params.save));
+                    result = true;
+                    break;
                 default:
                     throw new Error(`Unsupported method: ${method}`);
             }

From 3af1388944300b3a652bec68db5dd994a9eceb72 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 15:32:22 -0700
Subject: [PATCH 19/47] Allow null id in RStudio API calls to refer to active
 document

---
 src/rstudioapi.ts | 16 ++++++++--------
 src/session.ts    | 12 ++++++------
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/rstudioapi.ts b/src/rstudioapi.ts
index 76e1181b..0bdb5088 100644
--- a/src/rstudioapi.ts
+++ b/src/rstudioapi.ts
@@ -9,11 +9,11 @@
 import {
     window, TextEditor, TextDocument, Uri,
     workspace, WorkspaceEdit, Position, Range, Selection,
-    QuickPickItem, QuickPickOptions, ViewColumn
+    QuickPickItem, QuickPickOptions, ViewColumn, commands
 } from 'vscode';
 import { readJSON } from 'fs-extra';
 import * as path from 'path';
-import { sessionDir, sessionDirectoryExists, writeResponse, writeSuccessResponse } from './session';
+import { sessionDir, sessionDirectoryExists } from './session';
 import { runTextInTerm, restartRTerminal, chooseTerminal } from './rTerminal';
 import { config } from './util';
 
@@ -42,12 +42,12 @@ export function activeEditorContext() {
     };
 }
 
-export async function documentContext(id: string) {
+export async function documentContext(id: string | null) {
     const target = findTargetUri(id);
     const targetDocument = await workspace.openTextDocument(target);
     console.info(`[documentContext] getting context for: ${target.path}`);
     return {
-        id: targetDocument.uri
+        id: { external: targetDocument.uri.toString() }
     };
 }
 
@@ -81,7 +81,7 @@ export async function insertOrModifyText(query: any[], id: string | null = null)
     void workspace.applyEdit(edit);
 }
 
-export async function replaceTextInCurrentSelection(text: string, id: string): Promise<void> {
+export async function replaceTextInCurrentSelection(text: string, id: string | null): Promise<void> {
     const target = findTargetUri(id);
     console.info(`[replaceTextInCurrentSelection] inserting: ${text} into ${target.path}`);
     const edit = new WorkspaceEdit();
@@ -108,7 +108,7 @@ export async function navigateToFile(file: string, line: number, column: number)
     editor.revealRange(new Range(targetPosition, targetPosition));
 }
 
-export async function setSelections(ranges: number[][], id: string): Promise<void> {
+export async function setSelections(ranges: number[][], id: string | null): Promise<void> {
     // Setting selections can only be done on TextEditors not TextDocuments, but
     // it is the latter which are the things actually referred to by `id`. In
     // VSCode it's not possible to get a list of the open text editors. it is not
@@ -143,7 +143,7 @@ export async function setSelections(ranges: number[][], id: string): Promise<voi
     editor.selections = selectionObjects;
 }
 
-export async function documentSave(id: string): Promise<void> {
+export async function documentSave(id: string | null): Promise<void> {
     const target = findTargetUri(id);
     const targetDocument = await workspace.openTextDocument(target);
     await targetDocument.save();
@@ -153,7 +153,7 @@ export async function documentSaveAll(): Promise<void> {
     await workspace.saveAll();
 }
 
-export async function documentClose(id: string, save: boolean): Promise<void> {
+export async function documentClose(id: string | null, save: boolean): Promise<void> {
     const target = findTargetUri(id);
     const targetDocument = await workspace.openTextDocument(target);
     if (save) {
diff --git a/src/session.ts b/src/session.ts
index 1941ab92..9555244a 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -899,11 +899,11 @@ async function handleRequest(message: Record<string, unknown>, ws: WebSocket) {
                     result = rstudioapi.activeEditorContext();
                     break;
                 case 'insert_or_modify_text':
-                    await rstudioapi.insertOrModifyText(params.query as any[], String(params.id));
+                    await rstudioapi.insertOrModifyText(params.query as any[], params.id as string | null);
                     result = true;
                     break;
                 case 'replace_text_in_current_selection':
-                    await rstudioapi.replaceTextInCurrentSelection(String(params.text), String(params.id));
+                    await rstudioapi.replaceTextInCurrentSelection(String(params.text), params.id as string | null);
                     result = true;
                     break;
                 case 'show_dialog':
@@ -915,11 +915,11 @@ async function handleRequest(message: Record<string, unknown>, ws: WebSocket) {
                     result = true;
                     break;
                 case 'set_selection_ranges':
-                    await rstudioapi.setSelections(params.ranges as number[][], String(params.id));
+                    await rstudioapi.setSelections(params.ranges as number[][], params.id as string | null);
                     result = true;
                     break;
                 case 'document_save':
-                    await rstudioapi.documentSave(String(params.id));
+                    await rstudioapi.documentSave(params.id as string | null);
                     result = true;
                     break;
                 case 'document_save_all':
@@ -930,14 +930,14 @@ async function handleRequest(message: Record<string, unknown>, ws: WebSocket) {
                     result = rstudioapi.projectPath();
                     break;
                 case 'document_context':
-                    result = await rstudioapi.documentContext(String(params.id));
+                    result = await rstudioapi.documentContext(params.id as string | null);
                     break;
                 case 'document_new':
                     await rstudioapi.documentNew(String(params.text), String(params.type), params.position as number[]);
                     result = true;
                     break;
                 case 'document_close':
-                    await rstudioapi.documentClose(String(params.id), Boolean(params.save));
+                    await rstudioapi.documentClose(params.id as string | null, Boolean(params.save));
                     result = true;
                     break;
                 default:

From 410b7e2e9f2ef374a8a5728968ae6f6e93e4f7d1 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 15:32:49 -0700
Subject: [PATCH 20/47] Rename attachActive to activateRSession and improve
 session management

---
 package.json                  |  6 ++--
 src/extension.ts              |  6 ++--
 src/liveShare/index.ts        |  4 +--
 src/liveShare/shareSession.ts | 14 ++++----
 src/rstudioapi.ts             | 14 +++-----
 src/session.ts                | 64 +++++++++++++++++++++++++++--------
 6 files changed, 69 insertions(+), 39 deletions(-)

diff --git a/package.json b/package.json
index f87934a1..816f0d5b 100644
--- a/package.json
+++ b/package.json
@@ -393,9 +393,9 @@
         "command": "r.generateCCppProperties"
       },
       {
-        "title": "Attach Active Terminal",
+        "title": "Activate R Session",
         "category": "R",
-        "command": "r.attachActive"
+        "command": "r.activateRSession"
       },
       {
         "title": "Run Command With Selection or Word in Terminal",
@@ -1993,7 +1993,7 @@
   "scripts": {
     "vscode:prepublish": "tsc -p ./html/help && tsc -p ./html/httpgd && node esbuild.js --production",
     "changelog": "npx git-cliff v2.8.5.. -o",
-    "build": "tsc -p ./html/help && tsc -p ./html/httpgd && node esbuild.js",
+    "build": "tsc -p ./html/help && tsc -p ./html/httpgd && node esbuild.js && Rscript -e 'devtools::install(\"sess\")'",
     "watch": "node esbuild.js --watch",
     "watchHelp": "tsc -p ./html/help --watch",
     "watchHttpgd": "tsc -p ./html/httpgd --watch",
diff --git a/src/extension.ts b/src/extension.ts
index 8a66c707..495992ff 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -133,7 +133,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<apiImp
         // interaction with R sessions
         'r.previewDataframe': preview.previewDataframe,
         'r.previewEnvironment': preview.previewEnvironment,
-        'r.attachActive': session.attachActive,
+        'r.activateRSession': session.activateRSession,
         'r.launchAddinPicker': rstudioapi.launchAddinPicker,
 
         // workspace viewer
@@ -233,9 +233,9 @@ export async function activate(context: vscode.ExtensionContext): Promise<apiImp
             // create status bar item that contains info about the session watcher
             console.info('Create sessionStatusBarItem');
             sessionStatusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 1000);
-            sessionStatusBarItem.command = 'r.attachActive';
+            sessionStatusBarItem.command = 'r.activateRSession';
             sessionStatusBarItem.text = 'R: (not attached)';
-            sessionStatusBarItem.tooltip = 'Click to attach active terminal.';
+            sessionStatusBarItem.tooltip = 'Click to activate or focus R session.';
             sessionStatusBarItem.show();
             context.subscriptions.push(sessionStatusBarItem);
         }
diff --git a/src/liveShare/index.ts b/src/liveShare/index.ts
index e1830569..20e6df67 100644
--- a/src/liveShare/index.ts
+++ b/src/liveShare/index.ts
@@ -9,7 +9,7 @@ import * as vsls from 'vsls';
 import * as fs from 'fs-extra';
 
 import { enableSessionWatcher, extensionContext } from '../extension';
-import { attachActiveGuest, browserDisposables, initGuest } from './shareSession';
+import { activateRSessionGuest, browserDisposables, initGuest } from './shareSession';
 import { initTreeView, rLiveShareProvider, shareWorkspace, ToggleNode } from './shareTree';
 import { Commands, Callback, liveShareOnRequest, liveShareRequest } from './shareCommands';
 
@@ -93,7 +93,7 @@ export async function initLiveShare(context: vscode.ExtensionContext): Promise<v
             );
         } else {
             context.subscriptions.push(
-                vscode.commands.registerCommand('r.attachActiveGuest', () => attachActiveGuest())
+                vscode.commands.registerCommand('r.activateRSessionGuest', () => activateRSessionGuest())
             );
         }
     }
diff --git a/src/liveShare/shareSession.ts b/src/liveShare/shareSession.ts
index d11b930e..c74fca2e 100644
--- a/src/liveShare/shareSession.ts
+++ b/src/liveShare/shareSession.ts
@@ -49,9 +49,9 @@ export function initGuest(context: vscode.ExtensionContext): void {
     // create status bar item that contains info about the *guest* session watcher
     console.info('Create guestSessionStatusBarItem');
     const sessionStatusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 1000);
-    sessionStatusBarItem.command = 'r.attachActiveGuest';
+    sessionStatusBarItem.command = 'r.activateRSessionGuest';
     sessionStatusBarItem.text = 'Guest R: (not attached)';
-    sessionStatusBarItem.tooltip = 'Click to attach to host terminal';
+    sessionStatusBarItem.tooltip = 'Click to activate host R session';
     sessionStatusBarItem.show();
     context.subscriptions.push(
         sessionStatusBarItem,
@@ -64,14 +64,14 @@ export function initGuest(context: vscode.ExtensionContext): void {
 export function detachGuest(): void {
     console.info('[Guest Service] detach guest from workspace');
     sessionStatusBarItem.text = 'Guest R: (not attached)';
-    sessionStatusBarItem.tooltip = 'Click to attach to host terminal';
+    sessionStatusBarItem.tooltip = 'Click to activate host R session';
     guestWorkspace = undefined;
     rWorkspace?.refresh();
 }
 
-export function attachActiveGuest(): void {
+export function activateRSessionGuest(): void {
     if (config().get<boolean>('sessionWatcher', true)) {
-        console.info('[attachActiveGuest]');
+        console.info('[activateRSessionGuest]');
         void rGuestService?.requestAttach();
     } else {
         void vscode.window.showInformationMessage('This command requires that r.sessionWatcher be enabled.');
@@ -101,7 +101,7 @@ export async function updateGuestRequest(file: string, force: boolean = false):
         guestPid = String(request.pid);
         console.info(`[updateGuestRequest] attach PID: ${guestPid}`);
         sessionStatusBarItem.text = `Guest R: ${guestPid}`;
-        sessionStatusBarItem.tooltip = 'Click to attach to host terminal.';
+        sessionStatusBarItem.tooltip = 'Click to activate host R session';
         sessionStatusBarItem.show();
     }
 
@@ -129,7 +129,7 @@ export async function updateGuestRequest(file: string, force: boolean = false):
                 console.info(`[updateGuestRequest] attach PID: ${guestPid}`);
                 sessionStatusBarItem.text = `Guest R ${rVer}: ${guestPid}`;
                 // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                sessionStatusBarItem.tooltip = `${info?.version || 'unknown version'}\nProcess ID: ${guestPid}\nCommand: ${info?.command}\nStart time: ${info?.start_time}\nClick to attach to host terminal.`;
+                sessionStatusBarItem.tooltip = `${info?.version || 'unknown version'}\nProcess ID: ${guestPid}\nCommand: ${info?.command}\nStart time: ${info?.start_time}\nClick to activate host R session`;
                 sessionStatusBarItem.show();
                 break;
             }
diff --git a/src/rstudioapi.ts b/src/rstudioapi.ts
index 0bdb5088..4b417d75 100644
--- a/src/rstudioapi.ts
+++ b/src/rstudioapi.ts
@@ -9,7 +9,7 @@
 import {
     window, TextEditor, TextDocument, Uri,
     workspace, WorkspaceEdit, Position, Range, Selection,
-    QuickPickItem, QuickPickOptions, ViewColumn, commands
+    QuickPickItem, QuickPickOptions, ViewColumn
 } from 'vscode';
 import { readJSON } from 'fs-extra';
 import * as path from 'path';
@@ -155,17 +155,13 @@ export async function documentSaveAll(): Promise<void> {
 
 export async function documentClose(id: string | null, save: boolean): Promise<void> {
     const target = findTargetUri(id);
-    const targetDocument = await workspace.openTextDocument(target);
     if (save) {
+        const targetDocument = await workspace.openTextDocument(target);
         await targetDocument.save();
     }
-    // VS Code doesn't have a direct "close document" API that takes a Document.
-    // We have to show it and then execute the close editor command, 
-    // or use more complex workbench commands.
-    const editor = await window.showTextDocument(targetDocument, { preserveFocus: true, preview: true });
-    if (editor) {
-        await commands.executeCommand('workbench.action.closeActiveEditor');
-    }
+    const tabs = window.tabGroups.all.flatMap(g => g.tabs);
+    const targetTabs = tabs.filter(t => (t.input as any)?.uri?.toString() === target.toString());
+    await window.tabGroups.close(targetTabs);
 }
 
 // TODO: very similar to ./utils.getCurrentWorkspaceFolder()
diff --git a/src/session.ts b/src/session.ts
index 9555244a..fa88a572 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -8,14 +8,14 @@ import fetch from 'node-fetch';
 import * as vscode from 'vscode';
 import { commands, StatusBarItem, Uri, ViewColumn, Webview, window, workspace, env, WebviewPanelOnDidChangeViewStateEvent, WebviewPanel } from 'vscode';
 
-import { runTextInTerm, restartRTerminal } from './rTerminal';
+import { restartRTerminal, createRTerm } from './rTerminal';
 import { FSWatcher } from 'fs-extra';
 import { config, readContent, setContext, UriIcon } from './util';
 import { purgeAddinPickerItems } from './rstudioapi';
 
 import { IRequest } from './liveShare/shareSession';
 import { homeExtDir, rWorkspace, globalRHelp, globalHttpgdManager, extensionContext, sessionStatusBarItem } from './extension';
-import { UUID, rHostService, rGuestService, isLiveShare, isHost, isGuestSession, closeBrowser, guestResDir, shareBrowser, openVirtualDoc, shareWorkspace } from './liveShare';
+import { UUID, rHostService, rGuestService, isLiveShare, isHost, isGuestSession, closeBrowser, guestResDir, shareBrowser, openVirtualDoc } from './liveShare';
 
 export interface GlobalEnv {
     [key: string]: {
@@ -205,13 +205,54 @@ export function discoverSessions(): void {
     })();
 }
 
-export function attachActive(): void {
+export async function activateRSession(): Promise<void> {
     if (config().get<boolean>('sessionWatcher')) {
-        console.info('[attachActive]');
-        void runTextInTerm('if (requireNamespace("sess", quietly = TRUE)) sess::sess_app()');
-        if (isLiveShare() && shareWorkspace) {
-            rHostService?.notifyRequest(requestFile, true);
+        console.info('[activateRSession]');
+        const terminal = window.activeTerminal;
+        if (terminal) {
+            const pidArg = await terminal.processId;
+            if (pidArg) {
+                // 1. Check if we already have a session for this PID
+                const session = sessions.get(String(pidArg));
+                if (session) {
+                    await activateSession(session);
+                    terminal.show();
+                    return;
+                }
+
+                // 2. Check if we have an active connection that hasn't "attached" yet
+                for (const ws of activeConnections.values()) {
+                    if ((ws as any)._terminalPid === pidArg) {
+                        terminal.show();
+                        return; // Already connecting/connected
+                    }
+                }
+
+                // 3. Check if we have persisted state for this PID
+                const persistedSessions = extensionContext.workspaceState.get<Record<string, { port: number, token: string }>>('r.sessions', {});
+                if (persistedSessions[String(pidArg)]) {
+                    const sessionData = persistedSessions[String(pidArg)];
+                    startSessionWatcher(sessionData.port, sessionData.token, pidArg);
+                    terminal.show();
+                    return;
+                }
+            }
         }
+
+        // If we reached here, either there's no active terminal or it's not managed.
+        // We focus the terminal of the active session if it exists.
+        if (activeSession) {
+            for (const term of window.terminals) {
+                const termPid = await term.processId;
+                if (termPid && sessions.get(String(termPid)) === activeSession) {
+                    term.show();
+                    return;
+                }
+            }
+        }
+
+        // Otherwise, create a new R terminal
+        await createRTerm();
     } else {
         void window.showInformationMessage('This command requires that r.sessionWatcher be enabled.');
     }
@@ -743,14 +784,6 @@ function isFromWorkspace(dir: string) {
     return false;
 }
 
-export async function writeResponse(responseData: Record<string, unknown>, responseSessionDir: string): Promise<void> {
-    // Deprecated
-}
-
-export async function writeSuccessResponse(responseSessionDir: string): Promise<void> {
-    // Deprecated
-}
-
 import * as rstudioapi from './rstudioapi';
 
 export async function activateSession(session: Session): Promise<void> {
@@ -965,6 +998,7 @@ export async function cleanupSession(pidArg: string): Promise<void> {
             sessionStatusBarItem.tooltip = 'Click to attach active terminal.';
         }
         server = undefined;
+        activeSession = undefined;
         workspaceData.globalenv = {};
         workspaceData.loaded_namespaces = [];
         workspaceData.search = [];

From 15c621ca1be7972572325cf9f9d000eb661761db Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 15:58:50 -0700
Subject: [PATCH 21/47] Implement workspace synchronization for sess protocol

---
 sess/R/hooks.R | 9 +++++++++
 src/session.ts | 9 ++++++++-
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/sess/R/hooks.R b/sess/R/hooks.R
index 072750a5..f2400056 100644
--- a/sess/R/hooks.R
+++ b/sess/R/hooks.R
@@ -228,4 +228,13 @@ register_hooks <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
       patch_rstudioapi()
     }
   }
+
+  # 6. Workspace Update Callback
+  # This notifies the client whenever a top-level command is completed,
+  # suggesting that the Global Environment might have changed.
+  removeTaskCallback("sess.workspace")
+  addTaskCallback(function(...) {
+    notify_client("workspace_updated")
+    TRUE
+  }, name = "sess.workspace")
 }
diff --git a/src/session.ts b/src/session.ts
index fa88a572..04335088 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -124,6 +124,9 @@ export function startSessionWatcher(port: number, token: string, terminalPid?: n
     
     console.info(`[startSessionWatcher] Connecting to ws://127.0.0.1:${port}?token=${token}`);
     
+    // Initialize server object immediately so HTTP requests can proceed
+    server = { host: '127.0.0.1', port, token };
+
     let retries = 0;
     const connect = () => {
         const url = `ws://127.0.0.1:${port}?token=${token}`;
@@ -138,7 +141,6 @@ export function startSessionWatcher(port: number, token: string, terminalPid?: n
                 (ws as any)._terminalPid = terminalPid;
             }
             activeConnections.set(port, ws);
-            server = { host: '127.0.0.1', port, token };
             retries = 0;
         });
         
@@ -862,6 +864,7 @@ async function handleNotification(message: Record<string, unknown>, ws: WebSocke
             if (params.plot_url) {
                 await globalHttpgdManager?.showViewer(String(params.plot_url));
             }
+            void updateWorkspace(); // Initial workspace fetch
             void watchProcess(rPid).then((v: string) => { void cleanupSession(v); });
             break;
         }
@@ -872,6 +875,10 @@ async function handleNotification(message: Record<string, unknown>, ws: WebSocke
         //     }
         //     break;
         // }
+        case 'workspace_updated': {
+            void updateWorkspace();
+            break;
+        }
         case 'help': {
             if (globalRHelp && params.requestPath) {
                 await globalRHelp.showHelpForPath(String(params.requestPath), params.viewer);

From a8552f0767c9b944fc14dc546265f1d5dcc8046f Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 16:06:24 -0700
Subject: [PATCH 22/47] Fix TypeScript compilation errors and restore test
 setup

---
 src/completions.ts      | 30 ++++++++++++++++--------------
 src/session.ts          |  5 +++++
 src/test/suite/index.ts |  2 +-
 tsconfig.json           |  1 +
 4 files changed, 23 insertions(+), 15 deletions(-)

diff --git a/src/completions.ts b/src/completions.ts
index f9a365c8..ce26e526 100644
--- a/src/completions.ts
+++ b/src/completions.ts
@@ -54,7 +54,7 @@ export class HoverProvider implements vscode.HoverProvider {
             const response = await session.sessionRequest(session.server, {
                 method: 'hover',
                 params: { expr: expr }
-            });
+            }) as { str: string };
 
             if (response) {
                 hoverText = response.str;
@@ -62,7 +62,7 @@ export class HoverProvider implements vscode.HoverProvider {
 
         } else {
             const symbol = document.getText(hoverRange);
-            const str = session.workspaceData.globalenv[symbol]?.str;
+            const str = session.activeSession?.workspaceData.globalenv[symbol]?.str;
 
             if (str) {
                 hoverText = str;
@@ -137,7 +137,8 @@ export class LiveCompletionItemProvider implements vscode.CompletionItemProvider
         completionContext: vscode.CompletionContext
     ): Promise<vscode.CompletionItem[]> {
         const items: vscode.CompletionItem[] = [];
-        if (token.isCancellationRequested || !session.workspaceData?.globalenv) {
+        const activeSession = session.activeSession;
+        if (token.isCancellationRequested || !activeSession?.workspaceData?.globalenv) {
             return items;
         }
 
@@ -152,8 +153,9 @@ export class LiveCompletionItemProvider implements vscode.CompletionItemProvider
         const trigger = completionContext.triggerCharacter;
 
         if (trigger === undefined) {
-            Object.keys(session.workspaceData.globalenv).forEach((key) => {
-                const obj = session.workspaceData.globalenv[key];
+            const globalenv: session.GlobalEnv = activeSession.workspaceData.globalenv;
+            Object.keys(globalenv).forEach((key) => {
+                const obj = globalenv[key];
                 const item = new vscode.CompletionItem(
                     key,
                     obj.type === 'closure' || obj.type === 'builtin'
@@ -170,10 +172,10 @@ export class LiveCompletionItemProvider implements vscode.CompletionItemProvider
                 const re = /([a-zA-Z0-9._$@ ])+(?<![@$])/;
                 const exprRange = document.getWordRangeAtPosition(symbolPosition, re)?.with({ end: symbolPosition });
                 const expr = document.getText(exprRange);
-                const response: RObjectElement[] = await session.sessionRequest(session.server, {
+                const response = await session.sessionRequest(session.server, {
                     method: 'completion',
                     params: { expr: expr, trigger: completionContext.triggerCharacter }
-                });
+                }) as RObjectElement[];
 
                 if (response) {
                     items.push(...getCompletionItemsFromElements(response, '[session]'));
@@ -182,7 +184,7 @@ export class LiveCompletionItemProvider implements vscode.CompletionItemProvider
                 const symbolRange = document.getWordRangeAtPosition(symbolPosition);
                 const symbol = document.getText(symbolRange);
                 const doc = new vscode.MarkdownString('Element of `' + symbol + '`');
-                const obj = session.workspaceData.globalenv[symbol];
+                const obj = activeSession.workspaceData.globalenv[symbol];
                 let names: string[] | undefined;
                 if (obj !== undefined) {
                     if (completionContext.triggerCharacter === '$') {
@@ -200,11 +202,11 @@ export class LiveCompletionItemProvider implements vscode.CompletionItemProvider
         }
 
         if (trigger === undefined || trigger === '[' || trigger === ',' || trigger === '"' || trigger === '\'') {
-            items.push(...getBracketCompletionItems(document, position, token));
+            items.push(...getBracketCompletionItems(document, position, token, activeSession));
         }
 
         if (trigger === undefined || trigger === '(' || trigger === ',') {
-            items.push(...getPipelineCompletionItems(document, position, token));
+            items.push(...getPipelineCompletionItems(document, position, token, activeSession));
         }
 
         return items;
@@ -243,7 +245,7 @@ function getCompletionItems(names: string[], kind: vscode.CompletionItemKind, de
     });
 }
 
-function getBracketCompletionItems(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): vscode.CompletionItem[] {
+function getBracketCompletionItems(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken, activeSession: session.Session): vscode.CompletionItem[] {
     const items: vscode.CompletionItem[] = [];
     let range: vscode.Range | undefined = new vscode.Range(new vscode.Position(position.line, 0), position);
     let expectOpenBrackets = 0;
@@ -276,7 +278,7 @@ function getBracketCompletionItems(document: vscode.TextDocument, position: vsco
     }
 
     if (!token.isCancellationRequested && symbol !== undefined) {
-        const obj = session.workspaceData.globalenv[symbol];
+        const obj = activeSession.workspaceData.globalenv[symbol];
         if (obj !== undefined && obj.names !== undefined) {
             const doc = new vscode.MarkdownString('Element of `' + symbol + '`');
             items.push(...getCompletionItems(obj.names, vscode.CompletionItemKind.Variable, '[session]', doc));
@@ -285,7 +287,7 @@ function getBracketCompletionItems(document: vscode.TextDocument, position: vsco
     return items;
 }
 
-function getPipelineCompletionItems(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): vscode.CompletionItem[] {
+function getPipelineCompletionItems(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken, activeSession: session.Session): vscode.CompletionItem[] {
     const items: vscode.CompletionItem[] = [];
     const range = extendSelection(position.line, (x) => document.lineAt(x).text, document.lineCount);
     let symbol: string | undefined = undefined;
@@ -321,7 +323,7 @@ function getPipelineCompletionItems(document: vscode.TextDocument, position: vsc
     }
 
     if (!token.isCancellationRequested && symbol !== undefined) {
-        const obj = session.workspaceData.globalenv[symbol];
+        const obj = activeSession.workspaceData.globalenv[symbol];
         if (obj !== undefined && obj.names !== undefined) {
             const doc = new vscode.MarkdownString('Element of `' + symbol + '`');
             items.push(...getCompletionItems(obj.names, vscode.CompletionItemKind.Variable, '[session]', doc));
diff --git a/src/session.ts b/src/session.ts
index 04335088..a0ed8082 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -55,6 +55,11 @@ export class Session {
     constructor(server: SessionServer, ws: WebSocket) {
         this.server = server;
         this.ws = ws;
+        this.pid = '';
+        this.rVer = '';
+        this.sessionDir = '';
+        this.workingDir = '';
+        this.workspaceData = { search: [], loaded_namespaces: [], globalenv: {} };
     }
 }
 
diff --git a/src/test/suite/index.ts b/src/test/suite/index.ts
index a7429214..2092bc00 100644
--- a/src/test/suite/index.ts
+++ b/src/test/suite/index.ts
@@ -3,7 +3,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 
 import * as path from 'path';
-import * as Mocha from 'mocha';
+import Mocha from 'mocha';
 import { glob } from 'glob';
 
 export function run(): Promise<void> {
diff --git a/tsconfig.json b/tsconfig.json
index 53b31c95..e0464827 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -10,6 +10,7 @@
         "sourceMap": true,
         "rootDir": "src",
         "strict": true,
+        "esModuleInterop": true,
         "noFallthroughCasesInSwitch": true
     },
     "exclude": [

From c525673d83cd278224f47001f8b4a45bed855134 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 16:15:45 -0700
Subject: [PATCH 23/47] Migrate to VS Code Test CLI (@vscode/test-cli)

---
 .vscode-test.mjs | 10 ++++++++++
 package.json     |  7 ++++---
 2 files changed, 14 insertions(+), 3 deletions(-)
 create mode 100644 .vscode-test.mjs

diff --git a/.vscode-test.mjs b/.vscode-test.mjs
new file mode 100644
index 00000000..b14544dd
--- /dev/null
+++ b/.vscode-test.mjs
@@ -0,0 +1,10 @@
+import { defineConfig } from '@vscode/test-cli';
+
+export default defineConfig({
+	files: 'out/test/suite/**/*.test.js',
+	mocha: {
+		ui: 'tdd',
+		color: true,
+		timeout: 20000
+	}
+});
diff --git a/package.json b/package.json
index 816f0d5b..27c83cd7 100644
--- a/package.json
+++ b/package.json
@@ -1998,7 +1998,7 @@
     "watchHelp": "tsc -p ./html/help --watch",
     "watchHttpgd": "tsc -p ./html/httpgd --watch",
     "pretest": "tsc -p ./",
-    "test": "node ./out/test/runTest.js",
+    "test": "vscode-test",
     "lint": "eslint src --ext ts"
   },
   "devDependencies": {
@@ -2015,8 +2015,10 @@
     "@types/sinon": "^10.0.13",
     "@types/vscode": "^1.75.0",
     "@types/winreg": "^1.2.31",
+    "@types/ws": "^8.5.5",
     "@typescript-eslint/eslint-plugin": "^5.30.0",
     "@typescript-eslint/parser": "^5.30.0",
+    "@vscode/test-cli": "^0.0.9",
     "@vscode/test-electron": "^2.2.3",
     "esbuild": "^0.27.3",
     "eslint": "^7.28.0",
@@ -2024,8 +2026,7 @@
     "git-cliff": "^2.8.0",
     "mocha": "^11.1.0",
     "sinon": "^15.0.1",
-    "typescript": "^4.7.2",
-    "@types/ws": "^8.5.5"
+    "typescript": "^4.7.2"
   },
   "dependencies": {
     "ag-grid-community": "^31.3.2",

From 9747fa08187069d61ab5ee0c88c2b93612302129 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 16:16:03 -0700
Subject: [PATCH 24/47] Complete migration to VS Code Test CLI: update lockfile
 and remove obsolete files

---
 package-lock.json       | 485 ++++++++++++++++++++++++++++++++++++++--
 src/test/runTest.ts     |  23 --
 src/test/suite/index.ts |  41 ----
 3 files changed, 471 insertions(+), 78 deletions(-)
 delete mode 100644 src/test/runTest.ts
 delete mode 100644 src/test/suite/index.ts

diff --git a/package-lock.json b/package-lock.json
index 7b88816f..0e1ae834 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -22,7 +22,8 @@
         "node-fetch": "^2.6.7",
         "vscode-languageclient": "^9.0.1",
         "vsls": "^1.0.4753",
-        "winreg": "^1.2.4"
+        "winreg": "^1.2.4",
+        "ws": "^8.13.0"
       },
       "devDependencies": {
         "@types/cheerio": "^0.22.29",
@@ -38,8 +39,10 @@
         "@types/sinon": "^10.0.13",
         "@types/vscode": "^1.75.0",
         "@types/winreg": "^1.2.31",
+        "@types/ws": "^8.5.5",
         "@typescript-eslint/eslint-plugin": "^5.30.0",
         "@typescript-eslint/parser": "^5.30.0",
+        "@vscode/test-cli": "^0.0.9",
         "@vscode/test-electron": "^2.2.3",
         "esbuild": "^0.27.3",
         "eslint": "^7.28.0",
@@ -157,6 +160,13 @@
         "node": ">=4"
       }
     },
+    "node_modules/@bcoe/v8-coverage": {
+      "version": "0.2.3",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz",
+      "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@es-joy/jsdoccomment": {
       "version": "0.9.0-alpha.1",
       "resolved": "https://registry.npmjs.org/@es-joy/jsdoccomment/-/jsdoccomment-0.9.0-alpha.1.tgz",
@@ -779,6 +789,44 @@
         "url": "https://github.com/chalk/strip-ansi?sponsor=1"
       }
     },
+    "node_modules/@istanbuljs/schema": {
+      "version": "0.1.3",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@istanbuljs/schema/-/schema-0.1.3.tgz",
+      "integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
     "node_modules/@microsoft/servicehub-framework": {
       "version": "2.6.74",
       "resolved": "https://registry.npmjs.org/@microsoft/servicehub-framework/-/servicehub-framework-2.6.74.tgz",
@@ -1002,6 +1050,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/istanbul-lib-coverage": {
+      "version": "2.0.6",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz",
+      "integrity": "sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/js-yaml": {
       "version": "4.0.9",
       "resolved": "https://registry.npmjs.org/@types/js-yaml/-/js-yaml-4.0.9.tgz",
@@ -1337,6 +1392,243 @@
         "url": "https://opencollective.com/typescript-eslint"
       }
     },
+    "node_modules/@vscode/test-cli": {
+      "version": "0.0.9",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@vscode/test-cli/-/test-cli-0.0.9.tgz",
+      "integrity": "sha512-vsl5/ueE3Jf0f6XzB0ECHHMsd5A0Yu6StElb8a+XsubZW7kHNAOw4Y3TSSuDzKEpLnJ92nbMy1Zl+KLGCE6NaA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/mocha": "^10.0.2",
+        "c8": "^9.1.0",
+        "chokidar": "^3.5.3",
+        "enhanced-resolve": "^5.15.0",
+        "glob": "^10.3.10",
+        "minimatch": "^9.0.3",
+        "mocha": "^10.2.0",
+        "supports-color": "^9.4.0",
+        "yargs": "^17.7.2"
+      },
+      "bin": {
+        "vscode-test": "out/bin.mjs"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@vscode/test-cli/node_modules/@types/mocha": {
+      "version": "10.0.10",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/mocha/-/mocha-10.0.10.tgz",
+      "integrity": "sha512-xPyYSz1cMPnJQhl0CLMH68j3gprKZaTjG3s5Vi+fDgx+uhG9NOXwbVt52eFS8ECyXhyKcjDLCBEqBExKuiZb7Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@vscode/test-cli/node_modules/brace-expansion": {
+      "version": "2.0.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/@vscode/test-cli/node_modules/cliui": {
+      "version": "7.0.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/cliui/-/cliui-7.0.4.tgz",
+      "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.0",
+        "wrap-ansi": "^7.0.0"
+      }
+    },
+    "node_modules/@vscode/test-cli/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@vscode/test-cli/node_modules/minimatch": {
+      "version": "9.0.9",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/minimatch/-/minimatch-9.0.9.tgz",
+      "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.2"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/@vscode/test-cli/node_modules/mocha": {
+      "version": "10.8.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/mocha/-/mocha-10.8.2.tgz",
+      "integrity": "sha512-VZlYo/WE8t1tstuRmqgeyBgCbJc/lEdopaa+axcKzTBJ+UIdlAB9XnmvTCAH4pwR4ElNInaedhEBmZD8iCSVEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-colors": "^4.1.3",
+        "browser-stdout": "^1.3.1",
+        "chokidar": "^3.5.3",
+        "debug": "^4.3.5",
+        "diff": "^5.2.0",
+        "escape-string-regexp": "^4.0.0",
+        "find-up": "^5.0.0",
+        "glob": "^8.1.0",
+        "he": "^1.2.0",
+        "js-yaml": "^4.1.0",
+        "log-symbols": "^4.1.0",
+        "minimatch": "^5.1.6",
+        "ms": "^2.1.3",
+        "serialize-javascript": "^6.0.2",
+        "strip-json-comments": "^3.1.1",
+        "supports-color": "^8.1.1",
+        "workerpool": "^6.5.1",
+        "yargs": "^16.2.0",
+        "yargs-parser": "^20.2.9",
+        "yargs-unparser": "^2.0.0"
+      },
+      "bin": {
+        "_mocha": "bin/_mocha",
+        "mocha": "bin/mocha.js"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@vscode/test-cli/node_modules/mocha/node_modules/glob": {
+      "version": "8.1.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/glob/-/glob-8.1.0.tgz",
+      "integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==",
+      "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^5.0.1",
+        "once": "^1.3.0"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/@vscode/test-cli/node_modules/mocha/node_modules/minimatch": {
+      "version": "5.1.9",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/minimatch/-/minimatch-5.1.9.tgz",
+      "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@vscode/test-cli/node_modules/mocha/node_modules/supports-color": {
+      "version": "8.1.1",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/supports-color/-/supports-color-8.1.1.tgz",
+      "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/supports-color?sponsor=1"
+      }
+    },
+    "node_modules/@vscode/test-cli/node_modules/mocha/node_modules/yargs": {
+      "version": "16.2.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/yargs/-/yargs-16.2.0.tgz",
+      "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cliui": "^7.0.2",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.0",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^20.2.2"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@vscode/test-cli/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/@vscode/test-cli/node_modules/supports-color": {
+      "version": "9.4.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/supports-color/-/supports-color-9.4.0.tgz",
+      "integrity": "sha512-VL+lNrEoIXww1coLPOmiEmK/0sGigko5COxI09KzHc2VJXJsQ37UaQ+8quuxjDeA7+KnLGTWRyOXSLLR2Wb4jw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/supports-color?sponsor=1"
+      }
+    },
+    "node_modules/@vscode/test-cli/node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/@vscode/test-cli/node_modules/yargs-parser": {
+      "version": "20.2.9",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/yargs-parser/-/yargs-parser-20.2.9.tgz",
+      "integrity": "sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/@vscode/test-electron": {
       "version": "2.5.2",
       "resolved": "https://registry.npmjs.org/@vscode/test-electron/-/test-electron-2.5.2.tgz",
@@ -1559,6 +1851,32 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/c8": {
+      "version": "9.1.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/c8/-/c8-9.1.0.tgz",
+      "integrity": "sha512-mBWcT5iqNir1zIkzSPyI3NCR9EZCVI3WUD+AVO17MVWTSFNyUueXE82qTeampNtTr+ilN/5Ua3j24LgbCKjDVg==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "@bcoe/v8-coverage": "^0.2.3",
+        "@istanbuljs/schema": "^0.1.3",
+        "find-up": "^5.0.0",
+        "foreground-child": "^3.1.1",
+        "istanbul-lib-coverage": "^3.2.0",
+        "istanbul-lib-report": "^3.0.1",
+        "istanbul-reports": "^3.1.6",
+        "test-exclude": "^6.0.0",
+        "v8-to-istanbul": "^9.0.0",
+        "yargs": "^17.7.2",
+        "yargs-parser": "^21.1.1"
+      },
+      "bin": {
+        "c8": "bin/c8.js"
+      },
+      "engines": {
+        "node": ">=14.14.0"
+      }
+    },
     "node_modules/call-bind-apply-helpers": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
@@ -1831,6 +2149,13 @@
       "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
       "license": "MIT"
     },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/core-util-is": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
@@ -1946,9 +2271,9 @@
       }
     },
     "node_modules/diff": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/diff/-/diff-5.1.0.tgz",
-      "integrity": "sha512-D+mk+qE8VC/PAUrlAU34N+VfXev0ghe5ywmpqrawphmVZc1bEfn56uo9qpyGp1p4xpzOHkSW4ztBd6L7Xx4ACw==",
+      "version": "5.2.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/diff/-/diff-5.2.2.tgz",
+      "integrity": "sha512-vtcDfH3TOjP8UekytvnHH1o1P4FcUdt4eQ1Y+Abap1tk/OB2MWQvcwS2ClCd1zuIhc3JKOx6p3kod8Vfys3E+A==",
       "dev": true,
       "license": "BSD-3-Clause",
       "engines": {
@@ -2080,6 +2405,20 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/enhanced-resolve": {
+      "version": "5.20.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/enhanced-resolve/-/enhanced-resolve-5.20.0.tgz",
+      "integrity": "sha512-/ce7+jQ1PQ6rVXwe+jKEg5hW5ciicHwIQUagZkp6IufBoY3YDgdTTY1azVs0qoRgVmvsNB+rbjLJxDAeHHtwsQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.4",
+        "tapable": "^2.3.0"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
     "node_modules/enquirer": {
       "version": "2.4.1",
       "resolved": "https://registry.npmjs.org/enquirer/-/enquirer-2.4.1.tgz",
@@ -3206,6 +3545,13 @@
         "node": ">=12.0.0"
       }
     },
+    "node_modules/html-escaper": {
+      "version": "2.0.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/html-escaper/-/html-escaper-2.0.2.tgz",
+      "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/htmlparser2": {
       "version": "8.0.2",
       "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-8.0.2.tgz",
@@ -3491,6 +3837,45 @@
         "ws": "*"
       }
     },
+    "node_modules/istanbul-lib-coverage": {
+      "version": "3.2.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz",
+      "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/istanbul-lib-report": {
+      "version": "3.0.1",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz",
+      "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "istanbul-lib-coverage": "^3.0.0",
+        "make-dir": "^4.0.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/istanbul-reports": {
+      "version": "3.2.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/istanbul-reports/-/istanbul-reports-3.2.0.tgz",
+      "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "html-escaper": "^2.0.0",
+        "istanbul-lib-report": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/jackspeak": {
       "version": "3.4.3",
       "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz",
@@ -3722,6 +4107,22 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/make-dir": {
+      "version": "4.0.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/make-dir/-/make-dir-4.0.0.tgz",
+      "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "semver": "^7.5.3"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/math-intrinsics": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
@@ -3880,16 +4281,6 @@
         "balanced-match": "^1.0.0"
       }
     },
-    "node_modules/mocha/node_modules/diff": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/diff/-/diff-5.2.0.tgz",
-      "integrity": "sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">=0.3.1"
-      }
-    },
     "node_modules/mocha/node_modules/minimatch": {
       "version": "5.1.6",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
@@ -5028,6 +5419,57 @@
         "node": ">=8"
       }
     },
+    "node_modules/tapable": {
+      "version": "2.3.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/tapable/-/tapable-2.3.0.tgz",
+      "integrity": "sha512-g9ljZiwki/LfxmQADO3dEY1CbpmXT5Hm2fJ+QaGKwSXUylMybePR7/67YW7jOrrvjEgL1Fmz5kzyAjWVWLlucg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      }
+    },
+    "node_modules/test-exclude": {
+      "version": "6.0.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/test-exclude/-/test-exclude-6.0.0.tgz",
+      "integrity": "sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "@istanbuljs/schema": "^0.1.2",
+        "glob": "^7.1.4",
+        "minimatch": "^3.0.4"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/test-exclude/node_modules/glob": {
+      "version": "7.2.3",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/text-table": {
       "version": "0.2.0",
       "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
@@ -5166,6 +5608,21 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/v8-to-istanbul": {
+      "version": "9.3.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/v8-to-istanbul/-/v8-to-istanbul-9.3.0.tgz",
+      "integrity": "sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "^0.3.12",
+        "@types/istanbul-lib-coverage": "^2.0.1",
+        "convert-source-map": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=10.12.0"
+      }
+    },
     "node_modules/vscode-jsonrpc": {
       "version": "8.2.0",
       "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-8.2.0.tgz",
diff --git a/src/test/runTest.ts b/src/test/runTest.ts
deleted file mode 100644
index cc99580e..00000000
--- a/src/test/runTest.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import * as path from 'path';
-
-import { runTests } from '@vscode/test-electron';
-
-async function main() {
-    try {
-        // The folder containing the Extension Manifest package.json
-        // Passed to `--extensionDevelopmentPath`
-        const extensionDevelopmentPath = path.resolve(__dirname, '../../');
-
-        // The path to the extension test script
-        // Passed to --extensionTestsPath
-        const extensionTestsPath = path.resolve(__dirname, './suite/index');
-
-        // Download VS Code, unzip it and run the integration test
-        await runTests({ extensionDevelopmentPath, extensionTestsPath });
-    } catch (err) {
-        console.error('Failed to run tests');
-        process.exit(1);
-    }
-}
-
-void main();
diff --git a/src/test/suite/index.ts b/src/test/suite/index.ts
deleted file mode 100644
index 2092bc00..00000000
--- a/src/test/suite/index.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-
-import * as path from 'path';
-import Mocha from 'mocha';
-import { glob } from 'glob';
-
-export function run(): Promise<void> {
-    // Create the mocha test
-    const mocha = new Mocha({
-        ui: 'tdd',
-        color: true
-    });
-
-    const testsRoot = path.resolve(__dirname, '..');
-
-    return new Promise((c, e) => {
-        glob('**/**.test.js', { cwd: testsRoot })
-            .then(files => {
-                // Add files to the test suite
-                files.forEach(f => mocha.addFile(path.resolve(testsRoot, f)));
-
-                try {
-                    // Run the mocha test
-                    mocha.run(failures => {
-                        if (failures > 0) {
-                            e(new Error(`${failures} tests failed.`));
-                        } else {
-                            c();
-                        }
-                    });
-                } catch (err) {
-                    e(err);
-                }
-            })
-            .catch(err => {
-                return e(err);
-            });
-    });
-}

From 687728c2e20c35da431f07dc51c15d0683e451d5 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 18:44:23 -0700
Subject: [PATCH 25/47] Add and improve integration tests for R terminal and
 session PID verification

---
 src/test/suite/terminal.test.ts | 156 ++++++++++++++++++++++++++++++++
 1 file changed, 156 insertions(+)
 create mode 100644 src/test/suite/terminal.test.ts

diff --git a/src/test/suite/terminal.test.ts b/src/test/suite/terminal.test.ts
new file mode 100644
index 00000000..b4b3d72c
--- /dev/null
+++ b/src/test/suite/terminal.test.ts
@@ -0,0 +1,156 @@
+import * as vscode from 'vscode';
+import * as sinon from 'sinon';
+import * as assert from 'assert';
+import * as path from 'path';
+
+import { mockExtensionContext } from '../common/mockvscode';
+import * as rTerminal from '../../rTerminal';
+import * as util from '../../util';
+import * as session from '../../session';
+
+const extension_root: string = path.join(__dirname, '..', '..', '..');
+
+suite('R Terminal', () => {
+    let sandbox: sinon.SinonSandbox;
+
+    setup(() => {
+        sandbox = sinon.createSandbox();
+        mockExtensionContext(extension_root, sandbox);
+    });
+
+    teardown(() => {
+        sandbox.restore();
+    });
+
+    test('makeTerminalOptions sets session watcher environment variables', async () => {
+        // Stub config to enable sessionWatcher
+        const configStub = {
+            get: (key: string) => {
+                if (key === 'sessionWatcher') {
+                    return true;
+                }
+                if (key === 'rterm.option') {
+                    return ['--no-save'];
+                }
+                return undefined;
+            }
+        };
+        sandbox.stub(util, 'config').returns(configStub as any);
+        sandbox.stub(util, 'getRterm').resolves('/usr/local/bin/R');
+
+        const options = await rTerminal.makeTerminalOptions();
+
+        assert.strictEqual(options.name, 'R Interactive');
+        assert.ok(options.env);
+        assert.ok(options.env['SESS_PORT']);
+        assert.ok(options.env['SESS_TOKEN']);
+        assert.ok(options.env['R_PROFILE_USER']);
+        assert.ok(options.env['R_PROFILE_USER'].endsWith('R/profile.R'));
+    });
+
+    test('makeTerminalOptions does not set session watcher env if disabled', async () => {
+        const configStub = {
+            get: (key: string) => {
+                if (key === 'sessionWatcher') {
+                    return false;
+                }
+                return undefined;
+            }
+        };
+        sandbox.stub(util, 'config').returns(configStub as any);
+        sandbox.stub(util, 'getRterm').resolves('/usr/local/bin/R');
+
+        const options = await rTerminal.makeTerminalOptions();
+
+        assert.ok(options.env === undefined || options.env['SESS_PORT'] === undefined);
+    });
+
+    test('createRTerm and restartRTerminal integration test', async () => {
+        const configStub = {
+            get: (key: string) => {
+                if (key === 'sessionWatcher') {
+                    return true;
+                }
+                return undefined;
+            }
+        };
+        sandbox.stub(util, 'config').returns(configStub as any);
+        sandbox.stub(util, 'getRterm').resolves('/usr/local/bin/R');
+
+        // Spy on startSessionWatcher
+        const startSessionWatcherSpy = sandbox.spy(session, 'startSessionWatcher');
+
+        // First creation
+        const result = await rTerminal.createRTerm(true);
+        assert.ok(result, 'createRTerm should return true');
+        assert.ok(rTerminal.rTerm, 'rTerminal.rTerm should be defined');
+        const firstTerm = rTerminal.rTerm;
+
+        // Verify startSessionWatcher was called
+        const creationOptions = firstTerm.creationOptions as vscode.TerminalOptions;
+        assert.ok(startSessionWatcherSpy.calledOnce, 'startSessionWatcher should be called');
+        const firstPort = Number(creationOptions.env?.['SESS_PORT']);
+        const firstToken = creationOptions.env?.['SESS_TOKEN'] ?? undefined;
+        assert.ok(startSessionWatcherSpy.calledWith(firstPort, firstToken), 'startSessionWatcher should be called with correct port and token');
+
+        // Test restart
+        await rTerminal.restartRTerminal();
+        assert.ok(rTerminal.rTerm, 'rTerminal.rTerm should be defined after restart');
+        assert.notStrictEqual(rTerminal.rTerm, firstTerm, 'Restarted terminal should be a different object');
+        
+        // Verify startSessionWatcher was called again
+        assert.ok(startSessionWatcherSpy.calledTwice, 'startSessionWatcher should be called twice after restart');
+
+        // Clean up
+        rTerminal.rTerm?.dispose();
+    });
+
+    test('active R session PID matches terminal PID', async () => {
+        const configStub = {
+            get: (key: string) => {
+                if (key === 'sessionWatcher') {
+                    return true;
+                }
+                return undefined;
+            }
+        };
+        sandbox.stub(util, 'config').returns(configStub as any);
+        sandbox.stub(util, 'getRterm').resolves('/usr/local/bin/R');
+
+        // We need to mock the terminal and its processId
+        const fakeTerminal = {
+            name: 'R Interactive',
+            processId: Promise.resolve(1234),
+            show: () => { },
+            dispose: () => { },
+            sendText: () => { }
+        };
+        const createTerminalStub = sandbox.stub(vscode.window, 'createTerminal').returns(fakeTerminal as any);
+
+        const result = await rTerminal.createRTerm(true);
+        assert.ok(result);
+
+        // Manually trigger session activation as if the R process connected back
+        const fakeSession: any = {
+            pid: '1234',
+            rVer: '4.0.0',
+            info: {},
+            sessionDir: '',
+            workingDir: '',
+            workspaceData: { search: [], loaded_namespaces: [], globalenv: {} },
+            server: { host: '127.0.0.1', port: 1234, token: 'abc' },
+            ws: {} as any
+        };
+
+        await session.activateSession(fakeSession);
+
+        assert.ok(session.activeSession, 'Active session should be defined');
+        assert.ok(rTerminal.rTerm, 'rTerminal.rTerm should be defined');
+        const terminalPid = await rTerminal.rTerm.processId;
+        assert.strictEqual(session.activeSession.pid, String(terminalPid), 'Session PID should match terminal PID');
+
+        // Clean up
+        rTerminal.rTerm?.dispose();
+        createTerminalStub.restore();
+    });
+});

From 7c4015c464ffdd12f2cfa558e937f4aa5f4e3d8f Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 19:16:50 -0700
Subject: [PATCH 26/47] Implement terminal link provider for manual R session
 attachment

---
 sess/R/server.R  |  3 +++
 src/extension.ts |  1 +
 src/session.ts   | 31 +++++++++++++++++++++++++++++++
 3 files changed, 35 insertions(+)

diff --git a/sess/R/server.R b/sess/R/server.R
index 47ac5df8..fbf59794 100644
--- a/sess/R/server.R
+++ b/sess/R/server.R
@@ -105,6 +105,9 @@ sess_app <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
   .sess_env$server <- httpuv::startServer("127.0.0.1", port, app = app_handlers)
 
   # Print the connection string to the console.
+  # We use OSC 633;P;SessConnection=... to announce the connection to the terminal
+  # This is hidden in modern terminals but can be parsed by the extension.
+  cat(sprintf("\x1b]633;P;SessConnection=ws://127.0.0.1:%d?token=%s\x07", port, .sess_env$token))
   cat(sprintf("\n[sess] SESS_IPC_SERVER=ws://127.0.0.1:%d?token=%s\n", port, .sess_env$token))
 
   # Register runtime hooks
diff --git a/src/extension.ts b/src/extension.ts
index 495992ff..7b0a2950 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -229,6 +229,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<apiImp
             console.info('Initialize session watcher');
             void session.deploySessionWatcher(context.extensionPath);
             void session.discoverSessions();
+            context.subscriptions.push(session.setupTerminalLinkProvider());
 
             // create status bar item that contains info about the session watcher
             console.info('Create sessionStatusBarItem');
diff --git a/src/session.ts b/src/session.ts
index a0ed8082..c40c6663 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -1079,3 +1079,34 @@ export async function sessionRequest(server: SessionServer, data: Record<string,
         return undefined;
     }
 }
+
+interface SessionTerminalLink extends vscode.TerminalLink {
+    port: number;
+    token: string;
+}
+
+export function setupTerminalLinkProvider(): vscode.Disposable {
+    // One-click Link Provider (Stable API)
+    return vscode.window.registerTerminalLinkProvider({
+        provideTerminalLinks: (context: vscode.TerminalLinkContext) => {
+            const regex = /SESS_IPC_SERVER=ws:\/\/127.0.0.1:(\d+)\?token=([a-f0-9]+)/g;
+            const links: SessionTerminalLink[] = [];
+            let match;
+            while ((match = regex.exec(context.line)) !== null) {
+                links.push({
+                    startIndex: match.index,
+                    length: match[0].length,
+                    tooltip: 'Attach to R Session',
+                    port: Number(match[1]),
+                    token: match[2]
+                });
+            }
+            return links;
+        },
+        handleTerminalLink: async (link: SessionTerminalLink) => {
+            const terminal = vscode.window.activeTerminal;
+            const pidArg = await terminal?.processId;
+            startSessionWatcher(link.port, link.token, pidArg);
+        }
+    });
+}

From fd4524fc800d4c464ed0473bcb2e3aa9312c8438 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 20:31:32 -0700
Subject: [PATCH 27/47] Refactor session management: unify status bar reset,
 centralize session cleanup, and improve terminal link provider robustness

---
 sess/R/hooks.R   |  2 ++
 sess/R/server.R  |  7 +++--
 src/extension.ts |  3 +--
 src/rTerminal.ts |  1 -
 src/session.ts   | 66 ++++++++++++++++++++++++++++++++----------------
 5 files changed, 50 insertions(+), 29 deletions(-)

diff --git a/sess/R/hooks.R b/sess/R/hooks.R
index f2400056..8294c2e1 100644
--- a/sess/R/hooks.R
+++ b/sess/R/hooks.R
@@ -237,4 +237,6 @@ register_hooks <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
     notify_client("workspace_updated")
     TRUE
   }, name = "sess.workspace")
+
+  invisible(NULL)
 }
diff --git a/sess/R/server.R b/sess/R/server.R
index fbf59794..eb09bf36 100644
--- a/sess/R/server.R
+++ b/sess/R/server.R
@@ -105,11 +105,10 @@ sess_app <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
   .sess_env$server <- httpuv::startServer("127.0.0.1", port, app = app_handlers)
 
   # Print the connection string to the console.
-  # We use OSC 633;P;SessConnection=... to announce the connection to the terminal
-  # This is hidden in modern terminals but can be parsed by the extension.
-  cat(sprintf("\x1b]633;P;SessConnection=ws://127.0.0.1:%d?token=%s\x07", port, .sess_env$token))
-  cat(sprintf("\n[sess] SESS_IPC_SERVER=ws://127.0.0.1:%d?token=%s\n", port, .sess_env$token))
+  cat(sprintf("\nsess: ws://127.0.0.1:%d?token=%s\n\n", port, .sess_env$token))
 
   # Register runtime hooks
   register_hooks(use_rstudioapi = use_rstudioapi, use_httpgd = use_httpgd)
+
+  invisible(NULL)
 }
diff --git a/src/extension.ts b/src/extension.ts
index 7b0a2950..930e50b4 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -235,8 +235,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<apiImp
             console.info('Create sessionStatusBarItem');
             sessionStatusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 1000);
             sessionStatusBarItem.command = 'r.activateRSession';
-            sessionStatusBarItem.text = 'R: (not attached)';
-            sessionStatusBarItem.tooltip = 'Click to activate or focus R session.';
+            session.resetStatusBar();
             sessionStatusBarItem.show();
             context.subscriptions.push(sessionStatusBarItem);
         }
diff --git a/src/rTerminal.ts b/src/rTerminal.ts
index b02d36e3..e2de0c87 100644
--- a/src/rTerminal.ts
+++ b/src/rTerminal.ts
@@ -195,7 +195,6 @@ export function deleteTerminal(term: vscode.Terminal): void {
         if (config().get<boolean>('sessionWatcher')) {
             void term.processId.then((v) => {
                 if (v) {
-                    clearSessionState(v);
                     void cleanupSession(v.toString());
                 }
             });
diff --git a/src/session.ts b/src/session.ts
index c40c6663..e1ead15c 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -222,6 +222,7 @@ export async function activateRSession(): Promise<void> {
                 // 1. Check if we already have a session for this PID
                 const session = sessions.get(String(pidArg));
                 if (session) {
+                    console.info(`[activateRSession] Found existing session for PID: ${pidArg}`);
                     await activateSession(session);
                     terminal.show();
                     return;
@@ -230,6 +231,7 @@ export async function activateRSession(): Promise<void> {
                 // 2. Check if we have an active connection that hasn't "attached" yet
                 for (const ws of activeConnections.values()) {
                     if ((ws as any)._terminalPid === pidArg) {
+                        console.info(`[activateRSession] Already connecting/connected for PID: ${pidArg}`);
                         terminal.show();
                         return; // Already connecting/connected
                     }
@@ -238,6 +240,7 @@ export async function activateRSession(): Promise<void> {
                 // 3. Check if we have persisted state for this PID
                 const persistedSessions = extensionContext.workspaceState.get<Record<string, { port: number, token: string }>>('r.sessions', {});
                 if (persistedSessions[String(pidArg)]) {
+                    console.info(`[activateRSession] Found persisted session for PID: ${pidArg}`);
                     const sessionData = persistedSessions[String(pidArg)];
                     startSessionWatcher(sessionData.port, sessionData.token, pidArg);
                     terminal.show();
@@ -249,6 +252,7 @@ export async function activateRSession(): Promise<void> {
         // If we reached here, either there's no active terminal or it's not managed.
         // We focus the terminal of the active session if it exists.
         if (activeSession) {
+            console.info('[activateRSession] Focusing terminal of the active session');
             for (const term of window.terminals) {
                 const termPid = await term.processId;
                 if (termPid && sessions.get(String(termPid)) === activeSession) {
@@ -259,6 +263,7 @@ export async function activateRSession(): Promise<void> {
         }
 
         // Otherwise, create a new R terminal
+        console.info('[activateRSession] Creating new R terminal');
         await createRTerm();
     } else {
         void window.showInformationMessage('This command requires that r.sessionWatcher be enabled.');
@@ -813,17 +818,20 @@ export async function activateSession(session: Session): Promise<void> {
     rWorkspace?.refresh();
 }
 
-export async function switchSessionByTerminal(terminal: vscode.Terminal | undefined): Promise<void> {
-    if (!terminal) {
-        return;
+export function resetStatusBar(): void {
+    if (sessionStatusBarItem) {
+        sessionStatusBarItem.text = 'R: (not attached)';
+        sessionStatusBarItem.tooltip = 'Click to attach active terminal.';
     }
-    const terminalPid = await terminal.processId;
-    if (terminalPid) {
-        // Try to find a session that matches this terminal PID
-        const session = sessions.get(String(terminalPid));
-        if (session) {
-            await activateSession(session);
-        }
+}
+
+export async function switchSessionByTerminal(terminal: vscode.Terminal | undefined): Promise<void> {
+    const terminalPid = await terminal?.processId;
+    const session = terminalPid ? sessions.get(String(terminalPid)) : undefined;
+    if (session) {
+        await activateSession(session);
+    } else {
+        resetStatusBar();
     }
 }
 
@@ -1004,11 +1012,22 @@ async function handleRequest(message: Record<string, unknown>, ws: WebSocket) {
 }
 
 export async function cleanupSession(pidArg: string): Promise<void> {
-    if (pid === pidArg) {
-        if (sessionStatusBarItem) {
-            sessionStatusBarItem.text = 'R: (not attached)';
-            sessionStatusBarItem.tooltip = 'Click to attach active terminal.';
+    clearSessionState(Number(pidArg));
+    const session = sessions.get(pidArg);
+    if (session) {
+        // Find all keys in sessions that point to this session and remove them
+        const keysToRemove: string[] = [];
+        for (const [k, v] of sessions.entries()) {
+            if (v === session) {
+                keysToRemove.push(k);
+            }
         }
+        keysToRemove.forEach(k => sessions.delete(k));
+        // Terminate the WebSocket
+        session.ws.terminate();
+    }
+    if (activeSession === session || pid === pidArg) {
+        resetStatusBar();
         server = undefined;
         activeSession = undefined;
         workspaceData.globalenv = {};
@@ -1089,17 +1108,20 @@ export function setupTerminalLinkProvider(): vscode.Disposable {
     // One-click Link Provider (Stable API)
     return vscode.window.registerTerminalLinkProvider({
         provideTerminalLinks: (context: vscode.TerminalLinkContext) => {
-            const regex = /SESS_IPC_SERVER=ws:\/\/127.0.0.1:(\d+)\?token=([a-f0-9]+)/g;
+            const regex = /sess: ws:\/\/127\.0\.0\.1:(\d+)\?token=([a-z0-9]{32})/g;
             const links: SessionTerminalLink[] = [];
             let match;
             while ((match = regex.exec(context.line)) !== null) {
-                links.push({
-                    startIndex: match.index,
-                    length: match[0].length,
-                    tooltip: 'Attach to R Session',
-                    port: Number(match[1]),
-                    token: match[2]
-                });
+                const port = Number(match[1]);
+                if (!activeConnections.has(port)) {
+                    links.push({
+                        startIndex: match.index,
+                        length: match[0].length,
+                        tooltip: 'Click to attach R session',
+                        port: port,
+                        token: match[2]
+                    });
+                }
             }
             return links;
         },

From 65ded6030bde7c32522e1b64456f2adceb368b75 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 21:03:32 -0700
Subject: [PATCH 28/47] sess: Use unified tempdir for all temporary files

---
 sess/R/dispatch.R | 2 +-
 sess/R/hooks.R    | 4 ++--
 sess/R/server.R   | 8 ++++++--
 3 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/sess/R/dispatch.R b/sess/R/dispatch.R
index ca829119..849dcc0d 100644
--- a/sess/R/dispatch.R
+++ b/sess/R/dispatch.R
@@ -20,7 +20,7 @@ ipc_send <- function(method, params = list(), request = FALSE) {
 
   req_id <- NULL
   if (request) {
-    req_id <- basename(tempfile("req_"))
+    req_id <- basename(tempfile("req_", tmpdir = .sess_env$tempdir))
     msg$id <- req_id
   }
 
diff --git a/sess/R/hooks.R b/sess/R/hooks.R
index 8294c2e1..3ff4f7fd 100644
--- a/sess/R/hooks.R
+++ b/sess/R/hooks.R
@@ -88,7 +88,7 @@ register_hooks <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
     # make sure title is computed.
     force(title)
     # Dump to a temporary file locally so the payload size over WS isn't massive
-    file_path <- tempfile(fileext = ".json")
+    file_path <- tempfile(tmpdir = .sess_env$tempdir, fileext = ".json")
 
     row_limit <- abs(getOption("sess.row_limit", 100))
 
@@ -132,7 +132,7 @@ register_hooks <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
       ))
     } else {
       code <- if (is.primitive(x)) utils::capture.output(print(x)) else deparse(x)
-      file_path <- tempfile(fileext = ".R")
+      file_path <- tempfile(tmpdir = .sess_env$tempdir, fileext = ".R")
       writeLines(code, file_path)
       notify_client("dataview", list(
         title = title,
diff --git a/sess/R/server.R b/sess/R/server.R
index eb09bf36..6d284611 100644
--- a/sess/R/server.R
+++ b/sess/R/server.R
@@ -12,8 +12,12 @@ sess_app <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
   .sess_env$token <- if (nzchar(env_token)) env_token else paste0(sample(c(letters, 0:9), 32, replace = TRUE), collapse = "")
   .sess_env$pending_responses <- list()
 
+  # Specific tempdir for vscode-R
+  .sess_env$tempdir <- file.path(tempdir(), "sess")
+  dir.create(.sess_env$tempdir, showWarnings = FALSE, recursive = TRUE)
+
   # Temporary file for static plot serving
-  .sess_env$latest_plot_path <- file.path(tempdir(), "sess_plot.png")
+  .sess_env$latest_plot_path <- file.path(.sess_env$tempdir, "sess_plot.png")
 
   app_handlers <- list(
     # --- HTTP HANDLER (The "Pull" API) ---
@@ -70,7 +74,7 @@ sess_app <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
       notify_client("attach", list(
         version = sprintf("%s.%s", R.version$major, R.version$minor),
         pid = Sys.getpid(),
-        tempdir = tempdir(),
+        tempdir = .sess_env$tempdir,
         wd = getwd(),
         info = list(
           command = commandArgs()[[1L]],

From a93f756f8c42e8975ea618a14c074535f09ad504 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 21:06:42 -0700
Subject: [PATCH 29/47] Update sessionDir to use tempdir from sess directly

---
 src/session.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/session.ts b/src/session.ts
index e1ead15c..08e0e6b4 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -866,7 +866,7 @@ async function handleNotification(message: Record<string, unknown>, ws: WebSocke
             session.rVer = String(params.version);
             session.pid = rPid;
             session.info = params.info;
-            session.sessionDir = path.join(String(params.tempdir), 'vscode-R');
+            session.sessionDir = String(params.tempdir);
             session.workingDir = String(params.wd);
 
             // Switch active session

From fdd92af7e97cfe9a32369d48896ec64cefe55248 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 21:19:31 -0700
Subject: [PATCH 30/47] sess: Log client connection/disconnection to R console

---
 sess/R/server.R | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/sess/R/server.R b/sess/R/server.R
index 6d284611..82968422 100644
--- a/sess/R/server.R
+++ b/sess/R/server.R
@@ -69,6 +69,7 @@ sess_app <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
     onWSOpen = function(ws) {
       # Bind the active websocket to our environment
       .sess_env$ws <- ws
+      cat("[sess] Client connected\n")
 
       # Send the attach handshake immediately upon connection (JSON-RPC Notification)
       notify_client("attach", list(
@@ -99,6 +100,7 @@ sess_app <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
 
       ws$onClose(function() {
         .sess_env$ws <- NULL
+        cat("[sess] Client disconnected\n")
       })
     }
   )

From 223dd084d117dc17f475808066d14cfea7561a37 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 21:26:57 -0700
Subject: [PATCH 31/47] Implement manual R session connection via command and
 terminal links with URL highlighting

---
 package.json     |  5 +++++
 sess/R/server.R  |  2 +-
 src/extension.ts |  1 +
 src/session.ts   | 37 ++++++++++++++++++++++++++++++-------
 4 files changed, 37 insertions(+), 8 deletions(-)

diff --git a/package.json b/package.json
index 27c83cd7..a06565c5 100644
--- a/package.json
+++ b/package.json
@@ -397,6 +397,11 @@
         "category": "R",
         "command": "r.activateRSession"
       },
+      {
+        "title": "Connect to R Session",
+        "category": "R",
+        "command": "r.connectToSession"
+      },
       {
         "title": "Run Command With Selection or Word in Terminal",
         "category": "R",
diff --git a/sess/R/server.R b/sess/R/server.R
index 82968422..6045ca84 100644
--- a/sess/R/server.R
+++ b/sess/R/server.R
@@ -111,7 +111,7 @@ sess_app <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
   .sess_env$server <- httpuv::startServer("127.0.0.1", port, app = app_handlers)
 
   # Print the connection string to the console.
-  cat(sprintf("\nsess: ws://127.0.0.1:%d?token=%s\n\n", port, .sess_env$token))
+  cat(sprintf("\n[sess] Server address: ws://127.0.0.1:%d?token=%s\n\n", port, .sess_env$token))
 
   # Register runtime hooks
   register_hooks(use_rstudioapi = use_rstudioapi, use_httpgd = use_httpgd)
diff --git a/src/extension.ts b/src/extension.ts
index 930e50b4..7a3729c0 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -134,6 +134,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<apiImp
         'r.previewDataframe': preview.previewDataframe,
         'r.previewEnvironment': preview.previewEnvironment,
         'r.activateRSession': session.activateRSession,
+        'r.connectToSession': session.connectToSession,
         'r.launchAddinPicker': rstudioapi.launchAddinPicker,
 
         // workspace viewer
diff --git a/src/session.ts b/src/session.ts
index 08e0e6b4..b542b0f8 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -1108,27 +1108,50 @@ export function setupTerminalLinkProvider(): vscode.Disposable {
     // One-click Link Provider (Stable API)
     return vscode.window.registerTerminalLinkProvider({
         provideTerminalLinks: (context: vscode.TerminalLinkContext) => {
-            const regex = /sess: ws:\/\/127\.0\.0\.1:(\d+)\?token=([a-z0-9]{32})/g;
+            const regex = /\[sess\] Server address: (ws:\/\/127\.0\.0\.1:(\d+)\?token=([a-z0-9]{32}))/g;
             const links: SessionTerminalLink[] = [];
             let match;
             while ((match = regex.exec(context.line)) !== null) {
-                const port = Number(match[1]);
+                const url = match[1];
+                const port = Number(match[2]);
+                const token = match[3];
                 if (!activeConnections.has(port)) {
                     links.push({
-                        startIndex: match.index,
-                        length: match[0].length,
+                        startIndex: match.index + match[0].indexOf(url),
+                        length: url.length,
                         tooltip: 'Click to attach R session',
                         port: port,
-                        token: match[2]
+                        token: token
                     });
                 }
             }
             return links;
         },
         handleTerminalLink: async (link: SessionTerminalLink) => {
+            const url = `ws://127.0.0.1:${link.port}?token=${link.token}`;
+            await connectToSession(url);
+        }
+    });
+}
+
+export async function connectToSession(urlValue?: string): Promise<void> {
+    const url = await vscode.window.showInputBox({
+        value: urlValue,
+        prompt: 'Enter the R session WebSocket URL',
+        placeHolder: 'ws://127.0.0.1:PORT?token=TOKEN',
+        ignoreFocusOut: true
+    });
+    if (url) {
+        const regex = /ws:\/\/127\.0\.0\.1:(\d+)\?token=([a-z0-9]{32})/;
+        const match = regex.exec(url);
+        if (match) {
+            const port = Number(match[1]);
+            const token = match[2];
             const terminal = vscode.window.activeTerminal;
             const pidArg = await terminal?.processId;
-            startSessionWatcher(link.port, link.token, pidArg);
+            startSessionWatcher(port, token, pidArg);
+        } else {
+            void vscode.window.showErrorMessage('Invalid R session URL format.');
         }
-    });
+    }
 }

From a898aeeb85743756297b90d11c10ad085fb97dcd Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 21:35:34 -0700
Subject: [PATCH 32/47] lint: fix errors and warnings in session.ts

- Define SessionInfo and ExtWebSocket interfaces
- Remove unused imports (os, FSWatcher, IRequest, etc.)
- Remove unused functions (updateSessionWatcher, isFromWorkspace)
- Fix type safety for WebSocket and rstudioapi params
- Fix single quote and other minor lint issues
---
 src/session.ts | 108 +++++++++++++++++--------------------------------
 1 file changed, 38 insertions(+), 70 deletions(-)

diff --git a/src/session.ts b/src/session.ts
index b542b0f8..20bc23b9 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -1,21 +1,32 @@
 'use strict';
 
 import * as fs from 'fs-extra';
-import * as os from 'os';
 import * as path from 'path';
 import { Agent } from 'http';
 import fetch from 'node-fetch';
 import * as vscode from 'vscode';
-import { commands, StatusBarItem, Uri, ViewColumn, Webview, window, workspace, env, WebviewPanelOnDidChangeViewStateEvent, WebviewPanel } from 'vscode';
+import { commands, Uri, ViewColumn, Webview, window, workspace, env } from 'vscode';
 
 import { restartRTerminal, createRTerm } from './rTerminal';
-import { FSWatcher } from 'fs-extra';
 import { config, readContent, setContext, UriIcon } from './util';
 import { purgeAddinPickerItems } from './rstudioapi';
 
-import { IRequest } from './liveShare/shareSession';
 import { homeExtDir, rWorkspace, globalRHelp, globalHttpgdManager, extensionContext, sessionStatusBarItem } from './extension';
-import { UUID, rHostService, rGuestService, isLiveShare, isHost, isGuestSession, closeBrowser, guestResDir, shareBrowser, openVirtualDoc } from './liveShare';
+import { rHostService, rGuestService, isLiveShare, isHost, isGuestSession, guestResDir, shareBrowser, openVirtualDoc } from './liveShare';
+
+import WebSocket from 'ws';
+
+export interface SessionInfo {
+    version: string;
+    command: string;
+    start_time: string;
+}
+
+interface ExtWebSocket extends WebSocket {
+    _terminalPid?: number;
+    _port?: number;
+    _token?: string;
+}
 
 export interface GlobalEnv {
     [key: string]: {
@@ -47,7 +58,7 @@ export class Session {
     public ws: WebSocket;
     public pid: string;
     public rVer: string;
-    public info: any;
+    public info: SessionInfo;
     public sessionDir: string;
     public workingDir: string;
     public workspaceData: WorkspaceData;
@@ -57,6 +68,7 @@ export class Session {
         this.ws = ws;
         this.pid = '';
         this.rVer = '';
+        this.info = { version: '', command: '', start_time: '' };
         this.sessionDir = '';
         this.workingDir = '';
         this.workspaceData = { search: [], loaded_namespaces: [], globalenv: {} };
@@ -67,27 +79,17 @@ export let workspaceData: WorkspaceData;
 let resDir: string;
 export let requestFile: string;
 export let requestLockFile: string;
-let requestTimeStamp: number;
-let responseTimeStamp: number;
 export let sessionDir: string;
 export let workingDir: string;
 let rVer: string;
 let pid: string;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let info: any;
+let info: SessionInfo;
 const httpAgent = new Agent({ keepAlive: true });
 export let server: SessionServer | undefined;
 export let workspaceFile: string;
 
 const sessions = new Map<string, Session>();
 export let activeSession: Session | undefined;
-let workspaceLockFile: string;
-let workspaceTimeStamp: number;
-let plotFile: string;
-let plotLockFile: string;
-let plotTimeStamp: number;
-let workspaceWatcher: FSWatcher;
-let plotWatcher: FSWatcher;
 let activeBrowserUri: Uri | undefined;
 
 export function deploySessionWatcher(extensionPath: string): void {
@@ -106,10 +108,8 @@ export function deploySessionWatcher(extensionPath: string): void {
     });
 }
 
-import WebSocket from "ws";
-
-let wsClient: WebSocket | undefined;
-const activeConnections = new Map<number, WebSocket>();
+let wsClient: ExtWebSocket | undefined;
+const activeConnections = new Map<number, ExtWebSocket>();
 
 export function startSessionWatcher(port: number, token: string, terminalPid?: number): void {
     if (activeConnections.has(port)) {
@@ -118,7 +118,7 @@ export function startSessionWatcher(port: number, token: string, terminalPid?: n
         if (ws?.readyState === WebSocket.OPEN) {
             wsClient = ws;
             if (terminalPid) {
-                (ws as any)._terminalPid = terminalPid;
+                ws._terminalPid = terminalPid;
             }
             server = { host: '127.0.0.1', port, token };
             return;
@@ -135,21 +135,21 @@ export function startSessionWatcher(port: number, token: string, terminalPid?: n
     let retries = 0;
     const connect = () => {
         const url = `ws://127.0.0.1:${port}?token=${token}`;
-        const ws = new WebSocket(url);
+        const ws: ExtWebSocket = new WebSocket(url);
         
         ws.on('open', () => {
             console.info('[startSessionWatcher] Connected');
             wsClient = ws;
-            (ws as any)._port = port;
-            (ws as any)._token = token;
+            ws._port = port;
+            ws._token = token;
             if (terminalPid) {
-                (ws as any)._terminalPid = terminalPid;
+                ws._terminalPid = terminalPid;
             }
             activeConnections.set(port, ws);
             retries = 0;
         });
         
-        ws.on('message', (data: any) => {
+        ws.on('message', (data: WebSocket.Data) => {
             void (async () => {
                 try {
                     const message = JSON.parse(data.toString()) as Record<string, unknown>;
@@ -173,7 +173,7 @@ export function startSessionWatcher(port: number, token: string, terminalPid?: n
             }
         });
         
-        ws.on('error', (err: Error) => {
+        ws.on('error', () => {
             if (retries < 10 && !activeConnections.has(port)) {
                 retries++;
                 setTimeout(connect, 500);
@@ -230,7 +230,7 @@ export async function activateRSession(): Promise<void> {
 
                 // 2. Check if we have an active connection that hasn't "attached" yet
                 for (const ws of activeConnections.values()) {
-                    if ((ws as any)._terminalPid === pidArg) {
+                    if (ws._terminalPid === pidArg) {
                         console.info(`[activateRSession] Already connecting/connected for PID: ${pidArg}`);
                         terminal.show();
                         return; // Already connecting/connected
@@ -303,11 +303,6 @@ function writeSettings() {
     fs.writeFileSync(settingPath, JSON.stringify(config()));
 }
 
-function updateSessionWatcher() {
-    console.info(`[updateSessionWatcher] PID: ${pid}`);
-    console.info('[updateSessionWatcher] Done');
-}
-
 async function updatePlot() {
     if (!server) {return;}
     try {
@@ -770,37 +765,11 @@ export async function getWebviewHtml(webview: Webview, file: string, title: stri
         </html>`;
 }
 
-function isFromWorkspace(dir: string) {
-    if (workspace.workspaceFolders === undefined) {
-        let rel = path.relative(os.homedir(), dir);
-        if (rel === '') {
-            return true;
-        }
-        rel = path.relative(fs.realpathSync(os.homedir()), dir);
-        if (rel === '') {
-            return true;
-        }
-    } else {
-        for (const folder of workspace.workspaceFolders) {
-            let rel = path.relative(folder.uri.fsPath, dir);
-            if (!rel.startsWith('..') && !path.isAbsolute(rel)) {
-                return true;
-            }
-            rel = path.relative(fs.realpathSync(folder.uri.fsPath), dir);
-            if (!rel.startsWith('..') && !path.isAbsolute(rel)) {
-                return true;
-            }
-        }
-    }
-
-    return false;
-}
-
 import * as rstudioapi from './rstudioapi';
 
 export async function activateSession(session: Session): Promise<void> {
     activeSession = session;
-    wsClient = session.ws;
+    wsClient = session.ws as ExtWebSocket;
     server = session.server;
     pid = session.pid;
     rVer = session.rVer;
@@ -810,8 +779,7 @@ export async function activateSession(session: Session): Promise<void> {
     
     if (sessionStatusBarItem) {
         sessionStatusBarItem.text = `R ${rVer}: ${pid}`;
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/restrict-template-expressions
-        sessionStatusBarItem.tooltip = `${info?.version}\nProcess ID: ${pid}\nCommand: ${info?.command}\nStart time: ${info?.start_time}\nClick to attach to active terminal.`;
+        sessionStatusBarItem.tooltip = `${info.version}\nProcess ID: ${pid}\nCommand: ${info.command}\nStart time: ${info.start_time}\nClick to attach to active terminal.`;
         sessionStatusBarItem.show();
     }
     await setContext('rSessionActive', true);
@@ -838,11 +806,11 @@ export async function switchSessionByTerminal(terminal: vscode.Terminal | undefi
 export function updateSessionTerminalId(port: number, terminalPid: number): void {
     const ws = activeConnections.get(port);
     if (ws) {
-        (ws as any)._terminalPid = terminalPid;
+        ws._terminalPid = terminalPid;
     }
 }
 
-async function handleNotification(message: Record<string, unknown>, ws: WebSocket) {
+async function handleNotification(message: Record<string, unknown>, ws: ExtWebSocket) {
     const method = String(message.method);
     const params = (message.params as Record<string, unknown>) || {};
 
@@ -852,11 +820,11 @@ async function handleNotification(message: Record<string, unknown>, ws: WebSocke
         case 'attach': {
             if (!params.tempdir || !params.wd) {return;}
             const rPid = String(params.pid);
-            const terminalPid = (ws as any)._terminalPid ? String((ws as any)._terminalPid) : rPid;
+            const terminalPid = ws._terminalPid ? String(ws._terminalPid) : rPid;
             
             let session = sessions.get(terminalPid);
             if (!session) {
-                session = new Session({ host: '127.0.0.1', port: (ws as any)._port, token: (ws as any)._token }, ws);
+                session = new Session({ host: '127.0.0.1', port: ws._port || 0, token: ws._token || '' }, ws);
                 sessions.set(terminalPid, session);
                 // Also map R PID if it's different
                 if (rPid !== terminalPid) {
@@ -865,7 +833,7 @@ async function handleNotification(message: Record<string, unknown>, ws: WebSocke
             }
             session.rVer = String(params.version);
             session.pid = rPid;
-            session.info = params.info;
+            session.info = params.info as SessionInfo;
             session.sessionDir = String(params.tempdir);
             session.workingDir = String(params.wd);
 
@@ -939,7 +907,7 @@ async function handleNotification(message: Record<string, unknown>, ws: WebSocke
     }
 }
 
-async function handleRequest(message: Record<string, unknown>, ws: WebSocket) {
+async function handleRequest(message: Record<string, unknown>, ws: ExtWebSocket) {
     if (message.method) {
         const method = String(message.method);
         const params = (message.params as Record<string, unknown>) || {};
@@ -952,7 +920,7 @@ async function handleRequest(message: Record<string, unknown>, ws: WebSocket) {
                     result = rstudioapi.activeEditorContext();
                     break;
                 case 'insert_or_modify_text':
-                    await rstudioapi.insertOrModifyText(params.query as any[], params.id as string | null);
+                    await rstudioapi.insertOrModifyText(params.query as Record<string, unknown>[], params.id as string | null);
                     result = true;
                     break;
                 case 'replace_text_in_current_selection':

From 2a3279f99c49c389163edbbe1f2ee21dfdf50211 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 21:35:49 -0700
Subject: [PATCH 33/47] build: fix jquery.json-viewer path in esbuild.js

Previously it was copying the whole directory, causing a path mismatch in the webview. Now it copies individual files to the root of dist/resources.
---
 esbuild.js | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/esbuild.js b/esbuild.js
index b505d1d7..c16bf4dd 100644
--- a/esbuild.js
+++ b/esbuild.js
@@ -11,7 +11,8 @@ function copyResources() {
 
     const resources = [
         './node_modules/jquery/dist/jquery.min.js',
-        './node_modules/jquery.json-viewer/json-viewer',
+        './node_modules/jquery.json-viewer/json-viewer/jquery.json-viewer.js',
+        './node_modules/jquery.json-viewer/json-viewer/jquery.json-viewer.css',
         './node_modules/ag-grid-community/dist/ag-grid-community.min.noStyle.js',
         './node_modules/ag-grid-community/styles/ag-grid.min.css',
         './node_modules/ag-grid-community/styles/ag-theme-balham.min.css'
@@ -22,7 +23,7 @@ function copyResources() {
         const destName = path.basename(srcPath);
         const destPath = path.resolve(destDir, destName);
         if (fs.existsSync(srcPath)) {
-            fs.cpSync(srcPath, destPath, { recursive: true });
+            fs.copyFileSync(srcPath, destPath);
         } else {
             console.warn(`Warning: Resource not found: ${srcPath}`);
         }

From 9fd863929682674b5ac404e5fd0572c5bff9b330 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 21:47:21 -0700
Subject: [PATCH 34/47] lint: fix restrict-template-expressions and other minor
 lint issues

---
 src/completions.ts     | 10 ++--------
 src/extension.ts       |  1 -
 src/languageService.ts |  2 ++
 src/workspaceViewer.ts |  2 ++
 4 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/src/completions.ts b/src/completions.ts
index ce26e526..34fdb38c 100644
--- a/src/completions.ts
+++ b/src/completions.ts
@@ -1,10 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable @typescript-eslint/restrict-template-expressions */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-
-
+'use strict';
 import * as vscode from 'vscode';
 
 import * as session from './session';
@@ -101,7 +95,7 @@ export class HelpLinkHoverProvider implements vscode.HoverProvider {
             const encodedArgs = encodeURIComponent(JSON.stringify(args));
             const cmd = 'command:r.helpPanel.openForPath';
             const cmdUri = vscode.Uri.parse(`${cmd}?${encodedArgs}`);
-            return `[\`${cmdText}\`](${cmdUri})`;
+            return `[\`${cmdText}\`](${cmdUri.toString()})`;
         });
         const md = new vscode.MarkdownString(mds.join('  \n'));
         md.isTrusted = true;
diff --git a/src/extension.ts b/src/extension.ts
index 7a3729c0..8500c9fe 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -1,4 +1,3 @@
-
 'use strict';
 
 // interfaces, functions, etc. provided by vscode
diff --git a/src/languageService.ts b/src/languageService.ts
index 7b336f21..74f61192 100644
--- a/src/languageService.ts
+++ b/src/languageService.ts
@@ -1,3 +1,5 @@
+'use strict';
+
 import * as os from 'os';
 import { dirname } from 'path';
 import * as net from 'net';
diff --git a/src/workspaceViewer.ts b/src/workspaceViewer.ts
index c2d4f602..6f3a25e5 100644
--- a/src/workspaceViewer.ts
+++ b/src/workspaceViewer.ts
@@ -1,3 +1,5 @@
+'use strict';
+
 import * as vscode from 'vscode';
 import * as path from 'path';
 import { TreeDataProvider, EventEmitter, TreeItemCollapsibleState, TreeItem, Event, Uri, window, ThemeIcon } from 'vscode';

From dc9c9daa19c99fdecfaba46e506027739add445f Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 22:08:16 -0700
Subject: [PATCH 35/47] feat: prompt to install bundled sess package when
 creating R terminal

---
 R/install_sess.R | 31 +++++++++++++++++++++++++++++++
 src/rTerminal.ts |  1 +
 src/util.ts      | 39 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 71 insertions(+)
 create mode 100644 R/install_sess.R

diff --git a/R/install_sess.R b/R/install_sess.R
new file mode 100644
index 00000000..4901e656
--- /dev/null
+++ b/R/install_sess.R
@@ -0,0 +1,31 @@
+local({
+    args <- commandArgs(trailingOnly = TRUE)
+    if (length(args) < 2) {
+        stop("Missing arguments: pkg_path and repo")
+    }
+    pkg_path <- args[1]
+    repo <- args[2]
+
+    if (!file.exists(file.path(pkg_path, "DESCRIPTION"))) {
+        stop(paste("DESCRIPTION file not found in", pkg_path))
+    }
+
+    desc <- read.dcf(file.path(pkg_path, "DESCRIPTION"))
+    deps <- if ("Imports" %in% colnames(desc)) desc[, "Imports"] else ""
+    deps <- unlist(strsplit(deps, ","))
+    deps <- gsub("\\s*\\(.*\\)", "", deps)
+    deps <- trimws(deps)
+    # Filter out base packages and already installed packages
+    deps <- deps[nzchar(deps)]
+    installed <- rownames(installed.packages())
+    base_pkgs <- rownames(installed.packages(priority = "base"))
+    deps <- deps[!deps %in% base_pkgs & !deps %in% installed]
+
+    if (length(deps) > 0) {
+        message("Installing dependencies: ", paste(deps, collapse = ", "))
+        install.packages(deps, repos = repo)
+    }
+
+    message("Installing sess package from: ", pkg_path)
+    install.packages(pkg_path, repos = NULL, type = "source")
+})
diff --git a/src/rTerminal.ts b/src/rTerminal.ts
index e2de0c87..a3d87f34 100644
--- a/src/rTerminal.ts
+++ b/src/rTerminal.ts
@@ -155,6 +155,7 @@ export async function makeTerminalOptions(): Promise<vscode.TerminalOptions> {
 
 export async function createRTerm(preserveshow?: boolean): Promise<boolean> {
     const termOptions = await makeTerminalOptions();
+    void util.promptToInstallSessPackage(termOptions.cwd);
     const termPath = termOptions.shellPath;
     if(!termPath){
         void vscode.window.showErrorMessage('Could not find R path. Please check r.rterm and r.rpath setting.');
diff --git a/src/util.ts b/src/util.ts
index dfd9174d..74ebb2e4 100644
--- a/src/util.ts
+++ b/src/util.ts
@@ -588,6 +588,45 @@ export async function promptToInstallRPackage(name: string, section: string, cwd
         });
 }
 
+/**
+ * Prompt to install the bundled "sess" package
+ */
+export async function promptToInstallSessPackage(cwd?: string | vscode.Uri): Promise<void> {
+    const _config = config();
+    const sessionWatcher = _config.get<boolean>('sessionWatcher');
+    if (!sessionWatcher) {
+        return;
+    }
+    const sessVersion = await getRPackageVersion('sess', cwd instanceof vscode.Uri ? cwd.fsPath : cwd);
+    if (sessVersion) {
+        return;
+    }
+
+    const sessPath = extensionContext.asAbsolutePath('sess').replace(/\\/g, '/');
+    const installSessScript = extensionContext.asAbsolutePath(path.join('R', 'install_sess.R')).replace(/\\/g, '/');
+    const installMsg = 'R package "sess" (shipped with vscode-R) is required for the session watcher to work. Do you want to install it?';
+    await vscode.window.showErrorMessage(installMsg, 'Yes', 'No')
+        .then(async function (select) {
+            if (select === 'Yes') {
+                const rPath = await getRpath();
+                if (!rPath) {
+                    void vscode.window.showErrorMessage('R path not set', 'OK');
+                    return;
+                }
+                const repo = await getCranUrl('', cwd instanceof vscode.Uri ? cwd.fsPath : cwd);
+                const args = [
+                    '--silent',
+                    '--no-echo',
+                    '--no-save',
+                    '--no-restore',
+                    '-f', installSessScript,
+                    '--args', sessPath, repo
+                ];
+                void executeAsTask('Install "sess" package', rPath, args, true);
+            }
+        });
+}
+
 /**
  * Create temporary directory. Will avoid name clashes. Caller must delete directory after use.
  *

From ab3c58aaa92018242412e5cd9fbefbe2aae43f6b Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Thu, 12 Mar 2026 22:29:27 -0700
Subject: [PATCH 36/47] build: upgrade dependencies and devDependencies

---
 package-lock.json | 2132 +++++++++++++++++++++++++--------------------
 package.json      |   59 +-
 2 files changed, 1203 insertions(+), 988 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 0e1ae834..37cb95e4 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9,57 +9,66 @@
       "version": "2.8.6",
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
-        "ag-grid-community": "^31.3.2",
+        "ag-grid-community": "^31.3.4",
         "cheerio": "1.0.0-rc.12",
         "crypto": "^1.0.1",
         "ejs": "^3.1.10",
-        "fs-extra": "^10.0.0",
-        "highlight.js": "^11.9.0",
+        "fs-extra": "^10.1.0",
+        "highlight.js": "^11.11.1",
         "httpgd": "0.1.6",
         "jquery": "^3.7.1",
         "jquery.json-viewer": "^1.5.0",
-        "js-yaml": "^4.1.0",
-        "node-fetch": "^2.6.7",
+        "js-yaml": "^4.1.1",
+        "node-fetch": "^2.7.0",
         "vscode-languageclient": "^9.0.1",
         "vsls": "^1.0.4753",
-        "winreg": "^1.2.4",
-        "ws": "^8.13.0"
+        "winreg": "^1.2.5",
+        "ws": "^8.19.0"
       },
       "devDependencies": {
-        "@types/cheerio": "^0.22.29",
-        "@types/ejs": "^3.0.6",
-        "@types/express": "^4.17.12",
-        "@types/fs-extra": "^9.0.11",
-        "@types/glob": "^8.0.0",
+        "@types/cheerio": "^0.22.35",
+        "@types/ejs": "^3.1.5",
+        "@types/express": "^4.17.25",
+        "@types/fs-extra": "^9.0.13",
         "@types/highlight.js": "^10.1.0",
-        "@types/js-yaml": "^4.0.2",
-        "@types/mocha": "^8.2.2",
-        "@types/node": "^18.17.1",
-        "@types/node-fetch": "^2.5.10",
-        "@types/sinon": "^10.0.13",
-        "@types/vscode": "^1.75.0",
-        "@types/winreg": "^1.2.31",
-        "@types/ws": "^8.5.5",
-        "@typescript-eslint/eslint-plugin": "^5.30.0",
-        "@typescript-eslint/parser": "^5.30.0",
+        "@types/js-yaml": "^4.0.9",
+        "@types/mocha": "^8.2.3",
+        "@types/node": "^18.19.130",
+        "@types/node-fetch": "^2.6.13",
+        "@types/sinon": "^10.0.20",
+        "@types/vscode": "^1.110.0",
+        "@types/winreg": "^1.2.36",
+        "@types/ws": "^8.18.1",
+        "@typescript-eslint/eslint-plugin": "^5.62.0",
+        "@typescript-eslint/parser": "^5.62.0",
         "@vscode/test-cli": "^0.0.9",
-        "@vscode/test-electron": "^2.2.3",
-        "esbuild": "^0.27.3",
-        "eslint": "^7.28.0",
-        "eslint-plugin-jsdoc": "^35.1.3",
-        "git-cliff": "^2.8.0",
-        "mocha": "^11.1.0",
-        "sinon": "^15.0.1",
-        "typescript": "^4.7.2"
+        "@vscode/test-electron": "^2.5.2",
+        "esbuild": "^0.27.4",
+        "eslint": "^7.32.0",
+        "eslint-plugin-jsdoc": "^35.5.1",
+        "git-cliff": "^2.12.0",
+        "mocha": "^11.7.5",
+        "sinon": "^15.2.0",
+        "typescript": "^4.9.5"
       },
       "engines": {
         "vscode": "^1.75.0"
       }
     },
+    "node_modules/@babel/code-frame": {
+      "version": "7.12.11",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@babel/code-frame/-/code-frame-7.12.11.tgz",
+      "integrity": "sha512-Zt1yodBx1UcyiePMSkWnU4hPqhwq7hGi2nFL1LeA3EUl+q2LQx16MISgJ0+z7dnmgvP9QtIleuETGOiOH1RcIw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/highlight": "^7.10.4"
+      }
+    },
     "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.25.9.tgz",
-      "integrity": "sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==",
+      "version": "7.28.5",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -68,7 +77,7 @@
     },
     "node_modules/@babel/highlight": {
       "version": "7.25.9",
-      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.25.9.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@babel/highlight/-/highlight-7.25.9.tgz",
       "integrity": "sha512-llL88JShoCsth8fF8R4SJnIn+WLvR6ccFxu1H3FlMhDontdcmZWf2HgIZ7AIqV3Xcck1idlohrN4EUBQz6klbw==",
       "dev": true,
       "license": "MIT",
@@ -84,7 +93,7 @@
     },
     "node_modules/@babel/highlight/node_modules/ansi-styles": {
       "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ansi-styles/-/ansi-styles-3.2.1.tgz",
       "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
       "dev": true,
       "license": "MIT",
@@ -97,7 +106,7 @@
     },
     "node_modules/@babel/highlight/node_modules/chalk": {
       "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/chalk/-/chalk-2.4.2.tgz",
       "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
       "dev": true,
       "license": "MIT",
@@ -112,7 +121,7 @@
     },
     "node_modules/@babel/highlight/node_modules/color-convert": {
       "version": "1.9.3",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/color-convert/-/color-convert-1.9.3.tgz",
       "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
       "dev": true,
       "license": "MIT",
@@ -122,14 +131,14 @@
     },
     "node_modules/@babel/highlight/node_modules/color-name": {
       "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/color-name/-/color-name-1.1.3.tgz",
       "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/@babel/highlight/node_modules/escape-string-regexp": {
       "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
       "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
       "dev": true,
       "license": "MIT",
@@ -137,19 +146,9 @@
         "node": ">=0.8.0"
       }
     },
-    "node_modules/@babel/highlight/node_modules/has-flag": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/@babel/highlight/node_modules/supports-color": {
       "version": "5.5.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/supports-color/-/supports-color-5.5.0.tgz",
       "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
       "dev": true,
       "license": "MIT",
@@ -169,7 +168,7 @@
     },
     "node_modules/@es-joy/jsdoccomment": {
       "version": "0.9.0-alpha.1",
-      "resolved": "https://registry.npmjs.org/@es-joy/jsdoccomment/-/jsdoccomment-0.9.0-alpha.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@es-joy/jsdoccomment/-/jsdoccomment-0.9.0-alpha.1.tgz",
       "integrity": "sha512-Clxxc0PwpISoYYBibA+1L2qFJ7gvFVhI2Hos87S06K+Q0cXdOhZQJNKWuaQGPAeHjZEuUB/YoWOfwjuF2wirqA==",
       "dev": true,
       "license": "MIT",
@@ -184,7 +183,7 @@
     },
     "node_modules/@es-joy/jsdoccomment/node_modules/jsdoc-type-pratt-parser": {
       "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/jsdoc-type-pratt-parser/-/jsdoc-type-pratt-parser-1.0.4.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/jsdoc-type-pratt-parser/-/jsdoc-type-pratt-parser-1.0.4.tgz",
       "integrity": "sha512-jzmW9gokeq9+bHPDR1nCeidMyFUikdZlbOhKzh9+/nJqB75XhpNKec1/UuxW5c4+O+Pi31Gc/dCboyfSm/pSpQ==",
       "dev": true,
       "license": "MIT",
@@ -193,9 +192,9 @@
       }
     },
     "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.3.tgz",
-      "integrity": "sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/aix-ppc64/-/aix-ppc64-0.27.4.tgz",
+      "integrity": "sha512-cQPwL2mp2nSmHHJlCyoXgHGhbEPMrEEU5xhkcy3Hs/O7nGZqEpZ2sUtLaL9MORLtDfRvVl2/3PAuEkYZH0Ty8Q==",
       "cpu": [
         "ppc64"
       ],
@@ -210,9 +209,9 @@
       }
     },
     "node_modules/@esbuild/android-arm": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.3.tgz",
-      "integrity": "sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/android-arm/-/android-arm-0.27.4.tgz",
+      "integrity": "sha512-X9bUgvxiC8CHAGKYufLIHGXPJWnr0OCdR0anD2e21vdvgCI8lIfqFbnoeOz7lBjdrAGUhqLZLcQo6MLhTO2DKQ==",
       "cpu": [
         "arm"
       ],
@@ -227,9 +226,9 @@
       }
     },
     "node_modules/@esbuild/android-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.3.tgz",
-      "integrity": "sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/android-arm64/-/android-arm64-0.27.4.tgz",
+      "integrity": "sha512-gdLscB7v75wRfu7QSm/zg6Rx29VLdy9eTr2t44sfTW7CxwAtQghZ4ZnqHk3/ogz7xao0QAgrkradbBzcqFPasw==",
       "cpu": [
         "arm64"
       ],
@@ -244,9 +243,9 @@
       }
     },
     "node_modules/@esbuild/android-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.3.tgz",
-      "integrity": "sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/android-x64/-/android-x64-0.27.4.tgz",
+      "integrity": "sha512-PzPFnBNVF292sfpfhiyiXCGSn9HZg5BcAz+ivBuSsl6Rk4ga1oEXAamhOXRFyMcjwr2DVtm40G65N3GLeH1Lvw==",
       "cpu": [
         "x64"
       ],
@@ -261,9 +260,9 @@
       }
     },
     "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.3.tgz",
-      "integrity": "sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/darwin-arm64/-/darwin-arm64-0.27.4.tgz",
+      "integrity": "sha512-b7xaGIwdJlht8ZFCvMkpDN6uiSmnxxK56N2GDTMYPr2/gzvfdQN8rTfBsvVKmIVY/X7EM+/hJKEIbbHs9oA4tQ==",
       "cpu": [
         "arm64"
       ],
@@ -278,9 +277,9 @@
       }
     },
     "node_modules/@esbuild/darwin-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.3.tgz",
-      "integrity": "sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/darwin-x64/-/darwin-x64-0.27.4.tgz",
+      "integrity": "sha512-sR+OiKLwd15nmCdqpXMnuJ9W2kpy0KigzqScqHI3Hqwr7IXxBp3Yva+yJwoqh7rE8V77tdoheRYataNKL4QrPw==",
       "cpu": [
         "x64"
       ],
@@ -295,9 +294,9 @@
       }
     },
     "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.3.tgz",
-      "integrity": "sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.4.tgz",
+      "integrity": "sha512-jnfpKe+p79tCnm4GVav68A7tUFeKQwQyLgESwEAUzyxk/TJr4QdGog9sqWNcUbr/bZt/O/HXouspuQDd9JxFSw==",
       "cpu": [
         "arm64"
       ],
@@ -312,9 +311,9 @@
       }
     },
     "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.3.tgz",
-      "integrity": "sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/freebsd-x64/-/freebsd-x64-0.27.4.tgz",
+      "integrity": "sha512-2kb4ceA/CpfUrIcTUl1wrP/9ad9Atrp5J94Lq69w7UwOMolPIGrfLSvAKJp0RTvkPPyn6CIWrNy13kyLikZRZQ==",
       "cpu": [
         "x64"
       ],
@@ -329,9 +328,9 @@
       }
     },
     "node_modules/@esbuild/linux-arm": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.3.tgz",
-      "integrity": "sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/linux-arm/-/linux-arm-0.27.4.tgz",
+      "integrity": "sha512-aBYgcIxX/wd5n2ys0yESGeYMGF+pv6g0DhZr3G1ZG4jMfruU9Tl1i2Z+Wnj9/KjGz1lTLCcorqE2viePZqj4Eg==",
       "cpu": [
         "arm"
       ],
@@ -346,9 +345,9 @@
       }
     },
     "node_modules/@esbuild/linux-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.3.tgz",
-      "integrity": "sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/linux-arm64/-/linux-arm64-0.27.4.tgz",
+      "integrity": "sha512-7nQOttdzVGth1iz57kxg9uCz57dxQLHWxopL6mYuYthohPKEK0vU0C3O21CcBK6KDlkYVcnDXY099HcCDXd9dA==",
       "cpu": [
         "arm64"
       ],
@@ -363,9 +362,9 @@
       }
     },
     "node_modules/@esbuild/linux-ia32": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.3.tgz",
-      "integrity": "sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/linux-ia32/-/linux-ia32-0.27.4.tgz",
+      "integrity": "sha512-oPtixtAIzgvzYcKBQM/qZ3R+9TEUd1aNJQu0HhGyqtx6oS7qTpvjheIWBbes4+qu1bNlo2V4cbkISr8q6gRBFA==",
       "cpu": [
         "ia32"
       ],
@@ -380,9 +379,9 @@
       }
     },
     "node_modules/@esbuild/linux-loong64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.3.tgz",
-      "integrity": "sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/linux-loong64/-/linux-loong64-0.27.4.tgz",
+      "integrity": "sha512-8mL/vh8qeCoRcFH2nM8wm5uJP+ZcVYGGayMavi8GmRJjuI3g1v6Z7Ni0JJKAJW+m0EtUuARb6Lmp4hMjzCBWzA==",
       "cpu": [
         "loong64"
       ],
@@ -397,9 +396,9 @@
       }
     },
     "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.3.tgz",
-      "integrity": "sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/linux-mips64el/-/linux-mips64el-0.27.4.tgz",
+      "integrity": "sha512-1RdrWFFiiLIW7LQq9Q2NES+HiD4NyT8Itj9AUeCl0IVCA459WnPhREKgwrpaIfTOe+/2rdntisegiPWn/r/aAw==",
       "cpu": [
         "mips64el"
       ],
@@ -414,9 +413,9 @@
       }
     },
     "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.3.tgz",
-      "integrity": "sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/linux-ppc64/-/linux-ppc64-0.27.4.tgz",
+      "integrity": "sha512-tLCwNG47l3sd9lpfyx9LAGEGItCUeRCWeAx6x2Jmbav65nAwoPXfewtAdtbtit/pJFLUWOhpv0FpS6GQAmPrHA==",
       "cpu": [
         "ppc64"
       ],
@@ -431,9 +430,9 @@
       }
     },
     "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.3.tgz",
-      "integrity": "sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/linux-riscv64/-/linux-riscv64-0.27.4.tgz",
+      "integrity": "sha512-BnASypppbUWyqjd1KIpU4AUBiIhVr6YlHx/cnPgqEkNoVOhHg+YiSVxM1RLfiy4t9cAulbRGTNCKOcqHrEQLIw==",
       "cpu": [
         "riscv64"
       ],
@@ -448,9 +447,9 @@
       }
     },
     "node_modules/@esbuild/linux-s390x": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.3.tgz",
-      "integrity": "sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/linux-s390x/-/linux-s390x-0.27.4.tgz",
+      "integrity": "sha512-+eUqgb/Z7vxVLezG8bVB9SfBie89gMueS+I0xYh2tJdw3vqA/0ImZJ2ROeWwVJN59ihBeZ7Tu92dF/5dy5FttA==",
       "cpu": [
         "s390x"
       ],
@@ -465,9 +464,9 @@
       }
     },
     "node_modules/@esbuild/linux-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.3.tgz",
-      "integrity": "sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/linux-x64/-/linux-x64-0.27.4.tgz",
+      "integrity": "sha512-S5qOXrKV8BQEzJPVxAwnryi2+Iq5pB40gTEIT69BQONqR7JH1EPIcQ/Uiv9mCnn05jff9umq/5nqzxlqTOg9NA==",
       "cpu": [
         "x64"
       ],
@@ -482,9 +481,9 @@
       }
     },
     "node_modules/@esbuild/netbsd-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.3.tgz",
-      "integrity": "sha512-sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.4.tgz",
+      "integrity": "sha512-xHT8X4sb0GS8qTqiwzHqpY00C95DPAq7nAwX35Ie/s+LO9830hrMd3oX0ZMKLvy7vsonee73x0lmcdOVXFzd6Q==",
       "cpu": [
         "arm64"
       ],
@@ -499,9 +498,9 @@
       }
     },
     "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.3.tgz",
-      "integrity": "sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/netbsd-x64/-/netbsd-x64-0.27.4.tgz",
+      "integrity": "sha512-RugOvOdXfdyi5Tyv40kgQnI0byv66BFgAqjdgtAKqHoZTbTF2QqfQrFwa7cHEORJf6X2ht+l9ABLMP0dnKYsgg==",
       "cpu": [
         "x64"
       ],
@@ -516,9 +515,9 @@
       }
     },
     "node_modules/@esbuild/openbsd-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.3.tgz",
-      "integrity": "sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.4.tgz",
+      "integrity": "sha512-2MyL3IAaTX+1/qP0O1SwskwcwCoOI4kV2IBX1xYnDDqthmq5ArrW94qSIKCAuRraMgPOmG0RDTA74mzYNQA9ow==",
       "cpu": [
         "arm64"
       ],
@@ -533,9 +532,9 @@
       }
     },
     "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.3.tgz",
-      "integrity": "sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/openbsd-x64/-/openbsd-x64-0.27.4.tgz",
+      "integrity": "sha512-u8fg/jQ5aQDfsnIV6+KwLOf1CmJnfu1ShpwqdwC0uA7ZPwFws55Ngc12vBdeUdnuWoQYx/SOQLGDcdlfXhYmXQ==",
       "cpu": [
         "x64"
       ],
@@ -550,9 +549,9 @@
       }
     },
     "node_modules/@esbuild/openharmony-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.3.tgz",
-      "integrity": "sha512-NinAEgr/etERPTsZJ7aEZQvvg/A6IsZG/LgZy+81wON2huV7SrK3e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.4.tgz",
+      "integrity": "sha512-JkTZrl6VbyO8lDQO3yv26nNr2RM2yZzNrNHEsj9bm6dOwwu9OYN28CjzZkH57bh4w0I2F7IodpQvUAEd1mbWXg==",
       "cpu": [
         "arm64"
       ],
@@ -567,9 +566,9 @@
       }
     },
     "node_modules/@esbuild/sunos-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.3.tgz",
-      "integrity": "sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/sunos-x64/-/sunos-x64-0.27.4.tgz",
+      "integrity": "sha512-/gOzgaewZJfeJTlsWhvUEmUG4tWEY2Spp5M20INYRg2ZKl9QPO3QEEgPeRtLjEWSW8FilRNacPOg8R1uaYkA6g==",
       "cpu": [
         "x64"
       ],
@@ -584,9 +583,9 @@
       }
     },
     "node_modules/@esbuild/win32-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.3.tgz",
-      "integrity": "sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/win32-arm64/-/win32-arm64-0.27.4.tgz",
+      "integrity": "sha512-Z9SExBg2y32smoDQdf1HRwHRt6vAHLXcxD2uGgO/v2jK7Y718Ix4ndsbNMU/+1Qiem9OiOdaqitioZwxivhXYg==",
       "cpu": [
         "arm64"
       ],
@@ -601,9 +600,9 @@
       }
     },
     "node_modules/@esbuild/win32-ia32": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.3.tgz",
-      "integrity": "sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/win32-ia32/-/win32-ia32-0.27.4.tgz",
+      "integrity": "sha512-DAyGLS0Jz5G5iixEbMHi5KdiApqHBWMGzTtMiJ72ZOLhbu/bzxgAe8Ue8CTS3n3HbIUHQz/L51yMdGMeoxXNJw==",
       "cpu": [
         "ia32"
       ],
@@ -618,9 +617,9 @@
       }
     },
     "node_modules/@esbuild/win32-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.3.tgz",
-      "integrity": "sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@esbuild/win32-x64/-/win32-x64-0.27.4.tgz",
+      "integrity": "sha512-+knoa0BDoeXgkNvvV1vvbZX4+hizelrkwmGJBdT17t8FNPwG2lKemmuMZlmaNQ3ws3DKKCxpb4zRZEIp3UxFCg==",
       "cpu": [
         "x64"
       ],
@@ -635,9 +634,9 @@
       }
     },
     "node_modules/@eslint-community/eslint-utils": {
-      "version": "4.6.1",
-      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.6.1.tgz",
-      "integrity": "sha512-KTsJMmobmbrFLe3LDh0PC2FXpcSYJt/MLjlkh/9LEnmKYLSYmT/0EW9JWANjeoemiuZrmogti0tW5Ch+qNUYDw==",
+      "version": "4.9.1",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz",
+      "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -654,9 +653,9 @@
       }
     },
     "node_modules/@eslint-community/regexpp": {
-      "version": "4.12.1",
-      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz",
-      "integrity": "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==",
+      "version": "4.12.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@eslint-community/regexpp/-/regexpp-4.12.2.tgz",
+      "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -665,7 +664,7 @@
     },
     "node_modules/@eslint/eslintrc": {
       "version": "0.4.3",
-      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-0.4.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@eslint/eslintrc/-/eslintrc-0.4.3.tgz",
       "integrity": "sha512-J6KFFz5QCYUJq3pf0mjEcCJVERbzv71PUIDczuh9JkwGEzced6CO5ADLHB1rbf/+oPBtoPfMYNOpGDzCANlbXw==",
       "dev": true,
       "license": "MIT",
@@ -686,7 +685,7 @@
     },
     "node_modules/@eslint/eslintrc/node_modules/argparse": {
       "version": "1.0.10",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/argparse/-/argparse-1.0.10.tgz",
       "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
       "dev": true,
       "license": "MIT",
@@ -694,9 +693,20 @@
         "sprintf-js": "~1.0.2"
       }
     },
+    "node_modules/@eslint/eslintrc/node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
     "node_modules/@eslint/eslintrc/node_modules/ignore": {
       "version": "4.0.6",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-4.0.6.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ignore/-/ignore-4.0.6.tgz",
       "integrity": "sha512-cyFDKrqc/YdcWFniJhzI42+AzS+gNwmUzOSFcRCQYwySuBBBy/KjuxWLZ/FHEH6Moq1NizMOBWyTcv8O4OZIMg==",
       "dev": true,
       "license": "MIT",
@@ -705,9 +715,9 @@
       }
     },
     "node_modules/@eslint/eslintrc/node_modules/js-yaml": {
-      "version": "3.14.1",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz",
-      "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==",
+      "version": "3.14.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/js-yaml/-/js-yaml-3.14.2.tgz",
+      "integrity": "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -718,9 +728,22 @@
         "js-yaml": "bin/js-yaml.js"
       }
     },
+    "node_modules/@eslint/eslintrc/node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/@humanwhocodes/config-array": {
       "version": "0.5.0",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.5.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@humanwhocodes/config-array/-/config-array-0.5.0.tgz",
       "integrity": "sha512-FagtKFz74XrTl7y6HCzQpwDfXP0yhxe9lHLD1UZxjvZIcbyRz8zTFF/yYNfSfzU414eDwZ1SrO0Qvtyf+wFMQg==",
       "deprecated": "Use @eslint/config-array instead",
       "dev": true,
@@ -734,9 +757,33 @@
         "node": ">=10.10.0"
       }
     },
+    "node_modules/@humanwhocodes/config-array/node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/@humanwhocodes/config-array/node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/@humanwhocodes/object-schema": {
       "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz",
       "integrity": "sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==",
       "deprecated": "Use @eslint/object-schema instead",
       "dev": true,
@@ -744,7 +791,7 @@
     },
     "node_modules/@isaacs/cliui": {
       "version": "8.0.2",
-      "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@isaacs/cliui/-/cliui-8.0.2.tgz",
       "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==",
       "dev": true,
       "license": "ISC",
@@ -761,9 +808,9 @@
       }
     },
     "node_modules/@isaacs/cliui/node_modules/ansi-regex": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
-      "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
+      "version": "6.2.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ansi-regex/-/ansi-regex-6.2.2.tgz",
+      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -774,13 +821,13 @@
       }
     },
     "node_modules/@isaacs/cliui/node_modules/strip-ansi": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
-      "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
+      "version": "7.2.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/strip-ansi/-/strip-ansi-7.2.0.tgz",
+      "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "ansi-regex": "^6.0.1"
+        "ansi-regex": "^6.2.2"
       },
       "engines": {
         "node": ">=12"
@@ -829,7 +876,7 @@
     },
     "node_modules/@microsoft/servicehub-framework": {
       "version": "2.6.74",
-      "resolved": "https://registry.npmjs.org/@microsoft/servicehub-framework/-/servicehub-framework-2.6.74.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@microsoft/servicehub-framework/-/servicehub-framework-2.6.74.tgz",
       "integrity": "sha512-QJ//zzvxffupIkzupnVbMYY5YDOP+g5FlG6x0Pl7svRyq8pAouiibckJJcZlMtsMypKWwAnVBKb9/sonEOsUxw==",
       "license": "LICENSE.txt",
       "dependencies": {
@@ -842,7 +889,7 @@
     },
     "node_modules/@microsoft/servicehub-framework/node_modules/vscode-jsonrpc": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-4.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/vscode-jsonrpc/-/vscode-jsonrpc-4.0.0.tgz",
       "integrity": "sha512-perEnXQdQOJMTDFNv+UF3h1Y0z4iSiaN9jIlb0OqIYgosPCZGYh/MCUlkFtV2668PL69lRDO32hmvL2yiidUYg==",
       "license": "MIT",
       "engines": {
@@ -851,7 +898,7 @@
     },
     "node_modules/@nodelib/fs.scandir": {
       "version": "2.1.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
       "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
       "dev": true,
       "license": "MIT",
@@ -865,7 +912,7 @@
     },
     "node_modules/@nodelib/fs.stat": {
       "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
       "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
       "dev": true,
       "license": "MIT",
@@ -875,7 +922,7 @@
     },
     "node_modules/@nodelib/fs.walk": {
       "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
       "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
       "dev": true,
       "license": "MIT",
@@ -889,7 +936,7 @@
     },
     "node_modules/@pkgjs/parseargs": {
       "version": "0.11.0",
-      "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
       "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==",
       "dev": true,
       "license": "MIT",
@@ -898,9 +945,29 @@
         "node": ">=14"
       }
     },
+    "node_modules/@sec-ant/readable-stream": {
+      "version": "0.4.1",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@sec-ant/readable-stream/-/readable-stream-0.4.1.tgz",
+      "integrity": "sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@sindresorhus/merge-streams": {
+      "version": "4.0.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@sindresorhus/merge-streams/-/merge-streams-4.0.0.tgz",
+      "integrity": "sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/@sinonjs/commons": {
       "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/@sinonjs/commons/-/commons-3.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@sinonjs/commons/-/commons-3.0.1.tgz",
       "integrity": "sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ==",
       "dev": true,
       "license": "BSD-3-Clause",
@@ -910,7 +977,7 @@
     },
     "node_modules/@sinonjs/fake-timers": {
       "version": "10.3.0",
-      "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-10.3.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@sinonjs/fake-timers/-/fake-timers-10.3.0.tgz",
       "integrity": "sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA==",
       "dev": true,
       "license": "BSD-3-Clause",
@@ -919,20 +986,19 @@
       }
     },
     "node_modules/@sinonjs/samsam": {
-      "version": "8.0.2",
-      "resolved": "https://registry.npmjs.org/@sinonjs/samsam/-/samsam-8.0.2.tgz",
-      "integrity": "sha512-v46t/fwnhejRSFTGqbpn9u+LQ9xJDse10gNnPgAcxgdoCDMXj/G2asWAC/8Qs+BAZDicX+MNZouXT1A7c83kVw==",
+      "version": "8.0.3",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@sinonjs/samsam/-/samsam-8.0.3.tgz",
+      "integrity": "sha512-hw6HbX+GyVZzmaYNh82Ecj1vdGZrqVIn/keDTg63IgAwiQPO+xCz99uG6Woqgb4tM0mUiFENKZ4cqd7IX94AXQ==",
       "dev": true,
       "license": "BSD-3-Clause",
       "dependencies": {
         "@sinonjs/commons": "^3.0.1",
-        "lodash.get": "^4.4.2",
         "type-detect": "^4.1.0"
       }
     },
     "node_modules/@sinonjs/samsam/node_modules/type-detect": {
       "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/type-detect/-/type-detect-4.1.0.tgz",
       "integrity": "sha512-Acylog8/luQ8L7il+geoSxhEkazvkslg7PSNKOX59mbB9cOveP5aq9h74Y7YU8yDpJwetzQQrfIwtf4Wp4LKcw==",
       "dev": true,
       "license": "MIT",
@@ -942,15 +1008,16 @@
     },
     "node_modules/@sinonjs/text-encoding": {
       "version": "0.7.3",
-      "resolved": "https://registry.npmjs.org/@sinonjs/text-encoding/-/text-encoding-0.7.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@sinonjs/text-encoding/-/text-encoding-0.7.3.tgz",
       "integrity": "sha512-DE427ROAphMQzU4ENbliGYrBSYPXF+TtLg9S8vzeA+OF4ZKzoDdzfL8sxuMUGS/lgRhM6j1URSk9ghf7Xo1tyA==",
+      "deprecated": "Deprecated: no longer maintained and no longer used by Sinon packages. See\n  https://github.com/sinonjs/nise/issues/243 for replacement details.",
       "dev": true,
       "license": "(Unlicense OR Apache-2.0)"
     },
     "node_modules/@types/body-parser": {
-      "version": "1.19.5",
-      "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.5.tgz",
-      "integrity": "sha512-fB3Zu92ucau0iQ0JMCFQE7b/dv8Ot07NI3KaZIkIUNXq82k4eBAqUaneXfleGY9JWskeS9y+u0nXMyspcuQrCg==",
+      "version": "1.19.6",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/body-parser/-/body-parser-1.19.6.tgz",
+      "integrity": "sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -960,7 +1027,7 @@
     },
     "node_modules/@types/cheerio": {
       "version": "0.22.35",
-      "resolved": "https://registry.npmjs.org/@types/cheerio/-/cheerio-0.22.35.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/cheerio/-/cheerio-0.22.35.tgz",
       "integrity": "sha512-yD57BchKRvTV+JD53UZ6PD8KWY5g5rvvMLRnZR3EQBCZXiDT/HR+pKpMzFGlWNhFrXlo7VPZXtKvIEwZkAWOIA==",
       "dev": true,
       "license": "MIT",
@@ -970,7 +1037,7 @@
     },
     "node_modules/@types/connect": {
       "version": "3.4.38",
-      "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/connect/-/connect-3.4.38.tgz",
       "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==",
       "dev": true,
       "license": "MIT",
@@ -980,28 +1047,28 @@
     },
     "node_modules/@types/ejs": {
       "version": "3.1.5",
-      "resolved": "https://registry.npmjs.org/@types/ejs/-/ejs-3.1.5.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/ejs/-/ejs-3.1.5.tgz",
       "integrity": "sha512-nv+GSx77ZtXiJzwKdsASqi+YQ5Z7vwHsTP0JY2SiQgjGckkBRKZnk8nIM+7oUZ1VCtuTz0+By4qVR7fqzp/Dfg==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/@types/express": {
-      "version": "4.17.21",
-      "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.21.tgz",
-      "integrity": "sha512-ejlPM315qwLpaQlQDTjPdsUFSc6ZsP4AN6AlWnogPjQ7CVi7PYF3YVz+CY3jE2pwYf7E/7HlDAN0rV2GxTG0HQ==",
+      "version": "4.17.25",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/express/-/express-4.17.25.tgz",
+      "integrity": "sha512-dVd04UKsfpINUnK0yBoYHDF3xu7xVH4BuDotC/xGuycx4CgbP48X/KF/586bcObxT0HENHXEU8Nqtu6NR+eKhw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@types/body-parser": "*",
         "@types/express-serve-static-core": "^4.17.33",
         "@types/qs": "*",
-        "@types/serve-static": "*"
+        "@types/serve-static": "^1"
       }
     },
     "node_modules/@types/express-serve-static-core": {
-      "version": "4.19.6",
-      "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.19.6.tgz",
-      "integrity": "sha512-N4LZ2xG7DatVqhCZzOGb1Yi5lMbXSZcmdLDe9EzSndPV2HpWYWzRbaerl2n27irrm94EPpprqa8KpskPT085+A==",
+      "version": "4.19.8",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/express-serve-static-core/-/express-serve-static-core-4.19.8.tgz",
+      "integrity": "sha512-02S5fmqeoKzVZCHPZid4b8JH2eM5HzQLZWN2FohQEy/0eXTq8VXZfSN6Pcr3F6N9R/vNrj7cpgbhjie6m/1tCA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -1013,7 +1080,7 @@
     },
     "node_modules/@types/fs-extra": {
       "version": "9.0.13",
-      "resolved": "https://registry.npmjs.org/@types/fs-extra/-/fs-extra-9.0.13.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/fs-extra/-/fs-extra-9.0.13.tgz",
       "integrity": "sha512-nEnwB++1u5lVDM2UI4c1+5R+FYaKfaAzS4OococimjVm3nQw3TuzH5UNsocrcTBbhnerblyHj4A49qXbIiZdpA==",
       "dev": true,
       "license": "MIT",
@@ -1021,20 +1088,9 @@
         "@types/node": "*"
       }
     },
-    "node_modules/@types/glob": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/@types/glob/-/glob-8.1.0.tgz",
-      "integrity": "sha512-IO+MJPVhoqz+28h1qLAcBEH2+xHMK6MTyHJc7MTnnYb6wsoLR29POVGJ7LycmVXIqyy/4/2ShP5sUwTXuOwb/w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/minimatch": "^5.1.2",
-        "@types/node": "*"
-      }
-    },
     "node_modules/@types/highlight.js": {
       "version": "10.1.0",
-      "resolved": "https://registry.npmjs.org/@types/highlight.js/-/highlight.js-10.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/highlight.js/-/highlight.js-10.1.0.tgz",
       "integrity": "sha512-77hF2dGBsOgnvZll1vymYiNUtqJ8cJfXPD6GG/2M0aLRc29PkvB7Au6sIDjIEFcSICBhCh2+Pyq6WSRS7LUm6A==",
       "deprecated": "This is a stub types definition. highlight.js provides its own type definitions, so you do not need this installed.",
       "dev": true,
@@ -1044,9 +1100,9 @@
       }
     },
     "node_modules/@types/http-errors": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.4.tgz",
-      "integrity": "sha512-D0CFMMtydbJAegzOyHjtiKPLlvnm3iTZyZRSZoLq2mRhDdmLfIWOCYPfQJ4cu2erKghU++QvjcUjp/5h7hESpA==",
+      "version": "2.0.5",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/http-errors/-/http-errors-2.0.5.tgz",
+      "integrity": "sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==",
       "dev": true,
       "license": "MIT"
     },
@@ -1059,106 +1115,109 @@
     },
     "node_modules/@types/js-yaml": {
       "version": "4.0.9",
-      "resolved": "https://registry.npmjs.org/@types/js-yaml/-/js-yaml-4.0.9.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/js-yaml/-/js-yaml-4.0.9.tgz",
       "integrity": "sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/@types/json-schema": {
       "version": "7.0.15",
-      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/json-schema/-/json-schema-7.0.15.tgz",
       "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/@types/mime": {
       "version": "1.3.5",
-      "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.5.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/mime/-/mime-1.3.5.tgz",
       "integrity": "sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==",
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/@types/minimatch": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-5.1.2.tgz",
-      "integrity": "sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/@types/mocha": {
       "version": "8.2.3",
-      "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-8.2.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/mocha/-/mocha-8.2.3.tgz",
       "integrity": "sha512-ekGvFhFgrc2zYQoX4JeZPmVzZxw6Dtllga7iGHzfbYIYkAMUx/sAFP2GdFpLff+vdHXu5fl7WX9AT+TtqYcsyw==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/@types/node": {
-      "version": "18.19.86",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.86.tgz",
-      "integrity": "sha512-fifKayi175wLyKyc5qUfyENhQ1dCNI1UNjp653d8kuYcPQN5JhX3dGuP/XmvPTg/xRBn1VTLpbmi+H/Mr7tLfQ==",
+      "version": "18.19.130",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/node/-/node-18.19.130.tgz",
+      "integrity": "sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg==",
       "license": "MIT",
       "dependencies": {
         "undici-types": "~5.26.4"
       }
     },
     "node_modules/@types/node-fetch": {
-      "version": "2.6.12",
-      "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.6.12.tgz",
-      "integrity": "sha512-8nneRWKCg3rMtF69nLQJnOYUcbafYeFSjqkw3jCRLsqkWFlHaoQrr5mXmofFGOx3DKn7UfmBMyov8ySvLRVldA==",
+      "version": "2.6.13",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/node-fetch/-/node-fetch-2.6.13.tgz",
+      "integrity": "sha512-QGpRVpzSaUs30JBSGPjOg4Uveu384erbHBoT1zeONvyCfwQxIkUshLAOqN/k9EjGviPRmWTTe6aH2qySWKTVSw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@types/node": "*",
-        "form-data": "^4.0.0"
+        "form-data": "^4.0.4"
       }
     },
     "node_modules/@types/qs": {
-      "version": "6.9.18",
-      "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.18.tgz",
-      "integrity": "sha512-kK7dgTYDyGqS+e2Q4aK9X3D7q234CIZ1Bv0q/7Z5IwRDoADNU81xXJK/YVyLbLTZCoIwUoDoffFeF+p/eIklAA==",
+      "version": "6.15.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/qs/-/qs-6.15.0.tgz",
+      "integrity": "sha512-JawvT8iBVWpzTrz3EGw9BTQFg3BQNmwERdKE22vlTxawwtbyUSlMppvZYKLZzB5zgACXdXxbD3m1bXaMqP/9ow==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/@types/range-parser": {
       "version": "1.2.7",
-      "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/range-parser/-/range-parser-1.2.7.tgz",
       "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/@types/semver": {
-      "version": "7.7.0",
-      "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.7.0.tgz",
-      "integrity": "sha512-k107IF4+Xr7UHjwDc7Cfd6PRQfbdkiRabXGRjo07b4WyPahFBZCZ1sE+BNxYIJPPg73UkfOsVOLwqVc/6ETrIA==",
+      "version": "7.7.1",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/semver/-/semver-7.7.1.tgz",
+      "integrity": "sha512-FmgJfu+MOcQ370SD0ev7EI8TlCAfKYU+B4m5T3yXc1CiRN94g/SZPtsCkk506aUDtlMnFZvasDwHHUcZUEaYuA==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/@types/send": {
-      "version": "0.17.4",
-      "resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.4.tgz",
-      "integrity": "sha512-x2EM6TJOybec7c52BX0ZspPodMsQUd5L6PRwOunVyVUhXiBSKf3AezDL8Dgvgt5o0UfKNfuA0eMLr2wLT4AiBA==",
+      "version": "1.2.1",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/send/-/send-1.2.1.tgz",
+      "integrity": "sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@types/mime": "^1",
         "@types/node": "*"
       }
     },
     "node_modules/@types/serve-static": {
-      "version": "1.15.7",
-      "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.7.tgz",
-      "integrity": "sha512-W8Ym+h8nhuRwaKPaDw34QUkwsGi6Rc4yYqvKFo5rm2FUEhCFbzVWrxXUxuKK8TASjWsysJY0nsmNCGhCOIsrOw==",
+      "version": "1.15.10",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/serve-static/-/serve-static-1.15.10.tgz",
+      "integrity": "sha512-tRs1dB+g8Itk72rlSI2ZrW6vZg0YrLI81iQSTkMmOqnqCaNr/8Ek4VwWcN5vZgCYWbg/JJSGBlUaYGAOP73qBw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@types/http-errors": "*",
         "@types/node": "*",
-        "@types/send": "*"
+        "@types/send": "<1"
+      }
+    },
+    "node_modules/@types/serve-static/node_modules/@types/send": {
+      "version": "0.17.6",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/send/-/send-0.17.6.tgz",
+      "integrity": "sha512-Uqt8rPBE8SY0RK8JB1EzVOIZ32uqy8HwdxCnoCOsYrvnswqmFZ/k+9Ikidlk/ImhsdvBsloHbAlewb2IEBV/Og==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/mime": "^1",
+        "@types/node": "*"
       }
     },
     "node_modules/@types/sinon": {
       "version": "10.0.20",
-      "resolved": "https://registry.npmjs.org/@types/sinon/-/sinon-10.0.20.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/sinon/-/sinon-10.0.20.tgz",
       "integrity": "sha512-2APKKruFNCAZgx3daAyACGzWuJ028VVCUDk6o2rw/Z4PXT0ogwdV4KUegW0MwVs0Zu59auPXbbuBJHF12Sx1Eg==",
       "dev": true,
       "license": "MIT",
@@ -1167,29 +1226,29 @@
       }
     },
     "node_modules/@types/sinonjs__fake-timers": {
-      "version": "8.1.5",
-      "resolved": "https://registry.npmjs.org/@types/sinonjs__fake-timers/-/sinonjs__fake-timers-8.1.5.tgz",
-      "integrity": "sha512-mQkU2jY8jJEF7YHjHvsQO8+3ughTL1mcnn96igfhONmR+fUPSKIkefQYpSe8bsly2Ep7oQbn/6VG5/9/0qcArQ==",
+      "version": "15.0.1",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/sinonjs__fake-timers/-/sinonjs__fake-timers-15.0.1.tgz",
+      "integrity": "sha512-Ko2tjWJq8oozHzHV+reuvS5KYIRAokHnGbDwGh/J64LntgpbuylF74ipEL24HCyRjf9FOlBiBHWBR1RlVKsI1w==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/@types/vscode": {
-      "version": "1.99.1",
-      "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.99.1.tgz",
-      "integrity": "sha512-cQlqxHZ040ta6ovZXnXRxs3fJiTmlurkIWOfZVcLSZPcm9J4ikFpXuB7gihofGn5ng+kDVma5EmJIclfk0trPQ==",
+      "version": "1.110.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/vscode/-/vscode-1.110.0.tgz",
+      "integrity": "sha512-AGuxUEpU4F4mfuQjxPPaQVyuOMhs+VT/xRok1jiHVBubHK7lBRvCuOMZG0LKUwxncrPorJ5qq/uil3IdZBd5lA==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/@types/winreg": {
       "version": "1.2.36",
-      "resolved": "https://registry.npmjs.org/@types/winreg/-/winreg-1.2.36.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/winreg/-/winreg-1.2.36.tgz",
       "integrity": "sha512-DtafHy5A8hbaosXrbr7YdjQZaqVewXmiasRS5J4tYMzt3s1gkh40ixpxgVFfKiQ0JIYetTJABat47v9cpr/sQg==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/@types/ws": {
       "version": "8.18.1",
-      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@types/ws/-/ws-8.18.1.tgz",
       "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
       "license": "MIT",
       "dependencies": {
@@ -1198,7 +1257,7 @@
     },
     "node_modules/@typescript-eslint/eslint-plugin": {
       "version": "5.62.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.62.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.62.0.tgz",
       "integrity": "sha512-TiZzBSJja/LbhNPvk6yc0JrX9XqhQ0hdh6M2svYfsHGejaKFIAGd9MQ+ERIMzLGlN/kZoYIgdxFV0PuljTKXag==",
       "dev": true,
       "license": "MIT",
@@ -1233,7 +1292,7 @@
     },
     "node_modules/@typescript-eslint/parser": {
       "version": "5.62.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.62.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@typescript-eslint/parser/-/parser-5.62.0.tgz",
       "integrity": "sha512-VlJEV0fOQ7BExOsHYAGrgbEiZoi8D+Bl2+f6V2RrXerRSylnp+ZBHmPvaIa8cz0Ajx7WO7Z5RqfgYg7ED1nRhA==",
       "dev": true,
       "license": "BSD-2-Clause",
@@ -1261,7 +1320,7 @@
     },
     "node_modules/@typescript-eslint/scope-manager": {
       "version": "5.62.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.62.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@typescript-eslint/scope-manager/-/scope-manager-5.62.0.tgz",
       "integrity": "sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w==",
       "dev": true,
       "license": "MIT",
@@ -1279,7 +1338,7 @@
     },
     "node_modules/@typescript-eslint/type-utils": {
       "version": "5.62.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.62.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@typescript-eslint/type-utils/-/type-utils-5.62.0.tgz",
       "integrity": "sha512-xsSQreu+VnfbqQpW5vnCJdq1Z3Q0U31qiWmRhr98ONQmcp/yhiPJFPq8MXiJVLiksmOKSjIldZzkebzHuCGzew==",
       "dev": true,
       "license": "MIT",
@@ -1307,7 +1366,7 @@
     },
     "node_modules/@typescript-eslint/types": {
       "version": "5.62.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.62.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@typescript-eslint/types/-/types-5.62.0.tgz",
       "integrity": "sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ==",
       "dev": true,
       "license": "MIT",
@@ -1321,7 +1380,7 @@
     },
     "node_modules/@typescript-eslint/typescript-estree": {
       "version": "5.62.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.62.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@typescript-eslint/typescript-estree/-/typescript-estree-5.62.0.tgz",
       "integrity": "sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA==",
       "dev": true,
       "license": "BSD-2-Clause",
@@ -1349,7 +1408,7 @@
     },
     "node_modules/@typescript-eslint/utils": {
       "version": "5.62.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.62.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@typescript-eslint/utils/-/utils-5.62.0.tgz",
       "integrity": "sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ==",
       "dev": true,
       "license": "MIT",
@@ -1376,7 +1435,7 @@
     },
     "node_modules/@typescript-eslint/visitor-keys": {
       "version": "5.62.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.62.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@typescript-eslint/visitor-keys/-/visitor-keys-5.62.0.tgz",
       "integrity": "sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw==",
       "dev": true,
       "license": "MIT",
@@ -1423,16 +1482,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/@vscode/test-cli/node_modules/brace-expansion": {
-      "version": "2.0.2",
-      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/brace-expansion/-/brace-expansion-2.0.2.tgz",
-      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0"
-      }
-    },
     "node_modules/@vscode/test-cli/node_modules/cliui": {
       "version": "7.0.4",
       "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/cliui/-/cliui-7.0.4.tgz",
@@ -1445,6 +1494,16 @@
         "wrap-ansi": "^7.0.0"
       }
     },
+    "node_modules/@vscode/test-cli/node_modules/diff": {
+      "version": "5.2.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/diff/-/diff-5.2.2.tgz",
+      "integrity": "sha512-vtcDfH3TOjP8UekytvnHH1o1P4FcUdt4eQ1Y+Abap1tk/OB2MWQvcwS2ClCd1zuIhc3JKOx6p3kod8Vfys3E+A==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.3.1"
+      }
+    },
     "node_modules/@vscode/test-cli/node_modules/emoji-regex": {
       "version": "8.0.0",
       "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/emoji-regex/-/emoji-regex-8.0.0.tgz",
@@ -1452,20 +1511,14 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/@vscode/test-cli/node_modules/minimatch": {
-      "version": "9.0.9",
-      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/minimatch/-/minimatch-9.0.9.tgz",
-      "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
+    "node_modules/@vscode/test-cli/node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
       "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^2.0.2"
-      },
+      "license": "MIT",
       "engines": {
-        "node": ">=16 || 14 >=14.17"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
+        "node": ">=8"
       }
     },
     "node_modules/@vscode/test-cli/node_modules/mocha": {
@@ -1588,18 +1641,12 @@
         "node": ">=8"
       }
     },
-    "node_modules/@vscode/test-cli/node_modules/supports-color": {
-      "version": "9.4.0",
-      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/supports-color/-/supports-color-9.4.0.tgz",
-      "integrity": "sha512-VL+lNrEoIXww1coLPOmiEmK/0sGigko5COxI09KzHc2VJXJsQ37UaQ+8quuxjDeA7+KnLGTWRyOXSLLR2Wb4jw==",
+    "node_modules/@vscode/test-cli/node_modules/workerpool": {
+      "version": "6.5.1",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/workerpool/-/workerpool-6.5.1.tgz",
+      "integrity": "sha512-Fs4dNYcsdpYSAfVxhnl1L5zTksjvOJxtC5hzMNl+1t9B8hTJTdKDyZ5ju7ztgPy+ft9tBFXoOlDNiOT9WUXZlA==",
       "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/supports-color?sponsor=1"
-      }
+      "license": "Apache-2.0"
     },
     "node_modules/@vscode/test-cli/node_modules/wrap-ansi": {
       "version": "7.0.0",
@@ -1631,7 +1678,7 @@
     },
     "node_modules/@vscode/test-electron": {
       "version": "2.5.2",
-      "resolved": "https://registry.npmjs.org/@vscode/test-electron/-/test-electron-2.5.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@vscode/test-electron/-/test-electron-2.5.2.tgz",
       "integrity": "sha512-8ukpxv4wYe0iWMRQU18jhzJOHkeGKbnw7xWRX3Zw1WJA4cEKbHcmmLPdPrPtL6rhDcrlCZN+xKRpv09n4gRHYg==",
       "dev": true,
       "license": "MIT",
@@ -1648,7 +1695,7 @@
     },
     "node_modules/acorn": {
       "version": "7.4.1",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/acorn/-/acorn-7.4.1.tgz",
       "integrity": "sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==",
       "dev": true,
       "license": "MIT",
@@ -1661,7 +1708,7 @@
     },
     "node_modules/acorn-jsx": {
       "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
       "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
       "dev": true,
       "license": "MIT",
@@ -1671,14 +1718,14 @@
     },
     "node_modules/ag-grid-community": {
       "version": "31.3.4",
-      "resolved": "https://registry.npmjs.org/ag-grid-community/-/ag-grid-community-31.3.4.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ag-grid-community/-/ag-grid-community-31.3.4.tgz",
       "integrity": "sha512-jOxQO86C6eLnk1GdP24HB6aqaouFzMWizgfUwNY5MnetiWzz9ZaAmOGSnW/XBvdjXvC5Fpk3gSbvVKKQ7h9kBw==",
       "license": "MIT"
     },
     "node_modules/agent-base": {
-      "version": "7.1.3",
-      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.3.tgz",
-      "integrity": "sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw==",
+      "version": "7.1.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/agent-base/-/agent-base-7.1.4.tgz",
+      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -1686,9 +1733,9 @@
       }
     },
     "node_modules/ajv": {
-      "version": "6.12.6",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
-      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "version": "6.14.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ajv/-/ajv-6.14.0.tgz",
+      "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -1704,7 +1751,7 @@
     },
     "node_modules/ansi-colors": {
       "version": "4.1.3",
-      "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ansi-colors/-/ansi-colors-4.1.3.tgz",
       "integrity": "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==",
       "dev": true,
       "license": "MIT",
@@ -1714,7 +1761,7 @@
     },
     "node_modules/ansi-regex": {
       "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ansi-regex/-/ansi-regex-5.0.1.tgz",
       "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
       "dev": true,
       "license": "MIT",
@@ -1724,8 +1771,9 @@
     },
     "node_modules/ansi-styles": {
       "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ansi-styles/-/ansi-styles-4.3.0.tgz",
       "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "color-convert": "^2.0.1"
@@ -1739,7 +1787,7 @@
     },
     "node_modules/anymatch": {
       "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/anymatch/-/anymatch-3.1.3.tgz",
       "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
       "dev": true,
       "license": "ISC",
@@ -1753,13 +1801,13 @@
     },
     "node_modules/argparse": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/argparse/-/argparse-2.0.1.tgz",
       "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
       "license": "Python-2.0"
     },
     "node_modules/array-union": {
       "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/array-union/-/array-union-2.1.0.tgz",
       "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==",
       "dev": true,
       "license": "MIT",
@@ -1769,7 +1817,7 @@
     },
     "node_modules/astral-regex": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/astral-regex/-/astral-regex-2.0.0.tgz",
       "integrity": "sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==",
       "dev": true,
       "license": "MIT",
@@ -1779,32 +1827,32 @@
     },
     "node_modules/async": {
       "version": "3.2.6",
-      "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/async/-/async-3.2.6.tgz",
       "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==",
       "license": "MIT"
     },
     "node_modules/asynckit": {
       "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/asynckit/-/asynckit-0.4.0.tgz",
       "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/await-semaphore": {
       "version": "0.1.3",
-      "resolved": "https://registry.npmjs.org/await-semaphore/-/await-semaphore-0.1.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/await-semaphore/-/await-semaphore-0.1.3.tgz",
       "integrity": "sha512-d1W2aNSYcz/sxYO4pMGX9vq65qOTu0P800epMud+6cYYX0QcT7zyqcxec3VWzpgvdXo57UWmVbZpLMjX2m1I7Q==",
       "license": "MIT"
     },
     "node_modules/balanced-match": {
       "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/balanced-match/-/balanced-match-1.0.2.tgz",
       "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
       "license": "MIT"
     },
     "node_modules/binary-extensions": {
       "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/binary-extensions/-/binary-extensions-2.3.0.tgz",
       "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
       "dev": true,
       "license": "MIT",
@@ -1817,23 +1865,22 @@
     },
     "node_modules/boolbase": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/boolbase/-/boolbase-1.0.0.tgz",
       "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==",
       "license": "ISC"
     },
     "node_modules/brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "version": "2.0.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
       "license": "MIT",
       "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
+        "balanced-match": "^1.0.0"
       }
     },
     "node_modules/braces": {
       "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/braces/-/braces-3.0.3.tgz",
       "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
       "dev": true,
       "license": "MIT",
@@ -1846,7 +1893,7 @@
     },
     "node_modules/browser-stdout": {
       "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/browser-stdout/-/browser-stdout-1.3.1.tgz",
       "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==",
       "dev": true,
       "license": "ISC"
@@ -1879,7 +1926,7 @@
     },
     "node_modules/call-bind-apply-helpers": {
       "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
       "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
       "dev": true,
       "license": "MIT",
@@ -1893,7 +1940,7 @@
     },
     "node_modules/callsites": {
       "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/callsites/-/callsites-3.1.0.tgz",
       "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
       "dev": true,
       "license": "MIT",
@@ -1903,7 +1950,7 @@
     },
     "node_modules/camelcase": {
       "version": "6.3.0",
-      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/camelcase/-/camelcase-6.3.0.tgz",
       "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==",
       "dev": true,
       "license": "MIT",
@@ -1916,20 +1963,21 @@
     },
     "node_modules/cancellationtoken": {
       "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/cancellationtoken/-/cancellationtoken-2.2.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/cancellationtoken/-/cancellationtoken-2.2.0.tgz",
       "integrity": "sha512-uF4sHE5uh2VdEZtIRJKGoXAD9jm7bFY0tDRCzH4iLp262TOJ2lrtNHjMG2zc8H+GICOpELIpM7CGW5JeWnb3Hg==",
       "license": "MIT"
     },
     "node_modules/caught": {
       "version": "0.1.3",
-      "resolved": "https://registry.npmjs.org/caught/-/caught-0.1.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/caught/-/caught-0.1.3.tgz",
       "integrity": "sha512-DTWI84qfoqHEV5jHRpsKNnEisVCeuBDscXXaXyRLXC+4RD6rFftUNuTElcQ7LeO7w622pfzWkA1f6xu5qEAidw==",
       "license": "MIT"
     },
     "node_modules/chalk": {
       "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/chalk/-/chalk-4.1.2.tgz",
       "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "ansi-styles": "^4.1.0",
@@ -1942,9 +1990,32 @@
         "url": "https://github.com/chalk/chalk?sponsor=1"
       }
     },
+    "node_modules/chalk/node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/chalk/node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/cheerio": {
       "version": "1.0.0-rc.12",
-      "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.0.0-rc.12.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/cheerio/-/cheerio-1.0.0-rc.12.tgz",
       "integrity": "sha512-VqR8m68vM46BNnuZ5NtnGBKIE/DfN0cRIzg9n40EIq9NOv90ayxLBXA8fXC5gquFRGJSTRqBq25Jt2ECLR431Q==",
       "license": "MIT",
       "dependencies": {
@@ -1965,7 +2036,7 @@
     },
     "node_modules/cheerio-select": {
       "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/cheerio-select/-/cheerio-select-2.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/cheerio-select/-/cheerio-select-2.1.0.tgz",
       "integrity": "sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==",
       "license": "BSD-2-Clause",
       "dependencies": {
@@ -1982,7 +2053,7 @@
     },
     "node_modules/chokidar": {
       "version": "3.6.0",
-      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/chokidar/-/chokidar-3.6.0.tgz",
       "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
       "dev": true,
       "license": "MIT",
@@ -2005,22 +2076,9 @@
         "fsevents": "~2.3.2"
       }
     },
-    "node_modules/chokidar/node_modules/glob-parent": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
-      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "is-glob": "^4.0.1"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
     "node_modules/cli-cursor": {
       "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-5.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/cli-cursor/-/cli-cursor-5.0.0.tgz",
       "integrity": "sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw==",
       "dev": true,
       "license": "MIT",
@@ -2036,7 +2094,7 @@
     },
     "node_modules/cli-spinners": {
       "version": "2.9.2",
-      "resolved": "https://registry.npmjs.org/cli-spinners/-/cli-spinners-2.9.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/cli-spinners/-/cli-spinners-2.9.2.tgz",
       "integrity": "sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==",
       "dev": true,
       "license": "MIT",
@@ -2049,7 +2107,7 @@
     },
     "node_modules/cliui": {
       "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/cliui/-/cliui-8.0.1.tgz",
       "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
       "dev": true,
       "license": "ISC",
@@ -2064,14 +2122,14 @@
     },
     "node_modules/cliui/node_modules/emoji-regex": {
       "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/emoji-regex/-/emoji-regex-8.0.0.tgz",
       "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/cliui/node_modules/string-width": {
       "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/string-width/-/string-width-4.2.3.tgz",
       "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
       "dev": true,
       "license": "MIT",
@@ -2086,7 +2144,7 @@
     },
     "node_modules/cliui/node_modules/wrap-ansi": {
       "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
       "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
       "dev": true,
       "license": "MIT",
@@ -2104,8 +2162,9 @@
     },
     "node_modules/color-convert": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/color-convert/-/color-convert-2.0.1.tgz",
       "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "color-name": "~1.1.4"
@@ -2116,13 +2175,14 @@
     },
     "node_modules/color-name": {
       "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/color-name/-/color-name-1.1.4.tgz",
       "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "dev": true,
       "license": "MIT"
     },
     "node_modules/combined-stream": {
       "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/combined-stream/-/combined-stream-1.0.8.tgz",
       "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
       "dev": true,
       "license": "MIT",
@@ -2135,7 +2195,7 @@
     },
     "node_modules/comment-parser": {
       "version": "1.1.6-beta.0",
-      "resolved": "https://registry.npmjs.org/comment-parser/-/comment-parser-1.1.6-beta.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/comment-parser/-/comment-parser-1.1.6-beta.0.tgz",
       "integrity": "sha512-q3cA8TSMyqW7wcPSYWzbO/rMahnXgzs4SLG/UIWXdEsnXTFPZkEkWAdNgPiHig2OzxgpPLOh4WwsmClDxndwHw==",
       "dev": true,
       "license": "MIT",
@@ -2145,8 +2205,9 @@
     },
     "node_modules/concat-map": {
       "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/concat-map/-/concat-map-0.0.1.tgz",
       "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "dev": true,
       "license": "MIT"
     },
     "node_modules/convert-source-map": {
@@ -2158,14 +2219,14 @@
     },
     "node_modules/core-util-is": {
       "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/core-util-is/-/core-util-is-1.0.3.tgz",
       "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/cross-fetch": {
       "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/cross-fetch/-/cross-fetch-3.2.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/cross-fetch/-/cross-fetch-3.2.0.tgz",
       "integrity": "sha512-Q+xVJLoGOeIMXZmbUK4HYk+69cQH6LudR0Vu/pRm2YlU/hDV9CiS0gKUMaWY5f2NeUH9C1nV3bsTlCo0FsTV1Q==",
       "license": "MIT",
       "dependencies": {
@@ -2174,7 +2235,7 @@
     },
     "node_modules/cross-spawn": {
       "version": "7.0.6",
-      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/cross-spawn/-/cross-spawn-7.0.6.tgz",
       "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
       "dev": true,
       "license": "MIT",
@@ -2189,15 +2250,15 @@
     },
     "node_modules/crypto": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/crypto/-/crypto-1.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/crypto/-/crypto-1.0.1.tgz",
       "integrity": "sha512-VxBKmeNcqQdiUQUW2Tzq0t377b54N2bMtXO/qiLa+6eRRmmC4qT3D4OnTGoT/U6O9aklQ/jTwbOtRMTTY8G0Ig==",
       "deprecated": "This package is no longer supported. It's now a built-in Node module. If you've depended on crypto, you should switch to the one that's built-in.",
       "license": "ISC"
     },
     "node_modules/css-select": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.1.0.tgz",
-      "integrity": "sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==",
+      "version": "5.2.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/css-select/-/css-select-5.2.2.tgz",
+      "integrity": "sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==",
       "license": "BSD-2-Clause",
       "dependencies": {
         "boolbase": "^1.0.0",
@@ -2211,9 +2272,9 @@
       }
     },
     "node_modules/css-what": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.1.0.tgz",
-      "integrity": "sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==",
+      "version": "6.2.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/css-what/-/css-what-6.2.2.tgz",
+      "integrity": "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==",
       "license": "BSD-2-Clause",
       "engines": {
         "node": ">= 6"
@@ -2223,9 +2284,9 @@
       }
     },
     "node_modules/debug": {
-      "version": "4.4.0",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
-      "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
+      "version": "4.4.3",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -2242,7 +2303,7 @@
     },
     "node_modules/decamelize": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/decamelize/-/decamelize-4.0.0.tgz",
       "integrity": "sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==",
       "dev": true,
       "license": "MIT",
@@ -2255,14 +2316,14 @@
     },
     "node_modules/deep-is": {
       "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/deep-is/-/deep-is-0.1.4.tgz",
       "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/delayed-stream": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/delayed-stream/-/delayed-stream-1.0.0.tgz",
       "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
       "dev": true,
       "license": "MIT",
@@ -2271,9 +2332,9 @@
       }
     },
     "node_modules/diff": {
-      "version": "5.2.2",
-      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/diff/-/diff-5.2.2.tgz",
-      "integrity": "sha512-vtcDfH3TOjP8UekytvnHH1o1P4FcUdt4eQ1Y+Abap1tk/OB2MWQvcwS2ClCd1zuIhc3JKOx6p3kod8Vfys3E+A==",
+      "version": "7.0.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/diff/-/diff-7.0.0.tgz",
+      "integrity": "sha512-PJWHUb1RFevKCwaFA9RlG5tCd+FO5iRh9A8HEtkmBH2Li03iJriB6m6JIN4rGz3K3JLawI7/veA1xzRKP6ISBw==",
       "dev": true,
       "license": "BSD-3-Clause",
       "engines": {
@@ -2282,7 +2343,7 @@
     },
     "node_modules/dir-glob": {
       "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/dir-glob/-/dir-glob-3.0.1.tgz",
       "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==",
       "dev": true,
       "license": "MIT",
@@ -2295,7 +2356,7 @@
     },
     "node_modules/doctrine": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/doctrine/-/doctrine-3.0.0.tgz",
       "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==",
       "dev": true,
       "license": "Apache-2.0",
@@ -2308,7 +2369,7 @@
     },
     "node_modules/dom-serializer": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/dom-serializer/-/dom-serializer-2.0.0.tgz",
       "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==",
       "license": "MIT",
       "dependencies": {
@@ -2322,7 +2383,7 @@
     },
     "node_modules/domelementtype": {
       "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/domelementtype/-/domelementtype-2.3.0.tgz",
       "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==",
       "funding": [
         {
@@ -2334,7 +2395,7 @@
     },
     "node_modules/domhandler": {
       "version": "5.0.3",
-      "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/domhandler/-/domhandler-5.0.3.tgz",
       "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==",
       "license": "BSD-2-Clause",
       "dependencies": {
@@ -2349,7 +2410,7 @@
     },
     "node_modules/domutils": {
       "version": "3.2.2",
-      "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.2.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/domutils/-/domutils-3.2.2.tgz",
       "integrity": "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==",
       "license": "BSD-2-Clause",
       "dependencies": {
@@ -2363,7 +2424,7 @@
     },
     "node_modules/dunder-proto": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/dunder-proto/-/dunder-proto-1.0.1.tgz",
       "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
       "dev": true,
       "license": "MIT",
@@ -2378,14 +2439,14 @@
     },
     "node_modules/eastasianwidth": {
       "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
       "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/ejs": {
       "version": "3.1.10",
-      "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.1.10.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ejs/-/ejs-3.1.10.tgz",
       "integrity": "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==",
       "license": "Apache-2.0",
       "dependencies": {
@@ -2400,7 +2461,7 @@
     },
     "node_modules/emoji-regex": {
       "version": "9.2.2",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/emoji-regex/-/emoji-regex-9.2.2.tgz",
       "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
       "dev": true,
       "license": "MIT"
@@ -2421,7 +2482,7 @@
     },
     "node_modules/enquirer": {
       "version": "2.4.1",
-      "resolved": "https://registry.npmjs.org/enquirer/-/enquirer-2.4.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/enquirer/-/enquirer-2.4.1.tgz",
       "integrity": "sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ==",
       "dev": true,
       "license": "MIT",
@@ -2435,7 +2496,7 @@
     },
     "node_modules/entities": {
       "version": "4.5.0",
-      "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/entities/-/entities-4.5.0.tgz",
       "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
       "license": "BSD-2-Clause",
       "engines": {
@@ -2447,7 +2508,7 @@
     },
     "node_modules/es-define-property": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/es-define-property/-/es-define-property-1.0.1.tgz",
       "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
       "dev": true,
       "license": "MIT",
@@ -2457,7 +2518,7 @@
     },
     "node_modules/es-errors": {
       "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/es-errors/-/es-errors-1.3.0.tgz",
       "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
       "dev": true,
       "license": "MIT",
@@ -2467,7 +2528,7 @@
     },
     "node_modules/es-object-atoms": {
       "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
       "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
       "dev": true,
       "license": "MIT",
@@ -2480,7 +2541,7 @@
     },
     "node_modules/es-set-tostringtag": {
       "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
       "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
       "dev": true,
       "license": "MIT",
@@ -2495,9 +2556,9 @@
       }
     },
     "node_modules/esbuild": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.3.tgz",
-      "integrity": "sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==",
+      "version": "0.27.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/esbuild/-/esbuild-0.27.4.tgz",
+      "integrity": "sha512-Rq4vbHnYkK5fws5NF7MYTU68FPRE1ajX7heQ/8QXXWqNgqqJ/GkmmyxIzUnf2Sr/bakf8l54716CcMGHYhMrrQ==",
       "dev": true,
       "hasInstallScript": true,
       "license": "MIT",
@@ -2508,37 +2569,37 @@
         "node": ">=18"
       },
       "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.27.3",
-        "@esbuild/android-arm": "0.27.3",
-        "@esbuild/android-arm64": "0.27.3",
-        "@esbuild/android-x64": "0.27.3",
-        "@esbuild/darwin-arm64": "0.27.3",
-        "@esbuild/darwin-x64": "0.27.3",
-        "@esbuild/freebsd-arm64": "0.27.3",
-        "@esbuild/freebsd-x64": "0.27.3",
-        "@esbuild/linux-arm": "0.27.3",
-        "@esbuild/linux-arm64": "0.27.3",
-        "@esbuild/linux-ia32": "0.27.3",
-        "@esbuild/linux-loong64": "0.27.3",
-        "@esbuild/linux-mips64el": "0.27.3",
-        "@esbuild/linux-ppc64": "0.27.3",
-        "@esbuild/linux-riscv64": "0.27.3",
-        "@esbuild/linux-s390x": "0.27.3",
-        "@esbuild/linux-x64": "0.27.3",
-        "@esbuild/netbsd-arm64": "0.27.3",
-        "@esbuild/netbsd-x64": "0.27.3",
-        "@esbuild/openbsd-arm64": "0.27.3",
-        "@esbuild/openbsd-x64": "0.27.3",
-        "@esbuild/openharmony-arm64": "0.27.3",
-        "@esbuild/sunos-x64": "0.27.3",
-        "@esbuild/win32-arm64": "0.27.3",
-        "@esbuild/win32-ia32": "0.27.3",
-        "@esbuild/win32-x64": "0.27.3"
+        "@esbuild/aix-ppc64": "0.27.4",
+        "@esbuild/android-arm": "0.27.4",
+        "@esbuild/android-arm64": "0.27.4",
+        "@esbuild/android-x64": "0.27.4",
+        "@esbuild/darwin-arm64": "0.27.4",
+        "@esbuild/darwin-x64": "0.27.4",
+        "@esbuild/freebsd-arm64": "0.27.4",
+        "@esbuild/freebsd-x64": "0.27.4",
+        "@esbuild/linux-arm": "0.27.4",
+        "@esbuild/linux-arm64": "0.27.4",
+        "@esbuild/linux-ia32": "0.27.4",
+        "@esbuild/linux-loong64": "0.27.4",
+        "@esbuild/linux-mips64el": "0.27.4",
+        "@esbuild/linux-ppc64": "0.27.4",
+        "@esbuild/linux-riscv64": "0.27.4",
+        "@esbuild/linux-s390x": "0.27.4",
+        "@esbuild/linux-x64": "0.27.4",
+        "@esbuild/netbsd-arm64": "0.27.4",
+        "@esbuild/netbsd-x64": "0.27.4",
+        "@esbuild/openbsd-arm64": "0.27.4",
+        "@esbuild/openbsd-x64": "0.27.4",
+        "@esbuild/openharmony-arm64": "0.27.4",
+        "@esbuild/sunos-x64": "0.27.4",
+        "@esbuild/win32-arm64": "0.27.4",
+        "@esbuild/win32-ia32": "0.27.4",
+        "@esbuild/win32-x64": "0.27.4"
       }
     },
     "node_modules/escalade": {
       "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/escalade/-/escalade-3.2.0.tgz",
       "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
       "dev": true,
       "license": "MIT",
@@ -2548,7 +2609,7 @@
     },
     "node_modules/escape-string-regexp": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
       "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
       "dev": true,
       "license": "MIT",
@@ -2561,7 +2622,7 @@
     },
     "node_modules/eslint": {
       "version": "7.32.0",
-      "resolved": "https://registry.npmjs.org/eslint/-/eslint-7.32.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/eslint/-/eslint-7.32.0.tgz",
       "integrity": "sha512-VHZ8gX+EDfz+97jGcgyGCyRia/dPOd6Xh9yPv8Bl1+SoaIwD+a/vlrOmGRUyOYu7MwUhc7CxqeaDZU13S4+EpA==",
       "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.",
       "dev": true,
@@ -2620,7 +2681,7 @@
     },
     "node_modules/eslint-plugin-jsdoc": {
       "version": "35.5.1",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-35.5.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-35.5.1.tgz",
       "integrity": "sha512-pPYPWtsykwVEue1tYEyoppBj4dgF7XicF67tLLLraY6RQYBq7qMKjUHji19+hfiTtYKKBD0YfeK8hgjPAE5viw==",
       "dev": true,
       "license": "BSD-3-Clause",
@@ -2644,7 +2705,7 @@
     },
     "node_modules/eslint-scope": {
       "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/eslint-scope/-/eslint-scope-5.1.1.tgz",
       "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==",
       "dev": true,
       "license": "BSD-2-Clause",
@@ -2658,7 +2719,7 @@
     },
     "node_modules/eslint-utils": {
       "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/eslint-utils/-/eslint-utils-2.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/eslint-utils/-/eslint-utils-2.1.0.tgz",
       "integrity": "sha512-w94dQYoauyvlDc43XnGB8lU3Zt713vNChgt4EWwhXAP2XkBvndfxF0AgIqKOOasjPIPzj9JqgwkwbCYD0/V3Zg==",
       "dev": true,
       "license": "MIT",
@@ -2674,7 +2735,7 @@
     },
     "node_modules/eslint-utils/node_modules/eslint-visitor-keys": {
       "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz",
       "integrity": "sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ==",
       "dev": true,
       "license": "Apache-2.0",
@@ -2684,7 +2745,7 @@
     },
     "node_modules/eslint-visitor-keys": {
       "version": "3.4.3",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
       "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
       "dev": true,
       "license": "Apache-2.0",
@@ -2695,29 +2756,30 @@
         "url": "https://opencollective.com/eslint"
       }
     },
-    "node_modules/eslint/node_modules/@babel/code-frame": {
-      "version": "7.12.11",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.12.11.tgz",
-      "integrity": "sha512-Zt1yodBx1UcyiePMSkWnU4hPqhwq7hGi2nFL1LeA3EUl+q2LQx16MISgJ0+z7dnmgvP9QtIleuETGOiOH1RcIw==",
+    "node_modules/eslint/node_modules/argparse": {
+      "version": "1.0.10",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/argparse/-/argparse-1.0.10.tgz",
+      "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/highlight": "^7.10.4"
+        "sprintf-js": "~1.0.2"
       }
     },
-    "node_modules/eslint/node_modules/argparse": {
-      "version": "1.0.10",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
-      "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
+    "node_modules/eslint/node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "sprintf-js": "~1.0.2"
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
       }
     },
     "node_modules/eslint/node_modules/eslint-visitor-keys": {
       "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz",
       "integrity": "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==",
       "dev": true,
       "license": "Apache-2.0",
@@ -2725,22 +2787,9 @@
         "node": ">=10"
       }
     },
-    "node_modules/eslint/node_modules/glob-parent": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
-      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "is-glob": "^4.0.1"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
     "node_modules/eslint/node_modules/ignore": {
       "version": "4.0.6",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-4.0.6.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ignore/-/ignore-4.0.6.tgz",
       "integrity": "sha512-cyFDKrqc/YdcWFniJhzI42+AzS+gNwmUzOSFcRCQYwySuBBBy/KjuxWLZ/FHEH6Moq1NizMOBWyTcv8O4OZIMg==",
       "dev": true,
       "license": "MIT",
@@ -2749,9 +2798,9 @@
       }
     },
     "node_modules/eslint/node_modules/js-yaml": {
-      "version": "3.14.1",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz",
-      "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==",
+      "version": "3.14.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/js-yaml/-/js-yaml-3.14.2.tgz",
+      "integrity": "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -2762,9 +2811,22 @@
         "js-yaml": "bin/js-yaml.js"
       }
     },
+    "node_modules/eslint/node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/espree": {
       "version": "7.3.1",
-      "resolved": "https://registry.npmjs.org/espree/-/espree-7.3.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/espree/-/espree-7.3.1.tgz",
       "integrity": "sha512-v3JCNCE64umkFpmkFGqzVKsOT0tN1Zr+ueqLZfpV1Ob8e+CEgPWa+OxCoGH3tnhimMKIaBm4m/vaRpJ/krRz2g==",
       "dev": true,
       "license": "BSD-2-Clause",
@@ -2779,7 +2841,7 @@
     },
     "node_modules/espree/node_modules/eslint-visitor-keys": {
       "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz",
       "integrity": "sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ==",
       "dev": true,
       "license": "Apache-2.0",
@@ -2789,7 +2851,7 @@
     },
     "node_modules/esprima": {
       "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/esprima/-/esprima-4.0.1.tgz",
       "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
       "dev": true,
       "license": "BSD-2-Clause",
@@ -2802,9 +2864,9 @@
       }
     },
     "node_modules/esquery": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz",
-      "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==",
+      "version": "1.7.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/esquery/-/esquery-1.7.0.tgz",
+      "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==",
       "dev": true,
       "license": "BSD-3-Clause",
       "dependencies": {
@@ -2816,7 +2878,7 @@
     },
     "node_modules/esquery/node_modules/estraverse": {
       "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/estraverse/-/estraverse-5.3.0.tgz",
       "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
       "dev": true,
       "license": "BSD-2-Clause",
@@ -2826,7 +2888,7 @@
     },
     "node_modules/esrecurse": {
       "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/esrecurse/-/esrecurse-4.3.0.tgz",
       "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
       "dev": true,
       "license": "BSD-2-Clause",
@@ -2839,7 +2901,7 @@
     },
     "node_modules/esrecurse/node_modules/estraverse": {
       "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/estraverse/-/estraverse-5.3.0.tgz",
       "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
       "dev": true,
       "license": "BSD-2-Clause",
@@ -2849,7 +2911,7 @@
     },
     "node_modules/estraverse": {
       "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/estraverse/-/estraverse-4.3.0.tgz",
       "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==",
       "dev": true,
       "license": "BSD-2-Clause",
@@ -2859,7 +2921,7 @@
     },
     "node_modules/esutils": {
       "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/esutils/-/esutils-2.0.3.tgz",
       "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
       "dev": true,
       "license": "BSD-2-Clause",
@@ -2869,60 +2931,47 @@
     },
     "node_modules/event-lite": {
       "version": "0.1.3",
-      "resolved": "https://registry.npmjs.org/event-lite/-/event-lite-0.1.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/event-lite/-/event-lite-0.1.3.tgz",
       "integrity": "sha512-8qz9nOz5VeD2z96elrEKD2U433+L3DWdUdDkOINLGOJvx1GsMBbMn0aCeu28y8/e85A6mCigBiFlYMnTBEGlSw==",
       "license": "MIT"
     },
     "node_modules/execa": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/execa/-/execa-8.0.1.tgz",
-      "integrity": "sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==",
+      "version": "9.6.1",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/execa/-/execa-9.6.1.tgz",
+      "integrity": "sha512-9Be3ZoN4LmYR90tUoVu2te2BsbzHfhJyfEiAVfz7N5/zv+jduIfLrV2xdQXOHbaD6KgpGdO9PRPM1Y4Q9QkPkA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "cross-spawn": "^7.0.3",
-        "get-stream": "^8.0.1",
-        "human-signals": "^5.0.0",
-        "is-stream": "^3.0.0",
-        "merge-stream": "^2.0.0",
-        "npm-run-path": "^5.1.0",
-        "onetime": "^6.0.0",
+        "@sindresorhus/merge-streams": "^4.0.0",
+        "cross-spawn": "^7.0.6",
+        "figures": "^6.1.0",
+        "get-stream": "^9.0.0",
+        "human-signals": "^8.0.1",
+        "is-plain-obj": "^4.1.0",
+        "is-stream": "^4.0.1",
+        "npm-run-path": "^6.0.0",
+        "pretty-ms": "^9.2.0",
         "signal-exit": "^4.1.0",
-        "strip-final-newline": "^3.0.0"
+        "strip-final-newline": "^4.0.0",
+        "yoctocolors": "^2.1.1"
       },
       "engines": {
-        "node": ">=16.17"
+        "node": "^18.19.0 || >=20.5.0"
       },
       "funding": {
         "url": "https://github.com/sindresorhus/execa?sponsor=1"
       }
     },
-    "node_modules/execa/node_modules/onetime": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/onetime/-/onetime-6.0.0.tgz",
-      "integrity": "sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "mimic-fn": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/fast-deep-equal": {
       "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
       "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/fast-glob": {
       "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/fast-glob/-/fast-glob-3.3.3.tgz",
       "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
       "dev": true,
       "license": "MIT",
@@ -2937,37 +2986,24 @@
         "node": ">=8.6.0"
       }
     },
-    "node_modules/fast-glob/node_modules/glob-parent": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
-      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "is-glob": "^4.0.1"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
     "node_modules/fast-json-stable-stringify": {
       "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
       "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/fast-levenshtein": {
       "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
       "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/fast-uri": {
-      "version": "3.0.6",
-      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.0.6.tgz",
-      "integrity": "sha512-Atfo14OibSv5wAp4VWNsFYE1AchQRTv9cBGWET4pZWHzYshFSS9NQI6I57rdKn9croWVMbYFbLhJ+yJvmZIIHw==",
+      "version": "3.1.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/fast-uri/-/fast-uri-3.1.0.tgz",
+      "integrity": "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==",
       "dev": true,
       "funding": [
         {
@@ -2982,19 +3018,35 @@
       "license": "BSD-3-Clause"
     },
     "node_modules/fastq": {
-      "version": "1.19.1",
-      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz",
-      "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==",
+      "version": "1.20.1",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/fastq/-/fastq-1.20.1.tgz",
+      "integrity": "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==",
       "dev": true,
       "license": "ISC",
       "dependencies": {
         "reusify": "^1.0.4"
       }
     },
-    "node_modules/file-entry-cache": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz",
-      "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==",
+    "node_modules/figures": {
+      "version": "6.1.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/figures/-/figures-6.1.0.tgz",
+      "integrity": "sha512-d+l3qxjSesT4V7v2fh+QnmFnUWv9lSpjarhShNTgBOfA0ttejbQUAlHLitbjkoRiDulW0OPoQPYIGhIC8ohejg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-unicode-supported": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/file-entry-cache": {
+      "version": "6.0.1",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/file-entry-cache/-/file-entry-cache-6.0.1.tgz",
+      "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -3005,27 +3057,18 @@
       }
     },
     "node_modules/filelist": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/filelist/-/filelist-1.0.4.tgz",
-      "integrity": "sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==",
+      "version": "1.0.6",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/filelist/-/filelist-1.0.6.tgz",
+      "integrity": "sha512-5giy2PkLYY1cP39p17Ech+2xlpTRL9HLspOfEgm0L6CwBXBTgsK5ou0JtzYuepxkaQ/tvhCFIJ5uXo0OrM2DxA==",
       "license": "Apache-2.0",
       "dependencies": {
         "minimatch": "^5.0.1"
       }
     },
-    "node_modules/filelist/node_modules/brace-expansion": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
-      "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0"
-      }
-    },
     "node_modules/filelist/node_modules/minimatch": {
-      "version": "5.1.6",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
-      "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
+      "version": "5.1.9",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/minimatch/-/minimatch-5.1.9.tgz",
+      "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
       "license": "ISC",
       "dependencies": {
         "brace-expansion": "^2.0.1"
@@ -3036,7 +3079,7 @@
     },
     "node_modules/fill-range": {
       "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/fill-range/-/fill-range-7.1.1.tgz",
       "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
       "dev": true,
       "license": "MIT",
@@ -3049,7 +3092,7 @@
     },
     "node_modules/find-up": {
       "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/find-up/-/find-up-5.0.0.tgz",
       "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
       "dev": true,
       "license": "MIT",
@@ -3066,7 +3109,7 @@
     },
     "node_modules/flat": {
       "version": "5.0.2",
-      "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/flat/-/flat-5.0.2.tgz",
       "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==",
       "dev": true,
       "license": "BSD-3-Clause",
@@ -3076,7 +3119,7 @@
     },
     "node_modules/flat-cache": {
       "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/flat-cache/-/flat-cache-3.2.0.tgz",
       "integrity": "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==",
       "dev": true,
       "license": "MIT",
@@ -3090,15 +3133,15 @@
       }
     },
     "node_modules/flatted": {
-      "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz",
-      "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==",
+      "version": "3.4.1",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/flatted/-/flatted-3.4.1.tgz",
+      "integrity": "sha512-IxfVbRFVlV8V/yRaGzk0UVIcsKKHMSfYw66T/u4nTwlWteQePsxe//LjudR1AMX4tZW3WFCh3Zqa/sjlqpbURQ==",
       "dev": true,
       "license": "ISC"
     },
     "node_modules/foreground-child": {
       "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/foreground-child/-/foreground-child-3.3.1.tgz",
       "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==",
       "dev": true,
       "license": "ISC",
@@ -3114,15 +3157,16 @@
       }
     },
     "node_modules/form-data": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.2.tgz",
-      "integrity": "sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w==",
+      "version": "4.0.5",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/form-data/-/form-data-4.0.5.tgz",
+      "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "asynckit": "^0.4.0",
         "combined-stream": "^1.0.8",
         "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
         "mime-types": "^2.1.12"
       },
       "engines": {
@@ -3131,7 +3175,7 @@
     },
     "node_modules/fs-extra": {
       "version": "10.1.0",
-      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/fs-extra/-/fs-extra-10.1.0.tgz",
       "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
       "license": "MIT",
       "dependencies": {
@@ -3145,14 +3189,14 @@
     },
     "node_modules/fs.realpath": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/fs.realpath/-/fs.realpath-1.0.0.tgz",
       "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
       "dev": true,
       "license": "ISC"
     },
     "node_modules/fsevents": {
       "version": "2.3.3",
-      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/fsevents/-/fsevents-2.3.3.tgz",
       "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
       "dev": true,
       "hasInstallScript": true,
@@ -3167,7 +3211,7 @@
     },
     "node_modules/function-bind": {
       "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/function-bind/-/function-bind-1.1.2.tgz",
       "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
       "dev": true,
       "license": "MIT",
@@ -3177,14 +3221,14 @@
     },
     "node_modules/functional-red-black-tree": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz",
       "integrity": "sha512-dsKNQNdj6xA3T+QlADDA7mOSlX0qiMINjn0cgr+eGHGsbSHzTabcIogz2+p/iqP1Xs6EP/sS2SbqH+brGTbq0g==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/get-caller-file": {
       "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/get-caller-file/-/get-caller-file-2.0.5.tgz",
       "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
       "dev": true,
       "license": "ISC",
@@ -3193,9 +3237,9 @@
       }
     },
     "node_modules/get-east-asian-width": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.3.0.tgz",
-      "integrity": "sha512-vpeMIQKxczTD/0s2CdEWHcb0eeJe6TFjxb+J5xgX7hScxqrGuyjmv4c1D4A/gelKfyox0gJJwIHF+fLjeaM8kQ==",
+      "version": "1.5.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/get-east-asian-width/-/get-east-asian-width-1.5.0.tgz",
+      "integrity": "sha512-CQ+bEO+Tva/qlmw24dCejulK5pMzVnUOFOijVogd3KQs07HnRIgp8TGipvCCRT06xeYEbpbgwaCxglFyiuIcmA==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -3207,7 +3251,7 @@
     },
     "node_modules/get-intrinsic": {
       "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
       "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
       "dev": true,
       "license": "MIT",
@@ -3232,7 +3276,7 @@
     },
     "node_modules/get-proto": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/get-proto/-/get-proto-1.0.1.tgz",
       "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
       "dev": true,
       "license": "MIT",
@@ -3245,26 +3289,30 @@
       }
     },
     "node_modules/get-stream": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-8.0.1.tgz",
-      "integrity": "sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA==",
+      "version": "9.0.1",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/get-stream/-/get-stream-9.0.1.tgz",
+      "integrity": "sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "@sec-ant/readable-stream": "^0.4.1",
+        "is-stream": "^4.0.1"
+      },
       "engines": {
-        "node": ">=16"
+        "node": ">=18"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/git-cliff": {
-      "version": "2.8.0",
-      "resolved": "https://registry.npmjs.org/git-cliff/-/git-cliff-2.8.0.tgz",
-      "integrity": "sha512-iKF5QTXAb9+iVvmu5HpnMPWYw7fs74xkpAaRbSf29+dZaMTTNRIUST/y+Ir2S1bDUWWJNjXlwT9ZT62JuYLQnA==",
+      "version": "2.12.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/git-cliff/-/git-cliff-2.12.0.tgz",
+      "integrity": "sha512-kjTm5439LsvMs/xRxndWBUetrA4aQfLE8DTbR/ER5H7fGn7ioeFG9YNAK1V7dpTtNi6k2uKYY4f3EvT8J1d+1Q==",
       "dev": true,
       "license": "MIT OR Apache-2.0",
       "dependencies": {
-        "execa": "^8.0.1"
+        "execa": "^9.6.0"
       },
       "bin": {
         "git-cliff": "lib/cli/cli.js"
@@ -3273,18 +3321,18 @@
         "node": ">=18.19 || >=20.6 || >=21"
       },
       "optionalDependencies": {
-        "git-cliff-darwin-arm64": "2.8.0",
-        "git-cliff-darwin-x64": "2.8.0",
-        "git-cliff-linux-arm64": "2.8.0",
-        "git-cliff-linux-x64": "2.8.0",
-        "git-cliff-windows-arm64": "2.8.0",
-        "git-cliff-windows-x64": "2.8.0"
+        "git-cliff-darwin-arm64": "2.12.0",
+        "git-cliff-darwin-x64": "2.12.0",
+        "git-cliff-linux-arm64": "2.12.0",
+        "git-cliff-linux-x64": "2.12.0",
+        "git-cliff-windows-arm64": "2.12.0",
+        "git-cliff-windows-x64": "2.12.0"
       }
     },
     "node_modules/git-cliff-darwin-arm64": {
-      "version": "2.8.0",
-      "resolved": "https://registry.npmjs.org/git-cliff-darwin-arm64/-/git-cliff-darwin-arm64-2.8.0.tgz",
-      "integrity": "sha512-rurUV2d1Z2n+c2+wUrO0gZaFb3c1G+ej0bPfKTPfde/CblxiysMkh+4dz23NrVbc8IlS5rSYv/JFGVaVSBNJRw==",
+      "version": "2.12.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/git-cliff-darwin-arm64/-/git-cliff-darwin-arm64-2.12.0.tgz",
+      "integrity": "sha512-k3jzFDmkjc+6MjpnqvRenzMWRbZN5J+w3iQ8WNt9pSmPewNJIm92O/G6AbAxQaCbSfzQapeZ0e+5wSacVc62GA==",
       "cpu": [
         "arm64"
       ],
@@ -3296,9 +3344,9 @@
       ]
     },
     "node_modules/git-cliff-darwin-x64": {
-      "version": "2.8.0",
-      "resolved": "https://registry.npmjs.org/git-cliff-darwin-x64/-/git-cliff-darwin-x64-2.8.0.tgz",
-      "integrity": "sha512-Wtj+FGWZBWmeYUAGlkfz7QPz4+VVxxDPMhQ/7iwKVA3iryIX0slGfzYpqMurEFnTAMr0r+4IU3Q4O/ib7iUscg==",
+      "version": "2.12.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/git-cliff-darwin-x64/-/git-cliff-darwin-x64-2.12.0.tgz",
+      "integrity": "sha512-Kkoe+nfmXM/WMcZuC+OaIGA5vj847Ima6NEaaHnyb7Xsri+OAJryPXlABV7q6UeGfiiN2MlL8UsoHgnIEIQLqQ==",
       "cpu": [
         "x64"
       ],
@@ -3310,9 +3358,9 @@
       ]
     },
     "node_modules/git-cliff-linux-arm64": {
-      "version": "2.8.0",
-      "resolved": "https://registry.npmjs.org/git-cliff-linux-arm64/-/git-cliff-linux-arm64-2.8.0.tgz",
-      "integrity": "sha512-k4RdfMdORXyefznWlQb+7wDgo7XgQF9qg8hJC34bwyJK2sODirrGau3uTx1/9Fi37g+pAOM7wM+LYppHCTZ2bQ==",
+      "version": "2.12.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/git-cliff-linux-arm64/-/git-cliff-linux-arm64-2.12.0.tgz",
+      "integrity": "sha512-eTp2gZjV4LmfzdlhFsYFYuWf5mojALU03X/37r3VmnpuabaijuTEQo/zm/0BKP8gPiLKLR4ofdUvE1OSisCE1A==",
       "cpu": [
         "arm64"
       ],
@@ -3324,9 +3372,9 @@
       ]
     },
     "node_modules/git-cliff-linux-x64": {
-      "version": "2.8.0",
-      "resolved": "https://registry.npmjs.org/git-cliff-linux-x64/-/git-cliff-linux-x64-2.8.0.tgz",
-      "integrity": "sha512-FcWX4GHgodYrQlZR03fzooanStgR03JNWvyaMQB1asplQ18nlziK2UyA+PESCIxOQmeLXauqoCApfzmdtp5myg==",
+      "version": "2.12.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/git-cliff-linux-x64/-/git-cliff-linux-x64-2.12.0.tgz",
+      "integrity": "sha512-abidFG6dH2N5hPUF245/kRYdwViP11Pz7ZwIW/a86CJLZ/WSE7dJt0f2cUIkxTcFSsp11OwuLc5k1hAbwmiIRw==",
       "cpu": [
         "x64"
       ],
@@ -3338,9 +3386,9 @@
       ]
     },
     "node_modules/git-cliff-windows-arm64": {
-      "version": "2.8.0",
-      "resolved": "https://registry.npmjs.org/git-cliff-windows-arm64/-/git-cliff-windows-arm64-2.8.0.tgz",
-      "integrity": "sha512-GJSrqmBVTbMtBJI3/YCDxLviZZDgYgnKqYgquBk2u2AELAnnuWFnVFQ7ZEBUqgFF2UJu9EdV2Nv6MV8d/wnP0g==",
+      "version": "2.12.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/git-cliff-windows-arm64/-/git-cliff-windows-arm64-2.12.0.tgz",
+      "integrity": "sha512-rFuI+D/3Yq3jqafazZw5E68HsXEvcwI/B/5IPDIZD+QqZh8vETf4IXs7wVxYWWtHQJDC+G9ZrR3vE5648mdG3A==",
       "cpu": [
         "arm64"
       ],
@@ -3352,9 +3400,9 @@
       ]
     },
     "node_modules/git-cliff-windows-x64": {
-      "version": "2.8.0",
-      "resolved": "https://registry.npmjs.org/git-cliff-windows-x64/-/git-cliff-windows-x64-2.8.0.tgz",
-      "integrity": "sha512-8jl0YMXPYjUmVygUEeQ4wf1zte3Rv8LPq1sIklUKl80XE4g2Gm/8EIWbKpUPLQH6IncRwepY6VuMgpVpPXbwNw==",
+      "version": "2.12.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/git-cliff-windows-x64/-/git-cliff-windows-x64-2.12.0.tgz",
+      "integrity": "sha512-jskb3nyVGr4dekHSCDM/J6iho45t37wnmMGkPNq42kOoUp04JS96yMBrNRdXfXV9ViZsaZq3NaNu1e3QkhFlyA==",
       "cpu": [
         "x64"
       ],
@@ -3366,9 +3414,10 @@
       ]
     },
     "node_modules/glob": {
-      "version": "10.4.5",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
-      "integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
+      "version": "10.5.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/glob/-/glob-10.5.0.tgz",
+      "integrity": "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==",
+      "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
       "dev": true,
       "license": "ISC",
       "dependencies": {
@@ -3386,35 +3435,22 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
-    "node_modules/glob/node_modules/brace-expansion": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
-      "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0"
-      }
-    },
-    "node_modules/glob/node_modules/minimatch": {
-      "version": "9.0.5",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
-      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+    "node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
       "dev": true,
       "license": "ISC",
       "dependencies": {
-        "brace-expansion": "^2.0.1"
+        "is-glob": "^4.0.1"
       },
       "engines": {
-        "node": ">=16 || 14 >=14.17"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
+        "node": ">= 6"
       }
     },
     "node_modules/globals": {
       "version": "13.24.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/globals/-/globals-13.24.0.tgz",
       "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==",
       "dev": true,
       "license": "MIT",
@@ -3430,7 +3466,7 @@
     },
     "node_modules/globby": {
       "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/globby/-/globby-11.1.0.tgz",
       "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==",
       "dev": true,
       "license": "MIT",
@@ -3451,7 +3487,7 @@
     },
     "node_modules/gopd": {
       "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/gopd/-/gopd-1.2.0.tgz",
       "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
       "dev": true,
       "license": "MIT",
@@ -3464,29 +3500,30 @@
     },
     "node_modules/graceful-fs": {
       "version": "4.2.11",
-      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/graceful-fs/-/graceful-fs-4.2.11.tgz",
       "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
       "license": "ISC"
     },
     "node_modules/graphemer": {
       "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/graphemer/-/graphemer-1.4.0.tgz",
       "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/has-flag": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
-      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "version": "3.0.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
+      "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=8"
+        "node": ">=4"
       }
     },
     "node_modules/has-symbols": {
       "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/has-symbols/-/has-symbols-1.1.0.tgz",
       "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
       "dev": true,
       "license": "MIT",
@@ -3499,7 +3536,7 @@
     },
     "node_modules/has-tostringtag": {
       "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
       "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
       "dev": true,
       "license": "MIT",
@@ -3515,7 +3552,7 @@
     },
     "node_modules/hasown": {
       "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/hasown/-/hasown-2.0.2.tgz",
       "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
       "dev": true,
       "license": "MIT",
@@ -3528,7 +3565,7 @@
     },
     "node_modules/he": {
       "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/he/-/he-1.2.0.tgz",
       "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==",
       "dev": true,
       "license": "MIT",
@@ -3538,7 +3575,7 @@
     },
     "node_modules/highlight.js": {
       "version": "11.11.1",
-      "resolved": "https://registry.npmjs.org/highlight.js/-/highlight.js-11.11.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/highlight.js/-/highlight.js-11.11.1.tgz",
       "integrity": "sha512-Xwwo44whKBVCYoliBQwaPvtd/2tYFkRQtXDWj1nackaV2JPXx3L0+Jvd8/qCJ2p+ML0/XVkJ2q+Mr+UVdpJK5w==",
       "license": "BSD-3-Clause",
       "engines": {
@@ -3554,7 +3591,7 @@
     },
     "node_modules/htmlparser2": {
       "version": "8.0.2",
-      "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-8.0.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/htmlparser2/-/htmlparser2-8.0.2.tgz",
       "integrity": "sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==",
       "funding": [
         "https://github.com/fb55/htmlparser2?sponsor=1",
@@ -3573,7 +3610,7 @@
     },
     "node_modules/http-proxy-agent": {
       "version": "7.0.2",
-      "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
       "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
       "dev": true,
       "license": "MIT",
@@ -3587,7 +3624,7 @@
     },
     "node_modules/httpgd": {
       "version": "0.1.6",
-      "resolved": "https://registry.npmjs.org/httpgd/-/httpgd-0.1.6.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/httpgd/-/httpgd-0.1.6.tgz",
       "integrity": "sha512-HyozzYjOq+rGi3P+YZtLnvBPAWvdn2tiCfUuB4tSUradRtOoKAvwcZ+yvOYxusMzaZIGkf02s/BTkcDzj+XS/w==",
       "license": "MIT",
       "dependencies": {
@@ -3599,7 +3636,7 @@
     },
     "node_modules/https-proxy-agent": {
       "version": "7.0.6",
-      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
       "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
       "dev": true,
       "license": "MIT",
@@ -3612,18 +3649,18 @@
       }
     },
     "node_modules/human-signals": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-5.0.0.tgz",
-      "integrity": "sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==",
+      "version": "8.0.1",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/human-signals/-/human-signals-8.0.1.tgz",
+      "integrity": "sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ==",
       "dev": true,
       "license": "Apache-2.0",
       "engines": {
-        "node": ">=16.17.0"
+        "node": ">=18.18.0"
       }
     },
     "node_modules/ieee754": {
       "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ieee754/-/ieee754-1.2.1.tgz",
       "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
       "funding": [
         {
@@ -3643,7 +3680,7 @@
     },
     "node_modules/ignore": {
       "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ignore/-/ignore-5.3.2.tgz",
       "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
       "dev": true,
       "license": "MIT",
@@ -3653,14 +3690,14 @@
     },
     "node_modules/immediate": {
       "version": "3.0.6",
-      "resolved": "https://registry.npmjs.org/immediate/-/immediate-3.0.6.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/immediate/-/immediate-3.0.6.tgz",
       "integrity": "sha512-XXOFtyqDjNDAQxVfYxuF7g9Il/IbWmmlQg2MYKOH8ExIT1qg6xc4zyS3HaEEATgs1btfzxq15ciUiY7gjSXRGQ==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/import-fresh": {
       "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/import-fresh/-/import-fresh-3.3.1.tgz",
       "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
       "dev": true,
       "license": "MIT",
@@ -3677,7 +3714,7 @@
     },
     "node_modules/imurmurhash": {
       "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/imurmurhash/-/imurmurhash-0.1.4.tgz",
       "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
       "dev": true,
       "license": "MIT",
@@ -3687,7 +3724,7 @@
     },
     "node_modules/inflight": {
       "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/inflight/-/inflight-1.0.6.tgz",
       "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
       "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
       "dev": true,
@@ -3699,20 +3736,20 @@
     },
     "node_modules/inherits": {
       "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/inherits/-/inherits-2.0.4.tgz",
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
       "dev": true,
       "license": "ISC"
     },
     "node_modules/int64-buffer": {
       "version": "0.1.10",
-      "resolved": "https://registry.npmjs.org/int64-buffer/-/int64-buffer-0.1.10.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/int64-buffer/-/int64-buffer-0.1.10.tgz",
       "integrity": "sha512-v7cSY1J8ydZ0GyjUHqF+1bshJ6cnEVLo9EnjB8p+4HDRPZc9N5jjmvUV7NvEsqQOKyH0pmIBFWXVQbiS0+OBbA==",
       "license": "MIT"
     },
     "node_modules/is-binary-path": {
       "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/is-binary-path/-/is-binary-path-2.1.0.tgz",
       "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
       "dev": true,
       "license": "MIT",
@@ -3725,7 +3762,7 @@
     },
     "node_modules/is-extglob": {
       "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/is-extglob/-/is-extglob-2.1.1.tgz",
       "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
       "dev": true,
       "license": "MIT",
@@ -3735,7 +3772,7 @@
     },
     "node_modules/is-fullwidth-code-point": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
       "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
       "dev": true,
       "license": "MIT",
@@ -3745,7 +3782,7 @@
     },
     "node_modules/is-glob": {
       "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/is-glob/-/is-glob-4.0.3.tgz",
       "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
       "dev": true,
       "license": "MIT",
@@ -3758,7 +3795,7 @@
     },
     "node_modules/is-interactive": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/is-interactive/-/is-interactive-2.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/is-interactive/-/is-interactive-2.0.0.tgz",
       "integrity": "sha512-qP1vozQRI+BMOPcjFzrjXuQvdak2pHNUMZoeG2eRbiSqyvbEf/wQtEOTOX1guk6E3t36RkaqiSt8A/6YElNxLQ==",
       "dev": true,
       "license": "MIT",
@@ -3771,7 +3808,7 @@
     },
     "node_modules/is-number": {
       "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/is-number/-/is-number-7.0.0.tgz",
       "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
       "dev": true,
       "license": "MIT",
@@ -3779,37 +3816,50 @@
         "node": ">=0.12.0"
       }
     },
-    "node_modules/is-plain-obj": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz",
-      "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==",
+    "node_modules/is-path-inside": {
+      "version": "3.0.3",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/is-path-inside/-/is-path-inside-3.0.3.tgz",
+      "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==",
       "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8"
       }
     },
+    "node_modules/is-plain-obj": {
+      "version": "4.1.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/is-plain-obj/-/is-plain-obj-4.1.0.tgz",
+      "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/is-stream": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-3.0.0.tgz",
-      "integrity": "sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==",
+      "version": "4.0.1",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/is-stream/-/is-stream-4.0.1.tgz",
+      "integrity": "sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+        "node": ">=18"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/is-unicode-supported": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz",
-      "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==",
+      "version": "2.1.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/is-unicode-supported/-/is-unicode-supported-2.1.0.tgz",
+      "integrity": "sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=10"
+        "node": ">=18"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
@@ -3817,20 +3867,20 @@
     },
     "node_modules/isarray": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/isarray/-/isarray-1.0.0.tgz",
       "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
       "license": "MIT"
     },
     "node_modules/isexe": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/isexe/-/isexe-2.0.0.tgz",
       "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
       "dev": true,
       "license": "ISC"
     },
     "node_modules/isomorphic-ws": {
       "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/isomorphic-ws/-/isomorphic-ws-4.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/isomorphic-ws/-/isomorphic-ws-4.0.1.tgz",
       "integrity": "sha512-BhBvN2MBpWTaSHdWRb/bwdZJ1WaehQ2L1KngkCkfLUGF0mAWAT1sQUQacEmQ0jXkFw/czDXPNQSL5u2/Krsz1w==",
       "license": "MIT",
       "peerDependencies": {
@@ -3862,6 +3912,29 @@
         "node": ">=10"
       }
     },
+    "node_modules/istanbul-lib-report/node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/istanbul-lib-report/node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/istanbul-reports": {
       "version": "3.2.0",
       "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/istanbul-reports/-/istanbul-reports-3.2.0.tgz",
@@ -3878,7 +3951,7 @@
     },
     "node_modules/jackspeak": {
       "version": "3.4.3",
-      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/jackspeak/-/jackspeak-3.4.3.tgz",
       "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==",
       "dev": true,
       "license": "BlueOak-1.0.0",
@@ -3893,15 +3966,14 @@
       }
     },
     "node_modules/jake": {
-      "version": "10.9.2",
-      "resolved": "https://registry.npmjs.org/jake/-/jake-10.9.2.tgz",
-      "integrity": "sha512-2P4SQ0HrLQ+fw6llpLnOaGAvN2Zu6778SJMrCUwns4fOoG9ayrTiZk3VV8sCPkVZF8ab0zksVpS8FDY5pRCNBA==",
+      "version": "10.9.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/jake/-/jake-10.9.4.tgz",
+      "integrity": "sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA==",
       "license": "Apache-2.0",
       "dependencies": {
-        "async": "^3.2.3",
-        "chalk": "^4.0.2",
+        "async": "^3.2.6",
         "filelist": "^1.0.4",
-        "minimatch": "^3.1.2"
+        "picocolors": "^1.1.1"
       },
       "bin": {
         "jake": "bin/cli.js"
@@ -3912,27 +3984,27 @@
     },
     "node_modules/jquery": {
       "version": "3.7.1",
-      "resolved": "https://registry.npmjs.org/jquery/-/jquery-3.7.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/jquery/-/jquery-3.7.1.tgz",
       "integrity": "sha512-m4avr8yL8kmFN8psrbFFFmB/If14iN5o9nw/NgnnM+kybDJpRsAynV2BsfpTYrTRysYUdADVD7CkUUizgkpLfg==",
       "license": "MIT"
     },
     "node_modules/jquery.json-viewer": {
       "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/jquery.json-viewer/-/jquery.json-viewer-1.5.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/jquery.json-viewer/-/jquery.json-viewer-1.5.0.tgz",
       "integrity": "sha512-M/mRFXg14V/UUAlz7TBNBIDmQdWt05BunsqC/UjEx5BoFdQpNpfkfDdVn+VtjX951n/an/T9GWB3apBp02x8Mg==",
       "license": "MIT"
     },
     "node_modules/js-tokens": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/js-tokens/-/js-tokens-4.0.0.tgz",
       "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/js-yaml": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+      "version": "4.1.1",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/js-yaml/-/js-yaml-4.1.1.tgz",
+      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
       "license": "MIT",
       "dependencies": {
         "argparse": "^2.0.1"
@@ -3943,7 +4015,7 @@
     },
     "node_modules/jsdoc-type-pratt-parser": {
       "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/jsdoc-type-pratt-parser/-/jsdoc-type-pratt-parser-1.2.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/jsdoc-type-pratt-parser/-/jsdoc-type-pratt-parser-1.2.0.tgz",
       "integrity": "sha512-4STjeF14jp4bqha44nKMY1OUI6d2/g6uclHWUCZ7B4DoLzaB5bmpTkQrpqU+vSVzMD0LsKAOskcnI3I3VfIpmg==",
       "dev": true,
       "license": "MIT",
@@ -3953,29 +4025,29 @@
     },
     "node_modules/json-buffer": {
       "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/json-buffer/-/json-buffer-3.0.1.tgz",
       "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/json-schema-traverse": {
       "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
       "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/json-stable-stringify-without-jsonify": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
       "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/jsonfile": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
-      "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
+      "version": "6.2.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/jsonfile/-/jsonfile-6.2.0.tgz",
+      "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
       "license": "MIT",
       "dependencies": {
         "universalify": "^2.0.0"
@@ -3986,7 +4058,7 @@
     },
     "node_modules/jszip": {
       "version": "3.10.1",
-      "resolved": "https://registry.npmjs.org/jszip/-/jszip-3.10.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/jszip/-/jszip-3.10.1.tgz",
       "integrity": "sha512-xXDvecyTpGLrqFrvkrUSoxxfJI5AH7U8zxxtVclpsUtMCq4JQ290LY8AW5c7Ggnr/Y/oK+bQMbqK2qmtk3pN4g==",
       "dev": true,
       "license": "(MIT OR GPL-3.0-or-later)",
@@ -3999,14 +4071,14 @@
     },
     "node_modules/just-extend": {
       "version": "6.2.0",
-      "resolved": "https://registry.npmjs.org/just-extend/-/just-extend-6.2.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/just-extend/-/just-extend-6.2.0.tgz",
       "integrity": "sha512-cYofQu2Xpom82S6qD778jBDpwvvy39s1l/hrYij2u9AMdQcGRpaBu6kY4mVhuno5kJVi1DAz4aiphA2WI1/OAw==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/keyv": {
       "version": "4.5.4",
-      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/keyv/-/keyv-4.5.4.tgz",
       "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
       "dev": true,
       "license": "MIT",
@@ -4016,7 +4088,7 @@
     },
     "node_modules/levn": {
       "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/levn/-/levn-0.4.1.tgz",
       "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
       "dev": true,
       "license": "MIT",
@@ -4030,7 +4102,7 @@
     },
     "node_modules/lie": {
       "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/lie/-/lie-3.3.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/lie/-/lie-3.3.0.tgz",
       "integrity": "sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ==",
       "dev": true,
       "license": "MIT",
@@ -4040,7 +4112,7 @@
     },
     "node_modules/locate-path": {
       "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/locate-path/-/locate-path-6.0.0.tgz",
       "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
       "dev": true,
       "license": "MIT",
@@ -4055,37 +4127,29 @@
       }
     },
     "node_modules/lodash": {
-      "version": "4.17.21",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
-      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/lodash.get": {
-      "version": "4.4.2",
-      "resolved": "https://registry.npmjs.org/lodash.get/-/lodash.get-4.4.2.tgz",
-      "integrity": "sha512-z+Uw/vLuy6gQe8cfaFWD7p0wVv8fJl3mbzXh33RS+0oW2wvUqiRXiQ69gLWSLpgB5/6sU+r6BlQR0MBILadqTQ==",
-      "deprecated": "This package is deprecated. Use the optional chaining (?.) operator instead.",
+      "version": "4.17.23",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/lodash/-/lodash-4.17.23.tgz",
+      "integrity": "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/lodash.merge": {
       "version": "4.6.2",
-      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/lodash.merge/-/lodash.merge-4.6.2.tgz",
       "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/lodash.truncate": {
       "version": "4.4.2",
-      "resolved": "https://registry.npmjs.org/lodash.truncate/-/lodash.truncate-4.4.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/lodash.truncate/-/lodash.truncate-4.4.2.tgz",
       "integrity": "sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/log-symbols": {
       "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/log-symbols/-/log-symbols-4.1.0.tgz",
       "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==",
       "dev": true,
       "license": "MIT",
@@ -4100,9 +4164,22 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/log-symbols/node_modules/is-unicode-supported": {
+      "version": "0.1.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz",
+      "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/lru-cache": {
       "version": "10.4.3",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/lru-cache/-/lru-cache-10.4.3.tgz",
       "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
       "dev": true,
       "license": "ISC"
@@ -4125,7 +4202,7 @@
     },
     "node_modules/math-intrinsics": {
       "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
       "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
       "dev": true,
       "license": "MIT",
@@ -4133,16 +4210,9 @@
         "node": ">= 0.4"
       }
     },
-    "node_modules/merge-stream": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz",
-      "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/merge2": {
       "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/merge2/-/merge2-1.4.1.tgz",
       "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
       "dev": true,
       "license": "MIT",
@@ -4152,7 +4222,7 @@
     },
     "node_modules/micromatch": {
       "version": "4.0.8",
-      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/micromatch/-/micromatch-4.0.8.tgz",
       "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
       "dev": true,
       "license": "MIT",
@@ -4166,7 +4236,7 @@
     },
     "node_modules/mime-db": {
       "version": "1.52.0",
-      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/mime-db/-/mime-db-1.52.0.tgz",
       "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
       "dev": true,
       "license": "MIT",
@@ -4176,7 +4246,7 @@
     },
     "node_modules/mime-types": {
       "version": "2.1.35",
-      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/mime-types/-/mime-types-2.1.35.tgz",
       "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
       "dev": true,
       "license": "MIT",
@@ -4187,22 +4257,9 @@
         "node": ">= 0.6"
       }
     },
-    "node_modules/mimic-fn": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-4.0.0.tgz",
-      "integrity": "sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/mimic-function": {
       "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/mimic-function/-/mimic-function-5.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/mimic-function/-/mimic-function-5.0.1.tgz",
       "integrity": "sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==",
       "dev": true,
       "license": "MIT",
@@ -4214,51 +4271,56 @@
       }
     },
     "node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "version": "9.0.9",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/minimatch/-/minimatch-9.0.9.tgz",
+      "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
+      "dev": true,
       "license": "ISC",
       "dependencies": {
-        "brace-expansion": "^1.1.7"
+        "brace-expansion": "^2.0.2"
       },
       "engines": {
-        "node": "*"
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
       }
     },
     "node_modules/minipass": {
-      "version": "7.1.2",
-      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
-      "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+      "version": "7.1.3",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/minipass/-/minipass-7.1.3.tgz",
+      "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
       "dev": true,
-      "license": "ISC",
+      "license": "BlueOak-1.0.0",
       "engines": {
         "node": ">=16 || 14 >=14.17"
       }
     },
     "node_modules/mocha": {
-      "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/mocha/-/mocha-11.1.0.tgz",
-      "integrity": "sha512-8uJR5RTC2NgpY3GrYcgpZrsEd9zKbPDpob1RezyR2upGHRQtHWofmzTMzTMSV6dru3tj5Ukt0+Vnq1qhFEEwAg==",
+      "version": "11.7.5",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/mocha/-/mocha-11.7.5.tgz",
+      "integrity": "sha512-mTT6RgopEYABzXWFx+GcJ+ZQ32kp4fMf0xvpZIIfSq9Z8lC/++MtcCnQ9t5FP2veYEP95FIYSvW+U9fV4xrlig==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "ansi-colors": "^4.1.3",
         "browser-stdout": "^1.3.1",
-        "chokidar": "^3.5.3",
+        "chokidar": "^4.0.1",
         "debug": "^4.3.5",
-        "diff": "^5.2.0",
+        "diff": "^7.0.0",
         "escape-string-regexp": "^4.0.0",
         "find-up": "^5.0.0",
         "glob": "^10.4.5",
         "he": "^1.2.0",
+        "is-path-inside": "^3.0.3",
         "js-yaml": "^4.1.0",
         "log-symbols": "^4.1.0",
-        "minimatch": "^5.1.6",
+        "minimatch": "^9.0.5",
         "ms": "^2.1.3",
+        "picocolors": "^1.1.1",
         "serialize-javascript": "^6.0.2",
         "strip-json-comments": "^3.1.1",
         "supports-color": "^8.1.1",
-        "workerpool": "^6.5.1",
+        "workerpool": "^9.2.0",
         "yargs": "^17.7.2",
         "yargs-parser": "^21.1.1",
         "yargs-unparser": "^2.0.0"
@@ -4271,32 +4333,49 @@
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
       }
     },
-    "node_modules/mocha/node_modules/brace-expansion": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
-      "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+    "node_modules/mocha/node_modules/chokidar": {
+      "version": "4.0.3",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/chokidar/-/chokidar-4.0.3.tgz",
+      "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "balanced-match": "^1.0.0"
+        "readdirp": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 14.16.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
       }
     },
-    "node_modules/mocha/node_modules/minimatch": {
-      "version": "5.1.6",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
-      "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
+    "node_modules/mocha/node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
       "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^2.0.1"
-      },
+      "license": "MIT",
       "engines": {
-        "node": ">=10"
+        "node": ">=8"
+      }
+    },
+    "node_modules/mocha/node_modules/readdirp": {
+      "version": "4.1.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/readdirp/-/readdirp-4.1.2.tgz",
+      "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.18.0"
+      },
+      "funding": {
+        "type": "individual",
+        "url": "https://paulmillr.com/funding/"
       }
     },
     "node_modules/mocha/node_modules/supports-color": {
       "version": "8.1.1",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/supports-color/-/supports-color-8.1.1.tgz",
       "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
       "dev": true,
       "license": "MIT",
@@ -4312,14 +4391,14 @@
     },
     "node_modules/ms": {
       "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ms/-/ms-2.1.3.tgz",
       "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/msgpack-lite": {
       "version": "0.1.26",
-      "resolved": "https://registry.npmjs.org/msgpack-lite/-/msgpack-lite-0.1.26.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/msgpack-lite/-/msgpack-lite-0.1.26.tgz",
       "integrity": "sha512-SZ2IxeqZ1oRFGo0xFGbvBJWMp3yLIY9rlIJyxy8CGrwZn1f0ZK4r6jV/AM1r0FZMDUkWkglOk/eeKIL9g77Nxw==",
       "license": "MIT",
       "dependencies": {
@@ -4334,21 +4413,21 @@
     },
     "node_modules/natural-compare": {
       "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/natural-compare/-/natural-compare-1.4.0.tgz",
       "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/natural-compare-lite": {
       "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/natural-compare-lite/-/natural-compare-lite-1.4.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/natural-compare-lite/-/natural-compare-lite-1.4.0.tgz",
       "integrity": "sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/nerdbank-streams": {
       "version": "2.5.60",
-      "resolved": "https://registry.npmjs.org/nerdbank-streams/-/nerdbank-streams-2.5.60.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/nerdbank-streams/-/nerdbank-streams-2.5.60.tgz",
       "integrity": "sha512-saQaMyTtVDAEc+S+BPXKM6K1AF3FyrorFSDzaCkdmtDe2kZzu1aYPQZNLmnxJhxbTcghYrEmYFFoaDxBDVadCw==",
       "license": "MIT",
       "dependencies": {
@@ -4360,7 +4439,7 @@
     },
     "node_modules/nise": {
       "version": "5.1.9",
-      "resolved": "https://registry.npmjs.org/nise/-/nise-5.1.9.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/nise/-/nise-5.1.9.tgz",
       "integrity": "sha512-qOnoujW4SV6e40dYxJOb3uvuoPHtmLzIk4TFo+j0jPJoC+5Z9xja5qH5JZobEPsa8+YYphMrOSwnrshEhG2qww==",
       "dev": true,
       "license": "BSD-3-Clause",
@@ -4374,7 +4453,7 @@
     },
     "node_modules/nise/node_modules/@sinonjs/fake-timers": {
       "version": "11.3.1",
-      "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-11.3.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/@sinonjs/fake-timers/-/fake-timers-11.3.1.tgz",
       "integrity": "sha512-EVJO7nW5M/F5Tur0Rf2z/QoMo+1Ia963RiMtapiQrEWvY0iBUvADo8Beegwjpnle5BHkyHuoxSTW3jF43H1XRA==",
       "dev": true,
       "license": "BSD-3-Clause",
@@ -4384,7 +4463,7 @@
     },
     "node_modules/node-fetch": {
       "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/node-fetch/-/node-fetch-2.7.0.tgz",
       "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
       "license": "MIT",
       "dependencies": {
@@ -4404,7 +4483,7 @@
     },
     "node_modules/normalize-path": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/normalize-path/-/normalize-path-3.0.0.tgz",
       "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
       "dev": true,
       "license": "MIT",
@@ -4413,16 +4492,17 @@
       }
     },
     "node_modules/npm-run-path": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-5.3.0.tgz",
-      "integrity": "sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ==",
+      "version": "6.0.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/npm-run-path/-/npm-run-path-6.0.0.tgz",
+      "integrity": "sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "path-key": "^4.0.0"
+        "path-key": "^4.0.0",
+        "unicorn-magic": "^0.3.0"
       },
       "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+        "node": ">=18"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
@@ -4430,7 +4510,7 @@
     },
     "node_modules/npm-run-path/node_modules/path-key": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/path-key/-/path-key-4.0.0.tgz",
       "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==",
       "dev": true,
       "license": "MIT",
@@ -4443,7 +4523,7 @@
     },
     "node_modules/nth-check": {
       "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/nth-check/-/nth-check-2.1.1.tgz",
       "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==",
       "license": "BSD-2-Clause",
       "dependencies": {
@@ -4455,7 +4535,7 @@
     },
     "node_modules/once": {
       "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/once/-/once-1.4.0.tgz",
       "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
       "dev": true,
       "license": "ISC",
@@ -4465,7 +4545,7 @@
     },
     "node_modules/onetime": {
       "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/onetime/-/onetime-7.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/onetime/-/onetime-7.0.0.tgz",
       "integrity": "sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==",
       "dev": true,
       "license": "MIT",
@@ -4481,7 +4561,7 @@
     },
     "node_modules/optionator": {
       "version": "0.9.4",
-      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/optionator/-/optionator-0.9.4.tgz",
       "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
       "dev": true,
       "license": "MIT",
@@ -4499,7 +4579,7 @@
     },
     "node_modules/ora": {
       "version": "8.2.0",
-      "resolved": "https://registry.npmjs.org/ora/-/ora-8.2.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ora/-/ora-8.2.0.tgz",
       "integrity": "sha512-weP+BZ8MVNnlCm8c0Qdc1WSWq4Qn7I+9CJGm7Qali6g44e/PUzbjNqJX5NJ9ljlNMosfJvg1fKEGILklK9cwnw==",
       "dev": true,
       "license": "MIT",
@@ -4522,9 +4602,9 @@
       }
     },
     "node_modules/ora/node_modules/ansi-regex": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
-      "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
+      "version": "6.2.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ansi-regex/-/ansi-regex-6.2.2.tgz",
+      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -4535,9 +4615,9 @@
       }
     },
     "node_modules/ora/node_modules/chalk": {
-      "version": "5.4.1",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.4.1.tgz",
-      "integrity": "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==",
+      "version": "5.6.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/chalk/-/chalk-5.6.2.tgz",
+      "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -4548,28 +4628,15 @@
       }
     },
     "node_modules/ora/node_modules/emoji-regex": {
-      "version": "10.4.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.4.0.tgz",
-      "integrity": "sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw==",
+      "version": "10.6.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/emoji-regex/-/emoji-regex-10.6.0.tgz",
+      "integrity": "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A==",
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/ora/node_modules/is-unicode-supported": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-2.1.0.tgz",
-      "integrity": "sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/ora/node_modules/log-symbols": {
       "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-6.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/log-symbols/-/log-symbols-6.0.0.tgz",
       "integrity": "sha512-i24m8rpwhmPIS4zscNzK6MSEhk0DUWa/8iYQWxhffV8jkI4Phvs3F+quL5xvS0gdQR0FyTCMMH33Y78dDTzzIw==",
       "dev": true,
       "license": "MIT",
@@ -4586,7 +4653,7 @@
     },
     "node_modules/ora/node_modules/log-symbols/node_modules/is-unicode-supported": {
       "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-1.3.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/is-unicode-supported/-/is-unicode-supported-1.3.0.tgz",
       "integrity": "sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ==",
       "dev": true,
       "license": "MIT",
@@ -4599,7 +4666,7 @@
     },
     "node_modules/ora/node_modules/string-width": {
       "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/string-width/-/string-width-7.2.0.tgz",
       "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==",
       "dev": true,
       "license": "MIT",
@@ -4616,13 +4683,13 @@
       }
     },
     "node_modules/ora/node_modules/strip-ansi": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
-      "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
+      "version": "7.2.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/strip-ansi/-/strip-ansi-7.2.0.tgz",
+      "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "ansi-regex": "^6.0.1"
+        "ansi-regex": "^6.2.2"
       },
       "engines": {
         "node": ">=12"
@@ -4633,7 +4700,7 @@
     },
     "node_modules/p-limit": {
       "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/p-limit/-/p-limit-3.1.0.tgz",
       "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
       "dev": true,
       "license": "MIT",
@@ -4649,7 +4716,7 @@
     },
     "node_modules/p-locate": {
       "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/p-locate/-/p-locate-5.0.0.tgz",
       "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
       "dev": true,
       "license": "MIT",
@@ -4665,21 +4732,21 @@
     },
     "node_modules/package-json-from-dist": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
       "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==",
       "dev": true,
       "license": "BlueOak-1.0.0"
     },
     "node_modules/pako": {
       "version": "1.0.11",
-      "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/pako/-/pako-1.0.11.tgz",
       "integrity": "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==",
       "dev": true,
       "license": "(MIT AND Zlib)"
     },
     "node_modules/parent-module": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/parent-module/-/parent-module-1.0.1.tgz",
       "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
       "dev": true,
       "license": "MIT",
@@ -4690,13 +4757,26 @@
         "node": ">=6"
       }
     },
+    "node_modules/parse-ms": {
+      "version": "4.0.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/parse-ms/-/parse-ms-4.0.0.tgz",
+      "integrity": "sha512-TXfryirbmq34y8QBwgqCVLi+8oA3oWx2eAnSn62ITyEhEYaWRlVZ2DvMM9eZbMs/RfxPu/PK/aBLyGj4IrqMHw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/parse5": {
-      "version": "7.2.1",
-      "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.2.1.tgz",
-      "integrity": "sha512-BuBYQYlv1ckiPdQi/ohiivi9Sagc9JG+Ozs0r7b/0iK3sKmrb0b9FdWdBbOdx6hBCM/F9Ir82ofnBhtZOjCRPQ==",
+      "version": "7.3.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/parse5/-/parse5-7.3.0.tgz",
+      "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
       "license": "MIT",
       "dependencies": {
-        "entities": "^4.5.0"
+        "entities": "^6.0.0"
       },
       "funding": {
         "url": "https://github.com/inikulin/parse5?sponsor=1"
@@ -4704,7 +4784,7 @@
     },
     "node_modules/parse5-htmlparser2-tree-adapter": {
       "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.1.0.tgz",
       "integrity": "sha512-ruw5xyKs6lrpo9x9rCZqZZnIUntICjQAd0Wsmp396Ul9lN/h+ifgVV1x1gZHi8euej6wTfpqX8j+BFQxF0NS/g==",
       "license": "MIT",
       "dependencies": {
@@ -4715,9 +4795,21 @@
         "url": "https://github.com/inikulin/parse5?sponsor=1"
       }
     },
+    "node_modules/parse5/node_modules/entities": {
+      "version": "6.0.1",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/entities/-/entities-6.0.1.tgz",
+      "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
     "node_modules/path-exists": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/path-exists/-/path-exists-4.0.0.tgz",
       "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
       "dev": true,
       "license": "MIT",
@@ -4727,7 +4819,7 @@
     },
     "node_modules/path-is-absolute": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
       "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
       "dev": true,
       "license": "MIT",
@@ -4737,7 +4829,7 @@
     },
     "node_modules/path-key": {
       "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/path-key/-/path-key-3.1.1.tgz",
       "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
       "dev": true,
       "license": "MIT",
@@ -4747,7 +4839,7 @@
     },
     "node_modules/path-scurry": {
       "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/path-scurry/-/path-scurry-1.11.1.tgz",
       "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==",
       "dev": true,
       "license": "BlueOak-1.0.0",
@@ -4764,14 +4856,14 @@
     },
     "node_modules/path-to-regexp": {
       "version": "6.3.0",
-      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-6.3.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/path-to-regexp/-/path-to-regexp-6.3.0.tgz",
       "integrity": "sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/path-type": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/path-type/-/path-type-4.0.0.tgz",
       "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==",
       "dev": true,
       "license": "MIT",
@@ -4781,14 +4873,13 @@
     },
     "node_modules/picocolors": {
       "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/picocolors/-/picocolors-1.1.1.tgz",
       "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
-      "dev": true,
       "license": "ISC"
     },
     "node_modules/picomatch": {
       "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/picomatch/-/picomatch-2.3.1.tgz",
       "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
       "dev": true,
       "license": "MIT",
@@ -4801,7 +4892,7 @@
     },
     "node_modules/prelude-ls": {
       "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/prelude-ls/-/prelude-ls-1.2.1.tgz",
       "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
       "dev": true,
       "license": "MIT",
@@ -4809,16 +4900,32 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/pretty-ms": {
+      "version": "9.3.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/pretty-ms/-/pretty-ms-9.3.0.tgz",
+      "integrity": "sha512-gjVS5hOP+M3wMm5nmNOucbIrqudzs9v/57bWRHQWLYklXqoXKrVfYW2W9+glfGsqtPgpiz5WwyEEB+ksXIx3gQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "parse-ms": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/process-nextick-args": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
       "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/progress": {
       "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/progress/-/progress-2.0.3.tgz",
       "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==",
       "dev": true,
       "license": "MIT",
@@ -4828,7 +4935,7 @@
     },
     "node_modules/punycode": {
       "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/punycode/-/punycode-2.3.1.tgz",
       "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
       "dev": true,
       "license": "MIT",
@@ -4838,7 +4945,7 @@
     },
     "node_modules/queue-microtask": {
       "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/queue-microtask/-/queue-microtask-1.2.3.tgz",
       "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
       "dev": true,
       "funding": [
@@ -4859,7 +4966,7 @@
     },
     "node_modules/randombytes": {
       "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/randombytes/-/randombytes-2.1.0.tgz",
       "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==",
       "dev": true,
       "license": "MIT",
@@ -4869,7 +4976,7 @@
     },
     "node_modules/readable-stream": {
       "version": "2.3.8",
-      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/readable-stream/-/readable-stream-2.3.8.tgz",
       "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
       "dev": true,
       "license": "MIT",
@@ -4885,7 +4992,7 @@
     },
     "node_modules/readdirp": {
       "version": "3.6.0",
-      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/readdirp/-/readdirp-3.6.0.tgz",
       "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
       "dev": true,
       "license": "MIT",
@@ -4898,7 +5005,7 @@
     },
     "node_modules/regexpp": {
       "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/regexpp/-/regexpp-3.2.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/regexpp/-/regexpp-3.2.0.tgz",
       "integrity": "sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg==",
       "dev": true,
       "license": "MIT",
@@ -4911,7 +5018,7 @@
     },
     "node_modules/regextras": {
       "version": "0.8.0",
-      "resolved": "https://registry.npmjs.org/regextras/-/regextras-0.8.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/regextras/-/regextras-0.8.0.tgz",
       "integrity": "sha512-k519uI04Z3SaY0fLX843MRXnDeG2+vHOFsyhiPZvNLe7r8rD2YNRjq4BQLZZ0oAr2NrtvZlICsXysGNFPGa3CQ==",
       "dev": true,
       "license": "MIT",
@@ -4921,7 +5028,7 @@
     },
     "node_modules/require-directory": {
       "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/require-directory/-/require-directory-2.1.1.tgz",
       "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
       "dev": true,
       "license": "MIT",
@@ -4931,7 +5038,7 @@
     },
     "node_modules/require-from-string": {
       "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/require-from-string/-/require-from-string-2.0.2.tgz",
       "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
       "dev": true,
       "license": "MIT",
@@ -4941,7 +5048,7 @@
     },
     "node_modules/resolve-from": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/resolve-from/-/resolve-from-4.0.0.tgz",
       "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
       "dev": true,
       "license": "MIT",
@@ -4951,7 +5058,7 @@
     },
     "node_modules/restore-cursor": {
       "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-5.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/restore-cursor/-/restore-cursor-5.1.0.tgz",
       "integrity": "sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA==",
       "dev": true,
       "license": "MIT",
@@ -4968,7 +5075,7 @@
     },
     "node_modules/reusify": {
       "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/reusify/-/reusify-1.1.0.tgz",
       "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
       "dev": true,
       "license": "MIT",
@@ -4979,7 +5086,7 @@
     },
     "node_modules/rimraf": {
       "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/rimraf/-/rimraf-3.0.2.tgz",
       "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
       "deprecated": "Rimraf versions prior to v4 are no longer supported",
       "dev": true,
@@ -4994,11 +5101,22 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
+    "node_modules/rimraf/node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
     "node_modules/rimraf/node_modules/glob": {
       "version": "7.2.3",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/glob/-/glob-7.2.3.tgz",
       "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
-      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
       "dev": true,
       "license": "ISC",
       "dependencies": {
@@ -5016,9 +5134,22 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
+    "node_modules/rimraf/node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/run-parallel": {
       "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/run-parallel/-/run-parallel-1.2.0.tgz",
       "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
       "dev": true,
       "funding": [
@@ -5042,15 +5173,15 @@
     },
     "node_modules/safe-buffer": {
       "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/safe-buffer/-/safe-buffer-5.1.2.tgz",
       "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/semver": {
-      "version": "7.7.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.1.tgz",
-      "integrity": "sha512-hlq8tAfn0m/61p4BVRcPzIGr6LKiMwo4VM6dGi6pt4qcRkmNzTcWq6eCEjEh+qXjkMDvPlOFFSGwQjoEa6gyMA==",
+      "version": "7.7.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/semver/-/semver-7.7.4.tgz",
+      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
       "license": "ISC",
       "bin": {
         "semver": "bin/semver.js"
@@ -5061,7 +5192,7 @@
     },
     "node_modules/serialize-javascript": {
       "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/serialize-javascript/-/serialize-javascript-6.0.2.tgz",
       "integrity": "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==",
       "dev": true,
       "license": "BSD-3-Clause",
@@ -5071,14 +5202,14 @@
     },
     "node_modules/setimmediate": {
       "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/setimmediate/-/setimmediate-1.0.5.tgz",
       "integrity": "sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/shebang-command": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/shebang-command/-/shebang-command-2.0.0.tgz",
       "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
       "dev": true,
       "license": "MIT",
@@ -5091,7 +5222,7 @@
     },
     "node_modules/shebang-regex": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/shebang-regex/-/shebang-regex-3.0.0.tgz",
       "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
       "dev": true,
       "license": "MIT",
@@ -5101,7 +5232,7 @@
     },
     "node_modules/signal-exit": {
       "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/signal-exit/-/signal-exit-4.1.0.tgz",
       "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
       "dev": true,
       "license": "ISC",
@@ -5114,7 +5245,7 @@
     },
     "node_modules/sinon": {
       "version": "15.2.0",
-      "resolved": "https://registry.npmjs.org/sinon/-/sinon-15.2.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/sinon/-/sinon-15.2.0.tgz",
       "integrity": "sha512-nPS85arNqwBXaIsFCkolHjGIkFo+Oxu9vbgmBJizLAhqe6P2o3Qmj3KCUoRkfhHtvgDhZdWD3risLHAUJ8npjw==",
       "deprecated": "16.1.1",
       "dev": true,
@@ -5132,9 +5263,42 @@
         "url": "https://opencollective.com/sinon"
       }
     },
+    "node_modules/sinon/node_modules/diff": {
+      "version": "5.2.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/diff/-/diff-5.2.2.tgz",
+      "integrity": "sha512-vtcDfH3TOjP8UekytvnHH1o1P4FcUdt4eQ1Y+Abap1tk/OB2MWQvcwS2ClCd1zuIhc3JKOx6p3kod8Vfys3E+A==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.3.1"
+      }
+    },
+    "node_modules/sinon/node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/sinon/node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/slash": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/slash/-/slash-3.0.0.tgz",
       "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==",
       "dev": true,
       "license": "MIT",
@@ -5144,7 +5308,7 @@
     },
     "node_modules/slice-ansi": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-4.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/slice-ansi/-/slice-ansi-4.0.0.tgz",
       "integrity": "sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==",
       "dev": true,
       "license": "MIT",
@@ -5162,14 +5326,14 @@
     },
     "node_modules/spdx-exceptions": {
       "version": "2.5.0",
-      "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz",
       "integrity": "sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==",
       "dev": true,
       "license": "CC-BY-3.0"
     },
     "node_modules/spdx-expression-parse": {
       "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz",
       "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==",
       "dev": true,
       "license": "MIT",
@@ -5179,22 +5343,22 @@
       }
     },
     "node_modules/spdx-license-ids": {
-      "version": "3.0.21",
-      "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.21.tgz",
-      "integrity": "sha512-Bvg/8F5XephndSK3JffaRqdT+gyhfqIPwDHpX80tJrF8QQRYMo8sNMeaZ2Dp5+jhwKnUmIOyFFQfHRkjJm5nXg==",
+      "version": "3.0.23",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/spdx-license-ids/-/spdx-license-ids-3.0.23.tgz",
+      "integrity": "sha512-CWLcCCH7VLu13TgOH+r8p1O/Znwhqv/dbb6lqWy67G+pT1kHmeD/+V36AVb/vq8QMIQwVShJ6Ssl5FPh0fuSdw==",
       "dev": true,
       "license": "CC0-1.0"
     },
     "node_modules/sprintf-js": {
       "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/sprintf-js/-/sprintf-js-1.0.3.tgz",
       "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==",
       "dev": true,
       "license": "BSD-3-Clause"
     },
     "node_modules/stdin-discarder": {
       "version": "0.2.2",
-      "resolved": "https://registry.npmjs.org/stdin-discarder/-/stdin-discarder-0.2.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/stdin-discarder/-/stdin-discarder-0.2.2.tgz",
       "integrity": "sha512-UhDfHmA92YAlNnCfhmq0VeNL5bDbiZGg7sZ2IvPsXubGkiNa9EC+tUTsjBRsYUAz87btI6/1wf4XoVvQ3uRnmQ==",
       "dev": true,
       "license": "MIT",
@@ -5207,13 +5371,13 @@
     },
     "node_modules/strict-event-emitter-types": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/strict-event-emitter-types/-/strict-event-emitter-types-2.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/strict-event-emitter-types/-/strict-event-emitter-types-2.0.0.tgz",
       "integrity": "sha512-Nk/brWYpD85WlOgzw5h173aci0Teyv8YdIAEtV+N88nDB0dLlazZyJMIsN6eo1/AR61l+p6CJTG1JIyFaoNEEA==",
       "license": "ISC"
     },
     "node_modules/string_decoder": {
       "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/string_decoder/-/string_decoder-1.1.1.tgz",
       "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
       "dev": true,
       "license": "MIT",
@@ -5223,7 +5387,7 @@
     },
     "node_modules/string-width": {
       "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/string-width/-/string-width-5.1.2.tgz",
       "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
       "dev": true,
       "license": "MIT",
@@ -5242,7 +5406,7 @@
     "node_modules/string-width-cjs": {
       "name": "string-width",
       "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/string-width/-/string-width-4.2.3.tgz",
       "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
       "dev": true,
       "license": "MIT",
@@ -5257,15 +5421,15 @@
     },
     "node_modules/string-width-cjs/node_modules/emoji-regex": {
       "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/emoji-regex/-/emoji-regex-8.0.0.tgz",
       "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/string-width/node_modules/ansi-regex": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
-      "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
+      "version": "6.2.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ansi-regex/-/ansi-regex-6.2.2.tgz",
+      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -5276,13 +5440,13 @@
       }
     },
     "node_modules/string-width/node_modules/strip-ansi": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
-      "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
+      "version": "7.2.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/strip-ansi/-/strip-ansi-7.2.0.tgz",
+      "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "ansi-regex": "^6.0.1"
+        "ansi-regex": "^6.2.2"
       },
       "engines": {
         "node": ">=12"
@@ -5293,7 +5457,7 @@
     },
     "node_modules/strip-ansi": {
       "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/strip-ansi/-/strip-ansi-6.0.1.tgz",
       "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
       "dev": true,
       "license": "MIT",
@@ -5307,7 +5471,7 @@
     "node_modules/strip-ansi-cjs": {
       "name": "strip-ansi",
       "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/strip-ansi/-/strip-ansi-6.0.1.tgz",
       "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
       "dev": true,
       "license": "MIT",
@@ -5319,13 +5483,13 @@
       }
     },
     "node_modules/strip-final-newline": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-3.0.0.tgz",
-      "integrity": "sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==",
+      "version": "4.0.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/strip-final-newline/-/strip-final-newline-4.0.0.tgz",
+      "integrity": "sha512-aulFJcD6YK8V1G7iRB5tigAP4TsHBZZrOV8pjV++zdUwmeV8uzbY7yn6h9MswN62adStNZFuCIx4haBnRuMDaw==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
@@ -5333,7 +5497,7 @@
     },
     "node_modules/strip-json-comments": {
       "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
       "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
       "dev": true,
       "license": "MIT",
@@ -5345,20 +5509,21 @@
       }
     },
     "node_modules/supports-color": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "version": "9.4.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/supports-color/-/supports-color-9.4.0.tgz",
+      "integrity": "sha512-VL+lNrEoIXww1coLPOmiEmK/0sGigko5COxI09KzHc2VJXJsQ37UaQ+8quuxjDeA7+KnLGTWRyOXSLLR2Wb4jw==",
+      "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "has-flag": "^4.0.0"
-      },
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/supports-color?sponsor=1"
       }
     },
     "node_modules/table": {
       "version": "6.9.0",
-      "resolved": "https://registry.npmjs.org/table/-/table-6.9.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/table/-/table-6.9.0.tgz",
       "integrity": "sha512-9kY+CygyYM6j02t5YFHbNz2FN5QmYGv9zAjVp4lCDjlCw7amdckXlEt/bjMhUIfj4ThGRE4gCUH5+yGnNuPo5A==",
       "dev": true,
       "license": "BSD-3-Clause",
@@ -5374,9 +5539,9 @@
       }
     },
     "node_modules/table/node_modules/ajv": {
-      "version": "8.17.1",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
-      "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
+      "version": "8.18.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ajv/-/ajv-8.18.0.tgz",
+      "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -5392,21 +5557,21 @@
     },
     "node_modules/table/node_modules/emoji-regex": {
       "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/emoji-regex/-/emoji-regex-8.0.0.tgz",
       "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/table/node_modules/json-schema-traverse": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
       "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/table/node_modules/string-width": {
       "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/string-width/-/string-width-4.2.3.tgz",
       "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
       "dev": true,
       "license": "MIT",
@@ -5448,6 +5613,17 @@
         "node": ">=8"
       }
     },
+    "node_modules/test-exclude/node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
     "node_modules/test-exclude/node_modules/glob": {
       "version": "7.2.3",
       "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/glob/-/glob-7.2.3.tgz",
@@ -5470,16 +5646,29 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
+    "node_modules/test-exclude/node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/text-table": {
       "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/text-table/-/text-table-0.2.0.tgz",
       "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/to-regex-range": {
       "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/to-regex-range/-/to-regex-range-5.0.1.tgz",
       "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
       "dev": true,
       "license": "MIT",
@@ -5492,13 +5681,20 @@
     },
     "node_modules/tr46": {
       "version": "0.0.3",
-      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/tr46/-/tr46-0.0.3.tgz",
       "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",
       "license": "MIT"
     },
+    "node_modules/tslib": {
+      "version": "1.14.1",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/tslib/-/tslib-1.14.1.tgz",
+      "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
+      "dev": true,
+      "license": "0BSD"
+    },
     "node_modules/tsutils": {
       "version": "3.21.0",
-      "resolved": "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/tsutils/-/tsutils-3.21.0.tgz",
       "integrity": "sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==",
       "dev": true,
       "license": "MIT",
@@ -5512,16 +5708,9 @@
         "typescript": ">=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta"
       }
     },
-    "node_modules/tsutils/node_modules/tslib": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
-      "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
-      "dev": true,
-      "license": "0BSD"
-    },
     "node_modules/type-check": {
       "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/type-check/-/type-check-0.4.0.tgz",
       "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
       "dev": true,
       "license": "MIT",
@@ -5534,7 +5723,7 @@
     },
     "node_modules/type-detect": {
       "version": "4.0.8",
-      "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/type-detect/-/type-detect-4.0.8.tgz",
       "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==",
       "dev": true,
       "license": "MIT",
@@ -5544,7 +5733,7 @@
     },
     "node_modules/type-fest": {
       "version": "0.20.2",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/type-fest/-/type-fest-0.20.2.tgz",
       "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
       "dev": true,
       "license": "(MIT OR CC0-1.0)",
@@ -5557,7 +5746,7 @@
     },
     "node_modules/typescript": {
       "version": "4.9.5",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/typescript/-/typescript-4.9.5.tgz",
       "integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==",
       "dev": true,
       "license": "Apache-2.0",
@@ -5571,13 +5760,26 @@
     },
     "node_modules/undici-types": {
       "version": "5.26.5",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/undici-types/-/undici-types-5.26.5.tgz",
       "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
       "license": "MIT"
     },
+    "node_modules/unicorn-magic": {
+      "version": "0.3.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/unicorn-magic/-/unicorn-magic-0.3.0.tgz",
+      "integrity": "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/universalify": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/universalify/-/universalify-2.0.1.tgz",
       "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
       "license": "MIT",
       "engines": {
@@ -5586,7 +5788,7 @@
     },
     "node_modules/uri-js": {
       "version": "4.4.1",
-      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/uri-js/-/uri-js-4.4.1.tgz",
       "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
       "dev": true,
       "license": "BSD-2-Clause",
@@ -5596,14 +5798,14 @@
     },
     "node_modules/util-deprecate": {
       "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/util-deprecate/-/util-deprecate-1.0.2.tgz",
       "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/v8-compile-cache": {
       "version": "2.4.0",
-      "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.4.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/v8-compile-cache/-/v8-compile-cache-2.4.0.tgz",
       "integrity": "sha512-ocyWc3bAHBB/guyqJQVI5o4BZkPhznPYUG2ea80Gond/BgNWpap8TOmLSeeQG7bnh2KMISxskdADG59j7zruhw==",
       "dev": true,
       "license": "MIT"
@@ -5625,7 +5827,7 @@
     },
     "node_modules/vscode-jsonrpc": {
       "version": "8.2.0",
-      "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-8.2.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/vscode-jsonrpc/-/vscode-jsonrpc-8.2.0.tgz",
       "integrity": "sha512-C+r0eKJUIfiDIfwJhria30+TYWPtuHJXHtI7J0YlOmKAo7ogxP20T0zxB7HZQIFhIyvoBPwWskjxrvAtfjyZfA==",
       "license": "MIT",
       "engines": {
@@ -5634,7 +5836,7 @@
     },
     "node_modules/vscode-languageclient": {
       "version": "9.0.1",
-      "resolved": "https://registry.npmjs.org/vscode-languageclient/-/vscode-languageclient-9.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/vscode-languageclient/-/vscode-languageclient-9.0.1.tgz",
       "integrity": "sha512-JZiimVdvimEuHh5olxhxkht09m3JzUGwggb5eRUkzzJhZ2KjCN0nh55VfiED9oez9DyF8/fz1g1iBV3h+0Z2EA==",
       "license": "MIT",
       "dependencies": {
@@ -5646,19 +5848,10 @@
         "vscode": "^1.82.0"
       }
     },
-    "node_modules/vscode-languageclient/node_modules/brace-expansion": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
-      "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0"
-      }
-    },
     "node_modules/vscode-languageclient/node_modules/minimatch": {
-      "version": "5.1.6",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
-      "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
+      "version": "5.1.9",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/minimatch/-/minimatch-5.1.9.tgz",
+      "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
       "license": "ISC",
       "dependencies": {
         "brace-expansion": "^2.0.1"
@@ -5669,7 +5862,7 @@
     },
     "node_modules/vscode-languageserver-protocol": {
       "version": "3.17.5",
-      "resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.17.5.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.17.5.tgz",
       "integrity": "sha512-mb1bvRJN8SVznADSGWM9u/b07H7Ecg0I3OgXDuLdn307rl/J3A9YD6/eYOssqhecL27hK1IPZAsaqh00i/Jljg==",
       "license": "MIT",
       "dependencies": {
@@ -5679,13 +5872,13 @@
     },
     "node_modules/vscode-languageserver-types": {
       "version": "3.17.5",
-      "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.17.5.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/vscode-languageserver-types/-/vscode-languageserver-types-3.17.5.tgz",
       "integrity": "sha512-Ld1VelNuX9pdF39h2Hgaeb5hEZM2Z3jUrrMgWQAu82jMtZp7p3vJT3BzToKtZI7NgQssZje5o0zryOrhQvzQAg==",
       "license": "MIT"
     },
     "node_modules/vsls": {
       "version": "1.0.4753",
-      "resolved": "https://registry.npmjs.org/vsls/-/vsls-1.0.4753.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/vsls/-/vsls-1.0.4753.tgz",
       "integrity": "sha512-hmrsMbhjuLoU8GgtVfqhbV4ZkGvDpLV2AFmzx+cCOGNra2qk0Q36dYkfwENqy/vJVQ/2/lhxcn+69FYnKQRhgg==",
       "license": "SEE LICENSE IN LICENSE.txt",
       "dependencies": {
@@ -5694,13 +5887,13 @@
     },
     "node_modules/webidl-conversions": {
       "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
       "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
       "license": "BSD-2-Clause"
     },
     "node_modules/whatwg-url": {
       "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/whatwg-url/-/whatwg-url-5.0.0.tgz",
       "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
       "license": "MIT",
       "dependencies": {
@@ -5710,7 +5903,7 @@
     },
     "node_modules/which": {
       "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/which/-/which-2.0.2.tgz",
       "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
       "dev": true,
       "license": "ISC",
@@ -5726,13 +5919,13 @@
     },
     "node_modules/winreg": {
       "version": "1.2.5",
-      "resolved": "https://registry.npmjs.org/winreg/-/winreg-1.2.5.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/winreg/-/winreg-1.2.5.tgz",
       "integrity": "sha512-uf7tHf+tw0B1y+x+mKTLHkykBgK2KMs3g+KlzmyMbLvICSHQyB/xOFjTT8qZ3oeTFyU7Bbj4FzXitGG6jvKhYw==",
       "license": "BSD-2-Clause"
     },
     "node_modules/word-wrap": {
       "version": "1.2.5",
-      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/word-wrap/-/word-wrap-1.2.5.tgz",
       "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
       "dev": true,
       "license": "MIT",
@@ -5741,15 +5934,15 @@
       }
     },
     "node_modules/workerpool": {
-      "version": "6.5.1",
-      "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.5.1.tgz",
-      "integrity": "sha512-Fs4dNYcsdpYSAfVxhnl1L5zTksjvOJxtC5hzMNl+1t9B8hTJTdKDyZ5ju7ztgPy+ft9tBFXoOlDNiOT9WUXZlA==",
+      "version": "9.3.4",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/workerpool/-/workerpool-9.3.4.tgz",
+      "integrity": "sha512-TmPRQYYSAnnDiEB0P/Ytip7bFGvqnSU6I2BcuSw7Hx+JSg/DsUi5ebYfc8GYaSdpuvOcEs6dXxPurOYpe9QFwg==",
       "dev": true,
       "license": "Apache-2.0"
     },
     "node_modules/wrap-ansi": {
       "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
       "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
       "dev": true,
       "license": "MIT",
@@ -5768,7 +5961,7 @@
     "node_modules/wrap-ansi-cjs": {
       "name": "wrap-ansi",
       "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
       "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
       "dev": true,
       "license": "MIT",
@@ -5786,14 +5979,14 @@
     },
     "node_modules/wrap-ansi-cjs/node_modules/emoji-regex": {
       "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/emoji-regex/-/emoji-regex-8.0.0.tgz",
       "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/wrap-ansi-cjs/node_modules/string-width": {
       "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/string-width/-/string-width-4.2.3.tgz",
       "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
       "dev": true,
       "license": "MIT",
@@ -5807,9 +6000,9 @@
       }
     },
     "node_modules/wrap-ansi/node_modules/ansi-regex": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
-      "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
+      "version": "6.2.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ansi-regex/-/ansi-regex-6.2.2.tgz",
+      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -5820,9 +6013,9 @@
       }
     },
     "node_modules/wrap-ansi/node_modules/ansi-styles": {
-      "version": "6.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz",
-      "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==",
+      "version": "6.2.3",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ansi-styles/-/ansi-styles-6.2.3.tgz",
+      "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -5833,13 +6026,13 @@
       }
     },
     "node_modules/wrap-ansi/node_modules/strip-ansi": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
-      "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
+      "version": "7.2.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/strip-ansi/-/strip-ansi-7.2.0.tgz",
+      "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "ansi-regex": "^6.0.1"
+        "ansi-regex": "^6.2.2"
       },
       "engines": {
         "node": ">=12"
@@ -5850,15 +6043,15 @@
     },
     "node_modules/wrappy": {
       "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/wrappy/-/wrappy-1.0.2.tgz",
       "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
       "dev": true,
       "license": "ISC"
     },
     "node_modules/ws": {
-      "version": "8.18.1",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.1.tgz",
-      "integrity": "sha512-RKW2aJZMXeMxVpnZ6bck+RswznaxmzdULiBr6KY7XkTnW8uvt0iT9H5DkHUChXrc+uurzwa0rVI16n/Xzjdz1w==",
+      "version": "8.19.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/ws/-/ws-8.19.0.tgz",
+      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"
@@ -5878,7 +6071,7 @@
     },
     "node_modules/y18n": {
       "version": "5.0.8",
-      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/y18n/-/y18n-5.0.8.tgz",
       "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
       "dev": true,
       "license": "ISC",
@@ -5888,7 +6081,7 @@
     },
     "node_modules/yargs": {
       "version": "17.7.2",
-      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/yargs/-/yargs-17.7.2.tgz",
       "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
       "dev": true,
       "license": "MIT",
@@ -5907,7 +6100,7 @@
     },
     "node_modules/yargs-parser": {
       "version": "21.1.1",
-      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/yargs-parser/-/yargs-parser-21.1.1.tgz",
       "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
       "dev": true,
       "license": "ISC",
@@ -5917,7 +6110,7 @@
     },
     "node_modules/yargs-unparser": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/yargs-unparser/-/yargs-unparser-2.0.0.tgz",
       "integrity": "sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==",
       "dev": true,
       "license": "MIT",
@@ -5931,16 +6124,26 @@
         "node": ">=10"
       }
     },
+    "node_modules/yargs-unparser/node_modules/is-plain-obj": {
+      "version": "2.1.0",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/is-plain-obj/-/is-plain-obj-2.1.0.tgz",
+      "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/yargs/node_modules/emoji-regex": {
       "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/emoji-regex/-/emoji-regex-8.0.0.tgz",
       "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/yargs/node_modules/string-width": {
       "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/string-width/-/string-width-4.2.3.tgz",
       "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
       "dev": true,
       "license": "MIT",
@@ -5955,7 +6158,7 @@
     },
     "node_modules/yocto-queue": {
       "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/yocto-queue/-/yocto-queue-0.1.0.tgz",
       "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
       "dev": true,
       "license": "MIT",
@@ -5965,6 +6168,19 @@
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
+    },
+    "node_modules/yoctocolors": {
+      "version": "2.1.2",
+      "resolved": "https://us-npm.pkg.dev/artifact-foundry-prod/ah-3p-staging-npm/yoctocolors/-/yoctocolors-2.1.2.tgz",
+      "integrity": "sha512-CzhO+pFNo8ajLM2d2IW/R93ipy99LWjtwblvC1RsoSUMZgyLbYFr221TnSNT7GjGdYui6P459mw9JH/g/zW2ug==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
     }
   }
 }
diff --git a/package.json b/package.json
index a06565c5..8df155a2 100644
--- a/package.json
+++ b/package.json
@@ -2007,48 +2007,47 @@
     "lint": "eslint src --ext ts"
   },
   "devDependencies": {
-    "@types/cheerio": "^0.22.29",
-    "@types/ejs": "^3.0.6",
-    "@types/express": "^4.17.12",
-    "@types/fs-extra": "^9.0.11",
-    "@types/glob": "^8.0.0",
+    "@types/cheerio": "^0.22.35",
+    "@types/ejs": "^3.1.5",
+    "@types/express": "^4.17.25",
+    "@types/fs-extra": "^9.0.13",
     "@types/highlight.js": "^10.1.0",
-    "@types/js-yaml": "^4.0.2",
-    "@types/mocha": "^8.2.2",
-    "@types/node": "^18.17.1",
-    "@types/node-fetch": "^2.5.10",
-    "@types/sinon": "^10.0.13",
-    "@types/vscode": "^1.75.0",
-    "@types/winreg": "^1.2.31",
-    "@types/ws": "^8.5.5",
-    "@typescript-eslint/eslint-plugin": "^5.30.0",
-    "@typescript-eslint/parser": "^5.30.0",
+    "@types/js-yaml": "^4.0.9",
+    "@types/mocha": "^8.2.3",
+    "@types/node": "^18.19.130",
+    "@types/node-fetch": "^2.6.13",
+    "@types/sinon": "^10.0.20",
+    "@types/vscode": "^1.110.0",
+    "@types/winreg": "^1.2.36",
+    "@types/ws": "^8.18.1",
+    "@typescript-eslint/eslint-plugin": "^5.62.0",
+    "@typescript-eslint/parser": "^5.62.0",
     "@vscode/test-cli": "^0.0.9",
-    "@vscode/test-electron": "^2.2.3",
-    "esbuild": "^0.27.3",
-    "eslint": "^7.28.0",
-    "eslint-plugin-jsdoc": "^35.1.3",
-    "git-cliff": "^2.8.0",
-    "mocha": "^11.1.0",
-    "sinon": "^15.0.1",
-    "typescript": "^4.7.2"
+    "@vscode/test-electron": "^2.5.2",
+    "esbuild": "^0.27.4",
+    "eslint": "^7.32.0",
+    "eslint-plugin-jsdoc": "^35.5.1",
+    "git-cliff": "^2.12.0",
+    "mocha": "^11.7.5",
+    "sinon": "^15.2.0",
+    "typescript": "^4.9.5"
   },
   "dependencies": {
-    "ag-grid-community": "^31.3.2",
+    "ag-grid-community": "^31.3.4",
     "cheerio": "1.0.0-rc.12",
     "crypto": "^1.0.1",
     "ejs": "^3.1.10",
-    "fs-extra": "^10.0.0",
-    "highlight.js": "^11.9.0",
+    "fs-extra": "^10.1.0",
+    "highlight.js": "^11.11.1",
     "httpgd": "0.1.6",
     "jquery": "^3.7.1",
     "jquery.json-viewer": "^1.5.0",
-    "js-yaml": "^4.1.0",
-    "node-fetch": "^2.6.7",
+    "js-yaml": "^4.1.1",
+    "node-fetch": "^2.7.0",
     "vscode-languageclient": "^9.0.1",
     "vsls": "^1.0.4753",
-    "winreg": "^1.2.4",
-    "ws": "^8.13.0"
+    "winreg": "^1.2.5",
+    "ws": "^8.19.0"
   },
   "extensionDependencies": [
     "REditorSupport.r-syntax"

From 41b298ac83c2d6d41431638d4744039729590136 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Fri, 13 Mar 2026 14:11:39 -0700
Subject: [PATCH 37/47] feat: migrate sess to pure websocket architecture

---
 sess/R/dispatch.R   |  17 ++++---
 sess/R/handlers.R   |  15 ++++--
 sess/R/rstudioapi.R |  30 ++++++------
 sess/R/server.R     | 117 +++++++++++++++++++++++++-------------------
 sess/README.md      |  78 +++++++++++++++--------------
 src/completions.ts  |   2 +-
 src/session.ts      | 105 +++++++++++++++++++++++----------------
 7 files changed, 210 insertions(+), 154 deletions(-)

diff --git a/sess/R/dispatch.R b/sess/R/dispatch.R
index 849dcc0d..603ebbfb 100644
--- a/sess/R/dispatch.R
+++ b/sess/R/dispatch.R
@@ -26,12 +26,15 @@ ipc_send <- function(method, params = list(), request = FALSE) {
 
   # Push over the websocket
   payload <- jsonlite::toJSON(msg, auto_unbox = TRUE, null = "null", force = TRUE)
-  tryCatch({
-    .sess_env$ws$send(payload)
-  }, error = function(e) {
-    warning("Failed to send IPC message: ", e$message)
-    return(invisible(FALSE))
-  })
+  tryCatch(
+    {
+      .sess_env$ws$send(payload)
+    },
+    error = function(e) {
+      warning("Failed to send IPC message: ", e$message)
+      return(invisible(FALSE))
+    }
+  )
 
   if (!request) {
     return(invisible(TRUE))
@@ -41,7 +44,7 @@ ipc_send <- function(method, params = list(), request = FALSE) {
   # Process HTTP/WS events in the background while blocking the R console execution
   # This prevents the R event loop from locking up.
   while (is.null(.sess_env$pending_responses[[req_id]])) {
-    httpuv::service() 
+    httpuv::service()
     Sys.sleep(0.01)
   }
 
diff --git a/sess/R/handlers.R b/sess/R/handlers.R
index 28293b28..1243a7dd 100644
--- a/sess/R/handlers.R
+++ b/sess/R/handlers.R
@@ -32,13 +32,13 @@ handle_hover <- function(expr_str) {
   }, error = function(e) NULL)
 }
 
-handle_complete <- function(expr_str, trigger) {
+handle_complete <- function(expr_str, trigger = NULL) {
   obj <- tryCatch({
     expr <- parse(text = expr_str, keep.source = FALSE)[[1]]
     eval(expr, .GlobalEnv)
   }, error = function(e) NULL)
 
-  if (is.null(obj)) {
+  if (is.null(obj) || is.null(trigger)) {
     return(NULL)
   }
 
@@ -76,4 +76,13 @@ handle_complete <- function(expr_str, trigger) {
   }
   
   NULL
-}
\ No newline at end of file
+}
+
+handle_plot_latest <- function() {
+  if (file.exists(.sess_env$latest_plot_path)) {
+    raw_img <- readBin(.sess_env$latest_plot_path, "raw", file.info(.sess_env$latest_plot_path)$size)
+    list(data = as.character(jsonlite::base64_enc(raw_img)))
+  } else {
+    list(data = NULL)
+  }
+}
diff --git a/sess/R/rstudioapi.R b/sess/R/rstudioapi.R
index 1cacf7b2..c7b3031a 100644
--- a/sess/R/rstudioapi.R
+++ b/sess/R/rstudioapi.R
@@ -1,5 +1,5 @@
 getActiveDocumentContext <- function() {
-    editor_context <- request_client("active_editor_context", args = list())
+    editor_context <- request_client("rstudioapi/active_editor_context", args = list())
     make_rs_document_context(editor_context)
 }
 
@@ -18,9 +18,9 @@ isAvailable <- function(version_needed = NULL, child_ok = FALSE) {
 
 insertText <- function(location, text, id = NULL) {
     if (missing(text) && is.character(location) && length(location) == 1) {
-        return(invisible(request_client("replace_text_in_current_selection", args = list(text = location, id = id))))
+        return(invisible(request_client("rstudioapi/replace_text_in_current_selection", args = list(text = location, id = id))))
     } else if (missing(location)) {
-        return(invisible(request_client("replace_text_in_current_selection", args = list(text = text, id = id))))
+        return(invisible(request_client("rstudioapi/replace_text_in_current_selection", args = list(text = text, id = id))))
     } else if (is.null(location) && missing(text)) {
         return(invisible(NULL))
     }
@@ -36,7 +36,7 @@ insertText <- function(location, text, id = NULL) {
         )
     }, normalised_location, normalised_text, SIMPLIFY = FALSE)
 
-    invisible(request_client("insert_or_modify_text", args = list(query = query, id = id)))
+    invisible(request_client("rstudioapi/insert_or_modify_text", args = list(query = query, id = id)))
 }
 
 modifyRange <- insertText
@@ -71,11 +71,11 @@ findFun <- function(name, version_needed = NULL, ...) {
 
 showDialog <- function(title, message, url = "") {
     message <- sprintf("%s: %s \n%s", title, message, url)
-    invisible(request_client("show_dialog", args = list(message = message)))
+    invisible(request_client("rstudioapi/show_dialog", args = list(message = message)))
 }
 
 navigateToFile <- function(file, line = 1L, column = 1L) {
-    invisible(request_client("navigate_to_file", args = list(
+    invisible(request_client("rstudioapi/navigate_to_file", args = list(
         file = normalizePath(file),
         line = line,
         column = column
@@ -88,29 +88,29 @@ setSelectionRanges <- function(ranges, id = NULL) {
         if (rstudioapi::is.document_position(location)) rstudioapi::document_range(location, location) else location
     })
     sess_ranges <- lapply(ranges, serialize_range)
-    invisible(request_client("set_selection_ranges", args = list(ranges = sess_ranges, id = id)))
+    invisible(request_client("rstudioapi/set_selection_ranges", args = list(ranges = sess_ranges, id = id)))
 }
 
 setCursorPosition <- setSelectionRanges
 
-documentSave <- function(id = NULL) invisible(request_client("document_save", args = list(id = id)))
+documentSave <- function(id = NULL) invisible(request_client("rstudioapi/document_save", args = list(id = id)))
 
 getActiveProject <- function() {
-    path_object <- request_client("get_project_path", args = list())
+    path_object <- request_client("rstudioapi/get_project_path", args = list())
     path_object$path # Should be NULL if no project is open
 }
 
-document_context <- function(id = NULL) request_client("document_context", args = list(id = id))
+document_context <- function(id = NULL) request_client("rstudioapi/document_context", args = list(id = id))
 
 documentId <- function(allowConsole = TRUE) document_context()$id$external
 documentPath <- function(id = NULL) document_context(id)$id$path
 
-documentSaveAll <- function() invisible(request_client("document_save_all", args = list()))
+documentSaveAll <- function() invisible(request_client("rstudioapi/document_save_all", args = list()))
 
 documentNew <- function(text = "", type = c("r", "rmarkdown", "sql"), position = rstudioapi::document_position(1, 1), execute = FALSE) {
     if (!rstudioapi::is.document_position((position))) stop("DocumentNew requires a document_position object")
     if (length(text) != 1 || !is.character(text)) stop("text for DocumentNew must be a length one character vector.")
-    invisible(request_client("document_new", args = list(text = text, type = match.arg(type), position = serialize_pos(position))))
+    invisible(request_client("rstudioapi/document_new", args = list(text = text, type = match.arg(type), position = serialize_pos(position))))
 }
 
 setDocumentContents <- function(text, id = NULL) {
@@ -135,14 +135,14 @@ getVersion <- function() numeric_version("0")
 
 versionInfo <- function() list(citation = "", mode = "generic-ipc", version = numeric_version("0"), release_name = "generic-ipc")
 
-sendToConsole <- function(code, execute = TRUE, echo = TRUE, focus = FALSE, animate = FALSE) {
+sendToConsole <- function(code, echo = TRUE, execute = TRUE, focus = TRUE, animate = FALSE) {
     if (!echo) warning("rstudioapi::sendToConsole echo = FALSE is not supported in the generic IPC client.")
     code_to_run <- paste0(code, collapse = "\n")
-    invisible(notify_client("send_to_console", params = list(code = code_to_run, execute = execute, focus = focus, animate = animate)))
+    invisible(notify_client("rstudioapi/send_to_console", params = list(code = code_to_run, execute = execute, focus = focus, animate = animate)))
 }
 
 documentClose <- function(id = NULL, save = TRUE) {
-    invisible(request_client("document_close", args = list(id = id, save = save)))
+    invisible(request_client("rstudioapi/document_close", args = list(id = id, save = save)))
 }
 
 .sess_not_yet_implemented <- function(...) stop("This {rstudioapi} function is not currently implemented for generic IPC.")
diff --git a/sess/R/server.R b/sess/R/server.R
index 6045ca84..bb51db52 100644
--- a/sess/R/server.R
+++ b/sess/R/server.R
@@ -20,56 +20,39 @@ sess_app <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
   .sess_env$latest_plot_path <- file.path(.sess_env$tempdir, "sess_plot.png")
 
   app_handlers <- list(
-    # --- HTTP HANDLER (The "Pull" API) ---
-    call = function(req) {
+    # --- WEBSOCKET HANDLER ---
+    onWSOpen = function(ws) {
       # 1. Authentication Check
-      auth_header <- req$HTTP_AUTHORIZATION
-      if (is.null(auth_header) || auth_header != .sess_env$token) {
-        return(list(status = 401L, headers = list("Content-Type" = "text/plain"), body = "Unauthorized"))
-      }
-
-      path <- req$PATH_INFO
-
-      # 2. Routing
-      if (path == "/rpc" && req$REQUEST_METHOD == "POST") {
-        # JSON-RPC 2.0 Implementation
-        body <- tryCatch(jsonlite::fromJSON(req$rook.input$read_lines()), error = function(e) NULL)
-
-        if (is.null(body) || is.null(body$method)) {
-          return(json_rpc_error(NULL, -32600, "Invalid Request"))
-        }
-
-        # Dispatch method
-        res <- switch(body$method,
-          "workspace" = get_workspace_data(),
-          "hover" = handle_hover(body$params$expr),
-          "completion" = handle_complete(body$params$expr, body$params$trigger),
-          "plot_latest" = {
-            if (file.exists(.sess_env$latest_plot_path)) {
-              raw_img <- readBin(.sess_env$latest_plot_path, "raw", file.info(.sess_env$latest_plot_path)$size)
-              list(data = as.character(jsonlite::base64_enc(raw_img)))
-            } else {
-              list(data = NULL)
-            }
-          },
-          NULL
-        )
-
-        if (is.null(res)) {
-          return(json_rpc_error(body$id, -32601, "Method not found"))
-        }
+      # Extract token from QUERY_STRING (e.g., "?token=xyz")
+      query_string <- ws$request$QUERY_STRING
+      parsed_query <- tryCatch(
+        {
+          # Simple parsing for ?token=value
+          parts <- strsplit(query_string, "&")[[1]]
+          token_part <- parts[grep("token=", parts)]
+          if (length(token_part) > 0) {
+            sub("^\\??token=", "", token_part[1])
+          } else {
+            ""
+          }
+        },
+        error = function(e) ""
+      )
 
-        return(json_rpc_response(body$id, res))
+      print_async_msg <- function(msg) {
+        prompt <- if (interactive()) getOption("prompt") else ""
+        cat(sprintf("\r%s\n\n%s", msg, prompt))
       }
 
-      list(status = 404L, headers = list("Content-Type" = "text/plain"), body = "Not Found")
-    },
+      if (parsed_query != .sess_env$token) {
+        print_async_msg("[sess] Unauthorized WebSocket connection attempt")
+        ws$close()
+        return()
+      }
 
-    # --- WEBSOCKET HANDLER (The "Push" API) ---
-    onWSOpen = function(ws) {
       # Bind the active websocket to our environment
       .sess_env$ws <- ws
-      cat("[sess] Client connected\n")
+      print_async_msg("[sess] Client connected")
 
       # Send the attach handshake immediately upon connection (JSON-RPC Notification)
       notify_client("attach", list(
@@ -89,18 +72,54 @@ sess_app <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
         payload <- tryCatch(jsonlite::fromJSON(message), error = function(e) NULL)
 
         if (!is.null(payload) && !is.null(payload$id)) {
-          # It's a Response (to our RStudio API request)
-          if (!is.null(payload$result)) {
-            .sess_env$pending_responses[[as.character(payload$id)]] <- payload$result
-          } else if (!is.null(payload$error)) {
-            .sess_env$pending_responses[[as.character(payload$id)]] <- structure(payload$error, class = "json_rpc_error")
+          if (!is.null(payload$method)) {
+            # It's a Request from the Client (e.g., 'workspace', 'plot_latest')
+            handlers <- list(
+              "workspace" = function(p) get_workspace_data(),
+              "hover" = function(p) handle_hover(p$expr),
+              "completion" = function(p) handle_complete(p$expr, p$trigger),
+              "plot_latest" = function(p) handle_plot_latest()
+            )
+
+            if (payload$method %in% names(handlers)) {
+              res <- tryCatch({
+                handlers[[payload$method]](payload$params)
+              }, error = function(e) {
+                # Handle unexpected R errors in handlers
+                warning(sprintf("[sess] Error in handler for '%s': %s", payload$method, e$message))
+                NULL
+              })
+              
+              # Send successful response
+              succ_resp <- list(
+                jsonrpc = "2.0",
+                id = payload$id,
+                result = res
+              )
+              ws$send(jsonlite::toJSON(succ_resp, auto_unbox = TRUE, null = "null", force = TRUE))
+            } else {
+              # Method not found
+              err_resp <- list(
+                jsonrpc = "2.0",
+                id = payload$id,
+                error = list(code = -32601, message = "Method not found")
+              )
+              ws$send(jsonlite::toJSON(err_resp, auto_unbox = TRUE, null = "null", force = TRUE))
+            }
+          } else {
+            # It's a Response (to our RStudio API request)
+            if (!is.null(payload$result)) {
+              .sess_env$pending_responses[[as.character(payload$id)]] <- payload$result
+            } else if (!is.null(payload$error)) {
+              .sess_env$pending_responses[[as.character(payload$id)]] <- structure(payload$error, class = "json_rpc_error")
+            }
           }
         }
       })
 
       ws$onClose(function() {
         .sess_env$ws <- NULL
-        cat("[sess] Client disconnected\n")
+        print_async_msg("[sess] Client disconnected")
       })
     }
   )
diff --git a/sess/README.md b/sess/README.md
index 95aac043..fb8402e6 100644
--- a/sess/README.md
+++ b/sess/README.md
@@ -1,30 +1,32 @@
 # `sess`: Modern R IPC Server Protocol
 
-The `sess` package provides a high-performance, token-authenticated IPC (Inter-Process Communication) mechanism between R and a client (such as an IDE or editor extension). It uses a hybrid **Push (WebSocket)** and **Pull (HTTP)** architecture to replace legacy file-based watchers.
+The `sess` package provides a high-performance, token-authenticated IPC (Inter-Process Communication) mechanism between R and a client (such as an IDE or editor extension). It uses a pure **WebSocket** architecture to replace legacy file-based watchers.
 
 ## 1. Connection Handshake
 
 When `sess::sess_app()` is started, it prints a connection string to the R console:
+
 ```text
 [sess] SESS_IPC_SERVER=ws://127.0.0.1:PORT?token=TOKEN
 ```
+
 A client can intercept this string or be configured with the port and token to establish a connection.
 
 - **Port**: Randomly assigned by `httpuv::randomPort()`.
 - **Token**: A random 32-character alphanumeric string generated per session.
 
-## 2. Communication Channels
+Authentication is performed immediately upon WebSocket connection by verifying the `token` in the query string.
 
-`sess` uses a hybrid architecture following the **JSON-RPC 2.0** specification for all structured data exchange.
+## 2. Communication Channels
 
-### WebSocket (Push & Synchronous API)
+`sess` uses a pure WebSocket architecture following the **JSON-RPC 2.0** specification for all structured data exchange. The WebSocket connection serves three main purposes: pushing instantaneous events from R to the client via notifications, allowing R to synchronously call client-side methods, and allowing the client to query R state via asynchronous requests.
 
-The WebSocket connection serves two main purposes: instantaneous pushing of events from R to the client via notifications, and allowing R to synchronously call client-side methods (such as emulating the RStudio API).
+### 1. Client Notifications (`notify_client`)
 
-#### 1. Client Notifications (`notify_client`)
 The WebSocket is used for instantaneous events pushed from R to the client as **JSON-RPC Notifications** (no `id`).
 
 **Notification Format:**
+
 ```json
 {
   "jsonrpc": "2.0",
@@ -34,10 +36,11 @@ The WebSocket is used for instantaneous events pushed from R to the client as **
 ```
 
 The following methods are sent as notifications from R to the client:
+
 - **`attach`**: Sent immediately upon connection. Includes PID, R version, and session metadata.
 - **`detach`**: Sent when the R session is shutting down (params: `pid`).
 - **`dataview`**: Triggered by `View()`. Params include a temporary JSON file path containing the data.
-- **`plot_updated`**: Notifies that a new static plot is available. The client should request the `plot_latest` method via HTTP.
+- **`plot_updated`**: Notifies that a new static plot is available. The client should request the `plot_latest` method.
 - **`httpgd`**: Provides a URL for an `httpgd` live plot server (params: `url`).
 - **`help`**: Requests the client to display an R help page (params: `requestPath`).
 - **`browser`**: Requests the client to open a URL (params: `url`, `title`, `viewer`).
@@ -45,43 +48,38 @@ The following methods are sent as notifications from R to the client:
 - **`restart_r`**: Requests the client to restart the R session (params: `command`, `clean`).
 - **`send_to_console`**: Sends code to the console for execution without blocking the R session (params: `code`, `execute`, `focus`, `animate`).
 
-#### 2. Synchronous Client Requests (`request_client`)
+### 2. Synchronous Client Requests (`request_client`)
 
 The `request_client()` function allows R to call client-side functions synchronously by sending a **JSON-RPC Request** (with an `id`) over the WebSocket. This is primarily used to emulate the RStudio API.
 
 **Coordinate Handling**: The `sess` protocol uses **1-indexed** coordinates for all rows (lines) and columns (characters) on the wire. This aligns with R's internal representation. The client (e.g., VS Code extension) is responsible for converting these to its internal 0-indexed representation if necessary.
 
 **Serialization Format**:
+
 - **Position**: A numeric array `[row, column]`.
 - **Range**: An object `{ "start": [row, column], "end": [row, column] }`.
 
 Below are the JSON-RPC methods sent from R to the client to emulate RStudio API functionality:
 
-- **`active_editor_context`**: Requests the current context of the active editor.
-- **`replace_text_in_current_selection`**: Replaces text in the current selection (params: `text`, `id`).
-- **`insert_or_modify_text`**: Inserts or modifies text at specific locations (params: `query`, `id`).
-- **`show_dialog`**: Displays a message dialog to the user (params: `message`).
-- **`navigate_to_file`**: Opens and navigates to a specific file, line, and column (params: `file`, `line`, `column`).
-- **`set_selection_ranges`**: Sets the cursor or selection ranges in the editor (params: `ranges`, `id`).
-- **`document_save`**: Saves the specified document (params: `id`).
-- **`get_project_path`**: Retrieves the current project path.
-- **`document_context`**: Retrieves the context of a specific document (params: `id`).
-- **`document_save_all`**: Saves all open documents.
-- **`document_new`**: Creates a new document with specified text and type (params: `text`, `type`, `position`).
-- **`document_close`**: Closes the specified document (params: `id`, `save`).
-
----
-
-### HTTP (Pull API)
-The Pull API allows the client to query state using **JSON-RPC Requests** sent via `POST` to the `/rpc` endpoint. All HTTP requests must include the `Authorization` header set to the session token.
+- **`rstudioapi/active_editor_context`**: Requests the current context of the active editor.
+- **`rstudioapi/replace_text_in_current_selection`**: Replaces text in the current selection (params: `text`, `id`).
+- **`rstudioapi/insert_or_modify_text`**: Inserts or modifies text at specific locations (params: `query`, `id`).
+- **`rstudioapi/show_dialog`**: Displays a message dialog to the user (params: `message`).
+- **`rstudioapi/navigate_to_file`**: Opens and navigates to a specific file, line, and column (params: `file`, `line`, `column`).
+- **`rstudioapi/set_selection_ranges`**: Sets the cursor or selection ranges in the editor (params: `ranges`, `id`).
+- **`rstudioapi/document_save`**: Saves the specified document (params: `id`).
+- **`rstudioapi/get_project_path`**: Retrieves the current project path.
+- **`rstudioapi/document_context`**: Retrieves the context of a specific document (params: `id`).
+- **`rstudioapi/document_save_all`**: Saves all open documents.
+- **`rstudioapi/document_new`**: Creates a new document with specified text and type (params: `text`, `type`, `position`).
+- **`rstudioapi/document_close`**: Closes the specified document (params: `id`, `save`).
 
-#### Endpoints
+### 3. Server Requests (Pull API)
 
-| Endpoint | Method | Description |
-| :--- | :--- | :--- |
-| `/rpc` | `POST` | The primary JSON-RPC 2.0 entry point. Requires `Authorization: <token>` header. |
+The Pull API allows the client to query state using **JSON-RPC Requests** sent over the active WebSocket.
 
 #### JSON-RPC Request Format
+
 ```json
 {
   "jsonrpc": "2.0",
@@ -95,8 +93,10 @@ The Pull API allows the client to query state using **JSON-RPC Requests** sent v
 
 **`workspace`**
 Returns object metadata from the Global Environment.
+
 - **Request Params**: None.
 - **Response Result**:
+
   ```json
   {
     "globalenv": {
@@ -109,16 +109,20 @@ Returns object metadata from the Global Environment.
 
 **`plot_latest`**
 Returns the most recent static plot captured by the R session.
+
 - **Request Params**: None.
 - **Response Result**: `{"data": "iVBORw0KGgoAAAANSUhEUgA..."}` (base64 encoded PNG string). Returns `{"data": null}` if no plot exists.
 
 **`hover`**
+
 - **Request Params**: `{"expr": "head(mtcars)"}`
 - **Response Result**: `{"str": " 'data.frame': 6 obs. of 11 variables: ..."}`
 
 **`completion`**
+
 - **Request Params**: `{"expr": "mtcars", "trigger": "$"}`
 - **Response Result**:
+
   ```json
   [
     { "name": "mpg", "type": "double", "str": "numeric" },
@@ -133,11 +137,13 @@ Returns the most recent static plot captured by the R session.
 By default, the package does not inject hooks into the R session on load. Calling `sess::sess_app()` will start the server and automatically call `sess::register_hooks()` to enable features like automatic `View()` interception or plot redirection.
 
 ### Intercepted Functions
+
 - **`utils::View()`**: Redirects data to the client's data viewer. Supports `data.frame`, `matrix`, `list`, and `ArrowTabular` objects.
 - **`browser()`**, **`viewer()`**, **`page_viewer()`**: Redirects URLs and HTML files to the client's browser or webview.
 - **Help System**: Intercepts help topic printing to route HTML help to the client.
 
 ### Global Options
+
 - **`sess.row_limit`**: Limits the number of rows sent to the data viewer (default: 100). Set to 0 for no limit.
 - **`sess.dataview`**: Target viewer column for data (default: `"Two"`).
 - **`sess.browser`**: Target viewer for browser (default: `"Active"`).
@@ -146,20 +152,20 @@ By default, the package does not inject hooks into the R session on load. Callin
 
 ## 4. Comparison with Legacy IPC
 
-The `sess` package replaces the legacy file-based IPC mechanism with a modern, in-memory hybrid architecture using **JSON-RPC 2.0**.
+The `sess` package replaces the legacy file-based IPC mechanism with a modern, in-memory WebSocket architecture using **JSON-RPC 2.0**.
 
 | Feature | Legacy IPC (File-based) | Modern IPC (`sess`) |
 | :--- | :--- | :--- |
 | **Command Dispatch** | `request.log` + `request.lock` | **WS Notification** (JSON-RPC) |
-| **Workspace State** | `workspace.json` + `workspace.lock` | **HTTP RPC `workspace`** (On-demand) |
-| **Static Plots** | `plot.png` + `plot.lock` | **WS Notification** + **HTTP RPC `plot_latest`** |
+| **Workspace State** | `workspace.json` + `workspace.lock` | **WS Request `workspace`** (On-demand) |
+| **Static Plots** | `plot.png` + `plot.lock` | **WS Notification** + **WS Request `plot_latest`** |
 | **RStudio API (Sync)**| `request.log` + `response.lock` | **WS Request** (JSON-RPC) |
-| **Client Queries** | Internal HTTP Server (`httpuv`) | **HTTP RPC** (JSON-RPC 2.0) |
-| **Transport Reliability**| OS-level File System Watchers | **WebSocket & HTTP streams** |
+| **Client Queries** | Internal HTTP Server (`httpuv`) | **WS Request** (JSON-RPC 2.0) |
+| **Transport Reliability**| OS-level File System Watchers | **WebSocket** |
 | **Protocol Standard** | Ad-hoc JSON formats | **JSON-RPC 2.0** |
 
 ### Architectural Shifts
 
 1. **Elimination of File Watchers**: Replaces unreliable OS-level file system watchers with persistent WebSocket connections for instantaneous event pushing.
-2. **On-Demand Evaluation**: Evaluations of the Global Environment are now performed only when requested by the client ("Pull" model), reducing R's background workload.
-3. **Unified Standard**: Unifies all structured communication under the **JSON-RPC 2.0** standard across WebSocket and HTTP transports.
+2. **On-Demand Evaluation**: Evaluations of the Global Environment are now performed only when requested by the client, reducing R's background workload.
+3. **Unified Standard**: Unifies all structured communication under the **JSON-RPC 2.0** standard across a single WebSocket connection.
diff --git a/src/completions.ts b/src/completions.ts
index 34fdb38c..1af7882b 100644
--- a/src/completions.ts
+++ b/src/completions.ts
@@ -168,7 +168,7 @@ export class LiveCompletionItemProvider implements vscode.CompletionItemProvider
                 const expr = document.getText(exprRange);
                 const response = await session.sessionRequest(session.server, {
                     method: 'completion',
-                    params: { expr: expr, trigger: completionContext.triggerCharacter }
+                    params: { expr: expr, trigger: trigger }
                 }) as RObjectElement[];
 
                 if (response) {
diff --git a/src/session.ts b/src/session.ts
index 20bc23b9..64c30bfa 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -2,8 +2,6 @@
 
 import * as fs from 'fs-extra';
 import * as path from 'path';
-import { Agent } from 'http';
-import fetch from 'node-fetch';
 import * as vscode from 'vscode';
 import { commands, Uri, ViewColumn, Webview, window, workspace, env } from 'vscode';
 
@@ -84,7 +82,6 @@ export let workingDir: string;
 let rVer: string;
 let pid: string;
 let info: SessionInfo;
-const httpAgent = new Agent({ keepAlive: true });
 export let server: SessionServer | undefined;
 export let workspaceFile: string;
 
@@ -111,6 +108,8 @@ export function deploySessionWatcher(extensionPath: string): void {
 let wsClient: ExtWebSocket | undefined;
 const activeConnections = new Map<number, ExtWebSocket>();
 
+const pendingRequests = new Map<number, { resolve: (value: unknown) => void, reject: (reason?: unknown) => void }>();
+
 export function startSessionWatcher(port: number, token: string, terminalPid?: number): void {
     if (activeConnections.has(port)) {
         console.info(`[startSessionWatcher] Already connected to port ${port}`);
@@ -129,7 +128,7 @@ export function startSessionWatcher(port: number, token: string, terminalPid?: n
     
     console.info(`[startSessionWatcher] Connecting to ws://127.0.0.1:${port}?token=${token}`);
     
-    // Initialize server object immediately so HTTP requests can proceed
+    // Initialize server object immediately so requests can proceed
     server = { host: '127.0.0.1', port, token };
 
     let retries = 0;
@@ -153,9 +152,23 @@ export function startSessionWatcher(port: number, token: string, terminalPid?: n
             void (async () => {
                 try {
                     const message = JSON.parse(data.toString()) as Record<string, unknown>;
-                    if (!message.id) {
+                    if (message.id !== undefined && !message.method) {
+                        // Response to a client request
+                        const id = Number(message.id);
+                        const pending = pendingRequests.get(id);
+                        if (pending) {
+                            pendingRequests.delete(id);
+                            if (message.error) {
+                                pending.reject(message.error);
+                            } else {
+                                pending.resolve(message.result);
+                            }
+                        }
+                    } else if (!message.id) {
+                        // Notification from server
                         await handleNotification(message, ws);
                     } else {
+                        // Request from server
                         await handleRequest(message, ws);
                     }                } catch (e) {
                     console.error('[startSessionWatcher] Error handling message', e);
@@ -331,6 +344,9 @@ export async function updateWorkspace() {
         const response = await sessionRequest(server, { jsonrpc: '2.0', id: 1, method: 'workspace' });
         if (response) {
             workspaceData = response as WorkspaceData;
+            if (activeSession) {
+                activeSession.workspaceData = workspaceData;
+            }
             void rWorkspace?.refresh();
             console.info('[updateWorkspace] Done');
             if (isLiveShare()) {
@@ -814,8 +830,6 @@ async function handleNotification(message: Record<string, unknown>, ws: ExtWebSo
     const method = String(message.method);
     const params = (message.params as Record<string, unknown>) || {};
 
-    console.info(`[handleNotification] method: ${method}, params: ${JSON.stringify(params)}`);
-
     switch (method) {
         case 'attach': {
             if (!params.tempdir || !params.wd) {return;}
@@ -898,7 +912,7 @@ async function handleNotification(message: Record<string, unknown>, ws: ExtWebSo
             await restartRTerminal();
             break;
         }
-        case 'send_to_console': {
+        case 'rstudioapi/send_to_console': {
             await rstudioapi.sendCodeToRTerminal(String(params.code), Boolean(params.execute), Boolean(params.focus));
             break;
         }
@@ -916,48 +930,48 @@ async function handleRequest(message: Record<string, unknown>, ws: ExtWebSocket)
         
         try {
             switch (method) {
-                case 'active_editor_context':
+                case 'rstudioapi/active_editor_context':
                     result = rstudioapi.activeEditorContext();
                     break;
-                case 'insert_or_modify_text':
+                case 'rstudioapi/insert_or_modify_text':
                     await rstudioapi.insertOrModifyText(params.query as Record<string, unknown>[], params.id as string | null);
                     result = true;
                     break;
-                case 'replace_text_in_current_selection':
+                case 'rstudioapi/replace_text_in_current_selection':
                     await rstudioapi.replaceTextInCurrentSelection(String(params.text), params.id as string | null);
                     result = true;
                     break;
-                case 'show_dialog':
+                case 'rstudioapi/show_dialog':
                     rstudioapi.showDialog(String(params.message));
                     result = true;
                     break;
-                case 'navigate_to_file':
+                case 'rstudioapi/navigate_to_file':
                     await rstudioapi.navigateToFile(String(params.file), Number(params.line), Number(params.column));
                     result = true;
                     break;
-                case 'set_selection_ranges':
+                case 'rstudioapi/set_selection_ranges':
                     await rstudioapi.setSelections(params.ranges as number[][], params.id as string | null);
                     result = true;
                     break;
-                case 'document_save':
+                case 'rstudioapi/document_save':
                     await rstudioapi.documentSave(params.id as string | null);
                     result = true;
                     break;
-                case 'document_save_all':
+                case 'rstudioapi/document_save_all':
                     await rstudioapi.documentSaveAll();
                     result = true;
                     break;
-                case 'get_project_path':
+                case 'rstudioapi/get_project_path':
                     result = rstudioapi.projectPath();
                     break;
-                case 'document_context':
+                case 'rstudioapi/document_context':
                     result = await rstudioapi.documentContext(params.id as string | null);
                     break;
-                case 'document_new':
+                case 'rstudioapi/document_new':
                     await rstudioapi.documentNew(String(params.text), String(params.type), params.position as number[]);
                     result = true;
                     break;
-                case 'document_close':
+                case 'rstudioapi/document_close':
                     await rstudioapi.documentClose(params.id as string | null, Boolean(params.save));
                     result = true;
                     break;
@@ -1032,30 +1046,35 @@ async function watchProcess(pid: string): Promise<string> {
 
 export async function sessionRequest(server: SessionServer, data: Record<string, unknown>): Promise<unknown> {
     try {
-        const payload = data.jsonrpc ? data : {
-            jsonrpc: '2.0',
-            id: Math.floor(Math.random() * 1000000),
-            ...data
-        };
-        const response = await fetch(`http://${server.host}:${server.port}/rpc`, {
-            agent: httpAgent,
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Accept: 'application/json',
-                Authorization: server.token
-            },
-            body: JSON.stringify(payload),
-            follow: 0,
-            timeout: 500,
-        });
-
-        if (!response.ok) {
-            throw new Error(`Error! status: ${response.status}`);
+        if (!wsClient || wsClient.readyState !== WebSocket.OPEN) {
+            throw new Error('WebSocket is not connected');
         }
-
-        const res = await response.json() as Record<string, unknown>;
-        return res.result !== undefined ? res.result : res;
+        
+        return await new Promise((resolve, reject) => {
+            const id = data.id !== undefined ? Number(data.id) : Math.floor(Math.random() * 1000000);
+            const payload = data.jsonrpc ? data : {
+                jsonrpc: '2.0',
+                id,
+                ...data
+            };
+            
+            pendingRequests.set(id, { resolve, reject });
+            
+            try {
+                wsClient!.send(JSON.stringify(payload));
+            } catch (e) {
+                pendingRequests.delete(id);
+                reject(e);
+            }
+            
+            // Timeout after 5 seconds
+            setTimeout(() => {
+                if (pendingRequests.has(id)) {
+                    pendingRequests.delete(id);
+                    reject(new Error('Request timed out'));
+                }
+            }, 5000);
+        });
     } catch (error) {
         if (error instanceof Error) {
             console.log('error message: ', error.message);

From ff0f2d36e673607b9132df738aa31bfe9dc18e93 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Fri, 13 Mar 2026 19:33:11 -0700
Subject: [PATCH 38/47] feat: unify viewer hooks and simplify webview
 notification handling

---
 sess/R/dispatch.R |  6 +++---
 sess/R/hooks.R    | 35 +++++++++++++++++++----------------
 src/session.ts    | 30 ++++++++++++++++++++++--------
 3 files changed, 44 insertions(+), 27 deletions(-)

diff --git a/sess/R/dispatch.R b/sess/R/dispatch.R
index 603ebbfb..ded0e6f5 100644
--- a/sess/R/dispatch.R
+++ b/sess/R/dispatch.R
@@ -7,7 +7,7 @@
 #' @param request Logical. If TRUE, sends a Request and waits for a Response.
 #' @return The result of the request if request=TRUE, otherwise TRUE if sent.
 #' @keywords internal
-ipc_send <- function(method, params = list(), request = FALSE) {
+rpc_send <- function(method, params = list(), request = FALSE) {
   if (is.null(.sess_env$ws)) {
     return(invisible(FALSE))
   }
@@ -68,7 +68,7 @@ ipc_send <- function(method, params = list(), request = FALSE) {
 #' @param params A list containing the arguments for the command
 #' @export
 notify_client <- function(method, params = list()) {
-  ipc_send(method, params, request = FALSE)
+  rpc_send(method, params, request = FALSE)
 }
 
 #' Emulate rstudioapi (or any client action) synchronously but without blocking the R Event Loop
@@ -77,5 +77,5 @@ notify_client <- function(method, params = list()) {
 #' @param args List of arguments
 #' @export
 request_client <- function(action, args = list()) {
-  ipc_send(action, args, request = TRUE)
+  rpc_send(action, args, request = TRUE)
 }
diff --git a/sess/R/hooks.R b/sess/R/hooks.R
index 3ff4f7fd..e322a1eb 100644
--- a/sess/R/hooks.R
+++ b/sess/R/hooks.R
@@ -146,30 +146,33 @@ register_hooks <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
   rebind("View", show_dataview, ns = "utils")
 
   # 2. Browser & Webview Options 
-  # TODO: unify the viewers and let client to choose how to show
-  show_browser <- function(url, title = url, ...) {
-    notify_client("browser", list(url = url, title = title, viewer = getOption("sess.browser", "Active")))
-  }
-
-  show_webview <- function(url, title = "WebView", ...) {
-    # If the URL is a local file, normalize its path for the webview
-    if (file.exists(url)) {
-      url <- normalizePath(url, "/", mustWork = TRUE)
+  viewer <- function(url, ...) {
+    if (!is.character(url)) {
+      real_url <- NULL
+      temp_viewer <- function(url, ...) {
+        real_url <<- url
+      }
+      op <- options(viewer = temp_viewer, page_viewer = temp_viewer)
+      on.exit(options(op))
+      print(url)
+      if (is.character(real_url)) {
+        url <- real_url
+      } else {
+        stop("Invalid object")
+      }
     }
-    notify_client("webview", list(file = url, title = title, viewer = getOption("sess.webview", "Two")))
-  }
 
-  show_page_viewer <- function(url, title = "Page Viewer", ...) {
+    url <- sub("^file\\://", "", url)
     if (file.exists(url)) {
       url <- normalizePath(url, "/", mustWork = TRUE)
     }
-    notify_client("webview", list(file = url, title = title, viewer = getOption("sess.page_viewer", "Active")))
+    notify_client("webview", list(url = url))
   }
 
   options(
-    browser = show_browser,
-    viewer = show_webview,
-    page_viewer = show_page_viewer,
+    browser = viewer,
+    viewer = viewer,
+    page_viewer = viewer,
     help_type = "html"
   )
 
diff --git a/src/session.ts b/src/session.ts
index 64c30bfa..967ec524 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -886,15 +886,29 @@ async function handleNotification(message: Record<string, unknown>, ws: ExtWebSo
             }
             break;
         }
-        case 'browser': {
-            if (params.url && params.title && params.viewer !== undefined) {
-                await showBrowser(String(params.url), String(params.title), params.viewer as string | boolean);
-            }
-            break;
-        }
         case 'webview': {
-            if (params.file && params.title && params.viewer !== undefined) {
-                await showWebView(String(params.file), String(params.title), params.viewer as string | boolean);
+            if (params.url) {
+                const url = String(params.url);
+
+                const viewColumnConfig = config().get<Record<string, string>>('session.viewers.viewColumn') ?? {};
+                const viewerChoice = viewColumnConfig['viewer'] ?? 'Active';
+                const viewColumn = viewerChoice === 'Disable' ? false : viewerChoice;
+
+                if (url.startsWith('http://') || url.startsWith('https://')) {
+                    const isLocalHost = url.match(/^https?:\/\/(127\.0\.0\.1|localhost)(:\d+)?/i);
+                    if (isLocalHost) {
+                        const externalUri = await env.asExternalUri(Uri.parse(url));
+                        await showBrowser(externalUri.toString(true), url, viewColumn);
+                    } else {
+                        await showBrowser(url, url, viewColumn);
+                    }
+                } else {
+                    if (url.toLowerCase().endsWith('.html') || url.toLowerCase().endsWith('.htm')) {
+                        await showWebView(url, 'Viewer', viewColumn);
+                    } else {
+                        await showDataView('object', 'txt', 'Data Viewer', url, String(viewColumn));
+                    }
+                }
             }
             break;
         }

From c2b55870ce066176b1f481e88a5354b5d101d3e6 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Fri, 13 Mar 2026 22:41:58 -0700
Subject: [PATCH 39/47] feat: implement robust static plot capturing and expose
 VS Code settings to R session

---
 R/profile.R                     |  7 ++-
 sess/R/hooks.R                  | 83 +++++++++++++++++++++++++++++----
 sess/R/server.R                 | 21 +++++++--
 sess/README.md                  | 22 +++++----
 src/rTerminal.ts                |  4 +-
 src/session.ts                  |  7 +--
 src/test/suite/terminal.test.ts |  8 ++++
 7 files changed, 125 insertions(+), 27 deletions(-)

diff --git a/R/profile.R b/R/profile.R
index a316445e..0a9b081f 100644
--- a/R/profile.R
+++ b/R/profile.R
@@ -25,5 +25,10 @@ local({
 })
 
 if (requireNamespace("sess", quietly = TRUE)) {
-    sess::sess_app()
+    sess::sess_app(
+        port = as.integer(Sys.getenv("SESS_PORT")),
+        token = Sys.getenv("SESS_TOKEN"),
+        use_rstudioapi = as.logical(Sys.getenv("SESS_RSTUDIOAPI", "TRUE")),
+        use_httpgd = as.logical(Sys.getenv("SESS_USE_HTTPGD", "TRUE"))
+    )
 }
diff --git a/sess/R/hooks.R b/sess/R/hooks.R
index e322a1eb..123855bc 100644
--- a/sess/R/hooks.R
+++ b/sess/R/hooks.R
@@ -145,7 +145,7 @@ register_hooks <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
   }
   rebind("View", show_dataview, ns = "utils")
 
-  # 2. Browser & Webview Options 
+  # 2. Browser & Webview Options
   viewer <- function(url, ...) {
     if (!is.character(url)) {
       real_url <- NULL
@@ -207,18 +207,83 @@ register_hooks <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
       notify_client("httpgd", list(url = httpgd::hgd_url()))
     })
   } else {
-    # Default to static plot capturing
+    # Default to static plot capturing (Re-implementation based on vsc.R)
+    plot_file <- .sess_env$latest_plot_path
+    file.create(plot_file, showWarnings = FALSE)
+
+    plot_updated <- FALSE
+    null_dev_size <- c(7 + pi, 7 + pi)
+
+    check_null_dev <- function() {
+      cur_dev <- dev.cur()
+      cur_name <- names(cur_dev)
+      cur_size <- tryCatch(dev.size(), error = function(e) c(0, 0))
+
+      # On macOS, png() often opens "quartz_off_screen"
+      is_null_dev_name <- cur_name %in% c("png", "quartz_off_screen", "pdf")
+      size_match <- abs(cur_size[1] - null_dev_size[1]) < 1e-5 &&
+        abs(cur_size[2] - null_dev_size[2]) < 1e-5
+
+      res <- is_null_dev_name && size_match
+      return(res)
+    }
+
+    new_plot <- function() {
+      if (check_null_dev()) {
+        plot_updated <<- TRUE
+      }
+    }
+
     options(device = function(...) {
-      png(.sess_env$latest_plot_path, width = 800, height = 600, res = 72)
+      png(tempfile(tmpdir = .sess_env$tempdir, fileext = ".png"),
+        width = null_dev_size[[1L]],
+        height = null_dev_size[[2L]],
+        units = "in",
+        res = 72,
+        bg = "white"
+      )
+      dev.control(displaylist = "enable")
     })
 
-    setHook("plot.new", function(...) {
-      notify_client("plot_updated")
-    }, "replace")
+    update_plot <- function(...) {
+      tryCatch(
+        {
+          if (plot_updated && check_null_dev()) {
+            plot_updated <<- FALSE
+            record <- recordPlot()
+            if (length(record[[1L]])) {
+              dev_args <- getOption("vsc.dev.args", list(width = 800, height = 600))
+              if (is.null(dev_args$res)) dev_args$res <- 72
+
+              do.call(png, c(list(filename = plot_file), dev_args))
+              on.exit({
+                dev.off()
+                notify_client("plot_updated")
+              })
+              replayPlot(record)
+            }
+          }
+        },
+        error = function(e) {
+          warning("Error in sess update_plot: ", e$message)
+        }
+      )
+      TRUE
+    }
+
+    setHook("plot.new", new_plot, "replace")
+    setHook("grid.newpage", new_plot, "replace")
+
+    rebind(".External.graphics", function(...) {
+      out <- .Primitive(".External.graphics")(...)
+      if (check_null_dev()) {
+        plot_updated <<- TRUE
+      }
+      out
+    }, "base")
 
-    setHook("grid.newpage", function(...) {
-      notify_client("plot_updated")
-    }, "replace")
+    update_plot()
+    addTaskCallback(update_plot, name = "sess.plot")
   }
 
   # 5. rstudioapi hooks
diff --git a/sess/R/server.R b/sess/R/server.R
index bb51db52..686496b8 100644
--- a/sess/R/server.R
+++ b/sess/R/server.R
@@ -1,15 +1,22 @@
 #' Start the client R IPC Server
 #'
+#' @param port Integer. The port to use for the server. If NULL, it will use SESS_PORT env var or a random port.
+#' @param token String. The token to use for authentication. If NULL, it will use SESS_TOKEN env var or a random token.
 #' @param use_rstudioapi Logical. Should the rstudioapi emulation layer be enabled? Defaults to TRUE.
 #' @param use_httpgd Logical. Should httpgd be used for plotting if available? Defaults to TRUE
 #' @export
-sess_app <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
+sess_app <- function(port = NULL, token = NULL, use_rstudioapi = TRUE, use_httpgd = TRUE) {
   # Initialize state
   .sess_env$server <- NULL
   .sess_env$ws <- NULL
 
-  env_token <- Sys.getenv("SESS_TOKEN")
-  .sess_env$token <- if (nzchar(env_token)) env_token else paste0(sample(c(letters, 0:9), 32, replace = TRUE), collapse = "")
+  # Use token if provided, otherwise fallback to SESS_TOKEN env var, or random token
+  if (is.null(token) || is.na(token) || !nzchar(token)) {
+    env_token <- Sys.getenv("SESS_TOKEN")
+    .sess_env$token <- if (nzchar(env_token)) env_token else paste0(sample(c(letters, 0:9), 32, replace = TRUE), collapse = "")
+  } else {
+    .sess_env$token <- token
+  }
   .sess_env$pending_responses <- list()
 
   # Specific tempdir for vscode-R
@@ -125,14 +132,18 @@ sess_app <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
   )
 
   # Start the httpuv server on a specific or random port
-  env_port <- Sys.getenv("SESS_PORT")
-  port <- if (nzchar(env_port)) as.integer(env_port) else httpuv::randomPort()
+  if (is.null(port) || is.na(port)) {
+    env_port <- Sys.getenv("SESS_PORT")
+    port <- if (nzchar(env_port)) as.integer(env_port) else httpuv::randomPort()
+  }
   .sess_env$server <- httpuv::startServer("127.0.0.1", port, app = app_handlers)
 
   # Print the connection string to the console.
   cat(sprintf("\n[sess] Server address: ws://127.0.0.1:%d?token=%s\n\n", port, .sess_env$token))
 
   # Register runtime hooks
+  if (is.na(use_rstudioapi)) use_rstudioapi <- TRUE
+  if (is.na(use_httpgd)) use_httpgd <- TRUE
   register_hooks(use_rstudioapi = use_rstudioapi, use_httpgd = use_httpgd)
 
   invisible(NULL)
diff --git a/sess/README.md b/sess/README.md
index fb8402e6..658fab78 100644
--- a/sess/README.md
+++ b/sess/README.md
@@ -4,18 +4,24 @@ The `sess` package provides a high-performance, token-authenticated IPC (Inter-P
 
 ## 1. Connection Handshake
 
-When `sess::sess_app()` is started, it prints a connection string to the R console:
+### Starting the Server
 
-```text
-[sess] SESS_IPC_SERVER=ws://127.0.0.1:PORT?token=TOKEN
-```
+The server can be started by calling `sess::sess_app()`:
 
-A client can intercept this string or be configured with the port and token to establish a connection.
+```r
+sess::sess_app(
+  port = NULL,           # Integer: Server port (random if NULL)
+  token = NULL,          # String: Authentication token (random if NULL)
+  use_rstudioapi = TRUE, # Logical: Enable RStudio API emulation
+  use_httpgd = TRUE      # Logical: Use httpgd for plotting if available
+)
+```
 
-- **Port**: Randomly assigned by `httpuv::randomPort()`.
-- **Token**: A random 32-character alphanumeric string generated per session.
+It prints a connection string to the R console:
 
-Authentication is performed immediately upon WebSocket connection by verifying the `token` in the query string.
+```text
+[sess] Server address: ws://127.0.0.1:PORT?token=TOKEN
+```
 
 ## 2. Communication Channels
 
diff --git a/src/rTerminal.ts b/src/rTerminal.ts
index a3d87f34..7100a628 100644
--- a/src/rTerminal.ts
+++ b/src/rTerminal.ts
@@ -147,7 +147,9 @@ export async function makeTerminalOptions(): Promise<vscode.TerminalOptions> {
             R_PROFILE_USER_OLD: process.env.R_PROFILE_USER,
             R_PROFILE_USER: newRprofile,
             SESS_PORT: port.toString(),
-            SESS_TOKEN: token
+            SESS_TOKEN: token,
+            SESS_RSTUDIOAPI: config().get<boolean>('session.emulateRStudioAPI') ? 'TRUE' : 'FALSE',
+            SESS_USE_HTTPGD: config().get<boolean>('plot.useHttpgd') ? 'TRUE' : 'FALSE'
         };
     }
     return termOptions;
diff --git a/src/session.ts b/src/session.ts
index 967ec524..3fa99a2d 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -170,7 +170,8 @@ export function startSessionWatcher(port: number, token: string, terminalPid?: n
                     } else {
                         // Request from server
                         await handleRequest(message, ws);
-                    }                } catch (e) {
+                    }
+                } catch (e) {
                     console.error('[startSessionWatcher] Error handling message', e);
                 }
             })();
@@ -319,7 +320,7 @@ function writeSettings() {
 async function updatePlot() {
     if (!server) {return;}
     try {
-        const response = await sessionRequest(server, { jsonrpc: '2.0', id: 1, method: 'plot_latest' });
+        const response = await sessionRequest(server, { method: 'plot_latest' });
         if (response && (response as Record<string, unknown>).data) {
             const plotFile = path.join(sessionDir, 'plot.png');
             fs.writeFileSync(plotFile, Buffer.from((response as Record<string, unknown>).data as string, 'base64'));
@@ -341,7 +342,7 @@ async function updatePlot() {
 export async function updateWorkspace() {
     if (!server) {return;}
     try {
-        const response = await sessionRequest(server, { jsonrpc: '2.0', id: 1, method: 'workspace' });
+        const response = await sessionRequest(server, { method: 'workspace' });
         if (response) {
             workspaceData = response as WorkspaceData;
             if (activeSession) {
diff --git a/src/test/suite/terminal.test.ts b/src/test/suite/terminal.test.ts
index b4b3d72c..547b66bf 100644
--- a/src/test/suite/terminal.test.ts
+++ b/src/test/suite/terminal.test.ts
@@ -29,6 +29,12 @@ suite('R Terminal', () => {
                 if (key === 'sessionWatcher') {
                     return true;
                 }
+                if (key === 'session.emulateRStudioAPI') {
+                    return true;
+                }
+                if (key === 'plot.useHttpgd') {
+                    return true;
+                }
                 if (key === 'rterm.option') {
                     return ['--no-save'];
                 }
@@ -44,6 +50,8 @@ suite('R Terminal', () => {
         assert.ok(options.env);
         assert.ok(options.env['SESS_PORT']);
         assert.ok(options.env['SESS_TOKEN']);
+        assert.strictEqual(options.env['SESS_RSTUDIOAPI'], 'TRUE');
+        assert.strictEqual(options.env['SESS_USE_HTTPGD'], 'TRUE');
         assert.ok(options.env['R_PROFILE_USER']);
         assert.ok(options.env['R_PROFILE_USER'].endsWith('R/profile.R'));
     });

From d5217eba9bbba2e3fc1cc758e2adb608b0839b6d Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Sat, 14 Mar 2026 10:45:44 -0700
Subject: [PATCH 40/47] feat: implement responsive and configurable plot viewer
 with svglite support

---
 package.json                     |   9 ++
 sess/DESCRIPTION                 |   3 +-
 sess/R/handlers.R                |  41 ++++++++-
 sess/R/hooks.R                   |  11 +--
 sess/R/server.R                  |   2 +-
 src/plotViewer/standardViewer.ts | 153 +++++++++++++++++++++++++++++++
 src/session.ts                   |  22 +----
 7 files changed, 208 insertions(+), 33 deletions(-)
 create mode 100644 src/plotViewer/standardViewer.ts

diff --git a/package.json b/package.json
index 8df155a2..affa071f 100644
--- a/package.json
+++ b/package.json
@@ -1870,6 +1870,15 @@
           "default": false,
           "markdownDescription": "Use the httpgd-based plot viewer instead of the base VSCode-R plot viewer. Changes the option `vsc.use_httpgd` in R.\n\nRequires the `httpgd` R package version 1.2.0 or later."
         },
+        "r.plot.format": {
+          "type": "string",
+          "default": "svglite",
+          "enum": [
+            "png",
+            "svglite"
+          ],
+          "description": "The format to use for the standard plot viewer. Requires `#r.plot.useHttpgd#` to be set to `false`."
+        },
         "r.plot.defaults.colorTheme": {
           "type": "string",
           "default": "original",
diff --git a/sess/DESCRIPTION b/sess/DESCRIPTION
index d69f4443..c62fd127 100644
--- a/sess/DESCRIPTION
+++ b/sess/DESCRIPTION
@@ -13,5 +13,6 @@ Imports:
     jsonlite,
     utils,
     methods,
-    rstudioapi
+    rstudioapi,
+    svglite
 RoxygenNote: 7.2.3
diff --git a/sess/R/handlers.R b/sess/R/handlers.R
index 1243a7dd..6cdd4ee9 100644
--- a/sess/R/handlers.R
+++ b/sess/R/handlers.R
@@ -78,10 +78,43 @@ handle_complete <- function(expr_str, trigger = NULL) {
   NULL
 }
 
-handle_plot_latest <- function() {
-  if (file.exists(.sess_env$latest_plot_path)) {
-    raw_img <- readBin(.sess_env$latest_plot_path, "raw", file.info(.sess_env$latest_plot_path)$size)
-    list(data = as.character(jsonlite::base64_enc(raw_img)))
+handle_plot_latest <- function(params) {
+  record <- .sess_env$latest_plot_record
+  if (is.null(record)) {
+    return(list(data = NULL))
+  }
+
+  width <- if (is.null(params$width)) 800 else as.numeric(params$width)
+  height <- if (is.null(params$height)) 600 else as.numeric(params$height)
+  format <- if (is.null(params$format)) "svglite" else as.character(params$format)
+
+  plot_file <- tempfile(tmpdir = .sess_env$tempdir, fileext = paste0(".", format))
+
+  if (format == "svglite") {
+    if (requireNamespace("svglite", quietly = TRUE)) {
+      svglite::svglite(plot_file, width = width / 72, height = height / 72)
+    } else {
+      # Fallback to png
+      png(plot_file, width = width, height = height, res = 72)
+    }
+  } else {
+    png(plot_file, width = width, height = height, res = 72)
+  }
+
+  on.exit({
+    if (dev.cur() > 1) dev.off()
+    if (file.exists(plot_file)) unlink(plot_file)
+  })
+
+  replayPlot(record)
+  dev.off()
+
+  if (file.exists(plot_file)) {
+    raw_img <- readBin(plot_file, "raw", file.info(plot_file)$size)
+    list(
+      data = as.character(jsonlite::base64_enc(raw_img)),
+      format = if (format == "svglite" && !requireNamespace("svglite", quietly = TRUE)) "png" else format
+    )
   } else {
     list(data = NULL)
   }
diff --git a/sess/R/hooks.R b/sess/R/hooks.R
index 123855bc..9e12d629 100644
--- a/sess/R/hooks.R
+++ b/sess/R/hooks.R
@@ -252,15 +252,8 @@ register_hooks <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
             plot_updated <<- FALSE
             record <- recordPlot()
             if (length(record[[1L]])) {
-              dev_args <- getOption("vsc.dev.args", list(width = 800, height = 600))
-              if (is.null(dev_args$res)) dev_args$res <- 72
-
-              do.call(png, c(list(filename = plot_file), dev_args))
-              on.exit({
-                dev.off()
-                notify_client("plot_updated")
-              })
-              replayPlot(record)
+              .sess_env$latest_plot_record <- record
+              notify_client("plot_updated")
             }
           }
         },
diff --git a/sess/R/server.R b/sess/R/server.R
index 686496b8..44695ce4 100644
--- a/sess/R/server.R
+++ b/sess/R/server.R
@@ -85,7 +85,7 @@ sess_app <- function(port = NULL, token = NULL, use_rstudioapi = TRUE, use_httpg
               "workspace" = function(p) get_workspace_data(),
               "hover" = function(p) handle_hover(p$expr),
               "completion" = function(p) handle_complete(p$expr, p$trigger),
-              "plot_latest" = function(p) handle_plot_latest()
+              "plot_latest" = function(p) handle_plot_latest(p)
             )
 
             if (payload$method %in% names(handlers)) {
diff --git a/src/plotViewer/standardViewer.ts b/src/plotViewer/standardViewer.ts
new file mode 100644
index 00000000..b01b1e8e
--- /dev/null
+++ b/src/plotViewer/standardViewer.ts
@@ -0,0 +1,153 @@
+
+import * as vscode from 'vscode';
+import { asViewColumn, config, UriIcon } from '../util';
+import { sessionRequest, server } from '../session';
+
+export class StandardPlotViewer {
+    private panel: vscode.WebviewPanel | undefined;
+    private viewWidth: number = 800;
+    private viewHeight: number = 600;
+    private plotData: string | undefined;
+    private plotFormat: string | undefined;
+
+    public async update(): Promise<void> {
+        const viewColumn = asViewColumn(config().get<string>('session.viewers.viewColumn.plot'), vscode.ViewColumn.Two);
+        if (!this.panel) {
+            this.createPanel(viewColumn);
+        } else {
+            this.panel.reveal(viewColumn, true);
+            await this.requestPlot();
+        }
+    }
+
+    private createPanel(viewColumn: vscode.ViewColumn) {
+        this.panel = vscode.window.createWebviewPanel(
+            'r.standardPlot',
+            'R Plot',
+            {
+                viewColumn,
+                preserveFocus: true
+            },
+            {
+                enableScripts: true,
+                retainContextWhenHidden: true
+            }
+        );
+
+        this.panel.iconPath = new UriIcon('graph');
+        this.panel.webview.html = this.getHtml();
+
+        this.panel.webview.onDidReceiveMessage(async (msg: { type: string, width?: number, height?: number }) => {
+            if (msg.type === 'resize') {
+                this.viewWidth = msg.width || this.viewWidth;
+                this.viewHeight = msg.height || this.viewHeight;
+                await this.requestPlot();
+            }
+        });
+
+        this.panel.onDidDispose(() => {
+            this.panel = undefined;
+        });
+    }
+
+    private async requestPlot() {
+        if (!server || !this.panel) {
+            return;
+        }
+
+        const format = config().get<string>('plot.format', 'png');
+        const response = await sessionRequest(server, {
+            method: 'plot_latest',
+            params: {
+                width: this.viewWidth,
+                height: this.viewHeight,
+                format: format
+            }
+        });
+
+        if (response && (response as any).data) {
+            this.plotData = (response as any).data;
+            this.plotFormat = (response as any).format || format;
+            void this.panel.webview.postMessage({
+                type: 'update',
+                data: this.plotData,
+                format: this.plotFormat
+            });
+        }
+    }
+
+    private getHtml() {
+        return `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <style>
+        body, html {
+            margin: 0;
+            padding: 0;
+            width: 100%;
+            height: 100%;
+            overflow: hidden;
+            background-color: transparent;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+        }
+        img {
+            max-width: 100%;
+            max-height: 100%;
+            object-fit: contain;
+        }
+        svg {
+            width: 100%;
+            height: 100%;
+        }
+    </style>
+</head>
+<body>
+    <div id="plot-container"></div>
+    <script>
+        const vscode = acquireVsCodeApi();
+        const container = document.getElementById('plot-container');
+        
+        let resizeTimeout;
+        const observer = new ResizeObserver(entries => {
+            for (let entry of entries) {
+                const { width, height } = entry.contentRect;
+                if (width > 0 && height > 0) {
+                    clearTimeout(resizeTimeout);
+                    resizeTimeout = setTimeout(() => {
+                        vscode.postMessage({
+                            type: 'resize',
+                            width: Math.floor(width),
+                            height: Math.floor(height)
+                        });
+                    }, 200);
+                }
+            }
+        });
+        observer.observe(document.body);
+
+        window.addEventListener('message', event => {
+            const message = event.data;
+            if (message.type === 'update') {
+                if (message.format === 'svglite' || message.format === 'svg') {
+                    const binaryString = atob(message.data);
+                    const bytes = new Uint8Array(binaryString.length);
+                    for (let i = 0; i < binaryString.length; i++) {
+                        bytes[i] = binaryString.charCodeAt(i);
+                    }
+                    container.innerHTML = new TextDecoder().decode(bytes);
+                } else {
+                    container.innerHTML = '<img src="data:image/' + message.format + ';base64,' + message.data + '" />';
+                }
+            }
+        });
+    </script>
+</body>
+</html>
+        `;
+    }
+}
diff --git a/src/session.ts b/src/session.ts
index 3fa99a2d..b3fe88d9 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -13,6 +13,9 @@ import { homeExtDir, rWorkspace, globalRHelp, globalHttpgdManager, extensionCont
 import { rHostService, rGuestService, isLiveShare, isHost, isGuestSession, guestResDir, shareBrowser, openVirtualDoc } from './liveShare';
 
 import WebSocket from 'ws';
+import { StandardPlotViewer } from './plotViewer/standardViewer';
+
+const standardPlotViewer = new StandardPlotViewer();
 
 export interface SessionInfo {
     version: string;
@@ -319,24 +322,7 @@ function writeSettings() {
 
 async function updatePlot() {
     if (!server) {return;}
-    try {
-        const response = await sessionRequest(server, { method: 'plot_latest' });
-        if (response && (response as Record<string, unknown>).data) {
-            const plotFile = path.join(sessionDir, 'plot.png');
-            fs.writeFileSync(plotFile, Buffer.from((response as Record<string, unknown>).data as string, 'base64'));
-            void commands.executeCommand('vscode.open', Uri.file(plotFile), {
-                preserveFocus: true,
-                preview: true,
-                viewColumn: ViewColumn[(config().get<string>('session.viewers.viewColumn.plot') || 'Two') as keyof typeof ViewColumn],
-            });
-            console.info('[updatePlot] Done');
-            if (isLiveShare()) {
-                void rHostService?.notifyPlot(plotFile);
-            }
-        }
-    } catch (e) {
-        console.error(e);
-    }
+    await standardPlotViewer.update();
 }
 
 export async function updateWorkspace() {

From 11af1ea076d3f5f33b5b708a3e5097cd237fd6d9 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Sat, 14 Mar 2026 12:12:12 -0700
Subject: [PATCH 41/47] refactor: reorganize webview source files and unify
 build process

---
 esbuild.js                                    | 51 ++++++++++++--
 html/help/tsconfig.json                       | 17 -----
 html/help/webviewMessages.d.ts                | 42 ------------
 html/httpgd/tsconfig.json                     | 17 -----
 html/httpgd/webviewMessages.d.ts              | 66 -------------------
 html/session/webview/observer.js              | 41 ------------
 package.json                                  |  6 +-
 src/helpViewer/index.ts                       |  6 +-
 .../helpViewer/webview}/00Index.ejs           |  0
 .../helpViewer/webview/index.ts               |  2 +-
 .../help => src/helpViewer/webview}/theme.css |  0
 ...ebviewMessages.d.ts => webviewMessages.ts} | 14 ++--
 src/plotViewer/index.ts                       |  2 +-
 .../plotViewer/webview}/index.ejs             |  0
 .../plotViewer/webview}/index.ts              |  3 +-
 .../plotViewer/webview}/smallPlot.ejs         |  0
 .../plotViewer/webview}/style.css             |  0
 .../plotViewer/webview}/styleOverwrites.css   |  0
 .../plotViewer/webview}/vars.css              |  0
 ...ebviewMessages.d.ts => webviewMessages.ts} | 17 ++---
 20 files changed, 66 insertions(+), 218 deletions(-)
 delete mode 100644 html/help/tsconfig.json
 delete mode 100644 html/help/webviewMessages.d.ts
 delete mode 100644 html/httpgd/tsconfig.json
 delete mode 100644 html/httpgd/webviewMessages.d.ts
 delete mode 100644 html/session/webview/observer.js
 rename {html/help => src/helpViewer/webview}/00Index.ejs (100%)
 rename html/help/script.ts => src/helpViewer/webview/index.ts (98%)
 rename {html/help => src/helpViewer/webview}/theme.css (100%)
 rename src/helpViewer/{webviewMessages.d.ts => webviewMessages.ts} (86%)
 rename {html/httpgd => src/plotViewer/webview}/index.ejs (100%)
 rename {html/httpgd => src/plotViewer/webview}/index.ts (99%)
 rename {html/httpgd => src/plotViewer/webview}/smallPlot.ejs (100%)
 rename {html/httpgd => src/plotViewer/webview}/style.css (100%)
 rename {html/httpgd => src/plotViewer/webview}/styleOverwrites.css (100%)
 rename {html/httpgd => src/plotViewer/webview}/vars.css (100%)
 rename src/plotViewer/{webviewMessages.d.ts => webviewMessages.ts} (87%)

diff --git a/esbuild.js b/esbuild.js
index c16bf4dd..0b073080 100644
--- a/esbuild.js
+++ b/esbuild.js
@@ -31,10 +31,33 @@ function copyResources() {
     console.log('Resources copied.');
 }
 
+function copyWebviewAssets() {
+    const views = [
+        { name: 'help', src: 'src/helpViewer/webview' },
+        { name: 'httpgd', src: 'src/plotViewer/webview' }
+    ];
+
+    for (const view of views) {
+        const srcDir = path.join(__dirname, view.src);
+        const destDir = path.join(__dirname, 'dist', 'webviews', view.name);
+        fs.mkdirSync(destDir, { recursive: true });
+
+        const files = fs.readdirSync(srcDir);
+        for (const file of files) {
+            if (!file.endsWith('.ts')) {
+                fs.copyFileSync(path.join(srcDir, file), path.join(destDir, file));
+            }
+        }
+    }
+    console.log('Webview assets copied.');
+}
+
 async function main() {
     copyResources();
+    copyWebviewAssets();
 
-    const ctx = await esbuild.context({
+    // Extension context (Node)
+    const extensionCtx = await esbuild.context({
         entryPoints: ['./src/extension.ts'],
         bundle: true,
         format: 'cjs',
@@ -47,12 +70,32 @@ async function main() {
         logLevel: 'info',
     });
 
+    // Webview context (Browser)
+    const webviewCtx = await esbuild.context({
+        entryPoints: {
+            'help/index': './src/helpViewer/webview/index.ts',
+            'httpgd/index': './src/plotViewer/webview/index.ts'
+        },
+        bundle: true,
+        minify: production,
+        sourcemap: !production,
+        format: 'iife',
+        platform: 'browser',
+        outdir: 'dist/webviews',
+        logLevel: 'info',
+    });
+
     if (watch) {
-        await ctx.watch();
+        await Promise.all([
+            extensionCtx.watch(),
+            webviewCtx.watch()
+        ]);
         console.log('Watching for changes...');
     } else {
-        await ctx.rebuild();
-        await ctx.dispose();
+        await extensionCtx.rebuild();
+        await webviewCtx.rebuild();
+        await extensionCtx.dispose();
+        await webviewCtx.dispose();
     }
 }
 
diff --git a/html/help/tsconfig.json b/html/help/tsconfig.json
deleted file mode 100644
index a3421d71..00000000
--- a/html/help/tsconfig.json
+++ /dev/null
@@ -1,17 +0,0 @@
-
-{
-    "compilerOptions": {
-        "module": "commonjs",
-        "target": "es2018",
-        "lib": [
-            "es2018",
-            "DOM"
-        ],
-        "sourceMap": false,
-        "rootDir": ".",
-        "strict": true,
-        "noImplicitAny": true,
-        "noImplicitThis": true,
-        "noFallthroughCasesInSwitch": true
-    }
-}
diff --git a/html/help/webviewMessages.d.ts b/html/help/webviewMessages.d.ts
deleted file mode 100644
index 19e5ceaa..00000000
--- a/html/help/webviewMessages.d.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-interface VsCode {
-    postMessage: (msg: OutMessage) => void;
-    setState: (state: string) => void;
-}
-
-
-interface IOutMessage {
-    message: string;
-}
-interface LogMessage extends IOutMessage {
-    message: 'log',
-    body: any
-}
-interface MouseClickMessage extends IOutMessage {
-    message: 'mouseClick',
-    button: number,
-    scrollY: number
-}
-interface LinkClickedMessage extends IOutMessage {
-    message: 'linkClicked',
-    href: string,
-    scrollY: number
-}
-interface CodeClickedMessage extends IOutMessage {
-    message: 'codeClicked',
-    code: string,
-    modifiers: {
-        altKey: boolean,
-        ctrlKey: boolean,
-        shiftKey: boolean,
-        metaKey: boolean,
-    }
-}
-interface GetScrollYMessage extends IOutMessage {
-    message: 'getScrollY',
-    scrollY: number
-}
-
-type OutMessage = LogMessage | MouseClickMessage | LinkClickedMessage | CodeClickedMessage | GetScrollYMessage;
-
diff --git a/html/httpgd/tsconfig.json b/html/httpgd/tsconfig.json
deleted file mode 100644
index a3421d71..00000000
--- a/html/httpgd/tsconfig.json
+++ /dev/null
@@ -1,17 +0,0 @@
-
-{
-    "compilerOptions": {
-        "module": "commonjs",
-        "target": "es2018",
-        "lib": [
-            "es2018",
-            "DOM"
-        ],
-        "sourceMap": false,
-        "rootDir": ".",
-        "strict": true,
-        "noImplicitAny": true,
-        "noImplicitThis": true,
-        "noFallthroughCasesInSwitch": true
-    }
-}
diff --git a/html/httpgd/webviewMessages.d.ts b/html/httpgd/webviewMessages.d.ts
deleted file mode 100644
index 728f482a..00000000
--- a/html/httpgd/webviewMessages.d.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-interface VsCode {
-    postMessage: (msg: OutMessage) => void;
-    setState: (state: string) => void;
-}
-
-
-interface IMessage {
-    message: string;
-}
-interface ResizeMessage extends IMessage {
-    message: 'resize',
-    height: number,
-    width: number,
-    userTriggered: boolean
-}
-interface LogMessage extends IMessage {
-    message: 'log',
-    body: any
-}
-
-type OutMessage = ResizeMessage | LogMessage;
-
-
-
-
-interface UpdatePlotMessage extends IMessage {
-    message: 'updatePlot',
-    svg: string,
-    plotId: string
-}
-
-interface FocusPlotMessage extends IMessage {
-    message: 'focusPlot',
-    plotId: string
-}
-
-interface ToggleStyleMessage extends IMessage {
-    message: 'toggleStyle',
-    useOverwrites: boolean
-}
-
-interface ToggleFullWindowMessage extends IMessage {
-    message: 'toggleFullWindow',
-    useFullWindow: boolean
-}
-
-type PreviewPlotLayout = 'multirow' | 'scroll' | 'hidden';
-interface PreviewPlotLayoutMessage extends IMessage {
-    message: 'togglePreviewPlotLayout',
-    style: PreviewPlotLayout
-}
-
-interface HidePlotMessage extends IMessage {
-    message: 'hidePlot',
-    plotId: string
-}
-
-interface AddPlotMessage extends IMessage {
-    message: 'addPlot',
-    html: string
-}
-
-type InMessage = UpdatePlotMessage | FocusPlotMessage | ToggleStyleMessage | HidePlotMessage | AddPlotMessage | PreviewPlotLayoutMessage | ToggleFullWindowMessage;
-
diff --git a/html/session/webview/observer.js b/html/session/webview/observer.js
deleted file mode 100644
index 1f48a835..00000000
--- a/html/session/webview/observer.js
+++ /dev/null
@@ -1,41 +0,0 @@
-const MutationObserver = window.MutationObserver || window.WebKitMutationObserver;
-const replaceReg = /vscode-webview:\/\//;
-const testReg = /vscode-webview:\/\/.*\.[A-Za-z/0-9_-]*?\/.+/;
-const watchedTags = [
-  "IMG",
-  "A",
-  "LINK",
-  "SCRIPT"
-];
-const mutationQueue = [];
-
-const observer = new MutationObserver(mutations => {
-  if (!mutationQueue.length) {
-    requestAnimationFrame(setSrc);
-  }
-  mutationQueue.push(mutations);
-});
-
-observer.observe(document.getElementById("webview-content"), {
-  subtree: true,
-  attributes: true,
-  attributeFilter: ["src", "href", "style", "class"],
-  characterData: false
-});
-
-function setSrc() {
-  for (const mutations of mutationQueue) {
-    const targ = mutations[0].target;
-    if (watchedTags.includes(targ.tagName) && testReg.test(targ.src)) {
-      const newSrc = targ.src.replace(replaceReg, 'https://');
-      console.log(
-        `%c[VSC-R] %cThe file request '${targ.src}' was converted to the URL '${newSrc}'. Reason: the request appears to refer to a URL, not a local file as suggested by the file scheme. %cIf you believe this to be in error, please log an issue on GitHub.`,
-        "color: orange",
-        "color: inherit",
-        "font-style: italic"
-      );
-      targ.src = newSrc;
-    }
-  }
-  mutationQueue.length = 0;
-}
diff --git a/package.json b/package.json
index affa071f..68043d9e 100644
--- a/package.json
+++ b/package.json
@@ -2005,12 +2005,10 @@
     ]
   },
   "scripts": {
-    "vscode:prepublish": "tsc -p ./html/help && tsc -p ./html/httpgd && node esbuild.js --production",
+    "vscode:prepublish": "node esbuild.js --production",
     "changelog": "npx git-cliff v2.8.5.. -o",
-    "build": "tsc -p ./html/help && tsc -p ./html/httpgd && node esbuild.js && Rscript -e 'devtools::install(\"sess\")'",
+    "build": "node esbuild.js && Rscript -e 'devtools::install(\"sess\")'",
     "watch": "node esbuild.js --watch",
-    "watchHelp": "tsc -p ./html/help --watch",
-    "watchHttpgd": "tsc -p ./html/httpgd --watch",
     "pretest": "tsc -p ./",
     "test": "vscode-test",
     "lint": "eslint src --ext ts"
diff --git a/src/helpViewer/index.ts b/src/helpViewer/index.ts
index 3b0f6277..3d3df18f 100644
--- a/src/helpViewer/index.ts
+++ b/src/helpViewer/index.ts
@@ -70,10 +70,10 @@ export async function initializeHelp(
 
     // Gather options used in r help related files
     const rHelpOptions: HelpOptions = {
-        webviewScriptPath: context.asAbsolutePath('./html/help/script.js'),
-        webviewStylePath: context.asAbsolutePath('./html/help/theme.css'),
+        webviewScriptPath: context.asAbsolutePath('./dist/webviews/help/index.js'),
+        webviewStylePath: context.asAbsolutePath('./dist/webviews/help/theme.css'),
         rScriptFile: context.asAbsolutePath('./R/help/getAliases.R'),
-        indexTemplatePath: context.asAbsolutePath('./html/help/00Index.ejs'),
+        indexTemplatePath: context.asAbsolutePath('./dist/webviews/help/00Index.ejs'),
         rdToHtmlScriptFile: context.asAbsolutePath('./R/help/rdToHtml.R'),
         rPath: rPath,
         cwd: cwd,
diff --git a/html/help/00Index.ejs b/src/helpViewer/webview/00Index.ejs
similarity index 100%
rename from html/help/00Index.ejs
rename to src/helpViewer/webview/00Index.ejs
diff --git a/html/help/script.ts b/src/helpViewer/webview/index.ts
similarity index 98%
rename from html/help/script.ts
rename to src/helpViewer/webview/index.ts
index 8499bc45..2060c7e8 100644
--- a/html/help/script.ts
+++ b/src/helpViewer/webview/index.ts
@@ -1,4 +1,4 @@
-declare function acquireVsCodeApi(): VsCode;
+import { acquireVsCodeApi } from '../webviewMessages';
 
 const vscode = acquireVsCodeApi();
 
diff --git a/html/help/theme.css b/src/helpViewer/webview/theme.css
similarity index 100%
rename from html/help/theme.css
rename to src/helpViewer/webview/theme.css
diff --git a/src/helpViewer/webviewMessages.d.ts b/src/helpViewer/webviewMessages.ts
similarity index 86%
rename from src/helpViewer/webviewMessages.d.ts
rename to src/helpViewer/webviewMessages.ts
index 13a230fe..4a28c44d 100644
--- a/src/helpViewer/webviewMessages.d.ts
+++ b/src/helpViewer/webviewMessages.ts
@@ -1,15 +1,13 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-// Make sure these files contain the same interfaces as ./html/XXX/webviewMessages.d.ts!
-
-
-interface VsCode {
+export interface VsCode {
     postMessage: (msg: OutMessage) => void;
     setState: (state: string) => void;
 }
-declare function acquireVsCodeApi(): VsCode;
-
-
+/**
+ * Function declared by VS Code in Webview
+ */
+export const acquireVsCodeApi: any = (globalThis as any).acquireVsCodeApi;
 
 export interface IMessage {
     message: string;
@@ -45,5 +43,3 @@ export interface GetScrollYMessage extends IMessage {
 }
 
 export type OutMessage = LogMessage | MouseClickMessage | LinkClickedMessage | CodeClickedMessage | GetScrollYMessage;
-
-
diff --git a/src/plotViewer/index.ts b/src/plotViewer/index.ts
index 20f81d63..7a0d4305 100644
--- a/src/plotViewer/index.ts
+++ b/src/plotViewer/index.ts
@@ -61,7 +61,7 @@ export class HttpgdManager {
     recentlyActiveViewers: HttpgdViewer[] = [];
 
     constructor() {
-        const htmlRoot = extensionContext.asAbsolutePath('html/httpgd');
+        const htmlRoot = extensionContext.asAbsolutePath('dist/webviews/httpgd');
         this.viewerOptions = {
             parent: this,
             htmlRoot: htmlRoot,
diff --git a/html/httpgd/index.ejs b/src/plotViewer/webview/index.ejs
similarity index 100%
rename from html/httpgd/index.ejs
rename to src/plotViewer/webview/index.ejs
diff --git a/html/httpgd/index.ts b/src/plotViewer/webview/index.ts
similarity index 99%
rename from html/httpgd/index.ts
rename to src/plotViewer/webview/index.ts
index 40150573..8c2f960d 100644
--- a/html/httpgd/index.ts
+++ b/src/plotViewer/webview/index.ts
@@ -16,8 +16,7 @@ interface Plot {
     width?: number;
 }
 
-// get vscode api
-declare function acquireVsCodeApi(): VsCode;
+import { acquireVsCodeApi } from '../webviewMessages';
 const vscode = acquireVsCodeApi();
 
 // globals
diff --git a/html/httpgd/smallPlot.ejs b/src/plotViewer/webview/smallPlot.ejs
similarity index 100%
rename from html/httpgd/smallPlot.ejs
rename to src/plotViewer/webview/smallPlot.ejs
diff --git a/html/httpgd/style.css b/src/plotViewer/webview/style.css
similarity index 100%
rename from html/httpgd/style.css
rename to src/plotViewer/webview/style.css
diff --git a/html/httpgd/styleOverwrites.css b/src/plotViewer/webview/styleOverwrites.css
similarity index 100%
rename from html/httpgd/styleOverwrites.css
rename to src/plotViewer/webview/styleOverwrites.css
diff --git a/html/httpgd/vars.css b/src/plotViewer/webview/vars.css
similarity index 100%
rename from html/httpgd/vars.css
rename to src/plotViewer/webview/vars.css
diff --git a/src/plotViewer/webviewMessages.d.ts b/src/plotViewer/webviewMessages.ts
similarity index 87%
rename from src/plotViewer/webviewMessages.d.ts
rename to src/plotViewer/webviewMessages.ts
index f503b1b8..fe4573d1 100644
--- a/src/plotViewer/webviewMessages.d.ts
+++ b/src/plotViewer/webviewMessages.ts
@@ -1,15 +1,13 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-// Make sure these files contain the same interfaces as ./html/XXX/webviewMessages.d.ts!
-
-
-interface VsCode {
+export interface VsCode {
     postMessage: (msg: OutMessage) => void;
     setState: (state: string) => void;
 }
-declare function acquireVsCodeApi(): VsCode;
-
-
+/**
+ * Function declared by VS Code in Webview
+ */
+export const acquireVsCodeApi: any = (globalThis as any).acquireVsCodeApi;
 
 export interface IMessage {
     message: string;
@@ -28,8 +26,6 @@ export interface LogMessage extends IMessage {
 
 export type OutMessage = ResizeMessage | LogMessage;
 
-
-
 export interface UpdatePlotMessage extends IMessage {
     message: 'updatePlot',
     svg: string,
@@ -51,7 +47,6 @@ export interface ToggleFullWindowMessage extends IMessage {
     useFullWindow: boolean
 }
 
-
 export type PreviewPlotLayout = 'multirow' | 'scroll' | 'hidden';
 export interface PreviewPlotLayoutMessage extends IMessage {
     message: 'togglePreviewPlotLayout',
@@ -68,4 +63,4 @@ export interface AddPlotMessage extends IMessage {
     html: string
 }
 
-export type InMessage = UpdatePlotMessage | FocusPlotMessage | ToggleStyleMessage | HidePlotMessage | AddPlotMessage | PreviewPlotLayoutMessage | ToggleFullWindowMessage;
\ No newline at end of file
+export type InMessage = UpdatePlotMessage | FocusPlotMessage | ToggleStyleMessage | HidePlotMessage | AddPlotMessage | PreviewPlotLayoutMessage | ToggleFullWindowMessage;

From 65433cfde1add4d64d361c01391e1cd8e5323323 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Sat, 14 Mar 2026 12:25:23 -0700
Subject: [PATCH 42/47] refactor: decouple plot viewers and implement
 PlotManager for extensibility

---
 session.md                       |   6 +-
 src/extension.ts                 |   9 +-
 src/liveShare/shareCommands.ts   |   4 +-
 src/liveShare/shareSession.ts    |   4 +-
 src/plotViewer/httpgdViewer.ts   | 633 +++++++++++++++++++++++
 src/plotViewer/index.ts          | 851 ++-----------------------------
 src/plotViewer/standardViewer.ts |  23 +-
 src/plotViewer/types.ts          |  17 +
 src/session.ts                   |  11 +-
 9 files changed, 732 insertions(+), 826 deletions(-)
 create mode 100644 src/plotViewer/httpgdViewer.ts
 create mode 100644 src/plotViewer/types.ts

diff --git a/session.md b/session.md
index fe4df63c..4e0dc322 100644
--- a/session.md
+++ b/session.md
@@ -254,17 +254,17 @@ export async function showDataView(source: string, type: string, title: string,
 ```typescript
 case 'httpgd': {
     if (request.url) {
-        await globalHttpgdManager?.showViewer(request.url);
+        await globalPlotManager?.showHttpgdPlot(request.url);
     }
     break;
 }
 ```
 
-**Detail (`httpgd` [-> src/plotViewer/index.ts#L72](src/plotViewer/index.ts#L72)):**
+**Detail (`httpgd` [-> src/plotViewer/index.ts](src/plotViewer/index.ts)):**
 Triggered when an R script opens an `httpgd` graphics device (a modern SVG/HTML-based plotting device for R).
 
 1. **Intercepting the URL**: R tells VS Code the exact local URL/port where the `httpgd` server is streaming the plots.
-2. **Delegation to Manager**: The session handler passes this URL to the `globalHttpgdManager` (an instance of `HttpgdManager` defined in `src/plotViewer/index.ts`).
+2. **Delegation to Manager**: The session handler passes this URL to the `globalPlotManager` (an instance of `CommonPlotManager` defined in `src/plotViewer/index.ts`).
 3. **Viewer Instantiation**: The manager parses the URL, extracting the host and security token. It searches to see if a viewer for that host already exists. If not, it instantiates a new `HttpgdViewer`.
 4. **Webview Rendering**: The `HttpgdViewer` spins up a dedicated `WebviewPanel`. Instead of just embedding the plot as a static image, it loads a full React-based frontend application (bundled in the extension's resources) into the webview. This frontend connects directly to the R `httpgd` server via WebSockets to provide a live, interactive, resizable plot viewer with history tracking and export capabilities.
 
diff --git a/src/extension.ts b/src/extension.ts
index 8500c9fe..6c8e2fa7 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -20,7 +20,8 @@ import * as apiImplementation from './apiImplementation';
 import * as rHelp from './helpViewer';
 import * as completions from './completions';
 import * as rShare from './liveShare';
-import * as httpgdViewer from './plotViewer';
+import * as plotViewer from './plotViewer';
+import { PlotManager } from './plotViewer/types';
 import * as languageService from './languageService';
 import { RTaskProvider } from './tasks';
 
@@ -32,7 +33,7 @@ export let rWorkspace: workspaceViewer.WorkspaceDataProvider | undefined = undef
 export let globalRHelp: rHelp.RHelp | undefined = undefined;
 export let extensionContext: vscode.ExtensionContext;
 export let enableSessionWatcher: boolean | undefined = undefined;
-export let globalHttpgdManager: httpgdViewer.HttpgdManager | undefined = undefined;
+export let globalPlotManager: PlotManager | undefined = undefined;
 export let rmdPreviewManager: rmarkdown.RMarkdownPreviewManager | undefined = undefined;
 export let rmdKnitManager: rmarkdown.RMarkdownKnitManager | undefined = undefined;
 export let sessionStatusBarItem: vscode.StatusBarItem | undefined = undefined;
@@ -200,8 +201,8 @@ export async function activate(context: vscode.ExtensionContext): Promise<apiImp
         }
     ));
 
-    // initialize httpgd viewer
-    globalHttpgdManager = httpgdViewer.initializeHttpgd();
+    // initialize plot manager
+    globalPlotManager = plotViewer.initializePlotManager();
 
     // initialize the package/help related functions
     globalRHelp = await rHelp.initializeHelp(context, rExtension);
diff --git a/src/liveShare/shareCommands.ts b/src/liveShare/shareCommands.ts
index 7745d2af..c255f81b 100644
--- a/src/liveShare/shareCommands.ts
+++ b/src/liveShare/shareCommands.ts
@@ -9,7 +9,7 @@ import { forwardCommands, shareWorkspace } from './shareTree';
 import { runTextInTerm } from '../rTerminal';
 import { requestFile, WorkspaceData } from '../session';
 import { HelpFile } from '../helpViewer';
-import { globalHttpgdManager, globalRHelp } from '../extension';
+import { globalPlotManager, globalRHelp } from '../extension';
 
 // used in sending messages to the guest service,
 // distinguishes the type of vscode message to show
@@ -99,7 +99,7 @@ export const Commands: ICommands = {
             void updateGuestPlot(args[0]);
         },
         [Callback.NotifyGuestPlotManager]: (args: [url: string]): void => {
-            void globalHttpgdManager?.showViewer(args[0]);
+            void globalPlotManager?.showHttpgdPlot(args[0]);
         },
         [Callback.OrderDetach]: (): void => {
             void detachGuest();
diff --git a/src/liveShare/shareSession.ts b/src/liveShare/shareSession.ts
index c74fca2e..e41ec35a 100644
--- a/src/liveShare/shareSession.ts
+++ b/src/liveShare/shareSession.ts
@@ -1,7 +1,7 @@
 import path = require('path');
 import * as vscode from 'vscode';
 
-import { extensionContext, globalHttpgdManager, globalRHelp, rWorkspace } from '../extension';
+import { extensionContext, globalPlotManager, globalRHelp, rWorkspace } from '../extension';
 import { asViewColumn, config, readContent } from '../util';
 import { showBrowser, showDataView, showWebView, WorkspaceData } from '../session';
 import { liveSession, UUID, rGuestService, _sessionStatusBarItem as sessionStatusBarItem } from '.';
@@ -118,7 +118,7 @@ export async function updateGuestRequest(file: string, force: boolean = false):
             }
             case 'httpgd': {
                 if (request.url) {
-                    await globalHttpgdManager?.showViewer(request.url);
+                    await globalPlotManager?.showHttpgdPlot(request.url);
                 }
                 break;
             }
diff --git a/src/plotViewer/httpgdViewer.ts b/src/plotViewer/httpgdViewer.ts
new file mode 100644
index 00000000..ab55e775
--- /dev/null
+++ b/src/plotViewer/httpgdViewer.ts
@@ -0,0 +1,633 @@
+
+import * as vscode from 'vscode';
+import { Httpgd } from 'httpgd';
+import { HttpgdPlot, IHttpgdViewer, HttpgdViewerOptions } from './httpgdTypes';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as ejs from 'ejs';
+import { Response } from 'node-fetch';
+
+import { asViewColumn, config, setContext, UriIcon, makeWebviewCommandUriString } from '../util';
+import { extensionContext } from '../extension';
+import { FocusPlotMessage, InMessage, OutMessage, ToggleStyleMessage, UpdatePlotMessage, HidePlotMessage, AddPlotMessage, PreviewPlotLayout, PreviewPlotLayoutMessage, ToggleFullWindowMessage } from './webviewMessages';
+import { HttpgdIdResponse, HttpgdPlotId, HttpgdRendererId } from 'httpgd/lib/types';
+import { autoShareBrowser, isHost, shareServer } from '../liveShare';
+import { PlotViewer } from './types';
+
+export class HttpgdManager {
+    viewers: HttpgdViewer[] = [];
+    viewerOptions: HttpgdViewerOptions;
+    recentlyActiveViewers: HttpgdViewer[] = [];
+
+    constructor() {
+        const htmlRoot = extensionContext.asAbsolutePath('dist/webviews/httpgd');
+        this.viewerOptions = {
+            parent: this,
+            htmlRoot: htmlRoot,
+            preserveFocus: true
+        };
+    }
+
+    public async showViewer(urlString: string): Promise<void> {
+        const url = new URL(urlString);
+        const host = url.host;
+        const token = url.searchParams.get('token') || undefined;
+        const ind = this.viewers.findIndex(
+            (viewer) => viewer.host === host
+        );
+        if (ind >= 0) {
+            const viewer = this.viewers.splice(ind, 1)[0];
+            this.viewers.unshift(viewer);
+            viewer.show();
+        } else {
+            const conf = config();
+            const colorTheme = conf.get('plot.defaults.colorTheme', 'vscode');
+            this.viewerOptions.stripStyles = (colorTheme === 'vscode');
+            this.viewerOptions.previewPlotLayout = conf.get<PreviewPlotLayout>('plot.defaults.plotPreviewLayout', 'multirow');
+            this.viewerOptions.refreshTimeoutLength = conf.get('plot.timing.refreshInterval', 10);
+            this.viewerOptions.resizeTimeoutLength = conf.get('plot.timing.resizeInterval', 100);
+            this.viewerOptions.fullWindow = conf.get('plot.defaults.fullWindowMode', false);
+            this.viewerOptions.token = token;
+            const viewer = new HttpgdViewer(host, this.viewerOptions);
+            if (isHost() && autoShareBrowser) {
+                const disposable = await shareServer(url, 'httpgd');
+                viewer.webviewPanel?.onDidDispose(() => void disposable.dispose());
+            }
+            this.viewers.unshift(viewer);
+        }
+    }
+
+    public registerActiveViewer(viewer: HttpgdViewer): void {
+        const ind = this.recentlyActiveViewers.indexOf(viewer);
+        if (ind >= 0) {
+            this.recentlyActiveViewers.splice(ind, 1);
+        }
+        this.recentlyActiveViewers.unshift(viewer);
+    }
+
+    public getRecentViewer(): HttpgdViewer | undefined {
+        return this.recentlyActiveViewers.find((viewer) => !!viewer.webviewPanel);
+    }
+
+    public getNewestViewer(): HttpgdViewer | undefined {
+        return this.viewers[0];
+    }
+
+    public async openUrl(): Promise<void> {
+        const clipText = await vscode.env.clipboard.readText();
+        const val0 = clipText.trim().split(/[\n ]/)[0];
+        const options: vscode.InputBoxOptions = {
+            value: val0,
+            prompt: 'Please enter the httpgd url'
+        };
+        const urlString = await vscode.window.showInputBox(options);
+        if (urlString) {
+            await this.showViewer(urlString);
+        }
+    }
+}
+
+interface EjsData {
+    overwriteStyles: boolean;
+    previewPlotLayout: PreviewPlotLayout;
+    activePlot?: HttpgdPlotId;
+    plots: HttpgdPlot<string>[];
+    largePlot: HttpgdPlot<string>;
+    host: string;
+    asLocalPath: (relPath: string) => string;
+    asWebViewPath: (localPath: string) => string;
+    makeCommandUri: (command: string, ...args: any[]) => string;
+    overwriteCssPath: string;
+    plot?: HttpgdPlot<string>;
+}
+
+interface ShowOptions {
+    viewColumn: vscode.ViewColumn,
+    preserveFocus?: boolean
+}
+
+export class HttpgdViewer implements IHttpgdViewer, PlotViewer {
+    readonly id: string;
+    readonly parent: HttpgdManager;
+    readonly host: string;
+    readonly token?: string;
+    webviewPanel?: vscode.WebviewPanel;
+    readonly api: Httpgd;
+    plots: HttpgdPlot<string>[] = [];
+    activePlot?: HttpgdPlotId;
+    hiddenPlots: HttpgdPlotId[] = [];
+    readonly defaultStripStyles: boolean = true;
+    stripStyles: boolean;
+    readonly defaultPreviewPlotLayout: PreviewPlotLayout = 'multirow';
+    previewPlotLayout: PreviewPlotLayout;
+    readonly defaultFullWindow: boolean = false;
+    fullWindow: boolean;
+    customOverwriteCssPath?: string;
+    viewHeight: number = 600;
+    viewWidth: number = 800;
+    plotHeight: number = 600;
+    plotWidth: number = 800;
+    readonly zoom0: number = 1;
+    zoom: number = this.zoom0;
+    protected resizeTimeout?: NodeJS.Timeout;
+    readonly resizeTimeoutLength: number = 1300;
+    protected refreshTimeout?: NodeJS.Timeout;
+    readonly refreshTimeoutLength: number = 10;
+    private lastExportUri?: vscode.Uri;
+    readonly htmlTemplate: string;
+    readonly smallPlotTemplate: string;
+    readonly htmlRoot: string;
+    readonly showOptions: ShowOptions;
+    readonly webviewOptions: vscode.WebviewPanelOptions & vscode.WebviewOptions;
+
+    protected get activeIndex(): number {
+        if(!this.activePlot){
+            return -1;
+        }
+        return this.getIndex(this.activePlot);
+    }
+    protected set activeIndex(ind: number) {
+        if (this.plots.length === 0) {
+            this.activePlot = undefined;
+        } else {
+            ind = Math.max(ind, 0);
+            ind = Math.min(ind, this.plots.length - 1);
+            this.activePlot = this.plots[ind].id;
+        }
+    }
+
+    constructor(host: string, options: HttpgdViewerOptions) {
+        this.host = host;
+        this.id = host;
+        this.token = options.token;
+        this.parent = options.parent;
+
+        this.api = new Httpgd(this.host, this.token, true);
+        this.api.onPlotsChanged((newState) => {
+            void this.refreshPlotsDelayed(newState.plots);
+        });
+        const conf = config();
+        this.customOverwriteCssPath = conf.get('plot.customStyleOverwrites', '');
+        const localResourceRoots = (
+            this.customOverwriteCssPath ?
+                [extensionContext.extensionUri, vscode.Uri.file(path.dirname(this.customOverwriteCssPath))] :
+                undefined
+        );
+        this.htmlRoot = options.htmlRoot;
+        this.htmlTemplate = fs.readFileSync(path.join(this.htmlRoot, 'index.ejs'), 'utf-8');
+        this.smallPlotTemplate = fs.readFileSync(path.join(this.htmlRoot, 'smallPlot.ejs'), 'utf-8');
+        this.showOptions = {
+            viewColumn: options.viewColumn ?? asViewColumn(conf.get<string>('session.viewers.viewColumn.plot'), vscode.ViewColumn.Two),
+            preserveFocus: !!options.preserveFocus
+        };
+        this.webviewOptions = {
+            enableCommandUris: true,
+            enableScripts: true,
+            retainContextWhenHidden: true,
+            localResourceRoots: localResourceRoots
+        };
+        this.stripStyles = options.stripStyles ?? this.defaultStripStyles;
+        this.previewPlotLayout = options.previewPlotLayout ?? this.defaultPreviewPlotLayout;
+        this.fullWindow = options.fullWindow ?? this.defaultFullWindow;
+        this.resizeTimeoutLength = options.refreshTimeoutLength ?? this.resizeTimeoutLength;
+        this.refreshTimeoutLength = options.refreshTimeoutLength ?? this.refreshTimeoutLength;
+        void this.api.connect();
+    }
+
+    public handleCommand(command: string, ...args: any[]): void | Promise<void> {
+        const stringArg = findItemOfType(args, 'string');
+        const boolArg = findItemOfType(args, 'boolean');
+
+        switch (command) {
+            case 'showIndex': return this.focusPlot(stringArg);
+            case 'nextPlot': return this.nextPlot(boolArg);
+            case 'prevPlot': return this.prevPlot(boolArg);
+            case 'lastPlot': return this.nextPlot(true);
+            case 'firstPlot': return this.prevPlot(true);
+            case 'resetPlots': return this.resetPlots();
+            case 'toggleStyle': return this.toggleStyle(boolArg);
+            case 'togglePreviewPlots': return this.togglePreviewPlots(stringArg as PreviewPlotLayout);
+            case 'closePlot': return this.closePlot(stringArg);
+            case 'hidePlot': return this.hidePlot(stringArg);
+            case 'exportPlot': return this.exportPlot(stringArg);
+            case 'zoomIn': return this.zoomIn();
+            case 'zoomOut': return this.zoomOut();
+            case 'openExternal': return this.openExternal();
+            case 'toggleFullWindow': return this.toggleFullWindow();
+        }
+    }
+
+    public show(preserveFocus?: boolean): void {
+        preserveFocus ??= this.showOptions.preserveFocus;
+        if (!this.webviewPanel) {
+            const showOptions = {
+                ...this.showOptions,
+                preserveFocus: preserveFocus
+            };
+            this.webviewPanel = this.makeNewWebview(showOptions);
+            this.refreshHtml();
+        } else {
+            this.webviewPanel.reveal(undefined, preserveFocus);
+        }
+        this.parent.registerActiveViewer(this);
+    }
+
+    public openExternal(): void {
+        let urlString = `http://${this.host}/live`;
+        if (this.token) {
+            urlString += `?token=${this.token}`;
+        }
+        const uri = vscode.Uri.parse(urlString);
+        void vscode.env.openExternal(uri);
+    }
+
+    public async focusPlot(id?: HttpgdPlotId): Promise<void> {
+        this.activePlot = id || this.activePlot;
+        const plt = this.plots[this.activeIndex];
+        if (plt && (plt.height !== this.viewHeight || plt.width !== this.viewHeight || plt.zoom !== this.zoom)) {
+            await this.refreshPlots(this.api.getPlots());
+        } else {
+            this._focusPlot();
+        }
+    }
+    protected _focusPlot(plotId?: HttpgdPlotId): void {
+        plotId ??= this.activePlot;
+        if(!plotId){
+            return;
+        }
+        const msg: FocusPlotMessage = {
+            message: 'focusPlot',
+            plotId: plotId
+        };
+        this.postWebviewMessage(msg);
+        void this.setContextValues();
+    }
+
+    public async nextPlot(last?: boolean): Promise<void> {
+        this.activeIndex = last ? this.plots.length - 1 : this.activeIndex + 1;
+        await this.focusPlot();
+    }
+    public async prevPlot(first?: boolean): Promise<void> {
+        this.activeIndex = first ? 0 : this.activeIndex - 1;
+        await this.focusPlot();
+    }
+
+    public resetPlots(): void {
+        this.hiddenPlots = [];
+        this.zoom = this.zoom0;
+        void this.refreshPlots(this.api.getPlots(), true, true);
+    }
+
+    public hidePlot(id?: HttpgdPlotId): void {
+        id ??= this.activePlot;
+        if (!id) { return; }
+        const tmpIndex = this.activeIndex;
+        this.hiddenPlots.push(id);
+        this.plots = this.plots.filter((plt) => !this.hiddenPlots.includes(plt.id));
+        if (id === this.activePlot) {
+            this.activeIndex = tmpIndex;
+            this._focusPlot();
+        }
+        this._hidePlot(id);
+    }
+    protected _hidePlot(id: HttpgdPlotId): void {
+        const msg: HidePlotMessage = {
+            message: 'hidePlot',
+            plotId: id
+        };
+        this.postWebviewMessage(msg);
+    }
+
+    public async closePlot(id?: HttpgdPlotId): Promise<void> {
+        id ??= this.activePlot;
+        if (id) {
+            this.hidePlot(id);
+            await this.api.removePlot({ id: id });
+        }
+    }
+
+    public toggleStyle(force?: boolean): void {
+        this.stripStyles = force ?? !this.stripStyles;
+        const msg: ToggleStyleMessage = {
+            message: 'toggleStyle',
+            useOverwrites: this.stripStyles
+        };
+        this.postWebviewMessage(msg);
+    }
+
+    public toggleFullWindow(force?: boolean): void {
+        this.fullWindow = force ?? !this.fullWindow;
+        const msg: ToggleFullWindowMessage = {
+            message: 'toggleFullWindow',
+            useFullWindow: this.fullWindow
+        };
+        this.postWebviewMessage(msg);
+    }
+
+    public togglePreviewPlots(force?: PreviewPlotLayout): void {
+        if (force) {
+            this.previewPlotLayout = force;
+        } else if (this.previewPlotLayout === 'multirow') {
+            this.previewPlotLayout = 'scroll';
+        } else if (this.previewPlotLayout === 'scroll') {
+            this.previewPlotLayout = 'hidden';
+        } else if (this.previewPlotLayout === 'hidden') {
+            this.previewPlotLayout = 'multirow';
+        }
+        const msg: PreviewPlotLayoutMessage = {
+            message: 'togglePreviewPlotLayout',
+            style: this.previewPlotLayout
+        };
+        this.postWebviewMessage(msg);
+    }
+
+    public zoomOut(): void {
+        if (this.zoom > 0.1) {
+            this.zoom -= 0.1;
+            void this.resizePlot();
+        }
+    }
+
+    public zoomIn(): void {
+        this.zoom += 0.1;
+        void this.resizePlot();
+    }
+
+    public async setContextValues(mightBeInBackground: boolean = false): Promise<void> {
+        if (this.webviewPanel?.active) {
+            this.parent.registerActiveViewer(this);
+            await setContext('r.plot.active', true);
+            await setContext('r.plot.canGoBack', this.activeIndex > 0);
+            await setContext('r.plot.canGoForward', this.activeIndex < this.plots.length - 1);
+        } else if (!mightBeInBackground) {
+            await setContext('r.plot.active', false);
+        }
+    }
+
+    public getPanelPath(): string | undefined {
+        if (!this.webviewPanel) {
+            return undefined;
+        }
+        const dummyUri = this.webviewPanel.webview.asWebviewUri(vscode.Uri.file(''));
+        const m = /^[^.]*/.exec(dummyUri.authority);
+        const webviewId = m?.[0] || '';
+        return `webview-panel/webview-${webviewId}`;
+    }
+
+    protected getIndex(id: HttpgdPlotId): number {
+        return this.plots.findIndex((plt: HttpgdPlot<string>) => plt.id === id);
+    }
+
+    protected handleResize(height: number, width: number, userTriggered: boolean = false): void {
+        this.viewHeight = height;
+        this.viewWidth = width;
+        if (userTriggered || this.resizeTimeoutLength === 0) {
+            if(this.resizeTimeout){
+                clearTimeout(this.resizeTimeout);
+            }
+            this.resizeTimeout = undefined;
+            void this.resizePlot();
+        } else if (!this.resizeTimeout) {
+            this.resizeTimeout = setTimeout(() => {
+                void this.resizePlot().then(() =>
+                    this.resizeTimeout = undefined
+                );
+            }, this.resizeTimeoutLength);
+        }
+    }
+
+    protected async resizePlot(id?: HttpgdPlotId): Promise<void> {
+        id ??= this.activePlot;
+        if (!id) { return; }
+        const plt = await this.getPlotContent(id, this.viewWidth, this.viewHeight, this.zoom);
+        this.plotWidth = plt.width;
+        this.plotHeight = plt.height;
+        this.updatePlot(plt);
+    }
+
+    protected async refreshPlotsDelayed(plotsIdResponse: HttpgdIdResponse[], redraw: boolean = false, force: boolean = false): Promise<void> {
+        if(this.refreshTimeoutLength === 0){
+            await this.refreshPlots(plotsIdResponse, redraw, force);
+        } else{
+            clearTimeout(this.refreshTimeout);
+            this.refreshTimeout = setTimeout(() => {
+                void this.refreshPlots(plotsIdResponse, redraw, force).then(() =>
+                    this.refreshTimeout = undefined
+                );
+            }, this.refreshTimeoutLength);
+        }
+    }
+
+    protected async refreshPlots(plotsIdResponse: HttpgdIdResponse[], redraw: boolean = false, force: boolean = false): Promise<void> {
+        const nPlots = this.plots.length;
+        let plotIds = plotsIdResponse.map((x) => x.id);
+        plotIds = plotIds.filter((id) => !this.hiddenPlots.includes(id));
+        const newPlotPromises = plotIds.map(async (id) => {
+            const plot = this.plots.find((plt) => plt.id === id);
+            if (force || !plot || id === this.activePlot) {
+                return await this.getPlotContent(id, this.viewWidth, this.viewHeight, this.zoom);
+            } else {
+                return plot;
+            }
+        });
+        const newPlots = await Promise.all(newPlotPromises);
+        const oldPlotIds = this.plots.map(plt => plt.id);
+        this.plots = newPlots;
+        if (this.plots.length !== nPlots) {
+            this.activePlot = this.plots[this.plots.length - 1]?.id;
+        }
+        if (redraw || !this.webviewPanel) {
+            this.refreshHtml();
+        } else {
+            for (const plt of this.plots) {
+                if (oldPlotIds.includes(plt.id)) {
+                    this.updatePlot(plt);
+                } else {
+                    this.addPlot(plt);
+                }
+            }
+            this._focusPlot();
+        }
+    }
+
+    protected updatePlot(plt: HttpgdPlot<string>): void {
+        const msg: UpdatePlotMessage = {
+            message: 'updatePlot',
+            plotId: plt.id,
+            svg: plt.data
+        };
+        this.postWebviewMessage(msg);
+    }
+
+    protected addPlot(plt: HttpgdPlot<string>): void {
+        const ejsData = this.makeEjsData();
+        ejsData.plot = plt;
+        const html = ejs.render(this.smallPlotTemplate, ejsData);
+        const msg: AddPlotMessage = {
+            message: 'addPlot',
+            html: html
+        };
+        this.postWebviewMessage(msg);
+        void this.focusPlot(plt.id);
+        void this.setContextValues();
+    }
+
+    protected async getPlotContent(id: HttpgdPlotId, width: number, height: number, zoom: number): Promise<HttpgdPlot<string>> {
+        const args = {
+            id: id,
+            height: height,
+            width: width,
+            zoom: zoom,
+            renderer: 'svgp'
+        };
+        const plotContent = await this.api.getPlot(args);
+        const svg = await plotContent?.text() || '';
+        const plt: HttpgdPlot<string> = {
+            id: id,
+            data: svg,
+            height: height,
+            width: width,
+            zoom: zoom,
+        };
+        this.viewHeight = plt.height;
+        this.viewWidth = plt.width;
+        return plt;
+    }
+
+    protected refreshHtml(): void {
+        this.webviewPanel ??= this.makeNewWebview();
+        this.webviewPanel.webview.html = '';
+        this.webviewPanel.webview.html = this.makeHtml();
+        this.toggleFullWindow(this.fullWindow);
+        void this.setContextValues(true);
+    }
+
+    protected makeHtml(): string {
+        const ejsData = this.makeEjsData();
+        return ejs.render(this.htmlTemplate, ejsData);
+    }
+
+    protected makeEjsData(): EjsData {
+        const asLocalPath = (relPath: string) => {
+            if (!this.webviewPanel) {
+                return relPath;
+            }
+            const localUri = vscode.Uri.file(path.join(this.htmlRoot, relPath));
+            return localUri.fsPath;
+        };
+        const asWebViewPath = (localPath: string) => {
+            if (!this.webviewPanel) {
+                return localPath;
+            }
+            const localUri = vscode.Uri.file(path.join(this.htmlRoot, localPath));
+            const webViewUri = this.webviewPanel.webview.asWebviewUri(localUri);
+            return webViewUri.toString();
+        };
+        let overwriteCssPath = '';
+        if (this.customOverwriteCssPath) {
+            const uri = vscode.Uri.file(this.customOverwriteCssPath);
+            overwriteCssPath = this.webviewPanel?.webview.asWebviewUri(uri).toString() || '';
+        } else {
+            overwriteCssPath = asWebViewPath('styleOverwrites.css');
+        }
+        return {
+            overwriteStyles: this.stripStyles,
+            previewPlotLayout: this.previewPlotLayout,
+            plots: this.plots,
+            largePlot: this.plots[this.activeIndex],
+            activePlot: this.activePlot,
+            host: this.host,
+            asLocalPath: asLocalPath,
+            asWebViewPath: asWebViewPath,
+            makeCommandUri: makeWebviewCommandUriString,
+            overwriteCssPath: overwriteCssPath
+        };
+    }
+
+    protected makeNewWebview(showOptions?: ShowOptions): vscode.WebviewPanel {
+        const webviewPanel = vscode.window.createWebviewPanel(
+            'RPlot',
+            'R Plot',
+            showOptions || this.showOptions,
+            this.webviewOptions
+        );
+        webviewPanel.iconPath = new UriIcon('graph');
+        webviewPanel.onDidDispose(() => this.webviewPanel = undefined);
+        webviewPanel.onDidChangeViewState(() => {
+            void this.setContextValues();
+        });
+        webviewPanel.webview.onDidReceiveMessage((e: OutMessage) => {
+            this.handleWebviewMessage(e);
+        });
+        return webviewPanel;
+    }
+
+    protected handleWebviewMessage(msg: OutMessage): void {
+        if (msg.message === 'log') {
+            console.log(msg.body);
+        } else if (msg.message === 'resize') {
+            void this.handleResize(msg.height, msg.width, msg.userTriggered);
+        }
+    }
+
+    protected postWebviewMessage(msg: InMessage): void {
+        void this.webviewPanel?.webview.postMessage(msg);
+    }
+
+    public async exportPlot(id?: HttpgdPlotId, rendererId?: HttpgdRendererId, outFile?: string): Promise<void> {
+        id ||= this.activePlot || this.plots[this.plots.length - 1]?.id;
+        const plot = this.plots.find((plt) => plt.id === id);
+        if (!plot) {
+            void vscode.window.showWarningMessage('No plot available for export.');
+            return;
+        }
+        if (!rendererId) {
+            const renderers = this.api.getRenderers();
+            const qpItems  = renderers.map(renderer => ({
+                label: renderer.name,
+                detail: renderer.descr,
+                id: renderer.id
+            }));
+            const qpPick = await vscode.window.showQuickPick(qpItems, { placeHolder: 'Please choose a file format' });
+            rendererId = qpPick?.id;
+            if(!rendererId){
+                return;
+            }
+        }
+        if (!outFile) {
+            const options: vscode.SaveDialogOptions = {};
+            const renderer = this.api.getRenderers().find(r => r.id === rendererId);
+            const ext = renderer?.ext.replace(/^\./, '');
+            if(this.lastExportUri){
+                const noExtPath = this.lastExportUri.fsPath.replace(/\.[^.]*$/, '');
+                options.defaultUri = vscode.Uri.file(noExtPath + (ext ? `.${ext}` : ''));
+            } else {
+                const defaultFolder = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+                if(defaultFolder) options.defaultUri = vscode.Uri.file(path.join(defaultFolder, 'plot' + (ext ? `.${ext}` : '')));
+            }
+            if(ext && renderer?.name) options.filters = { [renderer.name]: [ext], ['All']: ['*'] };
+            const outUri = await vscode.window.showSaveDialog(options);
+            if(outUri){
+                this.lastExportUri = outUri;
+                outFile = outUri.fsPath;
+            } else return;
+        }
+        const plt = await this.api.getPlot({ id: this.activePlot, renderer: rendererId }) as any;
+        const dest = fs.createWriteStream(outFile);
+        dest.on('error', (err) => void vscode.window.showErrorMessage(`Export failed: ${err.message}`));
+        dest.on('close', () => void vscode.window.showInformationMessage(`Export done: ${outFile || ''}`));
+        void plt.body.pipe(dest);
+    }
+
+    public dispose(): void {
+        this.api.disconnect();
+    }
+}
+
+function findItemOfType(arr: any[], type: 'string'): string | undefined;
+function findItemOfType(arr: any[], type: 'boolean'): boolean | undefined;
+function findItemOfType(arr: any[], type: 'number'): number | undefined;
+function findItemOfType<T = unknown>(arr: any[], type: string): T {
+    const item = arr.find((elm) => typeof elm === type) as T;
+    return item;
+}
diff --git a/src/plotViewer/index.ts b/src/plotViewer/index.ts
index 7a0d4305..913ae47e 100644
--- a/src/plotViewer/index.ts
+++ b/src/plotViewer/index.ts
@@ -1,24 +1,10 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
 
 import * as vscode from 'vscode';
-import { Httpgd } from 'httpgd';
-import { HttpgdPlot, IHttpgdViewer, HttpgdViewerOptions } from './httpgdTypes';
-import * as path from 'path';
-import * as fs from 'fs';
-import * as ejs from 'ejs';
-
-import { asViewColumn, config, setContext, UriIcon, makeWebviewCommandUriString } from '../util';
-
+import { PlotViewer, PlotManager } from './types';
+import { HttpgdManager } from './httpgdViewer';
+import { StandardPlotViewer } from './standardViewer';
 import { extensionContext } from '../extension';
 
-import { FocusPlotMessage, InMessage, OutMessage, ToggleStyleMessage, UpdatePlotMessage, HidePlotMessage, AddPlotMessage, PreviewPlotLayout, PreviewPlotLayoutMessage, ToggleFullWindowMessage } from './webviewMessages';
-import { HttpgdIdResponse, HttpgdPlotId, HttpgdRendererId } from 'httpgd/lib/types';
-import { Response } from 'node-fetch';
-import { autoShareBrowser, isHost, shareServer } from '../liveShare';
-
 const commands = [
     'showViewers',
     'openUrl',
@@ -39,823 +25,76 @@ const commands = [
     'zoomOut'
 ] as const;
 
-type CommandName = typeof commands[number];
-
-export function initializeHttpgd(): HttpgdManager {
-    const httpgdManager = new HttpgdManager();
-    for (const cmd of commands) {
-        const fullCommand = `r.plot.${cmd}`;
-        const cb = httpgdManager.getCommandHandler(cmd);
-        extensionContext.subscriptions.push(
-            vscode.commands.registerCommand(fullCommand, cb)
-        );
-    }
-    return httpgdManager;
-}
-
-export class HttpgdManager {
-    viewers: HttpgdViewer[] = [];
-
-    viewerOptions: HttpgdViewerOptions;
-
-    recentlyActiveViewers: HttpgdViewer[] = [];
+export class CommonPlotManager implements PlotManager {
+    public httpgdManager: HttpgdManager;
+    public standardPlotViewer: StandardPlotViewer;
 
     constructor() {
-        const htmlRoot = extensionContext.asAbsolutePath('dist/webviews/httpgd');
-        this.viewerOptions = {
-            parent: this,
-            htmlRoot: htmlRoot,
-            preserveFocus: true
-        };
-    }
-
-    public async showViewer(urlString: string): Promise<void> {
-        const url = new URL(urlString);
-        const host = url.host;
-        const token = url.searchParams.get('token') || undefined;
-        const ind = this.viewers.findIndex(
-            (viewer) => viewer.host === host
-        );
-        if (ind >= 0) {
-            const viewer = this.viewers.splice(ind, 1)[0];
-            this.viewers.unshift(viewer);
-            viewer.show();
-        } else {
-            const conf = config();
-            const colorTheme = conf.get('plot.defaults.colorTheme', 'vscode');
-            this.viewerOptions.stripStyles = (colorTheme === 'vscode');
-            this.viewerOptions.previewPlotLayout = conf.get<PreviewPlotLayout>('plot.defaults.plotPreviewLayout', 'multirow');
-            this.viewerOptions.refreshTimeoutLength = conf.get('plot.timing.refreshInterval', 10);
-            this.viewerOptions.resizeTimeoutLength = conf.get('plot.timing.resizeInterval', 100);
-            this.viewerOptions.fullWindow = conf.get('plot.defaults.fullWindowMode', false);
-            this.viewerOptions.token = token;
-            const viewer = new HttpgdViewer(host, this.viewerOptions);
-            if (isHost() && autoShareBrowser) {
-                const disposable = await shareServer(url, 'httpgd');
-                viewer.webviewPanel?.onDidDispose(() => void disposable.dispose());
-            }
-            this.viewers.unshift(viewer);
-        }
+        this.httpgdManager = new HttpgdManager();
+        this.standardPlotViewer = new StandardPlotViewer();
     }
 
-    public registerActiveViewer(viewer: HttpgdViewer): void {
-        const ind = this.recentlyActiveViewers.indexOf(viewer);
-        if (ind) {
-            this.recentlyActiveViewers.splice(ind, 1);
-        }
-        this.recentlyActiveViewers.unshift(viewer);
+    get viewers(): PlotViewer[] {
+        const viewers: PlotViewer[] = [...this.httpgdManager.viewers];
+        viewers.push(this.standardPlotViewer);
+        return viewers;
     }
 
-    public getRecentViewer(): HttpgdViewer | undefined {
-        return this.recentlyActiveViewers.find((viewer) => !!viewer.webviewPanel);
+    get activeViewer(): PlotViewer | undefined {
+        return this.httpgdManager.getRecentViewer() || this.standardPlotViewer;
     }
 
-    public getNewestViewer(): HttpgdViewer | undefined {
-        return this.viewers[0];
+    public initialize(): void {
+        for (const cmd of commands) {
+            const fullCommand = `r.plot.${cmd}`;
+            extensionContext.subscriptions.push(
+                vscode.commands.registerCommand(fullCommand, (hostOrWebviewUri?: string | vscode.Uri, ...args: any[]) => {
+                    void this.handleCommand(cmd, hostOrWebviewUri, ...args);
+                })
+            );
+        }
     }
 
-    public getCommandHandler(command: CommandName): (...args: any[]) => void {
-        return (...args: any[]) => {
-            this.handleCommand(command, ...args);
-        };
+    public async showStandardPlot(): Promise<void> {
+        await this.standardPlotViewer.update();
     }
 
-    public async openUrl(): Promise<void> {
-        const clipText = await vscode.env.clipboard.readText();
-        const val0 = clipText.trim().split(/[\n ]/)[0];
-        const options: vscode.InputBoxOptions = {
-            value: val0,
-            prompt: 'Please enter the httpgd url'
-        };
-        const urlString = await vscode.window.showInputBox(options);
-        if (urlString) {
-            await this.showViewer(urlString);
-        }
+    public async showHttpgdPlot(url: string): Promise<void> {
+        await this.httpgdManager.showViewer(url);
     }
 
-    // generic command handler
-    public handleCommand(command: CommandName, hostOrWebviewUri?: string | vscode.Uri, ...args: any[]): void {
-        // the number and type of arguments given to a command can vary, depending on where it was called from:
-        // - calling from the title bar menu provides two arguments, the first of which identifies the webview
-        // - calling from the command palette provides no arguments
-        // - calling from a command uri provides a flexible number/type of arguments
-        // below  is an attempt to handle these different combinations efficiently and (somewhat) robustly
-        //
-
+    private async handleCommand(command: string, hostOrWebviewUri?: string | vscode.Uri, ...args: any[]): Promise<void> {
         if (command === 'showViewers') {
-            this.viewers.forEach(viewer => {
+            for (const viewer of this.viewers) {
                 viewer.show(true);
-            });
+            }
             return;
-        } else if (command === 'openUrl') {
-            void this.openUrl();
+        }
+
+        if (command === 'openUrl') {
+            await this.httpgdManager.openUrl();
             return;
         }
 
         // Identify the correct viewer
-        let viewer: HttpgdViewer | undefined;
+        let viewer: PlotViewer | undefined;
         if (typeof hostOrWebviewUri === 'string') {
-            const host = hostOrWebviewUri;
-            viewer = this.viewers.find((viewer) => viewer.host === host);
+            viewer = this.httpgdManager.viewers.find((v) => v.host === hostOrWebviewUri);
         } else if (hostOrWebviewUri instanceof vscode.Uri) {
-            const uri = hostOrWebviewUri;
-            viewer = this.viewers.find((viewer) => viewer.getPanelPath() === uri.path);
+            viewer = this.httpgdManager.viewers.find((v) => v.getPanelPath() === hostOrWebviewUri.path);
         }
 
-        // fall back to most recent viewer
-        viewer ||= this.getRecentViewer();
+        // Fallback to active viewer
+        viewer ||= this.activeViewer;
 
-        // Abort if no viewer identified
-        if (!viewer) {
-            return;
+        if (viewer) {
+            await viewer.handleCommand(command, ...args);
         }
-
-        // Get possible arguments for commands:
-        const stringArg = findItemOfType(args, 'string');
-        const boolArg = findItemOfType(args, 'boolean');
-
-        // Call corresponding method, possibly with an argument:
-        switch (command) {
-            case 'showIndex': {
-                void viewer.focusPlot(stringArg);
-                break;
-            } case 'nextPlot': {
-                void viewer.nextPlot(boolArg);
-                break;
-            } case 'prevPlot': {
-                void viewer.prevPlot(boolArg);
-                break;
-            } case 'lastPlot': {
-                void viewer.nextPlot(true);
-                break;
-            } case 'firstPlot': {
-                void viewer.prevPlot(true);
-                break;
-            } case 'resetPlots': {
-                viewer.resetPlots();
-                break;
-            } case 'toggleStyle': {
-                void viewer.toggleStyle(boolArg);
-                break;
-            } case 'togglePreviewPlots': {
-                void viewer.togglePreviewPlots(stringArg as PreviewPlotLayout);
-                break;
-            } case 'closePlot': {
-                void viewer.closePlot(stringArg);
-                break;
-            } case 'hidePlot': {
-                void viewer.hidePlot(stringArg);
-                break;
-            } case 'exportPlot': {
-                void viewer.exportPlot(stringArg);
-                break;
-            } case 'zoomIn': {
-                void viewer.zoomIn();
-                break;
-            } case 'zoomOut': {
-                void viewer.zoomOut();
-                break;
-            } case 'openExternal': {
-                void viewer.openExternal();
-                break;
-            } case 'toggleFullWindow': {
-                void viewer.toggleFullWindow();
-                break;
-            } default: {
-                break;
-            }
-        }
-    }
-}
-
-
-interface EjsData {
-    overwriteStyles: boolean;
-    previewPlotLayout: PreviewPlotLayout;
-    activePlot?: HttpgdPlotId;
-    plots: HttpgdPlot<string>[];
-    largePlot: HttpgdPlot<string>;
-    host: string;
-    asLocalPath: (relPath: string) => string;
-    asWebViewPath: (localPath: string) => string;
-    makeCommandUri: (command: string, ...args: any[]) => string;
-    overwriteCssPath: string;
-
-    // only used to render an individual smallPlot div:
-    plot?: HttpgdPlot<string>;
-}
-
-interface ShowOptions {
-    viewColumn: vscode.ViewColumn,
-    preserveFocus?: boolean
-}
-
-export class HttpgdViewer implements IHttpgdViewer {
-
-    readonly parent: HttpgdManager;
-
-    readonly host: string;
-    readonly token?: string;
-
-    // Actual webview where the plot viewer is shown
-    // Will have to be created anew, if the user closes it and the plot changes
-    webviewPanel?: vscode.WebviewPanel;
-
-    // Api that provides plot contents etc.
-    readonly api: Httpgd;
-
-    // active plots
-    plots: HttpgdPlot<string>[] = [];
-
-    // Id of the currently viewed plot
-    activePlot?: HttpgdPlotId;
-
-    // Ids of plots that are not shown, but not closed inside httpgd
-    hiddenPlots: HttpgdPlotId[] = [];
-
-    readonly defaultStripStyles: boolean = true;
-    stripStyles: boolean;
-
-    readonly defaultPreviewPlotLayout: PreviewPlotLayout = 'multirow';
-    previewPlotLayout: PreviewPlotLayout;
-
-    readonly defaultFullWindow: boolean = false;
-    fullWindow: boolean;
-
-    // Custom file to be used instead of `styleOverwrites.css`
-    customOverwriteCssPath?: string;
-
-    // Size of the view area:
-    viewHeight: number = 600;
-    viewWidth: number = 800;
-
-    // Size of the shown plot (as computed):
-    plotHeight: number = 600;
-    plotWidth: number = 800;
-
-    readonly zoom0: number = 1;
-    zoom: number = this.zoom0;
-
-    protected resizeTimeout?: NodeJS.Timeout;
-    readonly resizeTimeoutLength: number = 1300;
-
-    protected refreshTimeout?: NodeJS.Timeout;
-    readonly refreshTimeoutLength: number = 10;
-
-    private lastExportUri?: vscode.Uri;
-
-    readonly htmlTemplate: string;
-    readonly smallPlotTemplate: string;
-    readonly htmlRoot: string;
-
-    readonly showOptions: ShowOptions;
-    readonly webviewOptions: vscode.WebviewPanelOptions & vscode.WebviewOptions;
-
-    // Computed properties:
-
-    // Get/set active plot by index instead of id:
-    protected get activeIndex(): number {
-        if(!this.activePlot){
-            return -1;
-        }
-        return this.getIndex(this.activePlot);
-    }
-    protected set activeIndex(ind: number) {
-        if (this.plots.length === 0) {
-            this.activePlot = undefined;
-        } else {
-            ind = Math.max(ind, 0);
-            ind = Math.min(ind, this.plots.length - 1);
-            this.activePlot = this.plots[ind].id;
-        }
-    }
-
-    // constructor called by the session watcher if a corresponding function was called in R
-    // creates a new api instance itself
-    constructor(host: string, options: HttpgdViewerOptions) {
-        this.host = host;
-        this.token = options.token;
-        this.parent = options.parent;
-
-        this.api = new Httpgd(this.host, this.token, true);
-        this.api.onPlotsChanged((newState) => {
-            void this.refreshPlotsDelayed(newState.plots);
-        });
-        this.api.onConnectionChanged(() => {
-            // todo
-        });
-        this.api.onDeviceActiveChanged(() => {
-            // todo
-        });
-        const conf = config();
-        this.customOverwriteCssPath = conf.get('plot.customStyleOverwrites', '');
-        const localResourceRoots = (
-            this.customOverwriteCssPath ?
-                [extensionContext.extensionUri, vscode.Uri.file(path.dirname(this.customOverwriteCssPath))] :
-                undefined
-        );
-        this.htmlRoot = options.htmlRoot;
-        this.htmlTemplate = fs.readFileSync(path.join(this.htmlRoot, 'index.ejs'), 'utf-8');
-        this.smallPlotTemplate = fs.readFileSync(path.join(this.htmlRoot, 'smallPlot.ejs'), 'utf-8');
-        this.showOptions = {
-            viewColumn: options.viewColumn ?? asViewColumn(conf.get<string>('session.viewers.viewColumn.plot'), vscode.ViewColumn.Two),
-            preserveFocus: !!options.preserveFocus
-        };
-        this.webviewOptions = {
-            enableCommandUris: true,
-            enableScripts: true,
-            retainContextWhenHidden: true,
-            localResourceRoots: localResourceRoots
-        };
-        this.defaultStripStyles = options.stripStyles ?? this.defaultStripStyles;
-        this.stripStyles = this.defaultStripStyles;
-        this.defaultPreviewPlotLayout = options.previewPlotLayout ?? this.defaultPreviewPlotLayout;
-        this.previewPlotLayout = this.defaultPreviewPlotLayout;
-        this.defaultFullWindow = options.fullWindow ?? this.defaultFullWindow;
-        this.fullWindow = this.defaultFullWindow;
-        this.resizeTimeoutLength = options.refreshTimeoutLength ?? this.resizeTimeoutLength;
-        this.refreshTimeoutLength = options.refreshTimeoutLength ?? this.refreshTimeoutLength;
-        void this.api.connect();
-        //void this.checkState();
-    }
-
-
-    // Methods to interact with the webview
-    // Can e.g. be called by vscode commands + menu items:
-
-    // Called to create a new webview if the user closed the old one:
-    public show(preserveFocus?: boolean): void {
-        preserveFocus ??= this.showOptions.preserveFocus;
-        if (!this.webviewPanel) {
-            const showOptions = {
-                ...this.showOptions,
-                preserveFocus: preserveFocus
-            };
-            this.webviewPanel = this.makeNewWebview(showOptions);
-            this.refreshHtml();
-        } else {
-            this.webviewPanel.reveal(undefined, preserveFocus);
-        }
-        this.parent.registerActiveViewer(this);
-    }
-
-    public openExternal(): void {
-        let urlString = `http://${this.host}/live`;
-        if (this.token) {
-            urlString += `?token=${this.token}`;
-        }
-        const uri = vscode.Uri.parse(urlString);
-        void vscode.env.openExternal(uri);
-    }
-
-    // focus a specific plot id
-    public async focusPlot(id?: HttpgdPlotId): Promise<void> {
-        this.activePlot = id || this.activePlot;
-        const plt = this.plots[this.activeIndex];
-        if (plt.height !== this.viewHeight || plt.width !== this.viewHeight || plt.zoom !== this.zoom) {
-            await this.refreshPlots(this.api.getPlots());
-        } else {
-            this._focusPlot();
-        }
-    }
-    protected _focusPlot(plotId?: HttpgdPlotId): void {
-        plotId ??= this.activePlot;
-        if(!plotId){
-            return;
-        }
-        const msg: FocusPlotMessage = {
-            message: 'focusPlot',
-            plotId: plotId
-        };
-        this.postWebviewMessage(msg);
-        void this.setContextValues();
-    }
-
-    // navigate through plots (supply `true` to go to end/beginning of list)
-    public async nextPlot(last?: boolean): Promise<void> {
-        this.activeIndex = last ? this.plots.length - 1 : this.activeIndex + 1;
-        await this.focusPlot();
-    }
-    public async prevPlot(first?: boolean): Promise<void> {
-        this.activeIndex = first ? 0 : this.activeIndex - 1;
-        await this.focusPlot();
-    }
-
-    // restore closed plots, reset zoom, redraw html
-    public resetPlots(): void {
-        this.hiddenPlots = [];
-        this.zoom = this.zoom0;
-        void this.refreshPlots(this.api.getPlots(), true, true);
-    }
-
-    public hidePlot(id?: HttpgdPlotId): void {
-        id ??= this.activePlot;
-        if (!id) { return; }
-        const tmpIndex = this.activeIndex;
-        this.hiddenPlots.push(id);
-        this.plots = this.plots.filter((plt) => !this.hiddenPlots.includes(plt.id));
-        if (id === this.activePlot) {
-            this.activeIndex = tmpIndex;
-            this._focusPlot();
-        }
-        this._hidePlot(id);
-    }
-    protected _hidePlot(id: HttpgdPlotId): void {
-        const msg: HidePlotMessage = {
-            message: 'hidePlot',
-            plotId: id
-        };
-        this.postWebviewMessage(msg);
-    }
-
-    public async closePlot(id?: HttpgdPlotId): Promise<void> {
-        id ??= this.activePlot;
-        if (id) {
-            this.hidePlot(id);
-            await this.api.removePlot({ id: id });
-        }
-    }
-
-    public toggleStyle(force?: boolean): void {
-        this.stripStyles = force ?? !this.stripStyles;
-        const msg: ToggleStyleMessage = {
-            message: 'toggleStyle',
-            useOverwrites: this.stripStyles
-        };
-        this.postWebviewMessage(msg);
-    }
-
-    public toggleFullWindow(force?: boolean): void {
-        this.fullWindow = force ?? !this.fullWindow;
-        const msg: ToggleFullWindowMessage = {
-            message: 'toggleFullWindow',
-            useFullWindow: this.fullWindow
-        };
-        this.postWebviewMessage(msg);
-    }
-
-    public togglePreviewPlots(force?: PreviewPlotLayout): void {
-        if (force) {
-            this.previewPlotLayout = force;
-        } else if (this.previewPlotLayout === 'multirow') {
-            this.previewPlotLayout = 'scroll';
-        } else if (this.previewPlotLayout === 'scroll') {
-            this.previewPlotLayout = 'hidden';
-        } else if (this.previewPlotLayout === 'hidden') {
-            this.previewPlotLayout = 'multirow';
-        }
-        const msg: PreviewPlotLayoutMessage = {
-            message: 'togglePreviewPlotLayout',
-            style: this.previewPlotLayout
-        };
-        this.postWebviewMessage(msg);
-    }
-
-    public zoomOut(): void {
-        if (this.zoom > 0) {
-            this.zoom -= 0.1;
-            void this.resizePlot();
-        }
-    }
-
-    public zoomIn(): void {
-        this.zoom += 0.1;
-        void this.resizePlot();
-    }
-
-
-    public async setContextValues(mightBeInBackground: boolean = false): Promise<void> {
-        if (this.webviewPanel?.active) {
-            this.parent.registerActiveViewer(this);
-            await setContext('r.plot.active', true);
-            await setContext('r.plot.canGoBack', this.activeIndex > 0);
-            await setContext('r.plot.canGoForward', this.activeIndex < this.plots.length - 1);
-        } else if (!mightBeInBackground) {
-            await setContext('r.plot.active', false);
-        }
-    }
-
-    public getPanelPath(): string | undefined {
-        if (!this.webviewPanel) {
-            return undefined;
-        }
-        const dummyUri = this.webviewPanel.webview.asWebviewUri(vscode.Uri.file(''));
-        const m = /^[^.]*/.exec(dummyUri.authority);
-        const webviewId = m?.[0] || '';
-        return `webview-panel/webview-${webviewId}`;
-    }
-
-    protected getIndex(id: HttpgdPlotId): number {
-        return this.plots.findIndex((plt: HttpgdPlot<string>) => plt.id === id);
-    }
-
-    protected handleResize(height: number, width: number, userTriggered: boolean = false): void {
-        this.viewHeight = height;
-        this.viewWidth = width;
-        if (userTriggered || this.resizeTimeoutLength === 0) {
-            if(this.resizeTimeout){
-                clearTimeout(this.resizeTimeout);
-            }
-            this.resizeTimeout = undefined;
-            void this.resizePlot();
-        } else if (!this.resizeTimeout) {
-            this.resizeTimeout = setTimeout(() => {
-                void this.resizePlot().then(() =>
-                    this.resizeTimeout = undefined
-                );
-            }, this.resizeTimeoutLength);
-        }
-    }
-
-    protected async resizePlot(id?: HttpgdPlotId): Promise<void> {
-        id ??= this.activePlot;
-        if (!id) { return; }
-        const plt = await this.getPlotContent(id, this.viewWidth, this.viewHeight, this.zoom);
-        this.plotWidth = plt.width;
-        this.plotHeight = plt.height;
-        this.updatePlot(plt);
-    }
-
-    protected async refreshPlotsDelayed(plotsIdResponse: HttpgdIdResponse[], redraw: boolean = false, force: boolean = false): Promise<void> {
-        if(this.refreshTimeoutLength === 0){
-            await this.refreshPlots(plotsIdResponse, redraw, force);
-        } else{
-            clearTimeout(this.refreshTimeout);
-            this.refreshTimeout = setTimeout(() => {
-                void this.refreshPlots(plotsIdResponse, redraw, force).then(() =>
-                    this.refreshTimeout = undefined
-                );
-            }, this.refreshTimeoutLength);
-        }
-    }
-
-    protected async refreshPlots(plotsIdResponse: HttpgdIdResponse[], redraw: boolean = false, force: boolean = false): Promise<void> {
-        const nPlots = this.plots.length;
-        let plotIds = plotsIdResponse.map((x) => x.id);
-        plotIds = plotIds.filter((id) => !this.hiddenPlots.includes(id));
-        const newPlotPromises = plotIds.map(async (id) => {
-            const plot = this.plots.find((plt) => plt.id === id);
-            if (force || !plot || id === this.activePlot) {
-                return await this.getPlotContent(id, this.viewWidth, this.viewHeight, this.zoom);
-            } else {
-                return plot;
-            }
-        });
-        const newPlots = await Promise.all(newPlotPromises);
-        const oldPlotIds = this.plots.map(plt => plt.id);
-        this.plots = newPlots;
-        if (this.plots.length !== nPlots) {
-            this.activePlot = this.plots[this.plots.length - 1]?.id;
-        }
-        if (redraw || !this.webviewPanel) {
-            this.refreshHtml();
-        } else {
-            for (const plt of this.plots) {
-                if (oldPlotIds.includes(plt.id)) {
-                    this.updatePlot(plt);
-                } else {
-                    this.addPlot(plt);
-                }
-            }
-            this._focusPlot();
-        }
-    }
-
-    protected updatePlot(plt: HttpgdPlot<string>): void {
-        const msg: UpdatePlotMessage = {
-            message: 'updatePlot',
-            plotId: plt.id,
-            svg: plt.data
-        };
-        this.postWebviewMessage(msg);
-    }
-
-    protected addPlot(plt: HttpgdPlot<string>): void {
-        const ejsData = this.makeEjsData();
-        ejsData.plot = plt;
-        const html = ejs.render(this.smallPlotTemplate, ejsData);
-        const msg: AddPlotMessage = {
-            message: 'addPlot',
-            html: html
-        };
-        this.postWebviewMessage(msg);
-        void this.focusPlot(plt.id);
-        void this.setContextValues();
-    }
-
-    // get content of a single plot
-    protected async getPlotContent(id: HttpgdPlotId, width: number, height: number, zoom: number): Promise<HttpgdPlot<string>> {
-
-        const args = {
-            id: id,
-            height: height,
-            width: width,
-            zoom: zoom,
-            renderer: 'svgp'
-        };
-
-        const plotContent = await this.api.getPlot(args);
-        const svg = await plotContent?.text() || '';
-
-        const plt: HttpgdPlot<string> = {
-            id: id,
-            data: svg,
-            height: height,
-            width: width,
-            zoom: zoom,
-        };
-
-        this.viewHeight ??= plt.height;
-        this.viewWidth ??= plt.width;
-        return plt;
-    }
-
-
-    // functions for initial or re-drawing of html:
-
-    protected refreshHtml(): void {
-        this.webviewPanel ??= this.makeNewWebview();
-        this.webviewPanel.webview.html = '';
-        this.webviewPanel.webview.html = this.makeHtml();
-        // make sure that fullWindow is set correctly:
-        this.toggleFullWindow(this.fullWindow);
-        void this.setContextValues(true);
-    }
-
-    protected makeHtml(): string {
-        const ejsData = this.makeEjsData();
-        const html = ejs.render(this.htmlTemplate, ejsData);
-        return html;
-    }
-
-    protected makeEjsData(): EjsData {
-        const asLocalPath = (relPath: string) => {
-            if (!this.webviewPanel) {
-                return relPath;
-            }
-            const localUri = vscode.Uri.file(path.join(this.htmlRoot, relPath));
-            return localUri.fsPath;
-        };
-        const asWebViewPath = (localPath: string) => {
-            if (!this.webviewPanel) {
-                return localPath;
-            }
-            const localUri = vscode.Uri.file(path.join(this.htmlRoot, localPath));
-            const webViewUri = this.webviewPanel.webview.asWebviewUri(localUri);
-            return webViewUri.toString();
-        };
-        let overwriteCssPath = '';
-        if (this.customOverwriteCssPath) {
-            const uri = vscode.Uri.file(this.customOverwriteCssPath);
-            overwriteCssPath = this.webviewPanel?.webview.asWebviewUri(uri).toString() || '';
-        } else {
-            overwriteCssPath = asWebViewPath('styleOverwrites.css');
-        }
-        const ejsData: EjsData = {
-            overwriteStyles: this.stripStyles,
-            previewPlotLayout: this.previewPlotLayout,
-            plots: this.plots,
-            largePlot: this.plots[this.activeIndex],
-            activePlot: this.activePlot,
-            host: this.host,
-            asLocalPath: asLocalPath,
-            asWebViewPath: asWebViewPath,
-            makeCommandUri: makeWebviewCommandUriString,
-            overwriteCssPath: overwriteCssPath
-        };
-        return ejsData;
-    }
-
-    protected makeNewWebview(showOptions?: ShowOptions): vscode.WebviewPanel {
-        const webviewPanel = vscode.window.createWebviewPanel(
-            'RPlot',
-            'R Plot',
-            showOptions || this.showOptions,
-            this.webviewOptions
-        );
-        webviewPanel.iconPath = new UriIcon('graph');
-        webviewPanel.onDidDispose(() => this.webviewPanel = undefined);
-        webviewPanel.onDidChangeViewState(() => {
-            void this.setContextValues();
-        });
-        webviewPanel.webview.onDidReceiveMessage((e: OutMessage) => {
-            this.handleWebviewMessage(e);
-        });
-        return webviewPanel;
-    }
-
-    protected handleWebviewMessage(msg: OutMessage): void {
-        if (msg.message === 'log') {
-            console.log(msg.body);
-        } else if (msg.message === 'resize') {
-            const height = msg.height;
-            const width = msg.width;
-            const userTriggered = msg.userTriggered;
-            void this.handleResize(height, width, userTriggered);
-        }
-    }
-
-    protected postWebviewMessage(msg: InMessage): void {
-        void this.webviewPanel?.webview.postMessage(msg);
-    }
-
-
-    // export plot
-    // if no format supplied, show a quickpick menu etc.
-    // if no filename supplied, show selector window
-    public async exportPlot(id?: HttpgdPlotId, rendererId?: HttpgdRendererId, outFile?: string): Promise<void> {
-        // make sure id is valid or return:
-        id ||= this.activePlot || this.plots[this.plots.length - 1]?.id;
-        const plot = this.plots.find((plt) => plt.id === id);
-        if (!plot) {
-            void vscode.window.showWarningMessage('No plot available for export.');
-            return;
-        }
-        // make sure format is valid or return:
-        if (!rendererId) {
-            const renderers = this.api.getRenderers();
-            const qpItems  = renderers.map(renderer => ({
-                label: renderer.name,
-                detail: renderer.descr,
-                id: renderer.id
-            }));
-            const options: vscode.QuickPickOptions = {
-                placeHolder: 'Please choose a file format'
-            };
-            // format = await vscode.window.showQuickPick(formats, options);
-            const qpPick = await vscode.window.showQuickPick(qpItems, options);
-            rendererId = qpPick?.id;
-            if(!rendererId){
-                return;
-            }
-        }
-        // make sure outFile is valid or return:
-        if (!outFile) {
-            const options: vscode.SaveDialogOptions = {};
-
-            // Suggest a file extension:
-            const renderer = this.api.getRenderers().find(r => r.id === rendererId);
-            const ext = renderer?.ext.replace(/^\./, '');
-
-            // try to set default URI:
-            if(this.lastExportUri){
-                const noExtPath = this.lastExportUri.fsPath.replace(/\.[^.]*$/, '');
-                const defaultPath = noExtPath + (ext ? `.${ext}` : '');
-                options.defaultUri = vscode.Uri.file(defaultPath);
-            } else {
-                // construct default Uri
-                const defaultFolder = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
-                if(defaultFolder){
-                    const defaultName = 'plot' + (ext ? `.${ext}` : '');
-                    options.defaultUri = vscode.Uri.file(path.join(defaultFolder, defaultName));
-                }
-            }
-            // set file extension filter
-            if(ext && renderer?.name){
-                options.filters = {
-                    [renderer.name]: [ext],
-                    ['All']: ['*'],
-                };
-            }
-
-            const outUri = await vscode.window.showSaveDialog(options);
-            if(outUri){
-                this.lastExportUri = outUri;
-                outFile = outUri.fsPath;
-            } else {
-                return;
-            }
-        }
-        // get plot:
-        const plt = await this.api.getPlot({
-            id: this.activePlot,
-            renderer: rendererId
-        }) as unknown as Response; // I am not sure why eslint thinks this is the
-        // browser Response object and not the node-fetch one.
-        // cross-fetch problem or config problem in vscode-r?
-
-        const dest = fs.createWriteStream(outFile);
-        dest.on('error', (err) => void vscode.window.showErrorMessage(
-            `Export failed: ${err.message}`
-        ));
-        dest.on('close', () => void vscode.window.showInformationMessage(
-            `Export done: ${outFile || ''}`
-        ));
-        void plt.body.pipe(dest);
-    }
-
-    // Dispose-function to clean up when vscode closes
-    // E.g. to close connections etc., notify R, ...
-    public dispose(): void {
-        this.api.disconnect();
     }
 }
 
-// helper function to handle argument lists that might contain (useless) extra arguments
-function findItemOfType(arr: any[], type: 'string'): string | undefined;
-function findItemOfType(arr: any[], type: 'boolean'): boolean | undefined;
-function findItemOfType(arr: any[], type: 'number'): number | undefined;
-function findItemOfType<T = unknown>(arr: any[], type: string): T {
-    const item = arr.find((elm) => typeof elm === type) as T;
-    return item;
+export function initializePlotManager(): PlotManager {
+    const manager = new CommonPlotManager();
+    manager.initialize();
+    return manager;
 }
diff --git a/src/plotViewer/standardViewer.ts b/src/plotViewer/standardViewer.ts
index b01b1e8e..ec81a24e 100644
--- a/src/plotViewer/standardViewer.ts
+++ b/src/plotViewer/standardViewer.ts
@@ -2,8 +2,10 @@
 import * as vscode from 'vscode';
 import { asViewColumn, config, UriIcon } from '../util';
 import { sessionRequest, server } from '../session';
+import { PlotViewer } from './types';
 
-export class StandardPlotViewer {
+export class StandardPlotViewer implements PlotViewer {
+    readonly id: string = 'standard';
     private panel: vscode.WebviewPanel | undefined;
     private viewWidth: number = 800;
     private viewHeight: number = 600;
@@ -20,6 +22,23 @@ export class StandardPlotViewer {
         }
     }
 
+    public show(preserveFocus?: boolean): void {
+        if (this.panel) {
+            this.panel.reveal(undefined, preserveFocus);
+        }
+    }
+
+    public handleCommand(command: string): void {
+        if (command === 'showViewers') {
+            this.show();
+        }
+        // Other commands are not supported by the standard viewer
+    }
+
+    public dispose(): void {
+        this.panel?.dispose();
+    }
+
     private createPanel(viewColumn: vscode.ViewColumn) {
         this.panel = vscode.window.createWebviewPanel(
             'r.standardPlot',
@@ -55,7 +74,7 @@ export class StandardPlotViewer {
             return;
         }
 
-        const format = config().get<string>('plot.format', 'png');
+        const format = config().get<string>('plot.format', 'svglite');
         const response = await sessionRequest(server, {
             method: 'plot_latest',
             params: {
diff --git a/src/plotViewer/types.ts b/src/plotViewer/types.ts
new file mode 100644
index 00000000..9368380b
--- /dev/null
+++ b/src/plotViewer/types.ts
@@ -0,0 +1,17 @@
+
+import * as vscode from 'vscode';
+
+export interface PlotViewer {
+    readonly id: string;
+    show(preserveFocus?: boolean): void;
+    dispose(): void;
+    handleCommand(command: string, ...args: any[]): void | Promise<void>;
+}
+
+export interface PlotManager {
+    viewers: PlotViewer[];
+    activeViewer: PlotViewer | undefined;
+    initialize(): void;
+    showStandardPlot(): Promise<void>;
+    showHttpgdPlot(url: string): Promise<void>;
+}
diff --git a/src/session.ts b/src/session.ts
index b3fe88d9..d9a89c49 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -9,13 +9,10 @@ import { restartRTerminal, createRTerm } from './rTerminal';
 import { config, readContent, setContext, UriIcon } from './util';
 import { purgeAddinPickerItems } from './rstudioapi';
 
-import { homeExtDir, rWorkspace, globalRHelp, globalHttpgdManager, extensionContext, sessionStatusBarItem } from './extension';
+import { homeExtDir, rWorkspace, globalRHelp, globalPlotManager, extensionContext, sessionStatusBarItem } from './extension';
 import { rHostService, rGuestService, isLiveShare, isHost, isGuestSession, guestResDir, shareBrowser, openVirtualDoc } from './liveShare';
 
 import WebSocket from 'ws';
-import { StandardPlotViewer } from './plotViewer/standardViewer';
-
-const standardPlotViewer = new StandardPlotViewer();
 
 export interface SessionInfo {
     version: string;
@@ -322,7 +319,7 @@ function writeSettings() {
 
 async function updatePlot() {
     if (!server) {return;}
-    await standardPlotViewer.update();
+    await globalPlotManager?.showStandardPlot();
 }
 
 export async function updateWorkspace() {
@@ -844,7 +841,7 @@ async function handleNotification(message: Record<string, unknown>, ws: ExtWebSo
             console.info(`[startSessionWatcher] attach R PID: ${rPid}, terminal PID: ${terminalPid}`);
             purgeAddinPickerItems();
             if (params.plot_url) {
-                await globalHttpgdManager?.showViewer(String(params.plot_url));
+                await globalPlotManager?.showHttpgdPlot(String(params.plot_url));
             }
             void updateWorkspace(); // Initial workspace fetch
             void watchProcess(rPid).then((v: string) => { void cleanupSession(v); });
@@ -869,7 +866,7 @@ async function handleNotification(message: Record<string, unknown>, ws: ExtWebSo
         }
         case 'httpgd': {
             if (params.url) {
-                await globalHttpgdManager?.showViewer(String(params.url));
+                await globalPlotManager?.showHttpgdPlot(String(params.url));
             }
             break;
         }

From 5edd73a770ba6cfd6bd81a8724431b3ce449f5e7 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Sat, 14 Mar 2026 12:47:42 -0700
Subject: [PATCH 43/47] refactor: deprecate vsc.* R options in favor of sess
 system

---
 .gitignore                       |   3 -
 R/session/init.R                 | 104 ----
 R/session/profile.R              |  33 --
 R/session/rstudioapi.R           | 315 -----------
 R/session/rstudioapi_util.R      | 273 ---------
 R/session/vsc.R                  | 941 -------------------------------
 package.json                     |  38 +-
 sess/R/handlers.R                |  17 +-
 sess/R/hooks.R                   |   2 +-
 session.md                       | 650 ---------------------
 src/plotViewer/standardViewer.ts |   4 +-
 11 files changed, 37 insertions(+), 2343 deletions(-)
 delete mode 100644 R/session/init.R
 delete mode 100644 R/session/profile.R
 delete mode 100644 R/session/rstudioapi.R
 delete mode 100644 R/session/rstudioapi_util.R
 delete mode 100644 R/session/vsc.R
 delete mode 100644 session.md

diff --git a/.gitignore b/.gitignore
index 0841696a..b9ae4d20 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,9 +7,6 @@ node_modules
 *.vsix
 dist
 .vscode-test
-
-html/**/*.js
-
 *.temp
 *.tmp
 tmp.*
diff --git a/R/session/init.R b/R/session/init.R
deleted file mode 100644
index 410263c2..00000000
--- a/R/session/init.R
+++ /dev/null
@@ -1,104 +0,0 @@
-# This file is executed with its containing directory as wd
-
-# Remember the working directory (should be extension subfolder that contains this script)
-dir_init <- getwd()
-
-
-# This function is run at the beginning of R's startup sequence
-# Code that is meant to be run at the end of the startup should go in `init_last`
-init_first <- function() {
-    # return early if not a vscode term session
-    if (
-        !interactive()
-        || Sys.getenv("RSTUDIO") != ""
-        || Sys.getenv("TERM_PROGRAM") != "vscode"
-    ) {
-        return()
-    }
-
-    # check required packages
-    required_packages <- c("jsonlite", "rlang")
-    missing_packages <- required_packages[
-        !vapply(required_packages, requireNamespace,
-            logical(1L), quietly = TRUE
-        )
-    ]
-
-    if (length(missing_packages)) {
-        message(
-            "VSCode R Session Watcher requires ",
-            toString(missing_packages), ". ",
-            "Please install manually in order to use VSCode-R."
-        )
-    } else {
-        # Initialize vsc utils after loading other default packages
-        assign(".First.sys", init_last, envir = globalenv())
-    }
-}
-
-old.First.sys <- .First.sys
-
-# Overwrite for `.First.sys`
-# Is used to make sure that all default packages are loaded first
-# Will be assigned to and called from the global environment,
-# Will be run with wd being the user's working directory (!)
-init_last <- function() {
-    old.First.sys()
-
-    # cleanup previous version
-    removeTaskCallback("vscode-R")
-    options(vscodeR = NULL)
-    .vsc.name <- "tools:vscode"
-    if (.vsc.name %in% search()) {
-        detach(.vsc.name, character.only = TRUE)
-    }
-
-    # Source vsc utils in new environmeent
-    .vsc <- new.env()
-    source(file.path(dir_init, "vsc.R"), local = .vsc)
-
-    # attach functions that are meant to be called by the user/vscode
-    exports <- local({
-        .vsc <- .vsc
-        .vsc.attach <- .vsc$attach
-        .vsc.view <- .vsc$show_dataview
-        .vsc.browser <- .vsc$show_browser
-        .vsc.viewer <- .vsc$show_viewer
-        .vsc.page_viewer <- .vsc$show_page_viewer
-        View <- .vsc.view
-        environment()
-    })
-    attach(exports, name = .vsc.name, warn.conflicts = FALSE)
-
-    # overwrite S3 bindings from other packages
-    suppressWarnings({
-        if (!identical(getOption("vsc.helpPanel", "Two"), FALSE)) {
-            # Overwrite print function for results of `?`
-            .vsc$.S3method(
-                "print",
-                "help_files_with_topic",
-                .vsc$print.help_files_with_topic
-            )
-            # Overwrite print function for results of `??`
-            .vsc$.S3method(
-                "print",
-                "hsearch",
-                .vsc$print.hsearch
-            )
-        }
-        # Further S3 overwrites can go here
-        # ...
-    })
-
-    # remove this function from globalenv()
-    suppressWarnings(
-        rm(".First.sys", envir = globalenv())
-    )
-
-    # Attach to vscode
-    exports$.vsc.attach()
-
-    invisible()
-}
-
-init_first()
diff --git a/R/session/profile.R b/R/session/profile.R
deleted file mode 100644
index dafdf298..00000000
--- a/R/session/profile.R
+++ /dev/null
@@ -1,33 +0,0 @@
-# Source the original .Rprofile
-local({
-    try_source <- function(file) {
-        if (file.exists(file)) {
-            source(file)
-            TRUE
-        } else {
-            FALSE
-        }
-    }
-
-    r_profile <- Sys.getenv("R_PROFILE_USER_OLD")
-    Sys.setenv(
-        R_PROFILE_USER_OLD = "",
-        R_PROFILE_USER = r_profile
-    )
-
-    if (nzchar(r_profile)) {
-        try_source(r_profile)
-    } else {
-        try_source(".Rprofile") || try_source(file.path("~", ".Rprofile"))
-    }
-
-    invisible()
-})
-
-# Run vscode initializer
-local({
-    init_file <- Sys.getenv("VSCODE_INIT_R")
-    if (nzchar(init_file)) {
-        source(init_file, chdir = TRUE, local = TRUE)
-    }
-})
diff --git a/R/session/rstudioapi.R b/R/session/rstudioapi.R
deleted file mode 100644
index 60ea4358..00000000
--- a/R/session/rstudioapi.R
+++ /dev/null
@@ -1,315 +0,0 @@
-getActiveDocumentContext <- function() {
-    # In RStudio this returns either a document context for either the active
-    # source editor or active console.
-    # In VSCode this only ever returns the active (or last active) text editor.
-    # This is because it is currently not possible to tell in VSCode whether
-    # a text editor or terminal has focus. The concept of active is different.
-    # It means currently using or most recently used, and applies to text
-    # editors and terminals separately.
-    # This shoudln't be much of a limitation as the only context returned for
-    # the console was the current selection, so it is not very useful.
-    editor_context <- rstudioapi_call("active_editor_context")
-
-    make_rs_document_context(editor_context)
-}
-
-getSourceEditorContext <- getActiveDocumentContext
-
-verifyAvailable <- function(version_needed = NULL) {
-    if (is.null(version_needed)) TRUE else FALSE
-}
-
-isAvailable <- function(version_needed = NULL, child_ok) {
-    verifyAvailable(version_needed)
-}
-
-insertText <- function(location, text, id = NULL) {
-
-    ## insertText also supports insertText("text"), insertText(text = "text"),
-    ## allowing the location parameter to be used for the text when
-    ## text itself is null.
-    ## This is dispatched as a separate request type
-    if (missing(text) && is.character(location) && length(location) == 1) {
-        ## handling insertText("text")
-        return(invisible(
-            rstudioapi_call("replace_text_in_current_selection",
-                text = location,
-                id = id
-            )
-        ))
-    } else if (missing(location)) {
-        ## handling insertText(text = "text")
-        return(invisible(rstudioapi_call(
-            "replace_text_in_current_selection",
-            text = text,
-            id = id
-        )))
-    } else if (is.null(location) && missing(text)) {
-        ## handling insertText(NULL)
-        return(invisible(NULL))
-    }
-
-    ## ensure normalised_location is a list containing a possible mix of
-    ## document_position and document_range objects
-    normalised_location <- normalise_pos_or_range_arg(location)
-    normalised_text <- normalise_text_arg(text, length(normalised_location))
-    ## Having normalised we are guaranteed these are the same length.
-    ## Package up all the edits in a query to send to VSCode in an object
-    ## This is done so the edits can be applied in a single edit object, which
-    ## is hopefull closest to RStudio behaviour.
-    query <-
-        mapply(function(location, text) {
-            list(
-                operation = if (rstudioapi::is.document_range(location)) {
-                    "modifyRange"
-                } else {
-                    "insertText"
-                },
-                location = location,
-                text = text
-            )
-        },
-        normalised_location,
-        normalised_text,
-        SIMPLIFY = FALSE
-        )
-
-    invisible(
-        rstudioapi_call("insert_or_modify_text", query = query, id = id)
-    )
-}
-
-modifyRange <- insertText
-
-readPreference <- function(name, default) {
-    ## in future we could map some rstudio preferences to vscode settings.
-    ## since the caller must provide a default this should work.
-    default
-}
-
-readRStudioPreference <- readPreference
-
-.vsc_rstudioapi_env <- environment()
-
-hasFun <- function(name, version_needed = NULL, ...) {
-    if (!is.null(version_needed)) {
-        return(FALSE)
-    }
-
-    obj <- .vsc_rstudioapi_env[[name]]
-    is.function(obj) && !identical(obj, .vsc_not_yet_implemented)
-}
-
-findFun <- function(name, version_needed = NULL, ...) {
-    if (!is.null(version_needed)) {
-        stop("VSCode does not support used of 'version_needed'.")
-    }
-
-    if (hasFun(name, version_needed = version_needed, ...)) {
-        .vsc_rstudioapi_env[[name]]
-    } else {
-        stop("Cannot find function '", name, "'")
-    }
-}
-
-showDialog <- function(title, message, url = "") {
-    message <- sprintf("%s: %s \n%s", title, message, url)
-    invisible(
-        rstudioapi_call("show_dialog", message = message)
-    )
-}
-
-navigateToFile <- function(file, line = -1L, column = -1L) {
-    # normalise path since relative paths don't work as URIs in VSC
-    invisible(
-        rstudioapi_call(
-            "navigate_to_file",
-            file = normalizePath(file),
-            line = line,
-            column = column
-        )
-    )
-}
-
-setSelectionRanges <- function(ranges, id = NULL) {
-    ranges_or_positions <- normalise_pos_or_range_arg(ranges)
-
-    ranges <- lapply(ranges_or_positions, function(location) {
-        if (rstudioapi::is.document_position(location)) {
-            rstudioapi::document_range(location, location)
-        } else {
-            location
-        }
-    })
-
-    invisible(
-        rstudioapi_call("set_selection_ranges", ranges = ranges, id = id)
-    )
-}
-
-setCursorPosition <- setSelectionRanges
-
-documentSave <- function(id = NULL) {
-    invisible(
-        rstudioapi_call("document_save", id = id)
-    )
-}
-
-getActiveProject <- function() {
-    path_object <- rstudioapi_call("get_project_path")
-    if (is.null(path_object$path)) {
-        stop(
-            "No folder for active document. ",
-            "Is it unsaved? Try saving and run addin again."
-        )
-    }
-    path_object$path
-}
-
-.vsc_document_context <- function(id = NULL) {
-    doc_context <- rstudioapi_call("document_context", id = id)
-    doc_context
-}
-
-documentId <- function(allowConsole = TRUE) document_context()$id$external
-
-documentPath <- function(id = NULL) document_context(id)$id$path
-
-documentSaveAll <- function() {
-    invisible(
-        rstudioapi_call("document_save_all")
-    )
-}
-
-documentNew <- function(text,
-                        type = c("r", "rmarkdown", "sql"),
-                        position = rstudioapi::document_position(0, 0),
-                        execute = FALSE) {
-    if (!rstudioapi::is.document_position((position))) {
-        stop("DocumentNew requires a document_position object")
-    }
-    if (length(text) != 1 || !is.character(text)) {
-        stop("text for DocumentNew must be a length one character vector.")
-    }
-    if (execute) {
-        message(
-            "VSCode {rstudioapi} emulation does not support ",
-            " executing documents upon creation"
-        )
-    }
-
-    invisible(
-        rstudioapi_call(
-            "document_new",
-            text = text,
-            type = type,
-            position = position
-        )
-    )
-}
-
-setDocumentContents <- function(text, id = NULL) {
-    whole_document_range <-
-        rstudioapi::document_range(
-            rstudioapi::document_position(0, 0),
-            rstudioapi::document_position(Inf, Inf)
-        )
-    insertText(whole_document_range, text, id)
-}
-
-restartSession <- function() {
-    invisible(
-        rstudioapi_call("restart_r")
-    )
-}
-
-viewer <- function(url, height = NULL) {
-    # cant bind to this directly because it's not created when the binding is
-    # made.
-    .vsc.viewer(url)
-}
-
-getVersion <- function() {
-    numeric_version("0")
-}
-
-versionInfo <- function() {
-    list(
-        citation = "",
-        mode = "vscode",
-        version = numeric_version("0"),
-        release_name = "vscode"
-    )
-}
-
-sendToConsole <- function(code, execute = TRUE, echo = TRUE, focus = FALSE) {
-    if (!echo) {
-        stop("rstudioapi::sendToConsole only supports echo = TRUE in VSCode.")
-    }
-
-    code_to_run <- paste0(code, collapse = "\n")
-    invisible(
-        rstudioapi_call("send_to_console", code = code_to_run, execute = execute, focus = focus)
-    )
-}
-
-
-# Unimplemented API calls that will error if called.
-
-.vsc_not_yet_implemented <- function(...) {
-    stop("This {rstudioapi} function is not currently implemented for VSCode.")
-}
-
-
-getConsoleEditorContext <- .vsc_not_yet_implemented
-sourceMarkers <- .vsc_not_yet_implemented
-documentClose <- .vsc_not_yet_implemented
-showPrompt <- .vsc_not_yet_implemented
-showQuestion <- .vsc_not_yet_implemented
-updateDialog <- .vsc_not_yet_implemented
-openProject <- .vsc_not_yet_implemented
-initializeProject <- .vsc_not_yet_implemented
-addTheme <- .vsc_not_yet_implemented
-applyTheme <- .vsc_not_yet_implemented
-convertTheme <- .vsc_not_yet_implemented
-getThemeInfo <- .vsc_not_yet_implemented
-getThemes <- .vsc_not_yet_implemented
-removeTheme <- .vsc_not_yet_implemented
-jobAdd <- .vsc_not_yet_implemented
-jobAddOutput <- .vsc_not_yet_implemented
-jobAddProgress <- .vsc_not_yet_implemented
-jobRemove <- .vsc_not_yet_implemented
-jobRunScript <- .vsc_not_yet_implemented
-jobSetProgress <- .vsc_not_yet_implemented
-jobSetState <- .vsc_not_yet_implemented
-jobSetStatus <- .vsc_not_yet_implemented
-launcherGetInfo <- .vsc_not_yet_implemented
-launcherAvailable <- .vsc_not_yet_implemented
-launcherGetJobs <- .vsc_not_yet_implemented
-launcherConfig <- .vsc_not_yet_implemented
-launcherContainer <- .vsc_not_yet_implemented
-launcherControlJob <- .vsc_not_yet_implemented
-launcherGetJob <- .vsc_not_yet_implemented
-launcherHostMount <- .vsc_not_yet_implemented
-launcherNfsMount <- .vsc_not_yet_implemented
-launcherPlacementConstraint <- .vsc_not_yet_implemented
-launcherResourceLimit <- .vsc_not_yet_implemented
-launcherSubmitJob <- .vsc_not_yet_implemented
-launcherSubmitR <- .vsc_not_yet_implemented
-previewRd <- .vsc_not_yet_implemented
-previewSql <- .vsc_not_yet_implemented
-writePreference <- .vsc_not_yet_implemented
-writeRStudioPreference <- .vsc_not_yet_implemented
-getPersistentValue <- .vsc_not_yet_implemented
-setPersistentValue <- .vsc_not_yet_implemented
-savePlotAsImage <- .vsc_not_yet_implemented
-createProjectTemplate <- .vsc_not_yet_implemented
-hasColourConsole <- .vsc_not_yet_implemented
-bugReport <- .vsc_not_yet_implemented
-buildToolsCheck <- .vsc_not_yet_implemented
-buildToolsInstall <- .vsc_not_yet_implemented
-buildToolsExec <- .vsc_not_yet_implemented
-dictionariesPath <- .vsc_not_yet_implemented
-userDictionariesPath <- .vsc_not_yet_implemented
-executeCommand <- .vsc_not_yet_implemented
-translateLocalUrl <- .vsc_not_yet_implemented
diff --git a/R/session/rstudioapi_util.R b/R/session/rstudioapi_util.R
deleted file mode 100644
index c7b767d0..00000000
--- a/R/session/rstudioapi_util.R
+++ /dev/null
@@ -1,273 +0,0 @@
-rstudioapi_call <- function(action, ...) {
-    request_response("rstudioapi", action = action, args = list(...))
-}
-
-rstudioapi_patch_hook <- function(api_env) {
-    patch_rstudioapi_fn <-
-        function(old, new) {
-            if (namespace_has(old, "rstudioapi")) {
-                assignInNamespace(
-                    x = old,
-                    value = new,
-                    ns = "rstudioapi"
-                )
-            }
-        }
-    ## make assignments to functions found in api_env namespace
-    ## that have function with the same name in {rstudioapi} namespace
-    api_list <- as.list(api_env)
-    mapply(
-        patch_rstudioapi_fn,
-        names(api_list),
-        api_list
-    )
-}
-
-make_rs_range <- function(vsc_selection) {
-    if (is.null(vsc_selection$start$line) && !is.null(vsc_selection[["start.line"]])) {
-        start_line <- vsc_selection[["start.line"]]
-        start_character <- vsc_selection[["start.character"]]
-        end_line <- vsc_selection[["end.line"]]
-        end_character <- vsc_selection[["end.character"]]
-    } else {
-        start_line <- vsc_selection$start$line
-        start_character <- vsc_selection$start$character
-        end_line <- vsc_selection$end$line
-        end_character <- vsc_selection$end$character
-    }
-    rstudioapi::document_range(
-        start = rstudioapi::document_position(
-            row = start_line,
-            column = start_character
-        ),
-        end = rstudioapi::document_position(
-            row = end_line,
-            column = end_character
-        )
-    )
-}
-
-extract_document_ranges <- function(vsc_selections) {
-    if (is.data.frame(vsc_selections)) {
-        lapply(seq_len(nrow(vsc_selections)), function(i) {
-            make_rs_range(as.list(vsc_selections[i, , drop = FALSE]))
-        })
-    } else {
-        lapply(vsc_selections, make_rs_range)
-    }
-}
-
-to_content_lines <- function(contents, ranges) {
-    content_lines <- strsplit(contents, "\n|\r\n|\r$")[[1]]
-
-
-    # edge case handling: The cursor is at the start of a new empty line,
-    # and that line is the final line.
-    range_end_row <- unlist(lapply(ranges, function(range) range$end["row"]))
-    last_row <- max(range_end_row)
-    if (last_row == length(content_lines) + 1) {
-        content_lines <- c(content_lines, "")
-    }
-
-    content_lines
-}
-
-
-extract_range_text <- function(range, content_lines) {
-    if (!range_has_text(range)) {
-        return("")
-    }
-
-    content_rows <-
-        content_lines[(range$start["row"]):(range$end["row"])]
-    content_rows[length(content_rows)] <-
-        substring(
-            content_rows[length(content_rows)],
-            1,
-            range$end["column"] - 1
-            # it's a minus 1 here because the selection end point is the number
-            # of the first unselected column. I.e. range 1 - 2 is all of
-            # columns >= 1 and < 2, which is column 1.
-        )
-    content_rows[1] <-
-        substring(
-            content_rows[1],
-            range$start["column"]
-        )
-
-    paste0(content_rows, collapse = "\n")
-}
-
-range_has_text <- function(range) {
-    (range$end["row"] - range$start["row"]) +
-        (range$end["column"] - range$start["column"]) > 0
-}
-
-make_rs_document_selection <- function(ranges, range_texts) {
-    selection_data <-
-        mapply(
-            function(range, text) {
-                list(
-                    range = range,
-                    text = text
-                )
-            },
-            ranges,
-            range_texts,
-            SIMPLIFY = FALSE
-        )
-    structure(selection_data,
-        class = "document_selection"
-    )
-}
-
-make_rs_document_context <-
-    function(vsc_editor_context) {
-        document_ranges <-
-            extract_document_ranges(vsc_editor_context$selection)
-        content_lines <-
-            to_content_lines(vsc_editor_context$contents, document_ranges)
-        document_range_texts <-
-            lapply(
-                document_ranges,
-                extract_range_text,
-                content_lines
-            )
-        document_selection <-
-            make_rs_document_selection(
-                document_ranges,
-                document_range_texts
-            )
-
-        structure(list(
-            id = vsc_editor_context$id$external,
-            path = vsc_editor_context$path,
-            contents = content_lines,
-            selections = document_selection
-        ),
-        class = "document_context"
-        )
-    }
-
-is_positionable <- function(p) is.numeric(p) && length(p) == 2
-
-is_rangable <- function(r) is.numeric(r) && length(r) == 4
-
-normalise_pos_or_range_arg <- function(location) {
-    # This is necessary due to the loose constraints of the location argument
-    # in rstudioapi::insertText and rstudioapi::modifyRange. These
-    # functions can take single vectors coerable to postition or range OR a
-    # list where each element may be a location, range, or a vector coercable
-    # to such. I prefer to normalise the argument to a list of either formal
-    # positions or ranges.
-    if (rstudioapi::is.document_position(location)) {
-        list(location)
-    } else if (is_positionable(location)) {
-        list(rstudioapi::as.document_position(location))
-    } else if (rstudioapi::is.document_range(location)) {
-        list(location)
-    } else if (is_rangable(location)) {
-        list(rstudioapi::as.document_range(location))
-    } else if (is.list(location)) {
-        lapply(
-            location,
-            function(a_location) {
-                if (rstudioapi::is.document_position(a_location) || rstudioapi::is.document_range(a_location)) {
-                    a_location
-                } else if (is_positionable(a_location)) {
-                    rstudioapi::as.document_position(a_location)
-                } else if (is_rangable((a_location))) {
-                    rstudioapi::as.document_range(a_location)
-                } else {
-                    stop(
-                        "object in location list was not a",
-                        " document_position or document_range"
-                    )
-                }
-            }
-        )
-    } else {
-        stop("location object was not a document_position or document_range")
-    }
-}
-
-normalise_text_arg <- function(text, location_length) {
-    if (length(text) == location_length) {
-        text
-    } else if (length(text) == 1 && location_length > 1) {
-        rep(text, location_length)
-    } else {
-        stop(
-            "text vector needs to be of length 1 or",
-            " the same length as location list"
-        )
-    }
-}
-
-update_addin_registry <- function(addin_registry) {
-    pkgs <- .packages(all.available = TRUE)
-    addin_files <- vapply(pkgs, function(pkg) {
-        system.file("rstudio/addins.dcf", package = pkg)
-    }, character(1L))
-    addin_files <- addin_files[file.exists(addin_files)]
-    addin_descriptions <-
-        mapply(
-            function(package, package_dcf) {
-                addin_description_names <-
-                    c(
-                        "name",
-                        "description",
-                        "binding",
-                        "interactive",
-                        "package"
-                    )
-                description_result <-
-                    tryCatch({
-                        addin_description <-
-                            as.data.frame(read.dcf(package_dcf),
-                                stringsAsFactors = FALSE
-                            )
-
-                        if (ncol(addin_description) < 4) {
-                            NULL
-                        }
-                        ## if less than 4 columns it's malformed
-                        ## a NULL will be ignored in the rbind
-
-                        addin_description$package <- package
-                        names(addin_description) <- addin_description_names
-
-                        addin_description[, addin_description_names]
-                        ## this filters out any extra columns
-                    },
-                    error = function(cond) {
-                        message(
-                            "addins.dcf file for ", package,
-                            " could not be read from R library. ",
-                            "The RStudio addin picker will not ",
-                            "contain it's addins"
-                        )
-
-                        NULL
-                    }
-                    )
-
-                description_result
-            },
-            names(addin_files),
-            addin_files,
-            SIMPLIFY = FALSE
-        )
-    addin_descriptions_flat <-
-        do.call(
-            function(...) rbind(..., make.row.names = FALSE),
-            addin_descriptions
-        )
-
-    jsonlite::write_json(addin_descriptions_flat, addin_registry, pretty = TRUE)
-}
-
-namespace_has <- function(obj, namespace) {
-    attempt <- try(getFromNamespace(obj, namespace), silent = TRUE)
-    !inherits(attempt, "try-error")
-}
diff --git a/R/session/vsc.R b/R/session/vsc.R
deleted file mode 100644
index 5ab46139..00000000
--- a/R/session/vsc.R
+++ /dev/null
@@ -1,941 +0,0 @@
-pid <- Sys.getpid()
-wd <- getwd()
-tempdir <- tempdir()
-homedir <- Sys.getenv(
-    if (.Platform$OS.type == "windows") "USERPROFILE" else "HOME"
-)
-dir_watcher <- Sys.getenv("VSCODE_WATCHER_DIR", file.path(homedir, ".vscode-R"))
-request_file <- file.path(dir_watcher, "request.log")
-request_lock_file <- file.path(dir_watcher, "request.lock")
-settings_file <- file.path(dir_watcher, "settings.json")
-user_options <- names(options())
-
-logger <- if (getOption("vsc.debug", FALSE)) {
-    function(...) cat(..., "\n", sep = "")
-} else {
-    function(...) invisible()
-}
-
-load_settings <- function() {
-    if (!file.exists(settings_file)) {
-        return(FALSE)
-    }
-
-    setting <- function(x, ...) {
-        switch(EXPR = x, ..., x)
-    }
-
-    mapping <- quote(list(
-        vsc.use_webserver = session$useWebServer,
-        vsc.use_httpgd = plot$useHttpgd,
-        vsc.show_object_size = workspaceViewer$showObjectSize,
-        vsc.rstudioapi = session$emulateRStudioAPI,
-        vsc.str.max.level = setting(session$levelOfObjectDetail, Minimal = 0, Normal = 1, Detailed = 2),
-        vsc.object_length_limit = session$objectLengthLimit,
-        vsc.object_timeout = session$objectTimeout,
-        vsc.globalenv = session$watchGlobalEnvironment,
-        vsc.plot = setting(session$viewers$viewColumn$plot, Disable = FALSE),
-        vsc.dev.args = plot$devArgs,
-        vsc.browser = setting(session$viewers$viewColumn$browser, Disable = FALSE),
-        vsc.viewer = setting(session$viewers$viewColumn$viewer, Disable = FALSE),
-        vsc.page_viewer = setting(session$viewers$viewColumn$pageViewer, Disable = FALSE),
-        vsc.row_limit = session$data$rowLimit,
-        vsc.view = setting(session$viewers$viewColumn$view, Disable = FALSE),
-        vsc.helpPanel = setting(session$viewers$viewColumn$helpPanel, Disable = FALSE)
-    ))
-
-    vsc_settings <- tryCatch(jsonlite::read_json(settings_file), error = function(e) {
-        message("Error occurs when reading VS Code settings: ", conditionMessage(e))
-    })
-
-    if (is.null(vsc_settings)) {
-        return(FALSE)
-    }
-
-    ops <- eval(mapping, vsc_settings)
-
-    # exclude options set by user on startup
-    r_options <- ops[!(names(ops) %in% user_options)]
-
-    options(r_options)
-}
-
-load_settings()
-
-if (is.null(getOption("help_type"))) {
-    options(help_type = "html")
-}
-
-use_webserver <- isTRUE(getOption("vsc.use_webserver", FALSE))
-if (use_webserver) {
-    if (requireNamespace("httpuv", quietly = TRUE)) {
-        request_handlers <- list(
-            hover = function(expr, ...) {
-                tryCatch({
-                    expr <- parse(text = expr, keep.source = FALSE)[[1]]
-                    obj <- eval(expr, .GlobalEnv)
-                    list(str = capture_str(obj))
-                }, error = function(e) NULL)
-            },
-
-            complete = function(expr, trigger, ...) {
-                obj <- tryCatch({
-                    expr <- parse(text = expr, keep.source = FALSE)[[1]]
-                    eval(expr, .GlobalEnv)
-                }, error = function(e) NULL)
-
-                if (is.null(obj)) {
-                    return(NULL)
-                }
-
-                if (trigger == "$") {
-                    names <- if (is.object(obj)) {
-                        .DollarNames(obj, pattern = "")
-                    } else if (is.recursive(obj)) {
-                        names(obj)
-                    } else {
-                        NULL
-                    }
-
-                    result <- lapply(names, function(name) {
-                        item <- obj[[name]]
-                        list(
-                            name = name,
-                            type = typeof(item),
-                            str = try_capture_str(item)
-                        )
-                    })
-                    return(result)
-                }
-
-                if (trigger == "@" && isS4(obj)) {
-                    names <- slotNames(obj)
-                    result <- lapply(names, function(name) {
-                        item <- slot(obj, name)
-                        list(
-                            name = name,
-                            type = typeof(item),
-                            str = try_capture_str(item)
-                        )
-                    })
-                    return(result)
-                }
-            }
-        )
-
-        server <- getOption("vsc.server")
-        if (!is.null(server) && server$isRunning()) {
-            host <- server$getHost()
-            port <- server$getPort()
-            token <- attr(server, "token")
-        } else {
-            host <- "127.0.0.1"
-            port <- httpuv::randomPort()
-            token <- sprintf("%d:%d:%.6f", pid, port, Sys.time())
-            server <- httpuv::startServer(host, port,
-                list(
-                    onHeaders = function(req) {
-                        logger("http request ",
-                            req[["REMOTE_ADDR"]], ":",
-                            req[["REMOTE_PORT"]], " ",
-                            req[["REQUEST_METHOD"]], " ",
-                            req[["HTTP_USER_AGENT"]]
-                        )
-
-                        if (!nzchar(req[["REMOTE_ADDR"]]) || identical(req[["REMOTE_PORT"]], "0")) {
-                            return(NULL)
-                        }
-
-                        if (!identical(req[["HTTP_AUTHORIZATION"]], token)) {
-                            return(list(
-                                status = 401L,
-                                headers = list(
-                                    "Content-Type" = "text/plain"
-                                ),
-                                body = "Unauthorized"
-                            ))
-                        }
-
-                        if (!identical(req[["HTTP_CONTENT_TYPE"]], "application/json")) {
-                            return(list(
-                                status = 400L,
-                                headers = list(
-                                    "Content-Type" = "text/plain"
-                                ),
-                                body = "Bad request"
-                            ))
-                        }
-                    },
-                    call = function(req) {
-                        content <- req$rook.input$read_lines()
-                        request <- jsonlite::fromJSON(content, simplifyVector = FALSE)
-                        handler <- request_handlers[[request$type]]
-                        response <- if (is.function(handler)) do.call(handler, request)
-
-                        list(
-                            status = 200L,
-                            headers = list(
-                                "Content-Type" = "application/json"
-                            ),
-                            body = jsonlite::toJSON(response, auto_unbox = TRUE, force = TRUE)
-                        )
-                    }
-                )
-            )
-            attr(server, "token") <- token
-            options(vsc.server = server)
-        }
-    } else {
-        message("{httpuv} is required to use WebServer from the session watcher.")
-        use_webserver <- FALSE
-    }
-}
-
-get_timestamp <- function() {
-    sprintf("%.6f", Sys.time())
-}
-
-scalar <- function(x) {
-    class(x) <- c("scalar", class(x))
-    x
-}
-
-request <- function(command, ...) {
-    obj <- list(
-        time = Sys.time(),
-        pid = pid,
-        wd = wd,
-        command = command,
-        ...
-    )
-    jsonlite::write_json(obj, request_file,
-        auto_unbox = TRUE, null = "null", force = TRUE
-    )
-    cat(get_timestamp(), file = request_lock_file)
-}
-
-try_catch_timeout <- function(expr, timeout = Inf, ...) {
-    expr <- substitute(expr)
-    envir <- parent.frame()
-    setTimeLimit(timeout, transient = TRUE)
-    on.exit(setTimeLimit())
-    tryCatch(eval(expr, envir), ...)
-}
-
-capture_str <- function(object, max.level = getOption("vsc.str.max.level", 0)) {
-    paste0(utils::capture.output(
-        utils::str(object,
-            max.level = max.level,
-            give.attr = FALSE,
-            vec.len = 1
-        )
-    ), collapse = "\n")
-}
-
-try_capture_str <- function(object, max.level = getOption("vsc.str.max.level", 0)) {
-    tryCatch(
-        capture_str(object, max.level = max.level),
-        error = function(e) {
-            paste0(class(object), collapse = ", ")
-        }
-    )
-}
-
-rebind <- function(sym, value, ns) {
-    if (is.character(ns)) {
-        Recall(sym, value, getNamespace(ns))
-        pkg <- paste0("package:", ns)
-        if (pkg %in% search()) {
-            Recall(sym, value, as.environment(pkg))
-        }
-    } else if (is.environment(ns)) {
-        if (bindingIsLocked(sym, ns)) {
-            unlockBinding(sym, ns)
-            on.exit(lockBinding(sym, ns))
-        }
-        assign(sym, value, ns)
-    } else {
-        stop("ns must be a string or environment")
-    }
-}
-
-address <- function(x) {
-    info <- utils::capture.output(.Internal(inspect(x, 0L, 0L)))
-    sub("@([a-z0-9]+)\\s+.+", "\\1", info[[1]])
-}
-
-globalenv_cache <- new.env(parent = emptyenv())
-
-inspect_env <- function(env, cache) {
-    all_names <- ls(env)
-    rm(list = setdiff(names(globalenv_cache), all_names), envir = cache)
-    is_active <- vapply(all_names, bindingIsActive, logical(1), USE.NAMES = TRUE, env)
-    is_promise <- rlang::env_binding_are_lazy(env, all_names[!is_active])
-    show_object_size <- getOption("vsc.show_object_size", FALSE)
-    object_length_limit <- getOption("vsc.object_length_limit", 2000)
-    object_timeout <- getOption("vsc.object_timeout", 50) / 1000
-    str_max_level <- getOption("vsc.str.max.level", 0)
-    objs <- lapply(all_names, function(name) {
-        if (isTRUE(is_promise[name])) {
-            info <- list(
-                class = "promise",
-                type = scalar("promise"),
-                length = scalar(0L),
-                str = scalar("(promise)")
-            )
-        } else if (isTRUE(is_active[name])) {
-            info <- list(
-                class = "active_binding",
-                type = scalar("active_binding"),
-                length = scalar(0L),
-                str = scalar("(active-binding)")
-            )
-        } else {
-            obj <- env[[name]]
-
-            info <- list(
-                class = class(obj),
-                type = scalar(typeof(obj)),
-                length = scalar(length(obj))
-            )
-
-            if (show_object_size) {
-                addr <- address(obj)
-                cobj <- cache[[name]]
-                if (is.null(cobj) || cobj$address != addr || cobj$length != info$length) {
-                    cache[[name]] <- cobj <- list(
-                        address = addr,
-                        length = length(obj),
-                        size = unclass(object.size(obj))
-                    )
-                }
-                info$size <- scalar(cobj$size)
-            }
-
-            if (length(obj) > object_length_limit) {
-                info$str <- scalar(trimws(try_capture_str(obj, 0)))
-            } else {
-                info_str <- NULL
-                if (str_max_level > 0) {
-                    info_str <- try_catch_timeout(
-                        capture_str(obj, str_max_level),
-                        timeout = object_timeout,
-                        error = function(e) NULL
-                    )
-                }
-                if (is.null(info_str)) {
-                    info_str <- try_capture_str(obj, 0)
-                }
-                info$str <- scalar(trimws(info_str))
-                obj_names <- if (is.object(obj)) {
-                    .DollarNames(obj, pattern = "")
-                } else if (is.recursive(obj)) {
-                    names(obj)
-                } else {
-                    NULL
-                }
-
-                if (length(obj_names)) {
-                    info$names <- obj_names
-                }
-            }
-
-            if (isS4(obj)) {
-                info$slots <- slotNames(obj)
-            }
-
-            if (!is.null(dim(obj))) {
-                info$dim <- dim(obj)
-            }
-        }
-        info
-    })
-    names(objs) <- all_names
-    objs
-}
-
-dir_session <- file.path(tempdir, "vscode-R")
-dir.create(dir_session, showWarnings = FALSE, recursive = TRUE)
-
-removeTaskCallback("vsc.workspace")
-show_globalenv <- isTRUE(getOption("vsc.globalenv", TRUE))
-workspace_file <- file.path(dir_session, "workspace.json")
-workspace_lock_file <- file.path(dir_session, "workspace.lock")
-file.create(workspace_lock_file, showWarnings = FALSE)
-
-update_workspace <- function(...) {
-    tryCatch({
-        data <- list(
-            search = search()[-1],
-            loaded_namespaces = loadedNamespaces(),
-            globalenv = if (show_globalenv) inspect_env(.GlobalEnv, globalenv_cache) else NULL
-        )
-        jsonlite::write_json(data, workspace_file, force = TRUE, pretty = FALSE)
-        cat(get_timestamp(), file = workspace_lock_file)
-    }, error = message)
-    TRUE
-}
-update_workspace()
-addTaskCallback(update_workspace, name = "vsc.workspace")
-
-removeTaskCallback("vsc.plot")
-use_httpgd <- identical(getOption("vsc.use_httpgd", FALSE), TRUE)
-show_plot <- !identical(getOption("vsc.plot", "Two"), FALSE)
-if (use_httpgd && "httpgd" %in% .packages(all.available = TRUE)) {
-    options(device = function(...) {
-        httpgd::hgd(
-            silent = TRUE
-        )
-        .vsc$request("httpgd", url = httpgd::hgd_url())
-    })
-} else if (use_httpgd) {
-    message("Install package `httpgd` to use vscode-R with httpgd!")
-} else if (show_plot) {
-    plot_file <- file.path(dir_session, "plot.png")
-    plot_lock_file <- file.path(dir_session, "plot.lock")
-    file.create(plot_file, plot_lock_file, showWarnings = FALSE)
-
-    plot_updated <- FALSE
-    null_dev_id <- c(pdf = 2L)
-    null_dev_size <- c(7 + pi, 7 + pi)
-
-    check_null_dev <- function() {
-        identical(dev.cur(), null_dev_id) &&
-            identical(dev.size(), null_dev_size)
-    }
-
-    new_plot <- function() {
-        if (check_null_dev()) {
-            plot_updated <<- TRUE
-        }
-    }
-
-    options(
-        device = function(...) {
-            pdf(NULL,
-                width = null_dev_size[[1L]],
-                height = null_dev_size[[2L]],
-                bg = "white")
-            dev.control(displaylist = "enable")
-        }
-    )
-
-    update_plot <- function(...) {
-        tryCatch({
-            if (plot_updated && check_null_dev()) {
-                plot_updated <<- FALSE
-                record <- recordPlot()
-                if (length(record[[1L]])) {
-                    dev_args <- getOption("vsc.dev.args")
-                    do.call(png, c(list(filename = plot_file), dev_args))
-                    on.exit({
-                        dev.off()
-                        cat(get_timestamp(), file = plot_lock_file)
-                    })
-                    replayPlot(record)
-                }
-            }
-        }, error = message)
-        TRUE
-    }
-
-    setHook("plot.new", new_plot, "replace")
-    setHook("grid.newpage", new_plot, "replace")
-
-    rebind(".External.graphics", function(...) {
-        out <- .Primitive(".External.graphics")(...)
-        if (check_null_dev()) {
-            plot_updated <<- TRUE
-        }
-        out
-    }, "base")
-
-    update_plot()
-    addTaskCallback(update_plot, name = "vsc.plot")
-}
-
-show_view <- !identical(getOption("vsc.view", "Two"), FALSE)
-if (show_view) {
-    get_column_def <- function(name, field, value) {
-        filter <- TRUE
-        tooltip <- sprintf(
-            "%s, class: [%s], type: %s",
-            name,
-            toString(class(value)),
-            typeof(value)
-        )
-        if (is.numeric(value)) {
-            type <- "numericColumn"
-            if (is.null(attr(value, "class"))) {
-                filter <- "agNumberColumnFilter"
-            }
-        } else if (inherits(value, "Date")) {
-            type <- "dateColumn"
-            filter <- "agDateColumnFilter"
-        } else {
-            type <- "textColumn"
-            filter <- "agTextColumnFilter"
-        }
-        list(
-            headerName = name,
-            headerTooltip = tooltip,
-            field = field,
-            type = type,
-            filter = filter
-        )
-    }
-
-    dataview_table <- function(data) {
-        if (is.matrix(data)) {
-            data <- as.data.frame.matrix(data)
-        }
-
-        if (is.data.frame(data)) {
-            .nrow <- nrow(data)
-            .colnames <- colnames(data)
-            if (is.null(.colnames)) {
-                .colnames <- sprintf("V%d", seq_len(ncol(data)))
-            } else {
-                .colnames <- trimws(.colnames)
-            }
-            if (.row_names_info(data) > 0L) {
-                rownames <- rownames(data)
-                rownames(data) <- NULL
-            } else {
-                rownames <- seq_len(.nrow)
-            }
-            .colnames <- c("(row)", .colnames)
-            fields <- sprintf("x%d", seq_along(.colnames))
-            data <- c(list(" " = rownames), .subset(data))
-            names(data) <- fields
-            class(data) <- "data.frame"
-            attr(data, "row.names") <- .set_row_names(.nrow)
-            columns <- .mapply(get_column_def,
-                list(.colnames, fields, data),
-                NULL
-            )
-            list(
-                columns = columns,
-                data = data
-            )
-        } else {
-            stop("data must be a data.frame or a matrix")
-        }
-    }
-
-    show_dataview <- function(x, title, uuid = NULL,
-                              viewer = getOption("vsc.view", "Two"),
-                              row_limit = abs(getOption("vsc.row_limit", 0))) {
-        as_truncated_data <- function(.data) {
-            .nrow <- nrow(.data)
-            if (row_limit != 0 && row_limit < .nrow) {
-                title <<- sprintf("%s (limited to %d/%d)", title, row_limit, .nrow)
-                .data <- utils::head(.data, n = row_limit)
-            }
-            return(.data)
-        }
-
-        if (missing(title)) {
-            sub <- substitute(x)
-            title <- deparse(sub, nlines = 1)
-        }
-        if (inherits(x, "ArrowTabular")) {
-            x <- as_truncated_data(x)
-            x <- as.data.frame(x)
-        }
-        if (is.environment(x)) {
-            all_names <- ls(x)
-            is_active <- vapply(all_names, bindingIsActive, logical(1), USE.NAMES = TRUE, x)
-            is_promise <- rlang::env_binding_are_lazy(x, all_names[!is_active])
-            x <- lapply(all_names, function(name) {
-                if (isTRUE(is_promise[name])) {
-                    data.frame(
-                        class = "promise",
-                        type = "promise",
-                        length = 0L,
-                        size = 0L,
-                        value = "(promise)",
-                        stringsAsFactors = FALSE,
-                        check.names = FALSE
-                    )
-                } else if (isTRUE(is_active[name])) {
-                    data.frame(
-                        class = "active_binding",
-                        type = "active_binding",
-                        length = 0L,
-                        size = 0L,
-                        value = "(active-binding)",
-                        stringsAsFactors = FALSE,
-                        check.names = FALSE
-                    )
-                } else {
-                    obj <- x[[name]]
-                    data.frame(
-                        class = paste0(class(obj), collapse = ", "),
-                        type = typeof(obj),
-                        length = length(obj),
-                        size = as.integer(object.size(obj)),
-                        value = trimws(try_capture_str(obj, 0)),
-                        stringsAsFactors = FALSE,
-                        check.names = FALSE
-                    )
-                }
-            })
-            names(x) <- all_names
-            if (length(x)) {
-                x <- do.call(rbind, x)
-            } else {
-                x <- data.frame(
-                    class = character(),
-                    type = character(),
-                    length = integer(),
-                    size = integer(),
-                    value = character(),
-                    stringsAsFactors = FALSE,
-                    check.names = FALSE
-                )
-            }
-        }
-        if (is.data.frame(x) || is.matrix(x)) {
-            x <- as_truncated_data(x)
-            data <- dataview_table(x)
-            file <- tempfile(tmpdir = tempdir, fileext = ".json")
-            jsonlite::write_json(data, file, na = "string", null = "null", auto_unbox = TRUE, force = TRUE)
-            request("dataview", source = "table", type = "json",
-                title = title, file = file, viewer = viewer, uuid = uuid
-            )
-        } else if (is.list(x)) {
-            tryCatch({
-                file <- tempfile(tmpdir = tempdir, fileext = ".json")
-                jsonlite::write_json(x, file, na = "string", null = "null", auto_unbox = TRUE, force = TRUE)
-                request("dataview", source = "list", type = "json",
-                    title = title, file = file, viewer = viewer, uuid = uuid
-                )
-            }, error = function(e) {
-                file <- file.path(tempdir, paste0(make.names(title), ".txt"))
-                text <- utils::capture.output(print(x))
-                writeLines(text, file)
-                request("dataview", source = "object", type = "txt",
-                    title = title, file = file, viewer = viewer, uuid = uuid
-                )
-            })
-        } else {
-            file <- file.path(tempdir, paste0(make.names(title), ".R"))
-            if (is.primitive(x)) {
-                code <- utils::capture.output(print(x))
-            } else {
-                code <- deparse(x)
-            }
-            writeLines(code, file)
-            request("dataview", source = "object", type = "R",
-                title = title, file = file, viewer = viewer, uuid = uuid
-            )
-        }
-    }
-
-    rebind("View", show_dataview, "utils")
-}
-
-attach <- function() {
-    load_settings()
-    if (rstudioapi_enabled()) {
-        rstudioapi_util_env$update_addin_registry(addin_registry)
-    }
-    request("attach",
-        version = sprintf("%s.%s", R.version$major, R.version$minor),
-        tempdir = tempdir,
-        info = list(
-            command = commandArgs()[[1L]],
-            version = R.version.string,
-            start_time = format(file.info(tempdir)$ctime)
-        ),
-        plot_url = if (identical(names(dev.cur()), "httpgd")) httpgd::hgd_url(),
-        server = if (use_webserver) list(
-            host = host,
-            port = port,
-            token = token
-        ) else NULL
-    )
-}
-
-path_to_uri <- function(path) {
-    if (length(path) == 0) {
-        return(character())
-    }
-    path <- path.expand(path)
-    if (.Platform$OS.type == "windows") {
-        prefix <- "file:///"
-        path <- gsub("\\", "/", path, fixed = TRUE)
-    } else {
-        prefix <- "file://"
-    }
-    paste0(prefix, utils::URLencode(path))
-}
-
-request_browser <- function(url, title, ..., viewer) {
-    # Printing URL with specific port triggers
-    # auto port-forwarding under remote development
-    message("Browsing ", url)
-    request("browser", url = url, title = title, ..., viewer = viewer)
-}
-
-show_browser <- function(url, title = url, ...,
-                         viewer = getOption("vsc.browser", "Active")) {
-    proxy_uri <- Sys.getenv("VSCODE_PROXY_URI")
-    if (nzchar(proxy_uri)) {
-        is_base_path <- grepl("\\:\\d+$", url)
-        url <- sub("^https?\\://(127\\.0\\.0\\.1|localhost)(\\:)?",
-            sub("\\{\\{?port\\}\\}?/?", "", proxy_uri), url
-        )
-        if (is_base_path) {
-            url <- paste0(url, "/")
-        }
-    }
-    if (grepl("^https?\\://(127\\.0\\.0\\.1|localhost)(\\:\\d+)?", url)) {
-        request_browser(url = url, title = title, ..., viewer = viewer)
-    } else if (grepl("^https?\\://", url)) {
-        message(
-            if (nzchar(proxy_uri)) {
-                "VSCode is not running on localhost but on a remote server.\n"
-            } else {
-                "VSCode WebView only supports showing local http content.\n"
-            },
-            "Opening in external browser..."
-        )
-        request_browser(url = url, title = title, ..., viewer = FALSE)
-    } else {
-        path <- sub("^file\\://", "", url)
-        if (file.exists(path)) {
-            path <- normalizePath(path, "/", mustWork = TRUE)
-            if (grepl("\\.html?$", path, ignore.case = TRUE)) {
-                message(
-                    "VSCode WebView has restricted access to local file.\n",
-                    "Opening in external browser..."
-                )
-                request_browser(url = path_to_uri(path),
-                    title = title, ..., viewer = FALSE
-                )
-            } else {
-                request("dataview", source = "object", type = "txt",
-                    title = title, file = path, viewer = viewer
-                )
-            }
-        } else {
-            stop("File not exists")
-        }
-    }
-}
-
-show_webview <- function(url, title, ..., viewer) {
-    if (!is.character(url)) {
-        real_url <- NULL
-        temp_viewer <- function(url, ...) {
-            real_url <<- url
-        }
-        op <- options(viewer = temp_viewer, page_viewer = temp_viewer)
-        on.exit(options(op))
-        print(url)
-        if (is.character(real_url)) {
-            url <- real_url
-        } else {
-            stop("Invalid object")
-        }
-    }
-    proxy_uri <- Sys.getenv("VSCODE_PROXY_URI")
-    if (nzchar(proxy_uri)) {
-        is_base_path <- grepl("\\:\\d+$", url)
-        url <- sub("^https?\\://(127\\.0\\.0\\.1|localhost)(\\:)?",
-            sub("\\{\\{?port\\}\\}?/?", "", proxy_uri), url
-        )
-        if (is_base_path) {
-            url <- paste0(url, "/")
-        }
-    }
-    if (grepl("^https?\\://(127\\.0\\.0\\.1|localhost)(\\:\\d+)?", url)) {
-        request_browser(url = url, title = title, ..., viewer = viewer)
-    } else if (grepl("^https?\\://", url)) {
-        message(
-            if (nzchar(proxy_uri)) {
-                "VSCode is not running on localhost but on a remote server.\n"
-            } else {
-                "VSCode WebView only supports showing local http content.\n"
-            },
-            "Opening in external browser..."
-        )
-        request_browser(url = url, title = title, ..., viewer = FALSE)
-    } else if (file.exists(url)) {
-        file <- normalizePath(url, "/", mustWork = TRUE)
-        request("webview", file = file, title = title, viewer = viewer, ...)
-    } else {
-        stop("File not exists")
-    }
-}
-
-show_viewer <- function(url, title = NULL, ...,
-                        viewer = getOption("vsc.viewer", "Two")) {
-    if (is.null(title)) {
-        expr <- substitute(url)
-        if (is.character(url)) {
-            title <- "Viewer"
-        } else {
-            title <- deparse(expr, nlines = 1)
-        }
-    }
-    show_webview(url = url, title = title, ..., viewer = viewer)
-}
-
-show_page_viewer <- function(url, title = NULL, ...,
-                             viewer = getOption("vsc.page_viewer", "Active")) {
-    if (is.null(title)) {
-        expr <- substitute(url)
-        if (is.character(url)) {
-            title <- "Page Viewer"
-        } else {
-            title <- deparse(expr, nlines = 1)
-        }
-    }
-    show_webview(url = url, title = title, ..., viewer = viewer)
-}
-
-options(
-    browser = show_browser,
-    viewer = show_viewer,
-    page_viewer = show_page_viewer
-)
-
-# rstudioapi
-rstudioapi_enabled <- function() {
-    isTRUE(getOption("vsc.rstudioapi", TRUE))
-}
-
-if (rstudioapi_enabled()) {
-    response_timeout <- 5
-    response_lock_file <- file.path(dir_session, "response.lock")
-    response_file <- file.path(dir_session, "response.log")
-    file.create(response_lock_file, showWarnings = FALSE)
-    file.create(response_file, showWarnings = FALSE)
-    addin_registry <- file.path(dir_session, "addins.json")
-    # This is created in attach()
-
-    get_response_timestamp <- function() {
-        readLines(response_lock_file)
-    }
-    # initialise the reponse timestamp to empty string
-    response_time_stamp <- ""
-
-    get_response_lock <- function() {
-        lock_time_stamp <- get_response_timestamp()
-        if (isTRUE(lock_time_stamp != response_time_stamp)) {
-            response_time_stamp <<- lock_time_stamp
-            TRUE
-        } else {
-            FALSE
-        }
-    }
-
-    request_response <- function(command, ...) {
-        request(command, ..., sd = dir_session)
-        wait_start <- Sys.time()
-        while (!get_response_lock()) {
-            if ((Sys.time() - wait_start) > response_timeout) {
-                stop(
-                    "Did not receive a response from VSCode-R API within ",
-                    response_timeout, " seconds."
-                )
-            }
-            Sys.sleep(0.1)
-        }
-        jsonlite::read_json(response_file)
-    }
-
-    rstudioapi_util_env <- new.env()
-    rstudioapi_env <- new.env(parent = rstudioapi_util_env)
-    source(file.path(dir_init, "rstudioapi_util.R"), local = rstudioapi_util_env)
-    source(file.path(dir_init, "rstudioapi.R"), local = rstudioapi_env)
-    setHook(
-        packageEvent("rstudioapi", "onLoad"),
-        function(...) {
-            rstudioapi_util_env$rstudioapi_patch_hook(rstudioapi_env)
-        }
-    )
-    if ("rstudioapi" %in% loadedNamespaces()) {
-        # if the rstudioapi is already loaded, for example via a call to
-        # library(tidyverse) in the user's profile, we need to shim it now.
-        # There's no harm in having also registered the hook in this case. It can
-        # work in the event that the namespace is unloaded and reloaded.
-        rstudioapi_util_env$rstudioapi_patch_hook(rstudioapi_env)
-    }
-
-}
-
-print.help_files_with_topic <- function(h, ...) {
-    viewer <- getOption("vsc.helpPanel", "Two")
-    if (!identical(FALSE, viewer) && length(h) >= 1 && is.character(h)) {
-        file <- h[1]
-        path <- dirname(file)
-        dirpath <- dirname(path)
-        pkgname <- basename(dirpath)
-        requestPath <- paste0(
-            "/library/",
-            pkgname,
-            "/html/",
-            basename(file),
-            ".html"
-        )
-        request(command = "help", requestPath = requestPath, viewer = viewer)
-    } else {
-        utils:::print.help_files_with_topic(h, ...)
-    }
-    invisible(h)
-}
-
-print.hsearch <- function(x, ...) {
-    viewer <- getOption("vsc.helpPanel", "Two")
-    if (!identical(FALSE, viewer) && length(x) >= 1) {
-        requestPath <- paste0(
-            "/doc/html/Search?pattern=",
-            tools:::escapeAmpersand(x$pattern),
-            paste0("&fields.", x$fields, "=1",
-                collapse = ""
-            ),
-            if (!is.null(x$agrep)) paste0("&agrep=", x$agrep),
-            if (!x$ignore.case) "&ignore.case=0",
-            if (!identical(
-                x$types,
-                getOption("help.search.types")
-            )) {
-                paste0("&types.", x$types, "=1",
-                    collapse = ""
-                )
-            },
-            if (!is.null(x$package)) {
-                paste0(
-                    "&package=",
-                    paste(x$package, collapse = ";")
-                )
-            },
-            if (!identical(x$lib.loc, .libPaths())) {
-                paste0(
-                    "&lib.loc=",
-                    paste(x$lib.loc, collapse = ";")
-                )
-            }
-        )
-        request(command = "help", requestPath = requestPath, viewer = viewer)
-    } else {
-        utils:::print.hsearch(x, ...)
-    }
-    invisible(x)
-}
-
-# a copy of .S3method(), since this function is new in R 4.0
-.S3method <- function(generic, class, method) {
-    if (missing(method)) {
-        method <- paste(generic, class, sep = ".")
-    }
-    method <- match.fun(method)
-    registerS3method(generic, class, method, envir = parent.frame())
-    invisible(NULL)
-}
-
-reg.finalizer(.GlobalEnv, function(e) .vsc$request("detach"), onexit = TRUE)
diff --git a/package.json b/package.json
index 68043d9e..c80afc18 100644
--- a/package.json
+++ b/package.json
@@ -1628,26 +1628,26 @@
         "r.session.useWebServer": {
           "type": "boolean",
           "default": false,
-          "markdownDescription": "Enable experimental use of web server in the R session to handle session requests from the extension. Changes the option `vsc.use_webserver` in R. Requires `#r.sessionWatcher#` to be set to `true`. Requires the `httpuv` R package."
+          "markdownDescription": "Enable experimental use of web server in the R session to handle session requests from the extension. Requires `#r.sessionWatcher#` to be set to `true`. Requires the `httpuv` R package."
         },
         "r.session.watchGlobalEnvironment": {
           "type": "boolean",
           "default": true,
-          "markdownDescription": "Watch the global environment to provide hover, autocompletions, and workspace viewer information. Changes the option `vsc.globalenv` in R. Requires `#r.sessionWatcher#` to be set to `true`."
+          "markdownDescription": "Watch the global environment to provide hover, autocompletions, and workspace viewer information. Requires `#r.sessionWatcher#` to be set to `true`."
         },
         "r.session.objectLengthLimit": {
           "type": "integer",
           "default": 2000,
-          "markdownDescription": "The upper limit of object length to show object details in workspace viewer and provide session symbol completion. Decrease this value if you experience significant delay after executing R commands caused by large global objects with many elements. Changes the option `vsc.object_length_limit` in R. Requires `#r.sessionWatcher#` to be set to `true`."
+          "markdownDescription": "The upper limit of object length to show object details in workspace viewer and provide session symbol completion. Decrease this value if you experience significant delay after executing R commands caused by large global objects with many elements. Requires `#r.sessionWatcher#` to be set to `true`."
         },
         "r.session.objectTimeout": {
           "type": "integer",
           "default": 50,
-          "markdownDescription": "The maximum number of milliseconds to get information of a single object in the global environment. Decrease this value if you experience significant delay after executing R commands caused by large global objects with many elements. Changes the option `vsc.object_timeout` in R. Requires `#r.sessionWatcher#` to be set to `true`."
+          "markdownDescription": "The maximum number of milliseconds to get information of a single object in the global environment. Decrease this value if you experience significant delay after executing R commands caused by large global objects with many elements. Requires `#r.sessionWatcher#` to be set to `true`."
         },
         "r.session.levelOfObjectDetail": {
           "type": "string",
-          "markdownDescription": "How much of the object to show on hover, autocompletion, and in the workspace viewer? Changes the option `vsc.str.max.level` in R. Requires `#r.sessionWatcher#` to be set to `true`.",
+          "markdownDescription": "How much of the object to show on hover, autocompletion, and in the workspace viewer? Requires `#r.sessionWatcher#` to be set to `true`.",
           "default": "Minimal",
           "enum": [
             "Minimal",
@@ -1663,12 +1663,12 @@
         "r.session.emulateRStudioAPI": {
           "type": "boolean",
           "default": true,
-          "markdownDescription": "Emulate the RStudio API for addin support and other {rstudioapi} calls. Changes the option `vsc.rstudioapi` in R. Requires `#r.sessionWatcher#` to be set to `true`."
+          "markdownDescription": "Emulate the RStudio API for addin support and other {rstudioapi} calls. Requires `#r.sessionWatcher#` to be set to `true`."
         },
         "r.session.data.rowLimit": {
           "type": "integer",
           "default": 0,
-          "markdownDescription": "The maximum number of rows to be displayed in the data viewer. `0` means no limit. Changes the option `vsc.row_limit` in R. Requires `#r.sessionWatcher#` to be set to `true`."
+          "markdownDescription": "The maximum number of rows to be displayed in the data viewer. `0` means no limit. Changes the option `sess.row_limit` in R. Requires `#r.sessionWatcher#` to be set to `true`."
         },
         "r.session.data.pageSize": {
           "type": "integer",
@@ -1689,7 +1689,7 @@
           "properties": {
             "plot": {
               "type": "string",
-              "description": "Which view column to show the plot file on graphics update? \n\nChanges the option 'vsc.plot' in R.",
+              "description": "Which view column to show the plot viewer on graphics update?",
               "enum": [
                 "Two",
                 "Active",
@@ -1706,7 +1706,7 @@
             },
             "browser": {
               "type": "string",
-              "description": "Which view column to show the WebView triggered by browser (e.g. shiny apps)? \n\nChanges the option 'vsc.browser' in R.",
+              "description": "Which view column to show the WebView triggered by browser (e.g. shiny apps)?",
               "enum": [
                 "Two",
                 "Active",
@@ -1723,7 +1723,7 @@
             },
             "viewer": {
               "type": "string",
-              "description": "Which view column to show the WebView triggered by viewer (e.g. htmlwidgets)? \n\nChanges the option 'vsc.viewer' in R.",
+              "description": "Which view column to show the WebView triggered by viewer (e.g. htmlwidgets)?",
               "enum": [
                 "Two",
                 "Active",
@@ -1740,7 +1740,7 @@
             },
             "pageViewer": {
               "type": "string",
-              "description": "Which view column to show the WebView triggered by the page viewer (e.g. profvis)? \n\nChanges the option 'vsc.page_viewer' in R.",
+              "description": "Which view column to show the WebView triggered by the page viewer (e.g. profvis)?",
               "enum": [
                 "Two",
                 "Active",
@@ -1757,7 +1757,7 @@
             },
             "view": {
               "type": "string",
-              "description": "Which view column to show the WebView triggered by View()? \n\nChanges the option 'vsc.view' in R.",
+              "description": "Which view column to show the WebView triggered by View()? \n\nChanges the option 'sess.dataview' in R.",
               "enum": [
                 "Two",
                 "Active",
@@ -1774,7 +1774,7 @@
             },
             "helpPanel": {
               "type": "string",
-              "description": "Which view column to show the WebView triggered by the help panel? \n\nChanges the option 'vsc.help_panel' in R.",
+              "description": "Which view column to show the WebView triggered by the help panel? \n\nChanges the option 'sess.helpPanel' in R.",
               "enum": [
                 "Two",
                 "Active",
@@ -1800,7 +1800,7 @@
         "r.workspaceViewer.showObjectSize": {
           "type": "boolean",
           "default": false,
-          "markdownDescription": "Show object size when hovering over a workspace viewer item. Changes the option `vsc.show_object_size` in R."
+          "markdownDescription": "Show object size when hovering over a workspace viewer item."
         },
         "r.workspaceViewer.removeHiddenItems": {
           "type": "boolean",
@@ -1834,7 +1834,7 @@
         },
         "r.plot.devArgs": {
           "type": "object",
-          "markdownDescription": "The arguments for the png device to replay user graphics to show in VSCode. Requires `#r.plot.useHttpgd#` to be set to `false`. \n\nChanges the option `vsc.dev.args` in R.",
+          "markdownDescription": "The supplementary arguments for the rendering device (e.g., `png()` or `svglite()`) used by the standard plot viewer. Note that width and height are now handled dynamically by the responsive viewer and will be overridden. Requires `#r.plot.useHttpgd#` to be set to `false`. \n\nChanges the option `sess.devArgs` in R.",
           "default": {
             "width": 800,
             "height": 1200
@@ -1842,12 +1842,12 @@
           "properties": {
             "width": {
               "type": "number",
-              "description": "Width of the graphic device.",
+              "description": "Width of the graphic device (Note: This is now handled dynamically by the responsive viewer).",
               "default": 480
             },
             "height": {
               "type": "number",
-              "description": "Height of the graphic device.",
+              "description": "Height of the graphic device (Note: This is now handled dynamically by the responsive viewer).",
               "default": 480
             },
             "units": {
@@ -1868,7 +1868,7 @@
         "r.plot.useHttpgd": {
           "type": "boolean",
           "default": false,
-          "markdownDescription": "Use the httpgd-based plot viewer instead of the base VSCode-R plot viewer. Changes the option `vsc.use_httpgd` in R.\n\nRequires the `httpgd` R package version 1.2.0 or later."
+          "markdownDescription": "Use the httpgd-based plot viewer instead of the base VSCode-R plot viewer.\n\nRequires the `httpgd` R package version 1.2.0 or later."
         },
         "r.plot.format": {
           "type": "string",
@@ -1877,7 +1877,7 @@
             "png",
             "svglite"
           ],
-          "description": "The format to use for the standard plot viewer. Requires `#r.plot.useHttpgd#` to be set to `false`."
+          "description": "The graphics format to use for the standard plot viewer. Requires `#r.plot.useHttpgd#` to be set to `false`."
         },
         "r.plot.defaults.colorTheme": {
           "type": "string",
diff --git a/sess/R/handlers.R b/sess/R/handlers.R
index 6cdd4ee9..7349f39a 100644
--- a/sess/R/handlers.R
+++ b/sess/R/handlers.R
@@ -90,15 +90,26 @@ handle_plot_latest <- function(params) {
 
   plot_file <- tempfile(tmpdir = .sess_env$tempdir, fileext = paste0(".", format))
 
+  dev_args <- params$devArgs
+  if (is.null(dev_args)) {
+    dev_args <- list()
+  }
+  # Remove arguments that we handle ourselves
+  dev_args$filename <- NULL
+  dev_args$file <- NULL
+  dev_args$width <- NULL
+  dev_args$height <- NULL
+  dev_args$res <- NULL
+
   if (format == "svglite") {
     if (requireNamespace("svglite", quietly = TRUE)) {
-      svglite::svglite(plot_file, width = width / 72, height = height / 72)
+      do.call(svglite::svglite, c(list(filename = plot_file, width = width / 72, height = height / 72), dev_args))
     } else {
       # Fallback to png
-      png(plot_file, width = width, height = height, res = 72)
+      do.call(png, c(list(filename = plot_file, width = width, height = height, res = 72), dev_args))
     }
   } else {
-    png(plot_file, width = width, height = height, res = 72)
+    do.call(png, c(list(filename = plot_file, width = width, height = height, res = 72), dev_args))
   }
 
   on.exit({
diff --git a/sess/R/hooks.R b/sess/R/hooks.R
index 9e12d629..6ab5f5e3 100644
--- a/sess/R/hooks.R
+++ b/sess/R/hooks.R
@@ -207,7 +207,7 @@ register_hooks <- function(use_rstudioapi = TRUE, use_httpgd = TRUE) {
       notify_client("httpgd", list(url = httpgd::hgd_url()))
     })
   } else {
-    # Default to static plot capturing (Re-implementation based on vsc.R)
+    # Default to static plot capturing (Re-implementation based on legacy plot handler)
     plot_file <- .sess_env$latest_plot_path
     file.create(plot_file, showWarnings = FALSE)
 
diff --git a/session.md b/session.md
deleted file mode 100644
index 4e0dc322..00000000
--- a/session.md
+++ /dev/null
@@ -1,650 +0,0 @@
-# R and VS Code Inter-Process Communication (IPC)
-
-The communication between the R session and VS Code involves two primary mechanisms:
-
-1. **R to VS Code (Asynchronous)**: File-based IPC mechanisms used to push data or trigger UI actions in VS Code. It uses specific pairs of data/log and lock files:
-   - **Command Dispatch:** `request.log` and `request.lock`
-   - **Workspace State:** `workspace.json` and `workspace.lock`
-   - **Static Plots:** `plot.png` and `plot.lock`
-2. **VS Code to R (Synchronous)**: HTTP Server IPC where R runs a local `httpuv` server that VS Code queries.
-
-Here are the relevant code snippets for each mechanism.
-
----
-
-## 1. R to VS Code (File-based IPC)
-
-When R wants to push data or trigger UI actions in VS Code, it writes a payload or image to a temporary file and updates a corresponding lock file to notify VS Code's file system watcher.
-
-### 1.1 Command Dispatch (`request.log`)
-
-The base function used to send requests from R is `request()`. It writes the command and arguments to `request_file` and updates `request_lock_file` with a timestamp.
-
-#### R Component ([`R/session/vsc.R`](R/session/vsc.R))
-
-```r
-get_timestamp <- function() {
-    sprintf("%.6f", Sys.time())
-}
-
-request <- function(command, ...) {
-    obj <- list(
-        time = Sys.time(),
-        pid = pid,
-        wd = wd,
-        command = command,
-        ...
-    )
-    jsonlite::write_json(obj, request_file,
-        auto_unbox = TRUE, null = "null", force = TRUE
-    )
-    cat(get_timestamp(), file = request_lock_file)
-}
-```
-
-R uses this core `request` function to send 8 distinct types of commands to VS Code. Below are snippets representing how each command is triggered from R:
-
-**1. webview**: Opens a local HTML file in a VS Code Webview panel (e.g., for htmlwidgets). [-> `show_webview`](R/session/vsc.R#L729)
-
-```r
-show_webview <- function(url, title, ..., viewer) {
-    if (file.exists(url)) {
-        file <- normalizePath(url, "/", mustWork = TRUE)
-        request("webview", file = file, title = title, viewer = viewer, ...)
-    }
-}
-```
-
-**2. browser**: Opens an external URL or help page via VS Code. [-> `request_browser`](R/session/vsc.R#L675)
-
-```r
-request_browser <- function(url, title, ..., viewer) {
-    request("browser", url = url, title = title, ..., viewer = viewer)
-}
-```
-
-**3. dataview**: Opens the built-in VS Code data viewer (triggered by `View()`).
-
-```r
-# Inside dataview handler for a table/dataframe
-file <- tempfile(tmpdir = tempdir, fileext = ".json")
-jsonlite::write_json(data, file, na = "string", null = "null", auto_unbox = TRUE, force = TRUE)
-request("dataview", source = "table", type = "json",
-    title = title, file = file, viewer = viewer, uuid = uuid
-)
-```
-
-**4. httpgd**: Notifies VS Code that an `httpgd` plot graphics device is ready.
-
-```r
-.vsc$request("httpgd", url = httpgd::hgd_url())
-```
-
-**5. attach**: Called when the R session starts and attaches to VS Code, providing session metadata and the `SessionServer` credentials. [-> `attach`](R/session/vsc.R#L639)
-
-```r
-attach <- function() {
-    request("attach",
-        version = sprintf("%s.%s", R.version$major, R.version$minor),
-        tempdir = tempdir,
-        info = list(...)
-    )
-}
-```
-
-**6. detach**: Called when the R session is closing to clean up resources.
-
-```r
-reg.finalizer(.GlobalEnv, function(e) .vsc$request("detach"), onexit = TRUE)
-```
-
-**7. help**: Opens the help documentation panel inside VS Code.
-
-```r
-request(command = "help", requestPath = requestPath, viewer = viewer)
-```
-
-**8. rstudioapi**: Emulates an `rstudioapi` request synchronously. It waits for VS Code to respond using a `response.lock` polling mechanism.
-
-```r
-request_response <- function(command, ...) {
-    request(command, ..., sd = dir_session)
-    wait_start <- Sys.time()
-    while (!get_response_lock()) {
-        # Loop and sleep waiting for VS Code to reply
-    }
-}
-# (Dispatches to request_response with command = "rstudioapi")
-```
-
-#### TypeScript Component ([`src/session.ts`](src/session.ts))
-
-VS Code uses `fs.watch` to monitor the `request.lock` file. When modified, it reads `request.log` and dispatches the command.
-
-```typescript
-export function startRequestWatcher(sessionStatusBarItem: StatusBarItem): void {
-    requestFile = path.join(homeExtDir(), 'request.log');
-    requestLockFile = path.join(homeExtDir(), 'request.lock');
-    requestTimeStamp = 0;
-    
-    // Watch the lock file for changes
-    fs.watch(requestLockFile, {}, () => {
-        void updateRequest(sessionStatusBarItem);
-    });
-}
-```
-
-Inside `updateRequest`, the JSON payload is parsed and the specific `command` is passed to its respective handler function. Here is a detailed breakdown of how each command is resolved in VS Code:
-
-**1. `webview` Handler**
-
-```typescript
-case 'webview': {
-    if (request.file && request.title && request.viewer !== undefined) {
-        await showWebView(request.file, request.title, request.viewer);
-    }
-    break;
-}
-```
-
-**Detail (`showWebView` [-> src/session.ts#L313](src/session.ts#L313)):**
-This handles local HTML content, most notably interactive `htmlwidgets`.
-
-```typescript
-export async function showWebView(file: string, title: string, viewer: string | boolean): Promise<void> {
-    if (viewer === false) {
-        void env.openExternal(Uri.file(file));
-    } else {
-        const dir = path.dirname(file);
-        const webviewDir = extensionContext.asAbsolutePath('html/session/webview/');
-        const panel = window.createWebviewPanel('webview', title,
-            { preserveFocus: true, viewColumn: ViewColumn[String(viewer) as keyof typeof ViewColumn] },
-            {
-                enableScripts: true, enableFindWidget: true, retainContextWhenHidden: true,
-                localResourceRoots: [Uri.file(dir), Uri.file(webviewDir)],
-            });
-        panel.iconPath = new UriIcon('globe');
-        panel.webview.html = await getWebviewHtml(panel.webview, file, title, dir, webviewDir);
-    }
-}
-```
-
-1. **Fallback to OS Browser**: If `viewer` is explicitly `false`, it bypasses VS Code and opens the file in the OS's default external browser via `env.openExternal(Uri.file(file))`.
-2. **Creating the Panel**: Otherwise, `showWebView()` uses the VS Code API `window.createWebviewPanel()` to instantiate a native panel.
-3. **Security and Access**: It explicitly restricts file system access by setting `localResourceRoots`. It only allows the webview to read assets from two places: the directory containing the HTML file itself (so local CSS/JS dependencies can load), and the extension's `html/session/webview/` directory.
-4. **HTML Injection**: It calls `getWebviewHtml()` ([-> src/session.ts#L651](src/session.ts#L651)), which reads the target HTML file into a string. Crucially, it uses a regular expression to rewrite all relative `href` and `src` paths into secure `vscode-webview-resource://` URIs by prepending `webview.asWebviewUri(Uri.file(dir))`. Finally, it wraps the content with a Content Security Policy (CSP) and injects a custom `observer.js` script to handle layout updates, before assigning the final string to `panel.webview.html`.
-
-**2. `browser` Handler**
-
-```typescript
-case 'browser': {
-    if (request.url && request.title && request.viewer !== undefined) {
-        await showBrowser(request.url, request.title, request.viewer);
-    }
-    break;
-}
-```
-
-**Detail (`showBrowser` [-> src/session.ts#L225](src/session.ts#L225)):**
-This handles external URLs and active R servers (like the R help server).
-
-```typescript
-export async function showBrowser(url: string, title: string, viewer: string | boolean): Promise<void> {
-    const uri = Uri.parse(url);
-    if (viewer === false) {
-        void env.openExternal(uri);
-    } else {
-        const externalUri = await env.asExternalUri(uri);
-        const panel = window.createWebviewPanel('browser', title,
-            { preserveFocus: true, viewColumn: ViewColumn[String(viewer) as keyof typeof ViewColumn] },
-            { enableFindWidget: true, enableScripts: true, retainContextWhenHidden: true });
-        
-        // event listeners for activeBrowserPanel omitted for brevity
-        
-        panel.iconPath = new UriIcon('globe');
-        panel.webview.html = getBrowserHtml(externalUri); // Injects <iframe src="${uri}" width="100%" height="100%" />
-    }
-}
-```
-
-1. **URI Translation**: It uses `env.asExternalUri(uri)` on the requested URL. This is a critical step because if the VS Code session is running remotely (e.g., via SSH, GitHub Codespaces, or Dev Containers), this VS Code API automatically sets up an encrypted port-forwarding tunnel so the local IDE can access the remote R HTTP server securely.
-2. **Creating the Panel**: Like `webview`, it creates a `WebviewPanel` titled "browser".
-3. **State Management**: It attaches event listeners to track the active browser state (`activeBrowserPanel` and `activeBrowserUri`). This allows the extension to provide fallback commands like `refreshBrowser` or `openExternalBrowser` on the currently viewed page.
-4. **Iframe Embedding**: Instead of reading file contents, `getBrowserHtml()` simply generates a lightweight HTML template containing a fullscreen `<iframe src="${uri}" width="100%" height="100%" />` element. This embeds the live web page directly inside the IDE panel.
-
-**3. `dataview` Handler**
-
-```typescript
-case 'dataview': {
-    if (request.source && request.type && request.file && request.title && request.viewer !== undefined) {
-        await showDataView(request.source, request.type, request.title, request.file, request.viewer);
-    }
-    break;
-}
-```
-
-**Detail (`showDataView` [-> src/session.ts#L337](src/session.ts#L337)):**
-Activated by calling `View()` on an R object (like a `data.frame` or `list`).
-
-```typescript
-export async function showDataView(source: string, type: string, title: string, file: string, viewer: string): Promise<void> {
-    if (source === 'table') {
-        const panel = window.createWebviewPanel('dataview', title,
-            { preserveFocus: true, viewColumn: ViewColumn[viewer as keyof typeof ViewColumn] },
-            { enableScripts: true, enableFindWidget: true, retainContextWhenHidden: true, localResourceRoots: [Uri.file(resDir)] });
-        panel.iconPath = new UriIcon('open-preview');
-        panel.webview.html = await getTableHtml(panel.webview, file, title);
-    } else if (source === 'list') {
-        // similar to table, but calls getListHtml(panel.webview, file, title)
-    } else {
-        // Fallback for raw text 'object'
-        await commands.executeCommand('vscode.open', Uri.file(file), {
-            preserveFocus: true, preview: true, viewColumn: ViewColumn[viewer as keyof typeof ViewColumn],
-        });
-    }
-}
-```
-
-1. **Data Source - Table**: If the source is `'table'`, `showDataView()` creates a webview panel and gives it access to the extension's `dist/resources` folder. It reads the temporary `.json` data file dumped by R and passes the raw JSON into `getTableHtml()`. This function injects the data into an HTML template bundled with `ag-grid-community`, rendering a rich, interactive, sortable, filterable, and paginated data table interface purely via JavaScript.
-2. **Data Source - List**: If the source is `'list'`, it takes a similar approach but uses `getListHtml()`, rendering the data as a collapsible JSON tree view.
-3. **Fallback - Virtual Document**: If the object was too complex to serialize to JSON and R fell back to an `'object'` representation text file (`txt`), it skips the Webview entirely. Instead, it reads the file and opens it natively inside the IDE as a read-only Virtual Document using `vscode.open` and a custom document provider.
-
-**4. `httpgd` Handler**
-
-```typescript
-case 'httpgd': {
-    if (request.url) {
-        await globalPlotManager?.showHttpgdPlot(request.url);
-    }
-    break;
-}
-```
-
-**Detail (`httpgd` [-> src/plotViewer/index.ts](src/plotViewer/index.ts)):**
-Triggered when an R script opens an `httpgd` graphics device (a modern SVG/HTML-based plotting device for R).
-
-1. **Intercepting the URL**: R tells VS Code the exact local URL/port where the `httpgd` server is streaming the plots.
-2. **Delegation to Manager**: The session handler passes this URL to the `globalPlotManager` (an instance of `CommonPlotManager` defined in `src/plotViewer/index.ts`).
-3. **Viewer Instantiation**: The manager parses the URL, extracting the host and security token. It searches to see if a viewer for that host already exists. If not, it instantiates a new `HttpgdViewer`.
-4. **Webview Rendering**: The `HttpgdViewer` spins up a dedicated `WebviewPanel`. Instead of just embedding the plot as a static image, it loads a full React-based frontend application (bundled in the extension's resources) into the webview. This frontend connects directly to the R `httpgd` server via WebSockets to provide a live, interactive, resizable plot viewer with history tracking and export capabilities.
-
-**5. `attach` Handler**
-
-```typescript
-case 'attach': {
-    if (!request.tempdir || !request.wd) return;
-    // Update local variables
-    rVer = String(request.version);
-    pid = String(request.pid);
-    sessionDir = path.join(request.tempdir, 'vscode-R');
-
-    // UI Updates
-    sessionStatusBarItem.text = `R ${rVer}: ${pid}`;
-    sessionStatusBarItem.show();
-    await setContext('rSessionActive', true);
-
-    if (request.server) {
-        server = request.server;
-    }
-    void watchProcess(pid).then((v: string) => { void cleanupSession(v); });
-    break;
-}
-```
-
-**Detail (`attach`):**
-This is the foundational bootstrapping command. When R starts and sources the VS Code initialization script, it fires this payload.
-
-1. **State Initialization**: It caches critical session metadata into global variables: the active Process ID (`pid`), the R version (`rVer`), and the temporary session directory (`sessionDir`).
-2. **Status Bar Integration**: It updates the VS Code Status Bar at the bottom of the screen (e.g., displaying "R 4.3: 12345") to give the user visual confirmation that the IDE is hooked into the R terminal.
-3. **Context Switching**: It sets the VS Code context key `rSessionActive` to `true`. This enables context-aware menus, shortcuts, and features that should only be visible when R is running.
-4. **Synchronous IPC Setup**: Critically, it extracts the `request.server` object (which contains the `{httpuv}` host, port, and auth token) and saves it to the exported `server` variable, fully enabling the Synchronous HTTP IPC channel.
-5. **Process Monitoring**: It initiates `watchProcess(pid)` ([-> src/session.ts#L862](src/session.ts#L862)). This sets up an OS-level listener (using `process.kill(pid, 0)` checks or equivalent) to continuously monitor if the R process is alive. If the terminal is killed or R crashes, the watcher resolves, immediately triggering `cleanupSession()`.
-
-**6. `detach` Handler**
-
-```typescript
-case 'detach': {
-    if (request.pid) {
-        await cleanupSession(request.pid);
-    }
-    break;
-}
-```
-
-**Detail (`detach` / `cleanupSession` [-> src/session.ts#L845](src/session.ts#L845)):**
-Triggered explicitly by R's `.GlobalEnv` finalizer when the session is closing cleanly, or triggered forcefully by the `watchProcess` monitor if R crashes.
-
-1. **State Verification**: `cleanupSession(pidArg)` first checks if the `pid` trying to detach matches the currently tracked `pid`. This prevents race conditions if multiple R terminals are open.
-2. **UI Teardown**: It resets the status bar text to "R: (not attached)".
-3. **Data Clearing**: It aggressively clears the cached data. It sets `server = undefined` (cutting off HTTP IPC), empties the `workspaceData` (global environment variables, loaded namespaces), and commands the UI Workspace Viewer to refresh (effectively blanking out the variable explorer).
-4. **Addin Purging**: It calls `purgeAddinPickerItems()`, clearing out any cached RStudio Addins that were registered by that specific R session.
-
-**7. `help` Handler**
-
-```typescript
-case 'help': {
-    if (globalRHelp && request.requestPath) {
-        await globalRHelp.showHelpForPath(request.requestPath, request.viewer);
-    }
-    break;
-}
-```
-
-**Detail (`help` [-> src/helpViewer/index.ts#L587](src/helpViewer/index.ts#L587)):**
-Activated when you use `?function` or `help()` in R.
-
-1. **Delegation**: It passes the specific help path to the `globalRHelp` provider (an instance of `RHelp` from `src/helpViewer/index.ts`).
-2. **Internal Server Hook**: VS Code doesn't just open a dumb browser. R's internal dynamic help server (which handles parsing `.Rd` files to HTML) is running in the background. The `globalRHelp` manager constructs the correct URL targeting R's internal help port.
-3. **Custom Webview**: It opens a custom `HelpPanel` webview. This webview does not just display the HTML; it intercepts internal link clicks. If you click a link to another package's documentation, the webview intercepts the navigation event, prevents a full page reload, and requests the new content via the VS Code IPC, resulting in a much faster, app-like navigation experience for R help files.
-
-**8. `rstudioapi` Handler**
-
-```typescript
-case 'rstudioapi': {
-    if (request.action && request.args && request.sd) {
-        await dispatchRStudioAPICall(request.action, request.args, request.sd);
-    }
-    break;
-}
-```
-
-**Detail (`rstudioapi` [-> src/rstudioapi.ts#L22](src/rstudioapi.ts#L22)):**
-This is a complex bridge that allows R scripts (or packages that depend on `{rstudioapi}`) to natively control the VS Code editor, mimicking RStudio IDE behaviors.
-
-1. **Synchronous Blocking in R**: When R calls an `rstudioapi` function, the R process writes the request to `request.log` and then enters an infinite `while` loop, aggressively polling for the existence of a `response.log` file. R is completely blocked at this point.
-2. **Action Dispatching**: VS Code receives the request and passes it to `dispatchRStudioAPICall()` (in `src/rstudioapi.ts`). This function contains a large `switch` statement handling RStudio API actions like:
-    - `active_editor_context`: Gets the currently selected text and cursor position using VS Code's `window.activeTextEditor`.
-    - `insert_or_modify_text`: Applies a `WorkspaceEdit` using the VS Code API to programmatically type code into the editor.
-    - `navigate_to_file`: Uses `vscode.open` to jump the user's cursor to a specific file and line.
-3. **Unblocking R**: Once the VS Code API task completes, the handler MUST resolve the blocking loop. It does this by calling `writeResponse(data, sd)` or `writeSuccessResponse(sd)`. This function writes the requested data (or a simple boolean `true`) into a `response.log` file located in the session directory, and creates a `response.lock` file.
-4. **Resumption**: R's polling loop detects the lock file, reads the response data, breaks the loop, and returns the data back to the original `{rstudioapi}` function call.
-
-### 1.2 Workspace State (`workspace.json`)
-
-To populate the VS Code Workspace Viewer (Variable Explorer), R continuously monitors the `.GlobalEnv` and serializes its structure whenever it changes.
-
-#### R Component
-
-R maintains an `update_workspace` function that compares the current `.GlobalEnv` against a cached `globalenv_cache`. It calls `inspect_env` to extract metadata (type, class, size, dimensions, and a string preview using `capture_str()`) for all variables. This structured list is serialized via `jsonlite::write_json()` to `workspace.json`, and `workspace.lock` is updated with a timestamp.
-
-```r
-update_workspace <- function(...) {
-    tryCatch({
-        data <- list(
-            globalenv = if (show_globalenv) inspect_env(.GlobalEnv, globalenv_cache) else NULL
-        )
-        jsonlite::write_json(data, workspace_file, force = TRUE, pretty = FALSE)
-        cat(get_timestamp(), file = workspace_lock_file)
-    }, error = message)
-    TRUE
-}
-```
-
-#### TypeScript Component
-
-VS Code watches `workspace.lock` inside `updateSessionWatcher()`. When it detects a change, it reads the newly updated `workspace.json`, parses it into the global `workspaceData` object, and triggers a refresh event on the `workspaceViewer`. The tree view in VS Code then natively renders the updated variables and their properties.
-
-```typescript
-async function updateWorkspace() {
-    const lockContent = await fs.readFile(workspaceLockFile, 'utf8');
-    const newTimeStamp = Number.parseFloat(lockContent);
-    if (newTimeStamp !== workspaceTimeStamp) {
-        workspaceTimeStamp = newTimeStamp;
-        if (fs.existsSync(workspaceFile)) {
-            const content = await fs.readFile(workspaceFile, 'utf8');
-            workspaceData = JSON.parse(content) as WorkspaceData;
-            void rWorkspace?.refresh(); // Refreshes the Workspace Viewer Tree
-        }
-    }
-}
-```
-
-### 1.3 Static Plotting (`plot.png`)
-
-For users not using the modern `httpgd` device, R can be configured to produce static plots that are automatically displayed in VS Code.
-
-#### R Component
-
-R configures a custom `options(device = ...)` that initializes a null PDF device (to capture drawing operations silently). It overrides graphics hooks (`setHook("plot.new", ...)` and `rebind(".External.graphics", ...)`). When a plot is fully drawn, the `update_plot` function renders it using `png()` to a temporary `plot.png` file, then updates `plot.lock` with a timestamp.
-
-```r
-update_plot <- function(...) {
-    if (plot_updated && check_null_dev()) {
-        plot_updated <<- FALSE
-        record <- recordPlot()
-        if (length(record[[1L]])) {
-            dev_args <- getOption("vsc.dev.args")
-            do.call(png, c(list(filename = plot_file), dev_args))
-            on.exit({
-                dev.off()
-                cat(get_timestamp(), file = plot_lock_file)
-            })
-            replayPlot(record)
-        }
-    }
-    TRUE
-}
-```
-
-#### TypeScript Component
-
-Similar to the workspace watcher, VS Code monitors `plot.lock`. When modified, it uses the VS Code native API `vscode.open` to display the updated `plot.png` file in a built-in image viewer panel.
-
-```typescript
-async function updatePlot() {
-    const lockContent = await fs.readFile(plotLockFile, 'utf8');
-    const newTimeStamp = Number.parseFloat(lockContent);
-    if (newTimeStamp !== plotTimeStamp) {
-        plotTimeStamp = newTimeStamp;
-        if (fs.existsSync(plotFile) && fs.statSync(plotFile).size > 0) {
-            void commands.executeCommand('vscode.open', Uri.file(plotFile), {
-                preserveFocus: true,
-                preview: true,
-                viewColumn: ViewColumn[(config().get<string>('session.viewers.viewColumn.plot') || 'Two') as keyof typeof ViewColumn],
-            });
-        }
-    }
-}
-```
-
----
-
-## 2. VS Code to R (Synchronous HTTP IPC)
-
-For synchronous querying (e.g., fetching hover information, workspace variables, or autocomplete suggestions), the file-based IPC is too slow and chaotic. Instead, VS Code acts as an HTTP client sending POST requests directly to an internal HTTP server hosted by the R process.
-
-### R Component (`R/session/vsc.R`)
-
-Upon attaching to the VS Code terminal, R initializes a background HTTP server using the `{httpuv}` package.
-
-1. **Security and Bootstrapping**: It generates a secure, randomized `token` and binds to a `randomPort()` on `127.0.0.1`. It passes these credentials back to VS Code via the initial file-based `"attach"` request.
-2. **Request Routing**: The `httpuv` server listens for HTTP POST requests. When a request arrives, it validates the `HTTP_AUTHORIZATION` header against its secret token.
-3. **JSON Payload parsing**: It parses the body of the request (which is sent as JSON from VS Code) to figure out the `type` of request.
-4. **Request Handlers**: It routes the execution to specific functions defined in `request_handlers`.
-    - `hover`: Evaluates an expression (like a variable name the user is hovering over) in the `.GlobalEnv` and uses `capture_str()` to return a formatted string representation of the object's structure.
-    - `complete`: Handles autocompletion logic. For example, if the user types `df$`, the server intercepts the `$` trigger, evaluates `df`, and uses `.DollarNames` to return a list of all column names and their data types back to VS Code.
-
-```r
-        # Bootstrapping the Session Server
-        host <- "127.0.0.1"
-        port <- httpuv::randomPort()
-        token <- sprintf("%d:%d:%.6f", pid, port, Sys.time())
-        
-        request_handlers <- list(
-            hover = function(expr, ...) {
-                tryCatch({
-                    expr <- parse(text = expr, keep.source = FALSE)[[1]]
-                    obj <- eval(expr, .GlobalEnv)
-                    list(str = capture_str(obj))
-                }, error = function(e) NULL)
-            },
-            complete = function(expr, trigger, ...) {
-                # Logic to handle '$' or '@' triggers and return available names/slots
-                # ...
-            }
-        )
-
-        server <- httpuv::startServer(host, port,
-            list(
-                onHeaders = function(req) {
-                    # Validate auth token
-                    if (!identical(req[["HTTP_AUTHORIZATION"]], token)) {
-                        return(list(status = 401L, headers = list("Content-Type" = "text/plain"), body = "Unauthorized"))
-                    }
-                    # ...
-                },
-                call = function(req) {
-                    content <- req$rook.input$read_lines()
-                    request <- jsonlite::fromJSON(content, simplifyVector = FALSE)
-                    
-                    # Route to internal request handlers based on type (e.g., 'hover', 'complete')
-                    handler <- request_handlers[[request$type]]
-                    response <- if (is.function(handler)) do.call(handler, request)
-
-                    list(
-                        status = 200L,
-                        headers = list("Content-Type" = "application/json"),
-                        body = jsonlite::toJSON(response, auto_unbox = TRUE, force = TRUE)
-                    )
-                }
-            )
-        )
-        attr(server, "token") <- token
-        options(vsc.server = server)
-```
-
-### TypeScript Component (`src/session.ts` and `src/completions.ts`)
-
-Once VS Code receives the `"attach"` payload from R, it globally caches the `SessionServer` details. It then exposes a `sessionRequest` helper function for various UI Language Providers.
-
-**The `sessionRequest` Function (`src/session.ts`)**:
-This is a wrapper around `node-fetch`. It sends an HTTP POST request to `http://${server.host}:${server.port}`, stringifies the requested data into the JSON body, and critically, attaches the `server.token` to the `Authorization` header. It then awaits the JSON response.
-
-```typescript
-export interface SessionServer {
-    host: string;
-    port: number;
-    token: string;
-}
-
-export let server: SessionServer | undefined;
-
-// Function called by language features (hover, completion, etc.)
-export async function sessionRequest(server: SessionServer, data: any): Promise<any> {
-    try {
-        const response = await fetch(`http://${server.host}:${server.port}`, {
-            agent: httpAgent, // Keep-alive agent
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Accept: 'application/json',
-                Authorization: server.token
-            },
-            body: JSON.stringify(data),
-            follow: 0,
-            timeout: 500, // Very short timeout for snappiness
-        });
-
-        if (!response.ok) throw new Error(`Error! status: ${response.status}`);
-        return response.json();
-    } catch (error) {
-        console.log('error: ', error);
-    }
-}
-```
-
-**Implementation in Language Providers (`src/completions.ts`)**:
-When a user interacts with the editor (like hovering over a word or typing `$` to trigger completions), VS Code's extension API fires its respective provider events. These providers intercept the event, parse the text, and use `sessionRequest()` to ask the R HTTP server for live execution context.
-
-**1. Hover Provider (`type: 'hover'`):** [-> src/completions.ts#L34](src/completions.ts#L34)
-When you hover your mouse over a variable (e.g., `my_data`) in the editor:
-
-- **VS Code (Request)**: The `HoverProvider` in `src/completions.ts` uses a regex to grab the word under the cursor. It sends a JSON payload to the HTTP server: `{ "type": "hover", "expr": "my_data" }`.
-- **R (Processing)**: The `hover` handler inside `vsc.R`'s `request_handlers` takes over. It uses `parse(text = expr)` to turn the string into an R expression, and `eval(expr, .GlobalEnv)` to safely evaluate it in the global workspace. It then passes the resulting object into a custom `capture_str()` function (a wrapper around R's native `str()` function) to generate a concise, human-readable structural summary of the object.
-- **R (Response)**: It returns `{ "str": "data.frame': 3 obs. of  2 variables:\n $ x: num 1 2 3\n $ y: chr 'a' 'b' 'c'" }`.
-- **VS Code (Rendering)**: The Hover Provider receives this JSON, extracts the `.str` property, and wraps it in a `vscode.MarkdownString` formatted as an R code block (` ```r `). This is what pops up in the IDE as the hover tooltip.
-
-```typescript
-export class HoverProvider implements vscode.HoverProvider {
-    async provideHover(document: vscode.TextDocument, position: vscode.Position): Promise<vscode.Hover | null> {
-        // ... (Environment and Rmd checks omitted) ...
-
-        let hoverRange = document.getWordRangeAtPosition(position);
-        let hoverText = null;
-
-        if (session.server) {
-            const exprRegex = /([a-zA-Z0-9._$@ ])+(?<![@$])/;
-            hoverRange = document.getWordRangeAtPosition(position, exprRegex)?.with({ end: hoverRange?.end });
-            const expr = document.getText(hoverRange);
-            const response = await session.sessionRequest(session.server, {
-                type: 'hover',
-                expr: expr
-            });
-
-            if (response) {
-                hoverText = response.str;
-            }
-        } // ...
-
-        if (hoverText) {
-            return new vscode.Hover(`\`\`\`\n${hoverText}\n\`\`\``, hoverRange);
-        }
-        return null;
-    }
-}
-```
-
-**2. Completion Provider (`type: 'complete'`):** [-> src/completions.ts#L133](src/completions.ts#L133)
-When you type a trigger character like `$` (for lists/dataframes) or `@` (for S4 objects), you expect to see the internal properties of that object.
-
-- **VS Code (Request)**: If you type `df$`, the `CompletionItemProvider` grabs the `df` preceding the cursor and sends: `{ "type": "complete", "expr": "df", "trigger": "$" }`.
-- **R (Processing)**: The `complete` handler in `vsc.R` evaluates `df`. If it evaluates successfully, it checks the `trigger`:
-  - If `trigger == "$"`, it uses R's internal `.DollarNames(obj)` (for objects) or `names(obj)` (for recursive lists) to get an array of available property names.
-  - If `trigger == "@"`, it uses `slotNames(obj)` to get the S4 slot names.
-  - It then loops over those names. For each property (e.g., a specific column in a dataframe), it determines its `typeof()` and uses `try_capture_str()` to get a preview of its contents.
-- **R (Response)**: It returns a JSON array of `RObjectElement` items: `[ { "name": "col_A", "type": "double", "str": "num [1:10] 1.5 2.1..." }, ... ]`.
-- **VS Code (Rendering)**: The Completion Provider receives this array and passes it to `getCompletionItemsFromElements()` ([-> src/completions.ts#L221](src/completions.ts#L221)). This helper function loops over the R items and converts them into native VS Code `vscode.CompletionItem` objects.
-  - `e.name` becomes the label shown in the dropdown list.
-  - `e.type` determines the icon (e.g., if it's a "closure" or "builtin", it gets a Function icon $f(x)$, otherwise it gets a Variable/Field icon).
-  - `e.str` is wrapped in a Markdown code block and attached to `item.documentation`, so when you highlight a column name in the dropdown, a side-panel shows you a preview of the data inside that column.
-  - Finally, the provider returns these items, and VS Code renders the native Intellisense UI.
-
-```typescript
-export class LiveCompletionItemProvider implements vscode.CompletionItemProvider {
-    async provideCompletionItems(
-        document: vscode.TextDocument,
-        position: vscode.Position,
-        token: vscode.CancellationToken,
-        completionContext: vscode.CompletionContext
-    ): Promise<vscode.CompletionItem[]> {
-        const items: vscode.CompletionItem[] = [];
-        // ... (Environment and Rmd checks omitted) ...
-        const trigger = completionContext.triggerCharacter;
-
-        if (trigger === undefined) {
-            // ... Populate from workspaceData.globalenv (fallback) ...
-        } else if(trigger === '$' || trigger === '@') {
-            const symbolPosition = new vscode.Position(position.line, position.character - 1);
-            if (session.server) {
-                const re = /([a-zA-Z0-9._$@ ])+(?<![@$])/;
-                const exprRange = document.getWordRangeAtPosition(symbolPosition, re)?.with({ end: symbolPosition });
-                const expr = document.getText(exprRange);
-                
-                // Request live completions from R via HTTP
-                const response: RObjectElement[] = await session.sessionRequest(session.server, {
-                    type: 'complete',
-                    expr: expr,
-                    trigger: completionContext.triggerCharacter
-                });
-
-                if (response) {
-                    items.push(...getCompletionItemsFromElements(response, '[session]'));
-                }
-            } // ...
-        }
-        
-        // ...
-        return items;
-    }
-}
-```
diff --git a/src/plotViewer/standardViewer.ts b/src/plotViewer/standardViewer.ts
index ec81a24e..3c7066ae 100644
--- a/src/plotViewer/standardViewer.ts
+++ b/src/plotViewer/standardViewer.ts
@@ -75,12 +75,14 @@ export class StandardPlotViewer implements PlotViewer {
         }
 
         const format = config().get<string>('plot.format', 'svglite');
+        const devArgs = config().get<Record<string, unknown>>('plot.devArgs');
         const response = await sessionRequest(server, {
             method: 'plot_latest',
             params: {
                 width: this.viewWidth,
                 height: this.viewHeight,
-                format: format
+                format: format,
+                devArgs: devArgs
             }
         });
 

From 7e7ea5c2b7c439513004a2d4909c8d047a62341c Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Sat, 14 Mar 2026 14:24:51 -0700
Subject: [PATCH 44/47] fix: resolve TypeScript errors in httpgd plot viewer
 and webview

---
 src/plotViewer/index.ts         | 7 ++++---
 src/plotViewer/webview/index.ts | 4 ++--
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/plotViewer/index.ts b/src/plotViewer/index.ts
index 913ae47e..94fb49e1 100644
--- a/src/plotViewer/index.ts
+++ b/src/plotViewer/index.ts
@@ -1,7 +1,8 @@
 
 import * as vscode from 'vscode';
 import { PlotViewer, PlotManager } from './types';
-import { HttpgdManager } from './httpgdViewer';
+import { HttpgdManager, HttpgdViewer } from './httpgdViewer';
+export { HttpgdManager };
 import { StandardPlotViewer } from './standardViewer';
 import { extensionContext } from '../extension';
 
@@ -79,9 +80,9 @@ export class CommonPlotManager implements PlotManager {
         // Identify the correct viewer
         let viewer: PlotViewer | undefined;
         if (typeof hostOrWebviewUri === 'string') {
-            viewer = this.httpgdManager.viewers.find((v) => v.host === hostOrWebviewUri);
+            viewer = this.httpgdManager.viewers.find((v: HttpgdViewer) => v.host === hostOrWebviewUri);
         } else if (hostOrWebviewUri instanceof vscode.Uri) {
-            viewer = this.httpgdManager.viewers.find((v) => v.getPanelPath() === hostOrWebviewUri.path);
+            viewer = this.httpgdManager.viewers.find((v: HttpgdViewer) => v.getPanelPath() === hostOrWebviewUri.path);
         }
 
         // Fallback to active viewer
diff --git a/src/plotViewer/webview/index.ts b/src/plotViewer/webview/index.ts
index 8c2f960d..2afeab74 100644
--- a/src/plotViewer/webview/index.ts
+++ b/src/plotViewer/webview/index.ts
@@ -16,8 +16,8 @@ interface Plot {
     width?: number;
 }
 
-import { acquireVsCodeApi } from '../webviewMessages';
-const vscode = acquireVsCodeApi();
+import { acquireVsCodeApi, ResizeMessage, InMessage, PreviewPlotLayout } from '../webviewMessages';
+const vscode = acquireVsCodeApi() as { postMessage: (msg: any) => void };
 
 // globals
 let oldHeight = -1;

From 27ab44c303faef15004ac39e1794d534dc332f6d Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Sat, 14 Mar 2026 14:27:53 -0700
Subject: [PATCH 45/47] refactor: fix lint errors and improve type safety

---
 src/helpViewer/cran.ts            | 15 ---------------
 src/helpViewer/webview/index.ts   |  4 ++--
 src/helpViewer/webviewMessages.ts |  2 +-
 src/plotViewer/httpgdViewer.ts    | 23 +++++++++++------------
 src/plotViewer/index.ts           |  4 ++--
 src/plotViewer/standardViewer.ts  | 13 +++++++++----
 src/plotViewer/types.ts           |  4 +---
 src/plotViewer/webview/index.ts   |  8 --------
 src/plotViewer/webviewMessages.ts |  2 +-
 src/rTerminal.ts                  |  4 ++--
 src/rstudioapi.ts                 |  4 ++--
 src/session.ts                    |  2 +-
 src/test/suite/terminal.test.ts   | 22 +++++++++++-----------
 13 files changed, 43 insertions(+), 64 deletions(-)

diff --git a/src/helpViewer/cran.ts b/src/helpViewer/cran.ts
index ec6c1237..5ce98599 100644
--- a/src/helpViewer/cran.ts
+++ b/src/helpViewer/cran.ts
@@ -56,21 +56,6 @@ function parseCranPackagesFile(html: string): Package[] {
     return packages;
 }
 
-function parseCranJson(jsonString: string): Package[] {
-    const lines = jsonString.split('\n').filter(v => v);
-    const pkgs = lines.map(line => {
-        const j = JSON.parse(line) as {[key: string]: string};
-        const pkg: Package = {
-            name: j['Package'],
-            description: j['Title'],
-            date: j['modified'],
-            isCran: true
-        };
-        return pkg;
-    });
-    return pkgs;
-}
-
 function parseCranTable(html: string, baseUrl: string): Package[] {
     if(!html){
         return [];
diff --git a/src/helpViewer/webview/index.ts b/src/helpViewer/webview/index.ts
index 2060c7e8..1e2ab9e4 100644
--- a/src/helpViewer/webview/index.ts
+++ b/src/helpViewer/webview/index.ts
@@ -1,6 +1,6 @@
-import { acquireVsCodeApi } from '../webviewMessages';
+import { acquireVsCodeApi, VsCode } from '../webviewMessages';
 
-const vscode = acquireVsCodeApi();
+const vscode: VsCode = acquireVsCodeApi();
 
 // notify vscode when mouse buttons are clicked
 // used to implement back/forward on mouse buttons 3/4
diff --git a/src/helpViewer/webviewMessages.ts b/src/helpViewer/webviewMessages.ts
index 4a28c44d..4fc1c817 100644
--- a/src/helpViewer/webviewMessages.ts
+++ b/src/helpViewer/webviewMessages.ts
@@ -7,7 +7,7 @@ export interface VsCode {
 /**
  * Function declared by VS Code in Webview
  */
-export const acquireVsCodeApi: any = (globalThis as any).acquireVsCodeApi;
+export const acquireVsCodeApi: () => VsCode = (globalThis as { acquireVsCodeApi?: () => VsCode }).acquireVsCodeApi || (() => ({} as VsCode));
 
 export interface IMessage {
     message: string;
diff --git a/src/plotViewer/httpgdViewer.ts b/src/plotViewer/httpgdViewer.ts
index ab55e775..65d9aa28 100644
--- a/src/plotViewer/httpgdViewer.ts
+++ b/src/plotViewer/httpgdViewer.ts
@@ -5,7 +5,6 @@ import { HttpgdPlot, IHttpgdViewer, HttpgdViewerOptions } from './httpgdTypes';
 import * as path from 'path';
 import * as fs from 'fs';
 import * as ejs from 'ejs';
-import { Response } from 'node-fetch';
 
 import { asViewColumn, config, setContext, UriIcon, makeWebviewCommandUriString } from '../util';
 import { extensionContext } from '../extension';
@@ -96,7 +95,7 @@ interface EjsData {
     host: string;
     asLocalPath: (relPath: string) => string;
     asWebViewPath: (localPath: string) => string;
-    makeCommandUri: (command: string, ...args: any[]) => string;
+    makeCommandUri: (command: string, ...args: unknown[]) => string;
     overwriteCssPath: string;
     plot?: HttpgdPlot<string>;
 }
@@ -194,7 +193,7 @@ export class HttpgdViewer implements IHttpgdViewer, PlotViewer {
         void this.api.connect();
     }
 
-    public handleCommand(command: string, ...args: any[]): void | Promise<void> {
+    public handleCommand(command: string, ...args: unknown[]): void | Promise<void> {
         const stringArg = findItemOfType(args, 'string');
         const boolArg = findItemOfType(args, 'boolean');
 
@@ -603,20 +602,20 @@ export class HttpgdViewer implements IHttpgdViewer, PlotViewer {
                 options.defaultUri = vscode.Uri.file(noExtPath + (ext ? `.${ext}` : ''));
             } else {
                 const defaultFolder = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
-                if(defaultFolder) options.defaultUri = vscode.Uri.file(path.join(defaultFolder, 'plot' + (ext ? `.${ext}` : '')));
+                if(defaultFolder) {options.defaultUri = vscode.Uri.file(path.join(defaultFolder, 'plot' + (ext ? `.${ext}` : '')));}
             }
-            if(ext && renderer?.name) options.filters = { [renderer.name]: [ext], ['All']: ['*'] };
+            if(ext && renderer?.name) {options.filters = { [renderer.name]: [ext], ['All']: ['*'] };}
             const outUri = await vscode.window.showSaveDialog(options);
             if(outUri){
                 this.lastExportUri = outUri;
                 outFile = outUri.fsPath;
-            } else return;
+            } else {return;}
         }
-        const plt = await this.api.getPlot({ id: this.activePlot, renderer: rendererId }) as any;
+        const plt = await this.api.getPlot({ id: this.activePlot, renderer: rendererId }) as { body: NodeJS.ReadableStream };
         const dest = fs.createWriteStream(outFile);
         dest.on('error', (err) => void vscode.window.showErrorMessage(`Export failed: ${err.message}`));
         dest.on('close', () => void vscode.window.showInformationMessage(`Export done: ${outFile || ''}`));
-        void plt.body.pipe(dest);
+        plt.body.pipe(dest);
     }
 
     public dispose(): void {
@@ -624,10 +623,10 @@ export class HttpgdViewer implements IHttpgdViewer, PlotViewer {
     }
 }
 
-function findItemOfType(arr: any[], type: 'string'): string | undefined;
-function findItemOfType(arr: any[], type: 'boolean'): boolean | undefined;
-function findItemOfType(arr: any[], type: 'number'): number | undefined;
-function findItemOfType<T = unknown>(arr: any[], type: string): T {
+function findItemOfType(arr: unknown[], type: 'string'): string | undefined;
+function findItemOfType(arr: unknown[], type: 'boolean'): boolean | undefined;
+function findItemOfType(arr: unknown[], type: 'number'): number | undefined;
+function findItemOfType<T = unknown>(arr: unknown[], type: string): T {
     const item = arr.find((elm) => typeof elm === type) as T;
     return item;
 }
diff --git a/src/plotViewer/index.ts b/src/plotViewer/index.ts
index 94fb49e1..0c48c7d1 100644
--- a/src/plotViewer/index.ts
+++ b/src/plotViewer/index.ts
@@ -49,7 +49,7 @@ export class CommonPlotManager implements PlotManager {
         for (const cmd of commands) {
             const fullCommand = `r.plot.${cmd}`;
             extensionContext.subscriptions.push(
-                vscode.commands.registerCommand(fullCommand, (hostOrWebviewUri?: string | vscode.Uri, ...args: any[]) => {
+                vscode.commands.registerCommand(fullCommand, (hostOrWebviewUri?: string | vscode.Uri, ...args: unknown[]) => {
                     void this.handleCommand(cmd, hostOrWebviewUri, ...args);
                 })
             );
@@ -64,7 +64,7 @@ export class CommonPlotManager implements PlotManager {
         await this.httpgdManager.showViewer(url);
     }
 
-    private async handleCommand(command: string, hostOrWebviewUri?: string | vscode.Uri, ...args: any[]): Promise<void> {
+    private async handleCommand(command: string, hostOrWebviewUri?: string | vscode.Uri, ...args: unknown[]): Promise<void> {
         if (command === 'showViewers') {
             for (const viewer of this.viewers) {
                 viewer.show(true);
diff --git a/src/plotViewer/standardViewer.ts b/src/plotViewer/standardViewer.ts
index 3c7066ae..622b8c77 100644
--- a/src/plotViewer/standardViewer.ts
+++ b/src/plotViewer/standardViewer.ts
@@ -4,6 +4,11 @@ import { asViewColumn, config, UriIcon } from '../util';
 import { sessionRequest, server } from '../session';
 import { PlotViewer } from './types';
 
+interface PlotResponse {
+    data: string;
+    format: string;
+}
+
 export class StandardPlotViewer implements PlotViewer {
     readonly id: string = 'standard';
     private panel: vscode.WebviewPanel | undefined;
@@ -84,11 +89,11 @@ export class StandardPlotViewer implements PlotViewer {
                 format: format,
                 devArgs: devArgs
             }
-        });
+        }) as PlotResponse | undefined;
 
-        if (response && (response as any).data) {
-            this.plotData = (response as any).data;
-            this.plotFormat = (response as any).format || format;
+        if (response?.data) {
+            this.plotData = response.data;
+            this.plotFormat = response.format || format;
             void this.panel.webview.postMessage({
                 type: 'update',
                 data: this.plotData,
diff --git a/src/plotViewer/types.ts b/src/plotViewer/types.ts
index 9368380b..478c2d29 100644
--- a/src/plotViewer/types.ts
+++ b/src/plotViewer/types.ts
@@ -1,11 +1,9 @@
 
-import * as vscode from 'vscode';
-
 export interface PlotViewer {
     readonly id: string;
     show(preserveFocus?: boolean): void;
     dispose(): void;
-    handleCommand(command: string, ...args: any[]): void | Promise<void>;
+    handleCommand(command: string, ...args: unknown[]): void | Promise<void>;
 }
 
 export interface PlotManager {
diff --git a/src/plotViewer/webview/index.ts b/src/plotViewer/webview/index.ts
index 2afeab74..117fb3fb 100644
--- a/src/plotViewer/webview/index.ts
+++ b/src/plotViewer/webview/index.ts
@@ -64,14 +64,6 @@ function postResizeMessage(userTriggered: boolean = false){
     }
 }
 
-function postLogMessage(content: any){
-    console.log(content);
-    vscode.postMessage({
-        message: 'log',
-        body: content
-    });
-}
-
 window.addEventListener('message', (ev: MessageEvent<InMessage>) => {
     const msg = ev.data;
     if(msg.message === 'updatePlot'){
diff --git a/src/plotViewer/webviewMessages.ts b/src/plotViewer/webviewMessages.ts
index fe4573d1..2cdf8a6b 100644
--- a/src/plotViewer/webviewMessages.ts
+++ b/src/plotViewer/webviewMessages.ts
@@ -7,7 +7,7 @@ export interface VsCode {
 /**
  * Function declared by VS Code in Webview
  */
-export const acquireVsCodeApi: any = (globalThis as any).acquireVsCodeApi;
+export const acquireVsCodeApi: () => VsCode = (globalThis as { acquireVsCodeApi?: () => VsCode }).acquireVsCodeApi || (() => ({} as VsCode));
 
 export interface IMessage {
     message: string;
diff --git a/src/rTerminal.ts b/src/rTerminal.ts
index 7100a628..94dacda8 100644
--- a/src/rTerminal.ts
+++ b/src/rTerminal.ts
@@ -5,11 +5,11 @@ import { isDeepStrictEqual } from 'util';
 
 import * as vscode from 'vscode';
 
-import { extensionContext, homeExtDir } from './extension';
+import { extensionContext } from './extension';
 import * as util from './util';
 import * as selection from './selection';
 import { getSelection } from './selection';
-import { cleanupSession, saveSessionState, clearSessionState, updateSessionTerminalId } from './session';
+import { cleanupSession, saveSessionState, updateSessionTerminalId } from './session';
 import { config, delay, getRterm, getCurrentWorkspaceFolder } from './util';
 import { rGuestService, isGuestSession } from './liveShare';
 import * as fs from 'fs';
diff --git a/src/rstudioapi.ts b/src/rstudioapi.ts
index 4b417d75..72200aa4 100644
--- a/src/rstudioapi.ts
+++ b/src/rstudioapi.ts
@@ -14,7 +14,7 @@ import {
 import { readJSON } from 'fs-extra';
 import * as path from 'path';
 import { sessionDir, sessionDirectoryExists } from './session';
-import { runTextInTerm, restartRTerminal, chooseTerminal } from './rTerminal';
+import { runTextInTerm, chooseTerminal } from './rTerminal';
 import { config } from './util';
 
 let lastActiveTextEditor: TextEditor;
@@ -160,7 +160,7 @@ export async function documentClose(id: string | null, save: boolean): Promise<v
         await targetDocument.save();
     }
     const tabs = window.tabGroups.all.flatMap(g => g.tabs);
-    const targetTabs = tabs.filter(t => (t.input as any)?.uri?.toString() === target.toString());
+    const targetTabs = tabs.filter(t => (t.input as { uri?: Uri })?.uri?.toString() === target.toString());
     await window.tabGroups.close(targetTabs);
 }
 
diff --git a/src/session.ts b/src/session.ts
index d9a89c49..415faefb 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -1059,7 +1059,7 @@ export async function sessionRequest(server: SessionServer, data: Record<string,
             pendingRequests.set(id, { resolve, reject });
             
             try {
-                wsClient!.send(JSON.stringify(payload));
+                wsClient?.send(JSON.stringify(payload));
             } catch (e) {
                 pendingRequests.delete(id);
                 reject(e);
diff --git a/src/test/suite/terminal.test.ts b/src/test/suite/terminal.test.ts
index 547b66bf..03915b9c 100644
--- a/src/test/suite/terminal.test.ts
+++ b/src/test/suite/terminal.test.ts
@@ -41,7 +41,7 @@ suite('R Terminal', () => {
                 return undefined;
             }
         };
-        sandbox.stub(util, 'config').returns(configStub as any);
+        sandbox.stub(util, 'config').returns(configStub as unknown as vscode.WorkspaceConfiguration);
         sandbox.stub(util, 'getRterm').resolves('/usr/local/bin/R');
 
         const options = await rTerminal.makeTerminalOptions();
@@ -65,7 +65,7 @@ suite('R Terminal', () => {
                 return undefined;
             }
         };
-        sandbox.stub(util, 'config').returns(configStub as any);
+        sandbox.stub(util, 'config').returns(configStub as unknown as vscode.WorkspaceConfiguration);
         sandbox.stub(util, 'getRterm').resolves('/usr/local/bin/R');
 
         const options = await rTerminal.makeTerminalOptions();
@@ -82,7 +82,7 @@ suite('R Terminal', () => {
                 return undefined;
             }
         };
-        sandbox.stub(util, 'config').returns(configStub as any);
+        sandbox.stub(util, 'config').returns(configStub as unknown as vscode.WorkspaceConfiguration);
         sandbox.stub(util, 'getRterm').resolves('/usr/local/bin/R');
 
         // Spy on startSessionWatcher
@@ -122,24 +122,24 @@ suite('R Terminal', () => {
                 return undefined;
             }
         };
-        sandbox.stub(util, 'config').returns(configStub as any);
+        sandbox.stub(util, 'config').returns(configStub as unknown as vscode.WorkspaceConfiguration);
         sandbox.stub(util, 'getRterm').resolves('/usr/local/bin/R');
 
         // We need to mock the terminal and its processId
         const fakeTerminal = {
             name: 'R Interactive',
             processId: Promise.resolve(1234),
-            show: () => { },
-            dispose: () => { },
-            sendText: () => { }
+            show: () => { /* empty */ },
+            dispose: () => { /* empty */ },
+            sendText: () => { /* empty */ }
         };
-        const createTerminalStub = sandbox.stub(vscode.window, 'createTerminal').returns(fakeTerminal as any);
+        const createTerminalStub = sandbox.stub(vscode.window, 'createTerminal').returns(fakeTerminal as unknown as vscode.Terminal);
 
         const result = await rTerminal.createRTerm(true);
         assert.ok(result);
 
         // Manually trigger session activation as if the R process connected back
-        const fakeSession: any = {
+        const fakeSession = {
             pid: '1234',
             rVer: '4.0.0',
             info: {},
@@ -147,10 +147,10 @@ suite('R Terminal', () => {
             workingDir: '',
             workspaceData: { search: [], loaded_namespaces: [], globalenv: {} },
             server: { host: '127.0.0.1', port: 1234, token: 'abc' },
-            ws: {} as any
+            ws: {} as unknown as session.Session['ws']
         };
 
-        await session.activateSession(fakeSession);
+        await session.activateSession(fakeSession as session.Session);
 
         assert.ok(session.activeSession, 'Active session should be defined');
         assert.ok(rTerminal.rTerm, 'rTerminal.rTerm should be defined');

From d70152a4ec76ba1632be05add27b997d1e734eab Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Sat, 14 Mar 2026 14:30:19 -0700
Subject: [PATCH 46/47] fix: resolve TypeScript errors in tests and httpgd
 export

---
 src/plotViewer/httpgdViewer.ts  | 2 +-
 src/rstudioapi.ts               | 2 ++
 src/test/suite/terminal.test.ts | 4 ++--
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/plotViewer/httpgdViewer.ts b/src/plotViewer/httpgdViewer.ts
index 65d9aa28..432ffe0d 100644
--- a/src/plotViewer/httpgdViewer.ts
+++ b/src/plotViewer/httpgdViewer.ts
@@ -611,7 +611,7 @@ export class HttpgdViewer implements IHttpgdViewer, PlotViewer {
                 outFile = outUri.fsPath;
             } else {return;}
         }
-        const plt = await this.api.getPlot({ id: this.activePlot, renderer: rendererId }) as { body: NodeJS.ReadableStream };
+        const plt = await this.api.getPlot({ id: this.activePlot, renderer: rendererId }) as unknown as { body: NodeJS.ReadableStream };
         const dest = fs.createWriteStream(outFile);
         dest.on('error', (err) => void vscode.window.showErrorMessage(`Export failed: ${err.message}`));
         dest.on('close', () => void vscode.window.showInformationMessage(`Export done: ${outFile || ''}`));
diff --git a/src/rstudioapi.ts b/src/rstudioapi.ts
index 72200aa4..cc1cad13 100644
--- a/src/rstudioapi.ts
+++ b/src/rstudioapi.ts
@@ -1,3 +1,5 @@
+'use strict';
+
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/restrict-plus-operands */
 /* eslint-disable @typescript-eslint/restrict-template-expressions */
diff --git a/src/test/suite/terminal.test.ts b/src/test/suite/terminal.test.ts
index 03915b9c..feae4cea 100644
--- a/src/test/suite/terminal.test.ts
+++ b/src/test/suite/terminal.test.ts
@@ -142,7 +142,7 @@ suite('R Terminal', () => {
         const fakeSession = {
             pid: '1234',
             rVer: '4.0.0',
-            info: {},
+            info: { version: '4.0.0', command: 'R', start_time: '2021-01-01T00:00:00Z' },
             sessionDir: '',
             workingDir: '',
             workspaceData: { search: [], loaded_namespaces: [], globalenv: {} },
@@ -150,7 +150,7 @@ suite('R Terminal', () => {
             ws: {} as unknown as session.Session['ws']
         };
 
-        await session.activateSession(fakeSession as session.Session);
+        await session.activateSession(fakeSession as unknown as session.Session);
 
         assert.ok(session.activeSession, 'Active session should be defined');
         assert.ok(rTerminal.rTerm, 'rTerminal.rTerm should be defined');

From cc3d1543c7d6b08913078b9e2213f211ebe91284 Mon Sep 17 00:00:00 2001
From: Randy Lai <randy.cs.lai@gmail.com>
Date: Sat, 14 Mar 2026 14:34:16 -0700
Subject: [PATCH 47/47] refactor: remove eslint-disable and fix lint errors in
 rstudioapi.ts

---
 src/rstudioapi.ts | 80 ++++++++++++++++++++++++++++++++---------------
 src/session.ts    |  6 ++--
 2 files changed, 58 insertions(+), 28 deletions(-)

diff --git a/src/rstudioapi.ts b/src/rstudioapi.ts
index cc1cad13..4de8e0f0 100644
--- a/src/rstudioapi.ts
+++ b/src/rstudioapi.ts
@@ -1,13 +1,5 @@
 'use strict';
 
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/restrict-plus-operands */
-/* eslint-disable @typescript-eslint/restrict-template-expressions */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import {
     window, TextEditor, TextDocument, Uri,
     workspace, WorkspaceEdit, Position, Range, Selection,
@@ -21,10 +13,41 @@ import { config } from './util';
 
 let lastActiveTextEditor: TextEditor;
 
+// Types for rstudioapi
+export type RSCoord = number | 'Inf' | '-Inf';
+
+export interface RSPosition {
+    [index: number]: RSCoord;
+    length: number;
+}
+
+export interface RSRange {
+    start: RSPosition;
+    end: RSPosition;
+}
+
+export interface RSEditOperation {
+    operation: 'insertText' | 'modifyRange';
+    text: string;
+    location: RSPosition | RSRange;
+}
+
+interface RSSelection {
+    start: { line: number; character: number };
+    end: { line: number; character: number };
+}
+
+interface RSDocumentContext {
+    id: { external: string };
+    contents: string;
+    path: string;
+    selection: RSSelection[];
+}
+
 // dispatchRStudioAPICall removed
 
 //rstudioapi
-export function activeEditorContext() {
+export function activeEditorContext(): RSDocumentContext {
     // info returned from RStudio:
     // list with:
     // id
@@ -44,7 +67,7 @@ export function activeEditorContext() {
     };
 }
 
-export async function documentContext(id: string | null) {
+export async function documentContext(id: string | null): Promise<{ id: { external: string } }> {
     const target = findTargetUri(id);
     const targetDocument = await workspace.openTextDocument(target);
     console.info(`[documentContext] getting context for: ${target.path}`);
@@ -53,7 +76,7 @@ export async function documentContext(id: string | null) {
     };
 }
 
-export async function insertOrModifyText(query: any[], id: string | null = null) {
+export async function insertOrModifyText(query: RSEditOperation[], id: string | null = null): Promise<void> {
 
 
     const target = findTargetUri(id);
@@ -64,16 +87,16 @@ export async function insertOrModifyText(query: any[], id: string | null = null)
     query.forEach((op) => {
         assertSupportedEditOperation(op.operation);
 
-        let editLocation: any;
+        let editLocation: Position | Range;
         const editText = normaliseEditText(op.text, op.location, op.operation, targetDocument);
 
         if (op.operation === 'insertText') {
-            editLocation = parsePosition(op.location, targetDocument);
+            editLocation = parsePosition(op.location as RSPosition, targetDocument);
             console.info(`[insertTextAtPosition] inserting at: ${JSON.stringify(editLocation)}`);
             console.info(`[insertTextAtPosition] inserting text: ${editText}`);
             edit.insert(target, editLocation, editText);
         } else {
-            editLocation = parseRange(op.location, targetDocument);
+            editLocation = parseRange(op.location as RSRange, targetDocument);
             console.info(`[insertTextAtPosition] replacing at: ${JSON.stringify(editLocation)}`);
             console.info(`[insertTextAtPosition] replacing with text: ${editText}`);
             edit.replace(target, editLocation, editText);
@@ -110,7 +133,7 @@ export async function navigateToFile(file: string, line: number, column: number)
     editor.revealRange(new Range(targetPosition, targetPosition));
 }
 
-export async function setSelections(ranges: number[][], id: string | null): Promise<void> {
+export async function setSelections(ranges: RSRange[], id: string | null): Promise<void> {
     // Setting selections can only be done on TextEditors not TextDocuments, but
     // it is the latter which are the things actually referred to by `id`. In
     // VSCode it's not possible to get a list of the open text editors. it is not
@@ -235,12 +258,19 @@ interface AddinItem extends QuickPickItem {
 
 let addinQuickPicks: AddinItem[] | undefined = undefined;
 
+interface RawAddin {
+    package: string;
+    name: string;
+    description: string;
+    binding: string;
+}
+
 export async function getAddinPickerItems(): Promise<AddinItem[]> {
 
     if (typeof addinQuickPicks === 'undefined') {
-        const addins: any[] = await readJSON(path.join(sessionDir, 'addins.json')).
+        const addins: RawAddin[] = await readJSON(path.join(sessionDir, 'addins.json')).
             then(
-                (result) => result,
+                (result: RawAddin[]) => result,
                 () => {
                     throw ('Could not find list of installed addins.' +
                         ' options(vsc.rstudioapi = TRUE) must be set in your .Rprofile to use ' +
@@ -312,7 +342,7 @@ export async function sendCodeToRTerminal(code: string, execute: boolean, focus:
 }
 
 //utils
-function toVSCCoord(coord: any) {
+function toVSCCoord(coord: RSCoord) {
     // this is necessary because RStudio will accept negative or infinite values,
     // replacing them with the min or max or the document.
     // These must be clamped non-negative integers accepted by VSCode.
@@ -323,7 +353,7 @@ function toVSCCoord(coord: any) {
         coord_value = 10000000;
     } else if (coord === '-Inf') {
         coord_value = 0;
-    } else if (coord <= 0) {
+    } else if (typeof coord === 'number' && coord <= 0) {
         coord_value = 0;
     }
     else { // coord > 0
@@ -334,7 +364,7 @@ function toVSCCoord(coord: any) {
 
 }
 
-function parsePosition(rs_position: any[], targetDocument: TextDocument) {
+function parsePosition(rs_position: RSPosition, targetDocument: TextDocument) {
     if (rs_position.length !== 2) {
         throw ('an rstudioapi position must be an array of 2 numbers');
     }
@@ -344,7 +374,7 @@ function parsePosition(rs_position: any[], targetDocument: TextDocument) {
         ));
 }
 
-function parseRange(rs_range: any, targetDocument: TextDocument) {
+function parseRange(rs_range: RSRange, targetDocument: TextDocument) {
     if (rs_range.start.length !== 2 || rs_range.end.length !== 2) {
         throw ('an rstudioapi range must be an object containing two numeric arrays');
     }
@@ -363,16 +393,16 @@ function assertSupportedEditOperation(operation: string) {
     }
 }
 
-function normaliseEditText(text: string, editLocation: any,
+function normaliseEditText(text: string, editLocation: RSPosition | RSRange,
     operation: string, targetDocument: TextDocument) {
     // in a document with lines, does the line position extend past the existing
     // lines in the document? rstudioapi adds a newline in this case, so must we.
     // n_lines is a count, line is 0 indexed position hence + 1
     const editStartLine = operation === 'insertText' ?
-        editLocation[0] :
-        editLocation.start[0];
+        (editLocation as RSPosition)[0] :
+        (editLocation as RSRange).start[0];
     if (editStartLine === 'Inf' ||
-        (editStartLine + 1 > targetDocument.lineCount && targetDocument.lineCount > 0)) {
+        (typeof editStartLine === 'number' && editStartLine + 1 > targetDocument.lineCount && targetDocument.lineCount > 0)) {
         return (text + '\n');
     } else {
         return text;
diff --git a/src/session.ts b/src/session.ts
index 415faefb..12fc17cf 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -7,7 +7,7 @@ import { commands, Uri, ViewColumn, Webview, window, workspace, env } from 'vsco
 
 import { restartRTerminal, createRTerm } from './rTerminal';
 import { config, readContent, setContext, UriIcon } from './util';
-import { purgeAddinPickerItems } from './rstudioapi';
+import { purgeAddinPickerItems, RSEditOperation, RSRange } from './rstudioapi';
 
 import { homeExtDir, rWorkspace, globalRHelp, globalPlotManager, extensionContext, sessionStatusBarItem } from './extension';
 import { rHostService, rGuestService, isLiveShare, isHost, isGuestSession, guestResDir, shareBrowser, openVirtualDoc } from './liveShare';
@@ -932,7 +932,7 @@ async function handleRequest(message: Record<string, unknown>, ws: ExtWebSocket)
                     result = rstudioapi.activeEditorContext();
                     break;
                 case 'rstudioapi/insert_or_modify_text':
-                    await rstudioapi.insertOrModifyText(params.query as Record<string, unknown>[], params.id as string | null);
+                    await rstudioapi.insertOrModifyText(params.query as RSEditOperation[], params.id as string | null);
                     result = true;
                     break;
                 case 'rstudioapi/replace_text_in_current_selection':
@@ -948,7 +948,7 @@ async function handleRequest(message: Record<string, unknown>, ws: ExtWebSocket)
                     result = true;
                     break;
                 case 'rstudioapi/set_selection_ranges':
-                    await rstudioapi.setSelections(params.ranges as number[][], params.id as string | null);
+                    await rstudioapi.setSelections(params.ranges as RSRange[], params.id as string | null);
                     result = true;
                     break;
                 case 'rstudioapi/document_save':