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

package/dist/glass/webgpu/cadence.js

@@ -0,0 +1,35 @@
+/** Follow every 60 Hz page frame, or alternate frames on a 120 Hz page.
+ * The threshold sits between those cadences so normal timestamp jitter cannot
+ * turn a 60 Hz frame into a glass hold. Sampling still uses the exact page time. */
+export class ShapeCadence {
+    admittedAt;
+    admit(at) {
+        const minimumInterval = (1000 / 60) * 0.75;
+        if (!Number.isFinite(at))
+            return false;
+        if (this.admittedAt !== undefined && at - this.admittedAt < minimumInterval)
+            return false;
+        this.admittedAt = at;
+        return true;
+    }
+}
+/** Samples are the actual normalized compositor keyframe values, not pose messages.
+ * Interpolation matches a linear WAAPI keyframe sequence with evenly spaced offsets. */
+export function evaluateTrack(track, at) {
+    const t = Math.max(0, Math.min(1, (at - track.epoch) / Math.max(0.001, track.duration)));
+    let progress = t;
+    if (track.samples) {
+        const index = t * (track.samples.length - 1), lo = Math.floor(index), hi = Math.min(lo + 1, track.samples.length - 1);
+        progress = track.samples[lo] + (track.samples[hi] - track.samples[lo]) * (index - lo);
+    }
+    return track.from + (track.to - track.from) * progress;
+}
+export function validateTrack(track) {
+    if (![track.epoch, track.duration, track.from, track.to].every(Number.isFinite) ||
+        track.duration <= 0 ||
+        (track.samples &&
+            (track.samples.length < 2 ||
+                track.samples.length > 4096 ||
+                !track.samples.every(Number.isFinite))))
+        throw Error('Invalid glass timeline');
+}

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

@@ -0,0 +1,6 @@
+export declare function trackCanvasWrite(encoder: GPUCommandEncoder, canvas: object, pixels: number): void;
+export declare function submitCanvasCommands(device: GPUDevice, encoder: GPUCommandEncoder, commands: GPUCommandBuffer): void;
+export declare const canvasSubmissionCosts: () => {
+    submittedPixels: number;
+    submittedCommandBuffers: number;
+};

package/dist/glass/webgpu/canvasSubmission.js

@@ -0,0 +1,22 @@
+/** Full drawable attachment area in queue-accepted command buffers. This is not
+ * compositor scanout: screen cadence is measured independently by the recorder. */
+const pending = new WeakMap();
+const totals = { submittedPixels: 0, submittedCommandBuffers: 0 };
+export function trackCanvasWrite(encoder, canvas, pixels) {
+    let canvases = pending.get(encoder);
+    if (!canvases) {
+        canvases = new Map();
+        pending.set(encoder, canvases);
+    }
+    canvases.set(canvas, pixels);
+}
+export function submitCanvasCommands(device, encoder, commands) {
+    device.queue.submit([commands]);
+    const canvases = pending.get(encoder);
+    pending.delete(encoder);
+    if (!canvases?.size)
+        return;
+    totals.submittedPixels += [...canvases.values()].reduce((sum, pixels) => sum + pixels, 0);
+    totals.submittedCommandBuffers++;
+}
+export const canvasSubmissionCosts = () => ({ ...totals });

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

@@ -0,0 +1,77 @@
+import { type KeyboardBackdropAnchor } from './keyboardBackdrop.js';
+import { type SearchBackdropAnchor } from '../../search/searchBackdrop.js';
+import type { GlassCanvas } from '../rendererContract.js';
+import { type MirrorLayout, type MirrorNode, type MirrorCaptureRange } from '../lens/Scene.js';
+import type { SurfaceRenderSpec } from '../renderSpecs.js';
+/** `top`/`left`: viewport origin of the measured host. The capture is in viewport space,
+ * so a split layout's content column (right of the sidebar) draws at its own origin. */
+export type MeasuredSource = {
+    layout: MirrorLayout;
+    top: number;
+    left: number;
+    searchAnchor?: SearchBackdropAnchor;
+    keyboardAnchor?: KeyboardBackdropAnchor;
+};
+/** A compositor transform may advance between synchronous DOM reads. Reject that
+ * snapshot and retry at a bounded frame boundary before anything is rasterized. */
+export declare function measureProductionSource(host: HTMLElement, moving?: boolean, capture?: 'viewport' | 'plane', captureRange?: MirrorCaptureRange, 
+/** Return the previous measurement when nothing it read has changed (mirrorReuse.ts). */
+reuse?: boolean, 
+/** Wait only for motion that moves `host` itself (a capture that glass is waiting for). */
+ownMotionOnly?: boolean): Promise<MeasuredSource>;
+/** Every input of `rasterProductionSource`. Equal keys produce identical pixels. */
+export declare function productionSourceKey({ layout, top, left }: MeasuredSource, width: number, height: number, resolution: number, dark: boolean): string;
+export declare const productionSourceHeight: ({ layout, top }: MeasuredSource, height: number) => number;
+type ImageKey = string | Promise<HTMLImageElement | undefined>;
+type NodeClips = NonNullable<MirrorNode['clips']>;
+/** Whether two nodes are clipped by the same ancestor clips, in the same order. */
+export declare function sameClipChain(first: NodeClips, second: NodeClips): boolean;
+/** WebKit's accelerated 2D canvas can silently draw nothing for a large photo under memory
+ * pressure (measured: a 1320x5700 photo into a 1320x4800 capture left the page fill; 6-10 of
+ * 10-12 loaded harness arrivals, 0 of 12 idle). The capture key cannot see that, so the glass
+ * over it stayed flat until an unrelated recapture.
+ *
+ * A photo counts as missing only when the capture shows the fill where the photo's OWN pixel
+ * (sampled off-screen from the decoded image) is opaque and clearly different from the fill, at
+ * points no later node paints over. A photo that matches the fill there (a white product shot on
+ * a white page, a transparent PNG, a logo) cannot be judged and counts as drawn. A missing photo
+ * redraws the whole composition in its original order (a frame apart); one still missing after
+ * that marks the capture incomplete, and the caller recaptures it. */
+export type PhotoProbe = {
+    url: ImageKey;
+    node: number;
+    px: number;
+    py: number;
+    ix: number;
+    iy: number;
+};
+/** Up to three probe points per photo (device pixels in the capture, source pixels in the image). */
+export declare function photoProbes(measured: MeasuredSource, natural: (url: ImageKey) => readonly [number, number] | undefined, resolution: number, canvasWidth: number, canvasHeight: number): PhotoProbe[];
+/** A photo is missing when every usable probe shows the fill; a probe is usable when the
+ * image's own pixel there is opaque and clearly not the fill. No usable probe: drawn. */
+export declare function photoMissing(samples: readonly {
+    canvas: ArrayLike<number>;
+    image: ArrayLike<number>;
+}[], fill: ArrayLike<number>): boolean;
+/** Pixel readers (tests replace them). Image pixels come from a cached CPU canvas. */
+export declare const captureReaders: {
+    fill(fill: string): number[];
+    image(image: HTMLImageElement, ix: number, iy: number): ArrayLike<number>;
+    canvas(ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, px: number, py: number): ArrayLike<number>;
+    frame: () => Promise<void>;
+};
+/** The last raster into `canvas` is missing a photo (see photoMissing). */
+export declare const captureIncomplete: (canvas: HTMLCanvasElement) => boolean;
+/** Same measured scene-node contract as reference; raster ownership is Canvas2D.
+ * Draws into `canvas` (reused across revisions); the whole bitmap is overwritten. */
+export declare function rasterProductionSource(canvas: HTMLCanvasElement, measured: MeasuredSource, width: number, height: number, resolution: number, dark: boolean, fill?: string): Promise<HTMLCanvasElement>;
+/** Navigation composite: each route's visible viewport, side by side. Draws only
+ * the viewport rows of each route (never its full scroll height) directly into its cell. */
+export declare function rasterNavigationAtlas(atlas: GlassCanvas, routes: readonly {
+    measured: MeasuredSource;
+    scrollTop: number;
+}[], width: number, height: number, resolution: number, dark: boolean, viewportTop?: number): Promise<GlassCanvas>;
+/** One-shot capture into a new canvas. Production reuses canvases through `rasterProductionSource`. */
+export declare function captureProductionSource(host: HTMLElement, width: number, height: number, resolution: number, dark: boolean, canvas?: HTMLCanvasElement): Promise<HTMLCanvasElement>;
+export declare function captureProductionGlyphs(dock: HTMLElement, spec: SurfaceRenderSpec, resolution: number, canvas?: HTMLCanvasElement): Promise<HTMLCanvasElement>;
+export {};