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

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

@@ -0,0 +1,53 @@
+import type { Appearance } from '../lens/theme.js';
+import type { RuntimeGeometry, SurfaceRenderSpec } from '../renderSpecs.js';
+import type { SharedSourceImage, WebGPURequest as Request } from '../worker/protocol.js';
+import type { ProductionGlassRuntime } from './production.js';
+import { type MaterialContext, type Plane, type PlaneCapture } from './productionPlanes.js';
+import { type RegionTrack } from './productionTracks.js';
+/** Install this preparation's plane set: new captures and restored retained planes take their
+ * slots, unchanged planes follow their viewport origin, and planes that left the set are kept
+ * resident when the budget allows. Returns the worker slot changes for the batch and the capture
+ * canvases that are no longer needed. */
+export declare function commitPlaneSet(runtime: ProductionGlassRuntime, prepared: {
+    planes: readonly Plane[];
+    contentPlane: Plane;
+    captures: ReadonlyMap<string, PlaneCapture>;
+    reused: ReadonlySet<string>;
+    capture: {
+        context: MaterialContext;
+    } | undefined;
+    contextKey: string;
+    geometry: RuntimeGeometry;
+    resolution: number;
+    appearance: Appearance;
+    text: string;
+    damageGenerations?: ReadonlyMap<string, number>;
+}): {
+    removed: string[];
+    retain: string[];
+    restore: {
+        slot: string;
+        key: string;
+    }[];
+    unretain: string[];
+    droppedCanvases: HTMLCanvasElement[];
+};
+/** The batch's images: new plane captures, then new chrome glyphs, then glyph slots that take a
+ * kept image again (by key, with no image). */
+export declare function sourceImages(runtime: ProductionGlassRuntime, captures: ReadonlyMap<string, PlaneCapture>, glyphs: ReadonlyMap<SurfaceRenderSpec['id'], ImageBitmap>, keptGlyphs?: Iterable<SurfaceRenderSpec['id']>): SharedSourceImage[];
+/** The source install of every chrome surface on its layer (and its lift overlay), in transport
+ * order. A menu run in flight since the preparation started owns the menu surfaces' specs. */
+export declare function surfaceInstalls(runtime: ProductionGlassRuntime, specs: readonly SurfaceRenderSpec[], batch: {
+    menuTrack: RegionTrack | undefined;
+    barTrack: RegionTrack | undefined;
+    now: number;
+    appearance: Appearance;
+    sourceKey: string;
+    contentLayer: string;
+    sourceScrollY: number;
+    trigger: ReturnType<ProductionGlassRuntime['triggerValues']>;
+    geometry: RuntimeGeometry;
+    resolution: number;
+}): Request[];
+/** Follow every committed plane's scroll (a GPU offset, never a recapture) and its size. */
+export declare function syncPlaneScrolls(runtime: ProductionGlassRuntime, planes: readonly Plane[], scroller: HTMLElement): void;

package/dist/glass/webgpu/productionInstalls.js

@@ -0,0 +1,225 @@
+import { TabMotion } from '../lens/tabMotion.js';
+import { visiblePlaneSetKey, } from './productionPlanes.js';
+import { sampleRegion } from './productionTracks.js';
+// The commit and transport half of a source preparation (productionPrepare.ts): installing the
+// captured plane set in the runtime's bookkeeping and building the worker install requests.
+/** Install this preparation's plane set: new captures and restored retained planes take their
+ * slots, unchanged planes follow their viewport origin, and planes that left the set are kept
+ * resident when the budget allows. Returns the worker slot changes for the batch and the capture
+ * canvases that are no longer needed. */
+export function commitPlaneSet(runtime, prepared) {
+    const { planes, contentPlane, captures, reused, capture, contextKey, geometry } = prepared;
+    const { resolution, appearance, text } = prepared;
+    const clearCapturedDamage = (id) => {
+        if ((runtime.damageGenerations?.get(id) ?? 0) === (prepared.damageGenerations?.get(id) ?? 0))
+            runtime.damaged.delete(id);
+        else
+            runtime.prepareAgain = true;
+    };
+    if (capture)
+        runtime.context = capture.context;
+    const entryGeometry = (plane) => ({
+        origin: { ...plane.origin },
+        window: plane.window,
+        bands: plane.bands,
+        width: plane.width,
+        height: plane.height,
+        resolution,
+        host: plane.host,
+        searchAnchor: plane.measured.searchAnchor,
+        keyboardAnchor: plane.measured.keyboardAnchor,
+        appearance,
+        text,
+    });
+    const unretain = [];
+    const restore = [];
+    for (const [id, { signature }] of captures) {
+        runtime.planes.set(id, {
+            signature,
+            key: `backdrop:${id}:${++runtime.captureRevision}`,
+            revision: runtime.captureRevision,
+            ...entryGeometry(planes.find(plane => plane.id === id)),
+        });
+        clearCapturedDamage(id);
+        // A retained plane captured again (its content changed while covered): the worker frees the old image and texture.
+        const old = runtime.resident.recaptured(id);
+        if (old)
+            unretain.push(`${old}:front`);
+    }
+    for (const id of reused) {
+        const { imageBytes, ...plane } = runtime.resident.take(id);
+        runtime.planeBytes.set(id, imageBytes);
+        runtime.planes.set(id, {
+            ...plane,
+            ...entryGeometry(planes.find(candidate => candidate.id === id)),
+        });
+        clearCapturedDamage(id);
+        restore.push({ slot: `plane:${id}`, key: `${plane.key}:front` });
+    }
+    // Unchanged planes follow their current viewport origin (a navigation atlas copies from it).
+    for (const plane of planes) {
+        const entry = runtime.planes.get(plane.id);
+        if (entry)
+            Object.assign(entry, entryGeometry(plane));
+    }
+    if (capture)
+        runtime.contextGeometry = visiblePlaneSetKey(planes, runtime.planes, contentPlane, geometry);
+    const removed = [...runtime.planes.keys()].filter(id => !planes.some(plane => plane.id === id));
+    // Keep removed planes resident (newest last) when their host is still in the document and their
+    // capture is current; the budget then evicts orphaned, stale and oldest entries.
+    const retain = [];
+    const droppedCanvases = [];
+    for (const id of removed) {
+        const entry = runtime.planes.get(id);
+        runtime.planes.delete(id);
+        const imageBytes = runtime.planeBytes.get(id) ?? Infinity;
+        if (!runtime.damaged.delete(id) && runtime.resident.retain(id, { ...entry, imageBytes }))
+            retain.push(`${entry.key}:front`);
+        // The capture canvas is not kept for a retained plane (the worker holds its image). The
+        // caller releases it once this batch is posted (see releaseCaptureCanvas).
+        const dropped = runtime.planeCanvases.get(id);
+        if (dropped)
+            droppedCanvases.push(dropped.canvas);
+        runtime.planeCanvases.delete(id);
+        runtime.planeBytes.delete(id);
+        runtime.damageGenerations?.delete(id);
+    }
+    for (const key of runtime.resident.settle(contextKey).map(key => `${key}:front`)) {
+        const index = retain.indexOf(key);
+        if (index >= 0)
+            retain.splice(index, 1);
+        else
+            unretain.push(key);
+    }
+    runtime.installedSource = { ...runtime.planes.get(contentPlane.id) };
+    runtime.contentPlane = contentPlane.id;
+    return { removed, retain, restore, unretain, droppedCanvases };
+}
+/** The batch's images: new plane captures, then new chrome glyphs, then glyph slots that take a
+ * kept image again (by key, with no image). */
+export function sourceImages(runtime, captures, glyphs, keptGlyphs = []) {
+    return [
+        ...[...captures].map(([id, { bitmap }]) => ({
+            slot: `plane:${id}`,
+            key: `${runtime.planes.get(id).key}:front`,
+            image: bitmap,
+        })),
+        ...[...glyphs].map(([id, image]) => ({
+            slot: `glyph:${id}`,
+            key: runtime.glyphs.get(id).key,
+            image,
+        })),
+        ...[...keptGlyphs].map(id => ({ slot: `glyph:${id}`, key: runtime.glyphs.get(id).key })),
+    ];
+}
+/** The source install of every chrome surface on its layer (and its lift overlay), in transport
+ * order. A menu run in flight since the preparation started owns the menu surfaces' specs. */
+export function surfaceInstalls(runtime, specs, batch) {
+    const { menuTrack, barTrack, now, appearance, sourceKey, contentLayer, trigger } = batch;
+    const { geometry, resolution } = batch;
+    const installs = [];
+    for (const listed of specs) {
+        const spec = listed.id === 'right' && menuTrack ? sampleRegion(menuTrack, now) : listed;
+        const setup = {
+            spec,
+            appearance,
+            sourceKey,
+            contentLayer,
+            sourceScrollY: batch.sourceScrollY,
+            glyphKey: runtime.glyphs.get(spec.id).key,
+            trigger,
+            width: geometry.width,
+            height: geometry.height,
+            resolution,
+        };
+        const id = spec.id === 'dock' ? 'chrome' : spec.id === 'right' ? 'menu' : spec.id;
+        runtime.regionIds.set(spec.id, id);
+        if (spec.id === 'dock')
+            installs.push({
+                type: 'source',
+                revision: runtime.nextTransport(),
+                setup,
+                sentAt: performance.timeOrigin + performance.now(),
+            });
+        else if (spec.id === 'right')
+            installs.push({
+                type: 'layer-source',
+                revision: runtime.nextTransport(),
+                layerId: 'menu',
+                setup,
+            });
+        else
+            installs.push({
+                type: 'layer-source',
+                revision: runtime.nextTransport(),
+                layerId: 'chrome',
+                regionId: id,
+                setup,
+            });
+        // The menu trigger's press lift sits over the bar-glass trigger (its base), like every glass button.
+        if (runtime.liftAttached)
+            installs.push({
+                type: 'layer-source',
+                revision: runtime.nextTransport(),
+                layerId: spec.id === 'right' ? 'menu-lift' : 'chrome-lift',
+                setup: {
+                    ...setup,
+                    ...(spec.id === 'right'
+                        ? {
+                            spec: runtime.barTrigger(runtime.closedMenuSpec() ?? listed, 1),
+                            trigger: undefined,
+                        }
+                        : { spec }),
+                    liftOverlay: true,
+                    lift: {
+                        amount: 0,
+                        source: spec.id === 'dock' ? 'composed' : 'transmissive',
+                        optics: new TabMotion().optics(),
+                    },
+                },
+            });
+        runtime.specs.set(spec.id, spec);
+        // The trigger is bar glass: the same material and path as the back button (native
+        // toolbar buttons share one material). It rests at the CLOSED menu geometry whatever
+        // the menu's current state, and fades over the menu surface as the morph takes over.
+        if (spec.id === 'right') {
+            runtime.regionIds.set('region:bar-trigger', 'bar-trigger');
+            const restingTrigger = () => runtime.barTrigger(runtime.closedMenuSpec() ?? listed, runtime.menuResting() ? 1 : 0);
+            installs.push({
+                type: 'layer-source',
+                revision: runtime.nextTransport(),
+                layerId: 'chrome',
+                regionId: 'bar-trigger',
+                setup: {
+                    ...setup,
+                    spec: barTrack ? sampleRegion(barTrack, now) : restingTrigger(),
+                    trigger: undefined,
+                },
+            });
+        }
+    }
+    return installs;
+}
+/** Follow every committed plane's scroll (a GPU offset, never a recapture) and its size. */
+export function syncPlaneScrolls(runtime, planes, scroller) {
+    runtime.scrollerPlane = planes.find(plane => plane.host === scroller)?.id;
+    for (const [host, listener] of runtime.planeScrolls)
+        if (!planes.some(plane => plane.host === host)) {
+            host.removeEventListener('scroll', listener);
+            runtime.resize?.unobserve(host);
+            runtime.planeScrolls.delete(host);
+        }
+    for (const plane of planes) {
+        if (plane.host === scroller || runtime.planeScrolls.has(plane.host))
+            continue;
+        const host = plane.host;
+        const id = plane.id;
+        const listener = () => {
+            runtime.followWindow(id, host);
+            runtime.fire({ type: 'backdrop-scroll', id, x: host.scrollLeft, y: host.scrollTop });
+        };
+        host.addEventListener('scroll', listener, { passive: true });
+        runtime.resize?.observe(host);
+        runtime.planeScrolls.set(host, listener);
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { NavigationGlassState } from '../../navigation/glassTransition.js';
+import type { ProductionGlassRuntime } from './production.js';
+/** Navigation glass: while a navigator transition runs, the dock samples an atlas of every
+ * route in the transition, posed by the transition's track. Serialized with source preparation. */
+export declare function prepareNavigation(runtime: ProductionGlassRuntime, state: NavigationGlassState): Promise<void>;

package/dist/glass/webgpu/productionNavigation.js

@@ -0,0 +1,360 @@
+import { observeAnimations } from '../../motion/animate.js';
+import { windowCoversScrollport } from '../captureWindow.js';
+import { bandsCover } from './captureBands.js';
+import { captureProductionGlyphs, measureProductionSource, productionSourceKey, rasterNavigationAtlas, } from './capture.js';
+import { navigationTrack } from './navigationTracks.js';
+import { zoomGlassMotion } from '../../navigation/zoomGlass.js';
+import { textKey } from './productionPlanes.js';
+import { prepareInitialNavigationSource } from './productionPrepare.js';
+import { glassNow, glassTiming } from './profile.js';
+/** Navigation glass: while a navigator transition runs, the dock samples an atlas of every
+ * route in the transition, posed by the transition's track. Serialized with source preparation. */
+export async function prepareNavigation(runtime, state) {
+    runtime.navigationRelease?.();
+    const release = state.active ? runtime.appRegions.holdNavigation() : undefined;
+    runtime.navigationRelease = release;
+    if (state.active) {
+        runtime.preparedSignature = '';
+        runtime.menuCancel();
+        runtime.pointer = false;
+        runtime.tabInput('reset', runtime.options.geometry.tabBarSelectedIndex ?? 0, true);
+    }
+    runtime.navigationRoutes = state.active ? state.routes : [];
+    runtime.scheduleEdges();
+    runtime.navigationActive = state.active;
+    const revision = ++runtime.navigationRevision;
+    if (!state.active) {
+        runtime.navigationObserver?.disconnect();
+        runtime.navigationAnimations?.();
+        if (runtime.navigationInput)
+            document.removeEventListener('scroll', runtime.navigationInput, true);
+        runtime.navigationInput = undefined;
+        cancelAnimationFrame(runtime.navigationFrame);
+        runtime.schedulePrepare();
+        return;
+    }
+    if (state.routes.length < 2) {
+        release?.();
+        return;
+    }
+    const routes = state.routes;
+    if (routes.length > 8) {
+        release?.();
+        runtime.navigationRelease = undefined;
+        throw Error('Navigation composite exceeds the supported 8 simultaneous route sources');
+    }
+    const current = () => revision === runtime.navigationRevision && runtime.attached && runtime.navigationActive;
+    const queued = glassNow();
+    // Serialized with source preparation; failures of superseded navigations are not errors.
+    const run = async () => {
+        try {
+            await installNavigationAtlas(runtime, routes, revision, current, queued, state.zoom);
+        }
+        catch (error) {
+            if (current())
+                throw error;
+        }
+        finally {
+            release?.();
+        }
+    };
+    runtime.serial = runtime.serial.then(run, run);
+    return runtime.serial;
+}
+async function installNavigationAtlas(runtime, routes, revision, current, queued, zoom = false, fullCoverage = false) {
+    if (!current())
+        return;
+    const started = glassNow();
+    const geometry = runtime.options.geometry;
+    const appearance = runtime.options.appearance;
+    const resolution = devicePixelRatio;
+    glassTiming('navigation-queue', queued);
+    // A stack without a dock has no navigation atlas consumer: nothing is measured or composed.
+    const spec = runtime.specs.get('dock');
+    const regions = runtime.appRegions.needsBackdrop;
+    if (!spec && !regions)
+        return;
+    if (regions && !runtime.contentPlane) {
+        await prepareInitialNavigationSource(runtime, current);
+        if (!current())
+            return;
+        if (!runtime.contentPlane)
+            throw Error('Navigation glass regions have no installed content plane');
+    }
+    const dark = appearance === 'dark';
+    const cellWidth = Math.round(geometry.width * resolution);
+    const atlasWidth = Math.round(geometry.width * resolution * routes.length);
+    const atlasHeight = Math.round(geometry.height * resolution);
+    // Routes whose capture is resident in the worker (the installed content plane, or a route
+    // retained when a push covered it) are copied into the atlas on the GPU: no measurement,
+    // raster, bitmap or upload on this thread in the frames that start the motion. Only a route
+    // never captured (the destination of a push) is rasterized, into its own cell.
+    const captureRows = spec || zoom || fullCoverage
+        ? { top: 0, height: geometry.height }
+        : runtime.appRegions.navigationCaptureRows(geometry.height);
+    const text = textKey();
+    const resident = routes.map(route => residentRouteCapture(runtime, route, appearance, text, resolution));
+    const missing = routes.flatMap((_, i) => (resident[i] ? [] : [i]));
+    const measured = await Promise.all(missing.map(i => measureProductionSource(routes[i].source, true)));
+    glassTiming('navigation-measure', started, () => `${missing.length}/${routes.length}`);
+    if (!current())
+        return;
+    const scrolls = routes.map(route => route.source.scrollTop);
+    const signature = JSON.stringify([
+        captureRows,
+        routeSetSignature(resident, measured, missing, scrolls, geometry, resolution, dark),
+    ]);
+    // A republished, unchanged route set keeps its installed atlas (no raster, copy or upload).
+    const reuse = runtime.installedNavigation?.signature === signature
+        ? runtime.installedNavigation.key
+        : undefined;
+    const key = reuse ?? `navigation:${++runtime.navigationCapture}`;
+    const atlasStarted = glassNow();
+    const cells = [];
+    if (!reuse)
+        for (const i of routes.keys()) {
+            const entry = resident[i];
+            if (entry) {
+                cells.push(residentAtlasCell(entry, i, cellWidth, atlasHeight, scrolls[i], resolution));
+            }
+            else {
+                // A fresh canvas per rastered route, handed over with transferToImageBitmap (an ownership
+                // transfer). Re-rastering one shared canvas while an earlier snapshot of it was still
+                // referenced made the GPU process copy the whole backing store (CoreGraphics copy-on-write,
+                // CA::CG::AccelDataProvider::detach): 56-59 ms that held the first frames of a back swipe
+                // taking over a push, whose atlas rasters both routes (Catalyst Time Profiler, Oct 4).
+                const transferable = typeof OffscreenCanvas !== 'undefined';
+                const target = transferable ? new OffscreenCanvas(1, 1) : runtime.atlasCanvas;
+                const canvas = await rasterNavigationAtlas(target, [{ measured: measured[missing.indexOf(i)], scrollTop: scrolls[i] }], geometry.width, captureRows.height, resolution, dark, captureRows.top);
+                const position = { dx: i * cellWidth, dy: Math.round(captureRows.top * resolution) };
+                if (canvas instanceof OffscreenCanvas)
+                    cells.push({ image: canvas.transferToImageBitmap(), ...position });
+                else
+                    cells.push({ image: await createImageBitmap(canvas), ...position });
+                if (!current()) {
+                    closeCellImages(cells);
+                    return;
+                }
+            }
+        }
+    glassTiming('navigation-atlas', atlasStarted, () => reuse ? 'reused' : `${cells.filter(cell => 'plane' in cell).length} gpu`);
+    // Chrome glyphs: the installed dock ink when it is still current, captured only otherwise.
+    const glyphsStarted = glassNow();
+    let glyphKey = runtime.glyphs.get('dock')?.key;
+    const images = [];
+    if (spec && !glyphKey) {
+        const glyphCanvas = await captureProductionGlyphs(runtime.options.elements.chrome.dock, spec, resolution, runtime.atlasGlyphs);
+        glyphKey = `navigation-glyphs:${++runtime.navigationGlyphs}`;
+        images.push({
+            slot: 'navigation-glyphs',
+            key: glyphKey,
+            image: await createImageBitmap(glyphCanvas),
+        });
+    }
+    glassTiming('navigation-glyphs', glyphsStarted, images.length ? 'captured' : 'installed');
+    if (!current()) {
+        closeCellImages(cells);
+        for (const entry of images)
+            entry.image.close();
+        return;
+    }
+    const coversCurrentDemand = () => {
+        const demand = runtime.appRegions.navigationCaptureRows(geometry.height);
+        return bandsCover([{ top: captureRows.top, bottom: captureRows.top + captureRows.height }], [{ top: demand.top, bottom: demand.top + demand.height }], resolution);
+    };
+    // Registration and canvas geometry may change while pixels/glyphs are prepared.
+    // Retry once with the whole viewport so changing demand cannot keep recapturing bands.
+    if (regions && !coversCurrentDemand()) {
+        closeCellImages(cells);
+        for (const entry of images)
+            entry.image.close();
+        return installNavigationAtlas(runtime, routes, revision, current, queued, zoom, true);
+    }
+    runtime.installedNavigation = { signature, key };
+    const sent = [];
+    if (images.length)
+        sent.push(runtime.post({ type: 'source-images', revision: runtime.nextTransport(), images }, images.map(entry => entry.image)));
+    if (!reuse)
+        sent.push(runtime.post({
+            type: 'navigation-atlas',
+            revision: runtime.nextTransport(),
+            key,
+            width: atlasWidth,
+            height: atlasHeight,
+            background: dark ? [0, 0, 0, 1] : [242 / 255, 242 / 255, 247 / 255, 1],
+            cells,
+        }, cells.flatMap(cell => ('image' in cell ? [cell.image] : []))));
+    // No completion fence: the track below starts the worker's frame loop, whose first frame
+    // presents this install together with the other chrome surfaces.
+    if (spec)
+        sent.push(runtime.post({
+            type: 'source',
+            revision: runtime.nextTransport(),
+            settle: false,
+            setup: {
+                spec,
+                appearance,
+                navigationAtlas: routes.length,
+                navigationCoverage: {
+                    width: geometry.width,
+                    height: geometry.height,
+                    rows: [{ top: captureRows.top, bottom: captureRows.top + captureRows.height }],
+                },
+                sourceKey: key,
+                contentLayer: runtime.contentPlane,
+                glyphKey,
+                width: geometry.width,
+                height: geometry.height,
+                resolution,
+            },
+            sentAt: performance.timeOrigin + performance.now(),
+        }));
+    try {
+        await Promise.all(sent);
+    }
+    catch (error) {
+        runtime.installedNavigation = undefined;
+        throw error;
+    }
+    if (!current())
+        return;
+    if (regions && !coversCurrentDemand())
+        return installNavigationAtlas(runtime, routes, revision, current, queued, zoom, true);
+    glassTiming('navigation-prepared', started);
+    // Paused tracks have their real entrance pose. Install that atlas and draw the current
+    // region scene before allowing the navigation owner to start its shared motion epoch.
+    const pose = navigationTrack(routes, performance.now()).poses[0];
+    await runtime.post({
+        type: 'navigation-pose',
+        key,
+        at: performance.timeOrigin + performance.now(),
+        pose,
+    });
+    const rows = [{ top: captureRows.top, bottom: captureRows.top + captureRows.height }];
+    if (regions) {
+        await runtime.post({
+            type: 'navigation-regions',
+            prepare: true,
+            rows,
+            key,
+            routes: routes.length,
+            contentLayer: runtime.contentPlane,
+            width: geometry.width,
+            height: geometry.height,
+        });
+        if (!current())
+            return;
+        runtime.navigationCoverage = { key, rows, width: geometry.width, height: geometry.height };
+        runtime.coverageInstalled();
+        await runtime.appRegions.admitNavigation(key);
+    }
+    if (!current())
+        return;
+    followNavigationMotion(runtime, routes, revision, key, zoom);
+}
+/** A resident capture is used only while it matches the page: same appearance, text size and
+ * resolution, same layout width, and no DOM damage inside it since it was captured. */
+function residentRouteCapture(runtime, route, appearance, text, resolution) {
+    const id = runtime.planeIds.get(route.source);
+    if (!id || !route.source.isConnected)
+        return undefined;
+    const installed = runtime.planes.get(id);
+    const installedCurrent = installed &&
+        !runtime.damaged.has(id) &&
+        installed.appearance === appearance &&
+        installed.text === text;
+    const entry = installed
+        ? installedCurrent
+            ? installed
+            : undefined
+        : runtime.resident.usable(id, appearance, text);
+    // A banded capture holds only the rows its glass sampled: a route cell needs every row.
+    const matchesLayout = entry &&
+        !entry.bands &&
+        entry.resolution === resolution &&
+        Math.abs(route.source.offsetWidth - entry.width) <= 1 &&
+        (!entry.window ||
+            windowCoversScrollport(entry.window, route.source.scrollTop, route.source.clientHeight, route.source.scrollHeight));
+    return matchesLayout ? entry : undefined;
+}
+/** Everything the atlas shows: each route's capture identity, origin and scroll, and the viewport. */
+function routeSetSignature(resident, measured, missing, scrolls, geometry, resolution, dark) {
+    return JSON.stringify([
+        resident.map((entry, i) => [
+            entry
+                ? entry.key
+                : productionSourceKey(measured[missing.indexOf(i)], geometry.width, geometry.height, resolution, dark),
+            entry?.origin,
+            scrolls[i],
+        ]),
+        geometry.width,
+        geometry.height,
+        resolution,
+        dark,
+    ]);
+}
+/** The GPU copy of a resident route's capture into its atlas cell (device px). */
+function residentAtlasCell(entry, index, cellWidth, atlasHeight, scrollTop, resolution) {
+    const top = Math.max(0, entry.origin.y);
+    const dy = Math.round(top * resolution);
+    const dx = index * cellWidth + Math.max(0, Math.round(entry.origin.x * resolution));
+    return {
+        plane: `${entry.key}:front`,
+        dx,
+        dy,
+        sx: 0,
+        sy: Math.max(0, Math.round((scrollTop + top - entry.origin.y) * resolution)),
+        w: Math.min(cellWidth, Math.round(entry.width * resolution)),
+        h: atlasHeight - dy,
+    };
+}
+function closeCellImages(cells) {
+    for (const cell of cells)
+        if ('image' in cell)
+            cell.image.close();
+}
+/** Post the transition's track (or its single pose) to the worker, again on every scroll and route
+ * style change, and on the next frame while a route animation is still pending. */
+function followNavigationMotion(runtime, routes, revision, key, zoom = false) {
+    const submit = () => {
+        if (revision !== runtime.navigationRevision || !runtime.attached)
+            return;
+        // Zoom cleanup precedes Navigator's settled DOM commit. In that gap the entering
+        // route has the slide's parked translateX(100%) again. Keep the accepted zoom track
+        // through its endpoint instead of publishing that unrelated pose over the atlas.
+        if (zoom &&
+            !routes.some(route => zoomGlassMotion(route.motion) || zoomGlassMotion(route.screen)))
+            return;
+        try {
+            const track = navigationTrack(routes, performance.now());
+            if (track.duration <= 1)
+                runtime.fire({ type: 'navigation-pose', key, at: track.epoch, pose: track.poses[0] });
+            else
+                runtime.fire({ type: 'navigation-track', key, track });
+            const animationPending = routes.some(route => [...route.screen.getAnimations(), ...route.motion.getAnimations()].some(animation => animation.pending));
+            if (animationPending && !runtime.navigationFrame)
+                runtime.navigationFrame = requestAnimationFrame(() => {
+                    runtime.navigationFrame = 0;
+                    submit();
+                });
+        }
+        catch (error) {
+            runtime.fail('navigation timing', error);
+        }
+    };
+    if (runtime.navigationInput)
+        document.removeEventListener('scroll', runtime.navigationInput, true);
+    runtime.navigationInput = submit;
+    document.addEventListener('scroll', submit, { capture: true, passive: true });
+    runtime.navigationObserver?.disconnect();
+    runtime.navigationObserver = new MutationObserver(submit);
+    runtime.navigationAnimations?.();
+    const observers = routes
+        .flatMap(route => [route.screen, route.motion, route.dim])
+        .map(element => observeAnimations(element, () => queueMicrotask(submit)));
+    runtime.navigationAnimations = () => observers.forEach(stop => stop());
+    for (const route of routes)
+        for (const element of [route.screen, route.motion, route.dim])
+            runtime.navigationObserver.observe(element, { attributes: true, attributeFilter: ['style'] });
+    submit();
+}