peachsim 0.1.1644 → 0.1.1653

package/dist-types/packages/peach-engine/src/render-worker/image-lifecycle-event.d.ts

@@ -0,0 +1,22 @@
+export interface ImageDownloadProgress {
+    timeStamp: number;
+    loaded: number;
+    total: number;
+    progress: number;
+}
+export type ImageLifecycleBody = {
+    timeStamp: number;
+    uri: string;
+} & ({
+    phase: 'loadStart' | 'load' | 'error' | 'loadEnd';
+    width?: number;
+    height?: number;
+    mediaType?: string | null;
+    error?: string;
+} | ({
+    phase: 'progress';
+} & ImageDownloadProgress));
+export type ImageLifecycleEvent = ImageLifecycleBody & {
+    nodeId: number;
+};
+export type ImageLifecyclePhase = ImageLifecycleEvent['phase'];

package/dist-types/packages/peach-engine/src/render-worker/image-pixel-contract.d.ts

@@ -0,0 +1,48 @@
+export type ImagePixelRequest = {
+    readonly kind: 'decode';
+    readonly id: number;
+    readonly bytes: ArrayBuffer;
+    readonly size: {
+        readonly width: number;
+        readonly height: number;
+    } | null;
+} | {
+    readonly kind: 'cancel';
+    readonly id: number;
+};
+
+export type ImagePixelDecodeSize = Extract<ImagePixelRequest, {
+    kind: 'decode';
+}>['size'];
+export type ImagePixelReply = {
+    readonly id: number;
+    readonly pixels: ArrayBuffer;
+    readonly width: number;
+    readonly height: number;
+    readonly opaque: boolean;
+} | {
+    readonly id: number;
+    readonly error: string;
+};
+interface ImagePixels {
+    readonly pixels: Uint8Array;
+    readonly width: number;
+    readonly height: number;
+}
+export interface DecodedImagePixels extends ImagePixels {
+    readonly opaque: boolean;
+}
+export interface LiveFramePixels extends ImagePixels {
+    readonly order: 'rgba' | 'bgra';
+}
+export type ImageFrameSource = ImageBitmap | LiveFramePixels;
+export declare function isImageFrameSource(value: unknown): value is ImageFrameSource;
+export declare function imageFrameTransfer(source: ImageFrameSource | null): Transferable[];
+export declare function closeImageFrame(source: ImageFrameSource | null | undefined): void;
+export declare function premultiplyImagePixels(pixels: Uint8ClampedArray): boolean;
+export declare function paintedPixelReach(pixels: Uint8Array, width: number, height: number, pivot: {
+    x: number;
+    y: number;
+}): number;
+export declare function resolveImageSourceHeaders(source: unknown): Record<string, string> | undefined;
+export {};

package/dist-types/packages/peach-engine/src/render-worker/live-frame-mirror.d.ts

@@ -0,0 +1,34 @@
+import { type ImageFrameSource } from './image-pixel-contract.d.ts';
+export interface RemoteLiveFrameIdentity {
+    sessionId: string;
+    seq: number;
+    epoch: number;
+}
+export declare function readRemoteLiveFrameIdentity(value: unknown): RemoteLiveFrameIdentity | null;
+export type LiveFrameMirrorEnvelope = {
+    channelId: string;
+    bitmap: ImageFrameSource | null;
+    captureRequestId?: number;
+    remoteFrame?: RemoteLiveFrameIdentity;
+};
+export type LiveFramePortMessage = {
+    type: 'liveFrameMirror';
+    payload: LiveFrameMirrorEnvelope;
+} | {
+    type: 'liveFrameCaptureBarrier';
+    requestId: number;
+};
+export type LiveFramePortReply = {
+    type: 'liveFrameAcked';
+    channelId: string;
+};
+type PostMessage = (msg: Extract<LiveFramePortMessage, {
+    type: 'liveFrameMirror';
+}>, transfer: Transferable[]) => void;
+export declare function installLiveFrameMirrorPublisher(opts: {
+    post: PostMessage;
+}): void;
+export declare function uninstallLiveFrameMirrorPublisher(): void;
+export declare function applyLiveFrameMirror(envelope: LiveFrameMirrorEnvelope): void;
+export declare function __resetLiveFrameMirrorState(): void;
+export {};

package/dist-types/packages/peach-engine/src/render-worker/map-command-channel.d.ts

@@ -0,0 +1,189 @@
+import { type MapNativeOperation, type MapNativeEvent, type MapResourceRules } from './mapNativeContract.d.ts';
+import type { NativeSurfaceIdentity } from '../../../peach-globals/src/index.d.ts';
+export type LngLat = [number, number];
+export type MapCameraTransition = 'fly' | 'ease' | 'linear' | 'move';
+export type MapProjection = 'mercator' | 'globe';
+export type MapStyle = string | {
+    version: 8;
+    sources: Record<string, unknown>;
+    layers: Array<Record<string, unknown>>;
+};
+export type MapMountOptions = {
+    style?: MapStyle;
+    nativeAppearance?: 'light' | 'dark';
+    apple?: NativeSurfaceIdentity & {
+        token: string;
+        evaluationId: string;
+    };
+    projection?: MapProjection;
+    center?: LngLat;
+    zoom?: number;
+    bearing?: number;
+    pitch?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    scrollEnabled?: boolean;
+    zoomEnabled?: boolean;
+    rotateEnabled?: boolean;
+    pitchEnabled?: boolean;
+    nativeEvents?: boolean;
+    resourceTransport?: boolean;
+    resourceRules?: MapResourceRules;
+};
+export type MapMarker = {
+    id: string;
+    center: LngLat;
+    color?: string;
+    style?: 'apple-balloon';
+    selected?: boolean;
+};
+export type MapSource = {
+    id: string;
+    data?: unknown;
+    specification?: Record<string, unknown>;
+    cluster?: boolean;
+    clusterRadius?: number;
+    clusterMaxZoom?: number;
+    lineMetrics?: boolean;
+};
+export type MapLayerType = 'line' | 'circle' | 'fill' | 'symbol' | 'fill-extrusion' | 'heatmap' | 'background' | 'raster' | 'hillshade' | 'color-relief';
+export type MapLayer = {
+    id: string;
+    type: MapLayerType;
+    source?: string;
+    sourceLayer?: string;
+    style?: Record<string, unknown>;
+    filter?: unknown;
+    minzoom?: number;
+    maxzoom?: number;
+    beforeId?: string;
+    afterId?: string;
+    layerIndex?: number;
+};
+export type MapCommand = {
+    kind: 'native';
+    mapId: string;
+    requestId: number;
+    operation: MapNativeOperation;
+} | ({
+    kind: 'mount';
+    mapId: string;
+    width: number;
+    height: number;
+    scale: number;
+} & {
+    options: MapMountOptions;
+}) | {
+    kind: 'resize';
+    mapId: string;
+    width: number;
+    height: number;
+    scale: number;
+} | {
+    kind: 'camera';
+    mapId: string;
+    center?: LngLat;
+    zoom?: number;
+    bearing?: number;
+    pitch?: number;
+    animated?: boolean;
+    durationMs?: number;
+    transition?: MapCameraTransition;
+} | {
+    kind: 'fit';
+    mapId: string;
+    bounds: [LngLat, LngLat];
+    padding?: number;
+    animated?: boolean;
+} | {
+    kind: 'gesture';
+    mapId: string;
+    phase: 'pinch' | 'pan' | 'end';
+    scale?: number;
+    dx?: number;
+    dy?: number;
+    focusX?: number;
+    focusY?: number;
+} | {
+    kind: 'markers';
+    mapId: string;
+    markers: MapMarker[];
+} | {
+    kind: 'tap';
+    mapId: string;
+    x: number;
+    y: number;
+} | {
+    kind: 'style';
+    mapId: string;
+    sources: MapSource[];
+    layers: MapLayer[];
+} | {
+    kind: 'basemap';
+    mapId: string;
+    style?: MapStyle;
+    nativeAppearance?: 'light' | 'dark';
+} | {
+    kind: 'unmount';
+    mapId: string;
+};
+export type MapRegion = {
+    latitude: number;
+    longitude: number;
+    latitudeDelta: number;
+    longitudeDelta: number;
+};
+export type MapCameraState = {
+    center: LngLat;
+    zoom: number;
+    bearing: number;
+    pitch: number;
+};
+export type MapContent = {
+    labels: Array<{
+        label: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    attribution: Array<{
+        label: string;
+        url: string;
+    }>;
+};
+export type MapEvent = {
+    kind: 'regionChangeStart' | 'regionChange' | 'regionChangeComplete' | 'tap' | 'content';
+    mapId: string;
+    region: MapRegion;
+    camera: MapCameraState;
+    isGesture: boolean;
+    tap?: {
+        longitude: number;
+        latitude: number;
+    };
+    content?: MapContent;
+    bounds?: [number, number, number, number];
+    animated?: boolean;
+};
+export type MapHostEvent = MapEvent | MapNativeEvent;
+export declare function isMapStyle(value: unknown): value is MapStyle;
+export declare function isMapCommand(value: unknown): value is MapCommand;
+export declare function isMapEvent(value: unknown): value is MapHostEvent;
+type PostMessage = (msg: {
+    type: 'mapCommand';
+    payload: MapCommand;
+}) => void;
+export declare function installMapCommandTenantPublisher(opts: {
+    post: PostMessage;
+}): void;
+export declare function uninstallMapCommandTenantPublisher(): void;
+export declare function postMapCommand(cmd: MapCommand): boolean;
+export type MapEventListener = (event: MapEvent) => void;
+export declare function subscribeMapEvents(mapId: string, listener: MapEventListener): () => void;
+export declare function dispatchMapEvent(event: MapHostEvent): void;
+export declare function __resetMapCommandChannelState(): void;
+export declare function requestMapNative(mapId: string, operation: MapNativeOperation): Promise<unknown>;
+export declare function subscribeMapNativeEvents(mapId: string, listener: (event: MapNativeEvent) => void): () => void;
+export declare function releaseMapNativeRequests(mapId: string): void;
+export {};

package/dist-types/packages/peach-engine/src/render-worker/mapNativeContract.d.ts

@@ -0,0 +1,101 @@
+import type { LngLat } from './map-command-channel.d.ts';
+export type MapPadding = {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+};
+export type MapNativeStop = {
+    center?: LngLat;
+    bounds?: [number, number, number, number];
+    padding?: MapPadding;
+    zoom?: number;
+    bearing?: number;
+    pitch?: number;
+    duration?: number;
+    easing?: 'none' | 'linear' | 'ease' | 'fly';
+};
+export type MapResourceRules = {
+    transforms: Array<{
+        match: string | null;
+        find: string;
+        replace: string;
+    }>;
+    params: Array<{
+        match: string | null;
+        name: string;
+        value: string;
+    }>;
+    headers: Array<{
+        match: string | null;
+        name: string;
+        value: string;
+    }>;
+};
+export type MapNativeImage = {
+    uri: string;
+    scale?: number;
+    sdf?: boolean;
+};
+export type MapNativeOperation = {
+    method: 'setResourceRules';
+    rules: MapResourceRules;
+} | {
+    method: 'setImages';
+    images: Record<string, MapNativeImage>;
+} | {
+    method: 'setStop';
+    stop: MapNativeStop;
+} | {
+    method: 'configureCamera';
+    minZoom?: number;
+    maxZoom?: number;
+    maxBounds?: [number, number, number, number];
+} | {
+    method: 'getCenter' | 'getZoom' | 'getBearing' | 'getPitch' | 'getBounds' | 'getViewState';
+} | {
+    method: 'project' | 'unproject';
+    point: LngLat;
+} | {
+    method: 'queryRenderedFeatures';
+    geometry?: LngLat | [LngLat, LngLat];
+    layers: string[];
+    filter?: unknown[];
+} | {
+    method: 'querySourceFeatures';
+    source: string;
+    sourceLayer?: string;
+    filter?: unknown[];
+} | {
+    method: 'getClusterExpansionZoom' | 'getClusterChildren';
+    source: string;
+    clusterId: number;
+} | {
+    method: 'getClusterLeaves';
+    source: string;
+    clusterId: number;
+    limit: number;
+    offset: number;
+} | {
+    method: 'setSourceVisibility';
+    source: string;
+    sourceLayer?: string;
+    visible: boolean;
+};
+export type MapNativeEvent = {
+    kind: 'nativeReply';
+    mapId: string;
+    requestId: number;
+    result?: unknown;
+    error?: string;
+} | {
+    kind: 'nativeLifecycle';
+    mapId: string;
+    name: string;
+    error?: string;
+    image?: string;
+};
+export declare function mapNativeRecord(value: unknown): value is Record<string, unknown>;
+export declare function isMapResourceRules(value: unknown): value is MapResourceRules;
+export declare function isMapNativeStop(value: unknown): value is MapNativeStop;
+export declare function isMapNativeOperation(value: unknown): value is MapNativeOperation;

package/dist-types/packages/peach-engine/src/render-worker/native-dynamic-synchronizable.d.ts

@@ -0,0 +1,22 @@
+export declare const SYNCHRONIZABLE_ARENA_BYTES: number;
+export type SynchronizableArenaKey = 'tenant' | 'workers';
+export type SynchronizableArenas = Record<SynchronizableArenaKey, SharedArrayBuffer>;
+export declare function createSynchronizableArenas(): SynchronizableArenas;
+export declare function installSynchronizableArenas(buffers: SynchronizableArenas, own: SynchronizableArenaKey): void;
+export declare class NativeDynamicSynchronizableStorage {
+    offset: number;
+    access: Int32Array;
+    ownerCounter: Int32Array;
+    private buffer;
+    private header;
+    private arena;
+    private shared;
+    constructor(arena?: SynchronizableArenaKey, offset?: number);
+    share(): SynchronizableArenaKey;
+    get revision(): number;
+    read(): {
+        revision: number;
+        text: string;
+    };
+    write(text: string): number;
+}

package/dist-types/packages/peach-engine/src/render-worker/native-menu-gesture.d.ts

@@ -0,0 +1,9 @@
+export type NativeMenuGestureEvent = {
+    pointerId?: number;
+    pageX?: number;
+    pageY?: number;
+};
+type NativeMenuGestureHandler = (event?: NativeMenuGestureEvent) => boolean;
+export declare function registerNativeMenuGestureHandler(nextHandler: NativeMenuGestureHandler): () => void;
+export declare function publishNativeMenuGesture(event?: NativeMenuGestureEvent): boolean;
+export {};

package/dist-types/packages/peach-engine/src/render-worker/native-ui-commandContract.d.ts

@@ -0,0 +1,23 @@
+import type { NativeUIEvent, NativeUIRequest } from './native-ui-protocol.d.ts';
+import type { ShellTestBridgeRequest } from './test-bridge-protocol.d.ts';
+import type { SootSimReplayTarget } from '../../../peach-globals/src/index.d.ts';
+export type NativeUICommandPresentation = Extract<NativeUIRequest, {
+    kind: 'alert.show' | 'actionSheet.show' | 'imagePicker.show';
+}>;
+type NativeUICommandSettlement = Extract<NativeUIEvent, {
+    kind: 'alert.result' | 'actionSheet.result' | 'imagePicker.result';
+}>;
+export declare function isNativeUICommandPresentation(request: NativeUIRequest): request is NativeUICommandPresentation;
+export declare function isNativeUICommandSettlement(event: NativeUIEvent): event is NativeUICommandSettlement;
+export declare function nativeUICommandPresentationKind(event: NativeUICommandSettlement): NativeUICommandPresentation['kind'];
+type NativeUIRead = Extract<ShellTestBridgeRequest, {
+    method: 'listSemanticInspectable' | 'captureAccessibilityTree' | 'findByText' | 'resolveTapTarget' | 'queryAll';
+}>;
+export type NativeUICommand = NativeUIRead | {
+    type: 'tap';
+    x: number;
+    y: number;
+    target?: SootSimReplayTarget;
+};
+export declare function readNativeUICommand(value: unknown): NativeUICommand | null;
+export {};