npm - lecodes-3d-editor - Versions diffs - 0.1.0 - Mend

lecodes-3d-editor 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

package/README.md +31 -0
package/dist/app/assets/createViewer-DGHC9eXK.js +5 -0
package/dist/app/assets/createViewer2d-CI6PFuCm.js +1 -0
package/dist/app/assets/createViewerLite-CoShwplA.js +487 -0
package/dist/app/assets/creator-gl-GaTBGmVI.wasm +0 -0
package/dist/app/assets/creator-ui-DNJBpZ2P.wasm +0 -0
package/dist/app/assets/creator2d-zNxn9uSj.wasm +0 -0
package/dist/app/assets/fetch-CbiE4Jmm.js +1 -0
package/dist/app/assets/fetch-yAxxs-ZQ.js +1 -0
package/dist/app/assets/gizmo-D5xdNVjw.filamat +0 -0
package/dist/app/assets/index-BuGYQX6Z.css +1 -0
package/dist/app/assets/index-DZc_N5Kk.js +2 -0
package/dist/app/assets/lit-WtoZF0Yx.filamat +0 -0
package/dist/app/assets/matcap_porcelain_white-DRnbNWwg.jpg +0 -0
package/dist/app/assets/mediaplayer-40oza6jV.js +1 -0
package/dist/app/assets/neutral_ibl128-D-lzdkLN.ktx +0 -0
package/dist/app/assets/shadow-CnJ-PXnb.filamat +0 -0
package/dist/app/assets/src-DKPpeImT.js +451 -0
package/dist/app/assets/uberarchive-De8g3sSw.bin +0 -0
package/dist/app/assets/unlit-pnl94z8g.filamat +0 -0
package/dist/app/assets/video-CdjDrvX4.filamat +0 -0
package/dist/app/index.html +26 -0
package/dist/server.js +503 -0
package/package.json +34 -0
package/src/index.ts +19 -0

package/dist/app/assets/uberarchive-De8g3sSw.bin ADDED Viewed

Binary file

package/dist/app/assets/unlit-pnl94z8g.filamat ADDED Viewed

Binary file

package/dist/app/assets/video-CdjDrvX4.filamat ADDED Viewed

Binary file

package/dist/app/index.html ADDED Viewed

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>LeCodes Scene Editor</title>
+  <style>
+    /* Theme tokens (--bg, --accent, --font-ui, …) come from ui-kit, imported in main.ts. */
+    * { box-sizing: border-box; margin: 0; }
+    html, body, #app { height: 100%; }
+    body {
+      background: var(--bg);
+      color: var(--text);
+      font-family: var(--font-ui);
+      font-size: 14px;
+      overflow: hidden;
+    }
+    #app { display: flex; flex-direction: column; }
+  </style>
+  <script type="module" crossorigin src="/assets/index-DZc_N5Kk.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-BuGYQX6Z.css">
+</head>
+<body>
+  <div id="app"></div>
+</body>
+</html>

package/dist/server.js ADDED Viewed

@@ -0,0 +1,503 @@
+// src/server/index.ts
+import { createServer } from "node:http";
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync as statSync2, watch } from "node:fs";
+import { dirname, extname, join as join2, normalize, resolve as resolve2, sep as sep2 } from "node:path";
+import { fileURLToPath } from "node:url";
+// src/server/handlers.ts
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
+// src/sceneDocUtils.ts
+var ASPECT_RE = /(?:export\s+)?class\s+([A-Za-z_$][\w$]*)\s+extends\s+Aspect\s*</g;
+var classBody = (text, from) => {
+  let angle = 1;
+  let i = from;
+  for (;i < text.length && angle > 0; i++) {
+    if (text[i] === "<")
+      angle++;
+    else if (text[i] === ">")
+      angle--;
+  }
+  const open = text.indexOf("{", i);
+  if (open < 0)
+    return "";
+  let depth = 0;
+  for (let j = open;j < text.length; j++) {
+    if (text[j] === "{")
+      depth++;
+    else if (text[j] === "}" && --depth === 0)
+      return text.slice(open + 1, j);
+  }
+  return "";
+};
+var PROP_LINE_RE = /^\s*(?:readonly\s+)?([A-Za-z_$][\w$]*)\s*[?!]?\s*(?::\s*([^=;]+?))?\s*(?:=(?!=)|;|$)/;
+var extractFieldHints = (body) => {
+  const hints = [];
+  let depth = 0;
+  let doc = null;
+  let pendingDoc;
+  for (const line of body.split(`
+`)) {
+    const trimmed = line.trim();
+    if (doc) {
+      const end = trimmed.indexOf("*/");
+      doc.push(end >= 0 ? trimmed.slice(0, end) : trimmed);
+      if (end >= 0) {
+        pendingDoc = doc.map((l) => l.replace(/^[/*\s]+/, "").trim()).filter(Boolean).join(" ");
+        doc = null;
+      }
+      continue;
+    }
+    if (depth === 0) {
+      if (trimmed.startsWith("/**")) {
+        const oneLine = trimmed.indexOf("*/");
+        if (oneLine >= 0)
+          pendingDoc = trimmed.slice(3, oneLine).trim();
+        else
+          doc = [trimmed.slice(3)];
+        continue;
+      }
+      const m = trimmed.length > 0 && !trimmed.includes("(") ? PROP_LINE_RE.exec(line) : null;
+      if (m) {
+        const [, key, typeText] = m;
+        const parts = typeText?.split("|").map((p) => p.trim()) ?? [];
+        const literals = parts.map((p) => /^['"]([^'"]*)['"]$/.exec(p)?.[1]);
+        const options = parts.length >= 2 && literals.every((l) => l !== undefined) ? literals : undefined;
+        const node = parts.length > 0 && parts.every((p) => p === "Node" || p === "null") && parts.includes("Node") ? true : undefined;
+        if (options || pendingDoc || node)
+          hints.push({ key, options, tooltip: pendingDoc, node });
+      }
+      if (trimmed.length > 0 && !trimmed.startsWith("//"))
+        pendingDoc = undefined;
+    }
+    for (const ch of line) {
+      if (ch === "{")
+        depth++;
+      else if (ch === "}")
+        depth = Math.max(0, depth - 1);
+    }
+  }
+  return hints;
+};
+var scanUserAspects = (files) => {
+  const out = [];
+  for (const file of files) {
+    if (!file.path.endsWith(".ts") || file.path.endsWith(".scene.ts"))
+      continue;
+    if (!file.text.includes("extends Aspect"))
+      continue;
+    for (const m of file.text.matchAll(ASPECT_RE)) {
+      const hints = extractFieldHints(classBody(file.text, m.index + m[0].length));
+      out.push({ className: m[1], path: file.path, hints: hints.length > 0 ? hints : undefined });
+    }
+  }
+  return out;
+};
+// src/server/handlers.ts
+var TEXT_EXT = /\.(ts|js|json|svg|txt|md)$/i;
+var listProjectFiles = (dir, prefix = "") => {
+  const out = [];
+  for (const name of readdirSync(dir)) {
+    if (name === "node_modules" || name.startsWith("."))
+      continue;
+    const full = join(dir, name);
+    const rel = prefix ? `${prefix}/${name}` : name;
+    if (statSync(full).isDirectory())
+      out.push(...listProjectFiles(full, rel));
+    else
+      out.push(rel);
+  }
+  return out;
+};
+var projectOverview = (projectDir) => {
+  const files = listProjectFiles(projectDir);
+  const scenes = files.filter((f) => f.endsWith(".scene.ts")).map((f) => "./" + f);
+  const models = files.filter((f) => /\.(glb|gltf)$/i.test(f)).map((f) => "./" + f);
+  const aspects = scanUserAspects(files.filter((f) => TEXT_EXT.test(f)).map((f) => ({
+    path: "./" + f,
+    text: readFileSync(join(projectDir, f), "utf8")
+  })));
+  return { dir: projectDir, scenes, aspects, models };
+};
+var resolveInside = (projectDir, path) => {
+  const rel = path.replace(/^\.?[/\\]/, "").replace(/\\/g, "/");
+  const full = resolve(projectDir, rel);
+  if (full !== projectDir && !full.startsWith(resolve(projectDir) + sep))
+    return null;
+  return full;
+};
+var readBody = (req) => new Promise((res, rej) => {
+  let body = "";
+  req.on("data", (c) => {
+    body += c;
+  });
+  req.on("end", () => res(body));
+  req.on("error", rej);
+});
+var sendJson = (res, data, status = 200) => {
+  res.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+  res.end(JSON.stringify(data));
+};
+var handleSceneApi = async (host, req, res) => {
+  const { projectDir } = host;
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const path = url.pathname;
+  try {
+    if (path === "/api/project" && req.method === "GET") {
+      sendJson(res, projectOverview(projectDir));
+      return true;
+    }
+    if (path === "/api/file" && req.method === "GET") {
+      const full = resolveInside(projectDir, url.searchParams.get("path") ?? "");
+      if (!full || !existsSync(full)) {
+        sendJson(res, { error: "not found" }, 404);
+        return true;
+      }
+      sendJson(res, { text: readFileSync(full, "utf8") });
+      return true;
+    }
+    if (path === "/api/file" && req.method === "POST") {
+      const { path: rel, text } = JSON.parse(await readBody(req));
+      const full = resolveInside(projectDir, rel);
+      if (!full || typeof text !== "string") {
+        sendJson(res, { error: "bad request" }, 400);
+        return true;
+      }
+      writeFileSync(full, text, "utf8");
+      sendJson(res, { ok: true });
+      return true;
+    }
+    if (path === "/api/compile" && req.method === "POST") {
+      const { path: scenePath } = JSON.parse(await readBody(req));
+      if (typeof scenePath !== "string") {
+        sendJson(res, { js: null, error: "no scene path" });
+        return true;
+      }
+      try {
+        sendJson(res, await host.compile(scenePath));
+      } catch (e) {
+        sendJson(res, { js: null, error: e?.message?.replace(/mem:/g, "") ?? String(e) });
+      }
+      return true;
+    }
+    if (path.startsWith("/project/") && req.method === "GET") {
+      const full = resolveInside(projectDir, decodeURIComponent(path.slice("/project/".length)));
+      if (!full || !existsSync(full)) {
+        res.statusCode = 404;
+        res.end("Not found");
+        return true;
+      }
+      res.writeHead(200, { "content-type": "application/octet-stream", "cache-control": "no-store" });
+      res.end(readFileSync(full));
+      return true;
+    }
+  } catch (e) {
+    sendJson(res, { error: e?.message ?? String(e) }, 500);
+    return true;
+  }
+  return false;
+};
+// src/server/mcp.ts
+var PROTOCOL_VERSION = "2025-06-18";
+var KNOWN_PROTOCOLS = new Set(["2024-11-05", "2025-03-26", "2025-06-18"]);
+var ok = (id, result) => ({ jsonrpc: "2.0", id, result });
+var err = (id, code, message) => ({ jsonrpc: "2.0", id, error: { code, message } });
+var text = (s) => ({ type: "text", text: s });
+var asStringArray = (value) => Array.isArray(value) && value.every((v) => typeof v === "string") ? value : undefined;
+var TOOLS = [
+  {
+    name: "scene_state",
+    description: "The live project the editor sees: every `.scene.ts` file, every GLB/glTF model, and every " + "user aspect class (extends Aspect) with its syntactic field hints — string-literal-union " + "fields → select options, a JSDoc → the field tooltip, a `Node | null` field → a node " + "reference. Read this before adding nodes/aspects to a scene: it tells you which aspects and " + "models exist and what each aspect's editable fields are, which re-reading the source doesn't " + "hand you pre-synthesized. Editing a scene's nodes stays with your own Read/Edit of the " + "`.scene.ts` (a declarative defineScene).",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    run: (_args, ctx) => {
+      const { dir: _dir, ...rest } = ctx.overview();
+      return { content: [text(JSON.stringify(rest, null, 2))] };
+    }
+  },
+  {
+    name: "check_scene",
+    description: "Compile scenes through the editor's pipeline and report ok / compile-error per scene — the fast " + "'did I break anything?' loop after editing a .scene.ts or an aspect. No rendering. Omit " + "`paths` to check every scene. A compile error's message points at the offending source.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        paths: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Scene paths to check, e.g. "./city.scene.ts" (default: all scenes).'
+        }
+      },
+      additionalProperties: false
+    },
+    run: async (args, ctx) => {
+      const all = ctx.listScenes();
+      const requested = asStringArray(args.paths)?.map((p) => p.startsWith("./") ? p : "./" + p.replace(/^\//, ""));
+      const unknown = requested?.filter((p) => !all.includes(p)) ?? [];
+      const paths = requested ? requested.filter((p) => all.includes(p)) : all;
+      const scenes = await Promise.all(paths.map(async (path) => {
+        try {
+          const compiled = await ctx.compile(path);
+          return compiled.js !== null && !compiled.error ? { path, ok: true } : { path, ok: false, error: compiled.error ?? "compile produced no output" };
+        } catch (e) {
+          return { path, ok: false, error: e instanceof Error ? e.message : String(e) };
+        }
+      }));
+      const summary = {
+        ok: scenes.every((s) => s.ok),
+        checked: scenes.length,
+        failed: scenes.filter((s) => !s.ok).length,
+        scenes,
+        ...unknown.length ? { unknownPaths: unknown } : {}
+      };
+      return { content: [text(JSON.stringify(summary, null, 2))], isError: !summary.ok };
+    }
+  }
+];
+var listToolsResult = () => ({
+  tools: TOOLS.map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema }))
+});
+var callTool = async (params, ctx) => {
+  const { name, arguments: args } = params ?? {};
+  const tool = TOOLS.find((t) => t.name === name);
+  if (!tool)
+    return { content: [text(`Unknown tool: ${String(name)}`)], isError: true };
+  try {
+    return await tool.run(args ?? {}, ctx);
+  } catch (e) {
+    return { content: [text(e instanceof Error ? e.message : String(e))], isError: true };
+  }
+};
+var handleOne = async (msg, ctx) => {
+  const id = msg && typeof msg === "object" && "id" in msg ? msg.id : undefined;
+  const isNotification = id === undefined;
+  if (!msg || typeof msg !== "object" || typeof msg.method !== "string") {
+    return isNotification ? undefined : err(id ?? null, -32600, "Invalid Request");
+  }
+  const method = msg.method;
+  if (isNotification)
+    return;
+  switch (method) {
+    case "initialize": {
+      const requested = msg.params?.protocolVersion;
+      const protocolVersion = typeof requested === "string" && KNOWN_PROTOCOLS.has(requested) ? requested : PROTOCOL_VERSION;
+      return ok(id, {
+        protocolVersion,
+        capabilities: { tools: {} },
+        serverInfo: { name: ctx.serverName, version: ctx.version }
+      });
+    }
+    case "ping":
+      return ok(id, {});
+    case "tools/list":
+      return ok(id, listToolsResult());
+    case "tools/call":
+      return ok(id, await callTool(msg.params, ctx));
+    default:
+      return err(id, -32601, `Method not found: ${method}`);
+  }
+};
+var handleMcpMessage = async (message, ctx) => {
+  if (Array.isArray(message)) {
+    if (message.length === 0)
+      return err(null, -32600, "Invalid Request");
+    const responses = [];
+    for (const m of message) {
+      const r = await handleOne(m, ctx);
+      if (r !== undefined)
+        responses.push(r);
+    }
+    return responses.length ? responses : undefined;
+  }
+  return handleOne(message, ctx);
+};
+// src/server/index.ts
+var MCP_VERSION = "1.0.0";
+var readBody2 = (req) => new Promise((resolveBody, rejectBody) => {
+  let data = "";
+  req.on("data", (chunk) => {
+    data += chunk;
+  });
+  req.on("end", () => {
+    try {
+      resolveBody(JSON.parse(data || "{}"));
+    } catch (e) {
+      rejectBody(e);
+    }
+  });
+  req.on("error", rejectBody);
+});
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".ico": "image/x-icon",
+  ".wasm": "application/wasm",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".bin": "application/octet-stream"
+};
+var sendFile = (res, baseDir, relPath) => {
+  const abs = resolve2(baseDir, "." + sep2 + normalize(relPath).replace(/^([/\\])+/, ""));
+  if (!abs.startsWith(resolve2(baseDir) + sep2) && abs !== resolve2(baseDir))
+    return false;
+  if (!existsSync2(abs) || !statSync2(abs).isFile())
+    return false;
+  res.writeHead(200, {
+    "content-type": MIME[extname(abs).toLowerCase()] ?? "application/octet-stream",
+    "cache-control": "no-store"
+  });
+  res.end(readFileSync2(abs));
+  return true;
+};
+var startSceneServer = async (options) => {
+  const port = options.port ?? 4488;
+  const log = options.log ?? (() => {});
+  const appDir = options.appDir ?? join2(dirname(fileURLToPath(import.meta.url)), "app");
+  const host = { projectDir: resolve2(options.root), compile: options.compile };
+  const clients = new Set;
+  const broadcast = (event) => {
+    const payload = `data: ${JSON.stringify(event)}
+`;
+    for (const res of clients)
+      res.write(payload);
+  };
+  let pending = new Map;
+  let timer = null;
+  const flush = () => {
+    timer = null;
+    const events = [...pending];
+    pending = new Map;
+    for (const [path, type] of events)
+      broadcast({ type, path });
+    log(`change → ${events.map(([p]) => p).join(", ")}`);
+  };
+  const onFsEvent = (file) => {
+    if (!file) {
+      pending.set("./", "project");
+    } else {
+      const rel = "./" + file.replace(/\\/g, "/");
+      const type = /\.ts$/.test(rel) ? "scene" : "project";
+      pending.set(rel, type);
+    }
+    if (timer)
+      clearTimeout(timer);
+    timer = setTimeout(flush, 120);
+  };
+  let watcher = null;
+  try {
+    watcher = watch(host.projectDir, { recursive: true }, (_type, file) => onFsEvent(file));
+  } catch {
+    log("fs.watch(recursive) unavailable — hot reload disabled (refresh the browser manually).");
+  }
+  const mcpContext = {
+    serverName: "lecodes-scene",
+    version: MCP_VERSION,
+    overview: () => projectOverview(host.projectDir),
+    listScenes: () => projectOverview(host.projectDir).scenes,
+    compile: host.compile
+  };
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const path = decodeURIComponent(url.pathname);
+    try {
+      if (await handleSceneApi(host, req, res))
+        return;
+      if (path === "/mcp") {
+        if (req.method !== "POST") {
+          res.writeHead(405, { allow: "POST", "content-type": "text/plain" });
+          res.end("MCP endpoint accepts POST only.");
+          return;
+        }
+        const origin = req.headers.origin;
+        if (origin && !/^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin)) {
+          res.writeHead(403, { "content-type": "text/plain" });
+          res.end("Cross-origin requests are not allowed.");
+          return;
+        }
+        let message;
+        try {
+          message = await readBody2(req);
+        } catch {
+          res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+          res.end(JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } }));
+          return;
+        }
+        const response = await handleMcpMessage(message, mcpContext);
+        if (response === undefined) {
+          res.writeHead(202);
+          res.end();
+          return;
+        }
+        res.writeHead(200, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+        res.end(JSON.stringify(response));
+        return;
+      }
+      if (path === "/events") {
+        res.writeHead(200, {
+          "content-type": "text/event-stream",
+          "cache-control": "no-store",
+          connection: "keep-alive"
+        });
+        res.write(`retry: 1000
+`);
+        clients.add(res);
+        const ping = setInterval(() => res.write(`: ping
+`), 30000);
+        req.on("close", () => {
+          clients.delete(res);
+          clearInterval(ping);
+        });
+        return;
+      }
+      if (path !== "/" && sendFile(res, appDir, path))
+        return;
+      if (!sendFile(res, appDir, "index.html")) {
+        res.writeHead(503, { "content-type": "text/plain" });
+        res.end("The scene editor app is not built (missing dist/app). Reinstall scene-editor or run its build.");
+      }
+    } catch (e) {
+      res.writeHead(500, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: e instanceof Error ? e.message : String(e) }));
+    }
+  });
+  await new Promise((resolvePromise, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => resolvePromise());
+  });
+  return {
+    port,
+    url: `http://localhost:${port}`,
+    close: () => {
+      watcher?.close();
+      for (const res of clients)
+        res.end();
+      clients.clear();
+      server.close();
+    }
+  };
+};
+export {
+  startSceneServer,
+  resolveInside,
+  projectOverview,
+  listProjectFiles,
+  handleSceneApi,
+  TEXT_EXT
+};

package/package.json ADDED Viewed

@@ -0,0 +1,34 @@
+{
+  "name": "lecodes-3d-editor",
+  "version": "0.1.0",
+  "description": "LeCodes Scene Editor — the visual .scene.ts editor (Vue components + a standalone host). Embedded by the platform frontend as raw source; hosted on local files by the lecodes CLI (`lecodes scene`), like lecodes-design.",
+  "type": "module",
+  "license": "MIT",
+  "main": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./server": "./dist/server.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "bunx --bun vite",
+    "build": "vite build && bun build src/server/index.ts --target=node --outfile dist/server.js",
+    "typecheck": "bunx vue-tsc --noEmit",
+    "test": "bun test",
+    "prepublishOnly": "bun run build"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-vue": "^5.2.3",
+    "scene-doc": "workspace:*",
+    "sdk": "workspace:*",
+    "typescript": "~5.8.3",
+    "ui-kit": "workspace:*",
+    "viewer": "workspace:*",
+    "vite": "^8.0.16",
+    "vue": "^3.5.13",
+    "vue-tsc": "^2.2.8"
+  }
+}

package/src/index.ts ADDED Viewed

@@ -0,0 +1,19 @@
+// scene-editor: the visual .scene.ts editor as an embeddable Vue component. The host supplies a
+// SceneSource (file text + write + edit-mode compile + aspect list); everything else — document
+// round-trip (scene-doc), GL host lifecycle (viewer), harness wiring, tree/inspector UI — is
+// self-contained. `bun run dev` in this package runs the standalone auth-free playground.
+export { default as SceneEditor } from "./SceneEditor.vue"
+export { useSceneEditor, type SceneEditorCtl, type ScenePhase } from "./useSceneEditor"
+export { scanUserAspects, docRows, findDocNode, resolveScenePath, BUILTIN_ASPECTS, type SceneRow } from "./sceneDocUtils"
+export {
+  sceneGlobals,
+  type AspectClassInfo,
+  type CompiledScene,
+  type FieldDescriptor,
+  type FieldEditor,
+  type SceneHarness,
+  type SceneSource,
+  type UserAspect,
+  type Vec3Tuple,
+} from "./types"