@satinhq/kit 0.0.0-stage → 0.1.0-beta.1

package/dist/glass/webgpu/frameGraph.js

@@ -0,0 +1,287 @@
+import { takeSourceBands, takeSourcePixels } from './preparedSourcePixels.js';
+import { glassTimed } from './profile.js';
+const graphs = new WeakMap();
+const textureBytes = (width, height, levels) => Array.from({ length: levels }, (_, i) => Math.max(1, width >> i) * Math.max(1, height >> i) * 4).reduce((a, b) => a + b, 0);
+/** One device graph, independent of presentation canvases. Immutable source keys
+ * share uploads; ordered submissions reuse scratch targets and completed passes.
+ * A source key identifies content, never a canvas or a mutable DOM element. */
+export class FrameGraph {
+    static for(owner) {
+        let graph = graphs.get(owner);
+        if (!graph) {
+            graph = new FrameGraph(owner);
+            graphs.set(owner, graph);
+        }
+        return graph;
+    }
+    device;
+    generation = 0;
+    serial = 0;
+    textures = new Map();
+    images = new Map();
+    virtualImages = new Map();
+    uploaded = new WeakSet();
+    results = new WeakMap();
+    /** Where a failed upload is reported (the renderer's glass error channel). */
+    owner;
+    constructor(owner) {
+        this.owner = owner;
+        this.device = owner.liveDevice;
+        owner.subscribe(device => {
+            this.device = device;
+            if (!device) {
+                this.generation++;
+                this.textures.clear();
+                this.uploaded = new WeakSet();
+                this.results = new WeakMap();
+                this.published.clear();
+                this.publishedKey = new WeakMap();
+            }
+            else {
+                // Rebuild before raster subscribers resume. Atlas sources retain immutable
+                // CPU images, so no old-generation GPU texture participates in replay.
+                // A recipe can only retain an existing image. Nested atlas dependencies
+                // therefore precede their consumers in this insertion-ordered map.
+                for (const image of this.virtualImages.values()) {
+                    if (!image.replay)
+                        throw Error('Retained navigation atlas has no reconstruction recipe');
+                    image.target.release();
+                    image.target = this.target('front', image.width, image.height, false, image.key);
+                    image.replay.render(device, image.target.value);
+                    this.markUploaded(image.target.value);
+                }
+            }
+        });
+    }
+    image(key, image) {
+        key = key ?? `private-image-${++this.serial}`;
+        let entry = this.images.get(key);
+        if (entry) {
+            if (entry.value.width !== image.width || entry.value.height !== image.height) {
+                image.close();
+                throw Error('Immutable glass source key changed dimensions: ' + key);
+            }
+            if (image !== entry.value)
+                image.close();
+        }
+        else {
+            entry = { value: image, references: 0, bytes: image.width * image.height * 4, generation: 0 };
+            this.images.set(key, entry);
+        }
+        entry.references++;
+        const held = entry, identity = key;
+        let released = false;
+        return {
+            value: entry.value,
+            key,
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                if (--held.references === 0) {
+                    held.value.close();
+                    this.images.delete(identity);
+                }
+            },
+        };
+    }
+    /** An image lease for GPU-composed content (the navigation atlas): its texture is written by
+     * copies on the queue, never uploaded from a bitmap. `markUploaded` on its target first. */
+    virtual(key, width, height, replay) {
+        const existing = this.images.get(key);
+        if (existing) {
+            replay?.release();
+            return this.image(key, existing.value);
+        }
+        // A virtual image has no CPU pixels to upload again. Its retained image
+        // leases must therefore keep the composed texture alive through suspension,
+        // even after the navigation slot advances to a different atlas.
+        let target;
+        try {
+            target = this.target('front', width, height, false, key);
+        }
+        catch (error) {
+            replay?.release();
+            throw error;
+        }
+        const virtual = { key, width, height, target, replay };
+        this.virtualImages.set(key, virtual);
+        const graph = this;
+        const stub = {
+            width,
+            height,
+            close() {
+                virtual.target.release();
+                virtual.replay?.release();
+                graph.virtualImages.delete(key);
+            },
+        };
+        return this.image(key, stub);
+    }
+    reconstructVirtual(key) {
+        const image = this.virtualImages.get(key);
+        if (!image?.replay || !this.device)
+            throw Error('Navigation atlas reconstruction is unavailable');
+        image.replay.render(this.device, image.target.value);
+        this.markUploaded(image.target.value);
+    }
+    markUploaded(target) {
+        this.uploaded.add(target.texture);
+    }
+    /** Whether a bitmap is retained by a live image lease (shared sources are never closed by a borrower). */
+    owns(image) {
+        for (const entry of this.images.values())
+            if (entry.value === image)
+                return true;
+        return false;
+    }
+    retain(key) {
+        const entry = this.images.get(key);
+        if (!entry)
+            throw Error('Missing retained glass image: ' + key);
+        return this.image(key, entry.value);
+    }
+    target(role, width, height, mip = false, sourceKey) {
+        width = Math.max(1, Math.round(width));
+        height = Math.max(1, Math.round(height));
+        const levels = mip ? 1 + Math.floor(Math.log2(Math.max(width, height))) : 1;
+        const key = JSON.stringify([role, width, height, levels, sourceKey ?? 'scratch']);
+        let entry = this.textures.get(key);
+        if (!entry) {
+            if (!this.device)
+                throw Error('Frame graph has no live device');
+            const texture = this.device.createTexture({
+                label: role,
+                size: [width, height],
+                format: 'rgba8unorm',
+                mipLevelCount: levels,
+                usage: GPUTextureUsage.TEXTURE_BINDING |
+                    GPUTextureUsage.RENDER_ATTACHMENT |
+                    GPUTextureUsage.COPY_SRC |
+                    GPUTextureUsage.COPY_DST |
+                    (levels > 1 ? GPUTextureUsage.STORAGE_BINDING : 0),
+            });
+            entry = {
+                value: { texture, width, height, levels },
+                references: 0,
+                bytes: textureBytes(width, height, levels),
+                generation: this.generation,
+            };
+            this.textures.set(key, entry);
+        }
+        entry.references++;
+        const held = entry;
+        let released = false;
+        return {
+            key,
+            value: held.value,
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                if (held.generation !== this.generation)
+                    return;
+                if (--held.references === 0) {
+                    held.value.texture.destroy();
+                    this.textures.delete(key);
+                }
+            },
+        };
+    }
+    /** Textures whose upload the device rejected: written once more when next needed, then left. */
+    rejected = new WeakSet();
+    upload(image, target) {
+        if (this.uploaded.has(target.texture))
+            return;
+        if (!this.device)
+            throw Error('Frame graph upload has no device');
+        const device = this.device;
+        const texture = target.texture;
+        glassTimed('gpu-upload', () => {
+            // Banded captures retain sparse readback; the upload initializes their transparent gaps.
+            const bands = takeSourceBands(image);
+            const bytes = bands ? undefined : takeSourcePixels(image);
+            if (!bands && !bytes) {
+                device.queue.copyExternalImageToTexture({ source: image }, { texture, premultipliedAlpha: true, colorSpace: 'srgb' }, [image.width, image.height]);
+                return;
+            }
+            // Tightly packed rows. `writeTexture` takes any stride of at least a row's bytes (WebGPU,
+            // "validating linear texture data"); the multiple of 256 that sourcePixels.worker.ts and
+            // raster.ts pad to is a requirement of buffer copies only. The bytes must be exactly the
+            // image: any other length would be read at a stride that is not its rows'.
+            const writes = bands ?? [{ row: 0, rows: image.height, bytes: bytes }];
+            for (const { row, rows, bytes: written } of writes)
+                if (written.byteLength !== image.width * rows * 4 || row < 0 || row + rows > image.height)
+                    throw Error(bands
+                        ? `Glass source bytes (${written.byteLength}) are not rows ${row}..${row + rows} ` +
+                            `of a ${image.width}x${image.height} image`
+                        : `Glass source bytes (${written.byteLength}) are not a ${image.width}x${image.height} image`);
+            // A write the device rejects is reported when its error scope resolves, after this call:
+            // the texture is then not uploaded, and the next draw writes it again (once).
+            device.pushErrorScope?.('validation');
+            try {
+                // A partial first write makes WebKit clear the fresh texture before uploading.
+                // Initialize it in one write instead, retaining band-only raster and readback work.
+                // Gaps remain transparent and are still rejected by the coverage contract.
+                const upload = bands ? new Uint8Array(image.width * image.height * 4) : bytes;
+                if (bands) {
+                    for (const { row, bytes: written } of bands)
+                        upload.set(written, row * image.width * 4);
+                }
+                device.queue.writeTexture({ texture }, upload, { bytesPerRow: image.width * 4 }, [
+                    image.width,
+                    image.height,
+                ]);
+            }
+            finally {
+                void device.popErrorScope?.().then(error => {
+                    if (!error)
+                        return;
+                    this.owner.reportError?.('source upload', `${error.constructor.name}: ${error.message}`);
+                    if (this.rejected.has(texture))
+                        return;
+                    this.rejected.add(texture);
+                    this.uploaded.delete(texture);
+                }, () => { });
+            }
+        }, () => JSON.stringify({
+            width: image.width,
+            height: image.height,
+            bytes: image.width * image.height * 4,
+        }));
+        this.uploaded.add(texture);
+    }
+    matches(target, key) {
+        return this.results.get(target.texture) === key;
+    }
+    // Published results: a surface's finished result, readable by another surface that
+    // needs the identical intermediate (a lift overlay above the same bar) this frame.
+    published = new Map();
+    publishedKey = new WeakMap();
+    publish(key, target) {
+        this.unpublish(target);
+        this.published.set(key, target);
+        this.publishedKey.set(target.texture, key);
+    }
+    unpublish(target) {
+        const key = this.publishedKey.get(target.texture);
+        if (key !== undefined && this.published.get(key) === target)
+            this.published.delete(key);
+        this.publishedKey.delete(target.texture);
+    }
+    publishedResult(key) {
+        return this.published.get(key);
+    }
+    mark(target, key) {
+        this.results.set(target.texture, key);
+    }
+    report() {
+        return {
+            gpuBytes: [...this.textures.values()].reduce((n, e) => n + e.bytes, 0),
+            retainedBitmapBytes: [...this.images.values()].reduce((n, e) => n + e.bytes, 0),
+            textures: this.textures.size,
+            images: this.images.size,
+            generation: this.generation,
+        };
+    }
+}

package/dist/glass/webgpu/frameProbe.d.ts

@@ -0,0 +1,58 @@
+/** Worker frame evidence for the phone probe: per interaction kind, frame intervals,
+ * CPU, submit→completion latency and (when the device exposes `timestamp-query`) GPU
+ * time per frame. Runs only inside motion loops; the summary is posted once the loop
+ * goes idle, so idle stays at zero work. */
+export type FrameKind = 'drag' | 'scroll' | 'minimize' | 'menu' | 'navigation' | 'region' | 'other';
+export type FrameProbeSample = {
+    kind: FrameKind;
+    interval: number | null;
+    cpuMs: number;
+    doneMs?: number;
+    gpuMs?: number;
+    passes?: Record<string, number>;
+    passCount?: number;
+    restart: boolean;
+};
+export type FrameSummary = {
+    kind: FrameKind;
+    frames: number;
+    timestampQuery: boolean;
+    intervals: Stat;
+    cpuMs: Stat;
+    submitToDoneMs: Stat;
+    gpuMs?: Stat;
+    passMs?: Record<string, Stat>;
+    passesPerFrame?: Stat;
+    over20: number;
+    over34: number;
+    raw: {
+        interval: (number | null)[];
+        cpuMs: number[];
+        doneMs: (number | null)[];
+        gpuMs: (number | null)[];
+    };
+};
+type Stat = {
+    p50: number;
+    p95: number;
+    max: number;
+} | null;
+export declare class FrameProbe {
+    private samples;
+    private timer?;
+    private device?;
+    private post;
+    constructor(post: (summary: FrameSummary[]) => void);
+    get timestampQuery(): boolean;
+    useDevice(device: GPUDevice | undefined): void;
+    /** Wraps one frame's encoding and submission. Returns the frame's sample: its completion and
+     * GPU times are filled in when they arrive. */
+    frame(kind: FrameKind, interval: number | null, restart: boolean, encode: (e: GPUCommandEncoder) => void, canSubmit?: () => boolean): FrameProbeSample | undefined;
+    /** The loop went idle: summarize its frames by kind once their completions arrive. */
+    private pending;
+    /** The loop went idle. Scroll events restart the loop per event, so a summary waits
+     * for 300 ms of quiet (one timer after motion, never a loop), then groups by kind. */
+    flush(): void;
+    private summarize;
+}
+export {};

package/dist/glass/webgpu/frameProbe.js

@@ -0,0 +1,181 @@
+/// <reference types="@webgpu/types" />
+import { submitCanvasCommands } from './canvasSubmission.js';
+import { passTimer } from './passes.js';
+const stat = (values) => {
+    if (!values.length)
+        return null;
+    const s = [...values].sort((a, b) => a - b), q = (p) => s[Math.min(s.length - 1, Math.floor(p * s.length))];
+    return { p50: +q(0.5).toFixed(2), p95: +q(0.95).toFixed(2), max: +s[s.length - 1].toFixed(2) };
+};
+const round = (v) => v === undefined || v === null ? null : +v.toFixed(2);
+const CAPACITY = 96;
+/** Arms per-pass timestamps for one frame (see passTimer) and reads them back. */
+class GPUFrameTimer {
+    queries;
+    resolve;
+    reads;
+    constructor(device) {
+        this.queries = device.createQuerySet({ type: 'timestamp', count: 2 * CAPACITY });
+        this.resolve = device.createBuffer({
+            size: 16 * CAPACITY,
+            usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC,
+        });
+        this.reads = Array.from({ length: 4 }, () => ({
+            buffer: device.createBuffer({
+                size: 16 * CAPACITY,
+                usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+            }),
+            busy: false,
+        }));
+    }
+    begin() {
+        passTimer.set = this.queries;
+        passTimer.labels = [];
+        passTimer.capacity = CAPACITY;
+    }
+    cancel() {
+        passTimer.set = undefined;
+        passTimer.labels = [];
+    }
+    /** Returns a reader of {gpuMs, passes} for this frame, or undefined when no slot is free. */
+    end(e) {
+        const labels = passTimer.labels;
+        passTimer.set = undefined;
+        passTimer.labels = [];
+        const slot = this.reads.find(r => !r.busy);
+        if (!slot || !labels.length)
+            return undefined;
+        e.resolveQuerySet(this.queries, 0, 2 * labels.length, this.resolve, 0);
+        e.copyBufferToBuffer(this.resolve, 0, slot.buffer, 0, 16 * labels.length);
+        slot.busy = true;
+        return () => slot.buffer.mapAsync(GPUMapMode.READ, 0, 16 * labels.length).then(() => {
+            const t = new BigUint64Array(slot.buffer.getMappedRange(0, 16 * labels.length)).slice();
+            slot.buffer.unmap();
+            slot.busy = false;
+            let first = t[0], last = t[1];
+            const passes = {};
+            labels.forEach((label, i) => {
+                const b = t[2 * i], en = t[2 * i + 1];
+                if (b < first)
+                    first = b;
+                if (en > last)
+                    last = en;
+                passes[label] = (passes[label] ?? 0) + Number(en - b) / 1e6;
+            });
+            return { gpuMs: Number(last - first) / 1e6, passes, count: labels.length };
+        }, () => {
+            slot.busy = false;
+            return undefined;
+        });
+    }
+}
+export class FrameProbe {
+    samples = [];
+    timer;
+    device;
+    post;
+    constructor(post) {
+        this.post = post;
+    }
+    get timestampQuery() {
+        return !!this.device?.features.has('timestamp-query');
+    }
+    useDevice(device) {
+        this.device = device;
+        this.timer = undefined;
+        if (device?.features.has('timestamp-query'))
+            try {
+                this.timer = new GPUFrameTimer(device);
+            }
+            catch {
+                this.timer = undefined;
+            }
+    }
+    /** Wraps one frame's encoding and submission. Returns the frame's sample: its completion and
+     * GPU times are filled in when they arrive. */
+    frame(kind, interval, restart, encode, canSubmit = () => true) {
+        const device = this.device;
+        if (!device)
+            return;
+        clearTimeout(this.pending);
+        this.pending = 0;
+        const started = performance.now(), e = device.createCommandEncoder();
+        this.timer?.begin();
+        encode(e);
+        if (!canSubmit()) {
+            this.timer?.cancel();
+            return;
+        }
+        const read = this.timer?.end(e);
+        const commands = e.finish();
+        if (!canSubmit())
+            return;
+        submitCanvasCommands(device, e, commands);
+        const sample = { kind, interval, restart, cpuMs: performance.now() - started };
+        this.samples.push(sample);
+        if (this.samples.length > 2400)
+            this.samples.shift();
+        const submitted = performance.now();
+        void device.queue.onSubmittedWorkDone().then(() => {
+            sample.doneMs = performance.now() - submitted;
+        });
+        if (read)
+            void read().then(r => {
+                if (r) {
+                    sample.gpuMs = r.gpuMs;
+                    sample.passes = r.passes;
+                    sample.passCount = r.count;
+                }
+            });
+        return sample;
+    }
+    /** The loop went idle: summarize its frames by kind once their completions arrive. */
+    pending = 0;
+    /** The loop went idle. Scroll events restart the loop per event, so a summary waits
+     * for 300 ms of quiet (one timer after motion, never a loop), then groups by kind. */
+    flush() {
+        clearTimeout(this.pending);
+        if (!this.samples.length)
+            return;
+        this.pending = setTimeout(() => {
+            this.pending = 0;
+            this.summarize();
+        }, 300);
+    }
+    summarize() {
+        const samples = this.samples;
+        this.samples = [];
+        if (!samples.length)
+            return;
+        {
+            const kinds = [...new Set(samples.map(s => s.kind))];
+            this.post(kinds.map(kind => {
+                const list = samples.filter(s => s.kind === kind), intervals = list.filter(s => !s.restart && s.interval !== null).map(s => s.interval);
+                const done = list.flatMap(s => (s.doneMs === undefined ? [] : [s.doneMs])), gpu = list.flatMap(s => (s.gpuMs === undefined ? [] : [s.gpuMs]));
+                const timed = list.filter(s => s.passes), labels = [...new Set(timed.flatMap(s => Object.keys(s.passes)))];
+                const passMs = timed.length
+                    ? Object.fromEntries(labels.map(l => [l, stat(timed.map(s => s.passes[l] ?? 0))]))
+                    : undefined;
+                return {
+                    kind,
+                    frames: list.length,
+                    timestampQuery: this.timestampQuery,
+                    intervals: stat(intervals),
+                    cpuMs: stat(list.map(s => s.cpuMs)),
+                    submitToDoneMs: stat(done),
+                    gpuMs: gpu.length ? stat(gpu) : undefined,
+                    passMs,
+                    passesPerFrame: timed.length ? stat(timed.map(s => s.passCount)) : undefined,
+                    over20: intervals.filter(v => v > 20).length,
+                    over34: intervals.filter(v => v > 34).length,
+                    raw: {
+                        interval: list.slice(-240).map(s => (s.restart ? null : round(s.interval))),
+                        cpuMs: list.slice(-240).map(s => round(s.cpuMs)),
+                        doneMs: list.slice(-240).map(s => round(s.doneMs)),
+                        gpuMs: list.slice(-240).map(s => round(s.gpuMs)),
+                    },
+                };
+            }));
+        }
+    }
+}

package/dist/glass/webgpu/interactionProfiles.d.ts

@@ -0,0 +1,10 @@
+import type { TabHeldGeometry } from '../lens/tabMotion.js';
+export declare const NATIVE_HELD_TAB: TabHeldGeometry;
+export declare const NATIVE_HELD_TOP_TAB: TabHeldGeometry;
+export declare function tabHeldGeometry(width?: number, height?: number, dockWidth?: number, placement?: 'bottom' | 'top'): Readonly<{
+    widthDelta: number;
+    height: number;
+    edgeShift: number;
+    edgeOverflow?: number;
+    minHeight?: number;
+}> | undefined;

package/dist/glass/webgpu/interactionProfiles.js

@@ -0,0 +1,25 @@
+// Native lossless fitting set, 12v/native-stills: all 13 observed tab holds
+// have [9.7889447,867.7567146,127.7144342,72.4865708] presentation bounds.
+// This corrects only the measured 440pt, four-tab baseline. No timing fit.
+export const NATIVE_HELD_TAB = Object.freeze({
+    widthDelta: 20.21443424016636,
+    height: 72.48657078495921,
+    edgeShift: 6.60383815629875,
+    edgeOverflow: 11.211055276381925,
+});
+// iPadOS 27 regular-width top tab bar, iPad ReplayKit (Oct 11, fit-only cadence): a held
+// 85 pt Menus pill becomes a 109.4 pt × 55.5 pt lens centred on its tab, over a 44 pt bar whose
+// pills rest at 36 pt. Edge shift and overflow are not yet measured; they keep the phone defaults.
+// Evidence: the implementation contract
+export const NATIVE_HELD_TOP_TAB = Object.freeze({
+    widthDelta: 24.4,
+    height: 55.5,
+    edgeShift: 5,
+    edgeOverflow: 11,
+    minHeight: 36,
+});
+export function tabHeldGeometry(width, height, dockWidth, placement = 'bottom') {
+    if (placement === 'top')
+        return NATIVE_HELD_TOP_TAB;
+    return width === 107.5 && height === 54 && dockWidth === 398 ? NATIVE_HELD_TAB : undefined;
+}

package/dist/glass/webgpu/keptGlyphs.d.ts

@@ -0,0 +1,68 @@
+/** Chrome glyph ink the renderer keeps after its slot took other ink, so the same ink can be
+ * installed again by key, with no capture and no upload.
+ *
+ * The tab bar's ink follows the backdrop under the bar (tabGlyphContextStyle): entering a tab
+ * whose content differs under the bar changes it, and coming back changes it again. Each change
+ * was a capture of every tab's label and icon, a bitmap and an upload: 36 to 47 ms of capture and
+ * 15 to 85 ms of upload in the Catalyst host, on every such tab switch, and asynchronous, so the
+ * new backdrop could not be installed in the frame that shows the tab. A tab bar alternates
+ * between a handful of inks; the last four stay in the renderer (on a phone about 12 MB each: a
+ * 6 MB image and its 6 MB texture).
+ *
+ * This is the page's ledger of what the renderer keeps: the renderer keeps exactly the keys it
+ * was told to `keep` and not yet told to `unkeep` (worker protocol, `source-images`). */
+export declare class KeptGlyphs {
+    /** Kept ink by slot and signature, least recently used first. */
+    private kept;
+    /** Keys the renderer still holds for ink this ledger has forgotten. */
+    private dropped;
+    private readonly limit;
+    constructor(limit?: number);
+    private static entry;
+    /** The key of the kept image of this ink, when the renderer has one. */
+    find(id: string, signature: string): string | undefined;
+    /** A slot is taking other ink: its outgoing ink is kept (most recently used), and the least
+     * recently used ink beyond the limit is let go, never one that is `installed` now. Returns
+     * the keys the batch that replaces the slot tells the renderer to keep and to let go. */
+    replace(id: string, outgoing: {
+        signature: string;
+        key: string;
+    } | undefined, installed: readonly string[]): {
+        keep: string[];
+        unkeep: string[];
+    };
+    /** Ink was installed again from its kept image: it is the most recently used. */
+    used(id: string, signature: string): void;
+    /** Forget every kept ink (fonts changed, or a failed batch left the renderer's slots unknown):
+     * nothing is reused, and the next batch lets the renderer's images go. */
+    reset(): void;
+}
+/** The ink a surface installs in one source revision.
+ *
+ * Ink that would have to be captured while a new backdrop is being installed does not hold that
+ * backdrop back: its capture is asynchronous (icon decodes, a bitmap), and waiting for it showed
+ * the new tab's content over the previous tab's backdrop for the capture's whole duration. Such
+ * a revision commits with the ink the surface has (`deferred`), and the next one captures the new
+ * ink, whatever else it installs (`deferredBefore`). Ink the renderer keeps is installed at once, and so is the first ink of a surface (there
+ * is nothing to commit with instead). Transformed tab DOM during minimize is never captured. */
+export declare function inkForRevision(input: {
+    /** The signature of the ink the page shows now. */
+    signature: string;
+    installed: {
+        signature: string;
+        key: string;
+    } | undefined;
+    /** Whether the renderer keeps an image of that ink (KeptGlyphs.find). */
+    kept: boolean;
+    /** The tab bar's DOM ink is under a minimize transform. */
+    transformed: boolean;
+    /** This revision installs a new or restored backdrop plane. */
+    backdropChanges: boolean;
+    /** The previous revision deferred this surface's ink. Ink is deferred once: content that keeps
+     * changing under the bar would otherwise put a changed label or badge off for as long as it
+     * does (every revision installs a plane). The second revision waits for the ink. */
+    deferredBefore?: boolean;
+}): {
+    signature: string;
+    deferred: boolean;
+};