@netless/appliance-plugin 1.1.42-beta.3 → 1.1.43-beta.0

package/dist/plugin/renderImageBitmapRetirement.d.ts

@@ -0,0 +1,100 @@
+export declare const RenderImageBitmapRetireTimeoutMs = 5000;
+export declare const RenderImageBitmapMemoryPressureBytes: number;
+export declare const RenderImageBitmapMemoryPressureCount = 128;
+export declare const RenderImageBitmapMemoryPressureReportIntervalMs = 5000;
+type TimerHandle = ReturnType<typeof setTimeout>;
+export type RenderImageBitmapRetirementScheduler = {
+    requestFrame: (callback: FrameRequestCallback) => number;
+    cancelFrame: (handle: number) => void;
+    setTimer: (callback: () => void, timeoutMs: number) => TimerHandle;
+    clearTimer: (handle: TimerHandle) => void;
+    now: () => number;
+};
+export type RenderImageBitmapRetirementOptions = {
+    timeoutMs?: number;
+    memoryPressureBytes?: number;
+    memoryPressureCount?: number;
+    memoryPressureReportIntervalMs?: number;
+    scheduler?: Partial<RenderImageBitmapRetirementScheduler>;
+    onCloseError?: (viewId: string, error: unknown, snapshot: RenderImageBitmapMemorySnapshot) => void;
+    onScheduleError?: (stage: "request-frame" | "set-watchdog", error: unknown, snapshot: RenderImageBitmapMemorySnapshot) => void;
+    onTimeout?: (event: RenderImageBitmapTimeoutEvent) => void;
+    onMemoryPressure?: (snapshot: RenderImageBitmapMemorySnapshot) => void;
+};
+export type RenderImageBitmapMemoryViewSnapshot = Readonly<{
+    viewId: string;
+    activeCount: number;
+    estimatedBytes: number;
+    oldestAgeMs: number;
+}>;
+/**
+ * Tracks ImageBitmap ownership, not browser heap or exact GPU allocation.
+ * estimatedBytes uses width * height * 4 as a stable pressure signal.
+ */
+export type RenderImageBitmapMemorySnapshot = Readonly<{
+    activeCount: number;
+    estimatedBytes: number;
+    peakActiveCount: number;
+    peakEstimatedBytes: number;
+    totalRetiredCount: number;
+    totalReleasedCount: number;
+    watchdogReleasedCount: number;
+    closeErrorCount: number;
+    oldestAgeMs: number;
+    activeViews: ReadonlyArray<RenderImageBitmapMemoryViewSnapshot>;
+    destroyed: boolean;
+}>;
+export type RenderImageBitmapTimeoutEvent = Readonly<{
+    viewIds: ReadonlySet<string>;
+    releasedCount: number;
+    releasedEstimatedBytes: number;
+    oldestAgeMs: number;
+    snapshot: RenderImageBitmapMemorySnapshot;
+}>;
+export declare function getRenderImageBitmapDestroyLogLevel(beforeDestroy: RenderImageBitmapMemorySnapshot, afterDestroy: RenderImageBitmapMemorySnapshot): "error" | "info" | undefined;
+/**
+ * Keeps transferred render bitmaps alive across one browser paint opportunity.
+ * The first RAF promotes a bitmap to awaitingPaint; the second RAF releases it.
+ */
+export declare class RenderImageBitmapRetirementQueue {
+    private pending;
+    private awaitingPaint;
+    private readonly entries;
+    private readonly timeoutMs;
+    private readonly memoryPressureBytes;
+    private readonly memoryPressureCount;
+    private readonly memoryPressureReportIntervalMs;
+    private readonly scheduler;
+    private readonly onCloseError?;
+    private readonly onScheduleError?;
+    private readonly onTimeout?;
+    private readonly onMemoryPressure?;
+    private activeEstimatedBytes;
+    private peakActiveCount;
+    private peakEstimatedBytes;
+    private totalRetiredCount;
+    private totalReleasedCount;
+    private watchdogReleasedCount;
+    private closeErrorCount;
+    private lastMemoryPressureReportAt;
+    private frameHandle?;
+    private watchdogHandle?;
+    private destroyed;
+    constructor(options?: RenderImageBitmapRetirementOptions);
+    retire(viewId: string, bitmap: ImageBitmap): void;
+    getMemorySnapshot(): RenderImageBitmapMemorySnapshot;
+    closeNow(viewId: string, bitmap: ImageBitmap): void;
+    releaseView(viewId: string): void;
+    destroy(): RenderImageBitmapMemorySnapshot;
+    private ensureFrame;
+    private readonly onFrame;
+    private ensureWatchdog;
+    private readonly onWatchdog;
+    private releaseEntry;
+    private closeBitmap;
+    private estimateBitmapBytes;
+    private reportMemoryPressure;
+    private stopSchedulersWhenEmpty;
+    private cancelSchedulers;
+}
+export {};

package/dist/plugin/renderRuntimeCache.d.ts

@@ -0,0 +1,18 @@
+import { type CompactRenderModel } from "./renderingCompatibility";
+export declare const RenderModeCacheDatabaseName = "__APPLIANCE_PLUGIN_RENDER_MODE_DB";
+export declare const RenderModeCacheStoreName = "renderModes";
+export type CachedRenderRuntimeReadResult = {
+    renderModel?: CompactRenderModel;
+    readFailed?: boolean;
+    reason?: string;
+};
+type IDBFactoryLike = Pick<IDBFactory, "open"> & Partial<Pick<IDBFactory, "deleteDatabase">>;
+export type RenderRuntimeCacheDeadlineOptions = {
+    timeoutMs?: number;
+};
+export declare function createRenderRuntimeCacheKey(userAgent: string): string;
+export declare function readCachedRenderRuntimeDecisionWithStatus(key: string, factory?: IDBFactoryLike | undefined, options?: RenderRuntimeCacheDeadlineOptions): Promise<CachedRenderRuntimeReadResult>;
+export declare function readCachedRenderRuntimeDecision(key: string, factory?: IDBFactoryLike | undefined, options?: RenderRuntimeCacheDeadlineOptions): Promise<CompactRenderModel | undefined>;
+export declare function writeCachedRenderRuntimeDecision(key: string, renderModel: CompactRenderModel, factory?: IDBFactoryLike | undefined, options?: RenderRuntimeCacheDeadlineOptions): Promise<boolean>;
+export declare function deleteCachedRenderRuntimeDecision(key: string, factory?: IDBFactoryLike | undefined, options?: RenderRuntimeCacheDeadlineOptions): Promise<boolean>;
+export {};

package/dist/plugin/renderSurface.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+export interface RenderSurfaceRefs {
+    canvasContainerRef: React.RefObject<HTMLDivElement>;
+    subLocalCanvasContainerRef?: React.RefObject<HTMLDivElement>;
+    canvasServiceFloatRef: React.RefObject<HTMLCanvasElement>;
+    canvasFloatRef: React.RefObject<HTMLCanvasElement>;
+    canvasBgRef: React.RefObject<HTMLCanvasElement>;
+    canvasTopRef?: React.RefObject<HTMLCanvasElement>;
+}
+export declare const RenderSurface: (props: {
+    hasOffscreenCanvas: boolean;
+    isUseSimple: boolean;
+    generation: number;
+    refs: RenderSurfaceRefs;
+}) => React.JSX.Element;

package/dist/plugin/renderingCompatibility.d.ts

@@ -1,6 +1,15 @@
 import type { ECanvasContextType } from "../core/enum";
-import { VersionWorkerBlacklist, WorkerBlacklistByRuntime, WorkerCanvasContextBlacklistLevel, WorkerImageBitmapFeatureBlacklistLevel, WorkerMaskTextureFormatBlacklistLevel, WorkerMaskTextureUploadBlacklistLevel, WorkerRenderModeBlacklistLevel } from "./types";
+import { VersionWorkerBlacklist, WorkerBlacklistByRuntime, WorkerCanvasContextBlacklistLevel, WorkerMaskTextureFormatBlacklistLevel, WorkerMaskTextureUploadBlacklistLevel, WorkerRenderModeBlacklistLevel } from "./types";
 export type RenderMode = "worker-offscreen-transfer" | "worker-image-bitmap" | "main-thread";
+export type MainThreadRenderMode = "normal" | "readback";
+export declare const RenderCompatibilityPolicyVersion = "xiaomi-android-webview-offscreen-v1";
+export type CompactRenderModel = "offscreenTransfer+webgl2" | "offscreenTransfer+webgl" | "offscreenTransfer+canvas2d" | "imageBitmap+webgl2" | "imageBitmap+webgl" | "imageBitmap+canvas2d" | "mainThread+canvas2d";
+export declare function isCompactRenderModel(value: unknown): value is CompactRenderModel;
+export declare function parseRenderRuntimeModel(value: CompactRenderModel): {
+    renderMode: RenderMode;
+    contextType: ECanvasContextType;
+};
+export declare function formatRenderRuntimeModel(renderMode: RenderMode, contextType: ECanvasContextType): CompactRenderModel;
 export type RenderingRuntime = {
     kind: "androidWebView" | "iosWebView" | "harmonyArkWeb";
     version: string;
@@ -18,9 +27,14 @@ export type RenderCapabilities = {
     webgl2: boolean;
     webgl: boolean;
 };
-export type RenderingCompatibilityReason = "use-worker-main-thread" | "worker-capability-missing" | "use-simple-false" | "render-mode-blacklist" | "image-bitmap-unavailable" | "default-offscreen-transfer";
+export declare function hasRequiredWorkerUrls(cdn: {
+    fullWorkerUrl?: string;
+    subWorkerUrl?: string;
+}, useSimple: boolean): boolean;
+export type RenderingCompatibilityReason = "use-worker-main-thread" | "worker-capability-missing" | "use-simple-false" | "render-mode-blacklist" | "image-bitmap-unavailable" | "default-offscreen-transfer" | "worker-program-probe-failed" | "render-probe-passed" | "runtime-webgl-program-failure" | "cached-render-runtime-decision";
 export type RenderingCompatibilityDecision = {
     renderMode: RenderMode;
+    mainThreadRenderMode: MainThreadRenderMode;
     contextType: ECanvasContextType;
     reason: RenderingCompatibilityReason;
     capabilities: RenderCapabilities;
@@ -29,13 +43,16 @@ export type RenderingCompatibilityDecision = {
     effectiveContextLevel?: WorkerCanvasContextBlacklistLevel;
     effectiveMaskTextureFormatLevel?: WorkerMaskTextureFormatBlacklistLevel;
     effectiveMaskTextureUploadLevel?: WorkerMaskTextureUploadBlacklistLevel;
-    effectiveImageBitmapFeatureLevel?: WorkerImageBitmapFeatureBlacklistLevel;
     issues: string[];
+    /** Set when an auto decision was restored from the per-UA IndexedDB cache. */
+    renderRuntimeCacheState?: "hit";
+    renderRuntimeSource?: "config" | "cache" | "probe" | "fallback";
 };
-type BlacklistKind = "renderMode" | "canvasContext" | "maskTextureFormat" | "maskTextureUpload" | "imageBitmapFeature" | "fontFaceFallback";
+type BlacklistKind = "renderMode" | "canvasContext" | "maskTextureFormat" | "maskTextureUpload" | "fontFaceFallback";
 export declare function normalizeVersion(value: string): string | undefined;
 export declare function compareVersions(left: string, right: string): number;
 export declare function detectRenderingRuntime(userAgent?: string): RenderingRuntime | undefined;
+export declare function isKnownOffscreenTransferCompositionRisk(userAgent: string, runtime?: RenderingRuntime | undefined): boolean;
 export declare function resolveVersionBlacklistLevel(currentVersion: string, rules: VersionWorkerBlacklist | undefined, kind: BlacklistKind, issues?: string[]): number | undefined;
 export declare function mergeWorkerBlacklists(builtin: WorkerBlacklistByRuntime | undefined, injected: WorkerBlacklistByRuntime | undefined, kind: BlacklistKind): WorkerBlacklistByRuntime;
 export declare function isFontFaceFallbackBlacklisted(blacklist: WorkerBlacklistByRuntime | undefined, userAgent?: string): boolean;
@@ -48,7 +65,6 @@ export declare function resolveRenderingCompatibility(input: {
     workerCanvasContextBlacklist?: WorkerBlacklistByRuntime;
     workerMaskTextureFormatBlacklist?: WorkerBlacklistByRuntime;
     workerMaskTextureUploadBlacklist?: WorkerBlacklistByRuntime;
-    workerImageBitmapFeatureBlacklist?: WorkerBlacklistByRuntime;
     userAgent?: string;
     capabilities?: RenderCapabilities;
     workerUrl?: boolean;

package/dist/plugin/roomLifecycle.d.ts

@@ -0,0 +1,12 @@
+import type { Room } from "./types";
+import type { BaseApplianceManager } from "./baseApplianceManager";
+type LifecycleLogger = Pick<BaseApplianceManager["logger"], "error">;
+/**
+ * Transitional Room lifecycle interception. It keeps the SDK methods' Promise
+ * contract while ensuring Appliance work reaches Done before write access or
+ * the connection is relinquished.
+ */
+export declare function installRoomLifecycleInterceptors(room: Room, getManager: () => BaseApplianceManager | undefined, logger: LifecycleLogger): () => void;
+/** Remove this plugin's wrapper without clobbering a newer host wrapper. */
+export declare function uninstallRoomLifecycleInterceptors(room: Room): void;
+export {};

package/dist/plugin/selectorApi.d.ts

@@ -31,6 +31,12 @@ export declare class SelectorApiManager {
     /** 同一次属性更新导致的几何变化做尾部合并，只派发最后一次 */
     private pendingPropertyGeometryByKey;
     constructor(control: BaseApplianceManager);
+    /**
+     * Keep SelectorApi usable with older host/test control objects that predate
+     * the local-mutation admission hook. Production managers always provide the
+     * method; an absent hook preserves the previous API behavior.
+     */
+    private canAcceptLocalMutation;
     private formatFieldsFromChanges;
     private hasShapeChanges;
     private resolveShapeDispatchToolsTypes;
@@ -38,6 +44,8 @@ export declare class SelectorApiManager {
     private resolveCancelableUndoTickerId;
     private captureUndoTickerDuringDispatch;
     destroy(): void;
+    /** Dispose only one View's selector requests and timers. */
+    disposeView(viewId: string): void;
     /** 解析 viewId：未传时取 focuedView / mainView */
     resolveViewId(viewId?: string): string | undefined;
     /** 当前 selector 选中态快照 */

package/dist/plugin/single/applianceSingleManager.d.ts

@@ -4,8 +4,12 @@ import { ViewContainerSingleManager } from "./containerManager";
 export declare class ApplianceSingleManager extends BaseApplianceManager {
     viewContainerManager: ViewContainerSingleManager;
     divMainView?: HTMLDivElement;
+    private readonly bindMainViewListener;
     constructor(params: BaseApplianceManagerProps);
     init(): void;
+    destroy(options?: {
+        preserveStorage?: boolean;
+    }): Promise<void>;
     activePlugin(): void;
     activeWorker(): Promise<void>;
     onCameraChange: import("lodash").DebouncedFunc<(cameraState: CameraState) => void>;

package/dist/plugin/types.d.ts

@@ -244,7 +244,7 @@ export interface AppliancePluginInstance {
     cleanCurrentScene(retainPpt?: boolean): void;
     /** 把指定的方法注入到指定对象上 */
     /** 销毁 */
-    destroy(): void;
+    destroy(): Promise<void>;
     /** 设置当前用户的读写权限 */
     setWritable(writable: boolean): Promise<void>;
     /** setMemberState */
@@ -412,7 +412,8 @@ export type Logger = {
 };
 export declare enum WorkerRenderModeBlacklistLevel {
     OffscreenTransfer = 1,
-    ImageBitmap = 2
+    ImageBitmap = 2,
+    MainThread = 3
 }
 export declare enum WorkerCanvasContextBlacklistLevel {
     WebGL = 1
@@ -423,9 +424,6 @@ export declare enum WorkerMaskTextureFormatBlacklistLevel {
 export declare enum WorkerMaskTextureUploadBlacklistLevel {
     TextureSubImage2D = 1
 }
-export declare enum WorkerImageBitmapFeatureBlacklistLevel {
-    DirtyRect = 1
-}
 export declare enum FontFaceFallbackBlacklistLevel {
     RefreshTextRender = 1
 }
@@ -457,8 +455,6 @@ export type ExtrasOptions = {
     workerMaskTextureFormatBlacklist?: WorkerBlacklistByRuntime;
     /** API 可用但局部纹理上传行为异常的运行时版本 */
     workerMaskTextureUploadBlacklist?: WorkerBlacklistByRuntime;
-    /** API 可用但 ImageBitmap crop 行为异常的运行时版本 */
-    workerImageBitmapFeatureBlacklist?: WorkerBlacklistByRuntime;
     /** 按运行时版本启用字体加载失败后的文本补绘兜底 */
     fontFaceFallbackBlacklist?: WorkerBlacklistByRuntime;
     /** 是否使用背景Svg功能, 默认值为 ``false`` */
@@ -516,12 +512,8 @@ export type UndoRedoOpt = {
     maxStackLength?: number;
     /** 是否启用 undo 时序补丁, 默认值为 true */
     timingFix?: boolean;
-    /** 首个 ack 到达后的兜底超时时间，单位：毫秒，默认值为 5000 */
+    /** finalizeRequested 后等待渲染与存储确认的超时时间，单位：毫秒，默认值为 5000 */
     ackTimeout?: number;
-    /** 新 ticker 抢占旧 ticker 时的宽限超时时间，单位：毫秒，默认值为 3000 */
-    gracePeriodTimeout?: number;
-    /** Doing 链路无 ack 时的兜底超时时间，单位：毫秒，默认值为 30000 */
-    doingFallbackTimeout?: number;
 };
 export type SyncLoggerOpt = {
     /** 同步日志批量输出窗口，单位：毫秒，默认值为 4000 */
@@ -572,7 +564,6 @@ export type RequiredExtrasOptions = {
     workerCanvasContextBlacklist: WorkerBlacklistByRuntime;
     workerMaskTextureFormatBlacklist: WorkerBlacklistByRuntime;
     workerMaskTextureUploadBlacklist: WorkerBlacklistByRuntime;
-    workerImageBitmapFeatureBlacklist: WorkerBlacklistByRuntime;
     fontFaceFallbackBlacklist: WorkerBlacklistByRuntime;
     useBackgroundThread: Required<boolean>;
     syncOpt: Required<SyncOpt>;
@@ -745,6 +736,10 @@ export type BezierOpt = {
 export type PencilEraserOpt = {
     /** 是否使用位图方式局部橡皮擦 */
     useBitMap: boolean;
+    /** @deprecated Bitmap Eraser 始终使用事务级 FullLayer 透明 Doing Mask；该字段仅保留配置兼容。 */
+    fullLayerDoingMask?: boolean;
+    /** Bitmap Eraser 单个事务最多接收的逻辑输入点数，默认值为 ``500`` */
+    fullLayerDoingMaskMaxInputPoints?: number;
     /** BitMapEraser 完成擦除时是否删除已完全透明的对象，默认值为 ``true`` */
     removeOnDone?: boolean;
     /** 最大图片宽度 */
@@ -850,7 +845,9 @@ export type _ObjectTrue = true | {
 export type _ArrayTrue = true | Uid[];
 export declare enum EForceStopReason {
     /** 画笔过长 */
-    longPencil = "longPencil"
+    longPencil = "longPencil",
+    /** FullLayer 位图橡皮擦单次输入点数达到上限 */
+    longBitmapEraser = "longBitmapEraser"
 }
 export type AutoShapeDebugInfo = {
     workId: string;

package/dist/plugin/utils.d.ts

@@ -1,4 +1,5 @@
 import { Logger } from "./types";
+import { type InitLogCompletion, type InitLogProgressEvent } from "./initLogAggregator";
 export declare function isTouchEvent(event: any): any;
 export declare function isOnlyOneTouch(event: any): any;
 export declare function getPosition(event: any): {
@@ -11,6 +12,7 @@ export declare function getClientPosition(event: any): {
 };
 export declare class LoggerUtils implements Logger {
     private _logger?;
+    private readonly initLogAggregator;
     private pendingArgsByChannel;
     private flushTimerByChannel;
     constructor(_logger?: Logger);
@@ -23,5 +25,11 @@ export declare class LoggerUtils implements Logger {
     errorDebounced(channel: string, ...args: any[]): void;
     infoDebounced(channel: string, ...args: any[]): void;
     warnDebounced(channel: string, ...args: any[]): void;
+    recordInitLogProgress(event: InitLogProgressEvent): void;
+    completeInitViewLogs(completion: InitLogCompletion): void;
+    cancelInitViewLogs(viewId: string): void;
     destroy(): void;
 }
+export declare function logInitProgress(logger: Logger, event: InitLogProgressEvent): void;
+export declare function completeInitViewLogs(logger: Logger, completion: InitLogCompletion): void;
+export declare function cancelInitViewLogs(logger: Logger | undefined, viewId: string): void;