Improved error handling in viewer.

.env.dev

@@ -1,2 +1,2 @@
-LOG_LEVEL=DEBUG
+LOG_LEVEL=Debug
 PUBLIC_URL=/assets

.env.prod

@@ -1,2 +1,2 @@
-LOG_LEVEL=INFO
+LOG_LEVEL=Info
 PUBLIC_URL=/assets

.env.test

@@ -1,2 +1,2 @@
-LOG_LEVEL=WARN
+LOG_LEVEL=Warning
 RUN_ALL_TESTS=false

src/core/Logger.ts

@@ -26,7 +26,7 @@ function default_log_handler({ time, message, severity, logger, cause }: LogEntr
         case Severity.Info:
             method = console.info;
             break;
-        case Severity.Warn:
+        case Severity.Warning:
             method = console.warn;
             break;
         case Severity.Error:
@@ -91,8 +91,8 @@ export class Logger {
         this.log(Severity.Info, message, cause);
     };
 
-    warn = (message: string, cause?: any): void => {
+    warning = (message: string, cause?: any): void => {
-        this.log(Severity.Warn, message, cause);
+        this.log(Severity.Warning, message, cause);
     };
 
     error = (message: string, cause?: any): void => {

src/core/Result.ts

@@ -11,12 +11,15 @@ export type Success<T> = {
 
 export type Failure = {
     readonly success: false;
-    readonly value?: undefined;
+    readonly value?: never;
     readonly problems: readonly Problem[];
 };
 
 export type Problem = {
     readonly severity: Severity;
+    /**
+     * Readable message meant for users.
+     */
     readonly ui_message: string;
 };
 

src/core/Severity.ts

@@ -6,7 +6,7 @@ export enum Severity {
     Trace,
     Debug,
     Info,
-    Warn,
+    Warning,
     Error,
     Off,
 }

src/core/data_formats/asm/data_flow_analysis/get_map_designations.ts

@@ -25,7 +25,7 @@ export function get_map_designations(
                     const area_id = get_register_value(cfg, inst, inst.args[0].value);
 
                     if (area_id.size() !== 1) {
-                        logger.warn(`Couldn't determine area ID for map_designate instruction.`);
+                        logger.warning(`Couldn't determine area ID for map_designate instruction.`);
                         continue;
                     }
 
@@ -34,7 +34,7 @@ export function get_map_designations(
                     const variant_id = get_register_value(cfg, inst, variant_id_register);
 
                     if (variant_id.size() !== 1) {
-                        logger.warn(
+                        logger.warning(
                             `Couldn't determine area variant ID for map_designate instruction.`,
                         );
                         continue;

src/core/data_formats/asm/data_flow_analysis/get_register_value.ts

@@ -68,7 +68,7 @@ function find_values(
     register: number,
 ): ValueSet {
     if (++ctx.iterations > 100) {
-        logger.warn("Too many iterations.");
+        logger.warning("Too many iterations.");
         return new ValueSet().set_interval(MIN_REGISTER_VALUE, MAX_REGISTER_VALUE);
     }
 

src/core/data_formats/asm/data_flow_analysis/get_stack_value.ts

@@ -58,7 +58,7 @@ function find_values(
     position: number,
 ): ValueSet {
     if (++ctx.iterations > 100) {
-        logger.warn("Too many iterations.");
+        logger.warning("Too many iterations.");
         return new ValueSet().set_interval(MIN_STACK_VALUE, MAX_STACK_VALUE);
     }
 

src/core/data_formats/parsing/afs.ts

@@ -1,27 +1,37 @@
 import { Cursor } from "../cursor/Cursor";
 import { LogManager } from "../../Logger";
+import { Result, result_builder } from "../../Result";
+import { Severity } from "../../Severity";
 
 const logger = LogManager.get("core/data_formats/parsing/afs");
 
 const AFS = 0x00534641;
 
-type AfsFileEntry = {
-    readonly offset: number;
-    readonly size: number;
-};
-
 /**
  * AFS is a trivial archive format used by SEGA for e.g. player character textures.
  *
  * @param cursor - The AFS archive
  * @returns the contained files
  */
-export function parse_afs(cursor: Cursor): ArrayBuffer[] {
+export function parse_afs(cursor: Cursor): Result<ArrayBuffer[]> {
+    const result = result_builder<ArrayBuffer[]>(logger);
+
+    if (cursor.bytes_left < 8) {
+        return result
+            .add_problem(
+                Severity.Error,
+                "AFS archive is corrupted.",
+                "Too small to be an AFS archive.",
+            )
+            .failure();
+    }
+
     const magic = cursor.u32();
 
     if (magic !== AFS) {
-        logger.error("Not an AFS archive.");
+        return result
-        return [];
+            .add_problem(Severity.Error, "AFS archive is corrupted.", "Magic bytes not present.")
+            .failure();
     }
 
     const file_count = cursor.u16();
@@ -29,21 +39,41 @@ export function parse_afs(cursor: Cursor): ArrayBuffer[] {
     // Skip two unused bytes (are these just part of the file count field?).
     cursor.seek(2);
 
-    const file_entries: AfsFileEntry[] = [];
+    const files: ArrayBuffer[] = [];
+
+    for (let i = 1; i <= file_count; i++) {
+        if (cursor.bytes_left < 8) {
+            result.add_problem(
+                Severity.Warning,
+                `AFS file entry ${i} is invalid.`,
+                `Couldn't read file entry ${i}, only ${cursor.bytes_left} bytes left.`,
+            );
+
+            break;
+        }
 
-    for (let i = 0; i < file_count; i++) {
         const offset = cursor.u32();
         const size = cursor.u32();
 
-        file_entries.push({ offset, size });
+        if (offset > cursor.size) {
-    }
+            result.add_problem(
-
+                Severity.Warning,
-    const files: ArrayBuffer[] = [];
+                `AFS file entry ${i} is invalid.`,
-
+                `Invalid file offset ${offset} for entry ${i}.`,
-    for (const { offset, size } of file_entries) {
+            );
+        } else if (offset + size > cursor.size) {
+            result.add_problem(
+                Severity.Warning,
+                `AFS file entry ${i} is invalid.`,
+                `File size ${size} (offset: ${offset}) of entry ${i} too large.`,
+            );
+        } else {
+            const start_pos = cursor.position;
             cursor.seek_start(offset);
             files.push(cursor.array_buffer(size));
+            cursor.seek_start(start_pos);
+        }
     }
 
-    return files;
+    return result.success(files);
 }

src/core/data_formats/parsing/iff.ts

@@ -60,7 +60,7 @@ function parse<T>(
 
             if (!silent) {
                 result.add_problem(
-                    chunks.length === 0 ? Severity.Error : Severity.Warn,
+                    chunks.length === 0 ? Severity.Error : Severity.Warning,
                     "Invalid IFF format.",
                     `Size ${size} was too large (only ${cursor.bytes_left} bytes left) at position ${size_pos}.`,
                 );

src/core/data_formats/parsing/ninja/njcm.ts

@@ -302,7 +302,7 @@ function parse_chunks(
                 type: NjcmChunkType.Unknown,
                 type_id,
             });
-            logger.warn(`Unknown chunk type ${type_id} at offset ${chunk_start_position}.`);
+            logger.warning(`Unknown chunk type ${type_id} at offset ${chunk_start_position}.`);
         }
 
         cursor.seek_start(chunk_start_position + size);
@@ -317,7 +317,7 @@ function parse_vertex_chunk(
     flags: number,
 ): NjcmChunkVertex[] {
     if (chunk_type_id < 32 || chunk_type_id > 50) {
-        logger.warn(`Unknown vertex chunk type ${chunk_type_id}.`);
+        logger.warning(`Unknown vertex chunk type ${chunk_type_id}.`);
         return [];
     }
 

src/core/data_formats/parsing/ninja/texture.ts

@@ -47,12 +47,12 @@ export function parse_xvr(cursor: Cursor): XvrTexture {
 
 export function is_xvm(cursor: Cursor): boolean {
     const iff_result = parse_iff_headers(cursor, true);
+    cursor.seek_start(0);
 
-    if (!iff_result.success) {
+    return (
-        return false;
+        iff_result.success &&
-    }
+        iff_result.value.find(chunk => chunk.type === XVMH || chunk.type === XVRT) != undefined
-
+    );
-    return iff_result.value.find(chunk => chunk.type === XVMH || chunk.type === XVRT) != undefined;
 }
 
 export function parse_xvm(cursor: Cursor): Result<Xvm> {
@@ -84,7 +84,7 @@ export function parse_xvm(cursor: Cursor): Result<Xvm> {
 
     if (header && header.texture_count !== textures.length) {
         result.add_problem(
-            Severity.Warn,
+            Severity.Warning,
             "Corrupted XVM file.",
             `Found ${textures.length} textures instead of ${header.texture_count} as defined in the header.`,
         );

src/core/data_formats/parsing/ninja/xj.ts

@@ -58,7 +58,7 @@ export function parse_xj_model(cursor: Cursor): XjModel {
 
     if (vertex_info_count >= 1) {
         if (vertex_info_count > 1) {
-            logger.warn(`Vertex info count of ${vertex_info_count} was larger than expected.`);
+            logger.warning(`Vertex info count of ${vertex_info_count} was larger than expected.`);
         }
 
         model.vertices.push(...parse_vertex_info_table(cursor, vertex_info_table_offset));
@@ -116,7 +116,7 @@ function parse_vertex_info_table(cursor: Cursor, vertex_info_table_offset: numbe
                 uv = cursor.vec2_f32();
                 break;
             default:
-                logger.warn(`Unknown vertex type ${vertex_type} with size ${vertex_size}.`);
+                logger.warning(`Unknown vertex type ${vertex_type} with size ${vertex_size}.`);
                 break;
         }
 

src/core/data_formats/parsing/prc.ts

@@ -15,7 +15,7 @@ export function parse_prc(cursor: Cursor): Cursor {
     const out = prs_decompress(prc_decrypt(key, cursor));
 
     if (out.size !== size) {
-        logger.warn(
+        logger.warning(
             `Size of decrypted, decompressed file was ${out.size} instead of expected ${size}.`,
         );
     }

src/core/data_formats/parsing/quest/bin.ts

@@ -47,7 +47,7 @@ export function parse_bin(cursor: Cursor): { bin: BinFile; dc_gc_format: boolean
         : cursor.string_utf16(576, true, true);
 
     if (size !== cursor.size) {
-        logger.warn(`Value ${size} in bin size field does not match actual size ${cursor.size}.`);
+        logger.warning(`Value ${size} in bin size field does not match actual size ${cursor.size}.`);
     }
 
     cursor.seek(4); // Skip padding.

src/core/data_formats/parsing/quest/dat.ts

@@ -138,7 +138,7 @@ export function parse_dat(cursor: Cursor): DatFile {
             }
 
             if (entities_cursor.bytes_left) {
-                logger.warn(
+                logger.warning(
                     `Read ${entities_cursor.position} bytes instead of expected ${entities_cursor.size} for entity type ${entity_type}.`,
                 );
             }
@@ -285,7 +285,7 @@ function parse_events(cursor: Cursor, area_id: number, events: DatEvent[]): void
             actions_cursor.seek_start(event_actions_offset);
             actions = parse_event_actions(actions_cursor);
         } else {
-            logger.warn(`Invalid event actions offset ${event_actions_offset} for event ${id}.`);
+            logger.warning(`Invalid event actions offset ${event_actions_offset} for event ${id}.`);
         }
 
         events.push({
@@ -300,7 +300,7 @@ function parse_events(cursor: Cursor, area_id: number, events: DatEvent[]): void
     }
 
     if (cursor.position !== actions_offset) {
-        logger.warn(
+        logger.warning(
             `Read ${cursor.position - 16} bytes of event data instead of expected ${actions_offset -
                 16}.`,
         );
@@ -364,7 +364,7 @@ function parse_event_actions(cursor: Cursor): DatEventAction[] {
                 break;
 
             default:
-                logger.warn(`Unexpected event action type ${type}.`);
+                logger.warning(`Unexpected event action type ${type}.`);
                 break outer;
         }
     }

src/core/data_formats/parsing/quest/index.ts

@@ -82,10 +82,10 @@ export function parse_bin_dat_to_quest(
             episode = get_episode(label_0_segment);
             map_designations = get_map_designations(instruction_segments, label_0_segment);
         } else {
-            logger.warn(`No instruction for label 0 found.`);
+            logger.warning(`No instruction for label 0 found.`);
         }
     } else {
-        logger.warn("File contains no instruction labels.");
+        logger.warning("File contains no instruction labels.");
     }
 
     return {

src/core/data_formats/parsing/quest/object_code.ts

@@ -244,7 +244,7 @@ function internal_parse_object_code(
                 segment.labels.sort((a, b) => a - b);
             }
         } else {
-            logger.warn(`Label ${label} with offset ${offset} does not point to anything.`);
+            logger.warning(`Label ${label} with offset ${offset} does not point to anything.`);
         }
     }
 
@@ -410,7 +410,7 @@ function parse_segment(
         const info = label_holder.get_info(label);
 
         if (info == undefined) {
-            logger.warn(`Label ${label} is not registered in the label table.`);
+            logger.warning(`Label ${label} is not registered in the label table.`);
             return;
         }
 

src/core/data_formats/parsing/quest/qst.ts

@@ -326,7 +326,7 @@ function parse_files(
         }
 
         if (file.chunk_nos.has(chunk_no)) {
-            logger.warn(
+            logger.warning(
                 `File chunk number ${chunk_no} of file ${file_name} was already encountered, overwriting previous chunk.`,
             );
         } else {
@@ -338,7 +338,7 @@ function parse_files(
         cursor.seek(-CHUNK_BODY_SIZE - 4);
 
         if (size > CHUNK_BODY_SIZE) {
-            logger.warn(
+            logger.warning(
                 `Data segment size of ${size} is larger than expected maximum size, reading just ${CHUNK_BODY_SIZE} bytes.`,
             );
             size = CHUNK_BODY_SIZE;
@@ -361,7 +361,7 @@ function parse_files(
     }
 
     if (cursor.bytes_left) {
-        logger.warn(`${cursor.bytes_left} Bytes left in file.`);
+        logger.warning(`${cursor.bytes_left} Bytes left in file.`);
     }
 
     for (const file of files.values()) {
@@ -371,7 +371,7 @@ function parse_files(
 
         // Check whether the expected size was correct.
         if (file.expected_size != null && file.cursor.size !== file.expected_size) {
-            logger.warn(
+            logger.warning(
                 `File ${file.name} has an actual size of ${file.cursor.size} instead of the expected size ${file.expected_size}.`,
             );
         }
@@ -382,7 +382,7 @@ function parse_files(
 
         for (let chunk_no = 0; chunk_no < expected_chunk_count; ++chunk_no) {
             if (!file.chunk_nos.has(chunk_no)) {
-                logger.warn(`File ${file.name} is missing chunk ${chunk_no}.`);
+                logger.warning(`File ${file.name} is missing chunk ${chunk_no}.`);
             }
         }
     }

src/core/data_formats/parsing/rlc.ts

@@ -15,7 +15,7 @@ export function parse_rlc(cursor: Cursor): Cursor[] {
     const marker = cursor.string_ascii(16, true, true);
 
     if (marker !== MARKER) {
-        logger.warn(`First 16 bytes where "${marker}" instead of expected "${MARKER}".`);
+        logger.warning(`First 16 bytes where "${marker}" instead of expected "${MARKER}".`);
     }
 
     const table_size = cursor.u32();

src/core/gui/ResultPopup.css

@@ -1,4 +1,4 @@
-.core_ProblemsPopup {
+.core_ResultPopup {
     display: flex;
     flex-direction: column;
     outline: none;
@@ -9,33 +9,33 @@
     box-shadow: black 0 0 10px -2px;
 }
 
-.core_ProblemsPopup:focus-within {
+.core_ResultPopup:focus-within {
     border: var(--border-focus);
 }
 
-.core_ProblemsPopup h1 {
+.core_ResultPopup h1 {
     font-size: 20px;
     margin: 0 0 10px 0;
     padding-bottom: 4px;
     border-bottom: var(--border);
 }
 
-.core_ProblemsPopup_description {
+.core_ResultPopup_description {
     user-select: text;
     cursor: text;
 }
 
-.core_ProblemsPopup_body {
+.core_ResultPopup_body {
     user-select: text;
     overflow: auto;
     margin: 4px 0;
 }
 
-.core_ProblemsPopup_body ul {
+.core_ResultPopup_body ul {
     cursor: text;
 }
 
-.core_ProblemsPopup_footer {
+.core_ResultPopup_footer {
     display: flex;
     flex-direction: row;
     justify-content: flex-end;

src/core/gui/ResultPopup.ts

@@ -1,15 +1,14 @@
 import { ResizableWidget } from "./ResizableWidget";
 import { Widget } from "./Widget";
 import { div, h1, li, section, ul } from "./dom";
-import { Problem } from "../Result";
+import { Problem, Result } from "../Result";
 import { Button } from "./Button";
-import { Disposable } from "../observable/Disposable";
+import "./ResultPopup.css";
-import "./ProblemsPopup.css";
 
 const POPUP_WIDTH = 500;
 const POPUP_HEIGHT = 500;
 
-export class ProblemsPopup extends ResizableWidget {
+export class ResultPopup extends ResizableWidget {
     private x = 0;
     private y = 0;
     private prev_mouse_x = 0;
@@ -19,20 +18,20 @@ export class ProblemsPopup extends ResizableWidget {
     readonly children: readonly Widget[] = [];
     readonly dismiss_button = this.disposable(new Button({ text: "Dismiss" }));
 
-    constructor(description: string, problems: readonly Problem[] = []) {
+    constructor(title: string, description: string, problems: readonly Problem[] = []) {
         super();
 
         let header_element: HTMLElement;
 
         this.element = section(
-            { className: "core_ProblemsPopup", tabIndex: 0 },
+            { className: "core_ResultPopup", tabIndex: 0 },
-            (header_element = h1("Problems")),
+            (header_element = h1(title)),
-            div({ className: "core_ProblemsPopup_description" }, description),
+            div({ className: "core_ResultPopup_description" }, description),
             div(
-                { className: "core_ProblemsPopup_body" },
+                { className: "core_ResultPopup_body" },
                 ul(...problems.map(problem => li(problem.ui_message))),
             ),
-            div({ className: "core_ProblemsPopup_footer" }, this.dismiss_button.element),
+            div({ className: "core_ResultPopup_footer" }, this.dismiss_button.element),
         );
 
         this.element.style.width = `${POPUP_WIDTH}px`;
@@ -46,6 +45,8 @@ export class ProblemsPopup extends ResizableWidget {
         this.element.addEventListener("keydown", this.keydown);
         header_element.addEventListener("mousedown", this.mousedown);
 
+        this.disposables(this.dismiss_button.onclick.observe(() => this.dispose()));
+
         this.finalize_construction();
     }
 
@@ -85,19 +86,28 @@ export class ProblemsPopup extends ResizableWidget {
     };
 }
 
-export function show_problems_popup(
+/**
-    description: string,
+ * Shows a popup if `result` failed or succeeded with problems.
-    problems?: readonly Problem[],
+ *
-): Disposable {
+ * @param result
-    const popup = new ProblemsPopup(description, problems);
+ * @param problems_message - Message to show if problems occurred when result is successful.
-    const onclick = popup.dismiss_button.onclick.observe(() => popup.dispose());
+ * @param error_message - Message to show if result failed.
+ */
+export function show_result_popup(
+    result: Result<unknown>,
+    problems_message: string,
+    error_message: string,
+): void {
+    let popup: ResultPopup | undefined;
+
+    if (!result.success) {
+        popup = new ResultPopup("Error", error_message, result.problems);
+    } else if (result.problems.length) {
+        popup = new ResultPopup("Problems", problems_message, result.problems);
+    }
+
+    if (popup) {
         document.body.append(popup.element);
         popup.focus();
-
+    }
-    return {
-        dispose() {
-            onclick.dispose();
-            popup.dispose();
-        },
-    };
 }

src/core/gui/Table.ts

@@ -168,7 +168,7 @@ export class Table<T> extends Widget {
 
                         if (column.tooltip) cell.title = column.tooltip(value);
                     } catch (e) {
-                        logger.warn(
+                        logger.warning(
                             `Error while rendering cell for index ${index}, column ${i}.`,
                             e,
                         );

src/core/gui/dom.ts

@@ -391,7 +391,7 @@ export function bind_children_to<T>(
             if (child_element) {
                 child_element.remove();
             } else {
-                logger.warn(
+                logger.warning(
                     `Expected an element for removal at child index ${
                         change.index
                     } of ${node_to_string(element)} (child count: ${element.childElementCount}).`,

src/core/observable/Disposer.ts

@@ -89,7 +89,7 @@ export class Disposer implements Disposable {
             try {
                 disposable.dispose();
             } catch (e) {
-                logger.warn("Error while disposing.", e);
+                logger.warning("Error while disposing.", e);
             }
         }
     }

src/core/undo/UndoStack.ts

@@ -60,7 +60,7 @@ export class UndoStack implements Undo {
                 this.index.update(i => i - 1);
                 this.stack.get(this.index.val).undo();
             } catch (e) {
-                logger.warn("Error while undoing action.", e);
+                logger.warning("Error while undoing action.", e);
             } finally {
                 this.undoing_or_redoing = false;
             }
@@ -78,7 +78,7 @@ export class UndoStack implements Undo {
                 this.stack.get(this.index.val).redo();
                 this.index.update(i => i + 1);
             } catch (e) {
-                logger.warn("Error while redoing action.", e);
+                logger.warning("Error while redoing action.", e);
             } finally {
                 this.undoing_or_redoing = false;
             }

src/hunt_optimizer/stores/ItemDropStore.ts

@@ -93,7 +93,7 @@ function create_loader(
             const npc_type = (NpcType as any)[drop_dto.enemy];
 
             if (!npc_type) {
-                logger.warn(
+                logger.warning(
                     `Couldn't determine NpcType of episode ${drop_dto.episode} ${drop_dto.enemy}.`,
                 );
                 continue;
@@ -103,14 +103,14 @@ function create_loader(
             const item_type = item_type_store.get_by_id(drop_dto.item_type_id);
 
             if (!item_type) {
-                logger.warn(`Couldn't find item kind ${drop_dto.item_type_id}.`);
+                logger.warning(`Couldn't find item kind ${drop_dto.item_type_id}.`);
                 continue;
             }
 
             const section_id = (SectionId as any)[drop_dto.section_id];
 
             if (section_id == null) {
-                logger.warn(`Couldn't find section ID ${drop_dto.section_id}.`);
+                logger.warning(`Couldn't find section ID ${drop_dto.section_id}.`);
                 continue;
             }
 

src/quest_editor/QuestRunner.ts

@@ -317,7 +317,7 @@ export class QuestRunner {
             },
 
             warning: (msg: string, inst_ptr?: InstructionPointer): void => {
-                this.logger.warn(message_with_inst_ptr(msg, inst_ptr));
+                this.logger.warning(message_with_inst_ptr(msg, inst_ptr));
             },
 
             error: (err: Error, inst_ptr?: InstructionPointer): void => {

src/quest_editor/gui/EventSubGraphView.ts

@@ -105,7 +105,7 @@ export class EventSubGraphView extends View {
             const data = this.event_gui_data.get(event);
 
             if (!data) {
-                logger.warn(`No GUI data for event ${event.id}.`);
+                logger.warning(`No GUI data for event ${event.id}.`);
                 continue;
             }
 
@@ -119,7 +119,7 @@ export class EventSubGraphView extends View {
                 const child_data = this.event_gui_data.get(child);
 
                 if (!child_data) {
-                    logger.warn(`No GUI data for child event ${child.id}.`);
+                    logger.warning(`No GUI data for child event ${child.id}.`);
                     continue;
                 }
 

src/quest_editor/gui/LogView.css

@@ -39,6 +39,6 @@
     color: hsl(0, 80%, 50%);
 }
 
-.quest_editor_LogView .quest_editor_LogView_Warn_message .quest_editor_LogView_message_level {
+.quest_editor_LogView .quest_editor_LogView_Warning_message .quest_editor_LogView_message_level {
     color: hsl(30, 80%, 50%);
 }

src/quest_editor/gui/QuestEditorView.ts

@@ -244,7 +244,7 @@ export class QuestEditorView extends ResizableView {
                 return gl;
             }
         } catch (e) {
-            logger.warn("Couldn't instantiate golden layout with persisted layout.", e);
+            logger.warning("Couldn't instantiate golden layout with persisted layout.", e);
         }
 
         logger.info("Instantiating golden layout with default layout.");

src/quest_editor/loading/EntityAssetLoader.ts

@@ -59,12 +59,12 @@ export class EntityAssetLoader implements Disposable {
                     if (nj_objects.success && nj_objects.value.length) {
                         return ninja_object_to_buffer_geometry(nj_objects.value[0]);
                     } else {
-                        logger.warn(`Couldn't parse ${url} for ${entity_type_to_string(type)}.`);
+                        logger.warning(`Couldn't parse ${url} for ${entity_type_to_string(type)}.`);
                         return DEFAULT_ENTITY;
                     }
                 })
                 .catch(e => {
-                    logger.warn(
+                    logger.warning(
                         `Couldn't load geometry file for ${entity_type_to_string(type)}.`,
                         e,
                     );
@@ -82,7 +82,7 @@ export class EntityAssetLoader implements Disposable {
                     return xvm.success ? xvm_to_textures(xvm.value) : [];
                 })
                 .catch(e => {
-                    logger.warn(
+                    logger.warning(
                         `Couldn't load texture file for ${entity_type_to_string(type)}.`,
                         e,
                     );

src/quest_editor/model/QuestModel.ts

@@ -274,7 +274,7 @@ export class QuestModel {
             try {
                 variants.set(area_id, this.area_store.get_variant(this.episode, area_id, 0));
             } catch (e) {
-                logger.warn(e);
+                logger.warning(e);
             }
         }
 
@@ -285,7 +285,7 @@ export class QuestModel {
                     this.area_store.get_variant(this.episode, area_id, variant_id),
                 );
             } catch (e) {
-                logger.warn(e);
+                logger.warning(e);
             }
         }
 

src/quest_editor/scripting/vm/io.ts

@@ -49,44 +49,44 @@ export interface VirtualMachineIO
 
 export class DefaultVirtualMachineIO implements VirtualMachineIO {
     map_designate(area_id: number, area_variant_id: number): void {
-        logger.warn(`bb_map_designate(${area_id}, ${area_variant_id})`);
+        logger.warning(`bb_map_designate(${area_id}, ${area_variant_id})`);
     }
 
     set_floor_handler(area_id: number, label: number): void {
-        logger.warn(`set_floor_handler(${area_id}, ${label})`);
+        logger.warning(`set_floor_handler(${area_id}, ${label})`);
     }
 
     window_msg(msg: string): void {
-        logger.warn(`window_msg("${msg}")`);
+        logger.warning(`window_msg("${msg}")`);
     }
 
     message(msg: string): void {
-        logger.warn(`message("${msg}")`);
+        logger.warning(`message("${msg}")`);
     }
 
     add_msg(msg: string): void {
-        logger.warn(`add_msg("${msg}")`);
+        logger.warning(`add_msg("${msg}")`);
     }
 
     winend(): void {
-        logger.warn("winend");
+        logger.warning("winend");
     }
 
     p_dead_v3(player_slot: number): boolean {
-        logger.warn(`p_dead_v3(${player_slot})`);
+        logger.warning(`p_dead_v3(${player_slot})`);
         return false;
     }
 
     mesend(): void {
-        logger.warn("mesend");
+        logger.warning("mesend");
     }
 
     list(list_items: string[]): void {
-        logger.warn(`list([${list_items.map(i => `"${i}"`).join(", ")}])`);
+        logger.warning(`list([${list_items.map(i => `"${i}"`).join(", ")}])`);
     }
 
     warning(msg: string, inst_ptr?: InstructionPointer): void {
-        logger.warn(msg + this.srcloc_to_string(inst_ptr?.source_location));
+        logger.warning(msg + this.srcloc_to_string(inst_ptr?.source_location));
     }
 
     error(err: Error, inst_ptr?: InstructionPointer): void {

src/quest_editor/stores/LogStore.ts

@@ -65,7 +65,7 @@ export class LogStore implements Disposable {
                 this.log_buffer.splice(DROP_THRESHOLD_HALF, drop_len, {
                     time: new Date(),
                     message: `...dropped ${drop_len} messages...`,
-                    severity: Severity.Warn,
+                    severity: Severity.Warning,
                     logger,
                 });
                 this.logger_name_buffer.splice(

src/quest_editor/stores/QuestEditorStore.ts

@@ -161,7 +161,7 @@ export class QuestEditorStore extends Store {
         if (section) {
             entity.set_section(section);
         } else {
-            logger.warn(`Section ${entity.section_id.val} not found.`);
+            logger.warning(`Section ${entity.section_id.val} not found.`);
         }
     };
 }

src/quest_editor/stores/model_conversion.ts

@@ -118,7 +118,7 @@ function build_event_dags(
         let data = data_map.get(key);
 
         if (data && data.event) {
-            logger.warn(`Ignored duplicate event #${event.id} for area ${event.area_id}.`);
+            logger.warning(`Ignored duplicate event #${event.id} for area ${event.area_id}.`);
             continue;
         }
 
@@ -176,7 +176,7 @@ function build_event_dags(
                     }
                     break;
                 default:
-                    logger.warn(`Unknown event action type: ${(action as any).type}.`);
+                    logger.warning(`Unknown event action type: ${(action as any).type}.`);
                     break;
             }
         }
@@ -210,7 +210,7 @@ function build_event_dags(
                 if (child.event) {
                     event_dags.get(data.area_id)!.add_edge(data.event, child.event);
                 } else {
-                    logger.warn(`Event ${data.event.id} calls nonexistent event ${child_id}.`);
+                    logger.warning(`Event ${data.event.id} calls nonexistent event ${child_id}.`);
                 }
             }
         }

src/viewer/controllers/TextureController.ts

@@ -1,7 +1,7 @@
 import { Controller } from "../../core/controllers/Controller";
 import { filename_extension } from "../../core/util";
 import { read_file } from "../../core/files";
-import { parse_xvm, XvrTexture } from "../../core/data_formats/parsing/ninja/texture";
+import { is_xvm, parse_xvm, XvrTexture } from "../../core/data_formats/parsing/ninja/texture";
 import { ArrayBufferCursor } from "../../core/data_formats/cursor/ArrayBufferCursor";
 import { Endianness } from "../../core/data_formats/Endianness";
 import { parse_afs } from "../../core/data_formats/parsing/afs";
@@ -10,6 +10,9 @@ import { WritableListProperty } from "../../core/observable/property/list/Writab
 import { list_property } from "../../core/observable";
 import { ListProperty } from "../../core/observable/property/list/ListProperty";
 import { prs_decompress } from "../../core/data_formats/compression/prs/decompress";
+import { failure, Result, result_builder } from "../../core/Result";
+import { show_result_popup } from "../../core/gui/ResultPopup";
+import { Severity } from "../../core/Severity";
 
 const logger = LogManager.get("viewer/controllers/TextureController");
 
@@ -17,41 +20,65 @@ export class TextureController extends Controller {
     private readonly _textures: WritableListProperty<XvrTexture> = list_property();
     readonly textures: ListProperty<XvrTexture> = this._textures;
 
-    // TODO: notify user of problems.
     load_file = async (file: File): Promise<void> => {
+        let result: Result<unknown>;
+
         try {
             const ext = filename_extension(file.name).toLowerCase();
             const buffer = await read_file(file);
+            const cursor = new ArrayBufferCursor(buffer, Endianness.Little);
 
             if (ext === "xvm") {
-                const xvm = parse_xvm(new ArrayBufferCursor(buffer, Endianness.Little));
+                const xvm_result = (result = parse_xvm(cursor));
 
-                if (xvm.success) {
+                if (xvm_result.success) {
-                    this._textures.splice(0, Infinity, ...xvm.value.textures);
+                    this._textures.val = xvm_result.value.textures;
                 }
             } else if (ext === "afs") {
-                const afs = parse_afs(new ArrayBufferCursor(buffer, Endianness.Little));
+                const rb = result_builder(logger);
-                const textures: XvrTexture[] = [];
+                const afs_result = parse_afs(cursor);
+                rb.add_result(afs_result);
 
-                for (const buffer of afs) {
+                if (!afs_result.success) {
-                    const cursor = new ArrayBufferCursor(buffer, Endianness.Little);
+                    result = rb.failure();
-                    const xvm = parse_xvm(cursor);
-
-                    if (xvm.success) {
-                        textures.push(...xvm.value.textures);
                 } else {
-                        const xvm = parse_xvm(prs_decompress(cursor.seek_start(0)));
+                    const textures: XvrTexture[] = afs_result.value.flatMap(file => {
+                        const cursor = new ArrayBufferCursor(file, Endianness.Little);
 
-                        if (xvm.success) {
+                        if (is_xvm(cursor)) {
-                            textures.push(...xvm.value.textures);
+                            const xvm_result = parse_xvm(cursor);
-                        }
+                            rb.add_result(xvm_result);
+                            return xvm_result.value?.textures ?? [];
+                        } else {
+                            const xvm_result = parse_xvm(prs_decompress(cursor.seek_start(0)));
+                            rb.add_result(xvm_result);
+                            return xvm_result.value?.textures ?? [];
                         }
+                    });
+
+                    if (textures.length) {
+                        result = rb.success(textures);
+                    } else {
+                        result = rb.failure();
                     }
 
                     this._textures.val = textures;
                 }
+            } else {
+                logger.debug(`Unsupported file extension in filename "${file.name}".`);
+                result = failure([
+                    { severity: Severity.Error, ui_message: "Unsupported file type." },
+                ]);
+            }
         } catch (e) {
             logger.error("Couldn't read file.", e);
+            result = failure();
         }
+
+        show_result_popup(
+            result,
+            `Encountered some problems while opening "${file.name}".`,
+            `Couldn't open "${file.name}".`,
+        );
     };
 }

src/viewer/controllers/model/ModelToolBarController.ts

@@ -10,8 +10,9 @@ import { is_xvm, parse_xvm, XvrTexture } from "../../../core/data_formats/parsin
 import { parse_afs } from "../../../core/data_formats/parsing/afs";
 import { LogManager } from "../../../core/Logger";
 import { prs_decompress } from "../../../core/data_formats/compression/prs/decompress";
-import { show_problems_popup } from "../../../core/gui/ProblemsPopup";
+import { failure, Result, result_builder, success } from "../../../core/Result";
-import { Result, result_builder } from "../../../core/Result";
+import { show_result_popup } from "../../../core/gui/ResultPopup";
+import { Severity } from "../../../core/Severity";
 
 const logger = LogManager.get("viewer/controllers/model/ModelToolBarController");
 
@@ -53,22 +54,23 @@ export class ModelToolBarController extends Controller {
     };
 
     load_file = async (file: File): Promise<void> => {
+        let result: Result<unknown>;
+
         try {
             const buffer = await read_file(file);
             const cursor = new ArrayBufferCursor(buffer, Endianness.Little);
-            let result: Result<any> | undefined;
 
             if (file.name.endsWith(".nj")) {
-                result = parse_nj(cursor);
+                const nj_result = (result = parse_nj(cursor));
 
-                if (result.success) {
+                if (nj_result.success) {
-                    this.store.set_current_nj_object(result.value[0]);
+                    this.store.set_current_nj_object(nj_result.value[0]);
                 }
             } else if (file.name.endsWith(".xj")) {
-                result = parse_xj(cursor);
+                const xj_result = (result = parse_xj(cursor));
 
-                if (result.success) {
+                if (xj_result.success) {
-                    this.store.set_current_nj_object(result.value[0]);
+                    this.store.set_current_nj_object(xj_result.value[0]);
                 }
             } else if (file.name.endsWith(".njm")) {
                 this.store.set_current_animation(undefined);
@@ -79,20 +81,29 @@ export class ModelToolBarController extends Controller {
                 if (nj_object) {
                     this.set_animation_playing(true);
                     this.store.set_current_nj_motion(parse_njm(cursor, nj_object.bone_count()));
+                    result = success(undefined);
+                } else {
+                    result = failure([
+                        { severity: Severity.Error, ui_message: "No model to animate" },
+                    ]);
                 }
             } else if (file.name.endsWith(".xvm")) {
-                result = parse_xvm(cursor);
+                const xvm_result = (result = parse_xvm(cursor));
 
-                if (result.success) {
+                if (xvm_result.success) {
-                    this.store.set_current_textures(result.value.textures);
+                    this.store.set_current_textures(xvm_result.value.textures);
                 } else {
                     this.store.set_current_textures([]);
                 }
             } else if (file.name.endsWith(".afs")) {
-                const files = parse_afs(cursor);
                 const rb = result_builder(logger);
+                const afs_result = parse_afs(cursor);
+                rb.add_result(afs_result);
 
-                const textures: XvrTexture[] = files.flatMap(file => {
+                if (!afs_result.success) {
+                    result = rb.failure();
+                } else {
+                    const textures: XvrTexture[] = afs_result.value.flatMap(file => {
                         const cursor = new ArrayBufferCursor(file, Endianness.Little);
 
                         if (is_xvm(cursor)) {
@@ -113,27 +124,22 @@ export class ModelToolBarController extends Controller {
                     }
 
                     this.store.set_current_textures(textures);
+                }
             } else {
-                logger.error(`Unsupported file extension in filename "${file.name}".`);
+                logger.debug(`Unsupported file extension in filename "${file.name}".`);
-                show_problems_popup("Unsupported file type.");
+                result = failure([
-            }
+                    { severity: Severity.Error, ui_message: "Unsupported file type." },
-
+                ]);
-            if (result) {
-                let description: string;
-
-                if (result.success) {
-                    description = `Encountered some problems while opening "${file.name}".`;
-                } else {
-                    description = `Couldn't open "${file.name}" because of these problems.`;
-                }
-
-                if (result.problems.length) {
-                    show_problems_popup(description, result.problems);
-                }
             }
         } catch (e) {
             logger.error("Couldn't read file.", e);
-            show_problems_popup(`Couldn't open "${file.name}".`);
+            result = failure();
         }
+
+        show_result_popup(
+            result,
+            `Encountered some problems while opening "${file.name}".`,
+            `Couldn't open "${file.name}".`,
+        );
     };
 }

src/viewer/loading/CharacterClassAssetLoader.ts

@@ -169,16 +169,18 @@ export class CharacterClassAssetLoader implements Disposable {
                 .get(`/player/${model.name}Tex.afs`)
                 .array_buffer()
                 .then(buffer => {
-                    const afs = parse_afs(new ArrayBufferCursor(buffer, Endianness.Little));
+                    const afs_result = parse_afs(new ArrayBufferCursor(buffer, Endianness.Little));
                     const textures: XvrTexture[] = [];
 
-                    for (const file of afs) {
+                    if (afs_result.success) {
+                        for (const file of afs_result.value) {
                             const xvm = parse_xvm(new ArrayBufferCursor(file, Endianness.Little));
 
                             if (xvm.success) {
                                 textures.push(...xvm.value.textures);
                             }
                         }
+                    }
 
                     return textures;
                 });