返回提示词目录第 1358 页

跨浏览器兼容与生产缺陷排查

针对浏览器、平台与生产构建的环境差异,定位可复现缺陷并整理影响范围及修复建议。

完整提示词

# BROWSER COMPATIBILITY AND PRODUCTION BUG HUNTER

I want you to perform an exhaustive, systematic, and evidence-first analysis of issues that surface only:

- in specific browsers
- on specific operating systems
- on specific devices
- in production builds
- on CDNs
- within serverless runtimes
- under differing locale/timezone configurations
- over slow or degraded networks
- under different filesystem behaviors
- following code minification
- following tree shaking
- across differing JavaScript/Web API implementations

Main goal:

> Identify genuine cross-browser, cross-platform, and production-only defects that local development environments conceal.

This is not:

- a generic browser support checklist
- an inventory of obsolete browsers
- a recommendation to support every browser ever created
- automatic injection of polyfills
- a superficial review of `caniuse` tables
- a routine frontend code review
- a generic production-readiness audit

The focus is on bugs arising from discrepancies between:

```text
development
vs
production
```

or:

```text
browser A
vs
browser B
```

or:

```text
OS A
vs
OS B
```

Priority:

**reproducibility > user impact > evidence > breadth**

It is better to discover 8 genuine production or browser bugs than 80 theoretical compatibility risks.

---

# 1. IDENTIFY TARGET ENVIRONMENTS

Before the analysis, determine:

- supported browser portfolio
- minimum version baselines if defined
- desktop vs mobile scope
- supported operating systems
- SSR vs CSR model
- build compilation target
- bundler architecture
- transpilation pipeline
- polyfill strategy
- deployment platform
- Node/runtime engine version
- Edge runtime if utilized
- serverless/function execution runtime
- CDN tier
- reverse proxy architecture
- filesystem assumptions

Inspect:

- `package.json`
- browserslist configuration
- build configs
- Babel configuration
- TypeScript target settings
- PostCSS configuration
- CSS build tooling
- framework configuration
- deployment specifications
- Dockerfile
- CI/CD pipelines
- environment configs

If target browsers are undocumented:

**SUPPORTED BROWSER MATRIX: NOT DEFINED**

Do not automatically assume support for legacy browsers.

---

# 2. CREATE ENVIRONMENT MATRIX

Classify relevant runtime targets.

For example:

| Layer | Variant |
|---|---|
| Browser | Chrome |
| Browser | Firefox |
| Browser | Safari |
| Browser | Edge |
| OS | Windows |
| OS | macOS |
| OS | Linux |
| Mobile | iOS Safari |
| Mobile | Android Chrome |
| Runtime | Node |
| Runtime | Edge |
| Environment | Development |
| Environment | Production |

Exclude platforms that are out of scope for the product.

---

# 3. DEVELOPMENT VS PRODUCTION

Identify all divergence between development and production modes.

Map:

```text
Development
↓
bundler/dev server
↓
source code
↓
runtime
```

versus:

```text
Production
↓
optimized build
↓
minification
↓
tree shaking
↓
chunking
↓
CDN/server
```

Hunt for defects that can only materialize in the production pipeline.

---

# 4. ENVIRONMENT GUARDS

Search for:

```text
NODE_ENV
development
production
localhost
127.0.0.1
```

For every conditional branch, verify:

- whether production executes distinct logic
- whether development bypasses remain accidentally active
- whether fallbacks function exclusively in local development

---

# 5. LOCALHOST ASSUMPTIONS

Search for hardcoded:

```text
localhost
127.0.0.1
http://localhost
```

Inspect:

- API URLs
- WebSocket endpoints
- callback endpoints
- OAuth redirect targets
- image host domains
- CORS origins
- webhook receiver references

---

# 6. HTTP VS HTTPS

Development frequently operates over unencrypted HTTP.

Production universally enforces HTTPS.

Inspect APIs that strictly require a secure context:

- service workers
- clipboard API
- camera access
- microphone access
- geolocation
- credential transmission

---

# 7. MIXED CONTENT

Search for production HTTPS pages attempting to fetch:

```text
http://
```

resources.

Browsers will block mixed content:

- active API calls
- image assets
- external scripts
- embedded media

depending on browser security policies.

---

# 8. SECURE COOKIES

Cookies marked with:

```text
Secure
```

behave differently on local HTTP environments compared to production HTTPS.

Verify development vs production cookie configurations.

---

# 9. COOKIE DOMAINS

Look for mismatches across:

```text
localhost
app.example.com
www.example.com
api.example.com
```

Inspect:

- domain scope
- path scope
- SameSite attributes
- Secure flags

---

# 10. SAME-SITE BEHAVIOR

Authentication that succeeds locally can collapse when the frontend and backend reside on distinct production origins.

Trace:

```text
frontend
↓
cross-origin request
↓
cookie transmission
↓
CORS headers
```

---

# 11. CORS

Development proxy servers often mask CORS misconfigurations.

Verify production direct cross-origin requests.

Look for:

- wildcard `*` conflicting with credentialed requests
- missing allowed origin headers
- dynamic preview domain rejections
- localhost-only whitelist configurations

---

# 12. DEV PROXIES

If the development server proxies requests:

```text
/api
→ localhost:3001
```

verify how production routes resolve that exact same path.

---

# 13. ORIGIN ASSUMPTIONS

Look for:

```ts
window.location.origin
```

or hardcoded origin resolution logic.

Evaluate:

- reverse proxy setups
- custom domain mappings
- preview deployment hosts
- CDN host rewrites

---

# 14. FORWARDED HEADERS

When running behind reverse proxies or CDNs, inspect usage of:

- `X-Forwarded-For`
- `X-Forwarded-Proto`
- host headers

Never trust these headers without proper upstream infrastructure verification.

---

# 15. BASE URL GENERATION

Verify absolute URL synthesis for:

- canonical links
- OAuth redirects
- transactional emails
- API requests
- asset URLs

The production host may differ from the immediate incoming request host behind a proxy.

---

# 16. BUILD-TIME VS RUNTIME ENVIRONMENT VARIABLES

Distinguish between environment variables evaluated:

- during compilation/build time
- during server runtime
- inside client browser bundles

Look for:

```text
env changed after build
↓
frontend bundle still has old value
```

---

# 17. CLIENT ENV EXPOSURE

Ensure server-only secrets are not bundled into client-side JavaScript via public environment prefixes or build-time variable replacements.

If a secret is uncovered:

- do not display the full value in reports
- mask it appropriately

---

# 18. MISSING ENVIRONMENT VARIABLES

A local `.env.local` file can mask missing environment variables in production.

Verify startup environment validation routines.

---

# 19. FALLBACK CONFIGURATION

Look for patterns like:

```ts
process.env.API_URL || "http://localhost:3000"
```

In production, an unconfigured variable can silently divert requests to localhost.

---

# 20. CASE SENSITIVITY

Windows filesystems are typically case-insensitive.

Linux production deployment environments are strictly case-sensitive.

Look for:

```ts
import Button from "./button"
```

when the filesystem entity is actually:

```text
Button.tsx
```

This compiles cleanly on Windows development workstations but crashes production Linux builds.

---

# 21. IMPORT CASE AUDIT

Check case accuracy repository-wide across:

- import paths
- file names
- directory names
- static asset references

---

# 22. STATIC ASSET CASING

Specifically inspect:

```text
/Logo.png
```

versus actual:

```text
/logo.png
```

---

# 23. PATH SEPARATORS

Look for Windows-specific hardcoded paths:

```text
C:\folder\file
```

or manual string joins using:

```text
"\\"
```

instead of platform-agnostic `path.join()` or `path.resolve()`.

---

# 24. UNIX PATH ASSUMPTIONS

Conversely, assumptions like:

```text
/tmp/file
```

may fail or behave unexpectedly on non-Unix runtimes.

---

# 25. FILESYSTEM PERSISTENCE

Local development filesystems are persistent.

Serverless cloud execution environments are ephemeral and read-only (except `/tmp`).

Look for:

```text
write file
↓
expect file later
```

within production request lifecycles.

---

# 26. TEMP DIRECTORY

If the runtime only provides a transient scratch filesystem, verify that the application never treats it as durable long-term storage.

---

# 27. CURRENT WORKING DIRECTORY

Look for code presuming a specific current working directory (`cwd`).

Build and deployment pipelines may invoke processes from divergent parent roots.

---

# 28. FILE PERMISSIONS

Development accounts often enjoy elevated permissions compared to unprivileged production containers.

Inspect:

- read permissions
- write permissions
- execution permissions

---

# 29. EXECUTABLE ASSUMPTIONS

Look for process invocations calling:

```text
ffmpeg
python
bash
sh
cmd.exe
powershell
```

Verify that the required binary is genuinely installed in the production container image.

---

# 30. SHELL DIFFERENCES

A script command valid in:

```text
bash
```

may immediately fail under:

```text
cmd.exe
```

and vice versa.

---

# 31. CROSS-PLATFORM `npm` SCRIPTS

Review `package.json` scripts for Unix-specific constructs:

```text
VAR=value command
rm -rf
cp
mv
```

If the development team includes Windows engineers, flag cross-platform script breakages.

---

# 32. LINE ENDINGS

CRLF vs LF discrepancies are less frequent, but impact:

- shell scripts
- generated files
- rigid custom parsers

Report only concrete, observed issues.

---

# 33. FILE ENCODING

Verify assumptions regarding UTF-8 encoding.

Particularly with:

- CSV file processing
- legacy third-party data feeds
- Windows-exported files

---

# 34. UNICODE

Test character handling for:

- accented characters (č, ć, š, ž, đ, etc.)
- emojis
- CJK ideograms
- combining diacritical marks

wherever user inputs or filenames pass through the system.

---

# 35. UNICODE NORMALIZATION

Two visually indistinguishable characters may possess divergent Unicode code point representations (NFC vs NFD).

Relevant for:

- usernames
- file lookup keys
- search indices
- database unique constraints

Do not report if the application domain does not ingest such inputs.

---

# 36. LOCALE

Browser and server locales frequently diverge.

Look for:

```ts
toLocaleString()
```

invoked without explicit locale arguments when deterministic, repeatable output is required.

---

# 37. SERVER VS CLIENT LOCALE

SSR hydration mismatch scenario:

```text
server locale = en-US
client locale = sr-RS
```

producing differing initial DOM markup and triggering hydration errors.

---

# 38. NUMBER FORMATTING

Check:

```text
1,234.56
```

versus:

```text
1.234,56
```

especially if formatted display strings are subsequently parsed back into numeric values.

---

# 39. DECIMAL SEPARATORS

Never parse localized display strings as authoritative machine-readable numbers.

---

# 40. DATE PARSING

Browsers and runtimes parse non-standard date strings inconsistently.

Look for:

```ts
new Date("25/09/2026")
```

or other non-ISO date string formats.

---

# 41. ISO DATES

Distinguish between date-only strings:

```text
2026-09-25
```

and full ISO UTC timestamps:

```text
2026-09-25T00:00:00Z
```

Observing how server and browser timezones alter rendered dates.

---

# 42. TIMEZONES

Development laptops and production servers rarely share identical timezone settings.

Look for implicit local time assumptions:

```ts
new Date()
getHours()
setDate()
```

in core business logic.

---

# 43. DAYLIGHT SAVING TIME

If scheduling or date arithmetic crosses daylight saving transitions, inspect edge calculation rules.

---

# 44. CURRENT DATE DURING BUILD

SSG/build pipelines invoking:

```ts
new Date()
```

freeze that timestamp at build time rather than reflecting the active request time.

---

# 45. RANDOM VALUES DURING BUILD

Similarly, inspect:

```ts
Math.random()
```

baked into pre-rendered static artifacts.

---

# 46. NODE VERSION DRIFT

Verify:

- local developer Node version
- `engines` field in `package.json`
- CI/CD container Node version
- production hosting runtime version

Version drift introduces unexpected runtime behavioral variances.

---

# 47. PACKAGE MANAGER VERSION

Lockfile stability depends on:

- npm
- pnpm
- yarn

version consistency.

Verify CI and production installation parity.

---

# 48. LOCKFILES

Production builds must install strictly from committed lockfiles.

Look for:

- multiple competing lockfiles
- git-ignored lockfiles
- installation commands omitting frozen-lockfile flags

---

# 49. OPTIONAL DEPENDENCIES

Native or optional dependencies may install successfully on one OS while failing silently on another.

---

# 50. NATIVE MODULES

Specifically inspect native packages:

- image processing libraries
- embedded SQLite drivers
- cryptographic modules
- canvas libraries
- sharp or similar C++ bindings

for OS and architecture runtime compatibility.

---

# 51. CPU ARCHITECTURE

When deployment or developer environments span:

- x64
- ARM64

verify pre-compiled native binaries.

Do not report if the project contains no native dependencies.

---

# 52. BROWSER API SUPPORT

Search repository-wide for modern Web APIs.

For example:

- Clipboard API
- Web Share API
- ResizeObserver
- IntersectionObserver
- BroadcastChannel
- Web Locks API
- File System Access API
- Notification API
- Web Bluetooth
- WebUSB

Verify support baselines and fallback implementations for each.

---

# 53. FEATURE DETECTION

Prefer robust feature detection:

```ts
if ("share" in navigator)
```

over brittle user-agent string checks wherever possible.

---

# 54. USER-AGENT SNIFFING

Search for:

```text
userAgent
navigator.userAgent
```

Inspect:

- what capability is being inferred
- whether regex patterns risk obsolescence
- whether standard feature detection provides a superior alternative

---

# 55. SAFARI

Carefully review features with historically idiosyncratic browser behavior, but avoid filing generic "Safari bugs".

Pinpoint the exact Web API or CSS property semantics.

---

# 56. IOS SAFARI

Verify where applicable:

- viewport sizing quirks
- fixed positioning bugs
- form input focus zooming
- PWA standalone display
- video playback restrictions
- media autoplay blocks
- file input handling
- safe area insets

---

# 57. FIREFOX

Inspect concrete Web API and CSS engine divergences only where the application relies on the relevant capability.

---

# 58. EDGE

Modern Microsoft Edge shares the Chromium engine, though enterprise policies and security controls may differ.

Do not treat it as a distinct browser engine without specific architectural cause.

---

# 59. WEBKIT PREFIXES

Search for vendor-prefixed CSS rules.

Verify whether standard fallbacks exist where required.

---

# 60. CSS SUPPORT

Identify modern CSS capabilities:

- container queries
- subgrid
- `:has()` pseudo-class
- `dvh` / `svh` / `lvh` units
- `color-mix()`
- native CSS nesting

Verify target browser support baselines before filing findings.

---

# 61. CSS FALLBACKS

If unsupported CSS merely causes minor aesthetic degradation without impairing functionality, assign a low severity.

---

# 62. FLEXBOX EDGE CASES

Inspect:

- `min-content` sizing
- overflow containment
- percentage height calculations
- nested flex containers

only where code structure suggests an authentic cross-engine defect.

---

# 63. GRID EDGE CASES

Apply the same rigor to CSS Grid edge cases.

---

# 64. FORM CONTROLS

Native form controls render and behave differently across browser engines.

Inspect custom styling applied to:

- select dropdowns
- date pickers
- number inputs
- checkboxes
- radio buttons

---

# 65. DATE INPUTS

Native `input type="date"` interfaces and browser support vary widely.

Never rely on native visual pickers for mandatory business logic validation.

---

# 66. NUMBER INPUTS

Browser engines diverge in how they handle:

- localized decimal separators
- stepper spinners
- non-numeric text entry
- mobile virtual keyboards

Server-side validation remains mandatory.

---

# 67. FILE INPUTS

Inspect:

- `accept` attribute filtering
- `multiple` selection behavior
- camera capture triggers
- mobile operating system interactions

---

# 68. CAMERA / MEDIA CAPTURE

When using `getUserMedia`, inspect:

- permission prompt lifecycles
- secure context constraints
- hardware availability guards
- browser compatibility fallbacks

---

# 69. CLIPBOARD

When using the Clipboard API, inspect:

- permission handling
- secure context requirements
- fallback mechanisms for unprivileged contexts

---

# 70. DOWNLOADS

The `download` anchor attribute and blob URL downloads carry platform-specific limitations.

Inspect if file download is a critical product capability.

---

# 71. BLOB URL LIFECYCLE

Verify the blob URL lifecycle:

```text
createObjectURL
↓
download/preview
↓
revokeObjectURL
```

---

# 72. FILESYSTEM ACCESS API

If the application utilizes the File System Access API, verify fallback behavior for unsupported browsers.

---

# 73. WEB SHARE API

Verify graceful fallback when Web Share is absent.

---

# 74. NOTIFICATIONS

Permission models differ fundamentally across operating systems and browser engines.

Do not assume desktop and mobile notification flows are identical.

---

# 75. WEB PUSH

Web push support depends heavily on browser, OS, and platform combinations.

If implemented, provide a concrete capability matrix analysis.

---

# 76. SERVICE WORKERS

Service worker availability alone is insufficient.

Verify the specific underlying capabilities used within the worker on each target platform.

---

# 77. INDEXEDDB

If relying on IndexedDB, inspect:

- private/incognito browsing constraints
- quota exhaustion error paths
- schema migration routines

Do not assert universal behavior without runtime validation.

---

# 78. LOCALSTORAGE

`localStorage` can throw security exceptions in restricted privacy modes or if quotas are exceeded.

Verify error boundary handling on critical paths.

---

# 79. THIRD-PARTY COOKIES

If integrations depend on third-party cookies, modern browser privacy protections (e.g. tracking prevention) will break them.

Trace the end-to-end authentication or integration flow.

---

# 80. OAUTH POPUPS

Popup-based authentication flows frequently break due to:

- aggressive popup blockers
- cross-origin window opener policies
- mobile browser tab behaviors

Verify that a full-page redirect fallback flow exists.

---

# 81. POPUP BLOCKERS

`window.open` must typically be invoked directly within an authentic user gesture context.

If invoked following an asynchronous promise resolution, browsers will suppress the popup.

---

# 82. NEW TAB BEHAVIOR

Verify `target="_blank"` link handling where opener security and user experience are critical.

Defer pure security vulnerabilities to the security audit.

---

# 83. HISTORY API

SPA client-side routers respond differently to:

- direct browser refreshes
- server fallback rewrites
- static hosting hosts

---

# 84. DIRECT ROUTE REFRESH

Classic production deployment bug:

```text
client navigation /dashboard works
↓
hard refresh /dashboard
↓
server returns 404
```

when the hosting provider is not configured for SPA rewrite fallbacks.

---

# 85. STATIC HOSTING REWRITES

If running client-side routers on static cloud storage, verify URL rewrite configurations.

---

# 86. BASE PATH CONFIGURATION

If the application is mounted on a subpath:

```text
/app/
```

verify asset loading, router basenames, links, service workers, and manifests.

---

# 87. TRAILING SLASHES

Hosting platforms differ in how they normalize:

```text
/page
/page/
```

Verify routing consistency.

---

# 88. CDN CACHING

CDNs cache responses according to different rules than local development servers.

Map:

- HTML documents
- static asset bundles
- API endpoints
- redirects
- error responses

---

# 89. CACHED HTML

Stale HTML paired with an updated asset manifest triggers version mismatch failures.

---

# 90. CDN QUERY PARAMETERS

Ensure CDN cache keys properly account for query parameters that alter response content.

---

# 91. `Vary` HEADERS

If responses vary based on:

- Accept-Encoding
- locale
- authentication
- device type

verify that CDN caching rules respect appropriate `Vary` semantics.

---

# 92. PROXY COMPRESSION

Do not add manual compression middleware if upstream reverse proxies or CDNs already compress payloads.

Check for double-compression anomalies or corrupted headers.

---

# 93. MINIFICATION DEFECTS

Production minification can break code relying on:

- `function.name`
- `class.name`
- source code formatting

Look for reflection or runtime introspection patterns.

---

# 94. FUNCTION NAME DEPENDENCY

Example defect:

```ts
fn.name === "SomeHandler"
```

which fails once identifiers are mangled during minification.

---

# 95. CLASS NAME DEPENDENCY

Similarly, verify whether business logic relies on `constructor.name`.

---

# 96. TREE SHAKING HAZARDS

Side-effect imports can be stripped if package manifests erroneously mark modules as `sideEffects: false`.

Report only where concrete runtime symptoms or risks exist.

---

# 97. MODULE INITIALIZATION ORDER

Circular module dependencies often manifest differently after bundling and tree-shaking optimizations.

---

# 98. ESM VS CJS INTEROPERABILITY

Verify module compatibility across:

- default imports
- named imports
- `require()`
- dynamic `import()`

particularly across Node and runtime versions.

---

# 99. DYNAMIC IMPORTS

Import paths that bundlers cannot statically analyze may resolve in development but crash in production bundles.

---

# 100. CASE-SENSITIVE DYNAMIC IMPORTS

Specifically verify casing in dynamically constructed import paths.

---

# 101. SOURCE MAP CONFIGURATION

If source map generation affects operational security or debugging capabilities, document the pattern.

Do not automatically classify public source maps as critical security vulnerabilities without threat context.

---

# 102. PRODUCTION ERROR HANDLING

Development error overlays often mask the fact that production users receive an unhandled blank screen.

Verify global React/framework error boundaries.

---

# 103. CHUNK LOAD FAILURES

Production code splitting frequently encounters:

```text
old page
↓
new deployment
↓
old chunk removed
↓
dynamic import
↓
ChunkLoadError
```

Verify graceful recovery handling.

---

# 104. RELOAD LOOPS

If chunk loading failures trigger automatic page reloads, verify that a loop detection guard prevents infinite reloading.

---

# 105. LAZY ROUTES

Verify what users see if a lazy-loaded route bundle fails to download.

---

# 106. NETWORK SPEED LATENCY

Fast localhost environments conceal:

- loading race conditions
- request timeouts
- skeleton layout shifts
- out-of-order request resolution

Mentally or programmatically test degraded network conditions.

---

# 107. NETWORK DISCONNECTION

Production users can drop connections mid-request.

Verify critical mutation pipelines.

---

# 108. DNS / UPSTREAM FAILURES

While external infrastructure failures cannot always be prevented, client-side behavior must remain graceful when endpoints become unreachable.

---

# 109. CORPORATE FIREWALLS

If an application depends on non-standard ports, custom WebSockets, or external third-party domains, enterprise firewalls may block traffic.

Report only if enterprise networks fall within product requirements.

---

# 110. WEBSOCKETS

Verify:

- reverse proxy WebSocket upgrade support
- secure `wss://` enforcement
- reconnect logic with backoff
- polling fallback mechanisms

---

# 111. SERVER-SENT EVENTS (SSE)

When using Server-Sent Events, inspect:

- proxy buffering behaviors
- gateway timeouts
- browser connection limits per origin

---

# 112. LONG POLLING

Inspect timeout configurations and proxy buffering interactions.

---

# 113. KEEPALIVE FETCH REQUESTS

Browser limits on `fetch(..., { keepalive: true })` during page unload can truncate analytics or save requests.

Never rely on page unload requests for critical persistence without fail-safe architectures.

---

# 114. `beforeunload`

Browser support and UX constraints on `beforeunload` dialogs vary significantly.

Verify actual browser behavior before relying on custom exit prompts.

---

# 115. PAGE LIFECYCLE

Mobile browser engines will suspend or terminate background tabs under memory pressure.

Inspect critical user state residing exclusively in memory.

---

# 116. BACK-FORWARD CACHE (BFCACHE)

BFCache restores previous pages from memory without executing a standard reload.

If the application displays sensitive authenticated state, verify that restore events refresh necessary state.

---

# 117. `pageshow` EVENT

Verify specific `pageshow` handlers (`event.persisted`) for BFCache state reconciliation.

---

# 118. MOBILE MEMORY PRESSURE

Mobile browsers aggressively discard tabs and state under RAM pressure.

Evaluate data-loss risks if user drafts are stored solely in volatile component memory.

---

# 119. APPLICATION BACKGROUNDING

Scenario:

```text
user starts action
↓
switches app
↓
browser suspends page
↓
returns later
```

Inspect:

- stale cached data
- broken timer assumptions
- expired session tokens

---

# 120. TIMERS IN BACKGROUND TABS

Browsers heavily throttle timers (`setTimeout`, `setInterval`) in inactive tabs.

Never depend on client-side intervals for authoritative scheduling or precise timing.

---

# 121. `setInterval` AS AN AUTHORITATIVE CLOCK

If an application uses interval ticks as an authoritative countdown clock, check for drift following tab deactivation.

---

# 122. PAGE VISIBILITY API

If polling or realtime connections are maintained, verify that inactive background tabs pause or throttle non-essential traffic.

---

# 123. SCREEN SIZE VS DEVICE TYPE

Never assume:

```text
small width = mobile device
```

Tablets, split-screen desktop windows, and resized browser viewports produce identical widths.

---

# 124. INPUT MODALITY ASSUMPTIONS

Never assume:

```text
desktop = mouse
mobile = touch
```

Hybrid laptops and touch-enabled desktop monitors are widespread.

---

# 125. POINTER EVENTS

When binding to pointer, mouse, and touch events simultaneously, look for duplicate action triggers.

Example defect:

```text
touchend
+
click
```

firing the same mutation twice in flawed implementations.

---

# 126. PASSIVE EVENT LISTENERS

Passive event listeners on touch and scroll events affect scroll performance and prohibit `preventDefault()`.

Report only where concrete bugs arise.

---

# 127. KEYBOARD LAYOUTS

Hotkeys bound to physical key values (`e.key` vs `e.code`) behave differently across international keyboard layouts.

Relevant for power-user and desktop productivity tools.

---

# 128. INPUT METHOD EDITORS (IME)

For search and text inputs, verify East Asian IME composition handling if the application intercepts `keydown` or triggers real-time search.

Do not report if out of scope for the target user base.

---

# 129. COMPOSITION EVENTS

Ensure Enter key handling does not accidentally submit forms or chat messages while an IME composition session is active.

---

# 130. CLIPBOARD COPY/PASTE

Custom clipboard write actions can fail due to browser permission constraints.

Provide accessible visual fallbacks on critical paths.

---

# 131. DRAG AND DROP

Inspect cross-browser differences in:

- file drops
- touch emulation
- `dataTransfer` payloads

Verify keyboard-accessible alternatives.

---

# 132. DOWNLOAD FILENAMES

Operating systems and browsers sanitize suggested download filenames differently.

Never depend on exact saved filenames for subsequent business logic.

---

# 133. CONTENT-DISPOSITION

Server `Content-Disposition` headers must be tested for proper Unicode filename encoding (RFC 5987 / RFC 6266).

---

# 134. MIME TYPES

Production web servers or CDNs may emit incorrect MIME types, prompting strict browser blocking.

Verify:

- JavaScript (`application/javascript` / `text/javascript`)
- CSS (`text/css`)
- WebAssembly (`application/wasm`)
- Web fonts

---

# 135. NOSNIFF

When `X-Content-Type-Options: nosniff` is enforced, an incorrect MIME type becomes a blocking production bug.

---

# 136. WEB FONT CORS

Web fonts loaded from external origins strictly require valid cross-origin CORS headers.

---

# 137. IMAGE DOMAINS

Production image optimization pipelines will reject external domains not explicitly allowlisted in configuration.

---

# 138. REMOTE ASSETS

Verify domain allowlists for external assets and media.

---

# 139. CONTENT SECURITY POLICY (CSP)

Local development rarely enforces the strict CSP rules applied in production.

Inline scripts or styles functioning locally will be blocked in production.

Trace specific blocked resources.

---

# 140. NONCE / HASH CSP

If the framework generates CSP nonces, verify compatibility with SSR streaming.

Defer comprehensive CSP audits to the security audit.

---

# 141. AD BLOCKERS

If critical application functionality calls endpoints named:

```text
/analytics
/ads
/tracker
```

content and ad blockers will intercept and abort them.

Report only if primary product features depend on those requests.

---

# 142. PRIVACY EXTENSIONS

Similarly, evaluate integrations blocked by privacy extensions restricting third-party storage.

---

# 143. JAVASCRIPT DISABLED

Do not demand that a modern web application function with JavaScript disabled unless specifically required.

Evaluate public SEO content where applicable.

---

# 144. BROWSER EXTENSION INTERFERENCE

Do not attempt to defend against arbitrary browser extension DOM tampering.

However, critical applications should not crash catastrophically due to known extension DOM injections.

---

# 145. AUTOMATIC TRANSLATION

Browser translation features modify DOM text nodes directly.

If application code relies on exact visible text strings for DOM selectors or logic, flag this architectural risk.

---

# 146. PASSWORD MANAGERS

Form markup must adhere to standard semantic conventions so password managers and autofill systems operate cleanly.

---

# 147. AUTOFILL

Browser autofill can populate fields without firing standard synthetic change events in certain frameworks.

Test critical login and checkout forms.

---

# 148. PRINT STYLESHEETS

Only if printing or exporting is an advertised feature.

Otherwise:

**NOT APPLICABLE**

---

# 149. PDF GENERATION

If PDF generation relies on browser rendering (e.g. headless Chrome), verify engine-specific layout fidelity.

---

# 150. BROWSER EXTENSION APIS

If the product itself is a browser extension, this audit must explicitly evaluate:

- Chromium
- Firefox
- Manifest V3 vs V2
- Permission declarations

Otherwise:

**NOT APPLICABLE**

---

# 151. WEBASSEMBLY

If WebAssembly is used, inspect:

- MIME type serving
- target browser engine support
- thread and SIMD prerequisites
- cross-origin isolation headers

---

# 152. SHAREDARRAYBUFFER

If using `SharedArrayBuffer`, verify mandatory cross-origin isolation headers (`COOP`/`COEP`) and browser support.

---

# 153. CROSS-ORIGIN ISOLATION

`COOP` and `COEP` enforcement can inadvertently block unconfigured third-party embeds or images.

---

# 154. FEATURE FLAGS

Production feature flag configurations frequently diverge entirely from local development states.

Map critical feature flags.

---

# 155. STALE FEATURE FLAGS

If clients cache feature flag states, determine how long obsolete behavior persists.

---

# 156. BUILD FLAGS

Build-time compile flags require a fresh deployment to update.

Do not mistake them for dynamic runtime configuration.

---

# 157. PREVIEW ENVIRONMENTS

Preview deployment environments often feature:

- different domain origins
- divergent OAuth callback registrations
- separate API backends
- differing robots and CORS rules

Never treat a passing preview build as conclusive proof of production health.

---

# 158. STAGING DRIFT

Compare configuration across:

```text
development
staging
production
```

Look for environment discrepancies that alter runtime behavior.

---

# 159. PRODUCTION DATA SHAPES

Development test fixtures are typically clean and well-formed.

Real production data contains:

- null values
- extremely long strings
- diverse Unicode characters
- massive array payloads
- legacy schema artifacts

This represents a production compatibility failure even when not browser-specific.

---

# 160. LEGACY DATA

Ensure newly deployed code remains backwards compatible with legacy database records.

---

# 161. LEGACY CLIENTS

Users can keep open browser tabs across new production releases.

Verify API contract compatibility between old frontends and new backends.

---

# 162. LEGACY SERVICE WORKERS

If a PWA is implemented, defer deep auditing to the PWA audit, but flag cross-version compatibility defects here.

---

# 163. DATABASE CONNECTION RUNTIMES

When moving from a single persistent local Node process to serverless compute, database connection pooling behavior changes drastically.

---

# 164. GLOBAL IN-MEMORY STATE

Look for:

```ts
const cache = new Map()
```

treated as an authoritative single source of truth on the server.

In serverless or multi-instance clusters, memory is not globally synchronized.

---

# 165. SINGLE-INSTANCE ASSUMPTIONS

Development runs on a single server process.

Production environments scale horizontally across multiple instances.

Look for in-memory:

- mutexes/locks
- request counters
- rate limiters
- session stores
- task queues

---

# 166. LOCAL LOCKS

An in-memory mutex fails to protect concurrent operations across multiple production instances.

---

# 167. DUPLICATE CRON JOBS

If every application instance startup registers scheduled jobs, horizontal autoscaling will trigger duplicate job executions.

---

# 168. UN-AWAITED BACKGROUND TASKS

Serverless functions terminate execution as soon as the HTTP response finishes.

Look for:

```ts
sendResponse()
doAsyncWorkWithoutAwait()
```

which will be abruptly frozen or killed in serverless environments.

---

# 169. GATEWAY TIMEOUTS

Local development servers do not enforce strict 15-30 second edge request timeouts.

Identify long-running operational bottlenecks.

---

# 170. PAYLOAD SIZE LIMITS

Cloud platforms and API gateways enforce body and upload size limits (e.g. 4.5MB).

Verify file upload limits against target infrastructure specifications.

---

# 171. RESPONSE SIZE LIMITS

Apply the same scrutiny to massive server responses.

---

# 172. EDGE RUNTIME CONSTRAINTS

If routes execute on Edge runtimes, verify compatibility:

- Node.js core API absences
- filesystem absences
- native binary module incompatibilities
- database driver constraints

---

# 173. NODE-ONLY PACKAGES

Packages that build cleanly may throw fatal runtime errors when invoked inside an Edge runtime.

---

# 174. SERVER ACTION / FUNCTION REGIONS

If compute functions and database clusters reside in distant geographical regions, production network latency increases significantly.

---

# 175. CUSTOM DOMAINS AND DNS

If routing depends on host headers or domain matching, verify custom domain configurations independently of platform-generated URLs.

---

# 176. EMAIL VERIFICATION LINKS

Generated transactional email links must resolve to the authoritative production domain, never `localhost` or preview URLs.

---

# 177. WEBHOOK CALLBACKS

Verify public webhook receiver URLs against production domain configurations.

---

# 178. OAUTH CALLBACK URLS

OAuth identity providers require exact redirect URI allowlisting.

A working local callback provides no guarantee that production redirect URIs are registered.

---

# 179. CSP REPORTING

Ensure production CSP violations are reported and testable in staging environments where feasible.

---

# 180. LOGGING INFRASTRUCTURE

Production logging layers may serialize objects differently or silence log levels.

Ensure critical error handling does not depend on `console.log` side effects.

---

# 181. ERROR MASKING

Production environments suppress stack traces.

Client UI components must never rely on parsing development error message strings.

---

# 182. SOURCE MAP PIPELINES

If production telemetry and APM depend on source maps, verify symbol upload pipelines.

---

# 183. RUNTIME FEATURE DETECTION

For every optional Web API, verify:

```text
supported
↓
normal path

unsupported
↓
fallback
```

---

# 184. POLYFILL AUDIT

Map the application's polyfill strategy.

Look for:

- missing polyfills for declared target browsers
- conflicting global polyfills
- obsolete legacy polyfills bloating bundle payloads unnecessarily

Do not flag a package merely because it is mature.

---

# 185. TRANSPILATION TARGETS

Ensure compiler output syntax aligns with declared target browser versions.

If the build outputs modern syntax that target engines fail to parse, report a critical compatibility bug.

---

# 186. THIRD-PARTY PACKAGE BROWSER SUPPORT

External dependencies may deprecate older browser engines before the core application does.

Verify dependency syntax compatibility against target baselines.

---

# 187. CSS AUTOPREFIXING

If targeting browser engines requiring vendor prefixes, verify PostCSS and Autoprefixer configurations.

Do not inject manual CSS prefixes if build tooling handles it automatically.

---

# 188. JAVASCRIPT SYNTAX VS RUNTIME APIS

Distinguish syntax transpilation from runtime API availability.

Babel or TypeScript can transpile syntax:

```text
optional chaining (?.)
```

but will not polyfill global runtime methods automatically:

```text
structuredClone()
```

---

# 189. `structuredClone`

If used, verify target browser support baselines or fallback logic.

---

# 190. `crypto.randomUUID`

Similarly, check support and secure context requirements.

---

# 191. `Intl` APIS

Advanced internationalization APIs have staggered browser adoption.

Verify:

- `Intl.Segmenter`
- `Intl.DisplayNames`
- `Intl.RelativeTimeFormat`

---

# 192. `URLPattern` API

Verify target support before relying on native `URLPattern`.

---

# 193. OBSERVER APIS

Verify:

- `IntersectionObserver`
- `ResizeObserver`
- `MutationObserver`

against declared target baselines.

---

# 194. HTML `<dialog>` ELEMENT

If using native `<dialog>`, verify browser support and backdrop polyfill requirements.

---

# 195. POPOVER API

Verify support baselines and fallback strategies for the native HTML Popover API.

---

# 196. VIEW TRANSITIONS API

If relying on the View Transitions API, verify graceful degradation when unsupported.

---

# 197. CSS `:has()` SELECTOR

Verify engine support baselines.

---

# 198. CONTAINER QUERIES

Similarly verify CSS Container Queries against target environments.

---

# 199. BROWSER MATRIX TESTING

If automated E2E test suites exist, inspect which engines are actively executed:

```text
Chromium
Firefox
WebKit
```

If tests execute solely on Chromium:

do not claim verified cross-browser compatibility.

---

# 200. MOBILE TEST MATRIX

Inspect whether automated tests evaluate:

- iOS WebKit behavior
- Android Chromium behavior

where applicable.

---

# 201. VISUAL REGRESSION TESTING

A visual regression test passing on one engine does not guarantee pixel-identical rendering on others.

---

# 202. PRODUCTION BUILD TESTING

Essential mandate:

Where tooling permits, test against:

```text
production build
↓
production server
↓
critical user flows
```

Never base a compatibility audit exclusively on development server execution.

---

# 203. CLEAN INSTALLATION

Execute clean dependency installations only where safe and accessible.

Document package manager and runtime details.

---

# 204. BUILD VERIFICATION

If you cannot execute a production build:

```text
PRODUCTION BUILD: NOT VERIFIED
```

---

# 205. PREVIEW / STARTUP

If the framework exposes:

```text
build
start
```

evaluate the compiled artifact directly wherever possible.

---

# 206. BROWSER AUTOMATION

Where tooling allows, validate critical flows across multiple browser engines.

Priority:

- authentication
- navigation
- complex forms
- file operations
- critical transactions

---

# 207. DEVTOOLS CONSOLE

Search for engine-specific:

- errors
- warnings
- blocked asset loads
- CSP violations
- CORS rejections
- React hydration mismatches

---

# 208. NETWORK PANEL INSPECTION

Inspect:

- failed requests
- MIME type mismatches
- redirect chains
- CORS preflight failures
- cache headers
- chunk loading failures

---

# 209. SERVER ERROR LOGS

Production-only bugs often surface with client symptoms but stem from backend root causes.

Trace both ends of the wire.

---

# 210. FINDING FORMAT

Every serious finding must include:

```text
ID:
Severity:
Category:
Confidence:
Status:

Environment:
Browser:
OS:
Runtime:
Build mode:

Feature/Route:
File:
Relevant code/config:

Problem:

Evidence:

Why development does not expose it:

Reproduction:

Expected behavior:

Actual behavior:

Affected users/environments:

Impact:

Root cause:

Recommended remediation:

Cross-browser fallback:

Verification matrix:

Regression test:

Complexity:
XS / S / M / L / XL
```

If a value cannot be verified:

**NOT VERIFIED**

---

# 211. SEVERITY

Use:

## P0 - CRITICAL

- critical security or data-integrity defect surfacing in production
- catastrophic cross-user data leakage or irrecoverable data loss

## P1 - HIGH

- application or primary feature broken in a major supported browser
- production-only failure breaking a core user flow
- production deployment fails to boot reliably
- severe authentication, cookie, or CORS blockage

## P2 - MEDIUM

- important feature failing across a subset of supported environments
- confirmed production bug with an available workaround

## P3 - LOW

- localized browser or platform bug on secondary functionality

## P4 - IMPROVEMENT

- compatibility optimization without an existing failure

---

# 212. CONFIDENCE

Use:

```text
HIGH
MEDIUM
LOW
```

HIGH:

reproduced in the specific target environment or irrefutably demonstrated through configuration.

MEDIUM:

strong code/config evidence, but the target runtime was not executed directly.

LOW:

depends on unverified browser/platform specifics.

---

# 213. STATUS

Use:

```text
CONFIRMED
LIKELY
THEORETICAL
NOT VERIFIED
```

---

# 214. SUPPORT STATUS

For browser-specific findings, state:

```text
Browser support:
SUPPORTED TARGET
UNSUPPORTED TARGET
TARGET NOT DEFINED
```

A bug in a browser engine explicitly out of scope does not carry the same priority as one in a supported target.

---

# 215. FALSE-POSITIVE PREVENTION

Before confirming a finding, review:

1. target browser support matrix
2. framework behavior
3. transpilation pipeline
4. polyfill inclusions
5. component library internals
6. deployment configuration
7. CDN/proxy rules
8. runtime engine version
9. native browser behavior
10. production build outputs
11. automated test suites

Do not report an issue solely because a modern Web API is invoked.

---

# 216. DO NOT MODIFY CODE

During the audit:

- do not inject polyfills
- do not edit browserslist
- do not modify build targets
- do not alter CDN headers
- do not modify CORS configurations
- do not alter runtime configurations
- do not patch dependencies

Complete the audit first.

---

# 217. OUTPUT - BROWSER_PRODUCTION_COMPATIBILITY_AUDIT.md

Structure the final audit report as follows:

## 1. Executive Summary

- technology stack
- defined browser support scope
- deployment model
- primary cross-browser risks
- primary production-only risks
- runtime verification coverage

## 2. Browser Support Matrix

| Browser/Platform | Targeted | Tested | Result |
|---|---|---|---|

## 3. Environment Matrix

## 4. Development vs Production Differences

## 5. Build & Bundling Audit

## 6. Environment Variables Audit

## 7. Filesystem / OS Compatibility

## 8. Browser API Compatibility

## 9. CSS Compatibility

## 10. Forms & Input Compatibility

## 11. Auth / Cookie / CORS Compatibility

## 12. Routing / Hosting Compatibility

## 13. CDN / Cache Compatibility

## 14. Runtime Compatibility

## 15. Node / Edge / Serverless Audit

## 16. Locale / Date / Time Audit

## 17. Mobile Browser Audit

## 18. Production Data Compatibility

## 19. Dependency Compatibility

## 20. Existing Cross-Browser Tests

## 21. Findings Summary

| ID | Severity | Environment | Feature | Problem | Confidence | Status |
|---|---|---|---|---|---|---|

## 22. P0 Findings

## 23. P1 Findings

## 24. P2 Findings

## 25. P3 Findings

## 26. P4 Improvements

## 27. Things Done Well

## 28. Unsupported / Out-of-Scope Platforms

## 29. Unknown / Not Verified

## 30. Remediation Roadmap

---

# 218. WINDOWS TO LINUX PASS

If development involves Windows and production runs on Linux, re-examine:

- path casing
- path separators
- shell commands
- executable binary names
- file permissions
- line endings
- filesystem persistence

---

# 219. LOCAL TO SERVERLESS PASS

Simulate:

```text
one persistent local Node process
↓
many ephemeral production instances
```

Ask:

- what lives in process memory
- what is written to local disk
- which lock is process-local
- which scheduled job assumes a single instance

---

# 220. CHROME TO SAFARI PASS

For critical browser features, re-examine only explicitly utilized Web APIs and CSS features.

Do not generate an unfocused list of historical Safari grievances.

---

# 221. DESKTOP TO MOBILE BROWSER PASS

Ask:

- does the Web API exist on mobile browsers
- does the permission model work on mobile
- do popup flows succeed
- does the file picker function
- does mobile background tab suspension disrupt the flow

---

# 222. DEV TO PROD BUILD PASS

For every critical feature, ask:

> Could code splitting, minification, environment variable inlining, or tree shaking alter this behavior?

If no concrete technical rationale exists:

do not invent a finding.

---

# 223. FAST NETWORK TO SLOW NETWORK PASS

Ask:

> What race condition or timeout assumption becomes visible only when a request takes significantly longer?

---

# 224. SINGLE TAB TO LONG-LIVED TAB PASS

Simulate a user leaving the application open for hours or days.

Inspect:

- authentication token expiration
- newly deployed release versions
- stale CDN and cache storage
- WebSocket reconnection logic
- throttled timer intervals
- BFCache restoration

---

# 225. OLD CLIENT TO NEW BACKEND PASS

Critical during continuous deployment workflows.

Ask:

> Can yesterday's client bundle communicate safely with today's newly deployed backend?

Verify:

- required request fields
- new enum values
- removed endpoints
- modified response payloads

---

# 226. NEW CLIENT TO OLD BACKEND PASS

During rolling zero-downtime deployments, the inverse is equally probable.

Verify forward and backward compatibility.

---

# 227. PRODUCTION ERROR PASS

Deliberately analyze what users observe when:

- a chunk bundle fails to download
- an API CORS check fails
- an environment variable is absent
- a static asset returns 404
- a browser API is missing
- an auth cookie is omitted

Never accept an unhandled blank screen as an acceptable failure mode.

---

# 228. DIRECT URL PASS

For every primary SPA route, mentally test:

```text
paste URL into fresh browser
↓
Enter
```

Never evaluate client-side router navigation in isolation.

---

# 229. PRIVATE BROWSING PASS

If the application depends significantly on local persistence, evaluate private/incognito browsing constraints.

If unverified at runtime:

**NOT VERIFIED**

---

# 230. STRICT PRIVACY PASS

For authentication and third-party integrations, evaluate browser configurations blocking third-party cookies and storage.

Only where the application architecture depends on it.

---

# 231. SECOND PASS

After the environment passes, re-walk every finding as its own skeptic:

- reproduce it in the production build on a target browser or runtime, or state exactly why it could not be reproduced
- check whether feature detection, a polyfill, the transpilation target, a CSS fallback, a proxy or a platform setting already neutralizes it
- confirm that the affected browser, device or runtime is in the supported target matrix
- look for hidden paths: the same API or CSS feature used elsewhere, service workers, cached chunks from an older deploy, third-party scripts, embedded webviews
- check timing and scale: long-lived tabs, slow or flaky networks, a deploy during an open session, several tabs of the same user
- check that the proposed fix does not add unnecessary polyfills, bundle weight or legacy burden

A finding that cannot be tied to a supported environment and a concrete execution path is downgraded to THEORETICAL or NOT VERIFIED.

---

# 232. FINAL QUALITY GATE

Before returning your final response, verify:

- target browser matrix was established before assigning severity
- unsupported browsers were not prioritized over supported targets
- development and production were evaluated independently
- production build tests were not substituted with dev server runs
- browser API findings verified feature detection and polyfills
- CSS findings checked actual target engine support baselines
- Windows vs Linux discrepancies were analyzed where applicable
- local filesystems were not assumed persistent in serverless runtimes
- process memory was not assumed shared across server instances
- CORS defects were not asserted from source inspection alone if proxies resolve them
- cookie defects verified domain, SameSite, and Secure scopes
- date and locale defects detailed concrete execution flows
- legacy-client to new-backend compatibility was evaluated
- chunk deployment mismatches were evaluated
- theoretical concerns were not reported as confirmed bugs
- every P1/P2 finding names the affected environment
- recommendations do not introduce unnecessary polyfills or legacy burdens

---

# FINAL RULE

I do not want generic reports like:

> Test the application in Chrome, Firefox, and Safari and add necessary polyfills.

That is not a compatibility audit.

I am hunting for concrete failure mechanisms:

```text
Windows development
↓
filesystem import is case-insensitive
↓
import "./button"
↓
actual file Button.tsx
↓
Linux production build
↓
module not found
```

or:

```text
local development
↓
frontend and API same-origin through dev proxy
↓
cookies work
↓
production frontend and API on different origins
↓
SameSite/CORS config incompatible
↓
login appears broken only in production
```

or:

```text
production v1 page remains open
↓
v2 deployment removes old lazy chunk
↓
user opens rarely-used feature
↓
browser requests old chunk
↓
404
↓
feature crashes
```

or:

```text
server renders date using UTC
↓
browser renders same value using local timezone
↓
different visible text
↓
hydration mismatch
```

or:

```text
local persistent Node process
↓
in-memory rate limit works
↓
production has multiple serverless instances
↓
each instance has its own counter
↓
effective limit can be bypassed
```

These are the precise defects you must uncover.

Think through the boundaries between:

- browser rendering engines
- operating systems
- filesystems
- development environments
- production optimized builds
- persistent vs ephemeral runtimes
- single-process vs multi-instance topologies
- localhost vs production domain origins
- high-speed vs degraded networks
- newly deployed vs legacy client tabs
- divergent locale and timezone configurations

If a target environment could not be executed:

**NOT VERIFIED.**

If a browser engine is out of scope:

explicitly state that the finding is outside the supported target scope.

If it is merely an optimization:

**P4 - IMPROVEMENT.**

It is better to discover 7 authentic production-only bugs than to generate a massive catalog of theoretical browser discrepancies.

The objective is a forensically rigorous compatibility audit exposing everything that "works on my machine" locally, but will break the instant the application leaves the developer's workstation.

分类与标签

编程开发、浏览器兼容、生产故障、跨平台测试、缺陷复现

前往 AI 图片创作