@anionex/dsh-computer-use 0.1.0

package/native/macos/Sources/Monitor/main.swift

@@ -0,0 +1,139 @@
+import AppKit
+import CoreGraphics
+import Darwin
+import Foundation
+
+private func argument(_ name: String, default fallback: Int) -> Int {
+    let values = ProcessInfo.processInfo.arguments
+    guard let index = values.firstIndex(of: name), values.indices.contains(index + 1),
+          let value = Int(values[index + 1]), value > 0 else { return fallback }
+    return value
+}
+
+private func stringArgument(_ name: String) -> String? {
+    let values = ProcessInfo.processInfo.arguments
+    guard let index = values.firstIndex(of: name), values.indices.contains(index + 1) else { return nil }
+    return values[index + 1]
+}
+
+private func optionalIntegerArgument(_ name: String) -> Int32? {
+    guard let value = stringArgument(name), let parsed = Int32(value), parsed > 0 else { return nil }
+    return parsed
+}
+
+private func cursorLocation() -> CGPoint {
+    CGEvent(source: nil)?.location ?? .zero
+}
+
+private func frontmostPid() -> pid_t? {
+    NSWorkspace.shared.frontmostApplication?.processIdentifier
+}
+
+private func matchingWindows(ownerPid: pid_t?, title: String?) -> [[String: Any]] {
+    guard let windows = CGWindowListCopyWindowInfo(
+        [.optionOnScreenOnly, .excludeDesktopElements],
+        kCGNullWindowID
+    ) as? [[String: Any]] else { return [] }
+    return windows.filter { window in
+        if let ownerPid,
+           (window[kCGWindowOwnerPID as String] as? NSNumber)?.int32Value != ownerPid { return false }
+        if let title,
+           (window[kCGWindowName as String] as? String) != title { return false }
+        return true
+    }
+}
+
+private let durationMs = argument("--duration-ms", default: 1200)
+private let intervalMicros = useconds_t(argument("--interval-micros", default: 1000))
+private let windowOwnerPid = stringArgument("--window-owner-pid").flatMap { Int32($0) }
+private let windowTitle = stringArgument("--window-title")
+private let monitoredSourcePid = optionalIntegerArgument("--source-pid")
+private let baselineCursor = cursorLocation()
+private let baselineFrontmostPid = frontmostPid()
+private var maximumCursorDistance = 0.0
+private var observedFrontmostPids = Set<Int32>()
+private var maximumMatchingWindowCount = 0
+private var matchingWindowFrames: [[String: Any]] = []
+private var monitoredSourcePointerEvents = 0
+private var pointerEventSourceCounts: [String: Int] = [:]
+private var samples = 0
+
+private let pointerMask = [
+    CGEventType.mouseMoved,
+    .leftMouseDown,
+    .leftMouseUp,
+    .leftMouseDragged,
+    .rightMouseDown,
+    .rightMouseUp,
+    .rightMouseDragged,
+    .otherMouseDown,
+    .otherMouseUp,
+    .otherMouseDragged,
+    .scrollWheel,
+].reduce(CGEventMask(0)) { mask, type in
+    mask | (CGEventMask(1) << type.rawValue)
+}
+private let eventTap = CGEvent.tapCreate(
+    tap: .cgSessionEventTap,
+    place: .headInsertEventTap,
+    options: .listenOnly,
+    eventsOfInterest: pointerMask,
+    callback: { _, _, event, _ in
+        let sourcePid = event.getIntegerValueField(.eventSourceUnixProcessID)
+        pointerEventSourceCounts[String(sourcePid), default: 0] += 1
+        if let monitoredSourcePid, sourcePid == Int64(monitoredSourcePid) {
+            monitoredSourcePointerEvents += 1
+        }
+        return Unmanaged.passUnretained(event)
+    },
+    userInfo: nil
+)
+private let eventTapSource = eventTap.map {
+    CFMachPortCreateRunLoopSource(kCFAllocatorDefault, $0, 0)
+}
+
+if let eventTap, let eventTapSource {
+    CFRunLoopAddSource(CFRunLoopGetCurrent(), eventTapSource, .defaultMode)
+    CGEvent.tapEnable(tap: eventTap, enable: true)
+}
+
+if let baselineFrontmostPid { observedFrontmostPids.insert(baselineFrontmostPid) }
+FileHandle.standardOutput.write(Data("READY\n".utf8))
+
+let deadline = DispatchTime.now().uptimeNanoseconds + UInt64(durationMs) * 1_000_000
+while DispatchTime.now().uptimeNanoseconds < deadline {
+    let location = cursorLocation()
+    let distance = hypot(location.x - baselineCursor.x, location.y - baselineCursor.y)
+    maximumCursorDistance = max(maximumCursorDistance, distance)
+    if let pid = frontmostPid() { observedFrontmostPids.insert(pid) }
+    let windows = matchingWindows(ownerPid: windowOwnerPid, title: windowTitle)
+    maximumMatchingWindowCount = max(maximumMatchingWindowCount, windows.count)
+    if let first = windows.first,
+       let bounds = first[kCGWindowBounds as String] as? [String: Any] {
+        matchingWindowFrames = [bounds]
+    }
+    samples += 1
+    if eventTapSource != nil {
+        CFRunLoopRunInMode(.defaultMode, Double(intervalMicros) / 1_000_000, true)
+    } else {
+        usleep(intervalMicros)
+    }
+}
+
+let finalCursor = cursorLocation()
+let result: [String: Any] = [
+    "baselineCursor": ["x": baselineCursor.x, "y": baselineCursor.y],
+    "finalCursor": ["x": finalCursor.x, "y": finalCursor.y],
+    "maximumCursorDistance": maximumCursorDistance,
+    "baselineFrontmostPid": baselineFrontmostPid.map(Int.init) as Any,
+    "observedFrontmostPids": observedFrontmostPids.sorted().map(Int.init),
+    "samples": samples,
+    "maximumMatchingWindowCount": maximumMatchingWindowCount,
+    "matchingWindowFrames": matchingWindowFrames,
+    "eventTapAvailable": eventTap != nil,
+    "monitoredSourcePointerEvents": monitoredSourcePointerEvents,
+    "pointerEventSourceCounts": pointerEventSourceCounts,
+]
+let data = try JSONSerialization.data(withJSONObject: result, options: [.sortedKeys])
+FileHandle.standardOutput.write(data)
+FileHandle.standardOutput.write(Data("\n".utf8))

package/native/macos/manifest.json

@@ -0,0 +1,14 @@
+{
+  "schemaVersion": 1,
+  "helperVersion": "0.1.0",
+  "sourceSha256": "a913bbefeffc26247fb792490e9c2ae08598c923a9746b7d4ca8b7cc9efc607c",
+  "binary": {
+    "path": "bin/dsh-computer-use-helper",
+    "sha256": "6dbb7d4b171d9f480e046a4c69df6e3b41c8c5bf0decfabc6e5331c1dc79af91",
+    "architectures": [
+      "arm64",
+      "x86_64"
+    ],
+    "minimumMacOS": "14.0"
+  }
+}

package/package.json

@@ -0,0 +1,128 @@
+{
+  "name": "@anionex/dsh-computer-use",
+  "version": "0.1.0",
+  "description": "Accessibility-first macOS Computer Use capability for DeepSeek Harness with stale-observation protection, app leases, confirmations, screenshots, and Web diagnostics",
+  "keywords": [
+    "deepseek",
+    "deepseek-harness",
+    "computer-use",
+    "macos",
+    "accessibility",
+    "desktop-automation"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Anionex/dsh-computer-use.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Anionex/dsh-computer-use/issues"
+  },
+  "type": "module",
+  "packageManager": "pnpm@11.20.0",
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./service": {
+      "types": "./lib/types/service.d.ts",
+      "default": "./lib/service.js"
+    },
+    "./provider-macos": {
+      "types": "./lib/types/providers/macos.d.ts",
+      "default": "./lib/providers/macos.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "src",
+    "assets",
+    "native/macos/Sources",
+    "native/macos/bin",
+    "native/macos/manifest.json",
+    "scripts",
+    "docs",
+    "cordis.patch.yml",
+    "README.md",
+    "README.zh.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "native:build": "node scripts/build-native.mjs",
+    "check:native": "node scripts/check-native.mjs",
+    "build": "pnpm run native:build && tsc -p tsconfig.json && tsc -p tsconfig.client.json && node scripts/build-client.mjs",
+    "prepack": "pnpm run build",
+    "test": "pnpm run build && vitest run tests",
+    "test:model": "node scripts/model-e2e.mjs",
+    "test:watch": "vitest tests",
+    "validate": "node scripts/validate.mjs --lane all",
+    "validate:local": "node scripts/validate.mjs --lane local",
+    "validate:profile": "node scripts/validate.mjs --lane profile",
+    "validate:model": "node scripts/model-e2e.mjs",
+    "validate:release": "pnpm run validate && pnpm run validate:model"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-api-remotes"
+      ],
+      "platform": "web"
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-agent": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-api-remotes": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-brand": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-runtime": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-settings": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-settings": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-skill": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-storage-domain": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-subprocess": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-user-approval": "^0.1.0-rc.6",
+    "@deepseek-ai/cordis": "^4.0.1",
+    "react": "^18.2.0",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-host-webserver": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.0",
+    "@types/react": "~18.3.1",
+    "@types/react-dom": "~18.3.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10"
+  },
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
+  "license": "MIT"
+}

package/scripts/build-client.mjs

@@ -0,0 +1,24 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const root = dirname(fileURLToPath(new URL('../package.json', import.meta.url)))
+const compiledPath = join(root, '.client-build', 'index.js')
+const outputPath = join(root, 'lib', 'client.js')
+const source = await readFile(compiledPath, 'utf8')
+const wrapped = [
+  'window.__ModuleLoader__.load({ id: "@anionex/dsh-computer-use", factory: (require) => {',
+  'var module = { exports: {} }; var exports = module.exports;',
+  source.replace(/\n?\/\/# sourceMappingURL=.*$/u, ''),
+  'return module.exports; } });',
+  '//# sourceMappingURL=client.js.map',
+  '',
+].join('\n')
+
+await mkdir(dirname(outputPath), { recursive: true })
+await writeFile(outputPath, wrapped)
+const rawMap = JSON.parse(await readFile(`${compiledPath}.map`, 'utf8'))
+rawMap.file = 'client.js'
+rawMap.sources = rawMap.sources.map(sourcePath => `../src/client/${sourcePath.replace(/^\.\.\//u, '')}`)
+await writeFile(`${outputPath}.map`, `${JSON.stringify(rawMap)}\n`)
+await rm(join(root, '.client-build'), { recursive: true, force: true })

package/scripts/build-native.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+
+import { createHash } from 'node:crypto'
+import { spawn } from 'node:child_process'
+import { chmod, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises'
+import { arch } from 'node:os'
+import { basename, dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const ROOT = dirname(fileURLToPath(new URL('../package.json', import.meta.url)))
+const NATIVE = join(ROOT, 'native', 'macos')
+const BUILD = join(NATIVE, 'build')
+const HELPER_SOURCE = join(NATIVE, 'Sources', 'Helper')
+const FIXTURE_SOURCE = join(NATIVE, 'Sources', 'Fixture', 'main.swift')
+const MONITOR_SOURCE = join(NATIVE, 'Sources', 'Monitor', 'main.swift')
+const HELPER_OUTPUT = join(NATIVE, 'bin', 'dsh-computer-use-helper')
+const FIXTURE_APP = join(NATIVE, 'fixture', 'DSHComputerUseFixture.app')
+const MONITOR_OUTPUT = join(NATIVE, 'fixture', 'dsh-computer-use-input-monitor')
+const args = new Set(process.argv.slice(2))
+const helperOnly = args.has('--helper-only')
+const fixtureOnly = args.has('--fixture-only')
+if ([...args].some(value => !['--helper-only', '--fixture-only'].includes(value)) || (helperOnly && fixtureOnly)) {
+  throw new Error('usage: build-native.mjs [--helper-only | --fixture-only]')
+}
+
+async function run(command, commandArgs, timeoutMs = 180000) {
+  const result = await new Promise((resolveResult) => {
+    const child = spawn(command, commandArgs, { cwd: ROOT, stdio: ['ignore', 'pipe', 'pipe'] })
+    let stdout = ''
+    let stderr = ''
+    child.stdout.setEncoding('utf8').on('data', value => { stdout += value })
+    child.stderr.setEncoding('utf8').on('data', value => { stderr += value })
+    const timer = setTimeout(() => child.kill('SIGKILL'), timeoutMs)
+    child.once('error', error => {
+      clearTimeout(timer)
+      resolveResult({ code: -1, stdout, stderr: `${stderr}${error.message}` })
+    })
+    child.once('close', code => {
+      clearTimeout(timer)
+      resolveResult({ code: code ?? -1, stdout, stderr })
+    })
+  })
+  if (result.code !== 0) throw new Error(`${command} failed (${result.code})\n${result.stderr || result.stdout}`)
+  return result.stdout.trim()
+}
+
+async function hashFile(path) {
+  return createHash('sha256').update(await readFile(path)).digest('hex')
+}
+
+async function hashDirectory(directory) {
+  const names = (await readdir(directory)).filter(name => name.endsWith('.swift')).sort()
+  const hash = createHash('sha256')
+  for (const name of names) {
+    hash.update(name)
+    hash.update('\0')
+    hash.update(await readFile(join(directory, name)))
+    hash.update('\0')
+  }
+  return hash.digest('hex')
+}
+
+async function buildHelper() {
+  await mkdir(BUILD, { recursive: true })
+  await mkdir(dirname(HELPER_OUTPUT), { recursive: true })
+  const sources = (await readdir(HELPER_SOURCE)).filter(name => name.endsWith('.swift')).sort().map(name => join(HELPER_SOURCE, name))
+  const outputs = []
+  for (const architecture of ['arm64', 'x86_64']) {
+    const output = join(BUILD, `dsh-computer-use-helper-${architecture}`)
+    await run('xcrun', [
+      'swiftc', '-swift-version', '5', '-parse-as-library', '-O',
+      '-target', `${architecture}-apple-macos14.0`,
+      '-framework', 'AppKit',
+      '-framework', 'ApplicationServices',
+      '-framework', 'CoreGraphics',
+      '-framework', 'QuartzCore',
+      '-framework', 'ScreenCaptureKit',
+      '-lproc',
+      ...sources,
+      '-o', output,
+    ], 300000)
+    outputs.push(output)
+  }
+  await run('xcrun', ['lipo', '-create', ...outputs, '-output', HELPER_OUTPUT])
+  await chmod(HELPER_OUTPUT, 0o755)
+  await run('codesign', ['--force', '--sign', '-', '--timestamp=none', HELPER_OUTPUT])
+  const architectures = (await run('xcrun', ['lipo', '-archs', HELPER_OUTPUT])).split(/\s+/u).filter(Boolean).sort()
+  if (architectures.join(',') !== 'arm64,x86_64') throw new Error(`helper is not universal: ${architectures.join(', ')}`)
+  const manifest = {
+    schemaVersion: 1,
+    helperVersion: '0.1.0',
+    sourceSha256: await hashDirectory(HELPER_SOURCE),
+    binary: {
+      path: 'bin/dsh-computer-use-helper',
+      sha256: await hashFile(HELPER_OUTPUT),
+      architectures,
+      minimumMacOS: '14.0',
+    },
+  }
+  await writeFile(join(NATIVE, 'manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`)
+  return { path: HELPER_OUTPUT, ...manifest.binary }
+}
+
+async function buildFixture() {
+  const contents = join(FIXTURE_APP, 'Contents')
+  const executable = join(contents, 'MacOS', 'DSHComputerUseFixture')
+  await rm(FIXTURE_APP, { recursive: true, force: true })
+  await mkdir(dirname(executable), { recursive: true })
+  await mkdir(join(contents, 'Resources'), { recursive: true })
+  const targetArch = arch() === 'x64' ? 'x86_64' : 'arm64'
+  await run('xcrun', [
+    'swiftc', '-swift-version', '5', '-O',
+    '-target', `${targetArch}-apple-macos14.0`,
+    '-framework', 'AppKit',
+    FIXTURE_SOURCE,
+    '-o', executable,
+  ], 180000)
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+<key>CFBundleDevelopmentRegion</key><string>en</string>
+<key>CFBundleExecutable</key><string>DSHComputerUseFixture</string>
+<key>CFBundleIdentifier</key><string>io.anionex.dsh-computer-use-fixture</string>
+<key>CFBundleInfoDictionaryVersion</key><string>6.0</string>
+<key>CFBundleName</key><string>DSH Computer Use Fixture</string>
+<key>CFBundlePackageType</key><string>APPL</string>
+<key>CFBundleShortVersionString</key><string>0.1.0</string>
+<key>CFBundleVersion</key><string>1</string>
+<key>LSMinimumSystemVersion</key><string>14.0</string>
+<key>NSHighResolutionCapable</key><true/>
+</dict></plist>
+`
+  await writeFile(join(contents, 'Info.plist'), plist)
+  await run('codesign', ['--force', '--deep', '--sign', '-', '--timestamp=none', FIXTURE_APP])
+  await run('xcrun', [
+    'swiftc', '-swift-version', '5', '-O',
+    '-target', `${targetArch}-apple-macos14.0`,
+    '-framework', 'AppKit',
+    '-framework', 'CoreGraphics',
+    MONITOR_SOURCE,
+    '-o', MONITOR_OUTPUT,
+  ], 180000)
+  await chmod(MONITOR_OUTPUT, 0o755)
+  await run('codesign', ['--force', '--sign', '-', '--timestamp=none', MONITOR_OUTPUT])
+  return {
+    path: FIXTURE_APP,
+    bundleId: 'io.anionex.dsh-computer-use-fixture',
+    executable: basename(executable),
+    monitor: MONITOR_OUTPUT,
+  }
+}
+
+await mkdir(BUILD, { recursive: true })
+const result = {}
+if (!fixtureOnly) result.helper = await buildHelper()
+if (!helperOnly) result.fixture = await buildFixture()
+await rm(BUILD, { recursive: true, force: true })
+process.stdout.write(`${JSON.stringify({ ok: true, ...result }, null, 2)}\n`)

package/scripts/check-native.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+import { createHash } from 'node:crypto'
+import { execFile } from 'node:child_process'
+import { readFile, readdir } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { promisify } from 'node:util'
+import { fileURLToPath } from 'node:url'
+
+const execFileAsync = promisify(execFile)
+const root = dirname(fileURLToPath(new URL('../package.json', import.meta.url)))
+const nativeRoot = join(root, 'native', 'macos')
+const helperPath = join(nativeRoot, 'bin', 'dsh-computer-use-helper')
+const manifest = JSON.parse(await readFile(join(nativeRoot, 'manifest.json'), 'utf8'))
+
+function assert(condition, message) {
+  if (!condition) throw new Error(`native integrity: ${message}`)
+}
+
+async function sha256(path) {
+  return createHash('sha256').update(await readFile(path)).digest('hex')
+}
+
+async function sourceSha256() {
+  const sourceRoot = join(nativeRoot, 'Sources', 'Helper')
+  const names = (await readdir(sourceRoot)).filter(name => name.endsWith('.swift')).sort()
+  const hash = createHash('sha256')
+  for (const name of names) {
+    hash.update(name)
+    hash.update('\0')
+    hash.update(await readFile(join(sourceRoot, name)))
+    hash.update('\0')
+  }
+  return hash.digest('hex')
+}
+
+async function helperSource() {
+  const sourceRoot = join(nativeRoot, 'Sources', 'Helper')
+  const names = (await readdir(sourceRoot)).filter(name => name.endsWith('.swift')).sort()
+  return (await Promise.all(names.map(name => readFile(join(sourceRoot, name), 'utf8')))).join('\n')
+}
+
+assert(manifest.schemaVersion === 1, 'unsupported manifest schema')
+assert(manifest.binary?.path === 'bin/dsh-computer-use-helper', 'unexpected helper path')
+assert(manifest.binary?.minimumMacOS === '14.0', 'unexpected minimum macOS version')
+assert(manifest.sourceSha256 === await sourceSha256(), 'Swift source digest does not match manifest')
+assert(manifest.binary.sha256 === await sha256(helperPath), 'helper SHA-256 does not match manifest')
+
+const architectureOutput = await execFileAsync('xcrun', ['lipo', '-archs', helperPath])
+const architectures = architectureOutput.stdout.trim().split(/\s+/u).sort()
+assert(JSON.stringify(architectures) === JSON.stringify(['arm64', 'x86_64']), `unexpected architectures: ${architectures.join(', ')}`)
+await execFileAsync('codesign', ['--verify', '--strict', helperPath])
+
+const source = await helperSource()
+assert(!/CGWarpMouseCursorPosition|CGAssociateMouseAndMouseCursorPosition/u.test(source), 'source contains a system-cursor warp primitive')
+assert(!/\.post\s*\(\s*tap:|cghidEventTap/u.test(source), 'source contains a global HID pointer-post path')
+assert(source.includes('SLEventPostToPid'), 'source does not contain the target-process SkyLight pointer route')
+assert(source.includes('CGEventSetWindowLocation'), 'source does not bind pointer events to window-local coordinates')
+assert(source.includes('proc_pidfdinfo'), 'source does not inspect parent-owned native transports')
+assert(source.includes('getpgrp() == getpid()'), 'source does not require a managed detached process group')
+assert(source.includes('parentOwnsStandardTransport()'), 'source does not validate parent ownership of the three standard transports')
+const dynamicSymbols = [...source.matchAll(/Self\.resolve\s*\(\s*handle\s*,\s*"([^"]+)"/gu)].map(match => match[1]).sort()
+const allowedDynamicSymbols = ['CGEventSetWindowLocation', 'SLEventPostToPid', 'SLEventSetIntegerValueField'].sort()
+assert(
+  JSON.stringify(dynamicSymbols) === JSON.stringify(allowedDynamicSymbols),
+  `unexpected dynamic native symbols: ${dynamicSymbols.join(', ') || '(none)'}`,
+)
+assert((source.match(/\bdlsym\s*\(/gu) ?? []).length === 1, 'native helper must keep one audited dlsym call site')
+
+const symbolOutput = await execFileAsync('nm', ['-u', helperPath])
+const undefinedSymbols = symbolOutput.stdout.split(/\r?\n/u).map(line => line.trim().split(/\s+/u).at(-1)).filter(Boolean)
+for (const forbidden of ['_CGEventPost', '_CGWarpMouseCursorPosition', '_CGAssociateMouseAndMouseCursorPosition']) {
+  assert(!undefinedSymbols.includes(forbidden), `helper links forbidden global pointer symbol ${forbidden}`)
+}
+
+const stringOutput = await execFileAsync('strings', [helperPath])
+const binaryStrings = stringOutput.stdout.split(/\r?\n/u)
+for (const allowed of allowedDynamicSymbols) {
+  assert(binaryStrings.includes(allowed), `helper binary is missing audited dynamic symbol ${allowed}`)
+}
+for (const forbidden of ['CGEventPost', 'CGWarpMouseCursorPosition', 'CGAssociateMouseAndMouseCursorPosition']) {
+  assert(!binaryStrings.includes(forbidden), `helper contains forbidden dynamic symbol literal ${forbidden}`)
+}
+
+process.stdout.write(`${JSON.stringify({
+  ok: true,
+  helper: manifest.binary.path,
+  sha256: manifest.binary.sha256,
+  architectures,
+  minimumMacOS: manifest.binary.minimumMacOS,
+  pointerRouting: 'target-process-only',
+}, null, 2)}\n`)