@expo-harmony/expo-modules-autolinking 55.0.25-harmony.2 → 55.0.25-harmony.3

package/README.md

@@ -4,6 +4,12 @@
 
 为 HarmonyOS 上的 React Native 应用提供 Expo Modules 和 RNOH 原生模块自动链接能力，与官方同版本的 expo-modules-autolinking 配套使用。
 
+## 安装
+
+```bash
+npm install @expo-harmony/expo-modules-autolinking @react-native-oh/react-native-harmony-cli@^0.84.1
+```
+
 ## Author
 
 **expo-harmony** © [Baoshuo](https://github.com/renbaoshuo), Released under the MIT License.<br>

package/build/src/harmony/materialize.js

@@ -32,12 +32,17 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.materializeLocalSourcesAsync = materializeLocalSourcesAsync;
 exports.materializeModuleArtifactAsync = materializeModuleArtifactAsync;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const node_child_process_1 = require("node:child_process");
+const cross_spawn_1 = __importDefault(require("cross-spawn"));
+const toolCommand_1 = require("../utilities/toolCommand");
+const terminateProcess_1 = require("../utilities/terminateProcess");
 const errors_1 = require("../errors");
 const values_1 = require("../utilities/values");
 const publish_1 = require("./transaction/publish");
@@ -45,13 +50,6 @@ const DefaultBuildTimeoutMs = 10 * 60_000;
 const DefaultOutputLimit = 64 * 1024;
 const HarmonyProjectPath = 'harmony';
 const HarmonyBuildOutputPath = 'library/build/default/outputs/default/library.har';
-function materializationError(code, message, options, details) {
-    throw new errors_1.HarmonyAutolinkingError(code, message, {
-        packageName: options.packageName,
-        stage: 'artifact-materialize',
-        details,
-    });
-}
 function createFixedHvigorBuildDescriptor(projectPath, buildType) {
     return {
         executable: 'hvigorw',
@@ -101,7 +99,11 @@ async function validateBundledArtifactsAsync(options) {
     for (const relative of harPaths) {
         const harPath = path.resolve(options.packageRoot, relative);
         if (!await isNonEmptyRegularHarAsync(harPath, options.packageRoot, options.packageName)) {
-            materializationError('SOURCE_ARTIFACT_NOT_PUBLISHED', `${options.packageName} has a missing or empty Harmony HAR.`, options, { harPath: relative });
+            throw new errors_1.HarmonyAutolinkingError('SOURCE_ARTIFACT_NOT_PUBLISHED', `${options.packageName} has a missing or empty Harmony HAR.`, {
+                packageName: options.packageName,
+                stage: 'artifact-materialize',
+                details: { harPath: relative },
+            });
         }
     }
     return { kind: 'bundled', harPaths };
@@ -153,35 +155,28 @@ function fixedLocalSourceBuildSteps(build) {
     ];
 }
 function resolveFixedBuildStep(step, env) {
-    if (step.id === 'ohpm-install') {
-        return env.HARMONY_OHPM ? { ...step, executable: env.HARMONY_OHPM } : step;
-    }
-    const configured = env.HARMONY_HVIGORW;
-    if (configured) {
-        return /\.(?:c|m)?js$/iu.test(configured)
-            ? { ...step, executable: env.HARMONY_NODE || process.execPath, args: [configured, ...step.args] }
-            : { ...step, executable: configured };
-    }
-    return step;
+    const invocation = (0, toolCommand_1.resolveHarmonyCommand)(step.executable, step.args, env);
+    return { ...step, executable: invocation.command, args: invocation.args };
 }
 async function runFixedBuildStepAsync(step, packageName, options) {
     const timeoutMs = options.timeoutMs ?? DefaultBuildTimeoutMs;
     const outputLimit = options.outputLimit ?? DefaultOutputLimit;
     const stage = `artifact-materialize:${step.id}`;
-    const env = { ...process.env, ...options.env };
-    const resolvedStep = resolveFixedBuildStep(step, env);
     if (!Number.isInteger(timeoutMs) || timeoutMs <= 0
         || !Number.isInteger(outputLimit) || outputLimit <= 0) {
         throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'timeoutMs and outputLimit must be positive integers.', { packageName, stage });
     }
+    const env = { ...process.env, ...options.env };
+    const command = resolveFixedBuildStep(step, env);
     const result = await new Promise((resolve, reject) => {
         let output = '';
         let timedOut = false;
         let settled = false;
-        let killTimer;
+        let stopping;
+        let escalation;
         let child;
         try {
-            child = (0, node_child_process_1.spawn)(resolvedStep.executable, [...resolvedStep.args], {
+            child = (0, cross_spawn_1.default)(command.executable, [...command.args], {
                 cwd: step.cwd,
                 env,
                 shell: false,
@@ -198,30 +193,49 @@ async function runFixedBuildStepAsync(step, packageName, options) {
         child.stderr.on('data', (chunk) => {
             output = appendBounded(output, chunk, outputLimit);
         });
+        const finish = async (code, signal, error) => {
+            try {
+                await stopping;
+            }
+            catch (cause) {
+                error = cause;
+            }
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            if (escalation)
+                clearTimeout(escalation);
+            if (error)
+                reject(error);
+            else
+                resolve({ code, signal, output, timedOut });
+        };
         const timeout = setTimeout(() => {
             timedOut = true;
-            child.kill('SIGTERM');
-            killTimer = setTimeout(() => child.kill('SIGKILL'), 1_000);
-            killTimer.unref?.();
+            stopping = Promise.resolve().then(() => (0, terminateProcess_1.terminateProcess)(child, 'SIGTERM'));
+            if (process.platform === 'win32') {
+                void finish(null, 'SIGTERM');
+            }
+            else {
+                stopping.catch((error) => {
+                    void finish(null, null, error);
+                });
+                escalation = setTimeout(() => {
+                    stopping = (0, terminateProcess_1.terminateProcess)(child, 'SIGKILL');
+                    stopping.catch((error) => {
+                        void finish(null, null, error);
+                    });
+                }, 1_000);
+                escalation.unref?.();
+            }
         }, timeoutMs);
         timeout.unref?.();
         child.on('error', (cause) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeout);
-            if (killTimer)
-                clearTimeout(killTimer);
-            reject(cause);
+            void finish(null, null, cause);
         });
         child.on('close', (code, signal) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeout);
-            if (killTimer)
-                clearTimeout(killTimer);
-            resolve({ code, signal, output, timedOut });
+            void finish(code, signal);
         });
     }).catch((cause) => {
         throw new errors_1.HarmonyAutolinkingError('SOURCE_BUILD_FAILED', `Unable to execute the fixed ${step.label} for local Harmony source at ${step.cwd}.`, { cause, packageName, stage });
@@ -252,8 +266,8 @@ async function materializeLocalSourceAsync(options) {
     for (const step of fixedLocalSourceBuildSteps(artifact.build)) {
         await runFixedBuildStepAsync(step, module.packageName, options);
     }
-    const outputReady = await isNonEmptyRegularHarAsync(artifact.outputPath, artifact.build.cwd, module.packageName);
-    if (!outputReady) {
+    const ready = await isNonEmptyRegularHarAsync(artifact.outputPath, artifact.build.cwd, module.packageName);
+    if (!ready) {
         throw new errors_1.HarmonyAutolinkingError('SOURCE_BUILD_FAILED', `Hvigor did not produce a non-empty HAR at ${(0, values_1.normalizeSlashes)(path.relative(packageRoot, artifact.outputPath))}.`, { packageName: module.packageName, stage: 'artifact-materialize' });
     }
     await (0, publish_1.publishArtifactsAsync)({

package/build/src/harmony/rnoh/cli.d.ts

@@ -1,2 +1,5 @@
-declare function resolveCliAsync(cliOptions: any): Promise<string>;
+declare function resolveCliAsync(options: any): Promise<{
+    executable: string;
+    args: string[];
+}>;
 export { resolveCliAsync, };

package/build/src/harmony/rnoh/cli.js

@@ -9,47 +9,70 @@ const node_path_1 = __importDefault(require("node:path"));
 const constants_1 = require("../../config/constants");
 const errors_1 = require("../../errors");
 const values_1 = require("../../utilities/values");
-function findPackageJson(projectRoot, packageName) {
+function findPackageJson(root, packageName) {
     try {
-        return (0, values_1.resolvePackageFromProject)(projectRoot, `${packageName}/package.json`);
+        return (0, values_1.resolvePackageFromProject)(root, `${packageName}/package.json`);
     }
     catch (cause) {
-        throw new errors_1.HarmonyAutolinkingError('RNOH_CLI_NOT_FOUND', `${constants_1.RnohCliPackage} is not installed.`, {
+        throw new errors_1.HarmonyAutolinkingError('RNOH_CLI_NOT_FOUND', `${packageName} is not installed.`, {
             cause,
             stage: 'rnoh-preflight',
         });
     }
 }
-async function resolveCliAsync(cliOptions) {
-    const projectRoot = await (0, values_1.realpathExistingAsync)(cliOptions.projectRoot, {
+async function resolveCliAsync(options) {
+    const root = await (0, values_1.realpathExistingAsync)(options.projectRoot, {
         type: 'directory',
         field: 'projectRoot',
         stage: 'rnoh-preflight',
     });
-    const raw = cliOptions.rnohCliPackageJsonPath
-        || findPackageJson(projectRoot, constants_1.RnohCliPackage);
-    const pkg = await (0, values_1.realpathExistingAsync)(raw, {
+    const raw = options.rnohCliPackageJsonPath
+        || findPackageJson(root, constants_1.RnohCliPackage);
+    const manifest = await (0, values_1.realpathExistingAsync)(raw, {
         type: 'file',
         code: 'RNOH_CLI_NOT_FOUND',
         field: 'RNOH CLI package.json',
         stage: 'rnoh-preflight',
     });
-    const packageJson = await (0, values_1.readJsonAsync)(pkg, 'RNOH_CLI_NOT_FOUND', 'rnoh-preflight');
-    if (packageJson.name !== constants_1.RnohCliPackage) {
-        throw new errors_1.HarmonyAutolinkingError('RNOH_CLI_NOT_FOUND', `Expected ${constants_1.RnohCliPackage}, found ${String(packageJson.name)}.`, { stage: 'rnoh-preflight' });
+    const plugin = await (0, values_1.readJsonAsync)(manifest, 'RNOH_CLI_NOT_FOUND', 'rnoh-preflight');
+    if (plugin.name !== constants_1.RnohCliPackage) {
+        throw new errors_1.HarmonyAutolinkingError('RNOH_CLI_NOT_FOUND', `Expected ${constants_1.RnohCliPackage}, found ${String(plugin.name)}.`, { stage: 'rnoh-preflight' });
     }
-    const pluginRoot = node_path_1.default.dirname(pkg);
-    const pluginConfig = node_path_1.default.join(pluginRoot, 'react-native.config.js');
-    if (!node_fs_1.default.existsSync(pluginConfig)) {
+    const config = node_path_1.default.join(node_path_1.default.dirname(manifest), 'react-native.config.js');
+    if (!node_fs_1.default.existsSync(config)) {
         throw new errors_1.HarmonyAutolinkingError('RNOH_CLI_NOT_FOUND', `${constants_1.RnohCliPackage} does not expose its public React Native CLI plugin config.`, { stage: 'rnoh-preflight' });
     }
-    const exec = cliOptions.reactNativeExecutable
-        || node_path_1.default.join(cliOptions.nodeModulesPath || node_path_1.default.join(projectRoot, 'node_modules'), '.bin', 'react-native');
-    const executable = await (0, values_1.realpathExistingAsync)(exec, {
+    if (options.reactNativeExecutable) {
+        const executable = await (0, values_1.realpathExistingAsync)(options.reactNativeExecutable, {
+            type: 'file',
+            code: 'RNOH_CLI_NOT_FOUND',
+            field: 'project-local react-native executable',
+            stage: 'rnoh-preflight',
+        });
+        return { executable, args: [] };
+    }
+    // Resolve the package itself, not a package-manager-generated .bin shell shim.
+    // The real manifest path also handles symlinked packages (for example pnpm).
+    const file = await (0, values_1.realpathExistingAsync)(options.nodeModulesPath
+        ? node_path_1.default.join(options.nodeModulesPath, 'react-native', 'package.json')
+        : findPackageJson(root, 'react-native'), {
+        type: 'file',
+        code: 'RNOH_CLI_NOT_FOUND',
+        field: 'project-local react-native package.json',
+        stage: 'rnoh-preflight',
+    });
+    const pkg = await (0, values_1.readJsonAsync)(file, 'RNOH_CLI_NOT_FOUND', 'rnoh-preflight');
+    const bin = typeof pkg.bin === 'string'
+        ? pkg.bin
+        : pkg.bin?.['react-native'];
+    if (typeof bin !== 'string' || !bin.trim()) {
+        throw new errors_1.HarmonyAutolinkingError('RNOH_CLI_NOT_FOUND', 'The project-local react-native package does not declare a react-native bin entry.', { stage: 'rnoh-preflight' });
+    }
+    const entry = await (0, values_1.realpathExistingAsync)(node_path_1.default.resolve(node_path_1.default.dirname(file), bin), {
         type: 'file',
         code: 'RNOH_CLI_NOT_FOUND',
         field: 'project-local react-native executable',
         stage: 'rnoh-preflight',
     });
-    return executable;
+    return { executable: process.execPath, args: [entry] };
 }

package/build/src/harmony/rnoh/link.js

@@ -4,13 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.linkRnohAsync = linkRnohAsync;
-const node_child_process_1 = __importDefault(require("node:child_process"));
+const cross_spawn_1 = __importDefault(require("cross-spawn"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const constants_1 = require("../../config/constants");
 const errors_1 = require("../../errors");
 const options_1 = require("../../config/options");
 const values_1 = require("../../utilities/values");
+const terminateProcess_1 = require("../../utilities/terminateProcess");
 const generate_1 = require("../manifest/generate");
 const canonicalize_1 = require("../persistence/canonicalize");
 const packageMetadata_1 = require("./packageMetadata");
@@ -37,13 +38,14 @@ function spawnBoundedAsync(executable, argv, options = {}) {
         let stdoutTruncated = false;
         let stderrTruncated = false;
         let timedOut = false;
-        let killTimer;
+        let escalation;
         // eslint-disable-next-line prefer-const
         let timeout;
         let settled = false;
+        let stopping;
         let child;
         try {
-            child = node_child_process_1.default.spawn(executable, argv, {
+            child = (0, cross_spawn_1.default)(executable, argv, {
                 cwd: options.cwd,
                 env: options.env || process.env,
                 shell: false,
@@ -64,36 +66,56 @@ function spawnBoundedAsync(executable, argv, options = {}) {
                 stderrTruncated = true;
             stderr = appendBounded(stderr, chunk, outputLimit);
         });
-        child.on('error', (error) => {
+        const finish = async (code, signal, error) => {
+            try {
+                await stopping;
+            }
+            catch (cause) {
+                error = cause;
+            }
             if (settled)
                 return;
             settled = true;
             clearTimeout(timeout);
-            clearTimeout(killTimer);
-            reject(error);
+            clearTimeout(escalation);
+            if (error)
+                reject(error);
+            else
+                resolve({
+                    code,
+                    signal,
+                    timedOut,
+                    stdout: stdout.toString('utf8'),
+                    stderr: stderr.toString('utf8'),
+                    stdoutTruncated,
+                    stderrTruncated,
+                });
+        };
+        child.on('error', (error) => {
+            void finish(null, null, error);
         });
         timeout = setTimeout(() => {
             timedOut = true;
-            child.kill('SIGTERM');
-            killTimer = setTimeout(() => child.kill('SIGKILL'), 1_000);
-            killTimer.unref?.();
+            stopping = Promise.resolve().then(() => (0, terminateProcess_1.terminateProcess)(child, 'SIGTERM'));
+            if (process.platform === 'win32') {
+                void finish(null, 'SIGTERM');
+            }
+            else {
+                stopping.catch((error) => {
+                    void finish(null, null, error);
+                });
+                escalation = setTimeout(() => {
+                    stopping = (0, terminateProcess_1.terminateProcess)(child, 'SIGKILL');
+                    stopping.catch((error) => {
+                        void finish(null, null, error);
+                    });
+                }, 1_000);
+                escalation.unref?.();
+            }
         }, timeoutMs);
         timeout.unref?.();
         child.on('close', (code, signal) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeout);
-            clearTimeout(killTimer);
-            resolve({
-                code,
-                signal,
-                timedOut,
-                stdout: stdout.toString('utf8'),
-                stderr: stderr.toString('utf8'),
-                stdoutTruncated,
-                stderrTruncated,
-            });
+            void finish(code, signal);
         });
     });
 }
@@ -335,7 +357,7 @@ function patchOhpmManifest(artifact, descriptors, buildType, harmonyProjectPath)
     }).source;
 }
 async function linkRnohAsync(linkOptions) {
-    const executable = await (0, cli_1.resolveCliAsync)({
+    const command = await (0, cli_1.resolveCliAsync)({
         ...linkOptions,
         nodeModulesPath: linkOptions.commandNodeModulesPath || linkOptions.nodeModulesPath,
     });
@@ -347,12 +369,12 @@ async function linkRnohAsync(linkOptions) {
     };
     let result;
     try {
-        result = await spawnBoundedAsync(executable, buildLinkCommandArgs({
-            harmonyProjectPath: linkOptions.stageHarmonyProjectPath,
-            nodeModulesPath: linkOptions.nodeModulesPath,
-            include: linkOptions.include,
-            exclude: linkOptions.exclude,
-        }), spawn);
+        result = await spawnBoundedAsync(command.executable, [...command.args, ...buildLinkCommandArgs({
+                harmonyProjectPath: linkOptions.stageHarmonyProjectPath,
+                nodeModulesPath: linkOptions.nodeModulesPath,
+                include: linkOptions.include,
+                exclude: linkOptions.exclude,
+            })], spawn);
     }
     catch (cause) {
         throw new errors_1.HarmonyAutolinkingError('RNOH_LINK_FAILED', 'Unable to execute React Native link-harmony.', { cause, stage: 'rnoh-link' });

package/build/src/utilities/terminateProcess.d.ts

@@ -0,0 +1,3 @@
+import { type ChildProcess } from 'node:child_process';
+/** Stop a Windows command and its descendants before callers restore build inputs. */
+export declare function terminateProcess(child: ChildProcess, signal: NodeJS.Signals): Promise<void>;

package/build/src/utilities/terminateProcess.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.terminateProcess = terminateProcess;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+/** Stop a Windows command and its descendants before callers restore build inputs. */
+async function terminateProcess(child, signal) {
+    if (!child.pid)
+        return;
+    if (process.platform !== 'win32') {
+        child.kill(signal);
+        return;
+    }
+    try {
+        await new Promise((resolve, reject) => {
+            const command = node_path_1.default.win32.join(process.env.SystemRoot || process.env.SYSTEMROOT || 'C:\\Windows', 'System32', 'taskkill.exe');
+            const killer = (0, node_child_process_1.spawn)(command, ['/pid', String(child.pid), '/T', '/F'], {
+                shell: false,
+                windowsHide: true,
+                stdio: 'ignore',
+            });
+            const timer = setTimeout(() => {
+                try {
+                    killer.kill('SIGKILL');
+                }
+                catch { /* Still report the bounded termination failure. */ }
+                killer.unref();
+                reject(new Error(`Timed out terminating process tree ${child.pid}.`));
+            }, 5_000);
+            killer.once('error', (error) => {
+                clearTimeout(timer);
+                reject(error);
+            });
+            killer.once('exit', (code) => {
+                clearTimeout(timer);
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`taskkill failed for process tree ${child.pid} (exit ${code}).`));
+            });
+        });
+    }
+    catch (cause) {
+        // A failed taskkill must be reported, but must not keep the caller hung forever.
+        child.unref();
+        throw new Error(`Unable to terminate process tree ${child.pid}.`, { cause });
+    }
+    finally {
+        // Descendants can retain pipe handles after the immediate child has exited.
+        // taskkill has finished (or failed explicitly); do not wait forever for EOF.
+        child.stdin?.destroy();
+        child.stdout?.destroy();
+        child.stderr?.destroy();
+    }
+}

package/build/src/utilities/toolCommand.d.ts

@@ -0,0 +1,6 @@
+/** Keep tool overrides consistent across CLI, workspace and local HAR builds. */
+export declare function resolveHarmonyCommand(command: string, args: readonly string[], env?: NodeJS.ProcessEnv): {
+    command: string;
+    args: string[];
+};
+export { terminateProcess } from './terminateProcess';

package/build/src/utilities/toolCommand.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.terminateProcess = void 0;
+exports.resolveHarmonyCommand = resolveHarmonyCommand;
+/** Keep tool overrides consistent across CLI, workspace and local HAR builds. */
+function resolveHarmonyCommand(command, args, env = process.env) {
+    const configured = command === 'ohpm'
+        ? env.HARMONY_OHPM
+        : command === 'hvigorw' ? env.HARMONY_HVIGORW : undefined;
+    if (!configured)
+        return { command, args: [...args] };
+    const node = command === 'ohpm' ? env.HARMONY_OHPM_NODE : env.HARMONY_HVIGOR_NODE;
+    return /\.(?:c|m)?js$/iu.test(configured)
+        ? { command: node || env.HARMONY_NODE || process.execPath, args: [configured, ...args] }
+        : { command: configured, args: [...args] };
+}
+var terminateProcess_1 = require("./terminateProcess");
+Object.defineProperty(exports, "terminateProcess", { enumerable: true, get: function () { return terminateProcess_1.terminateProcess; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo-harmony/expo-modules-autolinking",
-  "version": "55.0.25-harmony.2",
+  "version": "55.0.25-harmony.3",
   "description": "HarmonyOS port of expo-modules-autolinking",
   "keywords": [
     "react-native",
@@ -20,7 +20,7 @@
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "scripts": {
-    "build": "rm -rf build && tsc -p tsconfig.json && chmod +x build/bin/expo-harmony-autolinking.js",
+    "build": "node ./scripts/build.mjs",
     "prepare": "yarn build",
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
@@ -30,6 +30,10 @@
       "require": "./build/index.js",
       "default": "./build/index.js"
     },
+    "./tool-command": {
+      "types": "./build/src/utilities/toolCommand.d.ts",
+      "default": "./build/src/utilities/toolCommand.js"
+    },
     "./harmony-module.schema.json": {
       "default": "./harmony-module.schema.json"
     }
@@ -40,6 +44,7 @@
   "dependencies": {
     "case": "1.6.3",
     "commander": "7.2.0",
+    "cross-spawn": "^7.0.6",
     "expo-modules-autolinking": "55.0.25",
     "json5": "2.2.3"
   },
@@ -52,11 +57,6 @@
   "peerDependencies": {
     "@react-native-oh/react-native-harmony-cli": "^0.84.1"
   },
-  "peerDependenciesMeta": {
-    "@react-native-oh/react-native-harmony-cli": {
-      "optional": true
-    }
-  },
   "engines": {
     "node": ">=20"
   },

package/scripts/build.mjs

@@ -0,0 +1,27 @@
+import { spawnSync } from 'node:child_process';
+import { chmodSync, rmSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const root = fileURLToPath(new URL('../', import.meta.url));
+
+rmSync(path.join(root, 'build'), { recursive: true, force: true });
+
+const result = spawnSync(process.execPath, [require.resolve('typescript/bin/tsc'), '-p', 'tsconfig.json'], {
+  cwd: root,
+  stdio: 'inherit',
+  shell: false,
+});
+
+if (result.error) {
+  throw new Error('Unable to start the TypeScript compiler.', { cause: result.error });
+}
+
+if (result.status !== 0) {
+  process.exitCode = result.status ?? 1;
+} else if (process.platform !== 'win32') {
+  const file = path.join(root, 'build/bin/expo-harmony-autolinking.js');
+  chmodSync(file, statSync(file).mode | 0o111);
+}

package/src/harmony/materialize.ts

@@ -1,6 +1,8 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { spawn } from 'node:child_process';
+import spawn from 'cross-spawn';
+import { resolveHarmonyCommand } from '../utilities/toolCommand';
+import { terminateProcess } from '../utilities/terminateProcess';
 
 import { HarmonyAutolinkingError } from '../errors';
 import type {
@@ -38,19 +40,6 @@ interface MaterializeModuleArtifactOptions {
   readonly rnoh: RnohMetadata;
 }
 
-function materializationError(
-  code: string,
-  message: string,
-  options: MaterializeModuleArtifactOptions,
-  details?: unknown
-): never {
-  throw new HarmonyAutolinkingError(code, message, {
-    packageName: options.packageName,
-    stage: 'artifact-materialize',
-    details,
-  });
-}
-
 function createFixedHvigorBuildDescriptor(
   projectPath: string,
   buildType: BuildType
@@ -114,6 +103,7 @@ async function isNonEmptyRegularHarAsync(
       { packageName, stage: 'artifact-materialize' }
     );
   }
+
   return stat.size > 0;
 }
 
@@ -124,17 +114,22 @@ async function validateBundledArtifactsAsync(
     ...options.rnoh.harPaths,
     ...(options.arkTs ? [options.arkTs.harPath] : []),
   ])].sort(compareText);
+
   for (const relative of harPaths) {
     const harPath = path.resolve(options.packageRoot, relative);
     if (!await isNonEmptyRegularHarAsync(harPath, options.packageRoot, options.packageName)) {
-      materializationError(
+      throw new HarmonyAutolinkingError(
         'SOURCE_ARTIFACT_NOT_PUBLISHED',
         `${options.packageName} has a missing or empty Harmony HAR.`,
-        options,
-        { harPath: relative }
+        {
+          packageName: options.packageName,
+          stage: 'artifact-materialize',
+          details: { harPath: relative },
+        }
       );
     }
   }
+
   return { kind: 'bundled', harPaths };
 }
 
@@ -162,6 +157,7 @@ async function materializeModuleArtifactAsync(
     packageName: options.packageName,
     mustExist: false,
   });
+
   return {
     kind: 'local-source',
     outputPath,
@@ -193,18 +189,8 @@ function fixedLocalSourceBuildSteps(build: FixedHvigorBuildDescriptor): Readonly
 }
 
 function resolveFixedBuildStep(step: FixedBuildStep, env: NodeJS.ProcessEnv): FixedBuildStep {
-  if (step.id === 'ohpm-install') {
-    return env.HARMONY_OHPM ? { ...step, executable: env.HARMONY_OHPM } : step;
-  }
-
-  const configured = env.HARMONY_HVIGORW;
-  if (configured) {
-    return /\.(?:c|m)?js$/iu.test(configured)
-      ? { ...step, executable: env.HARMONY_NODE || process.execPath, args: [configured, ...step.args] }
-      : { ...step, executable: configured };
-  }
-
-  return step;
+  const invocation = resolveHarmonyCommand(step.executable, step.args, env);
+  return { ...step, executable: invocation.command, args: invocation.args };
 }
 
 async function runFixedBuildStepAsync(
@@ -215,8 +201,6 @@ async function runFixedBuildStepAsync(
   const timeoutMs = options.timeoutMs ?? DefaultBuildTimeoutMs;
   const outputLimit = options.outputLimit ?? DefaultOutputLimit;
   const stage = `artifact-materialize:${step.id}`;
-  const env = { ...process.env, ...options.env };
-  const resolvedStep = resolveFixedBuildStep(step, env);
   if (!Number.isInteger(timeoutMs) || timeoutMs <= 0
     || !Number.isInteger(outputLimit) || outputLimit <= 0) {
     throw new HarmonyAutolinkingError(
@@ -226,6 +210,9 @@ async function runFixedBuildStepAsync(
     );
   }
 
+  const env = { ...process.env, ...options.env };
+  const command = resolveFixedBuildStep(step, env);
+
   const result = await new Promise<{
     code: number | null;
     signal: NodeJS.Signals | null;
@@ -235,10 +222,12 @@ async function runFixedBuildStepAsync(
     let output = '';
     let timedOut = false;
     let settled = false;
-    let killTimer: NodeJS.Timeout | undefined;
+    let stopping: Promise<void> | undefined;
+    let escalation: NodeJS.Timeout | undefined;
     let child;
+
     try {
-      child = spawn(resolvedStep.executable, [...resolvedStep.args], {
+      child = spawn(command.executable, [...command.args], {
         cwd: step.cwd,
         env,
         shell: false,
@@ -248,32 +237,55 @@ async function runFixedBuildStepAsync(
       reject(cause);
       return;
     }
+
     child.stdout.on('data', (chunk: Buffer) => {
       output = appendBounded(output, chunk, outputLimit);
     });
     child.stderr.on('data', (chunk: Buffer) => {
       output = appendBounded(output, chunk, outputLimit);
     });
+
+    const finish = async (code, signal, error?) => {
+      try {
+        await stopping;
+      } catch (cause) {
+        error = cause;
+      }
+
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      if (escalation) clearTimeout(escalation);
+
+      if (error) reject(error);
+      else resolve({ code, signal, output, timedOut });
+    };
+
     const timeout = setTimeout(() => {
       timedOut = true;
-      child.kill('SIGTERM');
-      killTimer = setTimeout(() => child.kill('SIGKILL'), 1_000);
-      killTimer.unref?.();
+      stopping = Promise.resolve().then(() => terminateProcess(child, 'SIGTERM'));
+      if (process.platform === 'win32') {
+        void finish(null, 'SIGTERM');
+      } else {
+        stopping.catch((error) => {
+          void finish(null, null, error);
+        });
+        escalation = setTimeout(() => {
+          stopping = terminateProcess(child, 'SIGKILL');
+          stopping.catch((error) => {
+            void finish(null, null, error);
+          });
+        }, 1_000);
+        escalation.unref?.();
+      }
     }, timeoutMs);
     timeout.unref?.();
+
     child.on('error', (cause) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timeout);
-      if (killTimer) clearTimeout(killTimer);
-      reject(cause);
+      void finish(null, null, cause);
     });
     child.on('close', (code, signal) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timeout);
-      if (killTimer) clearTimeout(killTimer);
-      resolve({ code, signal, output, timedOut });
+      void finish(code, signal);
     });
   }).catch((cause) => {
     throw new HarmonyAutolinkingError(
@@ -307,6 +319,7 @@ async function materializeLocalSourceAsync(
       { packageName: module.packageName, stage: 'artifact-materialize' }
     );
   }
+
   const artifact = module.artifact;
   const projectRoot = await fs.promises.realpath(options.projectRoot);
   const packageRoot = await fs.promises.realpath(module.packageRoot);
@@ -324,6 +337,7 @@ async function materializeLocalSourceAsync(
       { packageName: module.packageName, stage: 'artifact-materialize' }
     );
   }
+
   const harPath = await resolveInsideAsync(
     packageRoot,
     module.arkTs.harPath,
@@ -334,12 +348,13 @@ async function materializeLocalSourceAsync(
   for (const step of fixedLocalSourceBuildSteps(artifact.build)) {
     await runFixedBuildStepAsync(step, module.packageName, options);
   }
-  const outputReady = await isNonEmptyRegularHarAsync(
+
+  const ready = await isNonEmptyRegularHarAsync(
     artifact.outputPath,
     artifact.build.cwd,
     module.packageName
   );
-  if (!outputReady) {
+  if (!ready) {
     throw new HarmonyAutolinkingError(
       'SOURCE_BUILD_FAILED',
       `Hvigor did not produce a non-empty HAR at ${normalizeSlashes(path.relative(packageRoot, artifact.outputPath))}.`,
@@ -359,6 +374,7 @@ async function materializeLocalSourceAsync(
       { packageName: module.packageName, stage: 'artifact-materialize' }
     );
   }
+
   return {
     packageName: module.packageName,
     harPath,

package/src/harmony/rnoh/cli.ts

@@ -5,53 +5,83 @@ import { RnohCliPackage } from '../../config/constants';
 import { HarmonyAutolinkingError } from '../../errors';
 import { readJsonAsync, realpathExistingAsync, resolvePackageFromProject } from '../../utilities/values';
 
-function findPackageJson(projectRoot, packageName) {
+function findPackageJson(root, packageName) {
   try {
-    return resolvePackageFromProject(projectRoot, `${packageName}/package.json`);
+    return resolvePackageFromProject(root, `${packageName}/package.json`);
   } catch (cause) {
-    throw new HarmonyAutolinkingError('RNOH_CLI_NOT_FOUND', `${RnohCliPackage} is not installed.`, {
+    throw new HarmonyAutolinkingError('RNOH_CLI_NOT_FOUND', `${packageName} is not installed.`, {
       cause,
       stage: 'rnoh-preflight',
     });
   }
 }
 
-async function resolveCliAsync(cliOptions) {
-  const projectRoot = await realpathExistingAsync(cliOptions.projectRoot, {
+async function resolveCliAsync(options) {
+  const root = await realpathExistingAsync(options.projectRoot, {
     type: 'directory',
     field: 'projectRoot',
     stage: 'rnoh-preflight',
   });
 
-  const raw = cliOptions.rnohCliPackageJsonPath
-    || findPackageJson(projectRoot, RnohCliPackage);
-  const pkg = await realpathExistingAsync(raw, {
+  const raw = options.rnohCliPackageJsonPath
+    || findPackageJson(root, RnohCliPackage);
+  const manifest = await realpathExistingAsync(raw, {
     type: 'file',
     code: 'RNOH_CLI_NOT_FOUND',
     field: 'RNOH CLI package.json',
     stage: 'rnoh-preflight',
   });
 
-  const packageJson = await readJsonAsync(pkg, 'RNOH_CLI_NOT_FOUND', 'rnoh-preflight');
-  if (packageJson.name !== RnohCliPackage) {
-    throw new HarmonyAutolinkingError('RNOH_CLI_NOT_FOUND', `Expected ${RnohCliPackage}, found ${String(packageJson.name)}.`, { stage: 'rnoh-preflight' });
+  const plugin = await readJsonAsync(manifest, 'RNOH_CLI_NOT_FOUND', 'rnoh-preflight');
+  if (plugin.name !== RnohCliPackage) {
+    throw new HarmonyAutolinkingError('RNOH_CLI_NOT_FOUND', `Expected ${RnohCliPackage}, found ${String(plugin.name)}.`, { stage: 'rnoh-preflight' });
   }
 
-  const pluginRoot = path.dirname(pkg);
-  const pluginConfig = path.join(pluginRoot, 'react-native.config.js');
-  if (!fs.existsSync(pluginConfig)) {
+  const config = path.join(path.dirname(manifest), 'react-native.config.js');
+  if (!fs.existsSync(config)) {
     throw new HarmonyAutolinkingError('RNOH_CLI_NOT_FOUND', `${RnohCliPackage} does not expose its public React Native CLI plugin config.`, { stage: 'rnoh-preflight' });
   }
 
-  const exec = cliOptions.reactNativeExecutable
-    || path.join(cliOptions.nodeModulesPath || path.join(projectRoot, 'node_modules'), '.bin', 'react-native');
-  const executable = await realpathExistingAsync(exec, {
+  if (options.reactNativeExecutable) {
+    const executable = await realpathExistingAsync(options.reactNativeExecutable, {
+      type: 'file',
+      code: 'RNOH_CLI_NOT_FOUND',
+      field: 'project-local react-native executable',
+      stage: 'rnoh-preflight',
+    });
+
+    return { executable, args: [] as string[] };
+  }
+
+  // Resolve the package itself, not a package-manager-generated .bin shell shim.
+  // The real manifest path also handles symlinked packages (for example pnpm).
+  const file = await realpathExistingAsync(
+    options.nodeModulesPath
+      ? path.join(options.nodeModulesPath, 'react-native', 'package.json')
+      : findPackageJson(root, 'react-native'),
+    {
+      type: 'file',
+      code: 'RNOH_CLI_NOT_FOUND',
+      field: 'project-local react-native package.json',
+      stage: 'rnoh-preflight',
+    }
+  );
+  const pkg = await readJsonAsync(file, 'RNOH_CLI_NOT_FOUND', 'rnoh-preflight');
+  const bin = typeof pkg.bin === 'string'
+    ? pkg.bin
+    : pkg.bin?.['react-native'];
+  if (typeof bin !== 'string' || !bin.trim()) {
+    throw new HarmonyAutolinkingError('RNOH_CLI_NOT_FOUND', 'The project-local react-native package does not declare a react-native bin entry.', { stage: 'rnoh-preflight' });
+  }
+
+  const entry = await realpathExistingAsync(path.resolve(path.dirname(file), bin), {
     type: 'file',
     code: 'RNOH_CLI_NOT_FOUND',
     field: 'project-local react-native executable',
     stage: 'rnoh-preflight',
   });
-  return executable;
+
+  return { executable: process.execPath, args: [entry] };
 }
 
 export {

package/src/harmony/rnoh/link.ts

@@ -1,4 +1,4 @@
-import childProcess from 'node:child_process';
+import crossSpawn from 'cross-spawn';
 import fs from 'node:fs';
 import path from 'node:path';
 
@@ -6,6 +6,7 @@ import { RnohArtifacts } from '../../config/constants';
 import { HarmonyAutolinkingError } from '../../errors';
 import { assertSafeRnohPackageList } from '../../config/options';
 import { isPathInside, sanitizeOutput } from '../../utilities/values';
+import { terminateProcess } from '../../utilities/terminateProcess';
 import { createManifest } from '../manifest/generate';
 import { canonicalizeOhpmManifest } from '../persistence/canonicalize';
 import { resolveRnohMetadata } from './packageMetadata';
@@ -36,14 +37,15 @@ function spawnBoundedAsync(executable, argv, options: Record<string, any> = {})
     let stdoutTruncated = false;
     let stderrTruncated = false;
     let timedOut = false;
-    let killTimer;
+    let escalation;
     // eslint-disable-next-line prefer-const
     let timeout;
     let settled = false;
+    let stopping: Promise<void> | undefined;
     let child;
 
     try {
-      child = childProcess.spawn(executable, argv, {
+      child = crossSpawn(executable, argv, {
         cwd: options.cwd,
         env: options.env || process.env,
         shell: false,
@@ -64,28 +66,20 @@ function spawnBoundedAsync(executable, argv, options: Record<string, any> = {})
       stderr = appendBounded(stderr, chunk, outputLimit);
     });
 
-    child.on('error', (error) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timeout);
-      clearTimeout(killTimer);
-      reject(error);
-    });
-
-    timeout = setTimeout(() => {
-      timedOut = true;
-      child.kill('SIGTERM');
-      killTimer = setTimeout(() => child.kill('SIGKILL'), 1_000);
-      killTimer.unref?.();
-    }, timeoutMs);
-    timeout.unref?.();
+    const finish = async (code, signal, error?) => {
+      try {
+        await stopping;
+      } catch (cause) {
+        error = cause;
+      }
 
-    child.on('close', (code, signal) => {
       if (settled) return;
       settled = true;
       clearTimeout(timeout);
-      clearTimeout(killTimer);
-      resolve({
+      clearTimeout(escalation);
+
+      if (error) reject(error);
+      else resolve({
         code,
         signal,
         timedOut,
@@ -94,6 +88,34 @@ function spawnBoundedAsync(executable, argv, options: Record<string, any> = {})
         stdoutTruncated,
         stderrTruncated,
       });
+    };
+
+    child.on('error', (error) => {
+      void finish(null, null, error);
+    });
+
+    timeout = setTimeout(() => {
+      timedOut = true;
+      stopping = Promise.resolve().then(() => terminateProcess(child, 'SIGTERM'));
+      if (process.platform === 'win32') {
+        void finish(null, 'SIGTERM');
+      } else {
+        stopping.catch((error) => {
+          void finish(null, null, error);
+        });
+        escalation = setTimeout(() => {
+          stopping = terminateProcess(child, 'SIGKILL');
+          stopping.catch((error) => {
+            void finish(null, null, error);
+          });
+        }, 1_000);
+        escalation.unref?.();
+      }
+    }, timeoutMs);
+    timeout.unref?.();
+
+    child.on('close', (code, signal) => {
+      void finish(code, signal);
     });
   });
 }
@@ -370,7 +392,7 @@ function patchOhpmManifest(artifact, descriptors, buildType, harmonyProjectPath)
 }
 
 async function linkRnohAsync(linkOptions) {
-  const executable = await resolveCliAsync({
+  const command = await resolveCliAsync({
     ...linkOptions,
     nodeModulesPath: linkOptions.commandNodeModulesPath || linkOptions.nodeModulesPath,
   });
@@ -384,12 +406,12 @@ async function linkRnohAsync(linkOptions) {
 
   let result;
   try {
-    result = await spawnBoundedAsync(executable, buildLinkCommandArgs({
+    result = await spawnBoundedAsync(command.executable, [...command.args, ...buildLinkCommandArgs({
       harmonyProjectPath: linkOptions.stageHarmonyProjectPath,
       nodeModulesPath: linkOptions.nodeModulesPath,
       include: linkOptions.include,
       exclude: linkOptions.exclude,
-    }), spawn);
+    })], spawn);
   } catch (cause) {
     throw new HarmonyAutolinkingError('RNOH_LINK_FAILED', 'Unable to execute React Native link-harmony.', { cause, stage: 'rnoh-link' });
   }

package/src/utilities/terminateProcess.ts

@@ -0,0 +1,53 @@
+import { spawn, type ChildProcess } from 'node:child_process';
+import path from 'node:path';
+
+/** Stop a Windows command and its descendants before callers restore build inputs. */
+export async function terminateProcess(child: ChildProcess, signal: NodeJS.Signals): Promise<void> {
+  if (!child.pid) return;
+
+  if (process.platform !== 'win32') {
+    child.kill(signal);
+    return;
+  }
+
+  try {
+    await new Promise<void>((resolve, reject) => {
+      const command = path.win32.join(process.env.SystemRoot || process.env.SYSTEMROOT || 'C:\\Windows', 'System32', 'taskkill.exe');
+      const killer = spawn(command, ['/pid', String(child.pid), '/T', '/F'], {
+        shell: false,
+        windowsHide: true,
+        stdio: 'ignore',
+      });
+
+      const timer = setTimeout(() => {
+        try {
+          killer.kill('SIGKILL');
+        } catch { /* Still report the bounded termination failure. */ }
+        killer.unref();
+        reject(new Error(`Timed out terminating process tree ${child.pid}.`));
+      }, 5_000);
+
+      killer.once('error', (error) => {
+        clearTimeout(timer);
+        reject(error);
+      });
+      killer.once('exit', (code) => {
+        clearTimeout(timer);
+
+        if (code === 0) resolve();
+        else reject(new Error(`taskkill failed for process tree ${child.pid} (exit ${code}).`));
+      });
+    });
+  } catch (cause) {
+    // A failed taskkill must be reported, but must not keep the caller hung forever.
+    child.unref();
+
+    throw new Error(`Unable to terminate process tree ${child.pid}.`, { cause });
+  } finally {
+    // Descendants can retain pipe handles after the immediate child has exited.
+    // taskkill has finished (or failed explicitly); do not wait forever for EOF.
+    child.stdin?.destroy();
+    child.stdout?.destroy();
+    child.stderr?.destroy();
+  }
+}

package/src/utilities/toolCommand.ts

@@ -0,0 +1,14 @@
+/** Keep tool overrides consistent across CLI, workspace and local HAR builds. */
+export function resolveHarmonyCommand(command: string, args: readonly string[], env = process.env) {
+  const configured = command === 'ohpm'
+    ? env.HARMONY_OHPM
+    : command === 'hvigorw' ? env.HARMONY_HVIGORW : undefined;
+  if (!configured) return { command, args: [...args] };
+
+  const node = command === 'ohpm' ? env.HARMONY_OHPM_NODE : env.HARMONY_HVIGOR_NODE;
+  return /\.(?:c|m)?js$/iu.test(configured)
+    ? { command: node || env.HARMONY_NODE || process.execPath, args: [configured, ...args] }
+    : { command: configured, args: [...args] };
+}
+
+export { terminateProcess } from './terminateProcess';