@defold-typescript/tstl-plugin 0.24.0 → 0.25.0

package/dist/build-config.d.ts

@@ -0,0 +1,3 @@
+import { type BuildConfig } from "@defold-typescript/transpiler";
+import type { SceneReadHost } from "./scene-documents";
+export declare function readBuildConfigFromHost(host: SceneReadHost, projectRoot: string): BuildConfig;

package/dist/index.js

@@ -1,5 +1,472 @@
 // src/index.ts
-import { getProgramDiagnostics } from "@defold-typescript/transpiler";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import {
+  buildConfigKeyIndex as buildConfigKeyIndex2,
+  buildGuiNodeIndex as buildGuiNodeIndex2,
+  buildInputActionIndex as buildInputActionIndex2,
+  buildSceneComponentIndex as buildSceneComponentIndex2,
+  buildSceneObjectPathIndex as buildSceneObjectPathIndex2,
+  buildSpriteAnimationIndex as buildSpriteAnimationIndex2,
+  componentIdOfSameObjectAddress as componentIdOfSameObjectAddress2,
+  computeOutputRel as computeOutputRel2,
+  getProgramDiagnostics,
+  isAddressClass as isAddressClass2,
+  isFragmentCaret as isFragmentCaret2,
+  resolveClassifiedSlotAtPosition
+} from "@defold-typescript/transpiler";
+
+// src/build-config.ts
+import { DEFAULT_INCLUDE, parseBuildConfig } from "@defold-typescript/transpiler";
+var ALONGSIDE = { outDir: undefined, include: DEFAULT_INCLUDE };
+function readBuildConfigFromHost(host, projectRoot) {
+  const root = projectRoot.replace(/\\/g, "/").replace(/\/+$/, "");
+  const text = host.readFile(`${root}/tsconfig.json`);
+  if (text === undefined) {
+    return ALONGSIDE;
+  }
+  try {
+    return parseBuildConfig(text);
+  } catch {
+    return ALONGSIDE;
+  }
+}
+
+// src/scene-completions.ts
+var CONTRIBUTED_ENTRY_KIND = "string";
+function keyAboveAll(baseEntries) {
+  return `${baseEntries.reduce((greatest, base) => base.sortText > greatest ? base.sortText : greatest, "zz")}0`;
+}
+var DEFOLD_COMPLETION_SOURCE = "defold-typescript/scene";
+function entriesFor(ids, offeredName, baseEntries, replacementSpan) {
+  const offered = new Set(baseEntries.map((base) => base.name));
+  const sortText = keyAboveAll(baseEntries);
+  return [...ids].sort().filter((id) => !offered.has(offeredName(id))).map((id) => ({
+    name: id,
+    kind: CONTRIBUTED_ENTRY_KIND,
+    kindModifiers: "",
+    sortText,
+    replacementSpan,
+    source: DEFOLD_COMPLETION_SOURCE
+  }));
+}
+function buildSceneCompletionEntries(input) {
+  const { slot, ids, baseEntries } = input;
+  if (slot.fragmentStart === -1)
+    return [];
+  const fragmentOffset = slot.fragmentStart - slot.textStart;
+  const prefix = slot.text.slice(0, fragmentOffset);
+  return entriesFor(ids, (id) => `${prefix}${id}`, baseEntries, {
+    start: slot.fragmentStart,
+    length: slot.text.length - fragmentOffset
+  });
+}
+function buildAddressPathCompletionEntries(input) {
+  const { slot, paths, baseEntries } = input;
+  const length = slot.fragmentStart === -1 ? slot.text.length : slot.fragmentStart - slot.textStart - 1;
+  const suffix = slot.text.slice(length);
+  return entriesFor(paths, (path) => `${path}${suffix}`, baseEntries, {
+    start: slot.textStart,
+    length
+  });
+}
+function buildWholeLiteralCompletionEntries(input) {
+  const { slot, ids, baseEntries } = input;
+  return entriesFor(ids, (id) => id, baseEntries, {
+    start: slot.textStart,
+    length: slot.text.length
+  });
+}
+
+// src/scene-documents.ts
+import { isDefignoredPath } from "@defold-typescript/transpiler";
+var SCENE_EXTENSIONS = [".go", ".collection"];
+var GUI_EXTENSIONS = [".gui"];
+var INPUT_BINDING_EXTENSIONS = [".input_binding"];
+var ANIMATION_ASSET_EXTENSIONS = [".atlas", ".tilesource", ".sprite"];
+var PROJECT_EXTENSIONS = [".project"];
+var GAME_PROJECT_DOCUMENT = "game.project";
+function displayPathOf(projectRoot, filePath) {
+  const path = filePath.replace(/\\/g, "/");
+  const root = projectRoot.replace(/\\/g, "/").replace(/\/+$/, "");
+  return path.startsWith(`${root}/`) ? path.slice(root.length + 1) : path;
+}
+function isBuildOutput(displayPath) {
+  return displayPath.split("/").includes("build");
+}
+function isExcludedProjectPath(displayPath) {
+  return isBuildOutput(displayPath) || isDefignoredPath(displayPath);
+}
+function readSceneDocuments(host, projectRoot, extensions = SCENE_EXTENSIONS) {
+  const documents = new Map;
+  const unreadable = [];
+  const paths = [];
+  if (!host.readDirectory) {
+    unreadable.push("the editor host cannot enumerate project files, so no scene source was read");
+    return { documents, unreadable, paths };
+  }
+  for (const filePath of host.readDirectory(projectRoot, extensions)) {
+    const displayPath = displayPathOf(projectRoot, filePath);
+    if (isExcludedProjectPath(displayPath))
+      continue;
+    const text = host.readFile(filePath);
+    if (text === undefined) {
+      unreadable.push(`${displayPath}: could not be read`);
+      continue;
+    }
+    documents.set(displayPath, text);
+    paths.push(filePath);
+  }
+  return { documents, unreadable, paths };
+}
+function listProjectResourcePaths(host, projectRoot, extensions) {
+  if (!host.readDirectory)
+    return new Set;
+  const paths = [];
+  for (const filePath of host.readDirectory(projectRoot, extensions)) {
+    const displayPath = displayPathOf(projectRoot, filePath);
+    if (isExcludedProjectPath(displayPath))
+      continue;
+    if (!extensions.some((extension) => displayPath.endsWith(extension)))
+      continue;
+    paths.push(`/${displayPath}`);
+  }
+  return new Set(paths.sort());
+}
+
+// src/scene-index-cache.ts
+function cacheKey(extensions) {
+  return [...extensions].sort().join("|");
+}
+function createSceneIndexCache(host, projectRoot) {
+  const watchDirectory = host.watchDirectory;
+  const watchFile = host.watchFile;
+  const enabled = typeof watchDirectory === "function" && typeof watchFile === "function";
+  const documentCache = new Map;
+  const resourceCache = new Map;
+  const derivedCache = new Map;
+  const fileWatchers = new Map;
+  const servedExtensions = new Set;
+  let directoryWatcher;
+  let disposed = false;
+  function closeFileWatchers() {
+    for (const watcher of fileWatchers.values())
+      watcher.close();
+    fileWatchers.clear();
+  }
+  function invalidate() {
+    documentCache.clear();
+    resourceCache.clear();
+    derivedCache.clear();
+    closeFileWatchers();
+  }
+  function affectsCache(hostPath) {
+    const displayPath = displayPathOf(projectRoot, hostPath);
+    if (isExcludedProjectPath(displayPath))
+      return false;
+    for (const extension of servedExtensions) {
+      if (displayPath.endsWith(extension))
+        return true;
+    }
+    return false;
+  }
+  function onEvent(hostPath) {
+    if (disposed)
+      return;
+    if (affectsCache(hostPath))
+      invalidate();
+  }
+  function active() {
+    if (!enabled || disposed)
+      return false;
+    if (!directoryWatcher && watchDirectory) {
+      directoryWatcher = watchDirectory(projectRoot, onEvent, true);
+    }
+    return true;
+  }
+  function serve(extensions) {
+    for (const extension of extensions)
+      servedExtensions.add(extension);
+  }
+  function watchReadFiles(paths) {
+    if (!watchFile)
+      return;
+    for (const path of paths) {
+      if (fileWatchers.has(path))
+        continue;
+      fileWatchers.set(path, watchFile(path, (fileName) => onEvent(fileName)));
+    }
+  }
+  return {
+    host,
+    projectRoot,
+    documents(extensions = SCENE_EXTENSIONS) {
+      if (!active())
+        return readSceneDocuments(host, projectRoot, extensions);
+      const key = cacheKey(extensions);
+      const cached = documentCache.get(key);
+      if (cached)
+        return cached;
+      const result = readSceneDocuments(host, projectRoot, extensions);
+      documentCache.set(key, result);
+      serve(extensions);
+      watchReadFiles(result.paths);
+      return result;
+    },
+    resourcePaths(extensions) {
+      if (!active())
+        return listProjectResourcePaths(host, projectRoot, extensions);
+      const key = cacheKey(extensions);
+      const cached = resourceCache.get(key);
+      if (cached)
+        return cached;
+      const result = listProjectResourcePaths(host, projectRoot, extensions);
+      resourceCache.set(key, result);
+      serve(extensions);
+      return result;
+    },
+    derived(key, compute) {
+      if (!active())
+        return compute();
+      if (derivedCache.has(key))
+        return derivedCache.get(key);
+      const value = compute();
+      derivedCache.set(key, value);
+      return value;
+    },
+    dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      directoryWatcher?.close();
+      directoryWatcher = undefined;
+      closeFileWatchers();
+      documentCache.clear();
+      resourceCache.clear();
+      derivedCache.clear();
+    }
+  };
+}
+
+// src/scene-provenance.ts
+import {
+  buildConfigKeyIndex,
+  buildGuiNodeIndex,
+  buildInputActionIndex,
+  buildSceneComponentIndex,
+  buildSceneObjectPathIndex,
+  buildSpriteAnimationIndex,
+  componentIdOfSameObjectAddress,
+  computeOutputRel,
+  isAddressClass,
+  isFragmentCaret
+} from "@defold-typescript/transpiler";
+var COMPONENT_PROVENANCE = "provenance:component-ids";
+var ACTION_PROVENANCE = "provenance:input-actions";
+var GUI_PROVENANCE = "provenance:gui-nodes";
+var PATH_PROVENANCE = "provenance:object-paths";
+var ANIMATION_PROVENANCE = "provenance:sprite-animations";
+function byDeclaringDocument(documents, idsOf) {
+  const declarers = new Map;
+  for (const [displayPath, text] of documents) {
+    for (const id of idsOf(new Map([[displayPath, text]]))) {
+      const paths = declarers.get(id);
+      if (paths) {
+        paths.push(displayPath);
+      } else {
+        declarers.set(id, [displayPath]);
+      }
+    }
+  }
+  for (const paths of declarers.values())
+    paths.sort();
+  return declarers;
+}
+function byClaimedScript(documents) {
+  const byResource = new Map;
+  for (const [displayPath, text] of documents) {
+    const index = buildGuiNodeIndex(new Map([[displayPath, text]]));
+    for (const [resource, ids] of index.byScriptResource) {
+      let declarers = byResource.get(resource);
+      if (!declarers) {
+        declarers = new Map;
+        byResource.set(resource, declarers);
+      }
+      for (const id of ids) {
+        const paths = declarers.get(id);
+        if (paths) {
+          paths.push(displayPath);
+        } else {
+          declarers.set(id, [displayPath]);
+        }
+      }
+    }
+  }
+  for (const declarers of byResource.values()) {
+    for (const paths of declarers.values())
+      paths.sort();
+  }
+  return byResource;
+}
+function componentProvenance(cache) {
+  return cache.derived(COMPONENT_PROVENANCE, () => byDeclaringDocument(cache.documents().documents, (narrowed) => buildSceneComponentIndex(narrowed).ids));
+}
+function actionProvenance(cache) {
+  return cache.derived(ACTION_PROVENANCE, () => byDeclaringDocument(cache.documents(INPUT_BINDING_EXTENSIONS).documents, (narrowed) => buildInputActionIndex(narrowed)));
+}
+function nodeProvenance(cache, fileName) {
+  const byResource = cache.derived(GUI_PROVENANCE, () => byClaimedScript(cache.documents(GUI_EXTENSIONS).documents));
+  const config = readBuildConfigFromHost(cache.host, cache.projectRoot);
+  const resource = computeOutputRel(displayPathOf(cache.projectRoot, fileName), config, "gui-script");
+  return byResource.get(resource) ?? new Map;
+}
+function pathProvenance(cache) {
+  return cache.derived(PATH_PROVENANCE, () => buildSceneObjectPathIndex(cache.documents().documents).declaredIn);
+}
+function animationProvenance(input) {
+  const { slot, cache, fileName, entryName } = input;
+  const component = componentIdOfSameObjectAddress(slot.addressText ?? "");
+  if (component === undefined)
+    return [];
+  const index = cache.derived(ANIMATION_PROVENANCE, () => buildSpriteAnimationIndex({
+    scenes: cache.documents().documents,
+    assets: cache.documents(ANIMATION_ASSET_EXTENSIONS).documents
+  }));
+  const config = readBuildConfigFromHost(cache.host, cache.projectRoot);
+  const resource = computeOutputRel(displayPathOf(cache.projectRoot, fileName), config, "script");
+  const tileSet = index.tileSetByScriptResource.get(resource)?.get(component);
+  if (tileSet === undefined)
+    return [];
+  return index.byScriptResource.get(resource)?.get(component)?.has(entryName) ? [tileSet] : [];
+}
+function constantProvenance(slot, cache, entryName) {
+  if (slot.class === "config-key") {
+    const text = cache.documents(PROJECT_EXTENSIONS).documents.get(GAME_PROJECT_DOCUMENT);
+    if (text === undefined)
+      return [];
+    const keys = cache.derived("config-keys", () => buildConfigKeyIndex(text));
+    return keys.has(entryName) ? [GAME_PROJECT_DOCUMENT] : [];
+  }
+  const extensions = slot.resourceExtensions;
+  if (extensions === undefined || extensions.length === 0)
+    return [];
+  return cache.resourcePaths(extensions).has(entryName) ? [entryName.replace(/^\//, "")] : [];
+}
+function resolveEntryProvenance(input) {
+  const { slot, position, cache, fileName, entryName } = input;
+  if (isAddressClass(slot.class)) {
+    if (!isFragmentCaret(slot, position)) {
+      return pathProvenance(cache).get(entryName) ?? [];
+    }
+    return componentProvenance(cache).get(entryName) ?? [];
+  }
+  if (slot.class === "gui-node") {
+    return nodeProvenance(cache, fileName).get(entryName) ?? [];
+  }
+  if (slot.class === "action-id") {
+    return actionProvenance(cache).get(entryName) ?? [];
+  }
+  if (slot.class === "animation") {
+    return animationProvenance({ slot, cache, fileName, entryName });
+  }
+  if (slot.class === "config-key" || slot.class === "resource-path") {
+    return constantProvenance(slot, cache, entryName);
+  }
+  return [];
+}
+
+// src/index.ts
+var requireFromHere = createRequire(import.meta.url);
+var urlParameterTable;
+function loadUrlParameterTable() {
+  if (!urlParameterTable) {
+    try {
+      const path = requireFromHere.resolve("@defold-typescript/types/url-parameters.json");
+      urlParameterTable = JSON.parse(readFileSync(path, "utf8"));
+    } catch {
+      return;
+    }
+  }
+  return urlParameterTable;
+}
+function componentEntries(slot, position, cache, baseEntries) {
+  if (!isFragmentCaret2(slot, position)) {
+    return [];
+  }
+  return buildSceneCompletionEntries({
+    slot,
+    ids: cache.derived("component-ids", () => buildSceneComponentIndex2(cache.documents().documents).ids),
+    baseEntries
+  });
+}
+function objectPathEntries(slot, position, cache, baseEntries) {
+  if (isFragmentCaret2(slot, position)) {
+    return [];
+  }
+  return buildAddressPathCompletionEntries({
+    slot,
+    paths: cache.derived("object-paths", () => buildSceneObjectPathIndex2(cache.documents().documents).paths),
+    baseEntries
+  });
+}
+function nodeEntries(slot, cache, fileName, baseEntries) {
+  const { projectRoot } = cache;
+  const index = cache.derived("gui-nodes", () => buildGuiNodeIndex2(cache.documents(GUI_EXTENSIONS).documents));
+  const config = readBuildConfigFromHost(cache.host, projectRoot);
+  const resource = computeOutputRel2(displayPathOf(projectRoot, fileName), config, "gui-script");
+  const ids = index.byScriptResource.get(resource);
+  return ids === undefined ? [] : buildWholeLiteralCompletionEntries({ slot, ids, baseEntries });
+}
+function animationEntries(slot, cache, fileName, baseEntries) {
+  const component = componentIdOfSameObjectAddress2(slot.addressText ?? "");
+  if (component === undefined) {
+    return [];
+  }
+  const { projectRoot } = cache;
+  const index = cache.derived("sprite-animations", () => buildSpriteAnimationIndex2({
+    scenes: cache.documents().documents,
+    assets: cache.documents(ANIMATION_ASSET_EXTENSIONS).documents
+  }));
+  const config = readBuildConfigFromHost(cache.host, projectRoot);
+  const resource = computeOutputRel2(displayPathOf(projectRoot, fileName), config, "script");
+  const ids = index.byScriptResource.get(resource)?.get(component);
+  return ids === undefined ? [] : buildWholeLiteralCompletionEntries({ slot, ids, baseEntries });
+}
+function resourceEntries(slot, cache, baseEntries) {
+  const extensions = slot.resourceExtensions;
+  if (extensions === undefined || extensions.length === 0) {
+    return [];
+  }
+  const ids = cache.resourcePaths(extensions);
+  return buildWholeLiteralCompletionEntries({ slot, ids, baseEntries });
+}
+function configKeyEntries(slot, cache, baseEntries) {
+  const text = cache.documents(PROJECT_EXTENSIONS).documents.get(GAME_PROJECT_DOCUMENT);
+  if (text === undefined) {
+    return [];
+  }
+  const ids = cache.derived("config-keys", () => buildConfigKeyIndex2(text));
+  return buildWholeLiteralCompletionEntries({ slot, ids, baseEntries });
+}
+function actionIdEntries(slot, cache, baseEntries) {
+  const ids = cache.derived("input-actions", () => buildInputActionIndex2(cache.documents(INPUT_BINDING_EXTENSIONS).documents));
+  return buildWholeLiteralCompletionEntries({ slot, ids, baseEntries });
+}
+function provenancePanel(entryName, declaredIn) {
+  return {
+    name: entryName,
+    kind: CONTRIBUTED_ENTRY_KIND,
+    kindModifiers: "",
+    displayParts: [{ kind: "stringLiteral", text: JSON.stringify(entryName) }],
+    documentation: [
+      {
+        kind: "text",
+        text: `Declared in ${declaredIn.join(", ")}`
+      }
+    ],
+    source: [{ kind: "text", text: DEFOLD_COMPLETION_SOURCE }]
+  };
+}
 function init(modules) {
   const ts = modules.typescript;
   function create(info) {
@@ -13,6 +480,30 @@ function init(modules) {
         writable[key] = (...args) => fn.apply(base, args);
       }
     }
+    const serverHost = info.serverHost;
+    const cache = serverHost?.readDirectory ? createSceneIndexCache(serverHost, info.project.getCurrentDirectory()) : undefined;
+    proxy.dispose = () => {
+      cache?.dispose();
+      const disposeBase = base.dispose;
+      disposeBase?.call(base);
+    };
+    proxy.getCompletionEntryDetails = (fileName, position, entryName, formatOptions, source, preferences, data) => {
+      const forward = () => base.getCompletionEntryDetails?.(fileName, position, entryName, formatOptions, source, preferences, data);
+      if (source !== DEFOLD_COMPLETION_SOURCE || !cache) {
+        return forward();
+      }
+      const program = base.getProgram();
+      const table = loadUrlParameterTable();
+      if (!program || !table) {
+        return forward();
+      }
+      const slot = resolveClassifiedSlotAtPosition({ program, table, fileName, position });
+      if (!slot) {
+        return forward();
+      }
+      const declaredIn = resolveEntryProvenance({ slot, position, cache, fileName, entryName });
+      return declaredIn.length === 0 ? forward() : provenancePanel(entryName, declaredIn);
+    };
     proxy.getSemanticDiagnostics = (fileName) => {
       const prior = base.getSemanticDiagnostics(fileName);
       const program = base.getProgram();
@@ -22,6 +513,38 @@ function init(modules) {
       const transpiler = getProgramDiagnostics(program, program.getSourceFile(fileName)).map((diagnostic) => ({ ...diagnostic, category: ts.DiagnosticCategory.Suggestion }));
       return [...prior, ...transpiler];
     };
+    proxy.getCompletionsAtPosition = (fileName, position, options, formattingSettings) => {
+      const prior = base.getCompletionsAtPosition(fileName, position, options, formattingSettings);
+      const program = base.getProgram();
+      const table = loadUrlParameterTable();
+      if (!program || !table) {
+        return prior;
+      }
+      const slot = resolveClassifiedSlotAtPosition({ program, table, fileName, position });
+      if (!slot) {
+        return prior;
+      }
+      if (!cache) {
+        return prior;
+      }
+      const baseEntries = prior?.entries ?? [];
+      const entries = isAddressClass2(slot.class) ? [
+        ...componentEntries(slot, position, cache, baseEntries),
+        ...objectPathEntries(slot, position, cache, baseEntries)
+      ] : slot.class === "gui-node" ? nodeEntries(slot, cache, fileName, baseEntries) : slot.class === "animation" ? animationEntries(slot, cache, fileName, baseEntries) : slot.class === "resource-path" ? resourceEntries(slot, cache, baseEntries) : slot.class === "config-key" ? configKeyEntries(slot, cache, baseEntries) : slot.class === "action-id" ? actionIdEntries(slot, cache, baseEntries) : [];
+      if (entries.length === 0) {
+        return prior;
+      }
+      if (!prior) {
+        return {
+          isGlobalCompletion: false,
+          isMemberCompletion: false,
+          isNewIdentifierLocation: false,
+          entries
+        };
+      }
+      return { ...prior, entries: [...prior.entries, ...entries] };
+    };
     return proxy;
   }
   return { create };

package/dist/scene-completions.d.ts

@@ -0,0 +1,19 @@
+import type { ClassifiedSlot } from "@defold-typescript/transpiler";
+import type ts from "typescript";
+export declare const CONTRIBUTED_ENTRY_KIND: ts.ScriptElementKind;
+export declare const DEFOLD_COMPLETION_SOURCE = "defold-typescript/scene";
+export declare function buildSceneCompletionEntries(input: {
+    slot: ClassifiedSlot;
+    ids: ReadonlySet<string>;
+    baseEntries: readonly ts.CompletionEntry[];
+}): ts.CompletionEntry[];
+export declare function buildAddressPathCompletionEntries(input: {
+    slot: ClassifiedSlot;
+    paths: ReadonlySet<string>;
+    baseEntries: readonly ts.CompletionEntry[];
+}): ts.CompletionEntry[];
+export declare function buildWholeLiteralCompletionEntries(input: {
+    slot: ClassifiedSlot;
+    ids: ReadonlySet<string>;
+    baseEntries: readonly ts.CompletionEntry[];
+}): ts.CompletionEntry[];

package/dist/scene-documents.d.ts

@@ -0,0 +1,18 @@
+export interface SceneReadHost {
+    readDirectory?(path: string, extensions?: readonly string[]): string[];
+    readFile(path: string): string | undefined;
+}
+export declare const SCENE_EXTENSIONS: string[];
+export declare const GUI_EXTENSIONS: string[];
+export declare const INPUT_BINDING_EXTENSIONS: string[];
+export declare const ANIMATION_ASSET_EXTENSIONS: string[];
+export declare const PROJECT_EXTENSIONS: string[];
+export declare const GAME_PROJECT_DOCUMENT = "game.project";
+export declare function displayPathOf(projectRoot: string, filePath: string): string;
+export declare function isExcludedProjectPath(displayPath: string): boolean;
+export declare function readSceneDocuments(host: SceneReadHost, projectRoot: string, extensions?: readonly string[]): {
+    documents: Map<string, string>;
+    unreadable: string[];
+    paths: string[];
+};
+export declare function listProjectResourcePaths(host: SceneReadHost, projectRoot: string, extensions: readonly string[]): Set<string>;

package/dist/scene-index-cache.d.ts

@@ -0,0 +1,15 @@
+import type * as ts from "typescript";
+import { readSceneDocuments, type SceneReadHost } from "./scene-documents";
+export interface SceneWatchHost extends SceneReadHost {
+    watchFile?(path: string, callback: ts.FileWatcherCallback, pollingInterval?: number): ts.FileWatcher;
+    watchDirectory?(path: string, callback: ts.DirectoryWatcherCallback, recursive?: boolean): ts.FileWatcher;
+}
+export interface SceneIndexCache {
+    readonly host: SceneWatchHost;
+    readonly projectRoot: string;
+    documents(extensions?: readonly string[]): ReturnType<typeof readSceneDocuments>;
+    resourcePaths(extensions: readonly string[]): Set<string>;
+    derived<T>(key: string, compute: () => T): T;
+    dispose(): void;
+}
+export declare function createSceneIndexCache(host: SceneWatchHost, projectRoot: string): SceneIndexCache;

package/dist/scene-provenance.d.ts

@@ -0,0 +1,9 @@
+import { type ClassifiedSlot } from "@defold-typescript/transpiler";
+import type { SceneIndexCache } from "./scene-index-cache";
+export declare function resolveEntryProvenance(input: {
+    slot: ClassifiedSlot;
+    position: number;
+    cache: SceneIndexCache;
+    fileName: string;
+    entryName: string;
+}): readonly string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defold-typescript/tstl-plugin",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "description": "TypeScript language-service plugin surfacing Defold transpiler diagnostics live in the editor.",
   "license": "MIT",
   "repository": {
@@ -35,7 +35,8 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@defold-typescript/transpiler": "0.24.0"
+    "@defold-typescript/transpiler": "0.25.0",
+    "@defold-typescript/types": "0.25.0"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0 <7"

package/src/build-config.ts

@@ -0,0 +1,24 @@
+import { type BuildConfig, DEFAULT_INCLUDE, parseBuildConfig } from "@defold-typescript/transpiler";
+import type { SceneReadHost } from "./scene-documents";
+
+// Alongside output is what the build itself does with no `outDir`, so it is also
+// the honest answer when the config cannot be read: a wrong guess would offer
+// completions for a resource no scene names, and a throw here would take the
+// editor's own completions down with it.
+const ALONGSIDE: BuildConfig = { outDir: undefined, include: DEFAULT_INCLUDE };
+
+// The project's `tsconfig.json` as the build reads it, fetched through the
+// editor host rather than the filesystem so the plugin sees the same unsaved
+// state the editor does.
+export function readBuildConfigFromHost(host: SceneReadHost, projectRoot: string): BuildConfig {
+  const root = projectRoot.replace(/\\/g, "/").replace(/\/+$/, "");
+  const text = host.readFile(`${root}/tsconfig.json`);
+  if (text === undefined) {
+    return ALONGSIDE;
+  }
+  try {
+    return parseBuildConfig(text);
+  } catch {
+    return ALONGSIDE;
+  }
+}