@xmov/avatar 2.0.0-alpha.38

package/src/utils/GLPipelineDebugTools.ts

@@ -0,0 +1,174 @@
+import { GLPipelineCharData } from './GLPipeline'
+import { mvmul } from './Math'
+import { TensorDataType, RigidTransform, IBRAnimationFrameData_NN } from './DataInterface'
+
+function sampleUniformTensor(data: TensorDataType, index: number): number {
+    // @ts-ignore
+    if(Float16Array === data.constructor || Float32Array === data.constructor || Float64Array === data.constructor)return data[index];
+    else if(Uint8Array === data.constructor)return (data[index] / 0xFF);
+    else if(Int8Array === data.constructor)return ((data[index] + 0x80) / 0xFF) * 2.0 - 1.0;
+    else if(Uint16Array === data.constructor)return (data[index] / 0xFFFF);
+    else if(Int16Array === data.constructor)return ((data[index] + 0x8000) / 0xFFFF) * 2.0 - 1.0;
+    else if(Uint32Array === data.constructor)return (data[index] / 0xFFFFFFFF);
+    else if(Int32Array === data.constructor)return ((data[index] + 0x80000000) / 0xFFFFFFFF) * 2.0 - 1.0;
+    else if(BigUint64Array === data.constructor)return (Number(data[index] >> 32n) / 0xFFFFFFFF);
+    else if(BigInt64Array === data.constructor)return ((Number(data[index] >> 32n) + 0x80000000) / 0xFFFFFFFF) * 2.0 - 1.0;
+    else return 0.0;
+}
+function sampleUniformPCATensor(data: TensorDataType, index: number): number {
+    // @ts-ignore
+    if(Float16Array === data.constructor || Float32Array === data.constructor || Float64Array === data.constructor)return data[index];
+    else if(Uint8Array === data.constructor)return (data[index] / 0xFF) * 2.0 - 1.0;
+    else if(Int8Array === data.constructor)return ((data[index] + 0x80) / 0xFF) * 2.0 - 1.0;
+    else if(Uint16Array === data.constructor)return (data[index] / 0xFFFF) * 2.0 - 1.0;
+    else if(Int16Array === data.constructor)return ((data[index] + 0x8000) / 0xFFFF) * 2.0 - 1.0;
+    else if(Uint32Array === data.constructor)return (data[index] / 0xFFFFFFFF) * 2.0 - 1.0;
+    else if(Int32Array === data.constructor)return ((data[index] + 0x80000000) / 0xFFFFFFFF) * 2.0 - 1.0;
+    else if(BigUint64Array === data.constructor)return (Number(data[index] >> 32n) / 0xFFFFFFFF) * 2.0 - 1.0;
+    else if(BigInt64Array === data.constructor)return ((Number(data[index] >> 32n) + 0x80000000) / 0xFFFFFFFF) * 2.0 - 1.0;
+    else return 0.0;
+}
+
+export function getVertices(data: GLPipelineCharData, frame_data: IBRAnimationFrameData_NN): number[][][] {
+    let char = data.char!;
+
+    let initSkeletonStatus = char.evalSkeleton();
+    let currentSkeletonStatus = char.evalSkeletonFromMovable(frame_data.movableJointTransforms);
+    let joint_matrices = Array(char.skeleton.length);
+    for (let i = 0; i < char.skeleton.length; i++) {
+        const joint_transform = currentSkeletonStatus[i].apply(initSkeletonStatus[i].inv()) as RigidTransform;
+        joint_matrices[i] = joint_transform.homogeneous_matrix();
+    }
+
+    let result: number[][][] = [];
+    for (let mesh_index = 0; mesh_index < char.mesh.length; mesh_index++) {
+        let geometry: number[][] = [];
+        for (let i = 0; i < char.mesh[mesh_index].blendshapes.size[0]; i++) {
+            let vertex: number[] = [];
+            let neutral_vertices = char.mesh[mesh_index].vertices;
+            let blendshapes = char.mesh[mesh_index].blendshapes;
+            let blendshapeWeights = frame_data.blendshapeWeights;
+            for (let k = 0; k < 3; k++)vertex.push(neutral_vertices.data[i * neutral_vertices.size[1] + k] as number);
+            for (let j = 0; j < char.mesh[mesh_index].blendshapeIndices.length; j++) {
+                for (let k = 0; k < 3; k++)vertex[k] += blendshapeWeights[char.mesh[mesh_index].blendshapeIndices[j]] * Number(blendshapes.data[(i * blendshapes.size[1] + k) * blendshapes.size[2] + j]);
+            }
+
+            vertex.push(1.0);
+            let vertex_lbs = [0.0, 0.0, 0.0, 0.0];
+            let jointIndex = char.mesh[mesh_index].jointIndex;
+            let jointWeight = char.mesh[mesh_index].jointWeight;
+            for (let j = 0; j < char.maxJointsPerVertex; j++) {
+                let curJointIndex = jointIndex[i * char.maxJointsPerVertex + j];
+                if(curJointIndex < char.skeleton.length){
+                    let vertex_transformed = mvmul(joint_matrices[curJointIndex], vertex);
+                    for (let k = 0; k < 4; k++)vertex_lbs[k] += jointWeight[i * char.maxJointsPerVertex + j] * vertex_transformed[k];
+                }
+            }
+
+            for (let k = 0; k < 3; k++)vertex_lbs[k] /= vertex_lbs[3];
+            geometry.push([vertex_lbs[0], vertex_lbs[1], vertex_lbs[2]]);
+        }
+        result.push(geometry);
+    }
+    return result;
+}
+
+export function getPCATextures(data: GLPipelineCharData, frame_data: IBRAnimationFrameData_NN): ImageData[] {
+    let char = data.char!;
+    let result: ImageData[] = [];
+
+    for (let mesh_index = 0; mesh_index < char.mesh.length; mesh_index++) {
+        let texture_model = char.mesh[mesh_index].textureModels[frame_data.mesh[mesh_index].textureModelIndex];
+        let texture: number[][][] = [];
+        let texture_data = new Uint8ClampedArray(texture_model.data.size[1] * texture_model.data.size[2] * 4);
+
+        let mean_weight = 1.0;
+        if(texture_model.scalingFactor)mean_weight *= Number(texture_model.scalingFactor.data[0]);
+        for (let j = 0; j < texture_model.data.size[1]; j++){
+            let row: number[][] = [];
+            for (let k = 0; k < texture_model.data.size[2]; k++){
+                let pixel: number[] = [];
+                for (let l = 0; l < 3; l++)pixel.push(mean_weight * sampleUniformPCATensor(texture_model.data.data, (j * texture_model.data.size[2] + k) * 3 + l));
+                row.push(pixel);
+            }
+            texture.push(row);
+        }
+        for (let i = 1; i < texture_model.data.size[0]; i++) {
+            let weight = frame_data.mesh[mesh_index].texturePCAWeights[i - 1];
+            if(texture_model.scalingFactor)weight *= Number(texture_model.scalingFactor.data[i]);
+            for (let j = 0; j < texture_model.data.size[1]; j++){
+                for (let k = 0; k < texture_model.data.size[2]; k++){
+                    for (let l = 0; l < 3; l++)texture[j][k][l] += weight * sampleUniformPCATensor(texture_model.data.data, ((i * texture_model.data.size[1] + j) * texture_model.data.size[2] + k) * 3 + l);
+                }
+            }
+        }
+        for (let j = 0; j < texture_model.data.size[1]; j++){
+            let row: number[][] = [];
+            for (let k = 0; k < texture_model.data.size[2]; k++){
+                let pixel: number[] = [];
+                for (let l = 0; l < 3; l++)texture_data[(j * texture_model.data.size[2] + k) * 4 + l] = Math.round(texture[texture_model.data.size[1] - 1 - j][k][2 - l] * 255);
+                texture_data[(j * texture_model.data.size[2] + k) * 4 + 3] = 0xFF;
+            }
+        }
+        result.push(new ImageData(texture_data, texture_model.data.size[1], texture_model.data.size[2]));
+    }
+
+    return result;
+}
+
+interface PolygonMeshInfo {
+    vertices: number[][],
+    uv: number[][],
+    polygons: number[][]
+}
+
+function exportAsWavefrontObj(geometries: PolygonMeshInfo[]): string {
+    let vertex_string = "";
+    let polygon_string = "";
+    let vertex_index_offset = 1;
+    let geometry_offset = 0;
+    for(const geometry of geometries){
+        for(const vertex of geometry.vertices)vertex_string += `v ${vertex[0]} ${vertex[1]} ${vertex[2]}\n`
+        for(const uv of geometry.uv)vertex_string += `vt ${uv[0]} ${uv[1]}}\n`
+
+        polygon_string += `g Obj${geometry_offset}\n`
+        for(const poly of geometry.polygons){
+            let poly_str = poly.map(x => (x + vertex_index_offset).toString()).map(x => `${x}/${x}`).join(" ");
+            polygon_string += `f ${poly_str}\n`;
+        }
+
+        vertex_index_offset += geometry.vertices.length;
+        geometry_offset += 1;
+    }
+    return vertex_string + polygon_string;
+}
+
+export function getWavefrontObjFromVertices(data: GLPipelineCharData, vertices: number[][][]): string {
+    function unflattenUniform(data: TensorDataType, new_axis_size: number): number[][] {
+        let result: number[][] = [];
+        for (let i = 0; i < data.length; i++) {
+            if (0 == i % new_axis_size) result.push([]);
+            result[result.length - 1].push(sampleUniformTensor(data, i));
+        }
+        return result;
+    }
+    function unflatten(data: TensorDataType, new_axis_size: number): number[][] {
+        let result: number[][] = [];
+        for (let i = 0; i < data.length; i++) {
+            if (0 == i % new_axis_size) result.push([]);
+            result[result.length - 1].push(Number(data[i]));
+        }
+        return result;
+    }
+
+    let char = data.char!;
+    let geometries: PolygonMeshInfo[] = [];
+    for (let mesh_index = 0; mesh_index < char.mesh.length; mesh_index++) {
+        geometries.push({
+            vertices: vertices[mesh_index],
+            uv: unflattenUniform(char.mesh[mesh_index].UVCoord.data, 2),
+            polygons: unflatten(char.mesh[mesh_index].triangles.data, 3)
+        });
+    }
+    return exportAsWavefrontObj(geometries);
+}

package/src/utils/Math.ts

@@ -0,0 +1,266 @@
+export type vec3 = [number, number, number];
+export type vec4 = [number, number, number, number];
+export type mat3 = [vec3, vec3, vec3];
+export type mat4 = [vec4, vec4, vec4, vec4];
+
+export function length(vec: number[]): number { return Math.sqrt(vec.reduce((sum, val) => (sum + val * val), 0.0)); }
+export function normalize(vec: number[]): number[] {
+    let vec_len = length(vec);
+    return vec.map((x) => (x / vec_len));
+}
+export function mvmul(lhs: number[][], rhs: number[]): number[] {
+    // lhs is row major.
+    const size_row = lhs.length;
+    const size_col = rhs.length;
+    let result: number[] = Array(size_row);
+    for (let i = 0; i < size_row; i++) {
+        result[i] = 0.0;
+        for (let j = 0; j < size_col; j++)result[i] += lhs[i][j] * rhs[j];
+    }
+    return result;
+}
+export function mmul(lhs: number[][], rhs: number[][]): number[][] {
+    // lhs and rhs is row major.
+    const size_row = lhs.length;
+    const size_mid = rhs.length;
+    const size_col = rhs[0].length;
+    let result: number[][] = Array(size_row);
+    for (let i = 0; i < size_row; i++) {
+        let result_row: number[] = Array(size_col);
+        for (let j = 0; j < size_col; j++){
+            result_row[j] = 0.0;
+            for (let k = 0; k < size_mid; k++)result_row[j] += lhs[i][k] * rhs[k][j];
+        }
+        result[i] = result_row;
+    }
+    return result;
+}
+export function transpose(mat: number[][]): number[][] {
+    // lhs and rhs is row major.
+    const size_row = mat.length;
+    const size_col = mat[0].length;
+    let result: number[][] = Array(size_col);
+    for (let i = 0; i < size_col; i++) {
+        let result_row: number[] = Array(size_row);
+        for (let j = 0; j < size_row; j++) {
+            result_row[j] = mat[j][i];
+        }
+        result[i] = result_row;
+    }
+    return result;
+}
+export function identity(size: number): number[][] {
+    let result: number[][] = Array(size);
+    for (let i = 0; i < size; i++) {
+        let result_row: number[] = Array(size);
+        for (let j = 0; j < size; j++)result_row[j] = (i == j ? 1.0 : 0.0);
+        result[i] = result_row;
+    }
+    return result;
+}
+export function det3(mat: mat3): number {
+    let result = 0.0;
+    result += mat[0][0] * mat[1][1] * mat[2][2];
+    result += mat[0][1] * mat[1][2] * mat[2][0];
+    result += mat[0][2] * mat[1][0] * mat[2][1];
+    result -= mat[0][2] * mat[1][1] * mat[2][0];
+    result -= mat[0][1] * mat[1][0] * mat[2][2];
+    result -= mat[0][0] * mat[1][2] * mat[2][1];
+    return result;
+}
+export function inv3(mat: mat3): mat3 {
+	const invdet = 1.0 / det3(mat);
+	return [
+        [(mat[1][1] * mat[2][2] - mat[2][1] * mat[1][2]) * invdet, (mat[0][2] * mat[2][1] - mat[0][1] * mat[2][2]) * invdet, (mat[0][1] * mat[1][2] - mat[0][2] * mat[1][1]) * invdet],
+        [(mat[1][2] * mat[2][0] - mat[1][0] * mat[2][2]) * invdet, (mat[0][0] * mat[2][2] - mat[0][2] * mat[2][0]) * invdet, (mat[1][0] * mat[0][2] - mat[0][0] * mat[1][2]) * invdet],
+	    [(mat[1][0] * mat[2][1] - mat[2][0] * mat[1][1]) * invdet, (mat[2][0] * mat[0][1] - mat[0][0] * mat[2][1]) * invdet, (mat[0][0] * mat[1][1] - mat[1][0] * mat[0][1]) * invdet]
+    ];
+}
+export function inv4(mat: mat4): mat4 {
+    //Gauss-Jordan inverse from http://dev.gameres.com/Program/Visual/3D/Mnquick.htm
+    let result: mat4 = [[...mat[0]], [...mat[1]], [...mat[2]], [...mat[3]]];
+    let xPos = [0, 0, 0, 0], yPos = [0, 0, 0, 0];
+    let flip = 1;
+    let det = 1, tmp = 0;
+
+    for (let k = 0; k < 4; k++) {
+        //Choose pivot element
+        let pivot = 0;
+        for (let i = k; i < 4; i++) {
+            for (let j = k; j < 4; j++) {
+                if (Math.abs(result[i][j]) > pivot) { pivot = Math.abs(result[i][j]); xPos[k] = i; yPos[k] = j; }
+            }
+        }
+        if (pivot < Number.EPSILON) return new Array(4).fill(new Array(4).fill(NaN)) as mat4;
+        //Swap pivot element to lead element
+        if (xPos[k] != k) {
+            flip = -flip;
+            for (let i = 0; i < 4; i++) {
+                tmp = result[k][i];
+                result[k][i] = result[xPos[k]][i];
+                result[xPos[k]][i] = tmp;
+            }
+        }
+        if (yPos[k] != k) {
+            flip = -flip;
+            for (let i = 0; i < 4; i++) {
+                tmp = result[i][k];
+                result[i][k] = result[i][yPos[k]];
+                result[i][yPos[k]] = tmp;
+            }
+        }
+        det *= result[k][k];
+
+        //elimination
+        result[k][k] = 1 / result[k][k];
+        for (let j = 0; j < 4; j++) {
+            if (j != k) result[k][j] *= result[k][k];
+        }
+        for (let i = 0; i < 4; i++) {
+            if (i != k) {
+                for (let j = 0; j < 4; j++) {
+                    if (j != k) result[i][j] -= result[i][k] * result[k][j];
+                }
+            }
+        }
+        for (let i = 0; i < 4; i++) {
+            if (i != k) result[i][k] *= -result[k][k];
+        }
+    }
+
+    for (let k = 3; k >= 0; k--) {
+        if (yPos[k] != k) {
+            for (let i = 0; i < 4; i++) {
+                tmp = result[k][i];
+                result[k][i] = result[yPos[k]][i];
+                result[yPos[k]][i] = tmp;
+            }
+        }
+        if (xPos[k] != k) {
+            for (let i = 0; i < 4; i++) {
+                tmp = result[i][k];
+                result[i][k] = result[i][xPos[k]];
+                result[i][xPos[k]] = tmp;
+            }
+        }
+    }
+    return result;
+}
+export function quaternion_conj(q: vec4): vec4 {
+    return [q[0], -q[1], -q[2], -q[3]];
+}
+export function quaternion_mul(lhs: vec4, rhs: vec4): vec4 {
+    return [
+	    lhs[0] * rhs[0] - lhs[1] * rhs[1] - lhs[2] * rhs[2] - lhs[3] * rhs[3],
+	    lhs[0] * rhs[1] + lhs[1] * rhs[0] + lhs[2] * rhs[3] - lhs[3] * rhs[2],
+	    lhs[0] * rhs[2] - lhs[1] * rhs[3] + lhs[2] * rhs[0] + lhs[3] * rhs[1],
+	    lhs[0] * rhs[3] + lhs[1] * rhs[2] - lhs[2] * rhs[1] + lhs[3] * rhs[0],
+    ];
+}
+export function quaternion_to_mat(q: vec4): mat3 {
+    const [r, i, j, k] = q;
+    return [
+        [r * r + i * i - j * j - k * k, 2 * (i * j - k * r), 2 * (i * k + j * r)],
+        [2 * (i * j + k * r), r * r - i * i + j * j - k * k, 2 * (j * k - i * r)],
+        [2 * (i * k - j * r), 2 * (j * k + i * r), r * r - i * i - j * j + k * k]
+    ];
+}
+export function mat_to_quaternion(mat: mat3 | mat4): vec4 {
+    let trace: number;
+    let result: vec4;
+    if (mat[2][2] < 0.0) {
+        if (mat[0][0] > mat[1][1]) {
+            trace = 1.0 + mat[0][0] - mat[1][1] - mat[2][2];
+            result = [mat[2][1] - mat[1][2], trace, mat[1][0] + mat[0][1], mat[0][2] + mat[2][0]];
+        }
+        else {
+            trace = 1.0 - mat[0][0] + mat[1][1] - mat[2][2];
+            result = [mat[0][2] - mat[2][0], mat[1][0] + mat[0][1], trace, mat[2][1] + mat[1][2]];
+        }
+    }
+    else {
+        if (mat[0][0] < -mat[1][1]) {
+            trace = 1.0 - mat[0][0] - mat[1][1] + mat[2][2];
+            result = [mat[1][0] - mat[0][1], mat[0][2] + mat[2][0], mat[2][1] + mat[1][2], trace];
+        }
+        else {
+            trace = 1.0 + mat[0][0] + mat[1][1] + mat[2][2];
+            result = [trace, mat[2][1] - mat[1][2], mat[0][2] - mat[2][0], mat[1][0] - mat[0][1]];
+        }
+    }
+    let trace_2sqrt = 2.0 * Math.sqrt(trace); // need further check
+    for (let i = 0; i < 4; i++)result[i] /= trace_2sqrt;
+    return result;
+}
+export function GivensTransform(mat: number[][], row0: number, row1: number, angle: number): void {
+    // The angle should be in radian.
+
+    const s = Math.sin(angle);
+    const c = Math.cos(angle);
+    const size_col = mat[0].length;
+    for (let i = 0; i < size_col; i++) {
+        const a1 = c * mat[row0][i] - s * mat[row1][i];
+        const a2 = s * mat[row0][i] + c * mat[row1][i];
+        mat[row0][i] = a1;
+        mat[row1][i] = a2;
+    }
+}
+export function Euler_to_mat(angles: [number, number, number], order: string = "xyz"): mat3 {
+    // The angle should be in radian.
+    let result = identity(3) as mat3;
+    
+    switch(order){
+        case "xyz":
+            GivensTransform(result, 1, 2, angles[0]);
+            GivensTransform(result, 2, 0, angles[1]);
+            GivensTransform(result, 0, 1, angles[2]);
+            break
+        case "yzx":
+            GivensTransform(result, 0, 1, angles[2]);
+            GivensTransform(result, 1, 2, angles[0]);
+            GivensTransform(result, 2, 0, angles[1]);
+            break
+        case "zxy":
+            GivensTransform(result, 1, 2, angles[0]);
+            GivensTransform(result, 2, 0, angles[1]);
+            GivensTransform(result, 0, 1, angles[2]);
+            break
+        case "xzy":
+            GivensTransform(result, 1, 2, angles[0]);
+            GivensTransform(result, 0, 1, angles[2]);
+            GivensTransform(result, 2, 0, angles[1]);
+            break
+        case "yxz":
+            GivensTransform(result, 2, 0, angles[1]);
+            GivensTransform(result, 1, 2, angles[0]);
+            GivensTransform(result, 0, 1, angles[2]);
+            break
+        case "zyx":
+            GivensTransform(result, 0, 1, angles[2]);
+            GivensTransform(result, 2, 0, angles[1]);
+            GivensTransform(result, 1, 2, angles[0]);
+            break
+        default:
+            throw Error("Unrecognizable rotation order.");
+    }
+
+    return result;
+}
+export function make_homogeneous(mat: mat3, translation: vec3): mat4 {
+    // lhs and rhs is row major.
+    return [
+        [mat[0][0], mat[0][1], mat[0][2], translation[0]],
+        [mat[1][0], mat[1][1], mat[1][2], translation[1]],
+        [mat[2][0], mat[2][1], mat[2][2], translation[2]],
+        [0.0, 0.0, 0.0, 1.0]
+    ]
+}
+export function flatten(mat: number[][]): number[] {
+    const size_row = mat.length;
+    const size_col = mat[0].length;
+    let result: number[] = Array(size_row * size_col);
+    for (let i = 0; i < size_row; i++) {
+        for (let j = 0; j < size_col; j++)result[i * size_col + j] = mat[i][j];
+    }
+    return result;
+}

package/src/utils/__tests__/capability-checker.test.ts

@@ -0,0 +1,159 @@
+// @ts-nocheck
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { checkCapability } from '../capability-checker';
+
+type WorkerConstructor = new (url: string) => {
+  onmessage: ((event: { data: unknown }) => void) | null;
+  onerror: ((event: unknown) => void) | null;
+  terminate(): void;
+};
+
+function installCapabilityBrowser(WorkerClass?: WorkerConstructor) {
+  const globals = globalThis as typeof globalThis & Record<string, unknown>;
+  const descriptors = new Map<string, PropertyDescriptor | undefined>();
+  const remember = (name: string) => descriptors.set(
+    name,
+    Object.getOwnPropertyDescriptor(globalThis, name),
+  );
+
+  for (const name of [
+    'window',
+    'Worker',
+    'AudioContext',
+    'AudioWorkletNode',
+    'setTimeout',
+    'clearTimeout',
+  ]) {
+    remember(name);
+  }
+  const createObjectURL = URL.createObjectURL;
+  const revokeObjectURL = URL.revokeObjectURL;
+
+  Object.defineProperty(globalThis, 'window', { configurable: true, value: globalThis });
+  Object.defineProperty(globalThis, 'AudioContext', { configurable: true, value: class {} });
+  Object.defineProperty(globalThis, 'AudioWorkletNode', { configurable: true, value: class {} });
+  Object.defineProperty(globalThis, 'Worker', {
+    configurable: true,
+    value: WorkerClass,
+  });
+  Object.defineProperty(globalThis, 'setTimeout', {
+    configurable: true,
+    value: (callback: () => void) => {
+      queueMicrotask(callback);
+      return 1;
+    },
+  });
+  Object.defineProperty(globalThis, 'clearTimeout', {
+    configurable: true,
+    value: () => {},
+  });
+  Object.defineProperty(globalThis, 'isSecureContext', {
+    configurable: true,
+    value: true,
+  });
+  URL.createObjectURL = () => 'blob:test-worker';
+  URL.revokeObjectURL = () => {};
+
+  return () => {
+    for (const [name, descriptor] of descriptors) {
+      if (descriptor) {
+        Object.defineProperty(globalThis, name, descriptor);
+      } else {
+        delete globals[name];
+      }
+    }
+    delete globals.isSecureContext;
+    URL.createObjectURL = createObjectURL;
+    URL.revokeObjectURL = revokeObjectURL;
+  };
+}
+
+test('Worker probe timeout is retried and downgraded to a warning', async () => {
+  const workers: Array<{ terminated: boolean }> = [];
+  class SlowWorker {
+    onmessage = null;
+    onerror = null;
+    terminated = false;
+
+    constructor() {
+      workers.push(this);
+    }
+
+    terminate() {
+      this.terminated = true;
+    }
+  }
+  const restore = installCapabilityBrowser(SlowWorker);
+
+  try {
+    const report = await checkCapability(true);
+    const worker = report.items.find(item => item.name === 'worker');
+
+    assert.equal(report.supported, true);
+    assert.equal(report.fatalCount, 0);
+    assert.equal(report.warnCount, 1);
+    assert.equal(worker?.supported, false);
+    assert.equal(worker?.severity, 'warn');
+    assert.equal(workers.length, 2);
+    assert.ok(workers.every(instance => instance.terminated));
+  } finally {
+    restore();
+  }
+});
+
+test('Worker probe accepts a successful retry after an initial timeout', async () => {
+  let attempts = 0;
+  class RetriedWorker {
+    onmessage: ((event: { data: unknown }) => void) | null = null;
+    onerror = null;
+
+    constructor() {
+      attempts += 1;
+      if (attempts === 2) {
+        queueMicrotask(() => this.onmessage?.({ data: 'ok' }));
+      }
+    }
+
+    terminate() {}
+  }
+  const restore = installCapabilityBrowser(RetriedWorker);
+
+  try {
+    const report = await checkCapability(true);
+    const worker = report.items.find(item => item.name === 'worker');
+
+    assert.equal(report.supported, true);
+    assert.equal(report.warnCount, 0);
+    assert.equal(worker?.supported, true);
+    assert.deepEqual(worker?.detail, { attempts: 2 });
+  } finally {
+    restore();
+  }
+});
+
+test('Worker probe keeps explicit creation errors fatal', async () => {
+  class FailedWorker {
+    onmessage = null;
+    onerror: ((event: unknown) => void) | null = null;
+
+    constructor() {
+      queueMicrotask(() => this.onerror?.(new Error('worker failed')));
+    }
+
+    terminate() {}
+  }
+  const restore = installCapabilityBrowser(FailedWorker);
+
+  try {
+    const report = await checkCapability(true);
+    const worker = report.items.find(item => item.name === 'worker');
+
+    assert.equal(report.supported, false);
+    assert.equal(report.fatalCount, 1);
+    assert.equal(worker?.severity, 'fatal');
+    assert.equal(worker?.reason, 'Web Worker 创建失败');
+  } finally {
+    restore();
+  }
+});