@jxsuite/server 0.23.2 → 0.25.0

package/src/{studio-api.js → studio-api.ts}

@@ -11,10 +11,11 @@ import { resolve, relative, basename, dirname, isAbsolute } from "node:path";
 import { readdir, stat, readFile, writeFile, rename, unlink, mkdir } from "node:fs/promises";
 import { readFileSync, existsSync } from "node:fs";
 import { transpileJxMarkdown } from "@jxsuite/parser/transpile";
-import * as claude from "./claude-session.js";
+import * as claude from "./claude-session.ts";
+import type { ClassJsonDef } from "./types.ts";
 
 /** Normalise a path to forward slashes (Windows `path` module returns backslashes). */
-const fwd = (/** @type {string} */ p) => p.replaceAll("\\", "/");
+const fwd = (p: string) => p.replaceAll("\\", "/");
 
 /**
  * Check that a path is under either the server root OR the active project root. This allows file
@@ -24,7 +25,7 @@ const fwd = (/** @type {string} */ p) => p.replaceAll("\\", "/");
  * @param {string} root
  * @param {string | null} activeProjectRoot
  */
-function assertAccessible(filePath, root, activeProjectRoot) {
+function assertAccessible(filePath: string, root: string, activeProjectRoot: string | null) {
   const rel = relative(root, filePath);
   if (!rel.startsWith("..") && !rel.startsWith("/")) return;
   if (activeProjectRoot) {
@@ -34,8 +35,15 @@ function assertAccessible(filePath, root, activeProjectRoot) {
   throw new Error("Path outside project root");
 }
 
-/** @type {Record<string, string>} */
-const statusMap = { M: "M", T: "T", A: "A", D: "D", R: "R", C: "C", U: "U" };
+const statusMap: Record<string, string> = {
+  M: "M",
+  T: "T",
+  A: "A",
+  D: "D",
+  R: "R",
+  C: "C",
+  U: "U",
+};
 
 /**
  * Parse raw `git status --porcelain=v2 --branch` output into structured data.
@@ -50,7 +58,7 @@ const statusMap = { M: "M", T: "T", A: "A", D: "D", R: "R", C: "C", U: "U" };
  *   remotes?: string[];
  * }}
  */
-export function parseGitStatus(out) {
+export function parseGitStatus(out: string) {
   let branch = "";
   let ahead = 0;
   let behind = 0;
@@ -108,7 +116,12 @@ export function parseGitStatus(out) {
  * @param {string | null} [activeProjectRoot]
  * @returns {Promise<Response | null>}
  */
-export async function handleStudioApi(req, url, root, activeProjectRoot = null) {
+export async function handleStudioApi(
+  req: Request,
+  url: URL,
+  root: string,
+  activeProjectRoot: string | null = null,
+) {
   const path = url.pathname;
 
   // Project metadata
@@ -131,11 +144,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
     const absDir = isAbsolute(dir) ? dir : resolve(root, dir);
     try {
       assertAccessible(absDir, root, activeProjectRoot);
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 400 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 400 });
     }
     try {
       const projectRoot = fwd(absDir);
@@ -167,11 +177,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
       } catch {}
 
       return Response.json({ isSiteProject, projectConfig, directories, projectRoot });
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 500 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 500 });
     }
   }
 
@@ -205,11 +212,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
         dir = parent;
       }
       return Response.json({ sitePath: null });
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 500 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 500 });
     }
   }
 
@@ -230,11 +234,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
         }
       } catch {}
       return Response.json({ path: null });
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 500 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 500 });
     }
   }
 
@@ -260,11 +261,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
         } catch {}
       }
       return Response.json(sites);
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 500 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 500 });
     }
   }
 
@@ -285,11 +283,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
       const config = JSON.parse(await readFile(resolve(destPath, "project.json"), "utf8"));
       const projectRoot = fwd(relative(root, destPath));
       return Response.json({ root: projectRoot, config });
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 500 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 500 });
     }
   }
 
@@ -300,15 +295,12 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
     const absDir = isAbsolute(dir) ? dir : resolve(root, dir);
     try {
       assertAccessible(absDir, root, activeProjectRoot);
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 400 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 400 });
     }
 
     /** Report a path relative to the active project root (or server root as fallback). */
-    const reportRelative = (/** @type {string} */ fp) => {
+    const reportRelative = (fp: string) => {
       if (activeProjectRoot) {
         const rel = relative(activeProjectRoot, fp);
         if (!rel.startsWith("..")) return fwd(rel);
@@ -352,11 +344,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
         });
       }
       return Response.json(files);
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 500 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 500 });
     }
   }
 
@@ -366,11 +355,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
     const scanRoot = isAbsolute(dir) ? dir : resolve(root, dir);
     try {
       assertAccessible(scanRoot, root, activeProjectRoot);
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 400 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 400 });
     }
     try {
       const glob = new Bun.Glob("**/*.{json,md}");
@@ -406,14 +392,16 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
                   // Shorthand: "key": "value" or "key": 0 etc.
                   if (typeof d !== "object") return true;
                   // Full form: skip computed/handler/prototype entries
-                  return !d.$prototype && !d.$handler && !d.$compute;
+                  const obj = d as Record<string, unknown>;
+                  return !obj.$prototype && !obj.$handler && !obj.$compute;
                 })
                 .map(([name, d]) => {
-                  if (typeof d !== "object") {
+                  if (typeof d !== "object" || d === null) {
                     // Shorthand: infer type from value
                     return { name, type: typeof d, default: d };
                   }
-                  return { name, type: d.type, default: d.default, format: d.format };
+                  const obj = d as Record<string, unknown>;
+                  return { name, type: obj.type, default: obj.default, format: obj.format };
                 }),
               hasElements: Array.isArray(content.$elements) && content.$elements.length > 0,
             });
@@ -464,16 +452,14 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
                       source: "npm",
                       package: name,
                       description: decl.description || null,
-                      props: (decl.attributes || []).map(
-                        (/** @type {Record<string, unknown>} */ a) => ({
-                          name: a.name,
-                          type: /** @type {Record<string, unknown> | undefined} */ (a.type)?.text,
-                          default: a.default,
-                          description: a.description || null,
-                        }),
-                      ),
+                      props: (decl.attributes || []).map((a: Record<string, unknown>) => ({
+                        name: a.name,
+                        type: (a.type as Record<string, unknown> | undefined)?.text,
+                        default: a.default,
+                        description: a.description || null,
+                      })),
                       members: (decl.members || []).filter(
-                        (/** @type {Record<string, unknown>} */ m) =>
+                        (m: Record<string, unknown>) =>
                           m.kind === "field" && m.privacy !== "private",
                       ),
                       slots: decl.slots || [],
@@ -490,11 +476,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
       } catch {} // skip if no project package.json
 
       return Response.json(components);
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 500 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 500 });
     }
   }
 
@@ -538,11 +521,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
         } catch {}
       }
       return Response.json(packages);
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 500 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 500 });
     }
   }
 
@@ -567,11 +547,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
       if (!existsSync(cemPath)) return Response.json({ cem: null });
       const cem = JSON.parse(await readFile(cemPath, "utf8"));
       return Response.json({ cem });
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 500 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 500 });
     }
   }
 
@@ -596,11 +573,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
         );
       }
       return Response.json({ ok: true });
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 500 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 500 });
     }
   }
 
@@ -623,11 +597,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
         );
       }
       return Response.json({ ok: true });
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 500 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 500 });
     }
   }
 
@@ -638,21 +609,21 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
     const abs = fp.startsWith("~") ? fp.replace("~", process.env.HOME || "") : fp;
     try {
       assertAccessible(abs, root, activeProjectRoot);
-    } catch (/** @type {unknown} */ e) {
-      return new Response(/** @type {{ message?: string }} */ (e).message, { status: 400 });
+    } catch (e) {
+      return new Response((e as Error).message, { status: 400 });
     }
     try {
-      return Response.json({
-        content: await readFile(abs, "utf8"),
-        path: fp,
-      });
-    } catch (/** @type {unknown} */ e) {
-      return /** @type {{ code?: string }} */ (e).code === "ENOENT"
+      return Response.json(
+        {
+          content: await readFile(abs, "utf8"),
+          path: fp,
+        },
+        { headers: { "Cache-Control": "public, max-age=5" } },
+      );
+    } catch (e) {
+      return (e as NodeJS.ErrnoException).code === "ENOENT"
         ? new Response("Not found", { status: 404 })
-        : Response.json(
-            { error: /** @type {{ message?: string }} */ (e).message },
-            { status: 500 },
-          );
+        : Response.json({ error: (e as Error).message }, { status: 500 });
     }
   }
 
@@ -663,18 +634,15 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
     const abs = resolve(root, fp);
     try {
       assertAccessible(abs, root, activeProjectRoot);
-    } catch (/** @type {unknown} */ e) {
-      return new Response(/** @type {{ message?: string }} */ (e).message, { status: 400 });
+    } catch (e) {
+      return new Response((e as Error).message, { status: 400 });
     }
     try {
       await mkdir(dirname(abs), { recursive: true });
       await writeFile(abs, await req.text(), "utf8");
       return Response.json({ ok: true, path: fwd(relative(root, abs)) });
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 500 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 500 });
     }
   }
 
@@ -685,19 +653,16 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
     const abs = resolve(root, fp);
     try {
       assertAccessible(abs, root, activeProjectRoot);
-    } catch (/** @type {unknown} */ e) {
-      return new Response(/** @type {{ message?: string }} */ (e).message, { status: 400 });
+    } catch (e) {
+      return new Response((e as Error).message, { status: 400 });
     }
     try {
       await mkdir(dirname(abs), { recursive: true });
       const buffer = await req.arrayBuffer();
       await Bun.write(abs, new Uint8Array(buffer));
       return Response.json({ ok: true, path: fwd(relative(root, abs)) });
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 500 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 500 });
     }
   }
 
@@ -708,19 +673,16 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
     const abs = resolve(root, fp);
     try {
       assertAccessible(abs, root, activeProjectRoot);
-    } catch (/** @type {unknown} */ e) {
-      return new Response(/** @type {{ message?: string }} */ (e).message, { status: 400 });
+    } catch (e) {
+      return new Response((e as Error).message, { status: 400 });
     }
     try {
       await unlink(abs);
       return Response.json({ ok: true, path: fwd(relative(root, abs)) });
-    } catch (/** @type {unknown} */ e) {
-      return /** @type {{ code?: string }} */ (e).code === "ENOENT"
+    } catch (e) {
+      return (e as NodeJS.ErrnoException).code === "ENOENT"
         ? new Response("Not found", { status: 404 })
-        : Response.json(
-            { error: /** @type {{ message?: string }} */ (e).message },
-            { status: 500 },
-          );
+        : Response.json({ error: (e as Error).message }, { status: 500 });
     }
   }
 
@@ -739,8 +701,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
     try {
       assertAccessible(absFrom, root, activeProjectRoot);
       assertAccessible(absTo, root, activeProjectRoot);
-    } catch (/** @type {unknown} */ e) {
-      return new Response(/** @type {{ message?: string }} */ (e).message, { status: 400 });
+    } catch (e) {
+      return new Response((e as Error).message, { status: 400 });
     }
     try {
       await mkdir(dirname(absTo), { recursive: true });
@@ -750,11 +712,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
         from: fwd(relative(root, absFrom)),
         to: fwd(relative(root, absTo)),
       });
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 500 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 500 });
     }
   }
 
@@ -782,11 +741,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
         path: matches[0],
         ...(matches.length > 1 ? { alternatives: matches } : {}),
       });
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 500 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 500 });
     }
   }
 
@@ -823,10 +779,10 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
           moduleAbsPath = serverRequire.resolve(src);
         }
       }
-    } catch (/** @type {unknown} */ e) {
+    } catch (e) {
       return Response.json({
         schema: null,
-        error: /** @type {{ message?: string }} */ (e).message,
+        error: (e as Error).message,
       });
     }
 
@@ -836,10 +792,10 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
         const content = readFileSync(moduleAbsPath, "utf8");
         const classDef = JSON.parse(content);
         return Response.json({ schema: extractStudioSchema(classDef, moduleAbsPath) });
-      } catch (/** @type {unknown} */ e) {
+      } catch (e) {
         return Response.json({
           schema: null,
-          error: /** @type {{ message?: string }} */ (e).message,
+          error: (e as Error).message,
         });
       }
     }
@@ -865,10 +821,10 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
         return Response.json({ schema: null, error: `Export "${exportName}" not found` });
       }
       return Response.json({ schema: ExportedClass.schema ?? null });
-    } catch (/** @type {unknown} */ e) {
+    } catch (e) {
       return Response.json({
         schema: null,
-        error: /** @type {{ message?: string }} */ (e).message,
+        error: (e as Error).message,
       });
     }
   }
@@ -879,7 +835,7 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
     const cwd = activeProjectRoot || root;
     const gitCmd = path.slice("/__studio/git/".length);
 
-    const runGit = async (/** @type {string[]} */ args) => {
+    const runGit = async (args: string[]) => {
       const proc = Bun.spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "pipe" });
       const exitCode = await proc.exited;
       const stdout = await new Response(proc.stdout).text();
@@ -913,9 +869,12 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
           runGit(["remote"]),
         ]);
         const status = parseGitStatus(out);
-        status.isRepo = true;
-        status.remotes = remotesOut.trim().split("\n").filter(Boolean);
-        return Response.json(status);
+        const fullStatus = {
+          ...status,
+          isRepo: true,
+          remotes: remotesOut.trim().split("\n").filter(Boolean),
+        };
+        return Response.json(fullStatus);
       }
 
       if (gitCmd === "init" && req.method === "POST") {
@@ -991,11 +950,11 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
       }
 
       if (gitCmd === "push" && req.method === "POST") {
-        let body = {};
+        let body: Record<string, unknown> = {};
         try {
           body = await req.json();
         } catch {}
-        const { setUpstream } = /** @type {{ setUpstream?: boolean }} */ (body);
+        const { setUpstream } = body as { setUpstream?: boolean };
         if (setUpstream) {
           const branch = (await runGit(["rev-parse", "--abbrev-ref", "HEAD"])).trim();
           await runGit(["push", "-u", "origin", branch]);
@@ -1075,11 +1034,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
         if (exitCode !== 0) throw new Error(stderr || `git clone exited with ${exitCode}`);
         return Response.json({ ok: true, root: dest });
       }
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 500 },
-      );
+    } catch (e) {
+      return Response.json({ error: (e as Error).message }, { status: 500 });
     }
   }
 
@@ -1098,8 +1054,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
         systemPrompt: body.systemPrompt,
       });
       return Response.json(result);
-    } catch (/** @type {any} */ e) {
-      return Response.json({ error: e.message }, { status: 500 });
+    } catch (e) {
+      return Response.json({ error: e instanceof Error ? e.message : String(e) }, { status: 500 });
     }
   }
 
@@ -1122,8 +1078,8 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
       const body = await req.json();
       claude.sendMessage(id, body.message);
       return Response.json({ ok: true });
-    } catch (/** @type {any} */ e) {
-      return Response.json({ error: e.message }, { status: 500 });
+    } catch (e) {
+      return Response.json({ error: e instanceof Error ? e.message : String(e) }, { status: 500 });
     }
   }
 
@@ -1162,7 +1118,7 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
  *   required: string[];
  * }}
  */
-function extractStudioSchema(classDef, classJsonPath) {
+function extractStudioSchema(classDef: ClassJsonDef, classJsonPath: string) {
   // If extends.$ref points to a parent, recursively merge
   let parentSchema = null;
   if (classDef.extends && typeof classDef.extends === "object" && classDef.extends.$ref) {
@@ -1178,10 +1134,8 @@ function extractStudioSchema(classDef, classJsonPath) {
 
   const params = classDef.$defs?.parameters ?? {};
   const fields = classDef.$defs?.fields ?? {};
-  /** @type {Record<string, Record<string, unknown>>} */
-  const properties = {};
-  /** @type {string[]} */
-  const required = [];
+  const properties: Record<string, Record<string, unknown>> = {};
+  const required: string[] = [];
 
   // Start with parent properties (child overrides)
   if (parentSchema?.properties) {
@@ -1194,8 +1148,7 @@ function extractStudioSchema(classDef, classJsonPath) {
   // Build properties from parameters (constructor config surface)
   for (const [key, param] of Object.entries(params)) {
     const id = param.identifier ?? key;
-    /** @type {Record<string, unknown>} */
-    const prop = {};
+    const prop: Record<string, unknown> = {};
     if (param.type && typeof param.type === "object") Object.assign(prop, param.type);
     if (param.description) prop.description = param.description;
     if (param.examples) prop.examples = param.examples;
@@ -1208,8 +1161,7 @@ function extractStudioSchema(classDef, classJsonPath) {
     if (field.role !== "field") continue;
     if (field.access === "private") continue;
     const id = field.identifier ?? key;
-    /** @type {Record<string, unknown>} */
-    const prop = {};
+    const prop: Record<string, unknown> = {};
     if (field.type && typeof field.type === "object") Object.assign(prop, field.type);
     if (field.description) prop.description = field.description;
     if (field.default !== undefined) prop.default = field.default;
@@ -1221,8 +1173,7 @@ function extractStudioSchema(classDef, classJsonPath) {
 
   // Determine required from constructor parameters that have no default
   const ctorParams = classDef.$defs?.constructor?.parameters ?? [];
-  /** @type {Set<string>} */
-  const requiredSet = new Set(required);
+  const requiredSet: Set<string> = new Set(required);
   for (const p of ctorParams) {
     const name = p.$ref ? p.$ref.split("/").pop() : (p.identifier ?? p.name);
     if (name && properties[name] && properties[name].default === undefined) {
@@ -1230,9 +1181,12 @@ function extractStudioSchema(classDef, classJsonPath) {
     }
   }
 
+  const resolveMethod = classDef.$defs?.methods?.resolve;
+
   return {
     description: classDef.description ?? classDef.title,
     properties,
     required: [...requiredSet],
+    ...(resolveMethod?.returns ? { returns: resolveMethod.returns } : {}),
   };
 }

package/src/types.ts

@@ -0,0 +1,61 @@
+export interface BuildEntry {
+  entrypoints: string[];
+  outdir: string;
+  match?: ((path: string) => boolean) | RegExp;
+  label?: string;
+}
+
+export interface ClassJsonParam {
+  $ref?: string;
+  identifier?: string;
+  name?: string;
+}
+
+export interface ClassJsonField {
+  role?: string;
+  access?: string;
+  scope?: string;
+  identifier?: string;
+  initializer?: unknown;
+  default?: unknown;
+  type?: Record<string, unknown>;
+  description?: string;
+  examples?: unknown[];
+}
+
+export interface ClassJsonMethod {
+  identifier?: string;
+  role?: string;
+  scope?: string;
+  body?: string | string[];
+  getter?: { body: string };
+  setter?: { parameters?: ClassJsonParam[]; body: string };
+  parameters?: ClassJsonParam[];
+  returns?: Record<string, unknown>;
+}
+
+export interface ClassJsonParameterDef {
+  identifier?: string;
+  type?: Record<string, unknown>;
+  format?: string;
+  description?: string;
+  examples?: unknown[];
+}
+
+export interface ClassJsonDef {
+  title?: string;
+  description?: string;
+  $implementation?: string;
+  extends?: { $ref?: string };
+  $defs?: {
+    fields?: Record<string, ClassJsonField>;
+    constructor?: {
+      role?: string;
+      $prototype?: string;
+      body?: string | string[];
+      parameters?: ClassJsonParam[];
+    };
+    methods?: Record<string, ClassJsonMethod>;
+    parameters?: Record<string, ClassJsonParameterDef>;
+  };
+}