buninu-linux 0.7.3 → 0.7.5

package/initramfs/bin/dd

@@ -0,0 +1,126 @@
+#!/bin/bun
+// dd — copy blocks between files.
+//
+//   dd [if=FILE] [of=FILE] [bs=N] [ibs=N] [obs=N] [count=N] [skip=N] [seek=N]
+//      [conv=notrunc,sparse,sync,fsync,fdatasync,noerror] [status=none|noxfer|progress]
+//
+// N takes c (1), w (2), b (512), K/KiB, M/MiB, G/GiB (powers of 1024) or
+// kB, MB, GB (powers of 1000), and the AxB product form, as in coreutils.
+// conv=sparse seeks over output blocks that are all zero instead of writing them.
+
+import { closeSync, fstatSync, fsyncSync, ftruncateSync, openSync, readSync, writeSync } from "node:fs";
+
+const fail = (message) => {
+  console.error(`dd: ${message}`);
+  process.exit(1);
+};
+
+const multipliers = { c: 1, w: 2, b: 512, k: 1024, K: 1024, KiB: 1024, kB: 1e3, KB: 1e3, M: 1024 ** 2, MiB: 1024 ** 2, MB: 1e6, G: 1024 ** 3, GiB: 1024 ** 3, GB: 1e9 };
+const number = (name, text) => text.split("x").reduce((product, part) => {
+  const match = /^(\d+)([a-zA-Z]*)$/.exec(part);
+  if (!match || !(match[2] in { "": 1, ...multipliers })) fail(`invalid number: '${text}' for ${name}`);
+  return product * Number(match[1]) * (multipliers[match[2]] ?? 1);
+}, 1);
+
+const options = { if: null, of: null, ibs: 512, obs: 512, count: Infinity, skip: 0, seek: 0, conv: new Set(), status: "default" };
+for (const argument of process.argv.slice(2)) {
+  if (argument === "-h" || argument === "--help") {
+    console.error("Usage: dd [if=FILE] [of=FILE] [bs=N] [count=N] [skip=N] [seek=N] [conv=notrunc,sparse,...] [status=none]");
+    process.exit(0);
+  }
+  const separator = argument.indexOf("=");
+  if (separator < 0) fail(`unrecognized operand '${argument}'`);
+  const key = argument.slice(0, separator);
+  const value = argument.slice(separator + 1);
+  if (key === "if" || key === "of") options[key] = value;
+  else if (key === "bs") options.ibs = options.obs = number(key, value);
+  else if (key === "ibs" || key === "obs" || key === "count" || key === "skip" || key === "seek") options[key] = number(key, value);
+  else if (key === "conv") for (const flag of value.split(",")) {
+    if (!["notrunc", "sparse", "sync", "fsync", "fdatasync", "noerror"].includes(flag)) fail(`invalid conversion: '${flag}'`);
+    options.conv.add(flag);
+  }
+  else if (key === "status") {
+    if (!["none", "noxfer", "progress"].includes(value)) fail(`invalid status level: '${value}'`);
+    options.status = value;
+  }
+  else if (key === "iflag" || key === "oflag") {}
+  else fail(`unrecognized operand '${argument}'`);
+}
+if (options.ibs < 1 || options.obs < 1) fail("block sizes must be positive");
+
+const input = options.if === null ? 0 : (() => {
+  try { return openSync(options.if, "r"); } catch (error) { return fail(`failed to open '${options.if}': ${error.message}`); }
+})();
+const output = options.of === null ? 1 : (() => {
+  try { return openSync(options.of, options.conv.has("notrunc") ? (() => { try { openSync(options.of, "r"); return "r+"; } catch { return "w"; } })() : "a+"); }
+  catch (error) { return fail(`failed to open '${options.of}': ${error.message}`); }
+})();
+// "a+" would append; reopen read-write so writes land at explicit positions.
+const outputFd = options.of !== null && !options.conv.has("notrunc") ? (closeSync(output), openSync(options.of, "r+")) : output;
+const inputSeekable = fstatSync(input).isFile() || fstatSync(input).isBlockDevice();
+const outputSeekable = fstatSync(outputFd).isFile() || fstatSync(outputFd).isBlockDevice();
+
+let inputPosition = inputSeekable ? options.skip * options.ibs : null;
+if (!inputSeekable && options.skip) {
+  // Pipes: read and drop skip blocks.
+  const discard = Buffer.alloc(options.ibs);
+  for (let block = 0; block < options.skip; block++) if (readSync(input, discard, 0, options.ibs, null) === 0) break;
+}
+let outputPosition = options.seek * options.obs;
+// Without notrunc the output is cut at the seek point, as dd does.
+if (options.of !== null && !options.conv.has("notrunc") && fstatSync(outputFd).isFile()) ftruncateSync(outputFd, outputPosition);
+
+const stats = { fullIn: 0, partialIn: 0, fullOut: 0, partialOut: 0, bytes: 0 };
+const started = performance.now();
+const buffer = Buffer.alloc(options.ibs);
+let pending = Buffer.alloc(0);
+let skippedTail = false;
+
+const writeBlock = (block) => {
+  if (options.conv.has("sparse") && outputSeekable && block.every((byte) => byte === 0)) {
+    outputPosition += block.length;
+    skippedTail = true;
+  } else {
+    for (let offset = 0; offset < block.length;) {
+      offset += writeSync(outputFd, block, offset, block.length - offset, outputSeekable ? outputPosition + offset : null);
+    }
+    outputPosition += block.length;
+    skippedTail = false;
+  }
+  if (block.length === options.obs) stats.fullOut++; else stats.partialOut++;
+  stats.bytes += block.length;
+};
+
+for (let blocks = 0; blocks < options.count; blocks++) {
+  let count;
+  try {
+    count = readSync(input, buffer, 0, options.ibs, inputPosition);
+  } catch (error) {
+    if (!options.conv.has("noerror")) fail(`error reading '${options.if ?? "standard input"}': ${error.message}`);
+    count = 0;
+  }
+  if (count === 0) break;
+  if (inputPosition !== null) inputPosition += count;
+  if (count === options.ibs) stats.fullIn++; else stats.partialIn++;
+  let block = buffer.subarray(0, count);
+  if (options.conv.has("sync") && count < options.ibs) block = Buffer.concat([block, Buffer.alloc(options.ibs - count)]);
+  pending = Buffer.concat([pending, block]);
+  while (pending.length >= options.obs) {
+    writeBlock(pending.subarray(0, options.obs));
+    pending = pending.subarray(options.obs);
+  }
+}
+if (pending.length) writeBlock(Buffer.from(pending));
+// A sparse run at the end still has to reach the file's length.
+if (skippedTail && fstatSync(outputFd).size < outputPosition) ftruncateSync(outputFd, outputPosition);
+if (options.conv.has("fsync") || options.conv.has("fdatasync")) fsyncSync(outputFd);
+
+if (options.status !== "none") {
+  console.error(`${stats.fullIn}+${stats.partialIn} records in\n${stats.fullOut}+${stats.partialOut} records out`);
+  if (options.status !== "noxfer") {
+    const seconds = (performance.now() - started) / 1000;
+    console.error(`${stats.bytes} bytes copied, ${seconds.toFixed(3)} s, ${(stats.bytes / Math.max(seconds, 1e-9) / 1e6).toFixed(1)} MB/s`);
+  }
+}
+if (input !== 0) closeSync(input);
+if (outputFd !== 1) closeSync(outputFd);

package/initramfs/bin/gunzip

@@ -0,0 +1,6 @@
+#!/bin/bun
+// gunzip — see /lib/gzip.js.
+
+import { run } from "../lib/gzip.js";
+
+process.exit(run("gunzip", process.argv.slice(2), { decompress: true }));

package/initramfs/bin/gzip

@@ -0,0 +1,6 @@
+#!/bin/bun
+// gzip — see /lib/gzip.js.
+
+import { run } from "../lib/gzip.js";
+
+process.exit(run("gzip", process.argv.slice(2), {}));

package/initramfs/bin/mcopy

@@ -0,0 +1,6 @@
+#!/bin/bun
+// mcopy — see /lib/mtools.js.
+
+import { mcopy } from "../lib/mtools.js";
+
+process.exit(mcopy(process.argv.slice(2)));

package/initramfs/bin/mdir

@@ -0,0 +1,6 @@
+#!/bin/bun
+// mdir — see /lib/mtools.js.
+
+import { mdir } from "../lib/mtools.js";
+
+process.exit(mdir(process.argv.slice(2)));

package/initramfs/bin/mkfs.fat

@@ -0,0 +1,73 @@
+#!/bin/bun
+// mkfs.fat — make a FAT32 filesystem in an image file, laid out as
+// mkfs.fat 4.2 does (see /lib/fat.js).
+//
+//   mkfs.fat [-F 32] [-n LABEL] [-h HIDDEN] [-i VOLID] [-s SECTORS_PER_CLUSTER]
+//            [--invariant] [-C] FILE [BLOCKS]
+//
+// BLOCKS (1 KiB each) sizes the filesystem; -C creates FILE with that size.
+// SOURCE_DATE_EPOCH, when set, is the volume ID and the label's time, as
+// with mkfs.fat; --invariant fixes both to mkfs.fat's constants.
+
+import { closeSync, fstatSync, ftruncateSync, openSync } from "node:fs";
+import { FatError, format } from "../lib/fat.js";
+
+const fail = (message) => {
+  console.error(`mkfs.fat: ${message}`);
+  process.exit(1);
+};
+
+const usage = () => {
+  console.error(`Usage: mkfs.fat [-F 32] [-n LABEL] [-h HIDDEN] [-i VOLID] [-s SECTORS_PER_CLUSTER] [--invariant] [-C] FILE [BLOCKS]`);
+  process.exit(1);
+};
+
+const options = { label: "NO NAME", hidden: 0, volumeId: null, invariant: false, sectorsPerCluster: undefined, create: false, quiet: false };
+const operands = [];
+const argv = process.argv.slice(2);
+const value = (index, option) => {
+  if (index + 1 >= argv.length) fail(`option ${option} requires an argument`);
+  return argv[index + 1];
+};
+for (let index = 0; index < argv.length; index++) {
+  const argument = argv[index];
+  if (argument === "--help") usage();
+  else if (argument === "--invariant") options.invariant = true;
+  else if (argument === "-F") { if (value(index++, "-F") !== "32") fail("only -F 32 is supported"); }
+  else if (argument === "-n") options.label = value(index++, "-n");
+  else if (argument === "-h") options.hidden = Number(value(index++, "-h"));
+  else if (argument === "-i") options.volumeId = Number.parseInt(value(index++, "-i"), 16) >>> 0;
+  else if (argument === "-s") options.sectorsPerCluster = Number(value(index++, "-s"));
+  else if (argument === "-C") options.create = true;
+  else if (argument === "-v" || argument === "-I" || argument === "-a") {}
+  else if (argument === "-q") options.quiet = true;
+  else if (argument.startsWith("-") && argument.length > 1) fail(`unknown option ${argument}`);
+  else operands.push(argument);
+}
+if (operands.length < 1 || operands.length > 2) usage();
+const [file, blocks] = operands;
+if (options.label.length > 11) fail("label can be no longer than 11 characters");
+if (!Number.isInteger(options.hidden) || options.hidden < 0) fail(`bad number of hidden sectors: ${options.hidden}`);
+if (options.sectorsPerCluster !== undefined && ![1, 2, 4, 8, 16, 32, 64, 128].includes(options.sectorsPerCluster)) fail("bad number of sectors per cluster");
+
+let fd;
+try {
+  fd = openSync(file, options.create ? "wx" : "r+");
+} catch (error) {
+  fail(`unable to open ${file}: ${error.message}`);
+}
+try {
+  if (options.create) {
+    if (!blocks) fail("-C needs BLOCKS");
+    ftruncateSync(fd, Number(blocks) * 1024);
+  }
+  const bytes = blocks ? Number(blocks) * 1024 : fstatSync(fd).size;
+  if (!Number.isFinite(bytes) || bytes <= 0) fail(`bad size for ${file}`);
+  console.log("mkfs.fat (buninu-linux /bin/mkfs.fat)");
+  format(fd, { sectors: Math.floor(bytes / 512), label: options.label, volumeId: options.volumeId, hidden: options.hidden, invariant: options.invariant, sectorsPerCluster: options.sectorsPerCluster });
+} catch (error) {
+  if (error instanceof FatError) fail(error.message);
+  throw error;
+} finally {
+  closeSync(fd);
+}

package/initramfs/bin/mmd

@@ -0,0 +1,6 @@
+#!/bin/bun
+// mmd — see /lib/mtools.js.
+
+import { mmd } from "../lib/mtools.js";
+
+process.exit(mmd(process.argv.slice(2)));

package/initramfs/bin/parted

@@ -0,0 +1,178 @@
+#!/bin/bun
+// parted — GPT partitioning of a disk image, script mode only (see /lib/gpt.js).
+//
+//   parted [-s] IMAGE COMMAND...
+//
+// Commands, any number in a row as with parted -s:
+//   mklabel gpt
+//   mkpart NAME [FS-TYPE] START END    START/END with s, B, kB/MB/GB/TB,
+//                                      KiB/MiB/GiB/TiB, % or the current unit;
+//                                      a negative value counts from the end
+//   set NUMBER FLAG on|off             esp, boot, msftdata, bios_grub,
+//                                      legacy_boot, hidden, no_automount
+//   name NUMBER NAME
+//   rm NUMBER
+//   unit UNIT                          s, B, kB, MB, GB, TB, KiB, MiB, GiB, TiB, %
+//   print
+// START and END are used as given, without alignment; END is inclusive.
+
+import { closeSync, fstatSync, openSync } from "node:fs";
+import { GptError, SECTOR, TYPES, randomGuid, readGpt, usable, writeGpt } from "../lib/gpt.js";
+
+const fail = (message) => {
+  console.error(`Error: ${message}`);
+  process.exit(1);
+};
+
+const usage = () => {
+  console.error(`Usage: parted [-s] IMAGE COMMAND...
+  mklabel gpt | mkpart NAME [FS-TYPE] START END | set NUMBER FLAG on|off
+  name NUMBER NAME | rm NUMBER | unit UNIT | print`);
+  process.exit(1);
+};
+
+// -s is implied; -a takes a value and alignment is not applied anyway.
+const raw = process.argv.slice(2);
+const words = [];
+for (let index = 0; index < raw.length; index++) {
+  const argument = raw[index];
+  if (argument === "-s" || argument === "--script") continue;
+  if (argument === "-a" || argument === "--align") { index++; continue; }
+  if (argument.startsWith("--align=")) continue;
+  if (argument === "-h" || argument === "--help") usage();
+  if (argument.startsWith("-") && words.length === 0) fail(`unknown option ${argument}`);
+  words.push(argument);
+}
+if (words.length < 2) usage();
+const [image, ...commands] = words;
+
+let fd;
+try { fd = openSync(image, "r+"); } catch (error) { fail(`Could not stat device ${image} - ${error.message}.`); }
+const stat = fstatSync(fd);
+if (!stat.isFile()) fail(`${image}: only disk image files are supported`);
+const sectors = Math.floor(stat.size / SECTOR);
+if (sectors < 2 + 2 * 33 + 1) fail(`${image} is too small for a GPT`);
+
+let table = readGpt(fd, sectors);
+let dirty = false;
+let unit = "MB";
+
+const units = { s: SECTOR, B: 1, kB: 1e3, MB: 1e6, GB: 1e9, TB: 1e12, KiB: 1024, MiB: 1024 ** 2, GiB: 1024 ** 3, TiB: 1024 ** 4 };
+const unitName = (text) => Object.keys(units).find((name) => name.toLowerCase() === text.toLowerCase()) ?? (text === "%" ? "%" : null);
+
+/** A START or END position in sectors (END inclusive). */
+const position = (text, isEnd) => {
+  const match = /^(-?)(\d+(?:\.\d+)?)([a-zA-Z%]*)$/.exec(text);
+  if (!match) fail(`invalid position ${text}`);
+  const name = match[3] ? unitName(match[3]) : unit;
+  if (!name) fail(`invalid unit in ${text}`);
+  const amount = Number(match[2]);
+  if (name === "%") return Math.round((sectors - 1) * amount / 100);
+  const count = name === "s" ? amount : Math.round(amount * units[name] / SECTOR);
+  // A negative position counts back from the end of the disk: -1s is the last sector.
+  if (match[1]) return Math.floor(sectors - count);
+  return Math.floor(count - (isEnd && name !== "s" ? 1 : 0));
+};
+
+const requireTable = () => {
+  if (!table) fail(`${image}: unrecognised disk label`);
+  return table;
+};
+const partition = (text) => {
+  const number = Number(text);
+  const entry = requireTable().entries.find((candidate) => candidate.number === number);
+  if (!entry) fail(`Partition doesn't exist.`);
+  return entry;
+};
+
+const typeForFs = (fs) => {
+  if (!fs) return TYPES.linux;
+  if (/^(fat16|fat32|fat12|ntfs|exfat)$/i.test(fs)) return TYPES.msdata;
+  if (/^linux-swap/i.test(fs)) return TYPES.swap;
+  return TYPES.linux;
+};
+const knownFs = /^(fat12|fat16|fat32|ext2|ext3|ext4|btrfs|xfs|ntfs|exfat|linux-swap(\(v[01]\))?|hfs\+?|udf|zfs)$/i;
+
+const print = () => {
+  const current = requireTable();
+  const show = (sector) => unit === "s" ? `${sector}s` : unit === "%" ? `${((sector / (sectors - 1)) * 100).toFixed(1)}%` : `${+(sector * SECTOR / units[unit]).toFixed(1)}${unit}`;
+  console.log(`Model:  (file)\nDisk ${image}: ${show(sectors - 1 + (unit === "s" ? 1 : 0))}\nSector size (logical/physical): 512B/512B\nPartition Table: gpt\nDisk Flags: \n`);
+  console.log("Number  Start  End  Size  Name  Flags");
+  for (const entry of current.entries) {
+    const flags = [];
+    if (entry.type === TYPES.esp) flags.push("boot", "esp");
+    if (entry.type === TYPES.bios_grub) flags.push("bios_grub");
+    if (entry.type === TYPES.msdata) flags.push("msftdata");
+    if (entry.attributes & 4n) flags.push("legacy_boot");
+    console.log(` ${entry.number}  ${show(entry.first)}  ${show(entry.last)}  ${show(entry.last - entry.first + 1)}  ${entry.name}  ${flags.join(", ")}`);
+  }
+};
+
+try {
+  for (let index = 0; index < commands.length;) {
+    const command = commands[index++];
+    const take = (what) => {
+      if (index >= commands.length) fail(`${command}: expecting ${what}`);
+      return commands[index++];
+    };
+    if (command === "mklabel") {
+      const label = take("a disk label type");
+      if (label !== "gpt") fail(`only gpt labels are supported, not ${label}`);
+      table = { diskGuid: randomGuid(), entries: [] };
+      dirty = true;
+    } else if (command === "unit") {
+      const name = unitName(take("a unit"));
+      if (!name) fail(`invalid unit ${commands[index - 1]}`);
+      unit = name;
+    } else if (command === "mkpart") {
+      const current = requireTable();
+      const name = take("a partition name");
+      let fs = null;
+      if (knownFs.test(commands[index] ?? "")) fs = commands[index++];
+      const first = position(take("a start"), false);
+      const last = position(take("an end"), true);
+      const range = usable(sectors);
+      if (first < range.first || last > range.last || first > last) {
+        fail(`The location ${first}s-${last}s is outside of the usable range ${range.first}s-${range.last}s of the device.`);
+      }
+      if (current.entries.some((entry) => first <= entry.last && entry.first <= last)) fail("the partition overlaps another one");
+      let number = 1;
+      while (current.entries.some((entry) => entry.number === number)) number++;
+      current.entries.push({ number, type: typeForFs(fs), guid: randomGuid(), first, last, attributes: 0n, name, fs });
+      current.entries.sort((a, b) => a.number - b.number);
+      dirty = true;
+    } else if (command === "set") {
+      const entry = partition(take("a partition number"));
+      const flag = take("a flag").toLowerCase();
+      const state = take("on or off").toLowerCase();
+      if (state !== "on" && state !== "off") fail(`expecting on or off, not ${state}`);
+      const on = state === "on";
+      if (flag === "esp" || flag === "boot") entry.type = on ? TYPES.esp : typeForFs(entry.fs ?? "fat32");
+      else if (flag === "bios_grub") entry.type = on ? TYPES.bios_grub : typeForFs(entry.fs);
+      else if (flag === "msftdata") entry.type = on ? TYPES.msdata : TYPES.linux;
+      else {
+        const bits = { legacy_boot: 2n, hidden: 1n << 62n, no_automount: 1n << 63n }[flag];
+        if (bits === undefined) fail(`unsupported flag ${flag}`);
+        entry.attributes = on ? entry.attributes | bits : entry.attributes & ~bits;
+      }
+      dirty = true;
+    } else if (command === "name") {
+      const entry = partition(take("a partition number"));
+      entry.name = take("a name");
+      dirty = true;
+    } else if (command === "rm") {
+      const entry = partition(take("a partition number"));
+      table.entries = table.entries.filter((candidate) => candidate !== entry);
+      dirty = true;
+    } else if (command === "print") {
+      if (dirty) { writeGpt(fd, sectors, table); dirty = false; }
+      print();
+    } else fail(`unknown command ${command}`);
+  }
+  if (dirty) writeGpt(fd, sectors, table);
+} catch (error) {
+  if (error instanceof GptError) fail(error.message);
+  throw error;
+} finally {
+  closeSync(fd);
+}

package/initramfs/bin/truncate

@@ -0,0 +1,78 @@
+#!/bin/bun
+// truncate — set the size of files, creating them (sparse) when missing.
+//
+//   truncate -s [+|-|<|>|/|%]SIZE [-c] FILE...
+//
+// SIZE takes K, M, G, T (powers of 1024; KiB ... also), KB, MB, GB, TB
+// (powers of 1000) or nothing (bytes), as in coreutils.
+
+import { closeSync, fstatSync, ftruncateSync, openSync } from "node:fs";
+
+const fail = (message) => {
+  console.error(`truncate: ${message}`);
+  process.exit(1);
+};
+
+const usage = () => {
+  console.error(`Usage: truncate -s [+|-|<|>|/|%]SIZE [-c] FILE...`);
+  process.exit(1);
+};
+
+const units = { "": 1, K: 1024, M: 1024 ** 2, G: 1024 ** 3, T: 1024 ** 4, KB: 1e3, MB: 1e6, GB: 1e9, TB: 1e12 };
+const parseSize = (text) => {
+  const match = /^([+\-<>/%]?)(\d+)([KMGT]?)(B|iB)?$/i.exec(text);
+  if (!match) fail(`invalid size: '${text}'`);
+  const unit = match[3].toUpperCase() + (match[4] === "B" ? "B" : "");
+  if (!(unit in units)) fail(`invalid size: '${text}'`);
+  return { relation: match[1], bytes: Number(match[2]) * units[unit] };
+};
+
+let size = null;
+let create = true;
+const files = [];
+const argv = process.argv.slice(2);
+for (let index = 0; index < argv.length; index++) {
+  const argument = argv[index];
+  if (argument === "-h" || argument === "--help") usage();
+  else if (argument === "-s" || argument === "--size") {
+    if (index + 1 >= argv.length) fail("option requires an argument -- 's'");
+    size = parseSize(argv[++index]);
+  } else if (argument.startsWith("--size=")) size = parseSize(argument.slice(7));
+  else if (argument.startsWith("-s") && argument.length > 2) size = parseSize(argument.slice(2));
+  else if (argument === "-c" || argument === "--no-create") create = false;
+  else if (argument === "--") files.push(...argv.slice(index + 1)), index = argv.length;
+  else if (argument.startsWith("-") && argument !== "-") fail(`unknown option ${argument}`);
+  else files.push(argument);
+}
+if (size === null || files.length === 0) usage();
+
+let status = 0;
+for (const file of files) {
+  let fd;
+  try {
+    fd = openSync(file, create ? "a+" : "r+");
+  } catch (error) {
+    if (error.code === "ENOENT" && !create) continue;
+    console.error(`truncate: cannot open '${file}' for writing: ${error.message}`);
+    status = 1;
+    continue;
+  }
+  try {
+    const current = fstatSync(fd).size;
+    const { relation, bytes } = size;
+    const target = relation === "+" ? current + bytes
+      : relation === "-" ? Math.max(0, current - bytes)
+      : relation === "<" ? Math.min(current, bytes)
+      : relation === ">" ? Math.max(current, bytes)
+      : relation === "/" ? (bytes ? Math.floor(current / bytes) * bytes : fail("division by zero"))
+      : relation === "%" ? (bytes ? Math.ceil(current / bytes) * bytes : fail("division by zero"))
+      : bytes;
+    ftruncateSync(fd, target);
+  } catch (error) {
+    console.error(`truncate: failed to truncate '${file}': ${error.message}`);
+    status = 1;
+  } finally {
+    closeSync(fd);
+  }
+}
+process.exit(status);