@threenative/core 0.1.0 → 0.3.0

package/mcp/engine-server.mjs

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+import { realpathSync, readFileSync } from 'fs';
+import path from 'path';
+import { createInterface } from 'readline';
+import { fileURLToPath } from 'url';
+
+var ENGINE_MCP_TOOL_NAMES = [
+  "engine_search_capabilities",
+  "engine_capability_detail"
+];
+var DEFAULT_MANIFEST_FILE = "capabilities.json";
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "add",
+  "an",
+  "and",
+  "around",
+  "build",
+  "by",
+  "create",
+  "for",
+  "from",
+  "game",
+  "in",
+  "into",
+  "it",
+  "make",
+  "of",
+  "on",
+  "that",
+  "the",
+  "to",
+  "use",
+  "with"
+]);
+var MAX_COMPLETE_REQUEST_RESULTS = 15;
+var MAX_SITUATION_RESULTS = 5;
+var AUTHORING_INSTRUCTIONS = `Before authoring, infer concrete gameplay mechanics. Preserve the request's distinctive fantasy: choose the smallest loop that uses its characteristic setting, traversal medium, or simulation instead of a generic character game with themed props, and search those implied mechanics even when the user did not name engine terms. Search the mechanically explicit complete request with scope "request", then each mechanic with scope "mechanic". A genre label alone is not a capability query: clarify or decompose it; do not assume a preset. Inspect capability detail and obey constraints before implementing. Capability detail is authoritative on platform support: never invent a platform limitation it does not state.`;
+function defaultManifestPath(cwd = process.cwd()) {
+  return path.resolve(cwd, process.env.THREENATIVE_CAPABILITIES_MANIFEST ?? DEFAULT_MANIFEST_FILE);
+}
+function manifestError(file, reason) {
+  return new Error(`TN_ENGINE_CAPABILITIES_MANIFEST: ${file}: ${reason}`);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateManifest(value, file) {
+  if (!isRecord(value) || typeof value.version !== "number" || !Array.isArray(value.entries)) {
+    throw manifestError(file, "root must contain a numeric version and entries array");
+  }
+  for (const [index, raw] of value.entries.entries()) {
+    if (!isRecord(raw) || typeof raw.symbol !== "string" || typeof raw.package !== "string" || typeof raw.importPath !== "string" || typeof raw.kind !== "string" || typeof raw.signature !== "string" || typeof raw.summary !== "string" || typeof raw.example !== "string" || !Array.isArray(raw.situations) || !Array.isArray(raw.constraints) || !raw.situations.every((situation) => typeof situation === "string") || !raw.constraints.every((constraint) => typeof constraint === "string")) {
+      throw manifestError(file, `entry ${index} is malformed`);
+    }
+  }
+  return value;
+}
+function loadCapabilityManifest(file = defaultManifestPath()) {
+  let raw;
+  try {
+    raw = readFileSync(file, "utf8");
+  } catch (error) {
+    throw manifestError(file, `cannot read committed manifest: ${String(error)}`);
+  }
+  try {
+    return validateManifest(JSON.parse(raw), file);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("TN_ENGINE_CAPABILITIES_MANIFEST:"))
+      throw error;
+    throw manifestError(file, `cannot parse JSON: ${String(error)}`);
+  }
+}
+function tokens(value) {
+  return value.toLocaleLowerCase().split(/[^a-z0-9]+/u).filter((token) => token.length > 1 && !STOP_WORDS.has(token)).map((token) => {
+    if (token.length > 4 && token.endsWith("ies")) return `${token.slice(0, -3)}y`;
+    if (token.length > 3 && token.endsWith("s") && !token.endsWith("ss"))
+      return token.slice(0, -1);
+    return token;
+  });
+}
+function situationScore(query, situations) {
+  if (query.length === 0) return { matchedSituation: "", score: 0 };
+  const queryText = query.join(" ");
+  let best = 0;
+  let matchedSituation = "";
+  for (const situation of situations) {
+    const phrase = tokens(situation);
+    const overlap = new Set(phrase.filter((token) => query.includes(token))).size;
+    const score = overlap / Math.max(query.length, phrase.length);
+    const phraseBonus = phrase.join(" ").includes(queryText) || queryText.includes(phrase.join(" ")) ? 1 : 0;
+    if (overlap < (query.length >= 4 ? 2 : 1) && phraseBonus === 0) continue;
+    const candidate = score + phraseBonus;
+    if (candidate > best) {
+      best = candidate;
+      matchedSituation = situation;
+    }
+  }
+  return { matchedSituation, score: best };
+}
+function capabilitySearchKey(entry) {
+  return `${entry.importPath}
+${entry.signature}
+${entry.summary}
+${entry.situations.join("\n")}`;
+}
+function searchCapabilities(situation, manifestFile = defaultManifestPath(), scope = "mechanic") {
+  if (typeof situation !== "string" || situation.trim().length === 0)
+    throw new Error("engine_search_capabilities requires a non-empty situation string.");
+  const manifest = loadCapabilityManifest(manifestFile);
+  const query = tokens(situation);
+  const limit = scope === "request" ? MAX_COMPLETE_REQUEST_RESULTS : MAX_SITUATION_RESULTS;
+  return manifest.entries.map((entry) => ({ entry, ...situationScore(query, entry.situations) })).filter(({ score }) => score > 0).sort(
+    (left, right) => right.score - left.score || `${left.entry.importPath}:${left.entry.symbol}`.localeCompare(
+      `${right.entry.importPath}:${right.entry.symbol}`
+    )
+  ).filter(
+    (candidate, index, candidates) => candidates.findIndex(
+      (other) => capabilitySearchKey(other.entry) === capabilitySearchKey(candidate.entry)
+    ) === index
+  ).slice(0, limit).map(({ entry, matchedSituation }) => ({
+    constraints: entry.constraints,
+    example: entry.example,
+    importPath: entry.importPath,
+    matchedSituation,
+    summary: entry.summary,
+    symbol: entry.symbol
+  }));
+}
+function capabilityDetail(symbol, manifestFile = defaultManifestPath()) {
+  if (typeof symbol !== "string" || symbol.trim().length === 0)
+    throw new Error("engine_capability_detail requires a non-empty symbol string.");
+  const manifest = loadCapabilityManifest(manifestFile);
+  const entry = manifest.entries.find((candidate) => candidate.symbol === symbol);
+  if (entry === void 0) throw new Error(`Unknown engine capability '${symbol}'.`);
+  return entry;
+}
+var TOOL_DEFINITIONS = [
+  {
+    annotations: { destructiveHint: false, openWorldHint: false, readOnlyHint: true },
+    name: "engine_search_capabilities",
+    description: 'Search the installed engine by concrete gameplay mechanic. Decompose genres first. Use scope "request" for the mechanically explicit full request and "mechanic" for each focused search; matchedSituation explains every result.',
+    inputSchema: {
+      additionalProperties: false,
+      properties: {
+        scope: {
+          description: "Use request for the complete cross-system game request; use mechanic or omit it for one mechanic.",
+          enum: ["request", "mechanic"],
+          type: "string"
+        },
+        situation: { type: "string" }
+      },
+      required: ["situation"],
+      type: "object"
+    }
+  },
+  {
+    annotations: { destructiveHint: false, openWorldHint: false, readOnlyHint: true },
+    name: "engine_capability_detail",
+    description: "Inspect one engine capability's import, signature, example, constraints, and overrides.",
+    inputSchema: {
+      additionalProperties: false,
+      properties: { symbol: { type: "string" } },
+      required: ["symbol"],
+      type: "object"
+    }
+  }
+];
+function toolDefinitions() {
+  return TOOL_DEFINITIONS;
+}
+function jsonRpcError(id, code, message) {
+  return JSON.stringify({ id, jsonrpc: "2.0", error: { code, message } });
+}
+function jsonRpcResult(id, result) {
+  return JSON.stringify({ id, jsonrpc: "2.0", result });
+}
+function writeLine(value) {
+  process.stdout.write(`${value}
+`);
+}
+function toolText(value) {
+  return { content: [{ text: JSON.stringify(value, null, 2), type: "text" }] };
+}
+function handleToolCall(params, manifestFile) {
+  const name = params.name;
+  const argumentsValue = isRecord(params.arguments) ? params.arguments : {};
+  if (name === "engine_search_capabilities") {
+    if (typeof argumentsValue.situation !== "string")
+      throw new Error("engine_search_capabilities requires a string 'situation' argument.");
+    const scope = argumentsValue.scope ?? "mechanic";
+    if (scope !== "request" && scope !== "mechanic")
+      throw new Error("engine_search_capabilities scope must be 'request' or 'mechanic'.");
+    return toolText(searchCapabilities(argumentsValue.situation, manifestFile, scope));
+  }
+  if (name === "engine_capability_detail") {
+    if (typeof argumentsValue.symbol !== "string")
+      throw new Error("engine_capability_detail requires a string 'symbol' argument.");
+    return toolText(capabilityDetail(argumentsValue.symbol, manifestFile));
+  }
+  throw new Error(`Unknown engine MCP tool '${String(name)}'.`);
+}
+function handleLine(line, manifestFile) {
+  if (line.trim().length === 0) return void 0;
+  let request;
+  try {
+    request = JSON.parse(line);
+  } catch (error) {
+    return jsonRpcError(null, -32700, `Invalid JSON: ${String(error)}`);
+  }
+  if (!isRecord(request) || request.id === void 0 || typeof request.method !== "string")
+    return void 0;
+  try {
+    if (request.method === "initialize") {
+      return jsonRpcResult(request.id, {
+        capabilities: { tools: { listChanged: false } },
+        instructions: AUTHORING_INSTRUCTIONS,
+        protocolVersion: "2025-06-18",
+        serverInfo: { name: "threenative-engine-mcp", version: "0.2.0" }
+      });
+    }
+    if (request.method === "tools/list") {
+      return jsonRpcResult(request.id, { tools: TOOL_DEFINITIONS });
+    }
+    if (request.method === "tools/call") {
+      if (!isRecord(request.params)) throw new Error("tools/call requires an object params value.");
+      return jsonRpcResult(request.id, handleToolCall(request.params, manifestFile));
+    }
+    return jsonRpcError(request.id, -32601, `Method not found: ${request.method}`);
+  } catch (error) {
+    return jsonRpcError(request.id, -32e3, error instanceof Error ? error.message : String(error));
+  }
+}
+function runServer(manifestFile = defaultManifestPath()) {
+  loadCapabilityManifest(manifestFile);
+  const input = createInterface({ input: process.stdin });
+  input.on("line", (line) => {
+    const response = handleLine(line, manifestFile);
+    if (response !== void 0) writeLine(response);
+  });
+}
+var entryPath = process.argv[1];
+if (entryPath !== void 0 && realpathSync(path.resolve(entryPath)) === realpathSync(fileURLToPath(import.meta.url))) {
+  try {
+    runServer();
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exitCode = 1;
+  }
+}
+
+export { ENGINE_MCP_TOOL_NAMES, capabilityDetail, defaultManifestPath, handleLine, loadCapabilityManifest, runServer, searchCapabilities, toolDefinitions };

package/mcp/engine.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { launchMcpServer } from "./launch.mjs";
+import { MCP_PACKAGES } from "./servers.mjs";
+
+// The capability server reads a committed manifest from the project root. A scaffolded game has
+// one; a project that added ThreeNative to an existing tree does not, so fall back to the copy this
+// package ships rather than letting the server refuse to start.
+const bundled = path.resolve(fileURLToPath(import.meta.url), "..", "..", "capabilities.json");
+const env =
+  existsSync(path.join(process.cwd(), "capabilities.json")) || !existsSync(bundled)
+    ? {}
+    : Object.fromEntries([["THREENATIVE_CAPABILITIES_MANIFEST", bundled]]);
+
+const localServer = path.resolve(fileURLToPath(import.meta.url), "..", "engine-server.mjs");
+if (existsSync(localServer)) {
+  const { runServer } = await import("./engine-server.mjs");
+  runServer(env.THREENATIVE_CAPABILITIES_MANIFEST);
+} else {
+  await launchMcpServer({ ...MCP_PACKAGES.engine, env });
+}

package/mcp/install.mjs

@@ -0,0 +1,77 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { mergeMcpServers } from "./servers.mjs";
+
+/** The project being installed into, or undefined when this install has no project to write to —
+ * a nested dependency install, or core's own workspace build. */
+export function installTarget(environment = process.env, cwd = process.cwd()) {
+  const target = path.resolve(environment.INIT_CWD ?? cwd);
+  if (target.split(path.sep).includes("node_modules")) return undefined;
+  const manifestPath = path.join(target, "package.json");
+  if (!existsSync(manifestPath)) return undefined;
+  let name;
+  try {
+    name = JSON.parse(readFileSync(manifestPath, "utf8")).name;
+  } catch {
+    return undefined;
+  }
+  return name === "@threenative/core" ? undefined : target;
+}
+
+/** Adds the ThreeNative servers to `<target>/.mcp.json`, creating it when absent. Returns what it
+ * did so the installer can say so once and stay quiet otherwise. */
+export function ensureMcpConfig(target) {
+  const configPath = path.join(target, ".mcp.json");
+  let existing;
+  if (existsSync(configPath)) {
+    // A config we cannot parse is still the user's. Rewriting it would drop servers we never wrote.
+    try {
+      existing = JSON.parse(readFileSync(configPath, "utf8"));
+    } catch {
+      return "unreadable";
+    }
+  }
+  const { changed, config } = mergeMcpServers(existing);
+  if (!changed) return "unchanged";
+  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+  return existing === undefined ? "created" : "updated";
+}
+
+const CODEX_MCP_SERVERS = [
+  {
+    body: `[mcp_servers.threenative-assets]\ncommand = "node"\nargs = ["./node_modules/@threenative/core/mcp/assets.mjs"]\n\n[mcp_servers.threenative-assets.env]\nASSET_DOWNLOAD_DIR = "./public/assets"\nAUDIO_DOWNLOAD_DIR = "./public/audio"`,
+    name: "threenative-assets",
+  },
+  {
+    body: `[mcp_servers.threenative-sculpt]\ncommand = "node"\nargs = ["./node_modules/@threenative/core/mcp/sculpt.mjs"]`,
+    name: "threenative-sculpt",
+  },
+  {
+    body: `[mcp_servers.threenative-engine]\ncommand = "node"\nargs = ["./node_modules/@threenative/core/mcp/engine.mjs"]`,
+    name: "threenative-engine",
+  },
+];
+
+/** Adds any missing ThreeNative servers to Codex's project-scoped MCP config without replacing
+ * user-authored settings or server definitions. */
+export function ensureCodexMcpConfig(target) {
+  const directory = path.join(target, ".codex");
+  const configPath = path.join(directory, "config.toml");
+  const existing = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
+  const missing = CODEX_MCP_SERVERS.filter(
+    ({ name }) => !existing.includes(`[mcp_servers.${name}]`),
+  );
+  if (missing.length === 0) return "unchanged";
+  mkdirSync(directory, { recursive: true });
+  const separator =
+    existing.length === 0 || existing.endsWith("\n\n")
+      ? ""
+      : existing.endsWith("\n")
+        ? "\n"
+        : "\n\n";
+  writeFileSync(
+    configPath,
+    `${existing}${separator}${missing.map(({ body }) => body).join("\n\n")}\n`,
+  );
+  return existing.length === 0 ? "created" : "updated";
+}

package/mcp/launch.mjs

@@ -0,0 +1,72 @@
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+/** Where a package is installed, or undefined when it is not. Node's own resolver is the wrong tool
+ * here: `threenative-engine-mcp` publishes an `exports` map with only an `import` condition, which
+ * `createRequire().resolve` refuses, and the answer we want is the directory rather than a
+ * specifier's entry point. Walking `node_modules` upward from both the project and this package
+ * covers a direct dependency, a hoisted one, and pnpm's nested store alike. */
+function packageDirectory(name) {
+  const starts = [process.cwd(), path.dirname(fileURLToPath(import.meta.url))];
+  for (const start of starts) {
+    let directory = path.resolve(start);
+    while (true) {
+      const candidate = path.join(directory, "node_modules", name);
+      if (existsSync(path.join(candidate, "package.json"))) return candidate;
+      const parent = path.dirname(directory);
+      if (parent === directory) break;
+      directory = parent;
+    }
+  }
+  return undefined;
+}
+
+/** The module that starts the server. The published main entry is not always it —
+ * `threenative-sculpt-mcp` exports a library from `dist/index.js` and starts its server from the
+ * `bin` file — so `bin` wins wherever a package declares one. */
+function serverEntry(directory) {
+  const manifest = JSON.parse(readFileSync(path.join(directory, "package.json"), "utf8"));
+  const bin = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.[manifest.name];
+  const exported =
+    typeof manifest.exports === "string"
+      ? manifest.exports
+      : (manifest.exports?.["."]?.import ?? manifest.exports?.["."]);
+  const relative =
+    bin ??
+    (typeof exported === "string" ? exported : undefined) ??
+    manifest.main ??
+    manifest.module;
+  return relative === undefined ? undefined : path.resolve(directory, relative);
+}
+
+/** Runs an MCP server the project may or may not have installed. Nothing here may write to stdout:
+ * that stream is the JSON-RPC transport, and one stray line makes the server unusable. */
+export async function launchMcpServer({ name, version, env = {} }) {
+  for (const [key, value] of Object.entries(env)) process.env[key] ??= value;
+  const directory = packageDirectory(name);
+  const entry = directory === undefined ? undefined : serverEntry(directory);
+  if (entry !== undefined && existsSync(entry)) {
+    // A server entry that is also a `bin` starts itself only when it is the process's main module,
+    // which it decides by comparing `process.argv[1]` against its own path. Importing it without
+    // this line loads the module and starts nothing, and the host reports a server that connected
+    // and then went silent.
+    process.argv[1] = entry;
+    await import(pathToFileURL(entry).href);
+    return;
+  }
+  // Not installed. `npx` keeps the server available in a project that never listed it, which is the
+  // whole point of wiring these in from the library rather than from a scaffold.
+  const child = spawn("npx", ["--yes", `${name}@${version}`], {
+    env: process.env,
+    stdio: "inherit",
+  });
+  child.on("error", (error) => {
+    process.stderr.write(`TN_MCP_LAUNCH: ${name} is not installed and npx failed: ${error}\n`);
+    process.exit(1);
+  });
+  child.on("exit", (code, signal) => {
+    process.exit(signal === null ? (code ?? 0) : 1);
+  });
+}

package/mcp/sculpt.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { launchMcpServer } from "./launch.mjs";
+import { MCP_PACKAGES } from "./servers.mjs";
+
+await launchMcpServer(MCP_PACKAGES.sculpt);

package/mcp/servers.mjs

@@ -0,0 +1,59 @@
+// The MCP servers a ThreeNative project always has. `@threenative/core` is a direct dependency of
+// every generated game, so `./node_modules/@threenative/core/mcp/<file>` is a path that resolves
+// under npm, pnpm and yarn alike — unlike `./node_modules/threenative-asset-mcp/...`, which only
+// exists when the package manager hoists, and which a project that never listed the server as a
+// direct dependency does not have at all.
+export const MCP_SERVERS = Object.freeze({
+  "threenative-assets": Object.freeze({
+    command: "node",
+    args: Object.freeze(["./node_modules/@threenative/core/mcp/assets.mjs"]),
+    // Entries rather than an object literal: these are environment variable names, not identifiers,
+    // and written as property names they read as names the naming rule must judge.
+    env: Object.freeze(
+      Object.fromEntries([
+        ["ASSET_DOWNLOAD_DIR", "./public/assets"],
+        ["AUDIO_DOWNLOAD_DIR", "./public/audio"],
+      ]),
+    ),
+  }),
+  "threenative-sculpt": Object.freeze({
+    command: "node",
+    args: Object.freeze(["./node_modules/@threenative/core/mcp/sculpt.mjs"]),
+  }),
+  "threenative-engine": Object.freeze({
+    command: "node",
+    args: Object.freeze(["./node_modules/@threenative/core/mcp/engine.mjs"]),
+  }),
+});
+
+/** The external package each shim launches. Core installs asset and sculpt transitively and bundles
+ * engine discovery itself: a game author must never know these package names or install them
+ * separately. The pinned engine version remains an emergency fallback for a legacy development
+ * checkout whose bundle has not been built. */
+export const MCP_PACKAGES = Object.freeze({
+  assets: Object.freeze({ name: "threenative-asset-mcp", version: "0.6.0" }),
+  sculpt: Object.freeze({ name: "threenative-sculpt-mcp", version: "0.1.0" }),
+  engine: Object.freeze({ name: "threenative-engine-mcp", version: "0.2.0" }),
+});
+
+/** Adds the ThreeNative servers to an existing config without touching anything else in it, and
+ * reports whether the file needs rewriting. Fails closed on a config that is not an object: an
+ * unreadable `.mcp.json` is the user's, and overwriting it would lose servers we did not write. */
+export function mergeMcpServers(existing) {
+  const malformed =
+    existing !== undefined &&
+    (typeof existing !== "object" || existing === null || Array.isArray(existing));
+  if (malformed) {
+    throw new Error("MCP config root must be an object.");
+  }
+  const previous = existing ?? {};
+  const servers = { ...(previous.mcpServers ?? {}) };
+  let changed = false;
+  for (const [name, server] of Object.entries(MCP_SERVERS)) {
+    const wanted = JSON.parse(JSON.stringify(server));
+    if (JSON.stringify(servers[name]) === JSON.stringify(wanted)) continue;
+    servers[name] = wanted;
+    changed = true;
+  }
+  return { changed, config: { ...previous, mcpServers: servers } };
+}

package/package.json

@@ -1,10 +1,16 @@
 {
   "name": "@threenative/core",
-  "version": "0.1.0",
+  "version": "0.3.0",
+  "license": "MIT",
   "description": "The small vanilla Three.js game runtime foundation.",
   "type": "module",
   "files": [
-    "dist"
+    "dist",
+    "mcp",
+    "scripts",
+    "patches",
+    "capabilities.json",
+    "README.md"
   ],
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -22,6 +28,18 @@
       "types": "./dist/hot.d.ts",
       "import": "./dist/hot.js"
     },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js"
+    },
+    "./ui-layer": {
+      "types": "./dist/ui-layer.d.ts",
+      "import": "./dist/ui-layer.js"
+    },
+    "./world": {
+      "types": "./dist/world.d.ts",
+      "import": "./dist/world.js"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -30,18 +48,43 @@
   "sideEffects": false,
   "dependencies": {
     "three": "0.185.1",
-    "zustand": "5.x"
+    "three-mesh-bvh": "0.9.14",
+    "threenative-asset-mcp": "0.6.0",
+    "threenative-sculpt-mcp": "0.1.1",
+    "zustand": "5.0.14"
   },
   "devDependencies": {
+    "@types/react": "19.2.0",
+    "@types/react-reconciler": "0.32.1",
     "@types/three": "0.185.3",
     "publint": "0.3.22",
+    "react": "19.2.0",
+    "react-reconciler": "0.33.0",
     "tsup": "8.5.1",
     "typescript": "5.9.3",
-    "@threenative/playtest": "0.1.0"
+    "@threenative/playtest": "0.3.0",
+    "threenative-engine-mcp": "0.2.0"
+  },
+  "peerDependencies": {
+    "@threenative/playtest": ">=0.3.0 <0.4.0",
+    "react": ">=19.2.0 <20",
+    "react-reconciler": ">=0.33.0 <0.34"
+  },
+  "peerDependenciesMeta": {
+    "@threenative/playtest": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "react-reconciler": {
+      "optional": true
+    }
   },
   "scripts": {
-    "build": "tsup --config tsup.config.ts && publint",
+    "postinstall": "node ./scripts/postinstall.mjs",
+    "build": "node scripts/generate-version.mjs && tsup --config tsup.config.ts && node scripts/bundle-engine-mcp.mjs && publint",
     "typecheck": "tsc --noEmit",
-    "test": "pnpm run build"
+    "test": "publint --strict"
   }
 }