@defold-typescript/transpiler 0.30.0 → 0.31.0

package/src/scene-collection-roles.ts

@@ -0,0 +1,267 @@
+import { readGameProjectSetting } from "./config-key-index";
+import { parseSceneTextFormat, type SceneMessage, SceneTextFormatError } from "./scene-text-format";
+
+// Which world each collection is, so an address can say where it resolves. A
+// game object's address has two axes — which world, then which path inside it —
+// and only these roles can tell them apart. Shaped like the indexes it feeds: a
+// non-empty `incomplete` means the classification is not provably whole, so no
+// consumer may conclude a collection has no role.
+export interface SceneCollectionRoles {
+  /** The one collection `[bootstrap] main_collection` names, whose paths are bare. */
+  readonly bootstrap?: string | undefined;
+  /** Proxied collections, mapped to the socket `CollectionDesc.name` gives them. */
+  readonly sockets: ReadonlyMap<string, string>;
+  /** Collections another collection instances, whose paths exist only under that id. */
+  readonly instanced: ReadonlySet<string>;
+  /** Collection-factory prototypes, whose objects have no static path at all. */
+  readonly factoryPrototypes: ReadonlySet<string>;
+  readonly incomplete: readonly string[];
+}
+
+export interface SceneCollectionRolesInput {
+  /** The `.go`/`.collection` universe, keyed by display path. */
+  readonly documents: ReadonlyMap<string, string>;
+  /** The `.collectionproxy`/`.collectionfactory` documents, keyed by display path. */
+  readonly references: ReadonlyMap<string, string>;
+  /** `game.project`'s text, or `undefined` when the walk could not read it. */
+  readonly gameProject: string | undefined;
+}
+
+// The two places Defold embeds a whole escaped document in `data:`, the same
+// rule `buildSceneComponentIndex` states — every other `data:` is a plain scalar.
+const EMBEDDING_BLOCKS = new Set(["embedded_instances", "embedded_components"]);
+
+// A component reference and the field its document holds the target under: a
+// proxy names the collection it opens as a world, a factory names the prototype
+// it spawns copies of.
+const REFERENCE_KINDS = [
+  { extension: ".collectionproxy", type: "collectionproxy", field: "collection" },
+  { extension: ".collectionfactory", type: "collectionfactory", field: "prototype" },
+] as const;
+
+type ReferenceKind = (typeof REFERENCE_KINDS)[number];
+
+// Matches `scene-object-path-index.ts`: resource paths inside a scene are
+// project-absolute, documents are keyed by project-relative display path.
+function resourceKey(resource: string): string {
+  return resource.startsWith("/") ? resource.slice(1) : resource;
+}
+
+// `game.project` and a `.collectionproxy` name the *compiled* resource the
+// engine loads (`/main/main.collectionc`), not the source the walk read — the
+// same normalisation `resolveBootPathScripts` applies to its own boot walk.
+// Without it every real project fails to find its bootstrap world.
+function collectionKey(resource: string): string {
+  return resourceKey(resource).replace(/\.collectionc$/, ".collection");
+}
+
+function firstField(message: SceneMessage, name: string): string | undefined {
+  return (message.fields.get(name) ?? [])[0];
+}
+
+// Only a `.collection` is a world. A `.go` is a prototype, so running the role
+// rules over it would make every prototype in the project a role-less
+// "reachable no way" entry and drown the honest ones.
+function isCollection(displayPath: string): boolean {
+  return displayPath.endsWith(".collection");
+}
+
+/**
+ * Classify every collection the project declares into the world it is: the one
+ * bootstrap root, a proxy world addressed through its own socket, a collection
+ * instanced inside another, or a factory prototype with no static address.
+ *
+ * Pure, like the indexes it feeds — the filesystem walk belongs to the caller.
+ * There is deliberately no everything-else-is-a-root fallback: that fallback is
+ * what offers a bare `/enemy` for an object living in another world, and losing
+ * a completion is safe where offering a false one is not.
+ */
+export function buildSceneCollectionRoles(input: SceneCollectionRolesInput): SceneCollectionRoles {
+  const { documents, references, gameProject } = input;
+  const incomplete: string[] = [];
+
+  const parsed = new Map<string, SceneMessage>();
+  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 instanced = new Set<string>();
+  for (const document of parsed.values()) {
+    for (const block of document.messages.get("collection_instances") ?? []) {
+      const collection = firstField(block, "collection");
+      if (collection !== undefined) instanced.add(resourceKey(collection));
+    }
+  }
+
+  const proxied = new Set<string>();
+  const factoryPrototypes = new Set<string>();
+
+  function record(kind: ReferenceKind, resource: string): void {
+    (kind.type === "collectionproxy" ? proxied : factoryPrototypes).add(collectionKey(resource));
+  }
+
+  // A standalone reference is a component file of its own; its target lives in
+  // the reference document rather than in the scene that points at it, so a
+  // reference the walk never read is a named gap and not a dropped edge.
+  function followReferenceDocument(displayPath: string, resource: string): void {
+    const kind = REFERENCE_KINDS.find((candidate) => resource.endsWith(candidate.extension));
+    if (kind === undefined) return;
+    const text = references.get(resourceKey(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;
+    }
+    let document: SceneMessage;
+    try {
+      document = parseSceneTextFormat(text);
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError)) throw error;
+      incomplete.push(`${resourceKey(resource)}: could not be parsed (${error.message})`);
+      return;
+    }
+    const target = firstField(document, kind.field);
+    if (target === undefined) {
+      incomplete.push(
+        `${resourceKey(resource)}: declares no ${kind.field}:, so the collection it names is unclassified`,
+      );
+      return;
+    }
+    record(kind, target);
+  }
+
+  function walk(
+    message: SceneMessage,
+    blockName: string,
+    displayPath: string,
+    depth: number,
+  ): void {
+    if (blockName === "components") {
+      const component = firstField(message, "component");
+      if (component !== undefined) followReferenceDocument(displayPath, component);
+    }
+
+    const payloads: SceneMessage[] = [];
+    if (EMBEDDING_BLOCKS.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})`,
+          );
+        }
+      }
+    }
+
+    if (blockName === "embedded_components") {
+      const type = firstField(message, "type");
+      const kind = REFERENCE_KINDS.find((candidate) => candidate.type === type);
+      if (kind !== undefined) {
+        for (const payload of payloads) {
+          const target = firstField(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 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);
+
+  // The socket is the proxied collection's own `name:` — `CollectionDesc.name`,
+  // which the editor writes on the collection itself and which is deliberately
+  // neither the proxy component's id nor the file's basename.
+  const sockets = new Map<string, string>();
+  const byName = new Map<string, string[]>();
+  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 = firstField(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`,
+      );
+    }
+  }
+
+  // A project the walk found no collection in has no world to name, so an
+  // absent `[bootstrap]` says nothing a reader could act on — the same posture
+  // `sceneIndexForBuild` takes towards a scene-less project. A project that does
+  // have collections is a different case: there the absence is exactly why no
+  // address is offered bare, so it is always named.
+  const hasCollections = [...parsed.keys()].some(isCollection);
+
+  let bootstrap: string | undefined;
+  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);
+    }
+  }
+
+  for (const displayPath of parsed.keys()) {
+    if (!isCollection(displayPath)) continue;
+    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 };
+}

package/src/scene-component-index.ts

@@ -20,23 +20,56 @@ const COMPONENT_BLOCKS = new Set(["components", "embedded_components"]);
 // projects as unreadable and suppress the check for good.
 const EMBEDDING_BLOCKS = new Set(["embedded_instances", "embedded_components"]);
 
+// A component id and the resource it references, where one is referenced at all.
+// The two axes are gathered by one pass because they are read off the same
+// block: a second walk over the same documents is exactly how the id universe
+// and the resource universe drift apart.
+export interface ComponentDeclarations {
+  readonly ids: Set<string>;
+  readonly resources: Map<string, string>;
+}
+
+// Resource paths inside a scene are project-absolute; documents are keyed by
+// project-relative display path, the same convention `resourceKey` follows in
+// `scene-object-path-index.ts`.
+function resourceKey(resource: string): string {
+  return resource.startsWith("/") ? resource.slice(1) : resource;
+}
+
 function collect(
   message: SceneMessage,
   blockName: string,
   depth: number,
   displayPath: string,
-  ids: Set<string>,
+  declarations: ComponentDeclarations,
   incomplete: string[],
 ): void {
   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);
+    }
+    // `embedded_components` is skipped on purpose: its payload *is* the
+    // component, so it names no resource and must never be credited with one.
+    if (blockName === "components") {
+      const [id] = declared;
+      const [component] = message.fields.get("component") ?? [];
+      if (id !== undefined && id !== "" && component !== undefined) {
+        declarations.resources.set(id, resourceKey(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;
         incomplete.push(
@@ -47,11 +80,44 @@ function collect(
   }
   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);
     }
   }
 }
 
+/**
+ * Every component id one already-parsed scene message declares, plus the
+ * resource each *referenced* component names, following the two `data:`
+ * payloads Defold embeds a whole document in. Exported because the game-object
+ * path walk attributes components to the object that owns them and must read
+ * the same rule this index reads — a second collector is exactly how the two
+ * universes drift apart.
+ *
+ * `blockName` names the block `message` was taken from, because the `data:`
+ * re-parse is keyed off it: a whole document is `""`, while a single
+ * `embedded_instances` block has to say so or its payload is never opened.
+ */
+export function collectComponentDeclarations(
+  message: SceneMessage,
+  displayPath: string,
+  incomplete: string[],
+  blockName = "",
+): ComponentDeclarations {
+  const declarations: ComponentDeclarations = { ids: new Set(), resources: new Map() };
+  collect(message, blockName, 0, displayPath, declarations, incomplete);
+  return declarations;
+}
+
+/** The id half of {@link collectComponentDeclarations}, for callers that join no resources. */
+export function collectComponentIds(
+  message: SceneMessage,
+  displayPath: string,
+  incomplete: string[],
+  blockName = "",
+): Set<string> {
+  return collectComponentDeclarations(message, displayPath, incomplete, blockName).ids;
+}
+
 // Build the component-id universe from already-read scene sources: keys are
 // display paths, values are file text. Pure — the filesystem walk belongs to the
 // caller, so a test can drive this from inline strings and a build can drive it
@@ -69,7 +135,9 @@ export function buildSceneComponentIndex(
 
   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;
       incomplete.push(`${displayPath}: could not be parsed (${error.message})`);

package/src/scene-documents.ts

@@ -1,3 +1,4 @@
+import { readLibrarySceneDocuments } from "./library-dependencies";
 import { isDefignoredPath } from "./project-resources";
 
 // The narrow slice of `ts.server.ServerHost` this needs: the real host
@@ -18,9 +19,42 @@ export const SCENE_EXTENSIONS = [".go", ".collection"];
 export const GUI_EXTENSIONS = [".gui"];
 export const INPUT_BINDING_EXTENSIONS = [".input_binding"];
 
-// The documents an animation id is declared by: an atlas or tile source names
-// the ids, and a `.sprite` is the hop a referenced component takes to reach one.
-export const ANIMATION_ASSET_EXTENSIONS = [".atlas", ".tilesource", ".sprite"];
+// The component files that name a collection without instancing it: a
+// `.collectionproxy` opens it as its own world, a `.collectionfactory` spawns
+// copies of it at runtime. Deliberately not folded into `SCENE_EXTENSIONS`,
+// which would feed non-scene text to `buildSceneComponentIndex`.
+export const COLLECTION_REFERENCE_EXTENSIONS = [".collectionproxy", ".collectionfactory"];
+
+// The documents an animation id is declared by, plus every hop taken to reach
+// one: an atlas or tile source names a sprite's ids outright, a `.animationset`
+// names the files whose basenames are a model's ids, and a `.sprite` or
+// `.model` is the hop a referenced component takes to reach either.
+export const ANIMATION_ASSET_EXTENSIONS = [
+  ".atlas",
+  ".tilesource",
+  ".sprite",
+  ".model",
+  ".animationset",
+];
+
+// The file kinds a library shares into the address universe: the documents that
+// declare ids, plus the ones that *classify* a collection into the world it is —
+// a library's own `.collectionproxy` is what says its collection is a proxy
+// world rather than reached by nothing. `.input_binding` and `.project` are
+// deliberately absent: `game.project` names exactly one active binding file, and
+// a vendored `*.project` declares keys this project's readers cannot resolve —
+// the rule `PROJECT_EXTENSIONS` states below.
+//
+// It lives here rather than beside its reader for the reason the sets above do,
+// plus one more: `library-dependencies.ts` and this file import each other, and
+// a constant built from these arrays at that module's top level would read them
+// before this one had run.
+export const LIBRARY_SCENE_EXTENSIONS = [
+  ...SCENE_EXTENSIONS,
+  ...GUI_EXTENSIONS,
+  ...ANIMATION_ASSET_EXTENSIONS,
+  ...COLLECTION_REFERENCE_EXTENSIONS,
+];
 
 // The walk returns every `.project` the project holds, so the lookup is by
 // display path — a vendored `*.project` declares keys this project's readers
@@ -70,18 +104,32 @@ export function isExcludedProjectPath(displayPath: string): boolean {
 // silent hole cannot be reasoned about. `paths` names the host paths actually
 // read — what a watcher must be registered on, which cannot be reconstructed
 // from a display path for a file outside the project root.
+//
+// The universe is the project plus whatever `resolve` last materialized from its
+// library dependencies: a library document joins it under the merged Defold
+// resource path it is addressed by, with its origin recorded in `origins` rather
+// than folded into the key, and the project's own file wins a collision. Which
+// makes the universe only as current as the last `resolve` — so a dependency
+// that is declared but unresolved, unreadable or shadowed is a named
+// `unreadable` line, never a silent omission.
 export function readSceneDocuments(
   host: SceneReadHost,
   projectRoot: string,
   extensions: readonly string[] = SCENE_EXTENSIONS,
-): { documents: Map<string, string>; unreadable: string[]; paths: string[] } {
+): {
+  documents: Map<string, string>;
+  origins: Map<string, string>;
+  unreadable: string[];
+  paths: string[];
+} {
   const documents = new Map<string, string>();
+  const origins = new Map<string, string>();
   const unreadable: string[] = [];
   const paths: string[] = [];
 
   if (!host.readDirectory) {
     unreadable.push("the editor host cannot enumerate project files, so no scene source was read");
-    return { documents, unreadable, paths };
+    return { documents, origins, unreadable, paths };
   }
 
   for (const filePath of host.readDirectory(projectRoot, extensions)) {
@@ -96,7 +144,19 @@ export function readSceneDocuments(
     paths.push(filePath);
   }
 
-  return { documents, unreadable, paths };
+  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 };
 }
 
 // The project's own files of the given kinds, as the `/`-prefixed

package/src/scene-naming-context.ts

@@ -0,0 +1,130 @@
+import type { SceneObjectPathIndex } from "./scene-object-path-index";
+
+/**
+ * One place a script runs, and the addressing frame it runs in. At runtime an
+ * instance carries `m_CollectionPathHashState` seeded from its compiled id up
+ * to and including the last `/`, and `GetAbsoluteIdentifier` resolves a
+ * relative string by continuing that hash — so a relative address written in a
+ * script means one thing from this object and nothing anywhere else.
+ */
+export interface NamingContext {
+  /** The world-qualified composed path of the object hosting the script. */
+  readonly object: string;
+  /** The proxy socket this object lives behind, or `undefined` in the bootstrap world. */
+  readonly socket: string | undefined;
+  /**
+   * `object` through its last `/`, inclusive — the collection path a relative
+   * address continues. World-qualified by construction, so a relative address
+   * can never resolve across a world.
+   */
+  readonly prefix: string;
+}
+
+const SCRIPT_SUFFIX = ".script";
+const GUI_SUFFIX = ".gui";
+
+/**
+ * The proxy socket an address names, or `undefined` when it names none — a
+ * bootstrap-world path, a relative path, a bare `#fragment`.
+ *
+ * Defold's address grammar is `[socket:][path][#fragment]` with both bracketed
+ * halves optional, so `mylevel:`, `mylevel:enemy` and `mylevel:#body` are as
+ * socket-qualified as `mylevel:/path`. The socket is therefore read from the
+ * `:` delimiter rather than from a following `/`: the head is the address up to
+ * the first `/` or `#` (the whole address when it carries neither), and the
+ * socket is the text before that head's first `:`. A `:` inside a path segment
+ * (`/level:1/enemy`) is not a socket, because the `/` closes the head first,
+ * and an empty socket (`:path`) is none.
+ *
+ * Exported because a written address literal and a composed object path are the
+ * same shape: the cross-world check reads a socket out of source text with this
+ * one rule rather than a second reader that could disagree with the contexts it
+ * compares against.
+ */
+export function socketOfAddress(address: string): string | undefined {
+  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: string): NamingContext {
+  return {
+    object,
+    socket: socketOfAddress(object),
+    prefix: object.slice(0, object.lastIndexOf("/") + 1),
+  };
+}
+
+/**
+ * Every naming context each script resource runs in, keyed by that resource and
+ * sorted by object path.
+ *
+ * `guiScripts` maps a `.gui` display path to the gui-script resource it names,
+ * which the caller builds with `guiScriptResourceOf` — the walk needs no `.gui`
+ * documents of its own.
+ *
+ * A script hosted by several objects has several contexts, and that is not
+ * ambiguity: a `.go` instanced in two collections genuinely runs in both, and
+ * it is the consumer's provenance that tells an author which context an entry
+ * resolves from.
+ */
+export function buildScriptNamingContexts(
+  index: SceneObjectPathIndex,
+  guiScripts: ReadonlyMap<string, string>,
+): ReadonlyMap<string, readonly NamingContext[]> {
+  const contexts = new Map<string, NamingContext[]>();
+
+  for (const [object, resources] of index.componentResourcesOf) {
+    for (const resource of resources.values()) {
+      const script = resource.endsWith(SCRIPT_SUFFIX)
+        ? 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 hosted of contexts.values()) {
+    hosted.sort((a, b) => a.object.localeCompare(b.object));
+  }
+  return contexts;
+}
+
+/**
+ * The relative forms a script may write from one naming context: every object
+ * path under the context's prefix with that prefix stripped, and each of those
+ * joined to the components its object owns.
+ *
+ * An object `componentsOf` withheld still contributes its path — the object is
+ * provably there — but no `#component` join, because which components it owns
+ * was never read.
+ */
+export function relativeAddressesFrom(
+  index: SceneObjectPathIndex,
+  context: NamingContext,
+): { readonly paths: ReadonlySet<string>; readonly addresses: ReadonlySet<string> } {
+  const paths = new Set<string>();
+  const addresses = new Set<string>();
+
+  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 };
+}