peachsim 0.1.1641 → 0.1.1653

package/dist-types/packages/peach-engine/src/shell-intent.d.ts

@@ -0,0 +1,68 @@
+import type { ColorScheme } from '../../../../src/settingsContract.ts';
+import type { TopOverlayKind } from './top-overlay-state.d.ts';
+export type ShellIntent = {
+    type: 'goHome';
+} | {
+    type: 'appSwitcher';
+} | {
+    type: 'toggleLock';
+} | {
+    type: 'shake';
+} | {
+    type: 'openNotificationCenter';
+} | {
+    type: 'closeNotificationCenter';
+} | {
+    type: 'openControlCenter';
+} | {
+    type: 'closeControlCenter';
+} | {
+    type: 'setTopOverlay';
+    overlay: TopOverlayKind;
+} | {
+    type: 'inspectModeChange';
+    active: boolean;
+} | {
+    type: 'ringHint';
+} | {
+    type: 'ringModeChange';
+    mode: 'ring' | 'silent';
+} | {
+    type: 'hoverPosition';
+    x: number;
+    y: number;
+} | {
+    type: 'hoverLeave';
+} | {
+    type: 'inspectSelectPosition';
+    x: number;
+    y: number;
+} | {
+    type: 'inspectHoverNode';
+    nodeId: number | null;
+} | {
+    type: 'inspectSelectNode';
+    nodeId: number | null;
+} | {
+    type: 'prewarmApp';
+    appId: string;
+    iconPosition?: {
+        x: number;
+        y: number;
+    };
+} | {
+    type: 'cancelPrewarmApp';
+} | {
+    type: 'colorSchemeChange';
+    scheme: ColorScheme;
+};
+export type ShellIntentType = ShellIntent['type'];
+export declare const SHELL_INTENT_EVENT_NAMES: readonly ["sootsim:goHome", "sootsim:appSwitcher", "sootsim:toggleLock", "sootsim:shake", "sootsim:openNotificationCenter", "sootsim:closeNotificationCenter", "sootsim:openControlCenter", "sootsim:closeControlCenter", "sootsim:setTopOverlay", "sootsim:inspectModeChange", "sootsim:ringHint", "sootsim:ringModeChange", "sootsim:hoverPosition", "sootsim:hoverLeave", "sootsim:inspectSelectPosition", "sootsim:inspectHoverNode", "sootsim:inspectSelectNode", "sootsim:prewarmApp", "sootsim:cancelPrewarmApp", "sootsim:colorSchemeChange"];
+export type ShellIntentEventName = (typeof SHELL_INTENT_EVENT_NAMES)[number];
+export declare function isShellIntentEventName(name: string): boolean;
+export declare function dispatchShellIntent(intent: ShellIntent): void;
+type ShellIntentDetailFor<T extends ShellIntentType> = Extract<ShellIntent, {
+    type: T;
+}>;
+export declare function listenShellIntent<T extends ShellIntentType>(type: T, handler: (intent: ShellIntentDetailFor<T>) => void): () => void;
+export {};

package/dist-types/packages/peach-engine/src/sootsim-event.d.ts

@@ -0,0 +1,35 @@
+import type { SootsimEventMap as SharedSootsimEventMap } from '../../peach-globals/src/index.d.ts';
+export { SOOTSIM_BOOT_STAGE_ORDER, SOOTSIM_TENANT_READY_MARK } from '../../peach-globals/src/index.d.ts';
+export type { SootsimActiveAppChangeDetail, SootsimBootStage, SootsimBridgeStatusDetail, SootsimEmbedVisibilityDetail, SootsimEngineFailureDetail, SootsimHapticActivityDetail, SootsimHostKeyDetail, SootsimNavigateAppDetail, SootsimNavigateHomeDetail, SootsimSettingsPage, } from '../../peach-globals/src/index.d.ts';
+export interface SootsimEventMap extends SharedSootsimEventMap {
+    'peach:panRecognized': {
+        epochMs: number;
+    };
+    'sootsim:inspectHoverNode': {
+        nodeId: number | null;
+    };
+    'sootsim:inspectSelectNode': {
+        nodeId: number | null;
+    };
+    'sootsim:inspectTreeChange': {
+        kind: 'node' | 'motion';
+    };
+    'sootsim:connectRNLoading': {
+        active: boolean;
+        owner: number;
+        title: string;
+        detail: string;
+    };
+    'sootsim:engine-event': import('./shell-events.d.ts').EngineEvent;
+    'sootsim:shell-command': import('./shell-events.d.ts').ShellCommand;
+    'sootsim:remoteDisplay': {
+        connected: boolean;
+    };
+    'sootsim:compositorAdapter': {
+        isFallbackAdapter: boolean;
+    };
+}
+export type SootsimEventName = keyof SootsimEventMap;
+export declare function dispatchSootsimEvent<K extends SootsimEventName>(name: K, detail: SootsimEventMap[K], target?: EventTarget): void;
+export declare function listenSootsimEvent<K extends SootsimEventName>(name: K, handler: (detail: SootsimEventMap[K]) => void, target?: Pick<EventTarget, 'addEventListener' | 'removeEventListener'>): () => void;
+

package/dist-types/packages/peach-engine/src/top-overlay-state.d.ts

@@ -0,0 +1,5 @@
+export type TopOverlayKind = 'none' | 'notification-center' | 'control-center';
+export declare function isTopOverlayKind(value: unknown): value is TopOverlayKind;
+export declare function isNotificationCenterVisible(overlay: TopOverlayKind): boolean;
+export declare function isControlCenterVisible(overlay: TopOverlayKind): boolean;
+export declare function isTopOverlayVisible(overlay: TopOverlayKind): boolean;

package/dist-types/packages/peach-engine/src/web-authentication-automation-host.d.ts

@@ -0,0 +1,2 @@
+import type { BrowserContext, Page } from 'playwright';
+export declare function automateWebAuthenticationSessions(context: BrowserContext, bindingName: string, shellPage: Page, canPresent: boolean): Promise<void>;

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

@@ -0,0 +1,34 @@
+export type WebAuthenticationCallback = {
+    scheme: string;
+} | {
+    host: string;
+    path: string;
+};
+export type WebAuthenticationResult = {
+    type: 'success';
+    url: string;
+} | {
+    type: 'cancel';
+};
+export type WebAuthenticationHostResult = WebAuthenticationResult | {
+    type: 'prepared';
+    backend: 'external' | 'embedded' | 'unavailable';
+    nativeConsent: boolean;
+};
+export type WebAuthenticationHostRequest = {
+    kind: 'prepare';
+    appId: string;
+} | {
+    kind: 'start';
+    sessionOwner: string;
+    appId: string;
+    url: string;
+    callback: WebAuthenticationCallback | null;
+    ephemeral: boolean;
+} | {
+    kind: 'cancel';
+    sessionOwner: string;
+    appId: string;
+};
+export declare function isWebAuthenticationHostRequest(value: unknown): value is WebAuthenticationHostRequest;
+

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

@@ -0,0 +1,180 @@
+import { createCookieOperations } from '../../peach-compat/src/stubs/native-seams/react-native-cookies.d.ts';
+import type { SootSimWebViewHostRequest, SootSimWebKitEvent } from '../../peach-globals/src/index.d.ts';
+export declare const WEBVIEW_INSTANCE_ATTRIBUTE = "data-peach-webview";
+export declare const WEBVIEW_HOST_BINDING = "__peachWebViewHost";
+export declare const WEBVIEW_EXPO_DOM_PROMPT_CAPABILITY = "peach.webview.expoDomPrompt";
+export declare const WEBVIEW_SCHEME_NAVIGATION_EVENT = "peach:webview-scheme-navigation";
+export declare const WEBVIEW_LOAD_EVENT = "peach:webview-load";
+export type WebViewLoadResult = {
+    kind: 'ok';
+} | {
+    kind: 'httpError';
+    statusCode: number;
+} | {
+    kind: 'refused';
+} | {
+    kind: 'restrictedPort';
+};
+export type WebViewLoadObservation = {
+    frameName: string;
+    instanceId: string;
+    url: string;
+    result: WebViewLoadResult;
+};
+export declare const WEBVIEW_NETWORK_NAVIGATION_EVENT = "peach:webview-network-navigation";
+export type WebViewNetworkNavigation = {
+    instanceId: string;
+    navigation: number;
+    requestId: number;
+    phase: 'redirect' | 'response';
+    url: string;
+    status: number;
+    mime: string;
+    length?: number;
+    headers?: Record<string, string>;
+    method?: string;
+    bodyBase64?: string;
+};
+export type WebViewResponseCookies = {
+    instanceId: string;
+    phase: 'cookies';
+} & Omit<Extract<SootSimWebKitEvent, {
+    event: 'responseCookies';
+}>, 'event'>;
+export declare const WEBVIEW_FRAME_NAME_PREFIX = "peach-webview:";
+export type WebViewNetworkFailure = {
+    instanceId: string;
+    navigation: number;
+    phase: 'failure';
+    url: string;
+    domain: string;
+    code: number;
+    description: string;
+};
+export type WebViewFileRequest = {
+    instanceId: string;
+    navigation: number;
+    requestId: number;
+    phase: 'file';
+    url: string;
+};
+export type WebViewSnapshotReply = {
+    instanceId: string;
+    requestId: number;
+    phase: 'snapshot';
+    pngBase64: string | null;
+};
+export type WebViewSchemeNavigation = {
+    instanceId: string;
+    url: string;
+};
+export type WebViewHostRequest = SootSimWebViewHostRequest;
+export type WebViewHostAttach = Extract<WebViewHostRequest, {
+    kind: 'attach';
+}>;
+export type WebViewHostCall = (request: WebViewHostRequest) => Promise<void>;
+export declare function readWebViewHostRequest(value: unknown): WebViewHostRequest | null;
+export type HeaderEntry = {
+    name: string;
+    value: string;
+};
+export declare function withoutFramingRefusals(headers: HeaderEntry[]): HeaderEntry[];
+export declare function withFrameEmbedderHeaders(headers: HeaderEntry[]): HeaderEntry[];
+export type FirstPartyCookie = {
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+    expires: number;
+    httpOnly: boolean;
+    secure: true;
+    sameSite: 'None';
+};
+export declare function firstPartyCookie(line: string, url: string): FirstPartyCookie | null;
+export declare function webViewBeforeContentScript(beforeKey: string, source: string): string;
+export declare function webViewEvaluationScripts(js: string): [string, string, string];
+export declare function isAppSchemeUrl(url: string): boolean;
+export declare function isSameDocumentRequest(requested: string, url: string): boolean;
+export declare function redirectRequestHeaders(headers: Record<string, string>, from: string, to: string, discardBody?: boolean): Record<string, string>;
+export type WebViewAutomationNames = {
+    hostBinding: string;
+    instanceAttribute: string;
+    schemeNavigationEvent: string;
+    networkNavigationEvent: string;
+    loadEvent: string;
+    configTimingName: string;
+    bootstrapSource: string;
+};
+export type WebViewAutomationHelpers = {
+    cookieOperations: typeof createCookieOperations;
+    readRequest: typeof readWebViewHostRequest;
+    withoutFramingRefusals: typeof withoutFramingRefusals;
+    withFrameEmbedderHeaders: typeof withFrameEmbedderHeaders;
+    firstPartyCookie: typeof firstPartyCookie;
+    beforeContentScript: typeof webViewBeforeContentScript;
+    evaluationScripts: typeof webViewEvaluationScripts;
+    isAppScheme: typeof isAppSchemeUrl;
+    isSameDocument: typeof isSameDocumentRequest;
+    redirectRequestHeaders: typeof redirectRequestHeaders;
+};
+export declare const webViewAutomationHelpers: WebViewAutomationHelpers;
+export declare function webViewAutomationHelpersSource(): string;
+export declare function webViewAutomationNames(timingName: string, bootstrapSource: string): WebViewAutomationNames;
+type CdpSession = {
+    send(method: string, params?: Record<string, unknown>): Promise<any>;
+    detach(): Promise<void>;
+    on(event: string, listener: (event: any) => void): unknown;
+    off(event: string, listener: (event: any) => void): unknown;
+};
+type WebViewAutomationEvent = WebViewSchemeNavigation | WebViewNetworkNavigation | WebViewResponseCookies | WebViewNetworkFailure | WebViewFileRequest | WebViewSnapshotReply | WebViewLoadObservation;
+type AutomatedPage = {
+    on(event: 'framenavigated', listener: (frame: AutomatedFrame) => void): unknown;
+    on(event: 'dialog', listener: (dialog: AutomatedDialog) => void): unknown;
+    mouse: {
+        click(x: number, y: number): Promise<void>;
+    };
+    mainFrame(): AutomatedFrame;
+    frames(): AutomatedFrame[];
+    workers(): AutomatedWorker[];
+    evaluate(fn: (args: [string, WebViewAutomationEvent]) => void, args: [string, WebViewAutomationEvent]): Promise<void>;
+};
+type AutomatedDialog = {
+    type(): string;
+    message(): string;
+    accept(promptText?: string): Promise<void>;
+    dismiss(): Promise<void>;
+};
+type AutomatedWorker = {
+    evaluate<T>(fn: (args: T) => unknown, args: T): Promise<unknown>;
+};
+type AutomatedFrame = {
+    evaluate<T>(fn: (args: T) => void, args: T): Promise<void>;
+    page(): AutomatedPage;
+    parentFrame(): AutomatedFrame | null;
+    frameElement(): Promise<{
+        getAttribute(name: string): Promise<string | null>;
+    }>;
+};
+export declare function automateWebViewFrames(context: {
+    browser(): {
+        newBrowserCDPSession(): Promise<CdpSession>;
+    } | null;
+    newCDPSession(target: unknown): Promise<CdpSession>;
+    addInitScript(script: {
+        content: string;
+    }): Promise<unknown>;
+    on(event: 'page', listener: (page: AutomatedPage) => void): unknown;
+    on(event: 'close', listener: () => void): unknown;
+    pages(): AutomatedPage[];
+    addCookies(cookies: FirstPartyCookie[]): Promise<void>;
+    clearCookies(filter: {
+        name: string;
+        domain: string;
+        path: string;
+    }): Promise<void>;
+    exposeBinding(name: string, callback: (source: {
+        frame: AutomatedFrame;
+        page: AutomatedPage;
+    }, request: unknown) => Promise<void>): Promise<unknown>;
+}, names: WebViewAutomationNames, helpers: WebViewAutomationHelpers, tenantWorkers: (page: AutomatedPage) => AutomatedWorker[]): Promise<void>;
+export {};

package/dist-types/packages/peach-engine/src/wireframe-mode.d.ts

@@ -0,0 +1,16 @@
+export type WireframeStyle = 'clean' | 'sketch' | 'hatch' | 'onebit' | 'dots' | 'blueprint' | 'panel' | 'green';
+export type WireframeRgba = [number, number, number, number];
+export interface WireframeModeConfig {
+    style: WireframeStyle;
+    ink: WireframeRgba | null;
+    paper: WireframeRgba | null;
+    wallpaper: boolean;
+}
+export declare const WIREFRAME_WALLPAPER_PARAM = "wireframeWallpaper";
+export declare function isWireframeStyle(value: unknown): value is WireframeStyle;
+export declare function getWireframeMode(): WireframeModeConfig | null;
+export declare function setWireframeMode(next: WireframeStyle | Partial<WireframeModeConfig> | null): WireframeModeConfig | null;
+export declare function registerWireframePresenter(present: (next: WireframeStyle | null) => void): void;
+export declare function applyWireframeMode(next: WireframeStyle | null): void;
+export declare function subscribeWireframeMode(cb: () => void): () => void;
+

package/dist-types/packages/peach-globals/src/frameBreakdownContract.d.ts

@@ -0,0 +1,16 @@
+export declare const FRAME_PRESENTATION_REQUEST_KEY = "presentation";
+export declare const FRAME_WORK: readonly ['react commit', 'tenant frame', 'worklet call', 'sync wait', 'javascript frame', 'native frame', 'object-path handback', 'layout', 'paint', 'record', 'submit', 'submit-to-done bound', 'pipeline creation', 'raster miss', 'glyph build', 'mask build', 'javascript task', 'frame request', 'ui frame', 'ui pose', 'ui frame wait'];
+export type FrameWork = (typeof FRAME_WORK)[number];
+export type FrameRealm = 'page' | 'tenant' | 'ui' | 'compositor';
+export type FrameWorkSpan = {
+    from: number;
+    to: number;
+    realm: FrameRealm;
+    instance: number;
+    work: FrameWork;
+    key?: string;
+};
+export type FrameBreakdownCapture = {
+    spans: FrameWorkSpan[];
+    dropped: number;
+};