diff --git a/packages/analytics-browser/src/snippet-index.ts b/packages/analytics-browser/src/snippet-index.ts
index a35bf1745..d85b2481d 100644
--- a/packages/analytics-browser/src/snippet-index.ts
+++ b/packages/analytics-browser/src/snippet-index.ts
@@ -1,8 +1,25 @@
-import { getGlobalScope } from '@amplitude/analytics-core';
+import { getGlobalScope, registerSdkLoaderMetadata } from '@amplitude/analytics-core';
 import * as amplitude from './index';
 import { createInstance } from './browser-client-factory';
 import { runQueuedFunctions } from './utils/snippet-helper';
 
+registerSdkLoaderMetadata({
+  scriptUrl: resolveCurrentScriptUrl(),
+});
+
+function resolveCurrentScriptUrl(): string | undefined {
+  if (typeof document === 'undefined') {
+    return undefined;
+  }
+
+  const currentScript = document.currentScript as HTMLScriptElement | null;
+  if (currentScript?.src) {
+    return currentScript.src;
+  }
+
+  return undefined;
+}
+
 // https://developer.mozilla.org/en-US/docs/Glossary/IIFE
 (function () {
   const GlobalScope = getGlobalScope();
diff --git a/packages/analytics-core/src/diagnostics/diagnostics-client.ts b/packages/analytics-core/src/diagnostics/diagnostics-client.ts
index 8cce18ff8..615e29a12 100644
--- a/packages/analytics-core/src/diagnostics/diagnostics-client.ts
+++ b/packages/analytics-core/src/diagnostics/diagnostics-client.ts
@@ -3,6 +3,7 @@ import { DiagnosticsStorage, IDiagnosticsStorage } from './diagnostics-storage';
 import { ServerZoneType } from '../types/server-zone';
 import { getGlobalScope } from '../global-scope';
 import { isTimestampInSampleTemp } from '../utils/sampling';
+import { enableSdkErrorListeners } from './uncaught-sdk-errors';
 
 export const SAVE_INTERVAL_MS = 1000; // 1 second
 export const FLUSH_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
@@ -215,6 +216,7 @@ export class DiagnosticsClient implements IDiagnosticsClient {
     // Track internal diagnostics metrics for sampling
     if (this.shouldTrack) {
       this.increment('sdk.diagnostics.sampled.in.and.enabled');
+      enableSdkErrorListeners(this);
     }
   }
 
diff --git a/packages/analytics-core/src/diagnostics/uncaught-sdk-errors.ts b/packages/analytics-core/src/diagnostics/uncaught-sdk-errors.ts
new file mode 100644
index 000000000..40405dc62
--- /dev/null
+++ b/packages/analytics-core/src/diagnostics/uncaught-sdk-errors.ts
@@ -0,0 +1,157 @@
+import { getGlobalScope } from '../global-scope';
+import { IDiagnosticsClient } from './diagnostics-client';
+
+type ErrorEventType = 'error' | 'unhandledrejection';
+
+interface CapturedErrorContext {
+  readonly type: ErrorEventType;
+  readonly message: string;
+  readonly stack?: string;
+  readonly filename?: string;
+  readonly errorName?: string;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export const GLOBAL_KEY = '__AMPLITUDE_SCRIPT_URL__';
+export const EVENT_NAME_ERROR_UNCAUGHT = 'sdk.error.uncaught';
+
+const getNormalizedScriptUrl = (): string | undefined => {
+  const scope = getGlobalScope() as Record<string, unknown> | null;
+  /* istanbul ignore next */
+  return scope?.[GLOBAL_KEY] as string | undefined;
+};
+
+const setNormalizedScriptUrl = (url: string) => {
+  const scope = getGlobalScope() as Record<string, unknown> | null;
+  if (scope) {
+    scope[GLOBAL_KEY] = url;
+  }
+};
+
+export const registerSdkLoaderMetadata = (metadata: { scriptUrl?: string }) => {
+  if (metadata.scriptUrl) {
+    const normalized = normalizeUrl(metadata.scriptUrl);
+    if (normalized) {
+      setNormalizedScriptUrl(normalized);
+    }
+  }
+};
+
+export const enableSdkErrorListeners = (client: IDiagnosticsClient) => {
+  const scope = getGlobalScope();
+
+  if (!scope || typeof scope.addEventListener !== 'function') {
+    return;
+  }
+
+  const handleError = (event: ErrorEvent) => {
+    const error = event.error instanceof Error ? event.error : undefined;
+    const stack = error?.stack;
+    const match = detectSdkOrigin({ filename: event.filename, stack });
+    if (!match) {
+      return;
+    }
+
+    capture({
+      type: 'error',
+      message: event.message,
+      stack,
+      filename: event.filename,
+      errorName: error?.name,
+      metadata: {
+        colno: event.colno,
+        lineno: event.lineno,
+        isTrusted: event.isTrusted,
+        matchReason: match,
+      },
+    });
+  };
+
+  const handleRejection = (event: PromiseRejectionEvent) => {
+    const error = event.reason instanceof Error ? event.reason : undefined;
+    const stack = error?.stack;
+    const filename = extractFilenameFromStack(stack);
+    const match = detectSdkOrigin({ filename, stack });
+
+    if (!match) {
+      return;
+    }
+
+    /* istanbul ignore next */
+    capture({
+      type: 'unhandledrejection',
+      message: error?.message ?? stringifyReason(event.reason),
+      stack,
+      filename,
+      errorName: error?.name,
+      metadata: {
+        isTrusted: event.isTrusted,
+        matchReason: match,
+      },
+    });
+  };
+
+  const capture = (context: CapturedErrorContext) => {
+    client.recordEvent(EVENT_NAME_ERROR_UNCAUGHT, {
+      type: context.type,
+      message: context.message,
+      filename: context.filename,
+      error_name: context.errorName,
+      stack: context.stack,
+      ...context.metadata,
+    });
+  };
+
+  scope.addEventListener('error', handleError, true);
+  scope.addEventListener('unhandledrejection', handleRejection, true);
+};
+
+const detectSdkOrigin = (payload: { filename?: string; stack?: string }): 'filename' | 'stack' | undefined => {
+  const normalizedScriptUrl = getNormalizedScriptUrl();
+  if (!normalizedScriptUrl) {
+    return undefined;
+  }
+
+  if (payload.filename && payload.filename.includes(normalizedScriptUrl)) {
+    return 'filename';
+  }
+
+  if (payload.stack && payload.stack.includes(normalizedScriptUrl)) {
+    return 'stack';
+  }
+
+  return undefined;
+};
+
+const normalizeUrl = (value: string) => {
+  try {
+    /* istanbul ignore next */
+    const url = new URL(value, getGlobalScope()?.location?.origin);
+    return url.origin + url.pathname;
+  } catch {
+    return undefined;
+  }
+};
+
+const extractFilenameFromStack = (stack?: string) => {
+  if (!stack) {
+    return undefined;
+  }
+
+  const match = stack.match(/(https?:\/\/\S+?)(?=[)\s]|$)/);
+  /* istanbul ignore next */
+  return match ? match[1] : undefined;
+};
+
+/* istanbul ignore next */
+const stringifyReason = (reason: unknown) => {
+  if (typeof reason === 'string') {
+    return reason;
+  }
+
+  try {
+    return JSON.stringify(reason);
+  } catch {
+    return '[object Object]';
+  }
+};
diff --git a/packages/analytics-core/src/index.ts b/packages/analytics-core/src/index.ts
index 78bf84454..91b6a559b 100644
--- a/packages/analytics-core/src/index.ts
+++ b/packages/analytics-core/src/index.ts
@@ -30,6 +30,7 @@ export { getStorageKey } from './storage/helpers';
 export { BrowserStorage } from './storage/browser-storage';
 
 export { DiagnosticsClient, IDiagnosticsClient } from './diagnostics/diagnostics-client';
+export { registerSdkLoaderMetadata } from './diagnostics/uncaught-sdk-errors';
 
 export { BaseTransport } from './transports/base';
 export { FetchTransport } from './transports/fetch';
diff --git a/packages/analytics-core/test/diagnostics/uncaught-sdk-errors.test.ts b/packages/analytics-core/test/diagnostics/uncaught-sdk-errors.test.ts
new file mode 100644
index 000000000..0057ee075
--- /dev/null
+++ b/packages/analytics-core/test/diagnostics/uncaught-sdk-errors.test.ts
@@ -0,0 +1,360 @@
+import {
+  registerSdkLoaderMetadata,
+  enableSdkErrorListeners,
+  GLOBAL_KEY,
+  EVENT_NAME_ERROR_UNCAUGHT,
+} from '../../src/diagnostics/uncaught-sdk-errors';
+import { IDiagnosticsClient } from '../../src/diagnostics/diagnostics-client';
+import * as globalScopeModule from '../../src/global-scope';
+
+describe('uncaught-sdk-errors', () => {
+  let mockGlobalScope: Record<string, unknown> & {
+    addEventListener: jest.Mock;
+    removeEventListener: jest.Mock;
+  };
+  let mockDiagnosticsClient: jest.Mocked<IDiagnosticsClient>;
+  let errorHandler: ((event: ErrorEvent) => void) | undefined;
+  let rejectionHandler: ((event: PromiseRejectionEvent) => void) | undefined;
+
+  beforeEach(() => {
+    // Reset global state
+    mockGlobalScope = {
+      addEventListener: jest.fn((type: string, handler: unknown) => {
+        if (type === 'error') {
+          errorHandler = handler as (event: ErrorEvent) => void;
+        } else if (type === 'unhandledrejection') {
+          rejectionHandler = handler as (event: PromiseRejectionEvent) => void;
+        }
+      }),
+      removeEventListener: jest.fn(),
+    };
+
+    jest.spyOn(globalScopeModule, 'getGlobalScope').mockReturnValue(mockGlobalScope as unknown as typeof globalThis);
+
+    mockDiagnosticsClient = {
+      setTag: jest.fn(),
+      increment: jest.fn(),
+      recordHistogram: jest.fn(),
+      recordEvent: jest.fn(),
+      _flush: jest.fn(),
+      _setSampleRate: jest.fn(),
+    };
+
+    errorHandler = undefined;
+    rejectionHandler = undefined;
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    // Clean up global state
+    delete mockGlobalScope[GLOBAL_KEY];
+  });
+
+  describe('registerSdkLoaderMetadata', () => {
+    it('should register script URL in global scope', () => {
+      registerSdkLoaderMetadata({ scriptUrl: 'https://cdn.amplitude.com/libs/amplitude.js' });
+
+      expect(mockGlobalScope[GLOBAL_KEY]).toBe('https://cdn.amplitude.com/libs/amplitude.js');
+    });
+
+    it('should normalize script URL by removing query params', () => {
+      registerSdkLoaderMetadata({ scriptUrl: 'https://cdn.amplitude.com/libs/amplitude.js?v=1.0.0' });
+
+      expect(mockGlobalScope[GLOBAL_KEY]).toBe('https://cdn.amplitude.com/libs/amplitude.js');
+    });
+
+    it('should normalize script URL by removing hash', () => {
+      registerSdkLoaderMetadata({ scriptUrl: 'https://cdn.amplitude.com/libs/amplitude.js#section' });
+
+      expect(mockGlobalScope[GLOBAL_KEY]).toBe('https://cdn.amplitude.com/libs/amplitude.js');
+    });
+
+    it('should normalize script URL by removing both query params and hash', () => {
+      registerSdkLoaderMetadata({ scriptUrl: 'https://cdn.amplitude.com/libs/amplitude.js?v=1.0.0#section' });
+
+      expect(mockGlobalScope[GLOBAL_KEY]).toBe('https://cdn.amplitude.com/libs/amplitude.js');
+    });
+
+    it('should not register if scriptUrl is undefined', () => {
+      registerSdkLoaderMetadata({});
+
+      expect(mockGlobalScope[GLOBAL_KEY]).toBeUndefined();
+    });
+
+    it('should not register if scriptUrl is empty string', () => {
+      registerSdkLoaderMetadata({ scriptUrl: '' });
+
+      expect(mockGlobalScope[GLOBAL_KEY]).toBeUndefined();
+    });
+
+    it('should not register if scriptUrl is an invalid URL', () => {
+      registerSdkLoaderMetadata({ scriptUrl: 'not-a-valid-url' });
+
+      expect(mockGlobalScope[GLOBAL_KEY]).toBeUndefined();
+    });
+  });
+
+  describe('enableSdkErrorListeners', () => {
+    it('should add error and unhandledrejection event listeners', () => {
+      enableSdkErrorListeners(mockDiagnosticsClient);
+
+      expect(mockGlobalScope.addEventListener).toHaveBeenCalledWith('error', expect.any(Function), true);
+      expect(mockGlobalScope.addEventListener).toHaveBeenCalledWith('unhandledrejection', expect.any(Function), true);
+    });
+
+    it('should not add listeners if global scope is null', () => {
+      jest.spyOn(globalScopeModule, 'getGlobalScope').mockReturnValue(null as unknown as typeof globalThis);
+
+      enableSdkErrorListeners(mockDiagnosticsClient);
+
+      expect(mockGlobalScope.addEventListener).not.toHaveBeenCalled();
+    });
+
+    it('should not add listeners if addEventListener is not a function', () => {
+      const scopeWithoutAddEventListener = { ...mockGlobalScope };
+      delete (scopeWithoutAddEventListener as Record<string, unknown>).addEventListener;
+      jest
+        .spyOn(globalScopeModule, 'getGlobalScope')
+        .mockReturnValue(scopeWithoutAddEventListener as unknown as typeof globalThis);
+
+      enableSdkErrorListeners(mockDiagnosticsClient);
+
+      // Should not throw
+    });
+  });
+
+  describe('error handling', () => {
+    beforeEach(() => {
+      // Register script URL first
+      registerSdkLoaderMetadata({ scriptUrl: 'https://cdn.amplitude.com/libs/amplitude.js' });
+      enableSdkErrorListeners(mockDiagnosticsClient);
+    });
+
+    describe('ErrorEvent handling', () => {
+      it('should capture error when filename matches SDK script URL', () => {
+        const error = new Error('Test error');
+        const errorEvent = {
+          message: 'Test error',
+          filename: 'https://cdn.amplitude.com/libs/amplitude.js',
+          lineno: 100,
+          colno: 50,
+          error,
+          isTrusted: true,
+        } as ErrorEvent;
+
+        errorHandler?.(errorEvent);
+
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        expect(mockDiagnosticsClient.recordEvent).toHaveBeenCalledWith(EVENT_NAME_ERROR_UNCAUGHT, {
+          type: 'error',
+          message: 'Test error',
+          filename: 'https://cdn.amplitude.com/libs/amplitude.js',
+          error_name: 'Error',
+          stack: error.stack,
+          colno: 50,
+          lineno: 100,
+          isTrusted: true,
+          matchReason: 'filename',
+        });
+      });
+
+      it('should capture error when stack trace contains SDK script URL', () => {
+        const error = new Error('Test error');
+        error.stack = `Error: Test error
+    at functionName (https://cdn.amplitude.com/libs/amplitude.js:100:50)
+    at anotherFunction (https://example.com/app.js:200:30)`;
+
+        const errorEvent = {
+          message: 'Test error',
+          filename: 'https://example.com/app.js',
+          lineno: 200,
+          colno: 30,
+          error,
+          isTrusted: true,
+        } as ErrorEvent;
+
+        errorHandler?.(errorEvent);
+
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        expect(mockDiagnosticsClient.recordEvent).toHaveBeenCalledWith(EVENT_NAME_ERROR_UNCAUGHT, {
+          type: 'error',
+          message: 'Test error',
+          filename: 'https://example.com/app.js',
+          error_name: 'Error',
+          stack: error.stack,
+          colno: 30,
+          lineno: 200,
+          isTrusted: true,
+          matchReason: 'stack',
+        });
+      });
+
+      it('should NOT capture error when neither filename nor stack matches SDK script URL', () => {
+        const error = new Error('Test error');
+        error.stack = `Error: Test error
+    at functionName (https://example.com/app.js:100:50)`;
+
+        const errorEvent = {
+          message: 'Test error',
+          filename: 'https://example.com/app.js',
+          lineno: 100,
+          colno: 50,
+          error,
+          isTrusted: true,
+        } as ErrorEvent;
+
+        errorHandler?.(errorEvent);
+
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        expect(mockDiagnosticsClient.recordEvent).not.toHaveBeenCalled();
+      });
+
+      it('should handle error event without error object', () => {
+        const errorEvent = {
+          message: 'Script error',
+          filename: 'https://cdn.amplitude.com/libs/amplitude.js',
+          lineno: 0,
+          colno: 0,
+          error: null,
+          isTrusted: true,
+        } as ErrorEvent;
+
+        errorHandler?.(errorEvent);
+
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        expect(mockDiagnosticsClient.recordEvent).toHaveBeenCalledWith(EVENT_NAME_ERROR_UNCAUGHT, {
+          type: 'error',
+          message: 'Script error',
+          filename: 'https://cdn.amplitude.com/libs/amplitude.js',
+          error_name: undefined,
+          stack: undefined,
+          colno: 0,
+          lineno: 0,
+          isTrusted: true,
+          matchReason: 'filename',
+        });
+      });
+    });
+
+    describe('PromiseRejectionEvent handling', () => {
+      it('should capture unhandled rejection when stack contains SDK script URL', () => {
+        const error = new Error('Promise rejected');
+        error.stack = `Error: Promise rejected
+    at async functionName (https://cdn.amplitude.com/libs/amplitude.js:100:50)`;
+
+        const rejectionEvent = {
+          reason: error,
+          isTrusted: true,
+        } as PromiseRejectionEvent;
+
+        rejectionHandler?.(rejectionEvent);
+
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        expect(mockDiagnosticsClient.recordEvent).toHaveBeenCalledWith(EVENT_NAME_ERROR_UNCAUGHT, {
+          type: 'unhandledrejection',
+          message: 'Promise rejected',
+          filename: 'https://cdn.amplitude.com/libs/amplitude.js:100:50',
+          error_name: 'Error',
+          stack: error.stack,
+          isTrusted: true,
+          matchReason: 'filename',
+        });
+      });
+
+      it('should NOT capture unhandled rejection when stack does not contain SDK script URL', () => {
+        const error = new Error('Promise rejected');
+        error.stack = `Error: Promise rejected
+    at async functionName (https://example.com/app.js:100:50)`;
+
+        const rejectionEvent = {
+          reason: error,
+          isTrusted: true,
+        } as PromiseRejectionEvent;
+
+        rejectionHandler?.(rejectionEvent);
+
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        expect(mockDiagnosticsClient.recordEvent).not.toHaveBeenCalled();
+      });
+
+      it('should handle non-Error rejection reason as string', () => {
+        // First need to set up a scenario where it would match
+        // Since reason is not an Error, stack will be undefined, so it won't match
+        const rejectionEvent = {
+          reason: 'Simple string rejection',
+          isTrusted: true,
+        } as PromiseRejectionEvent;
+
+        rejectionHandler?.(rejectionEvent);
+
+        // Should not be captured because there's no way to match without stack
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        expect(mockDiagnosticsClient.recordEvent).not.toHaveBeenCalled();
+      });
+
+      it('should handle object rejection reason by stringifying', () => {
+        const rejectionEvent = {
+          reason: { code: 'ERR_001', details: 'Something went wrong' },
+          isTrusted: true,
+        } as PromiseRejectionEvent;
+
+        rejectionHandler?.(rejectionEvent);
+
+        // Should not be captured because there's no way to match without stack
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        expect(mockDiagnosticsClient.recordEvent).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('without registered script URL', () => {
+    beforeEach(() => {
+      // Don't register script URL
+      enableSdkErrorListeners(mockDiagnosticsClient);
+    });
+
+    it('should NOT capture any errors when no script URL is registered', () => {
+      const error = new Error('Test error');
+      const errorEvent = {
+        message: 'Test error',
+        filename: 'https://cdn.amplitude.com/libs/amplitude.js',
+        lineno: 100,
+        colno: 50,
+        error,
+        isTrusted: true,
+      } as ErrorEvent;
+
+      errorHandler?.(errorEvent);
+
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      expect(mockDiagnosticsClient.recordEvent).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('URL normalization edge cases', () => {
+    it('should handle filename with query params when matching', () => {
+      registerSdkLoaderMetadata({ scriptUrl: 'https://cdn.amplitude.com/libs/amplitude.js' });
+      enableSdkErrorListeners(mockDiagnosticsClient);
+
+      const error = new Error('Test error');
+      const errorEvent = {
+        message: 'Test error',
+        filename: 'https://cdn.amplitude.com/libs/amplitude.js?v=2.0.0',
+        lineno: 100,
+        colno: 50,
+        error,
+        isTrusted: true,
+      } as ErrorEvent;
+
+      errorHandler?.(errorEvent);
+
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      expect(mockDiagnosticsClient.recordEvent).toHaveBeenCalledWith(
+        EVENT_NAME_ERROR_UNCAUGHT,
+        expect.objectContaining({
+          matchReason: 'filename',
+        }),
+      );
+    });
+  });
+});
diff --git a/packages/analytics-core/test/index.test.ts b/packages/analytics-core/test/index.test.ts
index 168bcd0b1..14204b88c 100644
--- a/packages/analytics-core/test/index.test.ts
+++ b/packages/analytics-core/test/index.test.ts
@@ -61,6 +61,7 @@ import {
   generateHashCode,
   isTimestampInSample,
   DiagnosticsClient,
+  registerSdkLoaderMetadata,
 } from '../src/index';
 
 describe('index', () => {
@@ -141,6 +142,7 @@ describe('index', () => {
     expect(typeof generateHashCode).toBe('function');
     expect(typeof isTimestampInSample).toBe('function');
     expect(typeof DiagnosticsClient).toBe('function');
+    expect(typeof registerSdkLoaderMetadata).toBe('function');
   });
 
   describe('replaceSensitiveString export', () => {
diff --git a/test-server/diagnostics.html b/test-server/diagnostics.html
index 4d38e5b84..cbc53b661 100644
--- a/test-server/diagnostics.html
+++ b/test-server/diagnostics.html
@@ -7,51 +7,141 @@
     <title>SDK Diagnostics Test</title>
     <style>
       body {
-        font-family: Arial, sans-serif;
-        padding: 20px;
+        font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+        padding: 2rem;
+        max-width: 720px;
+        margin: 0 auto;
+        background-color: #f5f6fa;
+        color: #222;
       }
-      .container {
-        max-width: 600px;
+      .section {
+        margin-bottom: 2rem;
+      }
+      .actions {
+        display: flex;
+        gap: 1rem;
+        margin-bottom: 1rem;
+        flex-wrap: wrap;
       }
       button {
-        padding: 10px 20px;
-        margin: 10px 5px 10px 0;
+        padding: 0.75rem 1.5rem;
+        border-radius: 6px;
+        border: none;
         cursor: pointer;
+        font-size: 1rem;
+      }
+      .init-btn {
+        background-color: #37b24d;
+        color: white;
+      }
+      .plugin-btn {
+        background-color: #1c7ed6;
+        color: white;
+      }
+      .sdk-error-btn {
+        background-color: #f59f00;
+        color: white;
+      }
+      .not-captured-btn {
+        background-color: #fa5252;
+        color: white;
+      }
+      .log {
+        background: #0c111b;
+        color: #f1f3f5;
+        padding: 1rem;
+        min-height: 200px;
+        border-radius: 8px;
+        overflow: auto;
+        font-size: 0.85rem;
+        white-space: pre-wrap;
+        word-break: break-all;
+      }
+      code {
+        background: #e9ecef;
+        padding: 0.2rem 0.4rem;
+        border-radius: 4px;
+      }
+      h3 {
+        margin-top: 1.5rem;
+        margin-bottom: 0.5rem;
       }
     </style>
   </head>
+  <script src="/analytics-browser/lib/scripts/amplitude-min.js"></script>
+  <script type="module">
+    // Expose env vars to window for use in regular scripts
+    window.AMPLITUDE_API_KEY = import.meta.env.VITE_AMPLITUDE_API_KEY;
+  </script>
+  <script>
+    // Helper to log messages
+    function logMessage(message) {
+      var logElement = document.getElementById('log');
+      if (!logElement) return;
+      var timestamp = new Date().toISOString();
+      logElement.textContent = '[' + timestamp + '] ' + message + '\n' + logElement.textContent;
+    }
+
+    // Register global error handlers to see what's happening
+    window.addEventListener('error', function(event) {
+      logMessage('[window.error] ' + event.message + ' (' + (event.filename || 'unknown') + ')');
+    });
+
+    window.addEventListener('unhandledrejection', function(event) {
+      logMessage('[unhandledrejection] ' + String(event.reason));
+    });
+  </script>
   <body>
-    <div class="container">
-      <h1>SDK Diagnostics Test</h1>
-      <button id="initButton">Initialize SDK</button>
-      <button id="addPluginButton">Add Plugin (Remove User/Device ID)</button>
-      <button id="testButton">Test Button</button>
+    <h1>SDK Diagnostics Test</h1>
+    <p>This page tests SDK diagnostics including uncaught SDK error capture. SDK is loaded via <code>&lt;script&gt;</code> tag.</p>
+
+    <div class="section">
+      <h3>SDK Initialization</h3>
+      <div class="actions">
+        <button id="initButton" class="init-btn">Initialize SDK</button>
+        <button id="addPluginButton" class="plugin-btn">Add Plugin (Remove User/Device ID)</button>
+      </div>
     </div>
-    <script type="module">
-      import * as amplitude from '@amplitude/analytics-browser';
-      
-      window.amplitude = amplitude;
-      
-      const initButton = document.getElementById('initButton');
-      const addPluginButton = document.getElementById('addPluginButton');
-      const testButton = document.getElementById('testButton');
-      
+
+    <div class="section">
+      <h3>Uncaught SDK Error Tests</h3>
+      <div class="actions">
+        <button class="sdk-error-btn" onclick="triggerSdkSetupError()">SDK Error: Setup Error</button>
+        <button class="not-captured-btn" onclick="setupCustomPluginClickHandler()">Custom Plugin Click Handler (Not Captured)</button>
+        <button id="custom-plugin-click-target" class="not-captured-btn" style="display:none;">Click to Throw Error</button>
+        <button class="not-captured-btn" onclick="triggerAppError()">App Error (Not Captured)</button>
+      </div>
+    </div>
+
+    <h3>Event Log</h3>
+    <pre id="log" class="log"></pre>
+
+    <h3>Instructions</h3>
+    <ul>
+      <li>Click <strong>Initialize SDK</strong> first to set up Amplitude</li>
+      <li>Open Developer Tools → Network tab to see diagnostics requests</li>
+      <li><strong>SDK Error: Setup Error</strong> - Plugin setup returns a rejected promise (should be captured - error originates from SDK code)</li>
+      <li><strong>Custom Plugin Click Handler</strong> - Custom plugin sets up a click handler that throws (NOT captured - error originates from this page's code, not SDK)</li>
+      <li><strong>App Error</strong> - Throws error from application code (NOT captured - error originates from this page's code)</li>
+    </ul>
+
+    <script>
       // Create plugin that removes user_id and device_id from events
-      const removeIdsPlugin = () => {
+      function removeIdsPlugin() {
         return {
           name: 'remove-ids-plugin',
           type: 'before',
-          execute: async (event) => {
+          execute: function(event) {
             delete event.user_id;
             delete event.device_id;
-            console.log('Plugin: Removed user_id and device_id from event', event);
-            return event;
+            logMessage('Plugin: Removed user_id and device_id from event');
+            return Promise.resolve(event);
           }
         };
-      };
-      
-      initButton.addEventListener('click', () => {
-        const apiKey = import.meta.env.VITE_AMPLITUDE_API_KEY;
+      }
+
+      document.getElementById('initButton').addEventListener('click', function() {
+        var apiKey = window.AMPLITUDE_API_KEY;
         
         if (!apiKey) {
           alert('Please set VITE_AMPLITUDE_API_KEY in .env');
@@ -60,21 +150,58 @@ <h1>SDK Diagnostics Test</h1>
         
         amplitude._setDiagnosticsSampleRate(1);
         amplitude.init(apiKey, undefined, {
-            logLevel: 'debug',
             autocapture: true,
         });
-        console.log('SDK initialized with API key:', apiKey);
+        logMessage('SDK initialized with API key: ' + apiKey.substring(0, 10) + '...');
       });
       
-      addPluginButton.addEventListener('click', () => {
+      document.getElementById('addPluginButton').addEventListener('click', function() {
         amplitude.add(removeIdsPlugin());
-        console.log('Plugin added to amplitude');
-      });
-      
-      testButton.addEventListener('click', () => {
-        console.log('Test button clicked');
+        logMessage('Plugin added: remove-ids-plugin');
       });
+
+      // Uncaught SDK error test functions
+      function triggerSdkSetupError() {
+        logMessage('Adding plugin that throws in setup...');
+        amplitude.add({
+          name: 'plugin-setup-error',
+          type: 'before',
+          setup: function() {
+            return Promise.reject(new Error('Plugin setup error'));
+          },
+          execute: function(event) {
+            return Promise.resolve(event);
+          }
+        });
+      }
+
+      function setupCustomPluginClickHandler() {
+        logMessage('Adding custom plugin that sets up a click handler...');
+        amplitude.add({
+          name: 'custom-plugin-click-handler',
+          type: 'before',
+          setup: function() {
+            var btn = document.getElementById('custom-plugin-click-target');
+            btn.style.display = 'inline-block';
+            btn.addEventListener('click', function() {
+              logMessage('Click handler throwing error (from custom plugin code, not SDK)...');
+              throw new Error('Error from custom plugin click handler');
+            });
+            logMessage('Plugin setup complete. Click the red "Click to Throw Error" button.');
+            return Promise.resolve();
+          },
+          execute: function(event) {
+            return Promise.resolve(event);
+          }
+        });
+      }
+
+      function triggerAppError() {
+        logMessage('Throwing error from application code...');
+        throw new Error('Application level error');
+      }
+
+      logMessage('Page loaded. Click "Initialize SDK" to start.');
     </script>
   </body>
 </html>
-