peachsim 0.1.1644 → 0.1.1653

package/dist-types/packages/peach-engine/src/platform/android-back-panel.d.ts

@@ -0,0 +1,131 @@
+export declare const ANDROID_BACK_PANEL_WIDTH = 105;
+export declare const ANDROID_BACK_PANEL_HEIGHT = 268;
+export declare const ANDROID_BACK_ARROW_THICKNESS = 4;
+export declare function androidSpringHasSettled(input: {
+    value: number;
+    velocity: number;
+    finalPosition: number;
+    minimumVisibleChange: number;
+}): boolean;
+export interface SpringForce {
+    stiffness: number;
+    dampingRatio: number;
+}
+export declare function stepSpring(spring: SpringForce, finalPosition: number, value: number, velocity: number, elapsedMs: number): {
+    value: number;
+    velocity: number;
+};
+export interface SpringAnimationLifecycle {
+    running: boolean;
+    lastFrameTime: number;
+    finalPosition: number;
+    pendingPosition: number | null;
+}
+export declare function setSpringAnimationTarget(lifecycle: SpringAnimationLifecycle, position: number): boolean;
+export declare function endSpringAnimation(lifecycle: SpringAnimationLifecycle): void;
+export declare function stepSpringWithPendingTarget(input: {
+    spring: SpringForce;
+    finalPosition: number;
+    pendingPosition: number | null;
+    value: number;
+    velocity: number;
+    elapsedMs: number;
+}): {
+    value: number;
+    velocity: number;
+    finalPosition: number;
+};
+declare class MainHandler {
+    private readonly pending;
+    postDelayed(runnable: () => void, delayMs: number): void;
+    removeCallbacks(runnable: () => void): void;
+}
+export interface AndroidBackPanelFrame {
+    isLeftPanel: boolean;
+    left: number;
+    top: number;
+    horizontalTranslation: number;
+    verticalTranslation: number;
+    scale: number;
+    scalePivotX: number;
+    arrowLength: number;
+    arrowHeight: number;
+    arrowAlpha: number;
+    backgroundAlpha: number;
+    backgroundWidth: number;
+    backgroundHeight: number;
+    backgroundEdgeCornerRadius: number;
+    backgroundFarCornerRadius: number;
+}
+export declare const androidBackPanelSignal: import("../engine/signal.d.ts").Signal<AndroidBackPanelFrame | null>;
+export interface AndroidBackPanelCallbacks {
+    triggerBack(): void;
+    cancelBack(): void;
+}
+export interface AndroidBackPanelMotionEvent {
+    action: 'down' | 'move' | 'up' | 'cancel';
+    x: number;
+    y: number;
+    eventTime: number;
+}
+export declare class AndroidBackPanelController {
+    private readonly callbacks;
+    readonly handler: MainHandler;
+    private readonly view;
+    private readonly params;
+    private currentState;
+    private previousState;
+    private displayHeight;
+    private fullyStretchedThreshold;
+    private previousXTranslationOnActiveOffset;
+    private previousXTranslation;
+    private totalTouchDeltaActive;
+    private totalTouchDeltaInactive;
+    private touchDeltaStartX;
+    private velocitySamples;
+    private lastVelocityEventTime;
+    private startX;
+    private startY;
+    private gestureEntryTime;
+    private gestureInactiveTime;
+    private pastThresholdWhileEntryOrInactiveTime;
+    private entryToActiveDelay;
+    private hasPassedDragSlop;
+    private previousPreThresholdWidthInterpolator;
+    private readonly failsafeRunnable;
+    private readonly onEndSetCommittedStateListener;
+    private readonly onEndSetGoneStateListener;
+    private readonly onAlphaEndSetGoneStateListener;
+    constructor(callbacks: AndroidBackPanelCallbacks);
+    get elapsedTimeSinceEntry(): number;
+    private get elapsedTimeSinceInactive();
+    setDisplay(display: {
+        width: number;
+        height: number;
+        density: number;
+    }): void;
+    setIsLeftPanel(isLeftPanel: boolean): void;
+    private addVelocityMovement;
+    private velocityX;
+    onMotionEvent(event: AndroidBackPanelMotionEvent): void;
+    private cancelAllPendingAnimations;
+    private dragSlopExceeded;
+    private updateArrowStateOnMove;
+    private handleMoveEvent;
+    private setArrowStrokeAlpha;
+    private setVerticalTranslation;
+    private stretchActiveBackIndicator;
+    private stretchEntryBackIndicator;
+    private preThresholdWidthStretchAmount;
+    private stretchInactiveBackIndicator;
+    private isFlungAwayFromEdge;
+    private isPastThresholdToActive;
+    private playWithBackgroundWidthAnimation;
+    private updateYStartPosition;
+    private updateRestingArrowDimens;
+    private updateArrowState;
+    private convertVelocityToAnimationFactor;
+    private scheduleFailsafe;
+    private cancelFailsafe;
+}
+export {};

package/dist-types/packages/peach-engine/src/platform/android-gesture-exclusion.d.ts

@@ -0,0 +1,28 @@
+export declare const ANDROID_SYSTEM_GESTURE_EXCLUSION_RECTS_PROP = "sootsimAndroidSystemGestureExclusionRects";
+export declare const ANDROID_GESTURE_EXCLUSION_MAX_HEIGHT_DP = 200;
+export interface AndroidGestureExclusionRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface AndroidGestureExclusionSource {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rects: unknown;
+    visible?: boolean;
+}
+export interface AndroidGestureExclusionPolicy {
+    windowType: 'application' | 'home' | 'ime';
+    stickyImmersive: boolean;
+    transientNavigationBarShown?: boolean;
+    edgeWidth: number;
+}
+export declare function collectAndroidGestureExclusionRects(sources: readonly AndroidGestureExclusionSource[], viewport: {
+    width: number;
+    height: number;
+}): AndroidGestureExclusionRect[];
+export declare function androidGestureExclusionContains(rects: readonly AndroidGestureExclusionRect[], x: number, y: number): boolean;
+export declare function applyAndroidGestureExclusionPolicy(rects: readonly AndroidGestureExclusionRect[], viewportWidth: number, policy: AndroidGestureExclusionPolicy): AndroidGestureExclusionRect[];

package/dist-types/packages/peach-engine/src/platform/android-predictive-back.d.ts

@@ -0,0 +1,33 @@
+import { type SpringAnimationLifecycle } from './android-back-panel.d.ts';
+export type AndroidPredictiveBackPhase = 'started' | 'progressed' | 'cancelled' | 'invoked';
+export declare const ANDROID_BACK_LINEAR_PROGRESS_DISTANCE_DP = 412;
+export declare const ANDROID_BACK_NON_LINEAR_PROGRESS_FACTOR = 0.2;
+export declare function resolveAndroidPredictiveBackProgress(input: {
+    inwardDistance: number;
+    windowWidth: number;
+}): number;
+export declare function advanceAndroidPredictiveBackOrigin(input: {
+    origin: number | null;
+    touchX: number;
+    edge: 'left' | 'right';
+}): number;
+export declare const ANDROID_BACK_PROGRESS_SPRING_STIFFNESS = 1500;
+export declare const ANDROID_BACK_PROGRESS_SPRING_DAMPING_RATIO = 1;
+export interface AndroidBackProgressSpring extends SpringAnimationLifecycle {
+    value: number;
+    velocity: number;
+}
+export declare function createAndroidBackProgressSpring(): AndroidBackProgressSpring;
+export declare function setAndroidBackProgressTarget(spring: AndroidBackProgressSpring, rawProgress: number): void;
+export declare function resetAndroidBackProgressSpring(spring: AndroidBackProgressSpring): void;
+export declare function advanceAndroidBackProgressFrame(spring: AndroidBackProgressSpring, frameTimeMs: number, cancelling: boolean): {
+    posts: Array<{
+        phase: 'progressed' | 'cancelled';
+        progress: number;
+    }>;
+    settled: boolean;
+};
+export declare function stepAndroidBackProgressSpring(spring: AndroidBackProgressSpring, frameTimeMs: number): {
+    progress: number;
+    settled: boolean;
+};

package/dist-types/packages/peach-engine/src/platform/system-bars-state.d.ts

@@ -0,0 +1,14 @@
+import type { AndroidSystemBarState, AndroidSystemBarsPatch, AndroidSystemBarsState } from '../render-worker/native-ui-protocol.d.ts';
+export declare const DEFAULT_ANDROID_SYSTEM_BARS_STATE: AndroidSystemBarsState;
+export type AndroidSystemBarsWindow = 'app' | 'launcher';
+type Listener = () => void;
+export declare function getAndroidSystemBarsState(): AndroidSystemBarsState;
+export declare function subscribeAndroidSystemBars(listener: Listener): () => void;
+export declare function replaceAndroidSystemBarsState(next: AndroidSystemBarsState): boolean;
+export declare function applyAndroidSystemBarsPatch(patch: AndroidSystemBarsPatch): boolean;
+export declare function mergeAndroidSystemBarsPatch(state: AndroidSystemBarsState, patch: AndroidSystemBarsPatch): AndroidSystemBarsState;
+export declare function setAndroidSystemBarsRevealed(revealed: boolean): boolean;
+export declare function resolveAndroidSystemBarsWindow(shellState: string, activeAppId: string | null | undefined): AndroidSystemBarsWindow;
+export declare function resolveAndroidSystemBarsForWindow(appBars: AndroidSystemBarsState, window: AndroidSystemBarsWindow): AndroidSystemBarsState;
+export declare function resolveSystemBarForegroundColor(style: AndroidSystemBarState['style'], fallback: 'light' | 'dark'): string;
+export {};

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

@@ -0,0 +1 @@
+export declare const PLAYWRIGHT_SIM_HOST: string;

package/dist-types/packages/peach-engine/src/preview/bundle-layout.d.ts

@@ -0,0 +1,8 @@
+export type TextBundleFormat = 'metro' | 'vxrn' | 'unknown';
+export declare function textBundleFormat(source: string): TextBundleFormat;
+export declare function isRolldownBundle(bundleText: string): boolean;
+export declare function isNativeJavaScriptBundle(source: string): boolean;
+export declare const MIN_NAMED_MODULES = 5;
+export declare function bootReadsBundleLayout(source: string): boolean;
+export declare function scanMetroOrVxrnModuleNames(source: string, format: Exclude<TextBundleFormat, 'unknown'>): Set<string>;
+export declare function scanMetroDeclaredSpecifiers(source: string): Set<string>;

package/dist-types/packages/peach-engine/src/preview/bundle-variantContract.d.ts

@@ -0,0 +1,24 @@
+import type { PeachConfig } from '../config.d.ts';
+export declare const PREVIEW_BUNDLE_DEFAULT_MODULE_CONFIG = "default-v1";
+export declare const PREVIEW_BUNDLE_IDENTITY_CHECKED_HEADER = "Peach-Bundle-Identity-Checked";
+export type PreviewBundleStripModule = {
+    id: number;
+    name: string;
+};
+export type PreviewBundleStripCapture = {
+    moduleConfig: typeof PREVIEW_BUNDLE_DEFAULT_MODULE_CONFIG;
+    modules: PreviewBundleStripModule[];
+};
+export type PreviewBundleStripDescriptor = PreviewBundleStripCapture & {
+    engineBuildIdentity: string;
+};
+export declare function isEngineBuildIdentity(value: unknown): value is string;
+export declare function parsePreviewBundleStripDescriptor(value: unknown): PreviewBundleStripDescriptor | null;
+export declare function applyPreviewBundleVariant(bundleUrl: string, engineBuildIdentity: string, config?: PeachConfig | null): string;
+type EngineManifestDocument = {
+    getElementById(id: string): {
+        textContent: string | null;
+    } | null;
+};
+export declare function readEngineBuildIdentity(sourceDocument?: EngineManifestDocument | null): string | null;
+export {};

package/dist-types/packages/peach-engine/src/preview/capture-bundle.d.ts

@@ -0,0 +1,26 @@
+
+export type SnapshotDeviceSpec = {
+    model?: string;
+    width: number;
+    height: number;
+    cornerRadius?: number;
+    statusBarHeight?: number;
+    homeIndicatorHeight?: number;
+    dynamicIslandWidth?: number;
+};
+export type BundleSnapshot = {
+    bundleUrl: string | null;
+    entry: string | null;
+    deviceSpec: SnapshotDeviceSpec;
+    runtimeVersion: string | null;
+    pageHref: string;
+    storageScopeUrl: string;
+    bundleNativeAppIdentityHeader?: string | null;
+    transformedBundle: {
+        url: string;
+        byteLength: number;
+        timestamp: number;
+    } | null;
+};
+export declare function captureBundleSnapshot(): BundleSnapshot;
+export declare function installCaptureBundleGlobal(): void;

package/dist-types/packages/peach-engine/src/preview/compress-node.d.ts

@@ -0,0 +1,2 @@
+export declare const BUNDLE_BROTLI_QUALITY = 9;
+export declare function brotliBundle(bytes: Uint8Array | Buffer): Buffer;

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

@@ -0,0 +1,2 @@
+export declare function shouldCompress(contentType: string): boolean;
+export declare function bytesToBase64(bytes: Uint8Array): string;

package/dist-types/packages/peach-engine/src/preview/presigned-upload.d.ts

@@ -0,0 +1,60 @@
+import type { PreviewUploadFinalizeResponse, PreviewUploadInitRequest, PreviewUploadInitResponse } from './upload-protocol.d.ts';
+export type { PreviewUploadFileRequest as InitRequestFile, PreviewUploadFinalizeResponse as FinalizeResponse, PreviewUploadInitRequest as InitRequestBody, PreviewUploadInitResponse as InitResponse, PreviewUploadPresignedSlot as PresignedSlot, PreviewUploadSnapshotRequest as InitRequestSnapshot, } from './upload-protocol.d.ts';
+export interface PutJob {
+    url: string;
+    contentType: string;
+    bytes: Uint8Array;
+}
+export declare const PRESIGNED_UPLOAD_TIMEOUTS: {
+    initMs: number;
+    putBaseMs: number;
+    putFloorBytesPerSecond: number;
+    finalizeMs: number;
+};
+export declare function canonicalPublicPreviewOrigin(origin: string): string;
+export declare function parallelPuts(jobs: PutJob[], concurrency?: number, onProgress?: (done: number, total: number) => void): Promise<void>;
+export interface PresignedUploadExtras {
+    eventsBytes?: Uint8Array;
+    timelineBytes?: Uint8Array;
+    videoBytes?: Uint8Array;
+    sceneStreamBytes?: Uint8Array;
+    storageBytes?: Uint8Array;
+    failureBundleBytes?: Uint8Array;
+    snapshotBytes?: Map<string, Uint8Array>;
+}
+export interface PresignedUploadInputs {
+    originBase: string;
+    endpoints?: {
+        init: string;
+        finalize: string;
+    };
+    initBody: PreviewUploadInitRequest;
+    bundleBytes?: Uint8Array;
+    filesByHash: Map<string, Uint8Array>;
+    extras?: PresignedUploadExtras;
+    authHeader?: string;
+    accountId?: string | null;
+    adminBypassToken?: string;
+    concurrency?: number;
+    onPutProgress?: (done: number, total: number) => void;
+    onRemainingBudget?: (remainingMs: number) => void;
+}
+export declare function buildPutJobs(init: PreviewUploadInitResponse, bundleBytes: Uint8Array | undefined, filesByHash: Map<string, Uint8Array>, extras?: PresignedUploadExtras): PutJob[];
+export declare class PresignedUploadError extends Error {
+    readonly status: number;
+    readonly phase: 'init' | 'finalize';
+    readonly responseText: string;
+    constructor(message: string, status: number, phase: 'init' | 'finalize', responseText?: string);
+}
+export interface PresignedUploadTiming {
+    initMs: number;
+    putMs: number;
+    finalizeMs: number;
+    initServerTiming: string | null;
+    finalizeServerTiming: string | null;
+}
+export declare function runPresignedUpload(inputs: PresignedUploadInputs): Promise<{
+    init: PreviewUploadInitResponse;
+    finalize: PreviewUploadFinalizeResponse;
+    timing: PresignedUploadTiming;
+}>;

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

@@ -0,0 +1,144 @@
+export { isTimelineEvent as isTraceTimelineEvent } from '../../../peach-globals/src/index.d.ts';
+import type { SootSimReplayEvent, SootSimTimelineEvent } from '../../../peach-globals/src/index.d.ts';
+export declare const TRACE_CAPTURE_PREROLL_MS = 10000;
+export declare const TRACE_CAPTURE_POSTROLL_MS = 5000;
+export declare const TRACE_JANK_BUDGET_MS = 16.7;
+export type TraceFrameStats = {
+    frames: number;
+    avgMs?: number;
+    p95Ms?: number;
+    maxMs?: number;
+    jankFrames?: number;
+    elapsedMs?: number;
+    layoutAvgMs?: number;
+    renderAvgMs?: number;
+    copyAvgMs?: number;
+    missedTicks?: number;
+    hitches?: number;
+};
+export type TraceSnapshotLike = {
+    id: string;
+    label?: string | null;
+    kind?: string | null;
+    eventIndex?: number | null;
+    t?: number | null;
+    width?: number | null;
+    height?: number | null;
+};
+export type TraceStepIndexEntry = {
+    id: string;
+    actionIndex: number | null;
+    startMs: number;
+    endMs: number;
+    durationMs: number;
+    label: string;
+    actionType: string;
+    targetLabel?: string;
+    snapshotId?: string;
+    status?: 'success' | 'failure' | 'skipped';
+    error?: string;
+    timelineCount: number;
+    networkCount: number;
+    logCount: number;
+    frameStats?: TraceFrameStats | null;
+};
+export type TraceStep = TraceStepIndexEntry & {
+    action?: SootSimReplayEvent;
+    snapshot?: TraceSnapshotLike | null;
+    timelineEvents: SootSimTimelineEvent[];
+};
+export type BuildTraceInput = {
+    actions?: readonly SootSimReplayEvent[] | null;
+    snapshots?: readonly TraceSnapshotLike[] | null;
+    timelineEvents?: readonly SootSimTimelineEvent[] | null;
+    recordedDurationMs?: number | null;
+    recordingStartedAtMs?: number | null;
+    frameStats?: TraceFrameStats | null;
+};
+export declare function normalizeTraceFrameStats(value: unknown): TraceFrameStats | null;
+export declare function isTraceAction(value: unknown): value is SootSimReplayEvent;
+export declare function parseTraceJsonl<T>(text: string, isItem: (value: unknown) => value is T): T[];
+export declare function parseTraceActionsJsonl(text: string): SootSimReplayEvent[];
+export declare function describeTimelineEvent(event: SootSimTimelineEvent): string | undefined;
+export type TraceDriveToolCall = {
+    toolName: string;
+    durationMs?: number;
+    timedOut?: boolean;
+    outputSummary?: string;
+};
+export type TraceDriveStep = {
+    stepNumber: number;
+    finishReason: string;
+    text?: string;
+    startedAtMs?: number;
+    endedAtMs?: number;
+    toolCalls: TraceDriveToolCall[];
+};
+export type TraceDriveLog = {
+    startedAtMs: number | null;
+    endedAtMs: number | null;
+    status: 'success' | 'failure' | null;
+    error: string | null;
+    steps: TraceDriveStep[];
+};
+export declare function parseTraceDriveLogJsonl(text: string): TraceDriveLog | null;
+export declare function parseTraceTimelineJsonl(text: string): SootSimTimelineEvent[];
+export declare function relativeTimelineMs(event: Pick<SootSimTimelineEvent, 't'>, recordingStartedAtMs?: number | null): number;
+export declare function traceTimelineOriginMs(input: BuildTraceInput): number | null;
+export type TraceFrameSample = {
+    relMs: number;
+    totalMs: number;
+    layoutMs: number;
+    renderMs: number;
+    copyMs: number;
+};
+export declare function traceFrameSamples(events: readonly SootSimTimelineEvent[], recordingStartedAtMs?: number | null): TraceFrameSample[];
+export type TraceReactCause = 'state' | 'props' | 'context' | 'mount' | 'parent';
+export type TraceReactComponentStat = {
+    displayName: string;
+    renders: number;
+    totalMs: number;
+    maxMs: number;
+    causes: Record<TraceReactCause, number>;
+    changedKeys: string[];
+};
+export type TraceReactStats = {
+    commits: number;
+    totalMs: number;
+    maxCommitMs: number;
+    components: TraceReactComponentStat[];
+};
+export type TraceBreakdownLaneId = 'rendering' | 'react' | 'network' | 'animations';
+export type TraceBreakdownSegment = {
+    lane: TraceBreakdownLaneId;
+    startMs: number;
+    endMs: number;
+    durationMs: number;
+    label: string;
+    tone?: 'warn' | 'error';
+};
+export type TraceBreakdownLane = {
+    id: TraceBreakdownLaneId;
+    label: string;
+    totalMs: number;
+    count: number;
+    segments: TraceBreakdownSegment[];
+};
+export type TraceStepBreakdown = {
+    durationMs: number;
+    knownMs: number;
+    idleMs: number;
+    lanes: TraceBreakdownLane[];
+    frameTotals: {
+        frames: number;
+        jankFrames: number;
+        totalMs: number;
+        layoutMs: number;
+        renderMs: number;
+        copyMs: number;
+    };
+};
+export declare function traceReactStats(events: readonly SootSimTimelineEvent[]): TraceReactStats | null;
+export declare function traceStepBreakdown(step: Pick<TraceStep, 'startMs' | 'endMs'>, events: readonly SootSimTimelineEvent[], frameSamples: readonly TraceFrameSample[], recordingStartedAtMs?: number | null): TraceStepBreakdown;
+export declare function buildTraceStepIndex(input: BuildTraceInput): TraceStepIndexEntry[];
+export declare function buildTraceSteps(input: BuildTraceInput): TraceStep[];

package/dist-types/packages/peach-engine/src/preview/upload-protocol.d.ts

@@ -0,0 +1,152 @@
+import type { RemotePeerIdentity } from '../remote-stream/cloud-display.d.ts';
+import type { PreviewBundleStripDescriptor } from './bundle-variantContract.d.ts';
+import type { TraceFrameStats } from './trace.d.ts';
+import type { PreviewCaptureKind } from '../../../peach-globals/src/index.d.ts';
+export type PreviewUploadShareKind = 'flow' | 'build';
+export type PreviewUploadDeviceSpec = {
+    model?: string;
+    width: number;
+    height: number;
+    cornerRadius?: number;
+    statusBarHeight?: number;
+    homeIndicatorHeight?: number;
+    dynamicIslandWidth?: number;
+};
+export type PreviewUploadFileRequest = {
+    url: string;
+    urlhash: string;
+    contentHash?: string;
+    replayKey?: string;
+    sequence?: number;
+    method: string;
+    bodyHash: string;
+    callHash?: string;
+    requestVaryHash?: string;
+    status?: number;
+    contentType: string;
+    responseHeaders?: Array<{
+        name: string;
+        value: string;
+    }>;
+    encoding: 'gzip' | undefined;
+    sizeBytes: number;
+};
+export type PreviewSnapshotContentType = 'image/png' | 'image/webp';
+export type PreviewUploadSnapshotRequest = {
+    id?: string;
+    label?: string;
+    kind?: 'landing' | 'interaction' | 'final' | 'manual' | 'failure';
+    eventIndex?: number;
+    t?: number;
+    width?: number;
+    height?: number;
+    contentType?: PreviewSnapshotContentType;
+    sizeBytes: number;
+};
+export type { PreviewCaptureKind } from '../../../peach-globals/src/index.d.ts';
+export type PreviewUploadInitRequest = {
+    kind?: PreviewUploadShareKind;
+    buildPlatform?: 'ios' | 'android';
+    contentHash: string;
+    hasBundle?: boolean;
+    bundleSizeBytes?: number;
+    bundleContentType?: string;
+    bundleNativeAppIdentityHeader?: string | null;
+    bundleEncoding?: 'gzip' | 'br';
+    bundleMinified?: boolean;
+    bundleStrip?: PreviewBundleStripDescriptor;
+    bundleOrigin?: string | null;
+    appFonts?: string | null;
+    appManifest?: string | null;
+    appSplash?: string | null;
+    runtimeVersion?: string | null;
+    entry?: string | null;
+    isTransformed?: boolean;
+    deviceSpec: PreviewUploadDeviceSpec;
+    files: PreviewUploadFileRequest[];
+    events?: {
+        sizeBytes: number;
+        encoding?: 'gzip';
+    };
+    timeline?: {
+        sizeBytes: number;
+        encoding?: 'gzip';
+    };
+    flowVideo?: {
+        sizeBytes: number;
+        contentType: string;
+        durationMs?: number;
+    };
+    sceneStream?: {
+        sizeBytes: number;
+        durationMs: number;
+        peer: RemotePeerIdentity;
+    };
+    traceFrameStats?: TraceFrameStats;
+    recordedDurationMs?: number;
+    recordingStartedAtMs?: number;
+    capture?: PreviewCaptureKind;
+    storage?: {
+        sizeBytes: number;
+        encoding?: 'gzip';
+    };
+    failureBundle?: {
+        sizeBytes: number;
+        encoding?: 'gzip';
+    };
+    snapshots?: PreviewUploadSnapshotRequest[];
+    installationId?: string;
+    repoId?: string;
+    owner?: string;
+    repo?: string;
+    billingKind?: 'test_run';
+    runnerJobId?: string;
+    runScope?: string;
+    branch?: string;
+    commitSha?: string;
+    githubUsername?: string;
+    pullRequestNumber?: number;
+    pullRequestTitle?: string;
+};
+export type PreviewUploadPresignedSlot = {
+    putUrl: string;
+    objectKey: string;
+    contentType: string;
+};
+export type PreviewUploadFileSlot = (PreviewUploadPresignedSlot & {
+    urlhash: string;
+}) | {
+    urlhash: string;
+    skipped: true;
+    objectKey: string;
+    contentType: string;
+};
+export type PreviewUploadInitResponse = {
+    shareId: string;
+    token: string;
+    expiresAt: number;
+    bundle: PreviewUploadPresignedSlot | null;
+    files: PreviewUploadFileSlot[];
+    events: PreviewUploadPresignedSlot | null;
+    timeline: PreviewUploadPresignedSlot | null;
+    flowVideo: PreviewUploadPresignedSlot | null;
+    sceneStream: PreviewUploadPresignedSlot | null;
+    storage: PreviewUploadPresignedSlot | null;
+    failureBundle: PreviewUploadPresignedSlot | null;
+    snapshots: Array<PreviewUploadPresignedSlot & {
+        id: string;
+    }>;
+};
+export type PreviewUploadFinalizeRequest = {
+    token: string;
+};
+export type PreviewUploadFinalizeResponse = {
+    id: string;
+    url: string;
+    contentHash?: string;
+    filesStored?: number;
+    thumbnailKey?: string;
+    snapshotsStored?: number;
+    createdAt?: number;
+    visibility?: 'private' | 'public';
+};

package/dist-types/packages/peach-engine/src/profiler/animation-recording-loader.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-types/packages/peach-engine/src/profiler/profile-trace.d.ts

@@ -0,0 +1,4 @@
+export { profileFrameRows, profileTimelineRows, mergeProfileTimeline, isProfileFile, } from '../../../peach-globals/src/profileTrace.d.ts';
+import { type ProfileFile, type ProfileResult } from '../../../peach-globals/src/profilerContract.d.ts';
+import type { TraceFrameStats } from '../preview/trace.d.ts';
+export declare function profileFrameSummary(profile: ProfileResult | ProfileFile): TraceFrameStats;

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

@@ -0,0 +1,3 @@
+export * from '../../peach-kit/src/runtime.d.ts';
+export { default } from '../../peach-kit/src/runtime.d.ts';
+export { bindReact } from '../../peach-kit/src/internal.d.ts';