peachsim 0.1.1641 → 0.1.1653

package/dist-types/packages/peach-engine/src/react-native/AppState.d.ts

@@ -0,0 +1,45 @@
+export type AppStateStatus = 'active' | 'background' | 'inactive';
+export type AppStateEvent = 'change' | 'memoryWarning' | 'focus' | 'blur';
+type AppStateSignalEvent = Exclude<AppStateEvent, 'change'>;
+export interface SimulatedActivityScene {
+    state: string;
+    activeAppId: string | null;
+    systemAlertAppId?: string | null;
+    showSwitcher: boolean;
+    isLocked: boolean;
+    topOverlay: string;
+    ncVisible: boolean;
+    ccVisible: boolean;
+    switcherPhase?: string;
+}
+export declare function deriveAppStateFromShellScene(scene: SimulatedActivityScene | null, appId: string | null): {
+    state: AppStateStatus;
+    focused: boolean;
+};
+declare function addAppStateEventListener(type: 'change', handler: (state: AppStateStatus) => void): {
+    remove(): void;
+};
+declare function addAppStateEventListener(type: AppStateSignalEvent, handler: () => void): {
+    remove(): void;
+};
+export declare function updateAppStateFromHost(input: {
+    state: AppStateStatus;
+    focused: boolean;
+}): void;
+export declare function emitAppStateMemoryWarning(): void;
+export declare const AppState: {
+    readonly currentState: AppStateStatus;
+    isAvailable: boolean;
+    addEventListener: typeof addAppStateEventListener;
+};
+export declare const AppStateNativeModule: {
+    getConstants: () => {
+        initialAppState: AppStateStatus;
+    };
+    getCurrentAppState(success: (state: {
+        app_state: AppStateStatus;
+    }) => void, _error?: (error: Error) => void): void;
+    addListener(): void;
+    removeListeners(): void;
+};
+export {};

package/dist-types/packages/peach-engine/src/react-native/Appearance.d.ts

@@ -0,0 +1,34 @@
+export type ColorScheme = 'light' | 'dark';
+export type ColorSchemeName = ColorScheme | 'auto' | 'unspecified' | null;
+type AppearanceListener = (preferences: {
+    colorScheme: ColorScheme;
+}) => void;
+export declare const colorSchemeSignal: import("../engine/signal.d.ts").Signal<ColorScheme>;
+export declare function getPaintColorScheme(): ColorScheme;
+export declare function getPinnedPaintColorScheme(): ColorScheme | null;
+export declare function setPinnedPaintColorScheme(scheme: ColorScheme | null): void;
+export declare function withPaintColorScheme<T>(scheme: ColorScheme | null | undefined, operation: () => T): T;
+export declare function resolveDynamicColor<T>(dynamic: {
+    light?: T;
+    dark?: T;
+    highContrastLight?: T;
+    highContrastDark?: T;
+}, scheme?: ColorScheme): T | undefined;
+export declare const Appearance: {
+    getColorScheme: () => ColorScheme;
+    setColorScheme: (scheme: ColorSchemeName) => void;
+    addChangeListener: (listener: AppearanceListener) => {
+        remove: () => void;
+    };
+};
+export declare const systemColorSchemeSignal: import("../engine/signal.d.ts").Signal<ColorScheme>;
+export declare const appWindowStyleSignal: import("../engine/signal.d.ts").Signal<ColorScheme | null>;
+export declare function setGuestColorScheme(scheme: ColorSchemeName): void;
+export declare const GuestAppearance: {
+    getColorScheme: () => ColorScheme;
+    setColorScheme: (scheme: ColorSchemeName) => void;
+    addChangeListener: (listener: AppearanceListener) => {
+        remove: () => void;
+    };
+};
+export {};

package/dist-types/packages/peach-engine/src/react-native/framework-colors-data.d.ts

@@ -0,0 +1,2 @@
+import type { ColorScheme } from './Appearance.d.ts';
+export declare function resolveFrameworkColorValue(name: string, colorScheme: ColorScheme): string | null;

package/dist-types/packages/peach-engine/src/react-native/host-services.d.ts

@@ -0,0 +1,42 @@
+import type { WebAuthenticationHostRequest, WebAuthenticationHostResult } from '../webAuthenticationContract.d.ts';
+export type BrowserSessionResult = {
+    type: 'cancel' | 'dismiss' | 'locked';
+};
+export type BrowserSessionOptions = {
+    sessionOwner: string;
+    windowName?: string;
+    windowFeatures?: string;
+};
+export type VideoThumbnailOptions = {
+    quality?: number;
+    time?: number;
+    headers?: Record<string, string>;
+};
+export type VideoThumbnailResult = {
+    uri: string;
+    width: number;
+    height: number;
+};
+export interface ReactNativeHostServices {
+    webAuthenticationSession(request: WebAuthenticationHostRequest): Promise<WebAuthenticationHostResult>;
+    createVideoThumbnail(uri: string, options: VideoThumbnailOptions): Promise<VideoThumbnailResult>;
+    getImageSize(uri: string, headers?: Record<string, string>): Promise<{
+        width: number;
+        height: number;
+    }>;
+    storeImageBytes(uri: string, bytes: ArrayBuffer, headers?: Record<string, string>): Promise<void>;
+    prefetchImage(uri: string, requestId?: number, exactCacheKey?: string, headers?: Record<string, string>): Promise<boolean>;
+    abortImagePrefetch(requestId: number): Promise<void>;
+    queryImageCache(uris: string[]): Promise<Record<string, 'memory'>>;
+    openUrl(url: string): Promise<void>;
+    openBrowserSession(url: string, options: BrowserSessionOptions): Promise<BrowserSessionResult>;
+    dismissBrowserSession(sessionOwner: string): Promise<{
+        type: 'dismiss';
+    }>;
+    isScreenWakeLockAvailable(): Promise<boolean>;
+    activateScreenWakeLock(reference: string, restoreOnVisible: boolean): Promise<void>;
+    deactivateScreenWakeLock(reference: string): Promise<boolean>;
+    addScreenWakeLockReleaseListener(listener: (references: string[]) => void): () => void;
+}
+export declare function setReactNativeHostServices(services: ReactNativeHostServices | null): void;
+export declare function requireReactNativeHostServices(): ReactNativeHostServices;

package/dist-types/packages/peach-engine/src/react-native/layout-animation.d.ts

@@ -0,0 +1,22 @@
+export interface LayoutAnimationConfig {
+    duration?: number;
+    create?: LayoutAnimationPhaseConfig;
+    update?: LayoutAnimationPhaseConfig;
+    delete?: LayoutAnimationPhaseConfig;
+}
+export interface LayoutAnimationPhaseConfig {
+    type?: string;
+    property?: string;
+    duration?: number;
+    delay?: number;
+    springDamping?: number;
+    initialVelocity?: number;
+}
+export type LayoutAnimationProperty = 'opacity' | 'scaleX' | 'scaleY' | 'scaleXY';
+export interface PendingLayoutAnimation {
+    config: LayoutAnimationConfig;
+}
+export declare function isLayoutAnimationProperty(value: unknown): value is LayoutAnimationProperty;
+export declare function setPendingLayoutAnimation(config: LayoutAnimationConfig | null): void;
+export declare function configureNextLayoutAnimation(config: LayoutAnimationConfig, onComplete?: (() => void) | null, onError?: (() => void) | null): void;
+export declare function consumePendingLayoutAnimation(): PendingLayoutAnimation | null;

package/dist-types/packages/peach-engine/src/react-native/platform-colors.d.ts

@@ -0,0 +1,17 @@
+import type { AppCatalogColor } from '../../../../../src/assetCatalogContract.ts';
+export type { AppCatalogColor } from '../../../../../src/assetCatalogContract.ts';
+import { type DynamicColor } from '../engine/types.d.ts';
+export interface AndroidPlatformColorValue {
+    resource_paths: string[];
+}
+export declare function isAndroidPlatformColor(value: unknown): value is AndroidPlatformColorValue;
+export declare function isDynamicPlatformColor(value: unknown): value is DynamicColor;
+type FrameworkColorsData = typeof import('./framework-colors-data.d.ts');
+export declare function ensureFrameworkColors(): Promise<FrameworkColorsData>;
+export declare function resolveAndroidPlatformColor(value: unknown): string | null;
+export declare function setAppCatalogColors(colors: Readonly<Record<string, AppCatalogColor>>, accentName: string | null): void;
+export declare function setPackageCatalogColors(colors: Readonly<Record<string, AppCatalogColor>>): void;
+export declare function appCatalogAccent(): DynamicColor | null;
+export declare function appAccentColor(scheme: 'light' | 'dark'): string | null;
+export declare function appAccentStyleColor(): string | null;
+export declare function PlatformColor(...names: string[]): AndroidPlatformColorValue | DynamicColor | string;

package/dist-types/packages/peach-engine/src/remote-stream/client-config.d.ts

@@ -0,0 +1,10 @@
+import { type RemotePeerIdentity } from './cloud-display.d.ts';
+export type { RemotePeerIdentity } from './cloud-display.d.ts';
+export interface RemoteEngineClientConfig {
+    url: string;
+    expectedPeer: RemotePeerIdentity;
+    autoplay?: boolean;
+    authToken?: string;
+}
+export declare function parseRemoteEngineClientConfig(value: unknown): RemoteEngineClientConfig | null;
+export declare function isSceneRecordingSource(config: RemoteEngineClientConfig): boolean;

package/dist-types/packages/peach-engine/src/remote-stream/cloud-display.d.ts

@@ -0,0 +1,58 @@
+export declare const DISPLAY_SERVER_VERSION = 12;
+export declare const DISPLAY_SERVER_MAJOR = 2;
+export declare const DISPLAY_SERVER_MINOR = 26;
+export declare const DISPLAY_SERVER_SUBPROTOCOL = "rnx.display-server.v2.wire12.minor26";
+export declare const DISPLAY_SERVER_TOKEN_SUBPROTOCOL_PREFIX = "rnx.sim-token.";
+export declare const RNX_CLOUD_DISPLAY_GRANT_TTL_MS: number;
+export declare const RNX_CLOUD_DISPLAY_CLOSE: {
+    readonly replaced: 4001;
+    readonly childClosed: 4003;
+    readonly detached: 4004;
+};
+export declare const DISPLAY_SERVER_LIMITS: {
+    readonly maxFrameBytes: 4194304;
+    readonly maxStringBytes: 16384;
+    readonly maxCollection: 4096;
+    readonly maxNodes: 65536;
+    readonly maxCommitNodes: 8192;
+    readonly maxCommitBytes: 3145728;
+    readonly maxChildren: 8192;
+    readonly maxTreeDepth: 256;
+    readonly maxPropBytes: 2097152;
+    readonly maxCommitPropBytes: 3145728;
+    readonly maxFontBytes: 33554432;
+    readonly maxFontChunkBytes: 1048576;
+    readonly maxFontMetadataBytes: 65536;
+    readonly maxNativeUIBytes: 3932160;
+    readonly maxPendingFonts: 16;
+    readonly maxLiveFrameBytes: 3145728;
+    readonly maxLiveFramePixels: 4194304;
+    readonly maxLiveFrameChannels: 32;
+    readonly maxLiveFrameStoreBytes: 16777216;
+    readonly maxNativeAnimMirrors: 256;
+    readonly maxNativeAnimMirrorBytes: 262144;
+    readonly maxNativeAnimMirrorDepth: 64;
+};
+export type DisplayServerAppearance = 'light' | 'dark';
+export interface RemotePeerIdentity {
+    surfaceId: string;
+    appearance: DisplayServerAppearance;
+    deviceProfile: string;
+    engineBuild: string;
+    contentBuild: string;
+    canvasKitBuild: string;
+    fontManifestHash: string;
+    assetManifestHash: string;
+}
+export declare function readRemotePeerIdentity(value: unknown): RemotePeerIdentity | null;
+export interface CloudDisplayGrantRecord {
+    tokenHash: string;
+    expiresAt: number;
+}
+export declare function offeredSubprotocols(request: Request): string[];
+export declare function displayTokenFromSubprotocols(offered: readonly string[]): string | null;
+export declare function mintCloudDisplayGrant(now: number): Promise<{
+    authToken: string;
+    record: CloudDisplayGrantRecord;
+}>;
+export declare function cloudDisplayGrantAccepts(record: CloudDisplayGrantRecord | null, token: string | null, now: number): Promise<boolean>;

package/dist-types/packages/peach-engine/src/remote-stream/scene-recording.d.ts

@@ -0,0 +1,45 @@
+import { type RemotePeerIdentity } from './cloud-display.d.ts';
+declare const FORMAT = 1;
+export declare const MAX_SCENE_RECORDING_BYTES: number;
+export declare const SCENE_RECORDING_CONTENT_TYPE = "application/vnd.peach.scene-stream+gzip";
+export interface SceneRecordingHeader {
+    format: typeof FORMAT;
+    subprotocol: string;
+    peer: RemotePeerIdentity;
+    durationMs: number;
+    frameCount: number;
+    recordedAtEpochMs: number;
+}
+export interface SceneRecordingFrame {
+    t: number;
+    bytes: Uint8Array;
+}
+export interface SceneRecording {
+    header: SceneRecordingHeader;
+    frames: SceneRecordingFrame[];
+}
+export declare function readSceneRecordingHeader(value: unknown): SceneRecordingHeader | null;
+export declare function encodeSceneRecording(recording: SceneRecording): Promise<Uint8Array>;
+export declare function decodeSceneRecording(compressed: Uint8Array): Promise<SceneRecording>;
+export declare function readSceneRecordingUpload(bytes: Uint8Array): Promise<{
+    header: SceneRecordingHeader;
+    slot: {
+        sizeBytes: number;
+        durationMs: number;
+        peer: RemotePeerIdentity;
+    };
+}>;
+export declare class SceneRecorder {
+    readonly frames: SceneRecordingFrame[];
+    private bytes;
+    private awaitingFullScene;
+    private startedAtMs;
+    private readonly constructedAtMs;
+    private readonly constructedAtEpochMs;
+    private overflowed;
+    constructor(startedAtMs: number, bootstrap: readonly Uint8Array[], awaitingFullScene: boolean);
+    take(arrivalMs: number, bytes: Uint8Array, opensFullScene: boolean, isState: boolean): void;
+    private push;
+    finish(stoppedAtMs: number, peer: RemotePeerIdentity): SceneRecording;
+}
+export {};

package/dist-types/packages/peach-engine/src/render-worker/animated-drive-output.d.ts

@@ -0,0 +1,35 @@
+export interface AnimatedDriveInterpolateConfig {
+    inputRange: number[];
+    outputRange: Array<number | string>;
+    extrapolate?: 'clamp' | 'extend' | 'identity';
+    extrapolateLeft?: 'clamp' | 'extend' | 'identity';
+    extrapolateRight?: 'clamp' | 'extend' | 'identity';
+}
+export type AnimatedDriveExpr = {
+    k: 'driven';
+} | {
+    k: 'const';
+    value: number;
+} | {
+    k: 'add' | 'sub' | 'mul' | 'div';
+    a: AnimatedDriveExpr;
+    b: AnimatedDriveExpr;
+} | {
+    k: 'mod';
+    a: AnimatedDriveExpr;
+    modulus: number;
+} | {
+    k: 'interpolate';
+    parent: AnimatedDriveExpr;
+    config: AnimatedDriveInterpolateConfig;
+};
+export type AnimatedDriveValueKind = 'number' | 'color' | 'colorChannel' | 'transform' | 'filter';
+export interface AnimatedDriveOutput {
+    valueKind: AnimatedDriveValueKind;
+    interpolate?: AnimatedDriveInterpolateConfig;
+    expr?: AnimatedDriveExpr;
+    unit?: string;
+}
+export declare function normalizedRgba(value: number | string): number | null;
+export declare function animatedDriveOutput(output: AnimatedDriveOutput, base: number): number | string;
+export declare function packAnimatedColor(r: number, g: number, b: number, a: number): number;

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

@@ -0,0 +1,16 @@
+import type { AppLoadRequest } from './protocol.d.ts';
+import type { RetainedAppLoadRequest } from './retained-app-load.d.ts';
+export declare const TEST_FIXTURE_SHELL_APP_ID = "sootsim-test-fixture";
+export declare const KITCHEN_SINK_SHELL_APP_ID = "sootsim-kitchen-sink";
+export declare const REMOTE_DISPLAY_SHELL_APP_ID = "sootsim-remote-display";
+export declare function guestShellAppId(appLoad: AppLoadRequest | RetainedAppLoadRequest, surfaceBindings?: Record<string, string | null>): string;
+export declare function getVisibleHarnessAppForUrl(initUrl: string | null | undefined): {
+    color: string;
+    hidden: boolean;
+    icon: string;
+    iconImage?: string;
+    id: string;
+    name: string;
+} | null;
+export declare function isAppBootTargetUrl(initUrl: string | null | undefined): boolean;
+export declare function createRenderWorkerAppLoadRequest(initUrl: string): AppLoadRequest;

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

@@ -0,0 +1,2 @@
+export type AuxAppSurfaceId = 'app:one' | 'app:two';
+export declare function isSurfaceGeneration(value: unknown): value is number;

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

@@ -0,0 +1,42 @@
+import type { CompositorBackend } from './compositor-backend.d.ts';
+import type { GrDirectContext } from 'canvaskit-wasm';
+export declare const DEFAULT_SURFACE_CACHE_BUDGET_BYTES: number;
+export declare const APP_SURFACE_CACHE_BUDGET_BYTES: number;
+export declare const DEFAULT_GR_CONTEXT_BUDGET_BYTES: number;
+export declare const APP_SURFACE_GR_CONTEXT_BUDGET_BYTES: number;
+export declare function enableParallelShaderCompile(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+export declare function applyGrContextBudget(grCtx: GrDirectContext, bytes?: number): void;
+export declare function purgeGrResourceCache(grCtx: GrDirectContext, restoreBytes: number): void;
+export declare function readGrResourceCacheBytes(grCtx: GrDirectContext): {
+    usageBytes: number;
+    limitBytes: number;
+} | null;
+export declare const APP_SURFACE_SCRATCH_BUDGET_BYTES_PER_PIXEL = 128;
+export declare function resolveSharedGraphiteResourceCacheBudgetBytes(surfaceBudgets: Iterable<number>): number;
+export declare function resolveCanvasKitArtifactUrl(engineBase: string, artifact: string, pageUrl?: string): string;
+export declare function resolveCanvasKitGraphiteWasmUrl(engineBase: string, pageUrl?: string): string;
+export declare function resolveCanvasKitGaneshWasmUrl(engineBase: string, pageUrl?: string): string;
+export declare function resolveCanvasKitWasmUrlForBackend(backend: CompositorBackend, engineBase: string, pageUrl?: string): string;
+export declare function resolveGraphitePipelineCacheUrl(engineBase: string, pageUrl?: string): string;
+export declare function resolveCanvasKitEngineBaseFromWorkerUrl(workerUrl: string): string;
+export declare function loadSharedFontBuffers(fontUrls: readonly string[]): Promise<Record<string, ArrayBuffer>>;
+interface CanvasKitWasmKickoff {
+    url: string;
+    promise: Promise<Response>;
+}
+interface GraphitePipelineCacheKickoff {
+    url: string;
+    promise: Promise<Blob>;
+}
+export type GraphitePipelineCacheLoadResult = {
+    readonly status: 'loaded';
+    readonly body: Blob;
+} | {
+    readonly status: 'absent';
+    readonly reason: string;
+};
+
+type CanvasKitExecution = 'browser' | 'native';
+export declare function loadSharedCanvasKitWasmModule(wasmUrl: string, execution?: CanvasKitExecution): Promise<WebAssembly.Module>;
+export declare function loadSharedGraphitePipelineCache(pipelineCacheUrl: string): Promise<GraphitePipelineCacheLoadResult>;
+export {};