# OpenPWA

> The reference for Progressive Web Apps — APIs, browser compatibility, and ecosystem
> & store policy, in English and Chinese, kept current. Structured browser, platform,
> and ecosystem-policy data that search answer-engines and LLMs can quote.

OpenPWA is a reference kept current in place; News carries dated long-form articles written from PWA ecosystem signals and linked back into the reference. Prose entries are also served
as clean Markdown at `<entry-url>.md` for ingestion, and the full corpus is
inlined at https://openpwa.net/llms-full.txt.


## Reference
- [Reference](https://openpwa.net/reference/): The PWA knowledge tree — manifest, service workers, installability, device capabilities, storage, notifications, performance, and platforms — kept current and source-backed.
- [Capabilities](https://openpwa.net/reference/capabilities/): Device and platform capabilities: File System, Web Share, Bluetooth, WebGPU, Payment, and more.
- [Async Clipboard API: reading and writing the clipboard](https://openpwa.net/reference/capabilities/clipboard/): How navigator.clipboard.writeText/write and readText/read work, the secure-context and user-gesture requirements, the Clipboard permission model, and the legacy execCommand fallback.
- [Contact Picker API: letting users share selected contacts, not the whole address book](https://openpwa.net/reference/capabilities/contact-picker/): How the Contact Picker API's navigator.contacts.select() lets a user pick specific contacts and choose which fields to share with a site, why it requires a secure context and a user gesture, and why MDN marks it experimental and not Baseline.
- [Credential Management API](https://openpwa.net/reference/capabilities/credential-management/): navigator.credentials lets a site create, store, and retrieve sign-in credentials: the four credential types, the mediation modes, and the browser gaps.
- [Digital Goods API (Play Billing in TWAs)](https://openpwa.net/reference/capabilities/digital-goods/): The Digital Goods API lets a PWA running in a Trusted Web Activity query SKUs and purchases through Google Play Billing, alongside the Payment Request API.
- [Document Picture-in-Picture: always-on-top window](https://openpwa.net/reference/capabilities/document-picture-in-picture/): How the Document Picture-in-Picture API opens an always-on-top HTML window, its requestWindow() options, feature detection, and Chrome/Firefox browser support.
- [EyeDropper API: sampling on-screen colors](https://openpwa.net/reference/capabilities/eyedropper/): How the EyeDropper() constructor and open() method let a page sample a pixel's color anywhere on screen for a custom color picker, why open() requires a user gesture, and the desktop-only, Chromium-only support starting at Chrome and Edge 95.
- [File System Access API: read and write local files](https://openpwa.net/reference/capabilities/file-system-access/): Pickers, file and directory handles, the permission model, persisting handles in IndexedDB, OPFS, and what to fall back to where the pickers do not exist.
- [Geolocation API: accessing the user's location](https://openpwa.net/reference/capabilities/geolocation/): How navigator.geolocation works, the explicit permission prompt, secure-context requirement, getCurrentPosition vs watchPosition, accuracy hints, and privacy considerations.
- [Idle Detection API: watching for user and screen inactivity](https://openpwa.net/reference/capabilities/idle-detection/): How the IdleDetector interface reports whether the user is active or idle and whether the screen is locked or unlocked, its permission model and 60-second minimum threshold, and where it is (and is not) implemented.
- [Local Font Access API: enumerating the fonts installed on a device](https://openpwa.net/reference/capabilities/local-font-access/): How window.queryLocalFonts() lets a page enumerate locally installed fonts as FontData objects, the local-fonts permission it requires, why it does not need to return every font, and where it ships.
- [Local Network Access: a local-request prompt](https://openpwa.net/reference/capabilities/local-network-access/): How Chrome shows a Local Network Access permission prompt before a public page can reach a device on the local network, replacing silent preflight-only checks.
- [Media Session API](https://openpwa.net/reference/capabilities/media-session/): How navigator.mediaSession sets metadata and action handlers for OS-level media controls, with Chrome, Firefox, and Safari support versions.
- [Navigation API](https://openpwa.net/reference/capabilities/navigation-api/): How window.navigation and the navigate event let single-page apps intercept and control browser navigations, with Chrome, Firefox, and Safari support versions.
- [Payment Request API: browser-mediated checkout](https://openpwa.net/reference/capabilities/payment-request/): How PaymentRequest standardises checkout across browsers, the payment-method identifier system, the show()/abort() lifecycle, shipping and contact fields, and the secure-context requirement.
- [Manifest protocol_handlers: registering a PWA for custom URL schemes](https://openpwa.net/reference/capabilities/protocol-handlers/): How the manifest's protocol_handlers member registers an installed PWA to handle clicks on a given URL scheme, the web+ naming rule for custom schemes, and the %s placeholder that carries the clicked URL into your app.
- [Screen Capture API (getDisplayMedia)](https://openpwa.net/reference/capabilities/screen-capture/): getDisplayMedia() lets a page prompt the user to capture a screen, window, or tab as a MediaStream, for recording locally or sending over WebRTC.
- [Generic Sensor API](https://openpwa.net/reference/capabilities/sensors/): The Generic Sensor API exposes device sensors like Accelerometer and Gyroscope through common interfaces, behind a secure-context and Permissions API check.
- [Storage Buckets API: named partitions](https://openpwa.net/reference/capabilities/storage-buckets/): How navigator.storageBuckets creates separately named storage buckets, how Chrome exposes IndexedDB inside them, and the history of the durability option.
- [VirtualKeyboard API](https://openpwa.net/reference/capabilities/virtual-keyboard/): How the VirtualKeyboard API lets a page opt out of automatic viewport resizing and read the on-screen keyboard's geometry, with Chrome/Firefox/Safari support.
- [Screen Wake Lock API: keeping the screen on](https://openpwa.net/reference/capabilities/wake-lock/): How navigator.wakeLock.request() prevents the screen from dimming, the secure-context requirement, the automatic release on page visibility change, and when to use wake lock vs. other keep-alive patterns.
- [Web Bluetooth API: connecting to Bluetooth Low Energy devices](https://openpwa.net/reference/capabilities/web-bluetooth/): How navigator.bluetooth.requestDevice() requests access to Bluetooth Low Energy devices, the user-activation and secure-context requirements, and the GATT model.
- [WebHID API: navigator.hid device access from the web](https://openpwa.net/reference/capabilities/web-hid/): Pair a HID device with navigator.hid.requestDevice(), handle connect and disconnect events, and meet the secure-context and activation rules.
- [Web Locks API: exclusive and shared named locks](https://openpwa.net/reference/capabilities/web-locks/): How navigator.locks.request() grants exclusive or shared named locks to coordinate work, its storage-bucket scoping, and its secure-context restriction.
- [Web NFC: reading and writing NFC tags from the web](https://openpwa.net/reference/capabilities/web-nfc/): How NDEFReader.scan() and write() exchange NDEF messages with NFC tags, the spec's secure-context and visible-top-level-document requirements, the "nfc" permission prompt, and the current non-Baseline browser support starting at Chrome for Android 89.
- [Web Serial API: navigator.serial device access](https://openpwa.net/reference/capabilities/web-serial/): How navigator.serial.requestPort() and getPorts() grant page access to a serial port, which browsers support it, and how to feature-detect it with a fallback.
- [Web Share API: native share sheet from the browser](https://openpwa.net/reference/capabilities/web-share/): How navigator.share() triggers the OS share sheet, what data types it accepts, the user-gesture requirement, and when to fall back to a copy-to-clipboard pattern.
- [WebUSB API: connecting to non-standard USB devices from the web](https://openpwa.net/reference/capabilities/web-usb/): How navigator.usb.requestDevice() pairs with USB devices outside the standard device classes, the transient-activation and secure-context requirements, the permission/chooser model, and the optional landing-page mechanism.
- [WebAuthn and passkeys](https://openpwa.net/reference/capabilities/webauthn-passkeys/): How the Web Authentication API and passkeys give a PWA phishing-resistant, passwordless sign-in — credential creation and assertion, discoverable credentials, platform vs roaming authenticators, and cross-device sync.
- [WebCodecs: low-level, hardware-accelerated audio and video encoding](https://openpwa.net/reference/capabilities/webcodecs/): How the WebCodecs API's VideoEncoder, VideoDecoder, AudioEncoder, and AudioDecoder give per-frame, hardware-accelerated access to encoding and decoding inside a Dedicated Web Worker, and its fully-specified codec-string requirement.
- [WebGPU: GPU rendering and compute in the browser](https://openpwa.net/reference/capabilities/webgpu/): How navigator.gpu.requestAdapter()/requestDevice() expose the GPU for rendering and compute via WGSL, current Chrome/Firefox/Safari support, and the WebGL2 fallback path.
- [WebRTC: peer-to-peer audio, video, and data](https://openpwa.net/reference/capabilities/webrtc/): How getUserMedia, RTCPeerConnection, and RTCDataChannel fit together: signaling, ICE candidates, rendering the remote stream in a video element, and hang-up.
- [WebTransport: HTTP/3 streams and datagrams](https://openpwa.net/reference/capabilities/webtransport/): Send data over HTTP/3 with reliable streams and unreliable datagrams, how to detect support, and where Chrome, Edge, Firefox and Safari stand.
- [Window Management API: placing windows across multiple screens](https://openpwa.net/reference/capabilities/window-management/): How window.screen.isExtended and Window.getScreenDetails() expose multi-screen layout details, the window-management permission prompt, the secure-context requirement, and today's Chromium-only support per MDN.
- [Installation](https://openpwa.net/reference/installation/): Installability criteria, install prompts, badging, and the N+1 problem.
- [Badging API: app icon badges for installed PWAs](https://openpwa.net/reference/installation/badging/): How to set and clear numeric or presence badges on a PWA's app icon using the Badging API, with per-platform support notes for Android, iOS, and desktop.
- [Desktop PWA installation: Chrome, Edge, and beyond](https://openpwa.net/reference/installation/desktop-install/): How PWA installation works on Windows, macOS, Linux, and ChromeOS — install UI, window management, OS integration, and per-platform differences.
- [getInstalledRelatedApps(): detecting an installed native or PWA counterpart](https://openpwa.net/reference/installation/get-installed-related-apps/): How navigator.getInstalledRelatedApps() lets a web app check whether a related Android, UWP, or PWA counterpart declared in related_applications is already installed, and the verification each platform requires.
- [beforeinstallprompt and custom install prompts](https://openpwa.net/reference/installation/install-prompt/): How beforeinstallprompt works, how to defer and trigger it from a user gesture, installability criteria, and why iOS requires a manual Add to Home Screen.
- [Install prompt UX: when and how to surface your install button](https://openpwa.net/reference/installation/install-prompt-ux/): Best-practice patterns for timing, placement, and copy of a custom PWA install prompt using the beforeinstallprompt API, including iOS and desktop fallbacks.
- [App shortcuts after install](https://openpwa.net/reference/installation/install-shortcuts/): Manifest shortcuts are only displayed by right-clicking or long-pressing the app icon, meaning they only become available once the PWA is installed — not from a browser tab.
- [Installability criteria: what makes a PWA installable](https://openpwa.net/reference/installation/installability-criteria/): The exact criteria a PWA must meet before browsers show an install prompt or let a user add the app to their home screen, broken down by platform.
- [iOS Add to Home Screen: PWA installation on iOS](https://openpwa.net/reference/installation/ios-add-to-home-screen/): How PWA installation works on iOS and iPadOS — the manual Add to Home Screen gesture, what the Home Screen entry can do, and the iOS 26 change to web app mode.
- [The N+1 install problem: one PWA, multiple independent installs](https://openpwa.net/reference/installation/n-plus-one/): How installing a PWA is tied to the browser used to install it, so the same PWA can end up installed as separate, data-isolated instances from different browsers on one device — and why the browser that installed it is the only one aware of the installed state.
- [Richer install UI: enriching the install prompt with description and screenshots](https://openpwa.net/reference/installation/richer-install-ui/): How providing values for the manifest description and screenshots members adds those values to the install prompt on Android only, versus the browser's default prompt which shows just the app's name and icon.
- [Trusted Web Activity (TWA): PWAs in the Play Store](https://openpwa.net/reference/installation/twa/): What a Trusted Web Activity is, how it differs from a WebAPK, how Digital Asset Links verification works, and when to use TWA vs other install paths.
- [Uninstalling an installed PWA](https://openpwa.net/reference/installation/uninstall-retention/): How users uninstall an installed PWA on desktop and iOS, and where each platform surfaces the management UI, per MDN and Microsoft Edge's own documentation.
- [WebAPK: how Chrome installs PWAs on Android](https://openpwa.net/reference/installation/webapk/): What a WebAPK is, how Chrome mints and updates it, what capabilities it unlocks compared to a web shortcut, and its limitations.
- [Web app manifest: the minimal one that works](https://openpwa.net/reference/manifest/): The JSON file that makes a site installable — a minimal working manifest, how to link it, which members matter, and where each one is documented.
- [Manifest categories](https://openpwa.net/reference/manifest/categories/): The categories manifest member lists classifications such as productivity or games that help users discover a web app in app stores and other catalogs.
- [Manifest description: optional app-store text](https://openpwa.net/reference/manifest/description/): The description manifest member is optional text for app-store listings; Chrome has supported it since version 88, but Firefox and Safari do not implement it.
- [Manifest display modes: standalone vs fullscreen](https://openpwa.net/reference/manifest/display/): What the manifest display member controls, the fallback chain across fullscreen, standalone, minimal-ui and browser, and how to choose a mode.
- [display_override: opting into window-controls-overlay and tabbed modes](https://openpwa.net/reference/manifest/display-override/): How the manifest display_override array lets a PWA request display modes outside the fixed display fallback chain — window-controls-overlay and tabbed — while keeping a safe display fallback for older browsers.
- [Manifest edge_side_panel: pinning a PWA to the Microsoft Edge sidebar](https://openpwa.net/reference/manifest/edge-side-panel/): How the edge_side_panel manifest member and its preferred_width property let a PWA opt in to the Microsoft Edge sidebar, how to detect the sidebar context, and that Microsoft has announced this feature is being deprecated.
- [Manifest file_handlers](https://openpwa.net/reference/manifest/file-handlers/): How the file_handlers manifest member registers an installed PWA as an OS-level handler for specific file types, and how window.launchQueue delivers the opened file to your app code.
- [handle_links: link handling for installed PWAs](https://openpwa.net/reference/manifest/handle-links/): What the proposed handle_links member does (auto, preferred, not-preferred), how it relates to scope_extensions and launch_handler, and its status today.
- [Manifest icons and maskable icons](https://openpwa.net/reference/manifest/icons/): What the manifest icons member does, which properties are actually required, when a maskable icon is needed, and how to verify the icons you shipped at runtime.
- [Web app manifest id: a stable PWA identity](https://openpwa.net/reference/manifest/id/): The manifest id member pins an installed PWA's identity independently of start_url, so a changed URL never creates a duplicate install.
- [Manifest launch_handler: controlling how an installed app launches](https://openpwa.net/reference/manifest/launch-handler/): How the launch_handler manifest member's client_mode controls whether launching an installed web app focuses or navigates an existing window or opens a new one, its four values, their fallback behavior, and its current experimental, non-Baseline browser support.
- [Manifest localization: lang, dir, and *_localized members](https://openpwa.net/reference/manifest/localization/): How the Web App Manifest's dir and lang members set default text direction and language, and how the *_localized member pattern (name_localized, short_name_localized, description_localized, icons_localized) provides per-field translations with locale fallback.
- [How installed PWAs pick up manifest changes](https://openpwa.net/reference/manifest/manifest-updates/): Chrome checks an installed PWA's manifest roughly once a day and applies most updates, like a new name or theme color, only after every window closes.
- [Manifest name and short_name](https://openpwa.net/reference/manifest/name-short-name/): How the name and short_name manifest members control your PWA's display label in install prompts, home screens, app switchers, and OS launchers — and how to choose values that work everywhere.
- [orientation: requesting a PWA's default screen](https://openpwa.net/reference/manifest/orientation/): What the manifest orientation member requests, how it relates to the separate Screen Orientation API, and what happens when a value isn't honored.
- [Manifest protocol_handlers](https://openpwa.net/reference/manifest/protocol-handlers/): The protocol_handlers manifest member registers a web app in the OS's application preferences as a handler for URL schemes such as mailto or web+jngl.
- [related_applications and prefer_related_applications](https://openpwa.net/reference/manifest/related-applications/): How the manifest's related_applications array points to platform-specific apps (platform, url, id), and how the prefer_related_applications boolean hints browsers to offer a native app instead of the web app.
- [Manifest scope: your PWA's navigation boundary](https://openpwa.net/reference/manifest/scope/): How the manifest scope member decides which URLs get the app-like interface, how prefix matching and the fallback scope work, and how to test a URL at runtime.
- [scope_extensions: extending a PWA's scope across origins](https://openpwa.net/reference/manifest/scope-extensions/): How the experimental scope_extensions manifest member and its required .well-known/web-app-origin-association verification file let a PWA treat pages on other origins as in-scope, and why MDN flags it as experimental.
- [Manifest screenshots and richer install UI](https://openpwa.net/reference/manifest/screenshots/): How the screenshots manifest member supplies promotional images that browsers display in richer install dialogs and app-store-style previews, with accepted formats, platform constraints, and form_factor guidance.
- [Manifest share_target](https://openpwa.net/reference/manifest/share-target/): How the share_target manifest member registers your installed PWA as a target in the OS native share sheet — receiving shared URLs, text, titles, and files from other apps.
- [Manifest shortcuts](https://openpwa.net/reference/manifest/shortcuts/): How the shortcuts manifest member adds quick-action entries to the OS long-press or right-click context menu of your installed PWA — jumplist items on Windows, home-screen context menus on Android, and Dock shortcuts on macOS.
- [Manifest start_url](https://openpwa.net/reference/manifest/start-url/): How the start_url manifest member sets the entry point your PWA loads when launched from the home screen or app launcher, and how to design it for deep links, analytics, and scope alignment.
- [Tabbed application mode and tab_strip](https://openpwa.net/reference/manifest/tabbed-display/): How the experimental tabbed display_override value and the tab_strip member give an installed PWA its own tab strip, and how home_tab configures it.
- [Manifest theme_color and background_color](https://openpwa.net/reference/manifest/theme-background-color/): How the theme_color and background_color manifest members control the browser chrome color and the splash screen background of your installed PWA — including browser support, meta tag interaction, and dark-mode considerations.
- [Manifest widgets: PWA content on the OS widgets board](https://openpwa.net/reference/manifest/widgets/): How the manifest widgets member declares OS-widget-board entries for a PWA — the tag, template/ms_ac_template, data, icons and screenshots fields, the service-worker widgetinstall flow, and current Microsoft Edge/Windows 11 support.
- [Notifications](https://openpwa.net/reference/notifications/): Web Push, permissions, and periodic background sync.
- [iOS and Safari Web Push (16.4+)](https://openpwa.net/reference/notifications/ios-safari-push/): Web Push on iOS, iPadOS and Safari: the Home Screen requirement, the gesture-bound prompt, VAPID subscriptions, and the WebKit rules to design around.
- [The Notification interface: constructing and reading a single notification](https://openpwa.net/reference/notifications/notification/): The Notification() constructor and its options (body, icon, tag, data, requireInteraction), the click/close/error events, and why calling it directly throws a TypeError on nearly all mobile browsers per MDN.
- [Notification actions and badge options](https://openpwa.net/reference/notifications/notification-actions-badge/): How Notification actions buttons and the badge image option work, their persistent-notification requirement, and current browser support per MDN.
- [Notification triggers: the discontinued showTrigger / TimestampTrigger proposal](https://openpwa.net/reference/notifications/notification-triggers/): What Chrome's Notification Triggers API (showTrigger and TimestampTrigger) was meant to do, its feature-detection pattern, why Chrome's team ended its development, and why showTrigger and TimestampTrigger are absent from MDN's current showNotification() options reference.
- [The Notifications API: system notifications](https://openpwa.net/reference/notifications/notifications-api/): How a PWA shows OS-level notifications: the permission model, persistent versus non-persistent notifications, and why mobile means persistent ones.
- [Periodic background sync for content updates](https://openpwa.net/reference/notifications/periodic-background-sync/): How periodic background sync gives an installed PWA a silent periodic refresh, why Chrome gates it on install and engagement, and how to test it in DevTools.
- [The notification permission model](https://openpwa.net/reference/notifications/permissions/): How Notification.permission's three states work, why requestPermission() needs a user gesture, and why MDN says to stop prompting once a user has said no.
- [Web Push: subscriptions, permissions, and delivery](https://openpwa.net/reference/notifications/web-push/): How the Push API, VAPID subscriptions, the permission model, and the service worker push/notificationclick events fit together — and why iOS requires an installed PWA.
- [Performance](https://openpwa.net/reference/performance/): INP / Core Web Vitals, View Transitions, and Speculation Rules.
- [The app shell model](https://openpwa.net/reference/performance/app-shell/): How the app shell pattern caches a page's markup, styles, scripts, and images in a service worker so repeat visits render the UI chrome instantly.
- [Back/forward cache (bfcache): instant back and forward navigation](https://openpwa.net/reference/performance/bfcache/): How the back/forward cache stores a full in-memory snapshot of a page — including the JavaScript heap — so back and forward navigations can restore it instantly, why an unload listener can block eligibility in some browsers, and how to detect a bfcache restore with the pageshow event's persisted property.
- [Code splitting with dynamic import() in a PWA](https://openpwa.net/reference/performance/code-splitting/): How dynamic import() splits a bundle so startup loads less JavaScript, what that does to INP and LCP, and where it cannot be used in a PWA.
- [Core Web Vitals for PWAs: LCP, INP, and CLS](https://openpwa.net/reference/performance/core-web-vitals/): What LCP, INP, and CLS measure, their good/needs-improvement thresholds at the 75th percentile, field vs lab data, and the PWA-specific levers that move each metric.
- [Font and image optimization: font-display, picture, and AVIF/WebP](https://openpwa.net/reference/performance/fonts-images/): How the font-display CSS descriptor controls text visibility while a web font loads, how the img loading and fetchpriority attributes and the picture element control image delivery, and how AVIF and WebP compress smaller than JPEG and PNG per MDN.
- [Lighthouse PWA audits](https://openpwa.net/reference/performance/lighthouse/): Lighthouse audits pages for performance, accessibility and SEO. Its PWA category was removed, because those checks were tied to Chrome installability criteria.
- [Navigation preload as a performance fix: starting the network request while the service worker boots](https://openpwa.net/reference/performance/navigation-preload/): Why service worker boot-up time (commonly around 50ms on desktop and up to several hundred ms on mobile per web.dev) adds to Time to First Byte for navigations, how enabling navigation preload starts the network request while the worker is still booting, and when it does and doesn't help.
- [Precaching strategies: shipping the app shell ahead of time](https://openpwa.net/reference/performance/precaching/): How precaching populates the cache during service-worker install so a PWA's shell loads instantly and offline — what to precache vs runtime-cache, why content revisioning matters, and how Workbox's precache manifest automates it.
- [Resource hints: rel="preload" and rel="preconnect"](https://openpwa.net/reference/performance/resource-hints/): The difference between fetching a specific resource early with rel="preload" and warming up a connection with rel="preconnect", the as/crossorigin attributes that make preload avoid a double fetch, and their Baseline widely-available support per MDN.
- [Speculation Rules API: prefetching and prerendering likely next pages](https://openpwa.net/reference/performance/speculation-rules/): How a <script type="speculationrules"> JSON block tells the browser which URLs to prefetch or prerender before the user navigates, the eagerness levels that control timing, and why support is Chromium-first — Safari only experimentally supports prefetch, and Firefox does not implement it at all.
- [Startup performance: paint and navigation timings](https://openpwa.net/reference/performance/startup-performance/): Measure the wait before your app's content appears, using the paint entries first-paint and first-contentful-paint plus the navigation timing milestones.
- [View Transitions](https://openpwa.net/reference/performance/view-transitions/): Animating between DOM states with document.startViewTransition() for same-page transitions, and the @view-transition at-rule for cross-document navigations.
- [Platforms](https://openpwa.net/reference/platforms/): Safari/iOS, Chrome/Android, desktop, and Baseline 2026.
- [Baseline support overview](https://openpwa.net/reference/platforms/baseline-2026/): What Baseline means, the widely-available / newly-available / limited-availability tiers, the seven tracked browsers, the 30-month window, and Baseline 2026 as the currently developing yearly cohort.
- [PWAs on Chrome and Android (WebAPK, TWA)](https://openpwa.net/reference/platforms/chrome-android/): How PWAs install and run on Chrome for Android — the beforeinstallprompt flow, the WebAPK Chrome generates for you, and Trusted Web Activity for Google Play.
- [PWAs on ChromeOS (launcher, shelf, file handling)](https://openpwa.net/reference/platforms/chromeos/): How an installed PWA integrates into ChromeOS — appearing in the launcher and shelf like a native app, plus badging, Web Share/Share Target, and File Handling — and how to feature-detect each capability with a fallback.
- [PWAs on desktop](https://openpwa.net/reference/platforms/desktop/): How Chrome and Edge install a PWA from the desktop URL bar, what the manifest display fallback chain gives you, and why each browser keeps its own copy.
- [PWAs on Microsoft Edge (sidebar, store)](https://openpwa.net/reference/platforms/edge/): How Microsoft Edge installs a PWA through its browser install feature, lists PWAs in the Microsoft Store, and supports a deprecated sidebar manifest member.
- [PWAs on Firefox](https://openpwa.net/reference/platforms/firefox/): What installing a web app means on Firefox — taskbar web apps on Windows since Firefox 143, manifest-driven installation on Firefox for Android, no install prompt or beforeinstallprompt anywhere — and how to write install-flow code that does not assume one exists.
- [PWAs on iOS and Safari](https://openpwa.net/reference/platforms/ios-safari/): How PWAs install and run on iOS and iPadOS — Add to Home Screen, web app mode, Web Push and badging for Home Screen apps, and the WebKit limits to design for.
- [PWAs on Safari for macOS (Dock apps)](https://openpwa.net/reference/platforms/macos-safari/): How web apps install and run on macOS via Safari's Add to Dock — what macOS Sonoma and Safari 17 introduced, how the manifest shapes the Dock app, what works (push, notifications), and how it differs from iOS.
- [PWAs on Samsung Internet](https://openpwa.net/reference/platforms/samsung-internet/): How Samsung Internet installs PWAs: the manual Add to Home screen menu and the ambient-badging plus icon triggered by a standalone or fullscreen manifest.
- [PWAs on Windows](https://openpwa.net/reference/platforms/windows/): How Microsoft Edge installs a PWA on Windows and integrates it into the Taskbar, Start menu, and Alt+Tab switching, plus the FSLogix logout limitation.
- [Service workers: what they are, and a minimal one](https://openpwa.net/reference/service-worker/): The programmable network proxy behind offline PWAs — a minimal registration, the lifecycle in one pass, the traps, and where each part is documented.
- [Background Fetch: downloading large files that survive tab closure](https://openpwa.net/reference/service-worker/background-fetch/): How the Background Fetch API hands a long-running download to the browser itself, which shows the user progress and a cancel control and wakes the service worker with an event once the download finishes.
- [Background sync: retrying failed requests](https://openpwa.net/reference/service-worker/background-sync/): How the Background Sync API defers a failed request until the device regains connectivity, its registration/event API, and execution-time limits.
- [The Cache API](https://openpwa.net/reference/service-worker/cache-api/): How to open, populate, query, and delete caches using the Cache Storage API — the durable key/value store for Request/Response pairs available to service workers and pages.
- [Caching strategies for service workers](https://openpwa.net/reference/service-worker/caching-strategies/): The five standard caching strategies — Cache First, Network First, Stale-While-Revalidate, Network Only, Cache Only — when to use each, and how Workbox implements them.
- [The Clients API: a service worker's access to client objects](https://openpwa.net/reference/service-worker/clients-api/): How the Clients interface, exposed to a service worker as self.clients, provides get(), matchAll(), openWindow(), and claim() to find, focus, message, or take control of window and worker clients, and its Baseline widely-available browser support.
- [Debugging service workers](https://openpwa.net/reference/service-worker/debugging/): How to inspect, force-update, and diagnose service workers using Chrome DevTools, Firefox DevTools, and Safari Web Inspector — covering registration state, cache contents, fetch interception, and update flow.
- [The service worker fetch event and routing](https://openpwa.net/reference/service-worker/fetch-event/): How the FetchEvent interface works, how to respond with event.respondWith(), and patterns for routing requests to different handlers.
- [Service worker lifecycle: install to update](https://openpwa.net/reference/service-worker/lifecycle/): How a service worker registers, installs, activates, waits, and updates — and how skipWaiting and clients.claim change who controls the page.
- [Navigation preload: hiding service worker boot time from navigations](https://openpwa.net/reference/service-worker/navigation-preload/): How the NavigationPreloadManager lets the browser start fetching a navigation request in parallel with service worker boot-up, how to enable it and read FetchEvent.preloadResponse, the Service-Worker-Navigation-Preload header, and its Baseline widely-available status since April 2022.
- [Offline fallback for service workers](https://openpwa.net/reference/service-worker/offline-fallback/): How to serve a meaningful offline page when both the cache and the network are unavailable, using the service worker fetch event and a pre-cached fallback response.
- [Periodic background sync: refreshing content while the app is closed](https://openpwa.net/reference/service-worker/periodic-background-sync/): How the Periodic Background Sync API lets an installed PWA's service worker periodically download fresh content in the background, the registration and event API, and why Chrome restricts it to installed, engaged apps.
- [Service worker registration and scope](https://openpwa.net/reference/service-worker/registration-scope/): How navigator.serviceWorker.register() works, what scope controls, and how to align registration with your URL structure.
- [The service worker update flow and skipWaiting](https://openpwa.net/reference/service-worker/update-skipwaiting/): How the browser detects a new service worker version, what the waiting state means, and how skipWaiting() and clients.claim() opt into an immediate takeover.
- [Workbox](https://openpwa.net/reference/service-worker/workbox/): What Workbox is, how its modular packages map to service worker tasks, and how to add it to a project with or without a build tool.
- [Storage](https://openpwa.net/reference/storage/): Quotas, persistence, eviction, and the Storage Access API.
- [Cache Storage: the request/response store behind offline PWAs](https://openpwa.net/reference/storage/cache-storage/): How the Cache Storage API stores Request/Response pairs for offline-capable PWAs — the CacheStorage and Cache interfaces, where it runs, how it differs from the HTTP cache, and the practical rules for versioning and cleanup.
- [Clearing site data: the Clear-Site-Data response header](https://openpwa.net/reference/storage/clearing-data/): How the Clear-Site-Data HTTP response header's cache, cookies, storage, executionContexts, prefetchCache, and prerenderCache directives remove a site's browsing data on logout, its quoted-string syntax requirement, secure-context restriction, and Baseline-since-September-2023 support.
- [Eviction and best-effort vs persistent storage](https://openpwa.net/reference/storage/eviction/): How browsers classify per-origin storage as best-effort or persistent, the least-recently-used order they evict best-effort origins in under storage pressure, and why eviction always clears a whole storage bucket at once.
- [IndexedDB: structured client-side storage for PWAs](https://openpwa.net/reference/storage/indexeddb/): How IndexedDB stores structured data and large blobs in the browser — object stores, indexes, transactions, the asynchronous request model, versioned schema upgrades, and why most apps reach for a wrapper.
- [localStorage and sessionStorage](https://openpwa.net/reference/storage/localstorage/): How localStorage and sessionStorage differ, their same-origin and per-origin quota rules, and why private-browsing behavior actually varies by browser.
- [Origin Private File System (OPFS)](https://openpwa.net/reference/storage/opfs/): How navigator.storage.getDirectory() exposes a per-origin, user-invisible file storage endpoint, the synchronous FileSystemSyncAccessHandle methods available only inside dedicated Web Workers, and the Baseline-widely-available-since-March-2023 browser support.
- [CHIPS: partitioned third-party cookies, explained](https://openpwa.net/reference/storage/partitioned-storage-chips/): Set-Cookie: Partitioned gives a third-party cookie its own jar per top-level site. What CHIPS changes, how to set it, and where it is supported.
- [Storage persistence, quotas, and eviction](https://openpwa.net/reference/storage/persistence/): How the StorageManager API estimates quota and requests persistent storage, how browsers grant it, what gets evicted under pressure, and how to keep offline data durable.
- [Quotas and StorageManager.estimate()](https://openpwa.net/reference/storage/quota-estimate/): What navigator.storage.estimate() reports, how browsers compute the per-origin quota, why the numbers are deliberately imprecise, and how to budget storage and handle QuotaExceededError.
- [Storage Access API: third-party cookies in iframes](https://openpwa.net/reference/storage/storage-access-api/): How hasStorageAccess() and requestStorageAccess() let embedded cross-site content reach third-party cookies browsers block by default, and the gesture required.

## Compatibility
- [Compatibility](https://openpwa.net/compatibility/): The "Can I PWA?" data explorer — browser, OS, version, and country-weighted reach for every PWA capability, plus the ad, payment, and store policy dimensions no general reference carries.
- [Compatibility data API](https://openpwa.net/compatibility/api/): Fetch OpenPWA's PWA compatibility dataset as JSON — a feature index, per-feature support and policy rows with provenance, and country-weighted reach. CC BY 4.0.
- [Background Fetch support](https://openpwa.net/compatibility/background-fetch/): The Background Fetch API hands a long download off to the browser, which shows progress and a cancel control, then wakes the service worker once it settles.
- [Background Sync](https://openpwa.net/compatibility/background-sync/): Defer actions until the user has stable connectivity via the service worker.
- [Badging API](https://openpwa.net/compatibility/badging-api/): Set an app-icon badge (count or dot) on the installed PWA.
- [By browser](https://openpwa.net/compatibility/by-browser/): Feature × browser-family support pivot for PWA capabilities.
- [By country / region](https://openpwa.net/compatibility/by-country/): Effective PWA reach weighted by real-world browser share — the differentiator.
- [By feature](https://openpwa.net/compatibility/by-feature/): Per-capability PWA support matrices: OS × browser × version.
- [By OS](https://openpwa.net/compatibility/by-os/): Feature × operating-system support pivot for PWA capabilities.
- [Async Clipboard API](https://openpwa.net/compatibility/clipboard/): navigator.clipboard lets a page read and write the system clipboard programmatically, gated by a user gesture or the clipboard-read/clipboard-write permission.
- [Chinese vendor browsers](https://openpwa.net/compatibility/cn-vendor-browsers/): PWA install, standalone display, service worker and Web Push in Huawei, Xiaomi, OPPO, UC, QQ Browser and the WeChat WebView, from vendor documentation only.
- [Contact Picker support](https://openpwa.net/compatibility/contact-picker/): Browser support for the Contact Picker API, letting a page ask users to pick contacts via a browser-presented picker and share only selected fields.
- [EyeDropper API](https://openpwa.net/compatibility/eyedropper/): The EyeDropper API opens a browser-supplied eyedropper so a custom color picker can sample any on-screen pixel and read it back as an sRGB hex string.
- [File System Access API](https://openpwa.net/compatibility/file-system-access/): Read and write to the user's local file system with explicit permission.
- [Geolocation support](https://openpwa.net/compatibility/geolocation/): Read the user's geographic position with explicit permission, one-shot or via a watch.
- [getInstalledRelatedApps() browser support](https://openpwa.net/compatibility/get-installed-related-apps/): navigator.getInstalledRelatedApps() detects installed related Android, Windows, or PWA apps from the manifest. Chromium ships it; Firefox and Safari do not.
- [Idle Detection API](https://openpwa.net/compatibility/idle-detection/): The Idle Detection API reports whether the user is active or idle and whether the screen is locked, behind a permission grant and a 60-second threshold.
- [Install Prompt (beforeinstallprompt)](https://openpwa.net/compatibility/install-prompt/): Programmatic control over the PWA install prompt via the beforeinstallprompt event.
- [Local Font Access support](https://openpwa.net/compatibility/local-font-access/): window.queryLocalFonts() lets a page enumerate the fonts installed on a user's device as FontData objects, gated behind a local-fonts permission prompt.
- [Web App Manifest: categories support](https://openpwa.net/compatibility/manifest-categories/): The manifest categories member declares classifications for a web app. Browsers may parse this optional member, but it does not affect the app.
- [Manifest: description support](https://openpwa.net/compatibility/manifest-description/): The manifest description member has been supported in Chrome since version 88, but Firefox and Safari do not implement it.
- [Web App Manifest: display](https://openpwa.net/compatibility/manifest-display/): The display member chooses the installed app's window mode (standalone, fullscreen, minimal-ui, browser).
- [Web App Manifest: display_override](https://openpwa.net/compatibility/manifest-display-override/): The display_override member gives a PWA a fallback chain of display modes, so it can prefer newer ones like window-controls-overlay and still degrade safely.
- [manifest edge_side_panel browser support](https://openpwa.net/compatibility/manifest-edge-side-panel/): edge_side_panel is a Microsoft Edge-only manifest member for pinning a PWA to the sidebar. Microsoft has announced it is being deprecated.
- [manifest: file_handlers support](https://openpwa.net/compatibility/manifest-file-handlers/): Browser and platform support for the Web App Manifest file_handlers member — registering an installed PWA as an OS-level handler for specific file types.
- [manifest: handle_links support](https://openpwa.net/compatibility/manifest-handle-links/): Browser support for the Web App Manifest handle_links member, a WICG proposal letting an installed PWA suggest that in-scope links open inside the app.
- [Web App Manifest: icons](https://openpwa.net/compatibility/manifest-icons/): The icons member supplies home-screen, task-switcher, and install-dialog imagery for a PWA. It also supports maskable icons that adapt to platform-specific shapes.
- [manifest: id](https://openpwa.net/compatibility/manifest-id/): The id member of the Web App Manifest provides a stable identity for a PWA, decoupled from the start_url.
- [manifest: launch_handler support](https://openpwa.net/compatibility/manifest-launch-handler/): Browser and platform support for the Web App Manifest launch_handler member and its client_mode sub-field — controlling whether launching an installed PWA reuses an existing window or opens a new one.
- [manifest lang / dir browser support](https://openpwa.net/compatibility/manifest-localization/): The Web App Manifest's dir and lang members are defined by the spec, but MDN notes they are not implemented by any browser today.
- [Web App Manifest: name / short_name](https://openpwa.net/compatibility/manifest-name-short-name/): The name and short_name members define how a PWA is labelled in install prompts, the app shelf, and the home screen.
- [Web App Manifest: orientation support](https://openpwa.net/compatibility/manifest-orientation/): The manifest orientation member sets an installed web app's default screen orientation, such as portrait or landscape, at launch and while running.
- [Manifest: related_applications support](https://openpwa.net/compatibility/manifest-related-applications/): related_applications lists native or store apps tied to a PWA; prefer_related_applications hints a browser to favor installing one instead.
- [Web App Manifest: scope](https://openpwa.net/compatibility/manifest-scope/): The scope member fences the installed app's navigation boundary.
- [manifest: scope_extensions support](https://openpwa.net/compatibility/manifest-scope-extensions/): Browser support for the Web App Manifest scope_extensions member, letting an installed PWA's navigation scope span other origins opted in via a hosted file.
- [Web App Manifest: screenshots](https://openpwa.net/compatibility/manifest-screenshots/): The screenshots member supplies richer install UI in browsers and store listings.
- [manifest: share_target support](https://openpwa.net/compatibility/manifest-share-target/): Browser and platform support for the Web App Manifest share_target member — registering your PWA as a target in the OS native share sheet.
- [manifest: shortcuts support](https://openpwa.net/compatibility/manifest-shortcuts/): Browser and platform support for the Web App Manifest shortcuts member — quick-action entries in the OS context menu of an installed PWA.
- [Web App Manifest: start_url](https://openpwa.net/compatibility/manifest-start-url/): The start_url member identifies the URL that loads when a user launches an installed PWA from the home screen or app shelf.
- [manifest: display_override "tabbed" mode](https://openpwa.net/compatibility/manifest-tabbed-display/): The "tabbed" display_override value lets a PWA show a tab strip in its own window; Chrome documentation reports that it has shipped on ChromeOS.
- [Web App Manifest: theme_color / background_color](https://openpwa.net/compatibility/manifest-theme-background-color/): The theme_color and background_color manifest members set a PWA's UI color and splash background; Safari supports theme_color but not background_color.
- [manifest widgets browser support](https://openpwa.net/compatibility/manifest-widgets/): The widgets manifest member registers PWA widgets on an operating-system widgets board. Microsoft documents it for the Windows 11 Widgets Board.
- [Notification Triggers support](https://openpwa.net/compatibility/notification-triggers/): Notification Triggers proposed a showTrigger option to schedule a notification via a TimestampTrigger. Chrome's docs say development ended before it shipped.
- [Payment Request API](https://openpwa.net/compatibility/payment-request/): Browser-mediated checkout sheet collecting payment and contact details.
- [Periodic Background Sync support](https://openpwa.net/compatibility/periodic-background-sync/): The Periodic Background Sync API lets an installed PWA refresh content in the background, gated by installation and Chrome's engagement heuristics.
- [Persistent Storage](https://openpwa.net/compatibility/persistent-storage/): navigator.storage.persist() requests protection from automatic data eviction by the browser.
- [Policy dimension](https://openpwa.net/compatibility/policy/): Ad, payment, and store-acceptance policy as first-class compatibility data.
- [Manifest Protocol Handlers](https://openpwa.net/compatibility/protocol-handlers/): Register a PWA to handle custom or allow-listed URL protocols via manifest.protocol_handlers.
- [Generic Sensor API](https://openpwa.net/compatibility/sensors/): The Sensor APIs expose device sensors such as Accelerometer and Gyroscope through a common design, in secure contexts and behind a Permissions API grant.
- [Service Workers](https://openpwa.net/compatibility/service-worker/): The programmable network proxy that powers offline, caching, and push for PWAs.
- [Storage Buckets support](https://openpwa.net/compatibility/storage-buckets/): The Storage Buckets API lets a page create separately named buckets, each with its own IndexedDB, Cache, and eviction policy, instead of one origin-wide pool.
- [Trusted Web Activity availability](https://openpwa.net/compatibility/twa/): Trusted Web Activity opens your PWA from an Android app as a full-screen browser tab, with no browser UI, once Digital Asset Links verification passes.
- [Screen Wake Lock support](https://openpwa.net/compatibility/wake-lock/): The Screen Wake Lock API lets a page ask the device to keep its screen on, releasing the lock automatically once the tab is hidden.
- [Web Bluetooth API](https://openpwa.net/compatibility/web-bluetooth/): The Web Bluetooth API lets a web app reach nearby Bluetooth Low Energy devices via navigator.bluetooth.requestDevice() and talk to their GATT services.
- [WebHID API](https://openpwa.net/compatibility/web-hid/): The WebHID API lets a web app reach non-standard Human Interface Devices via navigator.hid.requestDevice() and exchange input, output, and feature reports.
- [Web NFC API](https://openpwa.net/compatibility/web-nfc/): The Web NFC API lets a web app read and write NDEF messages to NFC tags through the NDEFReader interface, on Chromium-based Android browsers.
- [Web Push](https://openpwa.net/compatibility/web-push/): Server-sent push messages delivered via the Push API + service worker, even when the app is closed.
- [WebRTC support](https://openpwa.net/compatibility/web-rtc/): Establish real-time peer-to-peer audio, video, and data connections directly between browsers.
- [Web Serial API](https://openpwa.net/compatibility/web-serial/): The Web Serial API lets a web app open a serial port via navigator.serial.requestPort() and read or write through the port's readable and writable streams.
- [Web Share API](https://openpwa.net/compatibility/web-share/): The Web Share API invokes the platform-native share sheet so users can share text, URLs, or files from a PWA. The Share Target extension lets a PWA receive shared content.
- [WebUSB API](https://openpwa.net/compatibility/web-usb/): The WebUSB API lets a web app request access to non-standard USB devices via navigator.usb.requestDevice() and communicate with them directly.
- [WebAPK availability](https://openpwa.net/compatibility/webapk/): Browser support for WebAPK — the mechanism Chrome uses to install PWAs as real Android apps with their own package identity.
- [WebAuthn / passkeys support](https://openpwa.net/compatibility/webauthn/): PublicKeyCredential lets a PWA register and verify public-key credentials instead of passwords; passkeys are discoverable WebAuthn credentials.
- [WebCodecs API](https://openpwa.net/compatibility/webcodecs/): The WebCodecs API gives web apps low-level, hardware-accelerated encode and decode of individual video frames and audio chunks, down at the codec level.
- [WebGPU](https://openpwa.net/compatibility/webgpu/): WebGPU exposes GPU rendering and compute to the web via navigator.gpu.requestAdapter()/requestDevice() and the WGSL shading language.
- [WebTransport support](https://openpwa.net/compatibility/webtransport/): WebTransport is a web API for low-latency, bidirectional messaging over HTTP/3, carrying reliable streams and unreliable datagrams on one connection.
- [Window Management API browser support](https://openpwa.net/compatibility/window-management/): The Window Management API (getScreenDetails, isExtended) is supported in Chromium browsers. Firefox and Safari have not implemented it.

## Guides
- [Guides](https://openpwa.net/guides/): Task-oriented how-tos and learning paths for building Progressive Web Apps — from your first PWA to installability, offline, performance, and advanced topics.
- [Advanced](https://openpwa.net/guides/advanced/): Production-grade capabilities — push, file access, and platform integration — added as progressive enhancement with a compatibility check at every step.
- [Distribute a PWA via app stores](https://openpwa.net/guides/app-store-distribution/): Wrap your PWA in a Trusted Web Activity for Google Play, package it with PWA Builder for the Microsoft Store, and hide install banners from users who have it.
- [Debug a PWA](https://openpwa.net/guides/debugging/): How to use Chrome DevTools' Application panel — Manifest, Service Workers, Cache Storage — to inspect and troubleshoot a PWA while developing it.
- [Discoverability: SEO and structured data for PWAs](https://openpwa.net/guides/discoverability/): How structured data (JSON-LD) and crawlable HTML help search engines understand a PWA and qualify it for rich results, checked with the Rich Results Test.
- [Handle files](https://openpwa.net/guides/file-handling/): A step-by-step guide to registering an installed PWA as an OS-level file handler — declaring file_handlers in the manifest, wiring the launchQueue consumer, and falling back when the API is unavailable.
- [Getting started](https://openpwa.net/guides/getting-started/): Build and ship your first installable PWA — add a manifest, register a service worker, and meet the installability bar — end to end.
- [Make it installable](https://openpwa.net/guides/installable/): Go beyond the minimum bar — meet every installability criterion and design an install moment that earns the add-to-home-screen.
- [Migrate from a native app to a PWA](https://openpwa.net/guides/migrate-from-native/): What a PWA is and the two pieces it rests on — a manifest supplying install metadata, and a service worker that can serve offline — with minimal examples.
- [Monetize a PWA](https://openpwa.net/guides/monetization/): The Payment Request API standardizes checkout so a PWA can collect payment, address, and contact details through the browser's own UI instead of a custom form, and it can surface payment methods such as Google Pay.
- [Offline strategies](https://openpwa.net/guides/offline/): Give the service worker something useful to do — pick a caching strategy per request type and keep the app working without a network.
- [Choosing a caching strategy](https://openpwa.net/guides/offline/caching-strategies/): How to pick the right service worker caching strategy for your PWA — cache-first, network-first, stale-while-revalidate, and when to use each.
- [Performance](https://openpwa.net/guides/performance/): Measure the Core Web Vitals, fix the largest offenders, and use the service worker to make launch feel instant.
- [Add push notifications](https://openpwa.net/guides/push-notifications/): Subscribe a service worker to a push service, ask for notification permission at the right moment, and show the message when the push event arrives.
- [Receive shared content (share target)](https://openpwa.net/guides/share-target/): A step-by-step guide to registering an installed PWA as a share target — declaring share_target in the manifest, handling the GET or POST request it triggers, and storing shared files for the app to read.
- [Add app shortcuts](https://openpwa.net/guides/shortcuts/): A step-by-step guide to adding shortcuts entries to your PWA manifest, so an installed app's icon offers quick-action jumps straight to key screens.
- [Test a PWA](https://openpwa.net/guides/testing/): How to test a PWA's installability and service worker in Chrome DevTools: inspecting the manifest, simulating offline, and forcing a worker update.
- [Update strategies](https://openpwa.net/guides/update-strategies/): Choose how your service worker rolls out a new version — immediate takeover, a user-prompted reload, or the quiet default — and when periodic update checks matter.

## Ecosystem
- [Ecosystem](https://openpwa.net/ecosystem/): PWA ecosystem intelligence — distribution, monetization, ad-network and payment support, store-acceptance policy, and tooling. Decision-grade commercial analysis, with no app catalog.
- [Ad networks](https://openpwa.net/ecosystem/ad-networks/): Which ad networks support PWA inventory, the standalone-vs-browser context that affects payout, and where the sourced, per-network verdicts live.
- [Distribution](https://openpwa.net/ecosystem/distribution/): How PWAs reach users — installable web, Trusted Web Activity on Android, packaged listings in app stores, and desktop install.
- [Monetization](https://openpwa.net/ecosystem/monetization/): The revenue paths open to a PWA — advertising, in-app payments and commerce, subscriptions, and affiliate — and where each is constrained by platform policy.
- [Payments](https://openpwa.net/ecosystem/payments/): Which payment methods and SDKs work inside a PWA — Payment Request, Google Pay, Apple Pay, and provider SDKs — and where the sourced support verdicts live.
- [Store policy](https://openpwa.net/ecosystem/stores/): How each app store packages a PWA — Google Play via TWA, the Microsoft Store as a packaged PWA, and Apple's web-only path — with the sourced accept/partial/reject verdicts owned by the policy data.
- [Tools](https://openpwa.net/ecosystem/tools/): A curated editorial reference of the build, package, audit, and test tooling that matters for PWAs — not a directory, marketplace, or sponsored listing.

## News
- [Safari 27 makes top-level await spec-compliant](https://openpwa.net/news/safari-27-adds-full-spec-compliance-for-top-level-await/): WebKit rebuilt Safari's ES module loader in pure C++, so top-level await now follows the ECMAScript spec instead of an abandoned 2016 proposal.

## Optional
- [中文](https://openpwa.net/zh/): the Chinese mirror, a first-class peer
- [News feed](https://openpwa.net/feed.xml): dated long-form articles on PWA ecosystem changes