@loaders.gl/tile-converter 4.1.0-alpha.1 → 4.1.0-alpha.10

package/dist/index.cjs

@@ -250,7 +250,7 @@ var AttributeMetadataInfo = class {
 // src/i3s-converter/i3s-converter.ts
 var import_core9 = require("@loaders.gl/core");
 var import_d_tiles2 = require("@loaders.gl/3d-tiles");
-var import_path7 = require("path");
+var import_path8 = require("path");
 var import_uuid4 = require("uuid");
 var import_process3 = __toESM(require("process"), 1);
 var import_json_map_transform8 = __toESM(require("json-map-transform"), 1);
@@ -3134,6 +3134,7 @@ function isAllVerticesInsideBoundingVolume(boundingVolume, positions) {
 
 // src/i3s-converter/i3s-converter.ts
 var import_textures = require("@loaders.gl/textures");
+var import_loader_utils4 = require("@loaders.gl/loader-utils");
 var import_images = require("@loaders.gl/images");
 var import_worker_utils2 = require("@loaders.gl/worker-utils");
 
@@ -3157,10 +3158,11 @@ var Queue = class extends Array {
 var import_process = __toESM(require("process"), 1);
 var MEMORY_LIMIT = 4 * 1024 * 1024 * 1024;
 var WriteQueue = class extends Queue {
-  constructor(listeningInterval = 2e3, writeConcurrency = 400) {
+  constructor(conversionDump, listeningInterval = 2e3, writeConcurrency = 400) {
     super();
     this.writePromise = null;
     this.fileMap = {};
+    this.conversionDump = conversionDump;
     this.listeningInterval = listeningInterval;
     this.writeConcurrency = writeConcurrency;
   }
@@ -3201,18 +3203,21 @@ var WriteQueue = class extends Queue {
     while (this.length) {
       const promises = [];
       const archiveKeys = [];
+      const changedRecords = [];
       for (let i = 0; i < this.writeConcurrency; i++) {
         const item = this.dequeue();
         if (!item) {
           break;
         }
-        const { archiveKey, writePromise } = item;
+        const { archiveKey, sourceId, outputId, resourceType, writePromise } = item;
         archiveKeys.push(archiveKey);
+        changedRecords.push({ sourceId, outputId, resourceType });
         const promise = writePromise();
         promises.push(promise);
       }
       const writeResults = await Promise.allSettled(promises);
       this.updateFileMap(archiveKeys, writeResults);
+      await this.conversionDump.updateConvertedTilesDump(changedRecords, writeResults);
     }
   }
   updateFileMap(archiveKeys, writeResults) {
@@ -3227,6 +3232,7 @@ var WriteQueue = class extends Queue {
 
 // src/constants.ts
 var BROWSER_ERROR_MESSAGE = "Tile converter does not work in browser, only in node js environment";
+var DUMP_FILE_SUFFIX = ".dump.json";
 
 // src/i3s-converter/helpers/node-index-document.ts
 var import_path6 = require("path");
@@ -3902,6 +3908,169 @@ var Progress = class {
   }
 };
 
+// src/i3s-converter/i3s-converter.ts
+var import_zip = require("@loaders.gl/zip");
+
+// src/lib/utils/conversion-dump.ts
+var import_path7 = require("path");
+var ConversionDump = class {
+  constructor() {
+    this.tilesConverted = {};
+  }
+  /**
+   * Create a dump file with convertion options
+   * @param options - converter options
+   */
+  async createDumpFile(options) {
+    const {
+      tilesetName,
+      slpk,
+      egmFilePath,
+      inputUrl,
+      outputPath,
+      draco = true,
+      maxDepth,
+      token,
+      generateTextures,
+      generateBoundingVolumes,
+      mergeMaterials: mergeMaterials2 = true,
+      metadataClass,
+      analyze = false
+    } = options;
+    this.options = {
+      tilesetName,
+      slpk,
+      egmFilePath,
+      inputUrl,
+      outputPath,
+      draco,
+      maxDepth,
+      token,
+      generateTextures,
+      generateBoundingVolumes,
+      mergeMaterials: mergeMaterials2,
+      metadataClass,
+      analyze
+    };
+    try {
+      await writeFile(
+        options.outputPath,
+        JSON.stringify({ options: this.options }),
+        `${options.tilesetName}${DUMP_FILE_SUFFIX}`
+      );
+    } catch (error) {
+      console.log("Can't create dump file", error);
+    }
+  }
+  /**
+   * Update conversion status in the dump file
+   */
+  async updateDumpFile() {
+    var _a2;
+    if (((_a2 = this.options) == null ? void 0 : _a2.outputPath) && this.options.tilesetName) {
+      try {
+        await writeFile(
+          this.options.outputPath,
+          JSON.stringify({
+            options: this.options,
+            tilesConverted: this.tilesConverted
+          }),
+          `${this.options.tilesetName}${DUMP_FILE_SUFFIX}`
+        );
+      } catch (error) {
+        console.log("Can't update dump file", error);
+      }
+    }
+  }
+  /**
+   * Delete a dump file
+   */
+  async deleteDumpFile() {
+    var _a2;
+    if (((_a2 = this.options) == null ? void 0 : _a2.outputPath) && this.options.tilesetName) {
+      await removeFile(
+        (0, import_path7.join)(this.options.outputPath, `${this.options.tilesetName}${DUMP_FILE_SUFFIX}`)
+      );
+    }
+  }
+  /**
+   * Get record from the tilesConverted Map
+   * @param fileName - source filename
+   * @returns existing object from the tilesConverted Map
+   */
+  getRecord(fileName) {
+    return this.tilesConverted[fileName];
+  }
+  /**
+   * Set a record for the dump file
+   * @param fileName - key - source filename
+   * @param object - value
+   */
+  setRecord(fileName, object) {
+    this.tilesConverted[fileName] = object;
+  }
+  /**
+   * Add a node into the dump file for the source file record
+   * @param fileName - source filename
+   * @param nodeId - nodeId of the node
+   */
+  async addNode(filename, nodeId) {
+    const { nodes } = this.getRecord(filename) || { nodes: [] };
+    nodes.push({ nodeId, done: {} });
+    if (nodes.length === 1) {
+      this.setRecord(filename, { nodes });
+    }
+    await this.updateDumpFile();
+  }
+  /**
+   * Update done status object for the writing resources
+   * @param fileName - key - source filename
+   * @param nodeId - nodeId for the source filename
+   * @param resourceType - resource type to update status
+   * @param value - value
+   */
+  updateDoneStatus(filename, nodeId, resourceType, value) {
+    var _a2;
+    const nodeDump = (_a2 = this.tilesConverted[filename]) == null ? void 0 : _a2.nodes.find(
+      (element) => element.nodeId === nodeId
+    );
+    if (nodeDump) {
+      nodeDump.done[resourceType] = value;
+    }
+  }
+  /**
+   * Update dump file according to writing results
+   * @param changedRecords - array of parameters ids for the written resources
+   * @param writeResults - array of writing resource files results
+   */
+  async updateConvertedTilesDump(changedRecords, writeResults) {
+    for (let i = 0; i < changedRecords.length; i++) {
+      if (changedRecords[i] && "value" in writeResults[i]) {
+        const { sourceId, resourceType, outputId } = changedRecords[i];
+        if (!sourceId || !resourceType || !outputId)
+          continue;
+        for (const node of this.tilesConverted[sourceId].nodes) {
+          if (typeof node.done !== "boolean" && node.nodeId === outputId) {
+            node.done[resourceType] = true;
+          }
+          if (typeof node.done !== "boolean") {
+            let done = false;
+            for (const key in node.done) {
+              done = node.done[key];
+              if (!done)
+                break;
+            }
+            if (done) {
+              node.done = true;
+            }
+          }
+        }
+      }
+    }
+    await this.updateDumpFile();
+  }
+};
+
 // src/i3s-converter/i3s-converter.ts
 var _a;
 var ION_DEFAULT_TOKEN = (_a = import_process3.default.env) == null ? void 0 : _a.IonToken;
@@ -3934,7 +4103,7 @@ var I3SConverter = class {
     this.geoidHeightModel = null;
     this.Loader = import_d_tiles2.Tiles3DLoader;
     this.workerSource = {};
-    this.writeQueue = new WriteQueue();
+    this.writeQueue = new WriteQueue(new ConversionDump());
     this.compressList = null;
     this.preprocessData = {
       meshTopologyTypes: /* @__PURE__ */ new Set(),
@@ -3961,6 +4130,7 @@ var I3SConverter = class {
     this.generateBoundingVolumes = false;
     this.layersHasTexture = false;
     this.compressList = null;
+    this.conversionDump = new ConversionDump();
   }
   /**
    * Convert a 3d tileset
@@ -4005,6 +4175,8 @@ var I3SConverter = class {
       analyze = false
     } = options;
     this.options = {
+      outputPath,
+      tilesetName,
       maxDepth,
       slpk,
       sevenZipExe,
@@ -4023,7 +4195,7 @@ var I3SConverter = class {
     this.Loader = inputUrl.indexOf(CESIUM_DATASET_PREFIX) !== -1 ? import_d_tiles2.CesiumIonLoader : import_d_tiles2.Tiles3DLoader;
     this.generateTextures = Boolean(generateTextures);
     this.generateBoundingVolumes = Boolean(generateBoundingVolumes);
-    this.writeQueue = new WriteQueue();
+    this.writeQueue = new WriteQueue(this.conversionDump);
     this.writeQueue.startListening();
     console.log("Loading egm file...");
     this.geoidHeightModel = await (0, import_core9.load)(egmFilePath, PGMLoader);
@@ -4031,6 +4203,7 @@ var I3SConverter = class {
     if (slpk) {
       this.nodePages.useWriteFunction(writeFileForSlpk);
     }
+    await this.conversionDump.createDumpFile(options);
     try {
       const preloadOptions = await this._fetchPreloadOptions();
       let tilesetUrl = inputUrl;
@@ -4164,12 +4337,12 @@ var I3SConverter = class {
    */
   async _createAndSaveTileset(outputPath, tilesetName) {
     var _a2, _b, _c;
-    const tilesetPath = (0, import_path7.join)(`${outputPath}`, `${tilesetName}`);
+    const tilesetPath = (0, import_path8.join)(`${outputPath}`, `${tilesetName}`);
     try {
       await removeDir(tilesetPath);
     } catch (e) {
     }
-    this.layers0Path = (0, import_path7.join)(tilesetPath, "SceneServer", "layers", "0");
+    this.layers0Path = (0, import_path8.join)(tilesetPath, "SceneServer", "layers", "0");
     this.materialDefinitions = [];
     this.materialMap = /* @__PURE__ */ new Map();
     const sourceRootTile = this.sourceTileset.root;
@@ -4286,8 +4459,9 @@ var I3SConverter = class {
    * @param tilesetPath - Path to save file
    */
   async _createSlpk(tilesetPath) {
+    await this.conversionDump.deleteDumpFile();
     if (this.options.slpk) {
-      const slpkTilesetPath = (0, import_path7.join)(tilesetPath, "SceneServer", "layers", "0");
+      const slpkTilesetPath = (0, import_path8.join)(tilesetPath, "SceneServer", "layers", "0");
       const slpkFileName = `${tilesetPath}.slpk`;
       await compressWithChildProcess(
         slpkTilesetPath,
@@ -4296,6 +4470,8 @@ var I3SConverter = class {
         ".",
         this.options.sevenZipExe
       );
+      const hashTable = await (0, import_zip.composeHashFile)(new import_loader_utils4.FileHandleFile(slpkFileName));
+      await (0, import_zip.addOneFile)(slpkFileName, hashTable, "@specialIndexFileHASH128@");
       try {
         await removeDir(tilesetPath);
       } catch (e) {
@@ -4436,7 +4612,10 @@ var I3SConverter = class {
       const node = await new NodeIndexDocument(nodeInPage.index, this).addData(nodeData);
       nodes.push(node);
       if (nodeInPage.mesh) {
-        await this._writeResources(resources, node.id);
+        if (sourceTile.id) {
+          await this.conversionDump.addNode(sourceTile.id, nodeInPage.index);
+        }
+        await this._writeResources(resources, node.id, sourceTile);
       }
       if (this.validate) {
         this.boundingVolumeWarnings = validateNodeBoundingVolumes(nodeData);
@@ -4560,9 +4739,11 @@ var I3SConverter = class {
    * @param resources.texture - texture image
    * @param resources.sharedResources - shared resource data object
    * @param resources.attributes - feature attributes
+   * @param nodePath - node path
+   * @param sourceTile - source tile (3DTile)
    * @return {Promise<void>}
    */
-  async _writeResources(resources, nodePath) {
+  async _writeResources(resources, nodePath, sourceTile) {
     const {
       geometry: geometryBuffer,
       compressedGeometry,
@@ -4570,12 +4751,38 @@ var I3SConverter = class {
       sharedResources,
       attributes
     } = resources;
-    const childPath = (0, import_path7.join)(this.layers0Path, "nodes", nodePath);
-    const slpkChildPath = (0, import_path7.join)("nodes", nodePath);
-    await this._writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath);
-    await this._writeShared(sharedResources, childPath, slpkChildPath, nodePath);
-    await this._writeTexture(texture, childPath, slpkChildPath);
-    await this._writeAttributes(attributes, childPath, slpkChildPath);
+    const childPath = (0, import_path8.join)(this.layers0Path, "nodes", nodePath);
+    const slpkChildPath = (0, import_path8.join)("nodes", nodePath);
+    await this._writeGeometries(
+      geometryBuffer,
+      compressedGeometry,
+      childPath,
+      slpkChildPath,
+      sourceTile.id || "",
+      parseInt(nodePath)
+    );
+    await this._writeShared(
+      sharedResources,
+      childPath,
+      slpkChildPath,
+      nodePath,
+      sourceTile.id || "",
+      parseInt(nodePath)
+    );
+    await this._writeTexture(
+      texture,
+      childPath,
+      slpkChildPath,
+      sourceTile.id || "",
+      parseInt(nodePath)
+    );
+    await this._writeAttributes(
+      attributes,
+      childPath,
+      slpkChildPath,
+      sourceTile.id || "",
+      parseInt(nodePath)
+    );
   }
   /**
    * Write non-compressed and compressed geometries in files
@@ -4583,30 +4790,46 @@ var I3SConverter = class {
    * @param compressedGeometry - Uint8Array with compressed (draco) geometry
    * @param childPath - a child path to write resources
    * @param slpkChildPath - resource path inside *slpk file
+   * @param sourceId - source filename
+   * @param nodeId - nodeId of a converted node for the writing
    */
-  async _writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath) {
+  async _writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath, sourceId, nodeId) {
+    this.conversionDump.updateDoneStatus(sourceId, nodeId, "GEOMETRY" /* GEOMETRY */, false);
     if (this.options.slpk) {
-      const slpkGeometryPath = (0, import_path7.join)(childPath, "geometries");
+      const slpkGeometryPath = (0, import_path8.join)(childPath, "geometries");
       await this.writeQueue.enqueue({
         archiveKey: `${slpkChildPath}/geometries/0.bin.gz`,
+        sourceId,
+        outputId: nodeId,
+        resourceType: "GEOMETRY" /* GEOMETRY */,
         writePromise: () => writeFileForSlpk(slpkGeometryPath, geometryBuffer, "0.bin")
       });
     } else {
-      const geometryPath = (0, import_path7.join)(childPath, "geometries/0/");
+      const geometryPath = (0, import_path8.join)(childPath, "geometries/0/");
       await this.writeQueue.enqueue({
+        sourceId,
+        outputId: nodeId,
+        resourceType: "GEOMETRY" /* GEOMETRY */,
         writePromise: () => writeFile(geometryPath, geometryBuffer, "index.bin")
       });
     }
     if (this.options.draco) {
+      this.conversionDump.updateDoneStatus(sourceId, nodeId, "DRACO_GEOMETRY" /* DRACO_GEOMETRY */, false);
       if (this.options.slpk) {
-        const slpkCompressedGeometryPath = (0, import_path7.join)(childPath, "geometries");
+        const slpkCompressedGeometryPath = (0, import_path8.join)(childPath, "geometries");
         await this.writeQueue.enqueue({
           archiveKey: `${slpkChildPath}/geometries/1.bin.gz`,
+          sourceId,
+          outputId: nodeId,
+          resourceType: "DRACO_GEOMETRY" /* DRACO_GEOMETRY */,
           writePromise: () => writeFileForSlpk(slpkCompressedGeometryPath, compressedGeometry, "1.bin")
         });
       } else {
-        const compressedGeometryPath = (0, import_path7.join)(childPath, "geometries/1/");
+        const compressedGeometryPath = (0, import_path8.join)(childPath, "geometries/1/");
         await this.writeQueue.enqueue({
+          sourceId,
+          outputId: nodeId,
+          resourceType: "DRACO_GEOMETRY" /* DRACO_GEOMETRY */,
           writePromise: () => writeFile(compressedGeometryPath, compressedGeometry, "index.bin")
         });
       }
@@ -4618,23 +4841,34 @@ var I3SConverter = class {
    * @param childPath - a child path to write resources
    * @param slpkChildPath - resource path inside *slpk file
    * @param nodePath - a node path
+   * @param sourceId - source filename
+   * @param nodeId - nodeId of a converted node for the writing
    */
-  async _writeShared(sharedResources, childPath, slpkChildPath, nodePath) {
+  async _writeShared(sharedResources, childPath, slpkChildPath, nodePath, sourceId, nodeId) {
     if (!sharedResources) {
       return;
     }
     sharedResources.nodePath = nodePath;
     const sharedData = (0, import_json_map_transform8.default)(sharedResources, SHARED_RESOURCES());
     const sharedDataStr = JSON.stringify(sharedData);
+    this.conversionDump.updateDoneStatus(sourceId, nodeId, "SHARED" /* SHARED */, false);
     if (this.options.slpk) {
-      const slpkSharedPath = (0, import_path7.join)(childPath, "shared");
+      const slpkSharedPath = (0, import_path8.join)(childPath, "shared");
       await this.writeQueue.enqueue({
         archiveKey: `${slpkChildPath}/shared/sharedResource.json.gz`,
+        sourceId,
+        outputId: nodeId,
+        resourceType: "SHARED" /* SHARED */,
         writePromise: () => writeFileForSlpk(slpkSharedPath, sharedDataStr, "sharedResource.json")
       });
     } else {
-      const sharedPath = (0, import_path7.join)(childPath, "shared/");
-      await this.writeQueue.enqueue({ writePromise: () => writeFile(sharedPath, sharedDataStr) });
+      const sharedPath = (0, import_path8.join)(childPath, "shared/");
+      await this.writeQueue.enqueue({
+        sourceId,
+        outputId: nodeId,
+        resourceType: "SHARED" /* SHARED */,
+        writePromise: () => writeFile(sharedPath, sharedDataStr)
+      });
     }
   }
   /**
@@ -4642,8 +4876,10 @@ var I3SConverter = class {
    * @param texture - the texture image
    * @param childPath - a child path to write resources
    * @param slpkChildPath - the resource path inside *slpk file
+   * @param sourceId - source filename
+   * @param nodeId - nodeId of a converted node for the writing
    */
-  async _writeTexture(texture, childPath, slpkChildPath) {
+  async _writeTexture(texture, childPath, slpkChildPath, sourceId, nodeId) {
     if (texture) {
       const format = this._getFormatByMimeType(texture == null ? void 0 : texture.mimeType);
       const formats = [];
@@ -4652,13 +4888,28 @@ var I3SConverter = class {
         case "jpg":
         case "png": {
           formats.push({ name: "0", format });
-          await this.writeTextureFile(textureData, "0", format, childPath, slpkChildPath);
+          this.conversionDump.updateDoneStatus(
+            sourceId,
+            nodeId,
+            `${"TEXTURE" /* TEXTURE */}/${format}`,
+            false
+          );
+          await this.writeTextureFile(
+            textureData,
+            "0",
+            format,
+            childPath,
+            slpkChildPath,
+            sourceId,
+            nodeId
+          );
           if (this.generateTextures) {
             formats.push({ name: "1", format: "ktx2" });
             const copyArrayBuffer = texture.image.data.subarray();
             const arrayToEncode = new Uint8Array(copyArrayBuffer);
             const ktx2TextureData = (0, import_core9.encode)(
               { ...texture.image, data: arrayToEncode },
+              // @ts-expect-error - Worker encoder typing is still WIP
               import_textures.KTX2BasisWriterWorker,
               {
                 ...import_textures.KTX2BasisWriterWorker.options,
@@ -4671,22 +4922,58 @@ var I3SConverter = class {
                 useLocalLibraries: true
               }
             );
-            await this.writeTextureFile(ktx2TextureData, "1", "ktx2", childPath, slpkChildPath);
+            this.conversionDump.updateDoneStatus(
+              sourceId,
+              nodeId,
+              `${"TEXTURE" /* TEXTURE */}/ktx2`,
+              false
+            );
+            await this.writeTextureFile(
+              ktx2TextureData,
+              "1",
+              "ktx2",
+              childPath,
+              slpkChildPath,
+              sourceId,
+              nodeId
+            );
           }
           break;
         }
         case "ktx2": {
           formats.push({ name: "1", format });
-          await this.writeTextureFile(textureData, "1", format, childPath, slpkChildPath);
+          this.conversionDump.updateDoneStatus(
+            sourceId,
+            nodeId,
+            `${"TEXTURE" /* TEXTURE */}/${format}`,
+            false
+          );
+          await this.writeTextureFile(
+            textureData,
+            "1",
+            format,
+            childPath,
+            slpkChildPath,
+            sourceId,
+            nodeId
+          );
           if (this.generateTextures) {
             formats.push({ name: "0", format: "jpg" });
             const decodedFromKTX2TextureData = (0, import_core9.encode)(texture.image.data[0], import_images.ImageWriter);
+            this.conversionDump.updateDoneStatus(
+              sourceId,
+              nodeId,
+              `${"TEXTURE" /* TEXTURE */}/jpg`,
+              false
+            );
             await this.writeTextureFile(
               decodedFromKTX2TextureData,
               "0",
               "jpg",
               childPath,
-              slpkChildPath
+              slpkChildPath,
+              sourceId,
+              nodeId
             );
           }
         }
@@ -4704,18 +4991,26 @@ var I3SConverter = class {
    * @param format
    * @param childPath
    * @param slpkChildPath
+   * @param sourceId
+   * @param nodeId
    */
-  async writeTextureFile(textureData, name, format, childPath, slpkChildPath) {
+  async writeTextureFile(textureData, name, format, childPath, slpkChildPath, sourceId, nodeId) {
     if (this.options.slpk) {
-      const slpkTexturePath = (0, import_path7.join)(childPath, "textures");
+      const slpkTexturePath = (0, import_path8.join)(childPath, "textures");
       const compress = false;
       await this.writeQueue.enqueue({
         archiveKey: `${slpkChildPath}/textures/${name}.${format}`,
+        sourceId,
+        outputId: nodeId,
+        resourceType: `${"TEXTURE" /* TEXTURE */}/${format}`,
         writePromise: () => writeFileForSlpk(slpkTexturePath, textureData, `${name}.${format}`, compress)
       });
     } else {
-      const texturePath = (0, import_path7.join)(childPath, `textures/${name}/`);
+      const texturePath = (0, import_path8.join)(childPath, `textures/${name}/`);
       await this.writeQueue.enqueue({
+        sourceId,
+        outputId: nodeId,
+        resourceType: `${"TEXTURE" /* TEXTURE */}/${format}`,
         writePromise: () => writeFile(texturePath, textureData, `index.${format}`)
       });
     }
@@ -4725,22 +5020,36 @@ var I3SConverter = class {
    * @param attributes - feature attributes
    * @param childPath - a child path to write resources
    * @param slpkChildPath - the resource path inside *slpk file
+   * @param sourceId - source filename
+   * @param nodeId - nodeId of a converted node for the writing
    */
-  async _writeAttributes(attributes = [], childPath, slpkChildPath) {
+  async _writeAttributes(attributes = [], childPath, slpkChildPath, sourceId, nodeId) {
     if ((attributes == null ? void 0 : attributes.length) && this.attributeMetadataInfo.attributeStorageInfo.length) {
       const minimumLength = attributes.length < this.attributeMetadataInfo.attributeStorageInfo.length ? attributes.length : this.attributeMetadataInfo.attributeStorageInfo.length;
       for (let index = 0; index < minimumLength; index++) {
         const folderName = this.attributeMetadataInfo.attributeStorageInfo[index].key;
         const fileBuffer = new Uint8Array(attributes[index]);
+        this.conversionDump.updateDoneStatus(
+          sourceId,
+          nodeId,
+          `${"ATTRIBUTES" /* ATTRIBUTES */}/${folderName}`,
+          false
+        );
         if (this.options.slpk) {
-          const slpkAttributesPath = (0, import_path7.join)(childPath, "attributes", folderName);
+          const slpkAttributesPath = (0, import_path8.join)(childPath, "attributes", folderName);
           await this.writeQueue.enqueue({
             archiveKey: `${slpkChildPath}/attributes/${folderName}.bin.gz`,
+            sourceId,
+            outputId: nodeId,
+            resourceType: `${"ATTRIBUTES" /* ATTRIBUTES */}/${folderName}`,
             writePromise: () => writeFileForSlpk(slpkAttributesPath, fileBuffer, "0.bin")
           });
         } else {
-          const attributesPath = (0, import_path7.join)(childPath, `attributes/${folderName}/0`);
+          const attributesPath = (0, import_path8.join)(childPath, `attributes/${folderName}/0`);
           await this.writeQueue.enqueue({
+            sourceId,
+            outputId: nodeId,
+            resourceType: `${"ATTRIBUTES" /* ATTRIBUTES */}/${folderName}`,
             writePromise: () => writeFile(attributesPath, fileBuffer, "index.bin")
           });
         }
@@ -4887,7 +5196,7 @@ var I3SConverter = class {
 };
 
 // src/3d-tiles-converter/3d-tiles-converter.ts
-var import_path8 = require("path");
+var import_path9 = require("path");
 var import_process4 = __toESM(require("process"), 1);
 var import_json_map_transform10 = __toESM(require("json-map-transform"), 1);
 var import_core15 = require("@loaders.gl/core");
@@ -5335,7 +5644,7 @@ var Tiles3DConverter = class {
     if (!rootNode.obb) {
       rootNode.obb = createObbFromMbs(rootNode.mbs);
     }
-    this.tilesetPath = (0, import_path8.join)(`${outputPath}`, `${tilesetName}`);
+    this.tilesetPath = (0, import_path9.join)(`${outputPath}`, `${tilesetName}`);
     this.attributeStorageInfo = this.sourceTileset.attributeStorageInfo;
     try {
       await removeDir(this.tilesetPath);