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

package/dist/index.cjs

@@ -115,6 +115,15 @@ var AttributeMetadataInfo = class {
       this._popupInfo = this.createPopupInfo(attributeNames);
     }
   }
+  /**
+   * Set AttributeMetadataInfo from object
+   * @param object - object with AttributeMetadataInfo props
+   */
+  fromObject(object) {
+    this._attributeStorageInfo = object.attributeStorageInfo;
+    this._fields = object.fields;
+    this._popupInfo = object.popupInfo;
+  }
   /**
    * Generates storage attribute for map segmentation.
    * @param attributeIndex - order index of attribute (f_0, f_1 ...).
@@ -257,7 +266,7 @@ var import_json_map_transform8 = __toESM(require("json-map-transform"), 1);
 var import_md52 = __toESM(require("md5"), 1);
 
 // src/i3s-converter/helpers/node-pages.ts
-var import_path3 = require("path");
+var import_path2 = require("path");
 var import_json_map_transform = __toESM(require("json-map-transform"), 1);
 
 // src/i3s-converter/json-templates/metadata.ts
@@ -287,17 +296,11 @@ var METADATA = () => ({
 var import_core = require("@loaders.gl/core");
 var import_loader_utils = require("@loaders.gl/loader-utils");
 var import_fs2 = require("fs");
-var import_path2 = require("path");
+var import_path = require("path");
 
 // src/lib/utils/compress-util.ts
 var import_zlib = require("zlib");
-var import_path = require("path");
 var import_fs = require("fs");
-var import_archiver = __toESM(require("archiver"), 1);
-var import_worker_utils = require("@loaders.gl/worker-utils");
-var import_jszip = __toESM(require("jszip"), 1);
-var import_crypto = require("@loaders.gl/crypto");
-var import_crypt = __toESM(require("crypt"), 1);
 function compressFileWithGzip(pathFile) {
   const compressedPathFile = `${pathFile}.gz`;
   const gzip = (0, import_zlib.createGzip)();
@@ -315,42 +318,6 @@ function compressFileWithGzip(pathFile) {
     input.pipe(gzip).pipe(output);
   });
 }
-async function compressWithChildProcess(inputFolder, outputFile, level, inputFiles, sevenZipExe) {
-  if (process.platform === "win32") {
-    await compressWithChildProcessWindows(inputFolder, outputFile, level, inputFiles, sevenZipExe);
-  } else {
-    await compressWithChildProcessUnix(inputFolder, outputFile, level, inputFiles);
-  }
-}
-async function compressWithChildProcessUnix(inputFolder, outputFile, level = 0, inputFiles = ".") {
-  const fullOutputFile = getAbsoluteFilePath(outputFile);
-  const args = [`-${level}`, "-r", fullOutputFile, inputFiles];
-  const childProcess = new import_worker_utils.ChildProcessProxy();
-  await childProcess.start({
-    command: "zip",
-    arguments: args,
-    spawn: {
-      cwd: inputFolder
-    },
-    wait: 0
-  });
-}
-async function compressWithChildProcessWindows(inputFolder, outputFile, level = 0, inputFiles = (0, import_path.join)(".", "*"), sevenZipExe) {
-  if (inputFiles[0] === "@") {
-    inputFiles = `*${inputFiles.substr(1)}`;
-  }
-  const fullOutputFile = getAbsoluteFilePath(outputFile);
-  const args = ["a", "-tzip", `-mx=${level}`, fullOutputFile, inputFiles];
-  const childProcess = new import_worker_utils.ChildProcessProxy();
-  await childProcess.start({
-    command: sevenZipExe,
-    arguments: args,
-    spawn: {
-      cwd: `${inputFolder}`
-    },
-    wait: 0
-  });
-}
 
 // src/lib/utils/file-utils.ts
 async function writeFile(path, data, fileName = "index.json") {
@@ -363,7 +330,7 @@ async function writeFile(path, data, fileName = "index.json") {
     toWriteData = data;
   }
   await import_fs2.promises.mkdir(path, { recursive: true });
-  const pathFile = (0, import_path2.join)(path, fileName);
+  const pathFile = (0, import_path.join)(path, fileName);
   try {
     await import_fs2.promises.writeFile(pathFile, toWriteData);
   } catch (err) {
@@ -395,7 +362,7 @@ async function openJson(path, fileName) {
     let count = 0;
     console.log(`load ${path}/${fileName}.`);
     const intervalId = setInterval(() => {
-      const pathFile = (0, import_path2.join)(path, fileName);
+      const pathFile = (0, import_path.join)(path, fileName);
       (0, import_core.load)(pathFile, import_loader_utils.JSONLoader).then((result) => {
         clearInterval(intervalId);
         resolve(result);
@@ -424,7 +391,7 @@ function removeFile(path) {
   return import_fs2.promises.unlink(path);
 }
 function getAbsoluteFilePath(filePath) {
-  return (0, import_path2.isAbsolute)(filePath) ? filePath : (0, import_path2.join)(process.cwd(), filePath);
+  return (0, import_path.isAbsolute)(filePath) ? filePath : (0, import_path.join)(process.cwd(), filePath);
 }
 
 // src/i3s-converter/helpers/node-pages.ts
@@ -461,10 +428,10 @@ var NodePages = class {
     let filePath;
     let fileName;
     if (this.converter.options.slpk) {
-      filePath = (0, import_path3.join)(this.converter.layers0Path, "nodepages");
+      filePath = (0, import_path2.join)(this.converter.layers0Path, "nodepages");
       fileName = `${nodePageId.toString()}.json`;
     } else {
-      filePath = (0, import_path3.join)(this.converter.layers0Path, "nodepages", nodePageId.toString());
+      filePath = (0, import_path2.join)(this.converter.layers0Path, "nodepages", nodePageId.toString());
       fileName = "index.json";
     }
     return { filePath, fileName };
@@ -476,7 +443,7 @@ var NodePages = class {
    */
   async loadNodePage(nodePageId) {
     const { filePath, fileName } = this.getNodePageFileName(nodePageId);
-    const fullName = (0, import_path3.join)(filePath, fileName);
+    const fullName = (0, import_path2.join)(filePath, fileName);
     if (await isFileExists(fullName)) {
       console.log(`load ${fullName}.`);
       return await openJson(filePath, fileName);
@@ -613,7 +580,7 @@ var NodePages = class {
     if (this.converter.options.slpk) {
       for (const [index, nodePage] of this.nodePages.entries()) {
         const nodePageStr = JSON.stringify(nodePage);
-        const slpkPath = (0, import_path3.join)(this.converter.layers0Path, "nodepages");
+        const slpkPath = (0, import_path2.join)(this.converter.layers0Path, "nodepages");
         await this.converter.writeQueue.enqueue({
           archiveKey: `nodePages/${index.toString()}.json.gz`,
           writePromise: () => this.writeFile(slpkPath, nodePageStr, `${index.toString()}.json`)
@@ -623,7 +590,7 @@ var NodePages = class {
     } else {
       for (const [index, nodePage] of this.nodePages.entries()) {
         const nodePageStr = JSON.stringify(nodePage);
-        const nodePagePath = (0, import_path3.join)(this.converter.layers0Path, "nodepages", index.toString());
+        const nodePagePath = (0, import_path2.join)(this.converter.layers0Path, "nodepages", index.toString());
         await this.converter.writeQueue.enqueue({
           writePromise: () => this.writeFile(nodePagePath, nodePageStr)
         });
@@ -709,7 +676,7 @@ var NodePages = class {
 };
 
 // src/lib/utils/statistic-utills.ts
-var import_path4 = require("path");
+var import_path3 = require("path");
 var import_fs3 = require("fs");
 function timeConverter(time) {
   if (typeof time === "number") {
@@ -741,7 +708,7 @@ function timeConverterFromSecondsAndMilliseconds(timeInSeconds, milliseconds) {
     result += `${seconds}s`;
   }
   if (!result) {
-    result += `${milliseconds}ms`;
+    result += `${Math.floor(milliseconds)}ms`;
   }
   return result;
 }
@@ -750,11 +717,11 @@ async function calculateFilesSize(params) {
   const fullOutputPath = getAbsoluteFilePath(outputPath);
   try {
     if (slpk) {
-      const slpkPath = (0, import_path4.join)(fullOutputPath, `${tilesetName}.slpk`);
+      const slpkPath = (0, import_path3.join)(fullOutputPath, `${tilesetName}.slpk`);
       const stat = await import_fs3.promises.stat(slpkPath);
       return stat.size;
     }
-    const directoryPath = (0, import_path4.join)(fullOutputPath, tilesetName);
+    const directoryPath = (0, import_path3.join)(fullOutputPath, tilesetName);
     const totalSize = await getTotalFilesSize(directoryPath);
     return totalSize;
   } catch (error) {
@@ -766,9 +733,9 @@ async function getTotalFilesSize(dirPath) {
   let totalFileSize = 0;
   const files = await import_fs3.promises.readdir(dirPath);
   for (const file of files) {
-    const fileStat = await import_fs3.promises.stat((0, import_path4.join)(dirPath, file));
+    const fileStat = await import_fs3.promises.stat((0, import_path3.join)(dirPath, file));
     if (fileStat.isDirectory()) {
-      totalFileSize += await getTotalFilesSize((0, import_path4.join)(dirPath, file));
+      totalFileSize += await getTotalFilesSize((0, import_path3.join)(dirPath, file));
     } else {
       totalFileSize += fileStat.size;
     }
@@ -2436,7 +2403,7 @@ function getPropertyTableExtension(tileContent) {
 // src/i3s-converter/helpers/create-scene-server-path.ts
 var import_uuid2 = require("uuid");
 var import_json_map_transform2 = __toESM(require("json-map-transform"), 1);
-var import_path5 = require("path");
+var import_path4 = require("path");
 
 // src/i3s-converter/json-templates/scene-server.ts
 var SCENE_SERVER = () => ({
@@ -2475,7 +2442,7 @@ async function createSceneServerPath(layerName, layers0, rootPath) {
     layers0
   };
   const sceneServer = (0, import_json_map_transform2.default)(sceneServerData, SCENE_SERVER());
-  const nodePagePath = (0, import_path5.join)(rootPath, "SceneServer");
+  const nodePagePath = (0, import_path4.join)(rootPath, "SceneServer");
   await writeFile(nodePagePath, JSON.stringify(sceneServer));
 }
 
@@ -3134,9 +3101,8 @@ 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");
+var import_worker_utils = require("@loaders.gl/worker-utils");
 
 // src/lib/utils/queue.ts
 var Queue = class extends Array {
@@ -3158,10 +3124,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;
   }
@@ -3202,18 +3169,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) {
@@ -3228,9 +3198,10 @@ 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");
+var import_path5 = require("path");
 var import_json_map_transform7 = __toESM(require("json-map-transform"), 1);
 var import_uuid3 = require("uuid");
 
@@ -3433,7 +3404,7 @@ var NodeIndexDocument = class {
    * @param node - Node3DIndexDocument object
    */
   async write(node) {
-    const path = (0, import_path6.join)(this.converter.layers0Path, "nodes", this.id);
+    const path = (0, import_path5.join)(this.converter.layers0Path, "nodes", this.id);
     if (this.converter.options.slpk) {
       await this.converter.writeQueue.enqueue(
         {
@@ -3464,7 +3435,7 @@ var NodeIndexDocument = class {
       return this.data;
     }
     const path = this.id;
-    const parentNodePath = (0, import_path6.join)(this.converter.layers0Path, "nodes", path);
+    const parentNodePath = (0, import_path5.join)(this.converter.layers0Path, "nodes", path);
     let parentNodeFileName = "index.json";
     if (this.converter.options.slpk) {
       parentNodeFileName = "3dNodeIndexDocument.json";
@@ -3546,8 +3517,7 @@ var NodeIndexDocument = class {
    * @return 3DNodeIndexDocument https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DNodeIndexDocument.cmn.md object
    */
   static async createNodeIndexDocument(parentNode, boundingVolumes, lodSelection, nodeInPage, resources) {
-    var _a2, _b;
-    const { texture, attributes } = resources;
+    var _a2, _b, _c, _d, _e;
     const nodeId = nodeInPage.index;
     const parentNodeData = await parentNode.load();
     const nodeData = {
@@ -3569,12 +3539,13 @@ var NodeIndexDocument = class {
     if (nodeInPage.mesh) {
       node.geometryData = [{ href: "./geometries/0" }];
       node.sharedResource = { href: "./shared" };
-      if (texture) {
+      if ("texture" in resources && resources.texture || "texelCountHint" in resources && resources.texelCountHint) {
         node.textureData = [{ href: "./textures/0" }, { href: "./textures/1" }];
       }
-      if (attributes && attributes.length && ((_b = (_a2 = parentNode.converter.layers0) == null ? void 0 : _a2.attributeStorageInfo) == null ? void 0 : _b.length)) {
+      if ("attributes" in resources && resources.attributes && resources.attributes.length && ((_b = (_a2 = parentNode.converter.layers0) == null ? void 0 : _a2.attributeStorageInfo) == null ? void 0 : _b.length) || "attributesCount" in resources && resources.attributesCount && ((_d = (_c = parentNode.converter.layers0) == null ? void 0 : _c.attributeStorageInfo) == null ? void 0 : _d.length)) {
+        const attributesLength = ("attributes" in resources ? (_e = resources.attributes) == null ? void 0 : _e.length : resources.attributesCount) || 0;
         node.attributeData = [];
-        const minimumLength = attributes.length < parentNode.converter.layers0.attributeStorageInfo.length ? attributes.length : parentNode.converter.layers0.attributeStorageInfo.length;
+        const minimumLength = attributesLength < parentNode.converter.layers0.attributeStorageInfo.length ? attributesLength : parentNode.converter.layers0.attributeStorageInfo.length;
         for (let index = 0; index < minimumLength; index++) {
           const folderName = parentNode.converter.layers0.attributeStorageInfo[index].key;
           node.attributeData.push({ href: `./attributes/${folderName}/0` });
@@ -3863,7 +3834,7 @@ var Progress = class {
    * @returns Number of milliseconds remaining
    */
   getTimeRemaining() {
-    if (!this._stepsDone || !this.startTime) {
+    if (!this._stepsTotal || !this._stepsDone || !this.startTime) {
       return null;
     }
     const timeRemainingInMilliSeconds = (this._stepsTotal - this._stepsDone) * this.milliSecForOneStep;
@@ -3905,6 +3876,262 @@ var Progress = class {
 
 // src/i3s-converter/i3s-converter.ts
 var import_zip = require("@loaders.gl/zip");
+
+// src/lib/utils/conversion-dump.ts
+var import_util = require("util");
+var import_path6 = require("path");
+var ConversionDump = class {
+  constructor() {
+    /**Restored/resumed dump indicator */
+    this.restored = false;
+    /** Array of materials definitions */
+    this.materialDefinitions = [];
+    this.tilesConverted = {};
+  }
+  /**
+   * Create a dump with convertion options
+   * @param currentOptions - converter options
+   */
+  async createDump(currentOptions) {
+    const {
+      tilesetName,
+      slpk,
+      egmFilePath,
+      inputUrl,
+      outputPath,
+      draco = true,
+      maxDepth,
+      token,
+      generateTextures,
+      generateBoundingVolumes,
+      mergeMaterials: mergeMaterials2 = true,
+      metadataClass,
+      analyze = false
+    } = currentOptions;
+    this.options = {
+      tilesetName,
+      slpk,
+      egmFilePath,
+      inputUrl,
+      outputPath,
+      draco,
+      maxDepth,
+      token,
+      generateTextures,
+      generateBoundingVolumes,
+      mergeMaterials: mergeMaterials2,
+      metadataClass,
+      analyze
+    };
+    const dumpFilename = (0, import_path6.join)(
+      this.options.outputPath,
+      this.options.tilesetName,
+      `${this.options.tilesetName}${DUMP_FILE_SUFFIX}`
+    );
+    if (await isFileExists(dumpFilename)) {
+      const {
+        options,
+        tilesConverted,
+        textureSetDefinitions,
+        attributeMetadataInfo,
+        materialDefinitions
+      } = await openJson(
+        (0, import_path6.join)(this.options.outputPath, this.options.tilesetName),
+        `${this.options.tilesetName}${DUMP_FILE_SUFFIX}`
+      );
+      if ((0, import_util.isDeepStrictEqual)(options, JSON.parse(JSON.stringify(this.options)))) {
+        this.tilesConverted = tilesConverted;
+        this.textureSetDefinitions = textureSetDefinitions;
+        this.attributeMetadataInfo = attributeMetadataInfo;
+        this.materialDefinitions = materialDefinitions;
+        this.restored = true;
+        return;
+      }
+    }
+    await this.deleteDumpFile();
+  }
+  /**
+   * Reset a dump
+   */
+  reset() {
+    this.restored = false;
+    this.tilesConverted = {};
+    if (this.textureSetDefinitions) {
+      delete this.textureSetDefinitions;
+    }
+    if (this.attributeMetadataInfo) {
+      delete this.attributeMetadataInfo;
+    }
+    if (this.materialDefinitions.length > 0) {
+      this.materialDefinitions = [];
+    }
+  }
+  /**
+   * 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(
+          (0, import_path6.join)(this.options.outputPath, this.options.tilesetName),
+          JSON.stringify({
+            options: this.options,
+            tilesConverted: this.tilesConverted,
+            textureSetDefinitions: this.textureSetDefinitions,
+            attributeMetadataInfo: this.attributeMetadataInfo,
+            materialDefinitions: this.materialDefinitions
+          }),
+          `${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 isFileExists(
+      (0, import_path6.join)(
+        this.options.outputPath,
+        this.options.tilesetName,
+        `${this.options.tilesetName}${DUMP_FILE_SUFFIX}`
+      )
+    )) {
+      await removeFile(
+        (0, import_path6.join)(
+          this.options.outputPath,
+          this.options.tilesetName,
+          `${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, dumpMetadata) {
+    const { nodes } = this.getRecord(filename) || { nodes: [] };
+    nodes.push({ nodeId, done: false, progress: {}, dumpMetadata });
+    if (nodes.length === 1) {
+      this.setRecord(filename, { nodes });
+    }
+    await this.updateDumpFile();
+  }
+  /**
+   * Clear dump record got the source filename
+   * @param fileName - source filename
+   */
+  clearDumpRecord(filename) {
+    this.setRecord(filename, { nodes: [] });
+  }
+  /**
+   * Add textures definitions into the dump file
+   * @param textureDefinitions - textures definitions array
+   */
+  addTexturesDefinitions(textureDefinitions) {
+    this.textureSetDefinitions = textureDefinitions;
+  }
+  /**
+   * 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) {
+      if (!nodeDump.progress) {
+        nodeDump.progress = {};
+      }
+      nodeDump.progress[resourceType] = value;
+      if (!value) {
+        nodeDump.done = false;
+      }
+    }
+  }
+  /**
+   * 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 (node.nodeId === outputId && node.progress) {
+            node.progress[resourceType] = true;
+            let done = false;
+            for (const key in node.progress) {
+              done = node.progress[key];
+              if (!done)
+                break;
+            }
+            node.done = done;
+            if (node.done) {
+              delete node.progress;
+            }
+            break;
+          }
+        }
+      }
+    }
+    await this.updateDumpFile();
+  }
+  /**
+   * Check is source file conversion complete
+   * @param filename - source filename
+   * @returns true if source file conversion complete
+   */
+  isFileConversionComplete(filename) {
+    var _a2, _b, _c;
+    let result = true;
+    for (const node of ((_a2 = this.tilesConverted[filename]) == null ? void 0 : _a2.nodes) || []) {
+      if (!node.done) {
+        result = false;
+        break;
+      }
+    }
+    return result && ((_c = (_b = this.tilesConverted[filename]) == null ? void 0 : _b.nodes) == null ? void 0 : _c.length) > 0;
+  }
+  /**
+   * Set materialDefinitions into a dump
+   * @param materialDefinitions - Array materialDefinitions
+   */
+  setMaterialsDefinitions(materialDefinitions) {
+    this.materialDefinitions = materialDefinitions;
+  }
+};
+
+// src/i3s-converter/i3s-converter.ts
 var _a;
 var ION_DEFAULT_TOKEN = (_a = import_process3.default.env) == null ? void 0 : _a.IonToken;
 var HARDCODED_NODES_PER_PAGE = 64;
@@ -3936,7 +4163,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(),
@@ -3963,6 +4190,7 @@ var I3SConverter = class {
     this.generateBoundingVolumes = false;
     this.layersHasTexture = false;
     this.compressList = null;
+    this.conversionDump = new ConversionDump();
   }
   /**
    * Convert a 3d tileset
@@ -4007,6 +4235,8 @@ var I3SConverter = class {
       analyze = false
     } = options;
     this.options = {
+      outputPath,
+      tilesetName,
       maxDepth,
       slpk,
       sevenZipExe,
@@ -4025,7 +4255,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);
@@ -4055,7 +4285,7 @@ var I3SConverter = class {
       throw error;
     } finally {
       await this.writeQueue.finalize();
-      const workerFarm = import_worker_utils2.WorkerFarm.getWorkerFarm({});
+      const workerFarm = import_worker_utils.WorkerFarm.getWorkerFarm({});
       workerFarm.destroy();
     }
     return "success";
@@ -4167,13 +4397,37 @@ var I3SConverter = class {
   async _createAndSaveTileset(outputPath, tilesetName) {
     var _a2, _b, _c;
     const tilesetPath = (0, import_path7.join)(`${outputPath}`, `${tilesetName}`);
+    await this.conversionDump.createDump(this.options);
+    if (this.conversionDump.restored && this.options.inquirer) {
+      const result = await this.options.inquirer.prompt([
+        {
+          name: "resumeConversion",
+          type: "confirm",
+          message: "Dump file of the previous conversion exists, do you want to resume that conversion?"
+        }
+      ]);
+      if (!result.resumeConversion) {
+        this.conversionDump.reset();
+      }
+    }
+    this.layers0Path = (0, import_path7.join)(tilesetPath, "SceneServer", "layers", "0");
+    const removePath = this.conversionDump.restored ? (0, import_path7.join)(this.layers0Path, "nodepages") : tilesetPath;
     try {
-      await removeDir(tilesetPath);
+      await removeDir(removePath);
     } catch (e) {
     }
-    this.layers0Path = (0, import_path7.join)(tilesetPath, "SceneServer", "layers", "0");
+    if (this.conversionDump.restored && this.conversionDump.attributeMetadataInfo) {
+      this.attributeMetadataInfo.fromObject(this.conversionDump.attributeMetadataInfo);
+    }
     this.materialDefinitions = [];
     this.materialMap = /* @__PURE__ */ new Map();
+    if (this.conversionDump.restored && this.conversionDump.materialDefinitions) {
+      for (let i = 0; i < this.conversionDump.materialDefinitions.length; i++) {
+        const hash = (0, import_md52.default)(JSON.stringify(this.conversionDump.materialDefinitions[i]));
+        this.materialMap.set(hash, i);
+      }
+      this.materialDefinitions = this.conversionDump.materialDefinitions;
+    }
     const sourceRootTile = this.sourceTileset.root;
     const sourceBoundingVolume = (0, import_tiles.createBoundingVolume)(
       sourceRootTile.boundingVolume,
@@ -4212,6 +4466,9 @@ var I3SConverter = class {
     if (this.attributeMetadataInfo.attributeStorageInfo.length) {
       this.layers0.layerType = _3D_OBJECT_LAYER_TYPE;
     }
+    if (this.conversionDump.restored && this.conversionDump.textureSetDefinitions) {
+      this.layers0.textureSetDefinitions = this.conversionDump.textureSetDefinitions;
+    }
     this.layers0.materialDefinitions = this.materialDefinitions;
     this.layers0.geometryDefinitions = (0, import_json_map_transform8.default)(
       this.geometryConfigs.map((config) => ({
@@ -4288,18 +4545,14 @@ 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 slpkFileName = `${tilesetPath}.slpk`;
-      await compressWithChildProcess(
-        slpkTilesetPath,
-        slpkFileName,
-        0,
-        ".",
-        this.options.sevenZipExe
-      );
-      const hashTable = await (0, import_zip.composeHashFile)(new import_loader_utils4.FileHandleFile(slpkFileName));
-      await (0, import_zip.addOneFile)(slpkFileName, hashTable, "@specialIndexFileHASH128@");
+      await (0, import_zip.createZip)(slpkTilesetPath, slpkFileName, async (fileList) => ({
+        path: "@specialIndexFileHASH128@",
+        file: await (0, import_zip.composeHashFile)(fileList)
+      }));
       try {
         await removeDir(tilesetPath);
       } catch (e) {
@@ -4333,7 +4586,13 @@ var I3SConverter = class {
       transformationMatrix = transformationMatrix.multiplyRight(sourceTile.transform);
     }
     const parentNode = parentNodes[0];
-    const childNodes = await this._createNode(parentNode, sourceTile, transformationMatrix);
+    const restoreResult = await this._restoreNode(parentNode, sourceTile, transformationMatrix);
+    let childNodes;
+    if (restoreResult === null) {
+      childNodes = await this._createNode(parentNode, sourceTile, transformationMatrix);
+    } else {
+      childNodes = restoreResult;
+    }
     await parentNode.addChildren(childNodes);
     const newTraversalProps = {
       transform: transformationMatrix,
@@ -4346,8 +4605,9 @@ var I3SConverter = class {
       if (timeRemainingStringBasedOnCount) {
         timeRemainingString = `${timeRemainingStringBasedOnCount} left`;
       }
-      let percentString = this.progresses[PROGRESS_PHASE1_COUNT].getPercentString();
-      console.log(`[converted ${percentString}%, ${timeRemainingString}]: ${sourceTile.id}`);
+      const percentString = this.progresses[PROGRESS_PHASE1_COUNT].getPercentString();
+      const progressString = percentString ? ` ${percentString}%, ${timeRemainingString}` : "";
+      console.log(`[converted${progressString}]: ${sourceTile.id}`);
     }
     return newTraversalProps;
   }
@@ -4366,6 +4626,88 @@ var I3SConverter = class {
       await node.save();
     }
   }
+  /**
+   * Generate NodeIndexDocument
+   * @param boundingVolumes - Bounding volumes
+   * @param resources - converted or dumped node resources data
+   * @param parentNode - 3DNodeIndexDocument of parent node
+   * @param sourceTile - source 3DTile data
+   * @param isDumped - indicator if the node is dumped
+   * @return NodeIndexDocument, nodeInPage and node data
+   */
+  async _generateNodeIndexDocument(boundingVolumes, resources, parentNode, sourceTile, isDumped) {
+    this.layersHasTexture = this.layersHasTexture || Boolean(
+      "texture" in resources && resources.texture || "texelCountHint" in resources && resources.texelCountHint
+    );
+    if (this.generateBoundingVolumes && resources.boundingVolumes) {
+      boundingVolumes = resources.boundingVolumes;
+    }
+    const lodSelection = convertGeometricErrorToScreenThreshold(sourceTile, boundingVolumes);
+    const maxScreenThresholdSQ = lodSelection.find(
+      (val) => val.metricType === "maxScreenThresholdSQ"
+    ) || { maxError: 0 };
+    if (isDumped) {
+      const draftObb = {
+        center: [],
+        halfSize: [],
+        quaternion: []
+      };
+      await this.nodePages.push({ index: 0, obb: draftObb }, parentNode.inPageId);
+    }
+    const nodeInPage = await this._updateNodeInNodePages(
+      maxScreenThresholdSQ,
+      boundingVolumes,
+      sourceTile,
+      parentNode.inPageId,
+      resources
+    );
+    const nodeData = await NodeIndexDocument.createNodeIndexDocument(
+      parentNode,
+      boundingVolumes,
+      lodSelection,
+      nodeInPage,
+      resources
+    );
+    const node = await new NodeIndexDocument(nodeInPage.index, this).addData(nodeData);
+    return { node, nodeInPage, nodeData };
+  }
+  /**
+   * Restore 3DNodeIndexDocument from a comversion dump file
+   * @param parentNode - 3DNodeIndexDocument of parent node
+   * @param sourceTile - source 3DTile data
+   * @param transformationMatrix - transformation matrix of the current tile, calculated recursively multiplying
+   *                               transform of all parent tiles and transform of the current tile
+   */
+  async _restoreNode(parentNode, sourceTile, transformationMatrix) {
+    this._checkAddRefinementTypeForTile(sourceTile);
+    await this._updateTilesetOptions();
+    if (this.conversionDump.restored && sourceTile.id && this.conversionDump.isFileConversionComplete(sourceTile.id)) {
+      const sourceBoundingVolume = (0, import_tiles.createBoundingVolume)(
+        sourceTile.boundingVolume,
+        transformationMatrix,
+        null
+      );
+      let boundingVolumes = createBoundingVolumes(sourceBoundingVolume, this.geoidHeightModel);
+      const nodes = [];
+      for (const convertedNode of this.conversionDump.tilesConverted[sourceTile.id].nodes) {
+        const { node } = await this._generateNodeIndexDocument(
+          boundingVolumes,
+          {
+            ...convertedNode.dumpMetadata,
+            nodeId: convertedNode.nodeId
+          },
+          parentNode,
+          sourceTile,
+          true
+        );
+        nodes.push(node);
+      }
+      return nodes;
+    } else if (this.conversionDump.restored && sourceTile.id) {
+      this.conversionDump.clearDumpRecord(sourceTile.id);
+    }
+    return null;
+  }
   /**
    * Convert tile to one or more I3S nodes
    * @param parentNode - 3DNodeIndexDocument of parent node
@@ -4375,6 +4717,7 @@ var I3SConverter = class {
    * @param level - tree level
    */
   async _createNode(parentNode, sourceTile, transformationMatrix) {
+    var _a2;
     this._checkAddRefinementTypeForTile(sourceTile);
     await this._updateTilesetOptions();
     let tileContent = null;
@@ -4391,6 +4734,11 @@ var I3SConverter = class {
     let boundingVolumes = createBoundingVolumes(sourceBoundingVolume, this.geoidHeightModel);
     const propertyTable = getPropertyTable(tileContent, this.options.metadataClass);
     this.createAttributeStorageInfo(tileContent, propertyTable);
+    this.conversionDump.attributeMetadataInfo = {
+      attributeStorageInfo: this.attributeMetadataInfo.attributeStorageInfo,
+      fields: this.attributeMetadataInfo.fields,
+      popupInfo: this.attributeMetadataInfo.popupInfo
+    };
     const resourcesData = await this._convertResources(
       sourceTile,
       transformationMatrix,
@@ -4415,32 +4763,30 @@ var I3SConverter = class {
       boundingVolumes: null
     };
     for (const resources of resourcesData || [emptyResources]) {
-      this.layersHasTexture = this.layersHasTexture || Boolean(resources.texture);
-      if (this.generateBoundingVolumes && resources.boundingVolumes) {
-        boundingVolumes = resources.boundingVolumes;
-      }
-      const lodSelection = convertGeometricErrorToScreenThreshold(sourceTile, boundingVolumes);
-      const maxScreenThresholdSQ = lodSelection.find(
-        (val) => val.metricType === "maxScreenThresholdSQ"
-      ) || { maxError: 0 };
-      const nodeInPage = await this._updateNodeInNodePages(
-        maxScreenThresholdSQ,
+      const { node, nodeInPage, nodeData } = await this._generateNodeIndexDocument(
         boundingVolumes,
-        sourceTile,
-        parentNode.inPageId,
-        resources
-      );
-      const nodeData = await NodeIndexDocument.createNodeIndexDocument(
+        resources,
         parentNode,
-        boundingVolumes,
-        lodSelection,
-        nodeInPage,
-        resources
+        sourceTile,
+        false
       );
-      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) {
+          const dumpMetadata = {
+            boundingVolumes: resources.boundingVolumes,
+            attributesCount: (_a2 = resources.attributes) == null ? void 0 : _a2.length,
+            featureCount: resources.featureCount,
+            geometry: Boolean(resources.geometry),
+            hasUvRegions: resources.hasUvRegions,
+            materialId: nodeInPage.mesh.material.definition,
+            texelCountHint: nodeInPage.mesh.material.texelCountHint,
+            vertexCount: resources.vertexCount
+          };
+          this.conversionDump.setMaterialsDefinitions(this.materialDefinitions);
+          await this.conversionDump.addNode(sourceTile.id, nodeInPage.index, dumpMetadata);
+        }
+        await this._writeResources(resources, node.id, sourceTile);
       }
       if (this.validate) {
         this.boundingVolumeWarnings = validateNodeBoundingVolumes(nodeData);
@@ -4506,7 +4852,7 @@ var I3SConverter = class {
    * @return the node object in node pages
    */
   async _updateNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources) {
-    const { meshMaterial, texture, vertexCount, featureCount, geometry, hasUvRegions } = resources;
+    const { vertexCount, featureCount, geometry, hasUvRegions } = resources;
     const nodeInPage = {
       index: 0,
       lodThreshold: maxScreenThresholdSQ.maxError,
@@ -4516,7 +4862,12 @@ var I3SConverter = class {
     if (geometry && this.isContentSupported(sourceTile)) {
       nodeInPage.mesh = {
         geometry: {
-          definition: this.findOrCreateGeometryDefinition(Boolean(texture), hasUvRegions),
+          definition: this.findOrCreateGeometryDefinition(
+            Boolean(
+              "texture" in resources && resources.texture || "texelCountHint" in resources && resources.texelCountHint
+            ),
+            hasUvRegions
+          ),
           resource: 0
         },
         attribute: {
@@ -4527,7 +4878,7 @@ var I3SConverter = class {
         }
       };
     }
-    let nodeId = resources.nodeId;
+    let nodeId = "nodeId" in resources ? resources.nodeId : void 0;
     let node;
     if (!nodeId) {
       node = await this.nodePages.push(nodeInPage, parentId);
@@ -4538,12 +4889,16 @@ var I3SConverter = class {
       console.log(`[warning]: node ${node.index} is created with empty content`);
     }
     NodePages.updateAll(node, nodeInPage);
-    if (meshMaterial) {
-      NodePages.updateMaterialByNodeId(node, this._findOrCreateMaterial(meshMaterial));
+    if ("meshMaterial" in resources && resources.meshMaterial) {
+      NodePages.updateMaterialByNodeId(node, this._findOrCreateMaterial(resources.meshMaterial));
+    } else if ("materialId" in resources && resources.materialId !== null) {
+      NodePages.updateMaterialByNodeId(node, resources.materialId);
     }
-    if (texture) {
-      const texelCountHint = texture.image.height * texture.image.width;
+    if ("texture" in resources && resources.texture) {
+      const texelCountHint = resources.texture.image.height * resources.texture.image.width;
       NodePages.updateTexelCountHintByNodeId(node, texelCountHint);
+    } else if ("texelCountHint" in resources && resources.texelCountHint) {
+      NodePages.updateTexelCountHintByNodeId(node, resources.texelCountHint);
     }
     if (vertexCount) {
       this.vertexCounter += vertexCount;
@@ -4564,9 +4919,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,
@@ -4576,10 +4933,36 @@ var I3SConverter = class {
     } = 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);
+    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
@@ -4587,30 +4970,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");
       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/");
       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");
         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/");
         await this.writeQueue.enqueue({
+          sourceId,
+          outputId: nodeId,
+          resourceType: "DRACO_GEOMETRY" /* DRACO_GEOMETRY */,
           writePromise: () => writeFile(compressedGeometryPath, compressedGeometry, "index.bin")
         });
       }
@@ -4622,23 +5021,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");
       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) });
+      await this.writeQueue.enqueue({
+        sourceId,
+        outputId: nodeId,
+        resourceType: "SHARED" /* SHARED */,
+        writePromise: () => writeFile(sharedPath, sharedDataStr)
+      });
     }
   }
   /**
@@ -4646,8 +5056,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 = [];
@@ -4656,7 +5068,21 @@ 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();
@@ -4676,22 +5102,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
             );
           }
         }
@@ -4699,6 +5161,9 @@ var I3SConverter = class {
       if (!this.layers0.textureSetDefinitions.length) {
         this.layers0.textureSetDefinitions.push({ formats });
         this.layers0.textureSetDefinitions.push({ formats, atlas: true });
+        if (this.layers0.textureSetDefinitions) {
+          this.conversionDump.addTexturesDefinitions(this.layers0.textureSetDefinitions);
+        }
       }
     }
   }
@@ -4709,18 +5174,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 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}/`);
       await this.writeQueue.enqueue({
+        sourceId,
+        outputId: nodeId,
+        resourceType: `${"TEXTURE" /* TEXTURE */}/${format}`,
         writePromise: () => writeFile(texturePath, textureData, `index.${format}`)
       });
     }
@@ -4730,22 +5203,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);
           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`);
           await this.writeQueue.enqueue({
+            sourceId,
+            outputId: nodeId,
+            resourceType: `${"ATTRIBUTES" /* ATTRIBUTES */}/${folderName}`,
             writePromise: () => writeFile(attributesPath, fileBuffer, "index.bin")
           });
         }
@@ -4932,6 +5419,9 @@ var TILE = () => ({
   geometricError: {
     path: "geometricError"
   },
+  refine: {
+    path: "refine"
+  },
   content: {
     path: "content"
   },
@@ -4956,7 +5446,7 @@ var TILESET = () => ({
 });
 
 // src/3d-tiles-converter/3d-tiles-converter.ts
-var import_worker_utils3 = require("@loaders.gl/worker-utils");
+var import_worker_utils2 = require("@loaders.gl/worker-utils");
 
 // src/3d-tiles-converter/helpers/b3dm-converter.ts
 var import_core12 = require("@loaders.gl/core");
@@ -4999,6 +5489,9 @@ function normalizeRegions(regions) {
 // src/3d-tiles-converter/helpers/b3dm-converter.ts
 var Z_UP_TO_Y_UP_MATRIX = new import_core13.Matrix4([1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1]);
 var scratchVector2 = new import_core13.Vector3();
+var KHR_MATERIALS_UNLIT = "KHR_materials_unlit";
+var METALLIC_FACTOR_DEFAULT = 1;
+var ROUGHNESS_FACTOR_DEFAULT = 1;
 var B3dmConverter = class {
   /**
    * The starter of content conversion
@@ -5028,6 +5521,11 @@ var B3dmConverter = class {
     const { material, attributes, indices: originalIndices, modelMatrix } = tileContent;
     const gltfBuilder = new import_gltf6.GLTFScenegraph();
     const textureIndex = await this._addI3sTextureToGLTF(tileContent, textureFormat, gltfBuilder);
+    const pbrMetallicRoughness = material == null ? void 0 : material.pbrMetallicRoughness;
+    if (pbrMetallicRoughness && (pbrMetallicRoughness.metallicFactor === void 0 || pbrMetallicRoughness.metallicFactor === METALLIC_FACTOR_DEFAULT) && (pbrMetallicRoughness.roughnessFactor === void 0 || pbrMetallicRoughness.roughnessFactor === ROUGHNESS_FACTOR_DEFAULT)) {
+      gltfBuilder.addObjectExtension(material, KHR_MATERIALS_UNLIT, {});
+      gltfBuilder.addExtension(KHR_MATERIALS_UNLIT);
+    }
     const pbrMaterialInfo = this._convertI3sMaterialToGLTFMaterial(material, textureIndex);
     const materialIndex = gltfBuilder.addMaterial(pbrMaterialInfo);
     const positions = attributes.positions;
@@ -5296,6 +5794,8 @@ var Tiles3DConverter = class {
     this.loaderOptions = {
       _nodeWorkers: true,
       reuseWorkers: true,
+      // TODO: converter freezes in the end because of i3s-content-worker
+      worker: false,
       i3s: { coordinateSystem: import_i3s2.COORDINATE_SYSTEM.LNGLAT_OFFSETS, decodeTextures: false },
       // We need to load local fs workers because nodejs can't load workers from the Internet
       "i3s-content": {
@@ -5351,13 +5851,14 @@ var Tiles3DConverter = class {
         box: i3sObbTo3dTilesObb(rootNode.obb, this.geoidHeightModel)
       },
       geometricError: convertScreenThresholdToGeometricError(rootNode),
-      children: []
+      children: [],
+      refine: "REPLACE"
     };
     await this._addChildren(rootNode, rootTile, 1);
     const tileset = (0, import_json_map_transform10.default)({ root: rootTile }, TILESET());
     await writeFile(this.tilesetPath, JSON.stringify(tileset), "tileset.json");
     this._finishConversion({ slpk: false, outputPath, tilesetName });
-    const workerFarm = import_worker_utils3.WorkerFarm.getWorkerFarm({});
+    const workerFarm = import_worker_utils2.WorkerFarm.getWorkerFarm({});
     workerFarm.destroy();
   }
   /**
@@ -5419,11 +5920,9 @@ var Tiles3DConverter = class {
     if (this.options.maxDepth && level > this.options.maxDepth) {
       return;
     }
-    const promises = [];
     for (const childNodeInfo of parentSourceNode.children || []) {
-      promises.push(this.convertChildNode(parentSourceNode, parentNode, level, childNodeInfo));
+      await this.convertChildNode(parentSourceNode, parentNode, level, childNodeInfo);
     }
-    await Promise.all(promises);
   }
   /**
    * Load a child node having information from the node header