@jxsuite/studio 5.0.0 → 5.2.0

package/src/grid/grid-open.ts

@@ -30,11 +30,25 @@ import type { AnyCommand, CommandRegistry } from "../commands/registry";
 /** Placeholder document for grid tabs — the grid never reads it; save routes to the controller. */
 const GRID_STUB_DOCUMENT = { children: [], tagName: "div" };
 
-/** Open (or activate) a `.csv` file as a grid tab. */
-export async function openCsvGridTab(path: string): Promise<Tab> {
+/**
+ * Open (or activate) a `.csv` file as a grid tab.
+ *
+ * The options are `openFileInTab`'s own, passed straight through: `paneId` says which pane the tab
+ * lands in (defaulting to the focused one), `focus: false` browses without moving the keyboard, and
+ * `preview` opens a disposable tab. An existing tab is activated with the caller's `focus` — the
+ * same rule the document path follows.
+ *
+ * @param {string} path - Project-relative path of the `.csv`
+ * @param {{ paneId?: string; focus?: boolean; preview?: boolean }} [opts]
+ * @returns {Promise<Tab>}
+ */
+export async function openCsvGridTab(
+  path: string,
+  opts: { paneId?: string; focus?: boolean; preview?: boolean } = {},
+): Promise<Tab> {
   const existing = workspace.tabs.get(path);
   if (existing) {
-    activateTab(path);
+    activateTab(path, { focus: opts.focus !== false });
     return existing;
   }
 
@@ -52,6 +66,9 @@ export async function openCsvGridTab(path: string): Promise<Tab> {
     documentPath: path,
     id: path,
     sourceFormat: formatForPath(path)?.name ?? null,
+    ...(opts.paneId !== undefined && { paneId: opts.paneId }),
+    ...(opts.preview === true && { preview: true }),
+    ...(opts.focus === false && { focus: false }),
   });
   const controller = createGridController(tab, source);
   void controller.load();

package/src/grid/grid-panel.ts

@@ -39,7 +39,7 @@ import { rectOf } from "../utils/geometry";
 import { activeTab, workspace } from "../workspace/workspace";
 import { createGridController, getGridController } from "./grid-controller";
 import { createCsvFileSource } from "./sources/csv-file-source";
-import { createGridView } from "./grid-view";
+import { loadedGridEngine, loadGridEngine } from "./grid-lazy";
 import { parseGridTabId } from "./grid-source";
 import { mountGridPanelSurface } from "../surfaces/grid-panel";
 import { openGridViewsSurface } from "../surfaces/grid-views";
@@ -473,12 +473,45 @@ export function renderGridMode(surface: CanvasSurface, tab: Tab) {
   const engine = controller;
   let hostEl: HTMLElement | null = null;
 
+  /**
+   * (Re)build the Tabulator engine over `host`, destroying whatever view is live first.
+   *
+   * Synchronous when `tabulator-tables` is already loaded — true for every mount after the
+   * session's first, so every existing caller keeps seeing `panel.view` set before this returns. On
+   * a cold first load it goes through `loadGridEngine()` instead (see `grid-lazy.ts`) and `onReady`
+   * — and, symmetrically with the `ready` handling below, `panel.bump()` — run once the import
+   * resolves, guarded against the pane having moved on in the meantime.
+   */
+  function rebuildView(onReady?: (view: GridView) => void) {
+    panel.view?.destroy();
+    panel.view = null;
+    if (!hostEl) {
+      return;
+    }
+    const requestedHost = hostEl;
+    const loaded = loadedGridEngine();
+    if (loaded) {
+      const view = loaded.createGridView(requestedHost, engine);
+      panel.view = view;
+      onReady?.(view);
+      return;
+    }
+    void loadGridEngine().then(({ createGridView }) => {
+      if (activeIn(paneId) !== panel || hostEl !== requestedHost || panel.view) {
+        return;
+      }
+      const view = createGridView(requestedHost, engine);
+      panel.view = view;
+      onReady?.(view);
+      panel.bump();
+    });
+  }
+
   const panel: ActiveGridPanel = {
     applyLayout(layout) {
       void engine.setSort(layout?.sort ?? null);
       engine.setGrouping(layout?.groupBy ?? null);
-      panel.remount();
-      panel.view?.setSearch(layout?.filter ?? "");
+      rebuildView((view) => view.setSearch(layout?.filter ?? ""));
       panel.bump();
     },
     bump() {
@@ -486,8 +519,7 @@ export function renderGridMode(surface: CanvasSurface, tab: Tab) {
     },
     paneId,
     remount() {
-      panel.view?.destroy();
-      panel.view = hostEl ? createGridView(hostEl, engine) : null;
+      rebuildView();
     },
     replace: null,
     scope,
@@ -576,14 +608,16 @@ export function renderGridMode(surface: CanvasSurface, tab: Tab) {
 
       // Create the engine once the columns exist and the host div is in the DOM.
       if (!panel.view && !engine.state.loading && engine.state.columns.length > 0 && hostEl) {
-        panel.view = createGridView(hostEl, engine);
-        if (!restored) {
+        rebuildView((view) => {
+          if (restored) {
+            return;
+          }
           restored = true;
           const layout = loadGridLayout(engine.source.id);
           void engine.setSort(layout?.sort ?? null);
           engine.setGrouping(layout?.groupBy ?? null);
-          panel.view.setSearch(layout?.filter ?? "");
-        }
+          view.setSearch(layout?.filter ?? "");
+        });
       }
     });
   });

package/src/i18n/i18n-commands.ts

@@ -195,6 +195,14 @@ export function i18nCommands(): AnyCommand[] {
       menus: ["context/tab", "palette"],
       group: "2_navigate",
       requires: "a document open in a project that declares more than one language",
+      /* `ctx.document.open` stays in the gate although `path` no longer needs a document open
+         (issue 333). `registry.run` evaluates `when` BEFORE `run` and refuses with
+         `CommandUnavailableError`, so relaxing it is the only way `{ locale, path }` could run with
+         no document open — and `when` reads the context, not the arguments, so the same relaxation
+         would light the palette row too, where the record runs with no `path` and would then throw
+         `addressedDocument`'s "needs a document open" out of a click instead of standing disabled
+         with its `requires` sentence. The palette's availability is the person's contract; an
+         argument-only gate needs a shape the registry does not have. Same on `createTranslation`. */
       when: (ctx) => ctx.project.isMultilingual && ctx.document.open,
       /* No `aiTool`, by §12.4's first deletion rule: this opens a surface for a person, and the
          model has `open_document` for the file it names. */
@@ -247,6 +255,8 @@ export function i18nCommands(): AnyCommand[] {
       menus: ["palette"],
       group: "2_navigate",
       requires: "a document open in a project that declares more than one language",
+      // `document.open` stays for the reason `i18n.openTranslation` gives: the gate runs before
+      // `run`, and it cannot see `path`.
       when: (ctx) => ctx.project.isMultilingual && ctx.document.open,
       /* The document history cannot hold this: the change is a file that did not exist, and
          `undo: "project"` would claim `project.json` moved, which it did not. */

package/src/media/media-open.ts

@@ -39,13 +39,22 @@ export function mediaTabModes(path: string): string[] {
 /**
  * Open (or activate) a media file's viewer tab.
  *
+ * The options are `openFileInTab`'s own, passed straight through: `paneId` says which pane the tab
+ * lands in (defaulting to the focused one), `focus: false` browses without moving the keyboard, and
+ * `preview` opens a disposable tab. An existing tab is activated with the caller's `focus` — the
+ * same rule the document path follows.
+ *
  * @param {string} path - Project-relative path of the file
+ * @param {{ paneId?: string; focus?: boolean; preview?: boolean }} [opts]
  * @returns {Tab}
  */
-export function openMediaTab(path: string): Tab {
+export function openMediaTab(
+  path: string,
+  opts: { paneId?: string; focus?: boolean; preview?: boolean } = {},
+): Tab {
   const existing = workspace.tabs.get(path);
   if (existing) {
-    activateTab(path);
+    activateTab(path, { focus: opts.focus !== false });
     return existing;
   }
   return openTab({
@@ -54,5 +63,8 @@ export function openMediaTab(path: string): Tab {
     documentPath: path,
     id: path,
     sourceFormat: null,
+    ...(opts.paneId !== undefined && { paneId: opts.paneId }),
+    ...(opts.preview === true && { preview: true }),
+    ...(opts.focus === false && { focus: false }),
   });
 }

package/src/packages/pull-package-sync.ts

@@ -19,7 +19,11 @@ import type { GitStatusResult } from "../types";
 
 const PKG_PATHS = ["package.json", "bun.lock", "bun.lockb"];
 
-/** Untracked markers across backends: desktop porcelain v1 emits "??", server porcelain v2 "U". */
+/**
+ * Untracked markers across backends. Every backend says `U` now — the desktop used to pass
+ * porcelain v1's raw `??` through, and this set is what kept package sync working while it did.
+ * `??` stays accepted so a Studio bundle ahead of its desktop host keeps working.
+ */
 const UNTRACKED_STATUSES = new Set(["??", "U"]);
 
 /** Above this many dirty files, skip the per-file upstream comparison and leave the error as-is. */

package/src/panels/ai-panel.ts

@@ -44,6 +44,7 @@ import { onCredentialsChanged } from "../settings/preferences-accounts";
 import { setDockCollapsed } from "../shell";
 import { hasSelection } from "../commands/context";
 import { activeRegistry } from "../commands/active-registry";
+import { runReported } from "../commands/run-reported";
 import { clearMarkdownCache } from "./ai-chat/chat-markdown";
 import {
   formatErrorAdvice,
@@ -158,12 +159,14 @@ export function renderAiPanel(): void {
  * Re-asked at click time, not trusted from the projection: state moves between the two, and
  * `registry.run` THROWS on a refusal. Same bargain `registry.handleKeyEvent` strikes for a chord
  * bound to a disabled command — swallow it here rather than make every surface wrap a dispatch in
- * try/catch.
+ * try/catch. What the gate lets through still runs through `commands/run-reported.ts`: a `run` body
+ * that rejects, or a schema the record has drifted from, is a sentence in Problems rather than an
+ * exception out of the click.
  */
 function runCommand(id: string): void {
   const registry = activeRegistry();
   if (registry?.isEnabled(id)) {
-    void registry.run(id);
+    void runReported(registry, id, undefined, "Assistant");
   }
 }
 

package/src/panels/block-action-bar.ts

@@ -70,6 +70,7 @@ import { showSlashMenu } from "../editor/slash-menu";
 import { getConvertTargets } from "../editor/convert-targets";
 import { rectOf } from "../utils/geometry";
 import { createCommandRegistry } from "../commands/registry";
+import { runReported } from "../commands/run-reported";
 import { editorKindForMode, makeContext } from "../commands/context";
 import { defaultCommands, noopCommandDeps } from "../commands/defaults";
 import { emptyBlockBarView, mountBlockActionBar } from "../surfaces/block-action-bar";
@@ -845,11 +846,15 @@ export function commandTooltip(registry: CommandRegistry, command: AnyCommand):
   return chord ? `${command.title} (${chord})` : command.title;
 }
 
-/** Run a command, swallowing the refusal a disabled control should never have produced. */
+/**
+ * Run a command, swallowing the refusal a disabled control should never have produced — and
+ * reporting, through `commands/run-reported.ts`, the one an enabled control can still meet: a `run`
+ * body that throws or rejects.
+ */
 export function runCommand(registry: CommandRegistry, id: string, target?: JxPath | null): void {
   const invoke = () => {
     if (registry.isEnabled(id)) {
-      void registry.run(id);
+      void runReported(registry, id, undefined, "Editor");
     }
   };
   if (target) {

package/src/panels/i18n-panel.ts

@@ -41,6 +41,7 @@
  */
 
 import { activeRegistry } from "../commands/active-registry";
+import { runReported } from "../commands/run-reported";
 import { errorMessage } from "@jxsuite/schema/parse";
 import { getEffectiveLocales } from "../site-context";
 import { getPlatform } from "../platform";
@@ -51,7 +52,6 @@ import {
   translationPathFor,
 } from "@jxsuite/schema/locale";
 import { mountI18nSurface } from "../surfaces/panel-i18n";
-import { notify } from "../services/notify";
 import { nothing } from "lit-html";
 import { projectState } from "../store";
 import { registerPanel } from "./panel-registry";
@@ -386,26 +386,19 @@ function cellTitle(cell: ParityCell, locale: string, refusal: string | undefined
  * already there, and a click that produced nothing and printed nothing would leave the author
  * looking at a grid that disagrees with the disk.
  *
- * Both shapes, as `panels/quick-search.ts`'s `runCommand` and `panels/settings-menu.ts`'s `runRow`
- * catch them: `registry.run` throws SYNCHRONOUSLY when the record refuses the arguments — it
- * coerces `{ locale, path }` against the record's schema before `run` is entered — and a
- * `Promise.resolve(...)` around a call that has already thrown catches nothing. That refusal was
- * every cell click for as long as the records did not declare `path`; the report is what makes the
- * next such drift a sentence in the Problems panel rather than an exception out of a click.
+ * Both shapes, through `commands/run-reported.ts`: `registry.run` throws SYNCHRONOUSLY when the
+ * record refuses the arguments — it coerces `{ locale, path }` against the record's schema before
+ * `run` is entered — and a `Promise.resolve(...)` around a call that has already thrown catches
+ * nothing. That refusal was every cell click for as long as the records did not declare `path`; the
+ * report is what makes the next such drift a sentence in the Problems panel rather than an
+ * exception out of a click.
  */
 function runByName(id: string, args: Record<string, unknown> = {}): void {
   const registry = activeRegistry();
   if (!registry?.get(id)) {
     return;
   }
-  const report = (error: unknown) => {
-    notify("error", errorMessage(error), { source: "Languages" });
-  };
-  try {
-    void Promise.resolve(registry.run(id, args)).catch(report);
-  } catch (error) {
-    report(error);
-  }
+  void runReported(registry, id, args, "Languages");
 }
 
 /**

package/src/panels/jump-bar.ts

@@ -58,6 +58,7 @@ import { derivationOfPane, tabOfPane } from "../canvas/canvas-surface";
 import { paneRegion } from "../ui/regions";
 import { primarySelection } from "../tabs/selection";
 import { activeRegistry } from "../commands/active-registry";
+import { runReported } from "../commands/run-reported";
 import { openMenu } from "../surfaces/menu";
 import { mountJumpBarSurface } from "../surfaces/jump-bar";
 import { PANE_SELECTOR } from "../surfaces/pane-grid";
@@ -427,7 +428,7 @@ function openChoices(segment: JumpSegment, anchor: HTMLElement | null): void {
     dividerAbove: false,
     id: String(i),
     run: () => {
-      void registry.run(choice.command, choice.args);
+      void runReported(registry, choice.command, choice.args, "Jump Bar");
     },
     title: choice.label,
   }));
@@ -544,7 +545,7 @@ export function attachJumpBarHost(paneId: string, host: HTMLElement | null): voi
         const segment = _bars.get(paneId)?.segments.get(key);
         const registry = activeRegistry();
         if (segment?.command && registry) {
-          void registry.run(segment.command, segment.args);
+          void runReported(registry, segment.command, segment.args, "Jump Bar");
         }
       },
     }),

package/src/panels/pane-context.ts

@@ -500,10 +500,11 @@ export interface PresetRow {
    *
    * The previous round made the row's ANSWER a pure function of the pane and left its ACTION
    * resolving the focus: every one of these three commands takes the focused pane as its subject
-   * (`pane.derive`'s `activePane()`/`sidePane()`, `pane.unsplit`'s `workspace.activePaneId`), so a
-   * row read off the secondary pane's menu derived from the primary. Reachable by keyboard and only
-   * by keyboard, which is why it survived a browser pass: `panels/pane-grid.ts` focuses a pane on
-   * POINTERDOWN, and a keyboard activation of a menu item fires `click` alone.
+   * (`pane.derive`'s `activePane()`/`paneBeside(source.id)`, `pane.unsplit`'s
+   * `workspace.activePaneId`), so a row read off the secondary pane's menu derived from the
+   * primary. Reachable by keyboard and only by keyboard, which is why it survived a browser pass:
+   * `panels/pane-grid.ts` focuses a pane on POINTERDOWN, and a keyboard activation of a menu item
+   * fires `click` alone.
    *
    * Carried on the row rather than passed as a command argument. A pane id in `args` would make
    * "which pane" a public input of `pane.derive` — a third property on a record the palette already

package/src/panels/pane-grid.ts

@@ -11,20 +11,22 @@
  * that scaffolding was standing in for, and the handover is deleted with it.
  *
  * **The document owns the frame; this module owns the decisions.** `surfaces/pane-grid.json` is the
- * cells, the four boxes inside each one, the splitter between two of them and every rule that lays
+ * cells, the five boxes inside each one, the splitter between two of them and every rule that lays
  * them out; `surfaces/pane-grid.ts` is the mount. What is left here is the flow: which panes there
  * are, what a cell's stage is furnished with, in what ORDER a departing cell is taken apart, and
  * what the grid's own tracks are. Everything a cell CONTAINS still arrives through the module that
  * owns it — `canvas/canvas-render.ts` is the render root of the stage and this document puts
  * nothing inside it, `panels/jump-bar.ts` and `panels/pane-context.ts` are handed the jump and
- * chrome boxes, and `panels/tab-strip.ts` is handed the strip.
+ * chrome boxes, `panels/tab-strip.ts` is handed the strip, and this module makes the fifth — the
+ * right-edge drop zone — a pragmatic target itself.
  *
  * **Three properties survived the conversion, and each is structural rather than remembered:**
  *
  * 1. _A pane is complete before it is published._ The runtime builds a `$map` row inside its own
- *    effect scope and inserts it afterwards, so the four `cellPart` calls below — the surface
- *    record, the gestures, the two bars' mounts, the pane-focus listener — all happen while the
- *    cell is still detached. There is no frame in which a cell exists with no stage inside it.
+ *    effect scope and inserts it afterwards, so the five `cellPart` calls below — the surface
+ *    record, the gestures, the two bars' mounts, the pane-focus listener, the drop zone's own
+ *    registration — all happen while the cell is still detached. There is no frame in which a cell
+ *    exists with no stage inside it.
  * 2. _A pane's node is never re-parented._ The repeater is keyed on the pane id and the runtime's
  *    forward-cursor pass only moves rows that are out of place. `workspace.panes[0]` is always the
  *    primary and `MAX_PANES` is 2, so no row ever moves — which matters because re-parenting is not
@@ -54,6 +56,12 @@
  */
 
 import { effect, effectScope } from "../reactivity";
+import {
+  dropTargetForElements,
+  monitorForElements,
+} from "@atlaskit/pragmatic-drag-and-drop/element/adapter";
+import { isTabDropSource } from "./tab-drop";
+import { rectOf } from "../utils/geometry";
 import {
   DEFAULT_PANE_SPLIT,
   PANE_SPLIT_MAX,
@@ -74,13 +82,13 @@ import { scheduleCanvasRender } from "../canvas/canvas-render";
 import { paneRegion, paneStripRegion } from "../ui/regions";
 import { attachJumpBarHost } from "./jump-bar";
 import { attachPaneChromeHost } from "./pane-context";
-import { focusPane, workspace } from "../workspace/workspace";
+import { MAX_PANES, focusPane, workspace } from "../workspace/workspace";
 import { mountPaneGridSurface } from "../surfaces/pane-grid";
 import type { EffectScope } from "@vue/reactivity";
 import type { CanvasSurface } from "../canvas/canvas-surface";
 import type { PaneCellPart, PaneGridRow, PaneGridSurface } from "../surfaces/pane-grid";
 
-/** One drawn pane: its root and the four surfaces inside it. */
+/** One drawn pane: its root and the five surfaces inside it. */
 export interface PaneCell {
   paneId: string;
   root: HTMLElement;
@@ -88,13 +96,16 @@ export interface PaneCell {
   jump: HTMLElement;
   chrome: HTMLElement;
   stage: HTMLElement;
+  dropZone: HTMLElement;
   surface: CanvasSurface;
 }
 
-/** A cell's record, plus the disposer its stage gestures live behind. */
+/** A cell's record, plus the disposers its stage gestures and its drop zone live behind. */
 interface CellState extends PaneCell {
   /** Stage-gesture disposer, live between the stage's creation and the cell's disposal. */
   releaseGestures: (() => void) | null;
+  /** The drop zone's pragmatic registration, live between its creation and the cell's disposal. */
+  releaseDropZone: (() => void) | null;
 }
 
 const _cells = new Map<string, CellState>();
@@ -110,6 +121,13 @@ let _drawn: string[] = [];
 
 let _scope: EffectScope | null = null;
 
+/**
+ * The monitor that ARMS the right-edge zones — `_surface.drag`'s one writer. It never resolves a
+ * drop; `panels/tab-strip.ts`'s own monitor does that, from the same drop targets this one only
+ * watches.
+ */
+let _dragMonitor: (() => void) | null = null;
+
 /** The cell a pane is drawn in, or null. Test-visible, and the bootstrap's handle on the primary. */
 export function cellForPane(paneId: string): PaneCell | null {
   return _cells.get(paneId) ?? null;
@@ -120,7 +138,7 @@ export function cellForPane(paneId: string): PaneCell | null {
  *
  * The mount is asynchronous — the runtime waits for the kit to be defined and renders one microtask
  * after that — so `mountShell()` starting the grid is not the same event as the grid existing. The
- * bootstrap reads the primary cell's four boxes on the line after it, exactly as `mountShellTree()`
+ * bootstrap reads the primary cell's five boxes on the line after it, exactly as `mountShellTree()`
  * made every caller await the frame for the same reason.
  */
 export function paneGridReady(): Promise<void> {
@@ -142,8 +160,10 @@ function cellState(paneId: string): CellState {
   }
   const cell: CellState = {
     chrome: null as unknown as HTMLElement,
+    dropZone: null as unknown as HTMLElement,
     jump: null as unknown as HTMLElement,
     paneId,
+    releaseDropZone: null,
     releaseGestures: null,
     root: null as unknown as HTMLElement,
     stage: null as unknown as HTMLElement,
@@ -217,7 +237,52 @@ function attachStage(cell: CellState, stage: HTMLElement): void {
 }
 
 /**
- * One of a cell's five boxes has been created. Fill the record in, and wire what belongs to it.
+ * The RIGHT BAND of `paneId`'s cell, and only while it is legal to drop there: the grid is still
+ * under {@link MAX_PANES}, and `paneId` names the LAST pane — the one a second pane would sit
+ * beside. A grid of two panes has no legal edge at all, so the band answers refused everywhere on
+ * it.
+ *
+ * The band itself is `min(120px, half the cell's own width)`: wide enough to aim at, narrow enough
+ * that the rest of the stage keeps ordinary canvas gestures — a drag never reaches this at all
+ * unless `canDrop` already accepted it, so the band only ever competes with itself.
+ */
+function edgeData(
+  paneId: string,
+  input: { clientX: number },
+  element: HTMLElement,
+): Record<string, unknown> {
+  if (workspace.panes.length >= MAX_PANES || workspace.panes.at(-1)?.id !== paneId) {
+    return { type: "pane-edge-refused" };
+  }
+  const rect = rectOf(element);
+  const band = Math.min(120, rect.width / 2);
+  if (input.clientX < rect.right - band) {
+    return { type: "pane-edge-refused" };
+  }
+  return { paneId, type: "pane-edge" };
+}
+
+/**
+ * Make a cell's drop zone a pragmatic target. `canDrop` alone is not enough to keep the zone out of
+ * a two-pane grid's way — {@link edgeData} refuses in the DATA, the same "never fall through" rule
+ * `files.ts`'s row targets use, because the zone sits ABOVE the stage (`z-index: 4`) and a refusal
+ * that let the drop bubble past it would still have kept the pointer from ever reaching the iframe
+ * underneath.
+ */
+function attachDropZone(paneId: string, element: HTMLElement): () => void {
+  return dropTargetForElements({
+    canDrop({ source }) {
+      return isTabDropSource(source.data);
+    },
+    element,
+    getData({ input }) {
+      return edgeData(paneId, input, element);
+    },
+  });
+}
+
+/**
+ * One of a cell's six boxes has been created. Fill the record in, and wire what belongs to it.
  *
  * The two bars are HANDED their host rather than resolving a region, the same way
  * `panels/frontmatter-panel.ts` is handed the stage. They cannot resolve one the way the tab strip
@@ -248,6 +313,11 @@ function cellPart(paneId: string, part: PaneCellPart, element: HTMLElement): voi
     attachPaneChromeHost(paneId, element);
     return;
   }
+  if (part === "dropZone") {
+    cell.dropZone = element;
+    cell.releaseDropZone = attachDropZone(paneId, element);
+    return;
+  }
   attachStage(cell, element);
 }
 
@@ -272,6 +342,8 @@ function cellPart(paneId: string, part: PaneCellPart, element: HTMLElement): voi
  *   the record the hosts resolve through.
  */
 function disposeCell(cell: CellState): void {
+  cell.releaseDropZone?.();
+  cell.releaseDropZone = null;
   attachJumpBarHost(cell.paneId, null);
   attachPaneChromeHost(cell.paneId, null);
   cell.releaseGestures?.();
@@ -396,6 +468,22 @@ export function mount(): void {
     { cellPart, move: setPaneSplit, settle: persistDocks },
   );
   _ready = _surface.ready;
+  _dragMonitor = monitorForElements({
+    canMonitor({ source }) {
+      return isTabDropSource(source.data);
+    },
+    onDrag({ location }) {
+      const [target] = location.current.dropTargets;
+      const edgePane = target?.data.type === "pane-edge" ? (target.data.paneId as string) : "";
+      _surface?.drag({ armed: true, edgePane });
+    },
+    onDragStart() {
+      _surface?.drag({ armed: true, edgePane: "" });
+    },
+    onDrop() {
+      _surface?.drag({ armed: false, edgePane: "" });
+    },
+  });
   _scope = effectScope();
   _scope.run(() => {
     effect(() => {
@@ -412,6 +500,8 @@ export function mount(): void {
 export function unmount(): void {
   _scope?.stop();
   _scope = null;
+  _dragMonitor?.();
+  _dragMonitor = null;
   /* Every cell is taken apart by the same ordered teardown a departing one gets, and BEFORE the
      document goes: doing it afterwards would hand `releaseCanvasHosts` a stage whose frames the
      runtime had already dropped. */

package/src/panels/problems-panel.ts

@@ -58,6 +58,7 @@
 import { nothing } from "lit-html";
 import { effect, effectScope } from "../reactivity";
 import { activeRegistry } from "../commands/active-registry";
+import { runReported } from "../commands/run-reported";
 import { clearProblems, dismiss, problemCount, problems } from "../services/notify";
 import { mountProblemsSurface } from "../surfaces/panel-problems";
 import { registerPanel } from "./panel-registry";
@@ -184,14 +185,17 @@ const ACTIONS: ProblemsActions = {
     openProblemPath(path);
   },
   /* By id, because a document can only hand back a value: the record and the registry are both
-     looked up at the moment of the click, which is also the moment the gate was last checked. */
+     looked up at the moment of the click, which is also the moment the gate was last checked.
+     The action's `actionArgs` were written by whoever filed the problem, against a schema that
+     may have moved since, so the run goes through `commands/run-reported.ts`: a refusal is a new
+     row in this same list, keyed by the command, rather than an exception out of the button. */
   runAction: (id) => {
     const record = problems.find((candidate) => candidate.id === id);
     const registry = activeRegistry();
     if (record?.action === undefined || !registry) {
       return;
     }
-    void registry.run(record.action, record.actionArgs);
+    void runReported(registry, record.action, record.actionArgs, "Problems");
   },
 };
 

package/src/panels/quick-search.ts

@@ -41,6 +41,7 @@ import { reactive } from "../reactivity";
 import paletteDoc from "../surfaces/palette.json";
 import { activeTab } from "../workspace/workspace";
 import { activeRegistry } from "../commands/active-registry";
+import { runActiveReported, runReported } from "../commands/run-reported";
 import type { PaletteMode } from "../commands/defaults";
 import type { AnyCommand, CommandRegistry } from "../commands/registry";
 import type { JxDocument, JxMutableNode } from "@jxsuite/schema/types";
@@ -671,17 +672,11 @@ function runCommand(command: AnyCommand, args?: Record<string, unknown>) {
   }
   trackRecentCommand(command.id);
   closeQuickSearch();
-  const report = (error: unknown) => {
-    console.error(`palette: command "${command.id}" failed`, error);
-  };
-  // Both shapes, deliberately: `run` may throw synchronously (a coercion refusal from
+  // Both shapes, through the one helper: `run` may throw synchronously (a coercion refusal from
   // `command-args.ts` does) or reject later. A palette that let either escape would take the
-  // Keydown listener down with it, and the overlay is already closed by then.
-  try {
-    void Promise.resolve(registry.run(command.id, args)).catch(report);
-  } catch (error) {
-    report(error);
-  }
+  // Keydown listener down with it, and the overlay is already closed by then — and a refusal that
+  // Went to the console, as this one did, was read by nobody. Problems is where it is read.
+  void runReported(registry, command.id, args, "Palette");
 }
 
 function selectRow(row: PaletteRow) {
@@ -702,9 +697,8 @@ function selectRow(row: PaletteRow) {
       return;
     }
     case "node": {
-      const registry = activeRegistry();
       closeQuickSearch();
-      void registry?.run("selection.set", { path: row.path });
+      void runActiveReported("selection.set", { path: row.path }, "Palette");
       return;
     }
     case "arg": {