@jxsuite/studio 8.1.0 → 9.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jxsuite/studio",
-  "version": "8.1.0",
+  "version": "9.0.0",
   "description": "Jx Studio — visual builder for Jx documents",
   "license": "MIT",
   "repository": {
@@ -31,7 +31,6 @@
     "./platform": "./src/platform.ts",
     "./types": "./src/types.ts",
     "./base64": "./src/utils/base64.ts",
-    "./directory-picker": "./src/services/directory-picker.ts",
     "./import-client": "./src/services/import-client.ts",
     "./github-auth": "./src/github/github-auth.ts",
     "./github-auth-status": "./src/github/github-auth-status.ts",
@@ -61,16 +60,16 @@
   "dependencies": {
     "@atlaskit/pragmatic-drag-and-drop": "^4.0.0",
     "@atlaskit/pragmatic-drag-and-drop-hitbox": "^3.0.0",
-    "@jxsuite/ai": "^0.40.0",
-    "@jxsuite/collab": "^0.11.2",
-    "@jxsuite/create": "^1.4.0",
-    "@jxsuite/formulas": "^0.0.24",
-    "@jxsuite/markup": "^1.0.0",
-    "@jxsuite/protocol": "^4.0.0",
-    "@jxsuite/runtime": "^5.2.0",
-    "@jxsuite/schema": "^4.0.0",
-    "@jxsuite/site": "^2.2.0",
-    "@jxsuite/ui": "^0.8.0",
+    "@jxsuite/ai": "^0.41.0",
+    "@jxsuite/collab": "^0.11.3",
+    "@jxsuite/create": "^1.4.1",
+    "@jxsuite/formulas": "^0.0.25",
+    "@jxsuite/markup": "^1.0.1",
+    "@jxsuite/protocol": "^5.0.0",
+    "@jxsuite/runtime": "^6.0.0",
+    "@jxsuite/schema": "^4.1.0",
+    "@jxsuite/site": "^2.2.1",
+    "@jxsuite/ui": "^0.8.1",
     "@vue/reactivity": "3.5.44",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/collab/collab-session.ts

@@ -26,7 +26,7 @@ import { jsonClone } from "../utils/studio-utils";
 import { cloneSelection } from "../tabs/selection";
 import {
   applyExternalDocOps,
-  isBatching,
+  isBatched,
   setBatchEndNotifier,
   setHistoryDelegate,
   setTransactGate,
@@ -318,7 +318,11 @@ function onBatchEnd(tab: Tab): void {
 
 function publishRecord(session: ActiveSession, record: TransactionRecord): void {
   const forward = record.docOps.map((pair) => pair.forward);
-  if (isBatching()) {
+  /* Buffered only while THIS tab has a lane segment open, which means the transaction just
+     observed was the lane owner's: anyone else's write closes the segment before it runs, and the
+     close flushes the buffer, so the Y document receives the owner's ops before the other writer's
+     and in local order. */
+  if (isBatched(session.tab)) {
     session.batchOps ??= [];
     if (forward.length === 0) {
       session.batchNeedsDiff = true;

package/src/commands/context.ts

@@ -31,6 +31,9 @@ export const CAPABILITIES = [
   "gitClone",
   "importSite",
   "openProjectInNewWindow",
+  /* Open Project's gate: a native dialog or the cloud's repository picker. A dev-server window opens
+     its project from `?project=`, so the command is not offered there. */
+  "openProject",
   "dataRows",
   "windowControls",
   "findReferences",
@@ -339,6 +342,7 @@ export function emptyContext(): CommandContext {
       gitClone: false,
       importSite: false,
       openProjectInNewWindow: false,
+      openProject: false,
       dataRows: false,
       windowControls: false,
       findReferences: false,

package/src/commands/defaults.ts

@@ -563,6 +563,8 @@ export function defaultCommands(deps: CommandDeps): AnyCommand[] {
       keybinding: "mod+o",
       menus: ["commandbar/overflow", "statusbar/project", "palette"],
       group: "1_file",
+      when: (ctx: CommandContext) => ctx.capability.openProject,
+      requires: "a host that can open a project from a dialog",
       run: () => deps.openProject(),
     },
     {

package/src/commands/live-context.ts

@@ -38,6 +38,7 @@ import { collabState } from "../collab/collab-state";
 
 import { canvasViewForMode, editorKindForMode, emptyContext } from "./context";
 import type { CommandContext } from "./context";
+import { canOpenProject } from "../platform";
 import type { StudioPlatform } from "../types";
 
 /** Elements that own the keyboard while focused. Matches the old listener's target test exactly. */
@@ -95,6 +96,7 @@ function capabilities(platform: StudioPlatform | null): CommandContext["capabili
     findReferences: has("findReferences"),
     gitClone: has("gitClone"),
     importSite: has("importSite"),
+    openProject: canOpenProject(platform),
     openProjectInNewWindow: has("openProjectInNewWindow"),
     readFileBytes: has("readFileBytes"),
     publish: has("cfApi"),

package/src/files/files.ts

@@ -39,7 +39,7 @@ import { errorMessage } from "@jxsuite/schema/parse";
 import { localeLabel, localeOfPath, resolveI18n } from "@jxsuite/schema/locale";
 import { showPromptDialog } from "../ui/layers";
 import { projectState, requireProjectState, setProjectState } from "../store";
-import { getPlatform } from "../platform";
+import { canOpenProject, getPlatform } from "../platform";
 import { disarmPreviewOverlay } from "../preview/preview-overlay";
 import { notify } from "../services/notify";
 import { loadComponentRegistry } from "./components";
@@ -309,7 +309,8 @@ export async function openProject({
 }): Promise<boolean> {
   try {
     const platform = getPlatform();
-    const result = await platform.openProject();
+    // The command is gated on the capability, so a host without the member never gets here.
+    const result = await platform.openProject?.();
     if (!result) {
       return false;
     } // User cancelled
@@ -864,7 +865,9 @@ function filesPanelValues(): FilesPanelValues {
   }
   if (!projectState.isSiteProject && projectState.projectRoot === ".") {
     _fileRows = [];
-    const values: FilesPanelValues = { ...emptyFilesPanelValues(), view: "welcome" };
+    // A host with no Open Project (the dev server) is told how its windows DO open one instead.
+    const view = canOpenProject(getPlatform()) ? "welcome" : "address";
+    const values: FilesPanelValues = { ...emptyFilesPanelValues(), view };
     _lastValues = values;
     return values;
   }

package/src/new-project/new-project-modal.ts

@@ -346,10 +346,7 @@ function finish(result: { root: string; config: ProjectConfig } | null) {
  * runs this same sequence itself.
  */
 async function finishCreated(result: { root: string; config: ProjectConfig }) {
-  const { adopted, error, openedElsewhere } = await adoptCreatedProject(result.root, {
-    // The wizard runs outside the agent loop — there is never a batch to flush and re-anchor.
-    getTab: () => null,
-  });
+  const { adopted, error, openedElsewhere } = await adoptCreatedProject(result.root);
   if (!adopted && !openedElsewhere) {
     notify.warn(
       "Created the project, but could not open it here.",

package/src/panels/ai-panel.ts

@@ -28,13 +28,13 @@
 
 import { effect, effectScope } from "../reactivity";
 import { createDocumentAssistant } from "../services/document-assistant";
-import { writesForTurn } from "../services/ai-writes";
+import { restoreTurn } from "../services/ai-writes";
+import { isString } from "@jxsuite/schema/guards";
 import { notify } from "../services/notify";
-import { undo } from "../tabs/transact";
+import type { NotifyOptions } from "../services/notify";
 import { activeTab } from "../workspace/workspace";
 import { setOpenAiKey } from "../services/ai-settings";
 import { hasAiCredentials } from "../services/ai-models";
-import { answerAsk, isAwaitingAnswer, pendingAsk, skipAsk } from "../services/ai-ask";
 import { activeImportRun, importRun } from "../services/import-run";
 import type { ImportBrief } from "../services/import-seed";
 import type { ImportBreakpointPolicy } from "../types";
@@ -124,7 +124,7 @@ export function bindAiPanelHost(el: HTMLElement | null) {
     run: runCommand,
     send: () => composer.send(),
     skip: () => {
-      skipAsk();
+      assistant.interactions.skip();
       renderAiPanel();
     },
     stop,
@@ -208,10 +208,10 @@ function watchAssistant() {
       // The registry is composed AFTER the bootstrap mounts this, and it is a reactive holder —
       // Reading it here is what turns the header's skeleton into its real buttons.
       void activeRegistry();
-      // The question is not chat state — it lives in `services/ai-ask.ts` — but it is drawn into
-      // This panel, so the same effect has to track it or a question would appear a turn late
-      // (and its ANSWER would never repaint the card at all).
-      void pendingAsk();
+      // The question is not chat state — it lives in the assistant's interaction store — but it is
+      // Drawn into this panel, so the same effect has to track it or a question would appear a turn
+      // Late (and its ANSWER would never repaint the card at all).
+      void assistant.interactions.pending;
       /* The run record, for the same reason: an import reports a line at a time from a store that
          is not chat state, and its chip has to follow every one of them. Reading the ACTIVE run
          tracks the whole record, so any field moving re-projects. */
@@ -268,7 +268,7 @@ async function handleAssistantSend(text: string) {
   }
   /* Answering comes first: a question is put by a turn that is still running, so a send while one
      waits is its answer, never a second turn. */
-  if (answerAsk(text.trim())) {
+  if (assistant.interactions.answer(text.trim())) {
     surface?.pin();
     renderAiPanel();
     return;
@@ -319,38 +319,31 @@ async function handleRetry(): Promise<void> {
 /**
  * Undo everything one assistant turn changed — ai.md §3.2's "Restore to here".
  *
- * The loop opens one batch per turn per document, so undoing the turn is undoing that batch. The
- * button is offered by the projection only when every recorded change was transactional; this guard
- * is the second half of the same promise, because a ledger can be trimmed (MAX_TURNS) between the
- * projection and the click and a Restore that silently restored SOME of a turn would be worse than
- * one that refused.
+ * The turn's batch lane left one step per document it wrote, and {@link restoreTurn} takes each
+ * back while it is still the top of its tab's history, or refuses the whole turn with a sentence.
+ * The button is offered by the projection only when every recorded change was transactional; the
+ * refusals are the second half of the same promise, because a ledger can be trimmed (MAX_TURNS) and
+ * a document edited between the projection and the click.
  *
  * @param {string} messageId
  */
 /* Exported so the guard can be exercised directly: the button is not DRAWN for a turn that touched
    disk, which would otherwise make the refusal path unreachable from the panel. */
 export function handleRestore(messageId: string): void {
-  const writes = writesForTurn(messageId);
-  if (writes.length === 0) {
-    notify.warn("There is no longer a record of what that turn changed.", { source: "Assistant" });
+  const restored = restoreTurn(messageId);
+  if (isString(restored)) {
+    notify.warn(restored, { source: "Assistant" });
     return;
   }
-  const disk = writes.filter((w) => w.disk).map((w) => w.path);
-  if (disk.length > 0) {
-    notify.warn(
-      `Cannot restore: ${disk.join(", ")} ${disk.length === 1 ? "was" : "were"} written straight ` +
-        "to disk, which undo cannot reach.",
-      { source: "Assistant" },
-    );
-    return;
-  }
-  const tab = activeTab.value;
-  if (!tab) {
-    notify.warn("Open the document that turn edited to restore it.", { source: "Assistant" });
-    return;
+  /* Redo reaches the active tab only, so it is offered only when that is the one tab restored;
+     across documents it would bring back part of the turn. */
+  const [only, ...rest] = restored;
+  const redoable = rest.length === 0 && only === activeTab.value;
+  const options: NotifyOptions = { source: "Assistant" };
+  if (redoable) {
+    options.action = "edit.redo";
   }
-  undo(tab);
-  notify.success("Restored to before that turn.", { action: "edit.redo", source: "Assistant" });
+  notify.success("Restored to before that turn.", options);
   renderAiPanel();
 }
 
@@ -509,7 +502,7 @@ export function revealAssistant(): void {
  * turn waiting forever on a question nobody wants to answer is exactly what Stop is for.
  */
 export function isAssistantWaiting(): boolean {
-  return isAwaitingAnswer();
+  return assistant.interactions.pending !== null;
 }
 
 /**
@@ -617,7 +610,7 @@ function projectPanel(): AiChatView {
   const advice = error ? formatErrorAdvice(error) : "";
   const newChatCommand = projectCommand("assistant.newChat", { icon: "plus" });
   const rows = projectRows({
-    ask: { importRun, pendingId: pendingAsk()?.id ?? null },
+    ask: { importRun, pendingId: assistant.interactions.pending?.callId ?? null },
     messages: cs.messages,
     status: cs.status,
   });

package/src/platform.ts

@@ -50,6 +50,26 @@ declare global {
   var __jxLauncher: LauncherSignal | undefined;
 }
 
+/**
+ * Whether this host offers Open Project at all: a native dialog (`openProject`), or the cloud's
+ * repository picker. The dev server has neither, because its windows open a project from the
+ * `?project=` URL parameter, so every surface that offers Open Project asks this first rather than
+ * drawing a control that cannot do anything.
+ */
+export function canOpenProject(platform: StudioPlatform | null | undefined): boolean {
+  if (!platform) {
+    return false;
+  }
+  if (isFunction(platform.openProject)) {
+    return true;
+  }
+  return (
+    platform.openProjectPicker === "repo-list" &&
+    isFunction(platform.listRepos) &&
+    isFunction(platform.importProject)
+  );
+}
+
 /** @param {StudioPlatform} platform */
 export function registerPlatform(platform: StudioPlatform) {
   globalThis.__jxPlatform = platform;

package/src/platforms/devserver.ts

@@ -2,18 +2,16 @@
  * Devserver.js — Dev Server Platform Adapter
  *
  * Implements the StudioPlatform interface for the @jxsuite/server development workflow. All file
- * I/O goes through /__studio/* REST endpoints. Project opening uses the Chrome File System Access
- * API (showDirectoryPicker).
+ * I/O goes through /__studio/* REST endpoints. There is no Open Project: a dev-server window opens
+ * a project from its `?project=` URL parameter (specs/desktop.md §8.2).
  *
  * See spec/desktop.md §8 for the full specification.
  */
 
 import { streamImport } from "../services/import-client";
-import { canPickDirectory, pickDirectoryPath } from "../services/directory-picker";
 import { negotiateCollab } from "@jxsuite/collab/negotiate";
 import type { CollabNegotiation } from "@jxsuite/collab/negotiate";
 import type { WsCollabConnection } from "@jxsuite/collab/client";
-import { isFunction } from "@jxsuite/schema/guards";
 import type { JsonObject, JsonValue, JxMutableNode, ProjectConfig } from "@jxsuite/schema/types";
 import type {
   DataConnectionsResponse,
@@ -80,16 +78,6 @@ interface FsEventBatch {
   events?: FsEvent[];
 }
 
-/** `showDirectoryPicker()` (WICG File System Access), which only Chromium-based browsers expose. */
-type ShowDirectoryPicker = (options: { mode: string }) => Promise<FileSystemDirectoryHandle>;
-
-/** True when the window implements the File System Access directory picker. */
-function hasDirectoryPicker(
-  host: Window,
-): host is Window & { showDirectoryPicker: ShowDirectoryPicker } {
-  return "showDirectoryPicker" in host && isFunction(host.showDirectoryPicker);
-}
-
 /** The options object {@link StudioPlatform.createProject} takes. */
 type CreateProjectOptions = Parameters<StudioPlatform["createProject"]>[0];
 
@@ -225,36 +213,6 @@ export function createDevServerPlatform() {
     return p.startsWith(`${_projectRoot}/`) ? p.slice(_projectRoot.length + 1) : p;
   }
 
-  /**
-   * Native folder chooser for the New Project modal's Browse… button. Present only when the browser
-   * implements `showDirectoryPicker` (Chromium-based); elsewhere the member stays undefined and the
-   * modal falls back to a typed Location field.
-   *
-   * The picked handle carries no filesystem path, so it is resolved by the id the picker tags the
-   * folder with (see `@jxsuite/studio/directory-picker`). Resolves `null` only when the user
-   * dismisses the chooser; every other failure rejects with a sentence the modal shows under
-   * Location. So `locate` keeps the helper's contract: `null` is "no folder holds this id" (the
-   * route's 200 `{ path: null }`), and a non-ok answer throws the problem the server sent rather
-   * than posing as a miss. A network failure (`TypeError: Failed to fetch`, e.g. a page that is not
-   * being served by the dev server at all) propagates as is, and the picker names it.
-   */
-  const directoryPicking: Pick<StudioPlatform, "pickDirectory"> = {};
-  if (canPickDirectory()) {
-    directoryPicking.pickDirectory = async (): Promise<string | null> =>
-      pickDirectoryPath(async ({ id, name }) => {
-        const res = await fetch(
-          `/__studio/locate-directory?name=${encodeURIComponent(name)}&id=${encodeURIComponent(id)}`,
-        );
-        if (!res.ok) {
-          // A proxy, or a `views://` host with no dev server behind it, may answer in HTML.
-          const body = await readJson<JsonValue>(res).catch(() => null);
-          throw new Error(problemMessage(body, res.status));
-        }
-        const found = await readJson<{ path?: string | null }>(res);
-        return found.path ?? null;
-      });
-  }
-
   return {
     id: "devserver",
 
@@ -293,80 +251,6 @@ export function createDevServerPlatform() {
       await postActivate(root ?? _projectRoot);
     },
 
-    // ─── Project opening ──────────────────────────────────────────────────
-
-    async openProject() {
-      // Use Chrome's showDirectoryPicker API
-      const host = window;
-      if (!hasDirectoryPicker(host)) {
-        throw new Error("showDirectoryPicker not available — use a Chromium-based browser");
-      }
-
-      let dirHandle;
-      try {
-        dirHandle = await host.showDirectoryPicker({ mode: "readwrite" });
-      } catch (error) {
-        // User cancelled the picker
-        if (error instanceof Error && error.name === "AbortError") {
-          return null;
-        }
-        throw error;
-      }
-
-      // Read project.json from the chosen directory
-      let siteHandle;
-      try {
-        siteHandle = await dirHandle.getFileHandle("project.json");
-      } catch {
-        throw new Error("No project.json found in selected folder");
-      }
-
-      const file = await siteHandle.getFile();
-      /* SAFETY: the user picked this folder as a project, and project.json is that project's own
-         config file; it is matched below against the server's parse of the same file, and every
-         adapter hands project.json to Studio as the ProjectConfig the session edits. */
-      const config = JSON.parse(await file.text()) as ProjectConfig;
-
-      // Resolve server-relative path by matching against known sites
-      const sitesRes = await fetch("/__studio/sites");
-      if (!sitesRes.ok) {
-        throw new Error("Failed to fetch site list from server");
-      }
-      const sites = await readJson<SiteEntry[]>(sitesRes);
-      const match = sites.find(
-        (s: SiteEntry) => JSON.stringify(s.config) === JSON.stringify(config),
-      );
-
-      if (!match) {
-        // Project is outside dev server root — ask the server to find it by directory name
-        const findRes = await fetch(
-          `/__studio/find-project?name=${encodeURIComponent(dirHandle.name)}`,
-        );
-        if (!findRes.ok) {
-          throw new Error("Could not locate project on disk");
-        }
-        const found = await readJson<{ path?: string }>(findRes);
-        if (!found.path) {
-          throw new Error(`Could not find project directory "${dirHandle.name}"`);
-        }
-        _projectRoot = found.path;
-      } else {
-        _projectRoot = match.path;
-      }
-
-      // Notify server of active project for static file resolution
-      await this.activate();
-
-      return {
-        config,
-        handle: {
-          name: config.name || _projectRoot.split("/").pop()!,
-          projectConfig: config,
-          root: _projectRoot,
-        },
-      };
-    },
-
     /**
      * Probe the server root to see if it is itself a site project. Used at startup to auto-detect
      * projects.
@@ -408,8 +292,6 @@ export function createDevServerPlatform() {
       return await res.json();
     },
 
-    ...directoryPicking,
-
     /** List starter templates from the dev server. */
     async listStarters(): Promise<StarterInfo[]> {
       const res = await fetch("/__studio/starters");