@jxsuite/server 8.1.0 → 8.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jxsuite/server",
-  "version": "8.1.0",
+  "version": "8.2.1",
   "description": "Jx development server with live reload, server-side proxy, and studio integration",
   "license": "MIT",
   "repository": {
@@ -54,17 +54,17 @@
     "upgrade": "bun update --latest && bun install"
   },
   "dependencies": {
-    "@jxsuite/ai": "^0.42.0",
-    "@jxsuite/catalog": "^0.1.6",
-    "@jxsuite/collab": "^0.11.4",
-    "@jxsuite/compiler": "^8.0.2",
-    "@jxsuite/create": "^1.5.2",
-    "@jxsuite/import": "^0.42.2",
-    "@jxsuite/protocol": "^6.2.0",
-    "@jxsuite/runtime": "^6.0.1",
-    "@jxsuite/schema": "^5.0.0",
-    "@jxsuite/site": "^2.2.2",
-    "@jxsuite/starters": "^3.1.4",
+    "@jxsuite/ai": "^0.42.1",
+    "@jxsuite/catalog": "^0.1.7",
+    "@jxsuite/collab": "^0.11.5",
+    "@jxsuite/compiler": "^8.1.0",
+    "@jxsuite/create": "^1.5.3",
+    "@jxsuite/import": "^0.42.3",
+    "@jxsuite/protocol": "^6.2.1",
+    "@jxsuite/runtime": "^6.0.2",
+    "@jxsuite/schema": "^5.1.0",
+    "@jxsuite/site": "^2.3.0",
+    "@jxsuite/starters": "^3.2.0",
     "@npmcli/arborist": "^10.0.4",
     "chokidar": "^6.0.0",
     "kysely": "^0.29.8",
@@ -74,9 +74,9 @@
     "zod": "^4.6.7"
   },
   "devDependencies": {
-    "@jxsuite/auth": "^0.8.2",
-    "@jxsuite/connector": "^0.8.2",
-    "@jxsuite/parser": "^4.1.2",
+    "@jxsuite/auth": "^0.8.3",
+    "@jxsuite/connector": "^0.8.3",
+    "@jxsuite/parser": "^4.2.0",
     "@jxsuite/test-support": "^0.0.0",
     "@types/npm-package-arg": "^6.1.4",
     "@types/npmcli__arborist": "^6.3.3",

package/src/refactor/apply.ts

@@ -15,6 +15,7 @@ import { errorMessage } from "@jxsuite/schema/parse";
 import { isUnder } from "./paths.ts";
 import { rewriteDocRefs, rewriteTagName } from "./refs.ts";
 import { documentGlob, fwd, loadDoc, skipScanPath } from "./scan.ts";
+import { invalidateReferenceCache } from "./find-refs.ts";
 import { refactorMounts } from "./mounts.ts";
 import type { RefChange } from "./refs.ts";
 import type { AssetMount } from "@jxsuite/schema/asset-paths";
@@ -74,6 +75,19 @@ export function deriveTag(absPath: string): string {
  * must have already moved the file on disk.
  */
 export async function applyRename(opts: ApplyRenameOptions): Promise<RenameReport> {
+  /* The usage cache is otherwise dropped by the file watcher, which reports this rename some time
+     after the route has answered it, and not at all under a path it ignores. The caller's very next
+     question is "who uses the new name?", and a confident zero read from the old sweep is the one
+     answer a delete must never be prompted by. On every exit: a pass that threw may have written. */
+  try {
+    return await rewriteReferences(opts);
+  } finally {
+    invalidateReferenceCache(opts.root);
+  }
+}
+
+/** The refactor pass itself: see {@link applyRename}. */
+async function rewriteReferences(opts: ApplyRenameOptions): Promise<RenameReport> {
   const root = fwd(opts.root);
   const absFrom = fwd(opts.absFrom);
   const absTo = fwd(opts.absTo);

package/src/refactor/watcher.ts

@@ -2,11 +2,13 @@
  * Watcher.ts — a small chokidar wrapper that emits coalesced, batched FS-event payloads to a sink.
  *
  * Used by the desktop project session (which has no SSE stream) to push filesystem changes to its
- * webview over RPC. The dev server keeps its own watcher in watch.ts (intertwined with
- * build/reload); both share the pure `toFsEvent`/`coalesceFsEvents` helpers.
+ * webview over RPC, and by the dev server for an active project its own watcher in watch.ts
+ * (intertwined with build/reload) cannot see. Both share the pure `toFsEvent`/`coalesceFsEvents`
+ * helpers.
  */
 
 import { watch } from "chokidar";
+import { relative } from "node:path";
 import { errorMessage } from "@jxsuite/schema/parse";
 import { coalesceFsEvents, toFsEvent } from "./fs-events.ts";
 import { invalidateReferenceCache } from "./find-refs.ts";
@@ -15,8 +17,14 @@ import type { FsEventPayload } from "./fs-events.ts";
 
 const IGNORE_SEGMENTS = ["node_modules", ".git", "dist", ".jx", ".direnv", ".devenv"];
 
-function isIgnored(path: string): boolean {
-  const f = path.replaceAll("\\", "/");
+/**
+ * Whether a path below `root` is one of the folders no project wants events for.
+ *
+ * Judged from the root down, because what lies above it says nothing about the project: read whole,
+ * a project at `~/dist/site` or `~/sites/.jx/site` would have every entry in it ignored.
+ */
+function isIgnored(root: string, path: string): boolean {
+  const f = `/${relative(root, path).replaceAll("\\", "/")}`;
   return IGNORE_SEGMENTS.some((s) => f.includes(`/${s}/`) || f.endsWith(`/${s}`));
 }
 
@@ -45,7 +53,7 @@ export function createFsWatcher(
     followSymlinks: true,
     ignoreInitial: true,
     ignorePermissionErrors: true,
-    ignored: createWatchIgnore(root, isIgnored),
+    ignored: createWatchIgnore(root, (path) => isIgnored(root, path)),
   });
 
   watcher.on("all", (eventType, changedPath) => {

package/src/server.ts

@@ -17,6 +17,8 @@ import { dirname, isAbsolute, relative, resolve } from "node:path";
 import { buildAll } from "./build.ts";
 import { createCollabRegistry } from "./collab.ts";
 import { createWatcher, injectSSE } from "./watch.ts";
+import { invalidateReferenceCache } from "./refactor/find-refs.ts";
+import { createFsWatcher } from "./refactor/watcher.ts";
 import { handleJxMounts } from "./jx-mounts.ts";
 import {
   handleResolve,
@@ -122,15 +124,39 @@ export async function createDevServer(options: {
     await buildAll(builds);
   }
 
+  // Active studio project root (set via /__studio/activate, used for static file fallback)
+  let activeProjectRoot: string | null = null;
+  let activeProjectWatcher: ReturnType<typeof createFsWatcher> | null = null;
+
+  /** The active project as the Studio that activated it spells it, which its `fs` filter compares. */
+  let activeProjectSpelling = "";
+
+  /**
+   * A root-relative path inside the active project, as that project's Studio looks for it.
+   *
+   * Studio keeps and activates a project by whatever it was opened with, usually an absolute path,
+   * and drops an `fs` event that does not start with it. The root watcher's own paths are relative
+   * to the server root, so read as they stand they reach no Studio holding an absolute root.
+   */
+  const spelledForStudio = (path: string): string => {
+    if (activeProjectRoot === null) {
+      return path;
+    }
+    const inside = relative(activeProjectRoot, resolve(absRoot, path)).replaceAll("\\", "/");
+    const outside = inside === "" || inside === ".." || inside.startsWith("../");
+    return outside || isAbsolute(inside) ? path : `${activeProjectSpelling}/${inside}`;
+  };
+
   // ─── File watcher + SSE ─────────────────────────────────────────────────────
 
   let handleSSE = null;
+  let rootWatcher: ReturnType<typeof createWatcher> | null = null;
   let fsWatcher: ReturnType<typeof createWatcher>["watcher"] | null = null;
   if (watch !== false) {
     const watchOpts = watch === true ? {} : watch;
-    const watcher = createWatcher(absRoot, builds, watchOpts);
-    ({ handleSSE } = watcher);
-    fsWatcher = watcher.watcher;
+    rootWatcher = createWatcher(absRoot, builds, { eventPath: spelledForStudio, ...watchOpts });
+    ({ handleSSE } = rootWatcher);
+    fsWatcher = rootWatcher.watcher;
   }
 
   // Bundle cache for npm packages (bare specifier → bundled JS)
@@ -155,8 +181,38 @@ export async function createDevServer(options: {
     });
   };
 
-  // Active studio project root (set via /__studio/activate, used for static file fallback)
-  let activeProjectRoot: string | null = null;
+  /**
+   * Watch the project being activated, when the server's own watcher cannot see it.
+   *
+   * `allowedRoots` and a project of the account's own can both lie outside the server root, and a
+   * project in a folder the root watcher ignores (`.cache`, `dist`) is below it and just as unseen.
+   * The usage cache is invalidated by the filesystem and the Files panel is kept current by it, so
+   * a project nothing watches would answer from its first sweep and show its first listing for the
+   * rest of the session. `createFsWatcher` drops the project's usage answers itself, and its events
+   * reach Studio over the same stream as the root watcher's, under the prefix that Studio filters
+   * on.
+   *
+   * Dropped here as well, since the project may have changed while it was not the active one.
+   */
+  async function watchActiveProject(next: string | null): Promise<void> {
+    await activeProjectWatcher?.close();
+    activeProjectWatcher = null;
+    if (next === null || rootWatcher === null) {
+      return;
+    }
+    invalidateReferenceCache(next);
+    const { broadcastEvent, sees } = rootWatcher;
+    if (containedPath(next, absRoot) === null || !sees(next)) {
+      activeProjectWatcher = createFsWatcher(next, (events) => {
+        broadcastEvent("fs", {
+          events: events.map((event) => ({
+            ...event,
+            path: `${activeProjectSpelling}/${event.path}`,
+          })),
+        });
+      });
+    }
+  }
 
   // ─── Realtime co-editing (/__studio/collab) ─────────────────────────────────
 
@@ -280,6 +336,7 @@ export async function createDevServer(options: {
           const raw = body.root || null;
           if (!raw) {
             activeProjectRoot = null;
+            await watchActiveProject(null);
             return Response.json({ ok: true, root: null });
           }
           const requested = resolve(absRoot, raw);
@@ -293,6 +350,10 @@ export async function createDevServer(options: {
             // And RFC 9457 §3.2 exists precisely so a problem can carry what a type documents.
             return problem("forbidden", "root not permitted", { ok: false });
           }
+          activeProjectSpelling = raw.replaceAll("\\", "/").replace(/\/+$/, "");
+          if (requested !== activeProjectRoot) {
+            await watchActiveProject(requested);
+          }
           activeProjectRoot = requested;
           return Response.json({ ok: true, root: activeProjectRoot });
         }

package/src/watch.ts

@@ -81,10 +81,12 @@ export function injectSSE(html: string) {
  *   debounce?: number;
  *   reloadOnAnyChange?: boolean;
  *   preReload?: (filename: string) => Promise<void> | void;
+ *   eventPath?: (path: string) => string;
  * }} [opts]
  * @returns {{
  *   broadcast: () => void;
  *   handleSSE: (request?: Request) => Response;
+ *   sees: (path: string) => boolean;
  *   watcher: import("chokidar").FSWatcher;
  * }}
  */
@@ -97,6 +99,8 @@ export function createWatcher(
     reloadOnAnyChange?: boolean;
     /** Runs before the reload broadcast — e.g. `jx dev` rebuilds the site here. */
     preReload?: (filename: string) => Promise<void> | void;
+    /** How an `fs` event names a root-relative path on the wire. Unchanged by default. */
+    eventPath?: (path: string) => string;
   } = {},
 ) {
   const ignore = opts.ignore ?? DEFAULT_IGNORE;
@@ -129,9 +133,11 @@ export function createWatcher(
       return;
     }
 
-    // The usage query's cache is invalidated by the filesystem, never by a timer — a delete
-    // Confirmation that says "used on 7 pages" must be answering about the tree as it is now.
-    invalidateReferenceCache(root);
+    /* The usage query's cache is invalidated by the filesystem, never by a timer: a delete
+       confirmation that says "used on 7 pages" must be answering about the tree as it is now. All
+       of it, not this root's: the answers are filed under the ACTIVE PROJECT, which is usually a
+       folder below the server root this watcher is on, and a sweep costs less than a wrong count. */
+    invalidateReferenceCache();
 
     // Structured FS events for the studio sidebar (coalesced + batched), emitted as a named "fs"
     // SSE event so the preview iframe ignores them while the studio shell subscribes to them.
@@ -141,7 +147,12 @@ export function createWatcher(
       clearTimeout(fsTimer ?? undefined);
       fsTimer = setTimeout(() => {
         if (fsBuffer.length > 0) {
-          broadcastEvent("fs", { events: fsBuffer });
+          const { eventPath } = opts;
+          broadcastEvent("fs", {
+            events: eventPath
+              ? fsBuffer.map((event) => ({ ...event, path: eventPath(event.path) }))
+              : fsBuffer,
+          });
           fsBuffer = [];
         }
       }, fsDebounceMs);
@@ -183,5 +194,9 @@ export function createWatcher(
     console.error("[watch] chokidar error:", message ?? err);
   });
 
-  return { broadcast, broadcastEvent, handleSSE, watcher };
+  /* Whether an absolute path below `root` is one this watcher reports, by the rule it hands chokidar
+     above. Lets the server tell which active project it has to watch separately. */
+  const sees = (path: string) => !shouldIgnore(path, ignore);
+
+  return { broadcast, broadcastEvent, handleSSE, sees, watcher };
 }