@jxsuite/server 1.2.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jxsuite/server",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Jx development server with live reload, server-side proxy, and studio integration",
   "license": "MIT",
   "repository": {
@@ -35,21 +35,21 @@
     "test:coverage": "bun test --isolate --coverage"
   },
   "dependencies": {
-    "@jxsuite/collab": "^0.5.0",
-    "@jxsuite/compiler": "^1.3.0",
-    "@jxsuite/create": "^1.2.0",
-    "@jxsuite/import": "^0.38.0",
-    "@jxsuite/protocol": "^0.6.0",
-    "@jxsuite/runtime": "^1.3.0",
-    "@jxsuite/schema": "^1.3.0",
-    "@jxsuite/starters": "^1.2.0",
+    "@jxsuite/collab": "^0.5.1",
+    "@jxsuite/compiler": "^1.4.0",
+    "@jxsuite/create": "^1.2.1",
+    "@jxsuite/import": "^0.38.1",
+    "@jxsuite/protocol": "^0.6.1",
+    "@jxsuite/runtime": "^1.3.1",
+    "@jxsuite/schema": "^1.4.0",
+    "@jxsuite/starters": "^1.2.1",
     "chokidar": "^5.0.0",
     "kysely": "^0.29.4",
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@jxsuite/auth": "^0.4.0",
-    "@jxsuite/connector": "^0.4.0",
-    "@jxsuite/parser": "^1.3.0"
+    "@jxsuite/auth": "^0.4.1",
+    "@jxsuite/connector": "^0.4.1",
+    "@jxsuite/parser": "^1.4.0"
   }
 }

package/src/code-api.ts

@@ -7,7 +7,8 @@
 
 import { tmpdir } from "node:os";
 import { errorMessage } from "@jxsuite/schema/parse";
-import { join, resolve } from "node:path";
+import { dirname, join } from "node:path";
+import { existsSync } from "node:fs";
 import { unlink } from "node:fs/promises";
 import { format } from "oxfmt";
 
@@ -26,11 +27,32 @@ interface CodeApiBody {
   args?: string[];
 }
 
-const OXLINT_BIN = resolve(
-  import.meta.dir,
-  "../../node_modules/.bin",
-  process.platform === "win32" ? "oxlint.exe" : "oxlint",
-);
+const OXLINT_NAME = process.platform === "win32" ? "oxlint.exe" : "oxlint";
+
+/**
+ * Locate the oxlint CLI: explicit JX_OXLINT_BIN override (empty value = disable lint outright),
+ * then a walk up from this module probing node_modules/.bin (finds the workspace root in the
+ * monorepo and the hoisted bin for npm consumers), then PATH. Null when oxlint is unavailable —
+ * e.g. the packaged desktop app, where the lint endpoint quietly returns no diagnostics.
+ */
+export function resolveOxlintBin(startDir: string = import.meta.dir): string | null {
+  const override = process.env.JX_OXLINT_BIN;
+  if (override !== undefined) {
+    return override || null;
+  }
+  let dir = startDir;
+  for (;;) {
+    const candidate = join(dir, "node_modules", ".bin", OXLINT_NAME);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      return Bun.which("oxlint", { PATH: process.env.PATH ?? "" });
+    }
+    dir = parent;
+  }
+}
 
 // ─── Wrapper utilities ───────────────────────────────────────────────────────
 
@@ -151,6 +173,12 @@ export async function handleCodeApi(req: Request, url: URL) {
       return Response.json({ diagnostics: [] });
     }
 
+    const oxlintBin = resolveOxlintBin();
+    if (!oxlintBin) {
+      // No oxlint anywhere (packaged desktop app) — lint quietly disables.
+      return Response.json({ diagnostics: [] });
+    }
+
     const wrapped = wrapBody(code, args);
     const headerLen = wrapped.indexOf("\n") + 1;
     const tmpFile = join(
@@ -160,7 +188,7 @@ export async function handleCodeApi(req: Request, url: URL) {
 
     try {
       await Bun.write(tmpFile, wrapped);
-      const proc = Bun.spawn([OXLINT_BIN, "--format=json", "-A", "no-unused-vars", tmpFile], {
+      const proc = Bun.spawn([oxlintBin, "--format=json", "-A", "no-unused-vars", tmpFile], {
         stderr: "pipe",
         stdout: "pipe",
       });

package/src/net-guard.ts

@@ -18,6 +18,8 @@
 
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { realpathSync } from "node:fs";
+import { resolveAssetUrl } from "@jxsuite/schema/asset-paths";
+import type { AssetMount } from "@jxsuite/schema/asset-paths";
 
 export const LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "::1", "[::1]"]);
 
@@ -151,14 +153,28 @@ export async function serveContained(absPath: string, root: string): Promise<Res
 }
 
 /**
- * Try to serve a project file at its natural URL: absolute-under-root, then root-relative, then
- * public/. Each candidate goes through containedPath (realpath). `decodedPath` is the once-decoded
- * URL pathname (leading slash, forward slashes).
+ * Try to serve a project file at its natural URL: an extension asset mount, then
+ * absolute-under-root, then root-relative, then public/. Each candidate goes through containedPath
+ * (realpath). `decodedPath` is the once-decoded URL pathname (leading slash, forward slashes).
+ *
+ * Mounts come first and are contained against their own directory rather than the project root:
+ * they exist precisely to publish directories that may sit outside it (extensions.md §8.5).
  */
 export async function serveProjectFile(
   decodedPath: string,
   root: string,
+  mounts: readonly AssetMount[] = [],
 ): Promise<Response | null> {
+  for (const mount of [...mounts].toSorted((a, b) => b.urlPrefix.length - a.urlPrefix.length)) {
+    const mounted = resolveAssetUrl([mount], decodedPath);
+    if (!mounted) {
+      continue;
+    }
+    const res = await serveContained(mounted, mount.dir);
+    if (res) {
+      return res;
+    }
+  }
   // Map the URL pathname back to a filesystem path. On Windows the browser requests an absolute
   // Path as /C:/Users/… (leading slash + forward slashes); drop the slash before the drive letter.
   // A POSIX absolute path arrives as //abs/path.

package/src/project-server.ts

@@ -27,7 +27,7 @@
 
 import { resolve, sep } from "node:path";
 import { handleJxMounts } from "./jx-mounts.ts";
-import { handleResolve, handleServerFunction } from "./resolve.ts";
+import { handleResolve, handleServerFunction, projectAssetMounts } from "./resolve.ts";
 import { handleAiApi } from "./ai-api.ts";
 import { handleImportApi } from "./import-api.ts";
 import { resolveNpmPath } from "./server.ts";
@@ -206,8 +206,9 @@ export function createProjectServer(options: CreateProjectServerOptions): Projec
         return handleServerFunction(req, root);
       }
 
-      // 6. Project files at natural URLs.
-      const fileRes = await serveProjectFile(normPath, root);
+      // 6. Project files at natural URLs, including extension asset mounts (§8.5) — that is what
+      // Lets a canvas preview show an image a content entry references relative to itself.
+      const fileRes = await serveProjectFile(normPath, root, await projectAssetMounts(root));
       if (fileRes) {
         return fileRes;
       }

package/src/resolve.ts

@@ -7,6 +7,8 @@ import { createRequire } from "node:module";
 import { containedPath } from "./net-guard.ts";
 import { buildProjectExtensionRegistry } from "@jxsuite/compiler/format-host";
 import { loadProjectSections } from "@jxsuite/compiler/project-sections";
+import { loadAssetMounts } from "@jxsuite/compiler/asset-mounts";
+import type { AssetMount } from "@jxsuite/schema/asset-paths";
 import type { DynamicClass } from "@jxsuite/runtime/types";
 import type { JxClassDef, ProjectConfig } from "@jxsuite/schema/types";
 
@@ -53,7 +55,10 @@ function isImportable(p: string, root: string, activeProjectRoot: string | null)
 }
 
 /** Per-project context cache, invalidated when project.json changes on disk. */
-const projectContextCache = new Map<string, { mtime: number; context: Record<string, unknown> }>();
+const projectContextCache = new Map<
+  string,
+  { mtime: number; context: Record<string, unknown>; mounts: AssetMount[] }
+>();
 
 /**
  * Lazy-load project context (project.json + extension-loaded sections) for class instantiation.
@@ -64,6 +69,12 @@ const projectContextCache = new Map<string, { mtime: number; context: Record<str
  * @returns {Promise<Record<string, unknown> | null>} `{ config, root, ...sections }` or null
  */
 async function loadProjectContext(projectRoot: string) {
+  const entry = await loadProjectEntry(projectRoot);
+  return entry?.context ?? null;
+}
+
+/** Load (or reuse) the cached project context plus its extension asset mounts. */
+async function loadProjectEntry(projectRoot: string) {
   const projectJsonPath = resolve(projectRoot, "project.json");
   if (!existsSync(projectJsonPath)) {
     return null;
@@ -72,19 +83,33 @@ async function loadProjectContext(projectRoot: string) {
     const { mtimeMs } = statSync(projectJsonPath);
     const cached = projectContextCache.get(projectRoot);
     if (cached && cached.mtime === mtimeMs) {
-      return cached.context;
+      return cached;
     }
     const config = JSON.parse(readFileSync(projectJsonPath, "utf8")) as ProjectConfig;
     const registry = await buildProjectExtensionRegistry(projectRoot, config);
     const sections = await loadProjectSections(projectRoot, config, registry);
+    const { mounts } = await loadAssetMounts(registry, config, projectRoot);
     const context = { config, root: projectRoot, ...sections };
-    projectContextCache.set(projectRoot, { context, mtime: mtimeMs });
-    return context;
+    const entry = { context, mounts, mtime: mtimeMs };
+    projectContextCache.set(projectRoot, entry);
+    return entry;
   } catch {
     return null;
   }
 }
 
+/**
+ * Extension asset mounts for a project (specs/extensions.md §8.5) — the directories the dev server
+ * serves at their site URLs, so content-relative images resolve exactly as they will once built.
+ *
+ * @param {string} projectRoot
+ * @returns {Promise<AssetMount[]>} Mounts, or an empty list when there is no project here
+ */
+export async function projectAssetMounts(projectRoot: string): Promise<AssetMount[]> {
+  const entry = await loadProjectEntry(projectRoot);
+  return entry?.mounts ?? [];
+}
+
 /**
  * Handle POST /**jx_resolve** — proxy $prototype + $src entries.
  *

package/src/server.ts

@@ -18,9 +18,14 @@ import { buildAll } from "./build.ts";
 import { createCollabRegistry } from "./collab.ts";
 import { createWatcher, injectSSE } from "./watch.ts";
 import { handleJxMounts } from "./jx-mounts.ts";
-import { handleResolve, handleServerFunction } from "./resolve.ts";
+import { handleResolve, handleServerFunction, projectAssetMounts } from "./resolve.ts";
 import { assertAccessible, handleStudioApi } from "./studio-api.ts";
-import { containedPath, decodeAndNormalizePath, originHostGate } from "./net-guard.ts";
+import {
+  containedPath,
+  decodeAndNormalizePath,
+  originHostGate,
+  serveProjectFile,
+} from "./net-guard.ts";
 import { handleCodeApi } from "./code-api.ts";
 import { handleAiApi } from "./ai-api.ts";
 import { handleImportApi } from "./import-api.ts";
@@ -403,6 +408,20 @@ export async function createDevServer(options: {
         }
       }
 
+      // Extension asset mounts (§8.5) publish directories that may sit outside the project root,
+      // Such as an external content source's co-located images. They resolve here exactly as they
+      // Will once the site is built, so dev and production render the same URLs.
+      if (activeProjectRoot) {
+        const mountRes = await serveProjectFile(
+          path,
+          activeProjectRoot,
+          await projectAssetMounts(activeProjectRoot),
+        );
+        if (mountRes) {
+          return new Response(mountRes.body, { headers: NO_CACHE });
+        }
+      }
+
       const rootSafe = containedPath(resolve(absRoot, `.${path}`), absRoot);
       const file = rootSafe ? Bun.file(rootSafe) : null;
       if (!file || !(await file.exists())) {