@defold-typescript/transpiler 0.29.0 → 0.31.0

package/dist/index.js

@@ -1,30 +1,3 @@
-// src/config-key-index.ts
-function sectionNameOf(line) {
-  const match = line.trim().match(/^\[(.+)\]$/);
-  return match?.[1];
-}
-function buildConfigKeyIndex(gameProjectText) {
-  const keys = new Set;
-  let section;
-  for (const line of gameProjectText.split(`
-`)) {
-    const header = sectionNameOf(line);
-    if (header !== undefined) {
-      section = header;
-      continue;
-    }
-    if (section === undefined)
-      continue;
-    const separator = line.indexOf("=");
-    if (separator === -1)
-      continue;
-    const key = line.slice(0, separator).trim();
-    if (key === "")
-      continue;
-    keys.add(`${section}.${key}`);
-  }
-  return keys;
-}
 // src/scene-text-format.ts
 class SceneTextFormatError extends Error {
   line;
@@ -183,19 +156,404 @@ function parseSceneTextFormat(text) {
   return parseBody(false, 1);
 }
 
-// src/gui-node-index.ts
-var SCRIPT_SUFFIX = ".gui_script";
-function scriptKeyOf(script) {
-  if (!script.endsWith(SCRIPT_SUFFIX))
+// src/animation-sources.ts
+function resourceKey(resource) {
+  return resource.startsWith("/") ? resource.slice(1) : resource;
+}
+function normalizeDocumentKey(path) {
+  return path.replaceAll("\\", "/");
+}
+var SPRITE_SUFFIX = ".sprite";
+var MODEL_SUFFIX = ".model";
+var ANIMATION_SET_SUFFIX = ".animationset";
+var HOP_ONLY_SUFFIXES = [SPRITE_SUFFIX, MODEL_SUFFIX, ANIMATION_SET_SUFFIX];
+function childrenOf(message, name) {
+  return message.messages.get(name) ?? [];
+}
+function declaredAnimations(document) {
+  const ids = new Set;
+  for (const animation of childrenOf(document, "animations")) {
+    for (const id of animation.fields.get("id") ?? []) {
+      if (id !== "")
+        ids.add(id);
+    }
+  }
+  return ids;
+}
+function readAnimationSources(assets, unresolved) {
+  const animationsByTileSet = new Map;
+  for (const [path, text] of assets) {
+    const displayPath = normalizeDocumentKey(path);
+    if (HOP_ONLY_SUFFIXES.some((suffix) => displayPath.endsWith(suffix)))
+      continue;
+    let document;
+    try {
+      document = parseSceneTextFormat(text);
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
+      continue;
+    }
+    animationsByTileSet.set(displayPath, declaredAnimations(document));
+  }
+  return animationsByTileSet;
+}
+function animationSetEntries(document) {
+  const entries = [];
+  for (const entry of childrenOf(document, "animations")) {
+    for (const animation of entry.fields.get("animation") ?? []) {
+      if (animation !== "")
+        entries.push(animation);
+    }
+  }
+  return entries;
+}
+
+// src/component-animation-index.ts
+var SCRIPT_SUFFIX = ".script";
+var SPRITE_SUFFIX2 = ".sprite";
+var MODEL_SUFFIX2 = ".model";
+var ANIMATION_SET_SUFFIX2 = ".animationset";
+var MESH_SUFFIXES = [".gltf", ".glb"];
+function firstField(message, name) {
+  return (message.fields.get(name) ?? [])[0];
+}
+function childrenOf2(message, name) {
+  return message.messages.get(name) ?? [];
+}
+function basename(resource) {
+  const file = resource.slice(resource.lastIndexOf("/") + 1);
+  const dot = file.lastIndexOf(".");
+  return dot === -1 ? file : file.slice(0, dot);
+}
+function readAssets(assets, unresolved) {
+  const animationsByTileSet = readAnimationSources(assets, unresolved);
+  const tileSetBySprite = new Map;
+  const modelDocuments = new Set;
+  const animationSourceByModel = new Map;
+  const entriesByAnimationSet = new Map;
+  for (const [path, text] of assets) {
+    const displayPath = normalizeDocumentKey(path);
+    const isSprite = displayPath.endsWith(SPRITE_SUFFIX2);
+    const isModel = displayPath.endsWith(MODEL_SUFFIX2);
+    const isAnimationSet = displayPath.endsWith(ANIMATION_SET_SUFFIX2);
+    if (!isSprite && !isModel && !isAnimationSet)
+      continue;
+    let document;
+    try {
+      document = parseSceneTextFormat(text);
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
+      continue;
+    }
+    if (isSprite) {
+      const tileSet = firstField(document, "tile_set");
+      if (tileSet !== undefined)
+        tileSetBySprite.set(displayPath, resourceKey(tileSet));
+      continue;
+    }
+    if (isModel) {
+      modelDocuments.add(displayPath);
+      const animations = firstField(document, "animations");
+      if (animations !== undefined)
+        animationSourceByModel.set(displayPath, animations);
+      continue;
+    }
+    entriesByAnimationSet.set(displayPath, animationSetEntries(document));
+  }
+  return {
+    animationsByTileSet,
+    tileSetBySprite,
+    modelDocuments,
+    animationSourceByModel,
+    entriesByAnimationSet
+  };
+}
+function resolveAnimationSet(input) {
+  const { path, prefix, stack, assets, unresolved } = input;
+  const entries = assets.entriesByAnimationSet.get(path);
+  if (entries === undefined)
     return;
-  const key = script.startsWith("/") ? script.slice(1) : script;
-  return key === SCRIPT_SUFFIX ? undefined : key;
+  stack.add(path);
+  try {
+    const ids = new Map;
+    for (const entry of entries) {
+      const key = resourceKey(entry);
+      if (MESH_SUFFIXES.some((suffix) => key.endsWith(suffix))) {
+        ids.set(prefix + basename(key), path);
+        continue;
+      }
+      if (!key.endsWith(ANIMATION_SET_SUFFIX2)) {
+        unresolved.push(`${path}: the entry ${entry} is not a .gltf, .glb or .animationset, so it declares no animation id`);
+        continue;
+      }
+      if (!assets.entriesByAnimationSet.has(key)) {
+        unresolved.push(`${path}: the entry ${entry} is not among the project's animation set documents`);
+        return;
+      }
+      if (stack.has(key)) {
+        unresolved.push(`${path}: the entry ${entry} re-enters an animation set already being read, so the chain is cyclic`);
+        return;
+      }
+      const nested = resolveAnimationSet({
+        path: key,
+        prefix: `${prefix + basename(key)}/`,
+        stack,
+        assets,
+        unresolved
+      });
+      if (nested === undefined)
+        return;
+      for (const [id, declaring] of nested)
+        if (!ids.has(id))
+          ids.set(id, declaring);
+    }
+    return ids;
+  } finally {
+    stack.delete(path);
+  }
 }
-function buildGuiNodeIndex(documents) {
+function componentAnimationSources(object, displayPath, assets, unresolved) {
+  const sources = new Map;
+  function claimModel(id, animations) {
+    if (!animations.endsWith(ANIMATION_SET_SUFFIX2)) {
+      unresolved.push(`${displayPath}: the model component "${id}" names ${animations} rather than an animation set, so none of its animation ids are established`);
+      return;
+    }
+    sources.set(id, { kind: "model", path: resourceKey(animations) });
+  }
+  for (const embedded of childrenOf2(object, "embedded_components")) {
+    const type = firstField(embedded, "type");
+    if (type !== "sprite" && type !== "model")
+      continue;
+    const id = firstField(embedded, "id");
+    const payload = firstField(embedded, "data");
+    if (id === undefined || payload === undefined)
+      continue;
+    let document;
+    try {
+      document = parseSceneTextFormat(payload);
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      unresolved.push(`${displayPath}: the embedded ${type} "${id}" could not be read (${error.message})`);
+      continue;
+    }
+    if (type === "sprite") {
+      const tileSet = firstField(document, "tile_set");
+      if (tileSet !== undefined)
+        sources.set(id, { kind: "sprite", path: resourceKey(tileSet) });
+      continue;
+    }
+    const animations = firstField(document, "animations");
+    if (animations !== undefined)
+      claimModel(id, animations);
+  }
+  for (const referenced of childrenOf2(object, "components")) {
+    const component = firstField(referenced, "component");
+    const id = firstField(referenced, "id");
+    if (id === undefined || component === undefined)
+      continue;
+    if (component.endsWith(SPRITE_SUFFIX2)) {
+      const tileSet = assets.tileSetBySprite.get(resourceKey(component));
+      if (tileSet === undefined) {
+        unresolved.push(`${displayPath}: the sprite component "${id}" names ${component}, which is not among the project's sprite documents`);
+        continue;
+      }
+      sources.set(id, { kind: "sprite", path: tileSet });
+      continue;
+    }
+    if (!component.endsWith(MODEL_SUFFIX2))
+      continue;
+    const resource = resourceKey(component);
+    if (!assets.modelDocuments.has(resource)) {
+      unresolved.push(`${displayPath}: the model component "${id}" names ${component}, which is not among the project's model documents`);
+      continue;
+    }
+    const animations = assets.animationSourceByModel.get(resource);
+    if (animations !== undefined)
+      claimModel(id, animations);
+  }
+  return sources;
+}
+function scriptResourcesOf(object) {
+  const resources = [];
+  for (const component of childrenOf2(object, "components")) {
+    const resource = firstField(component, "component");
+    if (resource === undefined || !resource.endsWith(SCRIPT_SUFFIX))
+      continue;
+    const key = resourceKey(resource);
+    if (key !== SCRIPT_SUFFIX.slice(1))
+      resources.push(key);
+  }
+  return resources;
+}
+function isGameObject(message) {
+  return message.messages.has("components") || message.messages.has("embedded_components");
+}
+function buildComponentAnimationIndex(input) {
+  const unresolved = [];
+  const assets = readAssets(input.assets, unresolved);
   const byScriptResource = new Map;
+  const sourceByScriptResource = new Map;
   const claimedBy = new Map;
+  function walk(message, blockName, displayPath) {
+    if (isGameObject(message)) {
+      claim(message, displayPath);
+    }
+    if (blockName === "embedded_instances") {
+      for (const payload of message.fields.get("data") ?? []) {
+        try {
+          walk(parseSceneTextFormat(payload), "", displayPath);
+        } catch (error) {
+          if (!(error instanceof SceneTextFormatError))
+            throw error;
+          unresolved.push(`${displayPath}: an embedded game object could not be read (${error.message})`);
+        }
+      }
+    }
+    for (const [name, nested] of message.messages) {
+      for (const child of nested) {
+        walk(child, name, displayPath);
+      }
+    }
+  }
+  function idsOf(id, source, displayPath) {
+    if (source.kind === "sprite") {
+      const declared = assets.animationsByTileSet.get(source.path);
+      if (declared !== undefined)
+        return new Map([...declared].map((name) => [name, source.path]));
+      unresolved.push(`${displayPath}: the sprite component "${id}" names the tile source /${source.path}, which is not among the project's asset documents`);
+      return;
+    }
+    const resolved = resolveAnimationSet({
+      path: source.path,
+      prefix: "",
+      stack: new Set,
+      assets,
+      unresolved
+    });
+    if (resolved !== undefined)
+      return resolved;
+    if (!assets.entriesByAnimationSet.has(source.path)) {
+      unresolved.push(`${displayPath}: the model component "${id}" names the animation set /${source.path}, which is not among the project's asset documents`);
+    }
+    return;
+  }
+  function claim(object, displayPath) {
+    const scripts = scriptResourcesOf(object);
+    if (scripts.length === 0)
+      return;
+    const sources = componentAnimationSources(object, displayPath, assets, unresolved);
+    const animations = new Map;
+    const declaringSources = new Map;
+    for (const [id, source] of sources) {
+      const resolved = idsOf(id, source, displayPath);
+      if (resolved === undefined)
+        continue;
+      animations.set(id, new Set(resolved.keys()));
+      declaringSources.set(id, resolved);
+    }
+    for (const key of scripts) {
+      const owner = claimedBy.get(key);
+      if (owner !== undefined) {
+        byScriptResource.delete(key);
+        sourceByScriptResource.delete(key);
+        unresolved.push(`${key}: claimed by both ${owner} and ${displayPath}, so its component animations are ambiguous`);
+        continue;
+      }
+      claimedBy.set(key, displayPath);
+      byScriptResource.set(key, animations);
+      sourceByScriptResource.set(key, declaringSources);
+    }
+  }
+  for (const [path, text] of input.scenes) {
+    const displayPath = normalizeDocumentKey(path);
+    try {
+      walk(parseSceneTextFormat(text), "", displayPath);
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
+    }
+  }
+  return { byScriptResource, sourceByScriptResource, unresolved };
+}
+function componentIdOfSameObjectAddress(address) {
+  if (!address.startsWith("#"))
+    return;
+  const id = address.slice(1);
+  if (id === "" || id.includes("/") || id.includes("#"))
+    return;
+  return id;
+}
+// src/config-key-index.ts
+function sectionNameOf(line) {
+  const match = line.trim().match(/^\[(.+)\]$/);
+  return match?.[1];
+}
+function buildConfigKeyIndex(gameProjectText) {
+  const keys = new Set;
+  let section;
+  for (const line of gameProjectText.split(`
+`)) {
+    const header = sectionNameOf(line);
+    if (header !== undefined) {
+      section = header;
+      continue;
+    }
+    if (section === undefined)
+      continue;
+    const separator = line.indexOf("=");
+    if (separator === -1)
+      continue;
+    const key = line.slice(0, separator).trim();
+    if (key === "")
+      continue;
+    keys.add(`${section}.${key}`);
+  }
+  return keys;
+}
+function readGameProjectSetting(gameProjectText, section, key) {
+  let current;
+  for (const line of gameProjectText.split(`
+`)) {
+    const header = sectionNameOf(line);
+    if (header !== undefined) {
+      current = header;
+      continue;
+    }
+    if (current !== section)
+      continue;
+    const separator = line.indexOf("=");
+    if (separator === -1)
+      continue;
+    if (line.slice(0, separator).trim() !== key)
+      continue;
+    const value = line.slice(separator + 1).trim();
+    if (value !== "")
+      return value;
+  }
+  return;
+}
+// src/gui-flipbook-index.ts
+var SCRIPT_SUFFIX2 = ".gui_script";
+function scriptKeyOf(script) {
+  if (!script.endsWith(SCRIPT_SUFFIX2))
+    return;
+  const key = resourceKey(script);
+  return key === SCRIPT_SUFFIX2 ? undefined : key;
+}
+function buildGuiFlipbookIndex(input) {
   const unresolved = [];
-  for (const [displayPath, text] of documents) {
+  const animationsBySource = readAnimationSources(input.assets, unresolved);
+  const byScriptResource = new Map;
+  const claimedBy = new Map;
+  for (const [path, text] of input.scenes) {
+    const displayPath = normalizeDocumentKey(path);
     let document;
     try {
       document = parseSceneTextFormat(text);
@@ -212,6 +570,83 @@ function buildGuiNodeIndex(documents) {
     if (key === undefined)
       continue;
     const owner = claimedBy.get(key);
+    if (owner !== undefined) {
+      byScriptResource.delete(key);
+      unresolved.push(`${key}: claimed by both ${owner} and ${displayPath}, so its flipbook animations are ambiguous`);
+      continue;
+    }
+    claimedBy.set(key, displayPath);
+    const declaredBy = new Map;
+    for (const message of document.messages.get("textures") ?? []) {
+      for (const texture of message.fields.get("texture") ?? []) {
+        if (texture === "")
+          continue;
+        const source = resourceKey(texture);
+        const ids = animationsBySource.get(source);
+        if (ids === undefined) {
+          unresolved.push(`${displayPath}: the texture ${texture} is not among the project's asset documents`);
+          continue;
+        }
+        for (const id of ids) {
+          const declarers = declaredBy.get(id);
+          if (declarers) {
+            declarers.add(source);
+          } else {
+            declaredBy.set(id, new Set([source]));
+          }
+        }
+      }
+    }
+    byScriptResource.set(key, declaredBy);
+  }
+  return { byScriptResource, unresolved };
+}
+// src/gui-node-index.ts
+var SCRIPT_SUFFIX3 = ".gui_script";
+function scriptKeyOf2(script) {
+  if (!script.endsWith(SCRIPT_SUFFIX3))
+    return;
+  const key = script.startsWith("/") ? script.slice(1) : script;
+  return key === SCRIPT_SUFFIX3 ? undefined : key;
+}
+function guiScriptResourceOf(document) {
+  const [script] = document.fields.get("script") ?? [];
+  return script === undefined ? undefined : scriptKeyOf2(script);
+}
+function guiScriptResourcesOf(documents) {
+  const scripts = new Map;
+  for (const [displayPath, text] of documents) {
+    let resource;
+    try {
+      resource = guiScriptResourceOf(parseSceneTextFormat(text));
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      continue;
+    }
+    if (resource !== undefined)
+      scripts.set(displayPath, resource);
+  }
+  return scripts;
+}
+function buildGuiNodeIndex(documents) {
+  const byScriptResource = new Map;
+  const claimedBy = new Map;
+  const unresolved = [];
+  for (const [displayPath, text] of documents) {
+    let document;
+    try {
+      document = parseSceneTextFormat(text);
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
+      continue;
+    }
+    const key = guiScriptResourceOf(document);
+    if (key === undefined)
+      continue;
+    const owner = claimedBy.get(key);
     if (owner !== undefined) {
       byScriptResource.delete(key);
       unresolved.push(`${key}: claimed by both ${owner} and ${displayPath}, so its node ids are ambiguous`);
@@ -252,6 +687,304 @@ function buildInputActionIndex(documents) {
   }
   return actions;
 }
+// src/project-resources.ts
+var SCAFFOLDED_DEFIGNORE_LINES = ["/node_modules", "/.defold-types", "/.vscode"];
+function isDefignoredPath(displayPath) {
+  const rooted = `/${displayPath.replace(/^\/+/, "")}`;
+  return SCAFFOLDED_DEFIGNORE_LINES.some((line) => rooted === line || rooted.startsWith(`${line}/`));
+}
+
+// src/scene-documents.ts
+var SCENE_EXTENSIONS = [".go", ".collection"];
+var GUI_EXTENSIONS = [".gui"];
+var INPUT_BINDING_EXTENSIONS = [".input_binding"];
+var COLLECTION_REFERENCE_EXTENSIONS = [".collectionproxy", ".collectionfactory"];
+var ANIMATION_ASSET_EXTENSIONS = [
+  ".atlas",
+  ".tilesource",
+  ".sprite",
+  ".model",
+  ".animationset"
+];
+var LIBRARY_SCENE_EXTENSIONS = [
+  ...SCENE_EXTENSIONS,
+  ...GUI_EXTENSIONS,
+  ...ANIMATION_ASSET_EXTENSIONS,
+  ...COLLECTION_REFERENCE_EXTENSIONS
+];
+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 origins = 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, origins, 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);
+  }
+  const library = readLibrarySceneDocuments(host, projectRoot, extensions);
+  unreadable.push(...library.unreadable);
+  for (const { displayPath, hostPath, url, text } of library.documents) {
+    if (documents.has(displayPath)) {
+      unreadable.push(`${displayPath}: also declared by ${url}; the project's own file is used`);
+      continue;
+    }
+    documents.set(displayPath, text);
+    origins.set(displayPath, url);
+    paths.push(hostPath);
+  }
+  return { documents, origins, 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/library-dependencies.ts
+function isProjectHeader(line) {
+  return line.trim() === "[project]";
+}
+function isSectionHeader(line) {
+  return /^\[.+\]\s*$/.test(line.trim());
+}
+function readGameProjectDependencies(gameProjectText) {
+  const lines = gameProjectText.split(`
+`);
+  const deps = [];
+  let inProject = false;
+  for (const line of lines) {
+    if (isSectionHeader(line)) {
+      inProject = isProjectHeader(line);
+      continue;
+    }
+    if (!inProject) {
+      continue;
+    }
+    const match = line.match(/^dependencies#(\d+)\s*=\s*(.+)$/);
+    if (match?.[1] !== undefined && match[2] !== undefined) {
+      deps.push({ index: Number(match[1]), url: match[2] });
+    }
+  }
+  return deps;
+}
+function archiveWrapperOf(entries) {
+  let wrapper;
+  for (const entry of entries) {
+    const separator = entry.indexOf("/");
+    if (separator <= 0) {
+      return;
+    }
+    const segment = entry.slice(0, separator);
+    if (wrapper === undefined) {
+      wrapper = segment;
+    } else if (wrapper !== segment) {
+      return;
+    }
+  }
+  return wrapper;
+}
+function readLibraryIncludeDirs(gameProjectText) {
+  let inLibrary = false;
+  for (const line of gameProjectText.split(`
+`)) {
+    if (isSectionHeader(line)) {
+      inLibrary = line.trim() === "[library]";
+      continue;
+    }
+    if (!inLibrary) {
+      continue;
+    }
+    const match = line.match(/^include_dirs\s*=\s*(.*)$/);
+    if (match?.[1] !== undefined) {
+      return match[1].split(",").map((dir) => dir.trim()).filter((dir) => dir.length > 0);
+    }
+  }
+  return [];
+}
+function isContainedResourcePath(path) {
+  if (path.length === 0 || path.includes("\\")) {
+    return false;
+  }
+  return path.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+}
+function libraryIncludedEntries(entries, gameProjectText) {
+  if (gameProjectText === undefined) {
+    return {
+      shared: [],
+      reasons: ["ships no game.project, so it declares no [library] include_dirs"],
+      refused: []
+    };
+  }
+  const includeDirs = new Set(readLibraryIncludeDirs(gameProjectText));
+  if (includeDirs.size === 0) {
+    return {
+      shared: [],
+      reasons: ["its game.project declares no [library] include_dirs"],
+      refused: []
+    };
+  }
+  const wrapper = archiveWrapperOf(entries);
+  const shared = [];
+  const refused = [];
+  for (const entry of entries) {
+    const path = wrapper === undefined ? entry : entry.slice(wrapper.length + 1);
+    const [head] = path.split("/");
+    if (head === undefined || !includeDirs.has(head)) {
+      continue;
+    }
+    const dot = path.lastIndexOf(".");
+    if (dot === -1 || !LIBRARY_SCENE_EXTENSIONS.includes(path.slice(dot).toLowerCase())) {
+      continue;
+    }
+    if (!isContainedResourcePath(path)) {
+      refused.push(entry);
+      continue;
+    }
+    shared.push({ entry, path });
+  }
+  shared.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  return { shared, reasons: [], refused };
+}
+var LIBRARY_DEPENDENCY_ROOT = ".defold-types/dependencies";
+var LIBRARY_DEPENDENCY_MANIFEST = `${LIBRARY_DEPENDENCY_ROOT}/dependencies.json`;
+function joinProject(projectRoot, relative) {
+  return `${projectRoot.replace(/\\/g, "/").replace(/\/+$/, "")}/${relative}`;
+}
+function readMaterializedKeys(manifestText) {
+  let parsed;
+  try {
+    parsed = JSON.parse(manifestText);
+  } catch {
+    return;
+  }
+  const entries = parsed?.dependencies;
+  if (!Array.isArray(entries))
+    return;
+  const keyByUrl = new Map;
+  for (const entry of entries) {
+    const { key, url } = entry ?? {};
+    if (typeof key === "string" && typeof url === "string")
+      keyByUrl.set(url, key);
+  }
+  return keyByUrl;
+}
+function readLibrarySceneDocuments(host, projectRoot, extensions = LIBRARY_SCENE_EXTENSIONS) {
+  const documents = [];
+  const unreadable = [];
+  if (!host.readDirectory)
+    return { documents, unreadable };
+  const gameProjectText = host.readFile(joinProject(projectRoot, GAME_PROJECT_DOCUMENT));
+  if (gameProjectText === undefined)
+    return { documents, unreadable };
+  const declared = [...readGameProjectDependencies(gameProjectText)].sort((a, b) => a.index - b.index);
+  if (declared.length === 0)
+    return { documents, unreadable };
+  const manifestText = host.readFile(joinProject(projectRoot, LIBRARY_DEPENDENCY_MANIFEST));
+  if (manifestText === undefined) {
+    for (const { url } of declared) {
+      unreadable.push(`${url}: is declared by game.project but ${LIBRARY_DEPENDENCY_MANIFEST} is absent`);
+    }
+    return { documents, unreadable };
+  }
+  const keyByUrl = readMaterializedKeys(manifestText);
+  if (keyByUrl === undefined) {
+    for (const { url } of declared) {
+      unreadable.push(`${url}: is declared by game.project but ${LIBRARY_DEPENDENCY_MANIFEST} is not a readable dependency manifest`);
+    }
+    return { documents, unreadable };
+  }
+  const resolved = [];
+  const urlByKey = new Map;
+  for (const { url } of declared) {
+    const key = keyByUrl.get(url);
+    if (key === undefined) {
+      unreadable.push(`${url}: is declared by game.project but was not materialized by the last resolve`);
+      continue;
+    }
+    resolved.push({ key, url });
+    urlByKey.set(key, url);
+  }
+  const root = joinProject(projectRoot, LIBRARY_DEPENDENCY_ROOT);
+  const filesByKey = new Map;
+  const stray = new Set;
+  for (const filePath of host.readDirectory(root, extensions)) {
+    const relative = displayPathOf(root, filePath);
+    if (relative === filePath.replace(/\\/g, "/"))
+      continue;
+    const separator = relative.indexOf("/");
+    if (separator <= 0)
+      continue;
+    const key = relative.slice(0, separator);
+    const url = urlByKey.get(key);
+    if (url === undefined) {
+      stray.add(key);
+      continue;
+    }
+    const bucket = filesByKey.get(key);
+    if (bucket === undefined)
+      filesByKey.set(key, [filePath]);
+    else
+      bucket.push(filePath);
+  }
+  const claimed = new Map;
+  for (const { key, url } of resolved) {
+    for (const hostPath of (filesByKey.get(key) ?? []).sort()) {
+      const displayPath = displayPathOf(root, hostPath).slice(key.length + 1);
+      if (displayPath === "")
+        continue;
+      const owner = claimed.get(displayPath);
+      if (owner !== undefined) {
+        unreadable.push(`${displayPath}: also declared by ${url}; ${owner}'s file is used`);
+        continue;
+      }
+      const text = host.readFile(hostPath);
+      if (text === undefined) {
+        unreadable.push(`${displayPath}: could not be read from ${url}`);
+        continue;
+      }
+      claimed.set(displayPath, url);
+      documents.push({ displayPath, hostPath, url, text });
+    }
+  }
+  for (const key of [...stray].sort()) {
+    unreadable.push(`${LIBRARY_DEPENDENCY_ROOT}/${key}: is materialized but no longer declared by game.project, so its scenes are left out`);
+  }
+  return { documents, unreadable };
+}
 // src/main-entry-factory-imports.ts
 import * as ts3 from "typescript";
 
@@ -826,25 +1559,30 @@ function getProgramDiagnostics(program, sourceFile) {
   });
   return diagnostics.filter((d) => d.file !== undefined && !isAmbient(d.file.fileName));
 }
-// src/project-resources.ts
-var SCAFFOLDED_DEFIGNORE_LINES = ["/node_modules", "/.defold-types", "/.vscode"];
-function isDefignoredPath(displayPath) {
-  const rooted = `/${displayPath.replace(/^\/+/, "")}`;
-  return SCAFFOLDED_DEFIGNORE_LINES.some((line) => rooted === line || rooted.startsWith(`${line}/`));
-}
 // src/scene-component-index.ts
 var COMPONENT_BLOCKS = new Set(["components", "embedded_components"]);
 var EMBEDDING_BLOCKS = new Set(["embedded_instances", "embedded_components"]);
-function collect(message, blockName, depth, displayPath, ids, incomplete) {
+function resourceKey2(resource) {
+  return resource.startsWith("/") ? resource.slice(1) : resource;
+}
+function collect(message, blockName, depth, displayPath, declarations, incomplete) {
   if (COMPONENT_BLOCKS.has(blockName)) {
-    for (const id of message.fields.get("id") ?? []) {
-      ids.add(id);
+    const declared = message.fields.get("id") ?? [];
+    for (const id of declared) {
+      declarations.ids.add(id);
+    }
+    if (blockName === "components") {
+      const [id] = declared;
+      const [component] = message.fields.get("component") ?? [];
+      if (id !== undefined && id !== "" && component !== undefined) {
+        declarations.resources.set(id, resourceKey2(component));
+      }
     }
   }
   if (EMBEDDING_BLOCKS.has(blockName)) {
     for (const payload of message.fields.get("data") ?? []) {
       try {
-        collect(parseSceneTextFormat(payload), "", depth + 1, displayPath, ids, incomplete);
+        collect(parseSceneTextFormat(payload), "", depth + 1, displayPath, declarations, incomplete);
       } catch (error) {
         if (!(error instanceof SceneTextFormatError))
           throw error;
@@ -854,10 +1592,18 @@ function collect(message, blockName, depth, displayPath, ids, incomplete) {
   }
   for (const [name, nested] of message.messages) {
     for (const child of nested) {
-      collect(child, name, depth, displayPath, ids, incomplete);
+      collect(child, name, depth, displayPath, declarations, incomplete);
     }
   }
 }
+function collectComponentDeclarations(message, displayPath, incomplete, blockName = "") {
+  const declarations = { ids: new Set, resources: new Map };
+  collect(message, blockName, 0, displayPath, declarations, incomplete);
+  return declarations;
+}
+function collectComponentIds(message, displayPath, incomplete, blockName = "") {
+  return collectComponentDeclarations(message, displayPath, incomplete, blockName).ids;
+}
 function buildSceneComponentIndex(documents) {
   const ids = new Set;
   const incomplete = [];
@@ -867,7 +1613,9 @@ function buildSceneComponentIndex(documents) {
   }
   for (const [displayPath, text] of documents) {
     try {
-      collect(parseSceneTextFormat(text), "", 0, displayPath, ids, incomplete);
+      for (const id of collectComponentIds(parseSceneTextFormat(text), displayPath, incomplete)) {
+        ids.add(id);
+      }
     } catch (error) {
       if (!(error instanceof SceneTextFormatError))
         throw error;
@@ -876,23 +1624,238 @@ function buildSceneComponentIndex(documents) {
   }
   return { ids, incomplete };
 }
+
 // src/scene-object-path-index.ts
 var LEAF_BLOCKS = ["instances", "embedded_instances"];
-function resourceKey(resource) {
+function resourceKey3(resource) {
+  return resource.startsWith("/") ? resource.slice(1) : resource;
+}
+function firstField2(message, name) {
+  return (message.fields.get(name) ?? [])[0];
+}
+function childrenOf3(message, name) {
+  return message.messages.get(name) ?? [];
+}
+function buildSceneObjectPathIndex(documents, roles) {
+  const incomplete = [];
+  if (documents.size === 0) {
+    incomplete.push("no scene sources were read, so no game-object path can be proven absent");
+    incomplete.push(...roles.incomplete);
+    return {
+      paths: new Set,
+      declaredIn: new Map,
+      componentsOf: new Map,
+      componentResourcesOf: new Map,
+      incomplete
+    };
+  }
+  const parsed = new Map;
+  for (const [displayPath, text] of documents) {
+    try {
+      parsed.set(displayPath, parseSceneTextFormat(text));
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      incomplete.push(`${displayPath}: could not be parsed (${error.message})`);
+    }
+  }
+  const composed = new Map;
+  const inProgress = new Set;
+  const prototypeDeclarations = new Map;
+  function declarationsOfPrototype(key) {
+    const done = prototypeDeclarations.get(key);
+    if (done !== undefined || prototypeDeclarations.has(key))
+      return done;
+    const document = parsed.get(key);
+    let declarations;
+    if (document !== undefined) {
+      const collected = collectComponentDeclarations(document, key, incomplete);
+      declarations = { components: [...collected.ids].sort(), resources: collected.resources };
+    }
+    prototypeDeclarations.set(key, declarations);
+    return declarations;
+  }
+  function pathsOf(displayPath) {
+    const done = composed.get(displayPath);
+    if (done !== undefined)
+      return done;
+    if (inProgress.has(displayPath)) {
+      incomplete.push(`${displayPath}: is instanced inside itself through a cycle of collection references, so its paths cannot be composed`);
+      return new Map;
+    }
+    const document = parsed.get(displayPath);
+    if (document === undefined)
+      return new Map;
+    inProgress.add(displayPath);
+    const paths2 = new Map;
+    for (const blockName of LEAF_BLOCKS) {
+      for (const block of childrenOf3(document, blockName)) {
+        const id = firstField2(block, "id");
+        if (id === undefined || id === "")
+          continue;
+        let components;
+        let resources;
+        if (blockName === "embedded_instances") {
+          const before = incomplete.length;
+          const declarations = collectComponentDeclarations(block, displayPath, incomplete, blockName);
+          if (incomplete.length === before) {
+            components = [...declarations.ids].sort();
+            resources = declarations.resources;
+          }
+        } else {
+          const prototype = firstField2(block, "prototype");
+          if (prototype === undefined) {
+            incomplete.push(`${displayPath}: the instance "${id}" declares no prototype, so the components it owns cannot be read`);
+          } else if (parsed.has(resourceKey3(prototype))) {
+            const declarations = declarationsOfPrototype(resourceKey3(prototype));
+            components = declarations?.components;
+            resources = declarations?.resources;
+          } else {
+            incomplete.push(`${displayPath}: the instance "${id}" names ${prototype}, which is not among the project's readable scene documents`);
+          }
+        }
+        paths2.set(`/${id}`, { declarer: displayPath, components, resources });
+      }
+    }
+    for (const block of childrenOf3(document, "collection_instances")) {
+      const id = firstField2(block, "id");
+      const collection = firstField2(block, "collection");
+      if (id === undefined || id === "" || collection === undefined)
+        continue;
+      const key = resourceKey3(collection);
+      if (!parsed.has(key)) {
+        incomplete.push(`${displayPath}: the collection instance "${id}" names ${collection}, which is not among the project's readable scene documents`);
+        continue;
+      }
+      for (const [nested, leaf] of pathsOf(key)) {
+        paths2.set(`/${id}${nested}`, leaf);
+      }
+    }
+    inProgress.delete(displayPath);
+    composed.set(displayPath, paths2);
+    return paths2;
+  }
+  for (const displayPath of parsed.keys())
+    pathsOf(displayPath);
+  const worlds = [];
+  if (roles.bootstrap !== undefined)
+    worlds.push(["", roles.bootstrap]);
+  for (const [displayPath, socket] of roles.sockets)
+    worlds.push([`${socket}:`, displayPath]);
+  const paths = new Set;
+  const declaredIn = new Map;
+  const componentsOf = new Map;
+  const componentResourcesOf = new Map;
+  const withheld = new Set;
+  for (const [prefix, displayPath] of worlds) {
+    for (const [path2, leaf] of pathsOf(displayPath)) {
+      const key = `${prefix}${path2}`;
+      paths.add(key);
+      const declarers = declaredIn.get(key);
+      if (declarers === undefined) {
+        declaredIn.set(key, [leaf.declarer]);
+      } else if (!declarers.includes(leaf.declarer)) {
+        declarers.push(leaf.declarer);
+      }
+      if (leaf.components === undefined || leaf.resources === undefined) {
+        withheld.add(key);
+        continue;
+      }
+      const owned = componentsOf.get(key);
+      if (owned === undefined) {
+        componentsOf.set(key, [...leaf.components]);
+      } else {
+        for (const id of leaf.components)
+          if (!owned.includes(id))
+            owned.push(id);
+      }
+      const referenced = componentResourcesOf.get(key);
+      if (referenced === undefined) {
+        componentResourcesOf.set(key, new Map(leaf.resources));
+      } else {
+        for (const [id, resource] of leaf.resources) {
+          if (!referenced.has(id))
+            referenced.set(id, resource);
+        }
+      }
+    }
+  }
+  for (const declarers of declaredIn.values())
+    declarers.sort();
+  for (const key of withheld) {
+    componentsOf.delete(key);
+    componentResourcesOf.delete(key);
+  }
+  for (const owned of componentsOf.values())
+    owned.sort();
+  incomplete.push(...roles.incomplete);
+  return {
+    paths,
+    declaredIn,
+    componentsOf,
+    componentResourcesOf,
+    incomplete: [...new Set(incomplete)]
+  };
+}
+
+// src/scene-address-declaration.ts
+var BANNER = `// Generated from this project's scenes by \`defold-typescript scene-types\`.
+// Do not edit: every run rewrites it from the .go/.collection sources.
+//
+// Each key is an address the project declares. The aliases in
+// \`@defold-typescript/types\` stay widened with \`(string & {})\`, so these keys
+// only add completions — an address composed at runtime is never rejected.
+`;
+function componentAddressesOf(documents, paths) {
+  const keys = [...buildSceneComponentIndex(documents).ids].map((id) => `#${id}`);
+  for (const [path2, ids] of paths.componentsOf) {
+    for (const id of ids)
+      keys.push(`${path2}#${id}`);
+  }
+  return keys;
+}
+function bodyOf(keys) {
+  if (keys.length === 0)
+    return "{}";
+  const members = keys.map((key) => `    ${JSON.stringify(key)}: true;
+`).sort().join("");
+  return `{
+${members}  }`;
+}
+function buildSceneAddressDeclaration(documents, roles) {
+  const index = buildSceneObjectPathIndex(documents, roles);
+  const components = componentAddressesOf(documents, index);
+  return `${BANNER}
+declare global {
+  interface SceneGameObjectAddresses ${bodyOf([...index.paths])}
+
+  interface SceneComponentAddresses ${bodyOf(components)}
+}
+
+export {};
+`;
+}
+// src/scene-collection-roles.ts
+var EMBEDDING_BLOCKS2 = new Set(["embedded_instances", "embedded_components"]);
+var REFERENCE_KINDS = [
+  { extension: ".collectionproxy", type: "collectionproxy", field: "collection" },
+  { extension: ".collectionfactory", type: "collectionfactory", field: "prototype" }
+];
+function resourceKey4(resource) {
   return resource.startsWith("/") ? resource.slice(1) : resource;
 }
-function firstField(message, name) {
+function collectionKey(resource) {
+  return resourceKey4(resource).replace(/\.collectionc$/, ".collection");
+}
+function firstField3(message, name) {
   return (message.fields.get(name) ?? [])[0];
 }
-function childrenOf(message, name) {
-  return message.messages.get(name) ?? [];
+function isCollection(displayPath) {
+  return displayPath.endsWith(".collection");
 }
-function buildSceneObjectPathIndex(documents) {
+function buildSceneCollectionRoles(input) {
+  const { documents, references, gameProject } = input;
   const incomplete = [];
-  if (documents.size === 0) {
-    incomplete.push("no scene sources were read, so no game-object path can be proven absent");
-    return { paths: new Set, declaredIn: new Map, incomplete };
-  }
   const parsed = new Map;
   for (const [displayPath, text] of documents) {
     try {
@@ -905,71 +1868,185 @@ function buildSceneObjectPathIndex(documents) {
   }
   const instanced = new Set;
   for (const document of parsed.values()) {
-    for (const block of childrenOf(document, "collection_instances")) {
-      const collection = firstField(block, "collection");
+    for (const block of document.messages.get("collection_instances") ?? []) {
+      const collection = firstField3(block, "collection");
       if (collection !== undefined)
-        instanced.add(resourceKey(collection));
+        instanced.add(resourceKey4(collection));
     }
   }
-  const composed = new Map;
-  const inProgress = new Set;
-  function pathsOf(displayPath) {
-    const done = composed.get(displayPath);
-    if (done !== undefined)
-      return done;
-    if (inProgress.has(displayPath)) {
-      incomplete.push(`${displayPath}: is instanced inside itself through a cycle of collection references, so its paths cannot be composed`);
-      return new Map;
+  const proxied = new Set;
+  const factoryPrototypes = new Set;
+  function record(kind, resource) {
+    (kind.type === "collectionproxy" ? proxied : factoryPrototypes).add(collectionKey(resource));
+  }
+  function followReferenceDocument(displayPath, resource) {
+    const kind = REFERENCE_KINDS.find((candidate) => resource.endsWith(candidate.extension));
+    if (kind === undefined)
+      return;
+    const text = references.get(resourceKey4(resource));
+    if (text === undefined) {
+      incomplete.push(`${displayPath}: the component ${resource} is not among the project's readable ${kind.extension} documents, so the collection it names is unclassified`);
+      return;
     }
-    const document = parsed.get(displayPath);
-    if (document === undefined)
-      return new Map;
-    inProgress.add(displayPath);
-    const paths2 = new Map;
-    for (const blockName of LEAF_BLOCKS) {
-      for (const block of childrenOf(document, blockName)) {
-        const id = firstField(block, "id");
-        if (id !== undefined && id !== "")
-          paths2.set(`/${id}`, displayPath);
+    let document;
+    try {
+      document = parseSceneTextFormat(text);
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      incomplete.push(`${resourceKey4(resource)}: could not be parsed (${error.message})`);
+      return;
+    }
+    const target = firstField3(document, kind.field);
+    if (target === undefined) {
+      incomplete.push(`${resourceKey4(resource)}: declares no ${kind.field}:, so the collection it names is unclassified`);
+      return;
+    }
+    record(kind, target);
+  }
+  function walk(message, blockName, displayPath, depth) {
+    if (blockName === "components") {
+      const component = firstField3(message, "component");
+      if (component !== undefined)
+        followReferenceDocument(displayPath, component);
+    }
+    const payloads = [];
+    if (EMBEDDING_BLOCKS2.has(blockName)) {
+      for (const payload of message.fields.get("data") ?? []) {
+        try {
+          payloads.push(parseSceneTextFormat(payload));
+        } catch (error) {
+          if (!(error instanceof SceneTextFormatError))
+            throw error;
+          incomplete.push(`${displayPath}: embedded payload at depth ${depth + 1} could not be parsed (${error.message})`);
+        }
       }
     }
-    for (const block of childrenOf(document, "collection_instances")) {
-      const id = firstField(block, "id");
-      const collection = firstField(block, "collection");
-      if (id === undefined || id === "" || collection === undefined)
-        continue;
-      const key = resourceKey(collection);
-      if (!parsed.has(key)) {
-        incomplete.push(`${displayPath}: the collection instance "${id}" names ${collection}, which is not among the project's readable scene documents`);
-        continue;
+    if (blockName === "embedded_components") {
+      const type = firstField3(message, "type");
+      const kind = REFERENCE_KINDS.find((candidate) => candidate.type === type);
+      if (kind !== undefined) {
+        for (const payload of payloads) {
+          const target = firstField3(payload, kind.field);
+          if (target === undefined) {
+            incomplete.push(`${displayPath}: the embedded ${kind.type} declares no ${kind.field}:, so the collection it names is unclassified`);
+            continue;
+          }
+          record(kind, target);
+        }
       }
-      for (const [nested, declarer] of pathsOf(key)) {
-        paths2.set(`/${id}${nested}`, declarer);
+    }
+    for (const payload of payloads)
+      walk(payload, "", displayPath, depth + 1);
+    for (const [name, nested] of message.messages) {
+      for (const child of nested)
+        walk(child, name, displayPath, depth);
+    }
+  }
+  for (const [displayPath, document] of parsed)
+    walk(document, "", displayPath, 0);
+  const sockets = new Map;
+  const byName = new Map;
+  for (const displayPath of [...proxied].sort()) {
+    const document = parsed.get(displayPath);
+    if (document === undefined) {
+      incomplete.push(`${displayPath}: is opened as a collection proxy but is not among the project's readable scene documents, so its world has no name`);
+      continue;
+    }
+    const name = firstField3(document, "name");
+    if (name === undefined || name === "") {
+      incomplete.push(`${displayPath}: is opened as a collection proxy but declares no name:, so its world cannot be addressed`);
+      continue;
+    }
+    sockets.set(displayPath, name);
+    byName.set(name, [...byName.get(name) ?? [], displayPath]);
+  }
+  for (const [name, holders] of byName) {
+    if (holders.length > 1) {
+      incomplete.push(`${holders.join(", ")}: all declare name: "${name}", so an address under that socket does not say which world it means`);
+    }
+  }
+  const hasCollections = [...parsed.keys()].some(isCollection);
+  let bootstrap;
+  if (gameProject === undefined) {
+    if (hasCollections) {
+      incomplete.push("game.project could not be read, so no collection is known to be the bootstrap world and no address is offered unqualified");
+    }
+  } else {
+    const main = readGameProjectSetting(gameProject, "bootstrap", "main_collection");
+    if (main === undefined) {
+      if (hasCollections) {
+        incomplete.push("game.project declares no [bootstrap] main_collection, so no collection is the bootstrap world");
       }
+    } else if (!parsed.has(collectionKey(main))) {
+      incomplete.push(`game.project names ${main} as [bootstrap] main_collection, which is not among the project's readable scene documents`);
+    } else {
+      bootstrap = collectionKey(main);
     }
-    inProgress.delete(displayPath);
-    composed.set(displayPath, paths2);
-    return paths2;
   }
-  const paths = new Set;
-  const declaredIn = new Map;
   for (const displayPath of parsed.keys()) {
-    const own = pathsOf(displayPath);
-    if (instanced.has(displayPath))
+    if (!isCollection(displayPath))
       continue;
-    for (const [path2, declarer] of own) {
-      paths.add(path2);
-      const declarers = declaredIn.get(path2);
-      if (declarers === undefined) {
-        declaredIn.set(path2, [declarer]);
-      } else if (!declarers.includes(declarer)) {
-        declarers.push(declarer);
+    if (displayPath === bootstrap || sockets.has(displayPath) || instanced.has(displayPath) || factoryPrototypes.has(displayPath)) {
+      continue;
+    }
+    incomplete.push(`${displayPath}: is reached by no bootstrap, proxy, instance or factory reference, so which world its objects live in is unknown`);
+  }
+  return { bootstrap, sockets, instanced, factoryPrototypes, incomplete };
+}
+// src/scene-naming-context.ts
+var SCRIPT_SUFFIX4 = ".script";
+var GUI_SUFFIX = ".gui";
+function socketOfAddress(address) {
+  const pathStart = address.indexOf("/");
+  const fragmentStart = address.indexOf("#");
+  const ends = [pathStart, fragmentStart, address.length].filter((end) => end >= 0);
+  const headEnd = Math.min(...ends);
+  const delimiter = address.indexOf(":");
+  return delimiter > 0 && delimiter < headEnd ? address.slice(0, delimiter) : undefined;
+}
+function contextOf(object) {
+  return {
+    object,
+    socket: socketOfAddress(object),
+    prefix: object.slice(0, object.lastIndexOf("/") + 1)
+  };
+}
+function buildScriptNamingContexts(index, guiScripts) {
+  const contexts = new Map;
+  for (const [object, resources] of index.componentResourcesOf) {
+    for (const resource of resources.values()) {
+      const script = resource.endsWith(SCRIPT_SUFFIX4) ? resource : resource.endsWith(GUI_SUFFIX) ? guiScripts.get(resource) : undefined;
+      if (script === undefined)
+        continue;
+      const hosted = contexts.get(script);
+      if (hosted === undefined) {
+        contexts.set(script, [contextOf(object)]);
+      } else if (!hosted.some((context) => context.object === object)) {
+        hosted.push(contextOf(object));
       }
     }
   }
-  for (const declarers of declaredIn.values())
-    declarers.sort();
-  return { paths, declaredIn, incomplete };
+  for (const hosted of contexts.values()) {
+    hosted.sort((a, b) => a.object.localeCompare(b.object));
+  }
+  return contexts;
+}
+function relativeAddressesFrom(index, context) {
+  const paths = new Set;
+  const addresses = new Set;
+  for (const key of index.paths) {
+    if (!key.startsWith(context.prefix))
+      continue;
+    const relative = key.slice(context.prefix.length);
+    if (relative === "")
+      continue;
+    paths.add(relative);
+    for (const id of index.componentsOf.get(key) ?? []) {
+      addresses.add(`${relative}#${id}`);
+    }
+  }
+  return { paths, addresses };
 }
 // src/session.ts
 import { readFileSync as readFileSync2 } from "node:fs";
@@ -1396,179 +2473,6 @@ function createTranspileSession() {
     getProgram: () => program
   };
 }
-// src/sprite-animation-index.ts
-function resourceKey2(resource) {
-  return resource.startsWith("/") ? resource.slice(1) : resource;
-}
-function normalizeDocumentKey(path4) {
-  return path4.replaceAll("\\", "/");
-}
-var SCRIPT_SUFFIX2 = ".script";
-var SPRITE_SUFFIX = ".sprite";
-function firstField2(message, name) {
-  return (message.fields.get(name) ?? [])[0];
-}
-function childrenOf2(message, name) {
-  return message.messages.get(name) ?? [];
-}
-function declaredAnimations(document) {
-  const ids = new Set;
-  for (const animation of childrenOf2(document, "animations")) {
-    for (const id of animation.fields.get("id") ?? []) {
-      if (id !== "")
-        ids.add(id);
-    }
-  }
-  return ids;
-}
-function readAssets(assets, unresolved) {
-  const animationsByTileSet = new Map;
-  const tileSetBySprite = new Map;
-  for (const [path4, text] of assets) {
-    const displayPath = normalizeDocumentKey(path4);
-    let document;
-    try {
-      document = parseSceneTextFormat(text);
-    } catch (error) {
-      if (!(error instanceof SceneTextFormatError))
-        throw error;
-      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
-      continue;
-    }
-    if (displayPath.endsWith(SPRITE_SUFFIX)) {
-      const tileSet = firstField2(document, "tile_set");
-      if (tileSet !== undefined)
-        tileSetBySprite.set(displayPath, resourceKey2(tileSet));
-      continue;
-    }
-    animationsByTileSet.set(displayPath, declaredAnimations(document));
-  }
-  return { animationsByTileSet, tileSetBySprite };
-}
-function spriteTileSets(object, displayPath, assets, unresolved) {
-  const tileSets = new Map;
-  for (const embedded of childrenOf2(object, "embedded_components")) {
-    if (firstField2(embedded, "type") !== "sprite")
-      continue;
-    const id = firstField2(embedded, "id");
-    const payload = firstField2(embedded, "data");
-    if (id === undefined || payload === undefined)
-      continue;
-    try {
-      const tileSet = firstField2(parseSceneTextFormat(payload), "tile_set");
-      if (tileSet !== undefined)
-        tileSets.set(id, resourceKey2(tileSet));
-    } catch (error) {
-      if (!(error instanceof SceneTextFormatError))
-        throw error;
-      unresolved.push(`${displayPath}: the embedded sprite "${id}" could not be read (${error.message})`);
-    }
-  }
-  for (const referenced of childrenOf2(object, "components")) {
-    const component = firstField2(referenced, "component");
-    const id = firstField2(referenced, "id");
-    if (id === undefined || component === undefined || !component.endsWith(SPRITE_SUFFIX))
-      continue;
-    const tileSet = assets.tileSetBySprite.get(resourceKey2(component));
-    if (tileSet === undefined) {
-      unresolved.push(`${displayPath}: the sprite component "${id}" names ${component}, which is not among the project's sprite documents`);
-      continue;
-    }
-    tileSets.set(id, tileSet);
-  }
-  return tileSets;
-}
-function scriptResourcesOf(object) {
-  const resources = [];
-  for (const component of childrenOf2(object, "components")) {
-    const resource = firstField2(component, "component");
-    if (resource === undefined || !resource.endsWith(SCRIPT_SUFFIX2))
-      continue;
-    const key = resourceKey2(resource);
-    if (key !== SCRIPT_SUFFIX2.slice(1))
-      resources.push(key);
-  }
-  return resources;
-}
-function isGameObject(message) {
-  return message.messages.has("components") || message.messages.has("embedded_components");
-}
-function buildSpriteAnimationIndex(input) {
-  const unresolved = [];
-  const assets = readAssets(input.assets, unresolved);
-  const byScriptResource = new Map;
-  const tileSetByScriptResource = new Map;
-  const claimedBy = new Map;
-  function walk(message, blockName, displayPath) {
-    if (isGameObject(message)) {
-      claim(message, displayPath);
-    }
-    if (blockName === "embedded_instances") {
-      for (const payload of message.fields.get("data") ?? []) {
-        try {
-          walk(parseSceneTextFormat(payload), "", displayPath);
-        } catch (error) {
-          if (!(error instanceof SceneTextFormatError))
-            throw error;
-          unresolved.push(`${displayPath}: an embedded game object could not be read (${error.message})`);
-        }
-      }
-    }
-    for (const [name, nested] of message.messages) {
-      for (const child of nested) {
-        walk(child, name, displayPath);
-      }
-    }
-  }
-  function claim(object, displayPath) {
-    const scripts = scriptResourcesOf(object);
-    if (scripts.length === 0)
-      return;
-    const tileSets = spriteTileSets(object, displayPath, assets, unresolved);
-    const animations = new Map;
-    const declaringTileSets = new Map;
-    for (const [id, tileSet] of tileSets) {
-      const declared = assets.animationsByTileSet.get(tileSet);
-      if (declared === undefined) {
-        unresolved.push(`${displayPath}: the sprite component "${id}" names the tile source /${tileSet}, which is not among the project's asset documents`);
-        continue;
-      }
-      animations.set(id, declared);
-      declaringTileSets.set(id, tileSet);
-    }
-    for (const key of scripts) {
-      const owner = claimedBy.get(key);
-      if (owner !== undefined) {
-        byScriptResource.delete(key);
-        tileSetByScriptResource.delete(key);
-        unresolved.push(`${key}: claimed by both ${owner} and ${displayPath}, so its sprite animations are ambiguous`);
-        continue;
-      }
-      claimedBy.set(key, displayPath);
-      byScriptResource.set(key, animations);
-      tileSetByScriptResource.set(key, declaringTileSets);
-    }
-  }
-  for (const [path4, text] of input.scenes) {
-    const displayPath = normalizeDocumentKey(path4);
-    try {
-      walk(parseSceneTextFormat(text), "", displayPath);
-    } catch (error) {
-      if (!(error instanceof SceneTextFormatError))
-        throw error;
-      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
-    }
-  }
-  return { byScriptResource, tileSetByScriptResource, unresolved };
-}
-function componentIdOfSameObjectAddress(address) {
-  if (!address.startsWith("#"))
-    return;
-  const id = address.slice(1);
-  if (id === "" || id.includes("/") || id.includes("#"))
-    return;
-  return id;
-}
 // src/url-address-slots.ts
 import * as ts11 from "typescript";
 var ADDRESS_CLASSES = {
@@ -1660,6 +2564,10 @@ function slotThroughHashedCall(checker, table, literal) {
   const ascended = classifiedEntryOfArgument(checker, table, call);
   return ascended?.entry.fqn === "hash" ? undefined : ascended;
 }
+function addressEntryOfArgument(checker, table, argument) {
+  const entry = classifiedEntryOfArgument(checker, table, argument)?.entry;
+  return entry !== undefined && isAddressClass(entry.class) ? entry : undefined;
+}
 function addressClassOfArgument(checker, table, argument) {
   return classifiedEntryOfArgument(checker, table, argument)?.entry.class ?? "none";
 }
@@ -1713,10 +2621,14 @@ function resolveClassifiedSlotAtPosition(input) {
     textStart,
     fragmentStart: hash === -1 ? -1 : textStart + hash + 1,
     ...addressText === undefined ? {} : { addressText },
+    ...classified.entry.nodeParameter === undefined ? {} : { nodeParameter: classified.entry.nodeParameter },
     ...classified.entry.resourceExtensions === undefined ? {} : { resourceExtensions: classified.entry.resourceExtensions }
   };
 }
-// src/url-fragment-reachability.ts
+// src/url-cross-world-address.ts
+import * as ts13 from "typescript";
+
+// src/url-address-literals.ts
 import * as ts12 from "typescript";
 function isAmbient2(fileName) {
   return /[\\/]node_modules[\\/]/.test(fileName) || /(^|[\\/])lib\.[^\\/]*\.d\.ts$/.test(fileName);
@@ -1767,8 +2679,89 @@ function hashedSourceOfType(checker, type, canonical) {
   const [source] = checker.getTypeArguments(type);
   return source?.isStringLiteral() ? source.value : undefined;
 }
+function staticAddressTextOf(checker, node, canonical) {
+  return ts12.isStringLiteralLike(node) ? node.text : hashedSourceOfType(checker, checker.getTypeAtLocation(node), canonical);
+}
+
+// src/url-cross-world-address.ts
+function slotRejectsForeignSocket(entry) {
+  return entry.socketScope === "same-world";
+}
+function worldPhrase(sockets) {
+  const named = [...new Set(sockets)].map((socket) => socket === undefined ? "the bootstrap world" : `"${socket}"`);
+  return named.join(" and ");
+}
+function checkCrossWorldAddresses(input) {
+  const { program, table, worldsOf, sourceFiles } = input;
+  const checker = program.getTypeChecker();
+  const canonical = canonicalHashSymbols(checker, program);
+  const findings = [];
+  const targets = sourceFiles ?? program.getSourceFiles();
+  for (const sourceFile of targets) {
+    if (isAmbient2(sourceFile.fileName))
+      continue;
+    const worlds = worldsOf(sourceFile.fileName);
+    if (worlds.length === 0)
+      continue;
+    const visit = (node) => {
+      if (ts13.isExpression(node)) {
+        const entry = addressEntryOfArgument(checker, table, node);
+        if (entry !== undefined && slotRejectsForeignSocket(entry)) {
+          const address = staticAddressTextOf(checker, node, canonical);
+          const socket = address === undefined ? undefined : socketOfAddress(address);
+          if (address !== undefined && socket !== undefined && worlds.every((world) => world !== socket)) {
+            findings.push({
+              fileName: sourceFile.fileName,
+              start: node.getStart(sourceFile),
+              length: node.getWidth(sourceFile),
+              address,
+              socket,
+              message: `this address names the world "${socket}", but \`${entry.fqn}\` resolves it in ` + `the world the script runs in (${worldPhrase(worlds)}), so it cannot resolve at ` + `runtime — only \`msg.post\` and \`msg.url\` cross a collection proxy`
+            });
+          }
+        }
+      }
+      ts13.forEachChild(node, visit);
+    };
+    ts13.forEachChild(sourceFile, visit);
+  }
+  return findings;
+}
+// src/url-fragment-reachability.ts
+import * as ts14 from "typescript";
+function pathOfKey(key) {
+  const socket = socketOfAddress(key);
+  return socket === undefined ? key : key.slice(socket.length + 1);
+}
+function declaredComponentsOf(objects, path4) {
+  if (objects === undefined || path4 === "")
+    return;
+  if (objects.incomplete.length > 0)
+    return;
+  if (socketOfAddress(path4) !== undefined) {
+    return objects.paths.has(path4) ? objects.componentsOf.get(path4) : undefined;
+  }
+  if (!path4.startsWith("/"))
+    return;
+  const declared = new Set;
+  let known = false;
+  for (const key of objects.paths) {
+    if (pathOfKey(key) !== path4)
+      continue;
+    const owned = objects.componentsOf.get(key);
+    if (owned === undefined)
+      return;
+    known = true;
+    for (const id of owned)
+      declared.add(id);
+  }
+  return known ? [...declared].sort() : undefined;
+}
+function declaredPhrase(ids) {
+  return ids.length === 0 ? "it declares no components at all" : `it declares ${ids.map((id) => `"${id}"`).join(", ")}`;
+}
 function checkUrlFragmentReachability(input) {
-  const { program, table, index, sourceFiles } = input;
+  const { program, table, index, objects, sourceFiles } = input;
   if (index.incomplete.length > 0) {
     return { kind: "suppressed", reasons: index.incomplete };
   }
@@ -1780,25 +2773,28 @@ function checkUrlFragmentReachability(input) {
     if (isAmbient2(sourceFile.fileName))
       continue;
     const visit = (node) => {
-      if (ts12.isExpression(node) && isAddressClass(addressClassOfArgument(checker, table, node))) {
-        const text = ts12.isStringLiteralLike(node) ? node.text : hashedSourceOfType(checker, checker.getTypeAtLocation(node), canonical);
+      if (ts14.isExpression(node) && isAddressClass(addressClassOfArgument(checker, table, node))) {
+        const text = staticAddressTextOf(checker, node, canonical);
         if (text !== undefined) {
           const hash = text.indexOf("#");
           const fragment = hash === -1 ? "" : text.slice(hash + 1);
-          if (fragment !== "" && !index.ids.has(fragment)) {
+          const declared = fragment === "" ? undefined : declaredComponentsOf(objects, text.slice(0, hash));
+          const reachable = declared === undefined ? index.ids.has(fragment) : declared.includes(fragment);
+          if (fragment !== "" && !reachable) {
+            const path4 = text.slice(0, hash);
             findings.push({
               fileName: sourceFile.fileName,
               start: node.getStart(sourceFile),
               length: node.getWidth(sourceFile),
               fragment,
-              message: `no \`.go\` or \`.collection\` in this project declares a component with the id ` + `"${fragment}", so this address cannot resolve at runtime`
+              message: declared === undefined ? `no \`.go\` or \`.collection\` in this project declares a component with the id ` + `"${fragment}", so this address cannot resolve at runtime` : `the game object "${path4}" declares no component with the id "${fragment}" ` + `(${declaredPhrase(declared)}), so this address cannot resolve at runtime`
             });
           }
         }
       }
-      ts12.forEachChild(node, visit);
+      ts14.forEachChild(node, visit);
     };
-    ts12.forEachChild(sourceFile, visit);
+    ts14.forEachChild(sourceFile, visit);
   }
   return { kind: "checked", findings };
 }
@@ -1806,27 +2802,59 @@ export {
   transpileProject,
   transpile,
   stripIncludeBase,
+  socketOfAddress,
+  slotRejectsForeignSocket,
   resolveClassifiedSlotAtPosition,
+  relativeAddressesFrom,
+  readSceneDocuments,
+  readLibrarySceneDocuments,
+  readGameProjectSetting,
+  readGameProjectDependencies,
   parseSceneTextFormat,
   parseBuildConfig,
+  listProjectResourcePaths,
+  libraryIncludedEntries,
   isFragmentCaret,
+  isExcludedProjectPath,
   isDefignoredPath,
+  isContainedResourcePath,
   isAddressClass,
+  guiScriptResourcesOf,
+  guiScriptResourceOf,
   getProgramDiagnostics,
   findMainEntryFactoryImports,
+  displayPathOf,
   createTranspileSession,
   computeOutputRel,
   componentIdOfSameObjectAddress,
+  collectComponentIds,
+  collectComponentDeclarations,
   checkUrlFragmentReachability,
-  buildSpriteAnimationIndex,
+  checkCrossWorldAddresses,
+  buildScriptNamingContexts,
   buildSceneObjectPathIndex,
   buildSceneComponentIndex,
+  buildSceneCollectionRoles,
+  buildSceneAddressDeclaration,
   buildInputActionIndex,
   buildGuiNodeIndex,
+  buildGuiFlipbookIndex,
   buildConfigKeyIndex,
+  buildComponentAnimationIndex,
+  archiveWrapperOf,
+  addressEntryOfArgument,
   addressClassOfArgument,
   SceneTextFormatError,
   SCRIPT_SUFFIX_BY_KIND,
+  SCENE_EXTENSIONS,
   SCAFFOLDED_DEFIGNORE_LINES,
-  DEFAULT_INCLUDE
+  PROJECT_EXTENSIONS,
+  LIBRARY_SCENE_EXTENSIONS,
+  LIBRARY_DEPENDENCY_ROOT,
+  INPUT_BINDING_EXTENSIONS,
+  GUI_EXTENSIONS,
+  GAME_PROJECT_DOCUMENT,
+  DEFAULT_INCLUDE,
+  COLLECTION_REFERENCE_EXTENSIONS,
+  ANIMATION_ASSET_EXTENSIONS
 };