nitro-patcher 0.3.0 → 1.0.0

package/src/nitro/nds-file.ts

@@ -4,20 +4,25 @@ import { readFile, writeFile } from "#nitro-runtime";
 import { Banner } from "./banner";
 import { BinaryWriter, DEFAULT_MAX_SIZE, bytes, range } from "./binary";
 import { crc16 } from "./crc";
-import { encryptSecureArea } from "./crypto";
-import { FileAllocationTable, FileNameTable, OverlayTable } from "./filesystem";
-import type { NitroFile, NitroFolder } from "./filesystem";
+import { decryptSecureArea, encryptSecureArea } from "./crypto";
+import { FileAllocationTable, FileNameTable, OverlayTable, encodeName } from "./filesystem";
+import type { NitroFile, NitroFolder, OverlayItem } from "./filesystem";
 import { Header } from "./header";
 import { TWL } from "./twl";
+import { noDsiVerification } from "./twl-complete";
+import type { DsiSection, DsiVerification } from "./twl-complete";
 
 export interface RomOptions {
   /** Maximum generated ROM size in bytes. Defaults to 1 GiB. */
   maxOutputSize?: number;
+  /** Complete DSi cartridge handling is opt-in for direct API calls. */
+  dsiMode?: "legacy" | "complete";
 }
 
 export interface RomFileInfo {
   /** ROM-relative path, including data/, overlay/, or a system filename. */
   path: string;
+  /** Input ROM identity and position; both are -1 for an added file until the output is reopened. */
   id: number;
   offset: number;
   size: number;
@@ -39,12 +44,18 @@ export class NDSFile {
   readonly warnings: string[] = [];
   private readonly paths = new Map<string, { path: string; file: NitroFile }>();
   private readonly maxOutputSize: number;
+  private readonly addedOverlays = new Map<string, { arm9: boolean; entry: OverlayItem }>();
+  private structureChanged = false;
 
   constructor(input: Uint8Array, options: RomOptions = {}) {
     this.original = bytes(input, "ROM");
     this.maxOutputSize = options.maxOutputSize ?? DEFAULT_MAX_SIZE;
+    if (!Number.isSafeInteger(this.maxOutputSize) || this.maxOutputSize < 1 || this.maxOutputSize > 0xffffffff)
+      throw new RangeError("Invalid output size limit");
     this.header = new Header(this.original);
     const h = this.header;
+    if (options.dsiMode === "complete" && h.unitCode === 3)
+      throw new Error("DSi-exclusive cartridges and DSiWare are unsupported");
     range(this.original, h.ARM9romOffset, h.ARM9size + (h.nitrocode ? 12 : 0), "ARM9");
     range(this.original, h.ARM7romOffset, h.ARM7size, "ARM7");
     this.banner = new Banner(this.original, h.bannerOffset, h.banner_size);
@@ -81,7 +92,53 @@ export class NDSFile {
       for (const child of folder.folders) visit(child, `${prefix + child.name}/`);
     };
     visit(this.root, "");
-    if (h.unitCode & 2 && h.twlInternalFlags & 1 && h.tid_high && h.tid_high !== 0xffffffff) {
+    if (options.dsiMode === "complete" && h.unitCode & 2) {
+      const regions: { start: number; size: number; name: string; payload?: boolean }[] = [
+        ...this.root.files.map((file) => ({ start: file.offset, size: file.size, name: file.name })),
+        ...this.fatTable.entries.map((file) => ({
+          start: file.offset,
+          size: file.size,
+          name: `FAT ${file.id}`,
+          payload: true,
+        })),
+        { start: h.dsi9_rom_offset, size: h.dsi9_size, name: "ARM9i" },
+        { start: h.dsi7_rom_offset, size: h.dsi7_size, name: "ARM7i" },
+        { start: h.sector_hashtable_start, size: h.sector_hashtable_size, name: "DSi sector table" },
+        { start: h.block_hashtable_start, size: h.block_hashtable_size, name: "DSi block table" },
+      ]
+        .filter((region) => region.size)
+        .sort((a, b) => a.start - b.start);
+      let systemEnd: (typeof regions)[number] | undefined;
+      let payloadEnd: (typeof regions)[number] | undefined;
+      for (const region of regions) {
+        range(this.original, region.start, region.size, region.name);
+        for (const previous of [systemEnd, region.payload ? undefined : payloadEnd])
+          if (previous && previous.start + previous.size > region.start)
+            throw new Error(`DSi ROM regions overlap: ${previous.name} and ${region.name}`);
+        if (region.payload) {
+          if (!payloadEnd || region.start + region.size > payloadEnd.start + payloadEnd.size) payloadEnd = region;
+        } else systemEnd = region;
+      }
+      this.twl = new TWL(
+        h,
+        this.overlay9Table.entries
+          .filter((entry) => entry.reserved & 0x2000000)
+          .map((entry) => {
+            const file = this.fatTable.entries[entry.fileId];
+            return { offset: file.offset, size: file.size };
+          }),
+        this.original,
+        { dsiMode: "complete", maxOutputSize: this.maxOutputSize },
+      );
+      for (const [name, offset, size] of [
+        ["arm9i.bin", h.dsi9_rom_offset, h.dsi9_size],
+        ["arm7i.bin", h.dsi7_rom_offset, h.dsi7_size],
+      ] as const) {
+        const file: NitroFile = { name, id: 0xffff, offset, size };
+        this.root.files.push(file);
+        this.paths.set(name, { path: name, file });
+      }
+    } else if (h.unitCode & 2 && h.twlInternalFlags & 1 && h.tid_high && h.tid_high !== 0xffffffff) {
       // Upstream silently discarded malformed TWL regions. Preserve valid DSi data,
       // and reject malformed data instead of emitting a ROM with missing sections.
       this.twl = new TWL(h, arm9Overlays, this.original);
@@ -103,7 +160,12 @@ export class NDSFile {
       path,
       id: file.id,
       offset: file.offset,
-      size: file.replacement?.length ?? file.size,
+      size:
+        this.twl?.complete && (path === "arm9i.bin" || path === "arm7i.bin")
+          ? this.twl.complete.getProgram(path === "arm9i.bin" ? "arm9i" : "arm7i").length
+          : this.addedOverlays.size && (path === "overarm9.bin" || path === "overarm7.bin")
+            ? this.readOverlayTable(path === "overarm9.bin").entries.length * 32
+            : (file.replacement?.length ?? file.size),
     }));
   }
   hasFile(path: string): boolean {
@@ -114,19 +176,149 @@ export class NDSFile {
     if (!entry) throw new Error(`ROM file not found: ${path}`);
     return Buffer.from(this.fileBytes(entry.file));
   }
-  /** Replace an existing file. Adding or deleting filesystem entries is not supported. */
+  /** Replace an existing file. */
   replaceFile(path: string, content: Uint8Array): void {
-    const entry = this.paths.get(key(path));
+    let entry = this.paths.get(key(path));
+    if (!entry && (key(path) === "overarm9.bin" || key(path) === "overarm7.bin")) {
+      if (content.byteLength > this.maxOutputSize) throw new RangeError("Replacement exceeds output size limit");
+      new OverlayTable(content, 0, content.byteLength, key(path) === "overarm9.bin");
+      const file: NitroFile = { name: key(path), id: 0xffff, offset: 0, size: 0 };
+      entry = { path: file.name, file };
+      this.root.files.push(file);
+      this.paths.set(file.name, entry);
+      this.structureChanged = true;
+    }
     if (!entry) throw new Error(`ROM file not found: ${path}`);
+    if (this.twl?.complete && content.byteLength > this.maxOutputSize)
+      throw new RangeError("Replacement exceeds output size limit");
+    if (this.twl?.complete && (key(path) === "arm9i.bin" || key(path) === "arm7i.bin")) {
+      this.twl.complete.setProgram(key(path) === "arm9i.bin" ? "arm9i" : "arm7i", bytes(content));
+      return;
+    }
     entry.file.replacement = Buffer.from(bytes(content));
   }
+  /** Add a NitroFS file and any missing parent directories. */
+  addFile(path: string, content: Uint8Array): void {
+    const components = path.replaceAll("\\", "/").split("/");
+    if (
+      components[0]?.toLowerCase() !== "data" ||
+      components.length < 2 ||
+      components.slice(1).some((name) => !name || name === "." || name === ".." || name.includes("\0"))
+    )
+      throw new Error(`Invalid NitroFS path: ${path}`);
+    if (components.length > 258) throw new Error("FNT directory depth exceeds 256");
+    if (this.hasFile(path)) throw new Error(`ROM file already exists: ${path}`);
+    const replacement = Buffer.from(bytes(content));
+    const names: { name: string; nameBytes?: Buffer }[] = components.slice(1).map((name) => ({ name }));
+    let existing: NitroFolder | undefined = this.data;
+    for (const [index, component] of names.entries()) {
+      const normalized = component.name.toLowerCase();
+      if (existing?.files.some((file) => file.name.toLowerCase() === normalized))
+        throw new Error(`ROM path conflicts with a file: ${path}`);
+      const child: NitroFolder | undefined = existing?.folders.find((child) => child.name.toLowerCase() === normalized);
+      if (index === names.length - 1 && child) throw new Error(`ROM path conflicts with a directory: ${path}`);
+      if (!child) component.nameBytes = encodeName(component.name);
+      existing = child;
+    }
+    let folder = this.data;
+    let prefix = "data";
+    for (const [index, component] of names.entries()) {
+      const normalized = component.name.toLowerCase();
+      const child = folder.folders.find((child) => child.name.toLowerCase() === normalized);
+      if (index === names.length - 1) {
+        const file: NitroFile = { ...component, id: -1, offset: -1, size: replacement.length, replacement };
+        folder.files.push(file);
+        const outputPath = `${prefix}/${file.name}`;
+        this.paths.set(key(outputPath), { path: outputPath, file });
+      } else {
+        if (child) folder = child;
+        else {
+          const created: NitroFolder = { ...component, id: -1, files: [], folders: [] };
+          folder.folders.push(created);
+          folder = created;
+        }
+        prefix += `/${folder.name}`;
+      }
+    }
+    this.structureChanged = true;
+  }
+  /** Add an overlay; file IDs are assigned when the ROM is serialized. */
+  addOverlay(arm9: boolean, metadata: Omit<OverlayItem, "fileId">, content: Uint8Array): void {
+    const path = `overlay/overlay${arm9 ? "" : "7"}_${String(metadata.overlayId).padStart(4, "0")}.bin`;
+    if (!Number.isSafeInteger(metadata.overlayId) || metadata.overlayId < 0 || metadata.overlayId >= 0xffffffff)
+      throw new RangeError("Invalid overlay ID");
+    if (this.hasFile(path)) throw new Error(`ROM file already exists: ${path}`);
+    if (content.byteLength > this.maxOutputSize) throw new RangeError("Overlay exceeds output size limit");
+    const entry: OverlayItem = { ...metadata, fileId: 0 };
+    const table = new OverlayTable(Buffer.alloc(0), 0, 0, arm9);
+    table.entries.push(entry);
+    table.toBuffer();
+    const replacement = Buffer.from(bytes(content));
+    const file: NitroFile = { name: path.slice(8), id: -1, offset: -1, size: replacement.length, replacement };
+    const tableName = arm9 ? "overarm9.bin" : "overarm7.bin";
+    if (!this.hasFile(tableName)) this.replaceFile(tableName, Buffer.alloc(0));
+    this.overlay.files.push(file);
+    this.paths.set(path, { path, file });
+    this.addedOverlays.set(path, { arm9, entry });
+    this.structureChanged = true;
+  }
+  private readOverlayTable(arm9: boolean): OverlayTable {
+    const original = arm9 ? this.overlay9Table : this.overlay7Table;
+    const replacement = this.paths.get(arm9 ? "overarm9.bin" : "overarm7.bin")?.file.replacement;
+    const raw = replacement ?? original.toBuffer();
+    const table = new OverlayTable(raw, 0, raw.length, arm9);
+    for (const { arm9: target, entry } of this.addedOverlays.values()) {
+      if (target !== arm9) continue;
+      const existing = table.entries.find((item) => item.overlayId === entry.overlayId);
+      if (existing) Object.assign(existing, entry);
+      else table.entries.push({ ...entry });
+    }
+    const ids = new Set<number>();
+    for (const entry of table.entries) {
+      if (ids.has(entry.overlayId)) throw new Error(`Duplicate overlay ID: ${entry.overlayId}`);
+      ids.add(entry.overlayId);
+      const path = `overlay/overlay${arm9 ? "" : "7"}_${String(entry.overlayId).padStart(4, "0")}.bin`;
+      if (!this.hasFile(path)) throw new Error(`Overlay table entry has no payload: ${path}`);
+    }
+    if (original.entries.some((entry) => !ids.has(entry.overlayId)))
+      throw new Error("Removing overlays is unsupported");
+    return table;
+  }
   private fileBytes(file: NitroFile): Buffer {
+    if (this.twl?.complete && (file.name === "arm9i.bin" || file.name === "arm7i.bin"))
+      return this.twl.complete.getProgram(file.name === "arm9i.bin" ? "arm9i" : "arm7i");
+    if (this.addedOverlays.size && (file.name === "overarm9.bin" || file.name === "overarm7.bin"))
+      return this.readOverlayTable(file.name === "overarm9.bin").toBuffer();
     return file.replacement ?? range(this.original, file.offset, file.size, file.name);
   }
 
+  verifyDsi(): DsiVerification {
+    if (this.twl?.complete) return this.twl.complete.verify();
+    if (this.header.unitCode & 2)
+      return new NDSFile(this.original, { dsiMode: "complete", maxOutputSize: this.maxOutputSize }).verifyDsi();
+    return noDsiVerification();
+  }
+
   /** Rebuild offsets, allocation table, CRCs and ROM padding. Safe to call repeatedly. */
   toBuffer(): Buffer {
+    if (
+      this.twl?.complete &&
+      !this.structureChanged &&
+      this.twl.complete.unchanged() &&
+      this.header.raw.equals(this.original.subarray(0, this.header.raw.length)) &&
+      this.banner
+        .toBuffer()
+        .equals(new Banner(this.original, this.header.bannerOffset, this.header.banner_size).toBuffer()) &&
+      [...this.paths.values()].every(
+        ({ file }) =>
+          !file.replacement || file.replacement.equals(range(this.original, file.offset, file.size, file.name)),
+      )
+    ) {
+      if (this.original.length > this.maxOutputSize) throw new RangeError("Output exceeds size limit");
+      return Buffer.from(this.original);
+    }
     const fntReplacement = this.root.files.find((file) => file.name === "fnt.bin")?.replacement;
+    if (this.structureChanged && fntReplacement) throw new Error("Adding files conflicts with an fnt.bin replacement");
     if (fntReplacement) {
       const replacementTree = new FileNameTable(this.fatTable, fntReplacement, 0, fntReplacement.length);
       const collect = (folder: NitroFolder): number[] =>
@@ -134,6 +326,9 @@ export class NDSFile {
       if (collect(replacementTree.root).join(",") !== collect(this.data).join(","))
         throw new Error("Replacement FNT must preserve existing file IDs");
     }
+    const layout = this.structureChanged ? this.fntTable.serialize(this.fatTable, this.overlay.files) : undefined;
+    if (this.twl?.complete) return this.serializeDsi(layout);
+    const overlayFiles = new Map(this.overlay.files.map((file) => [file.id, file]));
     const h = new Header(this.header.toBuffer());
     h.nitrocode = this.header.nitrocode;
     h.decrypted = this.header.decrypted;
@@ -153,31 +348,33 @@ export class NDSFile {
     }
     const placements = new Map<number, { start: number; end: number }>();
     const write = (file: NitroFile, padding = true): void => {
+      const id = layout ? (file.id >= 0 ? layout.sourceIds.get(file.id) : layout.ids.get(file)) : file.id;
+      if (layout && id !== undefined && placements.has(id)) return;
+      if (layout && file.id >= 0) file = overlayFiles.get(file.id) ?? file;
       const start = writer.position;
       writer.write(this.fileBytes(file));
-      if (file.id !== 0xffff) placements.set(file.id, { start, end: writer.position });
+      if (id !== undefined && id !== 0xffff) placements.set(id, { start, end: writer.position });
       if (padding) writer.pad(0x200);
     };
     const overlayIds = new Set<number>();
     const writeOverlays = (arm9: boolean): void => {
-      const originalTable = arm9 ? this.overlay9Table : this.overlay7Table;
       const name = arm9 ? "overarm9.bin" : "overarm7.bin";
       const entry = this.root.files.find((file) => file.name === name);
       if (!entry) return;
-      const raw = entry.replacement ?? originalTable.toBuffer();
-      const table = new OverlayTable(raw, 0, raw.length, arm9);
+      const table = this.readOverlayTable(arm9);
       const files = this.overlay.files
         .filter((file) => file.name.startsWith(arm9 ? "overlay_" : "overlay7_"))
-        .sort((a, b) => a.id - b.id);
+        .sort((a, b) => (a.id < 0 ? (b.id < 0 ? 0 : 1) : b.id < 0 ? -1 : a.id - b.id));
       for (const file of files) {
-        const item = table.entries.find((item) => item.fileId === file.id);
-        if (!item) throw new Error(`Replacement overlay table is missing file id ${file.id}`);
-        const size = this.fileBytes(file).length;
+        const item = table.entries.find(
+          (item) => file.name === `overlay${arm9 ? "" : "7"}_${String(item.overlayId).padStart(4, "0")}.bin`,
+        )!;
+        const size = this.fileBytes(layout && file.id >= 0 ? overlayFiles.get(file.id)! : file).length;
         if ((item.reserved >>> 24) & 1 || (!arm9 && item.reserved > 0))
           item.reserved = ((item.reserved & 0xff000000) | (size & 0xffffff)) >>> 0;
+        item.fileId = layout ? (file.id >= 0 ? layout.sourceIds.get(file.id)! : layout.ids.get(file)!) : file.id;
         overlayIds.add(file.id);
       }
-      if (table.entries.length !== files.length) throw new Error("Changing overlay file count is unsupported");
       const encoded = table.toBuffer();
       if (arm9) {
         h.ARM9overlayOffset = writer.position;
@@ -207,10 +404,12 @@ export class NDSFile {
     h.ARM7overlayOffset = 0;
     writeOverlays(false);
     h.FNToffset = writer.position;
-    h.FNTsize = this.fileBytes(system("fnt.bin")).length;
-    write(system("fnt.bin"));
+    const fnt = layout?.fnt ?? this.fileBytes(system("fnt.bin"));
+    h.FNTsize = fnt.length;
+    writer.write(fnt);
+    writer.pad(0x200);
     h.FAToffset = writer.position;
-    h.FATsize = this.fatTable.entries.length * 8;
+    h.FATsize = (layout?.files.length ?? this.fatTable.entries.length) * 8;
     writer.write(Buffer.alloc(h.FATsize));
     writer.pad(0x200);
     h.bannerOffset = writer.position;
@@ -223,19 +422,22 @@ export class NDSFile {
     if (h.unitCode & 2 && h.headerSize > 0x200) h.banner_size = bannerBytes.length;
     writer.write(bannerBytes);
     writer.pad(0x200);
-    for (const [index, id] of this.fatTable.sortedIDs.entries()) {
-      if (overlayIds.has(id)) continue;
-      const file = FileNameTable.findFile(id, this.root);
-      if (file) write(file, index < this.fatTable.sortedIDs.length - 1);
-      else {
-        // Games can address FAT entries directly without a NitroFS filename.
-        // Keep their payload and allocation instead of silently zeroing the entry.
-        const entry = this.fatTable.entries[id];
-        if (entry.size > 0) {
-          write({ ...entry, name: `FAT entry ${id}` }, index < this.fatTable.sortedIDs.length - 1);
+    if (layout) {
+      for (const [index, file] of layout.files.entries()) write(file, index < layout.files.length - 1);
+    } else
+      for (const [index, id] of this.fatTable.sortedIDs.entries()) {
+        if (overlayIds.has(id)) continue;
+        const file = FileNameTable.findFile(id, this.root);
+        if (file) write(file, index < this.fatTable.sortedIDs.length - 1);
+        else {
+          // Games can address FAT entries directly without a NitroFS filename.
+          // Keep their payload and allocation instead of silently zeroing the entry.
+          const entry = this.fatTable.entries[id];
+          if (entry.size > 0) {
+            write({ ...entry, name: `FAT entry ${id}` }, index < this.fatTable.sortedIDs.length - 1);
+          }
         }
       }
-    }
     const logicalEnd = writer.position;
     const fat = Buffer.alloc(h.FATsize);
     for (const [id, location] of placements) {
@@ -263,4 +465,150 @@ export class NDSFile {
   async saveAs(path: string): Promise<void> {
     await writeFile(path, this.toBuffer());
   }
+
+  private serializeDsi(layout: ReturnType<FileNameTable["serialize"]> | undefined): Buffer {
+    const twl = this.twl!.complete!;
+    const h = new Header(this.header.raw);
+    h.nitrocode = this.header.nitrocode;
+    const system = (name: string): NitroFile => this.paths.get(name)!.file;
+    const replacement = system("header.bin").replacement;
+    if (replacement) {
+      const source = new Header(replacement);
+      if (
+        source.unitCode !== 2 ||
+        source.tid_high !== h.tid_high ||
+        source.tid_low !== h.tid_low ||
+        (h.dsi9_size && !source.dsi9_size) ||
+        (h.dsi7_size && !source.dsi7_size)
+      )
+        throw new Error("Replacement header changes or clears the DSi cartridge identity or programs");
+      // Preserve semantic and unknown header bytes; physical fields are assigned below.
+      source.raw.copy(h.raw);
+      for (const [start, end] of [
+        [0x20, 0x40],
+        [0x40, 0x60],
+        [0x68, 0x6e],
+        [0x80, 0x88],
+        [0x90, 0x94],
+        [0x1c0, 0x1c4],
+        [0x1cc, 0x1d4],
+        [0x1dc, 0x214],
+        [0x220, 0x230],
+        [0x300, 0x378],
+        [0x3a0, 0x3b4],
+        [0xf80, 0x1000],
+      ])
+        this.header.raw.copy(h.raw, start, start, end);
+      h.ARM9entryAddress = source.ARM9entryAddress;
+      h.ARM9ramAddress = source.ARM9ramAddress;
+      h.ARM7entryAddress = source.ARM7entryAddress;
+      h.ARM7ramAddress = source.ARM7ramAddress;
+      h.dsi7_ram_address = source.dsi7_ram_address;
+      h.headerSize = this.header.headerSize;
+    }
+    const sections: DsiSection[] = [];
+    const add = (label: string, file: NitroFile, data: Buffer, place: (start: number) => void): void => {
+      sections.push({ label, start: file.offset, originalSize: file.size, data, place });
+    };
+    const arm9File = system("arm9.bin");
+    let arm9 = this.fileBytes(arm9File);
+    if (arm9File.replacement) h.nitrocode = arm9.length >= 12 && arm9.readUInt32LE(arm9.length - 12) === 0xdec00621;
+    if (h.gameCode !== twl.header.gameCode && arm9.readBigUInt64LE(0) !== 0xe7ffdeffe7ffdeffn)
+      arm9 = encryptSecureArea(h.gameCode, decryptSecureArea(twl.header.gameCode, arm9));
+    const signedOverlays = this.readOverlayTable(true).entries.filter((entry) => entry.reserved & 0x2000000);
+    if (signedOverlays.length !== twl.Overlays9Sha1Hmac.length) {
+      if (!arm9File.replacement) throw new Error("Changing signed overlay count requires an ARM9 replacement");
+    } else
+      arm9 = twl.updateOverlays9Sha1Hmac(
+        arm9,
+        h,
+        signedOverlays.map((entry) => this.getFile(`overlay/overlay_${String(entry.overlayId).padStart(4, "0")}.bin`)),
+      );
+    h.ARM9size = arm9.length - (h.nitrocode ? 12 : 0);
+    h.decrypted = arm9.length >= 8 && arm9.readBigUInt64LE(0) === 0xe7ffdeffe7ffdeffn;
+    const plainArm9 = h.decrypted ? Buffer.from(arm9) : decryptSecureArea(h.gameCode, arm9);
+    plainArm9.writeUInt16LE(crc16(range(plainArm9, 0x10, 0x7f0, "ARM9 secure-area CRC")), 0xe);
+    arm9 = h.decrypted ? plainArm9 : encryptSecureArea(h.gameCode, plainArm9);
+    add("ARM9", arm9File, arm9, (start) => {
+      h.ARM9romOffset = start;
+    });
+    const written = new Set<number>();
+    const fileList =
+      layout?.files ??
+      this.fatTable.entries.map(
+        (entry) => FileNameTable.findFile(entry.id, this.root) ?? { ...entry, name: `FAT entry ${entry.id}` },
+      );
+    const fat = Buffer.alloc(fileList.length * 8);
+    const addPayload = (file: NitroFile): void => {
+      const id = layout ? (file.id >= 0 ? layout.sourceIds.get(file.id)! : layout.ids.get(file)!) : file.id;
+      if (written.has(id)) return;
+      written.add(id);
+      const overlay = file.id >= 0 ? this.overlay.files.find((overlay) => overlay.id === file.id) : undefined;
+      if (overlay) file = overlay;
+      const data = this.fileBytes(file);
+      add(file.name, file, data, (start) => {
+        fat.writeUInt32LE(start, id * 8);
+        fat.writeUInt32LE(start + data.length, id * 8 + 4);
+      });
+    };
+    const overlays = (arm9: boolean): void => {
+      const name = arm9 ? "overarm9.bin" : "overarm7.bin";
+      if (!this.hasFile(name)) return;
+      const file = system(name);
+      const table = this.readOverlayTable(arm9);
+      for (const entry of table.entries) {
+        const payload = this.paths.get(
+          `overlay/overlay${arm9 ? "" : "7"}_${String(entry.overlayId).padStart(4, "0")}.bin`,
+        )!.file;
+        const size = this.fileBytes(payload).length;
+        if ((entry.reserved >>> 24) & 1 || (!arm9 && entry.reserved > 0))
+          entry.reserved = ((entry.reserved & 0xff000000) | size) >>> 0;
+        entry.fileId = layout
+          ? payload.id >= 0
+            ? layout.sourceIds.get(payload.id)!
+            : layout.ids.get(payload)!
+          : payload.id;
+      }
+      add(name, file, table.toBuffer(), (start) => {
+        if (arm9) {
+          h.ARM9overlayOffset = start;
+          h.ARM9overlaySize = table.entries.length * 32;
+        } else {
+          h.ARM7overlayOffset = start;
+          h.ARM7overlaySize = table.entries.length * 32;
+        }
+      });
+      for (const entry of table.entries)
+        addPayload(
+          this.paths.get(`overlay/overlay${arm9 ? "" : "7"}_${String(entry.overlayId).padStart(4, "0")}.bin`)!.file,
+        );
+    };
+    overlays(true);
+    const arm7 = system("arm7.bin");
+    h.ARM7size = this.fileBytes(arm7).length;
+    add("ARM7", arm7, this.fileBytes(arm7), (start) => {
+      h.ARM7romOffset = start;
+    });
+    overlays(false);
+    const fnt = layout?.fnt ?? this.fileBytes(system("fnt.bin"));
+    h.FNTsize = fnt.length;
+    add("FNT", system("fnt.bin"), fnt, (start) => {
+      h.FNToffset = start;
+    });
+    h.FATsize = fat.length;
+    add("FAT", system("fat.bin"), fat, (start) => {
+      h.FAToffset = start;
+    });
+    const bannerFile = system("banner.bin");
+    const banner = bannerFile.replacement
+      ? new Banner(bannerFile.replacement, 0, bannerFile.replacement.length)
+      : this.banner;
+    const bannerBytes = banner.toBuffer();
+    h.banner_size = bannerBytes.length;
+    add("Banner", bannerFile, bannerBytes, (start) => {
+      h.bannerOffset = start;
+    });
+    for (const file of fileList) addPayload(file);
+    return twl.serialize(h, sections, !!layout);
+  }
 }