@ghia/native 0.0.0 → 0.11.0

package/index.d.ts

@@ -0,0 +1,2603 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+
+/**
+ * Which binding artifact the generated loader actually loaded: `'native'` for
+ * a native addon, otherwise the `platformArchABI` of the WASI flavor. Every
+ * flavor napi-rs can build is listed, because `NAPI_RS_NATIVE_LIBRARY_PATH`
+ * can point the loader at a WASI artifact this package does not build itself.
+ */
+export declare const __napiBindingTarget: 'native' | 'wasm32-wasi' | 'wasm32-wasip1'
+
+/** An update ready to download and install. */
+export declare class AvailableUpdate {
+  /** Version currently running. */
+  get currentVersion(): string
+  /** Version announced by the feed. */
+  get version(): string
+  /** Release notes, if the feed sent `notes`. */
+  get notes(): string | null
+  /** RFC 3339 publish date, if the feed sent `pub_date`. */
+  get date(): string | null
+  /** Download URL from the feed. */
+  get downloadUrl(): string
+  /** Packager format: `app`, `appimage`, `nsis`, or `wix`. */
+  get format(): string
+  /**
+   * Download, verify the signature, and replace the running app.
+   *
+   * Does not relaunch. Quit after this returns, or the next start uses the
+   * new files.
+   */
+  downloadAndInstall(): Promise<unknown>
+}
+
+/** The main GPUI renderer exposed to Node.js. */
+export declare class GpuixRenderer {
+  constructor(eventCallback?: (((err: Error | null, arg: EventPayload) => any)) | undefined | null)
+  /** Initialize GPUI using the native event-loop architecture for this OS. */
+  init(options?: WindowOptions | undefined | null): void
+  /**
+   * Apply a batch of mutations in a single FFI call.
+   *
+   * Accepts a JSON array of mutation tuples. Each tuple is an array where
+   * the first element is the operation name (string) and remaining elements
+   * are the arguments:
+   *
+   *   ["createElement",    id, "type"]
+   *   ["destroyElement",   id]
+   *   ["appendChild",      parentId, childId]
+   *   ["insertBefore",     parentId, childId, beforeId]
+   *   ["setStyle",         id, { ...style }]
+   *   ["setText",          id, "content"]
+   *   ["setEventListener", id, "eventType", true|false]
+   *   ["setRoot",          id]
+   *   ["setKeyboardFocusDim", true|false]
+   *   ["setUniversalStyle", { ...style } | null]
+   *   ["setCustomProp",    id, "key", value]
+   *
+   * Returns accumulated destroyed IDs from all destroyElement ops.
+   * Acquires the tree mutex ONCE for the entire batch.
+   */
+  applyBatch(json: string): Array<number>
+  /** Pump the native event loop. Returns false after the last window closes. */
+  tick(): boolean
+  isInitialized(): boolean
+  /**
+   * Registers the function native calls synchronously for events whose
+   * default JS can cancel: `keydown`, `keyup`. It takes the `EventPayload`
+   * and returns `{ defaultPrevented, propagationStopped }`. Pass `null` to
+   * remove it.
+   *
+   * Synchronous on macOS, where GPUI runs on the JS thread inside `tick()`.
+   * Windows and Linux run GPUI on another thread and keep delivering these
+   * events through the queue, so their handlers cannot cancel anything.
+   */
+  setSyncEventHandler(handler?: ((arg: EventPayload) => SyncDispatchResult) | undefined | null): void
+  /**
+   * Wake JavaScript when the main run loop has work: input, a main-queue block (the
+   * display link's frame step among them), a timer. Returns true on macOS, false on
+   * other platforms. The callback should schedule the tick rather than run it inline,
+   * and tick() never blocks. A wake that lands while a tick is running, or after another
+   * wake that has not been ticked yet, is dropped; work that arrived meanwhile wakes
+   * again when the tick re-arms the watch. An idle app gets no wakes. Wakes do not keep
+   * the process alive.
+   * Pass null to clear the callback. Already queued callbacks may still arrive.
+   */
+  setFrameWakeCallback(callback?: (() => void) | undefined | null): boolean
+  /**
+   * Whether JavaScript must call tick() until it returns false.
+   *
+   * macOS: tick() pumps AppKit. Windows/Linux: tick() only reports whether
+   * the UI thread is still inside `Platform::run`. Both return false after
+   * the last window closes so the JS frame loop can exit the process.
+   */
+  requiresTick(): boolean
+  /**
+   * The paintable size of the window in logical pixels, excluding any
+   * platform title bar. This used to answer a hardcoded 800x600, so anything
+   * that turned a mouse position into layout coordinates pointed at the
+   * wrong place on every window that was not exactly that size.
+   */
+  getWindowSize(): WindowSize
+  getWindowInsets(): WindowInsets
+  /** `"hidden"` | `"minimal"` | `"full"`. Paints into the scene after layout. */
+  setDebugFrameOverlay(mode: string): string
+  /** Hidden → minimal → full → hidden. */
+  cycleDebugFrameOverlay(): string
+  getDebugFrameOverlay(): string
+  /** Clears the last 1000 draw samples. Frame count stays. */
+  resetDebugFrameOverlayStats(): void
+  /** Same numbers as the on-screen overlay: current, p90, p99, max, frames. */
+  getDebugFrameOverlayStats(): DebugFrameOverlayStats
+  /**
+   * How ticks were drawn by patching the frame before them since the window was made, with why
+   * the others were drawn whole: subtract two reads for a span of frames.
+   */
+  getPatchCounters(): PatchCounters
+  /**
+   * Bring the window forward and give it focus. This is how a window opened
+   * with `show: false` or `focus: false` is revealed later.
+   */
+  activateWindow(): void
+  /** Minimize the native window. */
+  minimizeWindow(): void
+  /** Run the native zoom or maximize operation. */
+  zoomWindow(): void
+  /** Enter or exit native fullscreen. */
+  toggleFullscreen(): void
+  setWindowTitle(title: string): void
+  /** Open the platform path picker. Returns null when the user cancels. */
+  promptForPaths(options?: PathPromptOptions | undefined | null): Promise<Array<string> | null>
+  /** Replace the system clipboard's contents with plain text. */
+  writeClipboardText(text: string): void
+  /** The system clipboard's text, or null when it holds none. */
+  readClipboardText(): string | null
+  /** Whether `openEyeDropper` exists on this platform. macOS only. */
+  supportsEyeDropper(): boolean
+  /**
+   * Run the screen colour picker. Resolves `#rrggbb`, or null when the user
+   * cancels. There is no way to dismiss it from code.
+   */
+  openEyeDropper(): Promise<string | null>
+  /**
+   * `loadURL(url)` (with the URL as `argument`), `reload()`, `stop()`, `goBack()` and
+   * `goForward()` of a `<webview>`.
+   */
+  webviewCommand(elementId: number, command: string, argument?: string | undefined | null): void
+  /** The URL, the title and the history of a `<webview>`. */
+  webviewState(elementId: number): WebviewStateReading
+  /**
+   * Runs `code` in the page of a `<webview>`. Resolves with the JSON of the result of its last
+   * expression, or null when that is `undefined`; rejects with the script's error.
+   */
+  webviewExecuteJavascript(elementId: number, code: string): Promise<string | null>
+  focusElement(elementId: number): void
+  /** `element.blur()`: clear focus when `element_id` is the focused element. */
+  blurElement(elementId: number): void
+  /**
+   * `element.matches(selector)` for `:focus`, `:focus-visible`,
+   * `:focus-within`, `:hover` and `:active`. Any other selector is an error.
+   */
+  matchesFocus(elementId: number, selector: string): boolean
+  /** Move focus to the next GPUI tab stop. */
+  focusNext(): void
+  /** Move focus to the previous GPUI tab stop. */
+  focusPrevious(): void
+  /** Host id of the focused element, or null when nothing is focused. */
+  getFocusedElementId(): number | null
+  /** Move focus to the next tab stop inside `element_id`, wrapping in that subtree. */
+  focusNextWithin(elementId: number): void
+  /** Move focus to the previous tab stop inside `element_id`, wrapping in that subtree. */
+  focusPreviousWithin(elementId: number): void
+  /** Enable the window key events requested by the React renderer. */
+  setWindowKeyEvents(keyDown: boolean, keyUp: boolean, eventId: number): void
+  blur(): void
+  /** Enable the window selectionChange event requested by the React renderer. */
+  setWindowSelectionChange(enabled: boolean, eventId: number): void
+  /** Enable the window appearanceChange event requested by the React renderer. */
+  setWindowAppearanceChange(enabled: boolean, eventId: number): void
+  /**
+   * Enable the `mediaChange` event behind `matchMedia`. It fires when the OS
+   * accessibility preferences or the window appearance change.
+   */
+  setWindowMediaChange(enabled: boolean): void
+  /**
+   * The OS accessibility preferences that media queries expose. All false
+   * where the OS has no read (everything but macOS).
+   */
+  getMediaFeatures(): MediaFeatures
+  /**
+   * `"system"` follows the OS light/dark setting, `"light"` and `"dark"`
+   * force it for the whole app. Only macOS applies it; elsewhere GPUI has no
+   * override and the call is accepted and ignored.
+   */
+  setAppearance(appearance: string): void
+  /** The effective appearance of the window, `"light"` or `"dark"`. */
+  getAppearance(): string
+  /** A value that is written with `set` and `jump` or animated. */
+  createMotionValue(id: number, initial: any): void
+  /**
+   * A value mapped from the number value `input` through `inputRange` and
+   * `outputRange`. `options` is `{ clamp?: boolean, ease?: ease | ease[] }`.
+   */
+  createMotionTransform(id: number, input: number, inputRange: Array<number>, outputRange: any, options?: any | undefined | null): void
+  /**
+   * A spring that chases another value. `config` is a spring transition
+   * without the `type`.
+   */
+  createMotionFollower(id: number, source: number, config: any): void
+  /** A spring with a target of its own, which `setMotionValue` moves. */
+  createMotionSpring(id: number, initial: any, config: any): void
+  /** Whether the value existed. Values that read it fail from then on. */
+  disposeMotionValue(id: number): boolean
+  getMotionValue(id: number): any
+  /** Units per second. Errors for a value that is not a number. */
+  getMotionValueVelocity(id: number): number
+  isMotionValueAnimating(id: number): boolean
+  /**
+   * Writes the value. Over a running animation this does not stop it:
+   * call `stopMotionValue` first to take the value from the animation.
+   */
+  setMotionValue(id: number, value: any): void
+  /** Writes the value, ending any animation and dropping its velocity. */
+  jumpMotionValue(id: number, value: any): void
+  /**
+   * Animates a value from where it is, with the speed it has. `transition`
+   * is the same description `motion` takes, tween by default.
+   */
+  animateMotionValue(id: number, target: any, transition?: any | undefined | null): void
+  /** Ends an animation where it is, keeping the speed for the next one. */
+  stopMotionValue(id: number): void
+  /**
+   * Holds the value's animation where it is. The value stays, its velocity
+   * reads 0 and no frame is asked for; `isMotionValueAnimating` stays true.
+   */
+  pauseMotionValue(id: number): void
+  /**
+   * Continues a held animation from the time it holds. A finished one plays
+   * again from its start, or from its end when its speed is negative.
+   */
+  playMotionValue(id: number): void
+  /**
+   * Sets the time of the value's animation, Motion's `time`: it counts the
+   * delay, so a time inside the delay shows the first keyframe. A finished
+   * animation is held there; one seeked past its end finishes, and its time
+   * reads back as set.
+   */
+  seekMotionValue(id: number, seconds: number): void
+  /**
+   * Sets the pace of the value's animation: 2 is twice as fast, a negative
+   * speed runs it backwards to its first keyframe, 0 holds it while it stays
+   * in effect. As in Motion, a hold lasts until `play`, whatever the speed
+   * is set to after.
+   */
+  setMotionValueSpeed(id: number, speed: number): void
+  /**
+   * Jumps the value's animation to its last keyframe (the first when it runs
+   * backwards) and finishes it.
+   */
+  completeMotionValue(id: number): void
+  /**
+   * What the controls of the value's animation read, or null if it has none:
+   * it was never animated, or was stopped or jumped.
+   */
+  getMotionValuePlayback(id: number): MotionValuePlayback | null
+  /**
+   * Takes the frames away from the clock of the value's animation, as Motion's
+   * `attachTimeline` does: it holds the time it has until something sets another.
+   */
+  detachMotionValueClock(id: number): void
+  /** Chooses which events the value delivers. Neither removes the listener. */
+  setMotionValueListener(id: number, change: boolean, animation: boolean): void
+  /**
+   * Defines the keyframes `animation-name: name` plays, as the `@keyframes`
+   * rule does. `framesJson` is a JSON object of `from`, `to`, `N%` or comma
+   * list keys to the animatable style properties plus `animationTimingFunction`.
+   * Redefining a name replaces it for running animations too. A bad
+   * definition throws and leaves the earlier one. Use `defineKeyframes` from
+   * `@ghia/native/host`, which defines it on every renderer.
+   */
+  defineKeyframes(name: string, framesJson: string): void
+  /**
+   * The CSS transitions, then the CSS animations, of an element that are
+   * running, paused or in effect through a fill, in the order of the DOM's
+   * `getAnimations()`, then the animations of a `motion` element that Motion hands to the browser.
+   *
+   * An element inside skipped content is styled first, as a read of its geometry would: Chrome
+   * makes the CSS animations of content it never rendered when one of its elements is read.
+   */
+  getAnimations(elementId: number): Array<WebAnimationInfo>
+  /**
+   * `getAnimations({ subtree: true })` of an element: the CSS transitions, then the CSS
+   * animations, of the element and the elements below it, each in document order of the
+   * elements, with the element each is of. Throws for an element id that is not valid; an
+   * element that is not in the tree has none.
+   */
+  getSubtreeAnimations(elementId: number): Array<ElementWebAnimationInfo>
+  /**
+   * `document.getAnimations()` of this renderer's window: as `getSubtreeAnimations` for the
+   * root of the tree.
+   */
+  getDocumentAnimations(): Array<ElementWebAnimationInfo>
+  /**
+   * One CSS animation or transition by the id `getAnimations` gave. A run
+   * that finished or was cancelled answers as it ended until
+   * `releaseAnimation` says JS consumed its `webanimationfinish` or
+   * `webanimationcancel` event; after that, and for a transition whose style
+   * moved off its end value, it throws.
+   */
+  getAnimation(animationId: number): WebAnimationInfo
+  /**
+   * What `effect.getTiming()` and `effect.getComputedTiming()` read of the run `animationId`,
+   * as of the last frame. Throws for a run native no longer has.
+   */
+  getAnimationEffect(animationId: number): WebAnimationEffectInfo
+  /** `effect.getKeyframes()` of the run `animationId`. Throws for a run native no longer has. */
+  getAnimationKeyframes(animationId: number): Array<WebAnimationKeyframeInfo>
+  /**
+   * `effect.updateTiming(timing)` of the run `animationId`: what it sets stays set against a
+   * later style. Throws `TypeError: ...` for an easing that does not parse.
+   */
+  updateAnimationTiming(animationId: number, timing: WebAnimationTimingUpdate): void
+  /**
+   * JS consumed one `webanimationfinish` or `webanimationcancel` event of the
+   * run: native stops answering for what it ended as. Call it for every such
+   * event, whether or not an `Animation` object exists for the run.
+   */
+  releaseAnimation(animationId: number): void
+  /**
+   * JS no longer holds an `Animation` for the run: native drops what it kept of a run that was
+   * cancelled, for a command to bring it back. A run that plays is not affected, and a call
+   * for a run native has already dropped is nothing.
+   */
+  forgetAnimation(animationId: number): void
+  /**
+   * `animation.pause()`: holds the current time at once, and from here the
+   * style's `animation-play-state` no longer decides.
+   */
+  pauseAnimation(animationId: number): void
+  /**
+   * `animation.play()`: continues from the held time at the next frame, or
+   * from the start (the end when running backwards) if it has finished.
+   */
+  playAnimation(animationId: number): void
+  /** `animation.currentTime = milliseconds`. */
+  setAnimationCurrentTime(animationId: number, milliseconds: number): void
+  /** `animation.playbackRate = rate`, keeping the current time. */
+  setAnimationPlaybackRate(animationId: number, rate: number): void
+  /**
+   * `animation.cancel()`: the animation is idle, with no current time and out of
+   * `getAnimations()`; `play()` brings it back from the start.
+   */
+  cancelAnimation(animationId: number): void
+  /**
+   * `animation.finish()`. Throws `InvalidStateError: ...` for a rate of 0 and for an animation
+   * that never ends.
+   */
+  finishAnimation(animationId: number): void
+  /**
+   * `animation.reverse()`: the rate flips at the next frame. Throws `InvalidStateError: ...`
+   * for an animation that never ends, from its start.
+   */
+  reverseAnimation(animationId: number): void
+  /**
+   * `animation.updatePlaybackRate(rate)`: at the next frame for a running animation, at once
+   * for the others.
+   */
+  updateAnimationPlaybackRate(animationId: number, rate: number): void
+  /**
+   * `animation.startTime = startTime`, in milliseconds on the timeline of the animations
+   * (`getAnimationTimelineTime`); `null` holds the current time.
+   */
+  setAnimationStartTime(animationId: number, startTime?: number | undefined | null): void
+  /**
+   * The time of the timeline of the animations (`animation.timeline.currentTime`): the
+   * instant of the last frame, in milliseconds on the clock of the renderer. The same
+   * number `startTime` and the `timelineTime` of the events are on.
+   */
+  getAnimationTimelineTime(): number
+  /** The current text selection joined in document order, or null. */
+  getSelectedText(): string | null
+  /** Drop the current selection and request a repaint. */
+  clearSelection(): void
+  /**
+   * Scroll an element to a DOM scroll position: `left` and `top` are `scrollLeft` and
+   * `scrollTop`, zero or more, so scrolling down is a larger `top`.
+   *
+   * `behavior` is `"instant"`, `"smooth"` or `"auto"` (the default), which follows the
+   * element's `scrollBehavior` style. A smooth scroll animates over the next frames.
+   */
+  scrollTo(elementId: number, left: number, top: number, behavior?: string | undefined | null): void
+  /**
+   * Scroll a child into view by its index in the children list.
+   *
+   * For a `<virtual-list>` the scroll is queued and applied on the next
+   * render, after that frame's child splice, so indices computed against a
+   * just-committed child list are never shifted twice. `offsetInItem` is in
+   * pixels and may be negative, which anchors the viewport top above the
+   * item and resolves against measured heights at layout time.
+   */
+  scrollToItem(elementId: number, index: number, offsetInItem?: number | undefined | null): void
+  /**
+   * The logical scroll anchor of a `<virtual-list>`:
+   * `[itemIndex, offsetInItemPx, viewportHeightPx]`, or null for anything
+   * else. `itemIndex == item count` is gpui's at-end sentinel.
+   *
+   * Unlike `getScrollOffset` this is exact even while row heights are still
+   * estimates, because it is the anchor gpui itself scrolls by.
+   */
+  getListScrollTop(elementId: number): Array<number> | null
+  /**
+   * The DOM scroll position of a scrollable element, `[scrollLeft, scrollTop]` (zero or
+   * more), or null if it is not a scroll container or a `<virtual-list>`.
+   */
+  getScrollOffset(elementId: number): Array<number> | null
+  /**
+   * The DOM's `scrollIntoView`: scrolls every scrollable ancestor so the element sits where
+   * `block` (default `"start"`) and `inline` (default `"nearest"`) ask. Each is `"start"`,
+   * `"center"`, `"end"` or `"nearest"`. `behavior` is as for `scrollTo`.
+   */
+  scrollIntoView(elementId: number, block?: string | undefined | null, inline?: string | undefined | null, behavior?: string | undefined | null): void
+  /**
+   * The default action of a scrolling key (`"up"`, `"down"`, `"left"`, `"right"`,
+   * `"pageup"`, `"pagedown"`, `"home"`, `"end"`, `"space"`): scrolls the innermost scrollable
+   * ancestor of the focused element, or the scroller under the pointer if nothing is focused.
+   * A focused text input or control keeps its keys.
+   *
+   * It reports nothing: called while the root view is being updated, it runs once that update
+   * has returned, and whether anything scrolled is not known yet at that point.
+   */
+  scrollByKey(key: string, shift: boolean): void
+  /**
+   * The DOM scroll geometry of an element:
+   * `[scrollLeft, scrollTop, scrollWidth, scrollHeight, clientWidth, clientHeight]`, or null
+   * if it has not been painted.
+   */
+  getScrollMetrics(elementId: number): Array<number> | null
+  /** The event types `window` or `document` listens for. Replaces the set. */
+  setWindowEventListeners(types: Array<string>): void
+  /**
+   * Capture the mouse for `element_id`. The request is recorded before this
+   * returns, so `hasPointerCapture` answers true and the next pointer input
+   * is already aimed at the element; that input fires `gotpointercapture`
+   * before its own events, as the DOM does. Ignored while no button is down.
+   */
+  setPointerCapture(elementId: number, pointerId: number): void
+  /**
+   * End `element_id`'s capture, if it holds one: recorded now, and the next
+   * pointer input fires `lostpointercapture`.
+   */
+  releasePointerCapture(elementId: number, pointerId: number): void
+  /** Whether `element_id` holds, or has been asked to hold, the mouse capture. */
+  hasPointerCapture(elementId: number, pointerId: number): boolean
+  /**
+   * End the element drag in progress, without a `dragend`: JS calls it when
+   * `dragstart` was cancelled. Recorded now and read first by the next
+   * pointer input, before it builds an event; the moves delivered since
+   * `dragstart` were already queued, and JS drops them.
+   */
+  cancelDrag(): void
+  /**
+   * Lock the pointer to `element_id`: the cursor hides and stops, and
+   * movement is reported as `movementX`/`movementY`. On macOS the lock is
+   * taken before this returns, from a handler too, and it fires
+   * `pointerlockchange` or, when the element is not connected or the platform
+   * refuses, `pointerlockerror`. Elsewhere the next frame applies it.
+   */
+  requestPointerLock(elementId: number): void
+  /** Release the pointer lock, if held. Applied like `requestPointerLock`. */
+  exitPointerLock(): void
+  /**
+   * The element that holds the pointer lock, or null. On macOS it is the
+   * element right after `requestPointerLock`.
+   */
+  pointerLockElement(): number | null
+  /**
+   * Deliver the click an activation that is not a pointer press makes on
+   * `element_id`, such as Enter on a button: a `click` with `detail` 0 that
+   * bubbles along the element's path, followed by the activation behaviour
+   * a label has. A disabled form control gets none, like
+   * `HTMLElement.click()`.
+   */
+  clickElement(elementId: number): void
+  /**
+   * Paint packed pixels onto an `<img>` host node. `format` is `"rgba"`
+   * (default) or `"bgra"`; BGRA skips the per-pixel swizzle.
+   */
+  setImagePixels(elementId: number, width: number, height: number, pixels: Buffer, format?: string | undefined | null): void
+  /**
+   * Decode PNG, JPEG, WebP, GIF, SVG, BMP, TIFF, ICO, or Netpbm bytes onto
+   * an `<img>` host node. Prefer `setImagePixels` for live waveforms.
+   */
+  setImage(elementId: number, bytes: Buffer): void
+  /**
+   * Encoded bytes for the `blob:` URL a `url()` background image names. The
+   * JS layer fetches the blob, because a blob URL only exists in its process.
+   */
+  setStyleImage(url: string, bytes: Buffer): void
+  /** The JS layer could not read the `blob:` URL a `url()` background names. */
+  failStyleImage(url: string, message: string): void
+  /** `select()` on an `<input>` or `<textarea>`: select all of its text. */
+  selectText(elementId: number): void
+  /**
+   * `setSelectionRange(start, end, direction)` on an `<input>` or
+   * `<textarea>`. Offsets are UTF-16 code units; `direction` is
+   * `"forward"`, `"backward"` or `"none"`.
+   */
+  setSelectionRange(elementId: number, start: number, end: number, direction?: string | undefined | null): void
+  /**
+   * `selectionStart`, `selectionEnd` and `selectionDirection` of an
+   * `<input>` or `<textarea>`.
+   */
+  getTextSelection(elementId: number): TextSelection
+  /**
+   * `form.requestSubmit()`: validate the form's controls, then emit `submit`.
+   * The events are delivered before this returns.
+   */
+  requestSubmit(elementId: number): void
+  /**
+   * Make the fonts in a TrueType or OpenType file (or a collection) usable by
+   * `fontFamily`, under the family names the file declares. Call it before
+   * the text that names the family is first laid out: a family that did not
+   * exist then has already fallen back to another font.
+   */
+  registerFont(data: Buffer): void
+  getAutomationTree(): string
+  getElementBounds(id: number): ElementBounds | null
+  /**
+   * The box of an element for the first report of an observer: laid out as `getElementBounds`
+   * does, but the content of a skipped ancestor is not, and an element inside it has no box
+   * (null), as Chrome's observers see it.
+   */
+  probeElementBounds(id: number): ElementBounds | null
+  /**
+   * The elements whose last painted box holds the window point `(x, y)`,
+   * topmost first, like the DOM's `elementsFromPoint`. An element that did
+   * not paint is never listed, `overflow: hidden | scroll` clips what lies
+   * outside it, and `pointer-events: none` is skipped.
+   */
+  getElementsAt(x: number, y: number): Array<number>
+  getAllText(): Array<string>
+  getPaintedText(): Array<string>
+  /**
+   * Every highlight wash painted in the last frame, in paint order.
+   *
+   * A quad is invisible to `getPaintedText()`, so this is the only way to
+   * assert on `highlight` without a screenshot.
+   */
+  getPaintedHighlights(): Array<HighlightMatch>
+  /**
+   * Press space-separated keys in Playwright's `keyboard.press` grammar
+   * (`"Enter"`, `"Shift+Tab"`, `"Meta+a"`, `"a"`, `"Space"`) through the
+   * focused element's input pipeline, each as a keydown then a keyup.
+   */
+  simulateKeystrokes(keystrokes: string): void
+  /** One keydown (one press in the `simulate_keystrokes` grammar), no keyup. */
+  simulateKeyDown(keystroke: string, isHeld?: boolean | undefined | null): void
+  /** One keyup (one press in the `simulate_keystrokes` grammar). */
+  simulateKeyUp(keystroke: string): void
+  /** `modifiers` is hyphenated: "cmd", "cmd-shift", "alt". */
+  simulateClick(x: number, y: number, button?: number | undefined | null, modifiers?: string | undefined | null): void
+  simulateMouseDown(x: number, y: number, button?: number | undefined | null, modifiers?: string | undefined | null): void
+  simulateMouseUp(x: number, y: number, button?: number | undefined | null, modifiers?: string | undefined | null): void
+  simulateMouseMove(x: number, y: number, pressedButton?: number | undefined | null, modifiers?: string | undefined | null): void
+  /**
+   * Dispatch a wheel event through the same GPUI hit test the trackpad uses.
+   * Deltas are pixels with the DOM's sign, like `WheelEvent.deltaY`: positive
+   * `delta_y` scrolls down, positive `delta_x` scrolls right, matching
+   * `TestGpuixRenderer::simulate_scroll_wheel`.
+   *
+   * `phase` is `"started"` (the default, a gesture of its own), `"moved"`,
+   * `"ended"` or `"cancelled"`. The scroller that took a gesture's first delta
+   * keeps the rest of it, so continue one with `"moved"`.
+   */
+  simulateScrollWheel(x: number, y: number, deltaX: number, deltaY: number, modifiers?: string | undefined | null, phase?: string | undefined | null): void
+  clockPause(): number
+  clockSet(nowMs: number): number
+  clockFastForward(deltaMs: number): number
+  clockResume(): number
+  captureScreenshot(path: string): void
+  /**
+   * Calls the registered frame wake closure from a Rust thread every `intervalMs`, the
+   * function the display link calls, so a hidden window gets deterministic wakes.
+   * `null` stops it; clearing the wake callback stops it too.
+   */
+  simulateFrameWakes(intervalMs?: number | undefined | null): void
+  /**
+   * Posts a real NSEvent for this window from `com.apple.NSEventThread`, the thread AppKit
+   * receives WindowServer input on, so an idle app's wake path is exercised the way input
+   * reaches it. `kind` is `"keyDown"` (the key `a`), `"mouseMove"`, `"click"` (a left mouse
+   * down, then up) or `"scroll"` (3 lines down); the last three need `x` and `y`, in logical
+   * pixels from the window's top left. The events go to `NSApplication`'s own queue: nothing
+   * is posted to the OS, and the window is not made key.
+   */
+  postNativeEvent(kind: string, x?: number | undefined | null, y?: number | undefined | null): void
+  /** Makes every `tick()` sleep `ms` inside its native call, a forced-slow frame. 0 turns it off. */
+  setTickDelay(ms: number): void
+}
+
+/**
+ * GPU-backed GPUI test renderer. Uses VisualTestAppContext with the native
+ * Metal or DirectX renderer and TestDispatcher for deterministic scheduling.
+ * Same GpuixView and rendering pipeline as production.
+ *
+ * Usage from JS:
+ *   const r = new TestGpuixRenderer()
+ *   r.applyBatch('[["createElement",1,"div"],["setRoot",1]]')
+ *   r.flush()                  // triggers GpuixView::render() on the GPU
+ *   r.simulateClick(50, 50)    // dispatches through GPUI hit testing
+ *   const events = r.drainEvents()
+ *   r.captureScreenshot("/tmp/test.png")  // saves rendered UI as PNG
+ */
+export declare class TestGpuixRenderer {
+  /**
+   * The same `WindowOptions` the live renderer opens its window with, translated by the
+   * same `to_gpui_window_options`. The size defaults to 1280x800 (not the live 800x600),
+   * and `focus` to false: the window is offscreen and must not take the OS's keyboard.
+   * `fullscreen` is ignored, because a fullscreen window would leave the offscreen
+   * position; see docs/reference.md's test renderer section for what else the window cannot
+   * represent. `scaleFactor` is the window's device pixels per CSS px, `1` when unset.
+   */
+  constructor(options?: WindowOptions | undefined | null, scaleFactor?: number | undefined | null)
+  /**
+   * Tears the window and its GPUI app down. Every call that needs the window
+   * throws afterwards; the retained tree stays readable. Call it after the
+   * root is unmounted.
+   */
+  dispose(): void
+  /**
+   * Wake JavaScript when the main run loop has work, like `GpuixRenderer.setFrameWakeCallback`:
+   * input that AppKit receives for the test window (`postNativeEvent`) is the usual wake, since
+   * the test window draws no frames. Returns true on macOS, false elsewhere. Pass null to clear.
+   */
+  setFrameWakeCallback(callback?: (() => void) | undefined | null): boolean
+  /**
+   * Whether JavaScript must call `tick()` for the frame loop: only where `setFrameWakeCallback`
+   * is.
+   */
+  requiresTick(): boolean
+  /**
+   * Hands the input AppKit has queued for the test window to it, without waiting, then runs the
+   * test context until it is parked. Draws nothing: frames stay `flush` and `drawFrame`.
+   * Returns true, since a test window stays open until `dispose`.
+   */
+  tick(): boolean
+  /**
+   * Posts a real NSEvent for the test window from `com.apple.NSEventThread`, as
+   * `GpuixRenderer.postNativeEvent` does: `kind` is `"keyDown"` (the key `a`), `"mouseMove"`,
+   * `"click"` or `"scroll"` (3 lines down); the last three need `x` and `y`, in logical pixels
+   * from the window's top left. The window is neither key nor on screen, and nothing reaches
+   * the OS. `tick()` is what delivers it to the window.
+   */
+  postNativeEvent(kind: string, x?: number | undefined | null, y?: number | undefined | null): void
+  /**
+   * Registers the function native calls synchronously for `keydown` and
+   * `keyup`; see `GpuixRenderer::setSyncEventHandler`. Without one, those
+   * events are queued for `drainEvents` like every other.
+   */
+  setSyncEventHandler(handler?: ((arg: EventPayload) => SyncDispatchResult) | undefined | null): void
+  /**
+   * How many elements the retained tree holds, reachable from the root or
+   * not. `getTreeJson` walks from the root, so it cannot see a node that was
+   * detached and never destroyed. This is the only way a test can prove a
+   * removal actually freed it.
+   */
+  getRetainedElementCount(): number
+  /**
+   * What the element build has done since the last `resetBuildCounters`. A draw builds every
+   * element, so divide by the frames drawn to get the per-frame figure.
+   */
+  getBuildCounters(): BuildCounters
+  /**
+   * What the retained subtrees of the window did since it was made: subtract two reads for a
+   * span of frames.
+   */
+  getRetainedCounters(): RetainedCounters
+  /**
+   * How the frames that were compared with a build differed from it, one entry each, see
+   * `setRetainVerify`.
+   */
+  getRetentionMismatches(): Array<string>
+  /**
+   * How many elements the retention bookkeeping holds a record of, and how many of those it
+   * takes to have motion running. Like `getRetainedElementCount` it proves a removal freed
+   * something: both stay bounded by the elements that are alive.
+   */
+  getRetainRecordCounts(): Array<number>
+  /**
+   * Why the last recorded frame built what it built, as JSON: the elements it built by reason,
+   * what named them, and the ones a record said could be skipped and were not. Needs
+   * `GPUIX_RETAIN_DEBUG=1`, and is empty without it.
+   */
+  getRetainDebug(): string
+  /**
+   * Whether a frame skips what it judges unchanged since the frame before, handing it to gpui
+   * as a retained subtree that is replayed. On unless `GPUIX_RETAIN_OFF`; turning it on after it
+   * was off starts from a frame that builds everything.
+   */
+  setRetainPlanning(planning: boolean): void
+  /**
+   * Whether a frame records what it builds at all, which `GPUIX_RETAIN_OFF` turns off for a whole
+   * run. Off, a frame costs what it did before retention; turning it on starts from a frame
+   * that builds everything.
+   */
+  setRetainEnabled(enabled: boolean): void
+  /**
+   * Builds each frame that replayed a retained subtree once more, whole, and compares the two:
+   * the scene, the hitboxes, the accessibility tree and the registries gpuix keeps (painted
+   * boxes, text and selection regions, measurements). A difference is counted in
+   * `getRetainedCounters().mismatches` and described by `getRetentionMismatches`. Every such
+   * frame costs two builds, so a benchmark leaves it off; `GPUIX_RETAIN_VERIFY` turns it on
+   * for a run.
+   */
+  setRetainVerify(verify: boolean): void
+  /**
+   * Counts as if the exclusions named here were lifted, to see which are worth lifting first:
+   * `paint-reporter`, `highlight`, `custom-element`, `svg`, `virtual-list`,
+   * `collapsed-table`, `display-contents`, `anchored`, `sticky`, `fixed`, `scroller`,
+   * `overflow-hidden`, `layout-animation`, `atomic-inline`, `label`. Nothing is reused.
+   */
+  setRetainLift(names: Array<string>): void
+  /** What the elements judged unchanged were built differently by, one line each. */
+  getRetainMismatches(): Array<string>
+  /**
+   * Layout nodes the window's engine made, found again, freed, and the styles and child lists it
+   * set, since the window was made: subtract two reads for a span of frames.
+   */
+  getLayoutCounters(): LayoutCounters
+  /**
+   * What building and drawing the elements did since the window was made: elements prepainted
+   * and painted (culled ones apart), and the scene primitives painting inserted against the
+   * ones a replay inserted again. Subtract two reads for a span of frames. Next to
+   * `getRetainedCounters`, which counts the replays themselves.
+   */
+  getFrameWorkCounters(): FrameWorkCounters
+  /**
+   * Whether the ticks of animations that only change what they paint are drawn by patching the
+   * frame before them. On unless `GPUIX_PATCH_OFF`, and never when the retention is off.
+   */
+  setPatchEnabled(enabled: boolean): void
+  /** How ticks were patched since the window was made: subtract two reads for a span of frames. */
+  getPatchCounters(): PatchCounters
+  resetBuildCounters(): void
+  /**
+   * How many frames the window has painted. A test that must prove a read did not draw once
+   * per call compares this before and after. A bounds or scroll read lays out and paints
+   * nothing: those passes are `getLayoutPassCount`.
+   */
+  getPaintedFrameCount(): number
+  /**
+   * How many layout-only passes the window has run: what a bounds or scroll read makes of a
+   * dirty window, in place of a draw. The next frame draws once more regardless.
+   */
+  getLayoutPassCount(): number
+  /**
+   * Pretends a screen reader is connected, or not. The test window starts with one, so every
+   * flush builds an accessibility tree. Without one nothing builds it, which is what a benchmark
+   * of the draw alone wants.
+   */
+  setA11yActive(active: boolean): void
+  /**
+   * How many subtrees the window has skipped as lying outside their clip, over its life: the
+   * work `getPaintedFrameCount` frames did not do. A test compares it before and after a frame.
+   */
+  getCulledSubtreeCount(): number
+  /**
+   * Apply a batch of mutations in a single FFI call.
+   * Same format as GpuixRenderer::apply_batch (string op names).
+   * Returns accumulated destroyed IDs from all destroyElement ops.
+   */
+  applyBatch(json: string): Array<number>
+  /**
+   * Notify the view entity and run GPUI until parked.
+   * This triggers GpuixView::render() → build_element() → GPUI layout.
+   * Must be called after mutations and before simulating events (GPUI's
+   * hit testing requires elements to be laid out).
+   */
+  flush(): void
+  /**
+   * Whether the test window is drawn whenever an update or a simulated input flushes, which
+   * is how a test sees the result of what it just did. A live window is drawn by the display
+   * link once per frame, however many inputs and reads came in it. A test that counts draws
+   * turns this off and ends each frame with `drawFrame`.
+   */
+  setInlineDraws(enabled: boolean): void
+  /**
+   * A display-link frame: delivers the frame callbacks the last draw queued, then draws a
+   * pending change, once. For use with `setInlineDraws(false)`.
+   */
+  drawFrame(): void
+  /**
+   * Draws only what a live window would: a pending change, nothing on a clean window.
+   * `flush()` notifies the view, so it draws every call; the `nativeSimulate*` helpers
+   * that wrap one input in a flush before and after use this instead, so an input costs
+   * the draws a window pays (one for what it changed, more only where a handler read
+   * layout in between) and not two more.
+   */
+  flushIfDirty(): void
+  /**
+   * Simulate a click at the given window coordinates.
+   * Dispatches MouseDown + MouseUp through GPUI's input pipeline,
+   * which triggers the same event handlers as production.
+   * IMPORTANT: Call flush() before this — hit testing requires laid-out elements.
+   * `modifiers` is hyphenated: "cmd", "cmd-shift", "alt".
+   */
+  simulateClick(x: number, y: number, button?: number | undefined | null, modifiers?: string | undefined | null): void
+  /**
+   * Press a space-separated sequence of keys through GPUI's input pipeline,
+   * in Playwright's `keyboard.press` grammar: a DOM `key` ("Enter", "a",
+   * "ArrowDown") or `code` ("Space", "KeyA"), modifiers joined with `+`
+   * ("Shift+Tab", "Meta+a", "ControlOrMeta+Shift+P"). Each press is a
+   * keydown then a keyup, and typed characters reach the focused input.
+   * An unknown name is an error and nothing is pressed.
+   */
+  simulateKeystrokes(keystrokes: string): void
+  /**
+   * Dispatch one keydown (one press in the `simulate_keystrokes` grammar)
+   * with no keyup after it. Pairs with `simulate_key_up`. A key that types
+   * text inserts it, like a keydown does in a browser.
+   */
+  simulateKeyDown(keystroke: string, isHeld?: boolean | undefined | null): void
+  /**
+   * A key the platform's input method consumes (one press in the
+   * `simulate_keystrokes` grammar), with no keyup after it, as macOS delivers
+   * it: the key is announced to the observers of keys that compose, then the
+   * input method calls the focused text input. `action` is `"mark"` (set the
+   * composition to `text`), `"commit"` (end it with `text`) or `"unmark"` (end
+   * it with the text it has; `text` is ignored). Pairs with `simulate_key_up`.
+   */
+  simulateImeKeyDown(keystroke: string, action: string, text?: string | undefined | null): void
+  /** Dispatch one keyup (one press in the `simulate_keystrokes` grammar). */
+  simulateKeyUp(keystroke: string): void
+  /**
+   * Simulate a mouse move to the given coordinates. It reports the buttons held by
+   * `simulate_mouse_down` that no `simulate_mouse_up` released, as a real OS does.
+   * movement_x, movement_y: the motion the platform reports for this move, which
+   * becomes `movementX`/`movementY`. Zero when not given.
+   */
+  simulateMouseMove(x: number, y: number, modifiers?: string | undefined | null, movementX?: number | undefined | null, movementY?: number | undefined | null): void
+  /**
+   * Simulate the pointer leaving the window, as the platform reports it when
+   * the cursor crosses the window edge: there is no final mouse move.
+   */
+  simulateMouseExit(x: number, y: number): void
+  /**
+   * The OS ate the release of `button` (left when not given): forget it as held without
+   * dispatching anything. The next move then reports no button, the way a pointer that
+   * let go outside the window does, and the page sees a lost release.
+   */
+  simulateLostMouseUp(button?: number | undefined | null): void
+  /**
+   * Focus an element by its numeric ID.
+   * The element must be DOM-focusable (an enabled input or textarea, or an
+   * element with a `tabIndex`), which is what gives it a FocusHandle.
+   * Call flush() before this so the element tree and focus handles exist.
+   */
+  focusElement(id: number): void
+  blurElement(id: number): void
+  matchesFocus(id: number, selector: string): boolean
+  focusNext(): void
+  focusPrevious(): void
+  promptForPaths(options?: PathPromptOptions | undefined | null): Promise<Array<string> | null>
+  /** The test window's own in-memory clipboard, never the system's. */
+  writeClipboardText(text: string): void
+  readClipboardText(): string | null
+  getFocusedElementId(): number | null
+  /** Makes the offscreen window key or not, as when the user switches apps. */
+  setWindowActive(active: boolean): void
+  focusNextWithin(elementId: number): void
+  focusPreviousWithin(elementId: number): void
+  setWindowKeyEvents(keyDown: boolean, keyUp: boolean, eventId: number): void
+  setWindowSelectionChange(enabled: boolean, eventId: number): void
+  setWindowAppearanceChange(enabled: boolean, eventId: number): void
+  setWindowMediaChange(enabled: boolean): void
+  /** The preferences this window reports, which start as "no preference". */
+  getMediaFeatures(): MediaFeatures
+  /**
+   * Change the reported OS preferences. Queues a `mediaChange` event when
+   * something changed and a listener is enabled, like the OS notification.
+   */
+  setMediaFeatures(reducedMotion?: boolean | undefined | null, increasedContrast?: boolean | undefined | null, forcedColors?: boolean | undefined | null): void
+  /**
+   * Sets the macOS "Show scroll bars" setting this window reports: `"overlay"` (Automatically
+   * or When scrolling, the default here) or `"classic"` (Always). The test window never
+   * hears from the OS, so this is how a test flips it.
+   */
+  setScrollbarStyle(style: string): void
+  /**
+   * `"system"` follows the platform's light/dark setting, `"light"` and `"dark"` force
+   * it, as on the live renderer. The override is the platform's (on macOS the process's
+   * `NSApplication.appearance`), so it outlives this renderer until a window is made
+   * with another `appearance` or `"system"` is set.
+   */
+  setAppearance(appearance: string): void
+  /** The platform window's title, as the title bar shows it. */
+  getWindowTitle(): string
+  getAppearance(): string
+  /**
+   * Simulate a mouse down event at the given window coordinates.
+   * Button: 0=left, 1=middle, 2=right. Defaults to left (0).
+   * `click_count` is what the platform reports for the press: 1 for a single
+   * click, 2 for the second press of a double click.
+   */
+  simulateMouseDown(x: number, y: number, button?: number | undefined | null, modifiers?: string | undefined | null, clickCount?: number | undefined | null): void
+  /**
+   * Simulate a mouse up event at the given window coordinates.
+   * Button: 0=left, 1=middle, 2=right. Defaults to left (0).
+   * `click_count` is the count the platform reports for the release.
+   */
+  simulateMouseUp(x: number, y: number, button?: number | undefined | null, modifiers?: string | undefined | null, clickCount?: number | undefined | null): void
+  /**
+   * Simulate a scroll wheel event at the given position.
+   * delta_x and delta_y are pixels with the DOM's sign, like `WheelEvent.deltaX`
+   * and `deltaY`: positive `delta_y` scrolls down, positive `delta_x` scrolls right.
+   *
+   * `phase` is `"started"` (the default, a gesture of its own), `"moved"`, `"ended"` or
+   * `"cancelled"`. The scroller that took a gesture's first delta keeps the rest of it, so
+   * continue one with `"moved"`.
+   */
+  simulateScrollWheel(x: number, y: number, deltaX: number, deltaY: number, modifiers?: string | undefined | null, phase?: string | undefined | null): void
+  /**
+   * Files from the OS enter the window at `x`, `y` (`FileDropEvent::Entered`).
+   * Returns the operation the window answered the drag source with, which the
+   * `dragover` it fired decided: `"none"`, `"copy"`, `"move"` or `"link"`, or
+   * `null` when the window picked none and the platform keeps its default.
+   */
+  simulateFileDragEnter(x: number, y: number, paths: Array<string>): string | null
+  /**
+   * The dragged files move to `x`, `y` (`FileDropEvent::Pending`). Returns the
+   * operation the window answered the drag source with, as `simulateFileDragEnter` does.
+   */
+  simulateFileDragMove(x: number, y: number): string | null
+  /** The dragged files are released at `x`, `y` (`FileDropEvent::Submit`). */
+  simulateFileDragSubmit(x: number, y: number): void
+  /** The dragged files leave the window (`FileDropEvent::Exited`). */
+  simulateFileDragExit(): void
+  /** The platform's drag session ends (`FileDropEvent::Ended`). */
+  simulateFileDragEnd(): void
+  /**
+   * A whole Finder-style drop at `x`, `y`, in the order the platform sends
+   * it: Entered, Submit, then Exited and Ended.
+   */
+  simulateFileDrop(x: number, y: number, paths: Array<string>): void
+  /** The current text selection joined in document order, or null. */
+  getSelectedText(): string | null
+  /** Drop the current selection. */
+  clearSelection(): void
+  /**
+   * Syntax-cache counters as `[hits, misses, documents]`.
+   *
+   * GPUIX rebuilds its whole element tree every frame, so a `<code>` block
+   * that misses the cache reparses at frame rate. A test can watch the hit
+   * count to catch that regression before a profiler does.
+   */
+  getSyntaxCacheStats(): Array<number>
+  /**
+   * Every string painted in the last frame, in paint order.
+   *
+   * `getAllText()` only sees `<text>` nodes in the retained tree. Native
+   * elements such as `<code>` and `<diff>` draw their text inside gpui, so
+   * this is the only way to assert on what they actually rendered.
+   */
+  getPaintedText(): Array<string>
+  /**
+   * Every highlight wash painted in the last frame, in paint order.
+   *
+   * A quad is invisible to `getPaintedText()`, so this is the only way to
+   * assert on `highlight` without a screenshot. Each entry carries its rects,
+   * so a soft-wrapped match is provably two boxes.
+   */
+  getPaintedHighlights(): Array<HighlightMatch>
+  /**
+   * Drag-select from one point to another: mouse down, move, up.
+   *
+   * A single helper rather than three calls because the listeners that drive
+   * selection are registered during **paint**, so a flush must sit between
+   * the down and the move. Getting that order wrong silently selects nothing,
+   * which is a miserable thing to debug from JS.
+   */
+  dragSelect(x1: number, y1: number, x2: number, y2: number): void
+  /**
+   * Scroll an element to a DOM scroll position: `left` and `top` are `scrollLeft` and
+   * `scrollTop`, zero or more, so scrolling down is a larger `top`.
+   * The offset is clamped to the layout of the tree as it is, which is laid out first if
+   * it changed. The window draws it with the next frame.
+   */
+  scrollTo(elementId: number, left: number, top: number, behavior?: string | undefined | null): void
+  /**
+   * Scroll a child into view by its index in the children list.
+   * Call flush() after to apply and re-render. For a `<virtual-list>` the
+   * scroll is queued and applied on that flush, after the child splice.
+   * `offset_in_item` is in pixels and may be negative, which anchors the
+   * viewport top above the item.
+   */
+  scrollToItem(elementId: number, index: number, offsetInItem?: number | undefined | null): void
+  /**
+   * The DOM's `scrollIntoView`: scrolls every scrollable ancestor until the element sits where
+   * `block` (default `"start"`) and `inline` (default `"nearest"`) ask.
+   */
+  scrollIntoView(elementId: number, block?: string | undefined | null, inline?: string | undefined | null, behavior?: string | undefined | null): void
+  /** The event types `window` or `document` listens for. Replaces the set. */
+  setWindowEventListeners(types: Array<string>): void
+  /**
+   * Capture the mouse for `element_id`; recorded before this returns, and the
+   * next simulated pointer input fires `gotpointercapture`. Ignored while no
+   * button is down.
+   */
+  setPointerCapture(elementId: number, pointerId: number): void
+  releasePointerCapture(elementId: number, pointerId: number): void
+  hasPointerCapture(elementId: number, pointerId: number): boolean
+  /**
+   * Ends the element drag in progress without a `dragend`; recorded now and
+   * read first by the next simulated pointer input.
+   */
+  cancelDrag(): void
+  /**
+   * Lock the pointer to `element_id`. The simulated platform answers before
+   * this returns, from a handler too, so the outcome is in `drainEvents`.
+   */
+  requestPointerLock(elementId: number): void
+  exitPointerLock(): void
+  pointerLockElement(): number | null
+  /**
+   * Whether the simulated platform grants lock requests, as one that can lock
+   * the pointer does. Off, a request fails the way GPUI's does when the
+   * platform refuses.
+   */
+  simulatePointerLockGranting(granting: boolean): void
+  /**
+   * The platform drops the lock, as it does when the window deactivates. The
+   * next frame notices, so this draws one.
+   */
+  simulatePointerLockLost(): void
+  /**
+   * The window actions a press in an `appRegion: "drag"` box asked for since the last call,
+   * oldest first: `move`, `titlebarDoubleClick`, `zoom` or `showMenu`. The offscreen window
+   * cannot start a real move, so the test renderer records them instead.
+   */
+  takeSimulatedWindowActions(): Array<string>
+  /**
+   * The click an activation that is not a pointer press makes on `element_id`,
+   * and the activation behaviour that follows it; collected for
+   * `drainEvents` like every other event.
+   */
+  clickElement(elementId: number): void
+  /** Packed `"rgba"` (default) or `"bgra"` pixels onto an `<img>` host node. */
+  setImagePixels(elementId: number, width: number, height: number, pixels: Buffer, format?: string | undefined | null): void
+  /** Encoded image bytes onto an `<img>` host node. */
+  setImage(elementId: number, bytes: Buffer): void
+  /** Encoded bytes for the `blob:` URL a `url()` background image names. */
+  setStyleImage(url: string, bytes: Buffer): void
+  /** The `blob:` URL a `url()` background names could not be read. */
+  failStyleImage(url: string, message: string): void
+  /** `select()` on an `<input>` or `<textarea>`. */
+  selectText(elementId: number): void
+  /** `setSelectionRange(start, end, direction)`; offsets are UTF-16 units. */
+  setSelectionRange(elementId: number, start: number, end: number, direction?: string | undefined | null): void
+  /** `form.requestSubmit()`: validate, then emit `submit`. */
+  requestSubmit(id: number): void
+  /** `selectionStart`, `selectionEnd` and `selectionDirection`. */
+  getTextSelection(elementId: number): TextSelection
+  /**
+   * `loadURL(url)` (with the URL as `argument`), `reload()`, `stop()`, `goBack()` and
+   * `goForward()` of a `<webview>`.
+   */
+  webviewCommand(elementId: number, command: string, argument?: string | undefined | null): void
+  /** The URL, the title and the history of a `<webview>`. */
+  webviewState(elementId: number): WebviewStateReading
+  /**
+   * Runs `code` in the page of a `<webview>`. Resolves with the JSON of the result, or null for
+   * `undefined`, once a test settles it (`settleWebviewScript`).
+   */
+  webviewExecuteJavascript(elementId: number, code: string): Promise<string | null>
+  /** What the page of a `<webview>` was asked to do, in order. */
+  getWebviewCommands(elementId: number): Array<WebviewCommandReading>
+  /** The page starts loading: `did-start-loading`. */
+  simulateWebviewStartLoading(elementId: number): void
+  /** The page stops loading: `did-stop-loading`. */
+  simulateWebviewStopLoading(elementId: number): void
+  /** The page commits `url`: `did-navigate`, and `getURL()` answers it. */
+  simulateWebviewNavigate(elementId: number, url: string): void
+  /** The page gets a title: `page-title-updated`, and `getTitle()` answers it. */
+  simulateWebviewTitle(elementId: number, title: string, explicitSet: boolean): void
+  /** A load fails: `did-fail-load`. */
+  simulateWebviewFail(elementId: number, errorCode: number, errorDescription: string, validatedUrl?: string | undefined | null): void
+  /**
+   * The page of a `<webview>` hands the keyboard on, as it does when Tab leaves its last
+   * tabbable element, or Shift+Tab (`backwards`) its first.
+   */
+  simulateWebviewTabOut(elementId: number, backwards: boolean): void
+  /** What `canGoBack()` and `canGoForward()` answer. */
+  setWebviewHistory(elementId: number, canGoBack: boolean, canGoForward: boolean): void
+  /**
+   * Settles the oldest `executeJavaScript` of a `<webview>` that waits: with the JSON of a
+   * result (none for `undefined`), or with the message of the error the script threw.
+   */
+  settleWebviewScript(elementId: number, result?: string | undefined | null, error?: string | undefined | null): void
+  /** Where the last composed frame put the surface of a `<webview>`, null while it has none. */
+  getWebviewSurface(elementId: number): WebviewSurfaceReading | null
+  /** The layers of the last composed frame, bottom to top. */
+  getCompositionLayers(): Array<CompositionLayerReading>
+  /**
+   * The container view AppKit holds for the surface of a `<webview>`, with the placement the
+   * last frame applied.
+   */
+  getWebviewNativeView(elementId: number): WebviewNativeViewReading
+  /**
+   * Where the last composed frame put the native view of a `<nativeview>`, null while it has no
+   * surface or the frame did not place it.
+   */
+  getNativeviewSurface(elementId: number): NativeviewSurfaceReading | null
+  /** The native surfaces the window made and removed, in order. */
+  getNativeSurfaceEvents(): Array<NativeSurfaceEventReading>
+  /** How many warnings a `<nativeview>` has issued. */
+  getNativeviewWarnings(elementId: number): number
+  /** Makes the window refuse native surfaces (`false`), as a platform that cannot compose does. */
+  setNativeSurfacesAvailable(available: boolean): void
+  /** Make the fonts in a TrueType or OpenType file usable by `fontFamily`. */
+  registerFont(data: Buffer): void
+  /**
+   * The logical scroll anchor of a `<virtual-list>`:
+   * `[itemIndex, offsetInItemPx, viewportHeightPx]`, or null for anything
+   * else. `itemIndex == item count` is gpui's at-end sentinel.
+   */
+  getListScrollTop(elementId: number): Array<number> | null
+  /** `"hidden"` | `"minimal"` | `"full"`. */
+  setDebugFrameOverlay(mode: string): string
+  /** Hidden → minimal → full → hidden. */
+  cycleDebugFrameOverlay(): string
+  getDebugFrameOverlay(): string
+  /** Clears the last 1000 draw samples. Frame count stays. */
+  resetDebugFrameOverlayStats(): void
+  /** Same numbers as the on-screen overlay: current, p90, p99, max, frames. */
+  getDebugFrameOverlayStats(): DebugFrameOverlayStats
+  /** The default action of a scrolling key. See `GpuixRenderer::scroll_by_key`. */
+  scrollByKey(key: string, shift: boolean): void
+  /**
+   * The DOM scroll geometry of an element:
+   * `[scrollLeft, scrollTop, scrollWidth, scrollHeight, clientWidth, clientHeight]`, or null
+   * if it has not been painted.
+   */
+  getScrollMetrics(elementId: number): Array<number> | null
+  /**
+   * The DOM scroll position of a scrollable element, `[scrollLeft, scrollTop]` (zero or
+   * more), or null if it is not a scroll container or a `<virtual-list>`.
+   */
+  getScrollOffset(elementId: number): Array<number> | null
+  /**
+   * The CSS keyword of the cursor the window asks the platform for at the pointer's last
+   * hit test (`default` when nothing asks). It is read from the window, not from the OS: the
+   * offscreen window is not active, so the platform is never told. A move (or a draw) is
+   * what updates it.
+   */
+  getCursor(): string
+  /**
+   * Capture a screenshot of the current rendered state and save as PNG.
+   * Supported on macOS through Metal and Windows through DirectX.
+   */
+  captureScreenshot(path: string): void
+  /**
+   * Return and clear all collected events since the last drain.
+   * Events are collected synchronously — no event loop queuing.
+   */
+  drainEvents(): Array<EventPayload>
+  /** Get all text content in the tree (depth-first order). */
+  getAllText(): Array<string>
+  /** Find element IDs matching the given type (e.g. "div", "text"). */
+  findByType(elementType: string): Array<number>
+  /** Check if an element has a specific event listener. */
+  hasEventListener(id: number, eventType: string): boolean
+  /** Get the text content of an element. */
+  getText(id: number): string | null
+  /** Get the full tree as JSON for snapshot testing. */
+  getTreeJson(): string
+  /**
+   * GPUI accessibility dump from the last painted frame.
+   * Empty until a11y is active; the test renderer turns that on at construct.
+   */
+  getA11yTree(): string
+  /** Tree JSON with last-paint bounds. Used by the automation locators. */
+  getAutomationTree(): string
+  /** Last painted bounds for an element, or null if it was not painted. */
+  getElementBounds(id: number): ElementBounds | null
+  /**
+   * The box of an element for the first report of an observer: laid out as `getElementBounds`
+   * does, but the content of a skipped ancestor is not, and an element inside it has no box
+   * (null), as Chrome's observers see it.
+   */
+  probeElementBounds(id: number): ElementBounds | null
+  /**
+   * The box the last layout gave an element, or null if it was not built. Unlike
+   * `getElementBounds`, it does not lay out the content of the skipped ancestors of the element
+   * to answer, so it tells whether the content of a `content-visibility` element is built.
+   */
+  getBuiltElementBounds(id: number): ElementBounds | null
+  /** Ids under the window point, topmost first. See the live renderer. */
+  getElementsAt(x: number, y: number): Array<number>
+  clockPause(): number
+  clockSet(nowMs: number): number
+  clockFastForward(deltaMs: number): number
+  /**
+   * Moves a paused clock as time passing does: the window is not told, as a live window is not
+   * when its clock runs. `clockFastForward` notifies the view, so the frame after it is built
+   * whole; the frame after this one is a tick, which can be drawn by patching the frame before.
+   */
+  clockAdvance(deltaMs: number): number
+  clockResume(): number
+  /** A value that is written with `set` and `jump` or animated. */
+  createMotionValue(id: number, initial: any): void
+  /**
+   * A value mapped from the number value `input` through `inputRange` and
+   * `outputRange`. `options` is `{ clamp?: boolean, ease?: ease | ease[] }`.
+   */
+  createMotionTransform(id: number, input: number, inputRange: Array<number>, outputRange: any, options?: any | undefined | null): void
+  /**
+   * A spring that chases another value. `config` is a spring transition
+   * without the `type`.
+   */
+  createMotionFollower(id: number, source: number, config: any): void
+  /** A spring with a target of its own, which `setMotionValue` moves. */
+  createMotionSpring(id: number, initial: any, config: any): void
+  /** Whether the value existed. Values that read it fail from then on. */
+  disposeMotionValue(id: number): boolean
+  getMotionValue(id: number): any
+  /** Units per second. Errors for a value that is not a number. */
+  getMotionValueVelocity(id: number): number
+  isMotionValueAnimating(id: number): boolean
+  /**
+   * Writes the value. Over a running animation this does not stop it:
+   * call `stopMotionValue` first to take the value from the animation.
+   */
+  setMotionValue(id: number, value: any): void
+  /** Writes the value, ending any animation and dropping its velocity. */
+  jumpMotionValue(id: number, value: any): void
+  /**
+   * Animates a value from where it is, with the speed it has. `transition`
+   * is the same description `motion` takes, tween by default.
+   */
+  animateMotionValue(id: number, target: any, transition?: any | undefined | null): void
+  /** Ends an animation where it is, keeping the speed for the next one. */
+  stopMotionValue(id: number): void
+  /**
+   * Holds the value's animation where it is. The value stays, its velocity
+   * reads 0 and no frame is asked for; `isMotionValueAnimating` stays true.
+   */
+  pauseMotionValue(id: number): void
+  /**
+   * Continues a held animation from the time it holds. A finished one plays
+   * again from its start, or from its end when its speed is negative.
+   */
+  playMotionValue(id: number): void
+  /**
+   * Sets the time of the value's animation, Motion's `time`: it counts the
+   * delay, so a time inside the delay shows the first keyframe. A finished
+   * animation is held there; one seeked past its end finishes, and its time
+   * reads back as set.
+   */
+  seekMotionValue(id: number, seconds: number): void
+  /**
+   * Sets the pace of the value's animation: 2 is twice as fast, a negative
+   * speed runs it backwards to its first keyframe, 0 holds it while it stays
+   * in effect. As in Motion, a hold lasts until `play`, whatever the speed
+   * is set to after.
+   */
+  setMotionValueSpeed(id: number, speed: number): void
+  /**
+   * Jumps the value's animation to its last keyframe (the first when it runs
+   * backwards) and finishes it.
+   */
+  completeMotionValue(id: number): void
+  /**
+   * What the controls of the value's animation read, or null if it has none:
+   * it was never animated, or was stopped or jumped.
+   */
+  getMotionValuePlayback(id: number): MotionValuePlayback | null
+  /**
+   * Takes the frames away from the clock of the value's animation. See
+   * `GpuixRenderer.detachMotionValueClock`.
+   */
+  detachMotionValueClock(id: number): void
+  /** Chooses which events the value delivers. Neither removes the listener. */
+  setMotionValueListener(id: number, change: boolean, animation: boolean): void
+  /**
+   * Defines the keyframes `animation-name: name` plays. See
+   * `GpuixRenderer.defineKeyframes`.
+   */
+  defineKeyframes(name: string, framesJson: string): void
+  /**
+   * The CSS transitions, then the CSS animations, of an element that are
+   * running, paused or in effect through a fill. See `GpuixRenderer.getAnimations`.
+   */
+  getAnimations(elementId: number): Array<WebAnimationInfo>
+  /** `getAnimations({ subtree: true })` of an element. See `GpuixRenderer.getSubtreeAnimations`. */
+  getSubtreeAnimations(elementId: number): Array<ElementWebAnimationInfo>
+  /** `document.getAnimations()` of this renderer. See `GpuixRenderer.getDocumentAnimations`. */
+  getDocumentAnimations(): Array<ElementWebAnimationInfo>
+  /**
+   * The SVG an `<svg>` element with shape children painted in the last
+   * frame, as the XML its shapes were written to, or `null` when it painted
+   * none. Animated attributes are in it as the frame had them.
+   */
+  getSvgMarkup(elementId: number): string | null
+  /**
+   * One CSS animation or transition by the id `getAnimations` gave. See
+   * `GpuixRenderer.getAnimation`.
+   */
+  getAnimation(animationId: number): WebAnimationInfo
+  /** See the renderer's `getAnimationEffect`. */
+  getAnimationEffect(animationId: number): WebAnimationEffectInfo
+  /** See the renderer's `getAnimationKeyframes`. */
+  getAnimationKeyframes(animationId: number): Array<WebAnimationKeyframeInfo>
+  /** See the renderer's `updateAnimationTiming`. */
+  updateAnimationTiming(animationId: number, timing: WebAnimationTimingUpdate): void
+  /** See the renderer's `releaseAnimation`. */
+  releaseAnimation(animationId: number): void
+  /** See the renderer's `forgetAnimation`. */
+  forgetAnimation(animationId: number): void
+  /**
+   * `animation.pause()`: holds the current time at once, and from here the
+   * style's `animation-play-state` no longer decides.
+   */
+  pauseAnimation(animationId: number): void
+  /**
+   * `animation.play()`: continues from the held time at the next frame, or
+   * from the start (the end when running backwards) if it has finished.
+   */
+  playAnimation(animationId: number): void
+  /** `animation.currentTime = milliseconds`. */
+  setAnimationCurrentTime(animationId: number, milliseconds: number): void
+  /** `animation.playbackRate = rate`, keeping the current time. */
+  setAnimationPlaybackRate(animationId: number, rate: number): void
+  /**
+   * `animation.cancel()`: the animation is idle, with no current time and out of
+   * `getAnimations()`; `play()` brings it back from the start.
+   */
+  cancelAnimation(animationId: number): void
+  /**
+   * `animation.finish()`. Throws `InvalidStateError: ...` for a rate of 0 and for an animation
+   * that never ends.
+   */
+  finishAnimation(animationId: number): void
+  /**
+   * `animation.reverse()`: the rate flips at the next frame. Throws `InvalidStateError: ...`
+   * for an animation that never ends, from its start.
+   */
+  reverseAnimation(animationId: number): void
+  /**
+   * `animation.updatePlaybackRate(rate)`: at the next frame for a running animation, at once
+   * for the others.
+   */
+  updateAnimationPlaybackRate(animationId: number, rate: number): void
+  /**
+   * `animation.startTime = startTime`, in milliseconds on the timeline of the animations
+   * (`getAnimationTimelineTime`); `null` holds the current time.
+   */
+  setAnimationStartTime(animationId: number, startTime?: number | undefined | null): void
+  /**
+   * The time of the timeline of the animations (`animation.timeline.currentTime`): the
+   * instant of the last frame, in milliseconds on the clock of the renderer. The same
+   * number `startTime` and the `timelineTime` of the events are on.
+   */
+  getAnimationTimelineTime(): number
+  /** Advance GPUI's deterministic test executor and run due timers. */
+  advanceTime(milliseconds: number): void
+  /** Get the root element ID, or null if no root is set. */
+  getRootId(): number | null
+  /**
+   * The offscreen window size, so `useWindowSize()` reports the same numbers
+   * under test as in a real window instead of falling back to a default.
+   */
+  getWindowSize(): WindowSize
+  /**
+   * Resize the offscreen window's content to `width` x `height`, as a user dragging its
+   * edge would: the size queries of `matchMedia` and `useWindowSize` see it, and a
+   * listening window queues a `mediaChange` event.
+   */
+  setWindowSize(width: number, height: number): void
+  /**
+   * Gives the window the scale factor of a display of another density, `2` for a retina one:
+   * the next frame lays out and paints at it, and a screenshot is the window's size times it.
+   * The factor stays until it is set again: resizing the window does not reset it.
+   */
+  setWindowScaleFactor(scaleFactor: number): void
+}
+
+/** Counts of the work the element build did, see `get_build_counters`. */
+export interface BuildCounters {
+  /** Elements `build_element` ran for. Text and inline boxes a paragraph builds itself are not counted. */
+  elementsBuilt: number
+  /**
+   * Elements a frame did not build because nothing they were built from had changed: they
+   * were replayed, or built later by gpui for a frame that could not replay them (those are
+   * counted in `elementsBuilt` as well).
+   */
+  elementsSkipped: number
+  /** `StyleDesc` values cloned, a state style inside a style counted as its own. */
+  styleDescClones: number
+  inheritedClones: number
+  /** The maximal unchanged subtrees a retained replay could have reused, see `retain`. */
+  retainableRoots: number
+  /** Elements in them, of `elementsBuilt`. */
+  retainableElements: number
+  /** Elements in those roots that hold at least eight. */
+  retainableElementsLarge: number
+  /** Elements judged unchanged that were built differently. Always 0 unless `setRetainVerify`. */
+  retainMismatches: number
+  /** Subtrees built whole as units: running paint-only animations a tick can build again alone. */
+  unitsBuilt: number
+  /** Subtrees that were that but hold more elements than a unit may. */
+  unitsOversized: number
+  /**
+   * Motions a sync read the element of: every motion of the page in a frame built whole, the ones
+   * that move in a tick that is patched.
+   */
+  motionsSynced: number
+  /**
+   * Motion values sampled for the elements that bind them: every value bound in a frame built
+   * whole, the ones that move or were written in a tick that is patched.
+   */
+  motionValuesSampled: number
+  /**
+   * A JSON object: elements by the reason they are, or are not, in a retainable subtree, for
+   * the builds since the reset. `retained` is the share that is; every built element is counted
+   * once.
+   */
+  retainReasons: string
+}
+
+/**
+ * Ask the update feed whether a newer signed bundle exists.
+ *
+ * Returns `null` when the feed is 204 or the announced version is not newer.
+ * `downloadAndInstall()` replaces the packaged app. It does not relaunch.
+ */
+export declare function checkUpdate(currentVersion: string, options: CheckUpdateOptions): Promise<AvailableUpdate | null>
+
+/** Options for [`check_update`]. */
+export interface CheckUpdateOptions {
+  /** Feed URLs. Slots `{{target}}`, `{{arch}}`, `{{current_version}}` are filled. */
+  endpoints: Array<string>
+  /** Public key from `cargo packager signer generate`. */
+  pubkey: string
+  /** Extra HTTP headers for the feed request. */
+  headers?: Array<UpdaterHeader>
+  /** Request timeout in milliseconds. */
+  timeoutMs?: number
+  /** Windows NSIS / WiX extra args. */
+  installerArgs?: Array<string>
+  /** Windows install UI: `passive` (default), `quiet`, or `basicUi`. */
+  installMode?: string
+}
+
+/** One layer of the last composed frame. */
+export interface CompositionLayerReading {
+  /** `"gpui"` or `"native"`. */
+  kind: string
+  /** The window's own GPUI layer, the one below every surface. */
+  isBase: boolean
+  /** For a GPUI layer: the primitives and groups of the scene it draws. */
+  primitives: number
+  /** For a native layer: the element of its webview. */
+  webview?: number
+  /** For a native layer: the element of its nativeview. */
+  nativeview?: number
+  /** For a native layer: whether it shows. */
+  visible: boolean
+}
+
+/** Recorded draw times from the debug frame overlay. */
+export interface DebugFrameOverlayStats {
+  currentMs?: number
+  p90Ms?: number
+  p99Ms?: number
+  maxMs?: number
+  frames: number
+  samples: number
+}
+
+/**
+ * A display, as Electron's `Display`. Coordinates are CSS px in one global space: the origin is
+ * the top-left of the primary display, y points down, and a display left of or above it has
+ * negative coordinates.
+ */
+export interface Display {
+  id: number
+  /** The name the OS gives the display, such as "Built-in Retina Display". */
+  label: string
+  bounds: Rectangle
+  /** `bounds` without the menu bar and the Dock. */
+  workArea: Rectangle
+  /** Device pixels per CSS px. */
+  scaleFactor: number
+  /** Degrees clockwise: 0, 90, 180 or 270. */
+  rotation: number
+  /** True for the display built into the machine. */
+  internal: boolean
+  /** The size of `bounds`. */
+  size: Size
+  /** The size of `workArea`. */
+  workAreaSize: Size
+}
+
+/**
+ * One file of an OS file drag, as the DOM `File` plus the path the browser
+ * would hide.
+ */
+export interface DroppedFile {
+  path: string
+  name: string
+  size: number
+  /** MIME type guessed from the extension, empty when unknown. */
+  type: string
+  /** Milliseconds since the Unix epoch. */
+  lastModified: number
+}
+
+export interface EdgeInsets {
+  top: number
+  right: number
+  bottom: number
+  left: number
+}
+
+/**
+ * Last box of a host element, as layout computed it: fractional, in 1/64 of a pixel, as
+ * `getBoundingClientRect` reports it, and not the box snapped to device pixels that is painted.
+ * The box of a transformed element, or one inside a transformed element, is the smallest box that
+ * holds its corners after the transforms.
+ */
+export interface ElementBounds {
+  x: number
+  y: number
+  width: number
+  height: number
+  /**
+   * The DOM's `clientLeft` and `clientTop`: the left and top border widths, rounded to whole
+   * pixels as the DOM does.
+   */
+  clientLeft: number
+  clientTop: number
+}
+
+/** A [`WebAnimationInfo`] with the element the run is of, for a read that spans elements. */
+export interface ElementWebAnimationInfo {
+  elementId: number
+  info: WebAnimationInfo
+}
+
+export interface EventModifiers {
+  shift: boolean
+  ctrl: boolean
+  alt: boolean
+  cmd: boolean
+}
+
+/** Event payload sent back to JS when a user interacts with an element. */
+export interface EventPayload {
+  /**
+   * Numeric element ID (matches the ID assigned in JS via createElement).
+   * This payload is what native sends: `target`, `path` and `related_target`
+   * are ids. JS turns them into elements before a handler sees the event, and
+   * `elementId` stays the id on the event a handler gets.
+   */
+  elementId: number
+  /**
+   * Event type string — matches the key used in EVENT_PROPS on the JS side.
+   * e.g. "click", "mousedown", "mouseenter", "keydown", "wheel", etc. Pointer,
+   * mouse and drag types are the lowercase DOM names.
+   */
+  eventType: string
+  /** Mouse X position in window coordinates (pixels). */
+  x?: number
+  /** Mouse Y position in window coordinates (pixels). */
+  y?: number
+  /**
+   * Which mouse button: 0=left, 1=middle, 2=right.
+   * Populated for: mousedown, mouseup, click, auxclick, contextmenu, mousedownoutside.
+   */
+  button?: number
+  /**
+   * Number of consecutive clicks (1=single, 2=double, 3=triple).
+   * Populated for: the click-family and down/up events; `detail` carries the same count.
+   */
+  clickCount?: number
+  /**
+   * Whether this is a right-click (convenience for click events).
+   * true when button==2 or ClickEvent::is_right_click().
+   */
+  isRightClick?: boolean
+  /**
+   * Which mouse button is currently held during a mouseMove.
+   * Same encoding as `button`: 0=left, 1=middle, 2=right.
+   * Populated for: mousemove.
+   */
+  pressedButton?: number
+  /**
+   * DOM `KeyboardEvent.key`: "a", "A", "Enter", "Escape", "ArrowDown", " ",
+   * "F1", "Shift". On macOS the character the keyboard layout types, with
+   * shift and option applied. See `events/key_names.rs`.
+   * Populated for: keydown, keyup.
+   */
+  key?: string
+  /**
+   * DOM `KeyboardEvent.code`, the physical key: "KeyA", "Digit1", "Enter",
+   * "ArrowLeft". From the key code where the platform reports one (macOS),
+   * otherwise derived from the key assuming a US QWERTY layout, and empty
+   * when it cannot be derived.
+   * Populated for: keydown, keyup.
+   */
+  code?: string
+  /**
+   * Legacy `KeyboardEvent.keyCode`, a Windows virtual-key code with the
+   * numbers Chrome on macOS reports: 65-90 for letters, 48-57 for the digit
+   * row, 13 for Enter, 37-40 for the arrows, 229 for a key the input method
+   * took ("Process"), and 0 for a key Chrome gives no code. See
+   * `events/key_codes.rs`.
+   * Populated for: keydown, keyup.
+   */
+  keyCode?: number
+  /**
+   * Legacy `KeyboardEvent.which`, equal to `key_code`.
+   * Populated for: keydown, keyup.
+   */
+  which?: number
+  /**
+   * The character produced by the key press (e.g. "ß" for option-s).
+   * May differ from `key` when modifiers are active.
+   * Populated for: keydown, keyup.
+   */
+  keyChar?: string
+  /**
+   * Whether this is a key-repeat event (key held down). Same as `repeat`.
+   * Populated for: keydown.
+   */
+  isHeld?: boolean
+  /**
+   * DOM `KeyboardEvent.repeat`.
+   * Populated for: keydown, keyup.
+   */
+  repeat?: boolean
+  /**
+   * DOM `KeyboardEvent.isComposing`: an input method composition is in
+   * progress. Only macOS reports it; elsewhere it is always false.
+   * Populated for: keydown, keyup, change.
+   */
+  isComposing?: boolean
+  /**
+   * DOM `CompositionEvent.data`: the text the composition replaces on
+   * compositionstart (the selection), the composition's current text on
+   * compositionupdate and the text it ended with on compositionend.
+   * Populated for: compositionstart, compositionupdate, compositionend.
+   */
+  data?: string
+  /**
+   * DOM `InputEvent.inputType` of an edit of the text (`insertText`,
+   * `deleteContentBackward`, `historyUndo`, ...), `""` for the number
+   * stepper. `data` is the inserted text for the insert types and absent
+   * otherwise; `isComposing` says the edit belongs to a composition.
+   * Populated for: change.
+   */
+  inputType?: string
+  /**
+   * DOM `shiftKey`, `ctrlKey`, `altKey`, `metaKey`: the booleans of
+   * `modifiers`, under the DOM names.
+   * Populated for: keydown, keyup.
+   */
+  shiftKey?: boolean
+  ctrlKey?: boolean
+  altKey?: boolean
+  metaKey?: boolean
+  /**
+   * Wheel delta on the X axis in pixels, positive towards the end, like the DOM.
+   * Populated for: wheel.
+   */
+  deltaX?: number
+  /**
+   * Wheel delta on the Y axis in pixels, positive towards the end, like the DOM.
+   * Populated for: wheel.
+   */
+  deltaY?: number
+  /**
+   * DOM `WheelEvent.deltaMode`. Always 0 (pixels): a mouse wheel's lines are
+   * converted natively.
+   * Populated for: wheel.
+   */
+  deltaMode?: number
+  /**
+   * true = pixel-precise (trackpad), false = line-based (mouse wheel).
+   * Populated for: wheel.
+   */
+  precise?: boolean
+  /**
+   * Touch phase for scroll: "started", "moved", "ended".
+   * Populated for: wheel (trackpad gestures).
+   */
+  touchPhase?: string
+  /**
+   * true = mouse entered element, false = mouse left element.
+   * Populated for: mouseenter, mouseleave.
+   */
+  hovered?: boolean
+  /**
+   * Element-defined string payload.
+   * Populated for: `<diff>` toggleFile (the file path), showMore (the
+   * hidden line count), and lineClick (the line text); `<markdown>`
+   * linkClick (the URL); `selectionChange` (joined selected text, or
+   * absent when the selection is empty).
+   */
+  value?: string
+  /** Line number on the pre-change side. Populated for: `<diff>` lineClick. */
+  oldLine?: number
+  /** Line number on the post-change side. Populated for: `<diff>` lineClick. */
+  newLine?: number
+  /** First visible logical index. Populated for: `<virtual-list>` visibleRange. */
+  startIndex?: number
+  /** Exclusive end of the visible logical range. Populated for: visibleRange. */
+  endIndex?: number
+  /**
+   * Intrinsic size of the decoded image, in pixels.
+   * Populated for: `<img>` load.
+   */
+  naturalWidth?: number
+  naturalHeight?: number
+  /**
+   * Border-box size of the element, in pixels. With `x` and `y`, its position
+   * in window coordinates. Populated for: layout.
+   */
+  width?: number
+  height?: number
+  /**
+   * Scroll offset of the element, the pair `getScrollOffset` returns: 0 at the
+   * start and negative as the content moves. Populated for: scroll.
+   */
+  scrollX?: number
+  scrollY?: number
+  /**
+   * Where an `<anchored>` layer settled: `"top"`, `"right"`, `"bottom"` or `"left"`, and
+   * the requested alignment. With the room left for the layer in whole pixels.
+   * Populated for: placement.
+   */
+  side?: string
+  align?: string
+  availableWidth?: number
+  availableHeight?: number
+  /**
+   * Border-box size of the trigger an `<anchored>` layer is placed against.
+   * Populated for: placement.
+   */
+  anchorWidth?: number
+  anchorHeight?: number
+  /**
+   * Matches found by this element's `highlight` prop. Counted once per match
+   * even when it is split across several painted runs, and it counts every
+   * retained match, not only the ones currently on screen.
+   * Populated for: highlight.
+   */
+  matchCount?: number
+  /**
+   * Logical native motion target that reached completion.
+   * Populated for: motionComplete.
+   */
+  motionGeneration?: number
+  /**
+   * The files of an OS file drag (`dataTransfer.files`). Sent once per drag,
+   * with its first event, a `dragenter`.
+   */
+  files?: Array<DroppedFile>
+  /**
+   * `[name, value]` of every named, enabled control in the form, in document
+   * order. Populated for: `<form>` submit.
+   */
+  formEntries?: Array<Array<string>>
+  /**
+   * Id of the element the event was aimed at (JS makes it `event.target`, the
+   * element itself). Absent means `element_id` is the target. Ids are `f64`
+   * like `element_id`: `u64` would reach JS as a `bigint` and never match the
+   * `number` keys of the handler map.
+   */
+  target?: number
+  /**
+   * Propagation path, target first and then each ancestor up to the root.
+   * JS runs capture over it root to target and bubble target to root, and
+   * gives handlers the elements as `composedPath()`. Absent means the event is
+   * handled at `element_id` only.
+   */
+  path?: Array<number>
+  /**
+   * Id of the other element of a boundary or focus event (JS makes it
+   * `event.relatedTarget`, the element itself, or `null` when absent).
+   * Populated for: mouseover, mouseout, mouseenter, mouseleave and the pointer equivalents,
+   * the drag enter and leave events, and the focus events: the element gaining focus on
+   * blur and focusout, the one losing it on focus and focusin. Absent when focus came
+   * from or went to nothing.
+   */
+  relatedTarget?: number
+  /**
+   * Pointer position in window coordinates, the DOM `clientX`/`clientY`.
+   * Same values as `x`/`y`, which stay for existing handlers.
+   */
+  clientX?: number
+  clientY?: number
+  /**
+   * Pointer position relative to the target's padding edge (its border box
+   * minus its border widths), the DOM `offsetX`/`offsetY`.
+   */
+  offsetX?: number
+  offsetY?: number
+  /**
+   * Pointer motion since the previous move, in logical pixels, the DOM
+   * `movementX`/`movementY`. Set on every pointer, mouse, wheel and drag
+   * event: the motion on pointermove and mousemove, 0 on the rest. Zero on a
+   * move too where the platform reports no relative motion.
+   */
+  movementX?: number
+  movementY?: number
+  /**
+   * Buttons held while the event fires, as the DOM bitmask: 1 primary,
+   * 2 secondary, 4 auxiliary, 8 back, 16 forward.
+   */
+  buttons?: number
+  /**
+   * The DOM `detail`: the consecutive click count on click-family and
+   * down/up events.
+   */
+  detail?: number
+  /** The DOM `pointerId`. 1 for the mouse, -1 for a click no pointer made. */
+  pointerId?: number
+  /** The DOM `pointerType`. "mouse" for the mouse, empty for a click no pointer made. */
+  pointerType?: string
+  /**
+   * Whether the element matches `:focus-visible`: the new focus for `focus`
+   * and `focusin`, the focus being left for `blur` and `focusout`.
+   * Populated for: focus, blur, focusin, focusout.
+   */
+  focusVisible?: boolean
+  /**
+   * Whether the element skips its content (`content-visibility: auto`).
+   * Populated for: contentvisibilityautostatechange.
+   */
+  skipped?: boolean
+  /**
+   * Content box, visible rect and viewport for an observer.
+   * Populated for: resizeObserve, intersectObserve. With `x`, `y`, `width`
+   * and `height` as the border box.
+   */
+  observation?: Observation
+  /**
+   * CSS name of the property a transition animates, `background-color`.
+   * Populated for: transitionrun, transitionstart, transitionend,
+   * transitioncancel.
+   */
+  propertyName?: string
+  /**
+   * The `animation-name` of the animation, as the DOM `animationName`.
+   * Populated for: animationstart, animationiteration, animationend,
+   * animationcancel.
+   */
+  animationName?: string
+  /**
+   * The id of the CSS animation or transition (`getAnimation`) the event is
+   * about. Populated for: webanimationfinish, webanimationcancel, which are
+   * internal events for the `Animation` objects of `getAnimations()`: they
+   * carry no path, so they reach no handler of the app.
+   */
+  animationId?: number
+  /**
+   * Milliseconds, the `currentTime` of the `AnimationPlaybackEvent`. Populated for:
+   * webanimationfinish.
+   */
+  currentTime?: number
+  /**
+   * Milliseconds on the renderer's clock, the `timelineTime` of the
+   * `AnimationPlaybackEvent`: the timeline time the event was made at. Populated for:
+   * webanimationfinish, webanimationcancel.
+   */
+  timelineTime?: number
+  /**
+   * Seconds of the transition's or animation's active time, as the DOM
+   * `elapsedTime`. Populated for: the transition and animation events.
+   */
+  elapsedTime?: number
+  /**
+   * Always `""`: gpuix has no pseudo-elements. Populated for: the transition
+   * and animation events.
+   */
+  pseudoElement?: string
+  /** The URL a `<webview>` committed. Populated for: did-navigate. */
+  url?: string
+  /** The title of the page of a `<webview>`. Populated for: page-title-updated. */
+  title?: string
+  /**
+   * Whether the page set its title (`document.title`) and not the browser from the URL.
+   * Populated for: page-title-updated.
+   */
+  explicitSet?: boolean
+  /**
+   * The `NSURLError` code of a failed `<webview>` load (`-1009` for no network), not a
+   * Chromium net error. Populated for: did-fail-load.
+   */
+  errorCode?: number
+  /** The localized description of the failure. Populated for: did-fail-load. */
+  errorDescription?: string
+  /** The URL that failed to load. Populated for: did-fail-load. */
+  validatedUrl?: string
+  /**
+   * The address of the content `NSView` of a `<nativeview>` as a decimal string: a pointer
+   * does not survive a round trip through an `f64` on every platform, and JS makes a `bigint`
+   * of it. Populated for: attach, detach.
+   */
+  nativeHandle?: string
+  modifiers?: EventModifiers
+}
+
+/**
+ * What building and drawing the elements did in the window since it was made, see
+ * `get_frame_work_counters`.
+ */
+export interface FrameWorkCounters {
+  /**
+   * Elements whose own prepaint ran, outside a subtree the clip hides. A retained subtree that
+   * is replayed prepaints none of its elements, and its root wrapper is not counted.
+   */
+  prepainted: number
+  /** Elements prepainted inside a subtree the clip hides (culled). */
+  culledPrepainted: number
+  /** Elements whose own paint ran. */
+  painted: number
+  /** Elements painted inside a culled subtree. */
+  culledPainted: number
+  /** Primitives painting put into the scene, after what is hidden or clipped away is left out. */
+  paintedPrimitives: number
+  /** Primitives a replay put into the scene again, which are not painted ones. */
+  replayedPrimitives: number
+  /**
+   * Draw orders worked out with a scene's bounds tree. A scene a patch makes again from the
+   * orders it had pays none, so the cost of a patched tick is not that of the page.
+   */
+  boundsInserts: number
+  /**
+   * Glyphs rasterized because the atlas did not have them. A glyph of a patched root that the
+   * clip hides is not rasterized until it shows.
+   */
+  rasterizedGlyphs: number
+  /**
+   * Frame callbacks that carried the animations of culled content on without drawing
+   * (`GpuixView::dormant_tick`).
+   */
+  dormantTicks: number
+}
+
+/** Every display, in the order the OS lists them. */
+export declare function getAllDisplays(): Array<Display>
+
+/** The display with the menu bar. Its `bounds` start at 0, 0. */
+export declare function getPrimaryDisplay(): Display
+
+/** True only when this binary compiled the real GPU test renderer. */
+export declare function hasTestGpuixRenderer(): boolean
+
+/**
+ * One highlight wash painted in the last frame, with the boxes it drew.
+ *
+ * The rects matter: a quad never lands in `getPaintedText()`, and a match that
+ * soft-wraps must produce one box per visual row. Without the geometry the only
+ * way to assert either is a screenshot.
+ */
+export interface HighlightMatch {
+  /** Numeric id of the element that painted the run. */
+  elementId: number
+  /** Index of the run within that element. 0 for a plain `<text>`. */
+  sub: number
+  /** The full string of the run, so `text.slice(start, end)` is the match. */
+  text: string
+  /** UTF-16 code-unit offsets into `text`, the units JS strings use. */
+  start: number
+  end: number
+  active: boolean
+  rects: Array<HighlightRect>
+}
+
+export interface HighlightRect {
+  x: number
+  y: number
+  width: number
+  height: number
+}
+
+/**
+ * Wayland `wlr-layer-shell` surface options. Linux/Wayland only; ignored on
+ * every other platform. When present on `WindowOptions`, the window is opened
+ * as a compositor-anchored surface (a bar, dock, notification overlay or
+ * wallpaper) with no native titlebar instead of a normal floating window.
+ * `width` / `height` then only constrain the axis the surface is not
+ * stretched along by its `anchor`.
+ */
+export interface LayerShellOptions {
+  /**
+   * Compositor surface namespace, used for window rules. Cannot be changed
+   * after the surface is created. Defaults to the empty string.
+   */
+  namespace?: string
+  /** `"background"` | `"bottom"` | `"top"` | `"overlay"`. Defaults to `"top"`. */
+  layer?: string
+  /**
+   * Screen edges to anchor to: any combination of `"top"`, `"bottom"`,
+   * `"left"`, `"right"`. Anchoring two opposite edges stretches the surface
+   * across that axis. Defaults to `["top", "left", "right"]` (a top bar).
+   */
+  anchor?: Array<string>
+  /**
+   * Logical pixels to reserve along the anchored edge so other windows do
+   * not overlap the surface. `0` lets the compositor decide, a negative
+   * value asks it not to reserve any space.
+   */
+  exclusiveZone?: number
+  /**
+   * Which edge the exclusive zone applies to when it cannot be inferred from
+   * a single-edge `anchor`. Same values as one `anchor` entry.
+   */
+  exclusiveEdge?: string
+  /**
+   * Gap between the surface and its anchor edge(s), in CSS order:
+   * `[top, right, bottom, left]`. Must have exactly four entries or it is
+   * ignored.
+   */
+  margin?: Array<number>
+  /**
+   * `"none"` | `"on-demand"` | `"exclusive"`. Defaults to `"none"`: a bar or
+   * overlay that never takes keyboard focus.
+   */
+  keyboardInteractivity?: string
+}
+
+/** What the layout engine of the window has done since the window was made, see `get_layout_counters`. */
+export interface LayoutCounters {
+  nodesCreated: number
+  nodesReused: number
+  nodesRemoved: number
+  stylesSet: number
+  childrenSet: number
+  passes: number
+  /** Calls to the measure functions of text and other measured leaves. */
+  measures: number
+  /**
+   * Nodes whose layout algorithm ran to place them: taffy's cache misses. A change to one leaf
+   * costs its chain of ancestors (and what their new sizes reach), not the size of the tree.
+   */
+  nodesLaidOut: number
+  /**
+   * Nodes whose layout algorithm ran only to size them, which a parent does to learn what a
+   * child contributes before it places it. Not counted in `nodesLaidOut`.
+   */
+  nodesSized: number
+  /**
+   * Elements the accessibility links read to resolve labels and `aria-*` id references, since the
+   * tree was made. A tree with none of either reads none.
+   */
+  relationVisits: number
+  /** Lines the platform shaped, since the window was made: the line layout cache missed. */
+  shapes: number
+  /**
+   * Wrapped line layouts computed (shaped and wrapped) because neither the frame nor the one
+   * before had them.
+   */
+  wrappedLayouts: number
+  /** Line layout lookups that found a layout of this frame or the frame before. */
+  lineLayoutHits: number
+  /**
+   * Line layout lookups that neither frame had but the window's shape store did: a layout shaped
+   * some frames ago, found again without shaping. Not counted in `shapes`.
+   */
+  shapeCacheHits: number
+  /**
+   * Subtrees whose painted extent (what culling reads) was worked out from their children,
+   * not found as an earlier pass or frame left it.
+   */
+  extentWalks: number
+  /** Subtrees whose scrollable overflow was worked out from their children. */
+  overflowWalks: number
+  /**
+   * Like `overflowWalks`, for the overflow from the unsnapped boxes that `scrollWidth` and
+   * `scrollHeight` read.
+   */
+  unsnappedOverflowWalks: number
+}
+
+/** `animateMotionValue` of a value that holds `from`, measured. Throws what it would. */
+export declare function measureMotionAnimation(from: any, target: any, transition?: any | undefined | null): MotionAnimationLength
+
+/** The OS accessibility preferences that media queries expose. */
+export interface MediaFeatures {
+  /** `prefers-reduced-motion: reduce`. */
+  reducedMotion: boolean
+  /** `prefers-contrast: more`. */
+  increasedContrast: boolean
+  /** `forced-colors: active`. macOS has no forced colors mode. */
+  forcedColors: boolean
+}
+
+/**
+ * How long an animation of a motion value lasts, found without a renderer from the transition
+ * and keyframes the renderer would run, so the controls can say before the value is bound.
+ */
+export interface MotionAnimationLength {
+  /** One iteration, without the delay or the repeats. */
+  duration: number
+  /** `duration` plus the delay. */
+  iterationDuration: number
+}
+
+/** What the controls of a motion value's animation read, in seconds. */
+export interface MotionValuePlayback {
+  /**
+   * Since the delay ended. Not held at the end of the last repeat: Motion's `time` goes on
+   * counting, and a seek past the end reads back as set.
+   */
+  time: number
+  /** The pace: 1 is real time, negative runs backwards. */
+  speed: number
+  /**
+   * One iteration, without the delay or the repeats. `Infinity` for a spring
+   * that has not come to rest in 20 seconds.
+   */
+  duration: number
+  /** `duration` plus the delay. */
+  iterationDuration: number
+  /** `"running"`, `"paused"` or `"finished"`. */
+  state: string
+  /**
+   * Motion's `startTime`: milliseconds on the renderer's clock since its origin, `null` before
+   * the animation starts and once it has finished.
+   */
+  startTime?: number
+}
+
+/** What the test platform did to a native surface. */
+export interface NativeSurfaceEventReading {
+  /** `"created"` when an element made its surface, `"removed"` when it dropped it. */
+  kind: string
+  /** The content view of the surface: the `handle` `attach` carries. */
+  handle: string
+}
+
+export interface NativeviewRect {
+  x: number
+  y: number
+  width: number
+  height: number
+}
+
+/** Where the last composed frame put the native view of a `<nativeview>`, in window pixels. */
+export interface NativeviewSurfaceReading {
+  /**
+   * The content view JS got with `attach`, as a decimal string: the address of the `NSView`
+   * of the window's offscreen platform, a number like 516333569280 that differs per run. The
+   * Rust unit tests run on gpui's test platform, where it is the index of the attachment.
+   */
+  handle: string
+  /** The whole surface, not cut by its clip. */
+  bounds: NativeviewRect
+  /**
+   * What shows of it: for an element that does not clip, the content mask around it, which
+   * can be larger than `bounds`.
+   */
+  clip: NativeviewRect
+  opacity: number
+  cornerRadius: number
+  capturesPointer: boolean
+}
+
+/**
+ * What one observation event carries beyond the element's border box, which
+ * travels in the payload's `x`, `y`, `width` and `height`.
+ */
+export interface Observation {
+  /**
+   * False when the element did not paint this frame (a virtual list row outside
+   * its window, removed). Every number is then 0. A `visibility: hidden`
+   * element keeps its box and is present.
+   */
+  present: boolean
+  /** Size of the content box: the border box minus border and padding. */
+  contentWidth: number
+  contentHeight: number
+  /**
+   * Padding on the left and top, which is where the content box starts
+   * inside the padding box (`ResizeObserverEntry.contentRect.x` and `.y`).
+   */
+  paddingLeft: number
+  paddingTop: number
+  /**
+   * The border widths of an intersection report, and the room a classic scrollbar takes on
+   * the right and at the bottom. The client box, which is what an `IntersectionObserver`
+   * root exposes, is the border box minus these.
+   */
+  borderLeft: number
+  borderTop: number
+  borderRight: number
+  borderBottom: number
+  scrollbarWidth: number
+  scrollbarHeight: number
+  /**
+   * The `overflow` clips of the ancestors, nearest first, in window
+   * coordinates. JS applies the ones below its root. The window edge is not
+   * one of them: an `IntersectionObserver` with a `rootMargin` sees past it.
+   */
+  clips: Array<ObservationClip>
+  /**
+   * The window's paintable size, which is the viewport of an
+   * `IntersectionObserver` with no `root`.
+   */
+  viewportWidth: number
+  viewportHeight: number
+}
+
+/**
+ * One ancestor's clip rect. An axis the ancestor does not clip spans
+ * `UNCLIPPED` either way.
+ */
+export interface ObservationClip {
+  /** The clipping ancestor's element id. */
+  id: number
+  x: number
+  y: number
+  width: number
+  height: number
+}
+
+/**
+ * How ticks were drawn by patching the frame before them, over the life of the window, see
+ * `get_patch_counters`.
+ */
+export interface PatchCounters {
+  /** Frames drawn by patching. */
+  patchedFrames: number
+  /** Units painted again by those frames. */
+  patchedUnits: number
+  /**
+   * Ticks that changed nothing that is drawn (every change was in skipped or sleeping content):
+   * no frame was built or presented.
+   */
+  emptyTicks: number
+  /** JSON object: ticks gpui drew whole after the patcher tried, by reason (`PatchDecline`). */
+  declines: string
+  /**
+   * JSON object: ticks gpuix did not try to patch, by kind (`Unpatchable`, and the units it
+   * could not build).
+   */
+  unpatchable: string
+}
+
+export interface PathPromptOptions {
+  /** Select files. Defaults to true unless `directories` is true. */
+  files?: boolean
+  /** Select directories. Defaults to false. */
+  directories?: boolean
+  /** Allow several paths. Defaults to false. */
+  multiple?: boolean
+  /** Label for the picker confirmation button. */
+  prompt?: string
+  /**
+   * Restrict the selectable files with the HTML `accept` syntax, such as
+   * ".png,.jpg,image/*,application/pdf". Directories are never filtered.
+   */
+  accept?: string
+}
+
+/** A rectangle in CSS px. */
+export interface Rectangle {
+  x: number
+  y: number
+  width: number
+  height: number
+}
+
+/** What the retained subtrees of the window did since it was made, see `get_retained_counters`. */
+export interface RetainedCounters {
+  /** Subtrees a frame did not build, because the frame before left them recorded as the same. */
+  hits: number
+  /** Subtrees whose prepaint was replayed from the recording. */
+  replays: number
+  /**
+   * Subtrees skipped for layout that had to be built for prepaint, because the place or the
+   * surroundings they were recorded in changed.
+   */
+  lazyBuilds: number
+  /** Subtrees built for layout. */
+  builds: number
+  layoutFallbacks: number
+  /**
+   * Subtrees a layout-only pass (a bounds read on a dirty window) did not build, because the
+   * last presented frame left them recorded as the same.
+   */
+  layoutSkips: number
+  /**
+   * Of those, the subtrees it published from their recording instead of building them for
+   * prepaint as it does the ones that moved.
+   */
+  layoutReplays: number
+  /** Subtrees built by a layout-only pass. */
+  layoutBuilds: number
+  /**
+   * Of the subtrees skipped with a layout record, those that a layout moved by a whole number
+   * of device pixels and that were put where they are, not built again.
+   */
+  layoutTranslations: number
+  /**
+   * Of those, the subtrees that left a layout record, which the next layout-only pass skips
+   * them with until a frame is drawn.
+   */
+  layoutRecords: number
+  /**
+   * Frames that replayed something and were compared with a build of the same frame; always 0
+   * unless `setRetainVerify`.
+   */
+  verified: number
+  /** Of those, the frames that differed. */
+  mismatches: number
+  /** A JSON object: the recordings that could not be replayed, by the first reason. */
+  nonReusable: string
+  /** Replays of a subtree that a scroller had moved, which are builds that were not made. */
+  relocations: number
+  /**
+   * A JSON object: the recordings of subtrees that a scroller moves that cannot be put
+   * elsewhere, by the first reason.
+   */
+  nonRelocatable: string
+  /**
+   * A JSON object: the subtrees that a scroller had moved and that were built again though
+   * they were the same but for where they are, by the reason.
+   */
+  relocationMisses: string
+}
+
+/** A size in CSS px. */
+export interface Size {
+  width: number
+  height: number
+}
+
+/** What the sync handler returns. */
+export interface SyncDispatchResult {
+  defaultPrevented: boolean
+  propagationStopped: boolean
+  /** The `dropEffect` a `dragover` ended with. */
+  dropEffect?: string
+}
+
+/** `selectionStart`, `selectionEnd` and `selectionDirection` of a text control. */
+export interface TextSelection {
+  start: number
+  end: number
+  /** `"forward"`, `"backward"` or `"none"`. */
+  direction: string
+}
+
+/** One extra HTTP header on the feed or download request. */
+export interface UpdaterHeader {
+  name: string
+  value: string
+}
+
+/**
+ * Checks a keyframes definition the way `GpuixRenderer.defineKeyframes` does,
+ * without a renderer. `defineKeyframes` from `@ghia/native/host` runs it
+ * first so a bad definition throws where it is written.
+ */
+export declare function validateKeyframes(name: string, framesJson: string): void
+
+/**
+ * What `getTiming()` and `getComputedTiming()` read of a CSS animation or transition, in
+ * milliseconds.
+ */
+export interface WebAnimationEffectInfo {
+  delay: number
+  /** `null` is `"auto"`. */
+  duration?: number
+  endDelay: number
+  fill: string
+  iterationStart: number
+  /** `Infinity` for an effect that repeats for ever. */
+  iterations: number
+  direction: string
+  easing: string
+  endTime: number
+  activeDuration: number
+  /** `null` for a run that was cancelled, which has no current time. */
+  localTime?: number
+  /** `null` outside the active phase when no fill holds the effect, and for a cancelled run. */
+  progress?: number
+  currentIteration?: number
+}
+
+/**
+ * A CSS animation or transition, or an animation of the motion engine, as `Animation.currentTime`,
+ * `playbackRate` and `playState` show it. `animationName` is set for a CSS animation and
+ * `transitionProperty` for a CSS transition; an animation of the motion engine has neither.
+ */
+export interface WebAnimationInfo {
+  /**
+   * Unique among the animations and transitions of the process, and the same
+   * for one run from its start to its end.
+   */
+  id: number
+  /** `"animation"`, `"transition"` or `"script"`. */
+  kind: string
+  /** The `animation-name`. */
+  animationName?: string
+  /** The CSS name of the transitioned property, `background-color`. */
+  transitionProperty?: string
+  /**
+   * Milliseconds from the start of the animation, the delay inside it, as of
+   * the last frame.
+   */
+  currentTime: number
+  /**
+   * Milliseconds where the effect ends, the delay inside it: what
+   * `currentTime` is at the end of a transition that finished. `Infinity`
+   * for an animation that repeats forever.
+   */
+  endTime: number
+  playbackRate: number
+  /**
+   * `"running"`, `"paused"`, `"finished"`, or `"idle"` for a run that was
+   * cancelled (`currentTime` is not meant then).
+   */
+  playState: string
+  /** A play or pause waits for the next frame. */
+  pending: boolean
+  /**
+   * The `startTime`: milliseconds on the renderer's clock since its origin, as the timeline
+   * of the animations reads (`getAnimationTimelineTime`). `null` while it has none.
+   */
+  startTime?: number
+}
+
+/** One keyframe of a CSS animation or transition, as `getKeyframes()` has it. */
+export interface WebAnimationKeyframeInfo {
+  /** The `computedOffset`. */
+  computedOffset: number
+  /** `null` for a keyframe of an animation of the motion engine that was given no offset or time. */
+  offset?: number
+  easing: string
+  /** `"auto"`, `"replace"`, `"add"` or `"accumulate"`. */
+  composite: string
+  values: Array<WebAnimationKeyframeValue>
+}
+
+/** One property of a keyframe of a CSS animation or transition, as `getKeyframes()` has it. */
+export interface WebAnimationKeyframeValue {
+  /** The camelCase name, `marginLeft`. */
+  property: string
+  /** The computed value as Chrome writes it: `16px`, `rgb(255, 0, 0)`. */
+  value: string
+}
+
+/**
+ * What `updateTiming()` sets, checked by JS: milliseconds, and the names of the DOM. A member
+ * left out is left as it is.
+ */
+export interface WebAnimationTimingUpdate {
+  delay?: number
+  /** `"auto"` or a number. */
+  duration?: number | string
+  endDelay?: number
+  fill?: string
+  iterationStart?: number
+  /** `Infinity` repeats for ever. */
+  iterations?: number
+  direction?: string
+  easing?: string
+}
+
+export interface WebviewCommandReading {
+  /**
+   * `loadURL`, `reload`, `stop`, `goBack`, `goForward`, `executeJavaScript` or
+   * `setFirstResponder`.
+   */
+  name: string
+  /**
+   * The URL, the code, or for the first responder `"false"` (the window's view), `"true"` (the
+   * page), `"forward"` or `"backward"` (the page, entered by Tab or Shift+Tab).
+   */
+  argument?: string
+}
+
+/** The container view AppKit applied the placement to, in window points from the top left. */
+export interface WebviewNativeViewReading {
+  hidden: boolean
+  x: number
+  y: number
+  width: number
+  height: number
+  contentX: number
+  contentY: number
+  contentWidth: number
+  contentHeight: number
+  opacity: number
+  /** A corner radius is cut into it. */
+  masked: boolean
+}
+
+/** What `getURL()`, `getTitle()`, `canGoBack()` and `canGoForward()` read. */
+export interface WebviewStateReading {
+  url: string
+  title: string
+  canGoBack: boolean
+  canGoForward: boolean
+}
+
+/** Where the last composed frame put the surface of a webview, in window pixels. */
+export interface WebviewSurfaceReading {
+  /** The surface is shown: it was painted and something of it is not clipped away. */
+  visible: boolean
+  /** The whole surface, not cut by its clip. */
+  x: number
+  y: number
+  width: number
+  height: number
+  /** What shows of it. Zero while it is not visible. */
+  clipX: number
+  clipY: number
+  clipWidth: number
+  clipHeight: number
+  opacity: number
+  cornerRadius: number
+  /** The position of the layer among the frame's layers, bottom to top. */
+  layer: number
+}
+
+export interface WindowInsets {
+  safeArea: EdgeInsets
+  ime: EdgeInsets
+  effective: EdgeInsets
+}
+
+export interface WindowOptions {
+  title?: string
+  /**
+   * The name used inside the macOS "Hide" and "Quit" menu items. Defaults to
+   * `title`. It does NOT set the title of the application menu itself: macOS
+   * takes that from the executable, and only a `.app` bundle changes it.
+   */
+  appName?: string
+  width?: number
+  height?: number
+  /**
+   * Where the window's top-left corner opens, in CSS px in the global space
+   * `getAllDisplays()` reports (origin at the primary display's top-left, y down).
+   * The display that contains the point, else the nearest, is the one the window
+   * opens on. Both `x` and `y` are needed; otherwise the window is centred, as in
+   * Electron. Ignored by `TestGpuixRenderer`.
+   */
+  x?: number
+  /** See `x`. */
+  y?: number
+  minWidth?: number
+  minHeight?: number
+  resizable?: boolean
+  fullscreen?: boolean
+  /** Plain alpha transparency. Prefer `window_background` when you need blur. */
+  transparent?: boolean
+  /** Hide the native titlebar so the app can draw chrome under the traffic lights. */
+  titlebarTransparent?: boolean
+  /**
+   * `"opaque"` | `"transparent"` | `"blurred"`. `transparent: true` is the
+   * same as `"transparent"` when this is unset.
+   */
+  windowBackground?: string
+  /**
+   * `"system"` | `"light"` | `"dark"`. Defaults to `"system"`: follow the OS
+   * setting. Applies to the whole app on macOS and is ignored elsewhere.
+   */
+  appearance?: string
+  trafficLightX?: number
+  trafficLightY?: number
+  /**
+   * Give the window key focus when it opens. `false` opens it behind the
+   * active app, like `open -g`. Ignored on Linux.
+   */
+  focus?: boolean
+  /**
+   * Show the window when it opens. `false` opens it hidden; call
+   * `activateWindow()` to reveal it. Ignored on Linux.
+   */
+  show?: boolean
+  /**
+   * Application id: Wayland `app_id` / X11 `WM_CLASS`. Desktop environments
+   * use it to group windows and match window rules. Required in practice for
+   * a `layerShell` surface a compositor is meant to target by rule.
+   */
+  appId?: string
+  /**
+   * Open the window as a Wayland `wlr-layer-shell` surface instead of a
+   * normal window. Linux/Wayland only; ignored elsewhere.
+   */
+  layerShell?: LayerShellOptions
+}
+
+export interface WindowSize {
+  width: number
+  height: number
+}