@0biwank/screen-capture 1.0.1 → 2.0.1

package/index.d.ts

@@ -0,0 +1,99 @@
+export interface CaptureOptions {
+  /** CGDirectDisplayID — 0 means primary display */
+  displayId?: number;
+  /** Capture one ScreenCaptureKit window instead of the complete display. */
+  captureWindow?: boolean;
+  /** CGWindowID used when captureWindow is true. */
+  windowId?: number;
+  /** If true, don't start ScreenCaptureKit (useful for camera-only) */
+  noScreen?: boolean;
+  /** If true, capture from native camera */
+  camera?: boolean;
+  /** Unique ID of the camera device; empty = default */
+  cameraDeviceUid?: string;
+
+  width?: number;
+  height?: number;
+  fps?: number;
+  /** Encoder GOP size in frames. Use segmentTime * fps for HLS-aligned chunks. */
+  gopSize?: number;
+  /** Video bitrate in bps (default 9 000 000) */
+  videoBitrate?: number;
+  cropX?: number;
+  cropY?: number;
+  cropWidth?: number;
+  cropHeight?: number;
+  /** Capture system audio via ScreenCaptureKit (default true) */
+  systemAudio?: boolean;
+  /** Mix microphone audio via AVAudioEngine (default false) */
+  microphone?: boolean;
+  /** CoreAudio device UID for the microphone; empty = OS default */
+  micDeviceUid?: string;
+  sampleRate?: number;
+  /** Audio bitrate in bps (default 128 000) */
+  audioBitrate?: number;
+  /** Directory where native file-backed HLS should write playlist.m3u8 and .ts files. */
+  outputDir?: string;
+  /** Recording ID used in segment filenames: <recordingId>-video-%04d.ts. */
+  recordingId?: string;
+  /** HLS segment duration in seconds. */
+  segmentTime?: number;
+}
+
+export interface DisplaySource {
+  id: number;
+  name: string;
+  isMain: boolean;
+  width: number;
+  height: number;
+}
+
+export interface WindowSource {
+  id: number;
+  name: string;
+}
+
+export interface AudioInputDevice {
+  uid: string;
+  name: string;
+  manufacturer: string;
+}
+
+export interface VideoInputDevice {
+  uid: string;
+  name: string;
+}
+
+export type SegmentReadyCallback = (fullPath: string) => void;
+
+/**
+ * Start native screen + audio capture.
+ * Returns false if capture could not be started.
+ */
+export function startCapture(options?: CaptureOptions): boolean;
+
+export function setSegmentReadyCallback(callback: SegmentReadyCallback | null | undefined): void;
+
+/**
+ * Stop capture and flush any remaining buffered data.
+ */
+export function stopCapture(): boolean;
+
+/** Return the last native capture error message, if any. */
+export function getLastError(): string;
+
+/** List available display sources. */
+export function listDisplaySources(): DisplaySource[];
+
+/** List available window sources. */
+export function listWindowSources(): WindowSource[];
+
+/** List native CoreAudio input devices. */
+export function listAudioInputDevices(): AudioInputDevice[];
+
+/** List available native camera devices. */
+export function listVideoInputDevices(): VideoInputDevice[];
+
+export function resumeCapture(): boolean;
+
+export function pauseCapture(): boolean;

package/index.js

@@ -1,16 +1,107 @@
-const processor = require('./build/Release/media_processor');
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+if (process.platform !== 'darwin') {
+  throw new Error(`@0biwank/screen-capture supports macOS only; received ${process.platform}`);
+}
+
+if (!['arm64', 'x64'].includes(process.arch)) {
+  throw new Error(`@0biwank/screen-capture does not support macOS architecture ${process.arch}`);
+}
+
+const prebuiltPath = path.join(
+  __dirname,
+  'prebuilds',
+  `darwin-${process.arch}`,
+  'native_capture.node',
+);
+const developmentPath = path.join(__dirname, 'build', 'Release', 'native_capture.node');
+const addonPath = fs.existsSync(prebuiltPath) ? prebuiltPath : developmentPath;
+
+if (!fs.existsSync(addonPath)) {
+  throw new Error(
+    `Missing @0biwank/screen-capture native binary for darwin-${process.arch}. ` +
+      `Expected ${prebuiltPath}`,
+  );
+}
+
+const addon = require(addonPath);
 
 module.exports = {
-    /** @returns {boolean} */
-    processMediaStream: processor.processMediaStream,
-    /** @returns {boolean} */
-    startCapture: processor.startCapture,
-    /** @returns {boolean} */
-    stopCapture: processor.stopCapture,
-    /** @returns {boolean} */
-    selectSource: processor.selectSource,
-    /** @returns {Array} */
-    listWindowSources: processor.listWindowSources,
-    /** @returns {Array} */
-    listDisplaySources: processor.listDisplaySources
-};
+  /**
+   * Start capturing.
+   *
+   * @param {object} [options]
+   * @param {number}  [options.displayId=0]         CGDirectDisplayID; 0 = primary
+   * @param {number}  [options.width=1920]
+   * @param {number}  [options.height=1080]
+   * @param {number}  [options.fps=30]
+   * @param {number}  [options.videoBitrate=9000000] bps
+   * @param {number}  [options.cropX=0]
+   * @param {number}  [options.cropY=0]
+   * @param {number}  [options.cropWidth=0]
+   * @param {number}  [options.cropHeight=0]
+   * @param {boolean} [options.systemAudio=true]
+   * @param {boolean} [options.microphone=false]
+   * @param {string}  [options.micDeviceUid='']      empty = default input device
+   * @param {number}  [options.sampleRate=48000]
+   * @param {number}  [options.audioBitrate=128000]  bps
+   * @param {string}  [options.outputDir]
+   * @param {string}  [options.recordingId]
+   * @param {number}  [options.segmentTime=4]
+   * @returns {boolean}
+   */
+  startCapture: addon.startCapture.bind(addon),
+
+  setSegmentReadyCallback: addon.setSegmentReadyCallback.bind(addon),
+
+  /**
+   * Stop capturing and flush remaining data.
+   * @returns {boolean}
+   */
+  stopCapture: addon.stopCapture.bind(addon),
+
+  /**
+   * Last native capture startup/runtime error.
+   * @returns {string}
+   */
+  getLastError: addon.getLastError.bind(addon),
+
+  /**
+   * List available displays.
+   * @returns {Array<{id: number, name: string, isMain: boolean, width: number, height: number}>}
+   */
+  listDisplaySources: addon.listDisplaySources.bind(addon),
+
+  /**
+   * List available windows.
+   * @returns {Array<{id: number, name: string}>}
+   */
+  listWindowSources: addon.listWindowSources.bind(addon),
+
+  /**
+   * List native CoreAudio input devices.
+   * @returns {Array<{ uid: string, name: string, manufacturer: string }>}
+   */
+  listAudioInputDevices: addon.listAudioInputDevices.bind(addon),
+
+  /**
+   * List native camera devices.
+   * @returns {Array<{ uid: string, name: string }>}
+   */
+  listVideoInputDevices: addon.listVideoInputDevices.bind(addon),
+
+  /**
+   * Resume capturing.
+   * @returns {boolean}
+   */
+  resumeCapture: addon.resumeCapture.bind(addon),
+
+  /**
+   * Pause capturing.
+   * @returns {boolean}
+   */
+  pauseCapture: addon.pauseCapture.bind(addon),
+};

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "@0biwank/screen-capture",
-  "version": "1.0.1",
-  "description": "Native screen capture addon for Node.js with HLS muxing support",
+  "version": "2.0.1",
+  "description": "Native screen + audio capture for macOS with file-backed HLS output.",
   "main": "index.js",
-  "gypfile": true,
+  "gypfile": false,
   "scripts": {
-    "build": "node-gyp configure build",
+    "build": "node scripts/build.mjs",
+    "build:vendor": "node scripts/build-ffmpeg-vendor.mjs",
+    "build:addon": "node-gyp configure build",
     "rebuild": "node-gyp rebuild",
+    "stage:prebuild": "node scripts/stage-prebuild.mjs",
+    "verify:runtime": "node scripts/verify-runtime.cjs",
+    "verify:package": "node scripts/verify-package.mjs",
+    "verify:packlist": "node scripts/verify-packlist.mjs",
     "test": "node test.js"
   },
   "keywords": [
@@ -14,35 +20,43 @@
     "desktop-capture",
     "native-addon",
     "napi",
-    "video-encoding",
-    "hls"
+    "macos",
+    "mpegts"
   ],
   "author": "Kunal Dubey",
-  "license": "MIT",
+  "license": "GPL-2.0-or-later",
   "repository": {
     "type": "git",
-    "url": "https://github.com/xakep8/screenCaptureNAPI"
+    "url": "git+https://github.com/xakep8/screenCaptureNAPI.git"
   },
   "homepage": "https://github.com/xakep8/screenCaptureNAPI#readme",
   "bugs": {
     "url": "https://github.com/xakep8/screenCaptureNAPI/issues"
   },
-  "os": [
-    "darwin"
-  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "files": [
     "index.js",
-    "build/Release/*.node",
+    "index.d.ts",
+    "prebuilds/**/*.node",
+    "prebuilds/SHA256SUMS",
+    "binding.gyp",
+    "include/**/*",
+    "src/**/*",
+    "scripts/**/*",
+    "vendor/ffmpeg/README.md",
     "README.md",
-    "LICENSE"
+    "SOURCE.md",
+    "THIRD_PARTY_NOTICES.md",
+    "LICENSE",
+    "LICENSES/**/*"
   ],
-  "dependencies": {
-    "node-addon-api": "^8.5.0"
-  },
   "devDependencies": {
+    "node-addon-api": "^8.5.0",
     "node-gyp": "^11.4.2"
   },
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=18.0.0"
   }
 }

package/prebuilds/SHA256SUMS

@@ -0,0 +1,2 @@
+92899877a4d6a464d7742998221b410ea2a404fe113743c8243c1ed3917e82b9  darwin-arm64/native_capture.node
+e6b6659d0e18c782a1cd95964fc7c263f771500ded12b4a1bcc996af448dac59  darwin-x64/native_capture.node

package/scripts/build-ffmpeg-vendor.mjs

@@ -0,0 +1,178 @@
+import {existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, copyFileSync} from 'fs';
+import {fileURLToPath} from 'url';
+import {join, resolve} from 'path';
+import {spawnSync} from 'child_process';
+import os from 'os';
+import {createHash} from 'crypto';
+
+const FFMPEG_VERSION = '8.1';
+const FFMPEG_SHA256 = 'b072aed6871998cce9b36e7774033105ca29e33632be5b6347f3206898e0756a';
+const X264_REF = 'b35605ace3ddf7c1a5d67a2eb553f034aef41d55';
+const X264_SHA256 = '6eeb82934e69fd51e043bd8c5b0d152839638d1ce7aa4eea65a3fedcf83ff224';
+const MACOS_DEPLOYMENT_TARGET = '14.0';
+
+const packageRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const requestedArch =
+  process.env.NATIVE_CAPTURE_ARCH ||
+  process.env.TARGET_ARCH ||
+  process.env.npm_config_arch ||
+  process.arch;
+const targetArch = requestedArch === 'x86_64' ? 'x64' : requestedArch;
+const vendorRoot = resolve(packageRoot, 'vendor', 'ffmpeg');
+const vendorDir = join(vendorRoot, `darwin-${targetArch}`);
+const workRoot = join(os.tmpdir(), `freeboom-native-ffmpeg-${targetArch}`);
+const ffmpegArchive = join(workRoot, `ffmpeg-${FFMPEG_VERSION}.tar.xz`);
+const x264Archive = join(workRoot, `x264-${X264_REF}.tar.bz2`);
+const ffmpegSrc = join(workRoot, 'ffmpeg-src');
+const x264Src = join(workRoot, 'x264-src');
+const x264Install = join(workRoot, 'x264-install');
+
+function run(command, args, options = {}) {
+  console.log(`[NativeVendor] ${command} ${args.join(' ')}`);
+  const result = spawnSync(command, args, {
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+    ...options,
+    env: {
+      ...process.env,
+      MACOSX_DEPLOYMENT_TARGET: MACOS_DEPLOYMENT_TARGET,
+      ...options.env,
+    },
+  });
+
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
+  }
+}
+
+function sha256(file) {
+  return createHash('sha256').update(readFileSync(file)).digest('hex');
+}
+
+function download(url, output, expectedSha256) {
+  if (existsSync(output) && sha256(output) === expectedSha256) {
+    console.log(`[NativeVendor] Reusing ${output}`);
+    return;
+  }
+
+  rmSync(output, {force: true});
+  run('curl', ['-fL', '--retry', '3', '--retry-delay', '2', url, '-o', output]);
+  const actualSha256 = sha256(output);
+  if (actualSha256 !== expectedSha256) {
+    rmSync(output, {force: true});
+    throw new Error(
+      `[NativeVendor] SHA-256 mismatch for ${url}: expected ${expectedSha256}, received ${actualSha256}`,
+    );
+  }
+}
+
+function patchFfmpegHlsMuxer() {
+  const hlsencPath = join(ffmpegSrc, 'libavformat', 'hlsenc.c');
+  const source = readFileSync(hlsencPath, 'utf8');
+  const needle = `        if (hls->segment_type == SEGMENT_TYPE_FMP4) {
+            EXTERN const FFOutputFormat ff_mp4_muxer;
+            vs->oformat = &ff_mp4_muxer.p;
+        } else {
+            EXTERN const FFOutputFormat ff_mpegts_muxer;
+            vs->oformat = &ff_mpegts_muxer.p;
+        }`;
+  const replacement = `        if (hls->segment_type == SEGMENT_TYPE_FMP4) {
+            av_log(s, AV_LOG_ERROR, "fmp4 HLS segments are disabled in this static build\\n");
+            return AVERROR_PATCHWELCOME;
+        } else {
+            EXTERN const FFOutputFormat ff_mpegts_muxer;
+            vs->oformat = &ff_mpegts_muxer.p;
+        }`;
+
+  if (!source.includes(needle)) {
+    throw new Error('Unable to patch FFmpeg HLS muxer; expected fMP4 branch was not found');
+  }
+
+  writeFileSync(hlsencPath, source.replace(needle, replacement));
+}
+
+if (process.platform !== 'darwin') {
+  console.log('[NativeVendor] Skipping FFmpeg static vendor build on', process.platform);
+  process.exit(0);
+}
+
+if (!['arm64', 'x64'].includes(targetArch)) {
+  throw new Error(`[NativeVendor] Unsupported macOS architecture: ${targetArch}`);
+}
+
+const compilerArch = targetArch === 'x64' ? 'x86_64' : 'arm64';
+const host = targetArch === 'x64' ? 'x86_64-apple-darwin' : 'aarch64-apple-darwin';
+const architectureFlags = `-arch ${compilerArch} -mmacosx-version-min=${MACOS_DEPLOYMENT_TARGET}`;
+
+rmSync(ffmpegSrc, {recursive: true, force: true});
+rmSync(x264Src, {recursive: true, force: true});
+rmSync(x264Install, {recursive: true, force: true});
+rmSync(vendorDir, {recursive: true, force: true});
+mkdirSync(workRoot, {recursive: true});
+mkdirSync(ffmpegSrc, {recursive: true});
+mkdirSync(x264Src, {recursive: true});
+mkdirSync(x264Install, {recursive: true});
+mkdirSync(vendorDir, {recursive: true});
+
+download(
+  `https://ffmpeg.org/releases/ffmpeg-${FFMPEG_VERSION}.tar.xz`,
+  ffmpegArchive,
+  FFMPEG_SHA256,
+);
+download(
+  `https://code.videolan.org/videolan/x264/-/archive/${X264_REF}/x264-${X264_REF}.tar.bz2`,
+  x264Archive,
+  X264_SHA256,
+);
+
+run('tar', ['-xJf', ffmpegArchive, '-C', ffmpegSrc, '--strip-components=1']);
+run('tar', ['-xjf', x264Archive, '-C', x264Src, '--strip-components=1']);
+
+run(
+  './configure',
+  [
+    `--prefix=${x264Install}`,
+    '--enable-static',
+    '--disable-cli',
+    '--disable-opencl',
+    `--host=${host}`,
+    `--extra-cflags=${architectureFlags}`,
+    `--extra-ldflags=${architectureFlags}`,
+  ],
+  {cwd: x264Src},
+);
+run('make', [`-j${os.cpus().length}`, 'install'], {cwd: x264Src});
+
+patchFfmpegHlsMuxer();
+
+run(
+  './configure',
+  [
+    `--prefix=${vendorDir}`,
+    '--disable-shared',
+    '--enable-static',
+    '--disable-programs',
+    '--disable-doc',
+    '--disable-debug',
+    '--disable-autodetect',
+    '--disable-network',
+    '--enable-gpl',
+    '--enable-libx264',
+    '--target-os=darwin',
+    `--arch=${compilerArch}`,
+    '--cc=clang',
+    `--extra-cflags=-I${join(x264Install, 'include')} ${architectureFlags}`,
+    `--extra-ldflags=-L${join(x264Install, 'lib')} ${architectureFlags}`,
+    `--pkg-config-flags=--static`,
+  ],
+  {
+    cwd: ffmpegSrc,
+    env: {
+      PKG_CONFIG_PATH: join(x264Install, 'lib', 'pkgconfig'),
+    },
+  },
+);
+run('make', [`-j${os.cpus().length}`, 'install'], {cwd: ffmpegSrc});
+
+copyFileSync(join(x264Install, 'lib', 'libx264.a'), join(vendorDir, 'lib', 'libx264.a'));
+console.log(`[NativeVendor] Static FFmpeg vendor bundle ready: ${vendorDir}`);

package/scripts/build.mjs

@@ -0,0 +1,53 @@
+import {existsSync} from 'fs';
+import {fileURLToPath} from 'url';
+import {join, resolve} from 'path';
+import {spawnSync} from 'child_process';
+
+if (process.platform !== 'darwin') {
+  console.log('[NativeCapture] Skipping macOS native capture build on', process.platform);
+  process.exit(0);
+}
+
+const packageRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const requestedArch =
+  process.env.NATIVE_CAPTURE_ARCH ||
+  process.env.TARGET_ARCH ||
+  process.env.npm_config_arch ||
+  process.arch;
+const targetArch = requestedArch === 'x86_64' ? 'x64' : requestedArch;
+const vendorLibDir = join(packageRoot, 'vendor', 'ffmpeg', `darwin-${targetArch}`, 'lib');
+const requiredVendorLibs = [
+  'libavformat.a',
+  'libavcodec.a',
+  'libswscale.a',
+  'libswresample.a',
+  'libavutil.a',
+  'libx264.a',
+];
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: packageRoot,
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+    ...options,
+  });
+
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
+  }
+}
+
+const hasVendorBundle = requiredVendorLibs.every(lib => existsSync(join(vendorLibDir, lib)));
+if (!hasVendorBundle && process.env.SKIP_NATIVE_FFMPEG_VENDOR_BUILD !== '1') {
+  console.log('[NativeCapture] Static FFmpeg vendor bundle missing; building it now');
+  run('node', ['scripts/build-ffmpeg-vendor.mjs'], {
+    env: {
+      ...process.env,
+      NATIVE_CAPTURE_ARCH: targetArch,
+    },
+  });
+}
+
+console.log('[NativeCapture] Building native addon');
+run('node-gyp', ['configure', 'build', `--arch=${targetArch}`]);

package/scripts/stage-prebuild.mjs

@@ -0,0 +1,28 @@
+import {chmodSync, copyFileSync, existsSync, mkdirSync} from 'fs';
+import {join, resolve} from 'path';
+import {fileURLToPath} from 'url';
+
+const packageRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const requestedArch =
+  process.env.NATIVE_CAPTURE_ARCH ||
+  process.env.TARGET_ARCH ||
+  process.env.npm_config_arch ||
+  process.arch;
+const arch = requestedArch === 'x86_64' ? 'x64' : requestedArch;
+
+if (!['arm64', 'x64'].includes(arch)) {
+  throw new Error(`Unsupported prebuild architecture: ${arch}`);
+}
+
+const source = join(packageRoot, 'build', 'Release', 'native_capture.node');
+const destinationDir = join(packageRoot, 'prebuilds', `darwin-${arch}`);
+const destination = join(destinationDir, 'native_capture.node');
+
+if (!existsSync(source)) {
+  throw new Error(`Native addon has not been built: ${source}`);
+}
+
+mkdirSync(destinationDir, {recursive: true});
+copyFileSync(source, destination);
+chmodSync(destination, 0o755);
+console.log(`[NativeCapture] Staged darwin-${arch} prebuild at ${destination}`);

package/scripts/verify-package.mjs

@@ -0,0 +1,39 @@
+import {createHash} from 'crypto';
+import {readdirSync, readFileSync, statSync} from 'fs';
+import {join, resolve} from 'path';
+import {spawnSync} from 'child_process';
+import {fileURLToPath} from 'url';
+
+const packageRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const expected = [
+  {arch: 'arm64', machine: 'arm64'},
+  {arch: 'x64', machine: 'x86_64'},
+];
+const checksumLines = [];
+
+for (const {arch, machine} of expected) {
+  const relativePath = `darwin-${arch}/native_capture.node`;
+  const filePath = join(packageRoot, 'prebuilds', relativePath);
+  const size = statSync(filePath).size;
+  if (size < 1024 * 1024 || size > 64 * 1024 * 1024) {
+    throw new Error(`Unexpected prebuild size for ${relativePath}: ${size}`);
+  }
+
+  const inspection = spawnSync('file', [filePath], {encoding: 'utf8'});
+  if (inspection.status !== 0 || !inspection.stdout.includes(machine)) {
+    throw new Error(`Invalid architecture for ${relativePath}: ${inspection.stdout}`);
+  }
+
+  const checksum = createHash('sha256').update(readFileSync(filePath)).digest('hex');
+  checksumLines.push(`${checksum}  ${relativePath}`);
+}
+
+const directories = readdirSync(join(packageRoot, 'prebuilds'), {withFileTypes: true})
+  .filter(entry => entry.isDirectory())
+  .map(entry => entry.name)
+  .sort();
+if (directories.join(',') !== 'darwin-arm64,darwin-x64') {
+  throw new Error(`Unexpected prebuild directories: ${directories.join(', ')}`);
+}
+
+process.stdout.write(`${checksumLines.join('\n')}\n`);

package/scripts/verify-packlist.mjs

@@ -0,0 +1,40 @@
+import {readFileSync} from 'fs';
+
+const reportPath = process.argv[2];
+if (!reportPath) throw new Error('Usage: node scripts/verify-packlist.mjs <npm-pack-report.json>');
+
+const [report] = JSON.parse(readFileSync(reportPath, 'utf8'));
+if (!report?.files) throw new Error('npm pack report does not contain a file list');
+
+const paths = report.files.map(file => file.path);
+const required = [
+  'index.js',
+  'index.d.ts',
+  'LICENSE',
+  'SOURCE.md',
+  'THIRD_PARTY_NOTICES.md',
+  'prebuilds/SHA256SUMS',
+  'prebuilds/darwin-arm64/native_capture.node',
+  'prebuilds/darwin-x64/native_capture.node',
+];
+
+for (const path of required) {
+  if (!paths.includes(path)) throw new Error(`Required package file is missing: ${path}`);
+}
+
+const forbidden = paths.filter(
+  path =>
+    path.startsWith('build/') ||
+    path.startsWith('node_modules/') ||
+    path.includes('/vendor/ffmpeg/darwin-') ||
+    /\.(a|o|dylib)$/.test(path),
+);
+if (forbidden.length > 0) {
+  throw new Error(`Forbidden package files found:\n${forbidden.join('\n')}`);
+}
+
+if (report.unpackedSize > 64 * 1024 * 1024) {
+  throw new Error(`Unpacked package is unexpectedly large: ${report.unpackedSize} bytes`);
+}
+
+console.log(`Verified npm pack contents: ${paths.length} files, ${report.unpackedSize} bytes`);

package/scripts/verify-runtime.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+const capture = require('../index.js');
+
+const expectedFunctions = [
+  'startCapture',
+  'setSegmentReadyCallback',
+  'stopCapture',
+  'getLastError',
+  'listDisplaySources',
+  'listWindowSources',
+  'listAudioInputDevices',
+  'listVideoInputDevices',
+  'pauseCapture',
+  'resumeCapture',
+];
+
+for (const name of expectedFunctions) {
+  if (typeof capture[name] !== 'function') {
+    throw new Error(`Missing native export: ${name}`);
+  }
+}
+
+if (typeof capture.getLastError() !== 'string') {
+  throw new Error('getLastError() must return a string');
+}
+
+console.log(`Verified ${expectedFunctions.length} native exports on darwin-${process.arch}`);