@defold-typescript/cli 0.5.4 → 0.6.0

package/src/json-output.ts

@@ -1,4 +1,4 @@
-export type CliCommand = "init" | "build";
+export type CliCommand = "init" | "build" | "setup-debug" | "defold" | "wall";
 
 export interface RenderResultInput {
   readonly command: CliCommand;
@@ -6,8 +6,17 @@ export interface RenderResultInput {
   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 function renderResult(input: RenderResultInput): string {
@@ -19,11 +28,47 @@ export function renderResult(input: RenderResultInput): string {
     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 =
+  const withMaterialized =
     "materializedSurface" in input
-      ? { ...withScriptKind, materializedSurface: input.materializedSurface }
-      : withScriptKind;
+      ? { ...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)}\n`;
 }
+
+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 function renderWatchEvent(input: RenderWatchEventInput): string {
+  const ok = input.error === undefined;
+  const base = ok
+    ? { command: "watch" as const, event: input.event, ok, written: input.written ?? [] }
+    : { command: "watch" as const, 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)}\n`;
+}

package/src/materialize.ts

@@ -14,15 +14,23 @@ import {
   resolveTypesPackageRoot,
 } from "./api-registry";
 import type { SelectedApiSurface } from "./api-surface";
-import { excludedModulesForKind, type ScriptKind } from "./script-kind";
 
 const MATERIALIZED_ROOT = ".defold-types";
 
+// The materialized surface must not mint its own copy of the branded engine
+// primitives: `Hash` & co. are `unique symbol`-branded per declaration, so a
+// copied `core-types.d.ts` is nominally distinct from the installed
+// `@defold-typescript/types` a consumer imports from, and the two never unify
+// (a consumer comparing `message_id === hash(...)` or assigning an imported
+// `Hash` would get TS2367/TS2741). Re-export the package's copy instead so the
+// ambient surface shares one brand. `engine-globals.d.ts` stays copied; its
+// relative `./core-types` import resolves to this re-export.
+const CORE_TYPES_REEXPORT = 'export * from "@defold-typescript/types/core-types";\n';
+
 export interface MaterializeApiSurfaceOptions {
   readonly cwd: string;
   readonly surface: SelectedApiSurface;
   readonly sourceGeneratedDir: string | null;
-  readonly scriptKind?: ScriptKind | null;
 }
 
 export interface MaterializeApiSurfaceResult {
@@ -53,10 +61,7 @@ export function materializeApiSurface(
   const absDir = path.join(cwd, MATERIALIZED_ROOT, surfaceId);
   mkdirSync(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 sources = listDts(sourceGeneratedDir).filter((file) => file !== "index.d.ts");
 
   // The `*-overloads` augmentations and the `core-types` they import live in the
   // types package `src/` (sibling of `generated/`), not among the generated
@@ -97,7 +102,7 @@ export function materializeApiSurface(
     );
   }
   if (includeCoreTypes) {
-    writeFileSync(path.join(absDir, "core-types.d.ts"), readFileSync(coreTypesSrc, "utf8"));
+    writeFileSync(path.join(absDir, "core-types.d.ts"), CORE_TYPES_REEXPORT);
   }
   if (includeEngineGlobals) {
     writeFileSync(path.join(absDir, "engine-globals.d.ts"), readFileSync(engineGlobalsSrc, "utf8"));
@@ -194,10 +199,9 @@ export interface MaterializeRefDocSurfaceOptions {
   readonly cwd: string;
   readonly surfaceId: string;
   readonly resolveOpts?: RefDocResolveOptions;
-  readonly scriptKind?: ScriptKind | null;
   // Registry override (defaults to the installed types package's
   // api-targets.json). Injected only by tests that need a multi-module ref-doc
-  // target to observe kind narrowing.
+  // target.
   readonly registry?: readonly RegistryTarget[];
 }
 
@@ -221,7 +225,6 @@ export async function materializeRefDocSurface(
   if (target?.source?.kind !== "ref-doc") {
     return { materializedDir: null, active: null };
   }
-  const excludeModules = [...excludedModulesForKind(opts.scriptKind ?? null)];
 
   const relDir = path.posix.join(MATERIALIZED_ROOT, surfaceId);
   const absDir = path.join(cwd, MATERIALIZED_ROOT, surfaceId);
@@ -233,9 +236,8 @@ export async function materializeRefDocSurface(
     await mod.materializeVersionedSurface(selfContained, {
       destDir: absDir,
       ...(resolveOpts ? { resolveOpts } : {}),
-      ...(excludeModules.length > 0 ? { excludeModules } : {}),
     });
-    copyFileSync(path.join(root, "src", "core-types.ts"), path.join(absDir, "core-types.d.ts"));
+    writeFileSync(path.join(absDir, "core-types.d.ts"), CORE_TYPES_REEXPORT);
     copyFileSync(
       path.join(root, "src", "engine-globals.d.ts"),
       path.join(absDir, "engine-globals.d.ts"),

package/src/mise-scaffold.ts

@@ -4,25 +4,31 @@
 // the block without disturbing user-authored `[tools]`/`[tasks.*]` content.
 const MANAGED_MARKER = "# managed by @defold-typescript";
 
-// `bunx --no-install` resolves only the locally installed binary and never
-// fetches from the registry — that is the installed-version contract the types
-// pin upholds, while staying cross-platform (the bare `node_modules/.bin` path
-// is `.cmd`-shimmed on Windows). `:upgrade` is the deliberate `@latest` pull
-// that re-pins `@defold-typescript/types` via `init --force` + reinstall.
+// Build/watch/setup-debug run `bunx @defold-typescript/cli <cmd>`: inside an
+// installed project bunx resolves the `@defold-typescript/cli` pinned in
+// `SCAFFOLD_DEV_DEPS`, so the task runs the version locked alongside
+// `@defold-typescript/types`. `:upgrade` is the deliberate `@latest` pull that
+// re-pins `@defold-typescript/types` via `init --force` + reinstall; it
+// suppresses the install reminder because its second command already reinstalls.
 export const 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"]
 `;
 
 // Drop every managed block (marker line through the next blank line or EOF),

package/src/scan.ts

@@ -1,10 +1,16 @@
 import { globSync, statSync } from "node:fs";
 import * as path from "node:path";
 
+export function normalizeScannedPath(rel: string): string {
+  return rel.split(/[/\\]/).join("/");
+}
+
 // `Bun.Glob` is undefined when the published bin runs under plain node, so the
 // scaffold/build path must use the cross-runtime `node:fs` glob instead. Bun's
 // `globSync` does not support `withFileTypes`, so directories are filtered out
 // with a stat to preserve the original `onlyFiles` contract.
 export function scanFilesSync(cwd: string, pattern: string): string[] {
-  return globSync(pattern, { cwd }).filter((rel) => statSync(path.join(cwd, rel)).isFile());
+  return globSync(pattern, { cwd })
+    .map(normalizeScannedPath)
+    .filter((rel) => statSync(path.join(cwd, rel)).isFile());
 }

package/src/script-kind.ts

@@ -1,3 +1,4 @@
+import * as path from "node:path";
 import { scanFilesSync } from "./scan";
 
 export type ScriptKind = "script" | "gui-script" | "render-script";
@@ -45,6 +46,36 @@ export function detectScriptKinds(cwd: string): Set<ScriptKind> {
   return kinds;
 }
 
+export function groupScriptKindsByDirectory(cwd: string): Map<string, Set<ScriptKind>> {
+  const byDir = new Map<string, Set<ScriptKind>>();
+  for (const [ext, kind] of Object.entries(KIND_BY_EXT)) {
+    for (const match of scanFilesSync(cwd, `**/*${ext}`)) {
+      if (isSkipped(match) || isGeneratedScript(match)) {
+        continue;
+      }
+      const dir = path.posix.dirname(match.split(path.sep).join("/"));
+      let set = byDir.get(dir);
+      if (set === undefined) {
+        set = new Set<ScriptKind>();
+        byDir.set(dir, set);
+      }
+      set.add(kind);
+    }
+  }
+  return byDir;
+}
+
+export function selectDirectoryWalls(cwd: string): Map<string, ScriptKind> {
+  const walls = new Map<string, ScriptKind>();
+  for (const [dir, kinds] of groupScriptKindsByDirectory(cwd)) {
+    const kind = selectScriptKind(kinds);
+    if (kind !== null) {
+      walls.set(dir, kind);
+    }
+  }
+  return walls;
+}
+
 export function selectScriptKind(kinds: Set<ScriptKind>): ScriptKind | null {
   if (kinds.size !== 1) {
     return null;
@@ -59,22 +90,3 @@ export function selectScriptKindEntrypoint(kinds: Set<ScriptKind>): string {
   const kind = selectScriptKind(kinds);
   return kind === null ? DEFAULT_TYPES_ENTRYPOINT : `${DEFAULT_TYPES_ENTRYPOINT}/${kind}`;
 }
-
-// The one restricted namespace each kind allows; mirrors `regen.ts`'s
-// RESTRICTED_NAMESPACES (gui -> gui_script, render -> render_script). `script`
-// allows neither.
-const RESTRICTED_MODULES: Record<ScriptKind, string> = {
-  script: "",
-  "gui-script": "gui",
-  "render-script": "render",
-};
-
-const ALL_RESTRICTED_MODULES: readonly string[] = ["gui", "render"];
-
-export function excludedModulesForKind(kind: ScriptKind | null): Set<string> {
-  if (kind === null) {
-    return new Set();
-  }
-  const allowed = RESTRICTED_MODULES[kind];
-  return new Set(ALL_RESTRICTED_MODULES.filter((mod) => mod !== allowed));
-}