@@ -0,0 +1,60 @@
+import { execFileSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import { createRequire } from 'node:module';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { expect, test } from '@playwright/test';
+
+const DEBUG_ID = /\/\/# debugId=([0-9a-f-]{36})/;
+
+// Not a listed subpath, so it is reached from the package root.
+const script = path.join(
+  path.dirname(createRequire(import.meta.url).resolve('@sentry/remix/package.json')),
+  'scripts',
+  'sentry-remix-v3-upload-sourcemaps.mjs',
+);
+
+test('emits the module graph with one map per module, all sharing the served debug IDs', async ({ baseURL }) => {
+  const outDir = fs.mkdtempSync(path.join(os.tmpdir(), 'remix-v3-upload-'));
+
+  const output = execFileSync(
+    'node',
+    [
+      '--import',
+      '@sentry/remix/v3/node',
+      script,
+      '--entry',
+      'app/actions/public/entry.ts',
+      '--dry-run',
+      '--out-dir',
+      outDir,
+    ],
+    { cwd: process.cwd(), env: { ...process.env, NODE_ENV: 'production' }, encoding: 'utf8' },
+  );
+  expect(output).toMatch(/emitted \d+ modules/);
+
+  const modules = walk(outDir).filter(file => !file.endsWith('.map'));
+  expect(modules.length).toBeGreaterThan(1);
+
+  for (const file of modules) {
+    const debugId = fs.readFileSync(file, 'utf8').match(DEBUG_ID)?.[1];
+    expect(debugId, `${file} has no debug ID`).toBeDefined();
+    const map = JSON.parse(fs.readFileSync(`${file}.map`, 'utf8')) as { debugId?: string };
+    expect(map.debugId, `${file}.map does not match its module`).toBe(debugId);
+  }
+
+  // The IDs are hashed from the compiled source, so the emitted entry must match what the server
+  // serves right now. That is what lets an upload made in CI symbolicate a running app.
+  const emittedEntry = modules.find(file => file.endsWith(path.join('app', 'actions', 'public', 'entry.ts')));
+  const served = await (await fetch(`${baseURL}/assets/app/actions/public/entry.ts`)).text();
+  expect(fs.readFileSync(emittedEntry as string, 'utf8').match(DEBUG_ID)?.[1]).toBe(served.match(DEBUG_ID)?.[1]);
+
+  fs.rmSync(outDir, { recursive: true, force: true });
+});
+
+function walk(dir: string): string[] {
+  return fs.readdirSync(dir, { withFileTypes: true }).flatMap(entry => {
+    const file = path.join(dir, entry.name);
+    return entry.isDirectory() ? walk(file) : [file];
+  });
+}
@@ -7,7 +7,8 @@
   "author": "Sentry",
   "license": "MIT",
   "bin": {
-    "sentry-upload-sourcemaps": "scripts/sentry-upload-sourcemaps.js"
+    "sentry-upload-sourcemaps": "scripts/sentry-upload-sourcemaps.js",
+    "sentry-remix-v3-upload-sourcemaps": "scripts/sentry-remix-v3-upload-sourcemaps.mjs"
   },
   "engines": {
     "node": ">=20.19.0 <22.0.0 || >=22.12.0 <23.0.0 || >=23.2.0"
 
@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+// Emits a Remix 3 app's browser module graph to a directory and uploads it to Sentry.
+//
+// Must run under the Sentry entry, which provides Remix's TypeScript loader and patches the asset
+// server so the emitted modules carry debug IDs:
+//
+//   node --import @sentry/remix/v3/node ./node_modules/.bin/sentry-remix-v3-upload-sourcemaps \
+//     --entry app/actions/public/entry.ts --release "$RELEASE"
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { parseArgs } from 'node:util';
+
+class UsageError extends Error {}
+
+let outDir;
+let keepOutput = false;
+
+try {
+  const values = parseOptions();
+  keepOutput = Boolean(values['keep-output'] || values['out-dir']);
+
+  const { emitAssets } = await import('@sentry/remix/v3');
+
+  let assetsModule;
+  try {
+    assetsModule = await import(pathToFileURL(path.resolve(values['assets-module'])).href);
+  } catch (error) {
+    if (error?.code === 'ERR_UNKNOWN_FILE_EXTENSION') {
+      fail(`could not load ${values['assets-module']}. Run this command with \`node --import @sentry/remix/v3/node\`.`);
+    }
+    throw error;
+  }
+  const assets = assetsModule[values['assets-export']];
+  if (typeof assets?.getPreloads !== 'function' || typeof assets?.fetch !== 'function') {
+    fail(`${values['assets-module']} does not export an asset server named "${values['assets-export']}"`);
+  }
+
+  outDir = values['out-dir'] ?? fs.mkdtempSync(path.join(os.tmpdir(), 'sentry-remix-v3-assets-'));
+  const emitted = await emitAssets({ assets, entries: values.entry, outDir });
+  const maps = emitted.filter(asset => asset.mapFile).length;
+  const debugIds = emitted.filter(asset => asset.debugId).length;
+  console.log(
+    `[sentry] emitted ${emitted.length} modules, ${maps} source maps, ${debugIds} debug IDs${keepOutput ? ` to ${outDir}` : ''}`,
+  );
+
+  if (emitted.length > 0 && debugIds === 0) {
+    // The one failure that is otherwise silent: an unpatched asset server emits plain modules.
+    fail(
+      'no debug IDs were emitted. Run this command with `node --import @sentry/remix/v3/node` so the asset server is instrumented.',
+    );
+  }
+
+  if (values['dry-run']) {
+    console.log('[sentry] --dry-run, skipping upload');
+  } else {
+    const { createSentrySDK } = await import('sentry');
+    const sentry = createSentrySDK({ url: values.url, org: values.org, project: values.project });
+    const release = values.release ?? (await sentry.release['propose-version']()).version;
+    await sentry.release.create({ orgVersion: release });
+    // Modules keep their served names (`.ts`, `.tsx`), which the upload skips by default.
+    const ext = [...new Set(emitted.map(asset => path.extname(asset.file)))].join(',');
+    await sentry.sourcemap.upload({ directory: outDir, release, ext });
+    await sentry.release.finalize({ orgVersion: release });
+    console.log(`[sentry] uploaded release ${release}`);
+  }
+} catch (error) {
+  if (!(error instanceof UsageError)) {
+    throw error;
+  }
+  console.error(`[sentry] ${error.message}`);
+  process.exitCode = 1;
+} finally {
+  if (outDir && !keepOutput) {
+    fs.rmSync(outDir, { recursive: true, force: true });
+  }
+}
+
+function parseOptions() {
+  let values;
+  try {
+    ({ values } = parseArgs({
+      options: {
+        entry: { type: 'string', multiple: true },
+        'assets-module': { type: 'string', default: './app/assets.ts' },
+        'assets-export': { type: 'string', default: 'assets' },
+        release: { type: 'string' },
+        org: { type: 'string' },
+        project: { type: 'string' },
+        url: { type: 'string' },
+        'out-dir': { type: 'string' },
+        'keep-output': { type: 'boolean', default: false },
+        'dry-run': { type: 'boolean', default: false },
+      },
+    }));
+  } catch (error) {
+    fail(error.message);
+  }
+  if (!values.entry?.length) {
+    fail('at least one --entry is required, e.g. --entry app/actions/public/entry.ts');
+  }
+  return values;
+}
+
+function fail(message) {
+  throw new UsageError(message);
+}
@@ -179,8 +179,16 @@ function withDebugIdOptions(options: AssetServerOptions | undefined): AssetServe
  * the `//# debugId=` comment and the source map's `debugId` field, which is what `sentry-cli` reads,
  * are added to the served response instead.
  */
+/**
+ * The asset server's own `fetch`, before stamping. The emitter needs it because stamping hides source
+ * maps by default, and the upload must still get them.
+ * @internal
+ */
+export const UNSTAMPED_FETCH: unique symbol = Symbol.for('sentry.remix.unstampedFetch');
+
 function stampServedAssets(server: AssetServer, { hideSourceMaps }: { hideSourceMaps: boolean }): void {
   const fetchAsset = server.fetch;
+  (server as AssetServer & { [UNSTAMPED_FETCH]?: AssetServer['fetch'] })[UNSTAMPED_FETCH] = fetchAsset;
   // The asset server memoizes compiled modules and identifies each version by its ETag, so the
   // stamped body is memoized the same way. Without this every hit copied the module body again.
   const stamped = new Map<string, string>();
 
@@ -0,0 +1,90 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { UNSTAMPED_FETCH } from './assetServer';
+import { addDebugIdToSourceMap, findDebugId } from './debugId';
+
+/** The subset of `@remix-run/assets`' `AssetServer` this needs. */
+export interface AssetServerLike {
+  fetch(request: Request): Promise<Response | null>;
+  getPreloads(filePath: string | readonly string[]): Promise<string[]>;
+  [UNSTAMPED_FETCH]?: (request: Request) => Promise<Response | null>;
+}
+
+export interface EmitAssetsOptions {
+  /** The app's own asset server. Driving the real one is what makes the debug IDs match production. */
+  assets: AssetServerLike;
+  /** Browser entry paths, e.g. `['app/actions/public/entry.ts']`. */
+  entries: readonly string[];
+  outDir: string;
+}
+
+export interface EmittedAsset {
+  /** Public URL the module is served from. */
+  url: string;
+  file: string;
+  /** Written when the asset server produced a source map for the module. */
+  mapFile?: string;
+  debugId?: string;
+}
+
+/**
+ * Compile a Remix 3 app's browser module graph to disk, for a source map upload.
+ *
+ * Remix 3 has no build step, so there is no output directory to upload. This drives the app's own
+ * asset server instead: same config, so the same compiled output and the same debug IDs the running
+ * server serves. `getPreloads()` is what forces compilation; the server compiles lazily, so without
+ * it only the modules something happened to request would exist.
+ */
+export async function emitAssets(options: EmitAssetsOptions): Promise<EmittedAsset[]> {
+  const { assets, entries, outDir } = options;
+  // Source maps are hidden by default, so they have to be read from the unstamped server.
+  const fetchMap: AssetServerLike['fetch'] = assets[UNSTAMPED_FETCH] ?? (request => assets.fetch(request));
+
+  const emitted: EmittedAsset[] = [];
+
+  for (const url of await assets.getPreloads([...entries])) {
+    const response = await assets.fetch(new Request(`http://asset-server${url}`));
+    if (response?.status !== 200) {
+      continue;
+    }
+
+    const source = await response.text();
+    const debugId = findDebugId(source);
+    const file = path.join(outDir, toRelativePath(url));
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, source);
+
+    const asset: EmittedAsset = { url, file, debugId };
+
+    const mapResponse = await fetchMap(new Request(`http://asset-server${toMapUrl(url)}`));
+    if (mapResponse?.status === 200) {
+      const map = await mapResponse.text();
+      asset.mapFile = `${file}.map`;
+      fs.writeFileSync(asset.mapFile, debugId ? addDebugIdToSourceMap(map, debugId) : map);
+    }
+
+    emitted.push(asset);
+  }
+
+  return emitted;
+}
+
+// The server resolves the map from the pathname, so `.map` goes before any query.
+function toMapUrl(url: string): string {
+  const queryIndex = url.indexOf('?');
+  return queryIndex === -1 ? `${url}.map` : `${url.slice(0, queryIndex)}.map${url.slice(queryIndex)}`;
+}
+
+// Decoded, so the tree on disk mirrors the module layout rather than the asset server's encoding.
+// Debug ID matching does not depend on these paths. `..` is dropped so the file stays under `outDir`.
+function toRelativePath(url: string): string {
+  const pathname = url.split('?')[0] ?? url;
+  return path.join(
+    ...pathname
+      .replace(/^\//, '')
+      .split('/')
+      .map(segment => decodeURIComponent(segment).replace(/[/\\]/g, '_'))
+      .filter(segment => segment !== '..'),
+  );
+}
@@ -5,5 +5,7 @@ export { remixV3Integration } from './server/integration';
 export { sentryRemixMiddleware } from './server/middleware';
 export { instrumentRemixV3 } from './server/instrument';
 export { instrumentAssetServer } from './assetServer';
+export { emitAssets } from './emitAssets';
+export type { EmitAssetsOptions, EmittedAsset } from './emitAssets';
 export { defaultShouldHandleError } from './server/errorFilter';
 export type { ShouldHandleError } from './server/errorFilter';