pup-recorder 0.4.0 → 0.4.3

package/dist/_tsup-dts-rollup.d.ts

@@ -3,36 +3,57 @@ import { AV_SAMPLE_FMT_FLTP } from 'node-av/constants';
 import { AVColorRange } from 'node-av/constants';
 import { AVPixelFormat } from 'node-av/constants';
 import { BrowserWindow } from 'electron';
-import { ChildProcess } from 'child_process';
+import { ChildProcess } from 'node:child_process';
 import { Codec } from 'node-av';
 import { CodecContext } from 'node-av';
-import { Debugger } from 'electron';
-import { EventEmitter } from 'events';
+import type { Debugger } from 'electron';
+import { Demuxer } from 'node-av/api';
+import { EventEmitter } from 'node:events';
 import { FFAudioEncoder } from 'node-av/constants';
-import { FFVideoEncoder } from 'node-av/constants';
+import type { FFVideoEncoder } from 'node-av/constants';
 import { FormatContext } from 'node-av';
 import { Frame } from 'node-av';
 import { HardwareContext } from 'node-av/api';
 import { HardwareFramesContext } from 'node-av';
 import type { NativeImage } from 'electron';
 import { Packet } from 'node-av';
-import { Size } from 'electron';
+import type { Size } from 'electron';
 import { SoftwareScaleContext } from 'node-av';
-import { SpawnOptions } from 'child_process';
+import { SpawnOptions } from 'node:child_process';
 import { Stream } from 'node-av';
-import { WebContents } from 'electron';
+import type { WebContents } from 'electron';
 import type { WebFrameMain } from 'electron';
 import z from 'zod';
 
+export declare function abortable<T>(p: Promise<T>, signal?: AbortSignal): Promise<T>;
+
 /** Insert emulation prevention bytes (00 00 03) for Annex B compliance. */
 export declare function addEmulationPrevention(nal: Buffer): Buffer;
 
-export declare function advanceVideos(frame: WebFrameMain | undefined, timestampMs: number): Promise<void>;
+export declare function advance(hook: VideoHook, timestampMs: number): Promise<unknown>;
+
+export declare interface AdvanceOptions {
+    frame: WebFrameMain | undefined;
+    timestampMs: number;
+    signal?: AbortSignal;
+}
+
+export declare function advanceVideos({ frame, timestampMs, signal }: AdvanceOptions): Promise<void>;
 
 export declare function advanceVirtualTime(cdp: Debugger, budget: number): Promise<void>;
 
+export declare const AHEAD = 10;
+
 export declare const ANNEX_B_START_CODE: Buffer<ArrayBuffer>;
 
+export declare interface AttachArgs {
+    video: HTMLVideoElement;
+    state: VideoState;
+    src: string;
+    birthMs: number;
+    native: boolean;
+}
+
 export declare function attachAudioListeners({ wc, encoder, getVideoTimeMs, onError }: AudioListenerOptions): AudioDisposal;
 
 export declare const AUDIO_CHUNK_CHANNEL = "audio-chunk";
@@ -123,7 +144,7 @@ export declare function buildStegoHTML(targetURL: string, size: Size): string;
 export declare function buildUnifiedExtradata(opts: UnifiedExtradataOptions): Buffer;
 
 export declare interface CancelMsg {
-    type: IpcMsgType.CANCEL;
+    type: IpcMsgType.Cancel;
     reason?: string;
 }
 
@@ -158,7 +179,7 @@ declare class CodecState_2 implements Disposable {
 }
 export { CodecState_2 as CodecState }
 
-declare class ConcurrencyLimiter {
+export declare class ConcurrencyLimiter {
     readonly maxConcurrency: number;
     private _active;
     private _queue;
@@ -173,15 +194,11 @@ declare class ConcurrencyLimiter {
     private flush;
     private next;
 }
-export { ConcurrencyLimiter }
-export { ConcurrencyLimiter as ConcurrencyLimiter_alias_1 }
 
-declare type ConsoleCallback = (level: string, message: string) => void;
-export { ConsoleCallback }
-export { ConsoleCallback as ConsoleCallback_alias_1 }
+export declare type ConsoleCallback = (level: string, message: string) => void;
 
 export declare interface ConsoleMsg {
-    type: IpcMsgType.CONSOLE;
+    type: IpcMsgType.Console;
     level: string;
     message: string;
 }
@@ -192,21 +209,39 @@ export declare function createStegoURL(src: string, size: Size): string;
 
 export declare function debounce<T extends (...args: unknown[]) => void>(fn: T, delay?: number): T;
 
+export declare interface DecodedFrame {
+    idx: number;
+    buf: Buffer;
+}
+
+export declare function decodeFrames(src: string, meta: VideoMeta, signal: AbortSignal): AsyncGenerator<DecodedFrame>;
+
 export declare class DecodeSession {
     readonly meta: VideoMeta;
-    private readonly src;
-    private readonly framesDir;
-    private proc;
-    private ready;
-    private done;
-    private waiters;
-    private watcher;
-    constructor(meta: VideoMeta, src: string, framesDir: string);
+    private readonly _src;
+    private _buf;
+    private _ready;
+    private _want;
+    private _done;
+    private _closed;
+    private _gen;
+    private _ctrl;
+    private _waiters;
+    private _resume;
+    private _restart;
+    private readonly _leadFrames;
+    private readonly _keepCount;
+    constructor(meta: VideoMeta, _src: string);
     getFrame(idx: number): Promise<Buffer>;
     close(): void;
     private wait;
-    private spawn;
-    private poll;
+    private wake;
+    private requestRestart;
+    private pump;
+    private decodePass;
+    private pause;
+    private untilRestart;
+    private evict;
     private drainWaiters;
 }
 
@@ -224,22 +259,22 @@ declare const DEFAULT_HEIGHT = 1080;
 export { DEFAULT_HEIGHT }
 export { DEFAULT_HEIGHT as DEFAULT_HEIGHT_alias_1 }
 
-declare const DEFAULT_OUT_FILE = "out/html.mp4,out/html.webm";
-export { DEFAULT_OUT_FILE }
-export { DEFAULT_OUT_FILE as DEFAULT_OUT_FILE_alias_1 }
+export declare const DEFAULT_OUT_FILE = "out/html.mp4,out/html.webm";
 
 declare const DEFAULT_WIDTH = 1920;
 export { DEFAULT_WIDTH }
 export { DEFAULT_WIDTH as DEFAULT_WIDTH_alias_1 }
 
-declare const defaultRenderOptions: RenderOptions;
-export { defaultRenderOptions }
-export { defaultRenderOptions as defaultRenderOptions_alias_1 }
+declare const DEFAULT_WINDOW_TIMEOUT = 10;
+export { DEFAULT_WINDOW_TIMEOUT }
+export { DEFAULT_WINDOW_TIMEOUT as DEFAULT_WINDOW_TIMEOUT_alias_1 }
+
+export declare const defaultRenderOptions: RenderOptions;
 
 export declare function disposeWindow(win: BrowserWindow): Promise<void>;
 
 export declare interface DoneMsg {
-    type: IpcMsgType.DONE;
+    type: IpcMsgType.Done;
     payload: IpcDonePayload;
 }
 
@@ -270,7 +305,7 @@ export declare function electronOpts(disableGpu: boolean): Promise<string[]>;
 
 export declare function encodeNalHeader(type: number, layerId: number, temporalId: number): [number, number];
 
-declare class EncoderPipeline {
+export declare class EncoderPipeline {
     private _s;
     private _disposed;
     private constructor();
@@ -284,10 +319,8 @@ declare class EncoderPipeline {
     private free;
     private bgraFrame;
 }
-export { EncoderPipeline }
-export { EncoderPipeline as EncoderPipeline_alias_1 }
 
-declare interface EncoderPipelineOptions {
+export declare interface EncoderPipelineOptions {
     width: number;
     height: number;
     fps: number;
@@ -295,27 +328,25 @@ declare interface EncoderPipelineOptions {
     withAudio?: boolean;
     disableHwCodec?: boolean;
 }
-export { EncoderPipelineOptions }
-export { EncoderPipelineOptions as EncoderPipelineOptions_alias_1 }
 
-declare type EnvParser<T> = (value: unknown) => T;
-export { EnvParser }
-export { EnvParser as EnvParser_alias_1 }
+export declare type EnvParser<T> = (value: unknown) => T;
 
 export declare interface ErrorMsg {
-    type: IpcMsgType.ERROR;
+    type: IpcMsgType.Error;
     error: string;
 }
 
 export declare function evalIn(cdp: Debugger, expression: string): Promise<unknown>;
 
-declare function exec(cmd: string, options?: SpawnOptions): ProcessHandle;
-export { exec }
-export { exec as exec_alias_1 }
+export declare function exec(cmd: string, options?: SpawnOptions): ProcessHandle;
 
 export declare function extractAlphaToYuv420pBuffer(bgraFrame: Frame, buf: Buffer): void;
 
-declare class FormatMuxer {
+export declare function fire(el: EventTarget, type: string): void;
+
+export declare function fitRect(srcW: number, srcH: number, dstW: number, dstH: number, fit: string): Vec4;
+
+export declare class FormatMuxer {
     private readonly _ctx;
     private _opened;
     constructor(outPath: string, formatName?: string);
@@ -324,13 +355,22 @@ declare class FormatMuxer {
     writePacket(pkt: Packet): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
 }
-export { FormatMuxer }
-export { FormatMuxer as FormatMuxer_alias_1 }
 
 export declare const FRAME_SYNC_MARKER_HEIGHT = 1;
 
 export declare const FRAME_SYNC_MARKER_WIDTH = 32;
 
+export declare class FrameCache {
+    private _caches;
+    cacheOf(id: string): VideoCache;
+    fetch(state: VideoState, idx: number): Promise<ImageBitmap | null>;
+    prefetch(state: VideoState, fromIdx: number, count: number): void;
+    evict(c: VideoCache): void;
+    release(id: string, state: VideoState): void;
+}
+
+export declare type FrameCb = (now: number, meta: VideoFrameMeta) => void;
+
 /**
  * Frame drop quality score (0 = perfect, 1 = worst).
  *
@@ -364,7 +404,8 @@ export declare class FrameDropStats {
 }
 
 export declare class FrameServer {
-    private sessions;
+    private _sessions;
+    private _closed;
     open(opts: OpenOptions): Promise<VideoMeta>;
     getFrame(id: string, idx: number): Promise<Buffer>;
     close(id: string): void;
@@ -373,6 +414,12 @@ export declare class FrameServer {
 
 export declare const frameServer: FrameServer;
 
+export declare const HAVE_ENOUGH_DATA = 4;
+
+export declare const HAVE_METADATA = 1;
+
+export declare const HAVE_NOTHING = 0;
+
 export declare type HwEncoder = VideoToolboxEncoder | NvencDualLayerEncoder;
 
 export declare interface HwVideoEncoderOptions {
@@ -393,6 +440,8 @@ export declare interface HwVideoFactoryOptions {
     sharedHw?: HardwareContext;
 }
 
+export declare function installMediaShim(hook: VideoHook): void;
+
 export declare function installTickHook(): void;
 
 export declare function installVideoHook(): void;
@@ -415,26 +464,24 @@ export declare interface IpcEvents {
 
 export declare type IpcMsg = ConsoleMsg | ProgressMsg | DoneMsg | ErrorMsg | CancelMsg;
 
-export declare const enum IpcMsgType {
-    CONSOLE = "console",
-    PROGRESS = "progress",
-    DONE = "done",
-    ERROR = "error",
-    CANCEL = "cancel"
+export declare enum IpcMsgType {
+    Console = "console",
+    Progress = "progress",
+    Done = "done",
+    Error = "error",
+    Cancel = "cancel"
 }
 
 export declare class IpcReader extends EventEmitter<IpcEvents> {
     constructor(child: ChildProcess);
 }
 
-declare interface IPCRenderOptions extends RenderOptions {
+export declare interface IPCRenderOptions extends RenderOptions {
     source: string;
     signal: AbortSignal;
     onProgress: ProgressCallback;
     onConsole: ConsoleCallback;
 }
-export { IPCRenderOptions }
-export { IPCRenderOptions as IPCRenderOptions_alias_1 }
 
 export declare class IpcWriter {
     writeConsole(level: string, message: string): void;
@@ -459,8 +506,6 @@ export { Lazy as Lazy_alias_1 }
 
 export declare function loadWindow({ source, renderer, onCreated, signal }: WindowOptions): Promise<BrowserWindow>;
 
-export declare function localize(src: string): Promise<string>;
-
 declare class Logger implements LoggerLike {
     private _level;
     private _impl?;
@@ -501,6 +546,15 @@ export declare function makePacket(): Packet;
 
 export declare const MAX_RENDER_ATTEMPTS = 3;
 
+export declare const MEDIA_ERR_DECODE = 3;
+
+export declare const MEDIA_ERR_NETWORK = 2;
+
+export declare interface MediaErrorLike {
+    code: number;
+    message: string;
+}
+
 export declare const NAL_BLA_W_LP = 16;
 
 export declare const NAL_HEADER_SIZE = 2;
@@ -527,13 +581,24 @@ export declare interface NalUnit {
     data: Buffer;
 }
 
+export declare const NETWORK_EMPTY = 0;
+
+export declare const NETWORK_IDLE = 1;
+
+export declare const NETWORK_LOADING = 2;
+
+export declare const NETWORK_NO_SOURCE = 3;
+
 export declare interface NetworkOptions {
     source: string;
     window: BrowserWindow;
     useInnerProxy?: boolean;
+    cancelMedia?: boolean;
 }
 
-declare function noerr<Fn extends (...args: any[]) => any, D>(fn: Fn, defaultValue: D): (...args: Parameters<Fn>) => ReturnType<Fn> | D;
+export declare function newVideoState(video: HTMLVideoElement, cv: HTMLCanvasElement): VideoState;
+
+declare function noerr<A extends unknown[], R, D>(fn: (...args: A) => R, defaultValue: D): (...args: A) => R | D;
 export { noerr }
 export { noerr as noerr_alias_1 }
 
@@ -560,11 +625,20 @@ export declare interface NvencHevcConfig {
     ppsHasLoopFilterAcrossSlicesFlag: boolean;
 }
 
+export declare function openInput(src: string, signal?: AbortSignal): Promise<Demuxer>;
+
 export declare interface OpenOptions {
     src: string;
     fps: number;
+    /** Display-box pixels (canvas backing store); decode is downscaled to cover this, never upscaled. */
+    dstW?: number;
+    dstH?: number;
+    /** objectFit; "none" needs 1:1 native pixels so it skips downscale. */
+    fit?: string;
 }
 
+export declare function openSession(hook: VideoHook, args: AttachArgs): Promise<VideoState | null>;
+
 export declare function openVideoCtx(opts: VideoCtxOptions, label: string): Promise<CodecContext>;
 
 export declare class OutputSink implements AsyncDisposable {
@@ -587,9 +661,7 @@ export declare class OutputSink implements AsyncDisposable {
 
 export declare function packBits(bits: number[]): Buffer;
 
-declare function pargs(): string[];
-export { pargs }
-export { pargs as pargs_alias_1 }
+export declare function pargs(): string[];
 
 declare function parseNumber(x: unknown): number;
 export { parseNumber }
@@ -597,9 +669,7 @@ export { parseNumber as parseNumber_alias_1 }
 
 export declare function parseNvencHevcConfig(extradata: Buffer): NvencHevcConfig;
 
-declare function parseString(x: unknown): string;
-export { parseString }
-export { parseString as parseString_alias_1 }
+export declare function parseString(x: unknown): string;
 
 /** Patch every VPS/SPS NAL in an Annex B bitstream so PTL matches Apple/x265. */
 export declare function patchHevcAlphaPtl(bitstream: Buffer): Buffer;
@@ -622,16 +692,16 @@ export declare interface ProbeResult {
     width: number;
     height: number;
     duration: number;
+    /** PTS (s) of the first decodable frame; a corrupt/empty leading run is held on it, like Chrome. */
+    leadGap: number;
 }
 
-declare interface ProcessHandle {
+export declare interface ProcessHandle {
     process: ChildProcess;
     wait: Promise<void>;
     get killed(): boolean;
     kill(): void;
 }
-export { ProcessHandle }
-export { ProcessHandle as ProcessHandle_alias_1 }
 
 declare class ProgressBar {
     private _written;
@@ -658,7 +728,7 @@ export { ProgressCallback }
 export { ProgressCallback as ProgressCallback_alias_1 }
 
 export declare interface ProgressMsg {
-    type: IpcMsgType.PROGRESS;
+    type: IpcMsgType.Progress;
     value: number;
 }
 
@@ -668,25 +738,15 @@ declare function pup(source: string, options: Partial<PupOptions>): Promise<PupR
 export { pup }
 export { pup as pup_alias_1 }
 
-declare const PUP_ARGS_KEY = "--pup-priv-args";
-export { PUP_ARGS_KEY }
-export { PUP_ARGS_KEY as PUP_ARGS_KEY_alias_1 }
+export declare const PUP_ARGS_KEY = "--pup-priv-args";
 
-declare const pupApp: string;
-export { pupApp }
-export { pupApp as pupApp_alias_1 }
+export declare const pupApp: string;
 
-declare const pupAudioPreload: string;
-export { pupAudioPreload }
-export { pupAudioPreload as pupAudioPreload_alias_1 }
+export declare const pupAudioPreload: string;
 
-declare const pupIframePreload: string;
-export { pupIframePreload }
-export { pupIframePreload as pupIframePreload_alias_1 }
+export declare const pupIframePreload: string;
 
-declare const pupLogLevel: number;
-export { pupLogLevel }
-export { pupLogLevel as pupLogLevel_alias_1 }
+export declare const pupLogLevel: number;
 
 declare interface PupOptions extends Partial<RenderOptions> {
     signal?: AbortSignal;
@@ -696,9 +756,7 @@ declare interface PupOptions extends Partial<RenderOptions> {
 export { PupOptions }
 export { PupOptions as PupOptions_alias_1 }
 
-declare const pupPkgRoot: string;
-export { pupPkgRoot }
-export { pupPkgRoot as pupPkgRoot_alias_1 }
+export declare const pupPkgRoot: string;
 
 declare interface PupResult extends RenderResult {
 }
@@ -710,7 +768,7 @@ export declare function removeEmulationPrevention(data: Buffer): Buffer;
 
 export declare function render(options: IPCRenderOptions): Promise<IpcDonePayload>;
 
-declare type RenderOptions = z.infer<typeof RenderSchema>;
+declare type RenderOptions = z.infer<typeof renderSchema>;
 export { RenderOptions }
 export { RenderOptions as RenderOptions_alias_1 }
 
@@ -723,7 +781,7 @@ declare interface RenderResult {
 export { RenderResult }
 export { RenderResult as RenderResult_alias_1 }
 
-declare const RenderSchema: z.ZodObject<{
+export declare const renderSchema: z.ZodObject<{
     duration: z.ZodNumber;
     width: z.ZodNumber;
     height: z.ZodNumber;
@@ -735,13 +793,12 @@ declare const RenderSchema: z.ZodObject<{
     disableGpu: z.ZodBoolean;
     disableHwCodec: z.ZodBoolean;
     windowTolerant: z.ZodBoolean;
+    windowTimeout: z.ZodNumber;
 }, z.core.$strip>;
-export { RenderSchema }
-export { RenderSchema as RenderSchema_alias_1 }
 
 export declare function resizeDrawable(cdp: Debugger, size: Size): Promise<void>;
 
-declare interface RetryOptions<Args extends any[], Ret> {
+declare interface RetryOptions<Args extends unknown[], Ret> {
     fn: (...args: Args) => Promise<Ret>;
     maxAttempts?: number;
     timeout?: number;
@@ -775,9 +832,13 @@ export declare interface RunElectronAppOptions {
     args: unknown[];
 }
 
+export declare const SCHEME = "pup-frame://";
+
 export declare function send(cdp: Debugger, method: string, params?: object): Promise<unknown>;
 
-export declare function setInterceptor({ source, window, useInnerProxy }: NetworkOptions): void;
+export declare function setInterceptor({ source, window, useInnerProxy, cancelMedia }: NetworkOptions): void;
+
+export declare function setupCanvas(video: HTMLVideoElement, snap: OffscreenCanvas | undefined): HTMLCanvasElement;
 
 export declare function setupFrameProtocol(): void;
 
@@ -817,10 +878,22 @@ export declare function stopStego(cdp: Debugger): Promise<unknown>;
 
 export declare function swapBuffer(wc: WebContents, expected: number, interval: number): Promise<void>;
 
-export declare function tick(frame: WebFrameMain | undefined, timestampMs: number): Promise<void>;
+export declare function syncOverlay(video: HTMLVideoElement, cv: HTMLCanvasElement): void;
+
+export declare const TAG = "[VideoHook]";
+
+export declare function tick(args: AdvanceOptions): Promise<void>;
 
 export declare const TICK_SYMBOL = "__pup_tick__";
 
+export declare function timeRanges(end: number): TimeRangesLike;
+
+export declare interface TimeRangesLike {
+    length: number;
+    start(i: number): number;
+    end(i: number): number;
+}
+
 export declare interface UnifiedExtradataOptions {
     baseExtradata: Buffer;
     alphaExtradata: Buffer;
@@ -830,11 +903,17 @@ export declare interface UnifiedExtradataOptions {
 
 export declare function unsetInterceptor(window: BrowserWindow): void;
 
-declare function useRetry<Args extends any[], Ret>({ fn, maxAttempts, timeout, signal }: RetryOptions<Args, Ret>): (...args: Args) => Promise<Ret>;
+declare function useRetry<Args extends unknown[], Ret>({ fn, maxAttempts, timeout, signal, }: RetryOptions<Args, Ret>): (...args: Args) => Promise<Ret>;
 export { useRetry }
 export { useRetry as useRetry_alias_1 }
 
-export declare const VIDEO_SYMBOL = "__pup_video__";
+declare type Vec4 = [number, number, number, number];
+
+export declare interface VideoCache {
+    bitmaps: Map<number, ImageBitmap>;
+    inFlight: Map<number, Promise<ImageBitmap | null>>;
+    readers: Map<VideoState, number>;
+}
 
 export declare interface VideoCtxOptions {
     codec: Codec;
@@ -875,12 +954,55 @@ export declare interface VideoEncoderOptions {
     muxer: FormatMuxer;
 }
 
+export declare interface VideoFrameMeta {
+    presentationTime: number;
+    expectedDisplayTime: number;
+    width: number;
+    height: number;
+    mediaTime: number;
+    presentedFrames: number;
+}
+
+export declare class VideoHook {
+    readonly sessions: WeakMap<HTMLVideoElement, VideoState>;
+    readonly attaching: WeakMap<HTMLVideoElement, Promise<VideoState | null>>;
+    readonly opening: Set<Promise<unknown>>;
+    readonly cache: FrameCache;
+    rvfcSeq: number;
+    currMs: number;
+    private _lastSnapshot;
+    install(): void;
+    attach(video: HTMLVideoElement, native?: boolean): Promise<VideoState | null>;
+    ready(): Promise<void>;
+    resume(video: HTMLVideoElement, state: VideoState): void;
+    detach(video: HTMLVideoElement): void;
+    onSrcChange(video: HTMLVideoElement): void;
+    reattach(video: HTMLVideoElement, state: VideoState): void;
+    private scan;
+}
+
 export declare interface VideoMeta {
     id: string;
+    /** Intrinsic source dimensions (reported as videoWidth/videoHeight). */
     width: number;
     height: number;
+    /** Decoded+scaled frame dimensions actually served (≤ source; capped to the display box). */
+    frameWidth: number;
+    frameHeight: number;
     fps: number;
     duration: number;
+    /** Seconds of corrupt/empty leading content held on the first decodable frame. */
+    leadGap: number;
+}
+
+export declare interface VideoMeta_alias_1 {
+    id: string;
+    width: number;
+    height: number;
+    frameWidth: number;
+    frameHeight: number;
+    duration: number;
+    fps: number;
 }
 
 export declare interface VideoSetup {
@@ -891,6 +1013,26 @@ export declare interface VideoSetup {
     ownsHw: boolean;
 }
 
+export declare interface VideoState {
+    meta: VideoMeta_alias_1 | null;
+    cv: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    paused: boolean;
+    currentTime: number;
+    ended: boolean;
+    lastDrawnIdx: number;
+    dead: boolean;
+    objectFit: string;
+    readyState: number;
+    networkState: number;
+    seeking: boolean;
+    waiting: boolean;
+    error: MediaErrorLike | undefined;
+    presentedFrames: number;
+    maxReached: number;
+    rvfc: Map<number, FrameCb>;
+}
+
 export declare class VideoToolboxEncoder implements Disposable {
     private _ctx;
     private _pkt;
@@ -929,8 +1071,6 @@ export declare interface WindowOptions {
 
 export declare function withRerender<T>(signal: AbortSignal, action: () => Promise<T>): Promise<T>;
 
-declare function withTimeout<T>(p: Promise<T>, ms: number, label: string): Promise<T>;
-export { withTimeout }
-export { withTimeout as withTimeout_alias_1 }
+export declare function withTimeout<T>(p: Promise<T>, ms: number, label: string): Promise<T>;
 
 export { }