Ported several things and fixed some bugs.

core/src/commonMain/kotlin/world/phantasmal/core/Strings.kt

@@ -0,0 +1,16 @@
+package world.phantasmal.core
+
+/**
+ * Returns the given filename without the file extension.
+ */
+fun basename(filename: String): String {
+    val dotIdx = filename.lastIndexOf(".")
+
+    // < 0 means filename doesn't contain any "."
+    // Also skip index 0 because that would mean the basename is empty.
+    if (dotIdx > 1) {
+        return filename.substring(0, dotIdx)
+    }
+
+    return filename
+}

lib/src/commonMain/kotlin/world/phantasmal/lib/Constants.kt

@@ -1,3 +0,0 @@
-package world.phantasmal.lib
-
-const val ZERO_U8: UByte = 0u

lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/Assembly.kt

@@ -3,7 +3,6 @@ package world.phantasmal.lib.assembly
 import mu.KotlinLogging
 import world.phantasmal.core.Problem
 import world.phantasmal.core.PwResult
-import world.phantasmal.core.PwResultBuilder
 import world.phantasmal.core.Severity
 import world.phantasmal.lib.buffer.Buffer
 
@@ -55,7 +54,7 @@ private class Assembler(private val assembly: List<String>, private val manualSt
     private var firstSectionMarker = true
     private var prevLineHadLabel = false
 
-    private val result = PwResultBuilder<List<Segment>>(logger)
+    private val result = PwResult.build<List<Segment>>(logger)
 
     fun assemble(): PwResult<List<Segment>> {
         // Tokenize and assemble line by line.

lib/src/commonMain/kotlin/world/phantasmal/lib/compression/prs/PrsDecompress.kt

@@ -2,7 +2,6 @@ package world.phantasmal.lib.compression.prs
 
 import mu.KotlinLogging
 import world.phantasmal.core.PwResult
-import world.phantasmal.core.PwResultBuilder
 import world.phantasmal.core.Severity
 import world.phantasmal.core.Success
 import world.phantasmal.lib.buffer.Buffer
@@ -67,7 +66,7 @@ private class PrsDecompressor(private val src: Cursor) {
 
             return Success(dst.seekStart(0))
         } catch (e: Throwable) {
-            return PwResultBuilder<Cursor>(logger)
+            return PwResult.build<Cursor>(logger)
                 .addProblem(Severity.Error, "PRS-compressed stream is corrupt.", cause = e)
                 .failure()
         }

lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/AbstractWritableCursor.kt

@@ -14,8 +14,8 @@ protected constructor(protected val offset: Int) : WritableCursor {
     protected val absolutePosition: Int
         get() = offset + position
 
-    override fun hasBytesLeft(bytes: Int): Boolean =
+    override fun hasBytesLeft(atLeast: Int): Boolean =
-        bytesLeft >= bytes
+        bytesLeft >= atLeast
 
     override fun seek(offset: Int): WritableCursor =
         seekStart(position + offset)

lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/BufferCursor.kt

@@ -19,9 +19,13 @@ class BufferCursor(
         get() = _size
         set(value) {
             if (value > _size) {
-                ensureSpace(value)
+                ensureSpace(value - _size)
             } else {
                 _size = value
+
+                if (position > _size) {
+                    position = _size
+                }
             }
         }
 

lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/Cursor.kt

@@ -21,7 +21,7 @@ interface Cursor {
 
     val bytesLeft: Int
 
-    fun hasBytesLeft(bytes: Int = 1): Boolean
+    fun hasBytesLeft(atLeast: Int = 1): Boolean
 
     /**
      * Seek forward or backward by a number of bytes.

lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/AreaCollisionGeometry.kt

@@ -0,0 +1,78 @@
+package world.phantasmal.lib.fileFormats
+
+import world.phantasmal.lib.cursor.Cursor
+
+class CollisionObject(
+    val meshes: List<CollisionMesh>,
+)
+
+class CollisionMesh(
+    val vertices: List<Vec3>,
+    val triangles: List<CollisionTriangle>,
+)
+
+class CollisionTriangle(
+    val index1: Int,
+    val index2: Int,
+    val index3: Int,
+    val flags: Int,
+    val normal: Vec3,
+)
+
+fun parseAreaCollisionGeometry(cursor: Cursor): CollisionObject {
+    val dataOffset = parseRel(cursor, parseIndex = false).dataOffset
+    cursor.seekStart(dataOffset)
+    val mainOffsetTableOffset = cursor.int()
+    cursor.seekStart(mainOffsetTableOffset)
+
+    val meshes = mutableListOf<CollisionMesh>()
+
+    while (cursor.hasBytesLeft()) {
+        val startPos = cursor.position
+        val blockTrailerOffset = cursor.int()
+
+        if (blockTrailerOffset == 0) {
+            break
+        }
+
+        val vertices = mutableListOf<Vec3>()
+        val triangles = mutableListOf<CollisionTriangle>()
+        meshes.add(CollisionMesh(vertices, triangles))
+
+        cursor.seekStart(blockTrailerOffset)
+
+        val vertexCount = cursor.int()
+        val vertexTableOffset = cursor.int()
+        val triangleCount = cursor.int()
+        val triangleTableOffset = cursor.int()
+
+        cursor.seekStart(vertexTableOffset)
+
+        repeat(vertexCount) {
+            vertices.add(cursor.vec3Float())
+        }
+
+        cursor.seekStart(triangleTableOffset)
+
+        repeat(triangleCount) {
+            val index1 = cursor.uShort().toInt()
+            val index2 = cursor.uShort().toInt()
+            val index3 = cursor.uShort().toInt()
+            val flags = cursor.uShort().toInt()
+            val normal = cursor.vec3Float()
+            cursor.seek(16)
+
+            triangles.add(CollisionTriangle(
+                index1,
+                index2,
+                index3,
+                flags,
+                normal
+            ))
+        }
+
+        cursor.seekStart(startPos + 24)
+    }
+
+    return CollisionObject(meshes)
+}

lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/Rel.kt

@@ -0,0 +1,50 @@
+package world.phantasmal.lib.fileFormats
+
+import world.phantasmal.lib.cursor.Cursor
+
+class Rel(
+    /**
+     * Offset from which to start parsing the file.
+     */
+    val dataOffset: Int,
+    /**
+     * List of offsets into the file, presumably used by Sega to fix pointers after loading a file
+     * directly into memory.
+     */
+    val index: List<RelIndexEntry>,
+)
+
+class RelIndexEntry(
+    val offset: Int,
+    val size: Int,
+)
+
+fun parseRel(cursor: Cursor, parseIndex: Boolean): Rel {
+    cursor.seekEnd(32)
+
+    val indexOffset = cursor.int()
+    val indexSize = cursor.int()
+    cursor.seek(8) // Typically 1, 0, 0,...
+    val dataOffset = cursor.int()
+    // Typically followed by 12 nul bytes.
+
+    cursor.seekStart(indexOffset)
+    val index = if (parseIndex) parseIndices(cursor, indexSize) else emptyList()
+
+    return Rel(dataOffset, index)
+}
+
+private fun parseIndices(cursor: Cursor, indexSize: Int): List<RelIndexEntry> {
+    val compactOffsets = cursor.uShortArray(indexSize)
+    var expandedOffset = 0
+
+    return compactOffsets.map { compactOffset ->
+        expandedOffset += 4 * compactOffset.toInt()
+
+        // Size is not always present.
+        cursor.seekStart(expandedOffset - 4)
+        val size = cursor.int()
+        val offset = cursor.int()
+        RelIndexEntry(offset, size)
+    }
+}

lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/Vector.kt

@@ -6,4 +6,4 @@ class Vec2(val x: Float, val y: Float)
 
 class Vec3(val x: Float, val y: Float, val z: Float)
 
-fun Cursor.vec3F32(): Vec3 = Vec3(float(), float(), float())
+fun Cursor.vec3Float(): Vec3 = Vec3(float(), float(), float())

lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/ninja/Ninja.kt

@@ -6,7 +6,7 @@ import world.phantasmal.core.Success
 import world.phantasmal.lib.cursor.Cursor
 import world.phantasmal.lib.fileFormats.Vec3
 import world.phantasmal.lib.fileFormats.parseIff
-import world.phantasmal.lib.fileFormats.vec3F32
+import world.phantasmal.lib.fileFormats.vec3Float
 
 private const val NJCM: Int = 0x4D434A4E
 
@@ -53,13 +53,13 @@ private fun <Model : NinjaModel, Context> parseSiblingObjects(
     val shapeSkip = (evalFlags and 0b10000000u) != 0u
 
     val modelOffset = cursor.int()
-    val pos = cursor.vec3F32()
+    val pos = cursor.vec3Float()
     val rotation = Vec3(
         angleToRad(cursor.int()),
         angleToRad(cursor.int()),
         angleToRad(cursor.int()),
     )
-    val scale = cursor.vec3F32()
+    val scale = cursor.vec3Float()
     val childOffset = cursor.int()
     val siblingOffset = cursor.int()
 

lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/ninja/Njcm.kt

@@ -1,23 +1,26 @@
 package world.phantasmal.lib.fileFormats.ninja
 
 import mu.KotlinLogging
-import world.phantasmal.lib.ZERO_U8
 import world.phantasmal.lib.cursor.Cursor
 import world.phantasmal.lib.fileFormats.Vec2
 import world.phantasmal.lib.fileFormats.Vec3
-import world.phantasmal.lib.fileFormats.vec3F32
+import world.phantasmal.lib.fileFormats.vec3Float
 import kotlin.math.abs
 
 // TODO:
-// - colors
+//  - colors
-// - bump maps
+//  - bump maps
 
 private val logger = KotlinLogging.logger {}
 
+private const val ZERO_U8: UByte = 0u
+
+// TODO: Simplify parser by not parsing chunks into vertices and meshes. Do the chunk to vertex/mesh
+//       conversion at a higher level.
 fun parseNjcmModel(cursor: Cursor, cachedChunkOffsets: MutableMap<UByte, Int>): NjcmModel {
     val vlistOffset = cursor.int() // Vertex list
     val plistOffset = cursor.int() // Triangle strip index list
-    val boundingSphereCenter = cursor.vec3F32()
+    val boundingSphereCenter = cursor.vec3Float()
     val boundingSphereRadius = cursor.float()
     val vertices: MutableList<NjcmVertex?> = mutableListOf()
     val meshes: MutableList<NjcmTriangleStrip> = mutableListOf()
@@ -120,20 +123,18 @@ private fun parseChunks(
                 ))
             }
             4 -> {
-                val cacheIndex = flags
                 val offset = cursor.position
 
                 chunks.add(NjcmChunk.CachePolygonList(
-                    cacheIndex,
+                    cacheIndex = flags,
                     offset,
                 ))
 
-                cachedChunkOffsets[cacheIndex] = offset
+                cachedChunkOffsets[flags] = offset
                 loop = false
             }
             5 -> {
-                val cacheIndex = flags
+                val cachedOffset = cachedChunkOffsets[flags]
-                val cachedOffset = cachedChunkOffsets[cacheIndex]
 
                 if (cachedOffset != null) {
                     cursor.seekStart(cachedOffset)
@@ -141,7 +142,7 @@ private fun parseChunks(
                 }
 
                 chunks.add(NjcmChunk.DrawPolygonList(
-                    cacheIndex,
+                    cacheIndex = flags,
                 ))
             }
             in 8..9 -> {
@@ -258,7 +259,7 @@ private fun parseVertexChunk(
 
     for (i in (0u).toUShort() until vertexCount) {
         var vertexIndex = index + i
-        val position = cursor.vec3F32()
+        val position = cursor.vec3Float()
         var normal: Vec3? = null
         var boneWeight = 1f
 
@@ -270,7 +271,7 @@ private fun parseVertexChunk(
             33 -> {
                 // NJDCVVNSH
                 cursor.seek(4) // Always 1.0
-                normal = cursor.vec3F32()
+                normal = cursor.vec3Float()
                 cursor.seek(4) // Always 0.0
             }
             in 35..40 -> {
@@ -285,10 +286,10 @@ private fun parseVertexChunk(
                 }
             }
             41 -> {
-                normal = cursor.vec3F32()
+                normal = cursor.vec3Float()
             }
             in 42..47 -> {
-                normal = cursor.vec3F32()
+                normal = cursor.vec3Float()
 
                 if (chunkTypeId == (44u).toUByte()) {
                     // NJDCVVNNF

lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/ByteCode.kt

@@ -2,7 +2,6 @@ package world.phantasmal.lib.fileFormats.quest
 
 import mu.KotlinLogging
 import world.phantasmal.core.PwResult
-import world.phantasmal.core.PwResultBuilder
 import world.phantasmal.core.Severity
 import world.phantasmal.lib.assembly.*
 import world.phantasmal.lib.assembly.dataFlowAnalysis.ControlFlowGraph
@@ -53,7 +52,7 @@ fun parseByteCode(
 ): PwResult<List<Segment>> {
     val cursor = BufferCursor(byteCode)
     val labelHolder = LabelHolder(labelOffsets)
-    val result = PwResultBuilder<List<Segment>>(logger)
+    val result = PwResult.build<List<Segment>>(logger)
     val offsetToSegment = mutableMapOf<Int, Segment>()
 
     findAndParseSegments(

lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Qst.kt

@@ -0,0 +1,409 @@
+package world.phantasmal.lib.fileFormats.quest
+
+import mu.KotlinLogging
+import world.phantasmal.core.PwResult
+import world.phantasmal.core.Severity
+import world.phantasmal.core.Success
+import world.phantasmal.core.basename
+import world.phantasmal.lib.Endianness
+import world.phantasmal.lib.buffer.Buffer
+import world.phantasmal.lib.cursor.Cursor
+import world.phantasmal.lib.cursor.WritableCursor
+import world.phantasmal.lib.cursor.cursor
+import kotlin.math.ceil
+import kotlin.math.max
+
+private val logger = KotlinLogging.logger {}
+
+// .qst format
+private const val DC_GC_PC_HEADER_SIZE = 60
+private const val BB_HEADER_SIZE = 88
+private const val ONLINE_QUEST = 0x44
+private const val DOWNLOAD_QUEST = 0xa6
+
+// Chunks
+private const val CHUNK_BODY_SIZE = 1024
+private const val DC_GC_PC_CHUNK_HEADER_SIZE = 20
+private const val DC_GC_PC_CHUNK_TRAILER_SIZE = 4
+private const val DC_GC_PC_CHUNK_SIZE =
+    CHUNK_BODY_SIZE + DC_GC_PC_CHUNK_HEADER_SIZE + DC_GC_PC_CHUNK_TRAILER_SIZE
+private const val BB_CHUNK_HEADER_SIZE = 24
+private const val BB_CHUNK_TRAILER_SIZE = 8
+private const val BB_CHUNK_SIZE = CHUNK_BODY_SIZE + BB_CHUNK_HEADER_SIZE + BB_CHUNK_TRAILER_SIZE
+
+class QstContent(
+    val version: Version,
+    val online: Boolean,
+    val files: List<QstContainedFile>,
+)
+
+class QstContainedFile(
+    val id: Int?,
+    val filename: String,
+    val questName: String?,
+    val data: Buffer,
+)
+
+/**
+ * Low level parsing function for .qst files.
+ */
+fun parseQst(cursor: Cursor): PwResult<QstContent> {
+    val result = PwResult.build<QstContent>(logger)
+
+    // A .qst file contains two headers that describe the embedded .dat and .bin files.
+    // Read headers and contained files.
+    val headers = parseHeaders(cursor)
+
+    if (headers.size < 2) {
+        return result
+            .addProblem(
+                Severity.Error,
+                "This .qst file is corrupt.",
+                "Corrupt .qst file, expected at least 2 headers but only found ${headers.size}.",
+            )
+            .failure()
+    }
+
+    var version: Version? = null
+    var online: Boolean? = null
+
+    for (header in headers) {
+        if (version != null && header.version != version) {
+            return result
+                .addProblem(
+                    Severity.Error,
+                    "This .qst file is corrupt.",
+                    "Corrupt .qst file, header version ${header.version} for file ${
+                        header.filename
+                    } doesn't match the previous header's version ${version}.",
+                )
+                .failure()
+        }
+
+        if (online != null && header.online != online) {
+            return result
+                .addProblem(
+                    Severity.Error,
+                    "This .qst file is corrupt.",
+                    "Corrupt .qst file, header type ${
+                        if (header.online) "\"online\"" else "\"download\""
+                    } for file ${header.filename} doesn't match the previous header's type ${
+                        if (online) "\"online\"" else "\"download\""
+                    }.",
+                )
+                .failure()
+        }
+
+        version = header.version
+        online = header.online
+    }
+
+    checkNotNull(version)
+    checkNotNull(online)
+
+    val parseFilesResult: PwResult<List<QstContainedFile>> = parseFiles(
+        cursor,
+        version,
+        headers.map { it.filename to it }.toMap()
+    )
+    result.addResult(parseFilesResult)
+
+    if (parseFilesResult !is Success) {
+        return result.failure()
+    }
+
+    return result.success(QstContent(
+        version,
+        online,
+        parseFilesResult.value
+    ))
+}
+
+private class QstHeader(
+    val version: Version,
+    val online: Boolean,
+    val questId: Int,
+    val name: String,
+    val filename: String,
+    val size: Int,
+)
+
+private fun parseHeaders(cursor: Cursor): List<QstHeader> {
+    val headers = mutableListOf<QstHeader>()
+
+    var prevQuestId: Int? = null
+    var prevFilename: String? = null
+
+    // .qst files should have two headers, some malformed files have more.
+    repeat(4) {
+        // Detect version and whether it's an online or download quest.
+        val version: Version
+        val online: Boolean
+
+        val versionA = cursor.uByte().toInt()
+        cursor.seek(1)
+        val versionB = cursor.uByte().toInt()
+        cursor.seek(-3)
+
+        if (versionA == BB_HEADER_SIZE && versionB == ONLINE_QUEST) {
+            version = Version.BB
+            online = true
+        } else if (versionA == DC_GC_PC_HEADER_SIZE && versionB == ONLINE_QUEST) {
+            version = Version.PC
+            online = true
+        } else if (versionB == DC_GC_PC_HEADER_SIZE) {
+            val pos = cursor.position
+            cursor.seek(35)
+
+            version = if (cursor.byte().toInt() == 0) {
+                Version.GC
+            } else {
+                Version.DC
+            }
+
+            cursor.seekStart(pos)
+
+            online = when (versionA) {
+                ONLINE_QUEST -> true
+                DOWNLOAD_QUEST -> false
+                else -> return@repeat
+            }
+        } else {
+            return@repeat
+        }
+
+        // Read header.
+        val headerSize: Int
+        val questId: Int
+        val name: String
+        val filename: String
+        val size: Int
+
+        when (version) {
+            Version.DC -> {
+                cursor.seek(1) // Skip online/download.
+                questId = cursor.uByte().toInt()
+                headerSize = cursor.uShort().toInt()
+                name = cursor.stringAscii(32, nullTerminated = true, dropRemaining = true)
+                cursor.seek(3)
+                filename = cursor.stringAscii(16, nullTerminated = true, dropRemaining = true)
+                cursor.seek(1)
+                size = cursor.int()
+            }
+
+            Version.GC -> {
+                cursor.seek(1) // Skip online/download.
+                questId = cursor.uByte().toInt()
+                headerSize = cursor.uShort().toInt()
+                name = cursor.stringAscii(32, nullTerminated = true, dropRemaining = true)
+                cursor.seek(4)
+                filename = cursor.stringAscii(16, nullTerminated = true, dropRemaining = true)
+                size = cursor.int()
+            }
+
+            Version.PC -> {
+                headerSize = cursor.uShort().toInt()
+                cursor.seek(1) // Skip online/download.
+                questId = cursor.uByte().toInt()
+                name = cursor.stringAscii(32, nullTerminated = true, dropRemaining = true)
+                cursor.seek(4)
+                filename = cursor.stringAscii(16, nullTerminated = true, dropRemaining = true)
+                size = cursor.int()
+            }
+
+            Version.BB -> {
+                headerSize = cursor.uShort().toInt()
+                cursor.seek(2) // Skip online/download.
+                questId = cursor.uShort().toInt()
+                cursor.seek(38)
+                filename = cursor.stringAscii(16, nullTerminated = true, dropRemaining = true)
+                size = cursor.int()
+                name = cursor.stringAscii(24, nullTerminated = true, dropRemaining = true)
+            }
+        }
+
+        // Use some simple heuristics to figure out whether the file contains more than two headers.
+        // Some malformed .qst files have extra headers.
+        if (
+            prevQuestId != null &&
+            prevFilename != null &&
+            (questId != prevQuestId || basename(filename) != basename(prevFilename!!))
+        ) {
+            cursor.seek(-headerSize)
+            return@repeat
+        }
+
+        prevQuestId = questId
+        prevFilename = filename
+
+        headers.add(QstHeader(
+            version,
+            online,
+            questId,
+            name,
+            filename,
+            size,
+        ))
+    }
+
+    return headers
+}
+
+private class QstFileData(
+    val name: String,
+    val expectedSize: Int?,
+    val cursor: WritableCursor,
+    var chunkNos: MutableSet<Int>,
+)
+
+private fun parseFiles(
+    cursor: Cursor,
+    version: Version,
+    headers: Map<String, QstHeader>,
+): PwResult<List<QstContainedFile>> {
+    val result = PwResult.build<List<QstContainedFile>>(logger)
+
+    // Files are interleaved in 1048 or 1056 byte chunks, depending on the version.
+    // Each chunk has a 20 or 24 byte header, 1024 byte data segment and a 4 or 8 byte trailer.
+    val files = mutableMapOf<String, QstFileData>()
+
+    val chunkSize: Int // Size including padding, header and trailer.
+    val trailerSize: Int
+
+    when (version) {
+        Version.DC,
+        Version.GC,
+        Version.PC,
+        -> {
+            chunkSize = DC_GC_PC_CHUNK_SIZE
+            trailerSize = DC_GC_PC_CHUNK_TRAILER_SIZE
+        }
+
+        Version.BB -> {
+            chunkSize = BB_CHUNK_SIZE
+            trailerSize = BB_CHUNK_TRAILER_SIZE
+        }
+    }
+
+    while (cursor.hasBytesLeft(chunkSize)) {
+        val startPosition = cursor.position
+
+        // Read chunk header.
+        var chunkNo: Int
+
+        when (version) {
+            Version.DC,
+            Version.GC,
+            -> {
+                cursor.seek(1)
+                chunkNo = cursor.uByte().toInt()
+                cursor.seek(2)
+            }
+
+            Version.PC -> {
+                cursor.seek(3)
+                chunkNo = cursor.uByte().toInt()
+            }
+
+            Version.BB -> {
+                cursor.seek(4)
+                chunkNo = cursor.int()
+            }
+        }
+
+        val fileName = cursor.stringAscii(16, nullTerminated = true, dropRemaining = true)
+
+        val file = files.getOrPut(fileName) {
+            val header = headers[fileName]
+            QstFileData(
+                fileName,
+                header?.size,
+                Buffer.withCapacity(
+                    header?.size ?: (10 * CHUNK_BODY_SIZE),
+                    Endianness.Little
+                ).cursor(),
+                mutableSetOf()
+            )
+        }
+
+        if (chunkNo in file.chunkNos) {
+            result.addProblem(
+                Severity.Warning,
+                "File chunk Int $chunkNo of file $fileName was already encountered, overwriting previous chunk.",
+            )
+        } else {
+            file.chunkNos.add(chunkNo)
+        }
+
+        // Read file data.
+        var size = cursor.seek(CHUNK_BODY_SIZE).int()
+        cursor.seek(-CHUNK_BODY_SIZE - 4)
+
+        if (size > CHUNK_BODY_SIZE) {
+            result.addProblem(
+                Severity.Warning,
+                "Data segment size of $size is larger than expected maximum size, reading just $CHUNK_BODY_SIZE bytes.",
+            )
+            size = CHUNK_BODY_SIZE
+        }
+
+        val data = cursor.take(size)
+        val chunkPosition = chunkNo * CHUNK_BODY_SIZE
+        file.cursor.size = max(chunkPosition + size, file.cursor.size)
+        file.cursor.seekStart(chunkPosition).writeCursor(data)
+
+        // Skip the padding and the trailer.
+        cursor.seek(CHUNK_BODY_SIZE - data.size + trailerSize)
+
+        check(cursor.position == startPosition + chunkSize) {
+            "Read ${
+                cursor.position - startPosition
+            } file chunk message bytes instead of expected ${chunkSize}."
+        }
+    }
+
+    if (cursor.hasBytesLeft()) {
+        result.addProblem(Severity.Warning, "${cursor.bytesLeft} Bytes left in file.")
+    }
+
+    for (file in files.values) {
+        // Clean up file properties.
+        file.cursor.seekStart(0)
+        file.chunkNos = file.chunkNos.sorted().toMutableSet()
+
+        // Check whether the expected size was correct.
+        if (file.expectedSize != null && file.cursor.size != file.expectedSize) {
+            result.addProblem(
+                Severity.Warning,
+                "File ${file.name} has an actual size of ${
+                    file.cursor.size
+                } instead of the expected size ${file.expectedSize}.",
+            )
+        }
+
+        // Detect missing file chunks.
+        val actualSize = max(file.cursor.size, file.expectedSize ?: 0)
+        val expectedChunkCount = ceil(actualSize.toDouble() / CHUNK_BODY_SIZE).toInt()
+
+        for (chunkNo in 0 until expectedChunkCount) {
+            if (chunkNo !in file.chunkNos) {
+                result.addProblem(
+                    Severity.Warning,
+                    "File ${file.name} is missing chunk ${chunkNo}.",
+                )
+            }
+        }
+    }
+
+    return result.success(
+        files.values.map { file ->
+            val header = headers[file.name]
+            QstContainedFile(
+                header?.questId,
+                file.name,
+                header?.name,
+                file.cursor.seekStart(0).buffer(),
+            )
+        }
+    )
+}

lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Quest.kt

@@ -11,6 +11,7 @@ import world.phantasmal.lib.assembly.Segment
 import world.phantasmal.lib.assembly.dataFlowAnalysis.getMapDesignations
 import world.phantasmal.lib.compression.prs.prsDecompress
 import world.phantasmal.lib.cursor.Cursor
+import world.phantasmal.lib.cursor.cursor
 
 private val logger = KotlinLogging.logger {}
 
@@ -35,23 +36,23 @@ fun parseBinDatToQuest(
     datCursor: Cursor,
     lenient: Boolean = false,
 ): PwResult<Quest> {
-    val rb = PwResultBuilder<Quest>(logger)
+    val result = PwResult.build<Quest>(logger)
 
     // Decompress and parse files.
     val binDecompressed = prsDecompress(binCursor)
-    rb.addResult(binDecompressed)
+    result.addResult(binDecompressed)
 
     if (binDecompressed !is Success) {
-        return rb.failure()
+        return result.failure()
     }
 
     val bin = parseBin(binDecompressed.value)
 
     val datDecompressed = prsDecompress(datCursor)
-    rb.addResult(datDecompressed)
+    result.addResult(datDecompressed)
 
     if (datDecompressed !is Success) {
-        return rb.failure()
+        return result.failure()
     }
 
     val dat = parseDat(datDecompressed.value)
@@ -71,16 +72,16 @@ fun parseBinDatToQuest(
         lenient,
     )
 
-    rb.addResult(parseByteCodeResult)
+    result.addResult(parseByteCodeResult)
 
     if (parseByteCodeResult !is Success) {
-        return rb.failure()
+        return result.failure()
     }
 
     val byteCodeIr = parseByteCodeResult.value
 
     if (byteCodeIr.isEmpty()) {
-        rb.addProblem(Severity.Warning, "File contains no instruction labels.")
+        result.addProblem(Severity.Warning, "File contains no instruction labels.")
     } else {
         val instructionSegments = byteCodeIr.filterIsInstance<InstructionSegment>()
 
@@ -94,7 +95,7 @@ fun parseBinDatToQuest(
         }
 
         if (label0Segment != null) {
-            episode = getEpisode(rb, label0Segment)
+            episode = getEpisode(result, label0Segment)
 
             for (npc in npcs) {
                 npc.episode = episode
@@ -102,11 +103,11 @@ fun parseBinDatToQuest(
 
             mapDesignations = getMapDesignations(instructionSegments, label0Segment)
         } else {
-            rb.addProblem(Severity.Warning, "No instruction segment for label 0 found.")
+            result.addProblem(Severity.Warning, "No instruction segment for label 0 found.")
         }
     }
 
-    return rb.success(Quest(
+    return result.success(Quest(
         id = bin.questId,
         language = bin.language,
         name = bin.questName,
@@ -123,6 +124,65 @@ fun parseBinDatToQuest(
     ))
 }
 
+class QuestData(
+    val quest: Quest,
+    val version: Version,
+    val online: Boolean,
+)
+
+fun parseQstToQuest(cursor: Cursor, lenient: Boolean = false): PwResult<QuestData> {
+    val result = PwResult.build<QuestData>(logger)
+
+    // Extract contained .dat and .bin files.
+    val qstResult = parseQst(cursor)
+    result.addResult(qstResult)
+
+    if (qstResult !is Success) {
+        return result.failure()
+    }
+
+    val version = qstResult.value.version
+    val online = qstResult.value.online
+    val files = qstResult.value.files
+    var datFile: QstContainedFile? = null
+    var binFile: QstContainedFile? = null
+
+    for (file in files) {
+        val fileName = file.filename.trim().toLowerCase()
+
+        if (fileName.endsWith(".dat")) {
+            datFile = file
+        } else if (fileName.endsWith(".bin")) {
+            binFile = file
+        }
+    }
+
+    if (datFile == null) {
+        return result.addProblem(Severity.Error, "File contains no DAT file.").failure()
+    }
+
+    if (binFile == null) {
+        return result.addProblem(Severity.Error, "File contains no BIN file.").failure()
+    }
+
+    val questResult = parseBinDatToQuest(
+        binFile.data.cursor(),
+        datFile.data.cursor(),
+        lenient,
+    )
+    result.addResult(questResult)
+
+    if (questResult !is Success) {
+        return result.failure()
+    }
+
+    return result.success(QuestData(
+        questResult.value,
+        version,
+        online,
+    ))
+}
+
 /**
  * Defaults to episode I.
  */

lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Version.kt

@@ -0,0 +1,23 @@
+package world.phantasmal.lib.fileFormats.quest
+
+enum class Version {
+    /**
+     * Dreamcast
+     */
+    DC,
+
+    /**
+     * GameCube
+     */
+    GC,
+
+    /**
+     * Desktop
+     */
+    PC,
+
+    /**
+     * BlueBurst
+     */
+    BB,
+}

lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/BufferCursorTests.kt

@@ -6,8 +6,8 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 
 class BufferCursorTests : WritableCursorTests() {
-    override fun createCursor(bytes: ByteArray, endianness: Endianness) =
+    override fun createCursor(bytes: ByteArray, endianness: Endianness, size: Int) =
-        BufferCursor(Buffer.fromByteArray(bytes, endianness))
+        BufferCursor(Buffer.fromByteArray(bytes, endianness), size = size)
 
     @Test
     fun writeUByte_increases_size_correctly() {

lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/CursorTests.kt

@@ -9,7 +9,11 @@ import kotlin.test.assertEquals
  * implementation.
  */
 abstract class CursorTests {
-    abstract fun createCursor(bytes: ByteArray, endianness: Endianness): Cursor
+    abstract fun createCursor(
+        bytes: ByteArray,
+        endianness: Endianness,
+        size: Int = bytes.size,
+    ): Cursor
 
     @Test
     fun simple_cursor_properties_and_invariants() {

lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/WritableCursorTests.kt

@@ -8,7 +8,11 @@ import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
 abstract class WritableCursorTests : CursorTests() {
-    abstract override fun createCursor(bytes: ByteArray, endianness: Endianness): WritableCursor
+    abstract override fun createCursor(
+        bytes: ByteArray,
+        endianness: Endianness,
+        size: Int,
+    ): WritableCursor
 
     @Test
     fun simple_WritableCursor_properties_and_invariants() {
@@ -31,6 +35,33 @@ abstract class WritableCursorTests : CursorTests() {
         assertEquals(endianness, cursor.endianness)
     }
 
+    @Test
+    fun size() {
+        size(Endianness.Little)
+        size(Endianness.Big)
+    }
+
+    private fun size(endianness: Endianness) {
+        val cursor = createCursor(ByteArray(20), endianness, size = 0)
+
+        assertEquals(0, cursor.size)
+
+        cursor.size = 10
+        cursor.seek(10)
+
+        assertEquals(10, cursor.size)
+
+        cursor.size = 20
+        cursor.seek(10)
+
+        assertEquals(20, cursor.size)
+
+        cursor.size = 5
+
+        assertEquals(5, cursor.size)
+        assertEquals(5, cursor.position)
+    }
+
     @Test
     fun writeUByte() {
         testIntegerWrite(1, { uByte().toInt() }, { writeUByte(it.toUByte()) }, Endianness.Little)

lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/QstTests.kt

@@ -0,0 +1,25 @@
+package world.phantasmal.lib.fileFormats.quest
+
+import world.phantasmal.lib.test.asyncTest
+import world.phantasmal.lib.test.readFile
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class QstTests {
+    @Test
+    fun parse_a_GC_quest() = asyncTest{
+        val cursor = readFile("/lost_heat_sword_gc.qst")
+        val qst = parseQst(cursor).unwrap()
+
+        assertEquals(Version.GC, qst.version)
+        assertTrue(qst.online)
+        assertEquals(2, qst.files.size)
+        assertEquals(58, qst.files[0].id)
+        assertEquals("quest58.bin", qst.files[0].filename)
+        assertEquals("PSO/Lost HEAT SWORD", qst.files[0].questName)
+        assertEquals(58, qst.files[1].id)
+        assertEquals("quest58.dat", qst.files[1].filename)
+        assertEquals("PSO/Lost HEAT SWORD", qst.files[1].questName)
+    }
+}

lib/src/jsMain/kotlin/world/phantasmal/lib/cursor/ArrayBufferCursor.kt

@@ -27,6 +27,10 @@ class ArrayBufferCursor(
         set(value) {
             require(size <= backingBuffer.byteLength - offset)
             field = value
+
+            if (position > size) {
+                position = size
+            }
         }
 
     override var endianness: Endianness

lib/src/jsTest/kotlin/world/phantasmal/lib/cursor/ArrayBufferCursorTests.kt

@@ -4,6 +4,6 @@ import org.khronos.webgl.Uint8Array
 import world.phantasmal.lib.Endianness
 
 class ArrayBufferCursorTests : WritableCursorTests() {
-    override fun createCursor(bytes: ByteArray, endianness: Endianness) =
+    override fun createCursor(bytes: ByteArray, endianness: Endianness, size: Int) =
-        ArrayBufferCursor(Uint8Array(bytes.toTypedArray()).buffer, endianness)
+        ArrayBufferCursor(Uint8Array(bytes.toTypedArray()).buffer, endianness, size = size)
 }

observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/ListValCreation.kt

@@ -1,7 +1,12 @@
 package world.phantasmal.observable.value.list
 
+private val EMPTY_LIST_VAL = StaticListVal<Nothing>(emptyList())
+
 fun <E> listVal(vararg elements: E): ListVal<E> = StaticListVal(elements.toList())
 
+@Suppress("UNCHECKED_CAST")
+fun <E> emptyListVal(): ListVal<E> = EMPTY_LIST_VAL as ListVal<E>
+
 fun <E> mutableListVal(
     elements: MutableList<E> = mutableListOf(),
     extractObservables: ObservablesExtractor<E>? = null,

web/src/main/kotlin/world/phantasmal/web/questEditor/QuestEditor.kt

@@ -4,16 +4,15 @@ import kotlinx.coroutines.CoroutineScope
 import org.w3c.dom.HTMLCanvasElement
 import world.phantasmal.web.core.loading.AssetLoader
 import world.phantasmal.web.externals.babylon.Engine
+import world.phantasmal.web.questEditor.controllers.NpcCountsController
 import world.phantasmal.web.questEditor.controllers.QuestEditorToolbarController
 import world.phantasmal.web.questEditor.controllers.QuestInfoController
 import world.phantasmal.web.questEditor.loading.EntityAssetLoader
+import world.phantasmal.web.questEditor.loading.QuestLoader
 import world.phantasmal.web.questEditor.rendering.QuestEditorMeshManager
 import world.phantasmal.web.questEditor.rendering.QuestRenderer
 import world.phantasmal.web.questEditor.stores.QuestEditorStore
-import world.phantasmal.web.questEditor.widgets.QuestEditorRendererWidget
+import world.phantasmal.web.questEditor.widgets.*
-import world.phantasmal.web.questEditor.widgets.QuestEditorToolbar
-import world.phantasmal.web.questEditor.widgets.QuestEditorWidget
-import world.phantasmal.web.questEditor.widgets.QuestInfoWidget
 import world.phantasmal.webui.DisposableContainer
 import world.phantasmal.webui.widgets.Widget
 
@@ -22,19 +21,24 @@ class QuestEditor(
     private val assetLoader: AssetLoader,
     private val createEngine: (HTMLCanvasElement) -> Engine,
 ) : DisposableContainer() {
+    // Asset Loaders
+    private val questLoader = addDisposable(QuestLoader(scope, assetLoader))
+
     // Stores
     private val questEditorStore = addDisposable(QuestEditorStore(scope))
 
     // Controllers
     private val toolbarController =
-        addDisposable(QuestEditorToolbarController(scope, questEditorStore))
+        addDisposable(QuestEditorToolbarController(scope, questLoader, questEditorStore))
     private val questInfoController = addDisposable(QuestInfoController(scope, questEditorStore))
+    private val npcCountsController = addDisposable(NpcCountsController(scope, questEditorStore))
 
     fun createWidget(): Widget =
         QuestEditorWidget(
             scope,
             QuestEditorToolbar(scope, toolbarController),
             { scope -> QuestInfoWidget(scope, questInfoController) },
+            { scope -> NpcCountsWidget(scope, npcCountsController) },
             { scope -> QuestEditorRendererWidget(scope, ::createQuestEditorRenderer) }
         )
 

web/src/main/kotlin/world/phantasmal/web/questEditor/controllers/NpcCountsController.kt

@@ -0,0 +1,44 @@
+package world.phantasmal.web.questEditor.controllers
+
+import kotlinx.coroutines.CoroutineScope
+import world.phantasmal.lib.fileFormats.quest.NpcType
+import world.phantasmal.observable.value.Val
+import world.phantasmal.observable.value.list.emptyListVal
+import world.phantasmal.web.questEditor.models.QuestNpcModel
+import world.phantasmal.web.questEditor.stores.QuestEditorStore
+import world.phantasmal.webui.controllers.Controller
+
+class NpcCountsController(scope: CoroutineScope, store: QuestEditorStore) : Controller(scope) {
+    val unavailable: Val<Boolean> = store.currentQuest.map { it == null }
+
+    val npcCounts: Val<List<NameWithCount>> = store.currentQuest
+        .flatMap { it?.npcs ?: emptyListVal() }
+        .map(::countNpcs)
+
+    private fun countNpcs(npcs: List<QuestNpcModel>): List<NameWithCount> {
+        val npcCounts = mutableMapOf<NpcType, Int>()
+        var extraCanadines = 0
+
+        for (npc in npcs) {
+            // Don't count Vol Opt twice.
+            if (npc.type != NpcType.VolOptPart2) {
+                npcCounts[npc.type] = (npcCounts[npc.type] ?: 0) + 1
+
+                // Cananes always come with 8 canadines.
+                if (npc.type == NpcType.Canane) {
+                    extraCanadines += 8
+                }
+            }
+        }
+
+        return npcCounts.entries
+            // Sort by canonical order.
+            .sortedBy { (npcType) -> npcType.ordinal }
+            .map { (npcType, count) ->
+                val extra = if (npcType == NpcType.Canadine) extraCanadines else 0
+                NameWithCount(npcType.simpleName, (count + extra).toString())
+            }
+    }
+
+    data class NameWithCount(val name: String, val count: String)
+}

web/src/main/kotlin/world/phantasmal/web/questEditor/controllers/QuestEditorToolbarController.kt

@@ -1,22 +1,28 @@
 package world.phantasmal.web.questEditor.controllers
 
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
+import mu.KotlinLogging
 import org.w3c.files.File
 import world.phantasmal.core.*
 import world.phantasmal.lib.Endianness
 import world.phantasmal.lib.cursor.cursor
+import world.phantasmal.lib.fileFormats.quest.Episode
 import world.phantasmal.lib.fileFormats.quest.Quest
 import world.phantasmal.lib.fileFormats.quest.parseBinDatToQuest
+import world.phantasmal.lib.fileFormats.quest.parseQstToQuest
 import world.phantasmal.observable.value.Val
 import world.phantasmal.observable.value.mutableVal
+import world.phantasmal.web.questEditor.loading.QuestLoader
 import world.phantasmal.web.questEditor.stores.QuestEditorStore
 import world.phantasmal.web.questEditor.stores.convertQuestToModel
 import world.phantasmal.webui.controllers.Controller
 import world.phantasmal.webui.readFile
 
+private val logger = KotlinLogging.logger {}
+
 class QuestEditorToolbarController(
     scope: CoroutineScope,
+    private val questLoader: QuestLoader,
     private val questEditorStore: QuestEditorStore,
 ) : Controller(scope) {
     private val _resultDialogVisible = mutableVal(false)
@@ -25,15 +31,25 @@ class QuestEditorToolbarController(
     val resultDialogVisible: Val<Boolean> = _resultDialogVisible
     val result: Val<PwResult<*>?> = _result
 
-    fun openFiles(files: List<File>) {
+    suspend fun createNewQuest(episode: Episode) {
-        launch {
+        questEditorStore.setCurrentQuest(
-            if (files.isEmpty()) return@launch
+            convertQuestToModel(questLoader.loadDefaultQuest(episode))
+        )
+    }
+
+    suspend fun openFiles(files: List<File>) {
+        try {
+            if (files.isEmpty()) return
 
             val qst = files.find { it.name.endsWith(".qst", ignoreCase = true) }
 
             if (qst != null) {
-                val buffer = readFile(qst)
+                val parseResult = parseQstToQuest(readFile(qst).cursor(Endianness.Little))
-                // TODO: Parse qst.
+                setResult(parseResult)
+
+                if (parseResult is Success) {
+                    setCurrentQuest(parseResult.value.quest)
+                }
             } else {
                 val bin = files.find { it.name.endsWith(".bin", ignoreCase = true) }
                 val dat = files.find { it.name.endsWith(".dat", ignoreCase = true) }
@@ -43,7 +59,7 @@ class QuestEditorToolbarController(
                         Severity.Error,
                         "Please select a .qst file or one .bin and one .dat file."
                     ))))
-                    return@launch
+                    return
                 }
 
                 val parseResult = parseBinDatToQuest(
@@ -56,6 +72,12 @@ class QuestEditorToolbarController(
                     setCurrentQuest(parseResult.value)
                 }
             }
+        } catch (e: Throwable) {
+            setResult(
+                PwResult.build<Nothing>(logger)
+                    .addProblem(Severity.Error, "Couldn't parse file.", cause = e)
+                    .failure()
+            )
         }
     }
 

web/src/main/kotlin/world/phantasmal/web/questEditor/loading/EntityAssetLoader.kt

@@ -176,7 +176,10 @@ private fun entityTypeToGeometryFormat(type: EntityType): GeomFormat =
     when (type) {
         is NpcType -> {
             when (type) {
-                NpcType.Dubswitch -> GeomFormat.Xj
+                NpcType.Dubswitch,
+                NpcType.Dubswitch2,
+                -> GeomFormat.Xj
+
                 else -> GeomFormat.Nj
             }
         }

web/src/main/kotlin/world/phantasmal/web/questEditor/loading/QuestLoader.kt

@@ -0,0 +1,42 @@
+package world.phantasmal.web.questEditor.loading
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.async
+import org.khronos.webgl.ArrayBuffer
+import world.phantasmal.core.disposable.TrackedDisposable
+import world.phantasmal.lib.Endianness
+import world.phantasmal.lib.cursor.cursor
+import world.phantasmal.lib.fileFormats.quest.Episode
+import world.phantasmal.lib.fileFormats.quest.Quest
+import world.phantasmal.lib.fileFormats.quest.parseQstToQuest
+import world.phantasmal.web.core.loading.AssetLoader
+
+class QuestLoader(
+    private val scope: CoroutineScope,
+    private val assetLoader: AssetLoader,
+) : TrackedDisposable() {
+    private val cache = LoadingCache<String, ArrayBuffer>()
+
+    override fun internalDispose() {
+        cache.dispose()
+        super.internalDispose()
+    }
+
+    suspend fun loadDefaultQuest(episode: Episode): Quest {
+        require(episode == Episode.I) {
+            "Episode $episode not yet supported."
+        }
+
+        return loadQuest("/defaults/default_ep_1.qst")
+    }
+
+    private suspend fun loadQuest(path: String): Quest {
+        val buffer = cache.getOrPut(path) {
+            scope.async {
+                assetLoader.loadArrayBuffer("/quests$path")
+            }
+        }.await()
+
+        return parseQstToQuest(buffer.cursor(Endianness.Little)).unwrap().quest
+    }
+}

web/src/main/kotlin/world/phantasmal/web/questEditor/widgets/NpcCountsWidget.kt

@@ -0,0 +1,65 @@
+package world.phantasmal.web.questEditor.widgets
+
+import kotlinx.coroutines.CoroutineScope
+import org.w3c.dom.Node
+import world.phantasmal.observable.value.not
+import world.phantasmal.web.core.widgets.UnavailableWidget
+import world.phantasmal.web.questEditor.controllers.NpcCountsController
+import world.phantasmal.webui.dom.*
+import world.phantasmal.webui.widgets.Widget
+
+class NpcCountsWidget(
+    scope: CoroutineScope,
+    private val ctrl: NpcCountsController,
+) : Widget(scope) {
+    override fun Node.createElement() =
+        div {
+            className = "pw-quest-editor-npc-counts"
+
+            table {
+                hidden(ctrl.unavailable)
+
+                bindChildrenTo(ctrl.npcCounts) { (name, count), _ ->
+                    tr {
+                        th { textContent = "$name:" }
+                        td { textContent = count }
+                    }
+                }
+            }
+            addChild(UnavailableWidget(
+                scope,
+                hidden = !ctrl.unavailable,
+                message = "No quest loaded."
+            ))
+        }
+
+    companion object {
+        init {
+            @Suppress("CssUnusedSymbol")
+            // language=css
+            style("""
+                .pw-quest-editor-npc-counts {
+                    box-sizing: border-box;
+                    padding: 3px;
+                    overflow: auto;
+                }
+
+                .pw-quest-editor-npc-counts table {
+                    user-select: text;
+                    width: 100%;
+                    max-width: 300px;
+                    margin: 0 auto;
+                }
+
+                .pw-quest-editor-npc-counts th {
+                    cursor: text;
+                    text-align: left;
+                }
+
+                .pw-quest-editor-npc-counts td {
+                    cursor: text;
+                }
+            """.trimIndent())
+        }
+    }
+}

web/src/main/kotlin/world/phantasmal/web/questEditor/widgets/QuestEditorToolbar.kt

@@ -1,10 +1,13 @@
 package world.phantasmal.web.questEditor.widgets
 
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
 import org.w3c.dom.Node
+import world.phantasmal.lib.fileFormats.quest.Episode
 import world.phantasmal.web.questEditor.controllers.QuestEditorToolbarController
 import world.phantasmal.webui.dom.Icon
 import world.phantasmal.webui.dom.div
+import world.phantasmal.webui.widgets.Button
 import world.phantasmal.webui.widgets.FileButton
 import world.phantasmal.webui.widgets.Toolbar
 import world.phantasmal.webui.widgets.Widget
@@ -20,13 +23,19 @@ class QuestEditorToolbar(
             addChild(Toolbar(
                 scope,
                 children = listOf(
+                    Button(
+                        scope,
+                        text = "New quest",
+                        iconLeft = Icon.NewFile,
+                        onClick = { scope.launch { ctrl.createNewQuest(Episode.I) } }
+                    ),
                     FileButton(
                         scope,
                         text = "Open file...",
                         iconLeft = Icon.File,
                         accept = ".bin, .dat, .qst",
                         multiple = true,
-                        filesSelected = ctrl::openFiles
+                        filesSelected = { files -> scope.launch { ctrl.openFiles(files) } }
                     )
                 )
             ))

web/src/main/kotlin/world/phantasmal/web/questEditor/widgets/QuestEditorWidget.kt

@@ -21,6 +21,7 @@ class QuestEditorWidget(
     scope: CoroutineScope,
     private val toolbar: Widget,
     private val createQuestInfoWidget: (CoroutineScope) -> Widget,
+    private val createNpcCountsWidget: (CoroutineScope) -> Widget,
     private val createQuestRendererWidget: (CoroutineScope) -> Widget,
 ) : Widget(scope) {
     override fun Node.createElement() =
@@ -45,7 +46,7 @@ class QuestEditorWidget(
                                         DockedWidget(
                                             title = "NPC Counts",
                                             id = "npc_counts",
-                                            createWidget = ::TestWidget
+                                            createWidget = createNpcCountsWidget
                                         ),
                                     )
                                 ),