refactor(scanner): type the worker path and align app-test results

Move the worker scanner surface into TypeScript, add a direct worker regression, and make the version=2 app-test path populate the same visible result data and final status as the legacy scanner. This keeps the refactor bounded while making the worker route safe to exercise.

Constraint: Must preserve the existing Apple Silicon app-test behavior while changing the worker internals
Rejected: Flip production to the worker path immediately | still needs the normal deploy path and broader production soak
Confidence: medium
Scope-risk: moderate
Reversibility: clean
Directive: Keep the version=2 adapter using the shared finishFileScan path until the legacy scanner can be removed entirely
Tested: pnpm run typecheck; pnpm exec vitest run test/scanner/client.test.ts; pnpm run test:browser (original workspace); netlify build --context deploy-preview (original workspace)
Not-tested: Browser suite from the clean clone environment (local Astro dev server startup timed out there)

Author: ThatGuySam

helpers/app-files-scanner.js

@@ -7,7 +7,7 @@ import { isString } from './check-types.js'
 import parseMacho from './macho/index.js'
 
 // Vite Web Workers - https://vitejs.dev/guide/features.html#web-workers
-import { runScanWorker } from '~/helpers/scanner/client.mjs'
+import { runScanWorker } from '~/helpers/scanner/client'
 
 const scannerVersion = (() => {
     // If there's no window
@@ -341,13 +341,58 @@ export default class AppFilesScanner {
             .then( response => response.data )
             .catch(function (error) {
                 console.error(error)
+
+                return {
+                    supportedVersionNumber: null
+                }
             })
 
         return {
             supportedVersionNumber
         }
     }
 
+    getFinishedStatusMessage ({
+        binarySupportsNative,
+        supportedVersionNumber
+    }) {
+        if ( binarySupportsNative ) {
+            return '✅ This app is natively compatible with Apple Silicon!'
+        }
+
+        if ( supportedVersionNumber != null ) {
+            return [
+                '✅ A native version of this has been reported',
+                ( isString( supportedVersionNumber ) && supportedVersionNumber.length > 0 ) ? `as of v${ supportedVersionNumber }` : null
+            ].filter( Boolean ).join(' ')
+        }
+
+        return `🔶 This app file is not natively compatible with Apple Silicon and may only run via Rosetta 2 translation, however, software vendors will sometimes will ship separate install files for Intel and ARM instead of a single one. `
+    }
+
+    finishFileScan ( file, scanIndex, {
+        binarySupportsNative,
+        supportedVersionNumber
+    } ) {
+        file.statusMessage = this.getFinishedStatusMessage({
+            binarySupportsNative,
+            supportedVersionNumber
+        })
+        file.status = 'finished'
+
+        if ( binarySupportsNative ) {
+            this.files.unshift( this.files.splice( scanIndex, 1 )[0] )
+        }
+    }
+
+    applyWorkerScanData ( file, scan ) {
+        file.appVersion = scan.appVersion || null
+        file.displayName = scan.displayName || file.displayName
+        file.details = Array.isArray( scan.details ) ? scan.details : []
+        file.displayBinarySize = scan.displayBinarySize || null
+        file.binarySize = typeof scan.binarySize === 'number' ? scan.binarySize : null
+    }
+
     async scanFile ( file, scanIndex ) {
 
         // If we've already scanned this
@@ -553,26 +598,10 @@ export default class AppFilesScanner {
 
         console.log('supportedVersionNumber', supportedVersionNumber)
 
-        let finishedStatusMessage = ''
-
-        if ( binarySupportsNative ) {
-            finishedStatusMessage = '✅ This app is natively compatible with Apple Silicon!'
-
-            // Shift this scan to the top
-            this.files.unshift( this.files.splice( scanIndex, 1 )[0] )
-        } else if ( supportedVersionNumber !== null ) {
-
-            finishedStatusMessage = [
-                '✅ A native version of this has been reported',
-                (supportedVersionNumber.length > 0) ? `as of v${supportedVersionNumber}` : null
-            ].join(' ')
-
-        } else {
-            finishedStatusMessage = `🔶 This app file is not natively compatible with Apple Silicon and may only run via Rosetta 2 translation, however, software vendors will sometimes will ship separate install files for Intel and ARM instead of a single one. `
-        }
-
-        file.statusMessage = finishedStatusMessage
-        file.status = 'finished'
+        this.finishFileScan( file, scanIndex, {
+            binarySupportsNative,
+            supportedVersionNumber
+        } )
 
         return
     }
@@ -618,20 +647,45 @@ export default class AppFilesScanner {
                 console.log( 'scannerVersion', scannerVersion )
 
                 if ( scannerVersion === '2' ) {
+                    try {
+                        const { scan } = await runScanWorker( file.instance, messageDetails => {
+                            console.log( 'messageDetails', messageDetails )
 
+                            if ( isString( messageDetails.message ) ) {
+                                file.statusMessage = messageDetails.message
+                            }
 
-                    const { scan } = await runScanWorker( file.instance, messageDetails => {
-                        console.log( 'messageDetails', messageDetails )
+                            if ( isString( messageDetails.status ) ) {
+                                file.status = messageDetails.status
+                            }
+                        } )
 
-                        file.statusMessage = messageDetails.message
-                        file.status = messageDetails.status
-                    } )
+                        this.applyWorkerScanData( file, scan )
 
-                    console.log('scan', scan)
+                        const { supportedVersionNumber } = await this.submitScanInfo({
+                            filename: scan.info?.filename || file.name,
+                            appVersion: scan.info?.appVersion || file.appVersion,
+                            result: scan.info?.result || ( scan.binarySupportsNative ? '✅' : '🔶' ),
+                            machoMeta: scan.info?.machoMeta || null,
+                            infoPlist: scan.info?.infoPlist || null
+                        })
 
-                    clearTimeout(timer)
+                        this.finishFileScan( file, scanIndex, {
+                            binarySupportsNative: Boolean( scan.binarySupportsNative ),
+                            supportedVersionNumber
+                        } )
 
-                    resolve()
+                        clearTimeout(timer)
+
+                        resolve()
+                    } catch ( error ) {
+                        file.statusMessage = `❔ ${ error.message }`
+                        file.status = 'finished'
+
+                        clearTimeout(timer)
+
+                        resolve()
+                    }
                     return
                 }
 

helpers/scanner/client.mjs

@@ -0,0 +1,124 @@
+import AppScanWorker from './worker?worker'
+
+import type {
+    AppScanSnapshot,
+    ScanFileLike,
+    ScanMessage
+} from './scan'
+
+const noop = () => {}
+
+type ScanMessageReceiver = ( details: ScanMessage ) => void
+
+interface WorkerScanFile extends ScanFileLike {
+    arrayBuffer: ArrayBuffer
+}
+
+interface WorkerFinishedMessage extends ScanMessage {
+    error?: {
+        message?: string
+    }
+    scan?: AppScanSnapshot
+    status: 'finished'
+}
+
+function toArrayBuffer ( value: ArrayBuffer | ArrayBufferView ) {
+    if ( value instanceof ArrayBuffer ) {
+        return value
+    }
+
+    return new Uint8Array(
+        value.buffer,
+        value.byteOffset,
+        value.byteLength
+    ).slice().buffer
+}
+
+function isWorkerFinishedMessage ( details: ScanMessage | WorkerFinishedMessage ): details is WorkerFinishedMessage {
+    return details.status === 'finished'
+}
+
+async function getArrayBufferFromFileData ( file: ScanFileLike ) {
+    if ( typeof file.arrayBuffer === 'function' ) {
+        return await file.arrayBuffer()
+    }
+
+    if ( file.arrayBuffer instanceof ArrayBuffer ) {
+        return file.arrayBuffer
+    }
+
+    if ( file.buffer instanceof ArrayBuffer ) {
+        return file.buffer
+    }
+
+    if ( ArrayBuffer.isView( file.buffer ) ) {
+        return toArrayBuffer( file.buffer )
+    }
+
+    throw new Error( 'No fileArrayBuffer' )
+}
+
+function makeWorkerFile ( file: ScanFileLike, arrayBuffer: ArrayBuffer ): WorkerScanFile {
+    return {
+        arrayBuffer,
+        name: file.name,
+        size: file.size ?? arrayBuffer.byteLength,
+        type: file.type ?? file.mimeType ?? ''
+    }
+}
+
+export async function runScanWorker (
+    file: ScanFileLike,
+    messageReceiver: ScanMessageReceiver = noop
+) {
+    const AppScanWorkerConstructor = AppScanWorker as unknown as { new (): Worker }
+    const appScanWorker = new AppScanWorkerConstructor()
+    const fileArrayBuffer = await getArrayBufferFromFileData( file )
+    const workerFile = makeWorkerFile( file, fileArrayBuffer )
+
+    const scan = await new Promise<AppScanSnapshot>( ( resolve, reject ) => {
+        const cleanup = () => {
+            appScanWorker.onmessage = null
+            appScanWorker.onerror = null
+            appScanWorker.terminate()
+        }
+
+        appScanWorker.onmessage = ( event: MessageEvent<ScanMessage | WorkerFinishedMessage> ) => {
+            const details = event.data
+
+            messageReceiver( details )
+
+            if ( !isWorkerFinishedMessage( details ) ) {
+                return
+            }
+
+            cleanup()
+
+            if ( details.scan ) {
+                resolve( details.scan )
+                return
+            }
+
+            reject( new Error( details.error?.message || details.message || 'Worker finished without a scan result.' ) )
+        }
+
+        appScanWorker.onerror = ( errorEvent: ErrorEvent ) => {
+            cleanup()
+            reject( new Error( errorEvent.message || 'Error received from App Scan Worker' ) )
+        }
+
+        appScanWorker.postMessage( {
+            status: 'start',
+            options: {
+                file: workerFile
+            }
+        }, [
+            fileArrayBuffer
+        ] )
+    } )
+
+    return {
+        appScanWorker,
+        scan
+    }
+}