@loaders.gl/tile-converter 4.1.1 → 4.2.0-alpha.2

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 ...).
@@ -252,7 +261,7 @@ var import_core9 = require("@loaders.gl/core");
 var import_d_tiles2 = require("@loaders.gl/3d-tiles");
 var import_path7 = require("path");
 var import_uuid4 = require("uuid");
-var import_process3 = __toESM(require("process"), 1);
+var import_process4 = __toESM(require("process"), 1);
 var import_json_map_transform8 = __toESM(require("json-map-transform"), 1);
 var import_md52 = __toESM(require("md5"), 1);
 
@@ -384,6 +393,13 @@ function removeFile(path) {
 function getAbsoluteFilePath(filePath) {
   return (0, import_path.isAbsolute)(filePath) ? filePath : (0, import_path.join)(process.cwd(), filePath);
 }
+async function renameFile(oldPath, newPath) {
+  try {
+    await import_fs2.promises.rename(oldPath, newPath);
+  } catch (err) {
+    console.log("Can't rename file", err);
+  }
+}
 
 // src/i3s-converter/helpers/node-pages.ts
 var NodePages = class {
@@ -3508,8 +3524,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 = {
@@ -3531,12 +3546,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` });
@@ -3550,6 +3566,8 @@ var NodeIndexDocument = class {
 // src/i3s-converter/helpers/load-3d-tiles.ts
 var import_d_tiles = require("@loaders.gl/3d-tiles");
 var import_core7 = require("@loaders.gl/core");
+var import_loader_utils4 = require("@loaders.gl/loader-utils");
+var import_zip = require("@loaders.gl/zip");
 var loadNestedTileset = async (sourceTileset, sourceTile, tilesetLoadOptions) => {
   const isTileset = isNestedTileset(sourceTile);
   if (!sourceTileset || !sourceTile.contentUrl || !isTileset) {
@@ -3607,7 +3625,10 @@ async function loadFromArchive(url, loader, loadOptions) {
   }
   if (filename) {
     const tz3Path = `${tz3UrlParts[0]}.3tz`;
-    const fileSystem = new import_d_tiles.Tiles3DArchiveFileSystem(tz3Path);
+    const fileProvider = new import_loader_utils4.FileHandleFile(tz3Path);
+    const hashTable = await loadHashTable(fileProvider);
+    const archive = new import_d_tiles.Tiles3DArchive(fileProvider, hashTable, tz3Path);
+    const fileSystem = new import_zip.ZipFileSystem(archive);
     const content = await (0, import_core7.load)(filename, loader, {
       ...loadOptions,
       fetch: fileSystem.fetch.bind(fileSystem)
@@ -3620,6 +3641,27 @@ async function loadFromArchive(url, loader, loadOptions) {
 function isNestedTileset(tile) {
   return (tile == null ? void 0 : tile.type) === "json" || (tile == null ? void 0 : tile.type) === "3tz";
 }
+async function loadHashTable(fileProvider) {
+  let hashTable;
+  const hashCDOffset = await (0, import_zip.searchFromTheEnd)(fileProvider, import_zip.CD_HEADER_SIGNATURE);
+  const cdFileHeader = await (0, import_zip.parseZipCDFileHeader)(hashCDOffset, fileProvider);
+  if ((cdFileHeader == null ? void 0 : cdFileHeader.fileName) === "@3dtilesIndex1@") {
+    const localFileHeader = await (0, import_zip.parseZipLocalFileHeader)(
+      cdFileHeader.localHeaderOffset,
+      fileProvider
+    );
+    if (!localFileHeader) {
+      throw new Error("corrupted 3tz");
+    }
+    const fileDataOffset = localFileHeader.fileDataOffset;
+    const hashFile = await fileProvider.slice(
+      fileDataOffset,
+      fileDataOffset + localFileHeader.compressedSize
+    );
+    hashTable = (0, import_zip.parseHashTable)(hashFile);
+  }
+  return hashTable;
+}
 
 // src/i3s-converter/i3s-converter.ts
 var import_core10 = require("@math.gl/core");
@@ -3866,19 +3908,313 @@ var Progress = class {
 };
 
 // src/i3s-converter/i3s-converter.ts
-var import_zip = require("@loaders.gl/zip");
+var import_zip2 = require("@loaders.gl/zip");
 
 // src/lib/utils/conversion-dump.ts
+var import_util = require("util");
 var import_path6 = require("path");
+var import_process3 = __toESM(require("process"), 1);
+var import_ajv = __toESM(require("ajv"), 1);
+
+// src/lib/json-schemas/conversion-dump-json-schema.ts
+var dumpJsonSchema = {
+  type: "object",
+  properties: {
+    options: {
+      type: "object",
+      properties: {
+        inputUrl: { type: "string" },
+        outputPath: { type: "string" },
+        tilesetName: { type: "string" },
+        maxDepth: { type: "number" },
+        slpk: { type: "boolean" },
+        egmFilePath: { type: "string" },
+        token: { type: "string" },
+        draco: { type: "boolean" },
+        mergeMaterials: { type: "boolean" },
+        generateTextures: { type: "boolean" },
+        generateBoundingVolumes: { type: "boolean" },
+        metadataClass: { type: "string" },
+        analyze: { type: "boolean" }
+      },
+      required: ["inputUrl", "outputPath", "tilesetName"]
+    },
+    tilesConverted: {
+      type: "object",
+      patternProperties: {
+        ".*": {
+          type: "object",
+          properties: {
+            nodes: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  nodeId: { type: ["number", "string"] },
+                  done: { type: "boolean" },
+                  progress: { type: "object", patternProperties: { ".*": { type: "boolean" } } },
+                  dumpMetadata: {
+                    type: "object",
+                    properties: {
+                      boundingVolumes: {
+                        type: ["object", "null"],
+                        properties: {
+                          mbs: {
+                            type: "array",
+                            minItems: 4,
+                            maxItems: 4,
+                            items: { type: "number" }
+                          },
+                          obb: {
+                            type: "object",
+                            properties: {
+                              center: {
+                                type: "array",
+                                minItems: 3,
+                                maxItems: 3,
+                                items: { type: "number" }
+                              },
+                              halfSize: {
+                                type: "array",
+                                minItems: 3,
+                                maxItems: 3,
+                                items: { type: "number" }
+                              },
+                              quaternion: {
+                                type: "array",
+                                minItems: 4,
+                                maxItems: 4,
+                                items: { type: "number" }
+                              }
+                            },
+                            required: ["center", "halfSize", "quaternion"]
+                          }
+                        },
+                        required: ["mbs", "obb"]
+                      },
+                      attributesCount: { type: "number" },
+                      featureCount: { type: "number" },
+                      geometry: { type: "boolean" },
+                      hasUvRegions: { type: "boolean" },
+                      materialId: { type: "number" },
+                      texelCountHint: { type: "number" },
+                      vertexCount: { type: "number" }
+                    },
+                    required: [
+                      "boundingVolumes",
+                      "featureCount",
+                      "geometry",
+                      "hasUvRegions",
+                      "materialId",
+                      "vertexCount"
+                    ]
+                  }
+                },
+                required: ["nodeId", "done"]
+              }
+            }
+          },
+          required: ["nodes"]
+        }
+      }
+    },
+    textureSetDefinitions: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          formats: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+                format: { enum: ["jpg", "png", "ktx-etc2", "dds", "ktx2"] }
+              },
+              required: ["name", "format"]
+            }
+          },
+          atlas: { type: "boolean" }
+        },
+        required: ["formats"]
+      }
+    },
+    attributeMetadataInfo: {
+      type: "object",
+      properties: {
+        attributeStorageInfo: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              key: { type: "string" },
+              name: { type: "string" },
+              header: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: { property: { type: "string" }, valueType: { type: "string" } },
+                  required: ["property", "valueType"]
+                }
+              },
+              ordering: { type: "array", items: { type: "string" } },
+              attributeValues: { $ref: "#/$defs/AttributeValue" },
+              attributeByteCounts: { $ref: "#/$defs/AttributeValue" },
+              objectIds: { $ref: "#/$defs/AttributeValue" }
+            },
+            required: ["key", "name", "header"]
+          }
+        },
+        fields: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              type: { $ref: "#/$defs/ESRIField" },
+              alias: { type: "string" },
+              domain: { $ref: "#/$defs/Domain" }
+            },
+            required: ["name", "type"]
+          }
+        },
+        popupInfo: {
+          type: "object",
+          properties: {
+            title: { type: "string" },
+            description: { type: "string" },
+            expressionInfos: { type: "array", items: {} },
+            fieldInfos: { type: "array", items: { $ref: "#/$defs/FieldInfo" } },
+            mediaInfos: { type: "array", items: {} },
+            popupElements: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  text: { type: "string" },
+                  type: { type: "string" },
+                  fieldInfos: { type: "array", items: { $ref: "#/$defs/FieldInfo" } }
+                }
+              }
+            }
+          }
+        }
+      },
+      required: ["attributeStorageInfo", "fields"]
+    },
+    materialDefinitions: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          pbrMetallicRoughness: {
+            type: "object",
+            properties: {
+              baseColorFactor: {
+                type: "array",
+                minItems: 4,
+                maxItems: 4,
+                items: { type: "number" }
+              },
+              baseColorTexture: { $ref: "#/$defs/I3SMaterialTexture" },
+              metallicFactor: { type: "number" },
+              roughnessFactor: { type: "number" },
+              metallicRoughnessTexture: { $ref: "#/$defs/I3SMaterialTexture" }
+            },
+            required: ["metallicFactor", "roughnessFactor"]
+          },
+          normalTexture: { $ref: "#/$defs/I3SMaterialTexture" },
+          occlusionTexture: { $ref: "#/$defs/I3SMaterialTexture" },
+          emissiveTexture: { $ref: "#/$defs/I3SMaterialTexture" },
+          emissiveFactor: { type: "array", minItems: 3, maxItems: 3, items: { type: "number" } },
+          alphaMode: { enum: ["opaque", "mask", "blend"] },
+          alphaCutoff: { type: "number" },
+          doubleSided: { type: "boolean" },
+          cullFace: { enum: ["none", "front", "back"] }
+        },
+        required: ["pbrMetallicRoughness", "alphaMode"]
+      }
+    }
+  },
+  required: ["options", "tilesConverted"],
+  $defs: {
+    AttributeValue: {
+      type: "object",
+      properties: {
+        valueType: { type: "string" },
+        encoding: { type: "string" },
+        valuesPerElement: { type: "number" }
+      },
+      required: ["valueType"]
+    },
+    ESRIField: {
+      enum: [
+        "esriFieldTypeDate",
+        "esriFieldTypeSingle",
+        "esriFieldTypeDouble",
+        "esriFieldTypeGUID",
+        "esriFieldTypeGlobalID",
+        "esriFieldTypeInteger",
+        "esriFieldTypeOID",
+        "esriFieldTypeSmallInteger",
+        "esriFieldTypeString"
+      ]
+    },
+    Domain: {
+      type: "object",
+      properties: {
+        type: { type: "string" },
+        name: { type: "string" },
+        description: { type: "string" },
+        fieldType: { type: "string" },
+        range: { type: "array", items: { type: "number" } },
+        codedValues: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: { name: { type: "string" }, code: { type: ["string", "number"] } },
+            required: ["name", "code"]
+          }
+        },
+        mergePolicy: { type: "string" },
+        splitPolicy: { type: "string" }
+      },
+      required: ["type", "name"]
+    },
+    FieldInfo: {
+      type: "object",
+      properties: {
+        fieldName: { type: "string" },
+        visible: { type: "boolean" },
+        isEditable: { type: "boolean" },
+        label: { type: "string" }
+      },
+      required: ["fieldName", "visible", "isEditable", "label"]
+    },
+    I3SMaterialTexture: {
+      type: "object",
+      properties: {
+        textureSetDefinitionId: { type: "number" },
+        texCoord: { type: "number" },
+        factor: { type: "number" }
+      },
+      required: ["textureSetDefinitionId"]
+    }
+  }
+};
+
+// src/lib/utils/conversion-dump.ts
 var ConversionDump = class {
   constructor() {
+    /**Restored/resumed dump indicator */
+    this.restored = false;
     this.tilesConverted = {};
   }
   /**
-   * Create a dump file with convertion options
-   * @param options - converter options
+   * Create a dump with convertion options
+   * @param currentOptions - converter options
    */
-  async createDumpFile(options) {
+  async createDump(currentOptions) {
     const {
       tilesetName,
       slpk,
@@ -3893,7 +4229,7 @@ var ConversionDump = class {
       mergeMaterials: mergeMaterials2 = true,
       metadataClass,
       analyze = false
-    } = options;
+    } = currentOptions;
     this.options = {
       tilesetName,
       slpk,
@@ -3909,14 +4245,55 @@ var ConversionDump = class {
       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);
+    const dumpFilename = (0, import_path6.join)(
+      this.options.outputPath,
+      this.options.tilesetName,
+      `${this.options.tilesetName}${DUMP_FILE_SUFFIX}`
+    );
+    if (await isFileExists(dumpFilename)) {
+      try {
+        const dump = await openJson(
+          (0, import_path6.join)(this.options.outputPath, this.options.tilesetName),
+          `${this.options.tilesetName}${DUMP_FILE_SUFFIX}`
+        );
+        const {
+          options,
+          tilesConverted,
+          textureSetDefinitions,
+          attributeMetadataInfo,
+          materialDefinitions
+        } = dump;
+        const ajv = new import_ajv.default();
+        const dumpJsonValidate = ajv.compile(dumpJsonSchema);
+        const isDumpValid = dumpJsonValidate(dump);
+        if (isDumpValid && (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;
+        }
+      } catch (error) {
+        console.log("Can't open dump file", error);
+      }
+    }
+    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) {
+      delete this.materialDefinitions;
     }
   }
   /**
@@ -3926,13 +4303,29 @@ var ConversionDump = class {
     var _a2;
     if (((_a2 = this.options) == null ? void 0 : _a2.outputPath) && this.options.tilesetName) {
       try {
+        const time = import_process3.default.hrtime();
         await writeFile(
-          this.options.outputPath,
+          (0, import_path6.join)(this.options.outputPath, this.options.tilesetName),
           JSON.stringify({
             options: this.options,
-            tilesConverted: this.tilesConverted
+            tilesConverted: this.tilesConverted,
+            textureSetDefinitions: this.textureSetDefinitions,
+            attributeMetadataInfo: this.attributeMetadataInfo,
+            materialDefinitions: this.materialDefinitions
           }),
-          `${this.options.tilesetName}${DUMP_FILE_SUFFIX}`
+          `${this.options.tilesetName}${DUMP_FILE_SUFFIX}.${time[0]}.${time[1]}`
+        );
+        await renameFile(
+          (0, import_path6.join)(
+            this.options.outputPath,
+            this.options.tilesetName,
+            `${this.options.tilesetName}${DUMP_FILE_SUFFIX}.${time[0]}.${time[1]}`
+          ),
+          (0, import_path6.join)(
+            this.options.outputPath,
+            this.options.tilesetName,
+            `${this.options.tilesetName}${DUMP_FILE_SUFFIX}`
+          )
         );
       } catch (error) {
         console.log("Can't update dump file", error);
@@ -3944,9 +4337,19 @@ var ConversionDump = class {
    */
   async deleteDumpFile() {
     var _a2;
-    if (((_a2 = this.options) == null ? void 0 : _a2.outputPath) && this.options.tilesetName) {
+    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}${DUMP_FILE_SUFFIX}`)
+        (0, import_path6.join)(
+          this.options.outputPath,
+          this.options.tilesetName,
+          `${this.options.tilesetName}${DUMP_FILE_SUFFIX}`
+        )
       );
     }
   }
@@ -3971,14 +4374,28 @@ var ConversionDump = class {
    * @param fileName - source filename
    * @param nodeId - nodeId of the node
    */
-  async addNode(filename, nodeId) {
+  async addNode(filename, nodeId, dumpMetadata) {
     const { nodes } = this.getRecord(filename) || { nodes: [] };
-    nodes.push({ nodeId, done: false, progress: {} });
+    nodes.push({ nodeId, done: false, 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
@@ -3992,6 +4409,9 @@ var ConversionDump = class {
       (element) => element.nodeId === nodeId
     );
     if (nodeDump) {
+      if (!nodeDump.progress) {
+        nodeDump.progress = {};
+      }
       nodeDump.progress[resourceType] = value;
       if (!value) {
         nodeDump.done = false;
@@ -4010,7 +4430,7 @@ var ConversionDump = class {
         if (!sourceId || !resourceType || !outputId)
           continue;
         for (const node of this.tilesConverted[sourceId].nodes) {
-          if (node.nodeId === outputId) {
+          if (node.nodeId === outputId && node.progress) {
             node.progress[resourceType] = true;
             let done = false;
             for (const key in node.progress) {
@@ -4020,7 +4440,7 @@ var ConversionDump = class {
             }
             node.done = done;
             if (node.done) {
-              node.progress = {};
+              delete node.progress;
             }
             break;
           }
@@ -4029,11 +4449,50 @@ var ConversionDump = class {
     }
     await this.updateDumpFile();
   }
+  /**
+   * Update 3d-tiles-converter dump file
+   * @param filename - source filename
+   * @param nodeId - nodeId
+   * @param done - conversion status
+   */
+  async updateConvertedNodesDumpFile(filename, nodeId, done) {
+    var _a2;
+    const nodeDump = (_a2 = this.tilesConverted[filename]) == null ? void 0 : _a2.nodes.find(
+      (element) => element.nodeId === nodeId
+    );
+    if (nodeDump) {
+      nodeDump.done = done;
+      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 ION_DEFAULT_TOKEN = (_a = import_process4.default.env) == null ? void 0 : _a.IonToken;
 var HARDCODED_NODES_PER_PAGE = 64;
 var _3D_TILES = "3DTILES";
 var _3D_OBJECT_LAYER_TYPE = "3DObject";
@@ -4114,7 +4573,7 @@ var I3SConverter = class {
       console.log(BROWSER_ERROR_MESSAGE);
       return BROWSER_ERROR_MESSAGE;
     }
-    this.conversionStartTime = import_process3.default.hrtime();
+    this.conversionStartTime = import_process4.default.hrtime();
     const {
       tilesetName,
       slpk,
@@ -4163,7 +4622,6 @@ var I3SConverter = class {
     if (slpk) {
       this.nodePages.useWriteFunction(writeFileForSlpk);
     }
-    await this.conversionDump.createDumpFile(options);
     try {
       const preloadOptions = await this._fetchPreloadOptions();
       let tilesetUrl = inputUrl;
@@ -4298,13 +4756,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,
@@ -4343,6 +4825,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) => ({
@@ -4423,9 +4908,9 @@ var I3SConverter = class {
     if (this.options.slpk) {
       const slpkTilesetPath = (0, import_path7.join)(tilesetPath, "SceneServer", "layers", "0");
       const slpkFileName = `${tilesetPath}.slpk`;
-      await (0, import_zip.createZip)(slpkTilesetPath, slpkFileName, async (fileList) => ({
+      await (0, import_zip2.createZip)(slpkTilesetPath, slpkFileName, async (fileList) => ({
         path: "@specialIndexFileHASH128@",
-        file: await (0, import_zip.composeHashFile)(fileList)
+        file: await (0, import_zip2.composeHashFile)(fileList)
       }));
       try {
         await removeDir(tilesetPath);
@@ -4460,7 +4945,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,
@@ -4494,6 +4985,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
@@ -4503,6 +5076,7 @@ var I3SConverter = class {
    * @param level - tree level
    */
   async _createNode(parentNode, sourceTile, transformationMatrix) {
+    var _a2;
     this._checkAddRefinementTypeForTile(sourceTile);
     await this._updateTilesetOptions();
     let tileContent = null;
@@ -4519,6 +5093,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,
@@ -4543,33 +5122,28 @@ 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) {
         if (sourceTile.id) {
-          await this.conversionDump.addNode(sourceTile.id, nodeInPage.index);
+          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);
       }
@@ -4637,7 +5211,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,
@@ -4647,7 +5221,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: {
@@ -4658,7 +5237,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);
@@ -4669,12 +5248,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;
@@ -4937,6 +5520,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);
+        }
       }
     }
   }
@@ -5088,7 +5674,7 @@ var I3SConverter = class {
     const { tilesCount, tilesWithAddRefineCount } = this.refinementCounter;
     const addRefinementPercentage = tilesWithAddRefineCount ? tilesWithAddRefineCount / tilesCount * 100 : 0;
     const filesSize = await calculateFilesSize(params);
-    const diff = import_process3.default.hrtime(this.conversionStartTime);
+    const diff = import_process4.default.hrtime(this.conversionStartTime);
     const conversionTime = timeConverter(diff);
     console.log(`------------------------------------------------`);
     console.log(`Finishing conversion of ${_3D_TILES}`);
@@ -5109,18 +5695,18 @@ var I3SConverter = class {
       "cesium-ion": { accessToken: this.options.token || ION_DEFAULT_TOKEN }
     };
     const preloadOptions = await this.Loader.preload(this.options.inputUrl, options);
-    this.refreshTokenTime = import_process3.default.hrtime();
+    this.refreshTokenTime = import_process4.default.hrtime();
     return { ...options, ...preloadOptions };
   }
   /**
    * Update options of source tileset
    */
   async _updateTilesetOptions() {
-    const diff = import_process3.default.hrtime(this.refreshTokenTime);
+    const diff = import_process4.default.hrtime(this.refreshTokenTime);
     if (diff[0] < REFRESH_TOKEN_TIMEOUT) {
       return;
     }
-    this.refreshTokenTime = import_process3.default.hrtime();
+    this.refreshTokenTime = import_process4.default.hrtime();
     const preloadOptions = await this._fetchPreloadOptions();
     if (preloadOptions.headers) {
       this.loadOptions.fetch = {
@@ -5153,7 +5739,7 @@ var I3SConverter = class {
 
 // src/3d-tiles-converter/3d-tiles-converter.ts
 var import_path8 = require("path");
-var import_process4 = __toESM(require("process"), 1);
+var import_process5 = __toESM(require("process"), 1);
 var import_json_map_transform10 = __toESM(require("json-map-transform"), 1);
 var import_core15 = require("@loaders.gl/core");
 var import_i3s2 = require("@loaders.gl/i3s");
@@ -5529,7 +6115,9 @@ var B3dmConverter = class {
 // src/3d-tiles-converter/helpers/load-i3s.ts
 var import_core14 = require("@loaders.gl/core");
 var import_i3s = require("@loaders.gl/i3s");
-var loadI3SContent = async (sourceTileset, sourceTile, tilesetLoadOptions) => {
+var import_loader_utils5 = require("@loaders.gl/loader-utils");
+var import_zip3 = require("@loaders.gl/zip");
+var loadI3SContent = async (sourceTileset, sourceTile, tilesetLoadOptions, slpkFilesystem) => {
   if (!sourceTileset || !sourceTile.contentUrl) {
     return null;
   }
@@ -5537,10 +6125,12 @@ var loadI3SContent = async (sourceTileset, sourceTile, tilesetLoadOptions) => {
     ...tilesetLoadOptions,
     i3s: {
       ...tilesetLoadOptions.i3s,
+      // @ts-expect-error
       isTileset: false,
+      // @ts-expect-error
       isTileHeader: false,
       _tileOptions: {
-        attributeUrls: sourceTile.attributeUrls,
+        attributeUrls: sourceTile.attributeUrls || [],
         textureUrl: sourceTile.textureUrl,
         textureFormat: sourceTile.textureFormat,
         textureLoaderOptions: sourceTile.textureLoaderOptions,
@@ -5550,20 +6140,64 @@ var loadI3SContent = async (sourceTileset, sourceTile, tilesetLoadOptions) => {
       },
       _tilesetOptions: {
         store: sourceTileset.store,
+        // @ts-expect-error
         attributeStorageInfo: sourceTileset.attributeStorageInfo,
+        // @ts-expect-error
         fields: sourceTileset.fields
       }
     }
   };
-  const tileContent = await (0, import_core14.load)(sourceTile.contentUrl, import_i3s.I3SLoader, loadOptions);
+  const tileContent = await loadFromArchive2(
+    sourceTile.contentUrl,
+    import_i3s.I3SLoader,
+    loadOptions,
+    slpkFilesystem
+  );
   return tileContent;
 };
+async function openSLPK(url) {
+  const slpkUrlParts = url.split(".slpk");
+  const { slpkFileName } = getSlpkUrlParts(url) || {};
+  if (slpkFileName) {
+    const slpkFileName2 = `${slpkUrlParts[0]}.slpk`;
+    const fileProvider = new import_loader_utils5.FileHandleFile(slpkFileName2);
+    const archive = await (0, import_i3s.parseSLPKArchive)(fileProvider, void 0, slpkFileName2);
+    const fileSystem = new import_zip3.ZipFileSystem(archive);
+    return fileSystem;
+  }
+  return null;
+}
+async function loadFromArchive2(url, loader, loadOptions, fileSystem) {
+  const slpkUrlParts = getSlpkUrlParts(url);
+  if (fileSystem !== null && slpkUrlParts !== null) {
+    const { internalFileName } = slpkUrlParts;
+    const content = await (0, import_core14.load)(internalFileName, loader, {
+      ...loadOptions,
+      fetch: fileSystem.fetch.bind(fileSystem)
+    });
+    return content;
+  }
+  return await (0, import_core14.load)(url, loader, loadOptions);
+}
+function getSlpkUrlParts(url) {
+  const slpkUrlParts = url.split(".slpk");
+  let result;
+  if (slpkUrlParts.length === 1) {
+    result = null;
+  } else if (slpkUrlParts.length === 2) {
+    result = { slpkFileName: `${slpkUrlParts[0]}.slpk`, internalFileName: slpkUrlParts[1].slice(1) };
+  } else {
+    throw new Error("Unexpected URL format");
+  }
+  return result;
+}
 
 // src/3d-tiles-converter/3d-tiles-converter.ts
 var I3S = "I3S";
 var Tiles3DConverter = class {
   constructor() {
     this.workerSource = {};
+    this.slpkFilesystem = null;
     this.loaderOptions = {
       _nodeWorkers: true,
       reuseWorkers: true,
@@ -5583,6 +6217,7 @@ var Tiles3DConverter = class {
     this.sourceTileset = null;
     this.attributeStorageInfo = null;
     this.workerSource = {};
+    this.conversionDump = new ConversionDump();
   }
   /**
    * Convert i3s format data to 3dTiles
@@ -5599,13 +6234,23 @@ var Tiles3DConverter = class {
       console.log(BROWSER_ERROR_MESSAGE);
       return BROWSER_ERROR_MESSAGE;
     }
-    const { inputUrl, outputPath, tilesetName, maxDepth, egmFilePath } = options;
-    this.conversionStartTime = import_process4.default.hrtime();
-    this.options = { maxDepth };
+    const { inputUrl, outputPath, tilesetName, maxDepth, egmFilePath, inquirer } = options;
+    this.conversionStartTime = import_process5.default.hrtime();
+    this.options = { maxDepth, inquirer };
     console.log("Loading egm file...");
     this.geoidHeightModel = await (0, import_core15.load)(egmFilePath, PGMLoader);
     console.log("Loading egm file completed!");
-    this.sourceTileset = await (0, import_core15.load)(inputUrl, import_i3s2.I3SLoader, this.loaderOptions);
+    this.slpkFilesystem = await openSLPK(inputUrl);
+    this.sourceTileset = await loadFromArchive2(
+      inputUrl,
+      import_i3s2.I3SLoader,
+      {
+        ...this.loaderOptions,
+        // @ts-expect-error `isTileset` can be boolean of 'auto' but TS expects a string
+        i3s: { ...this.loaderOptions.i3s, isTileset: true }
+      },
+      this.slpkFilesystem
+    );
     if (!this.sourceTileset) {
       return;
     }
@@ -5615,9 +6260,24 @@ var Tiles3DConverter = class {
     }
     this.tilesetPath = (0, import_path8.join)(`${outputPath}`, `${tilesetName}`);
     this.attributeStorageInfo = this.sourceTileset.attributeStorageInfo;
-    try {
-      await removeDir(this.tilesetPath);
-    } catch (e) {
+    await this.conversionDump.createDump(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();
+      }
+    }
+    if (!this.conversionDump.restored) {
+      try {
+        await removeDir(this.tilesetPath);
+      } catch (e) {
+      }
     }
     const rootTile = {
       boundingVolume: {
@@ -5630,7 +6290,11 @@ var Tiles3DConverter = class {
     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 });
+    await this.conversionDump.deleteDumpFile();
+    await this._finishConversion({ slpk: false, outputPath, tilesetName });
+    if (this.slpkFilesystem) {
+      this.slpkFilesystem.destroy();
+    }
     const workerFarm = import_worker_utils2.WorkerFarm.getWorkerFarm({});
     workerFarm.destroy();
   }
@@ -5644,7 +6308,18 @@ var Tiles3DConverter = class {
   async convertChildNode(parentSourceNode, parentNode, level, childNodeInfo) {
     const sourceChild = await this._loadChildNode(parentSourceNode, childNodeInfo);
     if (sourceChild.contentUrl) {
-      const content = await loadI3SContent(this.sourceTileset, sourceChild, this.loaderOptions);
+      if (this.conversionDump.restored && this.conversionDump.isFileConversionComplete(`${sourceChild.id}.b3dm`) && (sourceChild.obb || sourceChild.mbs)) {
+        const { child: child2 } = this._createChildAndBoundingVolume(sourceChild);
+        parentNode.children.push(child2);
+        await this._addChildren(sourceChild, child2, level + 1);
+        return;
+      }
+      const content = await loadI3SContent(
+        this.sourceTileset,
+        sourceChild,
+        this.loaderOptions,
+        this.slpkFilesystem
+      );
       if (!content) {
         await this._addChildren(sourceChild, parentNode, level + 1);
         return;
@@ -5654,29 +6329,21 @@ var Tiles3DConverter = class {
       if (this.attributeStorageInfo) {
         featureAttributes = await this._loadChildAttributes(sourceChild, this.attributeStorageInfo);
       }
-      if (!sourceChild.obb) {
-        sourceChild.obb = createObbFromMbs(sourceChild.mbs);
-      }
-      const boundingVolume = {
-        box: i3sObbTo3dTilesObb(sourceChild.obb, this.geoidHeightModel)
-      };
-      const child = {
-        boundingVolume,
-        geometricError: convertScreenThresholdToGeometricError(sourceChild),
-        children: []
-      };
+      const { child, boundingVolume } = this._createChildAndBoundingVolume(sourceChild);
       const i3sAttributesData = {
         tileContent: content,
-        box: boundingVolume.box,
+        box: boundingVolume.box || [],
         textureFormat: sourceChild.textureFormat
       };
       const b3dmConverter = new B3dmConverter();
       const b3dm = await b3dmConverter.convert(i3sAttributesData, featureAttributes);
-      child.content = {
-        uri: `${sourceChild.id}.b3dm`,
-        boundingVolume
-      };
+      await this.conversionDump.addNode(`${sourceChild.id}.b3dm`, sourceChild.id);
       await writeFile(this.tilesetPath, new Uint8Array(b3dm), `${sourceChild.id}.b3dm`);
+      await this.conversionDump.updateConvertedNodesDumpFile(
+        `${sourceChild.id}.b3dm`,
+        sourceChild.id,
+        true
+      );
       parentNode.children.push(child);
       await this._addChildren(sourceChild, child, level + 1);
     } else {
@@ -5716,15 +6383,39 @@ var Tiles3DConverter = class {
       const options = {
         i3s: {
           ...this.loaderOptions,
+          // @ts-expect-error
           isTileHeader: true,
           loadContent: false
         }
       };
       console.log(`Node conversion: ${nodeUrl}`);
-      header = await (0, import_core15.load)(nodeUrl, import_i3s2.I3SLoader, options);
+      header = await loadFromArchive2(nodeUrl, import_i3s2.I3SLoader, options, this.slpkFilesystem);
     }
     return header;
   }
+  /**
+   * Create child and child's boundingVolume for the converted node
+   * @param sourceChild
+   * @returns child and child's boundingVolume
+   */
+  _createChildAndBoundingVolume(sourceChild) {
+    if (!sourceChild.obb) {
+      sourceChild.obb = createObbFromMbs(sourceChild.mbs);
+    }
+    const boundingVolume = {
+      box: i3sObbTo3dTilesObb(sourceChild.obb, this.geoidHeightModel)
+    };
+    const child = {
+      boundingVolume,
+      geometricError: convertScreenThresholdToGeometricError(sourceChild),
+      children: [],
+      content: {
+        uri: `${sourceChild.id}.b3dm`,
+        boundingVolume
+      }
+    };
+    return { boundingVolume, child };
+  }
   /**
    * Make an url of a resource from its relative url having the base url
    * @param baseUrl the base url. A resulting url will be related from this url
@@ -5762,7 +6453,7 @@ var Tiles3DConverter = class {
         attributeName: attribute.name,
         attributeType: this._getAttributeType(attribute)
       };
-      promises.push((0, import_core15.load)(inputUrl, import_i3s2.I3SAttributeLoader, options));
+      promises.push(loadFromArchive2(inputUrl, import_i3s2.I3SAttributeLoader, options, this.slpkFilesystem));
     }
     const attributesList = await Promise.all(promises);
     this._replaceNestedArrays(attributesList);
@@ -5801,7 +6492,7 @@ var Tiles3DConverter = class {
    */
   async _finishConversion(params) {
     const filesSize = await calculateFilesSize(params);
-    const diff = import_process4.default.hrtime(this.conversionStartTime);
+    const diff = import_process5.default.hrtime(this.conversionStartTime);
     const conversionTime = timeConverter(diff);
     console.log(`------------------------------------------------`);
     console.log(`Finish conversion of ${I3S}`);