@defold-typescript/cli 0.5.5 → 0.7.0

package/dist/init.d.ts

@@ -1,12 +1,11 @@
-import { type ScriptKind } from "./script-kind";
 export interface RunInitOptions {
     readonly cwd: string;
     readonly force?: boolean;
 }
 export interface RunInitResult {
     readonly written: string[];
-    readonly scriptKind: ScriptKind | null;
 }
 export declare const SCAFFOLD_DEV_DEPS: Record<string, string>;
+export declare function reconcileManagedList(existing: unknown, managed: readonly string[], canonical: readonly string[]): string[];
 export declare function runNewProjectInit(cwd: string, force?: boolean): RunInitResult;
 export declare function runInit(opts: RunInitOptions): RunInitResult;

package/dist/install-reminder.d.ts

@@ -0,0 +1 @@
+export declare function installHint(env?: NodeJS.ProcessEnv): string;

package/dist/json-output.d.ts

@@ -1,11 +1,35 @@
-export type CliCommand = "init" | "build";
+export type CliCommand = "init" | "build" | "setup-debug" | "defold" | "wall";
 export interface RenderResultInput {
     readonly command: CliCommand;
     readonly written?: readonly string[];
     readonly error?: string;
     readonly defoldVersion?: string;
     readonly apiSurface?: string | null;
-    readonly scriptKind?: string | null;
     readonly materializedSurface?: string | null;
+    readonly directoryWalls?: readonly {
+        readonly dir: string;
+        readonly kind: string;
+    }[];
+    readonly eligible?: readonly {
+        readonly dir: string;
+        readonly kind: string;
+    }[];
+    readonly installCommand?: string;
+    readonly manualSteps?: readonly string[];
+    readonly actions?: Record<string, string>;
+    readonly addedTo?: string;
+    readonly removedFrom?: readonly string[];
+    readonly bootPath?: readonly string[];
+    readonly subcommand?: string;
+    readonly exitCode?: number;
 }
 export declare function renderResult(input: RenderResultInput): string;
+export type WatchEventName = "build" | "rebuild";
+export interface RenderWatchEventInput {
+    readonly event: WatchEventName;
+    readonly written?: readonly string[];
+    readonly changed?: readonly string[];
+    readonly removed?: readonly string[];
+    readonly error?: string;
+}
+export declare function renderWatchEvent(input: RenderWatchEventInput): string;

package/dist/materialize.d.ts

@@ -1,11 +1,9 @@
 import { type RegistryTarget } from "./api-registry";
 import type { SelectedApiSurface } from "./api-surface";
-import { type ScriptKind } from "./script-kind";
 export interface MaterializeApiSurfaceOptions {
     readonly cwd: string;
     readonly surface: SelectedApiSurface;
     readonly sourceGeneratedDir: string | null;
-    readonly scriptKind?: ScriptKind | null;
 }
 export interface MaterializeApiSurfaceResult {
     readonly materializedDir: string | null;
@@ -23,7 +21,6 @@ export interface MaterializeRefDocSurfaceOptions {
     readonly cwd: string;
     readonly surfaceId: string;
     readonly resolveOpts?: RefDocResolveOptions;
-    readonly scriptKind?: ScriptKind | null;
     readonly registry?: readonly RegistryTarget[];
 }
 export declare function materializeRefDocSurface(opts: MaterializeRefDocSurfaceOptions): Promise<MaterializeApiSurfaceResult>;

package/dist/mise-scaffold.d.ts

@@ -1,2 +1,2 @@
-export declare const MISE_TASKS_TOML = "# managed by @defold-typescript\n[tasks.\"defold-typescript:build\"]\ndescription = \"Build the TypeScript sources with the installed defold-typescript CLI\"\nrun = \"bunx --no-install defold-typescript build\"\n\n# managed by @defold-typescript\n[tasks.\"defold-typescript:watch\"]\ndescription = \"Watch and rebuild the TypeScript sources with the installed defold-typescript CLI\"\nrun = \"bunx --no-install defold-typescript watch\"\n\n# managed by @defold-typescript\n[tasks.\"defold-typescript:upgrade\"]\ndescription = \"Upgrade the defold-typescript CLI to its latest release and re-pin the types dependency\"\nrun = [\"bunx @defold-typescript/cli@latest init --force\", \"bun install\"]\n";
+export declare const MISE_TASKS_TOML = "# managed by @defold-typescript\n[tasks.\"defold-typescript:build\"]\ndescription = \"Build the TypeScript sources with the defold-typescript CLI\"\nrun = \"bunx @defold-typescript/cli build\"\n\n# managed by @defold-typescript\n[tasks.\"defold-typescript:watch\"]\ndescription = \"Watch and rebuild the TypeScript sources with the defold-typescript CLI\"\nrun = \"bunx @defold-typescript/cli watch\"\n\n# managed by @defold-typescript\n[tasks.\"defold-typescript:setup-debug\"]\ndescription = \"Wire the lldebugger game.project dependency and entry-script bootstrap with the defold-typescript CLI\"\nrun = \"bunx @defold-typescript/cli setup-debug\"\n\n# managed by @defold-typescript\n[tasks.\"defold-typescript:upgrade\"]\ndescription = \"Upgrade the defold-typescript CLI to its latest release and re-pin the types dependency\"\nrun = [\"bunx @defold-typescript/cli@latest init --force --suppress-install-reminder\", \"bun install\"]\n";
 export declare function mergeMiseToml(existing?: string): string;

package/dist/scan.d.ts

@@ -1 +1,2 @@
+export declare function normalizeScannedPath(rel: string): string;
 export declare function scanFilesSync(cwd: string, pattern: string): string[];

package/dist/script-kind.d.ts

@@ -3,6 +3,7 @@ export declare const DEFAULT_TYPES_ENTRYPOINT = "@defold-typescript/types";
 export declare function isSkipped(relPath: string): boolean;
 export declare function isComponentPath(relPath: string): boolean;
 export declare function detectScriptKinds(cwd: string): Set<ScriptKind>;
+export declare function groupScriptKindsByDirectory(cwd: string): Map<string, Set<ScriptKind>>;
+export declare function selectDirectoryWalls(cwd: string): Map<string, ScriptKind>;
 export declare function selectScriptKind(kinds: Set<ScriptKind>): ScriptKind | null;
 export declare function selectScriptKindEntrypoint(kinds: Set<ScriptKind>): string;
-export declare function excludedModulesForKind(kind: ScriptKind | null): Set<string>;

package/dist/setup-debug.d.ts

@@ -0,0 +1,40 @@
+export declare const LLDEBUGGER_URL = "https://github.com/defold-typescript/toolchain/releases/download/lldebugger-v1/lldebugger.zip";
+export declare const LEGACY_BOOTSTRAP_MARKER = "// lldebugger-bootstrap: debug entry, inert in release builds";
+export declare const AMBIENT_DTS_REL = "src/lldebugger.debug.d.ts";
+export declare const AMBIENT_DECLARATION = "/** @noResolution */\ndeclare module \"lldebugger.debug\" {\n  export function start(): void;\n}\n";
+export declare const BLOCK_BEGIN = "// defold-typescript:setup-debug BEGIN \u2014 managed block, do not edit";
+export declare const BLOCK_END = "// defold-typescript:setup-debug END";
+export declare function addLldebuggerDependency(gameProjectText: string): string;
+export type FileAction = "injected" | "refreshed" | "unchanged" | "removed";
+export interface UpsertResult {
+    readonly text: string;
+    readonly action: FileAction;
+}
+export declare function upsertManagedBlock(source: string): UpsertResult;
+export declare function injectDebugBootstrap(source: string): string;
+export interface StripResult {
+    readonly text: string;
+    readonly removed: boolean;
+}
+export declare function stripManagedBlock(source: string): StripResult;
+type ProjectScanner = (cwd: string, pattern: string) => string[];
+export declare function findEntryScriptCandidates(cwd: string, scanner?: ProjectScanner): string[];
+export interface SetupDebugOptions {
+    readonly cwd: string;
+    readonly script?: string;
+    readonly json?: boolean;
+    readonly chooseScript?: (candidates: string[]) => Promise<string>;
+    readonly scanFiles?: ProjectScanner;
+}
+export interface SetupDebugResult {
+    readonly ok: boolean;
+    readonly written: string[];
+    readonly actions: Record<string, FileAction>;
+    readonly manualSteps: readonly string[];
+    readonly error?: string;
+    readonly addedTo?: string;
+    readonly removedFrom?: string[];
+    readonly bootPath?: string[];
+}
+export declare function runSetupDebug(opts: SetupDebugOptions): Promise<SetupDebugResult>;
+export {};

package/dist/wall-interactive.d.ts

@@ -0,0 +1,16 @@
+import type { DirectoryWall } from "./directory-walls";
+export interface WallChoice {
+    readonly value: string;
+    readonly name: string;
+    readonly checked?: boolean;
+    readonly disabled?: string | false;
+}
+export type CheckboxPrompt = (opts: {
+    message: string;
+    choices: WallChoice[];
+}) => Promise<string[]>;
+export interface WallInteractiveDeps {
+    readonly checkbox?: CheckboxPrompt;
+}
+export declare function buildWallChoices(cwd: string): WallChoice[];
+export declare function runWallInteractive(cwd: string, deps?: WallInteractiveDeps): Promise<DirectoryWall[]>;

package/dist/wall.d.ts

@@ -0,0 +1,4 @@
+import { type DirectoryWall } from "./directory-walls";
+export declare function currentWalledDirs(cwd: string): string[];
+export declare function eligibleWalls(cwd: string): DirectoryWall[];
+export declare function applyWallSelection(cwd: string, desiredDirs: readonly string[]): DirectoryWall[];

package/dist/watch.d.ts

@@ -14,6 +14,7 @@ export interface RunWatchOptions {
     readonly watcherFactory?: WatcherFactory;
     readonly syncSurface?: () => void;
     readonly componentWatcherFactory?: WatcherFactory;
+    readonly json?: boolean;
 }
 export interface RunWatchHandle {
     readonly stop: () => void;

package/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@defold-typescript/cli",
-  "version": "0.5.5",
+  "version": "0.7.0",
   "description": "End-user CLI for scaffolding and building Defold projects written in TypeScript.",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/defold-typescript/toolchain.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/defold-typescript/toolchain#readme",
+  "bugs": "https://github.com/defold-typescript/toolchain/issues",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -31,7 +38,8 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@defold-typescript/transpiler": "0.5.5",
-    "@defold-typescript/types": "0.5.5"
+    "@defold-typescript/transpiler": "0.7.0",
+    "@defold-typescript/types": "0.7.0",
+    "@inquirer/prompts": "^7.0.0"
   }
 }

package/src/bob-command.ts

@@ -0,0 +1,137 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { delimiter, dirname, join } from "node:path";
+import { bobCacheDir, bobDownloadUrl, resolveBobJar, resolveJava } from "./bob";
+import { ENGINE_INFO_URL } from "./debug-launcher";
+
+export const DEFOLD_SUBCOMMANDS = ["resolve", "build", "bundle"] as const;
+export type DefoldSubcommand = (typeof DEFOLD_SUBCOMMANDS)[number];
+
+export function isDefoldSubcommand(value: string | undefined): value is DefoldSubcommand {
+  return value !== undefined && (DEFOLD_SUBCOMMANDS as readonly string[]).includes(value);
+}
+
+// bob takes options before the trailing command verb. `build` uses the debug
+// variant so output lands in `build/default`, matching the engine the debug
+// launcher runs.
+export function composeBobArgv(opts: {
+  java: string;
+  jar: string;
+  subcommand: string;
+  buildServer?: string;
+}): string[] {
+  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.`,
+      );
+  }
+}
+
+export interface DefoldIo {
+  readonly cacheDir: string;
+  readonly fetchSha: () => Promise<string>;
+  readonly probe: (candidate: string) => boolean;
+  readonly javaProbe: (cmd: string) => boolean;
+  readonly spawn: (argv: string[], cwd: string) => Promise<number>;
+  readonly download: (url: string, dest: string) => Promise<void>;
+}
+
+export interface DefoldCommandResult {
+  readonly ok: boolean;
+  readonly subcommand: string;
+  readonly exitCode: number;
+  readonly argv: string[];
+}
+
+export async function runDefoldCommand(opts: {
+  cwd: string;
+  subcommand: string;
+  java?: string;
+  buildServer?: string;
+  io: DefoldIo;
+}): Promise<DefoldCommandResult> {
+  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(): Promise<string> {
+  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()) as { sha1?: string };
+  if (!info.sha1) {
+    throw new Error(`defold-typescript: ${ENGINE_INFO_URL} returned no sha1.`);
+  }
+  return info.sha1;
+}
+
+function javaOnPath(cmd: string, env: NodeJS.ProcessEnv = process.env): boolean {
+  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 (existsSync(join(dir, cmd + ext))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+async function spawnInherit(argv: string[], cwd: string): Promise<number> {
+  const proc = Bun.spawn(argv, { cwd, stdio: ["inherit", "inherit", "inherit"] });
+  return proc.exited;
+}
+
+async function downloadTo(url: string, dest: string): Promise<void> {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(
+      `defold-typescript: bob.jar download failed (${url} -> ${res.status} ${res.statusText}).`,
+    );
+  }
+  mkdirSync(dirname(dest), { recursive: true });
+  await Bun.write(dest, res);
+}
+
+export function defaultDefoldIo(): DefoldIo {
+  return {
+    cacheDir: bobCacheDir(),
+    fetchSha: fetchStableSha,
+    probe: existsSync,
+    javaProbe: (cmd) => javaOnPath(cmd),
+    spawn: spawnInherit,
+    download: downloadTo,
+  };
+}

package/src/bob.ts

@@ -0,0 +1,59 @@
+import { homedir } from "node:os";
+import * as path from "node:path";
+import { ENGINE_ARCHIVE_BASE } from "./debug-launcher";
+
+// bob is Defold's headless build tool. It downloads version-matched from the
+// same archive the engine launcher uses, keyed by the stable-channel sha that
+// `debug-launcher.ts` already resolves from `ENGINE_INFO_URL`.
+export function bobDownloadUrl(sha1: string): string {
+  return `${ENGINE_ARCHIVE_BASE}/${sha1}/bob/bob.jar`;
+}
+
+// Mirrors `refDocCacheDir`: a `DEFOLD_TYPESCRIPT_CACHE` override wins, else the
+// XDG cache home, else `~/.cache`. The jar lives outside the repo, so it is
+// never committed.
+export function bobCacheDir(
+  env: NodeJS.ProcessEnv = process.env,
+  home: () => string = homedir,
+): string {
+  if (env.DEFOLD_TYPESCRIPT_CACHE) {
+    return path.join(env.DEFOLD_TYPESCRIPT_CACHE, "bob");
+  }
+  return path.join(env.XDG_CACHE_HOME ?? path.join(home(), ".cache"), "defold-typescript", "bob");
+}
+
+export function bobCachePath(opts: { sha1: string; cacheDir: string }): string {
+  return path.join(opts.cacheDir, opts.sha1, "bob.jar");
+}
+
+export interface ResolvedBobJar {
+  readonly jarPath: string;
+  readonly cached: boolean;
+}
+
+// Returns the sha-keyed cache path and whether it already exists. `cached`
+// false means the caller must download `bobDownloadUrl(sha1)` to `jarPath` —
+// this module performs no network or filesystem writes.
+export function resolveBobJar(opts: {
+  sha1: string;
+  cacheDir: string;
+  probe: (candidate: string) => boolean;
+}): ResolvedBobJar {
+  const jarPath = bobCachePath({ sha1: opts.sha1, cacheDir: opts.cacheDir });
+  return { jarPath, cached: opts.probe(jarPath) };
+}
+
+// override -> `java` on PATH -> clear error. `probe` is injectable so callers
+// (and tests) decide what "found on PATH" means without spawning.
+export function resolveJava(opts: { override?: string; probe: (cmd: string) => boolean }): string {
+  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.",
+  );
+}

package/src/boot-path.ts

@@ -0,0 +1,113 @@
+import { existsSync, readFileSync } from "node:fs";
+import * as path from "node:path";
+
+export interface BootPathCandidate {
+  readonly candidate: string;
+  readonly trace: string[];
+}
+
+// `game.project` is a flat INI the engine writes itself; mirror the no-parser
+// line idiom `addLldebuggerDependency` uses rather than adding a TOML dep.
+const MAIN_COLLECTION_RE = /^main_collection\s*=\s*(.+)$/m;
+
+// Both `.collection` files store component/collection references two ways: as a
+// bare `component: "/path"` line and, inside an embedded `data:` string, as an
+// escaped `component: \"/path\"`. The optional `\\?` before each quote matches
+// both forms with one expression.
+const COMPONENT_RE = /component:\s*\\?"([^"\\]+)\\?"/;
+const COLLECTION_RE = /collection:\s*\\?"([^"\\]+\.collectionc?)\\?"/;
+
+// A top-level (unescaped) instance id; the escaped `\"id\"` lines inside a
+// `data:` string start with a quote and never match `^\s*id:`.
+const TOP_LEVEL_ID_RE = /^\s*id:\s*"([^"\\]+)"\s*$/;
+
+const TS_SCRIPT_SUFFIX = ".ts.script";
+
+function projectPathToAbs(cwd: string, projectPath: string): string {
+  return path.join(cwd, projectPath.replace(/^\//, ""));
+}
+
+function relPosix(cwd: string, abs: string): string {
+  return path.relative(cwd, abs).split(path.sep).join("/");
+}
+
+// Walk the Defold boot path from `game.project`'s `main_collection`, collecting
+// every reachable `.ts.script` component (mapped back to its source `.ts`) with
+// the collection/instance chain that led to it. Never throws: a missing file or
+// absent `[bootstrap]` yields an empty result; a `collection:` ref cycle is cut
+// by the visited set.
+export function resolveBootPathScripts(cwd: string): BootPathCandidate[] {
+  const gameProjectPath = path.join(cwd, "game.project");
+  if (!existsSync(gameProjectPath)) {
+    return [];
+  }
+
+  let gameProject: string;
+  try {
+    gameProject = readFileSync(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: BootPathCandidate[] = [];
+  const visited = new Set<string>();
+
+  const walk = (collectionAbs: string, tracePrefix: string[]): void => {
+    if (visited.has(collectionAbs)) {
+      return;
+    }
+    visited.add(collectionAbs);
+    if (!existsSync(collectionAbs)) {
+      return;
+    }
+
+    let content: string;
+    try {
+      content = readFileSync(collectionAbs, "utf8");
+    } catch {
+      return;
+    }
+
+    const trace = [...tracePrefix, relPosix(cwd, collectionAbs)];
+    const children: string[] = [];
+    let currentId: string | null = null;
+
+    for (const line of content.split("\n")) {
+      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;
+}

package/src/build-output.ts

@@ -1,6 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import * as path from "node:path";
 import type { TranspileDiagnostic } from "@defold-typescript/transpiler";
+import type { ScriptKind } from "./script-kind";
 
 export interface BuildConfig {
   readonly outDir: string | undefined;
@@ -54,10 +55,42 @@ function stripIncludeBase(pattern: string): string {
   return lastSlash === -1 ? "" : upToWildcard.slice(0, lastSlash + 1);
 }
 
-export function computeScriptRel(rel: string, config: BuildConfig): string {
+const SCRIPT_SUFFIX_BY_KIND: Record<ScriptKind, string> = {
+  script: ".ts.script",
+  "gui-script": ".ts.gui_script",
+  "render-script": ".ts.render_script",
+};
+
+export type SourceOutputKind = ScriptKind | "module";
+
+// A `.ts` source carries no Defold component kind of its own; the lifecycle
+// factory it calls is the signal. The call is matched (trailing `(`) so a bare
+// import of all three factories does not decide the kind. Precedence
+// render > gui > script; a source using no factory emits as a Lua module.
+const FACTORY_KINDS: ReadonlyArray<readonly [ScriptKind, RegExp]> = [
+  ["render-script", /\bdefineRenderScript\s*\(/],
+  ["gui-script", /\bdefineGuiScript\s*\(/],
+  ["script", /\bdefineScript\s*\(/],
+];
+
+export function detectSourceOutputKind(source: string): SourceOutputKind {
+  for (const [kind, re] of FACTORY_KINDS) {
+    if (re.test(source)) {
+      return kind;
+    }
+  }
+  return "module";
+}
+
+export function detectSourceScriptKind(source: string): ScriptKind {
+  const kind = detectSourceOutputKind(source);
+  return kind === "module" ? "script" : kind;
+}
+
+function relUnderOutDir(rel: string, config: BuildConfig): string {
   const { outDir, include } = config;
   if (outDir === undefined || outDir === "" || outDir === ".") {
-    return rel.replace(/\.ts$/, ".ts.script");
+    return rel;
   }
   const includeBase =
     include
@@ -65,7 +98,33 @@ export function computeScriptRel(rel: string, config: BuildConfig): string {
       .filter((base) => rel.startsWith(base))
       .sort((a, b) => b.length - a.length)[0] ?? "";
   const relUnderBase = rel.slice(includeBase.length);
-  return path.posix.join(outDir, relUnderBase.replace(/\.ts$/, ".ts.script"));
+  return path.posix.join(outDir, relUnderBase);
+}
+
+export function computeOutputRel(rel: string, config: BuildConfig, kind: SourceOutputKind): string {
+  const baseRel = relUnderOutDir(rel, config);
+  if (kind === "module") {
+    return baseRel.replace(/\.ts$/, ".lua");
+  }
+  return baseRel.replace(/\.ts$/, SCRIPT_SUFFIX_BY_KIND[kind]);
+}
+
+export function computeScriptRel(
+  rel: string,
+  config: BuildConfig,
+  kind: ScriptKind = "script",
+): string {
+  return computeOutputRel(rel, config, kind);
+}
+
+export function outputRelsForSource(rel: string, config: BuildConfig): string[] {
+  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`]);
 }
 
 export function collectFailures(
@@ -73,6 +132,11 @@ export function collectFailures(
 ): Map<string, string[]> {
   const failures = new Map<string, string[]>();
   for (const diag of diagnostics) {
+    // Advisory diagnostics (e.g. the deprecated direct `go.property` call) warn
+    // but never fail the build — the call still registers at runtime.
+    if (diag.category === "warning") {
+      continue;
+    }
     const bucket = diag.file ?? PROJECT_BUCKET;
     const list = failures.get(bucket);
     if (list) {