@jxsuite/server 0.28.4 → 0.29.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jxsuite/server",
-  "version": "0.28.4",
+  "version": "0.29.0",
   "description": "Jx development server with live reload, server-side proxy, and studio integration",
   "license": "MIT",
   "repository": {
@@ -27,13 +27,13 @@
     "test:coverage": "bun test --isolate --coverage"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.173",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.175",
     "@anthropic-ai/sdk": "^0.104.1",
-    "@jxsuite/compiler": "^0.28.4",
-    "@jxsuite/create": "^0.28.4",
-    "@jxsuite/parser": "^0.28.4",
-    "@jxsuite/runtime": "^0.28.4",
-    "@jxsuite/schema": "^0.28.4",
+    "@jxsuite/compiler": "^0.29.0",
+    "@jxsuite/create": "^0.29.0",
+    "@jxsuite/parser": "^0.29.0",
+    "@jxsuite/runtime": "^0.29.0",
+    "@jxsuite/schema": "^0.29.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "chokidar": "^5.0.0",
     "zod": "^4.4.3"

package/src/claude-session.ts

@@ -136,7 +136,7 @@ export function createSession(
 
   const stream = query({ options: queryOpts, prompt: message });
   session.query = stream;
-  processStream(session, stream);
+  void processStream(session, stream);
 
   return { id };
 }
@@ -177,7 +177,7 @@ export function sendMessage(id: string, message: string) {
 
   const stream = query({ options: queryOpts, prompt: message });
   session.query = stream;
-  processStream(session, stream);
+  void processStream(session, stream);
 }
 
 /**

package/src/code-api.ts

@@ -21,6 +21,11 @@ interface OxcDiagnostic {
   [key: string]: unknown;
 }
 
+interface CodeApiBody {
+  code?: string;
+  args?: string[];
+}
+
 const OXLINT_BIN = resolve(
   import.meta.dir,
   "../../node_modules/.bin",
@@ -43,10 +48,10 @@ function unwrapFormatted(formatted: string) {
   const lines = formatted.split("\n");
   // Remove first line (function header) and last non-empty line (closing brace)
   let end = lines.length - 1;
-  while (end > 0 && lines[end].trim() === "") {
+  while (end > 0 && lines[end]!.trim() === "") {
     end -= 1;
   }
-  if (lines[end].trim() === "}") {
+  if (lines[end]!.trim() === "}") {
     end -= 1;
   }
   const bodyLines = lines.slice(1, end + 1);
@@ -90,9 +95,9 @@ export async function handleCodeApi(req: Request, url: URL) {
     return null;
   }
 
-  let body;
+  let body: CodeApiBody;
   try {
-    body = await req.json();
+    body = (await req.json()) as CodeApiBody;
   } catch {
     return new Response("Invalid JSON", { status: 400 });
   }
@@ -162,8 +167,8 @@ export async function handleCodeApi(req: Request, url: URL) {
       const output = await new Response(proc.stdout).text();
       await proc.exited;
 
-      const parsed = JSON.parse(output);
-      const adjusted = adjustDiagnostics(parsed.diagnostics || [], headerLen);
+      const parsed = JSON.parse(output) as { diagnostics?: OxcDiagnostic[] };
+      const adjusted = adjustDiagnostics(parsed.diagnostics ?? [], headerLen);
       return Response.json({ diagnostics: adjusted });
     } catch (error) {
       return Response.json({

package/src/resolve.ts

@@ -6,7 +6,34 @@ import { existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { loadContentTypes } from "@jxsuite/compiler/content-loader";
 import type { DynamicClass } from "@jxsuite/runtime/types";
-import type { JxClassDef } from "@jxsuite/schema/types";
+import type { JxClassDef, ProjectConfig } from "@jxsuite/schema/types";
+
+interface ModuleNamespace {
+  default?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+interface ClassInstance {
+  resolve?: () => unknown;
+  value?: unknown;
+  [key: string]: unknown;
+}
+
+interface ResolveBody {
+  $src?: string;
+  $prototype?: string;
+  $export?: string;
+  $base?: string;
+  [key: string]: unknown;
+}
+
+interface ServerFunctionBody {
+  $src?: string;
+  $export?: string;
+  $base?: string;
+  arguments?: Record<string, unknown>;
+  [key: string]: unknown;
+}
 
 /**
  * Lazy-load project context (project.json + content types) for class instantiation.
@@ -24,7 +51,7 @@ async function loadProjectContext(projectRoot: string) {
     return null;
   }
   try {
-    const config = JSON.parse(readFileSync(projectJsonPath, "utf8"));
+    const config = JSON.parse(readFileSync(projectJsonPath, "utf8")) as ProjectConfig;
     const contentTypes = config.contentTypes
       ? await loadContentTypes(projectRoot, config)
       : new Map();
@@ -46,9 +73,9 @@ export async function handleResolve(
   root: string,
   activeProjectRoot: string | null = null,
 ) {
-  let body;
+  let body: ResolveBody;
   try {
-    body = await req.json();
+    body = (await req.json()) as ResolveBody;
   } catch {
     return new Response("Invalid JSON body", { status: 400 });
   }
@@ -114,14 +141,16 @@ export async function handleResolve(
         // Hybrid mode: redirect to the JS implementation
         const implPath = resolve(dirname(moduleAbsPath), classDef.$implementation);
         const exportName = xport ?? classDef.title ?? $prototype;
-        const mod = await import(implPath);
-        const ExportedClass = mod[exportName] ?? mod.default?.[exportName];
+        const mod = (await import(implPath)) as ModuleNamespace;
+        const ExportedClass =
+          exportName === undefined ? undefined : (mod[exportName] ?? mod.default?.[exportName]);
         if (typeof ExportedClass !== "function") {
           return new Response(`Export "${exportName}" not found in "${classDef.$implementation}"`, {
             status: 500,
           });
         }
-        const instance = new ExportedClass(config);
+        const ClassCtor = ExportedClass as new (config: unknown) => ClassInstance;
+        const instance = new ClassCtor(config);
         const value =
           typeof instance.resolve === "function"
             ? await instance.resolve()
@@ -165,9 +194,9 @@ export async function handleResolve(
  * @param {string} root
  */
 export async function handleServerFunction(req: Request, root: string) {
-  let body;
+  let body: ServerFunctionBody;
   try {
-    body = await req.json();
+    body = (await req.json()) as ServerFunctionBody;
   } catch {
     return new Response("Invalid JSON body", { status: 400 });
   }
@@ -192,9 +221,9 @@ export async function handleServerFunction(req: Request, root: string) {
     });
   }
 
-  let mod;
+  let mod: ModuleNamespace;
   try {
-    mod = await import(moduleAbsPath);
+    mod = (await import(moduleAbsPath)) as ModuleNamespace;
   } catch (error) {
     return new Response(`Failed to import "${$src}": ${errorMessage(error)}`, {
       status: 500,
@@ -209,7 +238,7 @@ export async function handleServerFunction(req: Request, root: string) {
   }
 
   try {
-    const result = await fn(args);
+    const result = await (fn as (args: Record<string, unknown>) => unknown)(args);
     return Response.json(result ?? null);
   } catch (error) {
     return Response.json({ error: errorMessage(error) }, { status: 500 });

package/src/server.ts

@@ -30,6 +30,14 @@ import { existsSync, readFileSync } from "node:fs";
  * @param {string} urlPath - URL pathname (e.g. "/pages/@jxsuite/parser/Foo.class.json")
  * @returns {string | null} Absolute file path or null
  */
+interface PackageJson {
+  exports?: Record<string, string | { import?: string; default?: string }>;
+  customElements?: string;
+  module?: string;
+  main?: string;
+  [key: string]: unknown;
+}
+
 function resolveNpmPath(rootDir: string, urlPath: string) {
   let root = rootDir;
   let segments = urlPath.split("/").filter(Boolean);
@@ -49,7 +57,7 @@ function resolveNpmPath(rootDir: string, urlPath: string) {
   let start = -1;
   let isScoped = false;
   for (let i = 0; i < segments.length; i++) {
-    if (segments[i].startsWith("@")) {
+    if (segments[i]!.startsWith("@")) {
       start = i;
       isScoped = true;
       break;
@@ -63,14 +71,14 @@ function resolveNpmPath(rootDir: string, urlPath: string) {
     if (start < 0 || start + 1 >= segments.length) {
       return null;
     }
-    const scope = segments[start];
-    const pkg = segments[start + 1];
+    const scope = segments[start]!;
+    const pkg = segments[start + 1]!;
     subpath = segments.slice(start + 2).join("/");
     pkgDir = join(root, "node_modules", scope, pkg);
   } else {
     // Unscoped: try each segment as a package name in node_modules
     for (let i = 0; i < segments.length; i++) {
-      const candidate = join(root, "node_modules", segments[i]);
+      const candidate = join(root, "node_modules", segments[i]!);
       if (existsSync(join(candidate, "package.json"))) {
         start = i;
         pkgDir = candidate;
@@ -91,10 +99,11 @@ function resolveNpmPath(rootDir: string, urlPath: string) {
   // If there's a subpath, check package.json exports first
   if (subpath) {
     try {
-      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf8")) as PackageJson;
       const exportKey = `./${subpath}`;
-      if (pkgJson.exports && pkgJson.exports[exportKey]) {
-        const mapped = join(pkgDir, pkgJson.exports[exportKey]);
+      const exportVal = pkgJson.exports?.[exportKey];
+      if (typeof exportVal === "string") {
+        const mapped = join(pkgDir, exportVal);
         if (existsSync(mapped)) {
           return mapped;
         }
@@ -107,7 +116,7 @@ function resolveNpmPath(rootDir: string, urlPath: string) {
     }
     // CEM-relative: subpath may be relative to the custom elements manifest directory
     try {
-      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf8")) as PackageJson;
       if (pkgJson.customElements) {
         const cemDir = pkgJson.customElements.replace(/\/[^/]+$/, "");
         const cemRelative = join(pkgDir, cemDir, subpath);
@@ -120,7 +129,7 @@ function resolveNpmPath(rootDir: string, urlPath: string) {
 
   // Bare package (no subpath): resolve entry point
   try {
-    const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+    const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf8")) as PackageJson;
     const exp = pkgJson.exports?.["."];
     const entry =
       (typeof exp === "object" ? (exp.import ?? exp.default) : exp) ??
@@ -236,7 +245,7 @@ export async function createDevServer(options: {
       if (enableStudio && path.startsWith("/__studio/")) {
         // Activate project — tells the server which project root to use for static file fallback
         if (path === "/__studio/activate" && req.method === "POST") {
-          const body = await req.json();
+          const body = (await req.json()) as { root?: string };
           const raw = body.root || null;
           // Always store as absolute path
           activeProjectRoot = raw ? resolve(absRoot, raw) : null;
@@ -302,7 +311,7 @@ export async function createDevServer(options: {
                 minify: false,
               });
               if (result.success && result.outputs.length > 0) {
-                bundleCache.set(cacheKey, await result.outputs[0].text());
+                bundleCache.set(cacheKey, await result.outputs[0]!.text());
               }
             } catch (error) {
               console.error("Bundle failed for", resolved, error);

package/src/studio-api.ts

@@ -15,10 +15,88 @@ import { buildProjectFormatRegistry } from "@jxsuite/compiler/format-host";
 import type { FormatRegistry } from "@jxsuite/schema/format-registry";
 import * as claude from "./claude-session.ts";
 import type { ClassJsonDef } from "./types.ts";
+import type { ProjectConfig } from "@jxsuite/schema/types";
 
 /** Normalise a path to forward slashes (Windows `path` module returns backslashes). */
 const fwd = (p: string) => p.replaceAll("\\", "/");
 
+interface PackageJson {
+  name?: string;
+  workspaces?: unknown;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  customElements?: string;
+  [key: string]: unknown;
+}
+
+/** A custom-element-manifest declaration (subset consumed here). */
+interface CemDeclaration {
+  customElement?: boolean;
+  tagName?: string;
+  description?: string;
+  cssProperties?: unknown[];
+  events?: unknown[];
+  slots?: unknown[];
+  members?: { kind?: string; privacy?: string; [key: string]: unknown }[];
+  attributes?: {
+    name?: string;
+    default?: unknown;
+    description?: string;
+    type?: { text?: string };
+  }[];
+  [key: string]: unknown;
+}
+
+interface CemModule {
+  path?: string;
+  declarations?: CemDeclaration[];
+}
+
+interface Cem {
+  modules?: CemModule[];
+}
+
+/** A parsed Jx component document (subset consumed by component discovery). */
+interface ComponentDoc {
+  $id?: string;
+  tagName?: string;
+  $elements?: unknown[];
+  state?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+interface SlotDef {
+  name: string;
+  fallback?: unknown[];
+}
+
+/**
+ * Collect slot definitions (name + fallback children) from a parsed component tree. Whitespace-only
+ * names count as unnamed (""). Only static children arrays are walked.
+ */
+function collectSlotDefs(node: unknown, out: SlotDef[] = []): SlotDef[] {
+  if (!node || typeof node !== "object" || Array.isArray(node)) {
+    return out;
+  }
+  const el = node as Record<string, unknown>;
+  if (el.tagName === "slot") {
+    const attrs = el.attributes as Record<string, unknown> | undefined;
+    const rawName = attrs?.name;
+    const name = typeof rawName === "string" ? rawName.trim() : "";
+    const { children } = el;
+    out.push({
+      name,
+      ...(Array.isArray(children) && children.length > 0 ? { fallback: children } : {}),
+    });
+  }
+  if (Array.isArray(el.children)) {
+    for (const c of el.children) {
+      collectSlotDefs(c, out);
+    }
+  }
+  return out;
+}
+
 // ─── Format registry (per project root, invalidated on project.json change) ──
 
 const formatRegistryCache = new Map<string, { mtime: number; registry: FormatRegistry }>();
@@ -33,10 +111,10 @@ const formatRegistryCache = new Map<string, { mtime: number; registry: FormatReg
 async function getFormatRegistry(projectRoot: string): Promise<FormatRegistry> {
   const projectJsonPath = resolve(projectRoot, "project.json");
   let mtime = 0;
-  let projectConfig;
+  let projectConfig: ProjectConfig | undefined;
   try {
     mtime = statSync(projectJsonPath).mtimeMs;
-    projectConfig = JSON.parse(readFileSync(projectJsonPath, "utf8"));
+    projectConfig = JSON.parse(readFileSync(projectJsonPath, "utf8")) as ProjectConfig;
   } catch {
     projectConfig = undefined;
   }
@@ -111,14 +189,14 @@ export function parseGitStatus(out: string) {
     } else if (line.startsWith("# branch.ab ")) {
       const m = line.match(/\+(\d+) -(\d+)/);
       if (m) {
-        ahead = Number.parseInt(m[1], 10);
-        behind = Number.parseInt(m[2], 10);
+        ahead = Number.parseInt(m[1]!, 10);
+        behind = Number.parseInt(m[2]!, 10);
       }
     } else if (line.startsWith("1 ") || line.startsWith("2 ")) {
       const parts = line.split(" ");
-      const [, xy] = parts;
-      const [stagedCode] = xy;
-      const [, unstagedCode] = xy;
+      const xy = parts[1]!;
+      const stagedCode = xy[0]!;
+      const unstagedCode = xy[1]!;
       let filePath;
       if (line.startsWith("2 ")) {
         const tabIdx = line.indexOf("\t");
@@ -169,7 +247,7 @@ export async function handleStudioApi(
   // Project metadata
   if (path === "/__studio/project" && req.method === "GET") {
     try {
-      const pkg = JSON.parse(await readFile(resolve(root, "package.json"), "utf8"));
+      const pkg = JSON.parse(await readFile(resolve(root, "package.json"), "utf8")) as PackageJson;
       return Response.json({
         name: pkg.name ?? basename(root),
         root,
@@ -211,12 +289,12 @@ export async function handleStudioApi(
       }
 
       let isSiteProject = false;
-      let projectConfig = null;
+      let projectConfig: ProjectConfig | null = null;
       try {
-        const raw = JSON.parse(await readFile(resolve(absDir, "project.json"), "utf8"));
+        const raw = JSON.parse(await readFile(resolve(absDir, "project.json"), "utf8")) as unknown;
         if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
           isSiteProject = true;
-          projectConfig = raw;
+          projectConfig = raw as ProjectConfig;
         }
       } catch {}
 
@@ -245,7 +323,7 @@ export async function handleStudioApi(
       while (dir) {
         const candidate = resolve(dir, "project.json");
         if (existsSync(candidate)) {
-          const config = JSON.parse(readFileSync(candidate, "utf8"));
+          const config = JSON.parse(readFileSync(candidate, "utf8")) as ProjectConfig;
           const relPath = fwd(dir);
           const absFile = filePath.startsWith("~")
             ? filePath.replace("~", process.env.HOME || "")
@@ -313,10 +391,10 @@ export async function handleStudioApi(
         }
         const fp = resolve(root, match);
         try {
-          const raw = JSON.parse(await readFile(fp, "utf8"));
+          const raw = JSON.parse(await readFile(fp, "utf8")) as unknown;
           if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
             const projectDir = fwd(dirname(fp));
-            sites.push({ config: raw, path: projectDir });
+            sites.push({ config: raw as ProjectConfig, path: projectDir });
           }
         } catch {}
       }
@@ -329,7 +407,13 @@ export async function handleStudioApi(
   // Create a new project
   if (path === "/__studio/create-project" && req.method === "POST") {
     try {
-      const body = await req.json();
+      const body = (await req.json()) as {
+        name?: string;
+        description?: string;
+        url?: string;
+        adapter?: "static" | "cloudflare-pages" | "cloudflare-workers" | "node" | "bun";
+        directory?: string;
+      };
       const { name, description, url: siteUrl, adapter, directory } = body;
       if (!name || !directory) {
         return Response.json({ error: "name and directory are required" }, { status: 400 });
@@ -339,13 +423,15 @@ export async function handleStudioApi(
 
       const { generateProject } = await import("@jxsuite/create/generate");
       await generateProject(destPath, {
-        adapter,
-        description,
         name,
-        url: siteUrl,
+        ...(adapter !== undefined ? { adapter } : {}),
+        ...(description !== undefined ? { description } : {}),
+        ...(siteUrl !== undefined ? { url: siteUrl } : {}),
       });
 
-      const config = JSON.parse(await readFile(resolve(destPath, "project.json"), "utf8"));
+      const config = JSON.parse(
+        await readFile(resolve(destPath, "project.json"), "utf8"),
+      ) as ProjectConfig;
       const projectRoot = fwd(relative(root, destPath));
       return Response.json({ config, root: projectRoot });
     } catch (error) {
@@ -442,18 +528,19 @@ export async function handleStudioApi(
         }
         const fp = resolve(scanRoot, match);
         try {
-          let content;
+          let content: ComponentDoc;
           if (match.endsWith(".json")) {
-            content = JSON.parse(await readFile(fp, "utf8"));
+            content = JSON.parse(await readFile(fp, "utf8")) as ComponentDoc;
           } else {
             const entry = registry.byExtension(extname(match), "parse");
             if (!entry) {
               continue;
             }
             const source = await readFile(fp, "utf8");
-            content = (await entry.call("parse", source)) as Record<string, unknown>;
+            content = (await entry.call("parse", source)) as ComponentDoc;
           }
           if (content.tagName && content.tagName.includes("-")) {
+            const slotDefs = collectSlotDefs(content);
             components.push({
               $id: content.$id || null,
               hasElements: Array.isArray(content.$elements) && content.$elements.length > 0,
@@ -484,6 +571,7 @@ export async function handleStudioApi(
                     type: obj.type,
                   };
                 }),
+              ...(slotDefs.length > 0 ? { slots: slotDefs } : {}),
               source: "jx",
               tagName: content.tagName,
             });
@@ -495,7 +583,7 @@ export async function handleStudioApi(
       try {
         const projectPkgPath = resolve(scanRoot, "package.json");
         if (existsSync(projectPkgPath)) {
-          const pkg = JSON.parse(await readFile(projectPkgPath, "utf8"));
+          const pkg = JSON.parse(await readFile(projectPkgPath, "utf8")) as PackageJson;
           const deps = { ...pkg.dependencies, ...pkg.devDependencies };
           for (const name of Object.keys(deps)) {
             try {
@@ -520,7 +608,7 @@ export async function handleStudioApi(
               if (!actualPath) {
                 continue;
               }
-              const depPkg = JSON.parse(await readFile(actualPath, "utf8"));
+              const depPkg = JSON.parse(await readFile(actualPath, "utf8")) as PackageJson;
               if (!depPkg.customElements) {
                 continue;
               }
@@ -528,7 +616,7 @@ export async function handleStudioApi(
               if (!existsSync(cemPath)) {
                 continue;
               }
-              const cem = JSON.parse(await readFile(cemPath, "utf8"));
+              const cem = JSON.parse(await readFile(cemPath, "utf8")) as Cem;
               for (const mod of cem.modules || []) {
                 for (const decl of mod.declarations || []) {
                   if (decl.customElement && decl.tagName) {
@@ -539,17 +627,16 @@ export async function handleStudioApi(
                       events: decl.events || [],
                       hasElements: false,
                       members: (decl.members || []).filter(
-                        (m: Record<string, unknown>) =>
-                          m.kind === "field" && m.privacy !== "private",
+                        (m) => m.kind === "field" && m.privacy !== "private",
                       ),
                       modulePath: mod.path,
                       package: name,
                       path: null,
-                      props: (decl.attributes || []).map((a: Record<string, unknown>) => ({
+                      props: (decl.attributes || []).map((a) => ({
                         default: a.default,
                         description: a.description || null,
                         name: a.name,
-                        type: (a.type as Record<string, unknown> | undefined)?.text,
+                        type: a.type?.text,
                       })),
                       slots: decl.slots || [],
                       source: "npm",
@@ -580,17 +667,14 @@ export async function handleStudioApi(
       if (!existsSync(pkgPath)) {
         return Response.json([]);
       }
-      const pkg = JSON.parse(await readFile(pkgPath, "utf8"));
+      const pkg = JSON.parse(await readFile(pkgPath, "utf8")) as PackageJson;
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-      /**
-       * @type {{
-       *   name: string;
-       *   version: string;
-       *   hasCem: boolean;
-       *   customElementsPath: string | null;
-       * }[]}
-       */
-      const packages = [];
+      const packages: {
+        name: string;
+        version: string;
+        hasCem: boolean;
+        customElementsPath: string | null;
+      }[] = [];
       for (const [name, version] of Object.entries(deps)) {
         const depPkgPath = resolve(scanRoot, "node_modules", ...name.split("/"), "package.json");
         const fallbackPath = resolve(root, "node_modules", ...name.split("/"), "package.json");
@@ -603,12 +687,12 @@ export async function handleStudioApi(
           continue;
         }
         try {
-          const depPkg = JSON.parse(await readFile(actualPath, "utf8"));
+          const depPkg = JSON.parse(await readFile(actualPath, "utf8")) as PackageJson;
           packages.push({
             customElementsPath: depPkg.customElements || null,
             hasCem: Boolean(depPkg.customElements),
             name,
-            version: /** @type {string} */ version,
+            version,
           });
         } catch {}
       }
@@ -637,7 +721,7 @@ export async function handleStudioApi(
       if (!actualPath) {
         return Response.json({ cem: null });
       }
-      const depPkg = JSON.parse(await readFile(actualPath, "utf8"));
+      const depPkg = JSON.parse(await readFile(actualPath, "utf8")) as PackageJson;
       if (!depPkg.customElements) {
         return Response.json({ cem: null });
       }
@@ -645,7 +729,7 @@ export async function handleStudioApi(
       if (!existsSync(cemPath)) {
         return Response.json({ cem: null });
       }
-      const cem = JSON.parse(await readFile(cemPath, "utf8"));
+      const cem = JSON.parse(await readFile(cemPath, "utf8")) as Cem;
       return Response.json({ cem });
     } catch (error) {
       return Response.json({ error: errorMessage(error) }, { status: 500 });
@@ -655,7 +739,7 @@ export async function handleStudioApi(
   // Add an npm package
   if (path === "/__studio/packages/add" && req.method === "POST") {
     try {
-      const body = await req.json();
+      const body = (await req.json()) as { name?: string; dir?: string; dev?: boolean };
       const { name } = body;
       if (!name || typeof name !== "string") {
         return Response.json({ error: "Missing name" }, { status: 400 });
@@ -688,7 +772,7 @@ export async function handleStudioApi(
   // Remove an npm package
   if (path === "/__studio/packages/remove" && req.method === "POST") {
     try {
-      const body = await req.json();
+      const body = (await req.json()) as { name?: string; dir?: string };
       const { name } = body;
       if (!name || typeof name !== "string") {
         return Response.json({ error: "Missing name" }, { status: 400 });
@@ -808,9 +892,9 @@ export async function handleStudioApi(
 
   // Rename file
   if (path === "/__studio/file/rename" && req.method === "POST") {
-    let body;
+    let body: { from?: string; to?: string };
     try {
-      body = await req.json();
+      body = (await req.json()) as { from?: string; to?: string };
     } catch {
       return new Response("Invalid JSON", { status: 400 });
     }
@@ -841,9 +925,9 @@ export async function handleStudioApi(
 
   // Locate a file by name within the project root
   if (path === "/__studio/locate" && req.method === "POST") {
-    let body;
+    let body: { name?: string };
     try {
-      body = await req.json();
+      body = (await req.json()) as { name?: string };
     } catch {
       return new Response("Invalid JSON", { status: 400 });
     }
@@ -879,15 +963,16 @@ export async function handleStudioApi(
   // Dispatches parse/serialize through the project's format registry by import name.
   if (path === "/__studio/format" && req.method === "POST") {
     try {
-      const body = await req.json();
-      const { format, action, source, doc, options } = body as {
+      const body = (await req.json()) as {
         format?: string;
         action?: string;
         source?: string;
         doc?: Record<string, unknown>;
         options?: Record<string, unknown>;
+        dir?: string;
       };
-      const dir = (body.dir as string | undefined) || activeProjectRoot || root;
+      const { format, action, source, doc, options } = body;
+      const dir = body.dir || activeProjectRoot || root;
       const projectRoot = isAbsolute(dir) ? dir : resolve(root, dir);
       assertAccessible(projectRoot, root, activeProjectRoot);
 
@@ -985,7 +1070,7 @@ export async function handleStudioApi(
     if (moduleAbsPath.endsWith(".class.json")) {
       try {
         const content = readFileSync(moduleAbsPath, "utf8");
-        const classDef = JSON.parse(content);
+        const classDef = JSON.parse(content) as ClassJsonDef;
         return Response.json({
           schema: extractStudioSchema(classDef, moduleAbsPath),
         });
@@ -1003,7 +1088,7 @@ export async function handleStudioApi(
     if (existsSync(classJsonPath)) {
       try {
         const content = readFileSync(classJsonPath, "utf8");
-        const classDef = JSON.parse(content);
+        const classDef = JSON.parse(content) as ClassJsonDef;
         return Response.json({
           schema: extractStudioSchema(classDef, classJsonPath),
         });
@@ -1014,7 +1099,10 @@ export async function handleStudioApi(
 
     // Fallback: import JS module (backwards compat for classes without .class.json)
     try {
-      const mod = await import(moduleAbsPath);
+      const mod = (await import(moduleAbsPath)) as {
+        default?: Record<string, unknown>;
+        [key: string]: unknown;
+      };
       const ExportedClass = mod[exportName] ?? mod.default?.[exportName];
       if (typeof ExportedClass !== "function") {
         return Response.json({
@@ -1022,7 +1110,7 @@ export async function handleStudioApi(
           schema: null,
         });
       }
-      return Response.json({ schema: ExportedClass.schema ?? null });
+      return Response.json({ schema: (ExportedClass as { schema?: unknown }).schema ?? null });
     } catch (error) {
       return Response.json({
         error: errorMessage(error),
@@ -1091,7 +1179,10 @@ export async function handleStudioApi(
       }
 
       if (gitCmd === "add-remote" && req.method === "POST") {
-        const { name, url: remoteUrl } = await req.json();
+        const { name, url: remoteUrl } = (await req.json()) as {
+          name?: string;
+          url?: string;
+        };
         if (!name || !remoteUrl) {
           return new Response("name and url required", { status: 400 });
         }
@@ -1108,9 +1199,9 @@ export async function handleStudioApi(
             continue;
           }
           const [name, head] = line.split("\t");
-          branches.push(name);
+          branches.push(name!);
           if (head === "*") {
-            current = name;
+            current = name!;
           }
         }
         return Response.json({ branches, current });
@@ -1131,7 +1222,7 @@ export async function handleStudioApi(
       }
 
       if (gitCmd === "stage" && req.method === "POST") {
-        const { files } = await req.json();
+        const { files } = (await req.json()) as { files?: string[] };
         if (!Array.isArray(files) || files.length === 0) {
           return Response.json({ error: "Missing files" }, { status: 400 });
         }
@@ -1145,7 +1236,7 @@ export async function handleStudioApi(
       }
 
       if (gitCmd === "unstage" && req.method === "POST") {
-        const { files } = await req.json();
+        const { files } = (await req.json()) as { files?: string[] };
         if (!Array.isArray(files) || files.length === 0) {
           return Response.json({ error: "Missing files" }, { status: 400 });
         }
@@ -1154,7 +1245,7 @@ export async function handleStudioApi(
       }
 
       if (gitCmd === "commit" && req.method === "POST") {
-        const { message } = await req.json();
+        const { message } = (await req.json()) as { message?: string };
         if (!message || typeof message !== "string") {
           return Response.json({ error: "Missing message" }, { status: 400 });
         }
@@ -1169,11 +1260,11 @@ export async function handleStudioApi(
       }
 
       if (gitCmd === "push" && req.method === "POST") {
-        let body: Record<string, unknown> = {};
+        let body: { setUpstream?: boolean } = {};
         try {
-          body = await req.json();
+          body = (await req.json()) as { setUpstream?: boolean };
         } catch {}
-        const { setUpstream } = body as { setUpstream?: boolean };
+        const { setUpstream } = body;
         if (setUpstream) {
           const branchRaw = await runGit(["rev-parse", "--abbrev-ref", "HEAD"]);
           const branch = branchRaw.trim();
@@ -1195,7 +1286,7 @@ export async function handleStudioApi(
       }
 
       if (gitCmd === "checkout" && req.method === "POST") {
-        const { branch } = await req.json();
+        const { branch } = (await req.json()) as { branch?: string };
         if (!branch || typeof branch !== "string") {
           return Response.json({ error: "Missing branch" }, { status: 400 });
         }
@@ -1204,7 +1295,7 @@ export async function handleStudioApi(
       }
 
       if (gitCmd === "create-branch" && req.method === "POST") {
-        const { name } = await req.json();
+        const { name } = (await req.json()) as { name?: string };
         if (!name || typeof name !== "string") {
           return Response.json({ error: "Missing name" }, { status: 400 });
         }
@@ -1238,7 +1329,7 @@ export async function handleStudioApi(
       }
 
       if (gitCmd === "discard" && req.method === "POST") {
-        const { files } = await req.json();
+        const { files } = (await req.json()) as { files?: string[] };
         if (!Array.isArray(files) || files.length === 0) {
           return Response.json({ error: "Missing files" }, { status: 400 });
         }
@@ -1252,7 +1343,7 @@ export async function handleStudioApi(
       }
 
       if (gitCmd === "clone" && req.method === "POST") {
-        const { url: repoUrl } = await req.json();
+        const { url: repoUrl } = (await req.json()) as { url?: string };
         if (!repoUrl || typeof repoUrl !== "string") {
           return Response.json({ error: "Missing url" }, { status: 400 });
         }
@@ -1284,11 +1375,13 @@ export async function handleStudioApi(
 
   if (path === "/__studio/ai/session" && req.method === "POST") {
     try {
-      const body = await req.json();
+      const body = (await req.json()) as { message?: string; systemPrompt?: string };
       const projectDir = activeProjectRoot || root;
-      const result = claude.createSession(projectDir, body.message, {
-        systemPrompt: body.systemPrompt,
-      });
+      const opts: { systemPrompt?: string } = {};
+      if (body.systemPrompt !== undefined) {
+        opts.systemPrompt = body.systemPrompt;
+      }
+      const result = claude.createSession(projectDir, body.message!, opts);
       return Response.json(result);
     } catch (error) {
       return Response.json(
@@ -1303,7 +1396,7 @@ export async function handleStudioApi(
     path.endsWith("/stream") &&
     req.method === "GET"
   ) {
-    const [id] = path.split("/").slice(4);
+    const id = path.split("/").slice(4)[0]!;
     return claude.streamSession(id);
   }
 
@@ -1313,9 +1406,9 @@ export async function handleStudioApi(
     req.method === "POST"
   ) {
     try {
-      const [id] = path.split("/").slice(4);
-      const body = await req.json();
-      claude.sendMessage(id, body.message);
+      const id = path.split("/").slice(4)[0]!;
+      const body = (await req.json()) as { message?: string };
+      claude.sendMessage(id, body.message!);
       return Response.json({ ok: true });
     } catch (error) {
       return Response.json(
@@ -1326,19 +1419,19 @@ export async function handleStudioApi(
   }
 
   if (path.startsWith("/__studio/ai/session/") && path.endsWith("/stop") && req.method === "POST") {
-    const [id] = path.split("/").slice(4);
+    const id = path.split("/").slice(4)[0]!;
     claude.stopSession(id);
     return Response.json({ ok: true });
   }
 
   if (path.startsWith("/__studio/ai/session/") && req.method === "DELETE") {
-    const [id] = path.split("/").slice(4);
+    const id = path.split("/").slice(4)[0]!;
     claude.deleteSession(id);
     return Response.json({ ok: true });
   }
 
   if (path.startsWith("/__studio/ai/session/") && req.method === "GET") {
-    const [id] = path.split("/").slice(4);
+    const id = path.split("/").slice(4)[0]!;
     const info = claude.getSession(id);
     if (!info) {
       return Response.json({ error: "Not found" }, { status: 404 });
@@ -1369,7 +1462,7 @@ function extractStudioSchema(classDef: ClassJsonDef, classJsonPath: string) {
     try {
       const parentPath = resolve(dirname(classJsonPath), classDef.extends.$ref);
       const parentContent = readFileSync(parentPath, "utf8");
-      const parentDef = JSON.parse(parentContent);
+      const parentDef = JSON.parse(parentContent) as ClassJsonDef;
       parentSchema = extractStudioSchema(parentDef, parentPath);
     } catch {
       // Parent not found — proceed without inheritance