@vibecook/ghosttea-react 0.2.0

package/dist/terminal-render.worker.js

@@ -0,0 +1,3165 @@
+// ../terminal-frame/dist/index.js
+var FRAME_MAGIC = 826692180;
+var FRAME_PROTOCOL_VERSION = 1;
+var FRAME_HEADER_BYTES = 64;
+var SECTION_HEADER_BYTES = 16;
+var MAX_FRAME_BYTES = 16 * 1024 * 1024;
+var FrameFlag = {
+  FullSnapshot: 1 << 0,
+  MouseTracking: 1 << 1,
+  CatalogReset: 1 << 2
+};
+var SectionKind;
+(function(SectionKind2) {
+  SectionKind2[SectionKind2["GlyphDefinitions"] = 1] = "GlyphDefinitions";
+  SectionKind2[SectionKind2["StyleDefinitions"] = 2] = "StyleDefinitions";
+  SectionKind2[SectionKind2["RowReplacements"] = 3] = "RowReplacements";
+  SectionKind2[SectionKind2["CursorState"] = 4] = "CursorState";
+  SectionKind2[SectionKind2["SelectionSpans"] = 5] = "SelectionSpans";
+  SectionKind2[SectionKind2["ImageDefinitions"] = 6] = "ImageDefinitions";
+  SectionKind2[SectionKind2["ImagePlacements"] = 7] = "ImagePlacements";
+  SectionKind2[SectionKind2["ScrollbarState"] = 8] = "ScrollbarState";
+  SectionKind2[SectionKind2["ViewportMetadata"] = 9] = "ViewportMetadata";
+  SectionKind2[SectionKind2["AccessibilityText"] = 10] = "AccessibilityText";
+  SectionKind2[SectionKind2["ClipboardWrite"] = 11] = "ClipboardWrite";
+})(SectionKind || (SectionKind = {}));
+var GlyphFormat;
+(function(GlyphFormat2) {
+  GlyphFormat2[GlyphFormat2["Alpha8"] = 0] = "Alpha8";
+  GlyphFormat2[GlyphFormat2["Rgba8Premultiplied"] = 1] = "Rgba8Premultiplied";
+})(GlyphFormat || (GlyphFormat = {}));
+var CursorStyle;
+(function(CursorStyle2) {
+  CursorStyle2[CursorStyle2["Bar"] = 0] = "Bar";
+  CursorStyle2[CursorStyle2["Block"] = 1] = "Block";
+  CursorStyle2[CursorStyle2["Underline"] = 2] = "Underline";
+  CursorStyle2[CursorStyle2["HollowBlock"] = 3] = "HollowBlock";
+})(CursorStyle || (CursorStyle = {}));
+function assertRange(condition, message) {
+  if (!condition)
+    throw new RangeError(`Invalid terminal frame: ${message}`);
+}
+function decodeFrame(buffer) {
+  assertRange(buffer.byteLength >= FRAME_HEADER_BYTES, "truncated header");
+  assertRange(buffer.byteLength <= MAX_FRAME_BYTES, "packet exceeds limit");
+  const view = new DataView(buffer);
+  assertRange(view.getUint32(0, true) === FRAME_MAGIC, "bad magic");
+  assertRange(view.getUint16(4, true) === FRAME_PROTOCOL_VERSION, "unsupported protocol version");
+  const sectionCount = view.getUint16(60, true);
+  const tableEnd = FRAME_HEADER_BYTES + sectionCount * SECTION_HEADER_BYTES;
+  assertRange(tableEnd <= buffer.byteLength, "truncated section table");
+  const sections = [];
+  for (let index = 0; index < sectionCount; index += 1) {
+    const base = FRAME_HEADER_BYTES + index * SECTION_HEADER_BYTES;
+    const kind = view.getUint16(base, true);
+    const flags = view.getUint16(base + 2, true);
+    const offset = view.getUint32(base + 4, true);
+    const length = view.getUint32(base + 8, true);
+    const itemCount = view.getUint32(base + 12, true);
+    const end = offset + length;
+    assertRange(end >= offset && offset >= tableEnd && end <= buffer.byteLength, "section out of bounds");
+    sections.push({ kind, flags, itemCount, bytes: new Uint8Array(buffer, offset, length) });
+  }
+  return {
+    protocolVersion: view.getUint16(4, true),
+    flags: view.getUint16(6, true),
+    sessionHandle: view.getBigUint64(8, true),
+    viewHandle: view.getBigUint64(16, true),
+    sessionEpoch: view.getBigUint64(24, true),
+    layoutEpoch: view.getBigUint64(32, true),
+    frameSequence: view.getBigUint64(40, true),
+    terminalRevision: view.getBigUint64(48, true),
+    cols: view.getUint16(56, true),
+    rows: view.getUint16(58, true),
+    sections
+  };
+}
+function decodeRowReplacements(section) {
+  assertRange(section.kind === SectionKind.RowReplacements, "wrong row replacement section kind");
+  assertRange(section.bytes.byteLength >= 2, "truncated row replacement header");
+  const view = new DataView(section.bytes.buffer, section.bytes.byteOffset, section.bytes.byteLength);
+  const count = view.getUint16(0, true);
+  assertRange(count === section.itemCount, "row replacement count mismatch");
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  const rows = [];
+  let offset = 2;
+  for (let index = 0; index < count; index += 1) {
+    assertRange(offset + 18 <= section.bytes.byteLength, "truncated row replacement");
+    const row = view.getUint16(offset, true);
+    const revision = view.getBigUint64(offset + 2, true);
+    const length = view.getUint32(offset + 10, true);
+    const glyphCount = view.getUint16(offset + 14, true);
+    const styleCount = view.getUint16(offset + 16, true);
+    offset += 18;
+    assertRange(offset + length <= section.bytes.byteLength, "row replacement payload out of bounds");
+    const text = decoder.decode(section.bytes.subarray(offset, offset + length));
+    offset += length;
+    const glyphs = [];
+    for (let glyphIndex = 0; glyphIndex < glyphCount; glyphIndex += 1) {
+      assertRange(offset + 28 <= section.bytes.byteLength, "truncated glyph instance");
+      glyphs.push({
+        glyphId: view.getUint32(offset, true),
+        styleId: view.getUint32(offset + 4, true),
+        x: view.getFloat32(offset + 8, true),
+        y: view.getFloat32(offset + 12, true),
+        width: view.getFloat32(offset + 16, true),
+        height: view.getFloat32(offset + 20, true),
+        cellStart: view.getUint16(offset + 24, true),
+        cellSpan: view.getUint16(offset + 26, true)
+      });
+      offset += 28;
+    }
+    const styles = [];
+    for (let styleIndex = 0; styleIndex < styleCount; styleIndex += 1) {
+      assertRange(offset + 8 <= section.bytes.byteLength, "truncated row style run");
+      styles.push({
+        styleId: view.getUint32(offset, true),
+        cellStart: view.getUint16(offset + 4, true),
+        cellSpan: view.getUint16(offset + 6, true)
+      });
+      offset += 8;
+    }
+    rows.push({ row, revision, text, glyphs, styles });
+  }
+  assertRange(offset === section.bytes.byteLength, "trailing row replacement bytes");
+  return rows;
+}
+function decodeGlyphDefinitions(section) {
+  assertRange(section.kind === SectionKind.GlyphDefinitions, "wrong glyph definition section kind");
+  assertRange(section.bytes.byteLength >= 4, "truncated glyph definition header");
+  const view = new DataView(section.bytes.buffer, section.bytes.byteOffset, section.bytes.byteLength);
+  const count = view.getUint32(0, true);
+  assertRange(count === section.itemCount, "glyph definition count mismatch");
+  const definitions = [];
+  let offset = 4;
+  for (let index = 0; index < count; index += 1) {
+    assertRange(offset + 20 <= section.bytes.byteLength, "truncated glyph definition");
+    const format = view.getUint8(offset + 12);
+    assertRange(format === GlyphFormat.Alpha8 || format === GlyphFormat.Rgba8Premultiplied, "invalid glyph format");
+    assertRange(view.getUint8(offset + 13) === 0 && view.getUint16(offset + 14, true) === 0, "nonzero glyph reserved bytes");
+    const pixelLength = view.getUint32(offset + 16, true);
+    const width = view.getUint16(offset + 4, true);
+    const height = view.getUint16(offset + 6, true);
+    const expectedLength = width * height * (format === GlyphFormat.Alpha8 ? 1 : 4);
+    assertRange(pixelLength === expectedLength, "glyph pixel length mismatch");
+    offset += 20;
+    assertRange(offset + pixelLength <= section.bytes.byteLength, "glyph pixels out of bounds");
+    definitions.push({
+      id: view.getUint32(offset - 20, true),
+      width,
+      height,
+      bearingX: view.getInt16(offset - 12, true),
+      bearingY: view.getInt16(offset - 10, true),
+      format,
+      pixels: section.bytes.slice(offset, offset + pixelLength)
+    });
+    offset += pixelLength;
+  }
+  assertRange(offset === section.bytes.byteLength, "trailing glyph definition bytes");
+  return definitions;
+}
+function decodeStyleDefinitions(section) {
+  assertRange(section.kind === SectionKind.StyleDefinitions, "wrong style definition section kind");
+  assertRange(section.bytes.byteLength >= 4, "truncated style definition header");
+  const view = new DataView(section.bytes.buffer, section.bytes.byteOffset, section.bytes.byteLength);
+  const count = view.getUint32(0, true);
+  assertRange(count === section.itemCount, "style definition count mismatch");
+  assertRange(section.bytes.byteLength === 4 + count * 16, "invalid style definition length");
+  const styles = [];
+  for (let index = 0; index < count; index += 1) {
+    const offset = 4 + index * 16;
+    const flags = view.getUint16(offset + 4, true);
+    const foregroundKind = view.getUint8(offset + 6);
+    const backgroundKind = view.getUint8(offset + 7);
+    assertRange((flags & ~127) === 0, "invalid style flags");
+    assertRange(foregroundKind <= 1 && backgroundKind <= 1, "invalid style color kind");
+    assertRange(view.getUint16(offset + 14, true) === 0, "nonzero style reserved bytes");
+    styles.push({
+      id: view.getUint32(offset, true),
+      bold: (flags & 1) !== 0,
+      italic: (flags & 2) !== 0,
+      faint: (flags & 4) !== 0,
+      inverse: (flags & 8) !== 0,
+      invisible: (flags & 16) !== 0,
+      strikethrough: (flags & 32) !== 0,
+      underline: (flags & 64) !== 0,
+      ...foregroundKind === 1 ? { foreground: [view.getUint8(offset + 8), view.getUint8(offset + 9), view.getUint8(offset + 10)] } : {},
+      ...backgroundKind === 1 ? { background: [view.getUint8(offset + 11), view.getUint8(offset + 12), view.getUint8(offset + 13)] } : {}
+    });
+  }
+  return styles;
+}
+function decodeCursorState(section) {
+  assertRange(section.kind === SectionKind.CursorState, "wrong cursor section kind");
+  assertRange(section.itemCount === 1, "cursor item count mismatch");
+  assertRange(section.bytes.byteLength === 8, "invalid cursor payload length");
+  const view = new DataView(section.bytes.buffer, section.bytes.byteOffset, section.bytes.byteLength);
+  const visible = view.getUint8(4);
+  const style = view.getUint8(5);
+  const blinking = view.getUint8(6);
+  assertRange(visible <= 1, "invalid cursor visibility");
+  assertRange(style <= CursorStyle.HollowBlock, "invalid cursor style");
+  assertRange(blinking <= 1, "invalid cursor blinking state");
+  assertRange(view.getUint8(7) === 0, "nonzero cursor reserved byte");
+  return {
+    x: view.getUint16(0, true),
+    y: view.getUint16(2, true),
+    visible: visible === 1,
+    style,
+    blinking: blinking === 1
+  };
+}
+function decodeScrollbarState(section) {
+  assertRange(section.kind === SectionKind.ScrollbarState, "wrong scrollbar section kind");
+  assertRange(section.itemCount === 1, "scrollbar item count mismatch");
+  assertRange(section.bytes.byteLength === 24, "invalid scrollbar payload size");
+  const view = new DataView(section.bytes.buffer, section.bytes.byteOffset, section.bytes.byteLength);
+  const total = view.getBigUint64(0, true);
+  const offset = view.getBigUint64(8, true);
+  const length = view.getBigUint64(16, true);
+  assertRange(length <= total, "scrollbar viewport exceeds total rows");
+  assertRange(offset <= total - length, "scrollbar offset exceeds scrollable range");
+  return { total, offset, length };
+}
+function decodeClipboardWrite(section) {
+  assertRange(section.kind === SectionKind.ClipboardWrite, "wrong clipboard section kind");
+  assertRange(section.itemCount === 1, "clipboard item count mismatch");
+  assertRange(section.bytes.byteLength >= 4, "truncated clipboard payload");
+  const view = new DataView(section.bytes.buffer, section.bytes.byteOffset, section.bytes.byteLength);
+  const length = view.getUint32(0, true);
+  assertRange(length === section.bytes.byteLength - 4, "clipboard length mismatch");
+  return new TextDecoder("utf-8", { fatal: true }).decode(section.bytes.subarray(4));
+}
+
+// src/performance.ts
+function emptyRenderMetrics() {
+  return {
+    queueSubmits: 0,
+    fullRenders: 0,
+    partialRenders: 0,
+    damagedRows: 0,
+    geometryCacheHits: 0,
+    geometryCacheMisses: 0,
+    canvasPixels: 0,
+    renderPasses: 0,
+    drawCalls: 0,
+    rectangleVertices: 0,
+    monoGlyphVertices: 0,
+    colorGlyphVertices: 0,
+    fallbackGlyphVertices: 0,
+    vertexUploadBytes: 0,
+    atlasUploadBytes: 0,
+    atlasUploadCalls: 0
+  };
+}
+
+// src/renderers/types.ts
+function effectiveCursorStyle(view) {
+  if (!view.cursor.visible) return null;
+  if (!view.focused) return CursorStyle.HollowBlock;
+  if (view.cursor.blinking && !view.cursorBlinkVisible) return null;
+  return view.cursor.style;
+}
+function physicalPixels(value, dpr) {
+  return Math.max(1, Math.round(value * dpr));
+}
+function renderedSizeChanged(current, next) {
+  return current.dpr !== next.dpr || physicalPixels(current.width, current.dpr) !== physicalPixels(next.width, next.dpr) || physicalPixels(current.height, current.dpr) !== physicalPixels(next.height, next.dpr);
+}
+var DEFAULT_THEME = {
+  background: [40 / 255, 44 / 255, 52 / 255, 1],
+  foreground: [1, 1, 1, 1],
+  cursor: [1, 1, 1, 1],
+  selection: [1, 1, 1, 1],
+  selectionForeground: [40 / 255, 44 / 255, 52 / 255, 1]
+};
+var CELL_WIDTH = 7.83;
+var LINE_HEIGHT = 19;
+var ORIGIN_X = 2;
+var ORIGIN_Y = 2;
+
+// src/renderers/canvas-renderer.ts
+function css(color) {
+  const [red, green, blue, alpha] = color;
+  return `rgba(${Math.round(red * 255)}, ${Math.round(green * 255)}, ${Math.round(blue * 255)}, ${alpha})`;
+}
+function ordered(selection) {
+  if (!selection) return null;
+  const { anchor, focus } = selection;
+  return anchor.row < focus.row || anchor.row === focus.row && anchor.column <= focus.column ? [anchor, focus] : [focus, anchor];
+}
+var CanvasTerminalRenderer = class {
+  kind = "canvas2d";
+  #surfaces = /* @__PURE__ */ new Map();
+  #performanceMeasurementEnabled = false;
+  setPerformanceMeasurementEnabled(enabled) {
+    this.#performanceMeasurementEnabled = enabled;
+  }
+  mount(id, canvas) {
+    const context = canvas.getContext("2d", { alpha: false });
+    if (!context) throw new Error("Canvas2D worker backend unavailable");
+    this.#surfaces.set(id, { canvas, context, width: 1, height: 1, dpr: 1 });
+  }
+  unmount(id) {
+    this.#surfaces.delete(id);
+  }
+  resize(id, size) {
+    const surface2 = this.#surfaces.get(id);
+    if (!surface2) return;
+    const changed = renderedSizeChanged(surface2, size);
+    Object.assign(surface2, size);
+    if (!changed) return;
+    surface2.canvas.width = Math.max(1, Math.round(size.width * size.dpr));
+    surface2.canvas.height = Math.max(1, Math.round(size.height * size.dpr));
+  }
+  render(id, view) {
+    const surface2 = this.#surfaces.get(id);
+    if (!surface2) return;
+    const { context, width, height, dpr } = surface2;
+    context.save();
+    context.setTransform(dpr, 0, 0, dpr, 0, 0);
+    context.fillStyle = css(view.theme.background);
+    context.fillRect(0, 0, width, height);
+    const selection = ordered(view.selection);
+    if (selection) {
+      context.fillStyle = css(view.theme.selection);
+      const [start, end] = selection;
+      for (let row = start.row; row <= end.row; row += 1) {
+        const first = row === start.row ? start.column : 0;
+        const last = row === end.row ? end.column : Math.max(0, view.rows[row]?.length ?? 0);
+        context.fillRect(
+          ORIGIN_X + first * CELL_WIDTH,
+          ORIGIN_Y + row * LINE_HEIGHT,
+          Math.max(1, last - first + 1) * CELL_WIDTH,
+          LINE_HEIGHT
+        );
+      }
+    }
+    context.font = "13px ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace";
+    context.textBaseline = "top";
+    context.fillStyle = css(view.theme.foreground);
+    for (let row = 0; row < view.rows.length; row += 1) {
+      context.fillText(view.rows[row] ?? "", ORIGIN_X, ORIGIN_Y + row * LINE_HEIGHT);
+    }
+    if (selection) {
+      const [start, end] = selection;
+      context.fillStyle = css(view.theme.selectionForeground);
+      for (let row = start.row; row <= end.row; row += 1) {
+        const first = row === start.row ? start.column : 0;
+        const last = row === end.row ? end.column : Math.max(0, view.rows[row]?.length ?? 0);
+        context.save();
+        context.beginPath();
+        context.rect(
+          ORIGIN_X + first * CELL_WIDTH,
+          ORIGIN_Y + row * LINE_HEIGHT,
+          Math.max(1, last - first + 1) * CELL_WIDTH,
+          LINE_HEIGHT
+        );
+        context.clip();
+        context.fillText(view.rows[row] ?? "", ORIGIN_X, ORIGIN_Y + row * LINE_HEIGHT);
+        context.restore();
+      }
+    }
+    const cursorStyle = effectiveCursorStyle(view);
+    if (cursorStyle !== null) {
+      const x = ORIGIN_X + view.cursor.x * CELL_WIDTH;
+      const y = ORIGIN_Y + view.cursor.y * LINE_HEIGHT;
+      const color = cursorStyle === CursorStyle.HollowBlock ? [view.theme.cursor[0], view.theme.cursor[1], view.theme.cursor[2], 1] : view.theme.cursor;
+      context.fillStyle = css(color);
+      if (cursorStyle === CursorStyle.Bar) {
+        context.fillRect(x, y, 2, LINE_HEIGHT);
+      } else if (cursorStyle === CursorStyle.Underline) {
+        context.fillRect(x, y + LINE_HEIGHT - 2, CELL_WIDTH, 2);
+      } else if (cursorStyle === CursorStyle.HollowBlock) {
+        context.strokeStyle = css(color);
+        context.lineWidth = 1;
+        context.strokeRect(x + 0.5, y + 0.5, CELL_WIDTH - 1, LINE_HEIGHT - 1);
+      } else {
+        context.fillRect(x, y, CELL_WIDTH, LINE_HEIGHT);
+      }
+    }
+    context.restore();
+    if (!this.#performanceMeasurementEnabled) return void 0;
+    const metrics = emptyRenderMetrics();
+    metrics.fullRenders = 1;
+    metrics.damagedRows = Math.max(view.rows.length, view.nativeRows.length, view.nativeStyleRows.length);
+    metrics.canvasPixels = surface2.canvas.width * surface2.canvas.height;
+    metrics.renderPasses = 1;
+    metrics.drawCalls = 1;
+    return metrics;
+  }
+};
+
+// src/cell-width.ts
+var graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function splitGraphemes(text) {
+  return Array.from(graphemeSegmenter.segment(text), ({ segment }) => segment);
+}
+function graphemeCellWidth(grapheme) {
+  const codepoint = grapheme.codePointAt(0) ?? 0;
+  return /\p{Extended_Pictographic}/u.test(grapheme) || codepoint >= 4352 && codepoint <= 4447 || codepoint >= 11904 && codepoint <= 42191 || codepoint >= 44032 && codepoint <= 55203 || codepoint >= 63744 && codepoint <= 64255 || codepoint >= 65040 && codepoint <= 65135 || codepoint >= 65280 && codepoint <= 65376 || codepoint >= 127744 && codepoint <= 129791 || codepoint >= 131072 && codepoint <= 262141 ? 2 : 1;
+}
+
+// src/renderers/render-damage.ts
+function rowsForDamage(rowCount, damage, sceneValid) {
+  const full = !sceneValid || !damage || damage.full;
+  if (full) return { full: true, rows: Array.from({ length: rowCount }, (_, row) => row) };
+  const rows = /* @__PURE__ */ new Set();
+  for (const damagedRow of damage.rows) {
+    for (let row = damagedRow - 1; row <= damagedRow + 1; row += 1) {
+      if (row >= 0 && row < rowCount) rows.add(row);
+    }
+  }
+  return { full: false, rows: [...rows].sort((left, right) => left - right) };
+}
+
+// src/renderers/webgpu-renderer.ts
+var ATLAS_SIZE = 2048;
+var GEOMETRY_CACHE_LIMIT = 8;
+var FONT_STACK = "ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace";
+var RECT_SHADER = (
+  /* wgsl */
+  `
+struct VertexOutput {
+  @builtin(position) position: vec4f,
+  @location(0) color: vec4f,
+}
+
+@vertex fn vertex_main(
+  @builtin(vertex_index) vertex_index: u32,
+  @location(0) p0: vec2f,
+  @location(1) p1: vec2f,
+  @location(2) p2: vec2f,
+  @location(3) color: vec4f,
+) -> VertexOutput {
+  let p3 = p1 + p2 - p0;
+  let positions = array<vec2f, 6>(
+    p0,
+    p1,
+    p2,
+    p2,
+    p1,
+    p3,
+  );
+  var output: VertexOutput;
+  output.position = vec4f(positions[vertex_index], 0.0, 1.0);
+  output.color = color;
+  return output;
+}
+
+@fragment fn fragment_main(input: VertexOutput) -> @location(0) vec4f {
+  return vec4f(input.color.rgb * input.color.a, input.color.a);
+}
+`
+);
+function glyphShader(coverageChannel) {
+  return (
+    /* wgsl */
+    `
+@group(0) @binding(0) var atlas: texture_2d<f32>;
+@group(0) @binding(1) var atlas_sampler: sampler;
+
+struct VertexOutput {
+  @builtin(position) position: vec4f,
+  @location(0) uv: vec2f,
+  @location(1) color: vec4f,
+}
+
+@vertex fn vertex_main(
+  @builtin(vertex_index) vertex_index: u32,
+  @location(0) bounds: vec4f,
+  @location(1) uv_bounds: vec4f,
+  @location(2) color: vec4f,
+) -> VertexOutput {
+  let positions = array<vec2f, 6>(
+    vec2f(bounds.x, bounds.z),
+    vec2f(bounds.y, bounds.z),
+    vec2f(bounds.x, bounds.w),
+    vec2f(bounds.x, bounds.w),
+    vec2f(bounds.y, bounds.z),
+    vec2f(bounds.y, bounds.w),
+  );
+  let uvs = array<vec2f, 6>(
+    vec2f(uv_bounds.x, uv_bounds.z),
+    vec2f(uv_bounds.y, uv_bounds.z),
+    vec2f(uv_bounds.x, uv_bounds.w),
+    vec2f(uv_bounds.x, uv_bounds.w),
+    vec2f(uv_bounds.y, uv_bounds.z),
+    vec2f(uv_bounds.y, uv_bounds.w),
+  );
+  var output: VertexOutput;
+  output.position = vec4f(positions[vertex_index], 0.0, 1.0);
+  output.uv = uvs[vertex_index];
+  output.color = color;
+  return output;
+}
+
+@fragment fn fragment_main(input: VertexOutput) -> @location(0) vec4f {
+  let coverage = textureSample(atlas, atlas_sampler, input.uv).${coverageChannel};
+  let alpha = input.color.a * coverage;
+  return vec4f(input.color.rgb * alpha, alpha);
+}
+`
+  );
+}
+var MONO_GLYPH_SHADER = glyphShader("r");
+var FALLBACK_GLYPH_SHADER = glyphShader("a");
+var COLOR_GLYPH_SHADER = (
+  /* wgsl */
+  `
+@group(0) @binding(0) var atlas: texture_2d<f32>;
+@group(0) @binding(1) var atlas_sampler: sampler;
+
+struct VertexOutput {
+  @builtin(position) position: vec4f,
+  @location(0) uv: vec2f,
+  @location(1) color: vec4f,
+}
+
+@vertex fn vertex_main(
+  @builtin(vertex_index) vertex_index: u32,
+  @location(0) bounds: vec4f,
+  @location(1) uv_bounds: vec4f,
+  @location(2) color: vec4f,
+) -> VertexOutput {
+  let positions = array<vec2f, 6>(
+    vec2f(bounds.x, bounds.z),
+    vec2f(bounds.y, bounds.z),
+    vec2f(bounds.x, bounds.w),
+    vec2f(bounds.x, bounds.w),
+    vec2f(bounds.y, bounds.z),
+    vec2f(bounds.y, bounds.w),
+  );
+  let uvs = array<vec2f, 6>(
+    vec2f(uv_bounds.x, uv_bounds.z),
+    vec2f(uv_bounds.y, uv_bounds.z),
+    vec2f(uv_bounds.x, uv_bounds.w),
+    vec2f(uv_bounds.x, uv_bounds.w),
+    vec2f(uv_bounds.y, uv_bounds.z),
+    vec2f(uv_bounds.y, uv_bounds.w),
+  );
+  var output: VertexOutput;
+  output.position = vec4f(positions[vertex_index], 0.0, 1.0);
+  output.uv = uvs[vertex_index];
+  output.color = color;
+  return output;
+}
+
+@fragment fn fragment_main(input: VertexOutput) -> @location(0) vec4f {
+  return textureSample(atlas, atlas_sampler, input.uv);
+}
+`
+);
+var BETTER_CRT_SHADER = (
+  /* wgsl */
+  `
+@group(0) @binding(0) var terminal_image: texture_2d<f32>;
+@group(0) @binding(1) var terminal_sampler: sampler;
+
+@vertex fn vertex_main(@builtin(vertex_index) vertex_index: u32) -> @builtin(position) vec4f {
+  let positions = array<vec2f, 3>(
+    vec2f(-1.0, -1.0),
+    vec2f(3.0, -1.0),
+    vec2f(-1.0, 3.0),
+  );
+  return vec4f(positions[vertex_index], 0.0, 1.0);
+}
+
+@fragment fn fragment_main(@builtin(position) position: vec4f) -> @location(0) vec4f {
+  let dimensions = vec2f(textureDimensions(terminal_image));
+  var uv = position.xy / dimensions;
+  var dc = abs(vec2f(0.5) - uv);
+  dc *= dc;
+
+  // These constants are the active Ghostty shader's warp = 0.25 and
+  // scan = 0.50 values.
+  uv.x -= 0.5;
+  uv.x *= 1.0 + dc.y * 0.075;
+  uv.x += 0.5;
+  uv.y -= 0.5;
+  uv.y *= 1.0 + dc.x * 0.10;
+  uv.y += 0.5;
+
+  let scanline = abs(sin(position.y) * 0.125);
+  let color = textureSample(terminal_image, terminal_sampler, uv).rgb;
+  return vec4f(mix(color, vec3f(0.0), scanline), 1.0);
+}
+`
+);
+var premultipliedBlend = {
+  color: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
+  alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" }
+};
+var DynamicVertexBuffer = class {
+  constructor(device, label) {
+    this.device = device;
+    this.label = label;
+  }
+  #buffer;
+  #capacity = 0;
+  write(vertices) {
+    if (vertices.byteLength === 0) return void 0;
+    if (!this.#buffer || this.#capacity < vertices.byteLength) {
+      this.#buffer?.destroy();
+      this.#capacity = Math.max(4096, 2 ** Math.ceil(Math.log2(vertices.byteLength)));
+      this.#buffer = this.device.createBuffer({
+        label: this.label,
+        size: this.#capacity,
+        usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST
+      });
+    }
+    this.device.queue.writeBuffer(this.#buffer, 0, vertices);
+    return this.#buffer;
+  }
+  destroy() {
+    this.#buffer?.destroy();
+    this.#buffer = void 0;
+  }
+};
+var FallbackGlyphAtlas = class {
+  constructor(device, bindGroupLayout) {
+    this.device = device;
+    this.#texture = device.createTexture({
+      label: "terminal glyph atlas",
+      size: [ATLAS_SIZE, ATLAS_SIZE],
+      format: "rgba8unorm",
+      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
+    });
+    this.#sampler = device.createSampler({ minFilter: "linear", magFilter: "linear" });
+    this.#bindGroup = device.createBindGroup({
+      label: "terminal glyph atlas bindings",
+      layout: bindGroupLayout,
+      entries: [
+        { binding: 0, resource: this.#texture.createView() },
+        { binding: 1, resource: this.#sampler }
+      ]
+    });
+  }
+  #texture;
+  #sampler;
+  #bindGroup;
+  #cache = /* @__PURE__ */ new Map();
+  #scratch = new OffscreenCanvas(1, 1);
+  #x = 1;
+  #y = 1;
+  #rowHeight = 0;
+  #uploadBytes = 0;
+  #uploadCalls = 0;
+  #generation = 0;
+  get bindGroup() {
+    return this.#bindGroup;
+  }
+  get generation() {
+    return this.#generation;
+  }
+  prepare(values, dpr) {
+    const scale = Math.max(1, Math.min(3, dpr));
+    const all = [...new Set(values)].filter((value) => value.trim().length > 0);
+    const missing = all.filter((value) => !this.#cache.has(`${scale.toFixed(2)}:${value}`));
+    if (this.#fits(missing, scale, this.#x, this.#y, this.#rowHeight)) return;
+    this.#cache.clear();
+    this.#generation += 1;
+    this.#x = 1;
+    this.#y = 1;
+    this.#rowHeight = 0;
+    if (!this.#fits(all, scale, this.#x, this.#y, this.#rowHeight)) {
+      throw new Error("The diagnostic glyph atlas cannot fit the text visible in one frame");
+    }
+  }
+  #fits(values, scale, startX, startY, startRowHeight) {
+    let x = startX;
+    let y = startY;
+    let rowHeight = startRowHeight;
+    for (const value of values) {
+      const width = Math.max(1, Math.ceil(CELL_WIDTH * graphemeCellWidth(value) * scale));
+      const height = Math.max(1, Math.ceil(LINE_HEIGHT * scale));
+      if (x + width + 1 > ATLAS_SIZE) {
+        x = 1;
+        y += rowHeight + 1;
+        rowHeight = 0;
+      }
+      if (y + height + 1 > ATLAS_SIZE) return false;
+      x += width + 1;
+      rowHeight = Math.max(rowHeight, height);
+    }
+    return true;
+  }
+  glyph(grapheme, dpr) {
+    if (grapheme.trim().length === 0) return void 0;
+    const scale = Math.max(1, Math.min(3, dpr));
+    const cells = graphemeCellWidth(grapheme);
+    const key = `${scale.toFixed(2)}:${grapheme}`;
+    const cached = this.#cache.get(key);
+    if (cached) return cached;
+    const width = Math.max(1, Math.ceil(CELL_WIDTH * cells * scale));
+    const height = Math.max(1, Math.ceil(LINE_HEIGHT * scale));
+    if (this.#x + width + 1 > ATLAS_SIZE) {
+      this.#x = 1;
+      this.#y += this.#rowHeight + 1;
+      this.#rowHeight = 0;
+    }
+    if (this.#y + height + 1 > ATLAS_SIZE) {
+      throw new Error("Temporary glyph atlas exhausted");
+    }
+    this.#scratch.width = width;
+    this.#scratch.height = height;
+    const context = this.#scratch.getContext("2d", { willReadFrequently: true });
+    if (!context) throw new Error("Glyph raster canvas unavailable");
+    context.clearRect(0, 0, width, height);
+    context.fillStyle = "white";
+    context.font = `${13 * scale}px ${FONT_STACK}`;
+    context.textBaseline = "top";
+    context.fillText(grapheme, 0, Math.max(0, Math.floor((height - 15 * scale) / 2)));
+    const image = context.getImageData(0, 0, width, height);
+    this.device.queue.writeTexture(
+      { texture: this.#texture, origin: [this.#x, this.#y] },
+      image.data,
+      { bytesPerRow: width * 4, rowsPerImage: height },
+      [width, height]
+    );
+    this.#uploadBytes += image.data.byteLength;
+    this.#uploadCalls += 1;
+    const location = {
+      u0: this.#x / ATLAS_SIZE,
+      v0: this.#y / ATLAS_SIZE,
+      u1: (this.#x + width) / ATLAS_SIZE,
+      v1: (this.#y + height) / ATLAS_SIZE,
+      cells
+    };
+    this.#cache.set(key, location);
+    this.#x += width + 1;
+    this.#rowHeight = Math.max(this.#rowHeight, height);
+    return location;
+  }
+  destroy() {
+    this.#texture.destroy();
+  }
+  uploadMetrics() {
+    return { bytes: this.#uploadBytes, calls: this.#uploadCalls };
+  }
+};
+var NativeGlyphAtlas = class {
+  constructor(device, bindGroupLayout, label, format) {
+    this.device = device;
+    this.label = label;
+    this.format = format;
+    this.#texture = device.createTexture({
+      label,
+      size: [ATLAS_SIZE, ATLAS_SIZE],
+      format,
+      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
+    });
+    this.#sampler = device.createSampler({ minFilter: "linear", magFilter: "linear" });
+    this.#bindGroup = device.createBindGroup({
+      label: `${label} bindings`,
+      layout: bindGroupLayout,
+      entries: [
+        { binding: 0, resource: this.#texture.createView() },
+        { binding: 1, resource: this.#sampler }
+      ]
+    });
+  }
+  #texture;
+  #sampler;
+  #bindGroup;
+  #cache = /* @__PURE__ */ new Map();
+  #x = 1;
+  #y = 1;
+  #rowHeight = 0;
+  #uploadBytes = 0;
+  #uploadCalls = 0;
+  #generation = 0;
+  get bindGroup() {
+    return this.#bindGroup;
+  }
+  get generation() {
+    return this.#generation;
+  }
+  prepare(definitions) {
+    const all = /* @__PURE__ */ new Map();
+    const missing = /* @__PURE__ */ new Map();
+    for (const definition of definitions) {
+      all.set(definition.id, definition);
+      if (!this.#cache.has(definition.id)) missing.set(definition.id, definition);
+    }
+    if (this.#fits(missing.values(), this.#x, this.#y, this.#rowHeight)) return;
+    this.#cache.clear();
+    this.#generation += 1;
+    this.#x = 1;
+    this.#y = 1;
+    this.#rowHeight = 0;
+    if (!this.#fits(all.values(), this.#x, this.#y, this.#rowHeight)) {
+      throw new Error(`${this.label} cannot fit the glyphs visible in one frame`);
+    }
+  }
+  #fits(definitions, startX, startY, startRowHeight) {
+    let x = startX;
+    let y = startY;
+    let rowHeight = startRowHeight;
+    for (const { width, height } of definitions) {
+      if (width + 2 > ATLAS_SIZE || height + 2 > ATLAS_SIZE) return false;
+      if (x + width + 1 > ATLAS_SIZE) {
+        x = 1;
+        y += rowHeight + 1;
+        rowHeight = 0;
+      }
+      if (y + height + 1 > ATLAS_SIZE) return false;
+      x += width + 1;
+      rowHeight = Math.max(rowHeight, height);
+    }
+    return true;
+  }
+  glyph(definition) {
+    const cached = this.#cache.get(definition.id);
+    if (cached) return cached;
+    const { width, height } = definition;
+    if (this.#x + width + 1 > ATLAS_SIZE) {
+      this.#x = 1;
+      this.#y += this.#rowHeight + 1;
+      this.#rowHeight = 0;
+    }
+    if (this.#y + height + 1 > ATLAS_SIZE) throw new Error(`${this.label} exhausted`);
+    const pixels = definition.pixels;
+    const bytesPerPixel = this.format === "r8unorm" ? 1 : 4;
+    this.device.queue.writeTexture(
+      { texture: this.#texture, origin: [this.#x, this.#y] },
+      pixels,
+      { bytesPerRow: width * bytesPerPixel, rowsPerImage: height },
+      [width, height]
+    );
+    this.#uploadBytes += pixels.byteLength;
+    this.#uploadCalls += 1;
+    const location = {
+      u0: this.#x / ATLAS_SIZE,
+      v0: this.#y / ATLAS_SIZE,
+      u1: (this.#x + width) / ATLAS_SIZE,
+      v1: (this.#y + height) / ATLAS_SIZE,
+      cells: 0
+    };
+    this.#cache.set(definition.id, location);
+    this.#x += width + 1;
+    this.#rowHeight = Math.max(this.#rowHeight, height);
+    return location;
+  }
+  destroy() {
+    this.#texture.destroy();
+  }
+  uploadMetrics() {
+    return { bytes: this.#uploadBytes, calls: this.#uploadCalls };
+  }
+};
+function destroyCachedGeometry(geometry) {
+  geometry.rectangleBuffer?.destroy();
+  geometry.glyphBuffer?.destroy();
+  geometry.colorGlyphBuffer?.destroy();
+  geometry.fallbackGlyphBuffer?.destroy();
+}
+function clearGeometryCache(surface2) {
+  for (const geometry of surface2.geometryCache.values()) destroyCachedGeometry(geometry);
+  surface2.geometryCache.clear();
+  surface2.geometryCandidates.clear();
+}
+function createCachedVertexBuffer(device, label, data) {
+  if (data.byteLength === 0) return void 0;
+  const buffer = device.createBuffer({
+    label,
+    size: data.byteLength,
+    usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST
+  });
+  device.queue.writeBuffer(buffer, 0, data);
+  return buffer;
+}
+function geometryCacheKey(view, rows, hasNativeRows, atlasGenerations) {
+  const selection = view.selection ? `${view.selection.anchor.row},${view.selection.anchor.column},${view.selection.focus.row},${view.selection.focus.column}` : "-";
+  return [
+    view.sessionEpoch.toString(),
+    view.layoutEpoch.toString(),
+    hasNativeRows ? "native" : "fallback",
+    rows.map((row) => `${row}:${view.rowRevisions[row]?.toString() ?? "-"}`).join(","),
+    [
+      ...view.theme.background,
+      ...view.theme.foreground,
+      ...view.theme.selection,
+      ...view.theme.selectionForeground
+    ].join(","),
+    selection,
+    atlasGenerations.join(",")
+  ].join("|");
+}
+function pushCursorVertices(vertices, view, renderRowSet, scale, viewportWidth, viewportHeight) {
+  const cursorStyle = effectiveCursorStyle(view);
+  if (cursorStyle === null || !renderRowSet.has(view.cursor.y)) return;
+  const x = (ORIGIN_X + view.cursor.x * CELL_WIDTH) * scale;
+  const y = (ORIGIN_Y + view.cursor.y * LINE_HEIGHT) * scale;
+  const width = CELL_WIDTH * scale;
+  const height = LINE_HEIGHT * scale;
+  const stroke = Math.max(1, Math.round(scale));
+  const cursorColor = cursorStyle === CursorStyle.HollowBlock ? [view.theme.cursor[0], view.theme.cursor[1], view.theme.cursor[2], 1] : view.theme.cursor;
+  if (cursorStyle === CursorStyle.Bar) {
+    pushRectangle(
+      vertices,
+      x,
+      y,
+      Math.max(2, Math.round(2 * scale)),
+      height,
+      cursorColor,
+      viewportWidth,
+      viewportHeight
+    );
+  } else if (cursorStyle === CursorStyle.Underline) {
+    const thickness = Math.max(2, Math.round(2 * scale));
+    pushRectangle(vertices, x, y + height - thickness, width, thickness, cursorColor, viewportWidth, viewportHeight);
+  } else if (cursorStyle === CursorStyle.HollowBlock) {
+    pushRectangle(vertices, x, y, width, stroke, cursorColor, viewportWidth, viewportHeight);
+    pushRectangle(vertices, x, y + height - stroke, width, stroke, cursorColor, viewportWidth, viewportHeight);
+    pushRectangle(
+      vertices,
+      x,
+      y + stroke,
+      stroke,
+      Math.max(0, height - stroke * 2),
+      cursorColor,
+      viewportWidth,
+      viewportHeight
+    );
+    pushRectangle(
+      vertices,
+      x + width - stroke,
+      y + stroke,
+      stroke,
+      Math.max(0, height - stroke * 2),
+      cursorColor,
+      viewportWidth,
+      viewportHeight
+    );
+  } else {
+    pushRectangle(vertices, x, y, width, height, cursorColor, viewportWidth, viewportHeight);
+  }
+}
+function clipX(pixel, width) {
+  return pixel / Math.max(1, width) * 2 - 1;
+}
+function clipY(pixel, height) {
+  return 1 - pixel / Math.max(1, height) * 2;
+}
+function pushRectangle(output, x, y, width, height, color, viewportWidth, viewportHeight) {
+  const left = clipX(x, viewportWidth);
+  const right = clipX(x + width, viewportWidth);
+  const top = clipY(y, viewportHeight);
+  const bottom = clipY(y + height, viewportHeight);
+  output.push(left, top, right, top, left, bottom, ...color);
+}
+function pushGlyph(output, x, y, width, height, glyph, color, viewportWidth, viewportHeight) {
+  const left = clipX(x, viewportWidth);
+  const right = clipX(x + width, viewportWidth);
+  const top = clipY(y, viewportHeight);
+  const bottom = clipY(y + height, viewportHeight);
+  output.push(left, right, top, bottom, glyph.u0, glyph.u1, glyph.v0, glyph.v1, ...color);
+}
+function ordered2(selection) {
+  if (!selection) return null;
+  const { anchor, focus } = selection;
+  return anchor.row < focus.row || anchor.row === focus.row && anchor.column <= focus.column ? [anchor, focus] : [focus, anchor];
+}
+function cellLength(text) {
+  return splitGraphemes(text).reduce((total, grapheme) => total + graphemeCellWidth(grapheme), 0);
+}
+var BOX_DIRECTIONS = /* @__PURE__ */ new Map([
+  ["\u2500", "lr"],
+  ["\u2501", "lr"],
+  ["\u2502", "ud"],
+  ["\u2503", "ud"],
+  ["\u250C", "rd"],
+  ["\u250D", "rd"],
+  ["\u250E", "rd"],
+  ["\u250F", "rd"],
+  ["\u2510", "ld"],
+  ["\u2511", "ld"],
+  ["\u2512", "ld"],
+  ["\u2513", "ld"],
+  ["\u2514", "ru"],
+  ["\u2515", "ru"],
+  ["\u2516", "ru"],
+  ["\u2517", "ru"],
+  ["\u2518", "lu"],
+  ["\u2519", "lu"],
+  ["\u251A", "lu"],
+  ["\u251B", "lu"],
+  ["\u251C", "udr"],
+  ["\u251D", "udr"],
+  ["\u251E", "udr"],
+  ["\u2523", "udr"],
+  ["\u2524", "udl"],
+  ["\u2525", "udl"],
+  ["\u2526", "udl"],
+  ["\u252B", "udl"],
+  ["\u252C", "lrd"],
+  ["\u252F", "lrd"],
+  ["\u2530", "lrd"],
+  ["\u2533", "lrd"],
+  ["\u2534", "lru"],
+  ["\u2537", "lru"],
+  ["\u2538", "lru"],
+  ["\u253B", "lru"],
+  ["\u253C", "lrud"],
+  ["\u254B", "lrud"],
+  ["\u2574", "l"],
+  ["\u2576", "r"],
+  ["\u2575", "u"],
+  ["\u2577", "d"],
+  ["\u2550", "lr"],
+  ["\u2551", "ud"],
+  ["\u2554", "rd"],
+  ["\u2557", "ld"],
+  ["\u255A", "ru"],
+  ["\u255D", "lu"],
+  ["\u2560", "udr"],
+  ["\u2563", "udl"],
+  ["\u2566", "lrd"],
+  ["\u2569", "lru"],
+  ["\u256C", "lrud"],
+  ["\u256D", "rd"],
+  ["\u256E", "ld"],
+  ["\u256F", "lu"],
+  ["\u2570", "ru"]
+]);
+var ROUNDED_BOX_CORNERS = /* @__PURE__ */ new Set(["\u256D", "\u256E", "\u256F", "\u2570"]);
+function specialDrawingCells(text) {
+  const box = /* @__PURE__ */ new Map();
+  const block = /* @__PURE__ */ new Map();
+  let column = 0;
+  let simple = true;
+  for (let index = 0; index < text.length; index += 1) {
+    const codepoint = text.charCodeAt(index);
+    if (codepoint <= 127) {
+      column += 1;
+    } else if (codepoint >= 9600 && codepoint <= 9631) {
+      block.set(column, text[index]);
+      column += 1;
+    } else if (BOX_DIRECTIONS.has(text[index])) {
+      box.set(column, text[index]);
+      column += 1;
+    } else {
+      simple = false;
+      break;
+    }
+  }
+  if (simple) return { box, block };
+  box.clear();
+  block.clear();
+  column = 0;
+  for (const grapheme of splitGraphemes(text)) {
+    const codepoint = grapheme.codePointAt(0) ?? 0;
+    if (codepoint >= 9600 && codepoint <= 9631) block.set(column, grapheme);
+    else if (BOX_DIRECTIONS.has(grapheme)) box.set(column, grapheme);
+    column += graphemeCellWidth(grapheme);
+  }
+  return { box, block };
+}
+function rgb(color) {
+  return [color[0] / 255, color[1] / 255, color[2] / 255, 1];
+}
+function over(source, backdrop) {
+  if (source[3] >= 1) return source;
+  if (source[3] <= 0) return backdrop;
+  const alpha = source[3] + backdrop[3] * (1 - source[3]);
+  if (alpha <= Number.EPSILON) return [0, 0, 0, 0];
+  return [
+    (source[0] * source[3] + backdrop[0] * backdrop[3] * (1 - source[3])) / alpha,
+    (source[1] * source[3] + backdrop[1] * backdrop[3] * (1 - source[3])) / alpha,
+    (source[2] * source[3] + backdrop[2] * backdrop[3] * (1 - source[3])) / alpha,
+    alpha
+  ];
+}
+function selectionContains(selection, row, column) {
+  if (!selection) return false;
+  const [start, end] = selection;
+  if (row < start.row || row > end.row) return false;
+  const first = row === start.row ? start.column : 0;
+  const last = row === end.row ? end.column : Number.MAX_SAFE_INTEGER;
+  return column >= first && column <= last;
+}
+function resolveStyle(style, theme) {
+  let foreground = style?.foreground ? rgb(style.foreground) : theme.foreground;
+  let background = style?.background ? rgb(style.background) : null;
+  if (style?.inverse) {
+    const originalForeground = foreground;
+    foreground = background ?? theme.background;
+    background = originalForeground;
+  }
+  if (style?.faint) foreground = [foreground[0], foreground[1], foreground[2], foreground[3] * 0.55];
+  return {
+    foreground,
+    background,
+    underline: style?.underline ?? false,
+    strikethrough: style?.strikethrough ?? false,
+    invisible: style?.invisible ?? false
+  };
+}
+function pushBoxDrawing(output, grapheme, column, row, scale, color, viewportWidth, viewportHeight) {
+  const directions = BOX_DIRECTIONS.get(grapheme);
+  if (!directions) return;
+  const left = (ORIGIN_X + column * CELL_WIDTH) * scale;
+  const right = (ORIGIN_X + (column + 1) * CELL_WIDTH) * scale;
+  const top = (ORIGIN_Y + row * LINE_HEIGHT) * scale;
+  const bottom = (ORIGIN_Y + (row + 1) * LINE_HEIGHT) * scale;
+  const stroke = Math.max(1, Math.round(scale));
+  const centerX = Math.round((left + right - stroke) / 2);
+  const centerY = Math.round((top + bottom - stroke) / 2);
+  if (ROUNDED_BOX_CORNERS.has(grapheme)) {
+    const x = centerX + stroke / 2;
+    const y = centerY + stroke / 2;
+    const points = [];
+    const [originX, originY, startAngle, endAngle] = grapheme === "\u256D" ? [right, bottom, -Math.PI / 2, -Math.PI] : grapheme === "\u256E" ? [left, bottom, -Math.PI / 2, 0] : grapheme === "\u256F" ? [left, top, Math.PI / 2, 0] : [right, top, Math.PI, Math.PI / 2];
+    const radiusX = Math.abs(right - x);
+    const radiusY = Math.abs(bottom - y);
+    const steps = Math.max(5, Math.ceil(Math.max(radiusX, radiusY) / 2));
+    for (let step = 0; step <= steps; step += 1) {
+      const angle = startAngle + (endAngle - startAngle) * (step / steps);
+      points.push([originX + Math.cos(angle) * radiusX, originY + Math.sin(angle) * radiusY]);
+    }
+    for (let index = 1; index < points.length; index += 1) {
+      const from = points[index - 1];
+      const to = points[index];
+      const dx = to[0] - from[0];
+      const dy = to[1] - from[1];
+      const length = Math.hypot(dx, dy);
+      if (length <= Number.EPSILON) continue;
+      const nx = -dy / length * stroke / 2;
+      const ny = dx / length * stroke / 2;
+      output.push(
+        clipX(from[0] + nx, viewportWidth),
+        clipY(from[1] + ny, viewportHeight),
+        clipX(to[0] + nx, viewportWidth),
+        clipY(to[1] + ny, viewportHeight),
+        clipX(from[0] - nx, viewportWidth),
+        clipY(from[1] - ny, viewportHeight),
+        ...color
+      );
+    }
+    return;
+  }
+  if (directions.includes("u"))
+    pushRectangle(output, centerX, top, stroke, centerY + stroke - top, color, viewportWidth, viewportHeight);
+  if (directions.includes("d"))
+    pushRectangle(output, centerX, centerY, stroke, bottom - centerY, color, viewportWidth, viewportHeight);
+  if (directions.includes("l"))
+    pushRectangle(output, left, centerY, centerX + stroke - left, stroke, color, viewportWidth, viewportHeight);
+  if (directions.includes("r"))
+    pushRectangle(output, centerX, centerY, right - centerX, stroke, color, viewportWidth, viewportHeight);
+}
+var LOWER_BLOCK_RECTANGLES = Array.from({ length: 7 }, (_, index) => [
+  [0, 1 - (index + 1) / 8, 1, 1]
+]);
+var LEFT_BLOCK_RECTANGLES = Array.from({ length: 7 }, (_, index) => [
+  [0, 0, (7 - index) / 8, 1]
+]);
+var FULL_BLOCK_RECTANGLES = [[0, 0, 1, 1]];
+var RIGHT_HALF_RECTANGLES = [[0.5, 0, 1, 1]];
+var UPPER_EIGHTH_RECTANGLES = [[0, 0, 1, 1 / 8]];
+var RIGHT_EIGHTH_RECTANGLES = [[7 / 8, 0, 1, 1]];
+var QUADRANT_RECTANGLES = [
+  [0, 0, 0.5, 0.5],
+  [0.5, 0, 1, 0.5],
+  [0, 0.5, 0.5, 1],
+  [0.5, 0.5, 1, 1]
+];
+var QUADRANT_BLOCK_RECTANGLES = new Map(
+  [
+    [9622, [2]],
+    [9623, [3]],
+    [9624, [0]],
+    [9625, [0, 2, 3]],
+    [9626, [0, 3]],
+    [9627, [0, 1, 2]],
+    [9628, [0, 1, 3]],
+    [9629, [1]],
+    [9630, [1, 2]],
+    [9631, [1, 2, 3]]
+  ].map(([codepoint, quadrants]) => [
+    codepoint,
+    quadrants.map((quadrant) => QUADRANT_RECTANGLES[quadrant])
+  ])
+);
+function blockElementRectangles(codepoint) {
+  if (codepoint >= 9601 && codepoint <= 9607) return LOWER_BLOCK_RECTANGLES[codepoint - 9601];
+  if (codepoint === 9608) return FULL_BLOCK_RECTANGLES;
+  if (codepoint >= 9609 && codepoint <= 9615) return LEFT_BLOCK_RECTANGLES[codepoint - 9609];
+  if (codepoint === 9616) return RIGHT_HALF_RECTANGLES;
+  if (codepoint === 9620) return UPPER_EIGHTH_RECTANGLES;
+  if (codepoint === 9621) return RIGHT_EIGHTH_RECTANGLES;
+  return QUADRANT_BLOCK_RECTANGLES.get(codepoint);
+}
+function pushBlockElement(output, grapheme, column, row, scale, color, viewportWidth, viewportHeight) {
+  const codepoint = grapheme.charCodeAt(0);
+  if (codepoint < 9600 || codepoint > 9631) return false;
+  const cellLeft = (ORIGIN_X + column * CELL_WIDTH) * scale;
+  const cellRight = (ORIGIN_X + (column + 1) * CELL_WIDTH) * scale;
+  const cellTop = (ORIGIN_Y + row * LINE_HEIGHT) * scale;
+  const cellBottom = (ORIGIN_Y + (row + 1) * LINE_HEIGHT) * scale;
+  if (codepoint === 9600) {
+    const x0 = Math.round(cellLeft);
+    const x1 = Math.round(cellRight);
+    const y0 = Math.round(cellTop);
+    const y1 = Math.round(cellTop + (cellBottom - cellTop) * 0.5);
+    pushRectangle(output, x0, y0, x1 - x0, y1 - y0, color, viewportWidth, viewportHeight);
+    return true;
+  }
+  const rectangles = blockElementRectangles(codepoint);
+  if (!rectangles) return false;
+  for (const [left, top, right, bottom] of rectangles) {
+    const x0 = Math.round(cellLeft + (cellRight - cellLeft) * left);
+    const x1 = Math.round(cellLeft + (cellRight - cellLeft) * right);
+    const y0 = Math.round(cellTop + (cellBottom - cellTop) * top);
+    const y1 = Math.round(cellTop + (cellBottom - cellTop) * bottom);
+    pushRectangle(output, x0, y0, x1 - x0, y1 - y0, color, viewportWidth, viewportHeight);
+  }
+  return true;
+}
+var WebGpuTerminalRenderer = class _WebGpuTerminalRenderer {
+  constructor(device, format) {
+    this.device = device;
+    this.format = format;
+    const rectangleModule = device.createShaderModule({ label: "terminal rectangle shader", code: RECT_SHADER });
+    const glyphModule = device.createShaderModule({ label: "terminal glyph shader", code: MONO_GLYPH_SHADER });
+    const fallbackGlyphModule = device.createShaderModule({
+      label: "terminal fallback glyph shader",
+      code: FALLBACK_GLYPH_SHADER
+    });
+    const colorGlyphModule = device.createShaderModule({
+      label: "terminal color glyph shader",
+      code: COLOR_GLYPH_SHADER
+    });
+    const postProcessModule = device.createShaderModule({ label: "Ghostty bettercrt shader", code: BETTER_CRT_SHADER });
+    this.#rectanglePipeline = device.createRenderPipeline({
+      label: "terminal rectangle pipeline",
+      layout: "auto",
+      vertex: {
+        module: rectangleModule,
+        entryPoint: "vertex_main",
+        buffers: [
+          {
+            arrayStride: 40,
+            stepMode: "instance",
+            attributes: [
+              { shaderLocation: 0, offset: 0, format: "float32x2" },
+              { shaderLocation: 1, offset: 8, format: "float32x2" },
+              { shaderLocation: 2, offset: 16, format: "float32x2" },
+              { shaderLocation: 3, offset: 24, format: "float32x4" }
+            ]
+          }
+        ]
+      },
+      fragment: {
+        module: rectangleModule,
+        entryPoint: "fragment_main",
+        targets: [{ format, blend: premultipliedBlend }]
+      },
+      primitive: { topology: "triangle-list" }
+    });
+    this.#glyphPipeline = device.createRenderPipeline({
+      label: "terminal glyph pipeline",
+      layout: "auto",
+      vertex: {
+        module: glyphModule,
+        entryPoint: "vertex_main",
+        buffers: [
+          {
+            arrayStride: 48,
+            stepMode: "instance",
+            attributes: [
+              { shaderLocation: 0, offset: 0, format: "float32x4" },
+              { shaderLocation: 1, offset: 16, format: "float32x4" },
+              { shaderLocation: 2, offset: 32, format: "float32x4" }
+            ]
+          }
+        ]
+      },
+      fragment: { module: glyphModule, entryPoint: "fragment_main", targets: [{ format, blend: premultipliedBlend }] },
+      primitive: { topology: "triangle-list" }
+    });
+    this.#fallbackGlyphPipeline = device.createRenderPipeline({
+      label: "terminal fallback glyph pipeline",
+      layout: "auto",
+      vertex: {
+        module: fallbackGlyphModule,
+        entryPoint: "vertex_main",
+        buffers: [
+          {
+            arrayStride: 48,
+            stepMode: "instance",
+            attributes: [
+              { shaderLocation: 0, offset: 0, format: "float32x4" },
+              { shaderLocation: 1, offset: 16, format: "float32x4" },
+              { shaderLocation: 2, offset: 32, format: "float32x4" }
+            ]
+          }
+        ]
+      },
+      fragment: {
+        module: fallbackGlyphModule,
+        entryPoint: "fragment_main",
+        targets: [{ format, blend: premultipliedBlend }]
+      },
+      primitive: { topology: "triangle-list" }
+    });
+    this.#colorGlyphPipeline = device.createRenderPipeline({
+      label: "terminal color glyph pipeline",
+      layout: "auto",
+      vertex: {
+        module: colorGlyphModule,
+        entryPoint: "vertex_main",
+        buffers: [
+          {
+            arrayStride: 48,
+            stepMode: "instance",
+            attributes: [
+              { shaderLocation: 0, offset: 0, format: "float32x4" },
+              { shaderLocation: 1, offset: 16, format: "float32x4" },
+              { shaderLocation: 2, offset: 32, format: "float32x4" }
+            ]
+          }
+        ]
+      },
+      fragment: {
+        module: colorGlyphModule,
+        entryPoint: "fragment_main",
+        targets: [{ format, blend: premultipliedBlend }]
+      },
+      primitive: { topology: "triangle-list" }
+    });
+    this.#postProcessPipeline = device.createRenderPipeline({
+      label: "Ghostty custom shader pipeline",
+      layout: "auto",
+      vertex: { module: postProcessModule, entryPoint: "vertex_main" },
+      fragment: { module: postProcessModule, entryPoint: "fragment_main", targets: [{ format }] },
+      primitive: { topology: "triangle-list" }
+    });
+    this.#postProcessSampler = device.createSampler({
+      label: "Ghostty custom shader sampler",
+      addressModeU: "clamp-to-edge",
+      addressModeV: "clamp-to-edge",
+      minFilter: "linear",
+      magFilter: "linear"
+    });
+    this.#monoAtlas = new NativeGlyphAtlas(
+      device,
+      this.#glyphPipeline.getBindGroupLayout(0),
+      "native monochrome glyph atlas",
+      "r8unorm"
+    );
+    this.#colorAtlas = new NativeGlyphAtlas(
+      device,
+      this.#colorGlyphPipeline.getBindGroupLayout(0),
+      "native color glyph atlas",
+      "rgba8unorm"
+    );
+    this.#fallbackAtlas = new FallbackGlyphAtlas(device, this.#fallbackGlyphPipeline.getBindGroupLayout(0));
+  }
+  kind = "webgpu";
+  #surfaces = /* @__PURE__ */ new Map();
+  #rectanglePipeline;
+  #glyphPipeline;
+  #fallbackGlyphPipeline;
+  #colorGlyphPipeline;
+  #postProcessPipeline;
+  #postProcessSampler;
+  #monoAtlas;
+  #colorAtlas;
+  #fallbackAtlas;
+  #performanceMeasurementEnabled = false;
+  static async create(onLost) {
+    if (!navigator.gpu) throw new Error("WebGPU is unavailable");
+    const adapter = await navigator.gpu.requestAdapter();
+    if (!adapter) throw new Error("No WebGPU adapter is available");
+    const device = await adapter.requestDevice({ label: "Electron Ghostty terminal renderer" });
+    device.addEventListener("uncapturederror", (event) => {
+      console.error("[terminal-renderer] WebGPU validation error", event.error);
+    });
+    void device.lost.then((info) => {
+      if (info.reason !== "destroyed") onLost(info);
+    });
+    return new _WebGpuTerminalRenderer(device, navigator.gpu.getPreferredCanvasFormat());
+  }
+  setPerformanceMeasurementEnabled(enabled) {
+    this.#performanceMeasurementEnabled = enabled;
+  }
+  mount(id, canvas) {
+    const context = canvas.getContext("webgpu");
+    if (!context) throw new Error("WebGPU canvas context unavailable");
+    const sceneTexture = this.#createSceneTexture(canvas.width, canvas.height);
+    const surface2 = {
+      canvas,
+      context,
+      sceneTexture,
+      postProcessBindGroup: this.#createPostProcessBindGroup(sceneTexture),
+      width: 1,
+      height: 1,
+      dpr: 1,
+      rectangleBuffer: new DynamicVertexBuffer(this.device, `rectangles ${id}`),
+      glyphBuffer: new DynamicVertexBuffer(this.device, `glyphs ${id}`),
+      colorGlyphBuffer: new DynamicVertexBuffer(this.device, `color glyphs ${id}`),
+      fallbackGlyphBuffer: new DynamicVertexBuffer(this.device, `fallback glyphs ${id}`),
+      cursorBuffer: new DynamicVertexBuffer(this.device, `cursor ${id}`),
+      geometryCache: /* @__PURE__ */ new Map(),
+      geometryCandidates: /* @__PURE__ */ new Map(),
+      sceneValid: false
+    };
+    this.#surfaces.set(id, surface2);
+    this.#configure(surface2);
+  }
+  unmount(id) {
+    const surface2 = this.#surfaces.get(id);
+    if (!surface2) return;
+    surface2.context.unconfigure();
+    surface2.sceneTexture.destroy();
+    surface2.rectangleBuffer.destroy();
+    surface2.glyphBuffer.destroy();
+    surface2.colorGlyphBuffer.destroy();
+    surface2.fallbackGlyphBuffer.destroy();
+    surface2.cursorBuffer.destroy();
+    clearGeometryCache(surface2);
+    this.#surfaces.delete(id);
+  }
+  resize(id, size) {
+    const surface2 = this.#surfaces.get(id);
+    if (!surface2) return;
+    const changed = renderedSizeChanged(surface2, size);
+    Object.assign(surface2, size);
+    if (!changed) return;
+    surface2.canvas.width = Math.max(1, Math.round(size.width * size.dpr));
+    surface2.canvas.height = Math.max(1, Math.round(size.height * size.dpr));
+    this.#configure(surface2);
+  }
+  #configure(surface2) {
+    surface2.context.configure({ device: this.device, format: this.format, alphaMode: "premultiplied" });
+    surface2.sceneTexture.destroy();
+    surface2.sceneTexture = this.#createSceneTexture(surface2.canvas.width, surface2.canvas.height);
+    surface2.postProcessBindGroup = this.#createPostProcessBindGroup(surface2.sceneTexture);
+    clearGeometryCache(surface2);
+    surface2.sceneValid = false;
+  }
+  #createSceneTexture(width, height) {
+    return this.device.createTexture({
+      label: "terminal scene before Ghostty custom shaders",
+      size: [Math.max(1, width), Math.max(1, height)],
+      format: this.format,
+      usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
+    });
+  }
+  #createPostProcessBindGroup(texture) {
+    return this.device.createBindGroup({
+      label: "Ghostty custom shader bindings",
+      layout: this.#postProcessPipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: texture.createView() },
+        { binding: 1, resource: this.#postProcessSampler }
+      ]
+    });
+  }
+  render(id, view) {
+    if (!this.#surfaces.has(id)) return;
+    const encoder = this.device.createCommandEncoder({ label: `terminal frame ${id}` });
+    const metrics = view.damage?.geometryChanged === false ? this.#encodeCachedRender(id, view, encoder) : this.#encodeRender(id, view, encoder);
+    this.device.queue.submit([encoder.finish()]);
+    if (metrics) metrics.queueSubmits = 1;
+    return metrics;
+  }
+  renderBatch(entries) {
+    const active = entries.filter(({ id }) => this.#surfaces.has(id));
+    if (active.length === 0) return entries.map(() => void 0);
+    const encoder = this.device.createCommandEncoder({ label: `terminal frame batch (${active.length} panes)` });
+    const byId = /* @__PURE__ */ new Map();
+    for (const { id, view } of active) {
+      byId.set(
+        id,
+        view.damage?.geometryChanged === false ? this.#encodeCachedRender(id, view, encoder) : this.#encodeRender(id, view, encoder)
+      );
+    }
+    this.device.queue.submit([encoder.finish()]);
+    const firstMetrics = [...byId.values()].find((metrics) => metrics !== void 0);
+    if (firstMetrics) firstMetrics.queueSubmits = 1;
+    return entries.map(({ id }) => byId.get(id));
+  }
+  #buildGeometry(view, renderRows, rowCount, fullRedraw, hasNativeRows, scale, viewportWidth, viewportHeight) {
+    const rectangleVertices = [];
+    const glyphVertices = [];
+    const colorGlyphVertices = [];
+    const fallbackGlyphVertices = [];
+    const resolvedStyles = /* @__PURE__ */ new Map();
+    const styleFor = (styleId) => {
+      const cached = resolvedStyles.get(styleId);
+      if (cached) return cached;
+      const resolved = resolveStyle(view.styleDefinitions.get(styleId), view.theme);
+      resolvedStyles.set(styleId, resolved);
+      return resolved;
+    };
+    const monoDefinitions = /* @__PURE__ */ new Map();
+    const colorDefinitions = /* @__PURE__ */ new Map();
+    for (const row of renderRows) {
+      for (const glyph of view.nativeRows[row] ?? []) {
+        const definition = view.glyphDefinitions.get(glyph.glyphId);
+        if (!definition) continue;
+        (definition.format === GlyphFormat.Rgba8Premultiplied ? colorDefinitions : monoDefinitions).set(
+          definition.id,
+          definition
+        );
+      }
+    }
+    this.#monoAtlas.prepare(monoDefinitions.values());
+    this.#colorAtlas.prepare(colorDefinitions.values());
+    if (!fullRedraw) {
+      for (const row of renderRows) {
+        const top = row === 0 ? 0 : (ORIGIN_Y + row * LINE_HEIGHT) * scale;
+        const bottom = row === rowCount - 1 ? viewportHeight : Math.min(viewportHeight, (ORIGIN_Y + (row + 1) * LINE_HEIGHT) * scale);
+        pushRectangle(
+          rectangleVertices,
+          0,
+          top,
+          viewportWidth,
+          Math.max(0, bottom - top),
+          // The rectangle pipeline blends. Force the row reset opaque so it
+          // replaces stale scene pixels even when a theme carries alpha.
+          [view.theme.background[0], view.theme.background[1], view.theme.background[2], 1],
+          viewportWidth,
+          viewportHeight
+        );
+      }
+    }
+    for (const row of renderRows) {
+      for (const run of view.nativeStyleRows[row] ?? []) {
+        const style = styleFor(run.styleId);
+        if (!style.background) continue;
+        pushRectangle(
+          rectangleVertices,
+          (ORIGIN_X + run.cellStart * CELL_WIDTH) * scale,
+          (ORIGIN_Y + row * LINE_HEIGHT) * scale,
+          run.cellSpan * CELL_WIDTH * scale,
+          LINE_HEIGHT * scale,
+          style.background,
+          viewportWidth,
+          viewportHeight
+        );
+      }
+    }
+    const backgroundInstanceCount = rectangleVertices.length / 10;
+    const selection = ordered2(view.selection);
+    if (selection) {
+      const [start, end] = selection;
+      for (const row of renderRows) {
+        if (row < start.row || row > end.row) continue;
+        const first = row === start.row ? start.column : 0;
+        const last = row === end.row ? end.column : Math.max(0, cellLength(view.rows[row] ?? "") - 1);
+        pushRectangle(
+          rectangleVertices,
+          (ORIGIN_X + first * CELL_WIDTH) * scale,
+          (ORIGIN_Y + row * LINE_HEIGHT) * scale,
+          Math.max(1, last - first + 1) * CELL_WIDTH * scale,
+          LINE_HEIGHT * scale,
+          view.theme.selection,
+          viewportWidth,
+          viewportHeight
+        );
+      }
+    }
+    const selectionInstanceCount = rectangleVertices.length / 10 - backgroundInstanceCount;
+    if (!hasNativeRows) {
+      this.#fallbackAtlas.prepare(
+        renderRows.flatMap((row) => splitGraphemes(view.rows[row] ?? "")),
+        scale
+      );
+    }
+    if (hasNativeRows) {
+      for (const row of renderRows) {
+        const { box: boxCells, block: blockCells } = specialDrawingCells(view.rows[row] ?? "");
+        for (const instance of view.nativeRows[row] ?? []) {
+          const definition = view.glyphDefinitions.get(instance.glyphId);
+          if (!definition) continue;
+          const style = styleFor(instance.styleId);
+          if (style.invisible) continue;
+          const isSelected = selectionContains(selection, row, instance.cellStart);
+          const foreground = isSelected ? view.theme.selectionForeground : style.foreground;
+          const boxDrawing = boxCells.get(instance.cellStart);
+          if (boxDrawing) {
+            let backdrop = style.background ?? view.theme.background;
+            if (isSelected) backdrop = view.theme.selection;
+            pushBoxDrawing(
+              rectangleVertices,
+              boxDrawing,
+              instance.cellStart,
+              row,
+              scale,
+              over(foreground, backdrop),
+              viewportWidth,
+              viewportHeight
+            );
+            continue;
+          }
+          const blockElement = blockCells.get(instance.cellStart);
+          if (blockElement) {
+            let backdrop = style.background ?? view.theme.background;
+            if (isSelected) backdrop = view.theme.selection;
+            if (pushBlockElement(
+              rectangleVertices,
+              blockElement,
+              instance.cellStart,
+              row,
+              scale,
+              over(foreground, backdrop),
+              viewportWidth,
+              viewportHeight
+            ))
+              continue;
+          }
+          const atlas = definition.format === GlyphFormat.Alpha8 ? this.#monoAtlas : this.#colorAtlas;
+          const vertices = definition.format === GlyphFormat.Alpha8 ? glyphVertices : colorGlyphVertices;
+          pushGlyph(
+            vertices,
+            (ORIGIN_X + instance.x) * scale,
+            (ORIGIN_Y + row * LINE_HEIGHT + instance.y) * scale,
+            instance.width * scale,
+            instance.height * scale,
+            atlas.glyph(definition),
+            foreground,
+            viewportWidth,
+            viewportHeight
+          );
+        }
+      }
+    } else {
+      for (const row of renderRows) {
+        let column = 0;
+        for (const grapheme of splitGraphemes(view.rows[row] ?? "")) {
+          const glyph = this.#fallbackAtlas.glyph(grapheme, scale);
+          const cells = glyph?.cells ?? graphemeCellWidth(grapheme);
+          if (glyph) {
+            const foreground = selectionContains(selection, row, column) ? view.theme.selectionForeground : view.theme.foreground;
+            pushGlyph(
+              fallbackGlyphVertices,
+              (ORIGIN_X + column * CELL_WIDTH) * scale,
+              (ORIGIN_Y + row * LINE_HEIGHT) * scale,
+              CELL_WIDTH * cells * scale,
+              LINE_HEIGHT * scale,
+              glyph,
+              foreground,
+              viewportWidth,
+              viewportHeight
+            );
+          }
+          column += cells;
+        }
+      }
+    }
+    for (const row of renderRows) {
+      for (const run of view.nativeStyleRows[row] ?? []) {
+        const style = styleFor(run.styleId);
+        if (style.invisible) continue;
+        const x = (ORIGIN_X + run.cellStart * CELL_WIDTH) * scale;
+        const width = run.cellSpan * CELL_WIDTH * scale;
+        const rowTop = (ORIGIN_Y + row * LINE_HEIGHT) * scale;
+        const stroke = Math.max(1, Math.round(scale));
+        if (style.underline) {
+          pushRectangle(
+            rectangleVertices,
+            x,
+            Math.round(rowTop + 16 * scale),
+            width,
+            stroke,
+            style.foreground,
+            viewportWidth,
+            viewportHeight
+          );
+        }
+        if (style.strikethrough) {
+          pushRectangle(
+            rectangleVertices,
+            x,
+            Math.round(rowTop + 9 * scale),
+            width,
+            stroke,
+            style.foreground,
+            viewportWidth,
+            viewportHeight
+          );
+        }
+      }
+    }
+    const decorationInstanceStart = backgroundInstanceCount + selectionInstanceCount;
+    const decorationInstanceCount = rectangleVertices.length / 10 - decorationInstanceStart;
+    return {
+      rectangleData: new Float32Array(rectangleVertices),
+      glyphData: new Float32Array(glyphVertices),
+      colorGlyphData: new Float32Array(colorGlyphVertices),
+      fallbackGlyphData: new Float32Array(fallbackGlyphVertices),
+      backgroundInstanceCount,
+      selectionInstanceCount,
+      decorationInstanceStart,
+      decorationInstanceCount,
+      rectangleInstanceCount: rectangleVertices.length / 10,
+      glyphInstanceCount: glyphVertices.length / 12,
+      colorGlyphInstanceCount: colorGlyphVertices.length / 12,
+      fallbackGlyphInstanceCount: fallbackGlyphVertices.length / 12
+    };
+  }
+  #encodeRender(id, view, encoder) {
+    const surface2 = this.#surfaces.get(id);
+    if (!surface2) return;
+    const monoUploadsBefore = this.#performanceMeasurementEnabled ? this.#monoAtlas.uploadMetrics() : void 0;
+    const colorUploadsBefore = this.#performanceMeasurementEnabled ? this.#colorAtlas.uploadMetrics() : void 0;
+    const fallbackUploadsBefore = this.#performanceMeasurementEnabled ? this.#fallbackAtlas.uploadMetrics() : void 0;
+    const scale = surface2.dpr;
+    const viewportWidth = surface2.canvas.width;
+    const viewportHeight = surface2.canvas.height;
+    const rowCount = Math.max(view.rows.length, view.nativeRows.length, view.nativeStyleRows.length);
+    const { full: fullRedraw, rows: renderRows } = rowsForDamage(rowCount, view.damage, surface2.sceneValid);
+    const renderRowSet = new Set(renderRows);
+    const rectangleVertices = [];
+    const glyphVertices = [];
+    const colorGlyphVertices = [];
+    const fallbackGlyphVertices = [];
+    const resolvedStyles = /* @__PURE__ */ new Map();
+    const styleFor = (styleId) => {
+      const cached = resolvedStyles.get(styleId);
+      if (cached) return cached;
+      const resolved = resolveStyle(view.styleDefinitions.get(styleId), view.theme);
+      resolvedStyles.set(styleId, resolved);
+      return resolved;
+    };
+    const monoDefinitions = /* @__PURE__ */ new Map();
+    const colorDefinitions = /* @__PURE__ */ new Map();
+    for (const row of renderRows) {
+      for (const glyph of view.nativeRows[row] ?? []) {
+        const definition = view.glyphDefinitions.get(glyph.glyphId);
+        if (!definition) continue;
+        (definition.format === GlyphFormat.Rgba8Premultiplied ? colorDefinitions : monoDefinitions).set(
+          definition.id,
+          definition
+        );
+      }
+    }
+    this.#monoAtlas.prepare(monoDefinitions.values());
+    this.#colorAtlas.prepare(colorDefinitions.values());
+    if (!fullRedraw) {
+      for (const row of renderRows) {
+        const top = row === 0 ? 0 : (ORIGIN_Y + row * LINE_HEIGHT) * scale;
+        const bottom = row === rowCount - 1 ? viewportHeight : Math.min(viewportHeight, (ORIGIN_Y + (row + 1) * LINE_HEIGHT) * scale);
+        pushRectangle(
+          rectangleVertices,
+          0,
+          top,
+          viewportWidth,
+          Math.max(0, bottom - top),
+          // The rectangle pipeline blends. Force the row reset opaque so it
+          // replaces stale scene pixels even when a theme carries alpha.
+          [view.theme.background[0], view.theme.background[1], view.theme.background[2], 1],
+          viewportWidth,
+          viewportHeight
+        );
+      }
+    }
+    for (const row of renderRows) {
+      for (const run of view.nativeStyleRows[row] ?? []) {
+        const style = styleFor(run.styleId);
+        if (!style.background) continue;
+        pushRectangle(
+          rectangleVertices,
+          (ORIGIN_X + run.cellStart * CELL_WIDTH) * scale,
+          (ORIGIN_Y + row * LINE_HEIGHT) * scale,
+          run.cellSpan * CELL_WIDTH * scale,
+          LINE_HEIGHT * scale,
+          style.background,
+          viewportWidth,
+          viewportHeight
+        );
+      }
+    }
+    const backgroundInstanceCount = rectangleVertices.length / 10;
+    const selection = ordered2(view.selection);
+    if (selection) {
+      const [start, end] = selection;
+      for (const row of renderRows) {
+        if (row < start.row || row > end.row) continue;
+        const first = row === start.row ? start.column : 0;
+        const last = row === end.row ? end.column : Math.max(0, cellLength(view.rows[row] ?? "") - 1);
+        pushRectangle(
+          rectangleVertices,
+          (ORIGIN_X + first * CELL_WIDTH) * scale,
+          (ORIGIN_Y + row * LINE_HEIGHT) * scale,
+          Math.max(1, last - first + 1) * CELL_WIDTH * scale,
+          LINE_HEIGHT * scale,
+          view.theme.selection,
+          viewportWidth,
+          viewportHeight
+        );
+      }
+    }
+    const selectionInstanceCount = rectangleVertices.length / 10 - backgroundInstanceCount;
+    const hasNativeRows = view.nativeRows.some((row) => row.length > 0);
+    if (!hasNativeRows) {
+      this.#fallbackAtlas.prepare(
+        renderRows.flatMap((row) => splitGraphemes(view.rows[row] ?? "")),
+        scale
+      );
+    }
+    if (hasNativeRows) {
+      for (const row of renderRows) {
+        const { box: boxCells, block: blockCells } = specialDrawingCells(view.rows[row] ?? "");
+        for (const instance of view.nativeRows[row] ?? []) {
+          const definition = view.glyphDefinitions.get(instance.glyphId);
+          if (!definition) continue;
+          const style = styleFor(instance.styleId);
+          if (style.invisible) continue;
+          const isSelected = selectionContains(selection, row, instance.cellStart);
+          const foreground = isSelected ? view.theme.selectionForeground : style.foreground;
+          const boxDrawing = boxCells.get(instance.cellStart);
+          if (boxDrawing) {
+            let backdrop = style.background ?? view.theme.background;
+            if (isSelected) backdrop = view.theme.selection;
+            const boxColor = over(foreground, backdrop);
+            pushBoxDrawing(
+              rectangleVertices,
+              boxDrawing,
+              instance.cellStart,
+              row,
+              scale,
+              boxColor,
+              viewportWidth,
+              viewportHeight
+            );
+            continue;
+          }
+          const blockElement = blockCells.get(instance.cellStart);
+          if (blockElement) {
+            let backdrop = style.background ?? view.theme.background;
+            if (isSelected) backdrop = view.theme.selection;
+            const blockColor = over(foreground, backdrop);
+            if (pushBlockElement(
+              rectangleVertices,
+              blockElement,
+              instance.cellStart,
+              row,
+              scale,
+              blockColor,
+              viewportWidth,
+              viewportHeight
+            ))
+              continue;
+          }
+          const atlas = definition.format === GlyphFormat.Alpha8 ? this.#monoAtlas : this.#colorAtlas;
+          const vertices = definition.format === GlyphFormat.Alpha8 ? glyphVertices : colorGlyphVertices;
+          pushGlyph(
+            vertices,
+            (ORIGIN_X + instance.x) * scale,
+            (ORIGIN_Y + row * LINE_HEIGHT + instance.y) * scale,
+            instance.width * scale,
+            instance.height * scale,
+            atlas.glyph(definition),
+            foreground,
+            viewportWidth,
+            viewportHeight
+          );
+        }
+      }
+    } else {
+      for (const row of renderRows) {
+        let column = 0;
+        for (const grapheme of splitGraphemes(view.rows[row] ?? "")) {
+          const glyph = this.#fallbackAtlas.glyph(grapheme, scale);
+          const cells = glyph?.cells ?? graphemeCellWidth(grapheme);
+          if (glyph) {
+            const foreground = selectionContains(selection, row, column) ? view.theme.selectionForeground : view.theme.foreground;
+            pushGlyph(
+              fallbackGlyphVertices,
+              (ORIGIN_X + column * CELL_WIDTH) * scale,
+              (ORIGIN_Y + row * LINE_HEIGHT) * scale,
+              CELL_WIDTH * cells * scale,
+              LINE_HEIGHT * scale,
+              glyph,
+              foreground,
+              viewportWidth,
+              viewportHeight
+            );
+          }
+          column += cells;
+        }
+      }
+    }
+    for (const row of renderRows) {
+      for (const run of view.nativeStyleRows[row] ?? []) {
+        const style = styleFor(run.styleId);
+        if (style.invisible) continue;
+        const x = (ORIGIN_X + run.cellStart * CELL_WIDTH) * scale;
+        const width = run.cellSpan * CELL_WIDTH * scale;
+        const rowTop = (ORIGIN_Y + row * LINE_HEIGHT) * scale;
+        const stroke = Math.max(1, Math.round(scale));
+        if (style.underline) {
+          pushRectangle(
+            rectangleVertices,
+            x,
+            Math.round(rowTop + 16 * scale),
+            width,
+            stroke,
+            style.foreground,
+            viewportWidth,
+            viewportHeight
+          );
+        }
+        if (style.strikethrough) {
+          pushRectangle(
+            rectangleVertices,
+            x,
+            Math.round(rowTop + 9 * scale),
+            width,
+            stroke,
+            style.foreground,
+            viewportWidth,
+            viewportHeight
+          );
+        }
+      }
+    }
+    const decorationInstanceStart = backgroundInstanceCount + selectionInstanceCount;
+    const decorationInstanceCount = rectangleVertices.length / 10 - decorationInstanceStart;
+    const cursorStyle = effectiveCursorStyle(view);
+    if (cursorStyle !== null && renderRowSet.has(view.cursor.y)) {
+      const x = (ORIGIN_X + view.cursor.x * CELL_WIDTH) * scale;
+      const y = (ORIGIN_Y + view.cursor.y * LINE_HEIGHT) * scale;
+      const width = CELL_WIDTH * scale;
+      const height = LINE_HEIGHT * scale;
+      const stroke = Math.max(1, Math.round(scale));
+      const cursorColor = cursorStyle === CursorStyle.HollowBlock ? [view.theme.cursor[0], view.theme.cursor[1], view.theme.cursor[2], 1] : view.theme.cursor;
+      if (cursorStyle === CursorStyle.Bar) {
+        pushRectangle(
+          rectangleVertices,
+          x,
+          y,
+          Math.max(2, Math.round(2 * scale)),
+          height,
+          cursorColor,
+          viewportWidth,
+          viewportHeight
+        );
+      } else if (cursorStyle === CursorStyle.Underline) {
+        const thickness = Math.max(2, Math.round(2 * scale));
+        pushRectangle(
+          rectangleVertices,
+          x,
+          y + height - thickness,
+          width,
+          thickness,
+          cursorColor,
+          viewportWidth,
+          viewportHeight
+        );
+      } else if (cursorStyle === CursorStyle.HollowBlock) {
+        pushRectangle(rectangleVertices, x, y, width, stroke, cursorColor, viewportWidth, viewportHeight);
+        pushRectangle(
+          rectangleVertices,
+          x,
+          y + height - stroke,
+          width,
+          stroke,
+          cursorColor,
+          viewportWidth,
+          viewportHeight
+        );
+        pushRectangle(
+          rectangleVertices,
+          x,
+          y + stroke,
+          stroke,
+          Math.max(0, height - stroke * 2),
+          cursorColor,
+          viewportWidth,
+          viewportHeight
+        );
+        pushRectangle(
+          rectangleVertices,
+          x + width - stroke,
+          y + stroke,
+          stroke,
+          Math.max(0, height - stroke * 2),
+          cursorColor,
+          viewportWidth,
+          viewportHeight
+        );
+      } else {
+        pushRectangle(rectangleVertices, x, y, width, height, cursorColor, viewportWidth, viewportHeight);
+      }
+    }
+    const rectangleData = new Float32Array(rectangleVertices);
+    const glyphData = new Float32Array(glyphVertices);
+    const colorGlyphData = new Float32Array(colorGlyphVertices);
+    const fallbackGlyphData = new Float32Array(fallbackGlyphVertices);
+    const rectangleBuffer = surface2.rectangleBuffer.write(rectangleData);
+    const glyphBuffer = surface2.glyphBuffer.write(glyphData);
+    const colorGlyphBuffer = surface2.colorGlyphBuffer.write(colorGlyphData);
+    const fallbackGlyphBuffer = surface2.fallbackGlyphBuffer.write(fallbackGlyphData);
+    const cursorInstanceStart = decorationInstanceStart + decorationInstanceCount;
+    const cursorInstanceCount = rectangleVertices.length / 10 - cursorInstanceStart;
+    const pass = encoder.beginRenderPass({
+      label: `terminal pass ${id}`,
+      colorAttachments: [
+        {
+          view: surface2.sceneTexture.createView(),
+          clearValue: {
+            r: view.theme.background[0],
+            g: view.theme.background[1],
+            b: view.theme.background[2],
+            a: view.theme.background[3]
+          },
+          loadOp: fullRedraw ? "clear" : "load",
+          storeOp: "store"
+        }
+      ]
+    });
+    if (rectangleBuffer && backgroundInstanceCount > 0) {
+      pass.setPipeline(this.#rectanglePipeline);
+      pass.setVertexBuffer(0, rectangleBuffer);
+      pass.draw(6, backgroundInstanceCount);
+    }
+    if (rectangleBuffer && selectionInstanceCount > 0) {
+      pass.setPipeline(this.#rectanglePipeline);
+      pass.setVertexBuffer(0, rectangleBuffer);
+      pass.draw(6, selectionInstanceCount, 0, backgroundInstanceCount);
+    }
+    if (glyphBuffer && glyphData.length > 0) {
+      pass.setPipeline(this.#glyphPipeline);
+      pass.setBindGroup(0, this.#monoAtlas.bindGroup);
+      pass.setVertexBuffer(0, glyphBuffer);
+      pass.draw(6, glyphVertices.length / 12);
+    }
+    if (colorGlyphBuffer && colorGlyphData.length > 0) {
+      pass.setPipeline(this.#colorGlyphPipeline);
+      pass.setBindGroup(0, this.#colorAtlas.bindGroup);
+      pass.setVertexBuffer(0, colorGlyphBuffer);
+      pass.draw(6, colorGlyphVertices.length / 12);
+    }
+    if (fallbackGlyphBuffer && fallbackGlyphData.length > 0) {
+      pass.setPipeline(this.#fallbackGlyphPipeline);
+      pass.setBindGroup(0, this.#fallbackAtlas.bindGroup);
+      pass.setVertexBuffer(0, fallbackGlyphBuffer);
+      pass.draw(6, fallbackGlyphVertices.length / 12);
+    }
+    if (rectangleBuffer && decorationInstanceCount > 0) {
+      pass.setPipeline(this.#rectanglePipeline);
+      pass.setVertexBuffer(0, rectangleBuffer);
+      pass.draw(6, decorationInstanceCount, 0, decorationInstanceStart);
+    }
+    if (rectangleBuffer && cursorInstanceCount > 0) {
+      pass.setPipeline(this.#rectanglePipeline);
+      pass.setVertexBuffer(0, rectangleBuffer);
+      pass.draw(6, cursorInstanceCount, 0, cursorInstanceStart);
+    }
+    pass.end();
+    const postProcessPass = encoder.beginRenderPass({
+      label: `Ghostty custom shader pass ${id}`,
+      colorAttachments: [
+        {
+          view: surface2.context.getCurrentTexture().createView(),
+          clearValue: {
+            r: view.theme.background[0],
+            g: view.theme.background[1],
+            b: view.theme.background[2],
+            a: 1
+          },
+          loadOp: "clear",
+          storeOp: "store"
+        }
+      ]
+    });
+    postProcessPass.setPipeline(this.#postProcessPipeline);
+    postProcessPass.setBindGroup(0, surface2.postProcessBindGroup);
+    postProcessPass.draw(3);
+    postProcessPass.end();
+    surface2.sceneValid = true;
+    if (!this.#performanceMeasurementEnabled) return void 0;
+    const monoUploadsAfter = this.#monoAtlas.uploadMetrics();
+    const colorUploadsAfter = this.#colorAtlas.uploadMetrics();
+    const fallbackUploadsAfter = this.#fallbackAtlas.uploadMetrics();
+    return {
+      queueSubmits: 0,
+      fullRenders: Number(fullRedraw),
+      partialRenders: Number(!fullRedraw),
+      damagedRows: renderRows.length,
+      geometryCacheHits: 0,
+      geometryCacheMisses: 0,
+      canvasPixels: viewportWidth * viewportHeight,
+      renderPasses: 2,
+      drawCalls: Number(backgroundInstanceCount > 0) + Number(selectionInstanceCount > 0) + Number(glyphData.length > 0) + Number(colorGlyphData.length > 0) + Number(fallbackGlyphData.length > 0) + Number(decorationInstanceCount > 0) + Number(cursorInstanceCount > 0) + 1,
+      rectangleVertices: rectangleVertices.length / 10 * 6,
+      monoGlyphVertices: glyphVertices.length / 12 * 6,
+      colorGlyphVertices: colorGlyphVertices.length / 12 * 6,
+      fallbackGlyphVertices: fallbackGlyphVertices.length / 12 * 6,
+      vertexUploadBytes: rectangleData.byteLength + glyphData.byteLength + colorGlyphData.byteLength + fallbackGlyphData.byteLength,
+      atlasUploadBytes: monoUploadsAfter.bytes - monoUploadsBefore.bytes + (colorUploadsAfter.bytes - colorUploadsBefore.bytes) + (fallbackUploadsAfter.bytes - fallbackUploadsBefore.bytes),
+      atlasUploadCalls: monoUploadsAfter.calls - monoUploadsBefore.calls + (colorUploadsAfter.calls - colorUploadsBefore.calls) + (fallbackUploadsAfter.calls - fallbackUploadsBefore.calls)
+    };
+  }
+  #encodeCachedRender(id, view, encoder) {
+    const surface2 = this.#surfaces.get(id);
+    if (!surface2) return;
+    if (!surface2.sceneValid || !view.damage || view.damage.full) return this.#encodeRender(id, view, encoder);
+    const rowCount = Math.max(view.rows.length, view.nativeRows.length, view.nativeStyleRows.length);
+    const damage = rowsForDamage(rowCount, view.damage, surface2.sceneValid);
+    const monoUploadsBefore = this.#performanceMeasurementEnabled ? this.#monoAtlas.uploadMetrics() : void 0;
+    const colorUploadsBefore = this.#performanceMeasurementEnabled ? this.#colorAtlas.uploadMetrics() : void 0;
+    const fallbackUploadsBefore = this.#performanceMeasurementEnabled ? this.#fallbackAtlas.uploadMetrics() : void 0;
+    const scale = surface2.dpr;
+    const viewportWidth = surface2.canvas.width;
+    const viewportHeight = surface2.canvas.height;
+    const renderRowSet = new Set(damage.rows);
+    const hasNativeRows = view.nativeRows.some((row) => row.length > 0);
+    let geometry;
+    let geometryUploadBytes = 0;
+    const generations = () => [
+      this.#monoAtlas.generation,
+      this.#colorAtlas.generation,
+      this.#fallbackAtlas.generation
+    ];
+    let key = geometryCacheKey(view, damage.rows, hasNativeRows, generations());
+    const cached = surface2.geometryCache.get(key);
+    const cacheHit = cached !== void 0;
+    if (cached) {
+      geometry = cached;
+      surface2.geometryCache.delete(key);
+      surface2.geometryCache.set(key, cached);
+    } else {
+      const admitted = surface2.geometryCandidates.has(key);
+      const candidateKey = key;
+      const cpu = this.#buildGeometry(
+        view,
+        damage.rows,
+        rowCount,
+        false,
+        hasNativeRows,
+        scale,
+        viewportWidth,
+        viewportHeight
+      );
+      key = geometryCacheKey(view, damage.rows, hasNativeRows, generations());
+      const promote = admitted && key === candidateKey;
+      geometry = {
+        rectangleBuffer: promote ? createCachedVertexBuffer(this.device, `cached rectangles ${id}`, cpu.rectangleData) : surface2.rectangleBuffer.write(cpu.rectangleData),
+        glyphBuffer: promote ? createCachedVertexBuffer(this.device, `cached glyphs ${id}`, cpu.glyphData) : surface2.glyphBuffer.write(cpu.glyphData),
+        colorGlyphBuffer: promote ? createCachedVertexBuffer(this.device, `cached color glyphs ${id}`, cpu.colorGlyphData) : surface2.colorGlyphBuffer.write(cpu.colorGlyphData),
+        fallbackGlyphBuffer: promote ? createCachedVertexBuffer(this.device, `cached fallback glyphs ${id}`, cpu.fallbackGlyphData) : surface2.fallbackGlyphBuffer.write(cpu.fallbackGlyphData),
+        backgroundInstanceCount: cpu.backgroundInstanceCount,
+        selectionInstanceCount: cpu.selectionInstanceCount,
+        decorationInstanceStart: cpu.decorationInstanceStart,
+        decorationInstanceCount: cpu.decorationInstanceCount,
+        rectangleInstanceCount: cpu.rectangleInstanceCount,
+        glyphInstanceCount: cpu.glyphInstanceCount,
+        colorGlyphInstanceCount: cpu.colorGlyphInstanceCount,
+        fallbackGlyphInstanceCount: cpu.fallbackGlyphInstanceCount
+      };
+      geometryUploadBytes = cpu.rectangleData.byteLength + cpu.glyphData.byteLength + cpu.colorGlyphData.byteLength + cpu.fallbackGlyphData.byteLength;
+      if (promote) {
+        surface2.geometryCandidates.delete(key);
+        surface2.geometryCache.set(key, geometry);
+        while (surface2.geometryCache.size > GEOMETRY_CACHE_LIMIT) {
+          const oldestKey = surface2.geometryCache.keys().next().value;
+          if (oldestKey === void 0) break;
+          const oldest = surface2.geometryCache.get(oldestKey);
+          if (oldest) destroyCachedGeometry(oldest);
+          surface2.geometryCache.delete(oldestKey);
+        }
+      } else {
+        surface2.geometryCandidates.delete(key);
+        surface2.geometryCandidates.set(key, true);
+        while (surface2.geometryCandidates.size > GEOMETRY_CACHE_LIMIT) {
+          const oldestKey = surface2.geometryCandidates.keys().next().value;
+          if (oldestKey === void 0) break;
+          surface2.geometryCandidates.delete(oldestKey);
+        }
+      }
+    }
+    const cursorVertices = [];
+    pushCursorVertices(cursorVertices, view, renderRowSet, scale, viewportWidth, viewportHeight);
+    const cursorData = new Float32Array(cursorVertices);
+    const cursorBuffer = surface2.cursorBuffer.write(cursorData);
+    const cursorInstanceStart = 0;
+    const cursorInstanceCount = cursorData.length / 10;
+    const pass = encoder.beginRenderPass({
+      label: `terminal pass ${id}`,
+      colorAttachments: [
+        {
+          view: surface2.sceneTexture.createView(),
+          clearValue: {
+            r: view.theme.background[0],
+            g: view.theme.background[1],
+            b: view.theme.background[2],
+            a: view.theme.background[3]
+          },
+          loadOp: "load",
+          storeOp: "store"
+        }
+      ]
+    });
+    if (geometry.rectangleBuffer && geometry.backgroundInstanceCount > 0) {
+      pass.setPipeline(this.#rectanglePipeline);
+      pass.setVertexBuffer(0, geometry.rectangleBuffer);
+      pass.draw(6, geometry.backgroundInstanceCount);
+    }
+    if (geometry.rectangleBuffer && geometry.selectionInstanceCount > 0) {
+      pass.setPipeline(this.#rectanglePipeline);
+      pass.setVertexBuffer(0, geometry.rectangleBuffer);
+      pass.draw(6, geometry.selectionInstanceCount, 0, geometry.backgroundInstanceCount);
+    }
+    if (geometry.glyphBuffer && geometry.glyphInstanceCount > 0) {
+      pass.setPipeline(this.#glyphPipeline);
+      pass.setBindGroup(0, this.#monoAtlas.bindGroup);
+      pass.setVertexBuffer(0, geometry.glyphBuffer);
+      pass.draw(6, geometry.glyphInstanceCount);
+    }
+    if (geometry.colorGlyphBuffer && geometry.colorGlyphInstanceCount > 0) {
+      pass.setPipeline(this.#colorGlyphPipeline);
+      pass.setBindGroup(0, this.#colorAtlas.bindGroup);
+      pass.setVertexBuffer(0, geometry.colorGlyphBuffer);
+      pass.draw(6, geometry.colorGlyphInstanceCount);
+    }
+    if (geometry.fallbackGlyphBuffer && geometry.fallbackGlyphInstanceCount > 0) {
+      pass.setPipeline(this.#fallbackGlyphPipeline);
+      pass.setBindGroup(0, this.#fallbackAtlas.bindGroup);
+      pass.setVertexBuffer(0, geometry.fallbackGlyphBuffer);
+      pass.draw(6, geometry.fallbackGlyphInstanceCount);
+    }
+    if (geometry.rectangleBuffer && geometry.decorationInstanceCount > 0) {
+      pass.setPipeline(this.#rectanglePipeline);
+      pass.setVertexBuffer(0, geometry.rectangleBuffer);
+      pass.draw(6, geometry.decorationInstanceCount, 0, geometry.decorationInstanceStart);
+    }
+    if (cursorBuffer && cursorInstanceCount > 0) {
+      pass.setPipeline(this.#rectanglePipeline);
+      pass.setVertexBuffer(0, cursorBuffer);
+      pass.draw(6, cursorInstanceCount, 0, cursorInstanceStart);
+    }
+    pass.end();
+    const postProcessPass = encoder.beginRenderPass({
+      label: `Ghostty custom shader pass ${id}`,
+      colorAttachments: [
+        {
+          view: surface2.context.getCurrentTexture().createView(),
+          clearValue: {
+            r: view.theme.background[0],
+            g: view.theme.background[1],
+            b: view.theme.background[2],
+            a: 1
+          },
+          loadOp: "clear",
+          storeOp: "store"
+        }
+      ]
+    });
+    postProcessPass.setPipeline(this.#postProcessPipeline);
+    postProcessPass.setBindGroup(0, surface2.postProcessBindGroup);
+    postProcessPass.draw(3);
+    postProcessPass.end();
+    surface2.sceneValid = true;
+    if (!this.#performanceMeasurementEnabled) return void 0;
+    const monoUploadsAfter = this.#monoAtlas.uploadMetrics();
+    const colorUploadsAfter = this.#colorAtlas.uploadMetrics();
+    const fallbackUploadsAfter = this.#fallbackAtlas.uploadMetrics();
+    return {
+      queueSubmits: 0,
+      fullRenders: 0,
+      partialRenders: 1,
+      damagedRows: damage.rows.length,
+      geometryCacheHits: Number(cacheHit),
+      geometryCacheMisses: Number(!cacheHit),
+      canvasPixels: viewportWidth * viewportHeight,
+      renderPasses: 2,
+      drawCalls: Number(geometry.backgroundInstanceCount > 0) + Number(geometry.selectionInstanceCount > 0) + Number(geometry.glyphInstanceCount > 0) + Number(geometry.colorGlyphInstanceCount > 0) + Number(geometry.fallbackGlyphInstanceCount > 0) + Number(geometry.decorationInstanceCount > 0) + Number(cursorInstanceCount > 0) + 1,
+      rectangleVertices: (geometry.rectangleInstanceCount + cursorInstanceCount) * 6,
+      monoGlyphVertices: geometry.glyphInstanceCount * 6,
+      colorGlyphVertices: geometry.colorGlyphInstanceCount * 6,
+      fallbackGlyphVertices: geometry.fallbackGlyphInstanceCount * 6,
+      vertexUploadBytes: geometryUploadBytes + cursorData.byteLength,
+      atlasUploadBytes: monoUploadsAfter.bytes - monoUploadsBefore.bytes + (colorUploadsAfter.bytes - colorUploadsBefore.bytes) + (fallbackUploadsAfter.bytes - fallbackUploadsBefore.bytes),
+      atlasUploadCalls: monoUploadsAfter.calls - monoUploadsBefore.calls + (colorUploadsAfter.calls - colorUploadsBefore.calls) + (fallbackUploadsAfter.calls - fallbackUploadsBefore.calls)
+    };
+  }
+  settle() {
+    return this.device.queue.onSubmittedWorkDone();
+  }
+  destroy() {
+    for (const id of [...this.#surfaces.keys()]) this.unmount(id);
+    this.#monoAtlas.destroy();
+    this.#colorAtlas.destroy();
+    this.#fallbackAtlas.destroy();
+    this.device.destroy();
+  }
+};
+
+// src/frame-sequence.ts
+function classifyFrame(previous, incoming) {
+  const sameSession = previous.sessionEpoch === 0n || incoming.sessionEpoch === previous.sessionEpoch;
+  if (sameSession && (incoming.layoutEpoch < previous.layoutEpoch || incoming.layoutEpoch === previous.layoutEpoch && incoming.sequence <= previous.sequence))
+    return "stale";
+  if (previous.awaitingResync && !incoming.full) return "resync";
+  const changedSession = !sameSession;
+  const missingInitialSnapshot = previous.sessionEpoch === 0n && !incoming.full;
+  const sequenceGap = previous.sessionEpoch === incoming.sessionEpoch && previous.sequence !== 0n && incoming.sequence !== previous.sequence + 1n;
+  return !incoming.full && (changedSession || missingInitialSnapshot || sequenceGap) ? "resync" : "accept";
+}
+
+// src/cursor-invalidation.ts
+function cursorActivityChangesPixels(cursor, focused, cursorBlinkVisible) {
+  return focused && cursor.visible && cursor.blinking && !cursorBlinkVisible;
+}
+
+// src/catalog-budget.ts
+function catalogAdmission(resetsCatalog, alreadyUsingFallback, fits) {
+  if (alreadyUsingFallback && !resetsCatalog) return "text-fallback";
+  if (fits) return "install";
+  return resetsCatalog ? "text-fallback" : "request-full";
+}
+function glyphCatalogFits(sessionDefinitions, sessionPixelBytes, sharedDefinitions, sharedPixelBytes, definitions, budget) {
+  if (definitions.length === 0) return true;
+  let nextDefinitionCount = sessionDefinitions.size;
+  let nextSharedDefinitionCount = sharedDefinitions.size;
+  let nextSessionPixelBytes = sessionPixelBytes;
+  let nextSharedPixelBytes = sharedPixelBytes;
+  const pending = /* @__PURE__ */ new Set();
+  for (const definition of definitions) {
+    if (sessionDefinitions.has(definition.id) || pending.has(definition.id)) continue;
+    pending.add(definition.id);
+    const shared = sharedDefinitions.get(definition.id);
+    const pixelBytes = shared?.definition.pixels.byteLength ?? definition.pixels.byteLength;
+    nextDefinitionCount += 1;
+    nextSessionPixelBytes += pixelBytes;
+    if (!shared) {
+      nextSharedDefinitionCount += 1;
+      nextSharedPixelBytes += pixelBytes;
+    }
+    if (nextDefinitionCount > budget.maxDefinitions || nextSharedDefinitionCount > budget.maxSharedDefinitions || nextSessionPixelBytes > budget.maxSessionPixelBytes || nextSharedPixelBytes > budget.maxSharedPixelBytes)
+      return false;
+  }
+  return true;
+}
+function definitionCatalogFits(installed, definitions, maxDefinitions, retainedDefinitions = installed.size, maxRetainedDefinitions = Number.MAX_SAFE_INTEGER) {
+  if (definitions.length === 0) return true;
+  let nextDefinitionCount = installed.size;
+  let nextRetainedDefinitions = retainedDefinitions;
+  const pending = /* @__PURE__ */ new Set();
+  for (const definition of definitions) {
+    if (installed.has(definition.id) || pending.has(definition.id)) continue;
+    pending.add(definition.id);
+    nextDefinitionCount += 1;
+    nextRetainedDefinitions += 1;
+    if (nextDefinitionCount > maxDefinitions || nextRetainedDefinitions > maxRetainedDefinitions) return false;
+  }
+  return true;
+}
+
+// src/terminal-render.worker.ts
+var hiddenCursor = { x: 0, y: 0, visible: false, style: 1, blinking: false };
+var CURSOR_BLINK_INTERVAL_MS = 600;
+var MAX_SESSION_GLYPH_DEFINITIONS = 65536;
+var MAX_SESSION_GLYPH_PIXEL_BYTES = 64 * 1024 * 1024;
+var MAX_SESSION_STYLE_DEFINITIONS = 65536;
+var MAX_SHARED_GLYPH_DEFINITIONS = 131072;
+var MAX_SHARED_GLYPH_PIXEL_BYTES = 128 * 1024 * 1024;
+var MAX_RETAINED_STYLE_DEFINITIONS = 262144;
+var GLYPH_CATALOG_BUDGET = {
+  maxDefinitions: MAX_SESSION_GLYPH_DEFINITIONS,
+  maxSharedDefinitions: MAX_SHARED_GLYPH_DEFINITIONS,
+  maxSessionPixelBytes: MAX_SESSION_GLYPH_PIXEL_BYTES,
+  maxSharedPixelBytes: MAX_SHARED_GLYPH_PIXEL_BYTES
+};
+var NO_GLYPH_DEFINITIONS = [];
+var NO_STYLE_DEFINITIONS = [];
+var MAX_PERFORMANCE_SAMPLES = 1e5;
+var FRAME_CREDIT_BATCH_BYTES = 4 * 1024 * 1024;
+var FRAME_CREDIT_MAX_DELAY_MS = 8;
+var snapshots = /* @__PURE__ */ new Map();
+var sharedGlyphDefinitions = /* @__PURE__ */ new Map();
+var sharedGlyphPixelBytes = 0;
+var retainedStyleDefinitions = 0;
+var surfaces = /* @__PURE__ */ new Map();
+var surfaceIdsBySession = /* @__PURE__ */ new Map();
+var noSurfaceIds = /* @__PURE__ */ new Set();
+var presentationDefaults = /* @__PURE__ */ new Map();
+var mounts = /* @__PURE__ */ new Map();
+var cursorBlinkTimers = /* @__PURE__ */ new Map();
+var dirty = /* @__PURE__ */ new Set();
+var occluded = /* @__PURE__ */ new Set();
+var renderer;
+var rendererPromise;
+var flushScheduled = false;
+var recoveryAttempts = 0;
+var recovering = false;
+var nativeTextAnnounced = false;
+var forceCanvasFallback = false;
+var partialRenderingEnabled = true;
+var pendingFrameCreditBytes = 0;
+var frameCreditTimer;
+var performanceMeasurement;
+function appendPerformanceSample(samples, value) {
+  if (samples.length < MAX_PERFORMANCE_SAMPLES) samples.push(value);
+}
+function flushFrameCredit() {
+  if (frameCreditTimer !== void 0) clearTimeout(frameCreditTimer);
+  frameCreditTimer = void 0;
+  if (pendingFrameCreditBytes === 0) return;
+  const bytes = pendingFrameCreditBytes;
+  pendingFrameCreditBytes = 0;
+  postToRenderer({ type: "frame-credit", bytes });
+}
+function returnFrameCredit(bytes) {
+  pendingFrameCreditBytes += bytes;
+  if (pendingFrameCreditBytes >= FRAME_CREDIT_BATCH_BYTES) {
+    flushFrameCredit();
+  } else if (frameCreditTimer === void 0) {
+    frameCreditTimer = setTimeout(flushFrameCredit, FRAME_CREDIT_MAX_DELAY_MS);
+  }
+}
+function beginPerformanceMeasurement() {
+  const now = performance.now();
+  performanceMeasurement = {
+    startedAt: now,
+    lastActivityAt: now,
+    lastFrameAt: /* @__PURE__ */ new Map(),
+    dirtySince: /* @__PURE__ */ new Map(),
+    frames: {
+      received: 0,
+      bytes: 0,
+      full: 0,
+      incremental: 0,
+      stale: 0,
+      resyncRequested: 0,
+      rowsDecoded: 0,
+      glyphDefinitions: 0
+    },
+    scheduling: { flushes: 0, renderCalls: 0, maximumDirtyPanes: 0, panesPerFlush: [] },
+    renderer: {
+      queueSubmits: 0,
+      fullRenders: 0,
+      partialRenders: 0,
+      damagedRows: 0,
+      geometryCacheHits: 0,
+      geometryCacheMisses: 0,
+      canvasPixelFrames: 0,
+      renderPasses: 0,
+      drawCalls: 0,
+      rectangleVertices: 0,
+      monoGlyphVertices: 0,
+      colorGlyphVertices: 0,
+      fallbackGlyphVertices: 0,
+      vertexUploadBytes: 0,
+      atlasUploadBytes: 0,
+      atlasUploadCalls: 0
+    },
+    samples: { frameApplyMs: [], renderCpuMs: [], dirtyToRenderMs: [], frameArrivalToRenderMs: [] }
+  };
+  renderer?.setPerformanceMeasurementEnabled?.(true);
+}
+function notePerformanceActivity(now = performance.now()) {
+  if (performanceMeasurement) performanceMeasurement.lastActivityAt = now;
+}
+function recordRenderMetrics(metrics) {
+  const target = performanceMeasurement?.renderer;
+  if (!target) return;
+  target.queueSubmits += metrics.queueSubmits;
+  target.fullRenders += metrics.fullRenders;
+  target.partialRenders += metrics.partialRenders;
+  target.damagedRows += metrics.damagedRows;
+  target.geometryCacheHits += metrics.geometryCacheHits;
+  target.geometryCacheMisses += metrics.geometryCacheMisses;
+  target.canvasPixelFrames += metrics.canvasPixels;
+  target.renderPasses += metrics.renderPasses;
+  target.drawCalls += metrics.drawCalls;
+  target.rectangleVertices += metrics.rectangleVertices;
+  target.monoGlyphVertices += metrics.monoGlyphVertices;
+  target.colorGlyphVertices += metrics.colorGlyphVertices;
+  target.fallbackGlyphVertices += metrics.fallbackGlyphVertices;
+  target.vertexUploadBytes += metrics.vertexUploadBytes;
+  target.atlasUploadBytes += metrics.atlasUploadBytes;
+  target.atlasUploadCalls += metrics.atlasUploadCalls;
+}
+async function finishPerformanceMeasurement(requestId, quietMs, timeoutMs) {
+  const active = performanceMeasurement;
+  if (!active) throw new Error("No terminal render performance measurement is active");
+  const deadline = performance.now() + timeoutMs;
+  let timedOutWaitingForIdle = false;
+  let gpuQueueDrainMs = null;
+  while (true) {
+    const now = performance.now();
+    const hasVisibleDirty = [...dirty].some((id) => !occluded.has(id));
+    if (!flushScheduled && !hasVisibleDirty && now - active.lastActivityAt >= quietMs) {
+      const beforeDrainActivity = active.lastActivityAt;
+      if (renderer?.settle) {
+        const drainStarted = performance.now();
+        await renderer.settle();
+        gpuQueueDrainMs = performance.now() - drainStarted;
+      }
+      if (active.lastActivityAt === beforeDrainActivity && !flushScheduled) break;
+    }
+    if (now >= deadline) {
+      timedOutWaitingForIdle = true;
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, Math.min(25, Math.max(1, quietMs / 4))));
+  }
+  if (timedOutWaitingForIdle && renderer?.settle) {
+    const drainStarted = performance.now();
+    await renderer.settle();
+    gpuQueueDrainMs = performance.now() - drainStarted;
+  }
+  const snapshot2 = {
+    backend: renderer?.kind ?? "starting",
+    durationMs: performance.now() - active.startedAt,
+    timedOutWaitingForIdle,
+    gpuQueueDrainMs,
+    frames: active.frames,
+    scheduling: active.scheduling,
+    renderer: active.renderer,
+    samples: active.samples
+  };
+  renderer?.setPerformanceMeasurementEnabled?.(false);
+  if (performanceMeasurement === active) performanceMeasurement = void 0;
+  postToRenderer({ type: "performance-result", requestId, snapshot: snapshot2 });
+}
+function postToRenderer(message) {
+  self.postMessage(message);
+}
+function snapshot(sessionHandle) {
+  let value = snapshots.get(sessionHandle);
+  if (!value) {
+    value = {
+      rows: [],
+      nativeRows: [],
+      nativeStyleRows: [],
+      glyphDefinitions: /* @__PURE__ */ new Map(),
+      glyphPixelBytes: 0,
+      styleDefinitions: /* @__PURE__ */ new Map(),
+      rowRevisions: [],
+      cursor: hiddenCursor,
+      layoutEpoch: 0n,
+      sessionEpoch: 0n,
+      sequence: 0n,
+      awaitingResync: false,
+      catalogFallback: false,
+      scrollbar: null
+    };
+    snapshots.set(sessionHandle, value);
+  }
+  return value;
+}
+function clearSessionCatalog(session) {
+  for (const glyphId of session.glyphDefinitions.keys()) {
+    const shared = sharedGlyphDefinitions.get(glyphId);
+    if (!shared) continue;
+    shared.references -= 1;
+    if (shared.references <= 0) {
+      sharedGlyphDefinitions.delete(glyphId);
+      sharedGlyphPixelBytes -= shared.definition.pixels.byteLength;
+    }
+  }
+  session.glyphDefinitions.clear();
+  session.glyphPixelBytes = 0;
+  retainedStyleDefinitions -= session.styleDefinitions.size;
+  session.styleDefinitions.clear();
+}
+function installGlyphDefinitions(session, definitions) {
+  for (const decoded of definitions) {
+    if (session.glyphDefinitions.has(decoded.id)) continue;
+    let shared = sharedGlyphDefinitions.get(decoded.id);
+    const pixelBytes = shared?.definition.pixels.byteLength ?? decoded.pixels.byteLength;
+    if (shared) {
+      shared.references += 1;
+    } else {
+      shared = { definition: decoded, references: 1 };
+      sharedGlyphDefinitions.set(decoded.id, shared);
+      sharedGlyphPixelBytes += decoded.pixels.byteLength;
+    }
+    session.glyphDefinitions.set(decoded.id, shared.definition);
+    session.glyphPixelBytes += pixelBytes;
+  }
+}
+function installStyleDefinitions(session, definitions) {
+  for (const definition of definitions) {
+    if (session.styleDefinitions.has(definition.id)) continue;
+    session.styleDefinitions.set(definition.id, definition);
+    retainedStyleDefinitions += 1;
+  }
+}
+function dropSessionSnapshot(sessionHandle) {
+  const session = snapshots.get(sessionHandle);
+  if (session) clearSessionCatalog(session);
+  snapshots.delete(sessionHandle);
+}
+function defaults(sessionHandle) {
+  let value = presentationDefaults.get(sessionHandle);
+  if (!value) {
+    value = { theme: DEFAULT_THEME, selection: null, visible: true };
+    presentationDefaults.set(sessionHandle, value);
+  }
+  return value;
+}
+function surface(surfaceId, sessionHandle) {
+  const existing = surfaces.get(surfaceId);
+  if (existing) {
+    if (existing.sessionHandle !== sessionHandle) throw new Error(`Surface ${surfaceId} changed sessions`);
+    return existing;
+  }
+  const initial = defaults(sessionHandle);
+  const value = {
+    sessionHandle,
+    focused: false,
+    cursorBlinkVisible: true,
+    selection: initial.selection,
+    theme: initial.theme,
+    damage: { full: true, rows: /* @__PURE__ */ new Set(), geometryChanged: true }
+  };
+  surfaces.set(surfaceId, value);
+  let sessionSurfaceIds = surfaceIdsBySession.get(sessionHandle);
+  if (!sessionSurfaceIds) {
+    sessionSurfaceIds = /* @__PURE__ */ new Set();
+    surfaceIdsBySession.set(sessionHandle, sessionSurfaceIds);
+  }
+  sessionSurfaceIds.add(surfaceId);
+  if (!initial.visible) occluded.add(surfaceId);
+  return value;
+}
+function surfaceIdsForSession(sessionHandle) {
+  return surfaceIdsBySession.get(sessionHandle) ?? noSurfaceIds;
+}
+function deleteSurface(surfaceId) {
+  const value = surfaces.get(surfaceId);
+  if (!value) return void 0;
+  surfaces.delete(surfaceId);
+  const sessionSurfaceIds = surfaceIdsBySession.get(value.sessionHandle);
+  sessionSurfaceIds?.delete(surfaceId);
+  if (sessionSurfaceIds?.size === 0) surfaceIdsBySession.delete(value.sessionHandle);
+  return value;
+}
+function renderView(session, presentation) {
+  return {
+    rows: session.rows,
+    nativeRows: session.nativeRows,
+    nativeStyleRows: session.nativeStyleRows,
+    rowRevisions: session.rowRevisions,
+    glyphDefinitions: session.glyphDefinitions,
+    styleDefinitions: session.styleDefinitions,
+    sessionEpoch: session.sessionEpoch,
+    layoutEpoch: session.layoutEpoch,
+    cursor: session.cursor,
+    focused: presentation.focused,
+    cursorBlinkVisible: presentation.cursorBlinkVisible,
+    selection: presentation.selection,
+    theme: presentation.theme,
+    damage: presentation.damage
+  };
+}
+function scheduleCursorBlink(surfaceId, reset) {
+  const existing = cursorBlinkTimers.get(surfaceId);
+  if (existing !== void 0) clearTimeout(existing);
+  cursorBlinkTimers.delete(surfaceId);
+  const value = surfaces.get(surfaceId);
+  if (!value) return;
+  const session = snapshot(value.sessionHandle);
+  if (reset) value.cursorBlinkVisible = true;
+  if (occluded.has(surfaceId) || !value.focused || !session.cursor.visible || !session.cursor.blinking) return;
+  cursorBlinkTimers.set(
+    surfaceId,
+    setTimeout(() => {
+      cursorBlinkTimers.delete(surfaceId);
+      const current = surfaces.get(surfaceId);
+      const currentSession = current ? snapshots.get(current.sessionHandle) : void 0;
+      if (occluded.has(surfaceId) || !current || !currentSession || !current.focused || !currentSession.cursor.visible || !currentSession.cursor.blinking)
+        return;
+      current.cursorBlinkVisible = !current.cursorBlinkVisible;
+      invalidateRows(surfaceId, [currentSession.cursor.y]);
+      scheduleCursorBlink(surfaceId, false);
+    }, CURSOR_BLINK_INTERVAL_MS)
+  );
+}
+async function createRenderer() {
+  if (forceCanvasFallback) {
+    const canvas = new CanvasTerminalRenderer();
+    postToRenderer({ type: "renderer-status", backend: canvas.kind, recovered: true });
+    return canvas;
+  }
+  try {
+    const gpu = await WebGpuTerminalRenderer.create((info) => void recoverDevice(info));
+    recoveryAttempts = 0;
+    postToRenderer({ type: "renderer-status", backend: gpu.kind });
+    return gpu;
+  } catch (error) {
+    console.warn("[terminal-renderer] WebGPU unavailable; using diagnostic Canvas2D", error);
+    const canvas = new CanvasTerminalRenderer();
+    postToRenderer({ type: "renderer-status", backend: canvas.kind });
+    return canvas;
+  }
+}
+async function ensureRenderer() {
+  rendererPromise ??= createRenderer();
+  renderer = await rendererPromise;
+  return renderer;
+}
+async function recoverDevice(info) {
+  if (recovering || renderer?.kind === "canvas2d") return;
+  recovering = true;
+  recoveryAttempts += 1;
+  console.warn(`[terminal-renderer] WebGPU device lost (${info.reason}): ${info.message}`);
+  renderer = void 0;
+  rendererPromise = WebGpuTerminalRenderer.create((nextInfo) => void recoverDevice(nextInfo));
+  try {
+    const next = await rendererPromise;
+    renderer = next;
+    recoveryAttempts = 0;
+    recovering = false;
+    for (const [id, mount2] of mounts) {
+      next.mount(id, mount2.canvas);
+      next.resize(id, mount2.size);
+      invalidateFull(id);
+    }
+    postToRenderer({ type: "renderer-status", backend: next.kind, recovered: true });
+  } catch (error) {
+    console.error("[terminal-renderer] WebGPU recovery failed", error);
+    rendererPromise = void 0;
+    recovering = false;
+    if (recoveryAttempts >= 3) {
+      postToRenderer({ type: "renderer-reload-required", reason: "webgpu-device-loss" });
+      return;
+    }
+    const delay = Math.min(5e3, 250 * 2 ** Math.min(recoveryAttempts, 4));
+    setTimeout(() => void recoverDevice(info), delay);
+  }
+}
+function scheduleFlush() {
+  if (flushScheduled) return;
+  flushScheduled = true;
+  const run = () => {
+    flushScheduled = false;
+    void flush();
+  };
+  if (typeof self.requestAnimationFrame === "function") self.requestAnimationFrame(run);
+  else setTimeout(run, 8);
+}
+async function flush() {
+  const backend = await ensureRenderer();
+  const ids = [...dirty].filter((id) => !occluded.has(id));
+  if (performanceMeasurement && ids.length > 0) {
+    performanceMeasurement.scheduling.flushes += 1;
+    appendPerformanceSample(performanceMeasurement.scheduling.panesPerFlush, ids.length);
+    performanceMeasurement.scheduling.maximumDirtyPanes = Math.max(
+      performanceMeasurement.scheduling.maximumDirtyPanes,
+      ids.length
+    );
+  }
+  for (const id of ids) dirty.delete(id);
+  const entries = ids.flatMap((id) => {
+    const presentation = surfaces.get(id);
+    const session = presentation ? snapshots.get(presentation.sessionHandle) : void 0;
+    return mounts.has(id) && presentation && session ? [{ id, view: renderView(session, presentation) }] : [];
+  });
+  if (entries.length > 0) {
+    try {
+      const active = performanceMeasurement;
+      const beforeRender = active ? performance.now() : 0;
+      const metrics = backend.renderBatch ? backend.renderBatch(entries) : entries.map(({ id, view }) => backend.render(id, view));
+      const renderedAt = active ? performance.now() : 0;
+      for (const { id } of entries) {
+        const damage = surfaces.get(id)?.damage;
+        if (!damage) continue;
+        damage.full = false;
+        damage.rows.clear();
+        damage.geometryChanged = false;
+      }
+      if (active && performanceMeasurement === active) {
+        active.scheduling.renderCalls += entries.length;
+        appendPerformanceSample(active.samples.renderCpuMs, renderedAt - beforeRender);
+        for (let index = 0; index < entries.length; index += 1) {
+          const { id } = entries[index];
+          const dirtySince = active.dirtySince.get(id);
+          const sessionHandle = surfaces.get(id)?.sessionHandle;
+          const lastFrameAt = sessionHandle ? active.lastFrameAt.get(sessionHandle) : void 0;
+          if (dirtySince !== void 0)
+            appendPerformanceSample(active.samples.dirtyToRenderMs, renderedAt - dirtySince);
+          if (lastFrameAt !== void 0)
+            appendPerformanceSample(active.samples.frameArrivalToRenderMs, renderedAt - lastFrameAt);
+          active.dirtySince.delete(id);
+          recordRenderMetrics(metrics[index] ?? emptyRenderMetrics());
+        }
+        notePerformanceActivity(renderedAt);
+      }
+    } catch (error) {
+      console.error(`[terminal-renderer] failed to render ${entries.length} view(s)`, error);
+    }
+  }
+  if ([...dirty].some((id) => !occluded.has(id))) scheduleFlush();
+}
+function markDirty(id) {
+  if (performanceMeasurement && !performanceMeasurement.dirtySince.has(id)) {
+    performanceMeasurement.dirtySince.set(id, performance.now());
+  }
+  dirty.add(id);
+  if (!occluded.has(id)) scheduleFlush();
+}
+function invalidateFull(id) {
+  const value = surfaces.get(id);
+  if (!value) return;
+  const damage = value.damage;
+  damage.full = true;
+  damage.rows.clear();
+  damage.geometryChanged = true;
+  markDirty(id);
+}
+function invalidateRows(id, rows, geometryChanged = false) {
+  if (!partialRenderingEnabled) {
+    invalidateFull(id);
+    return;
+  }
+  const value = surfaces.get(id);
+  if (!value) return;
+  const damage = value.damage;
+  if (!damage.full) {
+    damage.geometryChanged ||= geometryChanged;
+    for (const row of rows) {
+      if (Number.isSafeInteger(row) && row >= 0) damage.rows.add(row);
+    }
+  }
+  markDirty(id);
+}
+function invalidateSessionFull(sessionHandle) {
+  for (const surfaceId of surfaceIdsForSession(sessionHandle)) invalidateFull(surfaceId);
+}
+function invalidateSessionRows(sessionHandle, rows, geometryChanged = false) {
+  const damagedRows = [...rows];
+  for (const surfaceId of surfaceIdsForSession(sessionHandle)) invalidateRows(surfaceId, damagedRows, geometryChanged);
+}
+async function mount(surfaceId, sessionHandle, canvas) {
+  if (mounts.has(surfaceId)) renderer?.unmount(surfaceId);
+  snapshot(sessionHandle);
+  surface(surfaceId, sessionHandle);
+  const entry = { canvas, size: { width: 1, height: 1, dpr: 1 }, sessionHandle };
+  mounts.set(surfaceId, entry);
+  const backend = await ensureRenderer();
+  if (mounts.get(surfaceId) !== entry) return;
+  backend.mount(surfaceId, canvas);
+  backend.resize(surfaceId, entry.size);
+  invalidateFull(surfaceId);
+}
+function applyFrame(packet) {
+  const active = performanceMeasurement;
+  const applyStarted = active ? performance.now() : 0;
+  if (active) {
+    active.frames.received += 1;
+    active.frames.bytes += packet.byteLength;
+    active.lastActivityAt = applyStarted;
+  }
+  const frame = decodeFrame(packet);
+  const id = frame.sessionHandle.toString();
+  if (active) {
+    active.lastFrameAt.set(id, applyStarted);
+    if ((frame.flags & FrameFlag.FullSnapshot) !== 0) active.frames.full += 1;
+    else active.frames.incremental += 1;
+  }
+  const previous = snapshot(id);
+  const fullFrame = (frame.flags & FrameFlag.FullSnapshot) !== 0;
+  const catalogReset = (frame.flags & FrameFlag.CatalogReset) !== 0;
+  if (catalogReset && !fullFrame) {
+    if (active) {
+      active.frames.resyncRequested += 1;
+      appendPerformanceSample(active.samples.frameApplyMs, performance.now() - applyStarted);
+    }
+    previous.awaitingResync = true;
+    postToRenderer({ type: "frame-resync-needed", sessionHandle: id });
+    return;
+  }
+  const classification = classifyFrame(previous, {
+    sessionEpoch: frame.sessionEpoch,
+    layoutEpoch: frame.layoutEpoch,
+    sequence: frame.frameSequence,
+    full: fullFrame
+  });
+  if (classification === "stale") {
+    if (active) {
+      active.frames.stale += 1;
+      appendPerformanceSample(active.samples.frameApplyMs, performance.now() - applyStarted);
+    }
+    return;
+  }
+  const changedSession = previous.sessionEpoch !== 0n && frame.sessionEpoch !== previous.sessionEpoch;
+  if (classification === "resync") {
+    if (active) {
+      active.frames.resyncRequested += 1;
+      appendPerformanceSample(active.samples.frameApplyMs, performance.now() - applyStarted);
+    }
+    previous.awaitingResync = true;
+    postToRenderer({ type: "frame-resync-needed", sessionHandle: id });
+    return;
+  }
+  const completingResync = previous.awaitingResync;
+  const rowSection = frame.sections.find((candidate) => candidate.kind === SectionKind.RowReplacements);
+  const cursorSection = frame.sections.find((candidate) => candidate.kind === SectionKind.CursorState);
+  const glyphSection = frame.sections.find((candidate) => candidate.kind === SectionKind.GlyphDefinitions);
+  const styleSection = frame.sections.find((candidate) => candidate.kind === SectionKind.StyleDefinitions);
+  const clipboardSection = frame.sections.find((candidate) => candidate.kind === SectionKind.ClipboardWrite);
+  const scrollbarSection = frame.sections.find((candidate) => candidate.kind === SectionKind.ScrollbarState);
+  if (!rowSection || !cursorSection) {
+    if (active) appendPerformanceSample(active.samples.frameApplyMs, performance.now() - applyStarted);
+    return;
+  }
+  const glyphDefinitions = glyphSection ? decodeGlyphDefinitions(glyphSection) : NO_GLYPH_DEFINITIONS;
+  const styleDefinitions = styleSection ? decodeStyleDefinitions(styleSection) : NO_STYLE_DEFINITIONS;
+  if (active) active.frames.glyphDefinitions += glyphDefinitions.length;
+  const resetsCatalog = changedSession || completingResync || catalogReset;
+  const wasCatalogFallback = previous.catalogFallback;
+  if (resetsCatalog) {
+    previous.rows = [];
+    previous.nativeRows = [];
+    previous.nativeStyleRows = [];
+    clearSessionCatalog(previous);
+    previous.rowRevisions = [];
+    const catalogFits = glyphCatalogFits(
+      previous.glyphDefinitions,
+      previous.glyphPixelBytes,
+      sharedGlyphDefinitions,
+      sharedGlyphPixelBytes,
+      glyphDefinitions,
+      GLYPH_CATALOG_BUDGET
+    ) && definitionCatalogFits(
+      previous.styleDefinitions,
+      styleDefinitions,
+      MAX_SESSION_STYLE_DEFINITIONS,
+      retainedStyleDefinitions,
+      MAX_RETAINED_STYLE_DEFINITIONS
+    );
+    const admission = catalogAdmission(true, wasCatalogFallback, catalogFits);
+    previous.catalogFallback = admission === "text-fallback";
+    if (admission === "install") {
+      installGlyphDefinitions(previous, glyphDefinitions);
+      installStyleDefinitions(previous, styleDefinitions);
+    } else if (!wasCatalogFallback) {
+      postToRenderer({
+        type: "catalog-pressure",
+        sessionHandle: id,
+        reason: "working-set-exceeds-budget"
+      });
+    }
+  } else if (!previous.catalogFallback) {
+    const catalogFits = glyphCatalogFits(
+      previous.glyphDefinitions,
+      previous.glyphPixelBytes,
+      sharedGlyphDefinitions,
+      sharedGlyphPixelBytes,
+      glyphDefinitions,
+      GLYPH_CATALOG_BUDGET
+    ) && definitionCatalogFits(
+      previous.styleDefinitions,
+      styleDefinitions,
+      MAX_SESSION_STYLE_DEFINITIONS,
+      retainedStyleDefinitions,
+      MAX_RETAINED_STYLE_DEFINITIONS
+    );
+    const admission = catalogAdmission(false, false, catalogFits);
+    if (admission === "request-full") {
+      if (active) {
+        active.frames.resyncRequested += 1;
+        appendPerformanceSample(active.samples.frameApplyMs, performance.now() - applyStarted);
+      }
+      previous.awaitingResync = true;
+      postToRenderer({ type: "frame-resync-needed", sessionHandle: id });
+      return;
+    }
+    if (admission === "install") {
+      installGlyphDefinitions(previous, glyphDefinitions);
+      installStyleDefinitions(previous, styleDefinitions);
+    }
+  }
+  if (!previous.catalogFallback && !nativeTextAnnounced && glyphDefinitions.length > 0) {
+    nativeTextAnnounced = true;
+    postToRenderer({ type: "renderer-status", backend: renderer?.kind ?? "starting", textEngine: "native" });
+  }
+  if (clipboardSection) {
+    postToRenderer({ type: "clipboard-write", text: decodeClipboardWrite(clipboardSection) });
+  }
+  if (scrollbarSection) {
+    const decoded = decodeScrollbarState(scrollbarSection);
+    const scrollbar = {
+      total: Number(decoded.total),
+      offset: Number(decoded.offset),
+      length: Number(decoded.length)
+    };
+    if (!Number.isSafeInteger(scrollbar.total) || !Number.isSafeInteger(scrollbar.offset) || !Number.isSafeInteger(scrollbar.length))
+      throw new RangeError("Scrollbar state exceeds JavaScript's safe integer range");
+    if (!previous.scrollbar || previous.scrollbar.total !== scrollbar.total || previous.scrollbar.offset !== scrollbar.offset || previous.scrollbar.length !== scrollbar.length) {
+      previous.scrollbar = scrollbar;
+      postToRenderer({ type: "scrollbar-state", sessionHandle: id, scrollbar });
+    }
+  }
+  const full = (rowSection.flags & 1) !== 0;
+  const useNativeCatalog = !previous.catalogFallback;
+  const rows = full ? Array(frame.rows).fill("") : previous.rows.slice();
+  const nativeRows = full ? Array.from({ length: frame.rows }, () => []) : previous.nativeRows.slice();
+  const nativeStyleRows = full ? Array.from({ length: frame.rows }, () => []) : previous.nativeStyleRows.slice();
+  const rowRevisions = full ? Array(frame.rows).fill(0n) : previous.rowRevisions.slice();
+  const replacements = decodeRowReplacements(rowSection);
+  const damagedRows = [];
+  if (active) active.frames.rowsDecoded += replacements.length;
+  for (const replacement of replacements) {
+    if (replacement.row >= frame.rows) throw new RangeError("Row replacement exceeds viewport");
+    if (replacement.revision < (rowRevisions[replacement.row] ?? 0n)) continue;
+    rows[replacement.row] = replacement.text;
+    nativeRows[replacement.row] = useNativeCatalog ? replacement.glyphs : [];
+    nativeStyleRows[replacement.row] = useNativeCatalog ? replacement.styles : [];
+    rowRevisions[replacement.row] = replacement.revision;
+    damagedRows.push(replacement.row);
+  }
+  previous.rows = rows;
+  previous.nativeRows = nativeRows;
+  previous.nativeStyleRows = nativeStyleRows;
+  previous.rowRevisions = rowRevisions;
+  const geometryChanged = damagedRows.length > 0;
+  const previousCursor = previous.cursor;
+  const nextCursor = decodeCursorState(cursorSection);
+  const cursorChanged = nextCursor.x !== previousCursor.x || nextCursor.y !== previousCursor.y || nextCursor.visible !== previousCursor.visible || nextCursor.style !== previousCursor.style || nextCursor.blinking !== previousCursor.blinking;
+  previous.cursor = nextCursor;
+  previous.layoutEpoch = frame.layoutEpoch;
+  previous.sessionEpoch = frame.sessionEpoch;
+  previous.sequence = frame.frameSequence;
+  previous.awaitingResync = false;
+  if (completingResync) postToRenderer({ type: "frame-resync-complete", sessionHandle: id });
+  const requiresFullRedraw = full || changedSession || completingResync;
+  if (!requiresFullRedraw && cursorChanged) damagedRows.push(previousCursor.y, nextCursor.y);
+  const hasRowDamage = damagedRows.length > 0;
+  for (const surfaceId of surfaceIdsForSession(id)) {
+    if (cursorChanged) scheduleCursorBlink(surfaceId, true);
+    if (requiresFullRedraw) invalidateFull(surfaceId);
+    else if (hasRowDamage) invalidateRows(surfaceId, damagedRows, geometryChanged);
+  }
+  if (active) appendPerformanceSample(active.samples.frameApplyMs, performance.now() - applyStarted);
+}
+self.onmessage = (event) => {
+  const message = event.data;
+  try {
+    if (message.type === "mount") {
+      void mount(message.surfaceId, message.sessionHandle, message.canvas).catch((error) => {
+        console.error("[terminal-renderer] mount failed", error);
+      });
+    } else if (message.type === "renderer-config") {
+      forceCanvasFallback = Boolean(message.forceCanvasFallback);
+    } else if (message.type === "partial-rendering") {
+      partialRenderingEnabled = Boolean(message.enabled);
+      for (const id of mounts.keys()) invalidateFull(id);
+    } else if (message.type === "unmount") {
+      mounts.delete(message.surfaceId);
+      dirty.delete(message.surfaceId);
+      deleteSurface(message.surfaceId);
+      occluded.delete(message.surfaceId);
+      renderer?.unmount(message.surfaceId);
+      const timer = cursorBlinkTimers.get(message.surfaceId);
+      if (timer !== void 0) clearTimeout(timer);
+      cursorBlinkTimers.delete(message.surfaceId);
+    } else if (message.type === "drop-session") {
+      for (const surfaceId of surfaceIdsForSession(message.sessionHandle)) {
+        mounts.delete(surfaceId);
+        dirty.delete(surfaceId);
+        surfaces.delete(surfaceId);
+        occluded.delete(surfaceId);
+        renderer?.unmount(surfaceId);
+        const timer = cursorBlinkTimers.get(surfaceId);
+        if (timer !== void 0) clearTimeout(timer);
+        cursorBlinkTimers.delete(surfaceId);
+      }
+      surfaceIdsBySession.delete(message.sessionHandle);
+      dropSessionSnapshot(message.sessionHandle);
+      presentationDefaults.delete(message.sessionHandle);
+      performanceMeasurement?.lastFrameAt.delete(message.sessionHandle);
+    } else if (message.type === "resize") {
+      const mounted = mounts.get(message.surfaceId);
+      if (!mounted) return;
+      const nextSize = { width: message.width, height: message.height, dpr: message.dpr };
+      const changed = renderedSizeChanged(mounted.size, nextSize);
+      mounted.size = nextSize;
+      if (!changed) return;
+      renderer?.resize(message.surfaceId, mounted.size);
+      invalidateFull(message.surfaceId);
+    } else if (message.type === "frame") {
+      try {
+        applyFrame(message.packet);
+      } finally {
+        returnFrameCredit(message.packet.byteLength);
+      }
+    } else if (message.type === "frame-gap") {
+      for (const sessionHandle of message.sessionHandles) {
+        const session = snapshot(sessionHandle);
+        if (session.awaitingResync) continue;
+        session.awaitingResync = true;
+        postToRenderer({ type: "frame-resync-needed", sessionHandle });
+      }
+    } else if (message.type === "expect-full") {
+      snapshot(message.sessionHandle).awaitingResync = true;
+    } else if (message.type === "theme") {
+      if (message.surfaceId) {
+        surface(message.surfaceId, message.sessionHandle).theme = message.theme;
+        invalidateFull(message.surfaceId);
+      } else {
+        defaults(message.sessionHandle).theme = message.theme;
+        for (const surfaceId of surfaceIdsForSession(message.sessionHandle)) {
+          surfaces.get(surfaceId).theme = message.theme;
+          invalidateFull(surfaceId);
+        }
+      }
+    } else if (message.type === "selection") {
+      if (message.surfaceId) {
+        surface(message.surfaceId, message.sessionHandle).selection = message.selection;
+        invalidateFull(message.surfaceId);
+      } else {
+        defaults(message.sessionHandle).selection = message.selection;
+        for (const surfaceId of surfaceIdsForSession(message.sessionHandle)) {
+          surfaces.get(surfaceId).selection = message.selection;
+          invalidateFull(surfaceId);
+        }
+      }
+    } else if (message.type === "visibility") {
+      if (!message.surfaceId) defaults(message.sessionHandle).visible = message.visible;
+      if (message.surfaceId) surface(message.surfaceId, message.sessionHandle);
+      const targetIds = message.surfaceId ? [message.surfaceId] : surfaceIdsForSession(message.sessionHandle);
+      for (const surfaceId of targetIds) {
+        if (message.visible) {
+          occluded.delete(surfaceId);
+          invalidateFull(surfaceId);
+          scheduleCursorBlink(surfaceId, true);
+        } else {
+          occluded.add(surfaceId);
+          const timer = cursorBlinkTimers.get(surfaceId);
+          if (timer !== void 0) clearTimeout(timer);
+          cursorBlinkTimers.delete(surfaceId);
+        }
+      }
+    } else if (message.type === "focus") {
+      const value = surface(message.surfaceId, message.sessionHandle);
+      value.focused = Boolean(message.focused);
+      scheduleCursorBlink(message.surfaceId, value.focused);
+      invalidateRows(message.surfaceId, [snapshot(message.sessionHandle).cursor.y]);
+    } else if (message.type === "cursor-activity") {
+      const session = snapshot(message.sessionHandle);
+      for (const surfaceId of surfaceIdsForSession(message.sessionHandle)) {
+        const value = surfaces.get(surfaceId);
+        const changesPixels = cursorActivityChangesPixels(session.cursor, value.focused, value.cursorBlinkVisible);
+        scheduleCursorBlink(surfaceId, true);
+        if (changesPixels) invalidateRows(surfaceId, [session.cursor.y]);
+      }
+    } else if (message.type === "force-full-redraw") {
+      invalidateSessionFull(message.sessionHandle);
+    } else if (message.type === "force-row-redraw") {
+      invalidateSessionRows(message.sessionHandle, [message.row]);
+    } else if (message.type === "performance-start") {
+      void ensureRenderer().then(() => {
+        beginPerformanceMeasurement();
+        postToRenderer({ type: "performance-started", requestId: message.requestId });
+      }).catch((error) => console.error("[terminal-renderer] failed to start performance measurement", error));
+    } else if (message.type === "performance-finish") {
+      void finishPerformanceMeasurement(message.requestId, message.quietMs, message.timeoutMs).catch((error) => {
+        console.error("[terminal-renderer] failed to finish performance measurement", error);
+      });
+    }
+  } catch (error) {
+    console.error("[terminal-renderer] rejected worker message", error);
+  }
+};
+//# sourceMappingURL=terminal-render.worker.js.map