@jxsuite/server 8.2.0 → 8.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jxsuite/server",
-  "version": "8.2.0",
+  "version": "8.3.0",
   "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.43.0",
+    "@jxsuite/catalog": "^0.1.8",
+    "@jxsuite/collab": "^0.11.6",
+    "@jxsuite/compiler": "^8.2.0",
+    "@jxsuite/create": "^1.5.4",
+    "@jxsuite/import": "^0.42.4",
+    "@jxsuite/protocol": "^6.2.2",
+    "@jxsuite/runtime": "^6.1.0",
+    "@jxsuite/schema": "^5.2.0",
+    "@jxsuite/site": "^2.3.1",
+    "@jxsuite/starters": "^3.3.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.4",
+    "@jxsuite/connector": "^0.8.4",
+    "@jxsuite/parser": "^4.3.0",
     "@jxsuite/test-support": "^0.0.0",
     "@types/npm-package-arg": "^6.1.4",
     "@types/npmcli__arborist": "^6.3.3",

package/src/dev.ts

@@ -195,7 +195,8 @@ export async function startDev({ port, root }: DevArgs): Promise<DevServerHandle
   const rebuild = () => {
     building = building.then(async () => {
       const { buildSite } = await import("@jxsuite/compiler/site");
-      const result = await buildSite(root, { verbose: false });
+      // A dev server shows authors their work, so entries a project holds back stay in it.
+      const result = await buildSite(root, { includeHeld: true, verbose: false });
       ({ serverEntries } = result);
       if (result.errors.length > 0) {
         for (const err of result.errors) {

package/src/resolve.ts

@@ -208,7 +208,9 @@ async function loadProjectContext(projectRoot: string): Promise<ProjectContext |
   if (!entry) {
     return null;
   }
+  // This host draws the canvas and Preview, so entries a project holds back stay visible to authors.
   entry.context ??= loadProjectSections(projectRoot, entry.config, entry.registry, {
+    includeHeld: true,
     lazy: true,
   }).then((sections) => ({ config: entry.config, root: projectRoot, ...sections }));
   try {
@@ -342,20 +344,16 @@ export async function handleResolve(
   }
 
   let moduleAbsPath;
+  let docDir: string | null = null;
   // A bare specifier resolves through Node's module resolution (an installed package), so the
   // Class file — and the `$implementation` sibling it names — are as trusted as the package's own
   // Code. The root-escape guard only binds a caller-supplied relative `$src`/`$base`.
   let trustedResolution = false;
   try {
+    docDir = $base ? baseDirectory($base, root, activeProjectRoot || root) : null;
     if ($src.startsWith("./") || $src.startsWith("../")) {
       // Relative path
-      if ($base) {
-        const docUrlPath = new URL($base).pathname;
-        const docDir = docUrlPath.slice(0, docUrlPath.lastIndexOf("/") + 1);
-        moduleAbsPath = resolve(resolve(root, `.${docDir}`), $src);
-      } else {
-        moduleAbsPath = resolve(activeProjectRoot || root, $src);
-      }
+      moduleAbsPath = resolve(docDir ?? (activeProjectRoot || root), $src);
       if (!isImportable(moduleAbsPath, root, activeProjectRoot)) {
         return new Response(`$src "${$src}" escapes the project root`, { status: 403 });
       }
@@ -371,13 +369,10 @@ export async function handleResolve(
   }
 
   // Rebase relative config paths from doc-relative to CWD-relative
-  if ($base) {
-    const docUrlPath = new URL($base).pathname;
-    const docDir = docUrlPath.slice(0, docUrlPath.lastIndexOf("/") + 1);
-    const docAbsDir = resolve(root, `.${docDir}`);
+  if (docDir) {
     for (const [k, v] of Object.entries(config)) {
       if (isString(v) && (v.startsWith("./") || v.startsWith("../"))) {
-        config[k] = `./${relative(process.cwd(), resolve(docAbsDir, v)).split("\\").join("/")}`;
+        config[k] = `./${relative(process.cwd(), resolve(docDir, v)).split("\\").join("/")}`;
       }
     }
   }

package/src/studio-api.ts

@@ -20,6 +20,7 @@ import {
   missingExtensionsNotice,
 } from "@jxsuite/compiler/format-host";
 import { readBundledProjectSchemas } from "@jxsuite/compiler/schema-command";
+import { projectCommitArgs, projectRelativePath, readGitPrefix } from "@jxsuite/protocol/git-scope";
 import { handleDataApi } from "./data-api.ts";
 import { containedPath } from "./net-guard.ts";
 import { startSitePreview } from "./site-preview.ts";
@@ -1792,12 +1793,26 @@ export async function handleStudioApi(
         /* `--untracked-files=all`: every untracked FILE, not its collapsed folder. By default git
            reports a wholly untracked `content/` as one entry, so a fresh repository listed a
            handful of folders that no group, comparison or checkbox could treat as a file, and the
-           count jumped to the real one the moment staging expanded them (studio.md §22.8). */
-        const [out, remotesOut] = await Promise.all([
-          runGit(["status", "--porcelain=v2", "--branch", "-z", "--untracked-files=all"]),
+           count jumped to the real one the moment staging expanded them (studio.md §22.8).
+           `-- .` and the prefix: the project's changes only, in the coordinates every other verb
+           reads. Porcelain prints from the repository root whatever the cwd is (git-scope.ts). */
+        const [out, remotesOut, prefix] = await Promise.all([
+          runGit([
+            "status",
+            "--porcelain=v2",
+            "--branch",
+            "-z",
+            "--untracked-files=all",
+            "--",
+            ".",
+          ]),
           runGit(["remote"]),
+          readGitPrefix(runGit),
         ]);
         const status = parseGitStatus(out);
+        for (const file of status.files) {
+          file.path = projectRelativePath(prefix, file.path);
+        }
         const fullStatus = {
           ...status,
           isRepo: true,
@@ -1908,12 +1923,7 @@ export async function handleStudioApi(
         if (!message || !isString(message)) {
           return problem("invalidRequest", "Missing message");
         }
-        const statusOut = await runGit(["status", "--porcelain"]);
-        const hasStaged = statusOut
-          .split("\n")
-          .some((l) => l.length > 0 && l[0] !== " " && l[0] !== "?");
-        const args = hasStaged ? ["commit", "-m", message] : ["commit", "-a", "-m", message];
-        const out = await runGit(args);
+        const out = await runGit(await projectCommitArgs(runGit, message));
         const hashMatch = out.match(/\[[\w/]+ ([a-f0-9]+)\]/);
         return Response.json({ hash: hashMatch?.[1] || "", ok: true });
       }
@@ -1947,13 +1957,15 @@ export async function handleStudioApi(
         try {
           await runGit(["pull"]);
         } catch (error) {
-          const conflicts =
+          const conflicting =
             error instanceof GitCommandError
               ? conflictingPaths(`${error.stdout}\n${error.stderr}`)
               : [];
-          if (conflicts.length === 0) {
+          if (conflicting.length === 0) {
             throw error;
           }
+          const prefix = await readGitPrefix(runGit);
+          const conflicts = conflicting.map((conflict) => projectRelativePath(prefix, conflict));
           return problem(
             "conflict",
             `Pull stopped: ${conflicts.length} file(s) changed on both sides.`,
@@ -2010,9 +2022,9 @@ export async function handleStudioApi(
           return problem("invalidRequest", "Invalid path");
         }
         /* `./` IS LOAD-BEARING. `git show <rev>:<path>` resolves <path> from the REPOSITORY ROOT,
-           whatever the cwd is; only a `./` prefix makes it relative to the cwd. Every other verb
-           here — status, diff, checkout — is cwd-relative, and so is the `readFile` the studio
-           pairs this with, so without it a project nested inside its repo compared two DIFFERENT
+           whatever the cwd is; only a `./` prefix makes it relative to the cwd. The paths this API
+           answers and accepts are project-relative, and so is the `readFile` the studio pairs this
+           with, so without it a project nested inside its repo compared two DIFFERENT
            FILES: the working copy of `examples/package.json` against the committed root
            `package.json`, with no error anywhere and a plausible-looking diff. */
         const content = await runGit(["show", `${ref}:./${fp}`]);