peachsim 0.1.1641 → 0.1.1653

package/dist-types/packages/peach-engine/src/engine/host-composite.d.ts

@@ -0,0 +1,100 @@
+import type { HostNative, PaintBoundaryState } from './paint-boundary-types.d.ts';
+export declare const HOST_FLATTEN_BOUNDS_CREATE = 0;
+export declare const HOST_FLATTEN_BOUNDS_ADD = 1;
+export declare const HOST_FLATTEN_BOUNDS_READ = 2;
+export declare const HOST_FLATTEN_BOUNDS_DISPOSE = 3;
+export declare const HOST_PICTURE = 1;
+export declare const HOST_LAYER = 2;
+export declare const HOST_LIVE = 3;
+export declare const HOST_RASTER_CACHEABLE = 1;
+export declare const HOST_TEXTURE_CACHEABLE = 2;
+export declare const HOST_IN_X = 0;
+export declare const HOST_IN_Y = 1;
+export declare const HOST_IN_W = 2;
+export declare const HOST_IN_H = 3;
+export declare const HOST_IN_DPR = 4;
+export declare const HOST_IN_FRAME_MS = 5;
+export declare const HOST_IN_FLAGS = 6;
+export declare const HOST_IN_SLOT = 7;
+export declare const HOST_IN_DAMAGE = 8;
+export declare const HOST_REBUILD = 1;
+export declare const HOST_LINEAR_CHANGED = 2;
+export declare const HOST_ANIMATED = 4;
+export declare const HOST_TRANSFORM = 8;
+export declare const HOST_PRESENTATION = 16;
+export declare const HOST_TRANSLUCENT = 32;
+export declare const HOST_REPAINT_BOUNDARY = 64;
+export declare const HOST_FLAT_BAKE = 128;
+export declare const HOST_FLAT_ANCESTOR = 256;
+export declare const HOST_CLIP = 512;
+export declare const HOST_NO_BLIT = 1024;
+export declare const HOST_MOTION_ENDED = 2048;
+export declare const HOST_REPLAY = 4096;
+export declare const HOST_DAMAGE = 8192;
+export declare const HOST_PROFILE = 16384;
+export declare const HOST_DEBUG = 32768;
+export declare const HOST_REALIZE = 65536;
+export declare const HOST_PUBLISHED = 1;
+export declare const HOST_CONTINUE = 2;
+export declare const HOST_FLATTEN_INSPECT_PRE = 1;
+export declare const HOST_FLATTEN_INSPECT_POST = 2;
+export declare const HOST_FLATTEN_INSPECT_VALIDATE = 3;
+export declare const HOST_FLATTEN_COUNT_REJECT = 9;
+export declare const HOST_EVENT_ACTIONS: readonly ['promotion', 'release', 'reject', 'warming', 'blit', 'failure', 'picture-replay'];
+export declare const HOST_TEXTURE_REASONS: readonly [undefined, 'not-requested', 'rebuild', 'chunks', 'work', 'bounds', 'dimensions', 'pixels', 'budget', 'promotion', 'blit'];
+export declare const HOST_RASTER_REASONS: readonly [undefined, undefined, 'rasterRejectRebuild', undefined, undefined, undefined, 'dimensions', 'pixels', 'budget', 'promotion', 'blit', 'rasterRejectLinear', 'rasterRejectAnimated', 'rasterRejectTransform', 'rasterRejectOpacity', 'cacheable-or-bounds', 'warming-or-failure'];
+export declare const HOST_PHASE_PREWARM = 17;
+export declare const HOST_PHASE_PAINT = 18;
+export declare const HOST_PROFILE_COUNTERS: readonly ['rasterRejectRebuild', 'rasterRejectLinear', 'rasterRejectAnimated', 'rasterRejectTransform', 'rasterRejectOpacity', 'rasterRejectAlsoBlocked', 'rasterRejectCacheable', 'rasterRejectBounds', 'rasterRejectPixels', 'rasterRejectBudget', 'rasterWarming', 'rasterPromotions', 'rasterBlits', 'boundaryPictureDamageSkips', 'textureLayerRejectRebuild', 'textureLayerRejectChunks', 'textureLayerRejectWork', 'textureLayerRejectBounds', 'textureLayerRejectPixels', 'textureLayerRejectBudget', 'textureLayerWarming', 'textureLayerDeferred', 'textureLayerPromotions', 'textureLayerPromotionFailures', 'textureLayerBlits', 'textureLayerFlattenPromotions', 'textureLayerFlattenBlits', 'textureLayerFlattenReleaseParamChange', 'textureLayerFlattenReleaseContentChange', 'rasterPromotionMs', 'rasterBlitMs', 'textureLayerPromotionMs', 'textureLayerBlitMs'];
+export declare const HOST_REALIZE_CHUNK_REPLAYS: 33;
+export declare const HOST_REALIZE_PROMOTIONS: number;
+export declare const HOST_REALIZE_RASTER_BLITS: number;
+export declare const SHADOW_MOTION_MASK_SIGMA = 8;
+export declare const SHADOW_MOTION_HOLD_MS = 80;
+export declare function hostNative(module: object): HostNative;
+export declare function hostInput(native: HostNative): Float64Array;
+export declare function hostCounters(native: HostNative): Float64Array;
+export declare function publishHostChunks(state: PaintBoundaryState, native: HostNative): void;
+export interface HostTexture {
+    width: number;
+    height: number;
+    dpr: number;
+}
+export declare function hostTexture(state: PaintBoundaryState): HostTexture | null;
+export declare function hostLedger(module: object): {
+    rasterImages: number;
+    rasterBytes: number;
+    textureLayerFlattenBytes: number;
+    textBackingImages: number;
+    textBackingBytes: number;
+    textBackingCreates: number;
+    textBackingReleases: number;
+};
+export declare const HOST_COMPOSITE_MATCHES = 1;
+export declare const HOST_COMPOSITE_LINEAR_CHANGED = 2;
+export declare const HOST_COMPOSITE_SCROLL_MATCHES = 4;
+export declare const HOST_SETTLE_PREVIOUS = 8;
+export declare const HOST_SETTLE_REBUILD = 1;
+export declare const HOST_SETTLE_CAPTURE = 2;
+export declare const HOST_SETTLE_DAMAGE_CLIP = 4;
+export declare const HOST_SETTLE_TRACE = 8;
+interface Box {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export interface CompositeInput {
+    matrix: ArrayLike<number>;
+    opacity: number;
+    scrollX: number;
+    scrollY: number;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    clip: Box | null;
+    outsets: Box;
+}
+export declare function settleComposite(state: PaintBoundaryState, native: HostNative, slot: number, flags: number, composite: CompositeInput, dpr: number, surfaceWidth: number, surfaceHeight: number, damageId: number): number;
+export {};

package/dist-types/packages/peach-engine/src/engine/hosted-semantics.d.ts

@@ -0,0 +1,49 @@
+import { type SootSimNode } from './node.d.ts';
+import type { InspectInfo } from './inspect-info.d.ts';
+export interface HostedSemanticsNode {
+    id: number;
+    parent: number | null;
+    className: string;
+    role: string | null;
+    text: string | null;
+    contentDescription: string | null;
+    testTag: string | null;
+    clickable: boolean;
+    focusable: boolean;
+    focused: boolean;
+    enabled: boolean;
+    checked: boolean | null;
+    selected: boolean;
+    visible: boolean;
+    bounds: readonly [number, number, number, number];
+}
+export interface HostedSemantics {
+    generation: number;
+    density: number;
+    nodes(): readonly HostedSemanticsNode[];
+}
+export declare function hostedLeafId(handle: number): number | null;
+export declare function setHostedSemantics(leaf: SootSimNode, provider: HostedSemantics | null): void;
+export declare function focusedHostedField(leaf: SootSimNode, provider: HostedSemantics): {
+    nodeId: number;
+    node: HostedSemanticsNode;
+    generation: number;
+} | null;
+export declare function isHostedNodeId(nodeId: number): boolean;
+export interface HostedRow {
+    node: HostedSemanticsNode;
+    info: InspectInfo;
+}
+export declare function hostedRows(leaf: SootSimNode, leafInfo: {
+    nodeId: number;
+    type: string;
+    visibleFrame: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}, space: {
+    ignorePresentationLayerTransforms: boolean;
+}): HostedRow[];
+export declare function isHostedRowShown(row: InspectInfo): boolean;

package/dist-types/packages/peach-engine/src/engine/image-audit.d.ts

@@ -0,0 +1,70 @@
+import type { SootSimNode } from './node.d.ts';
+export declare const IMAGE_AUDIT: {
+    active: boolean;
+};
+export interface ImageAuditRow {
+    nodeId: number;
+    type: string;
+    testID: string | null;
+    sourceUri: string | null;
+    cacheKey: string | null;
+    resizeMode: string | null;
+    sampling: string | null;
+    vector: boolean;
+    intrinsic: {
+        width: number;
+        height: number;
+    } | null;
+    decoded: {
+        width: number;
+        height: number;
+    };
+    sampled: {
+        width: number;
+        height: number;
+    };
+    destination: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    decision: {
+        gpuBacked: boolean;
+        hasMipmaps: boolean;
+    };
+    deviceScale: number;
+    dpr: number;
+    needed: {
+        width: number;
+        height: number;
+    };
+    effective: {
+        width: number;
+        height: number;
+    };
+    ceiling: {
+        width: number;
+        height: number;
+    } | null;
+    shortfall: number | null;
+}
+declare const _samplingCounts: {
+    mipmapped: number;
+    cubic: number;
+    linear: number;
+    nearest: number;
+    repeat: number;
+    exact: number;
+    none: number;
+};
+export declare function setImageAuditActive(active: boolean): void;
+export declare function clearImageAudit(): void;
+export declare function readImageAudit(): {
+    active: boolean;
+    draws: number;
+    samplingCounts: typeof _samplingCounts;
+    rows: ImageAuditRow[];
+};
+export declare function recordImageDraw(node: SootSimNode, src: ArrayLike<number>, dst: ArrayLike<number>, deviceScale: number, dpr: number, sampling: string | null, decision: ImageAuditRow['decision']): void;
+export {};

package/dist-types/packages/peach-engine/src/engine/image-loader.d.ts

@@ -0,0 +1,350 @@
+import { type MetroAssetPathRecord } from '../metro-asset-path.d.ts';
+import { type ImageFrameSource } from '../render-worker/image-pixel-contract.d.ts';
+import type { ImageDownloadProgress, ImageLifecycleEvent } from '../render-worker/image-lifecycle-event.d.ts';
+import type { DecodedImagePixels, ImagePixelDecodeSize } from '../render-worker/image-pixel-contract.d.ts';
+import type { CanvasKitRenderingApi as CanvasKit } from './canvaskit-api.d.ts';
+import type { SootSimNode } from './node.d.ts';
+import type { RenderContext } from './types.d.ts';
+import type { Image as SkImage, Shader as SkShader, TileMode } from 'canvaskit-wasm';
+declare let _onImageLifecycleEvent: ((event: ImageLifecycleEvent) => void) | null;
+type CachedImageEntry = {
+    image: SkImage;
+    version: number;
+    mipmapped?: boolean;
+    decodedScale?: number;
+    imageTransforms?: Map<string, CachedImageTransform>;
+    imageTransformBytes?: number;
+    externalSourceKey?: string;
+    bridgeImage?: SkImage;
+    paintOwner?: object;
+    paintSerial?: number;
+    drawnBy?: WeakRef<SootSimNode>;
+    intrinsicWidth: number;
+    intrinsicHeight: number;
+    vector?: boolean;
+};
+interface CachedImageTransform {
+    images: readonly (SkImage | null)[];
+    pixelBytes: number;
+    repeatShaderUsers: Set<WeakRef<SootSimNode>>;
+}
+export interface LoadedStaticImageRequest {
+    cacheKey: string;
+    requestToken: number;
+    image: SkImage;
+    mipmapped: boolean;
+}
+export interface SharedDeviceImageBridgeStats {
+    readonly bitmapEntries: number;
+    readonly liveBitmapEntries: number;
+    readonly bitmapAllocations: number;
+    readonly bitmapCacheHits: number;
+    readonly bitmapUploadsHeld: number;
+    readonly bitmapUploadRequests: number;
+    readonly bitmapUploadBytes: number;
+    readonly staticPixelUploadRequests: number;
+    readonly staticPixelUploadBytes: number;
+    readonly bitmapRetireQueued: number;
+    readonly bitmapRetireDisposed: number;
+    readonly snapshotEntries: number;
+    readonly snapshotBytes: number;
+    readonly snapshotReleases: number;
+    readonly snapshotsFreed: number;
+    readonly snapshotHits: number;
+    readonly snapshotMisses: number;
+}
+export interface SharedDeviceImageBridge {
+    resolveBitmapImage(sourceKey: string, revision: number, bitmap: ImageFrameSource, width: number, height: number, holdUpload: boolean): SkImage | null;
+    decodeStaticPixels(bytes: Uint8Array, size: ImagePixelDecodeSize, signal?: AbortSignal): Promise<DecodedImagePixels>;
+    resolveStaticPixelsImage(sourceKey: string, decoded: DecodedImagePixels, discard: () => void): SkImage | null;
+    hasOpenTransaction(): boolean;
+    resolveSnapshotImage(appId: string): SkImage | null;
+    releaseSnapshotImage(appId: string): void;
+    trimSnapshotImages(keepFraction: number): string[];
+    releaseBitmapImage(sourceKey: string): void;
+    getStats(): SharedDeviceImageBridgeStats;
+    resetStats(): void;
+}
+interface ResolvedAssetSource {
+    __packager_asset?: boolean;
+    uri: string;
+    width: number;
+    height: number;
+    scale: number;
+}
+type CustomSourceTransformer = (resolver: {
+    asset: MetroAssetPathRecord | null;
+    defaultAsset: () => ResolvedAssetSource;
+    fromSource: (uri: string) => ResolvedAssetSource;
+}) => {
+    uri?: string;
+} | null | undefined;
+export interface InspectImageSource {
+    kind: 'uri' | 'metro-asset' | 'module-default';
+    assetId?: number;
+    uri?: string;
+    assetPath?: string;
+    assetFile?: string;
+    modulePath?: string;
+    width?: number;
+    height?: number;
+    scale?: number;
+}
+export declare function subscribeLiveFrames(listener: (channelId: string) => void): () => void;
+export declare function readLiveFrameSource(channelId: string): ImageFrameSource | null;
+export declare function getLiveFrameChannels(): string[];
+export declare function beginNativeImagePreparation(): () => void;
+export declare function getLiveFramePresentCount(): number;
+export declare function getImageLoaderStats(): {
+    cacheEntries: number;
+    cachePixelBytes: number;
+    onScreenPixelBytes: number;
+    offScreenPixelBytes: number;
+    fullPaints: number;
+    partialPaints: number;
+    cachePixelBudget: number;
+    cacheMaxEntries: number;
+    pendingFetches: number;
+    pendingBytes: number;
+    failedUris: number;
+    snapshots: number;
+    snapshotPerf: {
+        stored: number;
+        uploads: number;
+        uploadedBytes: number;
+        uploadMsTotal: number;
+        uploadMsMax: number;
+    };
+    liveFrames: number;
+    liveFramePresentation: {
+        activeChannels: number;
+        publishes: number;
+        backpressureSkips: number;
+        staleHeals: number;
+    };
+    liveFramePerf: {
+        stored: number;
+        uploads: number;
+        uploadedBytes: number;
+        uploadMsTotal: number;
+        uploadMsMax: number;
+    };
+    sharedDeviceImages: SharedDeviceImageBridgeStats | null;
+    lifecycle: {
+        canvasKitVersion: number;
+        memoryTrimGeneration: number;
+        drops: {
+            aborted: number;
+            canvasKitChanged: number;
+            memoryTrimmed: number;
+            svgRasterizationFailed: number;
+        };
+        routes: {
+            bitmap: number;
+            svgBytes: number;
+            svgUri: number;
+            staticExternalUpload: number;
+        };
+    };
+    staticImagePreparation: {
+        requests: {
+            endToEndRequest: {
+                count: number;
+                totalMs: number;
+                maxMs: number;
+            };
+            cacheHit: {
+                count: number;
+                totalMs: number;
+                maxMs: number;
+            };
+            inFlightWait: {
+                count: number;
+                totalMs: number;
+                maxMs: number;
+            };
+        };
+        phases: {
+            networkByteLoad: {
+                count: number;
+                totalMs: number;
+                maxMs: number;
+            };
+            localByteLoad: {
+                count: number;
+                totalMs: number;
+                maxMs: number;
+            };
+            createImageBitmap: {
+                count: number;
+                totalMs: number;
+                maxMs: number;
+            };
+            offscreenPixelReadback: {
+                count: number;
+                totalMs: number;
+                maxMs: number;
+            };
+            canvasKitMakeImage: {
+                count: number;
+                totalMs: number;
+                maxMs: number;
+            };
+            fallbackMakeImageFromEncoded: {
+                count: number;
+                totalMs: number;
+                maxMs: number;
+            };
+            defaultMipmaps: {
+                count: number;
+                totalMs: number;
+                maxMs: number;
+            };
+        };
+    };
+    decodeSizing: {
+        powerOfTwoBuckets: number;
+        granularBuckets: number;
+        maxDimensionClamps: number;
+        invalidRequests: number;
+    };
+};
+export type ImageLoaderStats = ReturnType<typeof getImageLoaderStats>;
+export declare function getLoadedImageCacheKey(node: SootSimNode): string | null;
+export declare function getLoadedStaticImageRequest(node: SootSimNode): LoadedStaticImageRequest | null;
+export declare function isLoadedStaticImageRequestCurrent(node: SootSimNode, request: LoadedStaticImageRequest): boolean;
+export declare function countCachedImageEntriesForKeys(keys: ReadonlySet<string>): number;
+export declare function resetBitmapUploadPerf(): void;
+export declare function trimImageCache(targetFraction?: number): void;
+export declare function beginImagePaint(surface: object, full: boolean): void;
+export declare function endImagePaint(): void;
+export declare function setImageLoaderRenderDpr(dpr: number): void;
+export declare function trimImageMemory(targetFraction?: number): string[];
+export declare function queryImageCache(uris: readonly string[]): Record<string, 'memory'>;
+export declare function abortImagePrefetch(requestId: number): boolean;
+export declare function notifyFileStorageChanged(): void;
+export declare function releaseSnapshotImage(appId: string): void;
+export declare function trimSnapshotImages(keepFraction: number): string[];
+export declare function storeSnapshotBitmap(appId: string, bitmap: ImageBitmap): void;
+export declare function getStoredSnapshotImage(appId: string, ctx?: RenderContext): SkImage | null;
+export declare function liveFrameUri(channelId: string): string;
+export declare function setLiveFrameSink(sink: ((channelId: string, bitmap: ImageFrameSource | null) => boolean) | null): void;
+export declare function setSharedDeviceImageBridge(bridge: SharedDeviceImageBridge | null): void;
+export declare function setLiveFrameUploadHold(hold: boolean): void;
+export declare function hasActiveLiveFrameChannels(): boolean;
+export declare function setLiveFrameAnimating(channelId: string, inputEpoch: number | null): void;
+export declare function listAnimatingLiveFrameMotions(): string[];
+export declare function requestLiveFrameRepaint(): void;
+export declare function setGpuSceneFramesHeld(held: boolean): void;
+export declare function shouldSkipLiveFramePublish(channelId: string): boolean;
+export declare function clearLiveFrameInflight(channelId: string): void;
+export declare function storeLiveFrame(channelId: string, bitmap: ImageFrameSource): void;
+export declare function clearLiveFrame(channelId: string): void;
+export declare function storeWebViewFrame(surfaceId: string, generation: number, instanceId: string, bitmap: ImageBitmap, contentSize: {
+    width: number;
+    height: number;
+}): void;
+export declare function clearWebViewFrame(surfaceId: string, generation: number, instanceId: string): void;
+export declare function getWebViewFrameImage(instanceId: string, ctx: RenderContext): {
+    image: SkImage;
+    width: number;
+    height: number;
+} | null;
+export declare function getCkVersion(): number;
+export declare function resolveNodeImageSource(props: Record<string, unknown> | null | undefined, size?: {
+    width: number;
+    height: number;
+}, scale?: number): unknown;
+export { resolveImageSourceHeaders } from '../render-worker/image-pixel-contract.d.ts';
+export declare function getImageSourceKey(uri: string, headers?: Record<string, string>): string;
+export declare function resolveMetroAssetUri(assetId: number): {
+    uri: string;
+    width: number;
+    height: number;
+    scale: number;
+} | null;
+export declare function resolveMetroAssetSourceById(assetId: number): {
+    __packager_asset: true;
+    uri: string;
+    width: number;
+    height: number;
+    scale: number;
+} | null;
+export declare function pickAssetScale(scales: number[] | undefined, devicePixelRatio?: number): number;
+export declare function setCustomAssetSourceTransformer(transformer: CustomSourceTransformer): void;
+export declare function addCustomAssetSourceTransformer(transformer: CustomSourceTransformer): void;
+declare function resolvePublicAssetSource(source: unknown): unknown;
+export declare const resolveAssetSource: typeof resolvePublicAssetSource & {
+    pickScale: typeof pickAssetScale;
+    setCustomSourceTransformer: typeof setCustomAssetSourceTransformer;
+    addCustomSourceTransformer: typeof addCustomAssetSourceTransformer;
+};
+export declare function resolveNamedMetroAssetUri(assetName: string): {
+    uri: string;
+    width: number;
+    height: number;
+    scale: number;
+} | null;
+export declare function describeImageSource(source: unknown): InspectImageSource | null;
+export declare function buildMetroAssetUrl(asset: MetroAssetPathRecord, filename?: string): string;
+export declare function initImageLoader(ck: CanvasKit, onImageLoaded: (uri: string | null, needsRender: boolean, node?: SootSimNode | null) => void, onLiveFrameConsumed?: (channelId: string) => void): void;
+export declare function setImageLifecycleEventSink(sink: typeof _onImageLifecycleEvent): void;
+export declare function getCachedImage(cacheKey: string): SkImage | null;
+export declare function getCachedImageEntry(cacheKey: string): CachedImageEntry | null;
+export declare function readImageNodeDecode(node: SootSimNode): {
+    cacheKey: string | null;
+    sourceUri: string | null;
+    decodedWidth: number;
+    decodedHeight: number;
+    intrinsicWidth: number | null;
+    intrinsicHeight: number | null;
+    decodedScale: number | null;
+    vector: boolean;
+} | null;
+export declare function getImageNodeDecodedScale(node: SootSimNode): number | null;
+export declare function getImageNodeTransform(node: SootSimNode, transformKey: string): readonly (SkImage | null)[] | null;
+export declare function storeImageNodeTransform(node: SootSimNode, transformKey: string, images: readonly (SkImage | null)[]): boolean;
+export declare function getImageNodeRepeatShaders(node: SootSimNode, transformKey: string, tileModes: readonly (readonly [TileMode, TileMode])[]): readonly (SkShader | null)[] | null;
+export declare function getImageSize(uri: string, headers?: Record<string, string>): Promise<{
+    width: number;
+    height: number;
+} | null>;
+export declare function stampImageDraw(node: SootSimNode): void;
+export declare function getImageDecodeBucket(size: number, deviceScale?: number): number | null;
+interface RasterDecodeTarget {
+    width: number;
+    height: number;
+}
+interface ImageDecodeRequest {
+    decodedScale?: number;
+    resizeWidth?: number;
+    resizeHeight?: number;
+    rasterTarget?: RasterDecodeTarget;
+}
+export declare function engineDeployBase(): string;
+export declare function resolveImageFetchUri(uri: string): string;
+export declare function hasSootSimFile(uri: string): boolean;
+export declare function readSootSimFileBytes(uri: string): Uint8Array | null;
+export declare function storeImageBytes(uri: string, buffer: ArrayBuffer, headers?: Record<string, string>): void;
+export declare function loadBytesForUri(uri: string, headers?: Record<string, string>, signal?: AbortSignal, onProgress?: (event: ImageDownloadProgress) => void, downloadTimeoutMs?: number): Promise<Uint8Array>;
+export declare function setSvgRasterizeFallback(fallback: ((bytes: Uint8Array, targetWidth: number, targetHeight: number) => Promise<Uint8Array | null>) | null): void;
+export declare function isSvgUri(uri: string): boolean;
+export declare function looksLikeSvgBytes(bytes: Uint8Array): boolean;
+export declare const queuedImageLoads: Set<SootSimNode>;
+export declare function queueImageLoad(node: SootSimNode): void;
+export declare function kickQueuedImageLoads(): void;
+export declare function hasImageLoadInFlight(): boolean;
+export declare function loadImageForNode(node: SootSimNode, ctx?: RenderContext): void;
+export declare function drawsLiveImage(node: SootSimNode): boolean;
+export declare function touchPaintedImage(node: SootSimNode, ctx: RenderContext): void;
+export declare function clearImageRepeatShader(node: SootSimNode): void;
+export declare function clearImageNodeRepeatShaders(node: SootSimNode): void;
+export declare function releaseImageNode(node: SootSimNode): void;
+export declare function readImagePrefetchRequest(uri: string, exactCacheKey: string): ImageDecodeRequest | null;
+export declare function prefetchImage(uri: string, requestId?: number, exactCacheKey?: string, headers?: Record<string, string>, paintNode?: SootSimNode): Promise<boolean>;
+export declare function sniffImageMediaType(bytes: Uint8Array): string | null;
+export declare function clearImageCache(uri: string): void;
+export declare function resolveSvgRasterTargetDimensions(intrinsicWidth: number, intrinsicHeight: number, resizeWidth?: number, resizeHeight?: number): {
+    targetWidth: number;
+    targetHeight: number;
+};

package/dist-types/packages/peach-engine/src/engine/inspect-info.d.ts

@@ -0,0 +1,27 @@
+import { INSPECT_APP_ROOT_TEST_ID, INSPECT_OVERLAY_TEST_ID, pickInspectTarget, shouldOutlineInspectNode } from './inspect-outline.d.ts';
+import { type SootSimNode } from './node.d.ts';
+import { type VisibleFrameQuery } from './visible-frame.d.ts';
+import type { PeachSemanticInspectInfo, SootSimInspectAncestor, SootSimInspectBoxModel, SootSimInspectDeviceInfo, SootSimInspectInfo, SootSimInspectTreeNode } from '../../../peach-globals/src/index.d.ts';
+export type InspectDeviceInfo = SootSimInspectDeviceInfo;
+export type InspectAncestor = SootSimInspectAncestor;
+export type InspectBoxModel = SootSimInspectBoxModel;
+export type InspectInfo = SootSimInspectInfo;
+export type InspectQueryInfo = Omit<PeachSemanticInspectInfo, 'ancestors'> & Pick<InspectInfo, 'layout' | 'visibleFrame' | 'style' | 'ancestors' | 'srcloc'>;
+export declare function collectInspectText(node: SootSimNode): string | undefined;
+export declare function visibleInspectText(node: SootSimNode): string | undefined;
+export declare function pickInspectTooltipColors(info: InspectInfo): Array<[string, string]>;
+export declare function pickInspectFontSummary(info: InspectInfo): string | undefined;
+export declare function truncateInspectText(text: string, maxLength: number): string;
+export declare function infoToInspectText(info: InspectInfo): string;
+export declare function isInspectColorKey(key: string): boolean;
+export declare function isInspectableNode(node: SootSimNode, query?: VisibleFrameQuery): boolean;
+export { INSPECT_APP_ROOT_TEST_ID, INSPECT_OVERLAY_TEST_ID, pickInspectTarget, shouldOutlineInspectNode, };
+export declare function collectInspectTree(root: SootSimNode): SootSimInspectTreeNode[];
+export declare function getUIKitAccessibilityFrame(node: SootSimNode, painted?: InspectInfo['absolute']): InspectInfo['absolute'] | undefined;
+export declare function collectBackgroundPlaybackNodeIds(root: SootSimNode, drivenIds: ReadonlySet<number>, nodeId: (node: SootSimNode) => number | undefined): Set<number>;
+export declare function markBackgroundPlaybackInspectInfos<T>(infos: T[], nodeIds: ReadonlySet<number>): T[];
+export declare function collectInspectInfo(node: SootSimNode, query?: VisibleFrameQuery): InspectInfo;
+export declare function collectInspectQueryInfo(node: SootSimNode, query?: VisibleFrameQuery): InspectQueryInfo;
+export declare function collectHoverInspectInfo(node: SootSimNode, query?: VisibleFrameQuery): InspectInfo;
+export declare function serializeInspectValue(value: readonly PeachSemanticInspectInfo[]): PeachSemanticInspectInfo[];
+export declare function serializeInspectValue(value: unknown): unknown;

package/dist-types/packages/peach-engine/src/engine/inspect-outline.d.ts

@@ -0,0 +1,14 @@
+import { type VisibleFrameQuery } from './visible-frame.d.ts';
+import type { SootSimNode } from './node.d.ts';
+export declare const INSPECT_OVERLAY_TEST_ID = "__sootsimCanvasInspectOverlay";
+export declare const INSPECT_APP_ROOT_TEST_ID = "__sootsimInspectAppRoot";
+export declare const HANDLER_PROPS: readonly ['onPress', 'onClick', 'onPressIn', 'onPressOut', 'onLongPress', 'onPanStart', 'onPanMove', 'onPanEnd', 'onStartShouldSetResponder', 'onMoveShouldSetResponder', 'onResponderGrant', 'onResponderMove', 'onResponderRelease', 'onResponderTerminate'];
+export declare const PRESS_HANDLER_PROPS: readonly ['onPress', 'onClick', 'onPressIn', 'onPressOut', 'onLongPress'];
+export declare function hasInspectHandlers(node: SootSimNode): boolean;
+export declare function hasPressInspectHandlers(node: SootSimNode): boolean;
+export declare function hasSemanticIdentity(node: SootSimNode): boolean;
+export declare function hasPaintedInspectBox(node: SootSimNode): boolean;
+export declare function isLeafInspectContent(node: SootSimNode): boolean;
+export declare function getInspectRoot(node: SootSimNode): SootSimNode;
+export declare function shouldOutlineInspectNode(node: SootSimNode, query?: VisibleFrameQuery): boolean;
+export declare function pickInspectTarget(node: SootSimNode, root: SootSimNode): SootSimNode;

package/dist-types/packages/peach-engine/src/engine/inspect-visibility.d.ts

@@ -0,0 +1,33 @@
+import type { InspectInfo, InspectQueryInfo } from './inspect-info.d.ts';
+export interface InspectOcclusionRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface InspectOcclusionEntry<T> {
+    item: T | null;
+    rect: InspectOcclusionRect;
+    occludesBelow: boolean;
+    subtreeEnd?: number;
+}
+export declare function parseNumberish(value: unknown): number | null;
+export declare function hasNonTranslateTransform(style: Record<string, unknown>): boolean;
+export declare function intersectInspectRects(a: InspectOcclusionRect, b: InspectOcclusionRect): InspectOcclusionRect | null;
+export declare function overlapRect(a: InspectOcclusionRect, b: InspectOcclusionRect): InspectOcclusionRect | null;
+export declare function subtractRect(source: InspectOcclusionRect, cover: InspectOcclusionRect): InspectOcclusionRect[];
+export declare function isRectFullyCovered(rect: InspectOcclusionRect, covers: readonly InspectOcclusionRect[], coverCount?: number): boolean;
+export declare function inspectInfoArea(info: InspectInfo): number;
+export declare function inspectInfoContainsPoint(info: Pick<InspectInfo, 'absolute' | 'layout' | 'visibleFrame'>, x: number, y: number): boolean;
+export declare function getInspectInfoVisibleRect(info: InspectQueryInfo): InspectOcclusionRect;
+export declare function canStyleFullyOccludeInspect(style: Record<string, unknown>): boolean;
+export declare function backgroundPaintsNothingForInspect(value: unknown): boolean;
+export declare function getStyleInspectOcclusionRects(style: Record<string, unknown>, rect: InspectOcclusionRect): InspectOcclusionRect[];
+export declare function hasExplicitInspectIdentity(info: InspectQueryInfo): boolean;
+export declare function hasVisualInspectStyle(info: InspectQueryInfo): boolean;
+export declare function isOversizedInspectWrapper(info: InspectQueryInfo, rootArea: number): boolean;
+export declare function isStructuralInspectWrapper(info: InspectQueryInfo): boolean;
+export declare function shouldKeepVisibleInspectInfo(info: InspectQueryInfo, rootArea: number): boolean;
+export declare function filterOccludedInspectEntries<T>(entries: readonly InspectOcclusionEntry<T>[]): T[];
+export declare function pickVisibleInspectInfoAtPoint(infos: readonly InspectInfo[], x: number, y: number, _rootArea: number): InspectInfo | null;
+export declare function occlusionRectsContainPoint(rects: readonly InspectOcclusionRect[], x: number, y: number): boolean;

package/dist-types/packages/peach-engine/src/engine/ios-fast-scroll.d.ts

@@ -0,0 +1,16 @@
+export interface IosFastScroll {
+    count: number;
+    multiplier: number;
+    startMultiplier: number;
+    lastFlickAt: number;
+    direction: number;
+}
+export declare function createIosFastScroll(): IosFastScroll;
+export declare function beginIosFastScroll(fast: IosFastScroll, catchesDeceleration: boolean, now: number): void;
+export declare function updateIosFastScroll(fast: IosFastScroll, velocity: number, distance: number): void;
+export declare function releaseIosFastScroll(fast: IosFastScroll, release: {
+    velocity: number;
+    now: number;
+    paging: boolean;
+    outOfBounds: boolean;
+}): number;