@defold-typescript/tstl-plugin 0.29.0 → 0.31.0

package/dist/build-config.d.ts

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

package/dist/completion-harness.d.ts

@@ -0,0 +1,49 @@
+import ts from "typescript";
+export type PluginFactory = (modules: {
+    typescript: typeof import("typescript");
+}) => {
+    create(info: ts.server.PluginCreateInfo): ts.LanguageService;
+};
+export declare const SCENE_DOCUMENTS: Record<string, string>;
+export declare const BOOTSTRAP_MAIN = "[bootstrap]\nmain_collection = /main.collectionc\n";
+export declare function scriptObject(id: string, resource: string): string;
+export declare function proxyObject(collection: string): string;
+export declare const TWO_WORLD_DOCUMENTS: Record<string, string>;
+export interface ProxyHost {
+    documents: Record<string, string>;
+    /** Listed by `readDirectory`, but answered `undefined` by `readFile`. */
+    unreadable: Set<string>;
+    directoryReads: string[][];
+    openWatchers: number;
+    fireDirectory(hostPath: string): void;
+}
+export interface CompletionSetup {
+    service: ts.LanguageService;
+    host: ProxyHost;
+    baseDisposeCalls(): number;
+    detailsCalls(): unknown[][];
+}
+export declare function completionSetup(options: {
+    source: string;
+    base: ts.WithMetadata<ts.CompletionInfo> | undefined;
+    /** Further program files beside the edited one, so a check can be scoped to it. */
+    sources?: Record<string, string>;
+    documents?: Record<string, string>;
+    /** Scene sources the host lists but cannot read, so a walk composes a real hole. */
+    unreadable?: readonly string[];
+    baseDiagnostics?: ts.Diagnostic[];
+    serverHost?: boolean;
+    watch?: boolean;
+    baseDispose?: boolean;
+    baseDetails?: ts.CompletionEntryDetails;
+    fileName?: string;
+    init?: PluginFactory;
+}): CompletionSetup;
+export declare function completionProxy(options: {
+    source: string;
+    base: ts.WithMetadata<ts.CompletionInfo> | undefined;
+    documents?: Record<string, string>;
+    serverHost?: boolean;
+    fileName?: string;
+    init?: PluginFactory;
+}): ts.LanguageService;

package/dist/index.cjs

@@ -0,0 +1,6 @@
+// tsserver resolves a plugin with Node10 resolution — `exports` is not
+// consulted — and then rejects the loaded value unless it is itself a function.
+// `require()` of the ESM entry yields the namespace object instead, so this
+// CommonJS shim is what `main` points at: it unwraps the factory, and the ESM
+// bundle stays the single build of the plugin.
+module.exports = require("./index.js").default;

package/dist/index.js

@@ -2,22 +2,31 @@
 import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import {
+  ANIMATION_ASSET_EXTENSIONS as ANIMATION_ASSET_EXTENSIONS2,
+  buildComponentAnimationIndex as buildComponentAnimationIndex2,
   buildConfigKeyIndex as buildConfigKeyIndex2,
+  buildGuiFlipbookIndex as buildGuiFlipbookIndex2,
   buildGuiNodeIndex as buildGuiNodeIndex2,
   buildInputActionIndex as buildInputActionIndex2,
-  buildSceneComponentIndex as buildSceneComponentIndex2,
-  buildSceneObjectPathIndex as buildSceneObjectPathIndex2,
-  buildSpriteAnimationIndex as buildSpriteAnimationIndex2,
+  buildSceneObjectPathIndex as buildSceneObjectPathIndex3,
   componentIdOfSameObjectAddress as componentIdOfSameObjectAddress2,
-  computeOutputRel as computeOutputRel2,
+  computeOutputRel as computeOutputRel3,
+  displayPathOf as displayPathOf4,
+  GAME_PROJECT_DOCUMENT as GAME_PROJECT_DOCUMENT3,
+  GUI_EXTENSIONS as GUI_EXTENSIONS3,
   getProgramDiagnostics,
+  INPUT_BINDING_EXTENSIONS as INPUT_BINDING_EXTENSIONS2,
   isAddressClass as isAddressClass2,
   isFragmentCaret as isFragmentCaret2,
+  PROJECT_EXTENSIONS as PROJECT_EXTENSIONS3,
   resolveClassifiedSlotAtPosition
 } from "@defold-typescript/transpiler";
 
 // src/build-config.ts
-import { DEFAULT_INCLUDE, parseBuildConfig } from "@defold-typescript/transpiler";
+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(/\/+$/, "");
@@ -78,63 +87,26 @@ function buildWholeLiteralCompletionEntries(input) {
   });
 }
 
-// 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-diagnostics.ts
+import {
+  checkCrossWorldAddresses,
+  checkUrlFragmentReachability
+} from "@defold-typescript/transpiler";
 
 // src/scene-index-cache.ts
+import {
+  buildSceneCollectionRoles,
+  buildSceneComponentIndex,
+  COLLECTION_REFERENCE_EXTENSIONS,
+  displayPathOf,
+  GAME_PROJECT_DOCUMENT,
+  isExcludedProjectPath,
+  LIBRARY_DEPENDENCY_ROOT,
+  listProjectResourcePaths,
+  PROJECT_EXTENSIONS,
+  readSceneDocuments,
+  SCENE_EXTENSIONS
+} from "@defold-typescript/transpiler";
 function cacheKey(extensions) {
   return [...extensions].sort().join("|");
 }
@@ -162,6 +134,9 @@ function createSceneIndexCache(host, projectRoot) {
   }
   function affectsCache(hostPath) {
     const displayPath = displayPathOf(projectRoot, hostPath);
+    if (displayPath === LIBRARY_DEPENDENCY_ROOT || displayPath.startsWith(`${LIBRARY_DEPENDENCY_ROOT}/`)) {
+      return true;
+    }
     if (isExcludedProjectPath(displayPath))
       return false;
     for (const extension of servedExtensions) {
@@ -247,25 +222,145 @@ function createSceneIndexCache(host, projectRoot) {
     }
   };
 }
+function sceneComponentIndexOf(cache) {
+  return cache.derived("component-index", () => buildSceneComponentIndex(cache.documents().documents));
+}
+function sceneCollectionRolesOf(cache) {
+  return cache.derived("collection-roles", () => buildSceneCollectionRoles({
+    documents: cache.documents().documents,
+    references: cache.documents(COLLECTION_REFERENCE_EXTENSIONS).documents,
+    gameProject: cache.documents(PROJECT_EXTENSIONS).documents.get(GAME_PROJECT_DOCUMENT)
+  }));
+}
+
+// src/scene-relative-addresses.ts
+import {
+  buildSceneObjectPathIndex,
+  buildScriptNamingContexts,
+  computeOutputRel,
+  displayPathOf as displayPathOf2,
+  GUI_EXTENSIONS,
+  guiScriptResourcesOf,
+  relativeAddressesFrom
+} from "@defold-typescript/transpiler";
+var CONTEXTS = "relative:naming-contexts";
+function projectContexts(cache) {
+  return cache.derived(CONTEXTS, () => {
+    const index = buildSceneObjectPathIndex(cache.documents().documents, sceneCollectionRolesOf(cache));
+    const guiScripts = guiScriptResourcesOf(cache.documents(GUI_EXTENSIONS).documents);
+    return { index, byScriptResource: buildScriptNamingContexts(index, guiScripts) };
+  });
+}
+function projectObjectIndex(cache) {
+  return projectContexts(cache).index;
+}
+function relativeUniverseFor(cache, fileName) {
+  return cache.derived(`relative-universe:${fileName}`, () => {
+    const { index, byScriptResource } = projectContexts(cache);
+    const config = readBuildConfigFromHost(cache.host, cache.projectRoot);
+    const rel = displayPathOf2(cache.projectRoot, fileName);
+    const byObject = new Map;
+    for (const kind of ["script", "gui-script"]) {
+      for (const context of byScriptResource.get(computeOutputRel(rel, config, kind)) ?? []) {
+        byObject.set(context.object, context);
+      }
+    }
+    const contexts = [...byObject.values()].sort((a, b) => a.object.localeCompare(b.object));
+    const paths = new Set;
+    const addresses = new Set;
+    const contextsByEntry = new Map;
+    for (const context of contexts) {
+      const relative = relativeAddressesFrom(index, context);
+      for (const entry of relative.paths) {
+        paths.add(entry);
+        contextsByEntry.set(entry, [...contextsByEntry.get(entry) ?? [], context.object]);
+      }
+      for (const entry of relative.addresses) {
+        addresses.add(entry);
+        contextsByEntry.set(entry, [...contextsByEntry.get(entry) ?? [], context.object]);
+      }
+    }
+    for (const objects of contextsByEntry.values())
+      objects.sort();
+    return { contexts, paths, addresses, contextsByEntry };
+  });
+}
+function worldsFor(cache, fileName) {
+  const sockets = new Set;
+  for (const context of relativeUniverseFor(cache, fileName).contexts) {
+    sockets.add(context.socket);
+  }
+  return [...sockets];
+}
+function offersBareWorld(universe) {
+  return universe.contexts.length === 0 || universe.contexts.some((context) => context.socket === undefined);
+}
+
+// src/scene-diagnostics.ts
+var DEFOLD_DIAGNOSTIC_SOURCE = "defold-typescript";
+var UNREACHABLE_FRAGMENT_CODE = 9000101;
+var FOREIGN_SOCKET_CODE = 9000102;
+function suggestion(typescript, file, finding, code) {
+  return {
+    file,
+    start: finding.start,
+    length: finding.length,
+    messageText: finding.message,
+    category: typescript.DiagnosticCategory.Suggestion,
+    source: DEFOLD_DIAGNOSTIC_SOURCE,
+    code
+  };
+}
+function sceneReachabilityDiagnostics(input) {
+  const { ts: typescript, program, table, cache, fileName } = input;
+  const sourceFile = program.getSourceFile(fileName);
+  if (!sourceFile) {
+    return [];
+  }
+  const index = sceneComponentIndexOf(cache);
+  const report = checkUrlFragmentReachability({
+    program,
+    table,
+    index: { ids: index.ids, incomplete: [...index.incomplete, ...cache.documents().unreadable] },
+    objects: projectObjectIndex(cache),
+    sourceFiles: [sourceFile]
+  });
+  const fragments = report.kind === "suppressed" ? [] : report.findings.map((finding) => suggestion(typescript, sourceFile, finding, UNREACHABLE_FRAGMENT_CODE));
+  const crossWorld = checkCrossWorldAddresses({
+    program,
+    table,
+    worldsOf: (name) => worldsFor(cache, name),
+    sourceFiles: [sourceFile]
+  }).map((finding) => suggestion(typescript, sourceFile, finding, FOREIGN_SOCKET_CODE));
+  return [...fragments, ...crossWorld];
+}
 
 // src/scene-provenance.ts
 import {
+  ANIMATION_ASSET_EXTENSIONS,
+  buildComponentAnimationIndex,
   buildConfigKeyIndex,
+  buildGuiFlipbookIndex,
   buildGuiNodeIndex,
   buildInputActionIndex,
-  buildSceneComponentIndex,
-  buildSceneObjectPathIndex,
-  buildSpriteAnimationIndex,
+  buildSceneComponentIndex as buildSceneComponentIndex2,
+  buildSceneObjectPathIndex as buildSceneObjectPathIndex2,
   componentIdOfSameObjectAddress,
-  computeOutputRel,
+  computeOutputRel as computeOutputRel2,
+  displayPathOf as displayPathOf3,
+  GAME_PROJECT_DOCUMENT as GAME_PROJECT_DOCUMENT2,
+  GUI_EXTENSIONS as GUI_EXTENSIONS2,
+  INPUT_BINDING_EXTENSIONS,
   isAddressClass,
-  isFragmentCaret
+  isFragmentCaret,
+  PROJECT_EXTENSIONS as PROJECT_EXTENSIONS2
 } 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";
+var ANIMATION_PROVENANCE = "provenance:component-animations";
+var GUI_ANIMATION_PROVENANCE = "provenance:gui-flipbook";
 function byDeclaringDocument(documents, idsOf) {
   const declarers = new Map;
   for (const [displayPath, text] of documents) {
@@ -309,49 +404,73 @@ function byClaimedScript(documents) {
   return byResource;
 }
 function componentProvenance(cache) {
-  return cache.derived(COMPONENT_PROVENANCE, () => byDeclaringDocument(cache.documents().documents, (narrowed) => buildSceneComponentIndex(narrowed).ids));
+  return cache.derived(COMPONENT_PROVENANCE, () => byDeclaringDocument(cache.documents().documents, (narrowed) => buildSceneComponentIndex2(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 byResource = cache.derived(GUI_PROVENANCE, () => byClaimedScript(cache.documents(GUI_EXTENSIONS2).documents));
   const config = readBuildConfigFromHost(cache.host, cache.projectRoot);
-  const resource = computeOutputRel(displayPathOf(cache.projectRoot, fileName), config, "gui-script");
+  const resource = computeOutputRel2(displayPathOf3(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);
+  return cache.derived(PATH_PROVENANCE, () => buildSceneObjectPathIndex2(cache.documents().documents, sceneCollectionRolesOf(cache)).declaredIn);
+}
+function guiAnimationProvenance(input) {
+  const { cache, fileName, entryName } = input;
+  const index = cache.derived(GUI_ANIMATION_PROVENANCE, () => buildGuiFlipbookIndex({
+    scenes: cache.documents(GUI_EXTENSIONS2).documents,
+    assets: cache.documents(ANIMATION_ASSET_EXTENSIONS).documents
+  }));
+  const config = readBuildConfigFromHost(cache.host, cache.projectRoot);
+  const resource = computeOutputRel2(displayPathOf3(cache.projectRoot, fileName), config, "gui-script");
+  const declarers = index.byScriptResource.get(resource)?.get(entryName);
+  return declarers === undefined ? [] : [...declarers].sort();
 }
 function animationProvenance(input) {
   const { slot, cache, fileName, entryName } = input;
+  if (slot.nodeParameter !== undefined) {
+    return guiAnimationProvenance({ cache, fileName, entryName });
+  }
   const component = componentIdOfSameObjectAddress(slot.addressText ?? "");
   if (component === undefined)
     return [];
-  const index = cache.derived(ANIMATION_PROVENANCE, () => buildSpriteAnimationIndex({
+  const index = cache.derived(ANIMATION_PROVENANCE, () => buildComponentAnimationIndex({
     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] : [];
+  const resource = computeOutputRel2(displayPathOf3(cache.projectRoot, fileName), config, "script");
+  const source = index.sourceByScriptResource.get(resource)?.get(component)?.get(entryName);
+  return source === undefined ? [] : [source];
 }
 function constantProvenance(slot, cache, entryName) {
   if (slot.class === "config-key") {
-    const text = cache.documents(PROJECT_EXTENSIONS).documents.get(GAME_PROJECT_DOCUMENT);
+    const text = cache.documents(PROJECT_EXTENSIONS2).documents.get(GAME_PROJECT_DOCUMENT2);
     if (text === undefined)
       return [];
     const keys = cache.derived("config-keys", () => buildConfigKeyIndex(text));
-    return keys.has(entryName) ? [GAME_PROJECT_DOCUMENT] : [];
+    return keys.has(entryName) ? [GAME_PROJECT_DOCUMENT2] : [];
   }
   const extensions = slot.resourceExtensions;
   if (extensions === undefined || extensions.length === 0)
     return [];
   return cache.resourcePaths(extensions).has(entryName) ? [entryName.replace(/^\//, "")] : [];
 }
+function resolveRelativeEntryProvenance(input) {
+  const { slot, position, cache, fileName, entryName } = input;
+  if (!isAddressClass(slot.class) || isFragmentCaret(slot, position))
+    return;
+  const universe = relativeUniverseFor(cache, fileName);
+  const resolvesFrom = universe.contextsByEntry.get(entryName);
+  if (resolvesFrom === undefined)
+    return;
+  const others = universe.contexts.map((context) => context.object).filter((object) => !resolvesFrom.includes(object));
+  const relative = `Relative to ${resolvesFrom.join(", ")}`;
+  return others.length === 0 ? relative : `${relative}; not from ${others.join(", ")}`;
+}
 function resolveEntryProvenance(input) {
   const { slot, position, cache, fileName, entryName } = input;
   if (isAddressClass(slot.class)) {
@@ -395,40 +514,60 @@ function componentEntries(slot, position, cache, baseEntries) {
   }
   return buildSceneCompletionEntries({
     slot,
-    ids: cache.derived("component-ids", () => buildSceneComponentIndex2(cache.documents().documents).ids),
+    ids: sceneComponentIndexOf(cache).ids,
     baseEntries
   });
 }
-function objectPathEntries(slot, position, cache, baseEntries) {
+function objectPathEntries(slot, position, cache, fileName, baseEntries) {
   if (isFragmentCaret2(slot, position)) {
     return [];
   }
-  return buildAddressPathCompletionEntries({
-    slot,
-    paths: cache.derived("object-paths", () => buildSceneObjectPathIndex2(cache.documents().documents).paths),
-    baseEntries
-  });
+  const universe = relativeUniverseFor(cache, fileName);
+  const bare = offersBareWorld(universe);
+  const absolute = cache.derived("object-paths", () => buildSceneObjectPathIndex3(cache.documents().documents, sceneCollectionRolesOf(cache)).paths);
+  const paths = new Set;
+  for (const key of absolute) {
+    if (bare || !key.startsWith("/"))
+      paths.add(key);
+  }
+  for (const key of universe.paths)
+    paths.add(key);
+  const entries = buildAddressPathCompletionEntries({ slot, paths, baseEntries });
+  if (slot.fragmentStart === -1) {
+    entries.push(...buildWholeLiteralCompletionEntries({ slot, ids: universe.addresses, baseEntries }));
+  }
+  return entries;
 }
 function nodeEntries(slot, cache, fileName, baseEntries) {
   const { projectRoot } = cache;
-  const index = cache.derived("gui-nodes", () => buildGuiNodeIndex2(cache.documents(GUI_EXTENSIONS).documents));
+  const index = cache.derived("gui-nodes", () => buildGuiNodeIndex2(cache.documents(GUI_EXTENSIONS3).documents));
   const config = readBuildConfigFromHost(cache.host, projectRoot);
-  const resource = computeOutputRel2(displayPathOf(projectRoot, fileName), config, "gui-script");
+  const resource = computeOutputRel3(displayPathOf4(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 { projectRoot } = cache;
+  if (slot.nodeParameter !== undefined) {
+    const index2 = cache.derived("gui-flipbook", () => buildGuiFlipbookIndex2({
+      scenes: cache.documents(GUI_EXTENSIONS3).documents,
+      assets: cache.documents(ANIMATION_ASSET_EXTENSIONS2).documents
+    }));
+    const config2 = readBuildConfigFromHost(cache.host, projectRoot);
+    const resource2 = computeOutputRel3(displayPathOf4(projectRoot, fileName), config2, "gui-script");
+    const declared = index2.byScriptResource.get(resource2);
+    return declared === undefined ? [] : buildWholeLiteralCompletionEntries({ slot, ids: new Set(declared.keys()), baseEntries });
+  }
   const component = componentIdOfSameObjectAddress2(slot.addressText ?? "");
   if (component === undefined) {
     return [];
   }
-  const { projectRoot } = cache;
-  const index = cache.derived("sprite-animations", () => buildSpriteAnimationIndex2({
+  const index = cache.derived("component-animations", () => buildComponentAnimationIndex2({
     scenes: cache.documents().documents,
-    assets: cache.documents(ANIMATION_ASSET_EXTENSIONS).documents
+    assets: cache.documents(ANIMATION_ASSET_EXTENSIONS2).documents
   }));
   const config = readBuildConfigFromHost(cache.host, projectRoot);
-  const resource = computeOutputRel2(displayPathOf(projectRoot, fileName), config, "script");
+  const resource = computeOutputRel3(displayPathOf4(projectRoot, fileName), config, "script");
   const ids = index.byScriptResource.get(resource)?.get(component);
   return ids === undefined ? [] : buildWholeLiteralCompletionEntries({ slot, ids, baseEntries });
 }
@@ -441,7 +580,7 @@ function resourceEntries(slot, cache, baseEntries) {
   return buildWholeLiteralCompletionEntries({ slot, ids, baseEntries });
 }
 function configKeyEntries(slot, cache, baseEntries) {
-  const text = cache.documents(PROJECT_EXTENSIONS).documents.get(GAME_PROJECT_DOCUMENT);
+  const text = cache.documents(PROJECT_EXTENSIONS3).documents.get(GAME_PROJECT_DOCUMENT3);
   if (text === undefined) {
     return [];
   }
@@ -449,21 +588,16 @@ function configKeyEntries(slot, cache, baseEntries) {
   return buildWholeLiteralCompletionEntries({ slot, ids, baseEntries });
 }
 function actionIdEntries(slot, cache, baseEntries) {
-  const ids = cache.derived("input-actions", () => buildInputActionIndex2(cache.documents(INPUT_BINDING_EXTENSIONS).documents));
+  const ids = cache.derived("input-actions", () => buildInputActionIndex2(cache.documents(INPUT_BINDING_EXTENSIONS2).documents));
   return buildWholeLiteralCompletionEntries({ slot, ids, baseEntries });
 }
-function provenancePanel(entryName, declaredIn) {
+function provenancePanel(entryName, documentation) {
   return {
     name: entryName,
     kind: CONTRIBUTED_ENTRY_KIND,
     kindModifiers: "",
     displayParts: [{ kind: "stringLiteral", text: JSON.stringify(entryName) }],
-    documentation: [
-      {
-        kind: "text",
-        text: `Declared in ${declaredIn.join(", ")}`
-      }
-    ],
+    documentation: [{ kind: "text", text: documentation }],
     source: [{ kind: "text", text: DEFOLD_COMPLETION_SOURCE }]
   };
 }
@@ -501,8 +635,18 @@ function init(modules) {
       if (!slot) {
         return forward();
       }
+      const relative = resolveRelativeEntryProvenance({
+        slot,
+        position,
+        cache,
+        fileName,
+        entryName
+      });
+      if (relative !== undefined) {
+        return provenancePanel(entryName, relative);
+      }
       const declaredIn = resolveEntryProvenance({ slot, position, cache, fileName, entryName });
-      return declaredIn.length === 0 ? forward() : provenancePanel(entryName, declaredIn);
+      return declaredIn.length === 0 ? forward() : provenancePanel(entryName, `Declared in ${declaredIn.join(", ")}`);
     };
     proxy.getSemanticDiagnostics = (fileName) => {
       const prior = base.getSemanticDiagnostics(fileName);
@@ -511,7 +655,9 @@ function init(modules) {
         return prior;
       }
       const transpiler = getProgramDiagnostics(program, program.getSourceFile(fileName)).map((diagnostic) => ({ ...diagnostic, category: ts.DiagnosticCategory.Suggestion }));
-      return [...prior, ...transpiler];
+      const table = loadUrlParameterTable();
+      const scene = cache && table ? sceneReachabilityDiagnostics({ ts, program, table, cache, fileName }) : [];
+      return [...prior, ...transpiler, ...scene];
     };
     proxy.getCompletionsAtPosition = (fileName, position, options, formattingSettings) => {
       const prior = base.getCompletionsAtPosition(fileName, position, options, formattingSettings);
@@ -530,7 +676,7 @@ function init(modules) {
       const baseEntries = prior?.entries ?? [];
       const entries = isAddressClass2(slot.class) ? [
         ...componentEntries(slot, position, cache, baseEntries),
-        ...objectPathEntries(slot, position, cache, baseEntries)
+        ...objectPathEntries(slot, position, cache, fileName, 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;

package/dist/scene-diagnostics.d.ts

@@ -0,0 +1,29 @@
+import type { UrlParameterTable } from "@defold-typescript/types";
+import type * as ts from "typescript";
+import { type SceneIndexCache } from "./scene-index-cache";
+/** The `source` an editor renders beside the message, and `--json` never sees. */
+export declare const DEFOLD_DIAGNOSTIC_SOURCE = "defold-typescript";
+/**
+ * The address findings the editor surfaces on the file being edited, as
+ * advisory suggestions.
+ *
+ * Every path that cannot produce one answers with an empty array. A suppressed
+ * reachability report is the important case: there is no file span on which a
+ * "the check did not run" notice could honestly sit, and a speculative squiggle
+ * is worse than none — the build says so in prose instead, where a whole-project
+ * line has somewhere to go.
+ *
+ * The *whole* hole is one index, composed the way `sceneIndexForBuild` composes
+ * it: what the parse could not read plus what the walk could not reach. The
+ * completion path deliberately reads a partial universe — a suggestion claims
+ * nothing about what is absent — but a finding does, so a component declared
+ * only by an unresolved dependency suppresses the check rather than reporting
+ * the address as unreachable.
+ */
+export declare function sceneReachabilityDiagnostics(input: {
+    ts: typeof import("typescript");
+    program: ts.Program;
+    table: UrlParameterTable;
+    cache: SceneIndexCache;
+    fileName: string;
+}): ts.Diagnostic[];

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

@@ -1,5 +1,5 @@
+import { readSceneDocuments, type SceneCollectionRoles, type SceneComponentIndex, type SceneReadHost } from "@defold-typescript/transpiler";
 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;
@@ -13,3 +13,5 @@ export interface SceneIndexCache {
     dispose(): void;
 }
 export declare function createSceneIndexCache(host: SceneWatchHost, projectRoot: string): SceneIndexCache;
+export declare function sceneComponentIndexOf(cache: SceneIndexCache): SceneComponentIndex;
+export declare function sceneCollectionRolesOf(cache: SceneIndexCache): SceneCollectionRoles;

package/dist/scene-provenance.d.ts

@@ -1,5 +1,24 @@
 import { type ClassifiedSlot } from "@defold-typescript/transpiler";
-import type { SceneIndexCache } from "./scene-index-cache";
+import { type SceneIndexCache } from "./scene-index-cache";
+/**
+ * The sentence a relative entry's panel carries, or `undefined` where the entry
+ * is not one — a fragment caret, a slot that names no address, or a name this
+ * file's relative universe does not offer.
+ *
+ * A relative address is valid from the object hosting the script and nowhere
+ * else, so the objects it resolves from *are* its provenance: naming a declaring
+ * file instead would answer a question the author is not asking. Where the entry
+ * resolves from only some of the contexts this script runs in, the others are
+ * named too — a sometimes-valid entry that read as an always-valid one is the
+ * wrong-suggestion class this panel exists to close.
+ */
+export declare function resolveRelativeEntryProvenance(input: {
+    slot: ClassifiedSlot;
+    position: number;
+    cache: SceneIndexCache;
+    fileName: string;
+    entryName: string;
+}): string | undefined;
 export declare function resolveEntryProvenance(input: {
     slot: ClassifiedSlot;
     position: number;