@etothepii/satisfactory-file-parser 0.1.24 → 0.1.26

package/build/parser/stream/reworked/readable-stream-parser.js

@@ -0,0 +1,201 @@
+var _a;
+import { SatisfactorySave } from "../../satisfactory/save/satisfactory-save";
+import { SaveReader } from "../../satisfactory/save/save-reader";
+import { ReadableStream } from 'web-streams-polyfill';
+import { SaveComponent, isSaveComponent } from "../../satisfactory/objects/SaveComponent";
+import { SaveEntity, isSaveEntity } from "../../satisfactory/objects/SaveEntity";
+import { Level } from "../../satisfactory/save/level.class";
+const DEFAULT_BYTE_HIGHWATERMARK = 1024 * 1024 * 200;
+const createStringLengthQueuingStrategy = (highWaterMark = DEFAULT_BYTE_HIGHWATERMARK / 4) => ({
+    highWaterMark,
+    size: (chunk) => {
+        if (chunk === undefined) {
+            return 0;
+        }
+        return chunk.length;
+    }
+});
+class SimpleWaitForConsumerLock {
+    constructor() {
+        this.locked = false;
+        this.unlockWasCalledInTheMeantime = false;
+        this.executionFn = undefined;
+    }
+    lock(executionFn) {
+        this.executionFn = executionFn;
+        this.locked = true;
+        if (this.unlockWasCalledInTheMeantime) {
+            this.unlock();
+        }
+    }
+    unlock() {
+        this.locked = false;
+        if (this.executionFn) {
+            this.executionFn();
+            this.executionFn = undefined;
+        }
+        else {
+            this.unlockWasCalledInTheMeantime = true;
+        }
+    }
+}
+;
+class ReadableStreamParser {
+    static async WriteLevels(write, reader, mapName, buildVersion) {
+        const batchingSizeOfObjects = 1000;
+        const thresholdOfWrittenObjectsUntilWaitingForConsumerAgain = 3 * batchingSizeOfObjects;
+        const levelCount = reader.readInt32();
+        reader.onProgressCallback(reader.getBufferProgress(), `reading pack of ${levelCount + 1} levels.`);
+        let writtenTotalObjectsSinceConsumerSync = 0;
+        for (let j = 0; j <= levelCount; j++) {
+            let levelName = (j === levelCount) ? '' + mapName : reader.readString();
+            if (j % 500 === 0) {
+                reader.onProgressCallback(reader.getBufferProgress(), `reading level [${(j + 1)}/${(levelCount + 1)}] ${levelName}`);
+            }
+            await write(`${j > 0 ? ', ' : ''}{"name": "${levelName}", "objects": [`, false);
+            const headersBinLen = reader.readInt32();
+            const unk = reader.readInt32();
+            const posBeforeHeaders = reader.getBufferPosition();
+            const afterAllHeaders = posBeforeHeaders + headersBinLen;
+            let countObjectHeaders = reader.readInt32();
+            let totalReadObjectsInLevel = 0;
+            let writtenObjectsInLevel = 0;
+            let afterHeadersOfBatch = reader.getBufferPosition();
+            let afterObjectsOfBatch = -1;
+            do {
+                reader.skipBytes(afterHeadersOfBatch - reader.getBufferPosition());
+                const objectCountToRead = Math.min(countObjectHeaders - totalReadObjectsInLevel, batchingSizeOfObjects);
+                const objects = ReadableStreamParser.ReadNObjectHeaders(reader, objectCountToRead);
+                afterHeadersOfBatch = reader.getBufferPosition();
+                if (totalReadObjectsInLevel === 0) {
+                    reader.skipBytes(afterAllHeaders - reader.getBufferPosition());
+                    const objectContentsBinLen = reader.readInt32();
+                    const unk2 = reader.readInt32();
+                    const posBeforeContents = reader.getBufferPosition();
+                    const countEntities = reader.readInt32();
+                    afterObjectsOfBatch = reader.getBufferPosition();
+                }
+                else {
+                    reader.skipBytes(afterObjectsOfBatch - reader.getBufferPosition());
+                }
+                ReadableStreamParser.ReadNObjects(reader, objectCountToRead, objects, buildVersion);
+                afterObjectsOfBatch = reader.getBufferPosition();
+                totalReadObjectsInLevel += objectCountToRead;
+                if (countObjectHeaders > 10000 && totalReadObjectsInLevel % 10000 === 0) {
+                    reader.onProgressCallback(reader.getBufferProgress(), `read object count [${(totalReadObjectsInLevel + 1)}/${(countObjectHeaders + 1)}] in level ${levelName}`);
+                }
+                let shouldWait = false;
+                if (writtenTotalObjectsSinceConsumerSync >= thresholdOfWrittenObjectsUntilWaitingForConsumerAgain) {
+                    shouldWait = true;
+                    writtenTotalObjectsSinceConsumerSync = 0;
+                }
+                await write(`${writtenObjectsInLevel > 0 ? ', ' : ''}${objects.map(obj => JSON.stringify(obj)).join(', ')}`, shouldWait);
+                writtenTotalObjectsSinceConsumerSync += objectCountToRead;
+                writtenObjectsInLevel += objectCountToRead;
+            } while (totalReadObjectsInLevel < countObjectHeaders);
+            await write('], "collectables": [', false);
+            const collectables = Level.ReadCollectablesList(reader);
+            await write(`${collectables.map(obj => JSON.stringify(obj)).join(', ')}`, true);
+            await write(']', false);
+            await write('}', false);
+        }
+    }
+}
+_a = ReadableStreamParser;
+ReadableStreamParser.CreateReadableStreamForParsingSave = (onStart, onCancel, onPullRequest, highWaterMark = DEFAULT_BYTE_HIGHWATERMARK / 4) => {
+    let ourController = null;
+    const stream = new ReadableStream({
+        start: (controller) => {
+            ourController = controller;
+            onStart(ourController);
+        },
+        pull: (controller) => {
+            onPullRequest(ourController.desiredSize ?? 1);
+        },
+        cancel: (reason) => {
+            console.warn('parsing stream was canceled!', reason);
+            if (ourController !== null) {
+                ourController.close();
+            }
+            onCancel(reason);
+        }
+    }, createStringLengthQueuingStrategy(highWaterMark));
+    const finish = () => {
+        if (ourController !== null) {
+            ourController?.close();
+        }
+    };
+    return { stream, controller: ourController, finish };
+};
+ReadableStreamParser.CreateReadableStreamFromSaveToJson = (name, bytes, onDecompressedSaveBody = () => { }, onProgress = () => { }) => {
+    const waitForConsumerLock = new SimpleWaitForConsumerLock();
+    const waitForConsumer = async () => {
+        return new Promise((resolve, reject) => {
+            waitForConsumerLock.lock(resolve);
+        });
+    };
+    const { stream, controller, finish } = ReadableStreamParser.CreateReadableStreamForParsingSave((controller) => {
+    }, (reason) => { }, (desiredSize) => {
+        waitForConsumerLock.unlock();
+    });
+    const write = async (value, waitForConsumerToBeReady = true) => {
+        if (waitForConsumerToBeReady) {
+            await waitForConsumer();
+        }
+        controller.enqueue(value);
+    };
+    const startStreaming = async () => {
+        const reader = new SaveReader(bytes.buffer, onProgress);
+        const header = reader.readHeader();
+        const save = new SatisfactorySave(name, header);
+        const inflateResult = reader.inflateChunks();
+        onDecompressedSaveBody(reader.getBuffer());
+        const gridHash = reader.readSaveBodyHash();
+        const grids = reader.readGrids();
+        await ReadableStreamParser.WriteHeaderAndGrids(write, reader.compressionInfo, header, grids, gridHash);
+        await ReadableStreamParser.WriteLevels(write, reader, save.header.mapName, save.header.buildVersion);
+        await write(`]}`);
+        finish();
+    };
+    return { stream, startStreaming };
+};
+ReadableStreamParser.WriteHeaderAndGrids = async (write, compressionInfo, header, grids, gridHash) => {
+    return write(`{"header": ${JSON.stringify(header)}, "compressionInfo": ${JSON.stringify(compressionInfo)}, "gridHash": ${JSON.stringify(gridHash)}, "grids": ${JSON.stringify(grids)}, "levels": [`, false);
+};
+ReadableStreamParser.ReadNObjectHeaders = (reader, count) => {
+    let objects = [];
+    let objectsRead = 0;
+    for (; objectsRead < count; objectsRead++) {
+        let obj;
+        let objectType = reader.readInt32();
+        switch (objectType) {
+            case SaveEntity.TypeID:
+                obj = new SaveEntity('', '', '', '');
+                SaveEntity.ParseHeader(reader, obj);
+                break;
+            case SaveComponent.TypeID:
+                obj = new SaveComponent('', '', '', '');
+                SaveComponent.ParseHeader(reader, obj);
+                break;
+            default:
+                throw new Error('Unknown object type' + objectType);
+        }
+        objects.push(obj);
+    }
+    return objects;
+};
+ReadableStreamParser.ReadNObjects = (reader, count, objects, buildVersion) => {
+    for (let i = 0; i < count; i++) {
+        objects[i].saveOrBlueprintIndicator = reader.readInt32();
+        objects[i].unknownType2 = reader.readInt32();
+        const binarySize = reader.readInt32();
+        const before = reader.getBufferPosition();
+        if (isSaveEntity(objects[i])) {
+            SaveEntity.ParseData(objects[i], binarySize, reader, buildVersion, objects[i].typePath);
+        }
+        else if (isSaveComponent(objects[i])) {
+            SaveComponent.ParseData(objects[i], binarySize, reader, buildVersion, objects[i].typePath);
+        }
+    }
+};
+export { ReadableStreamParser };

package/build/parser/stream/reworked/stream-parser.d.ts

@@ -1,6 +1,8 @@
 /// <reference types="node" />
 import { WritableStream } from 'stream/web';
 export declare class StreamParser {
-    static ParseSaveFileAsynchronousToOutput(bytes: Uint8Array, outputJson: WritableStream<string>, onDecompressedSaveBody?: (buffer: ArrayBuffer) => void, onProgress?: (progress: number, message?: string) => void): Promise<void>;
+    static ParseSaveFileToJsonStream(name: string, bytes: Uint8Array, outputJson: WritableStream<string>, onDecompressedSaveBody?: (buffer: ArrayBuffer) => void, onProgress?: (progress: number, message?: string) => void): Promise<void>;
     private static readLevelsAsync;
+    private static ReadNObjectHeaders;
+    private static ReadNObjects;
 }

package/build/parser/stream/reworked/stream-parser.js

@@ -1,31 +1,106 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamParser = void 0;
-const __1 = require("../../..");
+import { Level, SatisfactorySave, SaveComponent, SaveEntity, SaveReader } from '../../..';
+import { isSaveComponent } from '../../satisfactory/objects/SaveComponent';
+import { isSaveEntity } from '../../satisfactory/objects/SaveEntity';
 class StreamParser {
-    static async ParseSaveFileAsynchronousToOutput(bytes, outputJson, onDecompressedSaveBody = () => { }, onProgress = () => { }) {
-        const reader = new __1.SaveReader(bytes.buffer, onProgress);
+    static async ParseSaveFileToJsonStream(name, bytes, outputJson, onDecompressedSaveBody = () => { }, onProgress = () => { }) {
+        const reader = new SaveReader(bytes.buffer, onProgress);
         const writer = outputJson.getWriter();
         const header = reader.readHeader();
-        const save = new __1.SatisfactorySave(header);
+        const save = new SatisfactorySave(name, header);
         const inflateResult = reader.inflateChunks();
         onDecompressedSaveBody(reader.getBuffer());
         const gridHash = reader.readSaveBodyHash();
         const grids = reader.readGrids();
-        await writer.write(`{"header:" ${JSON.stringify(header)}, "compressionInfo": {}, "gridHash": ${JSON.stringify(gridHash)}, "grids": ${JSON.stringify(grids)}, levels: [`);
+        await writer.write(`{"header": ${JSON.stringify(header)}, "compressionInfo": ${JSON.stringify(reader.compressionInfo)}, "gridHash": ${JSON.stringify(gridHash)}, "grids": ${JSON.stringify(grids)}, "levels": [`);
         await StreamParser.readLevelsAsync(reader, writer, save.header.mapName, save.header.buildVersion);
         await writer.write(`]}`);
+        await writer.ready;
         await writer.close();
     }
     static async readLevelsAsync(reader, writer, mapName, buildVersion) {
         const levelCount = reader.readInt32();
-        reader.onProgressCallback(reader.getBufferProgress(), `reading pack of ${levelCount} levels.`);
+        reader.onProgressCallback(reader.getBufferProgress(), `reading pack of ${levelCount + 1} levels.`);
+        const batchingSizeOfObjects = 1000;
         for (let j = 0; j <= levelCount; j++) {
             let levelName = (j === levelCount) ? '' + mapName : reader.readString();
-            if (j % 300 === 0) {
+            if (j % 500 === 0) {
                 reader.onProgressCallback(reader.getBufferProgress(), `reading level [${(j + 1)}/${(levelCount + 1)}] ${levelName}`);
             }
+            await writer.write(`${j > 0 ? ', ' : ''}{"name": "${levelName}", "objects": [`);
+            const headersBinLen = reader.readInt32();
+            const unk = reader.readInt32();
+            const posBeforeHeaders = reader.getBufferPosition();
+            const afterAllHeaders = posBeforeHeaders + headersBinLen;
+            let countObjectHeaders = reader.readInt32();
+            let totalReadObjects = 0;
+            let afterHeadersOfBatch = reader.getBufferPosition();
+            let afterObjectsOfBatch = -1;
+            do {
+                reader.skipBytes(afterHeadersOfBatch - reader.getBufferPosition());
+                const objectCountToRead = Math.min(countObjectHeaders - totalReadObjects, batchingSizeOfObjects);
+                const objects = StreamParser.ReadNObjectHeaders(reader, objectCountToRead);
+                afterHeadersOfBatch = reader.getBufferPosition();
+                if (totalReadObjects === 0) {
+                    reader.skipBytes(afterAllHeaders - reader.getBufferPosition());
+                    const objectContentsBinLen = reader.readInt32();
+                    const unk2 = reader.readInt32();
+                    const posBeforeContents = reader.getBufferPosition();
+                    const countEntities = reader.readInt32();
+                    afterObjectsOfBatch = reader.getBufferPosition();
+                }
+                else {
+                    reader.skipBytes(afterObjectsOfBatch - reader.getBufferPosition());
+                }
+                StreamParser.ReadNObjects(reader, objectCountToRead, objects, buildVersion);
+                afterObjectsOfBatch = reader.getBufferPosition();
+                totalReadObjects += objectCountToRead;
+                if (countObjectHeaders > 10000 && totalReadObjects % 10000 === 0) {
+                    reader.onProgressCallback(reader.getBufferProgress(), `read object count [${(totalReadObjects + 1)}/${(countObjectHeaders + 1)}] in level ${levelName}`);
+                }
+                await writer.write(`${objects.map(obj => JSON.stringify(obj)).join(', ')}`);
+            } while (totalReadObjects < countObjectHeaders);
+            await writer.write('], "collectables": [');
+            const collectables = Level.ReadCollectablesList(reader);
+            await writer.write(`${collectables.map(obj => JSON.stringify(obj)).join(', ')}`);
+            await writer.write(']');
+            await writer.write('}');
         }
     }
 }
-exports.StreamParser = StreamParser;
+StreamParser.ReadNObjectHeaders = (reader, count) => {
+    let objects = [];
+    let objectsRead = 0;
+    for (; objectsRead < count; objectsRead++) {
+        let obj;
+        let objectType = reader.readInt32();
+        switch (objectType) {
+            case SaveEntity.TypeID:
+                obj = new SaveEntity('', '', '', '');
+                SaveEntity.ParseHeader(reader, obj);
+                break;
+            case SaveComponent.TypeID:
+                obj = new SaveComponent('', '', '', '');
+                SaveComponent.ParseHeader(reader, obj);
+                break;
+            default:
+                throw new Error('Unknown object type' + objectType);
+        }
+        objects.push(obj);
+    }
+    return objects;
+};
+StreamParser.ReadNObjects = (reader, count, objects, buildVersion) => {
+    for (let i = 0; i < count; i++) {
+        objects[i].saveOrBlueprintIndicator = reader.readInt32();
+        objects[i].unknownType2 = reader.readInt32();
+        const binarySize = reader.readInt32();
+        const before = reader.getBufferPosition();
+        if (isSaveEntity(objects[i])) {
+            SaveEntity.ParseData(objects[i], binarySize, reader, buildVersion, objects[i].typePath);
+        }
+        else if (isSaveComponent(objects[i])) {
+            SaveComponent.ParseData(objects[i], binarySize, reader, buildVersion, objects[i].typePath);
+        }
+    }
+};
+export { StreamParser };

package/build/parser/stream/save-stream-json-stringifier.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SaveStreamJsonStringifier = void 0;
-const save_stream_writer_class_1 = require("./save-stream-writer.class");
-class SaveStreamJsonStringifier {
+import { SaveStreamWriter } from "./save-stream-writer.class";
+export class SaveStreamJsonStringifier {
     static async StreamStringifySave(save, output) {
-        const writer = new save_stream_writer_class_1.SaveStreamWriter(output.getWriter());
+        const writer = new SaveStreamWriter(output.getWriter());
         await writer.beginSave();
         await writer.writeHeader(save.header);
         if (save.compressionInfo) {
@@ -32,4 +29,3 @@ class SaveStreamJsonStringifier {
         await writer.close();
     }
 }
-exports.SaveStreamJsonStringifier = SaveStreamJsonStringifier;

package/build/parser/stream/save-stream-reader.class.js

@@ -1,17 +1,11 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SaveStreamReader = void 0;
-const pako_1 = __importDefault(require("pako"));
-const __1 = require("../..");
-const alignment_enum_1 = require("../byte/alignment.enum");
-const byte_stream_reader_class_1 = require("./byte-stream-reader.class");
-const stream_level_class_1 = require("./stream-level.class");
-class SaveStreamReader extends byte_stream_reader_class_1.ByteStreamReader {
+import Pako from "pako";
+import { CompressionLibraryError, CorruptSaveError, UnsupportedVersionError } from "../..";
+import { Alignment } from "../byte/alignment.enum";
+import { ByteStreamReader } from "./byte-stream-reader.class";
+import { StreamLevel } from "./stream-level.class";
+class SaveStreamReader extends ByteStreamReader {
     constructor(reader, maxBufferThreshold, onCloseCallback = async () => { }) {
-        super(reader, onCloseCallback, 30000, maxBufferThreshold, alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        super(reader, onCloseCallback, 30000, maxBufferThreshold, Alignment.LITTLE_ENDIAN);
         this.compressionInfo = {
             packageFileTag: 0,
             maxUncompressedChunkContentSize: 0,
@@ -61,7 +55,7 @@ class SaveStreamReader extends byte_stream_reader_class_1.ByteStreamReader {
         if (header.saveVersion >= 21) {
         }
         else {
-            throw new __1.UnsupportedVersionError("The save version is too old to support encoding currently. Save in newer game version.");
+            throw new UnsupportedVersionError("The save version is too old to support encoding currently. Save in newer game version.");
         }
         return header;
     }
@@ -71,22 +65,22 @@ class SaveStreamReader extends byte_stream_reader_class_1.ByteStreamReader {
         this.operatingDataView = new DataView(this.operatingStreamBuffer.buffer);
         this.currentByte = 0;
         if (this.compressionInfo.packageFileTag <= 0) {
-            this.compressionInfo.packageFileTag = this.operatingDataView.getInt32(0, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.compressionInfo.packageFileTag = this.operatingDataView.getInt32(0, this.alignment === Alignment.LITTLE_ENDIAN);
         }
         if (this.compressionInfo.maxUncompressedChunkContentSize <= 0) {
-            this.compressionInfo.maxUncompressedChunkContentSize = this.operatingDataView.getInt32(8, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.compressionInfo.maxUncompressedChunkContentSize = this.operatingDataView.getInt32(8, this.alignment === Alignment.LITTLE_ENDIAN);
         }
-        const chunkCompressedLength = this.operatingDataView.getInt32(32, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
-        const chunkUncompressedLength = this.operatingDataView.getInt32(40, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        const chunkCompressedLength = this.operatingDataView.getInt32(32, this.alignment === Alignment.LITTLE_ENDIAN);
+        const chunkUncompressedLength = this.operatingDataView.getInt32(40, this.alignment === Alignment.LITTLE_ENDIAN);
         this.currentByte = this.compressionInfo.chunkHeaderSize;
         await this.allocate(chunkCompressedLength);
         let currentChunk = this.operatingStreamBuffer.slice(this.currentByte, this.currentByte + chunkCompressedLength);
         this.currentByte += chunkCompressedLength;
         this.totalNumberOfBytesRead += chunkUncompressedLength;
         try {
-            const uncompressedChunk = pako_1.default.inflate(currentChunk);
+            const uncompressedChunk = Pako.inflate(currentChunk);
             if (uncompressedChunk.byteLength !== chunkUncompressedLength) {
-                throw new __1.CorruptSaveError('indicated save body chunk size does not match the inflated result. Save is possibly corrupt.');
+                throw new CorruptSaveError('indicated save body chunk size does not match the inflated result. Save is possibly corrupt.');
             }
             if (this.debug) {
                 console.log(`${new Date().toString()}: decompressed a chunk from ${currentChunk.byteLength} to ${uncompressedChunk.byteLength} bytes.`);
@@ -94,7 +88,7 @@ class SaveStreamReader extends byte_stream_reader_class_1.ByteStreamReader {
             return uncompressedChunk;
         }
         catch (err) {
-            throw new __1.CompressionLibraryError("Failed to inflate compressed save data. " + err);
+            throw new CompressionLibraryError("Failed to inflate compressed save data. " + err);
         }
     }
     debugInfo() {
@@ -102,7 +96,7 @@ class SaveStreamReader extends byte_stream_reader_class_1.ByteStreamReader {
     }
     async streamLevelsToOutput(writer, header) {
         if (header.saveVersion < 29) {
-            throw new __1.UnsupportedVersionError('Support for < U6 is not yet implemented.');
+            throw new UnsupportedVersionError('Support for < U6 is not yet implemented.');
         }
         await this.allocate(100);
         const numSubLevels = this.readInt32();
@@ -111,11 +105,11 @@ class SaveStreamReader extends byte_stream_reader_class_1.ByteStreamReader {
             if (this.debug) {
                 console.log(`${new Date().toString()}: reading level [${(j)}/${numSubLevels}] ${levelName}`);
             }
-            await stream_level_class_1.StreamLevel.ReadLevelAsync(this, writer, levelName, header.buildVersion);
+            await StreamLevel.ReadLevelAsync(this, writer, levelName, header.buildVersion);
         }
         return;
     }
 }
 SaveStreamReader.EPOCH_TICKS = 621355968000000000n;
 SaveStreamReader.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE = 48;
-exports.SaveStreamReader = SaveStreamReader;
+export { SaveStreamReader };

package/build/parser/stream/save-stream-writer.class.d.ts

@@ -6,20 +6,22 @@ import { ByteArray4, Grids } from '../satisfactory/save/save-reader';
 export declare class SaveStreamWriter {
     private writer;
     private mode;
+    private tracker;
     private formatTracker;
     constructor(writer: WritableStreamDefaultWriter<string>);
-    beginSave(): Promise<void>;
-    writeHeader(header: SatisfactorySaveHeader): Promise<void>;
-    writeCompressionInfo(compressionInfo: ChunkCompressionInfo): Promise<void>;
-    writeGridHash(gridHash: ByteArray4): Promise<void>;
-    writeGrids(grids: Grids): Promise<void>;
-    openLevels(): Promise<void>;
-    openLevel(levelName: string): Promise<void>;
-    writeObjects(...objects: SaveObject[]): Promise<void>;
-    switchInLevelToCollectables(): Promise<void>;
-    writeCollectables(...collectables: ObjectReference[]): Promise<void>;
-    endLevel(): Promise<void>;
-    endLevels(): Promise<void>;
-    endSave(): Promise<void>;
+    private createExecutionFunction;
+    beginSave: () => Promise<void>;
+    writeHeader: (header: SatisfactorySaveHeader) => Promise<void>;
+    writeCompressionInfo: (compressionInfo: ChunkCompressionInfo) => Promise<void>;
+    writeGridHash: (gridHash: ByteArray4) => Promise<void>;
+    writeGrids: (grids: Grids) => Promise<void>;
+    openLevels: () => Promise<void>;
+    openLevel: (levelName: string) => Promise<void>;
+    writeObjects: (...objects: SaveObject[]) => Promise<void>;
+    switchInLevelToCollectables: (...objects: SaveObject[]) => Promise<void>;
+    writeCollectables: (...collectables: ObjectReference[]) => Promise<void>;
+    endLevel: () => Promise<void>;
+    endLevels: () => Promise<void>;
+    endSave: () => Promise<void>;
     close(): Promise<void>;
 }