@jxsuite/studio 4.1.0 → 5.1.0

package/src/workspace/pane-derive.ts

@@ -291,7 +291,14 @@ function lensTarget(
         status: "unavailable",
       };
     }
-    if (derived.diff?.filePath === path) {
+    /* …AND IT MUST STILL BE CURRENT. Matching the path alone made this a cache with no
+       invalidation: a save moves the working tree under the comparison, and the artboards would go
+       on tinting the text as it was when the lens opened. `diffRev` is stamped by the loader, so an
+       injected comparison (which has none) is left alone rather than judged stale. */
+    if (
+      derived.diff?.filePath === path &&
+      (derived.diffRev === undefined || derived.diffRev === shell.git.rev)
+    ) {
       return { ...base, reason: "", status: "ready" };
     }
     /* A read that came back EMPTY is an answer, and it has to survive the next frame. The failure
@@ -332,10 +339,18 @@ function lensTarget(
 /**
  * The source-control entry for `path`, when it has changes a comparison can be built from.
  *
- * `M` and `A` and nothing else — the same two `panels/git-panel.ts` opens a diff for, because an
- * untracked or deleted file has no pair of texts to put side by side. `shell.git.status` is the
- * project's whole answer to "what has changed", so a diff lens can be offered for a page the author
- * has never clicked in the Git panel, which is the common case and was the refused one.
+ * `M`, `A` and `U`. `shell.git.status` is the project's whole answer to "what has changed", so a
+ * diff lens can be offered for a page the author has never clicked in the Git panel, which is the
+ * common case and was the refused one.
+ *
+ * The old rule was `M`/`A` alone, justified by "an untracked or deleted file has no pair of texts
+ * to put side by side". That was never true — one side is the empty string, which is exactly what
+ * `A` had always done — and it refused a comparison for a brand-new page the author had just
+ * written.
+ *
+ * `D` is still absent, and deliberately: a LENS draws the document its source pane is showing, and
+ * a deleted file cannot be open in a pane. An arm for it would be unreachable, which is a claim no
+ * test could check. The Source Control panel opens deleted files instead, through its own tab.
  *
  * A `null` path needs no guard of its own: no entry in `files` has a null path, so the search
  * simply finds nothing, and a guard whose true branch returns what the false branch already returns
@@ -347,7 +362,8 @@ function lensTarget(
 function gitChangeFor(path: string | null): GitFileStatus | null {
   return (
     shell.git.status?.files.find(
-      (file) => file.path === path && (file.status === "M" || file.status === "A"),
+      (file) =>
+        file.path === path && (file.status === "M" || file.status === "A" || file.status === "U"),
     ) ?? null
   );
 }
@@ -696,7 +712,7 @@ function selectInPane(paneId: string, target: DerivedTarget): void {
  * the pane went back to saying "Loading this file's changes…" permanently. A terminal answer has to
  * live where {@link lensTarget} — which composes every other answer — can see it.
  */
-const _diffLoads = new Map<string, { path: string; failed: boolean }>();
+const _diffLoads = new Map<string, { path: string; rev: number; failed: boolean }>();
 
 /**
  * Fetch the comparison a diff lens is missing, once.
@@ -708,10 +724,17 @@ const _diffLoads = new Map<string, { path: string; failed: boolean }>();
 function loadDiffFor(paneId: string, target: DerivedTarget, deps: DerivationDeps): void {
   const path = target.diffPath;
   const change = gitChangeFor(path);
-  if (path === null || !change || _diffLoads.get(paneId)?.path === path) {
+  /* THE REVISION IS HALF THE KEY, and without it this memo is a cache with no invalidation: it
+     asked once per PATH and never again, so a lens went on showing the comparison it read when it
+     opened for as long as it stayed open. Reading `shell.git.rev` here also makes it a tracked
+     input of the effect that calls this, so a save re-issues rather than waiting for something else
+     to repaint. */
+  const { rev } = shell.git;
+  const asked = _diffLoads.get(paneId);
+  if (path === null || !change || (asked?.path === path && asked.rev === rev)) {
     return;
   }
-  _diffLoads.set(paneId, { failed: false, path });
+  _diffLoads.set(paneId, { failed: false, path, rev });
   deps
     .loadDiff(path, change.status)
     .then((state) => {
@@ -725,8 +748,9 @@ function loadDiffFor(paneId: string, target: DerivedTarget, deps: DerivationDeps
       }
       if (state) {
         live.diff = state;
+        live.diffRev = rev;
       } else {
-        _diffLoads.set(paneId, { failed: true, path });
+        _diffLoads.set(paneId, { failed: true, path, rev });
       }
       /* Re-resolve rather than writing a status here: `ready` with the comparison in hand,
          `unavailable` with {@link DIFF_UNREADABLE} when the read came back empty — composed in the
@@ -1187,10 +1211,8 @@ export function derivationCommands(deps: DerivationDeps): AnyCommand[] {
       enablement: () => deriveRefusal(activePane().id) === null,
       requires: DERIVE_REQUIRES,
       undo: "none",
-      aiTool: {
-        description: "Show a projection of the current document in the pane beside it.",
-        name: "show_beside",
-      },
+      /* No `aiTool`, by §12.4's first deletion rule: chrome — it arranges what the person is
+         looking at. */
       run: (_ctx, args) => {
         const preset = enumArg("pane.derive", args, "preset", DERIVE_PRESETS);
         /* `??`, not `||`. `optionalStringArg` answers `undefined` or a non-empty string — it is

package/src/workspace/workspace.ts

@@ -10,7 +10,9 @@ import {
   stringArg,
   stringProperty,
 } from "../commands/command-args";
+import { EDITOR_KIND_LABELS } from "../commands/context";
 import type { Tab, TabOrigin } from "../tabs/tab";
+import type { JsonLayout } from "../files/json-layout";
 
 import type { ComponentEntry } from "../files/components";
 import type { AnyCommand, CommandRegistry } from "../commands/registry";
@@ -86,6 +88,16 @@ export type PaneDerivation =
       media: string | null;
       /** `diff` only: this pane's OWN diff, never `shell.git.diffState`. */
       diff: GitDiffState | null;
+      /**
+       * The `shell.git.rev` {@link diff} was read at, or absent when it was not read by the loader.
+       *
+       * What makes the comparison revalidate. Without it the lens asked once per PATH and never
+       * again, so it went on showing the texts it read when it opened — and change marks over a
+       * stale comparison describe a file the author has since edited. Absent means "not from the
+       * loader", and such a comparison is left alone rather than judged stale on a rev it never
+       * had.
+       */
+      diffRev?: number;
       /**
        * This pane's own scale. `session.ui.zoom` is per-TAB, so under a lens the mobile view and
        * the desktop view it is a lens OF would zoom together.
@@ -814,6 +826,7 @@ function setActiveTab(tabId: string, opts: { cycling?: boolean; focus?: boolean
  *   preview?: boolean;
  *   paneId?: string;
  *   focus?: boolean;
+ *   layout?: JsonLayout | null;
  * }} opts
  * @returns {Tab}
  */
@@ -829,6 +842,7 @@ export function openTab(opts: {
   preview?: boolean;
   paneId?: string;
   focus?: boolean;
+  layout?: JsonLayout | null;
 }) {
   const previous = workspace.tabs.get(opts.id);
   const preview = opts.preview === true && previous?.pinned !== true;
@@ -1284,6 +1298,65 @@ export function tabCommands(deps: TabCommandDeps): AnyCommand[] {
         cycleTab(-1);
       },
     },
+    {
+      args: argsSchema({
+        path: stringProperty(
+          'Project-relative path of the file to open, e.g. "pages/about.json" or ' +
+            '"components/nav-bar.json". It must exist.',
+        ),
+      }),
+      id: "document.open",
+      title: "Open Document",
+      category: "Document",
+      /* PROJECT level, though the namespace says document: the level is what a record acts on, and
+         this one acts on the workspace — it adds a tab — from a state where no document is open
+         at all. A document-level record would be gated on the one thing it exists to produce. */
+      level: "project",
+      menus: ["palette"],
+      group: "1_file",
+      when: (ctx) => ctx.project.open,
+      requires: "an open project",
+      aiTool: {
+        description:
+          "Open a project file as the active document; the document tools then operate on it. " +
+          "Use it when the user should SEE the page, or for iterative visual refinement after " +
+          "creating a page or component.",
+        name: "open_document",
+        /* The person's own read: `activeTab` is what the tab strip highlights, and `editor.kind`
+           is the fact the document-tree tier is gated on. Both are named so the model learns in one
+           round whether the tree tools reach the file it opened — a `.csv` lands in the Grid, a
+           `.png` in the Media viewer, and neither is an element tree. The `.value` read is module
+           state, which a projected `report` may close over (§12.4); `after` alone cannot say WHICH
+           document is active. */
+        report: ({ after, args }) => {
+          const path = stringArg("document.open", args, "path");
+          const active = activeTab.value?.documentPath ?? null;
+          if (active !== path) {
+            return `Opened "${path}", but the active document is ${active === null ? "none" : `"${active}"`}.`;
+          }
+          const where =
+            after.editor.kind === "canvas"
+              ? "on the canvas; the document tools now operate on it"
+              : `in the ${EDITOR_KIND_LABELS[after.editor.kind]} editor, which is not an element tree the document tools can edit`;
+          return `"${path}" is the active document, ${where}.`;
+        },
+      },
+      /* Refuses by THROWING (§12.4's first review rule). `openFileInTab` reports a file it cannot
+         open as a Problem and returns normally — the right answer for a click in the Files tree,
+         where the toast is in front of the person — so the record has to look for the tab itself.
+         The hand tool this replaced read `getTab()` after the open and called whatever it found a
+         success, so a missing file left the PREVIOUS document active and reported "Switched to". */
+      run: async (_ctx, args) => {
+        const path = stringArg("document.open", args, "path");
+        await deps.openFile(path);
+        if (![...workspace.tabs.values()].some((tab) => tab.documentPath === path)) {
+          throw new RangeError(
+            `command "document.open" argument "path": "${path}" could not be opened — it does ` +
+              `not exist, or no editor claims its format. Problems has the reason.`,
+          );
+        }
+      },
+    },
     {
       id: "document.reopenClosed",
       title: "Reopen Closed Document",
@@ -1419,12 +1492,8 @@ export function paneCommands(deps: TabCommandDeps): AnyCommand[] {
       enablement: () => workspace.activeTabId !== null,
       requires: "an open document",
       undo: "none",
-      aiTool: {
-        description:
-          "Open a second document in the pane beside the current one, without moving the document " +
-          "you are in.",
-        name: "compare_with",
-      },
+      /* No `aiTool`, by §12.4's first deletion rule: chrome — it arranges what the person is
+         looking at. */
       run: async (_ctx, args) => {
         const path = stringArg("pane.compareWith", args, "path");
         const here = activePane();