@cimplify/cli 0.15.3 → 0.16.0

package/dist/chunk-THATLMEX.mjs

@@ -0,0 +1,1227 @@
+#!/usr/bin/env node
+import { UiProp, UiKind, UiFlag, UI_HEADER_BYTES, UI_MAGIC, PatchWriter, UiRole, UiTrait, UiAnchor, UiOp, UI_VERSION } from '@cimplify/sdk/interactives';
+
+// src/interactives/inspect/contrast.ts
+var BYTE = 255;
+var LINEAR_KNEE = 0.03928;
+var LINEAR_SLOPE = 12.92;
+var GAMMA_OFFSET = 0.055;
+var GAMMA_SCALE = 1.055;
+var GAMMA = 2.4;
+var RED = 0.2126;
+var GREEN = 0.7152;
+var BLUE = 0.0722;
+var FLARE = 0.05;
+var MIX_STEP = 0.05;
+var HEX = 16;
+var BODY_CONTRAST = 4.5;
+var LARGE_CONTRAST = 3;
+var LARGE_TEXT_PT = 18;
+var LARGE_BOLD_TEXT_PT = 14;
+var BOLD_WEIGHT = 700;
+function fromWord(word2) {
+  return { r: word2 >>> 24 & BYTE, g: word2 >>> 16 & BYTE, b: word2 >>> 8 & BYTE, a: (word2 & BYTE) / BYTE };
+}
+function toHex(color) {
+  const byte = (v) => Math.round(Math.max(0, Math.min(BYTE, v))).toString(HEX).padStart(2, "0");
+  return `#${byte(color.r)}${byte(color.g)}${byte(color.b)}${color.a >= 1 ? "" : byte(color.a * BYTE)}`;
+}
+function over(top, bottom) {
+  const a = top.a + bottom.a * (1 - top.a);
+  if (a === 0) return { r: 0, g: 0, b: 0, a: 0 };
+  const mix2 = (t, b) => (t * top.a + b * bottom.a * (1 - top.a)) / a;
+  return { r: mix2(top.r, bottom.r), g: mix2(top.g, bottom.g), b: mix2(top.b, bottom.b), a };
+}
+function channel(value) {
+  const c = value / BYTE;
+  return c <= LINEAR_KNEE ? c / LINEAR_SLOPE : ((c + GAMMA_OFFSET) / GAMMA_SCALE) ** GAMMA;
+}
+function luminance(color) {
+  return RED * channel(color.r) + GREEN * channel(color.g) + BLUE * channel(color.b);
+}
+function contrastRatio(foreground, background2) {
+  const base = background2.a >= 1 ? background2 : over(background2, { r: 0, g: 0, b: 0, a: 1 });
+  const text = over(foreground, base);
+  const a = luminance(text);
+  const b = luminance(base);
+  return (Math.max(a, b) + FLARE) / (Math.min(a, b) + FLARE);
+}
+function largeText(sizePt, weight) {
+  return sizePt >= LARGE_TEXT_PT || sizePt >= LARGE_BOLD_TEXT_PT && weight >= BOLD_WEIGHT;
+}
+function requiredContrast(sizePt, weight) {
+  return largeText(sizePt, weight) ? LARGE_CONTRAST : BODY_CONTRAST;
+}
+function mix(from, to, t) {
+  return { r: from.r + (to.r - from.r) * t, g: from.g + (to.g - from.g) * t, b: from.b + (to.b - from.b) * t, a: from.a + (to.a - from.a) * t };
+}
+function passingColor(foreground, background2, required) {
+  const opaque = { ...foreground, a: 1 };
+  const towards = luminance(background2) > luminance({ r: BYTE / 2, g: BYTE / 2, b: BYTE / 2}) ? [{ r: 0, g: 0, b: 0, a: 1 }, { r: BYTE, g: BYTE, b: BYTE, a: 1 }] : [{ r: BYTE, g: BYTE, b: BYTE, a: 1 }, { r: 0, g: 0, b: 0, a: 1 }];
+  for (const target of towards) {
+    for (let t = 0; t <= 1 + MIX_STEP / 2; t += MIX_STEP) {
+      const candidate = mix(opaque, target, Math.min(1, t));
+      if (contrastRatio(candidate, background2) >= required) return candidate;
+    }
+  }
+  return towards[0];
+}
+var QUANT_SHIFT = 4;
+function dominantColor(pixels, width, height, rect) {
+  const x0 = Math.max(0, Math.floor(rect.x0));
+  const y0 = Math.max(0, Math.floor(rect.y0));
+  const x1 = Math.min(width, Math.ceil(rect.x1));
+  const y1 = Math.min(height, Math.ceil(rect.y1));
+  if (x1 <= x0 || y1 <= y0) return null;
+  const buckets = /* @__PURE__ */ new Map();
+  for (let y = y0; y < y1; y++) {
+    for (let x = x0; x < x1; x++) {
+      const at = (y * width + x) * 4;
+      const r = pixels[at];
+      const g = pixels[at + 1];
+      const b = pixels[at + 2];
+      const key = r >> QUANT_SHIFT << 8 | g >> QUANT_SHIFT << 4 | b >> QUANT_SHIFT;
+      const bucket = buckets.get(key);
+      if (bucket === void 0) buckets.set(key, { n: 1, r, g, b });
+      else {
+        bucket.n++;
+        bucket.r += r;
+        bucket.g += g;
+        bucket.b += b;
+      }
+    }
+  }
+  let best = null;
+  for (const bucket of buckets.values()) if (best === null || bucket.n > best.n) best = bucket;
+  return best === null ? null : { r: best.r / best.n, g: best.g / best.n, b: best.b / best.n, a: 1 };
+}
+var OP_STYLE = 25;
+var OP_STYLE_CLEAR = 26;
+var OP_TOKENS = 27;
+var OP_SLOTS = 28;
+var PROP_DISABLED = 47;
+var Condition = { focus: 2, disabled: 4, landscape: 8, portrait: 16, safe: 32, sm: 64, lg: 128 };
+var CONDITION_NAMES = [":pressed", ":focus", ":disabled", "@landscape", "@portrait", "@safe", "@sm", "@lg"];
+var CONDITION_PRIORITY = [170, 150, 92, 200, 200, 200, 200, 200];
+var BREAKPOINT_SM = 640;
+var BREAKPOINT_LG = 1024;
+var WORD = 4;
+var HEADER_WORDS = 2;
+var EXTENDED = 0;
+var COUNT_OFFSET = 8;
+var AUX_PROP_MASK = 255;
+var UNIT_SHIFT = 8;
+var UNIT_MASK = 15;
+var NO_NODE = 4294967295;
+var WORLD_ROOT_WORDS = 13;
+var ENTRY_PROP_MASK = 255;
+var ENTRY_UNIT_SHIFT = 8;
+var ENTRY_UNIT_MASK = 15;
+var ENTRY_COUNT_SHIFT = 16;
+var ENTRY_COUNT_MASK = 255;
+var ENTRY_REFERENCED = 1 << 24;
+var ENTRY_SAFE_EDGES = 1 << 25;
+var SLOT_REFERENCE = 2147483648;
+var TOKEN_MASK = 1073741823;
+var QUAD = 4;
+var ALL_EDGES = 15;
+var UNIT_POINTS = 1;
+var SAFE_QUAD_PROPS = /* @__PURE__ */ new Set([UiProp.padding, UiProp.margin]);
+var INSET_PROPS = [UiProp.inset_top, UiProp.inset_right, UiProp.inset_bottom, UiProp.inset_left];
+var KIND_NAMES = (() => {
+  const names = [];
+  for (const [name, code] of Object.entries(UiKind)) names[code] = name;
+  return names;
+})();
+var decoder = new TextDecoder();
+function emptyModel() {
+  return { nodes: /* @__PURE__ */ new Map(), strings: /* @__PURE__ */ new Map(), fonts: [], tokens: /* @__PURE__ */ new Map(), slots: /* @__PURE__ */ new Map(), problems: [], patches: 0, records: 0, created: 0 };
+}
+function conditionPriority(mask) {
+  let total = 0;
+  for (let bit = 0; bit < CONDITION_PRIORITY.length; bit++) if ((mask & 1 << bit) !== 0) total += CONDITION_PRIORITY[bit];
+  return total;
+}
+function conditionName(mask) {
+  if (mask === 0) return "default";
+  let out = "";
+  for (let bit = 0; bit < CONDITION_NAMES.length; bit++) if ((mask & 1 << bit) !== 0) out += CONDITION_NAMES[bit];
+  return out;
+}
+function detach(model, node) {
+  if (node.parent === null) return;
+  const parent = model.nodes.get(node.parent);
+  node.parent = null;
+  if (parent === void 0) return;
+  const at = parent.children.indexOf(node.id);
+  if (at >= 0) parent.children.splice(at, 1);
+}
+function forget(model, id) {
+  const node = model.nodes.get(id);
+  if (node === void 0) return;
+  detach(model, node);
+  for (const child of node.children.slice()) forget(model, child);
+  model.nodes.delete(id);
+}
+function readText(view, at, end) {
+  if (at + WORD > end) return "";
+  const length = view.getUint32(at, true);
+  const start = at + WORD;
+  const stop = Math.min(start + length, end);
+  return decoder.decode(new Uint8Array(view.buffer, view.byteOffset + start, stop - start));
+}
+function create(model, id, kind) {
+  if (model.nodes.has(id)) forget(model, id);
+  model.nodes.set(id, {
+    id,
+    kind: KIND_NAMES[kind] ?? "box",
+    order: model.created++,
+    parent: null,
+    children: [],
+    base: /* @__PURE__ */ new Map(),
+    variants: /* @__PURE__ */ new Map(),
+    props: /* @__PURE__ */ new Map(),
+    active: 0,
+    text: null,
+    textRef: null,
+    number: null,
+    label: null,
+    value: null,
+    placeholder: null,
+    image: null,
+    pathPoints: 0,
+    root: null,
+    worldRoot: null,
+    transition: null,
+    focused: false,
+    occluded: false
+  });
+}
+function readEntries(view, at, end) {
+  const entries = [];
+  let cursor = at;
+  while (cursor < end) {
+    const head = view.getUint32(cursor, true);
+    cursor += WORD;
+    const count = head >>> ENTRY_COUNT_SHIFT & ENTRY_COUNT_MASK;
+    let refs = 0;
+    let safe = 0;
+    if ((head & ENTRY_REFERENCED) !== 0) {
+      refs = view.getUint32(cursor, true);
+      cursor += WORD;
+    }
+    if ((head & ENTRY_SAFE_EDGES) !== 0) {
+      safe = view.getUint32(cursor, true);
+      cursor += WORD;
+    }
+    if (cursor + count * WORD > end) return null;
+    const words = [];
+    for (let i = 0; i < count; i++) words.push(view.getUint32(cursor + i * WORD, true));
+    cursor += count * WORD;
+    entries.push({ prop: head & ENTRY_PROP_MASK, unit: head >>> ENTRY_UNIT_SHIFT & ENTRY_UNIT_MASK, refs, safe, words });
+  }
+  return entries;
+}
+function applyRecord(model, view, op, aux, nodeId, at, end) {
+  const word2 = (i) => view.getUint32(at + i * WORD, true);
+  const float2 = (i) => view.getFloat32(at + i * WORD, true);
+  const payloadWords = (end - at) / WORD;
+  if (op === UiOp.create) {
+    create(model, nodeId, aux);
+    return;
+  }
+  if (op === UiOp.string) {
+    model.strings.set(nodeId, readText(view, at, end));
+    return;
+  }
+  if (op === UiOp.font) {
+    model.fonts.push({ family: word2(0), weight: word2(1), font: word2(2) });
+    return;
+  }
+  if (op === OP_TOKENS || op === OP_SLOTS) {
+    const table = op === OP_TOKENS ? model.tokens : model.slots;
+    if (op === OP_TOKENS && (aux & 1) !== 0) table.clear();
+    for (let i = 0; i + 1 < payloadWords; i += 2) table.set(op === OP_TOKENS ? word2(i) & TOKEN_MASK : word2(i), word2(i + 1));
+    return;
+  }
+  const node = model.nodes.get(nodeId);
+  if (node === void 0) {
+    model.problems.push(`op ${op} targets node ${nodeId}, which does not exist`);
+    return;
+  }
+  switch (op) {
+    case UiOp.destroy:
+      forget(model, nodeId);
+      return;
+    case UiOp.insert: {
+      const parent = model.nodes.get(word2(0));
+      if (parent === void 0) {
+        model.problems.push(`node ${nodeId} is inserted into node ${word2(0)}, which does not exist`);
+        return;
+      }
+      detach(model, node);
+      const before = word2(1);
+      const index = before === NO_NODE ? -1 : parent.children.indexOf(before);
+      if (index < 0) parent.children.push(nodeId);
+      else parent.children.splice(index, 0, nodeId);
+      node.parent = parent.id;
+      return;
+    }
+    case UiOp.remove:
+      detach(model, node);
+      return;
+    case UiOp.root:
+      node.root = { anchor: word2(0), safeArea: word2(1) !== 0, offset: [float2(2), float2(3)], z: view.getInt32(at + 4 * WORD, true) };
+      node.worldRoot = null;
+      return;
+    case UiOp.world_root:
+      if (payloadWords >= WORLD_ROOT_WORDS) node.worldRoot = { position: [float2(0), float2(1), float2(2)], z: view.getInt32(at + 12 * WORD, true) };
+      node.root = null;
+      return;
+    case UiOp.unroot:
+      node.root = null;
+      node.worldRoot = null;
+      return;
+    case UiOp.prop: {
+      const words = [];
+      for (let i = 0; i < payloadWords; i++) words.push(word2(i));
+      const prop = aux & AUX_PROP_MASK;
+      node.base.set(prop, { prop, unit: aux >> UNIT_SHIFT & UNIT_MASK, refs: 0, safe: 0, words });
+      return;
+    }
+    case UiOp.text:
+      node.text = readText(view, at, end);
+      node.textRef = null;
+      node.number = null;
+      return;
+    case UiOp.text_ref:
+      node.textRef = word2(0);
+      node.text = null;
+      node.number = null;
+      return;
+    case UiOp.number:
+      node.number = { value: view.getFloat64(at, true), format: view.getUint8(at + 2 * WORD), decimals: view.getUint8(at + 2 * WORD + 1) };
+      node.text = null;
+      node.textRef = null;
+      return;
+    case UiOp.label:
+      node.label = readText(view, at, end);
+      return;
+    case UiOp.value:
+      node.value = readText(view, at, end);
+      return;
+    case UiOp.placeholder:
+      node.placeholder = readText(view, at, end);
+      return;
+    case UiOp.image:
+      node.image = { asset: word2(0), width: float2(1), height: float2(2) };
+      return;
+    case UiOp.path:
+      node.pathPoints = Math.floor(payloadWords / 2);
+      return;
+    case UiOp.transition:
+      node.transition = { mask: aux, duration: float2(0), easing: word2(1) };
+      return;
+    case UiOp.focus:
+      for (const other of model.nodes.values()) other.focused = false;
+      node.focused = true;
+      return;
+    case UiOp.blur:
+      node.focused = false;
+      return;
+    case UiOp.occluded:
+      node.occluded = word2(0) !== 0;
+      return;
+    case OP_STYLE: {
+      const mask = aux & ENTRY_PROP_MASK;
+      const entries = readEntries(view, at, end);
+      if (entries === null) {
+        model.problems.push(`OP_STYLE for node ${nodeId} (mask ${mask}) is malformed`);
+        return;
+      }
+      if (mask === 0) for (const entry2 of entries) node.base.set(entry2.prop, entry2);
+      else if (entries.length === 0) node.variants.delete(mask);
+      else node.variants.set(mask, entries);
+      return;
+    }
+    case OP_STYLE_CLEAR:
+      node.variants.clear();
+      return;
+    default:
+      return;
+  }
+}
+function applyPatch(model, bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (bytes.byteLength < UI_HEADER_BYTES || view.getUint32(0, true) !== UI_MAGIC) {
+    model.problems.push(`patch ${model.patches} has no CUI1 header`);
+    model.patches++;
+    return;
+  }
+  const count = view.getUint32(COUNT_OFFSET, true);
+  let at = UI_HEADER_BYTES;
+  for (let i = 0; i < count; i++) {
+    if (at + HEADER_WORDS * WORD > bytes.byteLength) {
+      model.problems.push(`patch ${model.patches} ends inside record ${i}`);
+      break;
+    }
+    const op = view.getUint8(at);
+    const compact = view.getUint8(at + 1);
+    const aux = view.getUint16(at + 2, true);
+    const node = view.getUint32(at + 4, true);
+    let words = compact;
+    let payload = at + HEADER_WORDS * WORD;
+    if (compact === EXTENDED) {
+      words = view.getUint32(payload, true);
+      payload += WORD;
+    }
+    const end = at + words * WORD;
+    if (words < HEADER_WORDS || end > bytes.byteLength) {
+      model.problems.push(`patch ${model.patches} record ${i} (op ${op}) is malformed`);
+      break;
+    }
+    applyRecord(model, view, op, aux, node, payload, end);
+    model.records++;
+    at = end;
+  }
+  model.patches++;
+}
+function contextBits(context) {
+  let bits2 = Condition.safe | (context.width > context.height ? Condition.landscape : Condition.portrait);
+  if (context.width >= BREAKPOINT_SM) bits2 |= Condition.sm;
+  if (context.width >= BREAKPOINT_LG) bits2 |= Condition.lg;
+  return bits2;
+}
+var f32 = new Float32Array(1);
+var u32 = new Uint32Array(f32.buffer);
+function addFloat(word2, delta) {
+  u32[0] = word2;
+  f32[0] = f32[0] + delta;
+  return u32[0];
+}
+function entryValue(entry2, model, insets) {
+  let words = entry2.words.slice();
+  for (let i = 0; i < words.length; i++) {
+    if ((entry2.refs & 1 << i) === 0) continue;
+    const ref = words[i];
+    if ((ref & SLOT_REFERENCE) !== 0) {
+      words[i] = model.slots.get((ref & ~SLOT_REFERENCE) >>> 0) ?? 0;
+      continue;
+    }
+    const token = model.tokens.get(ref & TOKEN_MASK);
+    if (token === void 0) return null;
+    words[i] = token;
+  }
+  if (entry2.safe !== 0) {
+    const edges = [insets.top, insets.right, insets.bottom, insets.left];
+    if (SAFE_QUAD_PROPS.has(entry2.prop)) {
+      const broadcast = words.length === 1;
+      if (broadcast) words = [words[0], words[0], words[0], words[0]];
+      const safe = broadcast && (entry2.safe & 1) !== 0 ? ALL_EDGES : entry2.safe;
+      for (let i = 0; i < QUAD; i++) if ((safe & 1 << i) !== 0) words[i] = addFloat(words[i], edges[i]);
+    } else {
+      const edge = INSET_PROPS.indexOf(entry2.prop);
+      if (edge >= 0 && (entry2.safe & 1) !== 0 && entry2.unit === UNIT_POINTS) words[0] = addFloat(words[0], edges[edge]);
+    }
+  }
+  return { unit: entry2.unit, words };
+}
+function stateBits(model, node) {
+  let bits2 = 0;
+  let cursor = node;
+  while (cursor !== void 0) {
+    if (cursor.focused) bits2 |= Condition.focus;
+    if (cursor.base.get(PROP_DISABLED)?.words[0] === 1) bits2 |= Condition.disabled;
+    cursor = cursor.parent === null ? void 0 : model.nodes.get(cursor.parent);
+  }
+  if ((bits2 & Condition.disabled) !== 0) bits2 &= -4;
+  return bits2;
+}
+function resolveModel(model, context) {
+  const ctx = contextBits(context);
+  for (const node of model.nodes.values()) {
+    const active = stateBits(model, node) | ctx;
+    node.active = active;
+    const props = /* @__PURE__ */ new Map();
+    for (const [prop, entry2] of node.base) {
+      const value = entryValue(entry2, model, context.insets);
+      if (value !== null) props.set(prop, value);
+    }
+    const masks = [...node.variants.keys()].filter((m) => (m & ~active) === 0).sort((a, b) => conditionPriority(a) - conditionPriority(b) || a - b);
+    for (const mask of masks) {
+      for (const entry2 of node.variants.get(mask) ?? []) {
+        const value = entryValue(entry2, model, context.insets);
+        if (value !== null) props.set(entry2.prop, value);
+      }
+    }
+    node.props = props;
+  }
+}
+function decodeStream(patches, context = null) {
+  const model = emptyModel();
+  for (const patch of patches) applyPatch(model, patch);
+  resolveModel(model, context ?? { width: 0, height: 0, insets: { top: 0, right: 0, bottom: 0, left: 0 } });
+  return model;
+}
+function encodeEntry(entry2) {
+  let head = entry2.prop | entry2.unit << ENTRY_UNIT_SHIFT | entry2.words.length << ENTRY_COUNT_SHIFT;
+  const out = [];
+  if (entry2.refs !== 0) head |= ENTRY_REFERENCED;
+  if (entry2.safe !== 0) head |= ENTRY_SAFE_EDGES;
+  out.push(head >>> 0);
+  if (entry2.refs !== 0) out.push(entry2.refs);
+  if (entry2.safe !== 0) out.push(entry2.safe);
+  out.push(...entry2.words);
+  return out;
+}
+
+// src/interactives/inspect/props.ts
+var PROP_FOCUSABLE = 48;
+var PROP_TEXT_WRAP_STYLE = 74;
+var DEFAULT_FONT_SIZE = 16;
+var DEFAULT_FONT_WEIGHT = 400;
+var DEFAULT_TEXT_COLOR = 4294967295;
+var DIRECTION = { 0: "row", 1: "column", 2: "row-reverse", 3: "column-reverse" };
+var JUSTIFY = { 0: "start", 1: "end", 2: "center", 3: "space-between", 4: "space-around", 5: "space-evenly" };
+var ALIGN = { 0: "auto", 1: "start", 2: "end", 3: "center", 4: "stretch" };
+var POSITION = { 0: "relative", 1: "absolute" };
+var TEXT_ALIGN = { 0: "start", 1: "end", 2: "left", 3: "center", 4: "right" };
+var VERTICAL_ALIGN = { 0: "top", 1: "center", 2: "bottom" };
+var SHAPE_KIND = { 0: "rect", 1: "ellipse", 2: "path" };
+var TEXT_WRAP_STYLE = { 0: "greedy", 1: "balance", 2: "pretty" };
+var PROPS = {
+  [UiProp.width]: ["width", "length"],
+  [UiProp.height]: ["height", "length"],
+  [UiProp.min_width]: ["minWidth", "length"],
+  [UiProp.min_height]: ["minHeight", "length"],
+  [UiProp.max_width]: ["maxWidth", "length"],
+  [UiProp.max_height]: ["maxHeight", "length"],
+  [UiProp.basis]: ["basis", "length"],
+  [UiProp.padding]: ["padding", "quad"],
+  [UiProp.margin]: ["margin", "quad"],
+  [UiProp.border_width]: ["borderWidth", "quad"],
+  [UiProp.inset_top]: ["top", "length"],
+  [UiProp.inset_right]: ["right", "length"],
+  [UiProp.inset_bottom]: ["bottom", "length"],
+  [UiProp.inset_left]: ["left", "length"],
+  [UiProp.gap]: ["gap", "pair"],
+  [UiProp.grow]: ["grow", "float"],
+  [UiProp.shrink]: ["shrink", "float"],
+  [UiProp.aspect]: ["aspect", "float"],
+  [UiProp.direction]: ["direction", DIRECTION],
+  [UiProp.justify]: ["justify", JUSTIFY],
+  [UiProp.align_items]: ["alignItems", ALIGN],
+  [UiProp.align_self]: ["alignSelf", ALIGN],
+  [UiProp.align_content]: ["alignContent", ALIGN],
+  [UiProp.position]: ["position", POSITION],
+  [UiProp.wrap]: ["wrap", "bool"],
+  [UiProp.display_none]: ["displayNone", "bool"],
+  [UiProp.fill]: ["fill", "color"],
+  [UiProp.border_color]: ["borderColor", "colors"],
+  [UiProp.radii]: ["radius", "quad"],
+  [UiProp.opacity]: ["opacity", "float"],
+  [UiProp.translate]: ["translate", "pair"],
+  [UiProp.scale]: ["scale", "pair"],
+  [UiProp.rotate]: ["rotate", "float"],
+  [UiProp.origin]: ["origin", "pair"],
+  [UiProp.z_index]: ["zIndex", "int"],
+  [UiProp.hidden]: ["hidden", "bool"],
+  [UiProp.clip]: ["clip", "bool"],
+  [UiProp.pointer_events_none]: ["pointerEventsNone", "bool"],
+  [UiProp.shadow]: ["shadow", "shadow"],
+  [UiProp.gradient]: ["gradient", "gradient"],
+  [PROP_DISABLED]: ["disabled", "bool"],
+  [PROP_FOCUSABLE]: ["focusable", "bool"],
+  [UiProp.font_family]: ["fontFamily", "word"],
+  [UiProp.font_weight]: ["fontWeight", "word"],
+  [UiProp.font_size]: ["fontSize", "float"],
+  [UiProp.line_height]: ["lineHeight", "float"],
+  [UiProp.letter_spacing]: ["letterSpacing", "float"],
+  [UiProp.text_align]: ["textAlign", TEXT_ALIGN],
+  [UiProp.text_color]: ["textColor", "color"],
+  [UiProp.text_wrap]: ["textWrap", "bool"],
+  [UiProp.vertical_align]: ["verticalAlign", VERTICAL_ALIGN],
+  [UiProp.placeholder_color]: ["placeholderColor", "color"],
+  [PROP_TEXT_WRAP_STYLE]: ["textWrapStyle", TEXT_WRAP_STYLE],
+  [UiProp.image_tint]: ["tint", "color"],
+  [UiProp.image_uv]: ["uv", "quad"],
+  [UiProp.nine_slice]: ["nineSlice", "quad"],
+  [UiProp.nine_slice_uv]: ["nineSliceUv", "quad"],
+  [UiProp.shape_kind]: ["shape", SHAPE_KIND],
+  [UiProp.stroke_color]: ["stroke", "color"],
+  [UiProp.stroke_width]: ["strokeWidth", "float"],
+  [UiProp.scroll_axes]: ["scrollAxes", "word"]
+};
+var NOT_STYLE = /* @__PURE__ */ new Set([UiProp.flags, UiProp.role, UiProp.traits, UiProp.actions]);
+var f322 = new Float32Array(1);
+var u322 = new Uint32Array(f322.buffer);
+var i32 = new Int32Array(f322.buffer);
+function floatOf(word2) {
+  u322[0] = word2;
+  return Math.round(f322[0] * 1e3) / 1e3;
+}
+function intOf(word2) {
+  u322[0] = word2;
+  return i32[0];
+}
+var HEX2 = 16;
+var BYTE_HEX = 2;
+function hexColor(word2) {
+  return `#${(word2 >>> 0).toString(HEX2).padStart(BYTE_HEX * 4, "0")}`;
+}
+function quad(words) {
+  if (words.length < 4) return floatOf(words[0] ?? 0);
+  const values = words.slice(0, 4).map(floatOf);
+  return values.every((v) => v === values[0]) ? values[0] : values;
+}
+function pair(words) {
+  if (words.length < 2) return floatOf(words[0] ?? 0);
+  const values = words.slice(0, 2).map(floatOf);
+  return values[0] === values[1] ? values[0] : values;
+}
+function decode(shape, raw) {
+  const words = raw.words;
+  const first = words[0] ?? 0;
+  if (typeof shape === "object") return shape[first] ?? first;
+  switch (shape) {
+    case "length":
+      return raw.unit === 0 ? "auto" : raw.unit === 2 ? `${floatOf(first)}%` : floatOf(first);
+    case "float":
+      return floatOf(first);
+    case "int":
+      return intOf(first);
+    case "word":
+      return first;
+    case "bool":
+      return first !== 0;
+    case "color":
+      return hexColor(first);
+    case "colors": {
+      if (words.length < 4) return hexColor(first);
+      const colors = words.slice(0, 4).map(hexColor);
+      return colors.every((c) => c === colors[0]) ? colors[0] : colors;
+    }
+    case "quad":
+      return quad(words);
+    case "pair":
+      return pair(words);
+    case "shadow":
+      return words.length < 5 ? null : { color: hexColor(words[0]), x: floatOf(words[1]), y: floatOf(words[2]), blur: floatOf(words[3]), spread: floatOf(words[4]) };
+    case "gradient":
+      return words.length === 0 ? null : { kind: words[0] === 1 ? "radial" : "linear", stops: words.slice(1, 5).map(hexColor) };
+  }
+}
+function resolvedStyle(node) {
+  const out = {};
+  const ids = [...node.props.keys()].sort((a, b) => a - b);
+  for (const id of ids) {
+    if (NOT_STYLE.has(id)) continue;
+    const spec = PROPS[id];
+    const raw = node.props.get(id);
+    if (spec === void 0) {
+      out[`prop${id}`] = raw.words.slice();
+      continue;
+    }
+    out[spec[0]] = decode(spec[1], raw);
+  }
+  return out;
+}
+function word(node, prop) {
+  const raw = node.props.get(prop);
+  return raw === void 0 || raw.words.length === 0 ? null : raw.words[0];
+}
+function float(node, prop) {
+  const w = word(node, prop);
+  return w === null ? null : floatOf(w);
+}
+function fontSize(node) {
+  return float(node, UiProp.font_size) ?? DEFAULT_FONT_SIZE;
+}
+function fontWeight(node) {
+  return word(node, UiProp.font_weight) ?? DEFAULT_FONT_WEIGHT;
+}
+function textColor(node) {
+  return word(node, UiProp.text_color) ?? DEFAULT_TEXT_COLOR;
+}
+function flags(node) {
+  return word(node, UiProp.flags) ?? 0;
+}
+function traits(node) {
+  return word(node, UiProp.traits) ?? 0;
+}
+function role(node) {
+  const code = word(node, UiProp.role) ?? UiRole.none;
+  for (const [name, value] of Object.entries(UiRole)) if (value === code) return name;
+  return "none";
+}
+var INTERACTIVE_ROLES = /* @__PURE__ */ new Set(["button", "link", "adjustable", "tab", "text_field"]);
+var INTERACTIVE_FLAGS = UiFlag.tap | UiFlag.press | UiFlag.drag | UiFlag.long_press;
+function interactive(node) {
+  return node.kind === "input" || (flags(node) & INTERACTIVE_FLAGS) !== 0 || INTERACTIVE_ROLES.has(role(node));
+}
+function gestureNames(node) {
+  const bits2 = flags(node);
+  const out = [];
+  if ((bits2 & UiFlag.tap) !== 0) out.push("tap");
+  if ((bits2 & UiFlag.press) !== 0) out.push("press");
+  if ((bits2 & UiFlag.long_press) !== 0) out.push("long_press");
+  if ((bits2 & UiFlag.drag) !== 0) out.push("drag");
+  return out;
+}
+function disabled(node) {
+  return (traits(node) & UiTrait.disabled) !== 0 || (node.active & Condition.disabled) !== 0;
+}
+function hiddenFromAccessibility(node) {
+  return (traits(node) & UiTrait.hidden) !== 0;
+}
+var INSPECT_SCHEMA = "cimplify.inspect/1";
+var SITE = /^(.*):(\d+):(\d+)$/;
+function parseSite(where) {
+  const match = SITE.exec(where);
+  if (match === null) return null;
+  return { file: match[1], line: Number(match[2]), column: Number(match[3]) };
+}
+function anchorName(code) {
+  for (const [name, value] of Object.entries(UiAnchor)) if (value === code) return name;
+  return null;
+}
+function displayedText(node, model, shown) {
+  if (node.kind !== "text" && node.kind !== "input") return null;
+  if (shown !== void 0 && shown.length > 0) return shown;
+  if (node.text !== null) return node.text;
+  if (node.textRef !== null) return model.strings.get(node.textRef) ?? null;
+  if (node.number !== null) return String(node.number.value);
+  return null;
+}
+function viewportOf(device, reported) {
+  if (reported === null || reported.length < 7) return { width: device.width, height: device.height, scale: device.scale, insets: device.insets };
+  return { width: reported[0], height: reported[1], scale: reported[2], insets: { top: reported[3], right: reported[4], bottom: reported[5], left: reported[6] } };
+}
+function buildNodes(input) {
+  const { model, measured } = input;
+  const sites = /* @__PURE__ */ new Map();
+  for (const site of input.sites) sites.set(site[0], site);
+  const exempt = /* @__PURE__ */ new Map();
+  for (const [node, check, reason] of input.exempt) {
+    const list = exempt.get(node) ?? [];
+    list.push({ check, reason });
+    exempt.set(node, list);
+  }
+  const nodes = [...model.nodes.values()].sort((a, b) => {
+    const za = measured?.paint.get(a.id);
+    const zb = measured?.paint.get(b.id);
+    if (za !== void 0 && zb !== void 0) return za - zb;
+    if (za !== void 0) return -1;
+    if (zb !== void 0) return 1;
+    return a.order - b.order;
+  });
+  return nodes.map((node) => {
+    const rect = measured?.rects.get(node.id) ?? null;
+    const site = sites.get(node.id);
+    return {
+      id: node.id,
+      kind: node.kind,
+      name: site?.[2] ?? null,
+      parent: node.parent,
+      children: node.children.slice(),
+      rect,
+      visible: rect !== null && rect.width > 0 && rect.height > 0,
+      z: measured?.paint.get(node.id) ?? null,
+      text: displayedText(node, model, measured?.shown.get(node.id)),
+      label: node.label,
+      value: node.value,
+      placeholder: node.placeholder,
+      role: role(node),
+      gestures: gestureNames(node),
+      interactive: interactive(node),
+      state: { disabled: disabled(node), focused: node.focused, accessibility_hidden: hiddenFromAccessibility(node), occluded: node.occluded },
+      style: resolvedStyle(node),
+      variants: [...node.variants.keys()].sort((a, b) => conditionPriority(a) - conditionPriority(b) || a - b).map(conditionName),
+      conditions: conditionName(node.active),
+      root: node.root !== null ? { kind: "screen", anchor: anchorName(node.root.anchor), safe_area: node.root.safeArea, z: node.root.z } : node.worldRoot !== null ? { kind: "world", anchor: null, safe_area: null, z: node.worldRoot.z } : null,
+      intrinsic: measured?.intrinsic.get(node.id) ?? null,
+      source: site === void 0 ? null : parseSite(site[1]),
+      exempt: exempt.get(node.id) ?? []
+    };
+  });
+}
+var SNIPPET = 32;
+function quote(text) {
+  const flat = text.replace(/\s+/g, " ");
+  return JSON.stringify(flat.length > SNIPPET ? `${flat.slice(0, SNIPPET - 1)}\u2026` : flat);
+}
+function describeNode(node) {
+  const parts = [`${node.kind} #${node.id}`];
+  if (node.name !== null) parts.push(node.name);
+  if (node.text !== null && node.text.length > 0) parts.push(quote(node.text));
+  else if (node.label !== null && node.label.length > 0) parts.push(quote(node.label));
+  return parts.join(" ");
+}
+function sourceText(source) {
+  return source === null ? null : `${source.file}:${source.line}:${source.column}`;
+}
+function rectText(rect) {
+  return `${rect.x},${rect.y} ${rect.width}x${rect.height}`;
+}
+var COMPACT_STYLE_KEYS = ["fill", "textColor", "fontSize", "opacity", "direction", "padding", "gap", "radius", "clip", "hidden", "displayNone"];
+function compactTree(nodes, viewport, header, marks) {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const lines = [
+    `${header} viewport ${viewport.width}x${viewport.height}@${viewport.scale} safe ${viewport.insets.top}/${viewport.insets.right}/${viewport.insets.bottom}/${viewport.insets.left}`
+  ];
+  const visit = (node, depth) => {
+    const parts = [`${"  ".repeat(depth)}#${node.id} ${node.kind}`];
+    if (node.name !== null) parts.push(node.name);
+    if (node.text !== null && node.text.length > 0) parts.push(quote(node.text));
+    else if (node.label !== null && node.label.length > 0) parts.push(`label=${quote(node.label)}`);
+    parts.push(node.rect === null ? "(not drawn)" : rectText(node.rect));
+    if (node.z !== null) parts.push(`z${node.z}`);
+    if (node.root !== null) parts.push(node.root.kind === "world" ? "world-root" : `root:${node.root.anchor ?? "?"}${node.root.safe_area ? "+safe" : ""}`);
+    if (node.gestures.length > 0) parts.push(node.gestures.join("+"));
+    if (node.role !== "none" && node.role !== "group") parts.push(`role:${node.role}`);
+    if (node.state.disabled) parts.push("disabled");
+    if (node.state.focused) parts.push("focused");
+    for (const key of COMPACT_STYLE_KEYS) {
+      const value = node.style[key];
+      if (value === void 0 || value === false) continue;
+      parts.push(`${key}=${typeof value === "object" ? JSON.stringify(value) : String(value)}`);
+    }
+    const source = sourceText(node.source);
+    if (source !== null) parts.push(`@${source}`);
+    for (const mark of marks.get(node.id) ?? []) parts.push(`!${mark}`);
+    lines.push(parts.join(" "));
+    for (const child of node.children) {
+      const next = byId.get(child);
+      if (next !== void 0) visit(next, depth + 1);
+    }
+  };
+  const roots = nodes.filter((n) => n.parent === null || !byId.has(n.parent));
+  for (const root of roots) visit(root, 0);
+  return lines.join("\n");
+}
+
+// src/interactives/inspect/checks.ts
+var UI_EXEMPT_REASONS = {
+  text_overflow: ["intentional_clip", "marquee", "decorative"],
+  tap_target: ["expanded_hit_area", "dense_grid", "secondary_control", "decorative"],
+  contrast: ["decorative", "disabled", "logo", "inside_image"],
+  safe_area: ["full_bleed_background", "dismissible_overlay", "decorative"],
+  text_size: ["badge_counter", "legal_fine_print", "decorative"]
+};
+var MIN_TAP_PT = 44;
+var MIN_TEXT_PT = 11;
+var OVERFLOW_ALLOWANCE_PT = 0.5;
+var SAFE_ALLOWANCE_PT = 0.5;
+function ceil(value) {
+  return Math.ceil(value);
+}
+function fixed(value) {
+  return Math.round(value * 100) / 100;
+}
+function intersects(a, b) {
+  return a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
+}
+function overhang(inner, outer) {
+  return Math.max(outer.x - inner.x, outer.y - inner.y, inner.x + inner.width - (outer.x + outer.width), inner.y + inner.height - (outer.y + outer.height), 0);
+}
+function inWorld(node, byId) {
+  let cursor = node;
+  while (cursor !== void 0) {
+    if (cursor.root?.kind === "world") return true;
+    cursor = cursor.parent === null ? void 0 : byId.get(cursor.parent);
+  }
+  return false;
+}
+function textOverflow(node, model, byId, viewport, out) {
+  const rect = node.rect;
+  const base = { check: "text_overflow", node: node.id, element: describeNode(node), source: sourceText(node.source) };
+  const intrinsic = node.intrinsic;
+  const wraps = (word(model, UiProp.text_wrap) ?? 0) !== 0;
+  const size = fontSize(model);
+  if (intrinsic !== null) {
+    const overX = intrinsic.width - rect.width;
+    const overY = intrinsic.height - rect.height;
+    if (overX > OVERFLOW_ALLOWANCE_PT || overY > OVERFLOW_ALLOWANCE_PT) {
+      const smaller = Math.max(1, Math.floor(size * Math.min(rect.width / Math.max(intrinsic.width, 1), rect.height / Math.max(intrinsic.height, 1))));
+      const fix = overX > OVERFLOW_ALLOWANCE_PT && !wraps ? `set textWrap: true (class "text-wrap") so the text breaks onto more lines, widen the box to at least ${ceil(intrinsic.width)} pt, or lower fontSize to ${smaller}` : `remove the fixed height or raise it to at least ${ceil(intrinsic.height)} pt, or lower fontSize to ${smaller}`;
+      out.push({
+        ...base,
+        message: `text needs ${fixed(intrinsic.width)}x${fixed(intrinsic.height)} pt but its box is ${rect.width}x${rect.height} pt`,
+        fix,
+        measured: { needed_width: fixed(intrinsic.width), needed_height: fixed(intrinsic.height), width: rect.width, height: rect.height }
+      });
+      return;
+    }
+  }
+  let cursor = node.parent === null ? void 0 : byId.get(node.parent);
+  while (cursor !== void 0) {
+    const clips = cursor.style.clip === true || cursor.kind === "scroll";
+    if (clips && cursor.kind !== "scroll" && cursor.rect !== null) {
+      const cut = overhang(rect, cursor.rect);
+      if (cut > OVERFLOW_ALLOWANCE_PT) {
+        out.push({
+          ...base,
+          message: `text is clipped by ${describeNode(cursor)} by ${fixed(cut)} pt`,
+          fix: `let ${describeNode(cursor)} grow (remove its fixed width or height), give the text textWrap: true, or lower fontSize to ${Math.max(1, Math.floor(size * 0.85))}`,
+          measured: { clipped_by: cursor.id, overhang: fixed(cut) }
+        });
+        return;
+      }
+    }
+    cursor = cursor.parent === null ? void 0 : byId.get(cursor.parent);
+  }
+  const screen = { x: 0, y: 0, width: viewport.width, height: viewport.height };
+  const off = overhang(rect, screen);
+  if (off > OVERFLOW_ALLOWANCE_PT && !inWorld(node, byId)) {
+    out.push({
+      ...base,
+      message: `text runs ${fixed(off)} pt off the ${viewport.width}x${viewport.height} screen`,
+      fix: `constrain its container with maxWidth: "100%" and textWrap: true, or anchor its root inside the screen`,
+      measured: { overhang: fixed(off) }
+    });
+  }
+}
+function tapTarget(node, out) {
+  const rect = node.rect;
+  if (rect.width >= MIN_TAP_PT && rect.height >= MIN_TAP_PT) return;
+  const padX = Math.max(0, ceil((MIN_TAP_PT - rect.width) / 2));
+  const padY = Math.max(0, ceil((MIN_TAP_PT - rect.height) / 2));
+  out.push({
+    check: "tap_target",
+    node: node.id,
+    element: describeNode(node),
+    source: sourceText(node.source),
+    message: `tap target is ${rect.width}x${rect.height} pt, under the ${MIN_TAP_PT}x${MIN_TAP_PT} pt minimum`,
+    fix: `set minWidth: ${MIN_TAP_PT} and minHeight: ${MIN_TAP_PT} (class "min-w-11 min-h-11"), or add padding of ${padY} pt vertically and ${padX} pt horizontally`,
+    measured: { width: rect.width, height: rect.height, minimum: MIN_TAP_PT }
+  });
+}
+function layerColor(model) {
+  if (model.kind === "image") return "unknown";
+  const gradient = model.props.get(UiProp.gradient);
+  if (gradient !== void 0 && gradient.words.length > 0) return "unknown";
+  const fill = word(model, UiProp.fill);
+  if (fill === null) return null;
+  const color = fromWord(fill);
+  const opacity = float(model, UiProp.opacity) ?? 1;
+  return { ...color, a: color.a * opacity };
+}
+function background(start, ui) {
+  const layers = [];
+  let cursor = start;
+  while (cursor !== void 0) {
+    const layer = layerColor(cursor);
+    if (layer === "unknown") return null;
+    if (layer !== null && layer.a > 0) {
+      layers.push(layer);
+      if (layer.a >= 1) {
+        let color = layers[layers.length - 1];
+        for (let i = layers.length - 2; i >= 0; i--) color = over(layers[i], color);
+        return color;
+      }
+    }
+    cursor = cursor.parent === null ? void 0 : ui.nodes.get(cursor.parent);
+  }
+  return null;
+}
+function contrast(node, model, input, out, unresolved) {
+  const rect = node.rect;
+  const fg = fromWord(textColor(model));
+  const own = float(model, UiProp.opacity) ?? 1;
+  const foreground = { ...fg, a: fg.a * own };
+  let bg = background(model, input.model);
+  let sampled = false;
+  if (bg === null && input.screenshot !== null) {
+    const s = input.viewport.scale;
+    bg = dominantColor(input.screenshot.pixels, input.screenshot.width, input.screenshot.height, { x0: rect.x * s, y0: rect.y * s, x1: (rect.x + rect.width) * s, y1: (rect.y + rect.height) * s });
+    sampled = bg !== null;
+  }
+  if (bg === null) {
+    unresolved.push({ check: "contrast", node: node.id, element: describeNode(node), why: "the background is the game scene, an image or a gradient and no screenshot was taken" });
+    return;
+  }
+  const size = fontSize(model);
+  const weight = fontWeight(model);
+  const required = requiredContrast(size, weight);
+  const ratio = contrastRatio(foreground, bg);
+  if (ratio >= required) return;
+  const suggestion = passingColor(foreground, bg, required);
+  out.push({
+    check: "contrast",
+    node: node.id,
+    element: describeNode(node),
+    source: sourceText(node.source),
+    message: `contrast is ${fixed(ratio)}:1 (${toHex(foreground)} on ${toHex(bg)}${sampled ? ", background sampled from the frame" : ""}), under ${required}:1 for ${required === 3 ? "large" : "body"} text`,
+    fix: `use textColor ${toHex(suggestion)} (${fixed(contrastRatio(suggestion, bg))}:1), or darken or lighten the background behind it`,
+    measured: { ratio: fixed(ratio), required, foreground: toHex(foreground), background: toHex(bg), font_size: size }
+  });
+}
+function safeArea(node, viewport, out) {
+  const rect = node.rect;
+  const insets = viewport.insets;
+  const landscape = viewport.width > viewport.height;
+  const bands = [];
+  if (insets.top > 0) bands.push({ name: landscape ? "status bar" : "notch", band: { x: 0, y: 0, width: viewport.width, height: insets.top }, move: "down", amount: insets.top - rect.y });
+  if (insets.bottom > 0) bands.push({ name: "home indicator", band: { x: 0, y: viewport.height - insets.bottom, width: viewport.width, height: insets.bottom }, move: "up", amount: rect.y + rect.height - (viewport.height - insets.bottom) });
+  if (insets.left > 0) bands.push({ name: "notch", band: { x: 0, y: 0, width: insets.left, height: viewport.height }, move: "right", amount: insets.left - rect.x });
+  if (insets.right > 0) bands.push({ name: landscape ? "notch" : "screen edge", band: { x: viewport.width - insets.right, y: 0, width: insets.right, height: viewport.height }, move: "left", amount: rect.x + rect.width - (viewport.width - insets.right) });
+  for (const band of bands) {
+    if (!intersects(rect, band.band) || band.amount <= SAFE_ALLOWANCE_PT) continue;
+    out.push({
+      check: "safe_area",
+      node: node.id,
+      element: describeNode(node),
+      source: sourceText(node.source),
+      message: `${node.interactive ? "interactive" : "text"} node sits ${fixed(band.amount)} pt under the ${band.name}`,
+      fix: `root it with ui.root(element, { safe_area: true }), or add @safe padding on its container, for example { padding: { default: 8, "@safe": 8 } }; it needs to move ${band.move} ${ceil(band.amount)} pt`,
+      measured: { overlap: fixed(band.amount), inset: band.name === "home indicator" ? insets.bottom : band.move === "down" ? insets.top : band.move === "right" ? insets.left : insets.right }
+    });
+    return;
+  }
+}
+function textSize(node, model, out) {
+  const size = fontSize(model);
+  if (size >= MIN_TEXT_PT) return;
+  out.push({
+    check: "text_size",
+    node: node.id,
+    element: describeNode(node),
+    source: sourceText(node.source),
+    message: `text is ${size} pt, under the ${MIN_TEXT_PT} pt minimum`,
+    fix: `use fontSize: 12 or more (class "text-xs" is 12 pt)`,
+    measured: { font_size: size, minimum: MIN_TEXT_PT }
+  });
+}
+function runChecks(input) {
+  const byId = new Map(input.nodes.map((n) => [n.id, n]));
+  const found = [];
+  const unresolved = [];
+  for (const node of input.nodes) {
+    const model = input.model.nodes.get(node.id);
+    if (model === void 0 || !node.visible || node.rect === null) continue;
+    const isText = (node.kind === "text" || node.kind === "input") && (node.text ?? "").trim().length > 0;
+    if (isText) {
+      textOverflow(node, model, byId, input.viewport, found);
+      textSize(node, model, found);
+      if (!node.state.disabled) contrast(node, model, input, found, unresolved);
+    }
+    if (node.interactive && !node.state.disabled) tapTarget(node, found);
+    if ((isText || node.interactive) && !inWorld(node, byId)) safeArea(node, input.viewport, found);
+  }
+  const findings = [];
+  const exempted = [];
+  const invalid = [];
+  for (const node of input.nodes) {
+    for (const exemption of node.exempt) {
+      const reasons = UI_EXEMPT_REASONS[exemption.check];
+      if (reasons === void 0 || !reasons.includes(exemption.reason)) invalid.push(`${describeNode(node)}: "${exemption.reason}" is not a reason to exempt ${exemption.check}`);
+    }
+  }
+  for (const finding of found) {
+    const node = byId.get(finding.node);
+    const exemption = node?.exempt.find((e) => e.check === finding.check && UI_EXEMPT_REASONS[finding.check].includes(e.reason));
+    if (exemption === void 0) findings.push(finding);
+    else exempted.push({ ...finding, reason: exemption.reason });
+  }
+  return { findings, exempted, unresolved, invalid_exemptions: invalid };
+}
+function findingMarks(report) {
+  const marks = /* @__PURE__ */ new Map();
+  for (const finding of report.findings) {
+    const list = marks.get(finding.node) ?? [];
+    list.push(finding.check);
+    marks.set(finding.node, list);
+  }
+  return marks;
+}
+function formatFinding(finding) {
+  return `${finding.source ?? "(no source)"}: ${finding.check}: ${finding.element}: ${finding.message}. Fix: ${finding.fix}`;
+}
+var RECORD_BYTES = 52;
+var SETTLE_MICROS = 1e6;
+var SETTLE_FRAMES = 2;
+var UNIT_AUTO = 0;
+var UNIT_POINTS2 = 1;
+var ALIGN_START = 1;
+var PATCH_BYTES = 64 * 1024;
+var WORD2 = 4;
+var RECORD_HEADER_WORDS = 2;
+var MAX_COMPACT_WORDS = 255;
+var VERSION_OFFSET = 4;
+var COUNT_OFFSET2 = 8;
+var TEXT_KINDS = /* @__PURE__ */ new Set(["text", "input"]);
+var decoder2 = new TextDecoder();
+function round(value) {
+  return Math.round(value * 100) / 100;
+}
+function decodeShadow(exported) {
+  const records = Buffer.from(exported.records, "base64");
+  const strings = Buffer.from(exported.strings, "base64");
+  const view = new DataView(records.buffer, records.byteOffset, records.byteLength);
+  const text = (offset, length) => length === 0 ? "" : decoder2.decode(strings.subarray(offset, offset + length));
+  const out = [];
+  for (let at = 0; at + RECORD_BYTES <= records.byteLength; at += RECORD_BYTES) {
+    const u = (i) => view.getUint32(at + i * 4, true);
+    const f = (i) => view.getFloat32(at + i * 4, true);
+    out.push({
+      node: u(0),
+      parent: u(1),
+      role: u(2),
+      traits: u(3),
+      rect: { x: round(f(5)), y: round(f(6)), width: round(f(7)), height: round(f(8)) },
+      label: text(u(9), u(10)),
+      value: text(u(11), u(12))
+    });
+  }
+  return out;
+}
+function encoded(writer) {
+  if (writer.empty) return null;
+  const length = writer.finish();
+  return Buffer.from(writer.bytes.subarray(0, length)).toString("base64");
+}
+function preparePatch(model) {
+  const writer = new PatchWriter(PATCH_BYTES);
+  for (const node of model.nodes.values()) {
+    if ((word(node, UiProp.role) ?? UiRole.none) === UiRole.none) writer.propWord(node.id, UiProp.role, UiRole.group);
+    const bits2 = traits(node);
+    if ((bits2 & UiTrait.hidden) !== 0) writer.propWord(node.id, UiProp.traits, bits2 & ~UiTrait.hidden);
+    if (TEXT_KINDS.has(node.kind) && node.label !== null) writer.label(node.id, "");
+  }
+  return encoded(writer);
+}
+var f323 = new Float32Array(1);
+var u323 = new Uint32Array(f323.buffer);
+function bits(value) {
+  f323[0] = value;
+  return u323[0];
+}
+function entry(prop, unit, value) {
+  return { prop, unit, refs: 0, safe: 0, words: [value] };
+}
+function styleRecords(records) {
+  if (records.length === 0) return null;
+  const total = records.reduce((sum, r) => sum + RECORD_HEADER_WORDS + (RECORD_HEADER_WORDS + r.words.length > MAX_COMPACT_WORDS ? 1 : 0) + r.words.length, 0);
+  const view = new DataView(new ArrayBuffer(UI_HEADER_BYTES + total * WORD2));
+  view.setUint32(0, UI_MAGIC, true);
+  view.setUint16(VERSION_OFFSET, UI_VERSION, true);
+  view.setUint32(COUNT_OFFSET2, records.length, true);
+  let at = UI_HEADER_BYTES;
+  for (const record of records) {
+    const extended = RECORD_HEADER_WORDS + record.words.length > MAX_COMPACT_WORDS;
+    view.setUint8(at, OP_STYLE);
+    view.setUint8(at + 1, extended ? 0 : RECORD_HEADER_WORDS + record.words.length);
+    view.setUint16(at + 2, record.mask, true);
+    view.setUint32(at + 4, record.node, true);
+    at += RECORD_HEADER_WORDS * WORD2;
+    if (extended) {
+      view.setUint32(at, RECORD_HEADER_WORDS + 1 + record.words.length, true);
+      at += WORD2;
+    }
+    for (const w of record.words) {
+      view.setUint32(at, w >>> 0, true);
+      at += WORD2;
+    }
+  }
+  return Buffer.from(view.buffer).toString("base64");
+}
+function intrinsicPatch(model, rects) {
+  const records = [];
+  for (const node of model.nodes.values()) {
+    if (!TEXT_KINDS.has(node.kind)) continue;
+    const rect = rects.get(node.id);
+    if (rect === void 0) continue;
+    const wraps = (word(node, UiProp.text_wrap) ?? 0) !== 0;
+    const overrides = [
+      wraps ? entry(UiProp.width, UNIT_POINTS2, bits(rect.width)) : entry(UiProp.width, UNIT_AUTO, 0),
+      entry(UiProp.max_width, UNIT_AUTO, 0),
+      entry(UiProp.height, UNIT_AUTO, 0),
+      entry(UiProp.max_height, UNIT_AUTO, 0),
+      entry(UiProp.align_self, UNIT_AUTO, ALIGN_START),
+      entry(UiProp.shrink, UNIT_AUTO, bits(0)),
+      entry(UiProp.grow, UNIT_AUTO, bits(0))
+    ];
+    const kept = node.variants.get(node.active) ?? [];
+    const words = [];
+    for (const e of [...kept, ...overrides]) words.push(...encodeEntry(e));
+    records.push({ node: node.id, mask: node.active, words });
+  }
+  return styleRecords(records);
+}
+async function settled(driver) {
+  let last = null;
+  for (let i = 0; i < SETTLE_FRAMES; i++) last = await driver.frame(SETTLE_MICROS, true);
+  return last === null ? [] : decodeShadow(last);
+}
+async function measure(model, driver) {
+  if (!await driver.open()) return null;
+  try {
+    const prepare = preparePatch(model);
+    if (prepare !== null) await driver.apply(prepare);
+    const first = await settled(driver);
+    const rects = /* @__PURE__ */ new Map();
+    const paint = /* @__PURE__ */ new Map();
+    const shown = /* @__PURE__ */ new Map();
+    first.forEach((record, index) => {
+      rects.set(record.node, record.rect);
+      paint.set(record.node, index);
+      shown.set(record.node, record.label);
+    });
+    const intrinsic = /* @__PURE__ */ new Map();
+    const patch = intrinsicPatch(model, rects);
+    if (patch !== null) {
+      await driver.apply(patch);
+      for (const record of await settled(driver)) {
+        const node = model.nodes.get(record.node);
+        if (node !== void 0 && TEXT_KINDS.has(node.kind)) intrinsic.set(record.node, record.rect);
+      }
+    }
+    return { rects, paint, shown, intrinsic };
+  } finally {
+    await driver.close();
+  }
+}
+
+// src/interactives/inspect/report.ts
+function patchesOf(snapshot) {
+  return snapshot.patches.map((p) => new Uint8Array(Buffer.from(p, "base64")));
+}
+async function inspectSnapshot(snapshot, driver, device, screenshot) {
+  const viewport = viewportOf(device, snapshot.viewport);
+  const model = decodeStream(patchesOf(snapshot), viewport);
+  const measured = snapshot.ui ? await measure(model, driver) : null;
+  const nodes = buildNodes({ model, measured, sites: snapshot.sites, exempt: snapshot.exempt });
+  const checks = runChecks({ model, nodes, viewport, screenshot });
+  const problems = [...model.problems, ...snapshot.errors];
+  if (!snapshot.ui) problems.push("the game has not created a game UI yet");
+  else if (measured === null) problems.push("the engine could not lay out a copy of the game UI");
+  return {
+    model,
+    report: {
+      schema: INSPECT_SCHEMA,
+      frame: snapshot.frame,
+      time_ms: Math.round(snapshot.clock_ms * 1e3) / 1e3,
+      device: device.name,
+      viewport,
+      scene: snapshot.scene,
+      measured: measured !== null,
+      nodes,
+      checks,
+      problems
+    }
+  };
+}
+function compactReport(report) {
+  const scene = report.scene.current ?? report.scene.applied ?? null;
+  const header = `frame ${report.frame} t=${report.time_ms}ms device ${report.device}${scene === null ? "" : ` scene ${scene}`}`;
+  const tree = compactTree(report.nodes, report.viewport, header, findingMarks(report.checks));
+  const lines = [tree];
+  if (report.checks.findings.length > 0) {
+    lines.push("findings:");
+    for (const f of report.checks.findings) lines.push(`- ${f.check} #${f.node}${f.source === null ? "" : ` @${f.source}`}: ${f.message}; fix: ${f.fix}`);
+  }
+  for (const p of report.problems) lines.push(`problem: ${p}`);
+  return lines.join("\n");
+}
+
+export { compactReport, formatFinding, inspectSnapshot, patchesOf };