feat(sourcemap): 归档前 gzip 压缩

sourcemap 是 JSON，压缩比约 5:1：瘦身后 3.1MB 的 map gzip 后仅
0.94MB（相对原始 9.2MB 缩掉 90%），每次 publish 少传一个数量级。
临时文件仍以 .map 结尾（/upload 按扩展名路由额度），读取端一律按
gzip magic bytes 判断，因此明文归档（旧 CLI 发的版本）继续可读。

`pushy symbolicate` 同步支持两种归档。

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GkBW5Sa4doZiwQtBfzr3GE

Author: sunnylqm

src/symbolicate.ts

@@ -5,6 +5,7 @@ import { get } from './api';
 import { getPlatform, getSelectedApp } from './app';
 import type { Platform, Version } from './types';
 import { t } from './utils/i18n';
+import { unpackSourceMap } from './utils/slim-sourcemap';
 import { fetchVersions } from './versions';
 
 // A frame location inside a shipped bundle: `<bundle>:<line>:<column>`. Covers
@@ -137,7 +138,11 @@ export const symbolicateCommands = {
     if (!response.ok) {
       throw new Error(`Failed to download source map: HTTP ${response.status}`);
     }
-    const rawMap = JSON.parse(await response.text());
+    // Maps archived by recent CLI versions are gzipped; older ones are plain
+    // JSON, and unpackSourceMap accepts both.
+    const rawMap = JSON.parse(
+      unpackSourceMap(Buffer.from(await response.arrayBuffer())),
+    );
     const consumer = new SourceMapConsumer(rawMap);
 
     const stack = await readStack(args[0]);

src/utils/slim-sourcemap.ts

@@ -1,4 +1,5 @@
 import path from 'path';
+import zlib from 'zlib';
 
 interface SourceMapV3 {
   sources?: unknown;
@@ -81,3 +82,24 @@ function isDependencySource(source: string): boolean {
     source.startsWith('node_modules/') || source.includes('/node_modules/')
   );
 }
+
+/**
+ * Build the bytes actually archived with a version: the slimmed map (when it
+ * is a plain map we understand), gzipped. Source maps are JSON and compress
+ * about 5x, which is the difference between a multi-megabyte upload on every
+ * publish and a small one. Readers detect the gzip magic bytes rather than
+ * trusting a file name, so plain maps archived by older CLI versions keep
+ * working unchanged.
+ */
+export function packSourceMap(content: string, projectRoot: string): Buffer {
+  const slimmed = slimSourceMap(content, projectRoot);
+  return zlib.gzipSync(Buffer.from(slimmed ?? content, 'utf8'));
+}
+
+/** Decode an archived source map: gzip when the magic bytes say so. */
+export function unpackSourceMap(data: Buffer): string {
+  if (data.length >= 2 && data[0] === 0x1f && data[1] === 0x8b) {
+    return zlib.gunzipSync(data).toString('utf8');
+  }
+  return data.toString('utf8');
+}

src/versions.ts

@@ -20,7 +20,7 @@ import {
 } from './utils/hermes-base';
 import { t } from './utils/i18n';
 import { getBooleanOption, getStringListOption } from './utils/options';
-import { slimSourceMap } from './utils/slim-sourcemap';
+import { packSourceMap } from './utils/slim-sourcemap';
 import {
   bundleLocationFields,
   readZipEntryWithLocation,
@@ -546,25 +546,23 @@ export const versionCommands = {
     if (!sourcemapPath) {
       console.log(chalk.yellow(t('sourceMapMissingWarning')));
     }
-    // Archive a slimmed copy: relative paths, no dependency sourcesContent
-    // (see slimSourceMap). Frames keep symbolicating everywhere; only inline
-    // snippets of node_modules code are dropped, and the map shrinks by the
-    // bulk of its bytes. If the file is not a plain map, upload it untouched.
+    // Archive a slimmed, gzipped copy (see packSourceMap): relative paths, no
+    // dependency sourcesContent, ~5x smaller on the wire. Frames keep
+    // symbolicating everywhere; only inline snippets of node_modules code are
+    // dropped. The temp file keeps the .map extension because /upload routes
+    // by extension; readers detect gzip by magic bytes.
     let uploadSourcemapPath = sourcemapPath;
-    let slimTempDir: string | undefined;
+    let packTempDir: string | undefined;
     if (sourcemapPath) {
-      const slimmed = slimSourceMap(
-        fs.readFileSync(sourcemapPath, 'utf8'),
-        process.cwd(),
+      packTempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rnu-sourcemap-'));
+      uploadSourcemapPath = path.join(
+        packTempDir,
+        path.basename(sourcemapPath),
+      );
+      fs.writeFileSync(
+        uploadSourcemapPath,
+        packSourceMap(fs.readFileSync(sourcemapPath, 'utf8'), process.cwd()),
       );
-      if (slimmed !== null) {
-        slimTempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rnu-sourcemap-'));
-        uploadSourcemapPath = path.join(
-          slimTempDir,
-          path.basename(sourcemapPath),
-        );
-        fs.writeFileSync(uploadSourcemapPath, slimmed);
-      }
     }
 
     // Hashing/caching the bundle and asking git for the commit are independent
@@ -588,8 +586,8 @@ export const versionCommands = {
           )
         : Promise.resolve(undefined),
     ]);
-    if (slimTempDir) {
-      fs.rmSync(slimTempDir, { recursive: true, force: true });
+    if (packTempDir) {
+      fs.rmSync(packTempDir, { recursive: true, force: true });
     }
     const sourceMapKey = sourceMapUpload?.hash;
     if (sourcemapPath && !sourceMapKey) {

tests/slim-sourcemap.test.ts

@@ -1,5 +1,10 @@
 import { describe, expect, test } from 'bun:test';
-import { slimSourceMap } from '../src/utils/slim-sourcemap';
+import zlib from 'zlib';
+import {
+  packSourceMap,
+  slimSourceMap,
+  unpackSourceMap,
+} from '../src/utils/slim-sourcemap';
 
 const root = '/work/app';
 
@@ -72,3 +77,40 @@ describe('slimSourceMap', () => {
     expect(slimSourceMap(JSON.stringify([1, 2]), root)).toBeNull();
   });
 });
+
+describe('packSourceMap / unpackSourceMap', () => {
+  const map = JSON.stringify({
+    version: 3,
+    sources: ['/work/app/src/a.ts', '/work/app/node_modules/lib/b.js'],
+    sourcesContent: ['app code', 'dependency code'],
+    mappings: 'AAAA',
+  });
+
+  test('gzips the slimmed map and round-trips through unpack', () => {
+    const packed = packSourceMap(map, root);
+    expect(packed[0]).toBe(0x1f);
+    expect(packed[1]).toBe(0x8b);
+    expect(packed.length).toBeLessThan(Buffer.byteLength(map));
+    const restored = JSON.parse(unpackSourceMap(packed));
+    expect(restored.sources).toEqual(['src/a.ts', 'node_modules/lib/b.js']);
+    expect(restored.sourcesContent).toEqual(['app code', null]);
+  });
+
+  test('gzips unslimmable input unchanged rather than dropping it', () => {
+    const indexed = JSON.stringify({ version: 3, sections: [] });
+    const packed = packSourceMap(indexed, root);
+    expect(unpackSourceMap(packed)).toBe(indexed);
+  });
+
+  test('unpack accepts plain maps archived by older CLI versions', () => {
+    expect(unpackSourceMap(Buffer.from(map, 'utf8'))).toBe(map);
+  });
+
+  test('unpack rejects corrupt gzip instead of returning garbage', () => {
+    const broken = Buffer.concat([
+      zlib.gzipSync(Buffer.from(map)).subarray(0, 20),
+      Buffer.from([0, 0, 0, 0]),
+    ]);
+    expect(() => unpackSourceMap(broken)).toThrow();
+  });
+});