boo-flash 0.1.0

package/dist/app-node.js

@@ -0,0 +1,4020 @@
+// node_modules/@opentui/solid/index.js
+import { CliRenderer, createCliRenderer, engine as engine2 } from "@opentui/core";
+import { createTestRenderer } from "@opentui/core/testing";
+import { ASCIIFontRenderable, BoxRenderable, CodeRenderable, DiffRenderable, ImageRenderable, InputRenderable, LineNumberRenderable, MarkdownRenderable, ScrollBoxRenderable, SelectRenderable, TabSelectRenderable, TextareaRenderable, TextAttributes, TextNodeRenderable, TextRenderable } from "@opentui/core";
+import { engine, Timeline } from "@opentui/core";
+import { createContext, createSignal, onCleanup, onMount, useContext } from "solid-js/dist/solid.js";
+import { createEffect, createMemo as createMemo2, getOwner, onCleanup as onCleanup3, runWithOwner, splitProps, untrack as untrack2 } from "solid-js/dist/solid.js";
+import { BaseRenderable, createTextAttributes, ImageRenderable as ImageRenderable2, InputRenderable as InputRenderable2, InputRenderableEvents, isTextNodeRenderable, isEditBufferRenderable, parseColor, Renderable, RootTextNodeRenderable, ScrollBoxRenderable as ScrollBoxRenderable2, SelectRenderable as SelectRenderable2, SelectRenderableEvents, TabSelectRenderable as TabSelectRenderable2, TabSelectRenderableEvents, TextNodeRenderable as TextNodeRenderable2, TextRenderable as TextRenderable2 } from "@opentui/core";
+
+// node_modules/entities/dist/esm/decode-codepoint.js
+var _a;
+var decodeMap = /* @__PURE__ */ new Map([
+  [0, 65533],
+  // C1 Unicode control character reference replacements
+  [128, 8364],
+  [130, 8218],
+  [131, 402],
+  [132, 8222],
+  [133, 8230],
+  [134, 8224],
+  [135, 8225],
+  [136, 710],
+  [137, 8240],
+  [138, 352],
+  [139, 8249],
+  [140, 338],
+  [142, 381],
+  [145, 8216],
+  [146, 8217],
+  [147, 8220],
+  [148, 8221],
+  [149, 8226],
+  [150, 8211],
+  [151, 8212],
+  [152, 732],
+  [153, 8482],
+  [154, 353],
+  [155, 8250],
+  [156, 339],
+  [158, 382],
+  [159, 376]
+]);
+var fromCodePoint = (
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, n/no-unsupported-features/es-builtins
+  (_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : ((codePoint) => {
+    let output = "";
+    if (codePoint > 65535) {
+      codePoint -= 65536;
+      output += String.fromCharCode(codePoint >>> 10 & 1023 | 55296);
+      codePoint = 56320 | codePoint & 1023;
+    }
+    output += String.fromCharCode(codePoint);
+    return output;
+  })
+);
+function replaceCodePoint(codePoint) {
+  var _a2;
+  if (codePoint >= 55296 && codePoint <= 57343 || codePoint > 1114111) {
+    return 65533;
+  }
+  return (_a2 = decodeMap.get(codePoint)) !== null && _a2 !== void 0 ? _a2 : codePoint;
+}
+
+// node_modules/entities/dist/esm/internal/decode-shared.js
+function decodeBase64(input) {
+  const binary = (
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins
+    typeof atob === "function" ? (
+      // Browser (and Node >=16)
+      // eslint-disable-next-line n/no-unsupported-features/node-builtins
+      atob(input)
+    ) : (
+      // Older Node versions (<16)
+      // eslint-disable-next-line n/no-unsupported-features/node-builtins
+      typeof Buffer.from === "function" ? (
+        // eslint-disable-next-line n/no-unsupported-features/node-builtins
+        Buffer.from(input, "base64").toString("binary")
+      ) : (
+        // eslint-disable-next-line unicorn/no-new-buffer, n/no-deprecated-api
+        new Buffer(input, "base64").toString("binary")
+      )
+    )
+  );
+  const evenLength = binary.length & ~1;
+  const out = new Uint16Array(evenLength / 2);
+  for (let index = 0, outIndex = 0; index < evenLength; index += 2) {
+    const lo = binary.charCodeAt(index);
+    const hi = binary.charCodeAt(index + 1);
+    out[outIndex++] = lo | hi << 8;
+  }
+  return out;
+}
+
+// node_modules/entities/dist/esm/generated/decode-data-html.js
+var htmlDecodeTree = /* @__PURE__ */ decodeBase64("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");
+
+// node_modules/entities/dist/esm/internal/bin-trie-flags.js
+var BinTrieFlags;
+(function(BinTrieFlags2) {
+  BinTrieFlags2[BinTrieFlags2["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH";
+  BinTrieFlags2[BinTrieFlags2["FLAG13"] = 8192] = "FLAG13";
+  BinTrieFlags2[BinTrieFlags2["BRANCH_LENGTH"] = 8064] = "BRANCH_LENGTH";
+  BinTrieFlags2[BinTrieFlags2["JUMP_TABLE"] = 127] = "JUMP_TABLE";
+})(BinTrieFlags || (BinTrieFlags = {}));
+
+// node_modules/entities/dist/esm/decode.js
+var CharCodes;
+(function(CharCodes2) {
+  CharCodes2[CharCodes2["NUM"] = 35] = "NUM";
+  CharCodes2[CharCodes2["SEMI"] = 59] = "SEMI";
+  CharCodes2[CharCodes2["EQUALS"] = 61] = "EQUALS";
+  CharCodes2[CharCodes2["ZERO"] = 48] = "ZERO";
+  CharCodes2[CharCodes2["NINE"] = 57] = "NINE";
+  CharCodes2[CharCodes2["LOWER_A"] = 97] = "LOWER_A";
+  CharCodes2[CharCodes2["LOWER_F"] = 102] = "LOWER_F";
+  CharCodes2[CharCodes2["LOWER_X"] = 120] = "LOWER_X";
+  CharCodes2[CharCodes2["LOWER_Z"] = 122] = "LOWER_Z";
+  CharCodes2[CharCodes2["UPPER_A"] = 65] = "UPPER_A";
+  CharCodes2[CharCodes2["UPPER_F"] = 70] = "UPPER_F";
+  CharCodes2[CharCodes2["UPPER_Z"] = 90] = "UPPER_Z";
+})(CharCodes || (CharCodes = {}));
+var TO_LOWER_BIT = 32;
+function isNumber(code2) {
+  return code2 >= CharCodes.ZERO && code2 <= CharCodes.NINE;
+}
+function isHexadecimalCharacter(code2) {
+  return code2 >= CharCodes.UPPER_A && code2 <= CharCodes.UPPER_F || code2 >= CharCodes.LOWER_A && code2 <= CharCodes.LOWER_F;
+}
+function isAsciiAlphaNumeric(code2) {
+  return code2 >= CharCodes.UPPER_A && code2 <= CharCodes.UPPER_Z || code2 >= CharCodes.LOWER_A && code2 <= CharCodes.LOWER_Z || isNumber(code2);
+}
+function isEntityInAttributeInvalidEnd(code2) {
+  return code2 === CharCodes.EQUALS || isAsciiAlphaNumeric(code2);
+}
+var EntityDecoderState;
+(function(EntityDecoderState2) {
+  EntityDecoderState2[EntityDecoderState2["EntityStart"] = 0] = "EntityStart";
+  EntityDecoderState2[EntityDecoderState2["NumericStart"] = 1] = "NumericStart";
+  EntityDecoderState2[EntityDecoderState2["NumericDecimal"] = 2] = "NumericDecimal";
+  EntityDecoderState2[EntityDecoderState2["NumericHex"] = 3] = "NumericHex";
+  EntityDecoderState2[EntityDecoderState2["NamedEntity"] = 4] = "NamedEntity";
+})(EntityDecoderState || (EntityDecoderState = {}));
+var DecodingMode;
+(function(DecodingMode2) {
+  DecodingMode2[DecodingMode2["Legacy"] = 0] = "Legacy";
+  DecodingMode2[DecodingMode2["Strict"] = 1] = "Strict";
+  DecodingMode2[DecodingMode2["Attribute"] = 2] = "Attribute";
+})(DecodingMode || (DecodingMode = {}));
+var EntityDecoder = class {
+  constructor(decodeTree, emitCodePoint, errors) {
+    this.decodeTree = decodeTree;
+    this.emitCodePoint = emitCodePoint;
+    this.errors = errors;
+    this.state = EntityDecoderState.EntityStart;
+    this.consumed = 1;
+    this.result = 0;
+    this.treeIndex = 0;
+    this.excess = 1;
+    this.decodeMode = DecodingMode.Strict;
+    this.runConsumed = 0;
+  }
+  /** Resets the instance to make it reusable. */
+  startEntity(decodeMode) {
+    this.decodeMode = decodeMode;
+    this.state = EntityDecoderState.EntityStart;
+    this.result = 0;
+    this.treeIndex = 0;
+    this.excess = 1;
+    this.consumed = 1;
+    this.runConsumed = 0;
+  }
+  /**
+   * Write an entity to the decoder. This can be called multiple times with partial entities.
+   * If the entity is incomplete, the decoder will return -1.
+   *
+   * Mirrors the implementation of `getDecoder`, but with the ability to stop decoding if the
+   * entity is incomplete, and resume when the next string is written.
+   *
+   * @param input The string containing the entity (or a continuation of the entity).
+   * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.
+   * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+   */
+  write(input, offset) {
+    switch (this.state) {
+      case EntityDecoderState.EntityStart: {
+        if (input.charCodeAt(offset) === CharCodes.NUM) {
+          this.state = EntityDecoderState.NumericStart;
+          this.consumed += 1;
+          return this.stateNumericStart(input, offset + 1);
+        }
+        this.state = EntityDecoderState.NamedEntity;
+        return this.stateNamedEntity(input, offset);
+      }
+      case EntityDecoderState.NumericStart: {
+        return this.stateNumericStart(input, offset);
+      }
+      case EntityDecoderState.NumericDecimal: {
+        return this.stateNumericDecimal(input, offset);
+      }
+      case EntityDecoderState.NumericHex: {
+        return this.stateNumericHex(input, offset);
+      }
+      case EntityDecoderState.NamedEntity: {
+        return this.stateNamedEntity(input, offset);
+      }
+    }
+  }
+  /**
+   * Switches between the numeric decimal and hexadecimal states.
+   *
+   * Equivalent to the `Numeric character reference state` in the HTML spec.
+   *
+   * @param input The string containing the entity (or a continuation of the entity).
+   * @param offset The current offset.
+   * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+   */
+  stateNumericStart(input, offset) {
+    if (offset >= input.length) {
+      return -1;
+    }
+    if ((input.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {
+      this.state = EntityDecoderState.NumericHex;
+      this.consumed += 1;
+      return this.stateNumericHex(input, offset + 1);
+    }
+    this.state = EntityDecoderState.NumericDecimal;
+    return this.stateNumericDecimal(input, offset);
+  }
+  /**
+   * Parses a hexadecimal numeric entity.
+   *
+   * Equivalent to the `Hexademical character reference state` in the HTML spec.
+   *
+   * @param input The string containing the entity (or a continuation of the entity).
+   * @param offset The current offset.
+   * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+   */
+  stateNumericHex(input, offset) {
+    while (offset < input.length) {
+      const char = input.charCodeAt(offset);
+      if (isNumber(char) || isHexadecimalCharacter(char)) {
+        const digit = char <= CharCodes.NINE ? char - CharCodes.ZERO : (char | TO_LOWER_BIT) - CharCodes.LOWER_A + 10;
+        this.result = this.result * 16 + digit;
+        this.consumed++;
+        offset++;
+      } else {
+        return this.emitNumericEntity(char, 3);
+      }
+    }
+    return -1;
+  }
+  /**
+   * Parses a decimal numeric entity.
+   *
+   * Equivalent to the `Decimal character reference state` in the HTML spec.
+   *
+   * @param input The string containing the entity (or a continuation of the entity).
+   * @param offset The current offset.
+   * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+   */
+  stateNumericDecimal(input, offset) {
+    while (offset < input.length) {
+      const char = input.charCodeAt(offset);
+      if (isNumber(char)) {
+        this.result = this.result * 10 + (char - CharCodes.ZERO);
+        this.consumed++;
+        offset++;
+      } else {
+        return this.emitNumericEntity(char, 2);
+      }
+    }
+    return -1;
+  }
+  /**
+   * Validate and emit a numeric entity.
+   *
+   * Implements the logic from the `Hexademical character reference start
+   * state` and `Numeric character reference end state` in the HTML spec.
+   *
+   * @param lastCp The last code point of the entity. Used to see if the
+   *               entity was terminated with a semicolon.
+   * @param expectedLength The minimum number of characters that should be
+   *                       consumed. Used to validate that at least one digit
+   *                       was consumed.
+   * @returns The number of characters that were consumed.
+   */
+  emitNumericEntity(lastCp, expectedLength) {
+    var _a2;
+    if (this.consumed <= expectedLength) {
+      (_a2 = this.errors) === null || _a2 === void 0 ? void 0 : _a2.absenceOfDigitsInNumericCharacterReference(this.consumed);
+      return 0;
+    }
+    if (lastCp === CharCodes.SEMI) {
+      this.consumed += 1;
+    } else if (this.decodeMode === DecodingMode.Strict) {
+      return 0;
+    }
+    this.emitCodePoint(replaceCodePoint(this.result), this.consumed);
+    if (this.errors) {
+      if (lastCp !== CharCodes.SEMI) {
+        this.errors.missingSemicolonAfterCharacterReference();
+      }
+      this.errors.validateNumericCharacterReference(this.result);
+    }
+    return this.consumed;
+  }
+  /**
+   * Parses a named entity.
+   *
+   * Equivalent to the `Named character reference state` in the HTML spec.
+   *
+   * @param input The string containing the entity (or a continuation of the entity).
+   * @param offset The current offset.
+   * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+   */
+  stateNamedEntity(input, offset) {
+    const { decodeTree } = this;
+    let current = decodeTree[this.treeIndex];
+    let valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+    while (offset < input.length) {
+      if (valueLength === 0 && (current & BinTrieFlags.FLAG13) !== 0) {
+        const runLength = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
+        if (this.runConsumed === 0) {
+          const firstChar = current & BinTrieFlags.JUMP_TABLE;
+          if (input.charCodeAt(offset) !== firstChar) {
+            return this.result === 0 ? 0 : this.emitNotTerminatedNamedEntity();
+          }
+          offset++;
+          this.excess++;
+          this.runConsumed++;
+        }
+        while (this.runConsumed < runLength) {
+          if (offset >= input.length) {
+            return -1;
+          }
+          const charIndexInPacked = this.runConsumed - 1;
+          const packedWord = decodeTree[this.treeIndex + 1 + (charIndexInPacked >> 1)];
+          const expectedChar = charIndexInPacked % 2 === 0 ? packedWord & 255 : packedWord >> 8 & 255;
+          if (input.charCodeAt(offset) !== expectedChar) {
+            this.runConsumed = 0;
+            return this.result === 0 ? 0 : this.emitNotTerminatedNamedEntity();
+          }
+          offset++;
+          this.excess++;
+          this.runConsumed++;
+        }
+        this.runConsumed = 0;
+        this.treeIndex += 1 + (runLength >> 1);
+        current = decodeTree[this.treeIndex];
+        valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+      }
+      if (offset >= input.length)
+        break;
+      const char = input.charCodeAt(offset);
+      if (char === CharCodes.SEMI && valueLength !== 0 && (current & BinTrieFlags.FLAG13) !== 0) {
+        return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
+      }
+      this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);
+      if (this.treeIndex < 0) {
+        return this.result === 0 || // If we are parsing an attribute
+        this.decodeMode === DecodingMode.Attribute && // We shouldn't have consumed any characters after the entity,
+        (valueLength === 0 || // And there should be no invalid characters.
+        isEntityInAttributeInvalidEnd(char)) ? 0 : this.emitNotTerminatedNamedEntity();
+      }
+      current = decodeTree[this.treeIndex];
+      valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+      if (valueLength !== 0) {
+        if (char === CharCodes.SEMI) {
+          return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
+        }
+        if (this.decodeMode !== DecodingMode.Strict && (current & BinTrieFlags.FLAG13) === 0) {
+          this.result = this.treeIndex;
+          this.consumed += this.excess;
+          this.excess = 0;
+        }
+      }
+      offset++;
+      this.excess++;
+    }
+    return -1;
+  }
+  /**
+   * Emit a named entity that was not terminated with a semicolon.
+   *
+   * @returns The number of characters consumed.
+   */
+  emitNotTerminatedNamedEntity() {
+    var _a2;
+    const { result, decodeTree } = this;
+    const valueLength = (decodeTree[result] & BinTrieFlags.VALUE_LENGTH) >> 14;
+    this.emitNamedEntityData(result, valueLength, this.consumed);
+    (_a2 = this.errors) === null || _a2 === void 0 ? void 0 : _a2.missingSemicolonAfterCharacterReference();
+    return this.consumed;
+  }
+  /**
+   * Emit a named entity.
+   *
+   * @param result The index of the entity in the decode tree.
+   * @param valueLength The number of bytes in the entity.
+   * @param consumed The number of characters consumed.
+   *
+   * @returns The number of characters consumed.
+   */
+  emitNamedEntityData(result, valueLength, consumed) {
+    const { decodeTree } = this;
+    this.emitCodePoint(valueLength === 1 ? decodeTree[result] & ~(BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13) : decodeTree[result + 1], consumed);
+    if (valueLength === 3) {
+      this.emitCodePoint(decodeTree[result + 2], consumed);
+    }
+    return consumed;
+  }
+  /**
+   * Signal to the parser that the end of the input was reached.
+   *
+   * Remaining data will be emitted and relevant errors will be produced.
+   *
+   * @returns The number of characters consumed.
+   */
+  end() {
+    var _a2;
+    switch (this.state) {
+      case EntityDecoderState.NamedEntity: {
+        return this.result !== 0 && (this.decodeMode !== DecodingMode.Attribute || this.result === this.treeIndex) ? this.emitNotTerminatedNamedEntity() : 0;
+      }
+      // Otherwise, emit a numeric entity if we have one.
+      case EntityDecoderState.NumericDecimal: {
+        return this.emitNumericEntity(0, 2);
+      }
+      case EntityDecoderState.NumericHex: {
+        return this.emitNumericEntity(0, 3);
+      }
+      case EntityDecoderState.NumericStart: {
+        (_a2 = this.errors) === null || _a2 === void 0 ? void 0 : _a2.absenceOfDigitsInNumericCharacterReference(this.consumed);
+        return 0;
+      }
+      case EntityDecoderState.EntityStart: {
+        return 0;
+      }
+    }
+  }
+};
+function getDecoder(decodeTree) {
+  let returnValue = "";
+  const decoder = new EntityDecoder(decodeTree, (data) => returnValue += fromCodePoint(data));
+  return function decodeWithTrie(input, decodeMode) {
+    let lastIndex = 0;
+    let offset = 0;
+    while ((offset = input.indexOf("&", offset)) >= 0) {
+      returnValue += input.slice(lastIndex, offset);
+      decoder.startEntity(decodeMode);
+      const length = decoder.write(
+        input,
+        // Skip the "&"
+        offset + 1
+      );
+      if (length < 0) {
+        lastIndex = offset + decoder.end();
+        break;
+      }
+      lastIndex = offset + length;
+      offset = length === 0 ? lastIndex + 1 : lastIndex;
+    }
+    const result = returnValue + input.slice(lastIndex);
+    returnValue = "";
+    return result;
+  };
+}
+function determineBranch(decodeTree, current, nodeIndex, char) {
+  const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
+  const jumpOffset = current & BinTrieFlags.JUMP_TABLE;
+  if (branchCount === 0) {
+    return jumpOffset !== 0 && char === jumpOffset ? nodeIndex : -1;
+  }
+  if (jumpOffset) {
+    const value = char - jumpOffset;
+    return value < 0 || value >= branchCount ? -1 : decodeTree[nodeIndex + value] - 1;
+  }
+  const packedKeySlots = branchCount + 1 >> 1;
+  let lo = 0;
+  let hi = branchCount - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >>> 1;
+    const slot = mid >> 1;
+    const packed = decodeTree[nodeIndex + slot];
+    const midKey = packed >> (mid & 1) * 8 & 255;
+    if (midKey < char) {
+      lo = mid + 1;
+    } else if (midKey > char) {
+      hi = mid - 1;
+    } else {
+      return decodeTree[nodeIndex + packedKeySlots + mid];
+    }
+  }
+  return -1;
+}
+var htmlDecoder = /* @__PURE__ */ getDecoder(htmlDecodeTree);
+function decodeHTMLStrict(htmlString) {
+  return htmlDecoder(htmlString, DecodingMode.Strict);
+}
+
+// node_modules/entities/dist/esm/escape.js
+var getCodePoint = (
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  String.prototype.codePointAt == null ? (c, index) => (c.charCodeAt(index) & 64512) === 55296 ? (c.charCodeAt(index) - 55296) * 1024 + c.charCodeAt(index + 1) - 56320 + 65536 : c.charCodeAt(index) : (
+    // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+    (input, index) => input.codePointAt(index)
+  )
+);
+
+// node_modules/entities/dist/esm/index.js
+var EntityLevel;
+(function(EntityLevel2) {
+  EntityLevel2[EntityLevel2["XML"] = 0] = "XML";
+  EntityLevel2[EntityLevel2["HTML"] = 1] = "HTML";
+})(EntityLevel || (EntityLevel = {}));
+var EncodingMode;
+(function(EncodingMode2) {
+  EncodingMode2[EncodingMode2["UTF8"] = 0] = "UTF8";
+  EncodingMode2[EncodingMode2["ASCII"] = 1] = "ASCII";
+  EncodingMode2[EncodingMode2["Extensive"] = 2] = "Extensive";
+  EncodingMode2[EncodingMode2["Attribute"] = 3] = "Attribute";
+  EncodingMode2[EncodingMode2["Text"] = 4] = "Text";
+})(EncodingMode || (EncodingMode = {}));
+
+// node_modules/@opentui/solid/index.js
+import { onCleanup as onCleanup2, useContext as useContext2 } from "solid-js/dist/solid.js";
+import { createRoot, createRenderEffect, createMemo, createComponent, untrack, mergeProps } from "solid-js/dist/solid.js";
+import { mergeProps as mergeProps2 } from "solid-js/dist/solid.js";
+import { BaseRenderable as BaseRenderable2, isTextNodeRenderable as isTextNodeRenderable2, TextNodeRenderable as TextNodeRenderable3, TextRenderable as TextRenderable3, Yoga } from "@opentui/core";
+import { BoxRenderable as BoxRenderable2, RootRenderable } from "@opentui/core";
+import { createSignal as createSignal2 } from "solid-js/dist/solid.js";
+import { TimeToFirstDrawRenderable } from "@opentui/core";
+import { createSlotRegistry } from "@opentui/core";
+import { children, createMemo as createMemo3, createSignal as createSignal3, ErrorBoundary, For, onCleanup as onCleanup4, splitProps as splitProps2 } from "solid-js/dist/solid.js";
+var SpanRenderable = class extends TextNodeRenderable {
+  constructor(_ctx, options) {
+    super(options);
+    this._ctx = _ctx;
+  }
+};
+var TextModifierRenderable = class extends SpanRenderable {
+  constructor(options, modifier) {
+    super(null, options);
+    if (modifier === "b" || modifier === "strong") {
+      this.attributes = (this.attributes || 0) | TextAttributes.BOLD;
+    } else if (modifier === "i" || modifier === "em") {
+      this.attributes = (this.attributes || 0) | TextAttributes.ITALIC;
+    } else if (modifier === "u") {
+      this.attributes = (this.attributes || 0) | TextAttributes.UNDERLINE;
+    }
+  }
+};
+var BoldSpanRenderable = class extends TextModifierRenderable {
+  constructor(options) {
+    super(options, "b");
+  }
+};
+var ItalicSpanRenderable = class extends TextModifierRenderable {
+  constructor(options) {
+    super(options, "i");
+  }
+};
+var UnderlineSpanRenderable = class extends TextModifierRenderable {
+  constructor(options) {
+    super(options, "u");
+  }
+};
+var LineBreakRenderable = class extends SpanRenderable {
+  constructor(_ctx, options) {
+    super(null, options);
+    this.add();
+  }
+  add() {
+    return super.add(`
+`);
+  }
+};
+var LinkRenderable = class extends SpanRenderable {
+  constructor(_ctx, options) {
+    const linkOptions = {
+      ...options,
+      link: {
+        url: options.href
+      }
+    };
+    super(null, linkOptions);
+  }
+};
+var baseComponents = {
+  box: BoxRenderable,
+  text: TextRenderable,
+  input: InputRenderable,
+  select: SelectRenderable,
+  textarea: TextareaRenderable,
+  ascii_font: ASCIIFontRenderable,
+  tab_select: TabSelectRenderable,
+  scrollbox: ScrollBoxRenderable,
+  code: CodeRenderable,
+  diff: DiffRenderable,
+  line_number: LineNumberRenderable,
+  markdown: MarkdownRenderable,
+  image: ImageRenderable,
+  span: SpanRenderable,
+  strong: BoldSpanRenderable,
+  b: BoldSpanRenderable,
+  em: ItalicSpanRenderable,
+  i: ItalicSpanRenderable,
+  u: UnderlineSpanRenderable,
+  br: LineBreakRenderable,
+  a: LinkRenderable
+};
+var componentCatalogue = {
+  ...baseComponents
+};
+function extend(objects) {
+  Object.assign(componentCatalogue, objects);
+}
+function getComponentCatalogue() {
+  return componentCatalogue;
+}
+var RendererContext = createContext();
+var useRenderer = () => {
+  const renderer = useContext(RendererContext);
+  if (!renderer) {
+    throw new Error("No renderer found");
+  }
+  return renderer;
+};
+var onResize = (callback) => {
+  const renderer = useRenderer();
+  onMount(() => {
+    renderer.on("resize", callback);
+  });
+  onCleanup(() => {
+    renderer.off("resize", callback);
+  });
+};
+var useTerminalDimensions = () => {
+  const renderer = useRenderer();
+  const [terminalDimensions, setTerminalDimensions] = createSignal({
+    width: renderer.width,
+    height: renderer.height
+  });
+  const callback = (width, height) => {
+    setTerminalDimensions({
+      width,
+      height
+    });
+  };
+  onResize(callback);
+  return terminalDimensions;
+};
+var useKeyboard = (callback, options) => {
+  const renderer = useRenderer();
+  const keyHandler = renderer.keyInput;
+  onMount(() => {
+    keyHandler.on("keypress", callback);
+    if (options?.release) {
+      keyHandler.on("keyrelease", callback);
+    }
+  });
+  onCleanup(() => {
+    keyHandler.off("keypress", callback);
+    if (options?.release) {
+      keyHandler.off("keyrelease", callback);
+    }
+  });
+};
+var useTimeline = (options = {}) => {
+  const timeline = new Timeline(options);
+  onMount(() => {
+    if (options.autoplay !== false) {
+      timeline.play();
+    }
+    engine.register(timeline);
+  });
+  onCleanup(() => {
+    timeline.pause();
+    engine.unregister(timeline);
+  });
+  return timeline;
+};
+var memo = (fn) => createMemo(() => fn());
+function createRenderer({
+  createElement: createElement2,
+  createTextNode: createTextNode2,
+  createDynamicTextNode,
+  createSlotNode: createSlotNode2,
+  isTextNode,
+  replaceText,
+  insertNode: insertNode2,
+  removeNode,
+  setProperty,
+  getParentNode,
+  getFirstChild,
+  getNextSibling
+}) {
+  function insert2(parent, accessor, marker, initial) {
+    if (marker !== void 0 && !initial)
+      initial = [];
+    if (typeof accessor !== "function")
+      return insertExpression(parent, accessor, initial, marker);
+    createRenderEffect((current) => insertExpression(parent, accessor(), current, marker), initial);
+  }
+  function insertExpression(parent, value, current, marker, unwrapArray) {
+    while (typeof current === "function")
+      current = current();
+    if (value === current)
+      return current;
+    const t = typeof value, multi = marker !== void 0;
+    if (t === "string" || t === "number") {
+      if (t === "number")
+        value = value.toString();
+      if (multi) {
+        let node = current[0];
+        if (node && isTextNode(node)) {
+          replaceText(node, value);
+        } else
+          node = createDynamicTextNode(value);
+        current = cleanChildren(parent, current, marker, node);
+      } else {
+        if (current !== "" && typeof current === "string") {
+          replaceText(getFirstChild(parent), current = value);
+        } else {
+          cleanChildren(parent, current, marker, createDynamicTextNode(value));
+          current = value;
+        }
+      }
+    } else if (value == null || t === "boolean") {
+      current = cleanChildren(parent, current, marker);
+    } else if (t === "function") {
+      createRenderEffect(() => {
+        let v = value();
+        while (typeof v === "function")
+          v = v();
+        current = insertExpression(parent, v, current, marker);
+      });
+      return () => current;
+    } else if (Array.isArray(value)) {
+      const array = [];
+      if (normalizeIncomingArray(array, value, unwrapArray)) {
+        createRenderEffect(() => current = insertExpression(parent, array, current, marker, true));
+        return () => current;
+      }
+      if (array.length === 0) {
+        const replacement = cleanChildren(parent, current, marker);
+        if (multi)
+          return current = replacement;
+      } else {
+        if (Array.isArray(current)) {
+          if (current.length === 0) {
+            appendNodes(parent, array, marker);
+          } else
+            reconcileArrays(parent, current, array);
+        } else if (current == null || current === "") {
+          appendNodes(parent, array);
+        } else {
+          reconcileArrays(parent, multi && current || [getFirstChild(parent)], array);
+        }
+      }
+      current = array;
+    } else {
+      if (Array.isArray(current)) {
+        if (multi)
+          return current = cleanChildren(parent, current, marker, value);
+        cleanChildren(parent, current, null, value);
+      } else if (current == null || current === "" || !getFirstChild(parent)) {
+        insertNode2(parent, value);
+      } else
+        replaceNode(parent, value, getFirstChild(parent));
+      current = value;
+    }
+    return current;
+  }
+  function normalizeIncomingArray(normalized, array, unwrap) {
+    let dynamic = false;
+    for (let i = 0, len = array.length; i < len; i++) {
+      let item = array[i], t;
+      if (item == null || item === true || item === false)
+        ;
+      else if (Array.isArray(item)) {
+        dynamic = normalizeIncomingArray(normalized, item) || dynamic;
+      } else if ((t = typeof item) === "string" || t === "number") {
+        normalized.push(createDynamicTextNode(item));
+      } else if (t === "function") {
+        if (unwrap) {
+          while (typeof item === "function")
+            item = item();
+          dynamic = normalizeIncomingArray(normalized, Array.isArray(item) ? item : [item]) || dynamic;
+        } else {
+          normalized.push(item);
+          dynamic = true;
+        }
+      } else
+        normalized.push(item);
+    }
+    return dynamic;
+  }
+  function reconcileArrays(parentNode, a, b) {
+    let bLength = b.length, aEnd = a.length, bEnd = bLength, aStart = 0, bStart = 0, after = getNextSibling(a[aEnd - 1]), map = null;
+    while (aStart < aEnd || bStart < bEnd) {
+      if (a[aStart] === b[bStart]) {
+        aStart++;
+        bStart++;
+        continue;
+      }
+      while (a[aEnd - 1] === b[bEnd - 1]) {
+        aEnd--;
+        bEnd--;
+      }
+      if (aEnd === aStart) {
+        const node = bEnd < bLength ? bStart ? getNextSibling(b[bStart - 1]) : b[bEnd - bStart] : after;
+        while (bStart < bEnd)
+          insertNode2(parentNode, b[bStart++], node);
+      } else if (bEnd === bStart) {
+        while (aStart < aEnd) {
+          if (!map || !map.has(a[aStart]))
+            removeNode(parentNode, a[aStart]);
+          aStart++;
+        }
+      } else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
+        const node = getNextSibling(a[--aEnd]);
+        insertNode2(parentNode, b[bStart++], getNextSibling(a[aStart++]));
+        insertNode2(parentNode, b[--bEnd], node);
+        a[aEnd] = b[bEnd];
+      } else {
+        if (!map) {
+          map = /* @__PURE__ */ new Map();
+          let i = bStart;
+          while (i < bEnd)
+            map.set(b[i], i++);
+        }
+        const index = map.get(a[aStart]);
+        if (index != null) {
+          if (bStart < index && index < bEnd) {
+            let i = aStart, sequence = 1, t;
+            while (++i < aEnd && i < bEnd) {
+              if ((t = map.get(a[i])) == null || t !== index + sequence)
+                break;
+              sequence++;
+            }
+            if (sequence > index - bStart) {
+              const node = a[aStart];
+              while (bStart < index)
+                insertNode2(parentNode, b[bStart++], node);
+            } else
+              replaceNode(parentNode, b[bStart++], a[aStart++]);
+          } else
+            aStart++;
+        } else
+          removeNode(parentNode, a[aStart++]);
+      }
+    }
+  }
+  function cleanChildren(parent, current, marker, replacement) {
+    if (marker === void 0) {
+      let removed;
+      while (removed = getFirstChild(parent))
+        removeNode(parent, removed);
+      replacement && insertNode2(parent, replacement);
+      return replacement ?? "";
+    }
+    const node = replacement || createSlotNode2();
+    if (current.length) {
+      let inserted = false;
+      for (let i = current.length - 1; i >= 0; i--) {
+        const el = current[i];
+        if (node !== el) {
+          const isParent = getParentNode(el) === parent;
+          if (!inserted && !i)
+            isParent ? replaceNode(parent, node, el) : insertNode2(parent, node, marker);
+          else
+            isParent && removeNode(parent, el);
+        } else
+          inserted = true;
+      }
+    } else
+      insertNode2(parent, node, marker);
+    return [node];
+  }
+  function appendNodes(parent, array, marker) {
+    for (let i = 0, len = array.length; i < len; i++)
+      insertNode2(parent, array[i], marker);
+  }
+  function replaceNode(parent, newNode, oldNode) {
+    insertNode2(parent, newNode, oldNode);
+    removeNode(parent, oldNode);
+  }
+  function spreadExpression(node, props, prevProps = {}, skipChildren) {
+    props || (props = {});
+    if (!skipChildren) {
+      createRenderEffect(() => prevProps.children = insertExpression(node, props.children, prevProps.children));
+    }
+    createRenderEffect(() => props.ref && props.ref(node));
+    createRenderEffect(() => {
+      for (const prop in props) {
+        if (prop === "children" || prop === "ref")
+          continue;
+        const value = props[prop];
+        if (value === prevProps[prop])
+          continue;
+        setProperty(node, prop, value, prevProps[prop]);
+        prevProps[prop] = value;
+      }
+    });
+    return prevProps;
+  }
+  return {
+    render(code2, element) {
+      let disposer;
+      createRoot((dispose) => {
+        disposer = dispose;
+        insert2(element, code2());
+      });
+      return disposer;
+    },
+    insert: insert2,
+    spread(node, accessor, skipChildren) {
+      if (typeof accessor === "function") {
+        createRenderEffect((current) => spreadExpression(node, accessor(), current, skipChildren));
+      } else
+        spreadExpression(node, accessor, void 0, skipChildren);
+    },
+    createElement: createElement2,
+    createTextNode: createTextNode2,
+    insertNode: insertNode2,
+    setProp(node, name2, value, prev) {
+      setProperty(node, name2, value, prev);
+      return value;
+    },
+    mergeProps,
+    effect: createRenderEffect,
+    memo,
+    createComponent,
+    use(fn, element, arg) {
+      return untrack(() => fn(element, arg));
+    }
+  };
+}
+function createRenderer2(options) {
+  const renderer = createRenderer(options);
+  renderer.mergeProps = mergeProps2;
+  return renderer;
+}
+var idCounter = /* @__PURE__ */ new Map();
+function getNextId(elementType) {
+  if (!idCounter.has(elementType)) {
+    idCounter.set(elementType, 0);
+  }
+  const value = idCounter.get(elementType) + 1;
+  idCounter.set(elementType, value);
+  return `${elementType}-${value}`;
+}
+var log = (...args2) => {
+  if (process.env.DEBUG) {
+    console.log("[Reconciler]", ...args2);
+  }
+};
+var TextNode = class _TextNode extends TextNodeRenderable2 {
+  static fromString(text, options = {}) {
+    const node = new _TextNode(options);
+    node.add(text);
+    return node;
+  }
+};
+var logId = (node) => {
+  if (!node)
+    return;
+  return node.id;
+};
+var getNodeChildren = (node) => {
+  let children2;
+  if (node instanceof TextRenderable2) {
+    children2 = node.getTextChildren();
+  } else {
+    children2 = node.getChildren();
+  }
+  return children2;
+};
+function _insertNode(parent, node, anchor) {
+  log("Inserting node:", logId(node), "into parent:", logId(parent), "with anchor:", logId(anchor), node instanceof TextNode);
+  if (node instanceof SlotRenderable) {
+    node.parent = parent;
+    node = node.getSlotChild(parent);
+  }
+  if (anchor && anchor instanceof SlotRenderable) {
+    anchor = anchor.getSlotChild(parent);
+  }
+  if (isTextNodeRenderable(node)) {
+    if (!(parent instanceof TextRenderable2) && !isTextNodeRenderable(parent)) {
+      throw new Error(`Orphan text error: "${node.toChunks().map((c) => c.text).join("")}" must have a <text> as a parent: ${parent.id} above ${node.id}`);
+    }
+  }
+  if (!(parent instanceof BaseRenderable)) {
+    console.error("[INSERT]", "Tried to mount a non base renderable");
+    throw new Error("Tried to mount a non base renderable");
+  }
+  if (!anchor) {
+    parent.add(node);
+    return;
+  }
+  const children2 = getNodeChildren(parent);
+  const anchorIndex = children2.indexOf(anchor);
+  if (anchorIndex === -1) {
+    log("[INSERT]", "Could not find anchor", logId(parent), logId(anchor), "[children]", ...children2.map((c) => c.id));
+  }
+  parent.add(node, anchorIndex);
+}
+function _removeNode(parent, node) {
+  log("Removing node:", logId(node), "from parent:", logId(parent));
+  let slotParent;
+  if (node instanceof SlotRenderable) {
+    slotParent = node;
+    const slotChild = slotParent.getSlotChildForRemoval(parent);
+    if (!slotChild) {
+      if (slotParent.parent === parent) {
+        slotParent.parent = null;
+      }
+      return;
+    }
+    node = slotChild;
+  }
+  parent.remove(node);
+  slotParent?.didRemoveSlotChild(parent, node);
+  process.nextTick(() => {
+    if (node instanceof BaseRenderable && !node.parent) {
+      node.destroyRecursively();
+      return;
+    }
+  });
+}
+function _createTextNode(value, decodeEntities) {
+  log("Creating text node:", value);
+  const id = getNextId("text-node");
+  if (typeof value === "number") {
+    value = value.toString();
+  }
+  return TextNode.fromString(decodeEntities ? decodeHTMLStrict(value) : value, {
+    id
+  });
+}
+function createSlotNode() {
+  const id = getNextId("slot-node");
+  log("Creating slot node", id);
+  return new SlotRenderable(id);
+}
+function _getParentNode(childNode) {
+  log("Getting parent of node:", logId(childNode));
+  let parent = childNode.parent ?? void 0;
+  if (parent instanceof RootTextNodeRenderable) {
+    parent = parent.textParent ?? void 0;
+  }
+  const scrollBoxCandidate = parent?.parent?.parent?.parent;
+  if (scrollBoxCandidate instanceof ScrollBoxRenderable2 && scrollBoxCandidate.content === parent) {
+    parent = scrollBoxCandidate;
+  }
+  return parent;
+}
+var {
+  render: _render,
+  effect,
+  memo: memo2,
+  createComponent: createComponent2,
+  createElement,
+  createTextNode,
+  insertNode,
+  insert,
+  spread,
+  setProp,
+  mergeProps: mergeProps3,
+  use
+} = createRenderer2({
+  createElement(tagName) {
+    log("Creating element:", tagName);
+    const id = getNextId(tagName);
+    const solidRenderer = useContext2(RendererContext);
+    if (!solidRenderer) {
+      throw new Error("No renderer found");
+    }
+    const elements = getComponentCatalogue();
+    if (!elements[tagName]) {
+      throw new Error(`[Reconciler] Unknown component type: ${tagName}`);
+    }
+    const element = new elements[tagName](solidRenderer, {
+      id
+    });
+    if (element instanceof ImageRenderable2) {
+      onCleanup2(() => {
+        element.source = void 0;
+      });
+    }
+    log("Element created with id:", id);
+    return element;
+  },
+  createTextNode: (value) => _createTextNode(value, true),
+  createDynamicTextNode: (value) => _createTextNode(value, false),
+  createSlotNode,
+  replaceText(textNode, value) {
+    log("Replacing text:", value, "in node:", logId(textNode));
+    if (!(textNode instanceof TextNode))
+      return;
+    textNode.replace(value, 0);
+  },
+  setProperty(node, name2, value, prev) {
+    if (name2.startsWith("on:")) {
+      const eventName = name2.slice(3);
+      if (value) {
+        node.on(eventName, value);
+      }
+      if (prev) {
+        node.off(eventName, prev);
+      }
+      return;
+    }
+    if (isTextNodeRenderable(node)) {
+      if (name2 === "href") {
+        node.link = {
+          url: value
+        };
+        return;
+      }
+      if (name2 === "style") {
+        node.attributes |= createTextAttributes(value);
+        node.fg = value.fg ? parseColor(value.fg) : node.fg;
+        node.bg = value.bg ? parseColor(value.bg) : node.bg;
+        return;
+      }
+      return;
+    }
+    switch (name2) {
+      case "id":
+        log("Id mapped", node.id, "=", value);
+        node[name2] = value;
+        break;
+      case "focused":
+        if (!(node instanceof Renderable))
+          return;
+        if (value) {
+          node.focus();
+        } else {
+          node.blur();
+        }
+        break;
+      case "onChange":
+        let event = void 0;
+        if (node instanceof SelectRenderable2) {
+          event = SelectRenderableEvents.SELECTION_CHANGED;
+        } else if (node instanceof TabSelectRenderable2) {
+          event = TabSelectRenderableEvents.SELECTION_CHANGED;
+        } else if (node instanceof InputRenderable2) {
+          event = InputRenderableEvents.CHANGE;
+        }
+        if (!event)
+          break;
+        if (value) {
+          node.on(event, value);
+        }
+        if (prev) {
+          node.off(event, prev);
+        }
+        break;
+      case "onInput":
+        if (node instanceof InputRenderable2) {
+          if (value) {
+            node.on(InputRenderableEvents.INPUT, value);
+          }
+          if (prev) {
+            node.off(InputRenderableEvents.INPUT, prev);
+          }
+        }
+        break;
+      case "onSubmit":
+        if (node instanceof InputRenderable2) {
+          if (value) {
+            node.on(InputRenderableEvents.ENTER, value);
+          }
+          if (prev) {
+            node.off(InputRenderableEvents.ENTER, prev);
+          }
+        } else {
+          node[name2] = value;
+        }
+        break;
+      case "onSelect":
+        if (node instanceof SelectRenderable2) {
+          if (value) {
+            node.on(SelectRenderableEvents.ITEM_SELECTED, value);
+          }
+          if (prev) {
+            node.off(SelectRenderableEvents.ITEM_SELECTED, prev);
+          }
+        } else if (node instanceof TabSelectRenderable2) {
+          if (value) {
+            node.on(TabSelectRenderableEvents.ITEM_SELECTED, value);
+          }
+          if (prev) {
+            node.off(TabSelectRenderableEvents.ITEM_SELECTED, prev);
+          }
+        }
+        break;
+      case "style":
+        const nextStyle = value ?? {};
+        const previousStyle = prev ?? {};
+        if (isEditBufferRenderable(node) && previousStyle.selectionOccupancy && !nextStyle.selectionOccupancy) {
+          node.selectionOccupancy = void 0;
+        }
+        if (node instanceof ImageRenderable2) {
+          for (const prop in previousStyle) {
+            if (Object.prototype.hasOwnProperty.call(nextStyle, prop))
+              continue;
+            if (prop !== "fit" && prop !== "protocol")
+              continue;
+            node[prop] = void 0;
+          }
+        }
+        for (const prop in nextStyle) {
+          const propVal = nextStyle[prop];
+          if (propVal === previousStyle[prop])
+            continue;
+          node[prop] = propVal;
+        }
+        break;
+      case "text":
+      case "content": {
+        const textValue = typeof value === "string" ? value : Array.isArray(value) ? value.join("") : `${value}`;
+        node[name2] = textValue;
+        break;
+      }
+      default:
+        node[name2] = value;
+    }
+  },
+  isTextNode(node) {
+    return node instanceof TextNode;
+  },
+  insertNode: _insertNode,
+  removeNode: _removeNode,
+  getParentNode: _getParentNode,
+  getFirstChild(node) {
+    log("Getting first child of node:", logId(node));
+    const firstChild = getNodeChildren(node)[0];
+    if (!firstChild) {
+      log("No first child found for node:", logId(node));
+      return;
+    }
+    log("First child found:", logId(firstChild), "for node:", logId(node));
+    return firstChild;
+  },
+  getNextSibling(node) {
+    log("Getting next sibling of node:", logId(node));
+    const parent = _getParentNode(node);
+    if (!parent) {
+      log("No parent found for node:", logId(node));
+      return;
+    }
+    if (node instanceof SlotRenderable) {
+      const layoutSlotNode = node.getSlotChildForRemoval(parent);
+      if (layoutSlotNode) {
+        node = layoutSlotNode;
+      }
+    }
+    const siblings = getNodeChildren(parent);
+    const index = siblings.indexOf(node);
+    if (index === -1 || index === siblings.length - 1) {
+      log("No next sibling found for node:", logId(node));
+      return;
+    }
+    const nextSibling = siblings[index + 1];
+    if (!nextSibling) {
+      log("Next sibling is null for node:", logId(node));
+      return;
+    }
+    log("Next sibling found:", logId(nextSibling), "for node:", logId(node));
+    return nextSibling;
+  }
+});
+function getLayoutNodeConstructor(parent) {
+  const parentLayoutNode = parent?.getLayoutNode?.();
+  return parentLayoutNode?.constructor;
+}
+function createLayoutSlotYogaNode(parentNodeConstructor) {
+  return parentNodeConstructor?.create?.() ?? Yoga.default.Node.create();
+}
+var SlotBaseRenderable = class extends BaseRenderable2 {
+  constructor(id) {
+    super({
+      id
+    });
+  }
+  add(obj, index) {
+    throw new Error("Can't add children on an Slot renderable");
+  }
+  getChildren() {
+    return [];
+  }
+  remove(child) {
+  }
+  insertBefore(obj, anchor) {
+    throw new Error("Can't add children on an Slot renderable");
+  }
+  getRenderable(id) {
+    return;
+  }
+  getChildrenCount() {
+    return 0;
+  }
+  requestRender() {
+  }
+  findDescendantById(id) {
+    return;
+  }
+};
+var TextSlotRenderable = class extends TextNodeRenderable3 {
+  destroyed = false;
+  constructor(id, parent) {
+    super({
+      id
+    });
+    this._visible = false;
+    this.slotParent = parent;
+  }
+  detachFromSlot() {
+    this.slotParent = void 0;
+  }
+  disposeWithoutSlotCascade() {
+    if (this.destroyed) {
+      return;
+    }
+    this.destroyed = true;
+    this.detachFromSlot();
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    this.destroyed = true;
+    const slotParent = this.slotParent;
+    this.slotParent = void 0;
+    slotParent?.destroy();
+    super.destroy();
+  }
+};
+var LayoutSlotRenderable = class extends SlotBaseRenderable {
+  destroyed = false;
+  yogaNodeFreed = false;
+  constructor(id, parent, layoutParent) {
+    super(id);
+    this._visible = false;
+    this.slotParent = parent;
+    this.yogaNodeConstructor = getLayoutNodeConstructor(layoutParent);
+    this.yogaNode = createLayoutSlotYogaNode(this.yogaNodeConstructor);
+    this.yogaNode.setDisplay(Yoga.Display.None);
+  }
+  getLayoutNode() {
+    return this.yogaNode;
+  }
+  updateFromLayout() {
+  }
+  updateLayout() {
+  }
+  onRemove() {
+  }
+  isCompatibleWith(layoutParent) {
+    return this.yogaNodeConstructor === getLayoutNodeConstructor(layoutParent);
+  }
+  detachFromSlot() {
+    this.slotParent = void 0;
+  }
+  freeYogaNode() {
+    if (this.yogaNodeFreed) {
+      return;
+    }
+    this.yogaNodeFreed = true;
+    try {
+      this.yogaNode.free();
+    } catch {
+    }
+  }
+  disposeWithoutSlotCascade() {
+    if (this.destroyed) {
+      return;
+    }
+    this.destroyed = true;
+    this.detachFromSlot();
+    this.freeYogaNode();
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    this.destroyed = true;
+    const slotParent = this.slotParent;
+    this.slotParent = void 0;
+    this.freeYogaNode();
+    slotParent?.destroy();
+  }
+};
+var SlotRenderable = class extends SlotBaseRenderable {
+  destroyed = false;
+  layoutNodesByParent = /* @__PURE__ */ new Map();
+  textNodesByParent = /* @__PURE__ */ new Map();
+  layoutNodeCount = 0;
+  textNodeCount = 0;
+  constructor(id) {
+    super(id);
+    this._visible = false;
+  }
+  get layoutNode() {
+    return this.getCurrentSlotChild(this.layoutNodesByParent);
+  }
+  get textNode() {
+    return this.getCurrentSlotChild(this.textNodesByParent);
+  }
+  isTextSlotParent(parent) {
+    return isTextNodeRenderable2(parent) || parent instanceof TextRenderable3;
+  }
+  getCurrentSlotChild(nodesByParent) {
+    for (const node of nodesByParent.values()) {
+      if (node.parent) {
+        return node;
+      }
+    }
+    return nodesByParent.values().next().value;
+  }
+  getTextNodeForParent(parent) {
+    const mappedNode = this.textNodesByParent.get(parent);
+    if (mappedNode) {
+      return mappedNode;
+    }
+    for (const [mappedParent, textNode] of this.textNodesByParent) {
+      if (textNode.parent !== parent) {
+        continue;
+      }
+      this.textNodesByParent.delete(mappedParent);
+      this.textNodesByParent.set(parent, textNode);
+      return textNode;
+    }
+  }
+  getLayoutNodeForParent(parent) {
+    const mappedNode = this.layoutNodesByParent.get(parent);
+    if (mappedNode) {
+      return mappedNode;
+    }
+    for (const [mappedParent, layoutNode] of this.layoutNodesByParent) {
+      if (layoutNode.parent !== parent) {
+        continue;
+      }
+      this.layoutNodesByParent.delete(mappedParent);
+      this.layoutNodesByParent.set(parent, layoutNode);
+      return layoutNode;
+    }
+  }
+  takeReusableTextNode(parent) {
+    for (const [mappedParent, textNode] of this.textNodesByParent) {
+      if (textNode.parent) {
+        continue;
+      }
+      this.textNodesByParent.delete(mappedParent);
+      this.textNodesByParent.set(parent, textNode);
+      return textNode;
+    }
+  }
+  takeReusableLayoutNode(parent) {
+    for (const [mappedParent, layoutNode] of this.layoutNodesByParent) {
+      if (layoutNode.parent) {
+        continue;
+      }
+      if (!layoutNode.isCompatibleWith(parent)) {
+        continue;
+      }
+      this.layoutNodesByParent.delete(mappedParent);
+      this.layoutNodesByParent.set(parent, layoutNode);
+      return layoutNode;
+    }
+  }
+  disposeDetachedTextNodes() {
+    for (const [parent, textNode] of this.textNodesByParent) {
+      if (textNode.parent) {
+        continue;
+      }
+      this.textNodesByParent.delete(parent);
+      textNode.disposeWithoutSlotCascade();
+    }
+  }
+  disposeDetachedIncompatibleLayoutNodes(parent) {
+    for (const [mappedParent, layoutNode] of this.layoutNodesByParent) {
+      if (layoutNode.parent || layoutNode.isCompatibleWith(parent)) {
+        continue;
+      }
+      this.layoutNodesByParent.delete(mappedParent);
+      layoutNode.disposeWithoutSlotCascade();
+    }
+  }
+  getAttachedSlotParent(excludedNode) {
+    for (const textNode of this.textNodesByParent.values()) {
+      if (textNode !== excludedNode && textNode.parent) {
+        return textNode.parent;
+      }
+    }
+    for (const layoutNode of this.layoutNodesByParent.values()) {
+      if (layoutNode !== excludedNode && layoutNode.parent) {
+        return layoutNode.parent;
+      }
+    }
+    return null;
+  }
+  hasOtherAttachedSlotChildren(excludedNode) {
+    return this.getAttachedSlotParent(excludedNode) !== null;
+  }
+  getSlotChild(parent) {
+    if (this.isTextSlotParent(parent)) {
+      const existingTextNode = this.getTextNodeForParent(parent);
+      if (existingTextNode) {
+        return existingTextNode;
+      }
+      const reusableTextNode = this.takeReusableTextNode(parent);
+      if (reusableTextNode) {
+        return reusableTextNode;
+      }
+      this.disposeDetachedIncompatibleLayoutNodes(parent);
+      const textNode = new TextSlotRenderable(`slot-text-${this.id}-${++this.textNodeCount}`, this);
+      this.textNodesByParent.set(parent, textNode);
+      return textNode;
+    }
+    const existingLayoutNode = this.getLayoutNodeForParent(parent);
+    if (existingLayoutNode) {
+      return existingLayoutNode;
+    }
+    const reusableLayoutNode = this.takeReusableLayoutNode(parent);
+    if (reusableLayoutNode) {
+      return reusableLayoutNode;
+    }
+    this.disposeDetachedTextNodes();
+    this.disposeDetachedIncompatibleLayoutNodes(parent);
+    const layoutNode = new LayoutSlotRenderable(`slot-layout-${this.id}-${++this.layoutNodeCount}`, this, parent);
+    this.layoutNodesByParent.set(parent, layoutNode);
+    return layoutNode;
+  }
+  getSlotChildForRemoval(parent) {
+    if (this.isTextSlotParent(parent)) {
+      return this.getTextNodeForParent(parent);
+    }
+    return this.getLayoutNodeForParent(parent);
+  }
+  didRemoveSlotChild(parent, child) {
+    const hasOtherAttachedSlotChildren = this.hasOtherAttachedSlotChildren(child);
+    if (hasOtherAttachedSlotChildren && child instanceof TextSlotRenderable && this.getTextNodeForParent(parent) === child) {
+      this.textNodesByParent.delete(parent);
+      child.disposeWithoutSlotCascade();
+    }
+    if (hasOtherAttachedSlotChildren && child instanceof LayoutSlotRenderable && this.getLayoutNodeForParent(parent) === child) {
+      this.layoutNodesByParent.delete(parent);
+      child.disposeWithoutSlotCascade();
+    }
+    if (this.parent === parent) {
+      this.parent = this.getAttachedSlotParent(child);
+    }
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    this.destroyed = true;
+    const layoutNodes = new Set(this.layoutNodesByParent.values());
+    this.layoutNodesByParent.clear();
+    for (const layoutNode of layoutNodes) {
+      layoutNode.destroy();
+    }
+    const textNodes = new Set(this.textNodesByParent.values());
+    this.textNodesByParent.clear();
+    for (const textNode of textNodes) {
+      textNode.destroy();
+    }
+  }
+};
+extend({
+  time_to_first_draw: TimeToFirstDrawRenderable
+});
+var mountSolidRoot = (renderer, node) => {
+  let dispose;
+  let disposeRequested = false;
+  let disposed = false;
+  let mounting = true;
+  let destroyRequested = false;
+  const originalDestroy = renderer.destroy.bind(renderer);
+  const runDispose = () => {
+    if (disposed) {
+      return;
+    }
+    if (!dispose) {
+      disposeRequested = true;
+      return;
+    }
+    disposed = true;
+    dispose();
+  };
+  renderer.once("destroy", runDispose);
+  renderer.destroy = () => {
+    if (mounting) {
+      destroyRequested = true;
+      return;
+    }
+    originalDestroy();
+  };
+  try {
+    dispose = _render(() => createComponent2(RendererContext.Provider, {
+      get value() {
+        return renderer;
+      },
+      get children() {
+        return createComponent2(node, {});
+      }
+    }), renderer.root);
+  } finally {
+    mounting = false;
+    renderer.destroy = originalDestroy;
+  }
+  if (disposeRequested) {
+    runDispose();
+  }
+  if (destroyRequested) {
+    originalDestroy();
+  }
+};
+var render = async (node, rendererOrConfig = {}) => {
+  const renderer = rendererOrConfig instanceof CliRenderer ? rendererOrConfig : await createCliRenderer({
+    ...rendererOrConfig,
+    onDestroy: () => {
+      rendererOrConfig.onDestroy?.();
+    }
+  });
+  engine2.attach(renderer);
+  mountSolidRoot(renderer, node);
+};
+
+// src/index.tsx
+import { createCliRenderer as createCliRenderer2 } from "@opentui/core";
+
+// ../../apps/shared/theme.ts
+import { lstatSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// ../../apps/shared/Boo.ghostty
+var Boo_default = "# Boo: the default terminal palette, matching the native installer.\nbackground = #08080E\nforeground = #F5ECD8\ncursor-color = #25D9E8\ncursor-text = #071014\nselection-background = #0E5965\nselection-foreground = #F5ECD8\npalette = 0=#171522\npalette = 1=#FF577D\npalette = 2=#2BE566\npalette = 3=#FFD51A\npalette = 4=#5355C9\npalette = 5=#FF2A8A\npalette = 6=#25D9E8\npalette = 7=#B7AB9A\npalette = 8=#686379\npalette = 9=#FF839D\npalette = 10=#80F5A4\npalette = 11=#FFE873\npalette = 12=#9698FF\npalette = 13=#FF83BB\npalette = 14=#8CEEF5\npalette = 15=#F5ECD8\n# Extended terminal slots retain Boo's existing UI surface colors.\npalette = 16=#111018\npalette = 17=#171522\npalette = 18=#211D2C\npalette = 19=#071014\n";
+
+// ../../apps/shared/theme.ts
+var selectionPath = join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "ghostty/auto/theme.ghostty");
+var resources = process.env.GHOSTTY_RESOURCES_DIR || "/usr/share/ghostty";
+function colors(source) {
+  const values = {};
+  for (const line of source.split(/\r?\n/)) {
+    const match = line.match(/^\s*(background|foreground|cursor-color|cursor-text|selection-background|selection-foreground|palette)\s*=\s*(?:(\d+)=)?#?([\da-f]{6})\s*$/i);
+    if (match) values[match[1] === "palette" ? `palette${match[2]}` : match[1]] = `#${match[3]}`;
+  }
+  for (const key of ["background", "foreground", ...Array.from({ length: 16 }, (_, i) => `palette${i}`)]) {
+    if (!values[key]) throw new Error(`Theme is missing ${key}`);
+  }
+  return values;
+}
+function mix(a, b, amount) {
+  return "#" + [1, 3, 5].map((i) => Math.round(parseInt(a.slice(i, i + 2), 16) * (1 - amount) + parseInt(b.slice(i, i + 2), 16) * amount).toString(16).padStart(2, "0")).join("");
+}
+function ui(c, boo, light) {
+  return {
+    background: c.background,
+    foreground: c.foreground,
+    card: boo ? c.palette16 : mix(c.background, c.foreground, 0.04),
+    panel: boo ? c.palette17 : mix(c.background, c.foreground, 0.07),
+    panelAlt: boo ? c.palette18 : mix(c.background, c.foreground, 0.12),
+    selected: boo ? c["selection-background"] : mix(c.background, c.palette6, 0.25),
+    muted: boo ? c.palette7 : mix(c.background, c.foreground, 0.7),
+    accent: c.palette6,
+    // Deepen light palettes' secondary accent for readable headings and focus fills.
+    highlight: light ? mix(c.palette5, c.foreground, 0.6) : c.palette5,
+    accentInk: boo ? c.palette19 : c.background,
+    warning: c.palette3,
+    danger: c.palette5,
+    success: c.palette2,
+    border: c.palette4
+  };
+}
+var themes = [
+  { name: "Boo", kind: "Dark", description: "Electric cyan. Warm ink. Unmistakably Boo." },
+  { name: "Catppuccin Mocha", kind: "Dark", description: "Soft pastels on a deep, calm canvas." },
+  { name: "Catppuccin Latte", kind: "Light", description: "A bright canvas with gentle, colorful accents." }
+].map((entry) => {
+  const path = join(resources, "themes", entry.name);
+  try {
+    const native = colors(entry.name === "Boo" ? Boo_default : readFileSync(path, "utf8"));
+    return { ...entry, path, native, ui: ui(native, entry.name === "Boo", entry.kind === "Light"), error: "" };
+  } catch {
+    return { ...entry, path, native: colors(Boo_default), ui: ui(colors(Boo_default), true, false), error: "Bundled theme unavailable or invalid." };
+  }
+});
+function readSelection() {
+  let source = "";
+  try {
+    const stat = lstatSync(selectionPath);
+    if (!stat.isFile() || stat.size > 65536) throw new Error("Selection must be a regular file under 64 KiB");
+    source = readFileSync(selectionPath, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const lines = source.split(/\r?\n/).filter((line) => /^\s*theme\s*=/.test(line));
+  const value = lines.at(-1)?.replace(/^\s*theme\s*=\s*/, "").trim().replace(/^"(.*)"$/, "$1");
+  const malformed = source.split(/\r?\n/).some((line) => /^\s*theme(?:\s|=|$)/.test(line) && !/^\s*theme\s*=\s*\S/.test(line));
+  const index = malformed ? -1 : value ? themes.findIndex((theme) => theme.name === value || theme.path === value) : 0;
+  return { source, index, custom: index < 0, name: index < 0 ? "Custom theme" : themes[index].name };
+}
+var palette = (() => {
+  try {
+    return themes[readSelection().index]?.ui || themes[0].ui;
+  } catch {
+    return themes[0].ui;
+  }
+})();
+
+// src/App.tsx
+import { TextAttributes as TextAttributes2 } from "@opentui/core";
+import { For as For2, Show, createSignal as createSignal4, onMount as onMount2 } from "solid-js/dist/solid.js";
+
+// src/backend.ts
+import { createHash as createHash2 } from "node:crypto";
+import { chmod as chmod2, mkdtemp, open as open2, rm } from "node:fs/promises";
+import { tmpdir as tmpdir4 } from "node:os";
+import { dirname as dirname3, join as join5 } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/backends/macos.ts
+import { realpath } from "node:fs/promises";
+import { tmpdir, userInfo } from "node:os";
+
+// src/shared.ts
+import { spawn } from "node:child_process";
+
+// src/dependencies.ts
+import { realpathSync, statSync as statSync2 } from "node:fs";
+import { dirname } from "node:path";
+
+// src/runtime.ts
+import { constants, accessSync, statSync } from "node:fs";
+import { delimiter, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+function which(name2, path = process.env.PATH ?? "") {
+  for (const directory2 of path.split(delimiter)) {
+    if (!directory2) continue;
+    const candidate = join2(directory2, name2);
+    try {
+      accessSync(candidate, constants.X_OK);
+      if (statSync(candidate).isFile()) return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function resolvePackage(name2) {
+  return fileURLToPath(import.meta.resolve(name2));
+}
+
+// src/dependencies.ts
+var commonTools = ["curl", "zstd"];
+var candidateTools = ["gh", "unzip"];
+function preferredExecutable(name2, platform3, path, macSystemExists) {
+  if (platform3 === "darwin" && (name2 === "curl" || name2 === "unzip") && macSystemExists) return `/usr/bin/${name2}`;
+  return path;
+}
+function trustedLinuxPath(path) {
+  if (!path) return null;
+  try {
+    const resolved = realpathSync(path);
+    const binary = statSync2(resolved);
+    if (!binary.isFile() || binary.uid !== 0 || (binary.mode & 18) !== 0 || (binary.mode & 73) === 0) return null;
+    let parent = dirname(resolved);
+    while (true) {
+      const stat = statSync2(parent);
+      if (!stat.isDirectory() || stat.uid !== 0 || (stat.mode & 18) !== 0) return null;
+      const next = dirname(parent);
+      if (next === parent) break;
+      parent = next;
+    }
+    return resolved;
+  } catch {
+    return null;
+  }
+}
+function systemExecutable(name2) {
+  try {
+    return statSync2(`/usr/bin/${name2}`).isFile() ? `/usr/bin/${name2}` : null;
+  } catch {
+    return null;
+  }
+}
+function executable(name2) {
+  const path = preferredExecutable(name2, process.platform, which(name2), systemExecutable(name2) !== null);
+  if (process.platform === "linux") return trustedLinuxPath(path);
+  if (path || process.platform !== "darwin") return path;
+  const prefixes = process.arch === "arm64" ? ["/opt/homebrew", "/usr/local"] : ["/usr/local", "/opt/homebrew"];
+  for (const prefix of prefixes) {
+    const path2 = which(name2, `${prefix}/bin`);
+    if (path2) return path2;
+  }
+  return null;
+}
+function missing(names) {
+  return names.filter((name2) => !executable(name2));
+}
+
+// src/shared.ts
+var positive = (n) => Number.isSafeInteger(n) && Number(n) > 0;
+var cleanText = (s) => String(s).replace(/[\x00-\x1f\x7f-\x9f]/g, " ").slice(0, 300);
+async function command(argv, signal, options = {}) {
+  signal.throwIfAborted();
+  const binary = argv[0].includes("/") ? argv[0] : executable(argv[0]);
+  if (!binary) throw new Error(`Missing ${argv[0]}. Refresh dependency setup before continuing.`);
+  const child = spawn(binary, argv.slice(1), {
+    stdio: options.terminal ? "inherit" : ["pipe", "pipe", "pipe"],
+    env: { ...process.env, GH_DEBUG: "", GH_PAGER: "cat", PAGER: "cat", GH_PROMPT_DISABLED: "1" }
+  });
+  let failure;
+  const exited = new Promise((resolve) => {
+    child.on("error", (error) => {
+      failure = error;
+    });
+    child.on("close", resolve);
+  });
+  let stderr = "";
+  child.stderr?.on("data", (data) => {
+    if (argv[0] !== "gh") stderr = (stderr + data.toString()).slice(-1500);
+  });
+  child.stdin?.on("error", (error) => {
+    failure = error;
+  });
+  child.stdin?.end(options.input);
+  const stop = () => {
+    child.kill("SIGTERM");
+  };
+  signal.addEventListener("abort", stop, { once: true });
+  let output = "";
+  let count = 0;
+  try {
+    if (child.stdout) for await (const chunk of child.stdout) {
+      signal.throwIfAborted();
+      count += chunk.length;
+      if (count > (options.limit ?? 8 * 1024 ** 2)) throw new Error("Command output exceeds the expected size.");
+      if (options.consume) await options.consume(chunk);
+      else output += chunk.toString();
+    }
+    const code2 = await exited;
+    signal.throwIfAborted();
+    if (failure || code2 !== 0) {
+      const message = argv[0] === "gh" ? `GitHub request failed. Run ${cleanText(binary)} auth login if needed; check repository access and your connection, then refresh.` : `${argv[0].split("/").pop()} failed (${code2 ?? "not started"}). ${cleanText(stderr || failure?.message || "")}`;
+      throw new Error(message);
+    }
+    return output;
+  } finally {
+    signal.removeEventListener("abort", stop);
+    if (child.exitCode === null && child.signalCode === null) child.kill("SIGTERM");
+    await exited;
+  }
+}
+
+// src/installers/homebrew.ts
+import { spawn as spawn2 } from "node:child_process";
+var packages = [...commonTools, ...candidateTools];
+function dependencies(includeGitHub = false) {
+  const required2 = includeGitHub ? packages : commonTools;
+  const absent = missing(required2);
+  return {
+    missing: absent,
+    installer: absent.length ? executable("brew") : null,
+    guidance: "Install Homebrew from https://brew.sh, then refresh."
+  };
+}
+async function install(approved, signal) {
+  signal.throwIfAborted();
+  if (process.platform !== "darwin" || process.getuid?.() === 0) throw new Error("Run Boo Flash on macOS as your normal user, not with sudo.");
+  const absent = packages.filter((name2) => approved.includes(name2) && !executable(name2));
+  if (!absent.length) return "installed";
+  const brew = executable("brew");
+  if (!brew) throw new Error("Homebrew not found. Follow https://brew.sh, then refresh.");
+  process.stdout.write(`
+Boo Flash: Homebrew is installing ${absent.join(", ")} and required dependencies.
+Ctrl-C cancels and quits; wait for Homebrew to finish cleanup.
+
+`);
+  const child = spawn2(brew, ["install", "--formula", ...absent], {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      HOMEBREW_NO_ASK: "1",
+      HOMEBREW_NO_AUTO_UPDATE: "1",
+      HOMEBREW_NO_INSTALL_UPGRADE: "1",
+      HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK: "1",
+      HOMEBREW_NO_INSTALL_CLEANUP: "1"
+    }
+  });
+  let failed = false;
+  const [code2, exitSignal] = await new Promise((resolve) => {
+    child.on("error", () => {
+      failed = true;
+    });
+    child.on("close", (code3, signal2) => resolve([code3, signal2]));
+  });
+  if (signal.aborted || code2 === 130 || exitSignal === "SIGINT") return "cancelled";
+  if (failed || code2 !== 0) throw new Error(`Homebrew failed (${code2 ?? "not started"}). Quit to read its terminal output, resolve the reported issue, then refresh to retry.`);
+  const remaining = approved.filter((name2) => !executable(name2));
+  if (remaining.length) throw new Error(`Still missing: ${remaining.join(", ")}. Check Homebrew's terminal output and command paths, then refresh.`);
+  return "installed";
+}
+
+// src/backends/platform.ts
+import { spawn as spawn3 } from "node:child_process";
+function startWriter(binary, args2) {
+  const child = spawn3(binary, args2, { stdio: ["pipe", "ignore", "pipe"] });
+  let stderr = "";
+  child.stderr.on("data", (data) => {
+    stderr = (stderr + data.toString()).slice(-1500);
+  });
+  child.stdin.on("error", () => {
+  });
+  const done = new Promise((resolve) => {
+    child.on("error", (error) => {
+      stderr = `Could not start the privileged writer: ${error.message}`;
+    });
+    child.on("close", resolve);
+  });
+  return { stdin: child.stdin, done, error: () => stderr, stop: () => child.stdin.destroy() };
+}
+
+// src/backends/macos.ts
+var diskID = /^disk[0-9]+$/;
+var deviceID = /^disk[0-9]+(?:s[0-9]+)*$/;
+async function plist(argv, signal) {
+  const input = await command(argv, signal);
+  return JSON.parse(await command(["/usr/bin/plutil", "-convert", "json", "-o", "-", "--", "-"], signal, { input }));
+}
+async function disks(signal, source, staging = tmpdir(), unmounted) {
+  const info = (id) => plist(["/usr/sbin/diskutil", "info", "-plist", id], signal);
+  const listing = await plist(["/usr/sbin/diskutil", "list", "-plist", "physical"], signal);
+  const physical = new Set((listing.WholeDisks ?? []).filter((id) => diskID.test(id)));
+  if (!physical.size) throw new Error("Cannot resolve physical disks. Nothing can be selected.");
+  const apfs = await plist(["/usr/sbin/diskutil", "apfs", "list", "-plist"], signal);
+  if (!Array.isArray(apfs.Containers)) throw new Error("Cannot resolve APFS storage. Nothing can be selected.");
+  const containers = apfs.Containers;
+  const protectedDisks2 = /* @__PURE__ */ new Set();
+  const resolve = async (id, seen = /* @__PURE__ */ new Set()) => {
+    if (seen.has(id)) throw new Error("Unresolved storage cycle. Nothing can be selected.");
+    const next = new Set(seen).add(id);
+    const d = await info(id);
+    if (!deviceID.test(d.DeviceIdentifier)) throw new Error("Unresolved backing device. Nothing can be selected.");
+    if (d.WholeDisk === true && physical.has(d.DeviceIdentifier)) return [d.DeviceIdentifier];
+    if (d.WholeDisk === false && physical.has(d.ParentWholeDisk)) return resolve(d.ParentWholeDisk, next);
+    const container = containers.find((c) => c.ContainerReference === d.DeviceIdentifier || c.ContainerReference === d.APFSContainerReference || c.Volumes?.some((v) => v.DeviceIdentifier === d.DeviceIdentifier));
+    if (container) {
+      if (!Array.isArray(container.PhysicalStores) || !container.PhysicalStores.length) throw new Error("APFS physical stores are unavailable.");
+      const result = [];
+      for (const store of container.PhysicalStores) {
+        if (!deviceID.test(store.DeviceIdentifier)) throw new Error("Invalid APFS physical store.");
+        result.push(...await resolve(store.DeviceIdentifier, next));
+      }
+      return result;
+    }
+    if (d.WholeDisk === false && diskID.test(d.ParentWholeDisk)) return resolve(d.ParentWholeDisk, next);
+    throw new Error("A protected path has unsupported backing storage (for example RAID or a disk image). Nothing can be selected.");
+  };
+  const protectedPaths2 = ["/", "/System/Volumes/Data", userInfo().homedir, process.cwd(), source, process.execPath, staging];
+  protectedPaths2.push(resolvePackage("@opentui/core"));
+  for (const name2 of ["@opentui/solid", "solid-js"]) {
+    try {
+      protectedPaths2.push(resolvePackage(name2));
+    } catch {
+    }
+  }
+  protectedPaths2.push(process.env.OTUI_ASSET_ROOT || resolvePackage(`@opentui/core-darwin-${process.arch}`));
+  const zstd = executable("zstd");
+  if (!zstd) throw new Error("Install zstd before flashing.");
+  protectedPaths2.push(zstd);
+  const gh = executable("gh");
+  if (gh) protectedPaths2.push(gh);
+  for (const path of protectedPaths2) {
+    const canonical = await realpath(path);
+    const device = (await command(["/usr/bin/stat", "-f", "%Sd", canonical], signal)).trim();
+    if (!deviceID.test(device)) throw new Error("Cannot resolve a protected path to a disk. Nothing can be selected.");
+    for (const id of await resolve(device)) protectedDisks2.add(id);
+  }
+  for (const container of containers) {
+    if (container.PhysicalStores?.length !== 1 || container.Volumes?.some((v) => v.Roles?.some((r) => r === "System" || r === "Data"))) {
+      for (const id of await resolve(container.ContainerReference)) protectedDisks2.add(id);
+    }
+  }
+  const registry = await plist(["/usr/sbin/ioreg", "-a", "-r", "-c", "IOMedia", "-d", "1"], signal);
+  if (!Array.isArray(registry)) throw new Error("Cannot identify attached media. Nothing can be selected.");
+  const disks3 = [];
+  for (const id of physical) {
+    if (protectedDisks2.has(id)) continue;
+    const d = await info(id);
+    const media = registry.filter((m) => m["BSD Name"] === id && m.Whole === true);
+    const layout = listing.AllDisksAndPartitions?.find((p) => p.DeviceIdentifier === id);
+    if (!layout || JSON.stringify(layout).includes("Apple_CoreStorage") || JSON.stringify(layout).includes("Apple_RAID")) continue;
+    if (d.DeviceIdentifier !== id || d.DeviceNode !== `/dev/${id}` || d.WholeDisk !== true || d.Internal !== false || d.BusProtocol !== "USB" || d.WritableMedia !== true || d.DeviceBlockSize !== 512 || d.RAIDMaster === true || d.RAIDSlice === true || !positive(d.Size) || media.length !== 1 || !positive(media[0].IORegistryEntryID)) continue;
+    const identity2 = JSON.stringify([media[0].IORegistryEntryID, d.Size, d.DeviceTreePath ?? "", d.MediaName ?? ""]);
+    if (id === unmounted) {
+      const volumes = [id, ...(layout.Partitions ?? []).map((p) => p.DeviceIdentifier)];
+      const targetStores = new Set(volumes);
+      for (const c of containers) {
+        if (c.PhysicalStores?.some((s) => targetStores.has(s.DeviceIdentifier))) {
+          volumes.push(...(c.Volumes ?? []).map((v) => v.DeviceIdentifier));
+        }
+      }
+      for (const volume of volumes) {
+        if (!deviceID.test(volume)) throw new Error("Cannot verify all target volumes are unmounted.");
+        const v = await info(volume);
+        if (v.Mounted === true || typeof v.MountPoint === "string" && v.MountPoint !== "") {
+          throw new Error("A target volume is still mounted or was remounted. Close apps using the USB and try again.");
+        }
+      }
+    }
+    disks3.push({ id, bytes: d.Size, name: cleanText(d.MediaName || d.IORegistryEntryName || "USB drive"), identity: identity2 });
+  }
+  return disks3;
+}
+async function authorize(signal) {
+  await command(["/usr/bin/sudo", "-v"], signal, { terminal: true });
+}
+var platform = {
+  id: "macos",
+  label: "macOS / x86_64 UEFI",
+  successTitle: "USB safely ejected",
+  successDetail: "You can now remove the USB and boot your target computer.",
+  authorizationDetail: "The ordinary macOS sudo prompt follows. Boo Flash never reads your password.",
+  ejectDetail: "Waiting for macOS to make the USB safe to remove.",
+  incompleteDetail: "USB may be incomplete; not safely ejected. Eject it with macOS before removal.",
+  finalAuthorization: false,
+  reunmountBeforeEject: false,
+  dependencies,
+  installDependencies: install,
+  disks,
+  authorize,
+  async unmount(disk, signal) {
+    if (!diskID.test(disk.id)) throw new Error("Invalid macOS disk identifier.");
+    await command(["/usr/sbin/diskutil", "unmountDisk", `/dev/${disk.id}`], signal);
+  },
+  writer(disk) {
+    if (!diskID.test(disk.id)) throw new Error("Invalid macOS disk identifier.");
+    return startWriter("/usr/bin/sudo", ["-n", "--", "/bin/dd", `of=/dev/r${disk.id}`, "bs=4m"]);
+  },
+  async flush(_disk, signal) {
+    await command(["/bin/sync"], signal);
+  },
+  async eject(disk, signal) {
+    if (!diskID.test(disk.id)) throw new Error("Invalid macOS disk identifier.");
+    await command(["/usr/sbin/diskutil", "eject", `/dev/${disk.id}`], signal);
+  }
+};
+
+// src/backends/linux.ts
+import { lstatSync as lstatSync2, realpathSync as realpathSync2 } from "node:fs";
+import { lstat, readFile, realpath as realpath2 } from "node:fs/promises";
+import { tmpdir as tmpdir2, userInfo as userInfo2 } from "node:os";
+import { basename, dirname as dirname2, join as join3 } from "node:path";
+var diskID2 = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/;
+var stableDevice = /^\/dev\/disk\/by-id\/[A-Za-z0-9._:+\\-]{1,240}$/;
+var majorMinor = /^(0|[1-9][0-9]*):(0|[1-9][0-9]*)$/;
+var tools = ["sudo", "dd", "sync", "lsblk", "findmnt", "udevadm", "umount", "udisksctl"];
+var protectedSystemPaths = ["/", "/boot", "/boot/efi", "/efi", "/usr", "/var", "/opt", "/srv", "/home"];
+var findmntSourceColumn = "SOURCE";
+function exactObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseTopology(input) {
+  let root;
+  try {
+    root = JSON.parse(input);
+  } catch {
+    throw new Error("Linux block-device inventory is not valid JSON. Nothing can be selected.");
+  }
+  if (!exactObject(root) || !Array.isArray(root.blockdevices)) {
+    throw new Error("Linux block-device inventory is incomplete. Nothing can be selected.");
+  }
+  const devices = /* @__PURE__ */ new Map();
+  const parents = /* @__PURE__ */ new Map();
+  const children2 = /* @__PURE__ */ new Map();
+  const visit = (raw, parent) => {
+    if (!exactObject(raw)) throw new Error("Linux block-device inventory contains an invalid device. Nothing can be selected.");
+    const block = raw;
+    if (typeof block.path !== "string" || !/^\/dev\/[^\x00-\x1f\x7f-\x9f]{1,300}$/.test(block.path) || typeof block.name !== "string" || typeof block.kname !== "string" || typeof block.type !== "string" || !majorMinor.test(String(block["maj:min"])) || !Number.isSafeInteger(block.size) || Number(block.size) < 0 || !positive(block["log-sec"]) || typeof block.ro !== "boolean" || typeof block.rm !== "boolean" || !(block.tran === null || typeof block.tran === "string") || !(block.model === null || typeof block.model === "string") || !(block.fstype === null || typeof block.fstype === "string") || !(block.uuid === null || typeof block.uuid === "string") || !(block.label === null || typeof block.label === "string") || !(block.partuuid === null || typeof block.partuuid === "string") || !(block.partlabel === null || typeof block.partlabel === "string") || !Array.isArray(block.mountpoints) || block.mountpoints.some((point) => !(point === null || typeof point === "string"))) {
+      throw new Error("Linux block-device inventory contains unsupported values. Nothing can be selected.");
+    }
+    const key = String(block["maj:min"]);
+    const device = {
+      id: basename(block.path),
+      path: block.path,
+      type: block.type,
+      size: Number(block.size),
+      model: cleanText(block.model ?? "USB drive").trim() || "USB drive",
+      transport: block.tran,
+      removable: block.rm,
+      readonly: block.ro,
+      sector: block["log-sec"],
+      majorMinor: key,
+      mountpoints: block.mountpoints.filter((point) => typeof point === "string" && point.length > 0),
+      fstype: block.fstype,
+      uuid: block.uuid,
+      label: block.label,
+      partuuid: block.partuuid,
+      partlabel: block.partlabel,
+      ambiguous: false
+    };
+    const current = devices.get(key);
+    if (current) {
+      const structural = ["type", "size", "readonly", "sector", "fstype", "uuid", "label", "partuuid", "partlabel"];
+      if (structural.some((field) => current[field] !== device[field])) {
+        throw new Error("Linux block-device inventory disagrees about a device. Nothing can be selected.");
+      }
+      if (JSON.stringify(current) !== JSON.stringify(device)) current.ambiguous = true;
+    } else devices.set(key, device);
+    if (parent) {
+      if (!parents.has(key)) parents.set(key, /* @__PURE__ */ new Set());
+      if (!children2.has(parent)) children2.set(parent, /* @__PURE__ */ new Set());
+      parents.get(key).add(parent);
+      children2.get(parent).add(key);
+    }
+    if (block.children !== void 0 && !Array.isArray(block.children)) {
+      throw new Error("Linux block-device relationships are invalid. Nothing can be selected.");
+    }
+    for (const child of block.children ?? []) visit(child, key);
+  };
+  for (const block of root.blockdevices) visit(block);
+  if (!devices.size) throw new Error("Cannot resolve Linux block devices. Nothing can be selected.");
+  return { devices, parents, children: children2 };
+}
+function related(start, edges) {
+  const found = /* @__PURE__ */ new Set();
+  const pending = [start];
+  while (pending.length) {
+    const key = pending.pop();
+    if (found.has(key)) continue;
+    found.add(key);
+    for (const next of edges.get(key) ?? []) pending.push(next);
+  }
+  return found;
+}
+function protectedDisks(topology2, protectedDevices) {
+  const result = /* @__PURE__ */ new Set();
+  for (const key of protectedDevices) {
+    const match = majorMinor.exec(key);
+    if (!match) throw new Error("A protected Linux path has an invalid backing-device identity. Nothing can be selected.");
+    if (!topology2.devices.has(key)) throw new Error("A protected Linux path cannot be mapped to storage. Nothing can be selected.");
+    const device = topology2.devices.get(key);
+    const members = device.uuid ? [...topology2.devices.entries()].filter(([, candidate]) => candidate.uuid === device.uuid).map(([candidate]) => candidate) : [key];
+    for (const member of members) {
+      const ancestors = related(member, topology2.parents);
+      const disks3 = [...ancestors].filter((candidate) => topology2.devices.get(candidate)?.type === "disk");
+      if (!disks3.length) throw new Error("A protected Linux path has unsupported backing storage. Nothing can be selected.");
+      for (const disk of disks3) result.add(disk);
+    }
+  }
+  return result;
+}
+function eligibleDevices(topology2, protectedDevices, unmounted, usbParents) {
+  const protectedRoots = protectedDisks(topology2, protectedDevices);
+  const uuidMembers = /* @__PURE__ */ new Map();
+  for (const device of topology2.devices.values()) if (device.uuid) {
+    const members = uuidMembers.get(device.uuid) ?? [];
+    members.push(device);
+    uuidMembers.set(device.uuid, members);
+  }
+  const activeSharedFilesystems = new Set([...uuidMembers.entries()].filter(([, members]) => members.length > 1 && members.some((member) => member.mountpoints.length > 0)).map(([uuid]) => uuid));
+  const parentCounts = /* @__PURE__ */ new Map();
+  if (usbParents) for (const [key, parent] of usbParents) {
+    if (!topology2.devices.has(key) || topology2.parents.get(key)?.size) continue;
+    parentCounts.set(parent, (parentCounts.get(parent) ?? 0) + 1);
+  }
+  return [...topology2.devices.values()].filter((device) => {
+    if (device.type !== "disk" || device.transport !== "usb" || device.readonly || device.sector !== 512 || !positive(device.size) || device.ambiguous || device.path !== `/dev/${device.id}` || !diskID2.test(device.id) || protectedRoots.has(device.majorMinor) || topology2.parents.get(device.majorMinor)?.size || usbParents && (!usbParents.has(device.majorMinor) || parentCounts.get(usbParents.get(device.majorMinor)) !== 1)) return false;
+    const descendants = related(device.majorMinor, topology2.children);
+    if ([...descendants].some((key) => {
+      const child = topology2.devices.get(key);
+      return key !== device.majorMinor && child.type !== "part" || child.mountpoints.some((point) => point === "[SWAP]") || child.uuid !== null && activeSharedFilesystems.has(child.uuid) || unmounted === device.id && child.mountpoints.length > 0;
+    })) return false;
+    return true;
+  });
+}
+async function topology(signal) {
+  return parseTopology(await command([
+    "lsblk",
+    "--json",
+    "--bytes",
+    "--paths",
+    "--tree",
+    "--output",
+    "NAME,KNAME,PATH,TYPE,SIZE,MODEL,TRAN,RM,RO,LOG-SEC,MOUNTPOINTS,MAJ:MIN,PKNAME,FSTYPE,UUID,LABEL,PARTUUID,PARTLABEL"
+  ], signal, { limit: 8 * 1024 ** 2 }));
+}
+async function protectedPaths(source, staging) {
+  const paths = [
+    ...protectedSystemPaths,
+    userInfo2().homedir,
+    process.cwd(),
+    source,
+    process.execPath,
+    staging
+  ];
+  paths.push(resolvePackage("@opentui/core"));
+  for (const name2 of ["@opentui/solid", "solid-js"]) {
+    try {
+      paths.push(resolvePackage(name2));
+    } catch {
+    }
+  }
+  for (const name2 of [`@opentui/core-linux-${process.arch}`, `@opentui/core-linux-${process.arch}-musl`]) {
+    try {
+      paths.push(resolvePackage(name2));
+    } catch {
+    }
+  }
+  if (process.env.OTUI_ASSET_ROOT) paths.push(process.env.OTUI_ASSET_ROOT);
+  for (const name2 of [...commonTools, ...candidateTools, ...tools]) {
+    const path = executable(name2);
+    if (path) paths.push(path);
+  }
+  const result = [];
+  for (const path of paths) {
+    try {
+      result.push(await realpath2(path));
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  return result;
+}
+async function usbParent(device) {
+  let path;
+  try {
+    path = await realpath2(`/sys/class/block/${device.id}/device`);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+  while (path.startsWith("/sys/")) {
+    try {
+      await Promise.all([readFile(join3(path, "idVendor"), "utf8"), readFile(join3(path, "idProduct"), "utf8")]);
+      return path;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    const next = dirname2(path);
+    if (next === path) break;
+    path = next;
+  }
+  return null;
+}
+async function usbParentMap(inventory) {
+  const result = /* @__PURE__ */ new Map();
+  for (const device of inventory.devices.values()) {
+    if (inventory.parents.get(device.majorMinor)?.size || device.type === "part") continue;
+    const parent = await usbParent(device);
+    if (parent) result.set(device.majorMinor, parent);
+  }
+  return result;
+}
+async function sourceIdentity(source, signal, optional = false) {
+  const suffix = source.indexOf("[");
+  const path = suffix < 0 ? source : source.slice(0, suffix);
+  if (!path.startsWith("/dev/") || cleanText(path) !== path) return null;
+  if (optional) {
+    try {
+      await lstat(path);
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    }
+  }
+  const identity2 = (await command(["lsblk", "--noheadings", "--raw", "--nodeps", "--output", "MAJ:MIN", "--", path], signal)).trim();
+  if (!majorMinor.test(identity2) || identity2.includes("\n")) {
+    throw new Error("A protected Linux block source is ambiguous. Nothing can be selected.");
+  }
+  return identity2;
+}
+async function backingDevices(path, signal) {
+  const output = await command([
+    "findmnt",
+    "--json",
+    "--canonicalize",
+    "--first-only",
+    "--target",
+    path,
+    "--output",
+    `MAJ:MIN,${findmntSourceColumn}`
+  ], signal, { limit: 1024 ** 2 });
+  let parsed;
+  try {
+    parsed = JSON.parse(output);
+  } catch {
+    throw new Error("Cannot parse protected Linux storage. Nothing can be selected.");
+  }
+  if (!exactObject(parsed) || !Array.isArray(parsed.filesystems) || parsed.filesystems.length !== 1 || !exactObject(parsed.filesystems[0]) || !majorMinor.test(String(parsed.filesystems[0]["maj:min"])) || !(parsed.filesystems[0].source === null || typeof parsed.filesystems[0].source === "string")) {
+    throw new Error("Cannot resolve a protected Linux path to storage. Nothing can be selected.");
+  }
+  const result = /* @__PURE__ */ new Set();
+  const mounted = String(parsed.filesystems[0]["maj:min"]);
+  if (!mounted.startsWith("0:")) result.add(mounted);
+  if (typeof parsed.filesystems[0].source === "string") {
+    const identity2 = await sourceIdentity(parsed.filesystems[0].source, signal);
+    if (identity2) result.add(identity2);
+  }
+  if (!result.size) throw new Error("A protected Linux path has unsupported non-block backing storage. Nothing can be selected.");
+  return [...result];
+}
+async function fstabDevices(inventory, signal) {
+  let fstab;
+  try {
+    fstab = await readFile("/etc/fstab", "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  if (!fstab.split("\n").some((line) => line.trim() && !line.trim().startsWith("#"))) return [];
+  const output = await command(["findmnt", "--fstab", "--json", "--output", findmntSourceColumn], signal, { limit: 1024 ** 2 });
+  const sources = parseConfiguredSources(output);
+  const direct = (await Promise.all(sources.map((source) => sourceIdentity(source, signal, true)))).filter((value) => value !== null);
+  return [...configuredTagDevices(inventory, sources), ...direct];
+}
+function parseConfiguredSources(output) {
+  let parsed;
+  try {
+    parsed = JSON.parse(output);
+  } catch {
+    throw new Error("Cannot parse configured Linux storage. Nothing can be selected.");
+  }
+  if (!exactObject(parsed) || !Array.isArray(parsed.filesystems)) {
+    throw new Error("Cannot resolve configured Linux storage. Nothing can be selected.");
+  }
+  const sources = [];
+  for (const filesystem of parsed.filesystems) {
+    if (!exactObject(filesystem) || !(filesystem.source === null || typeof filesystem.source === "string")) {
+      throw new Error("Configured Linux storage is invalid. Nothing can be selected.");
+    }
+    if (typeof filesystem.source === "string") sources.push(filesystem.source);
+  }
+  return sources;
+}
+function configuredTagDevices(topology2, sources) {
+  const result = [];
+  for (const source of sources) {
+    const match = /^(UUID|LABEL|PARTUUID|PARTLABEL)=(.+)$/.exec(source);
+    if (!match) continue;
+    const field = { UUID: "uuid", LABEL: "label", PARTUUID: "partuuid", PARTLABEL: "partlabel" }[match[1]];
+    for (const device of topology2.devices.values()) if (device[field] === match[2]) result.push(device.majorMinor);
+  }
+  return result;
+}
+function properties(input) {
+  const result = /* @__PURE__ */ new Map();
+  for (const line of input.trim().split("\n")) {
+    const split = line.indexOf("=");
+    if (split < 1) throw new Error("Linux device identity is invalid. Nothing can be selected.");
+    const key = line.slice(0, split);
+    const value = line.slice(split + 1);
+    if (result.has(key)) throw new Error("Linux device identity contains duplicate properties. Nothing can be selected.");
+    result.set(key, value);
+  }
+  return result;
+}
+async function identity(device, signal) {
+  const info = properties(await command(["udevadm", "info", "--query=property", `--name=${device.path}`], signal));
+  const stat = await lstat(device.path);
+  const [major, minor] = device.majorMinor.split(":");
+  if (!stat.isBlockDevice() || info.get("DEVNAME") !== device.path || info.get("DEVTYPE") !== "disk" || info.get("DEVPATH")?.startsWith("/devices/") !== true || info.get("MAJOR") !== major || info.get("MINOR") !== minor) {
+    throw new Error("Linux USB identity does not match its block device. Nothing can be selected.");
+  }
+  const links = (info.get("DEVLINKS") ?? "").split(" ").filter((path) => path.startsWith("/dev/disk/by-id/") && !/-part[0-9]+$/.test(path) && cleanText(path) === path).sort();
+  const stable = [];
+  for (const link2 of links) {
+    try {
+      if ((await lstat(link2)).isSymbolicLink() && await realpath2(link2) === device.path) stable.push(link2);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  if (!stable.length) return null;
+  await command(["udisksctl", "info", "--block-device", stable[0]], signal, { limit: 1024 ** 2 });
+  return { device: stable[0], identity: JSON.stringify([
+    device.majorMinor,
+    device.size,
+    info.get("DEVPATH"),
+    stat.rdev,
+    stat.ino,
+    stat.ctimeMs,
+    stable[0],
+    info.get("ID_PATH") ?? "",
+    info.get("ID_SERIAL") ?? "",
+    device.model
+  ]) };
+}
+async function disks2(signal, source, staging = tmpdir2(), unmounted) {
+  await command(["udisksctl", "status"], signal, { limit: 1024 ** 2 });
+  const inventory = await topology(signal);
+  const usbParents = await usbParentMap(inventory);
+  const roots = [...new Set(await protectedPaths(source, staging))];
+  const protectedDevices = [
+    ...(await Promise.all(roots.map((path) => backingDevices(path, signal)))).flat(),
+    ...await fstabDevices(inventory, signal)
+  ];
+  const eligible = eligibleDevices(inventory, protectedDevices, unmounted, usbParents);
+  const result = [];
+  for (const device of eligible) {
+    const attached = await identity(device, signal);
+    if (attached) result.push({ id: device.id, name: device.model, bytes: device.size, ...attached });
+  }
+  return result;
+}
+function dependencies2(includeGitHub = false) {
+  const required2 = [...commonTools, ...tools, ...includeGitHub ? candidateTools : []];
+  return {
+    missing: missing(required2),
+    installer: null,
+    guidance: "Install the missing commands with your Linux distribution's package manager, then refresh."
+  };
+}
+function required(name2) {
+  const path = executable(name2);
+  if (!path) throw new Error(`Missing ${name2}. Install it with your Linux distribution's package manager, then refresh.`);
+  return path;
+}
+async function currentTarget(disk, signal) {
+  const inventory = await topology(signal);
+  const matches = [...inventory.devices.values()].filter((device) => device.id === disk.id);
+  if (matches.length !== 1) throw new Error("The selected Linux USB is no longer uniquely attached.");
+  const target = matches[0];
+  if (!eligibleDevices(inventory, [], void 0, await usbParentMap(inventory)).includes(target)) {
+    throw new Error("The selected Linux USB is no longer eligible.");
+  }
+  return { inventory, target };
+}
+function validateDeviceRoute(disk, inspect = { symlink: (path) => lstatSync2(path).isSymbolicLink(), realpath: realpathSync2 }) {
+  if (!diskID2.test(disk.id) || typeof disk.device !== "string" || !stableDevice.test(disk.device) || !inspect.symlink(disk.device) || inspect.realpath(disk.device) !== `/dev/${disk.id}`) {
+    throw new Error("Invalid or changed Linux USB identity.");
+  }
+  return disk.device;
+}
+var platform2 = {
+  id: "linux",
+  label: "Linux / x86_64 UEFI",
+  successTitle: "USB safely powered off",
+  successDetail: "You can now remove the USB and boot your target computer.",
+  authorizationDetail: "The ordinary Linux sudo prompt follows. Boo Flash never reads your password.",
+  ejectDetail: "Asking Linux to flush and safely power off the USB.",
+  incompleteDetail: "USB may be incomplete; not safely powered off. Use Linux's safe-removal control before removal.",
+  finalAuthorization: true,
+  reunmountBeforeEject: true,
+  dependencies: dependencies2,
+  async installDependencies() {
+    throw new Error("Automatic dependency installation is not supported on Linux. Install the missing commands with your distribution's package manager.");
+  },
+  disks: disks2,
+  async authorize(signal) {
+    await command([required("sudo"), "-v"], signal, { terminal: true });
+  },
+  async unmount(disk, signal) {
+    const { inventory, target } = await currentTarget(disk, signal);
+    const descendants = [...related(target.majorMinor, inventory.children)].map((key) => inventory.devices.get(key)).filter((device) => device.mountpoints.length > 0).reverse();
+    for (const device of descendants) {
+      await command([required("sudo"), "-n", "--", required("umount"), "--all-targets", "--", device.path], signal);
+    }
+  },
+  writer(disk) {
+    const device = validateDeviceRoute(disk);
+    return startWriter(required("sudo"), ["-n", "--", required("dd"), `of=${device}`, "bs=4M", "conv=fsync", "status=none"]);
+  },
+  async flush(_disk, signal) {
+    await command([required("sync")], signal);
+  },
+  async eject(disk, signal) {
+    const device = validateDeviceRoute(disk);
+    await command([required("sudo"), "-n", "--", required("udisksctl"), "power-off", "--block-device", device, "--no-user-interaction"], signal);
+  }
+};
+
+// src/cache.ts
+import { createHash } from "node:crypto";
+import { constants as constants2 } from "node:fs";
+import { chmod, link, lstat as lstat2, mkdir, open, readdir, realpath as realpath3, unlink } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join4 } from "node:path";
+var entryName = /^[1-9][0-9]*-[a-f0-9]{64}\.(zip|raw\.zst)$/;
+var recovery = "Clear cached images (or run --clear-cache), then retry. Unsafe paths must be corrected manually. No disk was written.";
+var code = (error) => error.code;
+var owned = (stat) => stat.uid === process.getuid?.() && (stat.mode & 63) === 0;
+async function directory() {
+  const uid = process.getuid?.();
+  if (uid === void 0 || uid === 0) throw new Error("Use a normal user account for the image cache, not sudo.");
+  const path = join4(await realpath3(tmpdir3()), `boo-flash-cache-${uid}`);
+  try {
+    await mkdir(path, { mode: 448 });
+  } catch (error) {
+    if (code(error) !== "EEXIST") throw error;
+  }
+  const stat = await lstat2(path);
+  if (!stat.isDirectory() || !owned(stat)) throw new Error(`Unsafe image cache directory: ${path}. ${recovery}`);
+  return path;
+}
+function name(image) {
+  if (!positive(image.id) || !positive(image.bytes) || image.digest.length !== 64 || !/^[a-f0-9]{64}$/.test(image.digest)) throw new Error("Invalid cache identity.");
+  return `${image.id}-${image.digest}.${image.cacheKind ?? "zip"}`;
+}
+function regular(stat) {
+  if (!stat.isFile() || !owned(stat)) throw new Error(`Unsafe cached image. ${recovery}`);
+}
+async function reuseArchive(image, snapshot, signal, progress = () => {
+}) {
+  const filename = name(image);
+  const path = join4(await directory(), filename);
+  let stat;
+  try {
+    stat = await lstat2(path);
+  } catch (error) {
+    if (code(error) === "ENOENT") return false;
+    throw error;
+  }
+  regular(stat);
+  try {
+    await link(path, snapshot);
+  } catch (error) {
+    if (code(error) === "ENOENT") return false;
+    throw new Error(`Cannot pin cached image (${code(error)}). No disk was written.`);
+  }
+  const file = await open(snapshot, constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK);
+  try {
+    const pinned = await file.stat();
+    regular(pinned);
+    if (pinned.dev !== stat.dev || pinned.ino !== stat.ino || pinned.size !== image.bytes) {
+      throw new Error(`Cached image changed or has the wrong size. ${recovery}`);
+    }
+    const hash = createHash("sha256");
+    const buffer = Buffer.alloc(1024 ** 2);
+    let count = 0;
+    progress(0);
+    while (true) {
+      signal.throwIfAborted();
+      const { bytesRead } = await file.read(buffer);
+      if (!bytesRead) break;
+      count += bytesRead;
+      if (count > image.bytes) throw new Error(`Cached image exceeds its API size. ${recovery}`);
+      hash.update(buffer.subarray(0, bytesRead));
+      progress(count);
+    }
+    if (count !== image.bytes || hash.digest("hex") !== image.digest) throw new Error(`Cached image SHA-256 or size mismatch. ${recovery}`);
+    signal.throwIfAborted();
+    return true;
+  } finally {
+    await file.close();
+  }
+}
+async function publishArchive(image, verified, signal) {
+  const filename = name(image);
+  const path = join4(await directory(), filename);
+  await chmod(verified, 256);
+  try {
+    await link(verified, path);
+  } catch (error) {
+    if (code(error) !== "EEXIST") throw new Error(`Cannot retain verified image in cache (${code(error)}). No disk was written.`);
+    const snapshot = `${verified}.cached`;
+    try {
+      if (!await reuseArchive(image, snapshot, signal)) {
+        throw new Error("Image cache was cleared during publication. Retry; no disk was written.");
+      }
+    } finally {
+      try {
+        await unlink(snapshot);
+      } catch (error2) {
+        if (code(error2) !== "ENOENT") throw error2;
+      }
+    }
+  }
+}
+async function clearCachedImages(signal) {
+  const path = await directory();
+  let count = 0;
+  for (const filename of await readdir(path)) {
+    signal.throwIfAborted();
+    if (entryName.exec(filename)?.[0] !== filename || !positive(Number(filename.split("-")[0]))) continue;
+    const entry = join4(path, filename);
+    try {
+      regular(await lstat2(entry));
+      await unlink(entry);
+      count++;
+    } catch (error) {
+      if (code(error) !== "ENOENT") throw error;
+    }
+  }
+  return `Removed ${count} cached archive(s) from ${path}. USB contents and active flashes are unchanged.`;
+}
+
+// src/backend.ts
+var profiles = ["intel", "amd", "nvidia"];
+var repository = "anomalyco/boo";
+var repositoryIdentities = /* @__PURE__ */ new Set([repository, "anomalyco/ghostty-distro"]);
+var releaseOrigin = "https://images.os.boo";
+var diskID3 = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/;
+var sha256 = /^[a-f0-9]{64}$/;
+var semanticVersion = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$/;
+var releaseVersion = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\+[1-9][0-9]*$/;
+var moduleDirectory = dirname3(fileURLToPath2(import.meta.url));
+function bytes(n) {
+  return n >= 1024 ** 3 ? `${(n / 1024 ** 3).toFixed(1)} GiB` : `${(n / 1024 ** 2).toFixed(1)} MiB`;
+}
+async function prepareSafeRemoval(platform3, disk, signal, authorize2, revalidate, update) {
+  if (platform3.finalAuthorization) {
+    update({ stage: "Authorizing", detail: "Refreshing Linux authorization before safe power-off." });
+    await authorize2();
+  }
+  if (platform3.reunmountBeforeEject) {
+    update({ stage: "Unmounting", detail: "Removing any target volumes remounted after writing, without force." });
+    await platform3.unmount(disk, signal);
+    await revalidate(true);
+  } else await revalidate();
+}
+async function discoverImages(signal) {
+  const get = async (url, fresh = false) => JSON.parse(await command([
+    "curl",
+    "--fail",
+    "--silent",
+    "--show-error",
+    "--proto",
+    "=https",
+    ...fresh ? ["--header", "Cache-Control: no-cache"] : [],
+    url
+  ], signal, { limit: 1024 ** 2 }));
+  const channel = await get(`${releaseOrigin}/channels/main.json`, true);
+  if (channel?.schema !== 1 || !releaseVersion.test(channel.version) || !/^[a-f0-9]{40}$/.test(channel.revision) || channel.prefix !== `releases/${channel.version}`) {
+    throw new Error("The Boo main release channel is invalid.");
+  }
+  const manifest = await get(`${releaseOrigin}/${channel.prefix}/release.json`);
+  const build = Number(channel.version.slice(channel.version.lastIndexOf("+") + 1));
+  if (manifest?.schema !== 1 || manifest.version !== channel.version || manifest.revision !== channel.revision || !semanticVersion.test(manifest.semantic_version) || manifest.version !== `${manifest.semantic_version}+${manifest.build_number}` || manifest.build_number !== build || !positive(build) || !manifest.artifacts || Object.keys(manifest.artifacts).sort().join(",") !== [...profiles].sort().join(",")) {
+    throw new Error("The Boo main release manifest is invalid.");
+  }
+  const images = profiles.map((profile) => {
+    const artifact = manifest.artifacts[profile];
+    const name2 = `boo-${channel.version}-x86_64-${profile}.raw.zst`;
+    if (artifact?.image !== name2 || !positive(artifact.compressed_bytes) || !sha256.test(artifact.compressed_sha256) || !positive(artifact.raw_apparent_bytes) || !sha256.test(artifact.raw_sha256)) {
+      throw new Error(`The Boo ${profile.toUpperCase()} release metadata is invalid.`);
+    }
+    return {
+      profile,
+      id: build,
+      name: name2,
+      bytes: artifact.compressed_bytes,
+      digest: artifact.compressed_sha256,
+      cacheKind: "raw.zst",
+      url: `${releaseOrigin}/${channel.prefix}/${name2}`,
+      rawBytes: artifact.raw_apparent_bytes,
+      rawDigest: artifact.raw_sha256
+    };
+  });
+  return { run: build, version: channel.version, revision: channel.revision, images };
+}
+async function discoverCandidates(signal) {
+  const api = async (path) => JSON.parse(await command(["gh", "api", "--hostname", "github.com", `repos/${repository}/${path}`], signal));
+  const result = await api("actions/workflows/candidate.yml/runs?status=success&per_page=10");
+  if (!Array.isArray(result.workflow_runs)) throw new Error("Invalid GitHub candidate workflow response.");
+  const candidates = [];
+  for (const run of result.workflow_runs.slice(0, 10)) {
+    if (run.status !== "completed" || run.conclusion !== "success" || run.path !== ".github/workflows/candidate.yml" || !positive(run.id) || !positive(run.run_number) || !Number.isFinite(Date.parse(run.created_at))) continue;
+    const batch = await api(`actions/runs/${run.id}/artifacts?per_page=100`);
+    if (!Array.isArray(batch.artifacts)) throw new Error("Invalid GitHub artifact response.");
+    for (const a of batch.artifacts) {
+      const match = /^boo-(intel|amd|nvidia)-candidate-([a-f0-9]{40})$/.exec(a.name);
+      if (!match || a.expired !== false || !(Date.parse(a.expires_at) > Date.now()) || !positive(a.id) || !positive(a.size_in_bytes) || !/^sha256:[a-f0-9]{64}$/.test(a.digest) || batch.artifacts.filter((other) => other.name === a.name).length !== 1) continue;
+      candidates.push({
+        run: run.id,
+        revision: match[2],
+        images: [{
+          profile: match[1],
+          id: a.id,
+          name: a.name,
+          bytes: a.size_in_bytes,
+          digest: a.digest.slice(7)
+        }],
+        candidate: { number: run.run_number, date: new Date(run.created_at).toISOString().slice(0, 10), title: cleanText(run.display_title ?? "") }
+      });
+      if (candidates.length === 10) return candidates;
+    }
+  }
+  return candidates;
+}
+var FlashBackend = class {
+  constructor(demo2) {
+    this.demo = demo2;
+  }
+  demo;
+  demoInstalled = false;
+  requirePlatform() {
+    if (process.platform === "darwin") return platform;
+    if (process.platform === "linux") return platform2;
+    throw new Error("Boo Flash supports macOS and Linux. Use --demo for a non-writing preview.");
+  }
+  get platformLabel() {
+    return this.demo ? "DEMO - no disks written" : this.requirePlatform().label;
+  }
+  get successTitle() {
+    return this.demo ? "Demo complete" : this.requirePlatform().successTitle;
+  }
+  get successDetail() {
+    return this.demo ? "Simulated success only. No USB was written or ejected." : this.requirePlatform().successDetail;
+  }
+  async clearCache(signal) {
+    if (this.demo) return "Demo only: no cached images or USB contents were changed.";
+    return clearCachedImages(signal);
+  }
+  dependencies(includeGitHub = false) {
+    if (!this.demo) return this.requirePlatform().dependencies(includeGitHub);
+    const setup = this.demo.startsWith("setup") || this.demo === "no-homebrew";
+    return {
+      missing: !setup || this.demoInstalled ? [] : this.demo === "setup-gh" ? includeGitHub ? ["gh"] : [] : this.demo === "setup-zstd" ? ["zstd"] : includeGitHub ? ["gh", "zstd"] : ["zstd"],
+      installer: this.demo === "no-homebrew" ? null : "Homebrew",
+      guidance: "Demo dependency guidance."
+    };
+  }
+  async installDependencies(approved, signal, terminal) {
+    if (!this.demo) {
+      return terminal(() => this.requirePlatform().installDependencies(approved, signal));
+    }
+    await delay(2e3, void 0, { signal });
+    return terminal(async () => {
+      process.stdout.write("\nDEMO dependency setup: no software is installed.\nSimulating Homebrew terminal handoff. Ctrl-C cancels and quits.\n");
+      await delay(3e3);
+      if (this.demo === "setup-interrupted") process.stdout.write("Simulated Homebrew interruption result, without signaling Boo Flash. Quitting.\n");
+      if (signal.aborted || this.demo === "setup-interrupted") return "cancelled";
+      if (this.demo === "setup-error") throw new Error("Simulated Homebrew failure. No software was installed. Resolve the reported issue, then refresh to retry.");
+      this.demoInstalled = true;
+      return "installed";
+    });
+  }
+  async catalog(signal) {
+    if (!this.demo) return discoverImages(signal);
+    await delay(350, void 0, { signal });
+    return { run: 149, version: "0.1.0+149", revision: "9b7574859120add5a1a478bc7923aeb1629be4ba", images: profiles.map((profile, index) => ({
+      profile,
+      id: index,
+      name: `demo-${profile}`,
+      bytes: 1083197973,
+      digest: "demo"
+    })) };
+  }
+  async candidates(signal) {
+    if (!this.demo) return discoverCandidates(signal);
+    const catalog = await this.catalog(signal);
+    return this.demo === "empty" ? [] : [{
+      ...catalog,
+      images: [catalog.images[0]],
+      candidate: { number: 1, date: "2026-08-28", title: "Simulated candidate" }
+    }];
+  }
+  async disks(signal, staging = tmpdir4(), unmounted) {
+    if (this.demo) {
+      await delay(250, void 0, { signal });
+      return this.demo === "empty" ? [] : [
+        { id: "demo-usb-a", name: "SanDisk Ultra USB 3.0", bytes: 32 * 1024 ** 3, identity: "demo-a" },
+        { id: "demo-usb-b", name: "Kingston DataTraveler", bytes: 64 * 1024 ** 3, identity: "demo-b" }
+      ];
+    }
+    if (process.getuid?.() === 0) throw new Error(`Run Boo Flash on ${this.requirePlatform().id === "macos" ? "macOS" : "Linux"} as your normal user, not with sudo.`);
+    return this.requirePlatform().disks(signal, moduleDirectory, staging, unmounted);
+  }
+  async flash(catalog, image, disk, signal, update, authorize2) {
+    if (this.demo) {
+      if (!disk.id.startsWith("demo-") || image.digest !== "demo") throw new Error("Invalid demo selection.");
+      for (const stage of ["Downloading", "Verifying", "Unmounting", "Writing", "Flushing", "Ejecting"]) {
+        const total = stage === "Downloading" ? image.bytes : stage === "Writing" ? 8 * 1024 ** 3 : void 0;
+        for (let i = 0; i <= (total ? 30 : 5); i++) {
+          signal.throwIfAborted();
+          update({
+            stage,
+            detail: "Simulated activity. No disk commands are run.",
+            total,
+            bytes: total ? Math.round(total * i / 30) : void 0,
+            speed: total ? total / 3 : void 0
+          });
+          await delay(100, void 0, { signal });
+          if (this.demo === "error" && stage === "Writing" && i === 13) throw new Error("Demo write failure. No disks were written or ejected. Refresh to choose again.");
+        }
+      }
+      return;
+    }
+    const platform3 = this.requirePlatform();
+    if (process.getuid?.() === 0) throw new Error(`Run Boo Flash on ${platform3.id === "macos" ? "macOS" : "Linux"} as your normal user, not with sudo.`);
+    if (!diskID3.test(disk.id) || !catalog.images.includes(image) || !profiles.includes(image.profile) || !positive(image.id) || !positive(image.bytes) || !sha256.test(image.digest)) throw new Error("Invalid flash selection.");
+    if (catalog.candidate) {
+      if (!positive(catalog.run) || !/^[a-f0-9]{40}$/.test(catalog.revision) || image.cacheKind || image.name !== `boo-${image.profile}-candidate-${catalog.revision}`) throw new Error("Invalid candidate selection.");
+      const artifact = JSON.parse(await command(["gh", "api", "--hostname", "github.com", `repos/${repository}/actions/artifacts/${image.id}`], signal));
+      if (artifact.id !== image.id || artifact.name !== image.name || artifact.workflow_run?.id !== catalog.run || artifact.expired !== false || !(Date.parse(artifact.expires_at) > Date.now()) || artifact.size_in_bytes !== image.bytes || artifact.digest !== `sha256:${image.digest}`) {
+        throw new Error("Selected candidate artifact changed or expired. Refresh Candidates. No disk was written.");
+      }
+    } else {
+      const build = Number(catalog.version?.slice(catalog.version.lastIndexOf("+") + 1));
+      const name2 = `boo-${catalog.version}-x86_64-${image.profile}.raw.zst`;
+      if (!releaseVersion.test(catalog.version ?? "") || !positive(build) || catalog.run !== build || image.id !== build || !/^[a-f0-9]{40}$/.test(catalog.revision) || image.name !== name2 || image.cacheKind !== "raw.zst" || image.url !== `${releaseOrigin}/releases/${catalog.version}/${name2}` || !positive(image.rawBytes) || !sha256.test(image.rawDigest ?? "")) throw new Error("Invalid Boo release selection.");
+    }
+    const staging = await mkdtemp(join5(tmpdir4(), "boo-flash-"));
+    const payload = join5(staging, catalog.candidate ? "image.zip" : "image.raw.zst");
+    let unretained = false;
+    let destructive = false;
+    try {
+      await chmod2(staging, 448);
+      let count = 0;
+      if (!await reuseArchive(image, payload, signal, (count2) => update({
+        stage: "Using cached image",
+        detail: `Verifying cached ${catalog.candidate ? "GitHub ZIP" : `Boo ${catalog.version} image`} size and SHA-256; no download.`,
+        bytes: count2,
+        total: image.bytes
+      }))) {
+        const payloadFile = await open2(payload, "wx", 384);
+        const payloadHash = createHash2("sha256");
+        const started = performance.now();
+        const detail = catalog.candidate ? "Selected candidate artifact only; authenticated with GitHub." : `Boo ${catalog.version} from images.os.boo.`;
+        update({ stage: "Downloading", detail, bytes: 0, total: image.bytes });
+        try {
+          const argv = catalog.candidate ? ["gh", "api", "--hostname", "github.com", `repos/${repository}/actions/artifacts/${image.id}/zip`] : ["curl", "--fail", "--silent", "--show-error", "--proto", "=https", image.url];
+          await command(argv, signal, {
+            limit: image.bytes,
+            consume: async (chunk) => {
+              payloadHash.update(chunk);
+              await payloadFile.writeFile(chunk);
+              count += chunk.length;
+              update({
+                stage: "Downloading",
+                detail,
+                bytes: count,
+                total: image.bytes,
+                speed: count / Math.max(1e-3, (performance.now() - started) / 1e3)
+              });
+            }
+          });
+        } finally {
+          await payloadFile.close();
+        }
+        if (count !== image.bytes || payloadHash.digest("hex") !== image.digest) {
+          throw new Error(`${catalog.candidate ? "GitHub ZIP" : "Release image"} size or SHA-256 mismatch. No disk was written.`);
+        }
+        unretained = true;
+        await publishArchive(image, payload, signal);
+        unretained = false;
+      }
+      signal.throwIfAborted();
+      let compressed = payload;
+      let rawBytes = image.rawBytes;
+      let rawDigest = image.rawDigest;
+      if (catalog.candidate) {
+        update({ stage: "Verifying", detail: "Checking GitHub ZIP digest, build identity and image checksums." });
+        const names = (await command(["unzip", "-Z1", payload], signal)).trim().split("\n");
+        for (const name2 of ["build-info.json", "SHA256SUMS", "SHA256SUMS.raw"]) {
+          if (names.filter((n) => n === name2).length !== 1) throw new Error(`Archive is missing a unique ${name2}.`);
+        }
+        const extractText = (name2) => command(["unzip", "-p", payload, name2], signal, { limit: 1024 ** 2 });
+        const metadata = JSON.parse(await extractText("build-info.json"));
+        const basename2 = `boo-${image.profile}-x86_64.raw.zst`;
+        if (metadata.semantic_version !== void 0 && (!semanticVersion.test(metadata.semantic_version) || metadata.build_number !== null || metadata.version !== metadata.semantic_version)) {
+          throw new Error("Build metadata has an invalid candidate image version.");
+        }
+        if (metadata.image !== basename2 || names.filter((name2) => name2 === basename2).length !== 1 || metadata.schema !== 1 || !repositoryIdentities.has(metadata.repository) || metadata.revision !== catalog.revision || metadata.variant !== image.profile || metadata.source_state !== "clean" || !positive(metadata.compressed_bytes) || metadata.compressed_bytes > image.bytes || !positive(metadata.raw_apparent_bytes) || !sha256.test(metadata.compressed_sha256) || !sha256.test(metadata.raw_sha256)) {
+          throw new Error("Build metadata does not match the selected candidate.");
+        }
+        if (metadata.candidate?.resolved_sha !== catalog.revision || metadata.candidate?.profile !== image.profile || metadata.candidate?.qualification !== "build-only" || typeof metadata.candidate?.source_ref !== "string" || !metadata.candidate.source_ref.trim()) {
+          throw new Error("Candidate source metadata does not match the selected artifact.");
+        }
+        if ((await extractText("SHA256SUMS")).trim() !== `${metadata.compressed_sha256}  ${basename2}` || (await extractText("SHA256SUMS.raw")).trim() !== `${metadata.raw_sha256}  ${basename2.slice(0, -4)}`) {
+          throw new Error("Image checksum manifests disagree with build metadata.");
+        }
+        compressed = join5(staging, basename2);
+        const file = await open2(compressed, "wx", 384);
+        const hash = createHash2("sha256");
+        count = 0;
+        try {
+          await command(["unzip", "-p", payload, basename2], signal, {
+            limit: metadata.compressed_bytes,
+            consume: async (chunk) => {
+              hash.update(chunk);
+              await file.writeFile(chunk);
+              count += chunk.length;
+              update({ stage: "Verifying", detail: "Extracting only the selected image; checking compressed SHA-256.", bytes: count, total: metadata.compressed_bytes });
+            }
+          });
+        } finally {
+          await file.close();
+        }
+        if (count !== metadata.compressed_bytes || hash.digest("hex") !== metadata.compressed_sha256) throw new Error("Compressed image size or SHA-256 mismatch.");
+        rawBytes = metadata.raw_apparent_bytes;
+        rawDigest = metadata.raw_sha256;
+      } else {
+        update({ stage: "Verifying", detail: `Boo ${catalog.version} release metadata and compressed SHA-256 verified.` });
+      }
+      if (!positive(rawBytes) || !sha256.test(rawDigest ?? "")) throw new Error("Image raw-stream metadata is invalid.");
+      if (rawBytes > disk.bytes) throw new Error(`Image needs ${bytes(rawBytes)}; the selected USB is too small.`);
+      const revalidate = async (unmounted = false) => {
+        const current = (await this.disks(signal, staging, unmounted ? disk.id : void 0)).find((d) => d.id === disk.id);
+        if (!current || current.identity !== disk.identity || current.bytes < rawBytes) {
+          throw new Error("USB identity, capacity or eligibility changed. Go back and select it again.");
+        }
+      };
+      update({ stage: "Authorizing", detail: platform3.authorizationDetail });
+      await authorize2();
+      await revalidate();
+      update({ stage: "Unmounting", detail: "Unmounting every volume on the USB, without force." });
+      await platform3.unmount(disk, signal);
+      await revalidate(true);
+      signal.throwIfAborted();
+      update({ stage: "Writing", detail: "Opening the raw USB device.", bytes: 0, total: rawBytes });
+      const writer = platform3.writer(disk);
+      destructive = true;
+      const stopWriter = writer.stop;
+      signal.addEventListener("abort", stopWriter, { once: true });
+      const rawHash = createHash2("sha256");
+      let written = 0;
+      const writeStarted = performance.now();
+      try {
+        await command(["zstd", "-dc", "--", compressed], signal, {
+          limit: rawBytes,
+          consume: async (chunk) => {
+            await new Promise((resolve, reject) => writer.stdin.write(chunk, (error) => error ? reject(error) : resolve()));
+            rawHash.update(chunk);
+            written += chunk.length;
+            update({
+              stage: "Writing",
+              detail: "Raw bytes delivered to dd; device flush follows.",
+              bytes: written,
+              total: rawBytes,
+              speed: written / Math.max(1e-3, (performance.now() - writeStarted) / 1e3)
+            });
+          }
+        });
+        writer.stdin.end();
+        update({ stage: "Flushing", detail: "Waiting for dd to close the raw device." });
+        if (await writer.done !== 0) throw new Error(`USB write failed. ${cleanText(writer.error())}`);
+        signal.throwIfAborted();
+        if (written !== rawBytes || rawHash.digest("hex") !== rawDigest) throw new Error("Raw stream length or SHA-256 mismatch. The USB is incomplete.");
+      } finally {
+        signal.removeEventListener("abort", stopWriter);
+        writer.stdin.destroy();
+        await writer.done;
+      }
+      update({ stage: "Flushing", detail: "Raw stream verified. Synchronizing pending writes (not a device read-back)." });
+      await platform3.flush(disk, signal);
+      await prepareSafeRemoval(platform3, disk, signal, authorize2, revalidate, update);
+      update({ stage: "Ejecting", detail: platform3.ejectDetail });
+      await platform3.eject(disk, signal);
+      signal.throwIfAborted();
+    } catch (error) {
+      const retained = unretained ? ` Verified download retained for manual recovery (not cached): ${payload.replace(/[\x00-\x1f\x7f-\x9f]/g, " ")}` : "";
+      if (signal.aborted) throw new Error((destructive ? `Cancelled. The writer has stopped; ${platform3.incompleteDetail}` : "Cancelled. No image was written; no safe-removal claim is made.") + retained);
+      throw new Error(`${cleanText(error instanceof Error ? error.message : error)}${destructive ? ` ${platform3.incompleteDetail}` : ""}${retained}`);
+    } finally {
+      if (!unretained) await rm(staging, { recursive: true, force: true });
+    }
+  }
+  async authorize(signal) {
+    if (this.demo) return;
+    if (process.getuid?.() === 0) throw new Error("Run Boo Flash as your normal user, not with sudo.");
+    await this.requirePlatform().authorize(signal);
+  }
+};
+
+// src/App.tsx
+function App(props) {
+  const renderer = useRenderer();
+  const dimensions = useTerminalDimensions();
+  const [screen, setScreen] = createSignal4("profile");
+  const [catalog, setCatalog] = createSignal4();
+  const [candidates, setCandidates] = createSignal4([]);
+  const [image, setImage] = createSignal4();
+  const [disks3, setDisks] = createSignal4([]);
+  const [disk, setDisk] = createSignal4();
+  const [cursor, setCursor] = createSignal4(0);
+  const [loading, setLoading] = createSignal4(true);
+  const [stopping, setStopping] = createSignal4(false);
+  const [error, setError] = createSignal4("");
+  const [notice, setNotice] = createSignal4("");
+  const [dependencies3, setDependencies] = createSignal4({
+    missing: [],
+    installer: null,
+    guidance: ""
+  });
+  const [setupCandidates, setSetupCandidates] = createSignal4(false);
+  const [progress, setProgress] = createSignal4({
+    stage: "Preparing",
+    detail: ""
+  });
+  const [frame, setFrame] = createSignal4(0);
+  let controller = new AbortController();
+  let pending = Promise.resolve();
+  let closing = false;
+  const spin = {
+    value: 0
+  };
+  const timeline = useTimeline({
+    duration: 800,
+    loop: true
+  });
+  timeline.add(spin, {
+    value: 4,
+    duration: 800,
+    onUpdate: () => setFrame(Math.floor(spin.value) % 4)
+  });
+  const spinner = () => ["|", "/", "-", "\\"][frame()];
+  const busy = () => loading() || screen() === "busy";
+  const compact = () => dimensions().height < 24;
+  const tight = () => dimensions().height < 20;
+  const visible = () => dimensions().width >= 40 && dimensions().height >= 16;
+  const options = () => screen() === "profile" ? 5 : screen() === "cleared" ? 1 : screen() === "candidates" ? Math.max(1, candidates().length) : screen() === "disks" ? disks3().length : 2;
+  const percent = () => progress().total ? Math.min(100, Math.floor((progress().bytes ?? 0) / progress().total * 100)) : void 0;
+  const path = (d) => props.backend.demo ? d.id : `/dev/${d.id}`;
+  const operation = (work) => {
+    controller = new AbortController();
+    setStopping(false);
+    setLoading(true);
+    pending = (async () => {
+      try {
+        await work(controller.signal);
+      } catch (e) {
+        if (!closing) {
+          const setup = screen() === "installing";
+          setError(controller.signal.aborted && setup ? "Setup cancelled. Refresh to check what is still missing." : controller.signal.aborted && props.backend.demo ? "Demo cancelled. No disks were written or ejected." : e instanceof Error ? e.message : "Operation failed. Refresh and try again.");
+          if (setup) setDependencies(props.backend.dependencies(setupCandidates()));
+          setScreen(setup ? "setup" : "error");
+          setCursor(0);
+        }
+      } finally {
+        setLoading(false);
+        setStopping(false);
+      }
+    })();
+  };
+  const loadCatalog = async (signal) => {
+    setSetupCandidates(false);
+    const state = props.backend.dependencies();
+    setDependencies(state);
+    if (state.missing.length) {
+      setScreen("setup");
+      return;
+    }
+    setScreen("profile");
+    setCatalog(await props.backend.catalog(signal));
+  };
+  const refresh = () => {
+    setError("");
+    setCatalog(void 0);
+    setDisk(void 0);
+    setScreen("profile");
+    setCursor(0);
+    operation(loadCatalog);
+  };
+  const loadCandidates = () => {
+    setSetupCandidates(true);
+    setCandidates([]);
+    setCursor(0);
+    setScreen("candidates");
+    operation(async (signal) => {
+      const state = props.backend.dependencies(true);
+      if (state.missing.length) {
+        setDependencies(state);
+        setScreen("setup");
+        return;
+      }
+      setCandidates(await props.backend.candidates(signal));
+    });
+  };
+  const chooseUSB = () => {
+    setDisk(void 0);
+    setCursor(-1);
+    setScreen("disks");
+    operation(async (signal) => {
+      const state = props.backend.dependencies();
+      if (state.missing.length) {
+        setDependencies(state);
+        setCatalog(void 0);
+        setScreen("setup");
+        setCursor(0);
+        return;
+      }
+      setDisks(await props.backend.disks(signal));
+    });
+  };
+  const stop = async () => {
+    closing = true;
+    if (busy()) setStopping(true);
+    controller.abort();
+    await pending;
+  };
+  props.registerStop(stop);
+  onMount2(refresh);
+  const activate = () => {
+    if (busy() || !visible()) return;
+    if (screen() === "setup") {
+      if (cursor() === 0) {
+        setScreen("profile");
+        return;
+      }
+      if (!dependencies3().installer) {
+        refresh();
+        return;
+      }
+      const approved = [...dependencies3().missing];
+      setError("");
+      setScreen("installing");
+      operation(async (signal) => {
+        const result = await props.backend.installDependencies(approved, signal, async (work) => {
+          renderer.suspend();
+          try {
+            const result2 = await work();
+            if (result2 === "cancelled") props.quit();
+            return result2;
+          } finally {
+            if (!closing) renderer.resume();
+          }
+        });
+        if (result === "cancelled") return;
+        signal.throwIfAborted();
+        setCursor(0);
+        if (setupCandidates()) {
+          setCandidates(await props.backend.candidates(signal));
+          setScreen("candidates");
+        } else await loadCatalog(signal);
+      });
+    } else if (screen() === "profile" && cursor() === 3) {
+      loadCandidates();
+    } else if (screen() === "profile" && cursor() === 4) {
+      setScreen("clear");
+      setCursor(0);
+    } else if (screen() === "clear") {
+      if (cursor() === 0) {
+        setScreen("profile");
+        setCursor(4);
+        return;
+      }
+      operation(async (signal) => {
+        setNotice(await props.backend.clearCache(signal));
+        setScreen("cleared");
+        setCursor(0);
+      });
+    } else if (screen() === "cleared") {
+      setScreen("profile");
+      setCursor(4);
+    } else if (screen() === "candidates") {
+      const candidate = candidates()[cursor()];
+      if (!candidate) {
+        refresh();
+        return;
+      }
+      setCatalog(candidate);
+      setImage(candidate.images[0]);
+      chooseUSB();
+    } else if (screen() === "profile" && !catalog()) {
+      refresh();
+    } else if (screen() === "profile" && catalog()) {
+      setImage(catalog().images[cursor()]);
+      chooseUSB();
+    } else if (screen() === "disks" && disks3()[cursor()]) {
+      setDisk(disks3()[cursor()]);
+      setCursor(0);
+      setScreen("confirm");
+    } else if (screen() === "confirm") {
+      if (cursor() === 0) {
+        chooseUSB();
+        return;
+      }
+      setScreen("busy");
+      setProgress({
+        stage: "Preparing",
+        detail: "Checking the selected image and USB."
+      });
+      operation(async (signal) => {
+        await props.backend.flash(catalog(), image(), disk(), signal, setProgress, async () => {
+          renderer.suspend();
+          try {
+            await props.backend.authorize(signal);
+          } finally {
+            renderer.resume();
+          }
+        });
+        signal.throwIfAborted();
+        setScreen("success");
+        setCursor(0);
+      });
+    } else if (screen() === "error" || screen() === "success") {
+      if (cursor() === 0) refresh();
+      else props.quit();
+    }
+  };
+  useKeyboard((key) => {
+    if (key.eventType === "release") return;
+    if (key.name === "q" || key.ctrl && key.name === "c") {
+      props.quit();
+      return;
+    }
+    if (key.name === "escape") {
+      if (busy()) {
+        setStopping(true);
+        controller.abort();
+        return;
+      }
+      if (screen() === "confirm") chooseUSB();
+      else if (screen() === "clear" || screen() === "cleared") {
+        setScreen("profile");
+        setCursor(4);
+      } else if (screen() === "setup") {
+        setScreen("profile");
+        setCursor(0);
+      } else refresh();
+      return;
+    }
+    if (busy() || !visible()) return;
+    if (key.name === "r") {
+      screen() === "disks" ? chooseUSB() : screen() === "candidates" ? loadCandidates() : refresh();
+      return;
+    }
+    if (["down", "right", "tab"].includes(key.name)) setCursor((n) => Math.min(options() - 1, n + 1));
+    if (["up", "left"].includes(key.name)) setCursor((n) => Math.max(0, n - 1));
+    if (key.name === "return" && !key.repeated) activate();
+  });
+  const row = (label, detail, index, danger = false) => (() => {
+    var _el$ = createElement("box"), _el$2 = createElement("text");
+    insertNode(_el$, _el$2);
+    setProp(_el$, "paddingX", 1);
+    setProp(_el$, "flexShrink", 0);
+    setProp(_el$2, "wrapMode", "none");
+    insert(_el$2, () => cursor() === index ? "> " : "  ", null);
+    insert(_el$2, label, null);
+    insert(_el$, createComponent2(Show, {
+      get when() {
+        return detail && !tight();
+      },
+      get children() {
+        var _el$3 = createElement("text"), _el$4 = createTextNode(` `);
+        insertNode(_el$3, _el$4);
+        setProp(_el$3, "wrapMode", "none");
+        insert(_el$3, detail, null);
+        effect((_$p) => setProp(_el$3, "fg", palette.muted, _$p));
+        return _el$3;
+      }
+    }), null);
+    effect((_p$) => {
+      var _v$ = detail && !tight() ? compact() ? 2 : 3 : 1, _v$2 = cursor() === index ? palette.selected : palette.panel, _v$3 = danger ? palette.warning : cursor() === index ? palette.accent : palette.foreground, _v$4 = TextAttributes2.BOLD;
+      _v$ !== _p$.e && (_p$.e = setProp(_el$, "height", _v$, _p$.e));
+      _v$2 !== _p$.t && (_p$.t = setProp(_el$, "backgroundColor", _v$2, _p$.t));
+      _v$3 !== _p$.a && (_p$.a = setProp(_el$2, "fg", _v$3, _p$.a));
+      _v$4 !== _p$.o && (_p$.o = setProp(_el$2, "attributes", _v$4, _p$.o));
+      return _p$;
+    }, {
+      e: void 0,
+      t: void 0,
+      a: void 0,
+      o: void 0
+    });
+    return _el$;
+  })();
+  return (() => {
+    var _el$5 = createElement("box"), _el$6 = createElement("box"), _el$7 = createElement("box"), _el$8 = createElement("text"), _el$0 = createElement("text"), _el$1 = createElement("box"), _el$10 = createElement("box"), _el$88 = createElement("text");
+    insertNode(_el$5, _el$6);
+    setProp(_el$5, "width", "100%");
+    setProp(_el$5, "height", "100%");
+    setProp(_el$5, "justifyContent", "center");
+    setProp(_el$5, "alignItems", "center");
+    insertNode(_el$6, _el$7);
+    insertNode(_el$6, _el$1);
+    insertNode(_el$6, _el$10);
+    insertNode(_el$6, _el$88);
+    setProp(_el$6, "border", true);
+    setProp(_el$6, "borderStyle", "single");
+    setProp(_el$6, "flexDirection", "column");
+    setProp(_el$6, "paddingX", 1);
+    insertNode(_el$7, _el$8);
+    insertNode(_el$7, _el$0);
+    setProp(_el$7, "height", 1);
+    setProp(_el$7, "flexDirection", "row");
+    setProp(_el$7, "justifyContent", "space-between");
+    setProp(_el$7, "flexShrink", 0);
+    insertNode(_el$8, createTextNode(`BOO FLASH`));
+    insert(_el$0, () => props.backend.platformLabel);
+    setProp(_el$1, "height", 1);
+    setProp(_el$1, "flexShrink", 0);
+    setProp(_el$10, "flexGrow", 1);
+    setProp(_el$10, "minHeight", 0);
+    setProp(_el$10, "overflow", "hidden");
+    insert(_el$10, createComponent2(Show, {
+      get when() {
+        return visible();
+      },
+      get fallback() {
+        return (() => {
+          var _el$89 = createElement("text");
+          insertNode(_el$89, createTextNode(`Enlarge the terminal to show the full choices and erase warning. Q quits.`));
+          effect((_$p) => setProp(_el$89, "fg", palette.warning, _$p));
+          return _el$89;
+        })();
+      },
+      get children() {
+        return [createComponent2(Show, {
+          get when() {
+            return screen() === "profile";
+          },
+          get children() {
+            return [(() => {
+              var _el$11 = createElement("text");
+              insertNode(_el$11, createTextNode(`Choose the target computer's GPU`));
+              effect((_p$) => {
+                var _v$5 = palette.foreground, _v$6 = TextAttributes2.BOLD;
+                _v$5 !== _p$.e && (_p$.e = setProp(_el$11, "fg", _v$5, _p$.e));
+                _v$6 !== _p$.t && (_p$.t = setProp(_el$11, "attributes", _v$6, _p$.t));
+                return _p$;
+              }, {
+                e: void 0,
+                t: void 0
+              });
+              return _el$11;
+            })(), (() => {
+              var _el$13 = createElement("text");
+              insert(_el$13, (() => {
+                var _c$ = memo2(() => !!loading());
+                return () => _c$() ? `${spinner()} Finding latest Boo release...` : memo2(() => !!catalog())() ? `Boo ${catalog().version} / ${catalog().revision.slice(0, 7)}` : "Dependencies needed. Enter to set up.";
+              })());
+              effect((_$p) => setProp(_el$13, "fg", palette.muted, _$p));
+              return _el$13;
+            })(), (() => {
+              var _el$14 = createElement("box");
+              setProp(_el$14, "gap", 0);
+              insert(_el$14, createComponent2(For2, {
+                each: profiles,
+                children: (profile, index) => row(profile.toUpperCase(), profile === "nvidia" ? "NVIDIA graphics" : `${profile === "intel" ? "Intel" : "AMD Radeon"} graphics`, index())
+              }), null);
+              insert(_el$14, () => row("Candidates", "", 3), null);
+              insert(_el$14, () => row("Clear cached images", "", 4), null);
+              return _el$14;
+            })(), (() => {
+              var _el$15 = createElement("text");
+              insertNode(_el$15, createTextNode(`All images support Intel and AMD x86_64 CPUs.`));
+              effect((_$p) => setProp(_el$15, "fg", palette.muted, _$p));
+              return _el$15;
+            })()];
+          }
+        }), createComponent2(Show, {
+          get when() {
+            return screen() === "clear";
+          },
+          get children() {
+            return [(() => {
+              var _el$17 = createElement("text");
+              insertNode(_el$17, createTextNode(`Clear cached images?`));
+              effect((_p$) => {
+                var _v$7 = palette.warning, _v$8 = TextAttributes2.BOLD;
+                _v$7 !== _p$.e && (_p$.e = setProp(_el$17, "fg", _v$7, _p$.e));
+                _v$8 !== _p$.t && (_p$.t = setProp(_el$17, "attributes", _v$8, _p$.t));
+                return _p$;
+              }, {
+                e: void 0,
+                t: void 0
+              });
+              return _el$17;
+            })(), (() => {
+              var _el$19 = createElement("text");
+              insertNode(_el$19, createTextNode(`Removes downloaded archives only, NOT USB contents. Active flashes are unaffected.`));
+              effect((_$p) => setProp(_el$19, "fg", palette.foreground, _$p));
+              return _el$19;
+            })(), (() => {
+              var _el$21 = createElement("text");
+              insertNode(_el$21, createTextNode(`Images will download again when needed. Pending downloads may still finish and be cached.`));
+              effect((_$p) => setProp(_el$21, "fg", palette.muted, _$p));
+              return _el$21;
+            })(), (() => {
+              var _el$23 = createElement("box");
+              insert(_el$23, () => row("Go back", "", 0), null);
+              insert(_el$23, () => row(loading() ? "Clearing..." : "Clear cached images", "", 1, true), null);
+              effect((_$p) => setProp(_el$23, "gap", tight() ? 0 : 1, _$p));
+              return _el$23;
+            })()];
+          }
+        }), createComponent2(Show, {
+          get when() {
+            return screen() === "cleared";
+          },
+          get children() {
+            return [(() => {
+              var _el$24 = createElement("text");
+              insertNode(_el$24, createTextNode(`Cache cleared`));
+              effect((_p$) => {
+                var _v$9 = palette.success, _v$0 = TextAttributes2.BOLD;
+                _v$9 !== _p$.e && (_p$.e = setProp(_el$24, "fg", _v$9, _p$.e));
+                _v$0 !== _p$.t && (_p$.t = setProp(_el$24, "attributes", _v$0, _p$.t));
+                return _p$;
+              }, {
+                e: void 0,
+                t: void 0
+              });
+              return _el$24;
+            })(), (() => {
+              var _el$26 = createElement("text");
+              insert(_el$26, notice);
+              effect((_$p) => setProp(_el$26, "fg", palette.foreground, _$p));
+              return _el$26;
+            })(), memo2(() => row("Go back", "", 0))];
+          }
+        }), createComponent2(Show, {
+          get when() {
+            return screen() === "candidates";
+          },
+          get children() {
+            return [(() => {
+              var _el$27 = createElement("text");
+              insertNode(_el$27, createTextNode(`Candidates`));
+              effect((_p$) => {
+                var _v$1 = palette.foreground, _v$10 = TextAttributes2.BOLD;
+                _v$1 !== _p$.e && (_p$.e = setProp(_el$27, "fg", _v$1, _p$.e));
+                _v$10 !== _p$.t && (_p$.t = setProp(_el$27, "attributes", _v$10, _p$.t));
+                return _p$;
+              }, {
+                e: void 0,
+                t: void 0
+              });
+              return _el$27;
+            })(), (() => {
+              var _el$29 = createElement("text");
+              insertNode(_el$29, createTextNode(`Build-only; not boot/install/hardware qualified.`));
+              effect((_$p) => setProp(_el$29, "fg", palette.warning, _$p));
+              return _el$29;
+            })(), createComponent2(Show, {
+              get when() {
+                return !loading();
+              },
+              get fallback() {
+                return (() => {
+                  var _el$91 = createElement("text"), _el$92 = createTextNode(` Finding completed candidates...`);
+                  insertNode(_el$91, _el$92);
+                  insert(_el$91, spinner, _el$92);
+                  effect((_$p) => setProp(_el$91, "fg", palette.muted, _$p));
+                  return _el$91;
+                })();
+              },
+              get children() {
+                return createComponent2(Show, {
+                  get when() {
+                    return candidates().length;
+                  },
+                  get fallback() {
+                    return [(() => {
+                      var _el$93 = createElement("text");
+                      insertNode(_el$93, createTextNode(`No completed candidates available`));
+                      effect((_$p) => setProp(_el$93, "fg", palette.muted, _$p));
+                      return _el$93;
+                    })(), memo2(() => row("Go back", "", 0))];
+                  },
+                  get children() {
+                    return [(() => {
+                      var _el$31 = createElement("box");
+                      setProp(_el$31, "gap", 0);
+                      insert(_el$31, createComponent2(For2, {
+                        get each() {
+                          return candidates().slice(Math.max(0, cursor() - 2), Math.max(3, cursor() + 1));
+                        },
+                        children: (c, index) => row(`${c.images[0].profile.toUpperCase()} ${c.revision.slice(0, 7)} #${c.candidate.number} ${c.candidate.date}`, c.candidate.title, index() + Math.max(0, cursor() - 2))
+                      }));
+                      return _el$31;
+                    })(), (() => {
+                      var _el$32 = createElement("text"), _el$33 = createTextNode(` of `), _el$34 = createTextNode(` candidates / Enter to choose`);
+                      insertNode(_el$32, _el$33);
+                      insertNode(_el$32, _el$34);
+                      insert(_el$32, () => cursor() + 1, _el$33);
+                      insert(_el$32, () => candidates().length, _el$34);
+                      effect((_$p) => setProp(_el$32, "fg", palette.muted, _$p));
+                      return _el$32;
+                    })()];
+                  }
+                });
+              }
+            })];
+          }
+        }), createComponent2(Show, {
+          get when() {
+            return screen() === "setup";
+          },
+          get children() {
+            return [(() => {
+              var _el$35 = createElement("text");
+              insertNode(_el$35, createTextNode(`Set up required tools`));
+              effect((_p$) => {
+                var _v$11 = palette.accent, _v$12 = TextAttributes2.BOLD;
+                _v$11 !== _p$.e && (_p$.e = setProp(_el$35, "fg", _v$11, _p$.e));
+                _v$12 !== _p$.t && (_p$.t = setProp(_el$35, "attributes", _v$12, _p$.t));
+                return _p$;
+              }, {
+                e: void 0,
+                t: void 0
+              });
+              return _el$35;
+            })(), (() => {
+              var _el$37 = createElement("text"), _el$38 = createTextNode(`Missing: `);
+              insertNode(_el$37, _el$38);
+              insert(_el$37, () => dependencies3().missing.join(", "), null);
+              effect((_$p) => setProp(_el$37, "fg", palette.foreground, _$p));
+              return _el$37;
+            })(), createComponent2(Show, {
+              get when() {
+                return !error();
+              },
+              get fallback() {
+                return (() => {
+                  var _el$95 = createElement("text");
+                  insert(_el$95, error);
+                  effect((_$p) => setProp(_el$95, "fg", palette.warning, _$p));
+                  return _el$95;
+                })();
+              },
+              get children() {
+                var _el$39 = createElement("text");
+                insert(_el$39, (() => {
+                  var _c$2 = memo2(() => !!dependencies3().installer);
+                  return () => _c$2() ? `${dependencies3().installer} will install ${dependencies3().missing.join(" and ")} and required dependencies, then continue.` : dependencies3().guidance;
+                })());
+                effect((_$p) => setProp(_el$39, "fg", palette.muted, _$p));
+                return _el$39;
+              }
+            }), createComponent2(Show, {
+              get when() {
+                return !tight();
+              },
+              get children() {
+                var _el$40 = createElement("text");
+                insert(_el$40, () => dependencies3().installer ? "Uses the ordinary terminal. Ctrl-C cancels and quits." : "Boo Flash will not change system packages on this platform.");
+                effect((_$p) => setProp(_el$40, "fg", palette.muted, _$p));
+                return _el$40;
+              }
+            }), createComponent2(Show, {
+              get when() {
+                return props.backend.demo;
+              },
+              get children() {
+                var _el$41 = createElement("text");
+                insertNode(_el$41, createTextNode(`Setup simulation; no software installed.`));
+                effect((_$p) => setProp(_el$41, "fg", palette.warning, _$p));
+                return _el$41;
+              }
+            }), (() => {
+              var _el$43 = createElement("box");
+              insert(_el$43, () => row("Go back", "", 0), null);
+              insert(_el$43, () => row(dependencies3().installer ? `Install ${dependencies3().missing.join(" + ")}` : "Refresh", "", 1), null);
+              effect((_$p) => setProp(_el$43, "gap", tight() ? 0 : 1, _$p));
+              return _el$43;
+            })()];
+          }
+        }), createComponent2(Show, {
+          get when() {
+            return screen() === "installing";
+          },
+          get children() {
+            return [(() => {
+              var _el$44 = createElement("text"), _el$45 = createTextNode(` `);
+              insertNode(_el$44, _el$45);
+              insert(_el$44, spinner, _el$45);
+              insert(_el$44, () => stopping() ? "Waiting for setup to stop..." : "Installing required tools", null);
+              effect((_p$) => {
+                var _v$13 = palette.accent, _v$14 = TextAttributes2.BOLD;
+                _v$13 !== _p$.e && (_p$.e = setProp(_el$44, "fg", _v$13, _p$.e));
+                _v$14 !== _p$.t && (_p$.t = setProp(_el$44, "attributes", _v$14, _p$.t));
+                return _p$;
+              }, {
+                e: void 0,
+                t: void 0
+              });
+              return _el$44;
+            })(), (() => {
+              var _el$46 = createElement("text"), _el$47 = createTextNode(` via `);
+              insertNode(_el$46, _el$47);
+              insert(_el$46, () => dependencies3().missing.join(" + "), _el$47);
+              insert(_el$46, () => dependencies3().installer, null);
+              effect((_$p) => setProp(_el$46, "fg", palette.foreground, _$p));
+              return _el$46;
+            })(), (() => {
+              var _el$48 = createElement("text"), _el$49 = createTextNode(` uses the ordinary terminal. Ctrl-C cancels and quits; wait for cleanup.`);
+              insertNode(_el$48, _el$49);
+              insert(_el$48, () => dependencies3().installer, _el$49);
+              effect((_$p) => setProp(_el$48, "fg", palette.muted, _$p));
+              return _el$48;
+            })(), createComponent2(Show, {
+              get when() {
+                return props.backend.demo;
+              },
+              get children() {
+                var _el$50 = createElement("text");
+                insertNode(_el$50, createTextNode(`Setup simulation; no software installed.`));
+                effect((_$p) => setProp(_el$50, "fg", palette.warning, _$p));
+                return _el$50;
+              }
+            })];
+          }
+        }), createComponent2(Show, {
+          get when() {
+            return screen() === "disks";
+          },
+          get children() {
+            return [(() => {
+              var _el$52 = createElement("text");
+              insertNode(_el$52, createTextNode(`Choose a USB drive`));
+              effect((_p$) => {
+                var _v$15 = palette.foreground, _v$16 = TextAttributes2.BOLD;
+                _v$15 !== _p$.e && (_p$.e = setProp(_el$52, "fg", _v$15, _p$.e));
+                _v$16 !== _p$.t && (_p$.t = setProp(_el$52, "attributes", _v$16, _p$.t));
+                return _p$;
+              }, {
+                e: void 0,
+                t: void 0
+              });
+              return _el$52;
+            })(), (() => {
+              var _el$54 = createElement("text");
+              insert(_el$54, (() => {
+                var _c$3 = memo2(() => !!loading());
+                return () => _c$3() ? `${spinner()} Checking disks and protected storage...` : "System, home and app storage are excluded.";
+              })());
+              effect((_$p) => setProp(_el$54, "fg", palette.muted, _$p));
+              return _el$54;
+            })(), createComponent2(Show, {
+              get when() {
+                return !loading();
+              },
+              get children() {
+                return createComponent2(Show, {
+                  get when() {
+                    return disks3().length > 0;
+                  },
+                  get fallback() {
+                    return (() => {
+                      var _el$96 = createElement("text");
+                      insertNode(_el$96, createTextNode(`No eligible USB drives. Connect a writable external USB drive, then press R to refresh.`));
+                      effect((_$p) => setProp(_el$96, "fg", palette.warning, _$p));
+                      return _el$96;
+                    })();
+                  },
+                  get children() {
+                    return [(() => {
+                      var _el$55 = createElement("box");
+                      setProp(_el$55, "gap", 0);
+                      insert(_el$55, createComponent2(For2, {
+                        get each() {
+                          return disks3().slice(Math.max(0, cursor() - 2), Math.max(3, cursor() + 1));
+                        },
+                        children: (d, index) => row(d.name, `${path(d)}  /  ${bytes(d.bytes)}  /  USB`, index() + Math.max(0, cursor() - 2))
+                      }));
+                      return _el$55;
+                    })(), (() => {
+                      var _el$56 = createElement("text");
+                      insert(_el$56, (() => {
+                        var _c$4 = memo2(() => cursor() < 0);
+                        return () => _c$4() ? "Use arrows to select a drive. Nothing is selected yet." : `${cursor() + 1} of ${disks3().length} drives / Enter to review`;
+                      })());
+                      effect((_$p) => setProp(_el$56, "fg", palette.muted, _$p));
+                      return _el$56;
+                    })()];
+                  }
+                });
+              }
+            })];
+          }
+        }), createComponent2(Show, {
+          get when() {
+            return screen() === "confirm";
+          },
+          get children() {
+            return [(() => {
+              var _el$57 = createElement("text");
+              insertNode(_el$57, createTextNode(`Erase this entire USB drive?`));
+              effect((_p$) => {
+                var _v$17 = palette.warning, _v$18 = TextAttributes2.BOLD;
+                _v$17 !== _p$.e && (_p$.e = setProp(_el$57, "fg", _v$17, _p$.e));
+                _v$18 !== _p$.t && (_p$.t = setProp(_el$57, "attributes", _v$18, _p$.t));
+                return _p$;
+              }, {
+                e: void 0,
+                t: void 0
+              });
+              return _el$57;
+            })(), (() => {
+              var _el$59 = createElement("box"), _el$60 = createElement("text"), _el$61 = createElement("text"), _el$62 = createElement("text"), _el$63 = createTextNode(` / `);
+              insertNode(_el$59, _el$60);
+              insertNode(_el$59, _el$61);
+              insertNode(_el$59, _el$62);
+              setProp(_el$59, "paddingX", 1);
+              setProp(_el$60, "height", 1);
+              setProp(_el$60, "wrapMode", "none");
+              insert(_el$60, () => disk()?.name);
+              insert(_el$61, (() => {
+                var _c$5 = memo2(() => !!disk());
+                return () => _c$5() ? `${path(disk())}  /  ${bytes(disk().bytes)}` : "";
+              })());
+              insertNode(_el$62, _el$63);
+              insert(_el$62, () => image()?.profile.toUpperCase(), _el$63);
+              insert(_el$62, (() => {
+                var _c$6 = memo2(() => !!catalog()?.candidate);
+                return () => _c$6() ? `candidate (build-only) ${catalog()?.revision.slice(0, 7)}` : `Boo ${catalog()?.version}`;
+              })(), null);
+              effect((_p$) => {
+                var _v$19 = palette.panelAlt, _v$20 = palette.foreground, _v$21 = TextAttributes2.BOLD, _v$22 = palette.accent, _v$23 = catalog()?.candidate ? palette.warning : palette.muted;
+                _v$19 !== _p$.e && (_p$.e = setProp(_el$59, "backgroundColor", _v$19, _p$.e));
+                _v$20 !== _p$.t && (_p$.t = setProp(_el$60, "fg", _v$20, _p$.t));
+                _v$21 !== _p$.a && (_p$.a = setProp(_el$60, "attributes", _v$21, _p$.a));
+                _v$22 !== _p$.o && (_p$.o = setProp(_el$61, "fg", _v$22, _p$.o));
+                _v$23 !== _p$.i && (_p$.i = setProp(_el$62, "fg", _v$23, _p$.i));
+                return _p$;
+              }, {
+                e: void 0,
+                t: void 0,
+                a: void 0,
+                o: void 0,
+                i: void 0
+              });
+              return _el$59;
+            })(), (() => {
+              var _el$64 = createElement("text");
+              insertNode(_el$64, createTextNode(`ALL data and partitions on this drive will be lost. Back up anything you need before continuing.`));
+              effect((_$p) => setProp(_el$64, "fg", palette.warning, _$p));
+              return _el$64;
+            })(), (() => {
+              var _el$66 = createElement("box");
+              insert(_el$66, () => row("Go back", "", 0), null);
+              insert(_el$66, () => row("Erase & flash", "", 1, true), null);
+              effect((_$p) => setProp(_el$66, "gap", tight() ? 0 : 1, _$p));
+              return _el$66;
+            })()];
+          }
+        }), createComponent2(Show, {
+          get when() {
+            return screen() === "busy";
+          },
+          get children() {
+            return [(() => {
+              var _el$67 = createElement("text"), _el$68 = createTextNode(` `);
+              insertNode(_el$67, _el$68);
+              insert(_el$67, spinner, _el$68);
+              insert(_el$67, (() => {
+                var _c$7 = memo2(() => !!stopping());
+                return () => _c$7() ? "Stopping safely..." : progress().stage;
+              })(), null);
+              effect((_p$) => {
+                var _v$24 = palette.accent, _v$25 = TextAttributes2.BOLD;
+                _v$24 !== _p$.e && (_p$.e = setProp(_el$67, "fg", _v$24, _p$.e));
+                _v$25 !== _p$.t && (_p$.t = setProp(_el$67, "attributes", _v$25, _p$.t));
+                return _p$;
+              }, {
+                e: void 0,
+                t: void 0
+              });
+              return _el$67;
+            })(), (() => {
+              var _el$69 = createElement("text"), _el$70 = createTextNode(` / `);
+              insertNode(_el$69, _el$70);
+              insert(_el$69, () => disk()?.name, _el$70);
+              insert(_el$69, () => image()?.profile.toUpperCase(), null);
+              effect((_$p) => setProp(_el$69, "fg", palette.foreground, _$p));
+              return _el$69;
+            })(), (() => {
+              var _el$71 = createElement("text");
+              insert(_el$71, (() => {
+                var _c$8 = memo2(() => !!stopping());
+                return () => _c$8() ? "Waiting for all child processes to stop. Keep the USB connected." : progress().detail;
+              })());
+              effect((_$p) => setProp(_el$71, "fg", palette.muted, _$p));
+              return _el$71;
+            })(), createComponent2(Show, {
+              get when() {
+                return percent() !== void 0;
+              },
+              get children() {
+                return [(() => {
+                  var _el$72 = createElement("box");
+                  setProp(_el$72, "border", true);
+                  setProp(_el$72, "height", 3);
+                  insert(_el$72, createComponent2(Show, {
+                    get when() {
+                      return percent() > 0;
+                    },
+                    get children() {
+                      var _el$73 = createElement("box");
+                      setProp(_el$73, "height", 1);
+                      effect((_p$) => {
+                        var _v$26 = `${percent() ?? 0}%`, _v$27 = palette.accent;
+                        _v$26 !== _p$.e && (_p$.e = setProp(_el$73, "width", _v$26, _p$.e));
+                        _v$27 !== _p$.t && (_p$.t = setProp(_el$73, "backgroundColor", _v$27, _p$.t));
+                        return _p$;
+                      }, {
+                        e: void 0,
+                        t: void 0
+                      });
+                      return _el$73;
+                    }
+                  }));
+                  effect((_p$) => {
+                    var _v$28 = palette.accent, _v$29 = palette.panelAlt;
+                    _v$28 !== _p$.e && (_p$.e = setProp(_el$72, "borderColor", _v$28, _p$.e));
+                    _v$29 !== _p$.t && (_p$.t = setProp(_el$72, "backgroundColor", _v$29, _p$.t));
+                    return _p$;
+                  }, {
+                    e: void 0,
+                    t: void 0
+                  });
+                  return _el$72;
+                })(), (() => {
+                  var _el$74 = createElement("text"), _el$75 = createTextNode(`% `), _el$76 = createTextNode(` / `);
+                  insertNode(_el$74, _el$75);
+                  insertNode(_el$74, _el$76);
+                  insert(_el$74, percent, _el$75);
+                  insert(_el$74, () => bytes(progress().bytes ?? 0), _el$76);
+                  insert(_el$74, () => bytes(progress().total ?? 0), null);
+                  effect((_p$) => {
+                    var _v$30 = palette.foreground, _v$31 = TextAttributes2.BOLD;
+                    _v$30 !== _p$.e && (_p$.e = setProp(_el$74, "fg", _v$30, _p$.e));
+                    _v$31 !== _p$.t && (_p$.t = setProp(_el$74, "attributes", _v$31, _p$.t));
+                    return _p$;
+                  }, {
+                    e: void 0,
+                    t: void 0
+                  });
+                  return _el$74;
+                })(), (() => {
+                  var _el$77 = createElement("text");
+                  insert(_el$77, (() => {
+                    var _c$9 = memo2(() => !!progress().speed);
+                    return () => _c$9() ? `${bytes(progress().speed)} / s` : "";
+                  })());
+                  effect((_$p) => setProp(_el$77, "fg", palette.muted, _$p));
+                  return _el$77;
+                })()];
+              }
+            }), (() => {
+              var _el$78 = createElement("text");
+              insertNode(_el$78, createTextNode(`Keep the USB connected until safe removal succeeds.`));
+              effect((_$p) => setProp(_el$78, "fg", palette.warning, _$p));
+              return _el$78;
+            })()];
+          }
+        }), createComponent2(Show, {
+          get when() {
+            return screen() === "success";
+          },
+          get children() {
+            return [(() => {
+              var _el$80 = createElement("text");
+              insert(_el$80, () => props.backend.successTitle);
+              effect((_p$) => {
+                var _v$32 = palette.success, _v$33 = TextAttributes2.BOLD;
+                _v$32 !== _p$.e && (_p$.e = setProp(_el$80, "fg", _v$32, _p$.e));
+                _v$33 !== _p$.t && (_p$.t = setProp(_el$80, "attributes", _v$33, _p$.t));
+                return _p$;
+              }, {
+                e: void 0,
+                t: void 0
+              });
+              return _el$80;
+            })(), (() => {
+              var _el$81 = createElement("text");
+              insert(_el$81, () => props.backend.successDetail);
+              effect((_$p) => setProp(_el$81, "fg", palette.foreground, _$p));
+              return _el$81;
+            })(), (() => {
+              var _el$82 = createElement("text");
+              insert(_el$82, (() => {
+                var _c$0 = memo2(() => !!props.backend.demo);
+                return () => _c$0() ? "The real flow checks the write, flush and safe removal." : catalog()?.candidate ? "GitHub ZIP, compressed image and raw stream verified. Not a device read-back." : "Compressed image and raw stream verified. Not a device read-back.";
+              })());
+              effect((_$p) => setProp(_el$82, "fg", palette.muted, _$p));
+              return _el$82;
+            })(), (() => {
+              var _el$83 = createElement("box");
+              setProp(_el$83, "gap", 1);
+              insert(_el$83, () => row("Choose another image", "", 0), null);
+              insert(_el$83, () => row("Quit", "", 1), null);
+              return _el$83;
+            })()];
+          }
+        }), createComponent2(Show, {
+          get when() {
+            return screen() === "error";
+          },
+          get children() {
+            return [(() => {
+              var _el$84 = createElement("text");
+              insertNode(_el$84, createTextNode(`Flash not completed`));
+              effect((_p$) => {
+                var _v$34 = palette.danger, _v$35 = TextAttributes2.BOLD;
+                _v$34 !== _p$.e && (_p$.e = setProp(_el$84, "fg", _v$34, _p$.e));
+                _v$35 !== _p$.t && (_p$.t = setProp(_el$84, "attributes", _v$35, _p$.t));
+                return _p$;
+              }, {
+                e: void 0,
+                t: void 0
+              });
+              return _el$84;
+            })(), (() => {
+              var _el$86 = createElement("text");
+              insert(_el$86, error);
+              effect((_$p) => setProp(_el$86, "fg", palette.foreground, _$p));
+              return _el$86;
+            })(), (() => {
+              var _el$87 = createElement("box");
+              setProp(_el$87, "gap", 1);
+              insert(_el$87, () => row("Refresh & try again", "", 0), null);
+              insert(_el$87, () => row("Quit", "", 1), null);
+              return _el$87;
+            })()];
+          }
+        })];
+      }
+    }));
+    setProp(_el$88, "height", 1);
+    setProp(_el$88, "flexShrink", 0);
+    setProp(_el$88, "wrapMode", "none");
+    insert(_el$88, (() => {
+      var _c$1 = memo2(() => !!busy());
+      return () => _c$1() ? "Esc cancel / Q stop & quit" : dimensions().width < 56 ? "Arrows / Enter / Esc / R / Q quit" : "Arrows / Enter / Esc back / R refresh / Q quit";
+    })());
+    effect((_p$) => {
+      var _v$36 = palette.background, _v$37 = dimensions().width <= 80 ? "100%" : 80, _v$38 = dimensions().height <= 24 ? "100%" : 24, _v$39 = palette.border, _v$40 = palette.card, _v$41 = palette.accent, _v$42 = TextAttributes2.BOLD, _v$43 = props.backend.demo ? palette.warning : palette.muted, _v$44 = palette.danger, _v$45 = tight() ? 0 : 1, _v$46 = tight() ? 0 : 1, _v$47 = tight() || (compact() || dimensions().width < 56) && screen() === "setup" ? 0 : 1, _v$48 = palette.muted;
+      _v$36 !== _p$.e && (_p$.e = setProp(_el$5, "backgroundColor", _v$36, _p$.e));
+      _v$37 !== _p$.t && (_p$.t = setProp(_el$6, "width", _v$37, _p$.t));
+      _v$38 !== _p$.a && (_p$.a = setProp(_el$6, "height", _v$38, _p$.a));
+      _v$39 !== _p$.o && (_p$.o = setProp(_el$6, "borderColor", _v$39, _p$.o));
+      _v$40 !== _p$.i && (_p$.i = setProp(_el$6, "backgroundColor", _v$40, _p$.i));
+      _v$41 !== _p$.n && (_p$.n = setProp(_el$8, "fg", _v$41, _p$.n));
+      _v$42 !== _p$.s && (_p$.s = setProp(_el$8, "attributes", _v$42, _p$.s));
+      _v$43 !== _p$.h && (_p$.h = setProp(_el$0, "fg", _v$43, _p$.h));
+      _v$44 !== _p$.r && (_p$.r = setProp(_el$1, "backgroundColor", _v$44, _p$.r));
+      _v$45 !== _p$.d && (_p$.d = setProp(_el$1, "marginTop", _v$45, _p$.d));
+      _v$46 !== _p$.l && (_p$.l = setProp(_el$10, "paddingTop", _v$46, _p$.l));
+      _v$47 !== _p$.u && (_p$.u = setProp(_el$10, "gap", _v$47, _p$.u));
+      _v$48 !== _p$.c && (_p$.c = setProp(_el$88, "fg", _v$48, _p$.c));
+      return _p$;
+    }, {
+      e: void 0,
+      t: void 0,
+      a: void 0,
+      o: void 0,
+      i: void 0,
+      n: void 0,
+      s: void 0,
+      h: void 0,
+      r: void 0,
+      d: void 0,
+      l: void 0,
+      u: void 0,
+      c: void 0
+    });
+    return _el$5;
+  })();
+}
+
+// src/index.tsx
+var args = process.argv.slice(2);
+var demo = args.includes("--demo");
+var fixture = args.find((arg) => arg.startsWith("--demo="))?.slice(7);
+if (args.length > 1 || args.some((arg) => !["--demo", "--demo=empty", "--demo=error", "--demo=setup", "--demo=setup-gh", "--demo=setup-zstd", "--demo=setup-error", "--demo=setup-interrupted", "--demo=no-homebrew", "--list-images", "--clear-cache"].includes(arg))) {
+  console.error("Usage: bun start [--demo[=empty|error|setup|setup-gh|setup-zstd|setup-error|setup-interrupted|no-homebrew] | --list-images | --clear-cache]");
+  process.exitCode = 1;
+} else if (args.includes("--clear-cache")) {
+  try {
+    console.log(await new FlashBackend().clearCache(new AbortController().signal));
+  } catch (e) {
+    console.error(e instanceof Error ? e.message : "Cache clear failed.");
+    process.exitCode = 1;
+  }
+} else if (args.includes("--list-images")) {
+  try {
+    console.log(JSON.stringify(await discoverImages(new AbortController().signal), null, 2));
+  } catch (e) {
+    console.error(e instanceof Error ? e.message : "Image discovery failed.");
+    process.exitCode = 1;
+  }
+} else if (!demo && !fixture && (!["darwin", "linux"].includes(process.platform) || process.getuid?.() === 0)) {
+  console.error("Boo Flash requires macOS or Linux and a normal user account. Use --demo for a non-writing UI preview.");
+  process.exitCode = 1;
+} else {
+  const backend = new FlashBackend(demo ? "normal" : fixture);
+  const renderer = await createCliRenderer2({
+    backgroundColor: palette.background,
+    targetFps: 30,
+    exitOnCtrlC: false,
+    exitSignals: []
+  });
+  let stop = async () => {
+  };
+  let finishing;
+  let finished;
+  const done = new Promise((resolve) => {
+    finished = resolve;
+  });
+  const quit = () => {
+    finishing ??= (async () => {
+      try {
+        await stop();
+      } finally {
+        renderer.destroy();
+        finished();
+      }
+    })();
+  };
+  const signals = ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"];
+  for (const signal of signals) process.on(signal, quit);
+  try {
+    await render(() => createComponent2(App, {
+      backend,
+      quit,
+      registerStop: (handler) => {
+        stop = handler;
+      }
+    }), renderer);
+    await done;
+  } finally {
+    await stop();
+    renderer.destroy();
+    for (const signal of signals) process.off(signal, quit);
+  }
+}