diff --git a/dev-packages/e2e-tests/test-applications/solid-2/README.md b/dev-packages/e2e-tests/test-applications/solid-2/README.md
new file mode 100644
index 000000000000..6c97875be876
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/solid-2/README.md
@@ -0,0 +1,26 @@
+# solid-2
+
+A Solid 2 app on `@solidjs/vite-plugin`'s start mode, built with `observe: true`, with `@sentry/solid-2` on both halves:
+
+- the server SDK through `start.instrument` (`src/instrument.ts`), which the plugin awaits before the server graph loads;
+- the browser SDK from `src/sentry.client.ts`, imported by the app behind an `isServer` guard;
+- `server.mjs`, a bare `node:http` host around the built `handleRequest`.
+
+No router: `App.tsx` switches on the pathname. `/` calls a server function on click, `/users/6` awaits one under a
+`<Loading>`, `/server-error` throws during SSR inside an `<Errored>`, `/client-error` throws in the browser inside one.
+
+What the tests pin, against the packed tarballs:
+
+- errors: both hooks fire once, with the component that threw and the boundary that met it; the wire carries the
+  sanitized message while Sentry gets the real one; a server-function throw arrives with the function id;
+- performance (server): a waiting `<Loading>` and the server function it awaited are spans under OTel's `http.server`
+  span, backdated from the runtime's clock;
+- performance (client): the `pageload` continues the server trace with no middleware (the runtime's `<meta>` pair and
+  `Server-Timing`); a click is a root span and the server-function call it made is its child, joined by identity even
+  though the call landed after the interaction settled.
+
+```bash
+pnpm install
+pnpm build
+pnpm test:prod
+```
diff --git a/dev-packages/e2e-tests/test-applications/solid-2/package.json b/dev-packages/e2e-tests/test-applications/solid-2/package.json
new file mode 100644
index 000000000000..ba1c9720648b
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/solid-2/package.json
@@ -0,0 +1,37 @@
+{
+  "name": "solid-2",
+  "version": "0.0.0",
+  "//": "Solid 2 on @solidjs/vite-plugin start mode: an observe build (`observe: true`), the server SDK initialized through `start.instrument` (awaited before the server graph loads — no `--import`), the browser SDK from the app's client module. server.mjs is the whole production host. @sentry/node is a direct dependency so the server build externalizes it: the plugin inlines @sentry/solid-2 (a consumer of the Solid runtime), and under pnpm a transitive @sentry/node would be bundled with it, where import-in-the-middle cannot find itself.",
+  "scripts": {
+    "clean": "pnpx rimraf node_modules pnpm-lock.yaml dist",
+    "build": "vite build",
+    "start": "PORT=3030 node server.mjs",
+    "test:prod": "TEST_ENV=production playwright test",
+    "test:build": "pnpm install && pnpm build",
+    "test:assert": "pnpm test:prod"
+  },
+  "type": "module",
+  "dependencies": {
+    "@sentry/node": "file:../../packed/sentry-node-packed.tgz",
+    "@sentry/solid-2": "file:../../packed/sentry-solid-2-packed.tgz",
+    "@solidjs/web": "^2.0.0-rc.9",
+    "solid-js": "^2.0.0-rc.9"
+  },
+  "devDependencies": {
+    "@playwright/test": "~1.63.0",
+    "@sentry-internal/test-utils": "link:../../../test-utils",
+    "@solidjs/vite-plugin": "^3.0.0-next.44",
+    "typescript": "^5.4.5",
+    "vite": "^8.1.5"
+  },
+  "volta": {
+    "extends": "../../package.json",
+    "node": "24.15.0"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "sentryTest": {
+    "optional": true
+  }
+}
diff --git a/dev-packages/e2e-tests/test-applications/solid-2/playwright.config.mjs b/dev-packages/e2e-tests/test-applications/solid-2/playwright.config.mjs
new file mode 100644
index 000000000000..b52ff06a5105
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/solid-2/playwright.config.mjs
@@ -0,0 +1,8 @@
+import { getPlaywrightConfig } from '@sentry-internal/test-utils';
+
+const config = getPlaywrightConfig({
+  startCommand: 'pnpm start',
+  port: 3030,
+});
+
+export default config;
diff --git a/dev-packages/e2e-tests/test-applications/solid-2/server.mjs b/dev-packages/e2e-tests/test-applications/solid-2/server.mjs
new file mode 100644
index 000000000000..20cb480cfc6b
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/solid-2/server.mjs
@@ -0,0 +1,87 @@
+// The whole production host for a Solid 2 start-mode app: static client assets
+// plus the built server bundle's `handleRequest`, an adapter-agnostic web
+// `Request -> Response` handler. Copied from @solidjs/vite-plugin's start-ssr
+// example, with one change: the handler is imported FIRST, and awaited. Its
+// entry runs `start.instrument` (Sentry.init, OpenTelemetry) to completion
+// before the rest of the server graph loads — so `node:http` is imported only
+// after the instrumentation that patches it is in place.
+const { handleRequest } = await import('./dist/server/server.js');
+const { createServer } = await import('node:http');
+const { readFileSync } = await import('node:fs');
+const { Readable } = await import('node:stream');
+const { fileURLToPath } = await import('node:url');
+const path = (await import('node:path')).default;
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const port = process.env.PORT || 3000;
+
+const MIME = {
+  '.js': 'application/javascript',
+  '.css': 'text/css',
+  '.html': 'text/html',
+  '.json': 'application/json',
+  '.ico': 'image/x-icon',
+  '.svg': 'image/svg+xml',
+};
+
+function webRequest(req) {
+  const url = new URL(req.url || '/', `http://${req.headers.host || `localhost:${port}`}`);
+  const method = req.method || 'GET';
+  // Attach a body only when the request carries one (Content-Length or
+  // Transfer-Encoding, RFC 9112 §6): the runtime treats a present body that
+  // decodes to nothing as malformed since @solidjs/web 2.0.0-rc.5.
+  const hasBody =
+    method !== 'GET' &&
+    method !== 'HEAD' &&
+    (req.headers['transfer-encoding'] !== undefined ||
+      (req.headers['content-length'] !== undefined && req.headers['content-length'] !== '0'));
+  const body = hasBody ? Readable.toWeb(req) : undefined;
+  return new Request(url, {
+    method,
+    headers: req.headers,
+    body,
+    ...(body ? { duplex: 'half' } : {}),
+  });
+}
+
+const server = createServer(async (req, res) => {
+  const url = req.url || '/';
+
+  // Static client assets first.
+  if (url !== '/' && !url.includes('..')) {
+    try {
+      const content = readFileSync(path.resolve(__dirname, 'dist/client' + url.split('?')[0]));
+      res.setHeader('Content-Type', MIME[path.extname(url)] || 'application/octet-stream');
+      res.end(content);
+      return;
+    } catch {
+      // Fall through to the handler (SSR routes, /_server, ...).
+    }
+  }
+
+  try {
+    // The `options.event` seam: extra fields spread into the request event,
+    // conventionally the platform's raw request as `nativeEvent` — app code
+    // reads it back via getRequestEvent() (e.g. the client IP from
+    // event.nativeEvent.socket.remoteAddress on bare Node).
+    const response = await handleRequest(webRequest(req), { event: { nativeEvent: req } });
+    res.statusCode = response.status;
+    const cookies = response.headers.getSetCookie?.();
+    response.headers.forEach((value, key) => {
+      if (key !== 'set-cookie') res.setHeader(key, value);
+    });
+    if (cookies?.length) res.setHeader('set-cookie', cookies);
+    if (response.body) {
+      for await (const chunk of response.body) res.write(chunk);
+    }
+    res.end();
+  } catch (e) {
+    console.error(e);
+    res.statusCode = 500;
+    res.end(e.message);
+  }
+});
+
+server.listen(port, () => {
+  console.log(`Server running at http://localhost:${port}`);
+});
diff --git a/dev-packages/e2e-tests/test-applications/solid-2/src/App.tsx b/dev-packages/e2e-tests/test-applications/solid-2/src/App.tsx
new file mode 100644
index 000000000000..6968528c2dda
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/solid-2/src/App.tsx
@@ -0,0 +1,78 @@
+import { Errored, Loading, getRequestEvent, isServer } from '@solidjs/web';
+import { createMemo, createSignal } from 'solid-js';
+import { explode, getPrefecture } from './data';
+if (!isServer) await import('./sentry.client');
+
+function pathname(): string {
+  if (isServer) return new URL(getRequestEvent()!.request.url).pathname;
+  return window.location.pathname;
+}
+
+function ServerError(): never {
+  throw new Error('Error thrown from Solid 2 E2E test app server render');
+}
+
+function ClientBoundary() {
+  const [fail, setFail] = createSignal(false);
+  const view = createMemo(() => {
+    if (fail()) throw new Error('Error thrown from Solid 2 E2E test app client render');
+    return 'client content';
+  });
+  return (
+    <>
+      <button id="clientErrorBtn" onClick={() => setFail(true)}>
+        break the client
+      </button>
+      <p id="clientContent">{view()}</p>
+    </>
+  );
+}
+
+function Home() {
+  const [result, setResult] = createSignal('');
+  return (
+    <>
+      <h1>Solid 2 E2E</h1>
+      <button id="callBtn" onClick={async () => setResult(JSON.stringify(await getPrefecture(6)))}>
+        call the server
+      </button>
+      <button id="explodeBtn" onClick={() => explode().catch(e => setResult(`caught: ${e.message}`))}>
+        call a failing server function
+      </button>
+      <p id="callResult">{result()}</p>
+      <a id="serverErrorLink" href="/server-error">
+        server error
+      </a>
+    </>
+  );
+}
+
+function UserPage() {
+  const user = createMemo(() => getPrefecture(6));
+  return (
+    <Loading fallback={<p id="loading">loading…</p>}>
+      <p id="user">{JSON.stringify(user())}</p>
+    </Loading>
+  );
+}
+
+export default function App() {
+  const path = pathname();
+  return (
+    <main>
+      {path === '/server-error' ? (
+        <Errored fallback={err => <p id="serverErrorFallback">fallback: {String((err() as Error).message)}</p>}>
+          <ServerError />
+        </Errored>
+      ) : path === '/client-error' ? (
+        <Errored fallback={err => <p id="clientErrorFallback">fallback: {String((err() as Error).message)}</p>}>
+          <ClientBoundary />
+        </Errored>
+      ) : path === '/users/6' ? (
+        <UserPage />
+      ) : (
+        <Home />
+      )}
+    </main>
+  );
+}
diff --git a/dev-packages/e2e-tests/test-applications/solid-2/src/data.ts b/dev-packages/e2e-tests/test-applications/solid-2/src/data.ts
new file mode 100644
index 000000000000..39997adc8649
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/solid-2/src/data.ts
@@ -0,0 +1,10 @@
+'use server';
+
+export async function getPrefecture(id: number): Promise<{ prefecture: string; id: number }> {
+  await new Promise(resolve => setTimeout(resolve, 20));
+  return { prefecture: 'Kagoshima', id };
+}
+
+export async function explode(): Promise<never> {
+  throw new Error('Error thrown from Solid 2 E2E test app server function');
+}
diff --git a/dev-packages/e2e-tests/test-applications/solid-2/src/instrument.ts b/dev-packages/e2e-tests/test-applications/solid-2/src/instrument.ts
new file mode 100644
index 000000000000..b5c25d3035f5
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/solid-2/src/instrument.ts
@@ -0,0 +1,13 @@
+// `start.instrument`: awaited to completion before anything else in the
+// server graph loads, so the Node SDK's OpenTelemetry setup lands before the
+// modules it patches.
+import * as Sentry from '@sentry/solid-2/server';
+
+Sentry.init({
+  dsn: process.env.E2E_TEST_DSN,
+  environment: 'qa', // dynamic sampling bias to keep transactions
+  tracesSampleRate: 1.0,
+  tunnel: 'http://localhost:3031/', // proxy server
+  integrations: [Sentry.solidServerTracingIntegration()],
+  debug: !!process.env.DEBUG,
+});
diff --git a/dev-packages/e2e-tests/test-applications/solid-2/src/sentry.client.ts b/dev-packages/e2e-tests/test-applications/solid-2/src/sentry.client.ts
new file mode 100644
index 000000000000..3a3529b4287b
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/solid-2/src/sentry.client.ts
@@ -0,0 +1,17 @@
+// The explicit client entry: this module is reachable from the server graph
+// (App.tsx imports it behind an `isServer` guard), where the bare package
+// would resolve to the server half and the client integrations would not
+// exist.
+import * as Sentry from '@sentry/solid-2/client';
+
+// Module-level so it runs when the app module is evaluated, before hydration.
+Sentry.init({
+  // We can't use env variables here, seems like they are stripped
+  // out in production builds.
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  environment: 'qa', // dynamic sampling bias to keep transactions
+  tunnel: 'http://localhost:3031/', // proxy server
+  tracesSampleRate: 1.0,
+  integrations: [Sentry.browserTracingIntegration(), Sentry.solidTracingIntegration()],
+  debug: !!import.meta.env.DEBUG,
+});
diff --git a/dev-packages/e2e-tests/test-applications/solid-2/start-event-proxy.mjs b/dev-packages/e2e-tests/test-applications/solid-2/start-event-proxy.mjs
new file mode 100644
index 000000000000..c98eeb1883c4
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/solid-2/start-event-proxy.mjs
@@ -0,0 +1,6 @@
+import { startEventProxyServer } from '@sentry-internal/test-utils';
+
+startEventProxyServer({
+  port: 3031,
+  proxyServerName: 'solid-2',
+});
diff --git a/dev-packages/e2e-tests/test-applications/solid-2/tests/errors.client.test.ts b/dev-packages/e2e-tests/test-applications/solid-2/tests/errors.client.test.ts
new file mode 100644
index 000000000000..6029b56545f5
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/solid-2/tests/errors.client.test.ts
@@ -0,0 +1,32 @@
+import { expect, test } from '@playwright/test';
+import { waitForError } from '@sentry-internal/test-utils';
+
+test.describe('client-side errors', () => {
+  test('captures what an <Errored> boundary caught, without wrapping anything', async ({ page }) => {
+    const errorEventPromise = waitForError('solid-2', errorEvent => {
+      return errorEvent?.exception?.values?.[0]?.value === 'Error thrown from Solid 2 E2E test app client render';
+    });
+
+    await page.goto('/client-error');
+    await expect(page.locator('#clientContent')).toHaveText('client content');
+    await page.locator('#clientErrorBtn').click();
+    await expect(page.locator('#clientErrorFallback')).toHaveText(/fallback: Error thrown/);
+
+    const error = await errorEventPromise;
+    expect(error).toMatchObject({
+      exception: {
+        values: [
+          {
+            type: 'Error',
+            value: 'Error thrown from Solid 2 E2E test app client render',
+            mechanism: { type: 'auto.function.solid.error_boundary', handled: true },
+          },
+        ],
+      },
+      tags: {
+        'solid.owner': expect.stringContaining('<ClientBoundary>'),
+        'solid.boundary': expect.stringContaining('<Errored>'),
+      },
+    });
+  });
+});
diff --git a/dev-packages/e2e-tests/test-applications/solid-2/tests/errors.server.test.ts b/dev-packages/e2e-tests/test-applications/solid-2/tests/errors.server.test.ts
new file mode 100644
index 000000000000..b75479dc6f07
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/solid-2/tests/errors.server.test.ts
@@ -0,0 +1,56 @@
+import { expect, test } from '@playwright/test';
+import { waitForError } from '@sentry-internal/test-utils';
+
+test.describe('server-side errors', () => {
+  test('captures a render error an <Errored> contained, as thrown, located by component', async ({ page }) => {
+    const errorEventPromise = waitForError('solid-2', errorEvent => {
+      return errorEvent?.exception?.values?.[0]?.value === 'Error thrown from Solid 2 E2E test app server render';
+    });
+
+    await page.goto('/server-error');
+    // The wire got the sanitized message; Sentry got the real one.
+    await expect(page.locator('#serverErrorFallback')).toHaveText(/fallback: Internal Server Error/);
+
+    const error = await errorEventPromise;
+    expect(error).toMatchObject({
+      exception: {
+        values: [
+          {
+            type: 'Error',
+            value: 'Error thrown from Solid 2 E2E test app server render',
+            mechanism: { type: 'auto.function.solid.server.render.fallback', handled: true },
+          },
+        ],
+      },
+      tags: {
+        'solid.kind': 'render',
+        'solid.handling': 'fallback',
+        'solid.owner': expect.stringContaining('<ServerError>'),
+        'solid.boundary_path': expect.stringContaining('<Errored>'),
+      },
+      transaction: 'GET /server-error',
+    });
+  });
+
+  test('captures a server function throw, unhandled, with the function id', async ({ page }) => {
+    const errorEventPromise = waitForError('solid-2', errorEvent => {
+      return errorEvent?.exception?.values?.[0]?.value === 'Error thrown from Solid 2 E2E test app server function';
+    });
+
+    await page.goto('/');
+    await page.locator('#explodeBtn').click();
+    await expect(page.locator('#callResult')).toHaveText(/caught:/);
+
+    const error = await errorEventPromise;
+    expect(error).toMatchObject({
+      exception: {
+        values: [
+          {
+            mechanism: { type: 'auto.function.solid.server.server-function.thrown', handled: true },
+          },
+        ],
+      },
+      tags: { 'solid.kind': 'server-function', 'solid.handling': 'thrown', 'solid.function': expect.any(String) },
+    });
+  });
+});
diff --git a/dev-packages/e2e-tests/test-applications/solid-2/tests/performance.client.test.ts b/dev-packages/e2e-tests/test-applications/solid-2/tests/performance.client.test.ts
new file mode 100644
index 000000000000..7f95f4d6cf6d
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/solid-2/tests/performance.client.test.ts
@@ -0,0 +1,57 @@
+import { expect, test } from '@playwright/test';
+import type { SerializedStreamedSpan } from '@sentry-internal/test-utils';
+import { collectStreamedSpans, getSpanOp } from '@sentry-internal/test-utils';
+
+test('the pageload continues the server trace through the runtime’s carriers', async ({ page }) => {
+  const isServer = (span: SerializedStreamedSpan): boolean =>
+    span.is_segment && getSpanOp(span) === 'http.server' && span.attributes['url.path']?.value === '/';
+  // No router in this app, so the pageload keeps the SDK's default name; the path is an attribute.
+  const isPageload = (span: SerializedStreamedSpan): boolean =>
+    span.is_segment && getSpanOp(span) === 'pageload' && span.attributes['url.path']?.value === '/';
+  // Grouped by trace: the two only satisfy this together if the browser
+  // continued the server's trace (other tests load '/' too).
+  const spansPromise = collectStreamedSpans('solid-2', spans => spans.some(isServer) && spans.some(isPageload));
+
+  await page.goto('/');
+
+  const spans = await spansPromise;
+  const server = spans.find(isServer)!;
+  const pageload = spans.find(isPageload)!;
+  // No middleware rewrote the document: the runtime emitted the <meta> pair
+  // from the trace provider's answer, and Server-Timing on the response.
+  expect(pageload.trace_id).toBe(server.trace_id);
+  expect(pageload.parent_span_id).toBe(server.span_id);
+});
+
+test('a click is a root span with the server-function call it made as a child, joined by identity', async ({
+  page,
+}) => {
+  const spansPromise = collectStreamedSpans(
+    'solid-2',
+    spans =>
+      spans.some(span => span.is_segment && getSpanOp(span) === 'ui.interaction.click') &&
+      spans.some(span => getSpanOp(span) === 'function.solid.call'),
+  );
+
+  await page.goto('/');
+  await page.locator('#callBtn').click();
+  await expect(page.locator('#callResult')).toContainText('Kagoshima');
+
+  const spans = await spansPromise;
+  const interaction = spans.find(span => span.is_segment && getSpanOp(span) === 'ui.interaction.click')!;
+  const call = spans.find(span => getSpanOp(span) === 'function.solid.call')!;
+
+  expect(interaction.name).toBe('click on button#callBtn');
+  expect(interaction.attributes).toMatchObject({
+    'sentry.origin': { value: 'auto.ui.solid.attribution', type: 'string' },
+    'solid.interaction.type': { value: 'click', type: 'string' },
+  });
+  expect(call.parent_span_id).toBe(interaction.span_id);
+  expect(call.trace_id).toBe(interaction.trace_id);
+  expect(call.attributes).toMatchObject({
+    'sentry.origin': { value: 'auto.http.solid.call', type: 'string' },
+    'solid.server_function.method': { value: 'POST', type: 'string' },
+    'solid.server_function.outcome': { value: 'ok', type: 'string' },
+    'solid.server_function.origin.kind': { value: 'interaction', type: 'string' },
+  });
+});
diff --git a/dev-packages/e2e-tests/test-applications/solid-2/tests/performance.server.test.ts b/dev-packages/e2e-tests/test-applications/solid-2/tests/performance.server.test.ts
new file mode 100644
index 000000000000..70c0440f0af1
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/solid-2/tests/performance.server.test.ts
@@ -0,0 +1,43 @@
+import { expect, test } from '@playwright/test';
+import { collectStreamedSpans, getSpanOp } from '@sentry-internal/test-utils';
+
+test('a waiting <Loading> boundary and the server function it awaited are spans under the request', async ({
+  page,
+}) => {
+  const spansPromise = collectStreamedSpans(
+    'solid-2',
+    spans =>
+      spans.some(
+        span =>
+          span.is_segment && getSpanOp(span) === 'http.server' && span.attributes['url.path']?.value === '/users/6',
+      ) &&
+      spans.some(span => getSpanOp(span) === 'solid.boundary') &&
+      spans.some(span => getSpanOp(span) === 'function.solid.direct'),
+  );
+
+  await page.goto('/users/6');
+  await expect(page.locator('#user')).toContainText('Kagoshima');
+
+  const spans = await spansPromise;
+  const request = spans.find(
+    span => span.is_segment && getSpanOp(span) === 'http.server' && span.attributes['url.path']?.value === '/users/6',
+  )!;
+  const boundary = spans.find(span => getSpanOp(span) === 'solid.boundary')!;
+  const invocation = spans.find(span => getSpanOp(span) === 'function.solid.direct')!;
+
+  // Both parent on the request: the records are delivered inside its async context.
+  expect(boundary.parent_span_id).toBe(request.span_id);
+  expect(invocation.parent_span_id).toBe(request.span_id);
+  expect(boundary.attributes).toMatchObject({
+    'sentry.origin': { value: 'auto.function.solid.server', type: 'string' },
+    'solid.boundary.outcome': { value: 'settled', type: 'string' },
+  });
+  expect(boundary.name).toContain('<UserPage>');
+  expect(invocation.attributes).toMatchObject({
+    'solid.server_function.direct': { value: true, type: 'boolean' },
+    'solid.server_function.outcome': { value: 'ok', type: 'string' },
+  });
+  // Backdated from the record's clock, inside the request's window.
+  expect(boundary.start_timestamp).toBeGreaterThanOrEqual(request.start_timestamp - 0.001);
+  expect(boundary.end_timestamp).toBeLessThanOrEqual(request.end_timestamp + 0.001);
+});
diff --git a/dev-packages/e2e-tests/test-applications/solid-2/tsconfig.json b/dev-packages/e2e-tests/test-applications/solid-2/tsconfig.json
new file mode 100644
index 000000000000..a14ff4542e48
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/solid-2/tsconfig.json
@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "preserve",
+    "jsxImportSource": "@solidjs/web",
+    "strict": true,
+    "skipLibCheck": true,
+    "types": ["vite/client"]
+  },
+  "include": ["src", "tests", "vite.config.ts"]
+}
diff --git a/dev-packages/e2e-tests/test-applications/solid-2/vite.config.ts b/dev-packages/e2e-tests/test-applications/solid-2/vite.config.ts
new file mode 100644
index 000000000000..451e6c83c785
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/solid-2/vite.config.ts
@@ -0,0 +1,19 @@
+import solid from '@solidjs/vite-plugin';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  plugins: [
+    solid({
+      ssr: true,
+      // The production-speed runtime that keeps `OBSERVE` alive — what the
+      // tracing integrations read. Errors report in every tier.
+      observe: true,
+      serverFunctions: true,
+      start: {
+        // Awaited to completion before the server graph loads: Sentry.init()
+        // runs before @solidjs/web or the app are imported.
+        instrument: './src/instrument.ts',
+      },
+    }),
+  ],
+});
diff --git a/docs/solid-2-observe.md b/docs/solid-2-observe.md
new file mode 100644
index 000000000000..5734244b6a34
--- /dev/null
+++ b/docs/solid-2-observe.md
@@ -0,0 +1,196 @@
+# Solid 2's observe tier — what `@sentry/solid-2` builds on
+
+A reviewer's brief for the Solid 2 SDK (`packages/solid-2`): what the runtime exposes, what the integration relies
+on, and where the trust boundaries are. The normative text lives in the Solid repo
+([RFC 08, dev diagnostics](https://github.com/solidjs/solid/blob/next/documentation/solid-2.0/08-dev-diagnostics.md),
+[RFC 12, SSR/HTTP](https://github.com/solidjs/solid/blob/next/documentation/solid-2.0/12-ssr-http.md),
+[RFC 10, server functions](https://github.com/solidjs/solid/blob/next/documentation/solid-2.0/10-server-functions.md));
+this is the map.
+
+## Three build tiers
+
+Solid 2 ships three builds of every runtime package, selected by export condition:
+
+| Tier      | Condition     | Contains                                                                         | Size (brotli, CSR app)   |
+| --------- | ------------- | -------------------------------------------------------------------------------- | ------------------------ |
+| `prod`    | default       | The runtime. `OBSERVE` and `DEV` are `undefined`.                                | 15.2 KB                  |
+| `observe` | `observe`     | prod + the structured channels and hook slots: `OBSERVE`. No console, no checks. | 16.7 KB (+1.3 KB wiring) |
+| `dev`     | `development` | observe + the dev checks and the console face: `DEV`. Unminified.                | —                        |
+
+The tiers nest: whatever works on `observe` works on `dev`. An app opts in with `solid({ observe: true })` in
+`@solidjs/vite-plugin`, which sets the condition for every environment and turns on the compiler's `componentNames`
+(component labels survive minification — the `<App> › <Feed>` paths below). In `vite dev` the `development`
+condition still wins, by design: the dev build is a superset.
+
+What this means for the SDK:
+
+- **Error reporting works in every tier.** The error hooks are part of the runtime, not of `OBSERVE`. A production
+  app with no observability tooling gets error events from `init()` alone.
+- **Tracing needs the observe build.** Without it `OBSERVE` is `undefined`, the tracing integrations log once in
+  debug mode and do nothing. There is no partial mode.
+- The attribution engine (`solid-js/attribution`) is a separate 10.5 KB entry the observe build carries only when
+  imported — `solidTracingIntegration` imports it, so enabling tracing costs that plus the 1.3 KB wiring. Idle
+  wiring cost with no hooks installed is capped by Solid's suite at 1.25× the prod build on a graph-heavy workload
+  (measured 1.03–1.09).
+
+## The surface the integration touches
+
+Everything is imported from `solid-js` and `@solidjs/web`. The SDK never imports `@solidjs/signals` (the engine
+package underneath), and never touches a `_`-prefixed field.
+
+### Error hooks (every tier)
+
+```ts
+// solid-js
+configureClientErrors({ onError(error, { ownerPath, boundaryPath }) {} });
+// @solidjs/web (server)
+configureServerErrors({
+  onError(error, { kind, handling, boundary, boundaryPath, functionId, direct, ownerPath, event }) {},
+});
+```
+
+- Called **once per error object**, at first sight. A boundary re-collecting the same failure after `reset()` says
+  nothing new.
+- **Client**: fires when an `<Errored>` renders its fallback — the one road a rendered failure took that no global
+  handler saw. Uncaught errors keep reaching `window.onerror` / `unhandledrejection`, which the browser SDK already
+  handles; the hook does not duplicate them.
+- **Server**: fires for every failure the runtime handles or fails on. `kind`/`handling` say which:
+  `render/fallback` (an `<Errored>` rendered its fallback), `render/client` (a `<Loading>` fragment rejected; the
+  client re-renders the subtree), `render/failed` (nothing contained it; the request fails), `render/serialize` (a
+  hydration value would not serialize), `server-function/thrown`, `server-function/channel` (a rejection escaping
+  through a returned promise/iterable/stream after the head committed). `direct: true` marks an in-process
+  server-function call made during SSR.
+- The hook receives the error **as thrown**. The wire — the fallback's serialized error, the RPC error body — gets
+  Solid's sanitized value (a generic `Error` outside dev) unless the hook **returns** a replacement. That return is
+  what `solidServerErrorsIntegration({ mapError })` exposes; the SDK itself never returns one.
+- `ownerPath` is where the error was **thrown** (labels up the owner chain of the computation that threw);
+  `boundaryPath` is where it was **met** (the boundary's own chain). Both only where the runtime keeps owner names —
+  observe and dev; production owners carry none, so in prod these are `undefined` and grouping falls back to the
+  stack.
+- Per-root hooks exist (`render(fn, el, { onError })`, `renderToStream(fn, { onError })`) and win over the ambient
+  one. The SDK uses the ambient one.
+
+### `OBSERVE.records` (observe tier)
+
+One process-wide channel, on both platforms, delivering **completed** records by type:
+
+| Type           | Platform | One per                                           | Joins by                                        |
+| -------------- | -------- | ------------------------------------------------- | ----------------------------------------------- |
+| `"call"`       | client   | server-function call the page made                | `id` with the server's `"invocation"`; `origin` |
+| `"invocation"` | server   | server-function execution (HTTP or direct)        | `id`; `boundary` with the boundary record       |
+| `"boundary"`   | server   | `<Loading>` that waited during a render           | `id` (hydration id); `revealGroup`              |
+| `"frame"`      | both     | frame stream produced (server) / applied (client) | `id` + `version` across the two sides           |
+
+The contract that shapes the integration:
+
+- A record is **plain data**: ids, names, `outcome`, `at`, `durationMs`, counts. Anything live — the request, the
+  response, the arguments, the result, the error as thrown — travels in a second `live` argument to the listener,
+  never on the record. Record attributes never carry values. The integration does not capture `live.error` either:
+  the same error object reaches an error hook (an `<Errored>` fallback, the server hook), and Sentry's once-per-object
+  guard means whichever ran first would win — the record beat the hook and misreported a handled boundary catch as
+  an unhandled crash before the e2e app caught it. Records set span status; hooks report errors.
+- Records arrive **settled**, with `at` on the `performance.now()` clock and durations from it, so spans are built
+  after the fact with explicit `startTime`/`end`. `epochSeconds(at) = (performance.timeOrigin + at) / 1000`.
+- A `"call"` carries `origin`: the engine's interaction/navigation frame, read at dispatch. It is the **same object**
+  the attribution engine puts on its `InteractionEvent`, so a call is joined to the click that made it by identity,
+  not by time (`Tracer.claimCall`).
+- Listeners run **inside the runtime**, synchronously. They must not throw (a throwing listener is reported and does
+  not stop others) and must not write signals — hence every span is built in `queueMicrotask`.
+- Server records are delivered inside the request's async context, so under `@sentry/node` they parent on the active
+  `http.server` span without anything passing a parent around.
+
+### The attribution engine (observe tier, `solid-js/attribution`)
+
+`attribution.enable(options)` installs the engine into the core's single hook slot; `attribution.subscribe(type, fn)`
+delivers `InteractionEvent`, `NavigationEvent`, `HoldEvent` and `RerunEvent` as they settle, bottom-up (a hold before
+the navigation it held, before the interaction that performed it). The SDK uses only those two calls. The engine's
+folds (`costs()`, `feedback()`, `why()`, `subscriptions()`) are named exports the SDK never imports, so they
+tree-shake out of an app that only ships the integration.
+
+- `InteractionEvent`: one per user event the web runtime stamped (`click`, `keydown`, …), with the handler's
+  duration, the writes it made, the re-runs and creations it caused, `settledMs` (dispatch → last effect that traces
+  back to it), and its `holds` and `navigations`. The integration's root span.
+- `NavigationEvent`: declared by the router via `withOrigin` — route pattern as `name`, concrete `to`/`from`,
+  `params`, redirect hops, `outcome`. Router-agnostic: any router that wraps its location write gets these; the SDK
+  has no router code.
+- `HoldEvent`: a write that landed behind async work, with what blocked it, how long, and which affordance
+  acknowledged the wait (`isPending`, `latest`, an optimistic value) or none — Solid's INP-shaped fact.
+- `RerunEvent`: per re-run, `nodeId` (no live node), causes, self-time. The integration folds these into a per-
+  interaction hot list; it never sends one per run.
+- The engine also emits **diagnostics** (`OBSERVE.diagnostics`): `SILENT_HOLD`, `LONG_HOLD`, `HOT_SCOPE_RERUNS`,
+  `ASYNC_WATERFALL`, and the server's `SSR_RENDER_ERROR_CONTAINED`, `SSR_ERROR_SANITIZED`, … A finding is an
+  **issue**, not a span: it has a stable identity and recurs, so the SDK fingerprints it by `[code, ...ownerPath]`.
+  Severity is Solid's: `info` is advisory and not reported by default; `error` findings do not exist in the observe
+  build (they are dev-only checks) except the server's contained-render-error family.
+
+### `OBSERVE.server.trace` (observe tier, server)
+
+`OBSERVE.server.trace.provide(request => TraceContext)` installs one provider, called once per request inside the
+request's async context. Whatever it answers — trace/span ids, `sampled`, and named `entries` — the runtime emits on
+**two carriers** it already owns: a `Server-Timing: traceparent;desc="…"` header on **every** response, and the
+`<meta name="sentry-trace">` / `<meta name="baggage">` pair in an HTML shell. So the browser `pageload` parents under
+the server request with no middleware and no body rewriting, and it works for frame streams and RPC responses that
+have no `<head>` at all (the 1.x `sentryBeforeResponseMiddleware` rewrite was silently a no-op for those).
+
+The provider answers from `getActiveSpan()` / `getTraceData()` and **overrides `parentId`**: the browser sends
+`sentry-trace` and `traceparent` with different span ids, `@sentry/node` continues from the former while the runtime
+derives its parent from the latter; the provider is where Sentry's view wins.
+
+## What the integration decides, and what it does not
+
+- **Sampling** is the SDK's (`tracesSampleRate` / `tracesSampler`). An unsampled session still pays Solid's 1.3 KB
+  wiring, but not the engine's work: `attribution.enable()` is called regardless today — a follow-up can gate it on
+  the sampling decision.
+- **Span topology.** A user interaction is a **root** span (`parentSpan: null`); its navigations, holds and calls are
+  children; a navigation or hold no interaction claims is a root of its own; an orphan navigation whose request time
+  falls inside a settled interaction's handler window gets a span **link** to it rather than a guessed parent. Whether
+  an interaction should instead parent under an active `pageload`/`navigation` idle span is an open product question
+  (`forceTransaction` is deprecated; span streaming makes "root or child" the only distinction).
+- **Calls after the interaction settled.** `onClick={async () => set(await call())}` makes no synchronous write, so
+  the engine settles the interaction as `idle` at once and the call it dispatched lands afterwards — carrying the
+  interaction's frame. It becomes a child of the interaction's (already ended) span by that identity, marked
+  `solid.server_function.after_settle`, rather than a root: the causal tree is right, the timing tells the truth.
+  Whether the engine should keep an interaction open across the handler's returned promise is a Solid-side question.
+- **Mechanism types** follow the `auto.function.solid.*` family; `sentry.origin` is `auto.ui.solid.attribution`,
+  `auto.http.solid.call`, `auto.ui.solid.frame`, `auto.function.solid.server`.
+- **Process-wide channels vs. per-client integrations.** Solid's channels are singletons; the integrations keep an
+  `uninstall` so a second `init()` (tests, HMR) replaces subscriptions instead of stacking them. The `Integration`
+  interface has no teardown hook, so this is module state.
+
+## PII
+
+Solid's records name things — owner paths, `name` options, store paths, route patterns, function ids — and are
+otherwise numbers, kinds and outcomes. The complete list of fields that carry user data is in RFC 08 ("Values in
+records — the PII surface"); what the integration does with each:
+
+| Field                                                 | Content                                             | Integration                                                             |
+| ----------------------------------------------------- | --------------------------------------------------- | ----------------------------------------------------------------------- |
+| `InteractionRef.target` / `ChangeOrigin.target`       | `tag#id "text"` with up to 30 chars of text content | Text stripped from names and attributes unless `targetText: true`       |
+| `ChangeRecord.prev`/`value`, `HeldWrite.prev`/`value` | Value previews (strings cut at 40 chars)            | Never sent — re-runs are folded to names and counts                     |
+| `ChangeOrigin`/`NavigationEvent` `to`/`from`/`params` | Concrete paths and bound params                     | Sent as span attributes (URLs are already in the trace)                 |
+| `DiagnosticEvent.data.error` (server error findings)  | The error as thrown, unsanitized                    | Not forwarded as an extra; the error hook captured it as an exception   |
+| `DiagnosticEvent.data`, `.message` (responsiveness)   | Interaction target, navigation paths                | Forwarded as extras / issue title, target text subject to the same gate |
+
+No `dataCollection` category fits UI text today; `targetText` is the integration's own switch until one exists.
+
+## Where the proofs are
+
+- Unit tests in `packages/solid-2/test` run against the **built observe artifacts** of the published Solid (aliased
+  explicitly — Vitest's resolver always prefers `development`), in jsdom for the client and Node for the server,
+  through the real `BrowserClient`/`NodeClient` under span streaming.
+- The join-by-identity of a call to its interaction, the trace provider answering from a real span, a waiting
+  `<Loading>` becoming a span with its component path, and the thrown-vs-met split are each pinned there.
+- The e2e app (`dev-packages/e2e-tests/test-applications/solid-2`) runs a built `@solidjs/vite-plugin` start-mode
+  app — observe build, server SDK through `start.instrument`, a bare `node:http` host — through Playwright against the
+  packed tarballs and proves what the units cannot: boundary and invocation spans parenting under OTel's
+  `http.server` span, the browser `pageload` continuing the server trace with no middleware, a click's call becoming
+  its child through a real fetch, and both error hooks firing once with component paths.
+
+Two things to know when reading the e2e app's config: the client module imports `@sentry/solid-2/client` explicitly
+because the module is reachable from the server graph (behind an `isServer` guard), where the bare specifier resolves
+to the server half; and the app declares `@sentry/node` as a direct dependency. The plugin inlines this package into
+the server bundle (it consumes the Solid runtime; an externalized copy would load Solid's prod build through Node and
+see no `OBSERVE`), and under pnpm's isolated layout a transitive `@sentry/node` is not resolvable from the app root,
+so Vite bundles it too — where `import-in-the-middle` cannot find itself and logs a registration failure (core-module
+instrumentation still works; the `http.server` spans show it). Declared by the app, `@sentry/node` resolves, is
+externalized, and the warning is gone. Worth a line in the SDK's install docs.
diff --git a/package.json b/package.json
index a25b4dd72738..99d40e43d86e 100644
--- a/package.json
+++ b/package.json
@@ -91,6 +91,7 @@
     "packages/server-runtime-injection",
     "packages/server-utils",
     "packages/solid",
+    "packages/solid-2",
     "packages/solidstart",
     "packages/svelte",
     "packages/sveltekit",
diff --git a/packages/solid-2/LICENSE b/packages/solid-2/LICENSE
new file mode 100644
index 000000000000..63e7eb28e19c
--- /dev/null
+++ b/packages/solid-2/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Functional Software, Inc. dba Sentry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/packages/solid-2/README.md b/packages/solid-2/README.md
new file mode 100644
index 000000000000..4a9a027ed790
--- /dev/null
+++ b/packages/solid-2/README.md
@@ -0,0 +1,111 @@
+<p align="center">
+  <a href="https://sentry.io/?utm_source=github&utm_medium=logo" target="_blank">
+    <img src="https://sentry-brand.storage.googleapis.com/sentry-wordmark-dark-280x84.png" alt="Sentry" width="280" height="84">
+  </a>
+</p>
+
+# Official Sentry SDK for Solid 2
+
+[![npm version](https://img.shields.io/npm/v/@sentry/solid-2.svg)](https://www.npmjs.com/package/@sentry/solid-2)
+[![npm dm](https://img.shields.io/npm/dm/@sentry/solid-2.svg)](https://www.npmjs.com/package/@sentry/solid-2)
+[![npm dt](https://img.shields.io/npm/dt/@sentry/solid-2.svg)](https://www.npmjs.com/package/@sentry/solid-2)
+
+This SDK is for Solid 2 (`solid-js` ^2). For Solid 1.x use [`@sentry/solid`](https://www.npmjs.com/package/@sentry/solid).
+What the runtime exposes and what this package relies on: [docs/solid-2-observe.md](../../docs/solid-2-observe.md).
+
+One package, both halves: the browser SDK (`@sentry/browser`) for the client and the Node SDK (`@sentry/node`) for
+the server, resolved by the `browser`/`node` export conditions, or explicitly as `@sentry/solid-2/client` and
+`@sentry/solid-2/server`. Use the explicit entries in any module both graphs can reach — a client `Sentry.init` behind
+an `isServer` guard is still resolved by the server build, to the server half.
+
+## Server setup
+
+Nothing here depends on how the app is hosted: the integrations read `@solidjs/web` and `solid-js`, which every
+server that renders Solid — the `@solidjs/vite-plugin` handler, an Express or Hono server calling `renderToStream`, a
+worker — already loads. The one requirement is `@sentry/node`'s: `init()` must run before the app's server graph
+loads, so OpenTelemetry can patch `node:http` and friends. Put it in a module of its own and load that first the way
+your host does — `node --import ./instrument.mjs`, or for an app served by the plugin's handler, its
+`start.instrument` option, which awaits the module before anything else in the server graph (a plain `import` at the
+top of an ESM entry is hoisted below the entry's own dependencies and does not work):
+
+```js
+// src/instrument.js — the server's Sentry.init(); nothing else
+import * as Sentry from '@sentry/solid-2/server';
+Sentry.init({ dsn: '__DSN__', tracesSampleRate: 1, integrations: [Sentry.solidServerTracingIntegration()] });
+```
+
+```js
+// vite.config.js
+solid({
+  ssr: true,
+  observe: true, // tracing reads the observe build; errors report in every tier
+  start: { instrument: './src/instrument.js' },
+});
+```
+
+Tracing needs Solid's observe build: the `observe` export condition on every environment, plus the compiler's
+`componentNames` so component labels survive minification. `solid({ observe: true })` sets both; without the plugin,
+set `resolve.conditions` (or `node --conditions=observe` for an unbundled server) and the compiler option yourself.
+
+When the plugin bundles the server, add `@sentry/node` to the app's own dependencies. The plugin inlines this package
+(it consumes the Solid runtime and must see the same copy the app does); with a package manager that isolates
+dependencies, a transitive `@sentry/node` is bundled along with it, where `import-in-the-middle` cannot find itself.
+Declared by the app, it stays external.
+
+## Errors
+
+Solid 2's runtime has an error hook on each platform, in every build tier. `init()` installs it: a rendered
+`<Errored>` fallback in the browser, and on the server an `<Errored>` fallback, a rejected `<Loading>` fragment, a
+server-function throw (HTTP or an in-process call during SSR), a hydration value that would not serialize, and the
+failure that fails a request — each once, with where it was met. Nothing to wrap.
+
+```js
+// client
+import * as Sentry from '@sentry/solid-2';
+Sentry.init({ dsn: '__DSN__' });
+
+// server (before the app loads)
+import * as Sentry from '@sentry/solid-2';
+Sentry.init({
+  dsn: '__DSN__',
+  integrations: [
+    // Optional: decide what the client receives in an error's place.
+    Sentry.solidServerErrorsIntegration({ mapError: (error, context) => new Error(`ref ${context.boundary}`) }),
+  ],
+});
+```
+
+## Tracing
+
+Tracing reads Solid's observe tier — the build the `observe` export condition selects — and is opt-in:
+
+```js
+// client
+Sentry.init({
+  dsn: '__DSN__',
+  tracesSampleRate: 1,
+  integrations: [Sentry.browserTracingIntegration(), Sentry.solidTracingIntegration()],
+});
+
+// server
+Sentry.init({
+  dsn: '__DSN__',
+  tracesSampleRate: 1,
+  integrations: [Sentry.solidServerTracingIntegration()],
+});
+```
+
+- **Client** — one root span per user interaction (`ui.interaction.click`), with the navigations, holds and
+  server-function calls it caused as children; a navigation or hold no interaction claims as its own root span; the
+  runtime's diagnostics (`SILENT_HOLD`, `HOT_SCOPE_RERUNS`, …) as issues fingerprinted by code and component path.
+- **Server** — the runtime carries Sentry's trace to the browser on its own two carriers (`Server-Timing` on every
+  response, the `<meta>` pair in an HTML shell), so a `pageload` parents under the server request with no middleware
+  and no body rewriting; plus one span per server-function execution, per `<Loading>` boundary that waited, and per
+  frame stream produced.
+
+Element text Solid attaches to an interaction's target (`button#next "Next →"`) is user data and left out of span
+names and attributes unless `solidTracingIntegration({ targetText: true })`; the element itself is kept. A finding's
+`data.error` — the error as thrown, on the server error findings — is not forwarded as an issue extra (the error hook
+already captured it as an exception).
+
+Without the observe build the tracing integrations are inert and log once in debug mode; errors still report.
diff --git a/packages/solid-2/package.json b/packages/solid-2/package.json
new file mode 100644
index 000000000000..a9a891c0559e
--- /dev/null
+++ b/packages/solid-2/package.json
@@ -0,0 +1,98 @@
+{
+  "name": "@sentry/solid-2",
+  "version": "10.67.0",
+  "description": "Official Sentry SDK for Solid 2 (client and server)",
+  "repository": "git://github.com/getsentry/sentry-javascript.git",
+  "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/solid-2",
+  "author": "Sentry",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.19.0 <22.0.0 || >=22.12.0 <23.0.0 || >=23.2.0"
+  },
+  "files": [
+    "/build",
+    "/*.d.ts",
+    "/*.d.ts.map"
+  ],
+  "main": "build/cjs/index.server.js",
+  "module": "build/esm/index.server.js",
+  "browser": "build/esm/index.client.js",
+  "types": "build/types/index.types.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./build/types/index.types.d.ts",
+      "browser": {
+        "import": "./build/esm/index.client.js",
+        "require": "./build/cjs/index.client.js"
+      },
+      "node": {
+        "import": "./build/esm/index.server.js",
+        "require": "./build/cjs/index.server.js"
+      },
+      "default": {
+        "import": "./build/esm/index.server.js",
+        "require": "./build/cjs/index.server.js"
+      }
+    },
+    "./client": {
+      "types": "./build/types/client/index.d.ts",
+      "import": "./build/esm/client/index.js",
+      "require": "./build/cjs/client/index.js"
+    },
+    "./server": {
+      "types": "./build/types/server/index.d.ts",
+      "import": "./build/esm/server/index.js",
+      "require": "./build/cjs/server/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@sentry/browser": "10.67.0",
+    "@sentry/core": "10.67.0",
+    "@sentry/node": "10.67.0"
+  },
+  "peerDependencies": {
+    "@solidjs/web": "^2.0.0-rc.9",
+    "solid-js": "^2.0.0-rc.9"
+  },
+  "devDependencies": {
+    "@solidjs/signals": "^2.0.0-rc.9",
+    "@solidjs/web": "^2.0.0-rc.9",
+    "solid-js": "^2.0.0-rc.9"
+  },
+  "scripts": {
+    "build": "run-p build:transpile build:types",
+    "build:dev": "yarn build",
+    "build:transpile": "rollup -c rollup.npm.config.mjs",
+    "build:types": "tsc -p tsconfig.types.json",
+    "build:watch": "run-p build:transpile:watch",
+    "build:dev:watch": "yarn build:watch",
+    "build:transpile:watch": "rollup -c rollup.npm.config.mjs --watch",
+    "build:tarball": "npm pack",
+    "circularDepCheck": "madge --circular src/index.client.ts && madge --circular src/index.server.ts && madge --circular src/index.types.ts",
+    "clean": "rimraf build coverage sentry-solid-2-*.tgz",
+    "lint:fix": "oxlint . --fix --type-aware",
+    "lint": "oxlint . --type-aware",
+    "lint:types": "oxlint src --type-aware --type-check",
+    "lint:es-compatibility": "es-check es2020 ./build/cjs/*.js && es-check es2020 ./build/esm/*.js --module",
+    "test": "vitest run",
+    "test:watch": "vitest --watch",
+    "yalc:publish": "yalc publish --push --sig"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
+  "nx": {
+    "targets": {
+      "build:types": {
+        "outputs": [
+          "{projectRoot}/build/types"
+        ]
+      }
+    }
+  },
+  "sideEffects": false
+}
diff --git a/packages/solid-2/rollup.npm.config.mjs b/packages/solid-2/rollup.npm.config.mjs
new file mode 100644
index 000000000000..90938cd1ed59
--- /dev/null
+++ b/packages/solid-2/rollup.npm.config.mjs
@@ -0,0 +1,10 @@
+import { makeBaseNPMConfig, makeNPMConfigVariants } from '@sentry-internal/rollup-utils';
+
+export default makeNPMConfigVariants(
+  makeBaseNPMConfig({
+    entrypoints: ['src/index.client.ts', 'src/index.server.ts', 'src/client/index.ts', 'src/server/index.ts'],
+    packageSpecificConfig: {
+      external: ['solid-js', 'solid-js/attribution', '@solidjs/web'],
+    },
+  }),
+);
diff --git a/packages/solid-2/src/client/errors.ts b/packages/solid-2/src/client/errors.ts
new file mode 100644
index 000000000000..8d8e325e8670
--- /dev/null
+++ b/packages/solid-2/src/client/errors.ts
@@ -0,0 +1,32 @@
+import { captureException, defineIntegration } from '@sentry/core';
+import { configureClientErrors } from 'solid-js';
+
+const INTEGRATION_NAME = 'SolidErrors';
+
+/**
+ * Reports every error a Solid `<Errored>` boundary catches — the runtime's
+ * client error hook, available in every build tier. Uncaught errors keep
+ * reaching the browser SDK's global handlers; this covers the ones a
+ * fallback swallowed.
+ */
+export const solidErrorsIntegration = defineIntegration(() => {
+  return {
+    name: INTEGRATION_NAME,
+    setup() {
+      configureClientErrors({
+        onError(error, { ownerPath, boundaryPath }) {
+          captureException(error, {
+            mechanism: { type: 'auto.function.solid.error_boundary', handled: true },
+            captureContext: {
+              tags: {
+                'solid.owner': ownerPath?.join(' › '),
+                'solid.boundary': boundaryPath?.join(' › '),
+              },
+              extra: { 'solid.ownerPath': ownerPath, 'solid.boundaryPath': boundaryPath },
+            },
+          });
+        },
+      });
+    },
+  };
+});
diff --git a/packages/solid-2/src/client/index.ts b/packages/solid-2/src/client/index.ts
new file mode 100644
index 000000000000..1fb6e060c43a
--- /dev/null
+++ b/packages/solid-2/src/client/index.ts
@@ -0,0 +1,7 @@
+export * from '@sentry/browser';
+
+export { init, getDefaultIntegrations } from './sdk';
+export { solidErrorsIntegration } from './errors';
+export { solidTracingIntegration } from './tracing';
+export type { SolidTracingOptions } from './tracing';
+export type { DiagnosticsOptions } from '../common/diagnostics';
diff --git a/packages/solid-2/src/client/records.ts b/packages/solid-2/src/client/records.ts
new file mode 100644
index 000000000000..2d4ce8a82b54
--- /dev/null
+++ b/packages/solid-2/src/client/records.ts
@@ -0,0 +1,76 @@
+import type { Span } from '@sentry/core';
+import { startInactiveSpan } from '@sentry/core';
+import type { CallEvent, CallLive, FrameEvent, FrameLive } from '@solidjs/web';
+import { describeOrigin } from '../common/target';
+import { epochSeconds, round } from '../common/time';
+
+const CALL_ORIGIN = 'auto.http.solid.call';
+const FRAME_ORIGIN = 'auto.ui.solid.frame';
+
+/**
+ * One span per server-function call the page made, as the caller awaited it:
+ * the twin of the server's `"invocation"` span (same `id`; the difference is
+ * the wire). The browser SDK's own `http.client` span for the fetch is the
+ * transport's view — this one is the runtime's, includes decode, and knows
+ * the function rather than the URL. A failed call sets the span's status
+ * only: the error itself reaches the caller, and whatever catches it there
+ * (an `<Errored>`, the server error hook on the other side) reports it once.
+ */
+export function callSpan(
+  event: CallEvent,
+  _live: CallLive,
+  parent: Span | null,
+  keepText: boolean,
+  afterSettle = false,
+): Span {
+  const origin = event.origin;
+  const span = startInactiveSpan({
+    name: event.id,
+    op: 'function.solid.call',
+    parentSpan: parent,
+    startTime: epochSeconds(event.at),
+    attributes: {
+      'solid.server_function.id': event.id,
+      'solid.server_function.method': event.method,
+      'solid.server_function.outcome': event.outcome,
+      'solid.server_function.deferred': event.deferred === true,
+      'solid.server_function.origin': origin ? describeOrigin(origin, keepText) : undefined,
+      'solid.server_function.origin.kind': origin?.kind,
+      'http.response.status_code': event.status,
+      'solid.server_function.after_settle': afterSettle ? true : undefined,
+      'sentry.origin': CALL_ORIGIN,
+    },
+  });
+  if (event.outcome === 'error') {
+    span.setStatus({ code: 2, message: event.status !== undefined ? `http ${event.status}` : 'network_error' });
+  }
+  span.end(epochSeconds(event.at + event.durationMs));
+  return span;
+}
+
+/** One span per frame stream the server-component transport applied, with the chunk census. */
+export function frameSpan(event: FrameEvent, _live: FrameLive): void {
+  if (event.side !== 'client') return;
+  const span = startInactiveSpan({
+    name: event.id || 'frame',
+    op: 'solid.frame.apply',
+    startTime: epochSeconds(event.at),
+    attributes: {
+      'solid.frame.id': event.id,
+      'solid.frame.address': event.address,
+      'solid.frame.version': event.version,
+      'solid.frame.outcome': event.outcome,
+      'solid.frame.shellMs': event.shellMs === undefined ? undefined : round(event.shellMs),
+      'solid.frame.chunks': event.chunks,
+      'solid.frame.fragments': event.fragments,
+      'solid.frame.slots': event.slots,
+      'solid.frame.regions': event.regions,
+      'solid.frame.errors': event.errors,
+      'sentry.origin': FRAME_ORIGIN,
+    },
+  });
+  if (event.outcome !== 'complete') {
+    span.setStatus({ code: 2, message: event.outcome });
+  }
+  span.end(epochSeconds(event.at + event.durationMs));
+}
diff --git a/packages/solid-2/src/client/sdk.ts b/packages/solid-2/src/client/sdk.ts
new file mode 100644
index 000000000000..d857feb030a6
--- /dev/null
+++ b/packages/solid-2/src/client/sdk.ts
@@ -0,0 +1,27 @@
+import type { BrowserOptions } from '@sentry/browser';
+import { getDefaultIntegrations as getBrowserDefaultIntegrations, init as browserInit } from '@sentry/browser';
+import type { Client, Integration } from '@sentry/core';
+import { applySdkMetadata } from '@sentry/core';
+import { solidErrorsIntegration } from './errors';
+
+/** Initializes the browser half of the Solid 2 SDK. */
+export function init(options: BrowserOptions): Client | undefined {
+  const opts = {
+    defaultIntegrations: getDefaultIntegrations(options),
+    ...options,
+  };
+
+  applySdkMetadata(opts, 'solid-2', ['solid-2', 'browser']);
+
+  return browserInit(opts);
+}
+
+/**
+ * The browser SDK's defaults plus Solid's error hook: a rendered `<Errored>`
+ * fallback reports in every build tier without wrapping anything. Tracing
+ * (`solidTracingIntegration`) is opt-in, like `browserTracingIntegration`,
+ * and needs the `observe` build.
+ */
+export function getDefaultIntegrations(options: BrowserOptions): Integration[] {
+  return [...getBrowserDefaultIntegrations(options), solidErrorsIntegration()];
+}
diff --git a/packages/solid-2/src/client/tracing.ts b/packages/solid-2/src/client/tracing.ts
new file mode 100644
index 000000000000..4ac3392a2b0f
--- /dev/null
+++ b/packages/solid-2/src/client/tracing.ts
@@ -0,0 +1,288 @@
+import type { Span, SpanContextData, SpanLink } from '@sentry/core';
+import { debug, defineIntegration, startInactiveSpan } from '@sentry/core';
+import type { CallEvent, CallLive } from '@solidjs/web';
+import { OBSERVE } from 'solid-js';
+import type {
+  AttributionOptions,
+  ChangeOrigin,
+  HoldEvent,
+  InteractionEvent,
+  NavigationEvent,
+  RerunEvent,
+} from 'solid-js/attribution';
+import { attribution } from 'solid-js/attribution';
+import type { DiagnosticsOptions } from '../common/diagnostics';
+import { captureDiagnostic } from '../common/diagnostics';
+import { describeOrigin, describeTarget } from '../common/target';
+import { epochSeconds, round } from '../common/time';
+import { DEBUG_BUILD } from '../debug-build';
+import { callSpan, frameSpan } from './records';
+
+const INTEGRATION_NAME = 'SolidTracing';
+const ORIGIN = 'auto.ui.solid.attribution';
+
+let uninstall: (() => void) | undefined;
+
+export interface SolidTracingOptions {
+  /**
+   * Options for Solid's attribution engine (`attribution.enable`). `log` is
+   * always off — the SDK is the consumer, not the console.
+   */
+  attribution?: Omit<AttributionOptions, 'log'>;
+  /** Report the runtime's diagnostics as issues (default on, `warn` and up). `false` disables. */
+  diagnostics?: DiagnosticsOptions | false;
+  /**
+   * Spans for the runtime's own records — server-function calls and applied
+   * frame streams (default on).
+   */
+  records?: boolean;
+  /**
+   * Keep the element text Solid puts in an interaction's target
+   * (`button#next "Next →"`, up to 30 characters) in span names and
+   * attributes. Off by default — the text of a `<td>` a user clicked is user
+   * data; the element alone (`button#next`) is kept either way.
+   */
+  targetText?: boolean;
+}
+
+/**
+ * Traces from Solid 2's observe tier: one root span per user interaction
+ * with its navigations, holds and server-function calls as children; a
+ * navigation or hold no interaction claims as a root span of its own; the
+ * runtime's diagnostics as issues. Records arrive settled, with an absolute
+ * `at` and durations, so every span is built retroactively with explicit
+ * start and end times. Inert on a build without `OBSERVE` (production
+ * without the `observe` condition): errors still report through
+ * `solidErrorsIntegration`.
+ */
+export const solidTracingIntegration = defineIntegration((options: SolidTracingOptions = {}) => {
+  return {
+    name: INTEGRATION_NAME,
+    setup() {
+      if (OBSERVE === undefined) {
+        DEBUG_BUILD && debug.warn('solidTracingIntegration: solid-js is not an observe build; no traces');
+        return;
+      }
+      // Solid's channels are process-wide, not per client: a second `init`
+      // (tests, HMR) replaces the previous subscriptions rather than stacking.
+      uninstall?.();
+      const tracer = new Tracer(options.targetText === true);
+      attribution.enable({ historyLimit: 200, ...options.attribution, log: false });
+      const off = [
+        attribution.subscribe('rerun', event => tracer.rerun(event)),
+        attribution.subscribe('interaction', event => queueMicrotask(() => tracer.interaction(event))),
+        attribution.subscribe('navigation', event => {
+          if (event.interaction === undefined) queueMicrotask(() => tracer.orphanNavigation(event));
+        }),
+        attribution.subscribe('hold', event => {
+          if (event.interaction === undefined && event.origin?.kind !== 'navigation') {
+            queueMicrotask(() => holdSpan(event, null, tracer.keepText));
+          }
+        }),
+      ];
+      if (options.diagnostics !== false) {
+        const diagnosticsOptions = options.diagnostics;
+        off.push(
+          OBSERVE.diagnostics.subscribe(event => queueMicrotask(() => captureDiagnostic(event, diagnosticsOptions))),
+        );
+      }
+      if (options.records !== false) {
+        off.push(
+          OBSERVE.records.subscribe('call', (event, live) => {
+            if (tracer.claimCall(event, live)) return;
+            queueMicrotask(() => callSpan(event, live, null, tracer.keepText));
+          }),
+          OBSERVE.records.subscribe('frame', (event, live) => {
+            if (event.side === 'client') queueMicrotask(() => frameSpan(event, live));
+          }),
+        );
+      }
+      uninstall = () => {
+        for (const fn of off) fn();
+        uninstall = undefined;
+      };
+    },
+  };
+});
+
+const isSilent = (hold: HoldEvent): boolean => hold.acknowledgements.length === 0 && hold.paintedDuringHold === 0;
+
+function holdSpan(hold: HoldEvent, parent: Span | null, keepText: boolean): Span {
+  const span = startInactiveSpan({
+    name: `hold${hold.blockers.length ? ` waiting on ${hold.blockers.join(', ')}` : ''}`,
+    op: 'solid.hold',
+    parentSpan: parent,
+    startTime: epochSeconds(hold.at),
+    attributes: {
+      'solid.hold.ms': round(hold.holdMs),
+      'solid.hold.tailMs': round(hold.tailMs),
+      'solid.hold.flushes': hold.flushes,
+      'solid.hold.silent': isSilent(hold),
+      'solid.hold.acknowledgedBy': hold.acknowledgements.map(a => `${a.kind}:${a.source}`),
+      'solid.hold.readers': hold.acknowledgements.flatMap(a => (a.reader ? [a.reader.join(' › ')] : [])),
+      'solid.hold.blockers': hold.blockers,
+      'solid.hold.heldWrites': hold.heldWrites.map(w => w.name),
+      'solid.hold.painted': hold.paintedDuringHold,
+      'solid.hold.action': hold.action,
+      'solid.hold.navigation': hold.origin ? describeOrigin(hold.origin, keepText) : undefined,
+      'sentry.origin': ORIGIN,
+    },
+  });
+  span.end(epochSeconds(hold.at + hold.holdMs));
+  return span;
+}
+
+function navigationSpan(nav: NavigationEvent, parent: Span | null, keepText: boolean, links?: SpanLink[]): Span {
+  const attributes: Record<string, string | number | boolean | string[] | undefined> = {
+    'solid.navigation.to': nav.to,
+    'solid.navigation.from': nav.from,
+    'solid.navigation.outcome': nav.outcome,
+    'solid.navigation.writes': nav.writes,
+    'solid.navigation.redirects': nav.redirects?.map(h => h.to ?? h.name ?? '?'),
+    'solid.navigation.silent': nav.hold !== undefined && isSilent(nav.hold),
+    'sentry.origin': ORIGIN,
+  };
+  for (const [key, value] of Object.entries(nav.params ?? {})) {
+    if (value !== undefined) attributes[`url.path.parameter.${key}`] = value;
+  }
+  const span = startInactiveSpan({
+    name: nav.name ?? nav.to ?? 'navigation',
+    op: 'navigation',
+    parentSpan: parent,
+    startTime: epochSeconds(nav.at),
+    attributes,
+    links,
+  });
+  if (nav.hold !== undefined) holdSpan(nav.hold, span, keepText);
+  span.end(epochSeconds(nav.at + (nav.settledMs ?? 0)));
+  return span;
+}
+
+interface RecentInteraction {
+  at: number;
+  until: number;
+  context: SpanContextData;
+}
+const RECENT_LIMIT = 50;
+
+class Tracer {
+  /** Self-time per node name for each open interaction — the record has totals, not the breakdown. */
+  private readonly _hot: WeakMap<ChangeOrigin, Map<string, number>>;
+  private readonly _settled: WeakSet<ChangeOrigin>;
+  /** The root span each settled interaction became — the parent for work it caused after its window closed. */
+  private readonly _spans: WeakMap<ChangeOrigin, Span>;
+  /** Server-function calls dispatched under an interaction still open, awaiting its segment. */
+  private readonly _calls: WeakMap<ChangeOrigin, Array<{ event: CallEvent; live: CallLive }>>;
+  /** Settled interactions kept for the time join, newest last. */
+  private readonly _recent: RecentInteraction[];
+
+  public constructor(public readonly keepText: boolean) {
+    this._hot = new WeakMap();
+    this._settled = new WeakSet();
+    this._spans = new WeakMap();
+    this._calls = new WeakMap();
+    this._recent = [];
+  }
+
+  public rerun(event: RerunEvent): void {
+    const origin = event.interaction;
+    // Runs after settle (an async landing behind a Loading boundary) are the record's, not its wait.
+    if (origin === undefined || this._settled.has(origin)) return;
+    let hot = this._hot.get(origin);
+    if (hot === undefined) this._hot.set(origin, (hot = new Map()));
+    hot.set(event.nodeName, (hot.get(event.nodeName) ?? 0) + event.selfMs);
+  }
+
+  /**
+   * A call whose `origin` is an interaction is the interaction's, joined by
+   * the engine's object identity rather than by time. Made while the
+   * interaction is still open, it is held for the interaction's span; made
+   * after the interaction settled — the usual shape of `onClick={async () =>
+   * set(await call())}`, where the handler's synchronous window closes long
+   * before the call lands — it becomes a child of that span at once, marked
+   * `after_settle`. Only a call with no interaction at all is a root span.
+   */
+  public claimCall(event: CallEvent, live: CallLive): boolean {
+    const origin = event.origin;
+    const interaction = origin === undefined ? undefined : origin.kind === 'interaction' ? origin : origin.interaction;
+    if (interaction === undefined) return false;
+    if (this._settled.has(interaction)) {
+      const parent = this._spans.get(interaction);
+      if (parent === undefined) return false;
+      queueMicrotask(() => callSpan(event, live, parent, this.keepText, true));
+      return true;
+    }
+    let calls = this._calls.get(interaction);
+    if (calls === undefined) this._calls.set(interaction, (calls = []));
+    calls.push({ event, live });
+    return true;
+  }
+
+  public interaction(event: InteractionEvent): void {
+    const { origin } = event;
+    this._settled.add(origin);
+    const span = startInactiveSpan({
+      name: describeOrigin(origin, this.keepText),
+      op: `ui.interaction.${event.name}`,
+      parentSpan: null,
+      startTime: epochSeconds(event.at),
+      attributes: {
+        'solid.interaction.type': event.name,
+        'solid.interaction.target': describeTarget(event.target, this.keepText),
+        'solid.interaction.outcome': event.outcome,
+        'solid.interaction.handlerMs': round(event.handlerMs),
+        'solid.interaction.writes': event.writes,
+        'solid.reruns': event.runs,
+        'solid.created': event.created,
+        'solid.runMs': round(event.runMs),
+        'solid.hot': this._hotList(origin),
+        'solid.holds': event.holds.length,
+        'solid.navigations': event.navigations.length,
+        'sentry.origin': ORIGIN,
+      },
+    });
+    const underNavigation = new Set<HoldEvent>();
+    for (const nav of event.navigations) {
+      if (nav.hold !== undefined) underNavigation.add(nav.hold);
+      navigationSpan(nav, span, this.keepText);
+    }
+    for (const hold of event.holds) if (!underNavigation.has(hold)) holdSpan(hold, span, this.keepText);
+    const calls = this._calls.get(origin);
+    if (calls !== undefined) {
+      this._calls.delete(origin);
+      for (const call of calls) callSpan(call.event, call.live, span, this.keepText);
+    }
+    span.end(epochSeconds(event.at + (event.settledMs ?? event.handlerMs)));
+    this._spans.set(origin, span);
+    this._recent.push({ at: event.at, until: event.at + event.handlerMs, context: span.spanContext() });
+    if (this._recent.length > RECENT_LIMIT) this._recent.shift();
+  }
+
+  /**
+   * A navigation the engine could not stamp with an interaction: a router
+   * that publishes in a later task, or a programmatic `navigate()`. If its
+   * request time sits inside a settled interaction's handler window, that
+   * click is its cause — the two traces are linked rather than a parent guessed.
+   */
+  public orphanNavigation(nav: NavigationEvent): void {
+    let cause: RecentInteraction | undefined;
+    for (let i = this._recent.length - 1; i >= 0 && cause === undefined; i--) {
+      const r = this._recent[i]!;
+      if (nav.at >= r.at && nav.at <= r.until) cause = r;
+    }
+    const links: SpanLink[] | undefined = cause
+      ? [{ context: cause.context, attributes: { 'solid.link': 'interaction-by-time' } }]
+      : undefined;
+    navigationSpan(nav, null, this.keepText, links);
+  }
+
+  private _hotList(origin: ChangeOrigin): string[] {
+    const hot = this._hot.get(origin);
+    this._hot.delete(origin);
+    if (hot === undefined) return [];
+    return [...hot]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 8)
+      .map(([name, ms]) => `${name} ${ms.toFixed(2)}ms`);
+  }
+}
diff --git a/packages/solid-2/src/common/diagnostics.ts b/packages/solid-2/src/common/diagnostics.ts
new file mode 100644
index 000000000000..71c4d7027f81
--- /dev/null
+++ b/packages/solid-2/src/common/diagnostics.ts
@@ -0,0 +1,52 @@
+import type { SeverityLevel } from '@sentry/core';
+import { captureEvent } from '@sentry/core';
+import type { DiagnosticEvent } from 'solid-js';
+
+const LEVEL: Record<DiagnosticEvent['severity'], SeverityLevel> = {
+  info: 'info',
+  warn: 'warning',
+  error: 'error',
+};
+
+export interface DiagnosticsOptions {
+  /**
+   * Minimum severity to report as an issue. `info` findings are advisory in
+   * Solid's own tiering (structured channel only, never the console); the
+   * default reports `warn` and up.
+   */
+  minSeverity?: DiagnosticEvent['severity'];
+}
+
+/**
+ * A finding's `data`, as the issue's extras. `data.error` — the value as
+ * thrown, unsanitized, on the server error findings — is left out: the error
+ * hook already captured it as an exception, and an extras object is not
+ * where an error's own properties should travel.
+ */
+function extras(event: DiagnosticEvent): Record<string, unknown> {
+  const { error: _error, ...data } = event.data ?? {};
+  return { ...data, ownerPath: event.ownerPath, message: event.message };
+}
+
+const RANK: Record<DiagnosticEvent['severity'], number> = { info: 0, warn: 1, error: 2 };
+
+/**
+ * A finding is an issue, not a span: it has a stable identity and recurs.
+ * Fingerprinted by code + owner path so every occurrence of "the pager holds
+ * silently" groups into one issue across sessions and minified identifiers.
+ */
+export function captureDiagnostic(event: DiagnosticEvent, options: DiagnosticsOptions = {}): void {
+  if (RANK[event.severity] < RANK[options.minSeverity ?? 'warn']) return;
+  captureEvent({
+    message: event.message.split('\n')[0],
+    level: LEVEL[event.severity],
+    fingerprint: [event.code, ...(event.ownerPath ?? (event.nodeName ? [event.nodeName] : []))],
+    tags: {
+      'solid.code': event.code,
+      'solid.kind': event.kind,
+      'solid.node': event.nodeName,
+      'solid.owner': event.ownerPath?.join(' › '),
+    },
+    extra: extras(event),
+  });
+}
diff --git a/packages/solid-2/src/common/target.ts b/packages/solid-2/src/common/target.ts
new file mode 100644
index 000000000000..b5376e2ad880
--- /dev/null
+++ b/packages/solid-2/src/common/target.ts
@@ -0,0 +1,18 @@
+import type { ChangeOrigin } from 'solid-js/attribution';
+import { formatOrigin } from 'solid-js/attribution';
+
+/**
+ * Solid describes the element an interaction hit as `tag#id "text"`, with up
+ * to 30 characters of its text content — a button's label, but also whatever
+ * a `<td>` said. The text is user data; unless the SDK is told to keep it,
+ * only the element stays: `button#next`.
+ */
+export function describeTarget(target: string | undefined, keepText: boolean): string | undefined {
+  return target === undefined || keepText ? target : target.replace(/ "[^"]*"$/, '');
+}
+
+/** `formatOrigin`, with target text handled the same way wherever an origin is named. */
+export function describeOrigin(origin: ChangeOrigin, keepText: boolean): string {
+  const text = formatOrigin(origin);
+  return keepText ? text : text.replace(/ "[^"]*"(?=[)\s]|$)/g, '');
+}
diff --git a/packages/solid-2/src/common/time.ts b/packages/solid-2/src/common/time.ts
new file mode 100644
index 000000000000..bd8eb06e98a5
--- /dev/null
+++ b/packages/solid-2/src/common/time.ts
@@ -0,0 +1,11 @@
+/**
+ * Every `at` Solid's runtime and attribution engine emit is on the
+ * `performance.now()` clock; Sentry spans take epoch seconds.
+ */
+export function epochSeconds(perfNow: number): number {
+  return (performance.timeOrigin + perfNow) / 1000;
+}
+
+export function round(ms: number): number {
+  return Math.round(ms * 100) / 100;
+}
diff --git a/packages/solid-2/src/debug-build.ts b/packages/solid-2/src/debug-build.ts
new file mode 100644
index 000000000000..60aa50940582
--- /dev/null
+++ b/packages/solid-2/src/debug-build.ts
@@ -0,0 +1,8 @@
+declare const __DEBUG_BUILD__: boolean;
+
+/**
+ * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.
+ *
+ * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.
+ */
+export const DEBUG_BUILD = __DEBUG_BUILD__;
diff --git a/packages/solid-2/src/index.client.ts b/packages/solid-2/src/index.client.ts
new file mode 100644
index 000000000000..4f1cce44fa36
--- /dev/null
+++ b/packages/solid-2/src/index.client.ts
@@ -0,0 +1 @@
+export * from './client';
diff --git a/packages/solid-2/src/index.server.ts b/packages/solid-2/src/index.server.ts
new file mode 100644
index 000000000000..0ce5251aa327
--- /dev/null
+++ b/packages/solid-2/src/index.server.ts
@@ -0,0 +1 @@
+export * from './server';
diff --git a/packages/solid-2/src/index.types.ts b/packages/solid-2/src/index.types.ts
new file mode 100644
index 000000000000..55baabff069f
--- /dev/null
+++ b/packages/solid-2/src/index.types.ts
@@ -0,0 +1,39 @@
+// We export everything from both the client part of the SDK and from the server part.
+// Some of the exports collide, which is not allowed, unless we redefine the colliding
+// exports in this file - which we do below.
+import type { Client, Integration, Options, StackParser } from '@sentry/core';
+import type * as clientSdk from './client';
+import type * as serverSdk from './server';
+
+export * from './client';
+export * from './server';
+
+/** Initializes Sentry Solid 2 SDK */
+export declare function init(options: Options | clientSdk.BrowserOptions | serverSdk.NodeOptions): Client | undefined;
+
+export declare const linkedErrorsIntegration: typeof clientSdk.linkedErrorsIntegration;
+export declare const consoleIntegration: typeof serverSdk.consoleIntegration;
+export declare const contextLinesIntegration: typeof clientSdk.contextLinesIntegration;
+export declare const startSpan: typeof clientSdk.startSpan;
+export declare const startSpanManual: typeof clientSdk.startSpanManual;
+export declare const startInactiveSpan: typeof clientSdk.startInactiveSpan;
+export declare const withStaticSpan: typeof clientSdk.withStaticSpan;
+// oxlint-disable-next-line typescript/no-deprecated
+export declare const withStreamedSpan: typeof clientSdk.withStreamedSpan;
+
+export declare const getDefaultIntegrations: (options: Options) => Integration[];
+export declare const defaultStackParser: StackParser;
+
+export declare function close(timeout?: number): PromiseLike<boolean>;
+export declare function flush(timeout?: number): PromiseLike<boolean>;
+export declare function lastEventId(): string | undefined;
+
+export declare const logger: typeof clientSdk.logger | typeof serverSdk.logger;
+
+export declare const growthbookIntegration: typeof clientSdk.growthbookIntegration;
+export declare const launchDarklyIntegration: typeof clientSdk.launchDarklyIntegration;
+export declare const buildLaunchDarklyFlagUsedHandler: typeof clientSdk.buildLaunchDarklyFlagUsedHandler;
+export declare const openFeatureIntegration: typeof clientSdk.openFeatureIntegration;
+export declare const OpenFeatureIntegrationHook: typeof clientSdk.OpenFeatureIntegrationHook;
+export declare const statsigIntegration: typeof clientSdk.statsigIntegration;
+export declare const unleashIntegration: typeof clientSdk.unleashIntegration;
diff --git a/packages/solid-2/src/server/errors.ts b/packages/solid-2/src/server/errors.ts
new file mode 100644
index 000000000000..2cb68ad7f821
--- /dev/null
+++ b/packages/solid-2/src/server/errors.ts
@@ -0,0 +1,55 @@
+import { captureException, defineIntegration } from '@sentry/core';
+import type { ServerErrorContext } from '@solidjs/web';
+import { configureServerErrors } from '@solidjs/web';
+
+const INTEGRATION_NAME = 'SolidServerErrors';
+
+export interface SolidServerErrorsOptions {
+  /**
+   * Map an error to what the client receives in its place — rendered into
+   * the fallback, serialized for hydration, sent as the RPC error. Return
+   * nothing for Solid's default wire policy (a generic error outside the dev
+   * build). Solid does not sanitize a returned value again.
+   */
+  mapError?: (error: unknown, context: ServerErrorContext) => unknown | void;
+}
+
+/**
+ * Reports every failure Solid's server runtime handles or fails on, once per
+ * error object, with where it was met: an `<Errored>` fallback rendered, a
+ * `<Loading>` fragment rejected, a server-function throw (HTTP dispatch or an
+ * in-process call during SSR), a hydration value that would not serialize,
+ * the failure that fails a request. The error as thrown — the wire gets the
+ * sanitized one. Available in every build tier.
+ */
+export const solidServerErrorsIntegration = defineIntegration((options: SolidServerErrorsOptions = {}) => {
+  return {
+    name: INTEGRATION_NAME,
+    setup() {
+      configureServerErrors({
+        onError(error, context) {
+          const { kind, handling, boundary, boundaryPath, functionId, direct, ownerPath } = context;
+          captureException(error, {
+            mechanism: {
+              type: `auto.function.solid.server.${kind}.${handling}`,
+              handled: handling !== 'failed',
+            },
+            captureContext: {
+              tags: {
+                'solid.kind': kind,
+                'solid.handling': handling,
+                'solid.boundary': boundary,
+                'solid.function': functionId,
+                'solid.direct': direct === undefined ? undefined : String(direct),
+                'solid.owner': ownerPath?.join(' › '),
+                'solid.boundary_path': boundaryPath?.join(' › '),
+              },
+              extra: { 'solid.ownerPath': ownerPath, 'solid.boundaryPath': boundaryPath },
+            },
+          });
+          return options.mapError?.(error, context);
+        },
+      });
+    },
+  };
+});
diff --git a/packages/solid-2/src/server/index.ts b/packages/solid-2/src/server/index.ts
new file mode 100644
index 000000000000..998ae0f638b3
--- /dev/null
+++ b/packages/solid-2/src/server/index.ts
@@ -0,0 +1,8 @@
+export * from '@sentry/node';
+
+export { init, getDefaultIntegrations } from './sdk';
+export { solidServerErrorsIntegration } from './errors';
+export type { SolidServerErrorsOptions } from './errors';
+export { solidServerTracingIntegration } from './tracing';
+export type { SolidServerTracingOptions } from './tracing';
+export type { DiagnosticsOptions } from '../common/diagnostics';
diff --git a/packages/solid-2/src/server/sdk.ts b/packages/solid-2/src/server/sdk.ts
new file mode 100644
index 000000000000..e5185a931947
--- /dev/null
+++ b/packages/solid-2/src/server/sdk.ts
@@ -0,0 +1,26 @@
+import type { Integration } from '@sentry/core';
+import { applySdkMetadata } from '@sentry/core';
+import type { NodeClient, NodeOptions } from '@sentry/node';
+import { getDefaultIntegrations as getNodeDefaultIntegrations, init as initNodeSdk } from '@sentry/node';
+import { solidServerErrorsIntegration } from './errors';
+
+/** Initializes the server half of the Solid 2 SDK. */
+export function init(options: NodeOptions): NodeClient | undefined {
+  const opts = {
+    defaultIntegrations: getDefaultIntegrations(options),
+    ...options,
+  };
+
+  applySdkMetadata(opts, 'solid-2', ['solid-2', 'node']);
+
+  return initNodeSdk(opts);
+}
+
+/**
+ * The Node SDK's defaults plus Solid's server error hook: every failure the
+ * server runtime handles reports in every build tier. Tracing
+ * (`solidServerTracingIntegration`) is opt-in and needs the `observe` build.
+ */
+export function getDefaultIntegrations(options: NodeOptions): Integration[] {
+  return [...getNodeDefaultIntegrations(options), solidServerErrorsIntegration()];
+}
diff --git a/packages/solid-2/src/server/tracing.ts b/packages/solid-2/src/server/tracing.ts
new file mode 100644
index 000000000000..91a992ca26d8
--- /dev/null
+++ b/packages/solid-2/src/server/tracing.ts
@@ -0,0 +1,149 @@
+import type { Span } from '@sentry/core';
+import { debug, defineIntegration, getActiveSpan, getTraceData, spanToJSON, startInactiveSpan } from '@sentry/core';
+import type { FrameEvent, FrameLive, InvocationEvent, InvocationLive, TraceContext } from '@solidjs/web';
+import type { BoundaryEvent, BoundaryLive } from 'solid-js';
+import { OBSERVE } from 'solid-js';
+import type { DiagnosticsOptions } from '../common/diagnostics';
+import { captureDiagnostic } from '../common/diagnostics';
+import { epochSeconds } from '../common/time';
+import { DEBUG_BUILD } from '../debug-build';
+
+const INTEGRATION_NAME = 'SolidServerTracing';
+const ORIGIN = 'auto.function.solid.server';
+
+let uninstall: (() => void) | undefined;
+
+export interface SolidServerTracingOptions {
+  /** Report the runtime's server diagnostics as issues (default on, `warn` and up). `false` disables. */
+  diagnostics?: DiagnosticsOptions | false;
+}
+
+/**
+ * The server half of Solid 2 tracing, all through `OBSERVE`: the trace
+ * provider that lets the runtime carry Sentry's trace to the browser on its
+ * own two carriers (`Server-Timing` on every response, the `<meta>` pair in
+ * an HTML shell — no middleware, no body rewriting, works for frames and RPC
+ * responses that have no `<head>`), and one span per server-function
+ * execution, per `<Loading>` boundary that waited, and per frame stream
+ * produced — each delivered inside the request's async context, so they
+ * parent on the active `http.server` span. Inert without `OBSERVE`.
+ */
+export const solidServerTracingIntegration = defineIntegration((options: SolidServerTracingOptions = {}) => {
+  return {
+    name: INTEGRATION_NAME,
+    setup() {
+      if (OBSERVE === undefined) {
+        DEBUG_BUILD && debug.warn('solidServerTracingIntegration: solid-js is not an observe build; no traces');
+        return;
+      }
+      // Solid's slots are process-wide, not per client: a second `init`
+      // replaces the previous provider and subscriptions rather than stacking.
+      uninstall?.();
+      const off = [
+        OBSERVE.server.trace.provide(traceProvider),
+        OBSERVE.records.subscribe('invocation', invocationSpan),
+        OBSERVE.records.subscribe('boundary', boundarySpan),
+        OBSERVE.records.subscribe('frame', (event, live) => {
+          if (event.side === 'server') frameSpan(event, live);
+        }),
+      ];
+      if (options.diagnostics !== false) {
+        const diagnosticsOptions = options.diagnostics;
+        off.push(OBSERVE.diagnostics.subscribe(event => captureDiagnostic(event, diagnosticsOptions)));
+      }
+      uninstall = () => {
+        for (const fn of off) fn();
+        uninstall = undefined;
+      };
+    },
+  };
+});
+
+/**
+ * Called by the runtime once per request, inside the request's async
+ * context, where the `http.server` span is active. The parent is overridden
+ * too: the browser sends `sentry-trace` and `traceparent` with different span
+ * ids, `@sentry/node` continues from the former while the runtime derives
+ * its parent from the latter — here Sentry's view wins.
+ */
+function traceProvider(): Partial<TraceContext> | undefined {
+  const span = getActiveSpan();
+  if (!span) return undefined;
+  const context = span.spanContext();
+  const data = getTraceData();
+  const entries: Record<string, string> = {};
+  if (data['sentry-trace']) entries['sentry-trace'] = data['sentry-trace'];
+  if (data.baggage) entries.baggage = data.baggage;
+  return {
+    traceId: context.traceId,
+    spanId: context.spanId,
+    parentId: spanToJSON(span).parent_span_id,
+    sampled: context.traceFlags % 2 === 1,
+    entries,
+  };
+}
+
+function invocationSpan(event: InvocationEvent, _live: InvocationLive): Span {
+  const start = epochSeconds(event.at);
+  const span = startInactiveSpan({
+    name: event.id,
+    op: event.direct ? 'function.solid.direct' : 'function.solid.rpc',
+    startTime: start,
+    attributes: {
+      'solid.server_function.id': event.id,
+      'solid.server_function.direct': event.direct,
+      'solid.server_function.deferred': event.deferred === true,
+      'solid.server_function.outcome': event.outcome,
+      'solid.server_function.boundary': event.boundary,
+      'sentry.origin': ORIGIN,
+    },
+  });
+  // Status only: the server error hook already captured the throw, once,
+  // with where it was met (`solidServerErrorsIntegration`).
+  if (event.outcome === 'error') span.setStatus({ code: 2, message: 'internal_error' });
+  span.end(epochSeconds(event.at + event.durationMs));
+  return span;
+}
+
+function boundarySpan(event: BoundaryEvent, _live: BoundaryLive): Span {
+  const span = startInactiveSpan({
+    name: event.ownerPath ? event.ownerPath.join(' › ') : `boundary ${event.id}`,
+    op: 'solid.boundary',
+    startTime: epochSeconds(event.at),
+    attributes: {
+      'solid.boundary.id': event.id,
+      'solid.boundary.outcome': event.outcome,
+      'solid.boundary.passes': event.passes,
+      'solid.boundary.streamed': event.streamed,
+      'solid.boundary.heldMs': event.heldMs,
+      'solid.boundary.revealGroup': event.revealGroup,
+      'sentry.origin': ORIGIN,
+    },
+  });
+  if (event.outcome === 'error') span.setStatus({ code: 2, message: 'internal_error' });
+  span.end(epochSeconds(event.at + event.durationMs + event.heldMs));
+  return span;
+}
+
+function frameSpan(event: FrameEvent, _live: FrameLive): Span {
+  const span = startInactiveSpan({
+    name: event.id || 'frame',
+    op: 'solid.frame.produce',
+    startTime: epochSeconds(event.at),
+    attributes: {
+      'solid.frame.id': event.id,
+      'solid.frame.version': event.version,
+      'solid.frame.outcome': event.outcome,
+      'solid.frame.shellMs': event.shellMs,
+      'solid.frame.chunks': event.chunks,
+      'solid.frame.fragments': event.fragments,
+      'solid.frame.slots': event.slots,
+      'solid.frame.regions': event.regions,
+      'solid.frame.errors': event.errors,
+      'sentry.origin': ORIGIN,
+    },
+  });
+  if (event.outcome === 'error') span.setStatus({ code: 2, message: 'internal_error' });
+  span.end(epochSeconds(event.at + event.durationMs));
+  return span;
+}
diff --git a/packages/solid-2/test/client/errors.test.ts b/packages/solid-2/test/client/errors.test.ts
new file mode 100644
index 000000000000..17d040918c18
--- /dev/null
+++ b/packages/solid-2/test/client/errors.test.ts
@@ -0,0 +1,82 @@
+/**
+ * @vitest-environment jsdom
+ */
+import type { Event } from '@sentry/core';
+import { createTransport, getCurrentScope, setCurrentClient } from '@sentry/core';
+import { render } from '@solidjs/web';
+import { createComponent, createMemo, createSignal, flush } from 'solid-js';
+import { Errored } from 'solid-js';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { BrowserClient, solidErrorsIntegration } from '../../src/client';
+import { DEV, OBSERVE } from 'solid-js';
+
+function clientWith(events: Event[]): BrowserClient {
+  const client = new BrowserClient({
+    dsn: 'https://public@dsn.ingest.sentry.io/1337',
+    integrations: [solidErrorsIntegration()],
+    transport: () => createTransport({ recordDroppedEvent: () => undefined }, _ => Promise.resolve({})),
+    stackParser: () => [],
+    beforeSend: event => {
+      events.push(event);
+      return null;
+    },
+  });
+  setCurrentClient(client);
+  client.init();
+  return client;
+}
+
+describe('solidErrorsIntegration', () => {
+  beforeEach(() => {
+    getCurrentScope().setClient(undefined);
+  });
+
+  it('runs against the observe build of solid-js', () => {
+    expect(OBSERVE).toBeDefined();
+    expect(DEV).toBeUndefined();
+  });
+
+  it('reports what an <Errored> boundary catches, once, with the component labels', async () => {
+    const events: Event[] = [];
+    const client = clientWith(events);
+    const [fail, setFail] = createSignal(false);
+    const boom = new Error('widget exploded');
+
+    const Widget = () => {
+      const view = createMemo(
+        () => {
+          if (fail()) throw boom;
+          return 'ok';
+        },
+        { name: 'view' },
+      );
+      return createMemo(() => view());
+    };
+    const App = () =>
+      createComponent(Errored, {
+        fallback: () => 'fallback',
+        get children() {
+          return createComponent(Widget, {}, 'Widget');
+        },
+      });
+
+    const container = document.createElement('div');
+    const dispose = render(() => createComponent(App, {}, 'App'), container);
+    flush();
+    setFail(true);
+    flush();
+    await client.flush(100);
+
+    expect(events).toHaveLength(1);
+    const event = events[0]!;
+    expect(event.exception?.values?.[0]).toMatchObject({
+      value: 'widget exploded',
+      mechanism: { type: 'auto.function.solid.error_boundary', handled: true },
+    });
+    // Where it broke, apart from where it was met.
+    expect(event.tags?.['solid.owner']).toBe('<App> › <Errored> › computed › <Widget> › view');
+    expect(event.tags?.['solid.boundary']).toBe('<App> › <Errored>');
+    expect(event.extra?.['solid.boundaryPath']).toEqual(['<App>', '<Errored>']);
+    dispose();
+  });
+});
diff --git a/packages/solid-2/test/client/tracing.test.ts b/packages/solid-2/test/client/tracing.test.ts
new file mode 100644
index 000000000000..abc9d7a4e39c
--- /dev/null
+++ b/packages/solid-2/test/client/tracing.test.ts
@@ -0,0 +1,309 @@
+/**
+ * @vitest-environment jsdom
+ */
+import type { Event, StreamedSpanJSON } from '@sentry/core';
+import { createTransport, getCurrentScope, setCurrentClient, spanStreamingIntegration } from '@sentry/core';
+import { OBSERVE, createEffect, createRoot, createSignal, flush } from 'solid-js';
+import { attribution } from 'solid-js/attribution';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { BrowserClient, solidTracingIntegration } from '../../src/client';
+import type { SolidTracingOptions } from '../../src/client';
+
+interface Captured {
+  events: Event[];
+  spans: StreamedSpanJSON[];
+}
+
+function clientWith(options?: SolidTracingOptions): { client: BrowserClient; captured: Captured } {
+  const captured: Captured = { events: [], spans: [] };
+  const client = new BrowserClient({
+    dsn: 'https://public@dsn.ingest.sentry.io/1337',
+    tracesSampleRate: 1,
+    integrations: [spanStreamingIntegration(), solidTracingIntegration(options)],
+    transport: () => createTransport({ recordDroppedEvent: () => undefined }, _ => Promise.resolve({})),
+    stackParser: () => [],
+    beforeSend: event => {
+      captured.events.push(event);
+      return null;
+    },
+    beforeSendSpan: span => {
+      captured.spans.push(span);
+      return span;
+    },
+  });
+  setCurrentClient(client);
+  client.init();
+  return { client, captured };
+}
+
+const settle = () => new Promise(resolve => setTimeout(resolve, 0));
+
+function readerApp(): { setCount: (n: number) => void; dispose: () => void } {
+  const [count, setCount] = createSignal(0, { name: 'count' });
+  const dispose = createRoot(dispose => {
+    createEffect(count, () => {}, { name: 'reader' });
+    return dispose;
+  });
+  flush();
+  return { setCount, dispose };
+}
+
+describe('solidTracingIntegration', () => {
+  beforeEach(() => {
+    getCurrentScope().setClient(undefined);
+  });
+  afterEach(() => {
+    attribution.disable();
+    flush();
+  });
+
+  it('turns a user interaction into a segment with the navigation it performed as a child', async () => {
+    const { client, captured } = clientWith();
+    expect(OBSERVE!.attribution.installed).not.toBeNull();
+    const app = readerApp();
+
+    OBSERVE!.attribution.withInteraction({ type: 'click', target: 'button#next "Next"' }, () =>
+      OBSERVE!.attribution.withOrigin(
+        { kind: 'navigation', name: '/users/:id', to: '/users/42', from: '/', params: { id: '42' } },
+        () => app.setCount(1),
+      ),
+    );
+    flush();
+    await settle();
+    await client.flush(100);
+
+    const segment = captured.spans.find(span => span.is_segment);
+    expect(segment).toBeDefined();
+    // Element text is user data: off by default, the element stays.
+    expect(segment).toMatchObject({
+      name: 'click on button#next',
+      attributes: expect.objectContaining({
+        'sentry.op': 'ui.interaction.click',
+        'solid.interaction.type': 'click',
+        'solid.interaction.target': 'button#next',
+        'solid.interaction.writes': 1,
+        'solid.navigations': 1,
+        'sentry.origin': 'auto.ui.solid.attribution',
+      }),
+    });
+    expect(segment!.attributes['solid.reruns']).toBeGreaterThanOrEqual(1);
+    expect(segment!.attributes['solid.hot']).toEqual(expect.arrayContaining([expect.stringMatching(/^reader /)]));
+
+    const nav = captured.spans.find(span => span.attributes['sentry.op'] === 'navigation');
+    expect(nav).toMatchObject({
+      name: '/users/:id',
+      parent_span_id: segment!.span_id,
+      trace_id: segment!.trace_id,
+      attributes: expect.objectContaining({
+        'solid.navigation.to': '/users/42',
+        'solid.navigation.from': '/',
+        'solid.navigation.outcome': 'committed',
+        'url.path.parameter.id': '42',
+      }),
+    });
+    // Backdated to the engine's clock: the segment starts at dispatch, not when the record settled.
+    expect(segment!.start_timestamp).toBeLessThanOrEqual(nav!.start_timestamp);
+    expect(nav!.end_timestamp!).toBeLessThanOrEqual(segment!.end_timestamp!);
+    app.dispose();
+  });
+
+  it('targetText keeps the element text in names and attributes', async () => {
+    const { client, captured } = clientWith({ targetText: true });
+    const app = readerApp();
+    OBSERVE!.attribution.withInteraction({ type: 'click', target: 'button#next "Next"' }, () => app.setCount(1));
+    flush();
+    await settle();
+    await client.flush(100);
+    const segment = captured.spans.find(span => span.is_segment);
+    expect(segment?.name).toBe('click on button#next "Next"');
+    expect(segment?.attributes['solid.interaction.target']).toBe('button#next "Next"');
+    app.dispose();
+  });
+
+  it("a server-function call made under an interaction is the interaction's child, joined by identity", async () => {
+    const { client, captured } = clientWith();
+    const app = readerApp();
+    const live = { args: [1], response: new Response(''), result: 'ok' };
+
+    OBSERVE!.attribution.withInteraction({ type: 'click', target: 'button#save' }, () => {
+      app.setCount(1);
+      // What the server-function client does at dispatch: the record carries
+      // the engine's own interaction frame, read while the handler runs.
+      const origin = OBSERVE!.attribution.currentOrigin();
+      OBSERVE!.records.emit(
+        'call',
+        { id: 'saveTodo', method: 'POST', at: performance.now(), durationMs: 12, outcome: 'ok', status: 200, origin },
+        live,
+      );
+    });
+    flush();
+    await settle();
+    await client.flush(100);
+
+    const segment = captured.spans.find(span => span.is_segment);
+    const call = captured.spans.find(span => span.attributes['sentry.op'] === 'function.solid.call');
+    expect(segment).toBeDefined();
+    expect(call).toMatchObject({
+      name: 'saveTodo',
+      parent_span_id: segment!.span_id,
+      trace_id: segment!.trace_id,
+      attributes: expect.objectContaining({
+        'solid.server_function.method': 'POST',
+        'solid.server_function.outcome': 'ok',
+        'solid.server_function.origin.kind': 'interaction',
+        'http.response.status_code': 200,
+        'sentry.origin': 'auto.http.solid.call',
+      }),
+    });
+    app.dispose();
+  });
+
+  it("a call that lands after its interaction settled is still the interaction's child, marked after_settle", async () => {
+    const { client, captured } = clientWith();
+    const app = readerApp();
+    let origin: ReturnType<typeof OBSERVE.attribution.currentOrigin>;
+
+    // `onClick={async () => set(await call())}`: the handler makes no
+    // synchronous write, so the interaction settles as `idle` at once…
+    OBSERVE!.attribution.withInteraction({ type: 'click', target: 'button#save' }, () => {
+      origin = OBSERVE!.attribution.currentOrigin();
+    });
+    flush();
+    await settle();
+    // …and the call it dispatched lands later, carrying that frame.
+    OBSERVE!.records.emit(
+      'call',
+      { id: 'saveTodo', method: 'POST', at: performance.now(), durationMs: 12, outcome: 'ok', status: 200, origin },
+      { args: [1], response: new Response(''), result: 'ok' },
+    );
+    await settle();
+    await client.flush(100);
+
+    const segment = captured.spans.find(
+      span => span.is_segment && span.attributes['sentry.op'] === 'ui.interaction.click',
+    );
+    const call = captured.spans.find(span => span.attributes['sentry.op'] === 'function.solid.call');
+    expect(segment).toBeDefined();
+    expect(call).toMatchObject({
+      parent_span_id: segment!.span_id,
+      attributes: expect.objectContaining({ 'solid.server_function.after_settle': true }),
+    });
+    expect(call!.start_timestamp).toBeGreaterThanOrEqual(segment!.end_timestamp!);
+    app.dispose();
+  });
+
+  it('a call with no interaction, and a failed one, are root spans; a failure is status only', async () => {
+    const { client, captured } = clientWith();
+    const boom = new Error('server said no');
+    OBSERVE!.records.emit(
+      'call',
+      { id: 'loadFeed', method: 'GET', at: performance.now(), durationMs: 40, outcome: 'ok', status: 200 },
+      { args: [], response: new Response(''), result: [] },
+    );
+    OBSERVE!.records.emit(
+      'call',
+      { id: 'deleteTodo', method: 'POST', at: performance.now(), durationMs: 8, outcome: 'error', status: 500 },
+      { args: [7], response: new Response('', { status: 500 }), error: boom },
+    );
+    await settle();
+    await client.flush(100);
+
+    const roots = captured.spans.filter(span => span.is_segment);
+    expect(roots.map(span => span.name).sort()).toEqual(['deleteTodo', 'loadFeed']);
+    const failed = roots.find(span => span.name === 'deleteTodo')!;
+    expect(failed.status).toBe('error');
+    // The error reached the caller; whatever catches it there reports it. Not here.
+    expect(captured.events).toEqual([]);
+  });
+
+  it('an applied frame stream is a span with its chunk census; a truncated one is an error', async () => {
+    const { client, captured } = clientWith();
+    const base = { version: 1, chunks: 5, fragments: 2, slots: 1, regions: 0, errors: 0, durationMs: 30 };
+    OBSERVE!.records.emit(
+      'frame',
+      {
+        ...base,
+        side: 'client',
+        id: 'Comments',
+        address: 'f0',
+        at: performance.now(),
+        shellMs: 4,
+        outcome: 'complete',
+      },
+      { response: new Response('') },
+    );
+    OBSERVE!.records.emit(
+      'frame',
+      { ...base, side: 'client', id: 'Sidebar', at: performance.now(), outcome: 'truncated' },
+      { response: new Response('') },
+    );
+    await settle();
+    await client.flush(100);
+
+    const frames = captured.spans.filter(span => span.attributes['sentry.op'] === 'solid.frame.apply');
+    expect(frames.map(span => span.name).sort()).toEqual(['Comments', 'Sidebar']);
+    const complete = frames.find(span => span.name === 'Comments')!;
+    expect(complete.attributes).toMatchObject({
+      'solid.frame.address': 'f0',
+      'solid.frame.chunks': 5,
+      'solid.frame.fragments': 2,
+      'solid.frame.shellMs': 4,
+      'sentry.origin': 'auto.ui.solid.frame',
+    });
+    expect(frames.find(span => span.name === 'Sidebar')!.status).toBe('error');
+  });
+
+  it('a navigation no interaction claims is its own segment', async () => {
+    const { client, captured } = clientWith();
+    const app = readerApp();
+
+    OBSERVE!.attribution.withOrigin({ kind: 'navigation', name: '/about', to: '/about' }, () => app.setCount(1));
+    flush();
+    await settle();
+    await client.flush(100);
+
+    const segments = captured.spans.filter(span => span.is_segment);
+    expect(segments).toHaveLength(1);
+    expect(segments[0]).toMatchObject({
+      name: '/about',
+      attributes: expect.objectContaining({ 'sentry.op': 'navigation' }),
+    });
+    app.dispose();
+  });
+
+  it('reports the runtime diagnostics as issues fingerprinted by code and owner', async () => {
+    const { client, captured } = clientWith({ attribution: { hotRuns: { count: 3, windowMs: 10_000 } } });
+    const app = readerApp();
+
+    for (let i = 1; i <= 6; i++) {
+      app.setCount(i);
+      flush();
+    }
+    await settle();
+    await client.flush(100);
+
+    const issue = captured.events.find(event => event.tags?.['solid.code'] === 'HOT_SCOPE_RERUNS');
+    expect(issue).toBeDefined();
+    expect(issue!.level).toBe('warning');
+    expect(issue!.fingerprint?.[0]).toBe('HOT_SCOPE_RERUNS');
+    expect(issue!.message).toContain('HOT_SCOPE_RERUNS');
+    expect(issue!.tags?.['solid.node']).toBe('reader');
+    app.dispose();
+  });
+
+  it('with diagnostics off, findings stay on the channel', async () => {
+    const { client, captured } = clientWith({
+      diagnostics: false,
+      attribution: { hotRuns: { count: 3, windowMs: 10_000 } },
+    });
+    const app = readerApp();
+    for (let i = 1; i <= 6; i++) {
+      app.setCount(i);
+      flush();
+    }
+    await settle();
+    await client.flush(100);
+    expect(captured.events).toEqual([]);
+    app.dispose();
+  });
+});
diff --git a/packages/solid-2/test/server/errors.test.ts b/packages/solid-2/test/server/errors.test.ts
new file mode 100644
index 000000000000..e834473d2ef4
--- /dev/null
+++ b/packages/solid-2/test/server/errors.test.ts
@@ -0,0 +1,132 @@
+import type { Event } from '@sentry/core';
+import { createTransport, getCurrentScope, setCurrentClient } from '@sentry/core';
+import { NodeClient } from '@sentry/node';
+import { Errored, renderToString } from '@solidjs/web';
+import { createComponent } from 'solid-js';
+import { beforeEach, describe, expect, it } from 'vitest';
+import type { SolidServerErrorsOptions } from '../../src/server';
+import { solidServerErrorsIntegration } from '../../src/server';
+
+function clientWith(events: Event[], options?: SolidServerErrorsOptions): NodeClient {
+  const client = new NodeClient({
+    dsn: 'https://public@dsn.ingest.sentry.io/1337',
+    integrations: [solidServerErrorsIntegration(options)],
+    transport: () => createTransport({ recordDroppedEvent: () => undefined }, _ => Promise.resolve({})),
+    stackParser: () => [],
+    beforeSend: event => {
+      events.push(event);
+      return null;
+    },
+  });
+  setCurrentClient(client);
+  client.init();
+  return client;
+}
+
+const fallback = (err: () => unknown) => String((err() as Error).message);
+
+function throwingApp(error: unknown): () => unknown {
+  return () =>
+    createComponent(
+      () =>
+        createComponent(
+          Errored,
+          {
+            fallback,
+            get children() {
+              throw error;
+            },
+          },
+          'Errored',
+        ),
+      {},
+      'App',
+    );
+}
+
+describe('solidServerErrorsIntegration', () => {
+  beforeEach(() => {
+    getCurrentScope().setClient(undefined);
+  });
+
+  it('reports the error as thrown when an <Errored> renders its fallback, with where it was met', async () => {
+    const events: Event[] = [];
+    const client = clientWith(events);
+    const boom = Object.assign(new Error('connect ECONNREFUSED postgres://app:hunter2@db'), {
+      connectionString: 'postgres://app:hunter2@db',
+    });
+
+    const html = renderToString(throwingApp(boom));
+    await client.flush(100);
+
+    // The wire gets Solid's default policy (generic outside dev); Sentry gets the real one.
+    expect(html).not.toContain('hunter2');
+    expect(events).toHaveLength(1);
+    const event = events[0]!;
+    expect(event.exception?.values?.[0]).toMatchObject({
+      value: 'connect ECONNREFUSED postgres://app:hunter2@db',
+      mechanism: { type: 'auto.function.solid.server.render.fallback', handled: true },
+    });
+    // Thrown in the boundary's own children getter here, so the two coincide.
+    expect(event.tags).toMatchObject({
+      'solid.kind': 'render',
+      'solid.handling': 'fallback',
+      'solid.owner': '<App> › <Errored>',
+      'solid.boundary_path': '<App> › <Errored>',
+    });
+    expect(event.tags?.['solid.boundary']).toEqual(expect.any(String));
+  });
+
+  it('names the component that threw apart from the boundary that met it', async () => {
+    const events: Event[] = [];
+    const client = clientWith(events);
+    const App = () =>
+      createComponent(
+        Errored,
+        {
+          fallback,
+          get children() {
+            return createComponent(
+              () => {
+                throw new Error('bad render');
+              },
+              {},
+              'Bad',
+            );
+          },
+        },
+        'Errored',
+      );
+    renderToString(() => createComponent(App, {}, 'App'));
+    await client.flush(100);
+
+    expect(events[0]?.tags).toMatchObject({
+      'solid.owner': '<App> › <Errored> › <Bad>',
+      'solid.boundary_path': '<App> › <Errored>',
+    });
+  });
+
+  it('mapError decides what the client receives in the error’s place', async () => {
+    const events: Event[] = [];
+    const client = clientWith(events, {
+      mapError: (error, { kind }) => new Error(`${kind} failed (ref ${(error as Error).message.length})`),
+    });
+
+    const html = renderToString(throwingApp(new Error('secret detail')));
+    await client.flush(100);
+
+    expect(html).toContain('render failed (ref 13)');
+    expect(html).not.toContain('secret detail');
+    expect(events[0]?.exception?.values?.[0]?.value).toBe('secret detail');
+  });
+
+  it('reports once per error object', async () => {
+    const events: Event[] = [];
+    const client = clientWith(events);
+    const boom = new Error('once');
+    renderToString(throwingApp(boom));
+    renderToString(throwingApp(boom));
+    await client.flush(100);
+    expect(events).toHaveLength(1);
+  });
+});
diff --git a/packages/solid-2/test/server/tracing.test.ts b/packages/solid-2/test/server/tracing.test.ts
new file mode 100644
index 000000000000..fb9aebbdcd47
--- /dev/null
+++ b/packages/solid-2/test/server/tracing.test.ts
@@ -0,0 +1,227 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { Event, StreamedSpanJSON } from '@sentry/core';
+import {
+  createTransport,
+  getCurrentScope,
+  setCurrentClient,
+  spanStreamingIntegration,
+  spanToJSON,
+  startSpan,
+} from '@sentry/core';
+import { NodeClient } from '@sentry/node';
+import type { RequestEvent } from '@solidjs/web';
+import { createRequestEvent, getTraceContext, Loading, renderToStream } from '@solidjs/web';
+import { OBSERVE, createComponent, createMemo } from 'solid-js';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { solidServerTracingIntegration } from '../../src/server';
+
+// The runtime finds the request scope on this storage — what a host wires up.
+const RequestContext = Symbol.for('solid.RequestContext');
+let storage: AsyncLocalStorage<RequestEvent>;
+beforeAll(() => {
+  storage = new AsyncLocalStorage();
+  (globalThis as Record<symbol, unknown>)[RequestContext] = storage;
+});
+afterAll(() => {
+  Reflect.deleteProperty(globalThis, RequestContext);
+});
+
+interface Captured {
+  events: Event[];
+  spans: StreamedSpanJSON[];
+}
+
+function clientWith(): { client: NodeClient; captured: Captured } {
+  const captured: Captured = { events: [], spans: [] };
+  const client = new NodeClient({
+    dsn: 'https://public@dsn.ingest.sentry.io/1337',
+    tracesSampleRate: 1,
+    integrations: [spanStreamingIntegration(), solidServerTracingIntegration()],
+    transport: () => createTransport({ recordDroppedEvent: () => undefined }, _ => Promise.resolve({})),
+    stackParser: () => [],
+    beforeSend: event => {
+      captured.events.push(event);
+      return null;
+    },
+    beforeSendSpan: span => {
+      captured.spans.push(span);
+      return span;
+    },
+  });
+  setCurrentClient(client);
+  client.init();
+  return { client, captured };
+}
+
+function stream(code: () => unknown): Promise<string> {
+  return new Promise(resolve => {
+    const chunks: string[] = [];
+    renderToStream(code).pipe({
+      write(chunk: string) {
+        chunks.push(chunk);
+      },
+      end() {
+        resolve(chunks.join(''));
+      },
+    });
+  });
+}
+
+const inRequest = <T>(fn: () => T): T =>
+  storage.run(createRequestEvent(new Request('https://app.example/users/42')), fn);
+
+describe('solidServerTracingIntegration', () => {
+  beforeEach(() => {
+    getCurrentScope().setClient(undefined);
+  });
+  afterEach(() => {
+    getCurrentScope().setClient(undefined);
+  });
+
+  it('runs against the observe build of solid-js', () => {
+    expect(OBSERVE).toBeDefined();
+  });
+
+  it("answers the runtime's trace provider from the active span, sentry-trace and baggage included", () => {
+    clientWith();
+    const { ctx, span } = inRequest(() =>
+      startSpan({ name: 'GET /users/:id', op: 'http.server' }, span => ({
+        ctx: getTraceContext()!,
+        span: spanToJSON(span),
+      })),
+    );
+    expect(ctx.traceId).toBe(span.trace_id);
+    expect(ctx.spanId).toBe(span.span_id);
+    expect(ctx.sampled).toBe(true);
+    expect(ctx.entries['sentry-trace']).toBe(`${span.trace_id}-${span.span_id}-1`);
+    expect(ctx.entries.baggage).toContain(`sentry-trace_id=${span.trace_id}`);
+    // The runtime's own W3C entry follows Sentry's ids.
+    expect(ctx.entries.traceparent).toBe(`00-${span.trace_id}-${span.span_id}-01`);
+  });
+
+  it('server-function executions are spans; a failed one is status only — the error hook reports it', async () => {
+    const { client, captured } = clientWith();
+    const boom = new Error('connect ECONNREFUSED postgres://app:hunter2@db');
+    const at = performance.now();
+    OBSERVE!.records.emit(
+      'invocation',
+      { id: 'loadFeed', direct: false, at, durationMs: 22, outcome: 'ok' },
+      { event: {} as never, args: [] },
+    );
+    OBSERVE!.records.emit(
+      'invocation',
+      { id: 'saveTodo', direct: true, at, durationMs: 3, outcome: 'error', boundary: '0-1', deferred: true },
+      { event: {} as never, args: [1], error: boom },
+    );
+    await client.flush(100);
+
+    const spans = captured.spans.filter(span => span.name === 'loadFeed' || span.name === 'saveTodo');
+    expect(spans).toHaveLength(2);
+    expect(spans.find(span => span.name === 'loadFeed')?.attributes).toMatchObject({
+      'sentry.op': 'function.solid.rpc',
+      'solid.server_function.direct': false,
+      'solid.server_function.outcome': 'ok',
+      'sentry.origin': 'auto.function.solid.server',
+    });
+    const failed = spans.find(span => span.name === 'saveTodo')!;
+    expect(failed.status).toBe('error');
+    expect(failed.attributes).toMatchObject({
+      'sentry.op': 'function.solid.direct',
+      'solid.server_function.boundary': '0-1',
+      'solid.server_function.deferred': true,
+    });
+    // Status only: the server error hook is the one path an error takes to Sentry.
+    expect(captured.events).toEqual([]);
+  });
+
+  it('a produced frame stream is a span with its census; the client half is left to the browser', async () => {
+    const { client, captured } = clientWith();
+    const base = { version: 1, chunks: 7, fragments: 3, slots: 2, regions: 1, errors: 0, durationMs: 18 };
+    OBSERVE!.records.emit(
+      'frame',
+      { ...base, side: 'server', id: 'Comments', at: performance.now(), shellMs: 2, outcome: 'complete' },
+      {},
+    );
+    OBSERVE!.records.emit(
+      'frame',
+      { ...base, side: 'client', id: 'Comments', at: performance.now(), outcome: 'complete' },
+      { response: new Response('') },
+    );
+    await client.flush(100);
+
+    const frames = captured.spans.filter(span => span.attributes['sentry.op'] === 'solid.frame.produce');
+    expect(frames).toHaveLength(1);
+    expect(frames[0]!.attributes).toMatchObject({
+      'solid.frame.id': 'Comments',
+      'solid.frame.regions': 1,
+      'solid.frame.shellMs': 2,
+      'sentry.origin': 'auto.function.solid.server',
+    });
+    expect(captured.spans.some(span => span.attributes['sentry.op'] === 'solid.frame.apply')).toBe(false);
+  });
+
+  it("a server finding's extras carry its data without the thrown error itself", async () => {
+    const { client, captured } = clientWith();
+    const boom = new Error('secret detail');
+    OBSERVE!.diagnostics.emit(
+      {
+        code: 'SSR_RENDER_ERROR_CONTAINED',
+        kind: 'ssr',
+        severity: 'error',
+        message: '[SSR_RENDER_ERROR_CONTAINED] Render error caught by <Errored>: Error: secret detail',
+        ownerPath: ['<App>', '<Errored>', '<Bad>'],
+        data: { handling: 'fallback', boundary: '0', boundaryPath: ['<App>', '<Errored>'], error: boom },
+      },
+      null,
+    );
+    await client.flush(100);
+
+    const issue = captured.events.find(event => event.tags?.['solid.code'] === 'SSR_RENDER_ERROR_CONTAINED');
+    expect(issue).toBeDefined();
+    expect(issue!.fingerprint).toEqual(['SSR_RENDER_ERROR_CONTAINED', '<App>', '<Errored>', '<Bad>']);
+    expect(issue!.extra).toMatchObject({ handling: 'fallback', boundary: '0', boundaryPath: ['<App>', '<Errored>'] });
+    expect(issue!.extra).not.toHaveProperty('error');
+  });
+
+  it('a <Loading> boundary that waited during the render becomes a span', async () => {
+    const { client, captured } = clientWith();
+    let release!: (value: string) => void;
+    const data = new Promise<string>(resolve => (release = resolve));
+
+    const Slow = () => {
+      const value = createMemo(() => data);
+      return createMemo(() => value());
+    };
+    const App = () =>
+      createComponent(
+        Loading,
+        {
+          fallback: 'loading',
+          get children() {
+            return createComponent(Slow, {}, 'Slow');
+          },
+        },
+        'Loading',
+      );
+
+    const html = inRequest(() => stream(() => createComponent(App, {}, 'App')));
+    await new Promise(resolve => setTimeout(resolve, 5));
+    release('ready');
+    expect(await html).toContain('ready');
+    await client.flush(100);
+
+    const boundary = captured.spans.find(span => span.attributes['sentry.op'] === 'solid.boundary');
+    expect(boundary).toBeDefined();
+    expect(boundary).toMatchObject({
+      name: '<App> › <Loading>',
+      attributes: expect.objectContaining({
+        'solid.boundary.outcome': 'settled',
+        'solid.boundary.streamed': true,
+        'sentry.origin': 'auto.function.solid.server',
+      }),
+    });
+    expect(boundary!.attributes['solid.boundary.passes']).toBeGreaterThanOrEqual(1);
+    // Backdated: the span covers the wait, on the record's clock.
+    expect(boundary!.end_timestamp! - boundary!.start_timestamp).toBeGreaterThan(0.004);
+  });
+});
diff --git a/packages/solid-2/test/tsconfig.json b/packages/solid-2/test/tsconfig.json
new file mode 100644
index 000000000000..38ca0b13bcdd
--- /dev/null
+++ b/packages/solid-2/test/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../tsconfig.test.json"
+}
diff --git a/packages/solid-2/tsconfig.json b/packages/solid-2/tsconfig.json
new file mode 100644
index 000000000000..fd54f069790c
--- /dev/null
+++ b/packages/solid-2/tsconfig.json
@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+
+  "include": ["src/**/*"],
+
+  "compilerOptions": {
+    "lib": ["DOM", "es2020"]
+  }
+}
diff --git a/packages/solid-2/tsconfig.test.json b/packages/solid-2/tsconfig.test.json
new file mode 100644
index 000000000000..9c723e1802ac
--- /dev/null
+++ b/packages/solid-2/tsconfig.test.json
@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+
+  "include": ["test/**/*", "vite.config.ts"],
+
+  "compilerOptions": {
+    "types": ["vite/client"]
+  }
+}
diff --git a/packages/solid-2/tsconfig.types.json b/packages/solid-2/tsconfig.types.json
new file mode 100644
index 000000000000..5e5cc814cbec
--- /dev/null
+++ b/packages/solid-2/tsconfig.types.json
@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+    "outDir": "build/types",
+    "rootDir": "./src"
+  }
+}
diff --git a/packages/solid-2/vite.config.ts b/packages/solid-2/vite.config.ts
new file mode 100644
index 000000000000..d43b0c8c7219
--- /dev/null
+++ b/packages/solid-2/vite.config.ts
@@ -0,0 +1,58 @@
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { defineConfig } from 'vitest/config';
+import baseConfig from '../../vite/vite.config';
+
+// Solid ships three build tiers behind export conditions (`development`,
+// `observe`, default = production). The SDK's tracing integrations need the
+// `observe` tier; Vite's resolver always prefers `development` in test mode,
+// so the tier is pinned by aliasing each package to its observe artifact —
+// the same files for the SDK and for Solid's own internal imports, so every
+// module sees one instance. Two projects: the browser and server halves are
+// different artifacts of the same packages.
+const require = createRequire(join(__dirname, 'package.json'));
+/** The install root of a package as this package resolves it (Solid 1.x lives at the workspace root for @sentry/solid). */
+function packageRoot(pkg: string): string {
+  let dir = dirname(require.resolve(pkg));
+  while (!existsSync(join(dir, 'package.json'))) dir = dirname(dir);
+  return dir;
+}
+const solidJs = packageRoot('solid-js');
+const web = packageRoot('@solidjs/web');
+const signals = packageRoot('@solidjs/signals');
+
+function project(name: string, platform: 'browser' | 'server', environment: string) {
+  const alias = [
+    { find: /^solid-js$/, replacement: `${solidJs}/dist/${platform === 'browser' ? 'solid' : 'server'}.observe.js` },
+    { find: /^solid-js\/attribution$/, replacement: `${solidJs}/dist/attribution.js` },
+    { find: /^solid-js\/internal$/, replacement: `${solidJs}/dist/internal.js` },
+    {
+      find: /^@solidjs\/web$/,
+      replacement: `${web}/dist/${platform === 'browser' ? 'web' : 'server'}.observe.js`,
+    },
+    { find: /^@solidjs\/signals$/, replacement: `${signals}/dist/observe/index.js` },
+    { find: /^@solidjs\/signals\/attribution$/, replacement: `${signals}/dist/observe/attribution.js` },
+  ];
+  return {
+    extends: true as const,
+    resolve: { alias },
+    test: {
+      name,
+      environment,
+      include: [`test/${name}/**/*.test.ts`],
+      // Keep Solid inside Vite's pipeline (where the aliases apply) rather
+      // than Node's loader: a package Node loads natively beside one Vite
+      // inlines is two module instances, two `OBSERVE`s.
+      server: { deps: { inline: [/solid-js/, /@solidjs/] } },
+    },
+  };
+}
+
+export default defineConfig({
+  ...baseConfig,
+  test: {
+    ...baseConfig.test,
+    projects: [project('client', 'browser', 'jsdom'), project('server', 'server', 'node')],
+  },
+});
diff --git a/yarn.lock b/yarn.lock
index e66adedac544..99d4464a2be7 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -8731,6 +8731,11 @@
   resolved "https://registry.yarnpkg.com/@solidjs/router/-/router-1.0.0.tgz#9e4e5d6dbdeb725e8e4a9b5a3c7158c39fff096f"
   integrity sha512-cCSk1hvgCowiMa9bzzYWHiLu1U4E22+DfJe6/rOwAyECKrxc3jrd5QnoW3sDDJtW+e077cz/M67bPl3DqOBw1Q==
 
+"@solidjs/signals@^2.0.0-rc.9":
+  version "2.0.0-rc.9"
+  resolved "https://registry.yarnpkg.com/@solidjs/signals/-/signals-2.0.0-rc.9.tgz#2140db06574f917ec35ce590f3420bd37a05c9b5"
+  integrity sha512-o3pqiTgpH5NR2DstiKrt9s/6+0YOFtv+MfvLONwLsS247I+EWMMyTu9BkRcgd35UR5Pa1DM16lI1/5uaIMY6Gw==
+
 "@solidjs/start@^1.3.2":
   version "1.3.2"
   resolved "https://registry.yarnpkg.com/@solidjs/start/-/start-1.3.2.tgz#438cf350fde2d4aa03c179fea224f7231c3d8489"
@@ -8759,6 +8764,14 @@
   dependencies:
     "@testing-library/dom" "^9.3.1"
 
+"@solidjs/web@^2.0.0-rc.9":
+  version "2.0.0-rc.9"
+  resolved "https://registry.yarnpkg.com/@solidjs/web/-/web-2.0.0-rc.9.tgz#a056d25115dcefd9aed178716c8bf7e6c031400f"
+  integrity sha512-pfiWoLDnLc+QYWc7UyLqO+5QrPEf3oTiNmmRC+C+uM6AZ5VH0bZMNPtLM5rJ29LKPiTwQitKV843IQDf/oeyhQ==
+  dependencies:
+    seroval "~1.6.7"
+    seroval-plugins "~1.6.7"
+
 "@speed-highlight/core@^1.2.14", "@speed-highlight/core@^1.2.7":
   version "1.2.15"
   resolved "https://registry.yarnpkg.com/@speed-highlight/core/-/core-1.2.15.tgz#88c45609a2b5c2293a2e1935417c507f98f39d0b"
@@ -24920,6 +24933,11 @@ seroval-plugins@~1.5.0:
   resolved "https://registry.yarnpkg.com/seroval-plugins/-/seroval-plugins-1.5.4.tgz#3e7d1910b5a516684046770d201b993c81b1b95a"
   integrity sha512-S0xQPhUTefAhNvNWFg0c1J8qJArHt5KdtJ/cFAofo06KD1MVSeFWyl4iiu+ApDIuw0WhjpOfCdgConOfAnLgkw==
 
+seroval-plugins@~1.6.7:
+  version "1.6.7"
+  resolved "https://registry.yarnpkg.com/seroval-plugins/-/seroval-plugins-1.6.7.tgz#4aba839a2fdafa9c115d965a71861d4b288b90c1"
+  integrity sha512-4Nk35ttD3DTDJW4hgw5StsVAPeU6qnDFnULAouw6tQ7oLTV/ICXrWpsXo2EE52eSP2joUMazbVf52mFEcADqRw==
+
 seroval@^1.4.0, seroval@^1.5.0, seroval@^1.5.4, seroval@^1.6.2:
   version "1.6.2"
   resolved "https://registry.yarnpkg.com/seroval/-/seroval-1.6.2.tgz#93ecff62ca1312a565e37146b2a332b9d625194d"
@@ -24930,6 +24948,11 @@ seroval@~1.5.0:
   resolved "https://registry.yarnpkg.com/seroval/-/seroval-1.5.4.tgz#9d0cedae244f8213bbbbbcc99c497eb7c945d961"
   integrity sha512-46uFvgrXTVxZcUorgSSRZ4y+ieqLLQRMlG4bnCZKW3qI6BZm7Rg4ntMW4p1mILEEBZWrFlcpp0AyIIlM6jD9iw==
 
+seroval@~1.6.7:
+  version "1.6.7"
+  resolved "https://registry.yarnpkg.com/seroval/-/seroval-1.6.7.tgz#b33953ac59aec5bde14f99e010bdaa7a507ae2db"
+  integrity sha512-AeDcLh0yO2SFm9W71essgnSzLV9DI8ZH0x0knXn2DMnUZj728mpLbxjlbB6IqKCmqh8JA3cEqRyGoNkt584JcQ==
+
 serve-index@^1.9.1:
   version "1.9.1"
   resolved "https://registry.yarnpkg.com/serve-index/-/serve-index-1.9.1.tgz#d3768d69b1e7d82e5ce050fff5b453bea12a9239"
@@ -25368,6 +25391,16 @@ solid-js@^1.9.11:
     seroval "~1.5.0"
     seroval-plugins "~1.5.0"
 
+solid-js@^2.0.0-rc.9:
+  version "2.0.0-rc.9"
+  resolved "https://registry.yarnpkg.com/solid-js/-/solid-js-2.0.0-rc.9.tgz#f07125cee1149da629326beed94afdf71c6188b9"
+  integrity sha512-J/oHWnWqe7S0FeIEdIRKDvyyo+HY/TYKr2PrIB8VlePMWuErDg78QHqdsAV7f6HKa9qhWR/23eqzR/ZRV9ep0g==
+  dependencies:
+    "@solidjs/signals" "^2.0.0-rc.9"
+    csstype "^3.1.0"
+    seroval "~1.6.7"
+    seroval-plugins "~1.6.7"
+
 solid-refresh@^0.6.3:
   version "0.6.3"
   resolved "https://registry.yarnpkg.com/solid-refresh/-/solid-refresh-0.6.3.tgz#d23ef80f04e177619c9234a809c573cb16360627"