@defold-typescript/cli 0.5.4 → 0.6.0

package/dist/bin.js

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/dispatch.ts
-import { existsSync as existsSync5, readFileSync as readFileSync8 } from "node:fs";
-import * as path10 from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync12 } from "node:fs";
+import * as path15 from "node:path";
 
 // src/api-registry.ts
 import { existsSync, readFileSync } from "node:fs";
-import { createRequire } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 import * as path from "node:path";
 function findPackageRoot(start) {
   let dir = start;
@@ -23,7 +25,7 @@ function findPackageRoot(start) {
 }
 function resolveTypesPackageRoot() {
   try {
-    const require2 = createRequire(import.meta.url);
+    const require2 = createRequire2(import.meta.url);
     const entry = require2.resolve("@defold-typescript/types");
     return findPackageRoot(path.dirname(entry));
   } catch {
@@ -81,17 +83,266 @@ function selectApiSurface(resolvedVersion) {
   return { surfaceId: null, available: false };
 }
 
+// src/bob-command.ts
+import { existsSync as existsSync2, mkdirSync } from "node:fs";
+import { delimiter, dirname as dirname2, join as join3 } from "node:path";
+
+// src/bob.ts
+import { homedir } from "node:os";
+import * as path2 from "node:path";
+
+// src/debug-launcher.ts
+var PLATFORM_TARGETS = {
+  "darwin-arm64": {
+    enginePlatform: "arm64-macos",
+    buildFolder: "arm64-macos",
+    executable: "dmengine"
+  },
+  "darwin-x64": {
+    enginePlatform: "x86_64-macos",
+    buildFolder: "x86_64-macos",
+    executable: "dmengine"
+  },
+  "linux-x64": {
+    enginePlatform: "x86_64-linux",
+    buildFolder: "x86_64-linux",
+    executable: "dmengine"
+  },
+  "win32-x64": {
+    enginePlatform: "x86_64-win32",
+    buildFolder: "x86_64-win32",
+    executable: "dmengine.exe"
+  }
+};
+var ENGINE_INFO_URL = "https://d.defold.com/stable/info.json";
+var ENGINE_ARCHIVE_BASE = "https://d.defold.com/archive/stable";
+var DEBUG_LAUNCHER_REL = ".vscode/defold-debug.ts";
+function debugLaunchConfig() {
+  return {
+    name: "Defold: Debug (TypeScript)",
+    type: "lua-local",
+    request: "launch",
+    stopOnEntry: false,
+    verbose: false,
+    internalConsoleOptions: "openOnSessionStart",
+    program: { command: "bun" },
+    args: [DEBUG_LAUNCHER_REL],
+    scriptFiles: ["src/**/*.ts.script"],
+    scriptRoots: [".", "src"]
+  };
+}
+var VSCODE_LAUNCH_CONTENT = {
+  version: "0.2.0",
+  configurations: [debugLaunchConfig()]
+};
+function renderDebugLauncher() {
+  const targets = JSON.stringify(PLATFORM_TARGETS, null, 2);
+  return `import { chmodSync, copyFileSync, existsSync, mkdirSync } from "node:fs";
+import * as path from "node:path";
+
+// Windows only: paths to OpenAL32.dll and wrap_oal.dll from your Defold SDK
+// (defoldsdk/ext/lib/x86_64-win32/). Leave empty on macOS/Linux.
+const WINDOWS_OPENAL32_PATH = "";
+const WINDOWS_WRAPOAL_PATH = "";
+
+interface EngineTarget {
+  enginePlatform: string;
+  buildFolder: string;
+  executable: string;
+}
+
+const PLATFORM_TARGETS: Record<string, EngineTarget> = ${targets};
+
+const ENGINE_INFO_URL = "${ENGINE_INFO_URL}";
+const ENGINE_ARCHIVE_BASE = "${ENGINE_ARCHIVE_BASE}";
+
+const target = PLATFORM_TARGETS[\`\${process.platform}-\${process.arch}\`];
+if (!target) {
+  console.error(\`Unsupported platform: \${process.platform}-\${process.arch}\`);
+  process.exit(1);
+}
+
+const here = path.dirname(new URL(import.meta.url).pathname);
+const stockEnginePath = path.join(here, target.executable);
+
+if (!existsSync(stockEnginePath)) {
+  const info = (await (await fetch(ENGINE_INFO_URL)).json()) as { sha1: string };
+  const url = \`\${ENGINE_ARCHIVE_BASE}/\${info.sha1}/engine/\${target.enginePlatform}/\${target.executable}\`;
+  console.log(\`Fetching \${url}\`);
+  const res = await fetch(url);
+  if (!res.ok) {
+    console.error(\`Engine download failed: \${res.status} \${res.statusText}\`);
+    process.exit(1);
+  }
+  await Bun.write(stockEnginePath, res);
+}
+
+const buildFolder = path.join("build", target.buildFolder);
+const buildEnginePath = path.join(buildFolder, target.executable);
+let enginePath = existsSync(buildEnginePath) ? buildEnginePath : stockEnginePath;
+
+if (process.platform === "win32" && enginePath === buildEnginePath) {
+  for (const [src, name] of [
+    [WINDOWS_OPENAL32_PATH, "OpenAL32.dll"],
+    [WINDOWS_WRAPOAL_PATH, "wrap_oal.dll"],
+  ] as const) {
+    const dest = path.join(buildFolder, name);
+    if (src && !existsSync(dest)) {
+      copyFileSync(src, dest);
+    }
+  }
+}
+
+// macOS: a build engine launched in place attaches to the editor process; copy
+// it aside first so it runs standalone.
+if (process.platform === "darwin" && enginePath === buildEnginePath) {
+  const tempEngine = path.join(buildFolder, "temp", target.executable);
+  mkdirSync(path.dirname(tempEngine), { recursive: true });
+  copyFileSync(buildEnginePath, tempEngine);
+  enginePath = tempEngine;
+}
+
+if (process.platform !== "win32") {
+  chmodSync(enginePath, 0o755);
+}
+
+const projectc = path.join("build", "default", "game.projectc");
+console.log(\`Launching \${enginePath} \${projectc}\`);
+const proc = Bun.spawn([enginePath, projectc], {
+  stdio: ["inherit", "inherit", "inherit"],
+});
+process.exit(await proc.exited);
+`;
+}
+var DEBUG_LAUNCHER_SOURCE = renderDebugLauncher();
+
+// src/bob.ts
+function bobDownloadUrl(sha1) {
+  return `${ENGINE_ARCHIVE_BASE}/${sha1}/bob/bob.jar`;
+}
+function bobCacheDir(env = process.env, home = homedir) {
+  if (env.DEFOLD_TYPESCRIPT_CACHE) {
+    return path2.join(env.DEFOLD_TYPESCRIPT_CACHE, "bob");
+  }
+  return path2.join(env.XDG_CACHE_HOME ?? path2.join(home(), ".cache"), "defold-typescript", "bob");
+}
+function bobCachePath(opts) {
+  return path2.join(opts.cacheDir, opts.sha1, "bob.jar");
+}
+function resolveBobJar(opts) {
+  const jarPath = bobCachePath({ sha1: opts.sha1, cacheDir: opts.cacheDir });
+  return { jarPath, cached: opts.probe(jarPath) };
+}
+function resolveJava(opts) {
+  if (opts.override) {
+    return opts.override;
+  }
+  if (opts.probe("java")) {
+    return "java";
+  }
+  throw new Error('defold-typescript: no Java runtime found. Install a JDK and ensure "java" is on PATH, ' + "or pass --java <path> (or set DEFOLD_JAVA). bob.jar requires a JVM to run.");
+}
+
+// src/bob-command.ts
+var DEFOLD_SUBCOMMANDS = ["resolve", "build", "bundle"];
+function isDefoldSubcommand(value) {
+  return value !== undefined && DEFOLD_SUBCOMMANDS.includes(value);
+}
+function composeBobArgv(opts) {
+  const base = [opts.java, "-jar", opts.jar];
+  const server = opts.buildServer ? ["--build-server", opts.buildServer] : [];
+  switch (opts.subcommand) {
+    case "resolve":
+      return [...base, ...server, "resolve"];
+    case "build":
+      return [...base, "--variant", "debug", ...server, "build"];
+    case "bundle":
+      return [...base, ...server, "bundle"];
+    default:
+      throw new Error(`defold-typescript: unknown defold subcommand "${opts.subcommand}"; expected resolve|build|bundle.`);
+  }
+}
+async function runDefoldCommand(opts) {
+  const { io } = opts;
+  const sha = await io.fetchSha();
+  const { jarPath, cached } = resolveBobJar({
+    sha1: sha,
+    cacheDir: io.cacheDir,
+    probe: io.probe
+  });
+  if (!cached) {
+    await io.download(bobDownloadUrl(sha), jarPath);
+  }
+  const java = resolveJava({
+    ...opts.java !== undefined ? { override: opts.java } : {},
+    probe: io.javaProbe
+  });
+  const argv = composeBobArgv({
+    java,
+    jar: jarPath,
+    subcommand: opts.subcommand,
+    ...opts.buildServer !== undefined ? { buildServer: opts.buildServer } : {}
+  });
+  const exitCode = await io.spawn(argv, opts.cwd);
+  return { ok: exitCode === 0, subcommand: opts.subcommand, exitCode, argv };
+}
+async function fetchStableSha() {
+  const res = await fetch(ENGINE_INFO_URL);
+  if (!res.ok) {
+    throw new Error(`defold-typescript: could not resolve the stable Defold sha (${ENGINE_INFO_URL} -> ${res.status} ${res.statusText}).`);
+  }
+  const info = await res.json();
+  if (!info.sha1) {
+    throw new Error(`defold-typescript: ${ENGINE_INFO_URL} returned no sha1.`);
+  }
+  return info.sha1;
+}
+function javaOnPath(cmd, env = process.env) {
+  const pathVar = env.PATH ?? env.Path ?? "";
+  const exts = process.platform === "win32" ? [".exe", ".bat", ".cmd", ""] : [""];
+  for (const dir of pathVar.split(delimiter).filter(Boolean)) {
+    for (const ext of exts) {
+      if (existsSync2(join3(dir, cmd + ext))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+async function spawnInherit(argv, cwd) {
+  const proc = Bun.spawn(argv, { cwd, stdio: ["inherit", "inherit", "inherit"] });
+  return proc.exited;
+}
+async function downloadTo(url, dest) {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`defold-typescript: bob.jar download failed (${url} -> ${res.status} ${res.statusText}).`);
+  }
+  mkdirSync(dirname2(dest), { recursive: true });
+  await Bun.write(dest, res);
+}
+function defaultDefoldIo() {
+  return {
+    cacheDir: bobCacheDir(),
+    fetchSha: fetchStableSha,
+    probe: existsSync2,
+    javaProbe: (cmd) => javaOnPath(cmd),
+    spawn: spawnInherit,
+    download: downloadTo
+  };
+}
+
 // src/build.ts
 import { readFileSync as readFileSync3 } from "node:fs";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 import { transpileProject } from "@defold-typescript/transpiler";
 
 // src/build-output.ts
-import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
-import * as path2 from "node:path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import * as path3 from "node:path";
 var DEFAULT_INCLUDE = ["src/**/*.ts"];
 var PROJECT_BUCKET = "<project>";
-function toPosix(p, sep2 = path2.sep) {
+function toPosix(p, sep2 = path3.sep) {
   return p.split(sep2).join("/");
 }
 var TRANSPILER_SOURCE_RE = /\.(ts|tsx|cts|mts)$/;
@@ -99,7 +350,7 @@ function isTranspilerSource(rel) {
   return TRANSPILER_SOURCE_RE.test(toPosix(rel));
 }
 function readBuildConfig(cwd) {
-  const tsconfigPath = path2.join(cwd, "tsconfig.json");
+  const tsconfigPath = path3.join(cwd, "tsconfig.json");
   let raw;
   try {
     raw = readFileSync2(tsconfigPath, "utf8");
@@ -114,24 +365,61 @@ function readBuildConfig(cwd) {
 function stripIncludeBase(pattern) {
   const firstWildcard = pattern.search(/[*?[]/);
   if (firstWildcard === -1) {
-    return pattern.endsWith("/") ? pattern : `${path2.posix.dirname(pattern)}/`;
+    return pattern.endsWith("/") ? pattern : `${path3.posix.dirname(pattern)}/`;
   }
   const upToWildcard = pattern.slice(0, firstWildcard);
   const lastSlash = upToWildcard.lastIndexOf("/");
   return lastSlash === -1 ? "" : upToWildcard.slice(0, lastSlash + 1);
 }
-function computeScriptRel(rel, config) {
+var SCRIPT_SUFFIX_BY_KIND = {
+  script: ".ts.script",
+  "gui-script": ".ts.gui_script",
+  "render-script": ".ts.render_script"
+};
+var FACTORY_KINDS = [
+  ["render-script", /\bdefineRenderScript\s*\(/],
+  ["gui-script", /\bdefineGuiScript\s*\(/],
+  ["script", /\bdefineScript\s*\(/]
+];
+function detectSourceOutputKind(source) {
+  for (const [kind, re] of FACTORY_KINDS) {
+    if (re.test(source)) {
+      return kind;
+    }
+  }
+  return "module";
+}
+function relUnderOutDir(rel, config) {
   const { outDir, include } = config;
   if (outDir === undefined || outDir === "" || outDir === ".") {
-    return rel.replace(/\.ts$/, ".ts.script");
+    return rel;
   }
   const includeBase = include.map(stripIncludeBase).filter((base) => rel.startsWith(base)).sort((a, b) => b.length - a.length)[0] ?? "";
   const relUnderBase = rel.slice(includeBase.length);
-  return path2.posix.join(outDir, relUnderBase.replace(/\.ts$/, ".ts.script"));
+  return path3.posix.join(outDir, relUnderBase);
+}
+function computeOutputRel(rel, config, kind) {
+  const baseRel = relUnderOutDir(rel, config);
+  if (kind === "module") {
+    return baseRel.replace(/\.ts$/, ".lua");
+  }
+  return baseRel.replace(/\.ts$/, SCRIPT_SUFFIX_BY_KIND[kind]);
+}
+function outputRelsForSource(rel, config) {
+  const outputs = [
+    computeOutputRel(rel, config, "module"),
+    computeOutputRel(rel, config, "script"),
+    computeOutputRel(rel, config, "gui-script"),
+    computeOutputRel(rel, config, "render-script")
+  ];
+  return outputs.flatMap((output) => [output, `${output}.map`]);
 }
 function collectFailures(diagnostics) {
   const failures = new Map;
   for (const diag of diagnostics) {
+    if (diag.category === "warning") {
+      continue;
+    }
     const bucket = diag.file ?? PROJECT_BUCKET;
     const list = failures.get(bucket);
     if (list) {
@@ -152,10 +440,10 @@ function throwIfFailures(failures) {
 ${formatted}`);
 }
 function writeScriptFile(cwd, scriptRel, lua, map) {
-  const scriptAbs = path2.join(cwd, scriptRel);
-  mkdirSync(path2.dirname(scriptAbs), { recursive: true });
+  const scriptAbs = path3.join(cwd, scriptRel);
+  mkdirSync2(path3.dirname(scriptAbs), { recursive: true });
   if (map) {
-    const mapBasename = `${path2.posix.basename(scriptRel)}.map`;
+    const mapBasename = `${path3.posix.basename(scriptRel)}.map`;
     writeFileSync(`${scriptAbs}.map`, map);
     writeFileSync(scriptAbs, `${lua}
 --# sourceMappingURL=${mapBasename}
@@ -167,9 +455,12 @@ function writeScriptFile(cwd, scriptRel, lua, map) {
 
 // src/scan.ts
 import { globSync, statSync } from "node:fs";
-import * as path3 from "node:path";
+import * as path4 from "node:path";
+function normalizeScannedPath(rel) {
+  return rel.split(/[/\\]/).join("/");
+}
 function scanFilesSync(cwd, pattern) {
-  return globSync(pattern, { cwd }).filter((rel) => statSync(path3.join(cwd, rel)).isFile());
+  return globSync(pattern, { cwd }).map(normalizeScannedPath).filter((rel) => statSync(path4.join(cwd, rel)).isFile());
 }
 
 // src/build.ts
@@ -188,7 +479,7 @@ function runBuild(opts) {
   }
   const files = {};
   for (const rel of sources) {
-    files[rel] = readFileSync3(path4.join(cwd, rel), "utf8");
+    files[rel] = readFileSync3(path5.join(cwd, rel), "utf8");
   }
   const result = transpileProject({ files });
   const failures = collectFailures(result.diagnostics);
@@ -201,25 +492,25 @@ function runBuild(opts) {
     if (!lua) {
       continue;
     }
-    const scriptRel = computeScriptRel(rel, config);
-    writeScriptFile(cwd, scriptRel, lua, result.sourceMaps[rel]);
-    written.push(scriptRel);
+    const outputRel = computeOutputRel(rel, config, detectSourceOutputKind(files[rel] ?? ""));
+    writeScriptFile(cwd, outputRel, lua, result.sourceMaps[rel]);
+    written.push(outputRel);
   }
   throwIfFailures(failures);
-  return { written };
+  return { written: written.sort() };
 }
 
 // src/cli-version.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 import { fileURLToPath } from "node:url";
 var VERSION_FALLBACK = "0.0.0";
 function defaultPackageRoot() {
-  return path5.join(path5.dirname(fileURLToPath(import.meta.url)), "..");
+  return path6.join(path6.dirname(fileURLToPath(import.meta.url)), "..");
 }
 function readCliVersion(packageRoot = defaultPackageRoot()) {
   try {
-    const pkg = JSON.parse(readFileSync4(path5.join(packageRoot, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync4(path6.join(packageRoot, "package.json"), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : VERSION_FALLBACK;
   } catch {
     return VERSION_FALLBACK;
@@ -227,136 +518,31 @@ function readCliVersion(packageRoot = defaultPackageRoot()) {
 }
 
 // src/init.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
-import * as path6 from "node:path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
+import * as path7 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
-// src/debug-launcher.ts
-var PLATFORM_TARGETS = {
-  darwin: { enginePlatform: "x86_64-darwin", buildFolder: "x86_64-osx", executable: "dmengine" },
-  linux: { enginePlatform: "x86_64-linux", buildFolder: "x86_64-linux", executable: "dmengine" },
-  win32: {
-    enginePlatform: "x86_64-win32",
-    buildFolder: "x86_64-win32",
-    executable: "dmengine.exe"
-  }
-};
-var ENGINE_INFO_URL = "https://d.defold.com/stable/info.json";
-var ENGINE_ARCHIVE_BASE = "https://d.defold.com/archive/stable";
-var DEBUG_LAUNCHER_REL = ".vscode/defold-debug.ts";
-function debugLaunchConfig() {
-  return {
-    name: "Defold: Debug (TypeScript)",
-    type: "lua-local",
-    request: "launch",
-    stopOnEntry: false,
-    verbose: false,
-    internalConsoleOptions: "openOnSessionStart",
-    program: { command: "bun" },
-    args: [DEBUG_LAUNCHER_REL]
-  };
-}
-var VSCODE_LAUNCH_CONTENT = {
-  version: "0.2.0",
-  configurations: [debugLaunchConfig()]
-};
-function renderDebugLauncher() {
-  const targets = JSON.stringify(PLATFORM_TARGETS, null, 2);
-  return `import { chmodSync, copyFileSync, existsSync, mkdirSync } from "node:fs";
-import * as path from "node:path";
-
-// Windows only: paths to OpenAL32.dll and wrap_oal.dll from your Defold SDK
-// (defoldsdk/ext/lib/x86_64-win32/). Leave empty on macOS/Linux.
-const WINDOWS_OPENAL32_PATH = "";
-const WINDOWS_WRAPOAL_PATH = "";
-
-interface EngineTarget {
-  enginePlatform: string;
-  buildFolder: string;
-  executable: string;
-}
-
-const PLATFORM_TARGETS: Record<string, EngineTarget> = ${targets};
-
-const ENGINE_INFO_URL = "${ENGINE_INFO_URL}";
-const ENGINE_ARCHIVE_BASE = "${ENGINE_ARCHIVE_BASE}";
-
-const target = PLATFORM_TARGETS[process.platform];
-if (!target) {
-  console.error(\`Unsupported platform: \${process.platform}\`);
-  process.exit(1);
-}
-
-const here = path.dirname(new URL(import.meta.url).pathname);
-const stockEnginePath = path.join(here, target.executable);
-
-if (!existsSync(stockEnginePath)) {
-  const info = (await (await fetch(ENGINE_INFO_URL)).json()) as { sha1: string };
-  const url = \`\${ENGINE_ARCHIVE_BASE}/\${info.sha1}/engine/\${target.enginePlatform}/\${target.executable}\`;
-  console.log(\`Fetching \${url}\`);
-  const res = await fetch(url);
-  if (!res.ok) {
-    console.error(\`Engine download failed: \${res.status} \${res.statusText}\`);
-    process.exit(1);
-  }
-  await Bun.write(stockEnginePath, res);
-}
-
-const buildFolder = path.join("build", target.buildFolder);
-const buildEnginePath = path.join(buildFolder, target.executable);
-let enginePath = existsSync(buildEnginePath) ? buildEnginePath : stockEnginePath;
-
-if (process.platform === "win32" && enginePath === buildEnginePath) {
-  for (const [src, name] of [
-    [WINDOWS_OPENAL32_PATH, "OpenAL32.dll"],
-    [WINDOWS_WRAPOAL_PATH, "wrap_oal.dll"],
-  ] as const) {
-    const dest = path.join(buildFolder, name);
-    if (src && !existsSync(dest)) {
-      copyFileSync(src, dest);
-    }
-  }
-}
-
-// macOS: a build engine launched in place attaches to the editor process; copy
-// it aside first so it runs standalone.
-if (process.platform === "darwin" && enginePath === buildEnginePath) {
-  const tempEngine = path.join(buildFolder, "temp", target.executable);
-  mkdirSync(path.dirname(tempEngine), { recursive: true });
-  copyFileSync(buildEnginePath, tempEngine);
-  enginePath = tempEngine;
-}
-
-if (process.platform !== "win32") {
-  chmodSync(enginePath, 0o755);
-}
-
-const projectc = path.join("build", "default", "game.projectc");
-console.log(\`Launching \${enginePath} \${projectc}\`);
-const proc = Bun.spawn([enginePath, projectc], {
-  stdio: ["inherit", "inherit", "inherit"],
-});
-process.exit(await proc.exited);
-`;
-}
-var DEBUG_LAUNCHER_SOURCE = renderDebugLauncher();
-
 // src/mise-scaffold.ts
 var MANAGED_MARKER = "# managed by @defold-typescript";
 var MISE_TASKS_TOML = `${MANAGED_MARKER}
 [tasks."defold-typescript:build"]
-description = "Build the TypeScript sources with the installed defold-typescript CLI"
-run = "bunx --no-install defold-typescript build"
+description = "Build the TypeScript sources with the defold-typescript CLI"
+run = "bunx @defold-typescript/cli build"
 
 ${MANAGED_MARKER}
 [tasks."defold-typescript:watch"]
-description = "Watch and rebuild the TypeScript sources with the installed defold-typescript CLI"
-run = "bunx --no-install defold-typescript watch"
+description = "Watch and rebuild the TypeScript sources with the defold-typescript CLI"
+run = "bunx @defold-typescript/cli watch"
+
+${MANAGED_MARKER}
+[tasks."defold-typescript:setup-debug"]
+description = "Wire the lldebugger game.project dependency and entry-script bootstrap with the defold-typescript CLI"
+run = "bunx @defold-typescript/cli setup-debug"
 
 ${MANAGED_MARKER}
 [tasks."defold-typescript:upgrade"]
 description = "Upgrade the defold-typescript CLI to its latest release and re-pin the types dependency"
-run = ["bunx @defold-typescript/cli@latest init --force", "bun install"]
+run = ["bunx @defold-typescript/cli@latest init --force --suppress-install-reminder", "bun install"]
 `;
 function stripManagedBlocks(text) {
   const lines = text.split(`
@@ -415,18 +601,6 @@ function isComponentPath(relPath) {
   }
   return Object.keys(KIND_BY_EXT).some((ext) => relPath.endsWith(ext));
 }
-function detectScriptKinds(cwd) {
-  const kinds = new Set;
-  for (const [ext, kind] of Object.entries(KIND_BY_EXT)) {
-    for (const match of scanFilesSync(cwd, `**/*${ext}`)) {
-      if (!isSkipped(match) && !isGeneratedScript(match)) {
-        kinds.add(kind);
-        break;
-      }
-    }
-  }
-  return kinds;
-}
 function selectScriptKind(kinds) {
   if (kinds.size !== 1) {
     return null;
@@ -440,19 +614,6 @@ function selectScriptKindEntrypoint(kinds) {
   const kind = selectScriptKind(kinds);
   return kind === null ? DEFAULT_TYPES_ENTRYPOINT : `${DEFAULT_TYPES_ENTRYPOINT}/${kind}`;
 }
-var RESTRICTED_MODULES = {
-  script: "",
-  "gui-script": "gui",
-  "render-script": "render"
-};
-var ALL_RESTRICTED_MODULES = ["gui", "render"];
-function excludedModulesForKind(kind) {
-  if (kind === null) {
-    return new Set;
-  }
-  const allowed = RESTRICTED_MODULES[kind];
-  return new Set(ALL_RESTRICTED_MODULES.filter((mod) => mod !== allowed));
-}
 
 // src/init.ts
 var CONFLICTING_TS_CONFIGS = [
@@ -469,11 +630,29 @@ var TSCONFIG_COMPILER_OPTIONS = {
   strict: true,
   skipLibCheck: true
 };
-var GITIGNORE_LINES = ["src/**/*.ts.script", "src/**/*.ts.script.map"];
+var GITIGNORE_LINES = [
+  "src/**/*.ts.script",
+  "src/**/*.ts.script.map",
+  "src/**/*.ts.gui_script",
+  "src/**/*.ts.gui_script.map",
+  "src/**/*.ts.render_script",
+  "src/**/*.ts.render_script.map",
+  "src/**/*.lua",
+  "src/**/*.lua.map"
+];
 var BIOME_JSON_CONTENT = {
   $schema: "https://biomejs.dev/schemas/2.4.15/schema.json",
   files: {
-    includes: ["src/**/*.ts", "!**/dist", "!**/node_modules", "!**/*.ts.script"]
+    includes: [
+      "src/**/*.ts",
+      "!**/dist",
+      "!**/node_modules",
+      "!**/*.ts.script",
+      "!**/*.ts.gui_script",
+      "!**/*.ts.render_script",
+      "!src/**/*.lua",
+      "!src/**/*.lua.map"
+    ]
   },
   formatter: {
     enabled: true,
@@ -505,9 +684,15 @@ var BIOME_JSON_CONTENT = {
   }
 };
 var VSCODE_EXTENSIONS_CONTENT = {
-  recommendations: ["sumneko.lua", "astronachos.defold", "tomblind.local-lua-debugger-vscode"],
+  recommendations: ["tomblind.local-lua-debugger-vscode"],
   unwantedRecommendations: ["johnnymorganz.luau-lsp"]
 };
+var MANAGED_RECOMMENDATIONS = [
+  "tomblind.local-lua-debugger-vscode",
+  "sumneko.lua",
+  "astronachos.defold"
+];
+var MANAGED_UNWANTED = ["johnnymorganz.luau-lsp"];
 var VSCODE_SETTINGS_CONTENT = {
   "Lua.workspace.ignoreDir": ["src"]
 };
@@ -552,7 +737,7 @@ function inlineSnippetBody(factory, includeOnInput) {
   return [
     `import { ${factory} } from "@defold-typescript/types";`,
     "",
-    `export const script = ${factory}({`,
+    `export default ${factory}({`,
     `  // ${HOOK_COMMENTS.init}`,
     "  init() {",
     "    return { $0 };",
@@ -570,7 +755,7 @@ function typedSnippetBody(factory, includeOnInput) {
     "  $1",
     "};",
     "",
-    `export const script = ${factory}<Self>({`,
+    `export default ${factory}<Self>({`,
     `  // ${HOOK_COMMENTS.init}`,
     "  init(): Self {",
     "    return { $0 };",
@@ -617,21 +802,20 @@ var VSCODE_SNIPPETS_CONTENT = {
     description: "Empty Defold render script with an explicit Self type."
   }
 };
-var MAIN_TS_CONTENT = `export function init(): void {
-  const start = vmath.vector3(0, 0, 0);
-  msg.post("main:/hero", "spawn", { start });
-}
-`;
-var MAIN_SCRIPT_CONTENT = `function init(self) end
-function update(self, dt) end
-function on_message(self, message_id, message, sender) end
-function final(self) end
+var MAIN_TS_CONTENT = `import { defineScript } from "@defold-typescript/types";
+
+export default defineScript({
+  init() {
+    const start = vmath.vector3(0, 0, 0);
+    return { start };
+  },
+});
 `;
 var MAIN_COLLECTION_CONTENT = `name: "main"
 scale_along_z: 0
 embedded_instances {
   id: "main"
-  data: "components {\\n  id: \\"main\\"\\n  component: \\"/main/main.script\\"\\n}\\n"
+  data: "components {\\n  id: \\"main\\"\\n  component: \\"/src/main.ts.script\\"\\n}\\n"
   position { x: 0.0 y: 0.0 z: 0.0 }
   rotation { x: 0.0 y: 0.0 z: 0.0 w: 1.0 }
   scale3 { x: 1.0 y: 1.0 z: 1.0 }
@@ -639,8 +823,8 @@ embedded_instances {
 `;
 function typesVersionSpec() {
   try {
-    const here = path6.dirname(fileURLToPath2(import.meta.url));
-    const pkg = JSON.parse(readFileSync5(path6.join(here, "..", "package.json"), "utf8"));
+    const here = path7.dirname(fileURLToPath2(import.meta.url));
+    const pkg = JSON.parse(readFileSync5(path7.join(here, "..", "package.json"), "utf8"));
     return pkg.version ? `^${pkg.version}` : "latest";
   } catch {
     return "latest";
@@ -664,8 +848,8 @@ function writeJson(filePath, value) {
 `);
 }
 function writeGitignore(cwd) {
-  const gitignorePath = path6.join(cwd, ".gitignore");
-  if (existsSync2(gitignorePath)) {
+  const gitignorePath = path7.join(cwd, ".gitignore");
+  if (existsSync3(gitignorePath)) {
     const existing = readFileSync5(gitignorePath, "utf8");
     const present = new Set(existing.split(`
 `).map((line) => line.trim()));
@@ -686,16 +870,16 @@ function writeGitignore(cwd) {
   }
 }
 function writeBiome(cwd, written) {
-  const biomePath = path6.join(cwd, "biome.json");
-  if (existsSync2(biomePath)) {
+  const biomePath = path7.join(cwd, "biome.json");
+  if (existsSync3(biomePath)) {
     return;
   }
   writeJson(biomePath, BIOME_JSON_CONTENT);
   written.push("biome.json");
 }
 function writeMiseTasks(cwd, written) {
-  const misePath = path6.join(cwd, "mise.toml");
-  const existing = existsSync2(misePath) ? readFileSync5(misePath, "utf8") : undefined;
+  const misePath = path7.join(cwd, "mise.toml");
+  const existing = existsSync3(misePath) ? readFileSync5(misePath, "utf8") : undefined;
   writeFileSync2(misePath, mergeMiseToml(existing));
   written.push("mise.toml");
 }
@@ -759,6 +943,27 @@ function unionStrings(existing, additions) {
   }
   return out;
 }
+function reconcileManagedList(existing, managed, canonical) {
+  const managedSet = new Set(managed);
+  const canonicalSet = new Set(canonical);
+  const out = [];
+  const values = Array.isArray(existing) ? existing.filter((value) => typeof value === "string") : [];
+  for (const value of values) {
+    if (out.includes(value)) {
+      continue;
+    }
+    if (managedSet.has(value) && !canonicalSet.has(value)) {
+      continue;
+    }
+    out.push(value);
+  }
+  for (const value of canonical) {
+    if (!out.includes(value)) {
+      out.push(value);
+    }
+  }
+  return out;
+}
 function readVscodeJson(filePath) {
   try {
     const parsed = parseJsonc(readFileSync5(filePath, "utf8"));
@@ -768,26 +973,29 @@ function readVscodeJson(filePath) {
   }
 }
 function writeVscodeExtensions(cwd, written) {
-  const dir = path6.join(cwd, ".vscode");
-  const filePath = path6.join(dir, "extensions.json");
-  if (existsSync2(filePath)) {
+  const dir = path7.join(cwd, ".vscode");
+  const filePath = path7.join(dir, "extensions.json");
+  if (existsSync3(filePath)) {
     const existing = readVscodeJson(filePath);
     if (existing === null) {
       return;
     }
-    existing.recommendations = unionStrings(existing.recommendations, VSCODE_EXTENSIONS_CONTENT.recommendations);
-    existing.unwantedRecommendations = unionStrings(existing.unwantedRecommendations, VSCODE_EXTENSIONS_CONTENT.unwantedRecommendations);
-    writeJson(filePath, existing);
+    const before = JSON.stringify(existing);
+    existing.recommendations = reconcileManagedList(existing.recommendations, MANAGED_RECOMMENDATIONS, VSCODE_EXTENSIONS_CONTENT.recommendations);
+    existing.unwantedRecommendations = reconcileManagedList(existing.unwantedRecommendations, MANAGED_UNWANTED, VSCODE_EXTENSIONS_CONTENT.unwantedRecommendations);
+    if (JSON.stringify(existing) !== before) {
+      writeJson(filePath, existing);
+    }
     return;
   }
-  mkdirSync2(dir, { recursive: true });
+  mkdirSync3(dir, { recursive: true });
   writeJson(filePath, VSCODE_EXTENSIONS_CONTENT);
   written.push(".vscode/extensions.json");
 }
 function writeVscodeSettings(cwd, written) {
-  const dir = path6.join(cwd, ".vscode");
-  const filePath = path6.join(dir, "settings.json");
-  if (existsSync2(filePath)) {
+  const dir = path7.join(cwd, ".vscode");
+  const filePath = path7.join(dir, "settings.json");
+  if (existsSync3(filePath)) {
     const existing = readVscodeJson(filePath);
     if (existing === null) {
       return;
@@ -796,14 +1004,14 @@ function writeVscodeSettings(cwd, written) {
     writeJson(filePath, existing);
     return;
   }
-  mkdirSync2(dir, { recursive: true });
+  mkdirSync3(dir, { recursive: true });
   writeJson(filePath, VSCODE_SETTINGS_CONTENT);
   written.push(".vscode/settings.json");
 }
 function writeVscodeSnippets(cwd, written) {
-  const dir = path6.join(cwd, ".vscode");
-  const filePath = path6.join(dir, "defold-typescript.code-snippets");
-  if (existsSync2(filePath)) {
+  const dir = path7.join(cwd, ".vscode");
+  const filePath = path7.join(dir, "defold-typescript.code-snippets");
+  if (existsSync3(filePath)) {
     const existing = readVscodeJson(filePath);
     if (existing === null) {
       return;
@@ -816,15 +1024,15 @@ function writeVscodeSnippets(cwd, written) {
     writeJson(filePath, existing);
     return;
   }
-  mkdirSync2(dir, { recursive: true });
+  mkdirSync3(dir, { recursive: true });
   writeJson(filePath, VSCODE_SNIPPETS_CONTENT);
   written.push(".vscode/defold-typescript.code-snippets");
 }
 function writeVscodeLaunch(cwd, written) {
-  const dir = path6.join(cwd, ".vscode");
-  const filePath = path6.join(dir, "launch.json");
+  const dir = path7.join(cwd, ".vscode");
+  const filePath = path7.join(dir, "launch.json");
   const ours = debugLaunchConfig();
-  if (existsSync2(filePath)) {
+  if (existsSync3(filePath)) {
     const existing = readVscodeJson(filePath);
     if (existing === null) {
       return;
@@ -839,36 +1047,35 @@ function writeVscodeLaunch(cwd, written) {
     writeJson(filePath, existing);
     return;
   }
-  mkdirSync2(dir, { recursive: true });
+  mkdirSync3(dir, { recursive: true });
   writeJson(filePath, VSCODE_LAUNCH_CONTENT);
   written.push(".vscode/launch.json");
 }
 function writeVscodeDebugLauncher(cwd, written) {
-  const dir = path6.join(cwd, ".vscode");
-  const filePath = path6.join(dir, "defold-debug.ts");
-  if (existsSync2(filePath)) {
+  const dir = path7.join(cwd, ".vscode");
+  const filePath = path7.join(dir, "defold-debug.ts");
+  if (existsSync3(filePath)) {
     return;
   }
-  mkdirSync2(dir, { recursive: true });
+  mkdirSync3(dir, { recursive: true });
   writeFileSync2(filePath, DEBUG_LAUNCHER_SOURCE);
   written.push(".vscode/defold-debug.ts");
 }
 function writeTsSurface(cwd, written, force = false) {
-  mkdirSync2(path6.join(cwd, "src"), { recursive: true });
-  writeFileSync2(path6.join(cwd, "src", "main.ts"), MAIN_TS_CONTENT);
+  mkdirSync3(path7.join(cwd, "src"), { recursive: true });
+  writeFileSync2(path7.join(cwd, "src", "main.ts"), MAIN_TS_CONTENT);
   written.push("src/main.ts");
-  const kinds = detectScriptKinds(cwd);
   const tsconfig = {
     compilerOptions: {
       ...TSCONFIG_COMPILER_OPTIONS,
-      types: [selectScriptKindEntrypoint(kinds)]
+      types: [DEFAULT_TYPES_ENTRYPOINT]
     },
     include: ["src/**/*.ts"]
   };
-  writeJson(path6.join(cwd, "tsconfig.json"), tsconfig);
+  writeJson(path7.join(cwd, "tsconfig.json"), tsconfig);
   written.push("tsconfig.json");
-  const pkgPath = path6.join(cwd, "package.json");
-  if (existsSync2(pkgPath)) {
+  const pkgPath = path7.join(cwd, "package.json");
+  if (existsSync3(pkgPath)) {
     const existing = JSON.parse(readFileSync5(pkgPath, "utf8"));
     const devDeps = { ...existing.devDependencies ?? {} };
     for (const [name, version] of Object.entries(SCAFFOLD_DEV_DEPS)) {
@@ -882,7 +1089,7 @@ function writeTsSurface(cwd, written, force = false) {
     writeJson(pkgPath, existing);
   } else {
     const fresh = {
-      name: path6.basename(cwd),
+      name: path7.basename(cwd),
       version: "0.0.0",
       type: "module",
       devDependencies: { ...SCAFFOLD_DEV_DEPS },
@@ -900,43 +1107,56 @@ function writeTsSurface(cwd, written, force = false) {
   writeVscodeSnippets(cwd, written);
   writeVscodeLaunch(cwd, written);
   writeVscodeDebugLauncher(cwd, written);
-  return selectScriptKind(kinds);
 }
 function runNewProjectInit(cwd, force = false) {
-  if (!existsSync2(cwd)) {
-    mkdirSync2(cwd, { recursive: true });
+  if (!existsSync3(cwd)) {
+    mkdirSync3(cwd, { recursive: true });
   } else if (readdirSync(cwd).length > 0 && !force) {
     throw new Error(`defold-typescript init: refusing to synthesize a new Defold project into non-empty directory ${cwd}. Pass --force to proceed.`);
   }
   const written = [];
-  writeFileSync2(path6.join(cwd, "game.project"), `[project]
-title = ${path6.basename(cwd)}
+  writeFileSync2(path7.join(cwd, "game.project"), `[project]
+title = ${path7.basename(cwd)}
 main_collection = /main/main.collectionc
 `);
   written.push("game.project");
-  mkdirSync2(path6.join(cwd, "main"), { recursive: true });
-  writeFileSync2(path6.join(cwd, "main", "main.collection"), MAIN_COLLECTION_CONTENT);
+  mkdirSync3(path7.join(cwd, "main"), { recursive: true });
+  writeFileSync2(path7.join(cwd, "main", "main.collection"), MAIN_COLLECTION_CONTENT);
   written.push("main/main.collection");
-  writeFileSync2(path6.join(cwd, "main", "main.script"), MAIN_SCRIPT_CONTENT);
-  written.push("main/main.script");
-  const scriptKind = writeTsSurface(cwd, written, force);
-  return { written, scriptKind };
+  writeTsSurface(cwd, written, force);
+  return { written };
 }
 function runInit(opts) {
   const { cwd, force = false } = opts;
-  if (!existsSync2(path6.join(cwd, "game.project"))) {
+  if (!existsSync3(path7.join(cwd, "game.project"))) {
     return runNewProjectInit(cwd, force);
   }
   if (!force) {
     for (const rel of CONFLICTING_TS_CONFIGS) {
-      if (existsSync2(path6.join(cwd, rel))) {
+      if (existsSync3(path7.join(cwd, rel))) {
         throw new Error(`defold-typescript init: refusing to overwrite existing TS config: ${rel}. Pass --force to overwrite.`);
       }
     }
   }
   const written = [];
-  const scriptKind = writeTsSurface(cwd, written, force);
-  return { written, scriptKind };
+  writeTsSurface(cwd, written, force);
+  return { written };
+}
+
+// src/install-reminder.ts
+function installHint(env = process.env) {
+  const agent = env.npm_config_user_agent ?? "";
+  const manager = agent.split("/")[0];
+  if (manager === "pnpm") {
+    return "pnpm install";
+  }
+  if (manager === "yarn") {
+    return "yarn install";
+  }
+  if (manager === "npm") {
+    return "npm install";
+  }
+  return "bun install";
 }
 
 // src/json-output.ts
@@ -945,176 +1165,765 @@ function renderResult(input) {
   const base = ok ? { command: input.command, ok, written: input.written ?? [] } : { command: input.command, ok, error: input.error };
   const withVersion = input.defoldVersion === undefined ? base : { ...base, defoldVersion: input.defoldVersion };
   const withSurface = "apiSurface" in input ? { ...withVersion, apiSurface: input.apiSurface } : withVersion;
-  const withScriptKind = "scriptKind" in input ? { ...withSurface, scriptKind: input.scriptKind } : withSurface;
-  const payload = "materializedSurface" in input ? { ...withScriptKind, materializedSurface: input.materializedSurface } : withScriptKind;
+  const withMaterialized = "materializedSurface" in input ? { ...withSurface, materializedSurface: input.materializedSurface } : withSurface;
+  const withWalls = "directoryWalls" in input ? { ...withMaterialized, directoryWalls: input.directoryWalls } : withMaterialized;
+  const withEligible = "eligible" in input ? { ...withWalls, eligible: input.eligible } : withWalls;
+  const withInstall = "installCommand" in input ? { ...withEligible, installCommand: input.installCommand } : withEligible;
+  const withManual = "manualSteps" in input ? { ...withInstall, manualSteps: input.manualSteps } : withInstall;
+  const withActions = "actions" in input ? { ...withManual, actions: input.actions } : withManual;
+  const withAdded = "addedTo" in input ? { ...withActions, addedTo: input.addedTo } : withActions;
+  const withRemoved = "removedFrom" in input ? { ...withAdded, removedFrom: input.removedFrom } : withAdded;
+  const withBoot = "bootPath" in input ? { ...withRemoved, bootPath: input.bootPath } : withRemoved;
+  const withSub = "subcommand" in input ? { ...withBoot, subcommand: input.subcommand } : withBoot;
+  const payload = "exitCode" in input ? { ...withSub, exitCode: input.exitCode } : withSub;
   return `${JSON.stringify(payload)}
 `;
 }
+function renderWatchEvent(input) {
+  const ok = input.error === undefined;
+  const base = ok ? { command: "watch", event: input.event, ok, written: input.written ?? [] } : { command: "watch", event: input.event, ok, error: input.error };
+  const withChanged = "changed" in input ? { ...base, changed: input.changed } : base;
+  const withRemoved = "removed" in input ? { ...withChanged, removed: input.removed } : withChanged;
+  return `${JSON.stringify(withRemoved)}
+`;
+}
 
 // src/materialize.ts
 import {
   copyFileSync,
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync3,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync4,
   readdirSync as readdirSync2,
   readFileSync as readFileSync6,
   rmSync,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 var MATERIALIZED_ROOT = ".defold-types";
+var CORE_TYPES_REEXPORT = `export * from "@defold-typescript/types/core-types";
+`;
 function writeJson2(filePath, value) {
   writeFileSync3(filePath, `${JSON.stringify(value, null, 2)}
 `);
 }
-function listDts(dir) {
-  return readdirSync2(dir).filter((file) => file.endsWith(".d.ts")).sort();
+function listDts(dir) {
+  return readdirSync2(dir).filter((file) => file.endsWith(".d.ts")).sort();
+}
+function materializeApiSurface(opts) {
+  const { cwd, surface, sourceGeneratedDir } = opts;
+  if (!surface.available || surface.surfaceId === null || sourceGeneratedDir === null) {
+    return { materializedDir: null, active: null };
+  }
+  const { surfaceId } = surface;
+  const relDir = path8.posix.join(MATERIALIZED_ROOT, surfaceId);
+  const absDir = path8.join(cwd, MATERIALIZED_ROOT, surfaceId);
+  mkdirSync4(absDir, { recursive: true });
+  const sources = listDts(sourceGeneratedDir).filter((file) => file !== "index.d.ts");
+  const srcDir = path8.resolve(sourceGeneratedDir, "..", "src");
+  const overloads = ["msg-overloads.d.ts", "message-guard.d.ts", "go-overloads.d.ts"].filter((file) => existsSync4(path8.join(srcDir, file)));
+  const coreTypesSrc = path8.join(srcDir, "core-types.ts");
+  const includeCoreTypes = overloads.length > 0 && existsSync4(coreTypesSrc);
+  const engineGlobalsSrc = path8.join(srcDir, "engine-globals.d.ts");
+  const includeEngineGlobals = includeCoreTypes && existsSync4(engineGlobalsSrc);
+  const wanted = new Set(sources);
+  for (const file of overloads) {
+    wanted.add(file);
+  }
+  if (includeCoreTypes) {
+    wanted.add("core-types.d.ts");
+  }
+  if (includeEngineGlobals) {
+    wanted.add("engine-globals.d.ts");
+  }
+  for (const existing of readdirSync2(absDir)) {
+    if (existing.endsWith(".d.ts") && existing !== "index.d.ts" && !wanted.has(existing)) {
+      rmSync(path8.join(absDir, existing));
+    }
+  }
+  for (const file of sources) {
+    writeFileSync3(path8.join(absDir, file), readFileSync6(path8.join(sourceGeneratedDir, file), "utf8"));
+  }
+  if (includeCoreTypes) {
+    writeFileSync3(path8.join(absDir, "core-types.d.ts"), CORE_TYPES_REEXPORT);
+  }
+  if (includeEngineGlobals) {
+    writeFileSync3(path8.join(absDir, "engine-globals.d.ts"), readFileSync6(engineGlobalsSrc, "utf8"));
+  }
+  for (const file of overloads) {
+    writeFileSync3(path8.join(absDir, file), readFileSync6(path8.join(srcDir, file), "utf8"));
+  }
+  const modules = [...sources, ...overloads].map((file) => file.replace(/\.d\.ts$/, ""));
+  if (includeEngineGlobals) {
+    modules.push("engine-globals");
+  }
+  const imports = modules.map((mod) => `import "./${mod}";`).join(`
+`);
+  writeFileSync3(path8.join(absDir, "index.d.ts"), `${imports}
+
+export {};
+`);
+  writeJson2(path8.join(absDir, "package.json"), {
+    name: `@defold-typescript/materialized-${surfaceId}`,
+    types: "index.d.ts"
+  });
+  return { materializedDir: relDir, active: surfaceId };
+}
+function ensureGitignoreLine(cwd, line) {
+  const gitignorePath = path8.join(cwd, ".gitignore");
+  if (!existsSync4(gitignorePath)) {
+    writeFileSync3(gitignorePath, `${line}
+`);
+    return;
+  }
+  const existing = readFileSync6(gitignorePath, "utf8");
+  const present = new Set(existing.split(`
+`).map((entry) => entry.trim()));
+  if (present.has(line)) {
+    return;
+  }
+  const prefix = existing.endsWith(`
+`) || existing === "" ? "" : `
+`;
+  writeFileSync3(gitignorePath, `${existing}${prefix}${line}
+`);
+}
+function ensureMaterializedReference(cwd, materializedDir) {
+  if (materializedDir === null) {
+    return;
+  }
+  const surfaceId = path8.posix.basename(materializedDir);
+  const tsconfigPath = path8.join(cwd, "tsconfig.json");
+  if (existsSync4(tsconfigPath)) {
+    const tsconfig = JSON.parse(readFileSync6(tsconfigPath, "utf8"));
+    const current = tsconfig.compilerOptions ?? {};
+    const alreadyRepointed = JSON.stringify(current.typeRoots) === JSON.stringify([MATERIALIZED_ROOT]) && JSON.stringify(current.types) === JSON.stringify([surfaceId]);
+    if (!alreadyRepointed) {
+      tsconfig.compilerOptions = {
+        ...current,
+        typeRoots: [MATERIALIZED_ROOT],
+        types: [surfaceId]
+      };
+      writeJson2(tsconfigPath, tsconfig);
+    }
+  }
+  ensureGitignoreLine(cwd, `${MATERIALIZED_ROOT}/`);
+}
+function resolveCurrentSurfaceGeneratedDir() {
+  const root = resolveTypesPackageRoot();
+  return root === null ? null : path8.join(root, "generated");
+}
+async function materializeRefDocSurface(opts) {
+  const { cwd, surfaceId, resolveOpts } = opts;
+  const root = resolveTypesPackageRoot();
+  if (root === null) {
+    return { materializedDir: null, active: null };
+  }
+  const registry = opts.registry ?? loadApiTargetsRegistry();
+  const target = registry.find((t) => t.id === surfaceId);
+  if (target?.source?.kind !== "ref-doc") {
+    return { materializedDir: null, active: null };
+  }
+  const relDir = path8.posix.join(MATERIALIZED_ROOT, surfaceId);
+  const absDir = path8.join(cwd, MATERIALIZED_ROOT, surfaceId);
+  try {
+    const mod = await import(path8.join(root, "scripts", "materialize-version.ts"));
+    const selfContained = { ...target, coreTypesImport: "./core-types" };
+    await mod.materializeVersionedSurface(selfContained, {
+      destDir: absDir,
+      ...resolveOpts ? { resolveOpts } : {}
+    });
+    writeFileSync3(path8.join(absDir, "core-types.d.ts"), CORE_TYPES_REEXPORT);
+    copyFileSync(path8.join(root, "src", "engine-globals.d.ts"), path8.join(absDir, "engine-globals.d.ts"));
+    const indexPath = path8.join(absDir, "index.d.ts");
+    writeFileSync3(indexPath, `import "./engine-globals";
+${readFileSync6(indexPath, "utf8")}`);
+  } catch {
+    rmSync(absDir, { recursive: true, force: true });
+    return { materializedDir: null, active: null };
+  }
+  return { materializedDir: relDir, active: surfaceId };
+}
+
+// src/setup-debug.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "node:fs";
+import * as path10 from "node:path";
+
+// src/boot-path.ts
+import { existsSync as existsSync5, readFileSync as readFileSync7 } from "node:fs";
+import * as path9 from "node:path";
+var MAIN_COLLECTION_RE = /^main_collection\s*=\s*(.+)$/m;
+var COMPONENT_RE = /component:\s*\\?"([^"\\]+)\\?"/;
+var COLLECTION_RE = /collection:\s*\\?"([^"\\]+\.collectionc?)\\?"/;
+var TOP_LEVEL_ID_RE = /^\s*id:\s*"([^"\\]+)"\s*$/;
+var TS_SCRIPT_SUFFIX = ".ts.script";
+function projectPathToAbs(cwd, projectPath) {
+  return path9.join(cwd, projectPath.replace(/^\//, ""));
+}
+function relPosix(cwd, abs) {
+  return path9.relative(cwd, abs).split(path9.sep).join("/");
+}
+function resolveBootPathScripts(cwd) {
+  const gameProjectPath = path9.join(cwd, "game.project");
+  if (!existsSync5(gameProjectPath)) {
+    return [];
+  }
+  let gameProject;
+  try {
+    gameProject = readFileSync7(gameProjectPath, "utf8");
+  } catch {
+    return [];
+  }
+  const mainMatch = gameProject.match(MAIN_COLLECTION_RE);
+  if (mainMatch?.[1] === undefined) {
+    return [];
+  }
+  const mainCollection = mainMatch[1].trim().replace(/\.collectionc$/, ".collection");
+  const candidates = [];
+  const visited = new Set;
+  const walk = (collectionAbs, tracePrefix) => {
+    if (visited.has(collectionAbs)) {
+      return;
+    }
+    visited.add(collectionAbs);
+    if (!existsSync5(collectionAbs)) {
+      return;
+    }
+    let content;
+    try {
+      content = readFileSync7(collectionAbs, "utf8");
+    } catch {
+      return;
+    }
+    const trace = [...tracePrefix, relPosix(cwd, collectionAbs)];
+    const children = [];
+    let currentId = null;
+    for (const line of content.split(`
+`)) {
+      const idMatch = line.match(TOP_LEVEL_ID_RE);
+      if (idMatch?.[1] !== undefined) {
+        currentId = idMatch[1];
+        continue;
+      }
+      const componentMatch = line.match(COMPONENT_RE);
+      const component = componentMatch?.[1];
+      if (component?.endsWith(TS_SCRIPT_SUFFIX)) {
+        const candidate = component.replace(/^\//, "").replace(/\.script$/, "");
+        candidates.push({
+          candidate,
+          trace: [...trace, currentId ?? "?", component]
+        });
+        continue;
+      }
+      const collectionMatch = line.match(COLLECTION_RE);
+      if (collectionMatch?.[1] !== undefined) {
+        const ref = collectionMatch[1].replace(/\.collectionc$/, ".collection");
+        children.push(projectPathToAbs(cwd, ref));
+      }
+    }
+    for (const child of children) {
+      walk(child, trace);
+    }
+  };
+  walk(projectPathToAbs(cwd, mainCollection), ["game.project"]);
+  return candidates;
+}
+
+// src/setup-debug.ts
+var LLDEBUGGER_URL = "https://github.com/king8fisher/defold-typescript/releases/download/lldebugger-v1/lldebugger.zip";
+var LEGACY_BOOTSTRAP_MARKER = "// lldebugger-bootstrap: debug entry, inert in release builds";
+var AMBIENT_DTS_REL = "src/lldebugger.debug.d.ts";
+var AMBIENT_DECLARATION = `/** @noResolution */
+declare module "lldebugger.debug" {
+  export function start(): void;
+}
+`;
+var BLOCK_BEGIN = "// defold-typescript:setup-debug BEGIN — managed block, do not edit";
+var BLOCK_END = "// defold-typescript:setup-debug END";
+var MANAGED_BLOCK = `${BLOCK_BEGIN}
+import * as lldebugger from "lldebugger.debug";
+
+if (sys.get_engine_info().is_debug) {
+  lldebugger.start();
+}
+
+${BLOCK_END}`;
+var FACTORY_NAMES = ["defineScript", "defineGuiScript", "defineRenderScript"];
+var MANUAL_STEPS = [
+  "Install the Local Lua Debugger extension (tomblind.local-lua-debugger-vscode) in VS Code.",
+  "Run Project -> Fetch Libraries in the Defold editor to download the lldebugger module."
+];
+function isProjectHeader(line) {
+  return line.trim() === "[project]";
+}
+function isSectionHeader(line) {
+  return /^\[.+\]\s*$/.test(line.trim());
+}
+function addLldebuggerDependency(gameProjectText) {
+  const lines = gameProjectText.split(`
+`);
+  if (!lines.some(isProjectHeader)) {
+    throw new Error("defold-typescript setup-debug: game.project has no [project] section; this is not a Defold project.");
+  }
+  if (gameProjectText.includes(LLDEBUGGER_URL)) {
+    return gameProjectText;
+  }
+  let inProject = false;
+  let maxIndex = -1;
+  let lastDepLine = -1;
+  let lastProjectLine = -1;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (isSectionHeader(line)) {
+      inProject = isProjectHeader(line);
+      if (inProject) {
+        lastProjectLine = i;
+      }
+      continue;
+    }
+    if (inProject && line.trim() !== "") {
+      lastProjectLine = i;
+      const dep = line.match(/^dependencies#(\d+)\s*=/);
+      if (dep?.[1] !== undefined) {
+        const n = Number(dep[1]);
+        if (n > maxIndex) {
+          maxIndex = n;
+        }
+        lastDepLine = i;
+      }
+    }
+  }
+  const newLine = `dependencies#${maxIndex + 1} = ${LLDEBUGGER_URL}`;
+  const insertAt = (lastDepLine >= 0 ? lastDepLine : lastProjectLine) + 1;
+  lines.splice(insertAt, 0, newLine);
+  return lines.join(`
+`);
+}
+var LEGACY_BLOCK = `${LEGACY_BOOTSTRAP_MARKER}
+/** @noResolution */
+declare module "lldebugger.debug" {
+  export function start(): void;
+}
+
+import * as lldebugger from "lldebugger.debug";
+
+if (sys.get_engine_info().is_debug) {
+  lldebugger.start();
+}
+`;
+function occurrences(haystack, needle) {
+  return haystack.split(needle).length - 1;
+}
+function upsertManagedBlock(source) {
+  const begins = occurrences(source, BLOCK_BEGIN);
+  const ends = occurrences(source, BLOCK_END);
+  if (begins !== ends || begins > 1) {
+    throw new Error("defold-typescript setup-debug: malformed managed block (mismatched, duplicate, or out-of-order sentinels); refusing to edit.");
+  }
+  if (begins === 1) {
+    const beginAt = source.indexOf(BLOCK_BEGIN);
+    const endAt = source.indexOf(BLOCK_END);
+    if (endAt < beginAt) {
+      throw new Error("defold-typescript setup-debug: malformed managed block (END before BEGIN); refusing to edit.");
+    }
+    const regionEnd = endAt + BLOCK_END.length;
+    const region = source.slice(beginAt, regionEnd);
+    if (region === MANAGED_BLOCK) {
+      return { text: source, action: "unchanged" };
+    }
+    const text = source.slice(0, beginAt) + MANAGED_BLOCK + source.slice(regionEnd);
+    return { text, action: "refreshed" };
+  }
+  if (source.includes(LEGACY_BLOCK)) {
+    return { text: source.replace(LEGACY_BLOCK, `${MANAGED_BLOCK}
+`), action: "refreshed" };
+  }
+  return { text: `${MANAGED_BLOCK}
+
+${source}`, action: "injected" };
+}
+function stripManagedBlock(source) {
+  const begins = occurrences(source, BLOCK_BEGIN);
+  const ends = occurrences(source, BLOCK_END);
+  if (begins === 0 && ends === 0) {
+    return { text: source, removed: false };
+  }
+  if (begins !== ends || begins > 1) {
+    throw new Error("defold-typescript setup-debug: malformed managed block (mismatched, duplicate, or out-of-order sentinels); refusing to edit.");
+  }
+  const beginAt = source.indexOf(BLOCK_BEGIN);
+  const endAt = source.indexOf(BLOCK_END);
+  if (endAt < beginAt) {
+    throw new Error("defold-typescript setup-debug: malformed managed block (END before BEGIN); refusing to edit.");
+  }
+  const regionEnd = endAt + BLOCK_END.length;
+  const after = source.slice(regionEnd).replace(/^\n{1,2}/, "");
+  return { text: source.slice(0, beginAt) + after, removed: true };
 }
-function materializeApiSurface(opts) {
-  const { cwd, surface, sourceGeneratedDir } = opts;
-  if (!surface.available || surface.surfaceId === null || sourceGeneratedDir === null) {
-    return { materializedDir: null, active: null };
+function hasFactoryCall(text) {
+  return FACTORY_NAMES.some((name) => text.includes(`${name}(`));
+}
+function findEntryScriptCandidates(cwd, scanner = scanFilesSync) {
+  const srcDir = path10.join(cwd, "src");
+  if (!existsSync6(srcDir)) {
+    return [];
   }
-  const { surfaceId } = surface;
-  const relDir = path7.posix.join(MATERIALIZED_ROOT, surfaceId);
-  const absDir = path7.join(cwd, MATERIALIZED_ROOT, surfaceId);
-  mkdirSync3(absDir, { recursive: true });
-  const excluded = excludedModulesForKind(opts.scriptKind ?? null);
-  const sources = listDts(sourceGeneratedDir).filter((file) => file !== "index.d.ts").filter((file) => !excluded.has(file.replace(/\.d\.ts$/, "")));
-  const srcDir = path7.resolve(sourceGeneratedDir, "..", "src");
-  const overloads = ["msg-overloads.d.ts", "message-guard.d.ts", "go-overloads.d.ts"].filter((file) => existsSync3(path7.join(srcDir, file)));
-  const coreTypesSrc = path7.join(srcDir, "core-types.ts");
-  const includeCoreTypes = overloads.length > 0 && existsSync3(coreTypesSrc);
-  const engineGlobalsSrc = path7.join(srcDir, "engine-globals.d.ts");
-  const includeEngineGlobals = includeCoreTypes && existsSync3(engineGlobalsSrc);
-  const wanted = new Set(sources);
-  for (const file of overloads) {
-    wanted.add(file);
+  return scanner(cwd, "src/**/*.ts").map(normalizeScannedPath).filter((rel) => !isSkipped(rel)).filter((rel) => hasFactoryCall(readFileSync8(path10.join(cwd, rel), "utf8"))).sort();
+}
+function failure(error) {
+  return { ok: false, written: [], actions: {}, manualSteps: MANUAL_STEPS, error };
+}
+async function defaultChooseScript(candidates) {
+  const { select } = await import("@inquirer/prompts");
+  return select({
+    message: "Select the entry script to receive the debugger bootstrap:",
+    choices: candidates.map((candidate) => ({ name: candidate, value: candidate }))
+  });
+}
+async function pickCandidate(candidates, opts) {
+  if (candidates.length === 1) {
+    return candidates[0];
   }
-  if (includeCoreTypes) {
-    wanted.add("core-types.d.ts");
+  const chooser = opts.chooseScript ?? (opts.json ? undefined : defaultChooseScript);
+  if (chooser === undefined) {
+    return failure(`defold-typescript setup-debug: multiple entry scripts found (${candidates.join(", ")}); pass --script to choose one.`);
   }
-  if (includeEngineGlobals) {
-    wanted.add("engine-globals.d.ts");
+  return chooser(candidates);
+}
+async function resolveTargetScript(opts) {
+  const { cwd } = opts;
+  const script = opts.script === undefined ? undefined : normalizeScannedPath(opts.script);
+  const bootCandidates = resolveBootPathScripts(cwd).filter((entry) => existsSync6(path10.join(cwd, entry.candidate)));
+  if (script !== undefined) {
+    if (!existsSync6(path10.join(cwd, script))) {
+      return failure(`defold-typescript setup-debug: script not found: ${script}`);
+    }
+    const onPath = bootCandidates.find((entry) => entry.candidate === script);
+    return { target: script, bootPath: onPath?.trace ?? [] };
   }
-  for (const existing of readdirSync2(absDir)) {
-    if (existing.endsWith(".d.ts") && existing !== "index.d.ts" && !wanted.has(existing)) {
-      rmSync(path7.join(absDir, existing));
+  if (bootCandidates.length > 0) {
+    const picked2 = await pickCandidate(bootCandidates.map((entry) => entry.candidate), opts);
+    if (typeof picked2 !== "string") {
+      return picked2;
     }
+    const onPath = bootCandidates.find((entry) => entry.candidate === picked2);
+    return { target: picked2, bootPath: onPath?.trace ?? [] };
   }
-  for (const file of sources) {
-    writeFileSync3(path7.join(absDir, file), readFileSync6(path7.join(sourceGeneratedDir, file), "utf8"));
+  const scanned = findEntryScriptCandidates(cwd, opts.scanFiles);
+  if (scanned.length === 0) {
+    return failure("defold-typescript setup-debug: no entry script with a lifecycle factory call found under src/.");
   }
-  if (includeCoreTypes) {
-    writeFileSync3(path7.join(absDir, "core-types.d.ts"), readFileSync6(coreTypesSrc, "utf8"));
+  const picked = await pickCandidate(scanned, opts);
+  if (typeof picked !== "string") {
+    return picked;
   }
-  if (includeEngineGlobals) {
-    writeFileSync3(path7.join(absDir, "engine-globals.d.ts"), readFileSync6(engineGlobalsSrc, "utf8"));
+  return { target: picked, bootPath: [] };
+}
+async function runSetupDebug(opts) {
+  const { cwd } = opts;
+  const gameProjectPath = path10.join(cwd, "game.project");
+  if (!existsSync6(gameProjectPath)) {
+    return failure("defold-typescript setup-debug: no game.project here; this is not a Defold project.");
   }
-  for (const file of overloads) {
-    writeFileSync3(path7.join(absDir, file), readFileSync6(path7.join(srcDir, file), "utf8"));
+  const resolved = await resolveTargetScript(opts);
+  if (!("target" in resolved)) {
+    return resolved;
   }
-  const modules = [...sources, ...overloads].map((file) => file.replace(/\.d\.ts$/, ""));
-  if (includeEngineGlobals) {
-    modules.push("engine-globals");
+  const { target, bootPath } = resolved;
+  const written = [];
+  const actions = {};
+  const dtsPath = path10.join(cwd, AMBIENT_DTS_REL);
+  mkdirSync5(path10.dirname(dtsPath), { recursive: true });
+  const existingDts = existsSync6(dtsPath) ? readFileSync8(dtsPath, "utf8") : null;
+  if (existingDts === null) {
+    writeFileSync4(dtsPath, AMBIENT_DECLARATION);
+    actions[AMBIENT_DTS_REL] = "injected";
+  } else if (existingDts !== AMBIENT_DECLARATION) {
+    writeFileSync4(dtsPath, AMBIENT_DECLARATION);
+    actions[AMBIENT_DTS_REL] = "refreshed";
+  } else {
+    actions[AMBIENT_DTS_REL] = "unchanged";
+  }
+  written.push(AMBIENT_DTS_REL);
+  const scriptPath = path10.join(cwd, target);
+  const source = readFileSync8(scriptPath, "utf8");
+  const { text: injected, action: scriptAction } = upsertManagedBlock(source);
+  if (injected !== source) {
+    writeFileSync4(scriptPath, injected);
+  }
+  actions[target] = scriptAction;
+  written.push(target);
+  const gameProjectText = readFileSync8(gameProjectPath, "utf8");
+  const updated = addLldebuggerDependency(gameProjectText);
+  if (updated !== gameProjectText) {
+    writeFileSync4(gameProjectPath, updated);
+    actions["game.project"] = "injected";
+  } else {
+    actions["game.project"] = "unchanged";
   }
-  const imports = modules.map((mod) => `import "./${mod}";`).join(`
-`);
-  writeFileSync3(path7.join(absDir, "index.d.ts"), `${imports}
+  written.push("game.project");
+  const removedFrom = [];
+  for (const scannedRel of (opts.scanFiles ?? scanFilesSync)(cwd, "src/**/*.ts")) {
+    const rel = normalizeScannedPath(scannedRel);
+    if (isSkipped(rel) || rel === target) {
+      continue;
+    }
+    const otherPath = path10.join(cwd, rel);
+    const otherSource = readFileSync8(otherPath, "utf8");
+    let stripped;
+    try {
+      stripped = stripManagedBlock(otherSource);
+    } catch {
+      continue;
+    }
+    if (stripped.removed) {
+      writeFileSync4(otherPath, stripped.text);
+      actions[rel] = "removed";
+      removedFrom.push(rel);
+    }
+  }
+  removedFrom.sort();
+  return {
+    ok: true,
+    written,
+    actions,
+    manualSteps: MANUAL_STEPS,
+    addedTo: target,
+    removedFrom,
+    bootPath
+  };
+}
 
-export {};
-`);
-  writeJson2(path7.join(absDir, "package.json"), {
-    name: `@defold-typescript/materialized-${surfaceId}`,
-    types: "index.d.ts"
-  });
-  return { materializedDir: relDir, active: surfaceId };
+// src/wall.ts
+import { existsSync as existsSync8, readFileSync as readFileSync10, rmSync as rmSync2 } from "node:fs";
+import * as path12 from "node:path";
+
+// src/directory-walls.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "node:fs";
+import * as path11 from "node:path";
+function describeWall(dir, kind) {
+  return {
+    dir,
+    kind,
+    typesEntrypoint: selectScriptKindEntrypoint(new Set([kind]))
+  };
 }
-function ensureGitignoreLine(cwd, line) {
-  const gitignorePath = path7.join(cwd, ".gitignore");
-  if (!existsSync3(gitignorePath)) {
-    writeFileSync3(gitignorePath, `${line}
-`);
-    return;
+function groupSourceScriptKindsByDirectory(cwd) {
+  const byDir = new Map;
+  const seen = new Set;
+  for (const pattern of readBuildConfig(cwd).include) {
+    for (const match of scanFilesSync(cwd, pattern)) {
+      const rel = match.split(path11.sep).join("/");
+      if (seen.has(rel) || !isTranspilerSource(rel) || isSkipped(rel)) {
+        continue;
+      }
+      seen.add(rel);
+      const kind = detectSourceOutputKind(readFileSync9(path11.join(cwd, match), "utf8"));
+      if (kind === "module") {
+        continue;
+      }
+      const dir = path11.posix.dirname(rel);
+      let set = byDir.get(dir);
+      if (set === undefined) {
+        set = new Set;
+        byDir.set(dir, set);
+      }
+      set.add(kind);
+    }
   }
-  const existing = readFileSync6(gitignorePath, "utf8");
-  const present = new Set(existing.split(`
-`).map((entry) => entry.trim()));
-  if (present.has(line)) {
-    return;
+  return byDir;
+}
+function planSourceDirectoryWalls(cwd) {
+  const walls = [];
+  for (const [dir, kinds] of groupSourceScriptKindsByDirectory(cwd)) {
+    const kind = selectScriptKind(kinds);
+    if (kind !== null) {
+      walls.push(describeWall(dir, kind));
+    }
   }
-  const prefix = existing.endsWith(`
-`) || existing === "" ? "" : `
-`;
-  writeFileSync3(gitignorePath, `${existing}${prefix}${line}
+  return walls.sort((a, b) => a.dir < b.dir ? -1 : a.dir > b.dir ? 1 : 0);
+}
+function directoryWallTsconfig(wall) {
+  const depth = wall.dir.split("/").length;
+  return {
+    extends: `${"../".repeat(depth)}tsconfig.json`,
+    compilerOptions: { composite: true, typeRoots: null, types: [wall.typesEntrypoint] },
+    include: ["**/*.ts"],
+    exclude: []
+  };
+}
+function writeJson3(filePath, value) {
+  mkdirSync6(path11.dirname(filePath), { recursive: true });
+  writeFileSync5(filePath, `${JSON.stringify(value, null, 2)}
 `);
 }
-function ensureMaterializedReference(cwd, materializedDir) {
-  if (materializedDir === null) {
-    return;
+function sortedWallDirs(walls) {
+  return walls.map((w) => w.dir).filter((dir) => dir !== ".").sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+}
+function isInsideAnyDir(rel, dirs) {
+  return dirs.some((dir) => rel === dir || rel.startsWith(`${dir}/`));
+}
+function hasRootOwnedTranspilerSources(cwd, wallDirs) {
+  const seen = new Set;
+  for (const pattern of readBuildConfig(cwd).include) {
+    for (const match of scanFilesSync(cwd, pattern)) {
+      const rel = match.split(path11.sep).join("/");
+      if (seen.has(rel) || !isTranspilerSource(rel) || isSkipped(rel)) {
+        continue;
+      }
+      seen.add(rel);
+      if (!isInsideAnyDir(rel, wallDirs)) {
+        return true;
+      }
+    }
   }
-  const surfaceId = path7.posix.basename(materializedDir);
-  const tsconfigPath = path7.join(cwd, "tsconfig.json");
-  if (existsSync3(tsconfigPath)) {
-    const tsconfig = JSON.parse(readFileSync6(tsconfigPath, "utf8"));
-    const current = tsconfig.compilerOptions ?? {};
-    const alreadyRepointed = JSON.stringify(current.typeRoots) === JSON.stringify([MATERIALIZED_ROOT]) && JSON.stringify(current.types) === JSON.stringify([surfaceId]);
-    if (!alreadyRepointed) {
-      tsconfig.compilerOptions = {
-        ...current,
-        typeRoots: [MATERIALIZED_ROOT],
-        types: [surfaceId]
-      };
-      writeJson2(tsconfigPath, tsconfig);
+  return false;
+}
+function wireWallReferences(cwd, walls) {
+  const rootPath = path11.join(cwd, "tsconfig.json");
+  const current = JSON.parse(readFileSync9(rootPath, "utf8"));
+  const wallDirs = sortedWallDirs(walls);
+  const previousReferences = current.references ?? [];
+  const previousManaged = new Set(previousReferences.map((ref) => ref.path));
+  const nextExclude = [
+    ...new Set([
+      ...(current.exclude ?? []).filter((entry) => !previousManaged.has(entry)),
+      ...wallDirs
+    ])
+  ];
+  const next = { ...current };
+  if (wallDirs.length > 0) {
+    next.references = wallDirs.map((dir) => ({ path: dir }));
+  } else {
+    delete next.references;
+  }
+  if (nextExclude.length > 0) {
+    next.exclude = nextExclude;
+  } else {
+    delete next.exclude;
+  }
+  if (wallDirs.length > 0 && !hasRootOwnedTranspilerSources(cwd, wallDirs)) {
+    next.files = [];
+  } else if (previousReferences.length > 0 && JSON.stringify(next.files) === JSON.stringify([])) {
+    delete next.files;
+  }
+  if (JSON.stringify(next) !== JSON.stringify(current)) {
+    writeJson3(rootPath, next);
+  }
+}
+function writeDirectoryWallTsconfigs(cwd, walls) {
+  const written = [];
+  for (const w of walls) {
+    if (w.dir === ".") {
+      continue;
+    }
+    const rel = `${w.dir}/tsconfig.json`;
+    const target = path11.join(cwd, w.dir, "tsconfig.json");
+    const desired = directoryWallTsconfig(w);
+    if (existsSync7(target)) {
+      const current = JSON.parse(readFileSync9(target, "utf8"));
+      const options = current.compilerOptions ?? {};
+      const alreadyNarrowed = current.extends === desired.extends && options.composite === desired.compilerOptions.composite && options.typeRoots === desired.compilerOptions.typeRoots && JSON.stringify(options.types) === JSON.stringify(desired.compilerOptions.types) && JSON.stringify(current.include) === JSON.stringify(desired.include) && JSON.stringify(current.exclude) === JSON.stringify(desired.exclude);
+      if (!alreadyNarrowed) {
+        writeJson3(target, {
+          ...current,
+          extends: desired.extends,
+          compilerOptions: {
+            ...options,
+            composite: desired.compilerOptions.composite,
+            typeRoots: desired.compilerOptions.typeRoots,
+            types: desired.compilerOptions.types
+          },
+          include: desired.include,
+          exclude: desired.exclude
+        });
+        written.push(rel);
+      }
+    } else {
+      writeJson3(target, desired);
+      written.push(rel);
     }
   }
-  ensureGitignoreLine(cwd, `${MATERIALIZED_ROOT}/`);
+  return written.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
 }
-function resolveCurrentSurfaceGeneratedDir() {
-  const root = resolveTypesPackageRoot();
-  return root === null ? null : path7.join(root, "generated");
+
+// src/wall.ts
+function sortDirs(items) {
+  return items.sort((a, b) => a.dir < b.dir ? -1 : a.dir > b.dir ? 1 : 0);
 }
-async function materializeRefDocSurface(opts) {
-  const { cwd, surfaceId, resolveOpts } = opts;
-  const root = resolveTypesPackageRoot();
-  if (root === null) {
-    return { materializedDir: null, active: null };
-  }
-  const registry = opts.registry ?? loadApiTargetsRegistry();
-  const target = registry.find((t) => t.id === surfaceId);
-  if (target?.source?.kind !== "ref-doc") {
-    return { materializedDir: null, active: null };
+function currentWalledDirs(cwd) {
+  const rootPath = path12.join(cwd, "tsconfig.json");
+  if (!existsSync8(rootPath)) {
+    return [];
   }
-  const excludeModules = [...excludedModulesForKind(opts.scriptKind ?? null)];
-  const relDir = path7.posix.join(MATERIALIZED_ROOT, surfaceId);
-  const absDir = path7.join(cwd, MATERIALIZED_ROOT, surfaceId);
   try {
-    const mod = await import(path7.join(root, "scripts", "materialize-version.ts"));
-    const selfContained = { ...target, coreTypesImport: "./core-types" };
-    await mod.materializeVersionedSurface(selfContained, {
-      destDir: absDir,
-      ...resolveOpts ? { resolveOpts } : {},
-      ...excludeModules.length > 0 ? { excludeModules } : {}
-    });
-    copyFileSync(path7.join(root, "src", "core-types.ts"), path7.join(absDir, "core-types.d.ts"));
-    copyFileSync(path7.join(root, "src", "engine-globals.d.ts"), path7.join(absDir, "engine-globals.d.ts"));
-    const indexPath = path7.join(absDir, "index.d.ts");
-    writeFileSync3(indexPath, `import "./engine-globals";
-${readFileSync6(indexPath, "utf8")}`);
+    const parsed = JSON.parse(readFileSync10(rootPath, "utf8"));
+    return (parsed.references ?? []).map((ref) => ref.path).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
   } catch {
-    rmSync(absDir, { recursive: true, force: true });
-    return { materializedDir: null, active: null };
+    return [];
   }
-  return { materializedDir: relDir, active: surfaceId };
+}
+function eligibleWalls(cwd) {
+  return planSourceDirectoryWalls(cwd);
+}
+function applyWallSelection(cwd, desiredDirs) {
+  const byDir = new Map(eligibleWalls(cwd).map((wall) => [wall.dir, wall]));
+  const desired = [];
+  const desiredSet = new Set;
+  for (const dir of desiredDirs) {
+    if (desiredSet.has(dir)) {
+      continue;
+    }
+    const wall = byDir.get(dir);
+    if (wall === undefined) {
+      throw new Error(`defold-typescript wall: ${dir} is not a single-kind source directory that can be walled`);
+    }
+    desired.push(wall);
+    desiredSet.add(dir);
+  }
+  for (const dir of currentWalledDirs(cwd)) {
+    if (!desiredSet.has(dir)) {
+      rmSync2(path12.join(cwd, dir, "tsconfig.json"), { force: true });
+    }
+  }
+  writeDirectoryWallTsconfigs(cwd, desired);
+  wireWallReferences(cwd, desired);
+  return sortDirs(desired);
+}
+
+// src/wall-interactive.ts
+function buildWallChoices(cwd) {
+  const current = new Set(currentWalledDirs(cwd));
+  const choices = [];
+  for (const [dir, kinds] of groupSourceScriptKindsByDirectory(cwd)) {
+    const kind = selectScriptKind(kinds);
+    if (kind === null) {
+      choices.push({ value: dir, name: dir, disabled: `mixed: ${[...kinds].sort().join(", ")}` });
+    } else {
+      choices.push({ value: dir, name: `${dir} (${kind})`, checked: current.has(dir) });
+    }
+  }
+  return choices.sort((a, b) => a.value < b.value ? -1 : a.value > b.value ? 1 : 0);
+}
+async function defaultCheckbox() {
+  const { checkbox } = await import("@inquirer/prompts");
+  return (opts) => checkbox({ message: opts.message, choices: opts.choices });
+}
+async function runWallInteractive(cwd, deps = {}) {
+  const checkbox = deps.checkbox ?? await defaultCheckbox();
+  const selection = await checkbox({
+    message: "Select the source directories to wall (space toggles, enter confirms):",
+    choices: buildWallChoices(cwd)
+  });
+  return applyWallSelection(cwd, selection);
 }
 
 // src/watch.ts
-import { existsSync as existsSync4, watch as fsWatch } from "node:fs";
-import * as path9 from "node:path";
+import { existsSync as existsSync9, watch as fsWatch } from "node:fs";
+import * as path14 from "node:path";
 
 // src/build-session.ts
-import { readFileSync as readFileSync7, rmSync as rmSync2 } from "node:fs";
-import * as path8 from "node:path";
+import { readFileSync as readFileSync11, rmSync as rmSync3 } from "node:fs";
+import * as path13 from "node:path";
 import {
   createTranspileSession
 } from "@defold-typescript/transpiler";
@@ -1122,7 +1931,14 @@ function createBuildSession(opts) {
   const { cwd } = opts;
   const config = readBuildConfig(cwd);
   const session = createTranspileSession();
-  function writeOutputs(result, keys) {
+  function pruneOutputs(rel, keepRel) {
+    for (const outputRel of outputRelsForSource(rel, config)) {
+      if (outputRel !== keepRel && outputRel !== `${keepRel}.map`) {
+        rmSync3(path13.join(cwd, outputRel), { force: true });
+      }
+    }
+  }
+  function writeOutputs(result, keys, sources, pruneAlternatives = false) {
     const failures = collectFailures(result.diagnostics);
     const written = [];
     for (const rel of keys) {
@@ -1133,12 +1949,15 @@ function createBuildSession(opts) {
       if (lua === undefined) {
         continue;
       }
-      const scriptRel = computeScriptRel(rel, config);
-      writeScriptFile(cwd, scriptRel, lua, result.sourceMaps[rel]);
-      written.push(scriptRel);
+      const outputRel = computeOutputRel(rel, config, detectSourceOutputKind(sources[rel] ?? ""));
+      if (pruneAlternatives) {
+        pruneOutputs(rel, outputRel);
+      }
+      writeScriptFile(cwd, outputRel, lua, result.sourceMaps[rel]);
+      written.push(outputRel);
     }
     throwIfFailures(failures);
-    return { written };
+    return { written: written.sort() };
   }
   function buildAll() {
     const seen = new Set;
@@ -1153,28 +1972,30 @@ function createBuildSession(opts) {
     }
     const files = {};
     for (const rel of sources) {
-      files[rel] = readFileSync7(path8.join(cwd, rel), "utf8");
+      files[rel] = readFileSync11(path13.join(cwd, rel), "utf8");
     }
     const result = session.update(files);
-    return writeOutputs(result, sources);
+    return writeOutputs(result, sources, files);
   }
   function applyEvents(changed, removed) {
     const sourceChanged = changed.filter(isTranspilerSource);
     const sourceRemoved = removed.filter(isTranspilerSource);
     const changes = {};
     for (const rel of sourceChanged) {
-      changes[rel] = readFileSync7(path8.join(cwd, rel), "utf8");
+      changes[rel] = readFileSync11(path13.join(cwd, rel), "utf8");
     }
     for (const rel of sourceRemoved) {
       changes[rel] = null;
     }
     const result = session.update(changes);
     for (const rel of sourceRemoved) {
-      const scriptAbs = path8.join(cwd, computeScriptRel(rel, config));
-      rmSync2(scriptAbs, { force: true });
-      rmSync2(`${scriptAbs}.map`, { force: true });
+      pruneOutputs(rel);
+    }
+    const changedSources = {};
+    for (const rel of sourceChanged) {
+      changedSources[rel] = changes[rel] ?? "";
     }
-    return writeOutputs(result, sourceChanged);
+    return writeOutputs(result, sourceChanged, changedSources, true);
   }
   return { buildAll, applyEvents };
 }
@@ -1213,7 +2034,7 @@ function runWatch(opts) {
     opts.syncSurface?.();
     session = createBuildSession({ cwd });
     const { written } = session.buildAll();
-    stdout.write(formatBuildLine(written));
+    stdout.write(opts.json ? renderWatchEvent({ event: "build", written }) : formatBuildLine(written));
   } catch (err) {
     rejectDone(rewrapInitError(err));
     return {
@@ -1222,7 +2043,7 @@ function runWatch(opts) {
       waitForIdle: () => Promise.resolve()
     };
   }
-  const srcDir = path9.join(cwd, "src");
+  const srcDir = path14.join(cwd, "src");
   let scheduled = null;
   let syncScheduled = null;
   let rebuildBusy = false;
@@ -1246,7 +2067,7 @@ function runWatch(opts) {
     const removed = [];
     for (const rel of drained) {
       const key = `src/${toPosix(rel)}`;
-      if (existsSync4(path9.join(srcDir, rel))) {
+      if (existsSync9(path14.join(srcDir, rel))) {
         changed.push(key);
       } else {
         removed.push(key);
@@ -1254,11 +2075,15 @@ function runWatch(opts) {
     }
     try {
       const { written } = session.applyEvents(changed, removed);
-      stdout.write(formatBuildLine(written));
+      stdout.write(opts.json ? renderWatchEvent({ event: "rebuild", written, changed, removed }) : formatBuildLine(written));
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      stderr.write(`${message}
+      if (opts.json) {
+        stdout.write(renderWatchEvent({ event: "rebuild", error: message }));
+      } else {
+        stderr.write(`${message}
 `);
+      }
     }
     rebuildBusy = false;
     notifyIdle();
@@ -1328,7 +2153,9 @@ function runWatch(opts) {
 }
 
 // src/dispatch.ts
-var USAGE = `Usage: defold-typescript <init|build|watch> [path]
+var USAGE = `Usage: defold-typescript <init|build|watch|wall|setup-debug|defold> [path]
+`;
+var DEFOLD_USAGE = `Usage: defold-typescript defold <resolve|build|bundle> [path]
 `;
 function parseDefoldVersionFlag(argv) {
   let flag;
@@ -1346,13 +2173,47 @@ function parseDefoldVersionFlag(argv) {
   }
   return { flag, rest };
 }
+function parseScriptFlag(argv) {
+  let script;
+  const rest = [];
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--script") {
+      script = argv[i + 1];
+      i++;
+    } else if (arg?.startsWith("--script=")) {
+      script = arg.slice("--script=".length);
+    } else if (arg !== undefined) {
+      rest.push(arg);
+    }
+  }
+  return { script, rest };
+}
+function parseValueFlag(argv, name) {
+  const long = `--${name}`;
+  const eq = `${long}=`;
+  let value;
+  const rest = [];
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === long) {
+      value = argv[i + 1];
+      i++;
+    } else if (arg?.startsWith(eq)) {
+      value = arg.slice(eq.length);
+    } else if (arg !== undefined) {
+      rest.push(arg);
+    }
+  }
+  return { value, rest };
+}
 function readProjectPin(cwd) {
-  const pkgPath = path10.join(cwd, "package.json");
-  if (!existsSync5(pkgPath)) {
+  const pkgPath = path15.join(cwd, "package.json");
+  if (!existsSync10(pkgPath)) {
     return;
   }
   try {
-    return readDefoldVersionPin(JSON.parse(readFileSync8(pkgPath, "utf8")));
+    return readDefoldVersionPin(JSON.parse(readFileSync12(pkgPath, "utf8")));
   } catch {
     return;
   }
@@ -1367,10 +2228,16 @@ function dispatch(argv, io, internals) {
     return 0;
   }
   const force = argv.includes("--force");
-  const { flag: defoldVersionFlag, rest: nonFlagArgs } = parseDefoldVersionFlag(argv);
-  const positional = nonFlagArgs.filter((a) => a !== "--json" && a !== "--force");
+  const suppressInstallReminder = argv.includes("--suppress-install-reminder");
+  const wallRemove = argv.includes("--remove");
+  const wallList = argv.includes("--list");
+  const { flag: defoldVersionFlag, rest: afterVersionArgs } = parseDefoldVersionFlag(argv);
+  const { script: scriptFlag, rest: afterScriptArgs } = parseScriptFlag(afterVersionArgs);
+  const { value: javaFlag, rest: afterJavaArgs } = parseValueFlag(afterScriptArgs, "java");
+  const { value: buildServerFlag, rest: nonFlagArgs } = parseValueFlag(afterJavaArgs, "build-server");
+  const positional = nonFlagArgs.filter((a) => a !== "--json" && a !== "--force" && a !== "--suppress-install-reminder" && a !== "--remove" && a !== "--list");
   const [command, ...rest] = positional;
-  const cwd = rest[0] ? path10.resolve(rest[0]) : process.cwd();
+  const cwd = rest[0] ? path15.resolve(rest[0]) : process.cwd();
   const pin = readProjectPin(cwd);
   const resolvedVersion = resolveDefoldVersion({
     ...defoldVersionFlag !== undefined ? { flag: defoldVersionFlag } : {},
@@ -1380,18 +2247,22 @@ function dispatch(argv, io, internals) {
   const apiSurface = surface.surfaceId;
   if (command === "init") {
     try {
-      const { written, scriptKind } = runInit({ cwd, force });
+      const { written } = runInit({ cwd, force });
       if (json) {
         io.stdout.write(renderResult({
           command: "init",
           written,
           defoldVersion: resolvedVersion,
           apiSurface,
-          scriptKind
+          installCommand: installHint()
         }));
       } else {
         io.stdout.write(`defold-typescript init: wrote ${written.length} files: ${written.join(", ")}
 `);
+        if (!suppressInstallReminder) {
+          io.stdout.write(`Next: run \`${installHint()}\` to install dependencies.
+`);
+        }
       }
       return 0;
     } catch (err) {
@@ -1405,8 +2276,52 @@ function dispatch(argv, io, internals) {
       return 1;
     }
   }
+  if (command === "setup-debug") {
+    return (async () => {
+      const result = await runSetupDebug({
+        cwd,
+        json,
+        ...scriptFlag !== undefined ? { script: scriptFlag } : {}
+      });
+      if (json) {
+        io.stdout.write(renderResult(result.ok ? {
+          command: "setup-debug",
+          written: result.written,
+          actions: result.actions,
+          manualSteps: result.manualSteps,
+          ...result.addedTo !== undefined ? { addedTo: result.addedTo } : {},
+          removedFrom: result.removedFrom ?? [],
+          bootPath: result.bootPath ?? []
+        } : { command: "setup-debug", error: result.error ?? "setup-debug failed" }));
+      } else if (result.ok) {
+        io.stdout.write(`defold-typescript setup-debug: wrote ${result.written.length} files: ${result.written.join(", ")}
+`);
+        if (result.addedTo !== undefined) {
+          io.stdout.write(`Debugger bootstrap added to: ${result.addedTo}
+`);
+        }
+        if (result.removedFrom !== undefined && result.removedFrom.length > 0) {
+          io.stdout.write(`Removed stale bootstrap from: ${result.removedFrom.join(", ")}
+`);
+        }
+        if (result.bootPath !== undefined && result.bootPath.length > 0) {
+          io.stdout.write(`Boot path: ${result.bootPath.join(" -> ")}
+`);
+        }
+        io.stdout.write(`Remaining manual steps:
+`);
+        for (const step of result.manualSteps) {
+          io.stdout.write(`  - ${step}
+`);
+        }
+      } else {
+        io.stderr.write(`${result.error}
+`);
+      }
+      return result.ok ? 0 : 1;
+    })();
+  }
   if (command === "build") {
-    const scriptKind = selectScriptKind(detectScriptKinds(cwd));
     const reportBuild = (written, materializedDir) => {
       ensureMaterializedReference(cwd, materializedDir);
       if (json) {
@@ -1415,7 +2330,6 @@ function dispatch(argv, io, internals) {
           written,
           defoldVersion: resolvedVersion,
           apiSurface,
-          scriptKind,
           materializedSurface: materializedDir
         }));
       } else {
@@ -1443,7 +2357,6 @@ function dispatch(argv, io, internals) {
           const { materializedDir } = await materializeRefDocSurface({
             cwd,
             surfaceId,
-            scriptKind,
             ...internals?.resolveOpts ? { resolveOpts: internals.resolveOpts } : {},
             ...internals?.refDocRegistry ? { registry: internals.refDocRegistry } : {}
           });
@@ -1463,8 +2376,7 @@ function dispatch(argv, io, internals) {
       const { materializedDir } = materializeApiSurface({
         cwd,
         surface,
-        sourceGeneratedDir,
-        scriptKind
+        sourceGeneratedDir
       });
       return reportBuild(written, materializedDir);
     } catch (err) {
@@ -1478,12 +2390,10 @@ function dispatch(argv, io, internals) {
     if (!isRefDocSurface) {
       const sourceGeneratedDir = internals?.sourceGeneratedDir ?? resolveCurrentSurfaceGeneratedDir();
       syncSurface = () => {
-        const scriptKind = selectScriptKind(detectScriptKinds(cwd));
         const { materializedDir } = materializeApiSurface({
           cwd,
           surface,
-          sourceGeneratedDir,
-          scriptKind
+          sourceGeneratedDir
         });
         ensureMaterializedReference(cwd, materializedDir);
       };
@@ -1497,7 +2407,8 @@ function dispatch(argv, io, internals) {
         ...internals?.watcherFactory ? { watcherFactory: internals.watcherFactory } : {},
         ...internals?.debounceMs !== undefined ? { debounceMs: internals.debounceMs } : {},
         ...syncSurface ? { syncSurface } : {},
-        ...componentWatcherFactory ? { componentWatcherFactory } : {}
+        ...componentWatcherFactory ? { componentWatcherFactory } : {},
+        ...json ? { json: true } : {}
       };
       const handle = runWatch(watchOpts);
       if (internals) {
@@ -1514,12 +2425,10 @@ function dispatch(argv, io, internals) {
     };
     if (isRefDocSurface) {
       const surfaceId = surface.surfaceId;
-      const scriptKind = selectScriptKind(detectScriptKinds(cwd));
       return (async () => {
         const { materializedDir } = await materializeRefDocSurface({
           cwd,
           surfaceId,
-          scriptKind,
           ...internals?.resolveOpts ? { resolveOpts: internals.resolveOpts } : {},
           ...internals?.refDocRegistry ? { registry: internals.refDocRegistry } : {}
         });
@@ -1529,6 +2438,116 @@ function dispatch(argv, io, internals) {
     }
     return launchWatch();
   }
+  if (command === "wall") {
+    const wallCwd = internals?.cwd ?? process.cwd();
+    const dirs = rest;
+    const toJsonWall = (w) => ({
+      dir: w.dir,
+      kind: w.kind
+    });
+    const reportWalls = (walls) => {
+      if (json) {
+        io.stdout.write(renderResult({ command: "wall", directoryWalls: walls.map(toJsonWall) }));
+      } else if (walls.length === 0) {
+        io.stdout.write(`defold-typescript wall: no directories walled
+`);
+      } else {
+        io.stdout.write(`defold-typescript wall: walled ${walls.map((w) => w.dir).join(", ")}
+`);
+      }
+    };
+    if (wallList) {
+      const current = currentWalledDirs(wallCwd);
+      const eligible = eligibleWalls(wallCwd);
+      const currentWalls = eligible.filter((w) => current.includes(w.dir));
+      if (json) {
+        io.stdout.write(renderResult({
+          command: "wall",
+          directoryWalls: currentWalls.map(toJsonWall),
+          eligible: eligible.map(toJsonWall)
+        }));
+      } else {
+        io.stdout.write(`defold-typescript wall: walled [${current.join(", ")}]; eligible [${eligible.map((w) => w.dir).join(", ")}]
+`);
+      }
+      return 0;
+    }
+    if (dirs.length > 0) {
+      try {
+        const current = currentWalledDirs(wallCwd);
+        const desired = wallRemove ? current.filter((d) => !dirs.includes(d)) : [...current, ...dirs];
+        reportWalls(applyWallSelection(wallCwd, desired));
+        return 0;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (json) {
+          io.stdout.write(renderResult({ command: "wall", error: message }));
+        } else {
+          io.stderr.write(`${message}
+`);
+        }
+        return 1;
+      }
+    }
+    const interactive = !json && (internals?.isTty ?? Boolean(process.stdout.isTTY));
+    if (!interactive) {
+      io.stderr.write(`defold-typescript wall: no directory given; pass <dir> or run in a terminal for the interactive menu
+`);
+      return 1;
+    }
+    return (async () => {
+      try {
+        reportWalls(await runWallInteractive(wallCwd, internals?.wallCheckbox ? { checkbox: internals.wallCheckbox } : {}));
+        return 0;
+      } catch (err) {
+        io.stderr.write(`${err instanceof Error ? err.message : String(err)}
+`);
+        return 1;
+      }
+    })();
+  }
+  if (command === "defold") {
+    const subcommand = rest[0];
+    const defoldCwd = rest[1] ? path15.resolve(rest[1]) : process.cwd();
+    if (!isDefoldSubcommand(subcommand)) {
+      io.stderr.write(DEFOLD_USAGE);
+      return 1;
+    }
+    const javaOverride = javaFlag ?? process.env.DEFOLD_JAVA;
+    const defoldIo = { ...defaultDefoldIo(), ...internals?.defoldIo };
+    return (async () => {
+      try {
+        const result = await runDefoldCommand({
+          cwd: defoldCwd,
+          subcommand,
+          ...javaOverride !== undefined ? { java: javaOverride } : {},
+          ...buildServerFlag !== undefined ? { buildServer: buildServerFlag } : {},
+          io: defoldIo
+        });
+        if (json) {
+          io.stdout.write(renderResult(result.ok ? { command: "defold", subcommand: result.subcommand, exitCode: result.exitCode } : {
+            command: "defold",
+            subcommand: result.subcommand,
+            exitCode: result.exitCode,
+            error: `bob ${result.subcommand} exited with code ${result.exitCode}`
+          }));
+        } else if (!result.ok) {
+          io.stderr.write(`defold-typescript defold ${result.subcommand}: bob exited with code ${result.exitCode}
+`);
+        }
+        return result.exitCode;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (json) {
+          io.stdout.write(renderResult({ command: "defold", subcommand, error: message }));
+        } else {
+          io.stderr.write(`${message}
+`);
+        }
+        return 1;
+      }
+    })();
+  }
   io.stderr.write(USAGE);
   return 1;
 }