@jxsuite/studio 6.1.2 → 8.0.0

package/src/commands/context.ts

@@ -23,6 +23,8 @@
 
 import type { KeyScope } from "./levels";
 import type { JxPath } from "../state";
+import { DEFAULT_WORKSPACE } from "../workspace/workspace-ids";
+import type { WorkspaceId } from "../workspace/workspace-ids";
 
 /** PAL-derived capability keys. One `when` clause replaces a scattered `if (platform.x)`. */
 export const CAPABILITIES = [
@@ -35,6 +37,11 @@ export const CAPABILITIES = [
   /* The image editor's gate. A backend that cannot hand Studio a project file's raw bytes cannot
      decode one, so the Image mode is not offered at all rather than offered and then failing. */
   "readFileBytes",
+  /* The Publish family's host question (studio.md §22.8): the host can reach the Cloudflare API
+     (`cfApi`), so it can connect a provider, deploy and read deployments. Whether it can open a
+     pull request is not a key: no record is refused on it. Send for review is a destination
+     inside the workspace, refused by the flow with its reason (`publish/publish-changes.ts`). */
+  "publish",
 ] as const;
 
 export type Capability = (typeof CAPABILITIES)[number];
@@ -55,10 +62,11 @@ export type EditorKind =
   | "grid"
   | "code"
   | "diff"
-  | "library"
   | "config"
+  | "tokens"
   | "entry"
   | "media"
+  | "home"
   | "none";
 
 /** The Canvas view axis — one control, three values (§4.2). */
@@ -90,18 +98,22 @@ const EDITOR_KIND_BY_MODE = new Map<string, EditorKind>([
   ["entry", "entry"],
   ["git-diff", "diff"],
   ["grid", "grid"],
-  ["manage", "library"],
+  /* A workspace's home (`workspace/workspace-home.ts`): the surface a workspace opens on when none
+     of its own tabs is open. No document, no selection, nothing to paste into, so not the Canvas
+     key scope a mode this map did not know would fall into. */
+  ["content-home", "home"],
+  ["media-home", "home"],
+  ["publish-home", "home"],
   /* The Media viewer — `media/media-pane.ts`. An image, a video, a font specimen: files the studio
      can SHOW but has no document model for, which is why clicking one used to end in "No format
      class imported for …", advice that means nothing about a PNG. */
   ["media", "media"],
   ["preview", "canvas"],
-  /* Project Settings — `settings/settings-document.ts`'s SETTINGS_MODE. A form over `project.json`,
-     which is a configuration object and not a document tree; `stylebook` (Project Styles) is the
-     second editor over that same document and answers `config` for the same reason. */
-  ["settings", "config"],
   ["source", "code"],
   ["stylebook", "config"],
+  /* The Variables view (`style/variables-view.ts`): a form over `project.json`'s custom
+     properties, nothing to paste into, so the global key scope rather than the Canvas one. */
+  ["tokens", "tokens"],
 ]);
 
 /**
@@ -109,8 +121,7 @@ const EDITOR_KIND_BY_MODE = new Map<string, EditorKind>([
  *
  * An unknown mode reads as Canvas, and that default is only for modes STUDIO DOES NOT OWN: a format
  * declares its own list (`format.studio.modes`) and every mode declared that way is a view of the
- * artboard. A mode Studio itself introduces is not covered by it and belongs in the map above —
- * which is what `settings` was not.
+ * artboard. A mode Studio itself introduces is not covered by it and belongs in the map above.
  */
 /**
  * Human names for the editor kinds, so no surface prints an enum at a reader — and so two surfaces
@@ -121,13 +132,16 @@ const EDITOR_KIND_BY_MODE = new Map<string, EditorKind>([
 export const EDITOR_KIND_LABELS: Readonly<Record<EditorKind, string>> = {
   canvas: "Canvas",
   code: "Code",
-  config: "Project Styles",
+  /* The Styles workspace's three views of `project.json` are named for what each one edits:
+     Elements (element defaults by tag, the `stylebook` editor), Variables and Code. */
+  config: "Elements",
   diff: "Diff",
   entry: "Entry",
   grid: "Grid",
+  home: "Home",
   media: "Media",
-  library: "Library",
   none: "None",
+  tokens: "Variables",
 };
 
 export function editorKindForMode(mode: string): EditorKind {
@@ -164,6 +178,15 @@ export interface CommandContext {
     behind: number;
     dirtyCount: number;
   };
+  /**
+   * Which of the five workspaces is on screen (`shell.workspace`). A record or a panel whose
+   * surface belongs to one workspace gates on this, and every builder of a context — the live one,
+   * `panelContext()` and this module's empty one — has to fill it, or a predicate reads the default
+   * and silently never holds.
+   */
+  workspace: {
+    id: WorkspaceId;
+  };
   document: {
     open: boolean;
     dirty: boolean;
@@ -293,6 +316,7 @@ export function emptyContext(): CommandContext {
   return {
     project: { open: false, isSite: false, isRepo: false, isMultilingual: false },
     git: { ahead: 0, behind: 0, dirtyCount: 0 },
+    workspace: { id: DEFAULT_WORKSPACE },
     document: { open: false, dirty: false, mode: "", canUndo: false, canRedo: false },
     editor: { kind: "none" },
     canvas: { view: "design" },
@@ -319,6 +343,7 @@ export function emptyContext(): CommandContext {
       windowControls: false,
       findReferences: false,
       readFileBytes: false,
+      publish: false,
     },
   };
 }

package/src/commands/defaults.ts

@@ -50,9 +50,9 @@ export type DockId = "navigator" | "inspector" | "bottom";
 export type PaletteMode = "picker" | "files" | "commands" | "nodes" | "projects";
 
 /**
- * One panel, as the ⌘1–8 direct keys address it.
+ * One panel, as its `panel.focus.<id>` record addresses it.
  *
- * Structurally the part of `panels/panel-registry.ts`'s `PanelRecord` a chord needs, declared here
+ * Structurally the part of `panels/panel-registry.ts`'s `PanelRecord` a record needs, declared here
  * rather than imported so this module keeps its one load-bearing property: it imports no state and
  * no DOM, which is what lets the three CI checks load the command set in a bare Bun process. The
  * ROSTER arrives by injection ({@link CommandDeps.panelRoster}) from the panel registry, so there
@@ -64,30 +64,52 @@ export interface RailPanel {
   /** The panel's human name, which is also the command's title after "Show ". */
   title: string;
   /** `false` for a panel with no rail button — reachable by name, not by number. */
-  rail?: boolean;
+  rail?: boolean | "developer";
   /** The panel's own visibility predicate, composed into the command's. */
   when?: (ctx: CommandContext) => boolean;
 }
 
-/** How many rail panels get a ⌘N: the Navigator rail (§5.1) spends four per level group. */
-export const RAIL_CHORD_LIMIT = 8;
+/** The Inspector strip's three tabs (§6): Page · Element · Assistant. */
+export type InspectorStripId = "page" | "element" | "assistant";
 
 /**
- * The Inspector's four tabs, in the order §6 names them — which is the order ⌘⇧1–4 follow.
+ * One Inspector LEAF — a view the dock can show — in the order §6 names them, which is the order
+ * ⌘⇧1–5 follow: Page, Element's Content · Style · Logic, then Assistant.
  *
- * `"assistant"` is the fourth tab, not a dock of its own (there is no assistant column, §3.1), so
- * it is one of `shell.ts`'s `INSPECTOR_TAB_IDS` like the other three.
+ * `"assistant"` is a leaf, not a dock of its own (there is no assistant column, §3.1), so it is one
+ * of `shell.ts`'s `INSPECTOR_TAB_IDS` like the others. `strip` says which of the three strip tabs
+ * hosts the leaf: the three node views share Element, behind a sub-switch, because they share one
+ * target.
  */
 export interface InspectorTab {
-  /** The stored `session.ui.rightTab` value, or `"assistant"` for the assistant dock. */
+  /** The stored `session.ui.rightTab` value. */
   id: string;
   title: string;
+  strip: InspectorStripId;
 }
 
 export const INSPECTOR_TABS: readonly InspectorTab[] = [
-  { id: "properties", title: "Content" },
-  { id: "style", title: "Style" },
-  { id: "events", title: "Logic" },
+  { id: "page", strip: "page", title: "Page" },
+  { id: "properties", strip: "element", title: "Content" },
+  { id: "style", strip: "element", title: "Style" },
+  { id: "events", strip: "element", title: "Logic" },
+  { id: "assistant", strip: "assistant", title: "Assistant" },
+];
+
+/** One tab of the strip, and the leaves it hosts. */
+export interface InspectorStripTab {
+  id: InspectorStripId;
+  title: string;
+}
+
+/**
+ * The strip, in order. Three tabs, under the four-per-dock cap (`studio-ui-guidelines.md` §12.2):
+ * Element's sub-switch is inside a tab's body and is not a dock tab. The Page tab's title is
+ * contextual on screen (Page, Template, Component, Entry or Document, §6); this is its name.
+ */
+export const INSPECTOR_STRIP: readonly InspectorStripTab[] = [
+  { id: "page", title: "Page" },
+  { id: "element", title: "Element" },
   { id: "assistant", title: "Assistant" },
 ];
 
@@ -119,7 +141,8 @@ export interface CommandDeps {
    */
   newWindow: () => void | Promise<void>;
   /**
-   * The rail's panels in rail order, then the rail-less ones — the roster ⌘1–8 is generated from.
+   * The rail's panels in rail order, then the rail-less ones — the roster `panel.focus.*` is
+   * generated from.
    *
    * Every entry is a Navigator panel: the rail is the Navigator's, and a Bottom-dock tab is
    * addressed by `view.setBottomTab` instead — one door per surface. `panels/navigator-panels.ts`'s
@@ -131,8 +154,8 @@ export interface CommandDeps {
   panelRoster: readonly RailPanel[];
   /**
    * Toggle-FOCUS a panel: reveal it and take focus, or — when it already has focus — collapse the
-   * dock hosting it and hand focus back to the pane. Deliberately not toggle-visible: ⌘1 pressed
-   * from the canvas must land you in Files, not close it.
+   * dock hosting it and hand focus back to the pane. Deliberately not toggle-visible: running it
+   * from the canvas must land you in the panel, not close it.
    */
   focusPanel: (panelId: string) => void;
   /** Show an Inspector tab and focus the dock. `"assistant"` addresses the assistant dock. */
@@ -305,6 +328,7 @@ export function defaultCommands(deps: CommandDeps): AnyCommand[] {
       keybinding: "mod+z",
       menus: ["commandbar/primary", "palette"],
       group: "1_history",
+      order: 1,
       when: documentOpen,
       enablement: (ctx) => ctx.document.canUndo,
       requires: "a change to undo",
@@ -319,6 +343,7 @@ export function defaultCommands(deps: CommandDeps): AnyCommand[] {
       keybinding: ["mod+shift+z", "mod+y"],
       menus: ["commandbar/primary", "palette"],
       group: "1_history",
+      order: 2,
       when: documentOpen,
       enablement: (ctx) => ctx.document.canRedo,
       requires: "a change to redo",
@@ -545,7 +570,7 @@ export function defaultCommands(deps: CommandDeps): AnyCommand[] {
        * The other half of multi-window, and the half that had no door.
        *
        * "Open a project ELSEWHERE" is reachable from Open Project and from Recents
-       * (desktop.md §4.2a); "open an EMPTY window" was reachable only from the ElectroBun
+       * (desktop.md §4.2a); "open an EMPTY window" was reachable only from the desktop
        * launcher's native application menu — so on a launcher whose window has no menu bar,
        * `newWindow` existed on the platform and could not be run. Gated on the same capability
        * every other multi-window verb is, so a host with one window does not offer it.
@@ -601,40 +626,39 @@ export function defaultCommands(deps: CommandDeps): AnyCommand[] {
 }
 
 /**
- * ⌘1–8 — one record per panel, generated from {@link CommandDeps.panelRoster}.
+ * One `panel.focus.<id>` record per Navigator panel, generated from
+ * {@link CommandDeps.panelRoster}.
  *
- * Generated rather than written out eight times for the reason the whole registry exists: the rail,
- * the chord, the palette row and the generated shortcut sheet are then four renderings of one list.
- * Only the first eight get a chord; a ninth panel keeps its name and its palette row, which is the
- * cost studio-ui-guidelines.md §12.2 puts on chrome.
+ * Generated rather than written out once per panel for the reason the whole registry exists: the
+ * rail, the palette row and the generated command sheet are then three renderings of one list.
+ *
+ * **No chords.** ⌘1–8 used to follow the rail here. The digit row now switches WORKSPACES (⌘1–5,
+ * `view.setWorkspace`), because the rail is Design's alone and a chord that reached a panel from
+ * Publish would open a column the workspace does not draw. The records stay, in the palette and
+ * bindable in Preferences › Keyboard, and the rail is the pointer's way to them.
  */
 export function panelFocusCommands(deps: CommandDeps): AnyCommand[] {
-  let chordsSpent = 0;
-  return deps.panelRoster.map((panel) => {
-    const command: AnyCommand = {
-      id: `panel.focus.${panel.id}`,
-      title: `Show ${panel.title}`,
-      category: "View",
-      // Application, like `view.setActivity`: revealing a panel arranges the workspace. What the
-      // PANEL acts on is the panel record's own level, and that is `registerPanel()`'s field.
-      level: "application",
-      menus: ["palette"],
-      group: "4_docks",
-      requires: "an open project",
-      // The panel's OWN `when` composes in, so a declared-but-unbuilt surface (Search, Problems)
-      // Has no palette row and no live chord — the record exists, the affordance does not.
-      when: (ctx: CommandContext) => ctx.project.open && (panel.when?.(ctx) ?? true),
-      run: () => deps.focusPanel(panel.id),
-    };
-    if (panel.rail !== false && chordsSpent < RAIL_CHORD_LIMIT) {
-      chordsSpent += 1;
-      command.keybinding = `mod+${chordsSpent}`;
-    }
-    return command;
-  });
+  return deps.panelRoster.map((panel): AnyCommand => ({
+    id: `panel.focus.${panel.id}`,
+    title: `Show ${panel.title}`,
+    category: "View",
+    // Application, like `view.setActivity`: revealing a panel arranges the workspace. What the
+    // PANEL acts on is the panel record's own level, and that is `registerPanel()`'s field.
+    level: "application",
+    menus: ["palette"],
+    group: "4_docks",
+    requires: "an open project",
+    // The panel's OWN `when` composes in, so a declared-but-unbuilt surface (Search, Problems)
+    // Has no palette row — the record exists, the affordance does not.
+    when: (ctx: CommandContext) => ctx.project.open && (panel.when?.(ctx) ?? true),
+    run: () => deps.focusPanel(panel.id),
+  }));
 }
 
-/** ⌘⇧1–4 — one record per Inspector tab, generated from {@link INSPECTOR_TABS}. */
+/**
+ * ⌘⇧1–5 — one record per Inspector leaf, generated from {@link INSPECTOR_TABS}, so the chords
+ * follow the strip left to right: Page, Element › Content, Style, Logic, then Assistant.
+ */
 export function inspectorFocusCommands(deps: CommandDeps): AnyCommand[] {
   return INSPECTOR_TABS.map((tab, index) => {
     const command: AnyCommand = {

package/src/commands/keymap.ts

@@ -547,14 +547,23 @@ export function createKeymap(options: { mac?: boolean } = {}): Keymap {
  * The command id is deliberately dropped — the frame decides whether to forward, never what runs —
  * and the projection is a pure function of the keymap so the host can recompute and repost it
  * whenever a rebinding lands.
+ *
+ * `except` names commands whose chords the second realm must leave alone: a command that never
+ * applies to what that realm draws (`canvas/iframe-keys.ts` `HOST_ONLY_COMMANDS`) would otherwise
+ * have the realm cancel the keystroke's own default for nothing.
  */
 export function chordsInScopes<S extends KeyScope>(
   keymap: Keymap,
   scopes: readonly S[],
+  except: ReadonlySet<string> = new Set(),
 ): { chord: string; scope: S }[] {
   const seen = new Set<string>();
   const out: { chord: string; scope: S }[] = [];
   for (const entry of keymap.entries()) {
+    // A command that can never run on behalf of the second realm must not make it swallow a key.
+    if (except.has(entry.commandId)) {
+      continue;
+    }
     /* `find` rather than a `Set.has` test: the narrowed member is what makes the result carry the
        CALLER's scope union. The canvas frame's table is three scopes wide (`FRAME_KEY_SCOPES`) and
        has to stay that way across the bridge, where `SyncedChord` declares exactly those three —

package/src/commands/levels.ts

@@ -176,17 +176,20 @@ export type PanelPlacement = (typeof PANEL_PLACEMENTS)[number];
 export const PANEL_PLACEMENT_MATRIX: Readonly<Record<PanelPlacement, PlacementRule>> = {
   "rail/project": {
     admits: ["project"],
-    note: "the rail's upper group — Files, Search, Source Control, Problems",
+    note: "the rail's upper group — Site, and Files with the developer panels on",
   },
   "rail/document": {
     admits: ["document"],
-    note: "the rail's lower group — Outline, Page, Data, Packages",
+    note: "the rail's lower group — Outline, Data, and Packages with the developer panels on",
   },
   navigator: {
     admits: ["project", "document"],
     note: "whichever level the hosted panel declares; the panel header prints it",
   },
-  inspector: { admits: ["selection"], note: "the Inspector's tabs are selection surfaces" },
+  inspector: {
+    admits: ["document", "selection"],
+    note: "Page is the open document's tab, Element the selection's (§6)",
+  },
   "dock.bottom": { admits: ["project", "document"], note: "the panel header states which" },
 };
 
@@ -196,8 +199,11 @@ export interface PlaceablePanel {
   level: Level;
   /** The dock hosting the panel's body. */
   dock: "navigator" | "inspector" | "bottom";
-  /** `false` for a panel with no rail button — it declares no rail-group placement. */
-  rail?: boolean | undefined;
+  /**
+   * `false` for a panel with no rail button — it declares no rail-group placement. `"developer"` is
+   * a rail button only while the developer panels are shown, and it still holds its placement.
+   */
+  rail?: boolean | "developer" | undefined;
 }
 
 /** One rejected (panel, placement) pair. Shaped like {@link PlacementViolation}, keyed by panel. */

package/src/commands/live-context.ts

@@ -97,6 +97,7 @@ function capabilities(platform: StudioPlatform | null): CommandContext["capabili
     importSite: has("importSite"),
     openProjectInNewWindow: has("openProjectInNewWindow"),
     readFileBytes: has("readFileBytes"),
+    publish: has("cfApi"),
     // Multi-window is a desktop-only family; `newWindow` is the one every member implies.
     windowControls: has("newWindow"),
   };
@@ -133,6 +134,7 @@ export function createLiveContext(sources: LiveContextSources): () => CommandCon
     ctx.git.ahead = shell.git.status?.ahead ?? 0;
     ctx.git.behind = shell.git.status?.behind ?? 0;
     ctx.git.dirtyCount = shell.git.status?.files.length ?? 0;
+    ctx.workspace.id = shell.workspace;
 
     ctx.document.open = tab !== null;
     // Typing still in a source buffer is unsaved work too, though the document has not seen it.

package/src/commands/registry.ts

@@ -81,6 +81,12 @@ export interface Command<A = void> {
   menus?: readonly Placement[];
   /** Menu ordering key: "1_clipboard", "3_structure", "9_danger". */
   group?: string;
+  /**
+   * Position within its {@link Command.group}, lower first. A command without one follows the
+   * ordered commands of its group, by title. A group whose members have a reading order of their
+   * own (Undo before Redo) states it here, because the title is an accident of the language.
+   */
+  order?: number;
   /**
    * How the effect is undone. Also the LEDGER SCOPE of a bridged write:
    * `services/ai-command-tools.ts` records one "Changed N files" entry per path a projected run
@@ -371,7 +377,10 @@ export function createCommandRegistry(options: CommandRegistryOptions): CommandR
             (command.menus ?? ["palette"]).includes(placement) && visibleWith(command, ctx),
         )
         .toSorted(
-          (a, b) => (a.group ?? "").localeCompare(b.group ?? "") || a.title.localeCompare(b.title),
+          (a, b) =>
+            (a.group ?? "").localeCompare(b.group ?? "") ||
+            (a.order ?? Number.POSITIVE_INFINITY) - (b.order ?? Number.POSITIVE_INFINITY) ||
+            a.title.localeCompare(b.title),
         );
     },
     isVisible(id) {

package/src/content/collection-match.ts

@@ -1,12 +1,13 @@
 /**
  * Collection-match — the ONE answer to "which content collection owns this path".
  *
- * Three matchers already existed and disagreed: `utils/studio-utils.ts`'s `findContentTypeSchema`,
+ * Three matchers existed and disagreed: `utils/studio-utils.ts`'s `findContentTypeSchema`,
  * `grid/sources/content-source.ts`'s `collectionInfo` and `browse/library-model.ts`'s
- * `contentTypeFor`. Each was right about the question it was written for and wrong about the
- * others', which was tolerable while the consumers were a form and a grid. It stopped being
- * tolerable when the Files tree began asking, because a mismatch there does not draw the wrong
- * field — it CONSTRAINS or REROUTES a creation, and both are wrong answers the author cannot see.
+ * `contentTypeFor` (since deleted: the Content workspace asks this module instead). Each was right
+ * about the question it was written for and wrong about the others', which was tolerable while the
+ * consumers were a form and a grid. It stopped being tolerable when the Files tree began asking,
+ * because a mismatch there does not draw the wrong field — it CONSTRAINS or REROUTES a creation,
+ * and both are wrong answers the author cannot see.
  *
  * Four things this states that no predecessor did:
  *