feat(publish): report bytecodeVersion 0 for plain JS bundles and for native packages

The server could not tell "plain JS" from "not reported" (both NULL), so a
plain JS version stayed the "unknown epoch" hermes base candidate forever
and every Hermes build downloaded and probed it again.

- version publish always sends bytecodeVersion: the HBC version, or 0 for a
  plain JS bundle (no longer the base's version as a fallback)
- package/create sends the embedded bundle's bytecodeVersion the same way
- a server base reported as 0 is logged as "plain JS"

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: sunnylqm

src/package.ts

@@ -17,7 +17,11 @@ import {
 import { updateJson } from './utils/constants';
 import { getDepVersions } from './utils/dep-versions';
 import { getCommitInfo } from './utils/git';
-import { bundleEntryMatcher, cachePut } from './utils/hermes-base';
+import {
+  bundleEntryMatcher,
+  cachePut,
+  reportedBytecodeVersion,
+} from './utils/hermes-base';
 import { t } from './utils/i18n';
 import { getStringListOption } from './utils/options';
 import { bundleLocationFields, locateZipEntry } from './utils/zip-range';
@@ -196,6 +200,11 @@ async function uploadNativePackage(
       // against the client-reported bundleHash to decide pdiff applicability.
       // Old servers strip unknown fields, so this is forward-compatible.
       ...(bundleHash ? { bundleHash } : {}),
+      // HBC version of the embedded bundle (0 = plain JS), so the server
+      // offers this package as hermes base only to a matching compile
+      ...(bundleFile
+        ? { bytecodeVersion: reportedBytecodeVersion(bundleFile) }
+        : {}),
       ...bundleLocation,
       deps: getDepVersions(),
       commit: await getCommitInfo(),

src/utils/hermes-base.ts

@@ -63,10 +63,29 @@ export class HbcVersionMismatchError extends PermanentBaseError {
     readonly version: number | null,
     readonly expected: number,
   ) {
-    super(`downloaded base is HBC ${version ?? 'n/a'}, need ${expected}`);
+    super(
+      `downloaded base is ${version == null ? 'plain JS' : `HBC ${version}`}, need ${expected}`,
+    );
   }
 }
 
+/**
+ * `bytecodeVersion` reported for a bundle that is not Hermes bytecode, so the
+ * server can tell "plain JS" from "not reported" (NULL) and never offers it
+ * as a base.
+ */
+export const PLAIN_JS_BYTECODE_VERSION = 0;
+
+/** the `bytecodeVersion` to report for `bundle` at publish / upload time */
+export function reportedBytecodeVersion(bundle: Buffer): number {
+  return getHbcVersion(bundle) ?? PLAIN_JS_BYTECODE_VERSION;
+}
+
+const describeBytecodeVersion = (version: number | null) =>
+  version === PLAIN_JS_BYTECODE_VERSION
+    ? 'plain JS'
+    : `HBC ${version ?? 'n/a'}`;
+
 /** bytes `getHbcVersion` needs to read the version */
 const HBC_HEAD_BYTES = 128;
 
@@ -905,7 +924,7 @@ export async function resolveHermesBase(
   ) {
     log(
       t('hermesBaseNone', {
-        reason: `server base is HBC ${record.bytecodeVersion}, need ${bytecodeVersion}`,
+        reason: `server base is ${describeBytecodeVersion(record.bytecodeVersion)}, need ${bytecodeVersion}`,
       }),
     );
     return null;

src/versions.ts

@@ -10,12 +10,12 @@ import type { Package, Platform, Version } from './types';
 import { isNonInteractive, loadTtyTable, question } from './utils';
 import { getDepVersions } from './utils/dep-versions';
 import { getCommitInfo } from './utils/git';
-import { getHbcVersion } from './utils/hbcTransform';
 import {
   BUNDLE_ENTRY_NAMES,
   cachePut,
   extractBundleFromArchive,
   type HermesBaseMeta,
+  reportedBytecodeVersion,
   sha256Hex,
   truncateHermesBaseDetail,
 } from './utils/hermes-base';
@@ -497,8 +497,8 @@ async function describePpkBundle(
     if (bundle) {
       const bundleHash = sha256Hex(bundle);
       meta.bundleHash = bundleHash;
-      const hbcVersion = getHbcVersion(bundle) ?? base?.bytecodeVersion;
-      if (hbcVersion != null) meta.bytecodeVersion = hbcVersion;
+      // 0 for plain JS: the server then never offers it as a Hermes base
+      meta.bytecodeVersion = reportedBytecodeVersion(bundle);
       await cachePut(bundle, undefined, bundleHash).catch(() => {});
       Object.assign(meta, bundleLocationFields(found?.location));
     }

tests/hermes-base.test.ts

@@ -842,11 +842,18 @@ describe('publish metadata never sends JSON null', () => {
       });
       expect(used.hermesBaseOutcome).toBe('used');
       expect('hermesBaseDetail' in used).toBe(false);
-      // plain JS bundle: no bytecodeVersion at all rather than null
+      // plain JS bundle: reported as 0, never null — even when compiled
+      // against a base (the bundle, not the base, decides)
       const js = path.join(dir, 'js.ppk');
       await writeZip(js, { 'index.bundlejs': Buffer.from('var a = 1;') });
       const plain = await describePpkBundleForTests(js, undefined);
-      expect('bytecodeVersion' in plain).toBe(false);
+      expect(plain.bytecodeVersion).toBe(0);
+      const plainWithBase = await describePpkBundleForTests(js, {
+        bytecodeVersion: 98,
+        baseVersionId: null,
+        baseHash: null,
+      });
+      expect(plainWithBase.bytecodeVersion).toBe(0);
     } finally {
       fs.removeSync(dir);
     }

tests/package.test.ts

@@ -215,7 +215,8 @@ describe('packageCommands native upload', () => {
     infoSpy = spyOn(utils, 'getApkInfo').mockResolvedValue({
       versionName: '1.0.0',
       buildTime: 123,
-    });
+      bundleFile: Buffer.from('var a = 1;'),
+    } as never);
     postSpy = spyOn(api, 'post').mockResolvedValue({ id: 9 });
   });
 
@@ -269,6 +270,8 @@ describe('packageCommands native upload', () => {
         buildTime: '123',
         hash: 'slim-package-hash',
         name: '1.0.0',
+        // the embedded bundle is plain JS
+        bytecodeVersion: 0,
       }),
     );
     expect(fs.existsSync(uploadedPath)).toBe(false);

tests/zip-range.test.ts

@@ -464,7 +464,7 @@ describe('zip-range', () => {
               98,
             ).catch((e) => e);
             expect(error).toBeInstanceOf(HbcVersionMismatchError);
-            expect(error.message).toBe('downloaded base is HBC n/a, need 98');
+            expect(error.message).toBe('downloaded base is plain JS, need 98');
             expect(messages).toEqual([]);
             // tail + one header/head chunk, not the bundle body
             expect(server.log.length).toBeLessThanOrEqual(2);