From 75126d454151c6810fc76263a48f17f1128a1401 Mon Sep 17 00:00:00 2001
From: Alvin Ji <alvinji@chromium.org>
Date: Thu, 19 Mar 2026 13:37:31 -0700
Subject: [PATCH 01/12] rebase to Chore: remove updatable-rec stuff (#224)

---
 index.html | 663 +++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 470 insertions(+), 193 deletions(-)

diff --git a/index.html b/index.html
index f7c0c64..40a4ab0 100644
--- a/index.html
+++ b/index.html
@@ -67,12 +67,41 @@ <h2>
         System (GPS) and location inferred from network signals such as IP
         address, RFID, WiFi and Bluetooth MAC addresses, and GSM/CDMA cell IDs,
         as well as user input. The API itself is agnostic of the underlying
-        location information sources, and no guarantee is given that the API
-        returns the device's actual location.
+        <dfn>location information source</dfn>s, and no guarantee is given that
+        the API returns the device's actual location.
       </p>
       <p>
-        If an end user [=check permission|grants permission=],
-        <cite>Geolocation</cite>:
+        This specification provides two ways for users to share their location:
+        a <em>precise position</em> and an <em>approximate position</em>.
+      </p>
+      <p>
+        A <dfn>precise position</dfn> is a position returned by the underlying
+        [=location information source=]. By default, any location data is
+        considered precise, regardless of its accuracy estimate, unless it has
+        been explicitly coarsened by an [=approximate location information
+        source=] to be an [=approximate position=].
+      </p>
+      <p>
+        An <dfn>approximate position</dfn> is a less precise,
+        privacy-preserving representation of the user's location. Instead of
+        providing precise coordinates, an [=approximate location information
+        source=] can return a location that is intentionally coarsened to a
+        larger area, such as the nearest city, postal code, or a predefined
+        region. This is often sufficient for applications that don't need to
+        know the user's [=precise position=], for example, a weather
+        application that only needs a city-level location. By sharing an
+        [=approximate position=], users can still get the benefit of a
+        location-aware application without revealing their [=precise
+        position=].
+      </p>
+      <p>
+        An <dfn>approximate location information source</dfn> is a [=location
+        information source=] that returns positions that have been
+        intentionally obfuscated to make it more difficult to recover the true
+        location.
+      </p>
+      <p>
+        If an end user grants permission, <cite>Geolocation</cite>:
       </p>
       <ul>
         <li>Provides location data as latitude, longitude, altitude, speed, and
@@ -127,8 +156,17 @@ <h3>
           Get current position
         </h3>
         <p>
-          Request the user's current location. If the user allows it, you will
-          get back a position object.
+          Request the user's current location. If the user grants permission,
+          the API will return a position object. The website can influence the
+          position's accuracy by using the {{PositionOptions}} dictionary's
+          {{PositionOptions/accuracyMode}} member. By default, the user agent
+          will provide a {{AccuracyMode/"precise"}} location. However, a
+          website can request an [=approximate position=] by setting
+          {{PositionOptions/accuracyMode}} to {{AccuracyMode/"approximate"}},
+          which helps protect user privacy if high accuracy is not required. In
+          addition, the user can instruct the user agent to only provide an
+          approximate position, even if the website requested a precise
+          position.
         </p>
         <aside class="example" title="A one-shot position request">
           <pre class="js">
@@ -138,6 +176,16 @@ <h3>
             });
           </pre>
         </aside>
+        <aside class="example" title="Requesting an approximate position">
+          <pre class="js">
+            navigator.geolocation.getCurrentPosition(position =&gt; {
+              const { latitude, longitude } = position.coords;
+              // Use the approximate location for city-level features, like showing weather.
+            },
+            console.error,
+            { accuracyMode: "approximate" });
+          </pre>
+        </aside>
       </section>
       <section class="informative">
         <h3>
@@ -234,22 +282,37 @@ <h3>
         </h3>
         <p>
           By default, the API always attempts to return a cached position so
-          long as it has a previously acquired position. In this example, we
-          accept a position whose age is no greater than 10 minutes. If the
-          user agent does not have a fresh enough cached position object, it
-          automatically acquires a new position.
+          long as it has a previously acquired position that matches the
+          requested {{PositionOptions/accuracyMode}}. In this example, we
+          accept a precise position whose age is no greater than 10 minutes. If
+          the user agent does not have a fresh enough cached position object of
+          the correct accuracy, it automatically acquires a new position.
+        </p>
+        <aside class="example" title="Getting a cached precise position">
+          <pre class="js">
+            navigator.geolocation.getCurrentPosition(
+              successCallback,
+              console.error,
+              { maximumAge: 600_000 } // `accuracyMode` defaults to "precise"
+            );
+
+            function successCallback(position) {
+            }
+          </pre>
+        </aside>
+        <p>
+          Similarly, you can request a cached approximate position.
         </p>
-        <aside class="example" title="Getting cached position">
+        <aside class="example" title="Getting a cached approximate position">
           <pre class="js">
             navigator.geolocation.getCurrentPosition(
               successCallback,
               console.error,
-              { maximumAge: 600_000 }
+              { maximumAge: 600_000, accuracyMode: "approximate" }
             );
 
             function successCallback(position) {
-              // By using the 'maximumAge' member above, the position
-              // object is guaranteed to be at most 10 minutes old.
+              // This position is approximate and at most 10 minutes old.
             }
           </pre>
         </aside>
@@ -343,17 +406,38 @@ <h2>
         information also discloses the location of the user of the device,
         thereby potentially compromising the user's privacy.
       </p>
+      <p>
+        To mitigate this privacy risk, this specification introduces the
+        {{PositionOptions/accuracyMode}} option, which allows the application
+        to request an [=approximate position=]. This allows applications to
+        function without needing the user's [=precise position=], thus offering
+        a more privacy-friendly alternative. When an application requests an
+        [=approximate position=], the user agent can provide a less precise
+        location that still meets the application's needs while protecting the
+        user's [=precise position=]. Even when a [=precise position=] is
+        requested, the user agent can provide an [=approximate position=]
+        instead, for example, if the user has only granted permission for
+        approximate accuracy.
+      </p>
       <section class="informative">
         <h3>
           User consent
         </h3>
         <p>
-          <cite>Geolocation</cite> is a [=powerful feature=] that requires
-          [=express permission=] from an end-user before any location data is
-          shared with a web application. This requirement is normatively
-          enforced by the [=check permission=] steps on which the
+          <cite>Geolocation</cite> uses the [=powerful feature=]s
+          <a>"geolocation-approximate"</a> and <a>"geolocation"</a>, which
+          require [=express permission=] from an end-user before any location
+          data is shared with a web application. This requirement is
+          normatively enforced by the [=request permission to use=] algorithm,
+          which is customized for precise location by the [=request precise
+          geolocation permission=] steps, on which the
           {{Geolocation/getCurrentPosition()}} and
-          {{Geolocation/watchPosition()}} methods rely.
+          {{Geolocation/watchPosition()}} methods rely. [=User agents=] with
+          support for [=approximate position=] are strongly encouraged to allow
+          the user to choose between sharing a [=precise position=] or an
+          [=approximate position=]. This choice gives users more control over
+          their privacy, allowing them to share a less precise location when
+          they are not comfortable sharing their [=precise position=].
         </p>
         <p>
           An end-user will generally give [=express permission=] through a user
@@ -372,7 +456,7 @@ <h3>
           Although the granularity of the permission [=permission/lifetime=]
           varies across user-agents, this specification urges user agents to
           limit the lifetime to a single browsing session by default (see
-          [[[#check-permission]]] for normative requirements).
+          [[[#permission]]] for normative requirements).
         </p>
       </section>
       <section id="privacy_for_recipients" class="informative">
@@ -399,6 +483,15 @@ <h3>
           stored, users need to be allowed to update and delete this
           information.
         </p>
+        <p>
+          In line with this principle, recipients are strongly encouraged to
+          request the lowest level of location accuracy that is sufficient for
+          their application's functionality. For instance, if an application
+          only needs to know the user's city, it can respect user privacy by
+          requesting an [=approximate position=] by setting the `accuracyMode`
+          option to `"approximate"`. This practice of data minimization is a
+          key aspect of respecting user privacy.
+        </p>
         <p>
           The recipients of location information need to refrain from
           retransmitting the location information without the user’s express
@@ -437,25 +530,120 @@ <h3>
           interfaces that enable revocation of permissions.
         </p>
       </section>
-      <section id="check-permission">
-        <h3>
-          Checking permission to use the API
-        </h3>
+      <section id="permission">
+        <h2>
+          Geolocation permissions
+        </h2>
+        <p>
+          <cite>Geolocation</cite> defines two [=powerful features=] identified
+          by the [=powerful feature/name=]s <code><dfn class=
+          "permission">"geolocation"</dfn></code> (for precise location) and
+          <code><dfn class="permission">"geolocation-approximate"</dfn></code>
+          (for approximate location).
+        </p>
+        <p>
+          <code><a>"geolocation-approximate"</a></code> is a [=default powerful
+          feature=], while <code><a>"geolocation"</a></code> is a [=powerful
+          feature=] with:
+        </p>
+        <ul>
+          <li>A custom [=powerful feature/permission result type=]
+          {{GeolocationPermissionStatus}}:
+            <pre class="idl">
+                [Exposed=(Window,Worker)]
+                interface GeolocationPermissionStatus : PermissionStatus {
+                  readonly attribute AccuracyMode accuracyMode;
+                };
+              </pre>
+          </li>
+          <li>A custom <dfn>precise permission query algorithm</dfn>, which,
+          given a {{PermissionDescriptor}} |permissionDesc| and a
+          {{GeolocationPermissionStatus}} |status|, runs the following steps:
+            <ol class="algorithm">
+              <li>Let |approximatePermissionDesc| be a {{PermissionDescriptor}}
+              with {{PermissionDescriptor/name}} set to
+              <a>"geolocation-approximate"</a>.
+              </li>
+              <li>Let |approximatePermissionState| be
+              |approximatePermissionDesc|'s [=permission state=].
+              </li>
+              <li>If |approximatePermissionState| is [=permission/"granted"=]
+              and |permissionDesc|'s [=permission state=] is
+              [=permission/"prompt"=], set |status|'s to
+              [=permission/"prompt"=]. Otherwise, set |status|'s
+              {{PermissionStatus/state}} to |appxorimatePermissionState|.
+              </li>
+              <li>If |status|'s {{PermissionStatus/state}} is equal to
+              [=permission/"granted"=], set |status|'s
+              {{GeolocationPermissionStatus/accuracyMode}} to
+              {{AccuracyMode/"precise"}} if also |permissionDesc|'s
+              [=permission state=] is [=permission/"granted"=] or to
+              {{AccuracyMode/"approximate"}} otherwise.
+              </li>
+            </ol>
+          </li>
+        </ul>
         <p>
-          <cite>Geolocation</cite> is a [=default powerful feature=] identified
-          by the [=powerful feature/name=] <code><dfn class=
-          "permission">"geolocation"</dfn></code>.
+          To <dfn>request precise geolocation permission</dfn>, the user agent
+          MUST run the following steps.
         </p>
+        <ol class="algorithm">
+          <li>Let |preciseLocationDescriptor| be a new {{PermissionDescriptor}}
+          with {{PermissionDescriptor/name}} set to <a>"geolocation"</a>.
+          </li>
+          <li>Run the [=precise permission query algorithm=] given
+          |preciseLocationDescriptor| and a new {{GeolocationPermissionStatus}}
+          |status|.
+          </li>
+          <li>If |status|'s {{PermissionStatus/state}} is not
+          [=permission/"prompt"=], return |status|.
+          </li>
+          <li>Let |approximateLocationDescriptor| be a new
+          {{PermissionDescriptor}} with {{PermissionDescriptor/name}} set to
+          <a>"geolocation-approximate"</a>.
+          </li>
+          <li>Run the [=powerful feature/permission query algorithm=] given
+          |approximateLocationDescriptor| and a new {{PermissionStatus}}
+          |approximateStatus|.
+          </li>
+          <li>If |approximateStatus|.{{PermissionStatus/state}} is
+          [=permission/"granted"=], [=request permission to use=]
+          |preciseLocationDescriptor|. Otherwise, [=request permission to use=]
+          |approximateLocationDescriptor| and [=request permission to use=]
+          |preciseLocationDescriptor|.
+            <aside class="note">
+              <p>
+                The user agent is free to group the two resulting questions for
+                the user into a single permission prompt, asking the user
+                whether they want to expression permission to grant either
+                approximate or precise geolocation (or none).
+              </p>
+            </aside>
+          </li>
+          <li>Run the [=precise permission query algorithm=] given
+          |preciseLocationDescriptor| and a new {{GeolocationPermissionStatus}}
+          |newGeolocationStatus|.
+          </li>
+          <li>Assert: |newGeolocationStatus|'s state is not
+          [=permission/"prompt"=].
+          </li>
+          <li>Return |newGeolocationStatus|.
+          </li>
+        </ol>
+      </section>
+      <section>
+        <h3>
+          Preventing Precise Location Reconstruction
+        </h3>
         <p>
-          When <dfn data-local-lt="check permission">checking permission</dfn>
-          to use the API, a user agent MAY suggest time-based [=permission=]
-          [=permission/lifetimes=], such as "24 hours", "1 week", or choose to
-          remember the permission [=permission/grant=] indefinitely. However,
-          it is RECOMMENDED that a user agent prioritize restricting the
-          [=permission=] [=permission/lifetime=] to a single session: This can
-          be, for example, until the [=environment settings object/realm=] is
-          destroyed, the end-user [=navigates=] away from the [=origin=], or
-          the relevant browser tab is closed.
+          A malicious actor could potentially infer a user's [=precise
+          position=] by collecting and correlating multiple, distinct
+          [=approximate positions=]. To mitigate this risk of a refinement
+          attack, when a site receives an [=approximate position=], any
+          subsequent calls from that same site within a user-agent-defined time
+          window SHOULD return the exact same, cached [=approximate position=]
+          data. A user agent might, for example, use a time window of 15
+          minutes.
         </p>
       </section>
     </section>
@@ -646,8 +834,7 @@ <h3>
           <li>Let |document:Document| be the |geolocation|'s [=relevant global
           object=]'s [=associated `Document`=].
           </li>
-          <li data-tests="">If |document| is not [=allowed to use=] the
-          "geolocation" feature:
+          <li>If |document| is not [=allowed to use=] <a>"geolocation"</a>:
             <ol>
               <li>If |watchId| was passed, [=List/remove=] |watchId| from
               |watchIDs|.
@@ -684,16 +871,34 @@ <h3>
             </ol>
           </li>
           <li>Let |descriptor| be a new {{PermissionDescriptor}} whose
-          {{PermissionDescriptor/name}} is <a>"geolocation"</a>.
+          {{PermissionDescriptor/name}} is <a>"geolocation-approximate"</a> if
+          |options|.{{PositionOptions/accuracyMode}} is
+          {{AccuracyMode/"approximate"}}, otherwise <a>"geolocation"</a>.
           </li>
           <li>[=In parallel=]:
             <ol>
-              <li>Set |permission| to [=request permission to use=]
-              |descriptor|.
+              <li>Let |resolvedPermissionState| be `null`.
+              </li>
+              <li>If |permissionName| is <a>"geolocation-approximate"</a>:
+                <ol>
+                  <li>Set |resolvedPermissionState| to the result of running
+                  [=request permission to use=] |descriptor|.
+                  </li>
+                </ol>
+              </li>
+              <li>Otherwise (|permissionName| is <a>"geolocation"</a>):
+                <ol>
+                  <li>Let |precisePermissionStatus:GeolocationPermissionStatus|
+                  be [=request precise geolocation permission=].
+                  </li>
+                  <li>Set |resolvedPermissionState| to
+                  |precisePermissionStatus|.state.
+                  </li>
+                </ol>
               </li>
               <li data-tests=
               "getCurrentPosition_permission_allow.https.html, getCurrentPosition_permission_deny.https.html">
-              If |permission| is "denied", then:
+              If |resolvedPermissionState| is "denied", then:
                 <ol>
                   <li>If |watchId| was passed, [=list/remove=] |watchId| from
                   |watchIDs|.
@@ -777,19 +982,45 @@ <h3>
           |timeoutTime|, during which it tries to acquire the device's position
           by running the following steps:
             <ol>
-              <li>Let |permission| be [=get the current permission state=] of
-              <a>"geolocation"</a>.
+              <li>Let |permissionStatus:GeolocationPermissionStatus| be the
+              result of running the [=geolocation/precise permission query
+              algorithm=] given a new {{PermissionDescriptor}} with its
+              {{PermissionDescriptor/name}} set to "geolocation".
+              </li>
+              <li>Let |effectiveAccuracy:AccuracyMode?| be `null`.
+              </li>
+              <li>If |permissionStatus|.{{PermissionStatus/state}} is
+              [=permission/granted=]:
+                <ol>
+                  <li>If |options|.{{PositionOptions/accuracyMode}} is
+                  "approximate":
+                    <ol>
+                      <li>Set |effectiveAccuracy| to "approximate".
+                      </li>
+                    </ol>
+                  </li>
+                  <li>Otherwise (|options|.{{PositionOptions/accuracyMode}} is
+                  "precise"):
+                    <ol>
+                      <li>Set |effectiveAccuracy| to
+                      |permissionStatus|.{{GeolocationPermissionStatus/accuracyMode}}.
+                      </li>
+                    </ol>
+                  </li>
+                </ol>
               </li>
-              <li>If |permission| is "denied":
+              <li>If |effectiveAccuracy| is `null`:
                 <ol>
                   <li>Stop |timeout|.
                   </li>
                   <li>Do the <a href="#permission-denied">user or system denied
                   permission</a> failure case step.
                   </li>
+                  <li>Terminate this algorithm.
+                  </li>
                 </ol>
               </li>
-              <li>If |permission| is "granted":
+              <li>Otherwise, run belows steps to determine |position|:
                 <ol>
                   <li>Check if an emulated position should be used by running
                   the following steps:
@@ -811,8 +1042,9 @@ <h3>
                             </ol>
                           </li>
                           <li>Let |position| be [=a new `GeolocationPosition`=]
-                          passing |emulatedPositionData|, |acquisitionTime| and
-                          |options|.{{PositionOptions/enableHighAccuracy}}.
+                          passing |emulatedPositionData|, |acquisitionTime|,
+                          |options|.{{PositionOptions/enableHighAccuracy}}, and
+                          |effectiveAccuracy|.
                           </li>
                           <li>[=Queue a task=] on the [=geolocation task
                           source=] with a step that [=invokes=]
@@ -835,9 +1067,8 @@ <h3>
                       </li>
                       <li>If |cachedPosition|'s
                       {{GeolocationPosition/timestamp}}'s value is greater than
-                      |cacheTime|, and
-                      |cachedPosition|.{{GeolocationPosition/[[isHighAccuracy]]}}
-                      equals |options|.{{PositionOptions/enableHighAccuracy}}:
+                      |cacheTime|, and |effectiveAccuracy| equals
+                      |cachedPosition|'s {{GeolocationPosition/accuracyMode}}:
                         <ol>
                           <li>[=Queue a task=] on the [=geolocation task
                           source=] with a step that [=invokes=]
@@ -850,165 +1081,173 @@ <h3>
                       </li>
                     </ol>
                   </li>
-                  <li>Otherwise, if |position| is not |cachedPosition|, try to
-                  acquire position data from the underlying system, optionally
-                  taking into consideration the value of
-                  |options|.{{PositionOptions/enableHighAccuracy}} during
-                  acquisition.
-                  </li>
-                  <li>If the |timeout| elapses during acquisition, or acquiring
-                  the device's position results in failure:
+                  <li>Otherwise, try to acquire position data from the
+                  underlying system, with the following considerations:
                     <ol>
-                      <li>Stop the |timeout|.
-                      </li>
-                      <li>Go to <a href="#errors-reasons">dealing with
-                      failures</a>.
-                      </li>
-                      <li>Terminate this algorithm.
+                      <li>If |effectiveAccuracy| is "approximate", the user
+                      agent SHOULD acquire a position with a level of accuracy
+                      that is sufficient to protect user privacy (e.g.,
+                      city-level accuracy). The
+                      {{PositionOptions/enableHighAccuracy}} member is ignored.
                       </li>
-                    </ol>
-                  </li>
-                  <li data-cite="infra">If acquiring the position data from the
-                  system succeeds:
-                    <ol data-cite="infra">
-                      <li>Let |positionData| be a [=map=] with the following
-                      name/value pairs based on the acquired position data:
-                        <dl data-sort="">
-                          <dt>
-                            "latitude"
-                          </dt>
-                          <dd>
-                            A {{double}} that represents the latitude
-                            coordinates on the Earth's surface in degrees,
-                            using the [[WGS84]] coordinate system. Latitude
-                            measures how far north or south a point is from the
-                            Equator.
-                          </dd>
-                          <dt>
-                            "longitude"
-                          </dt>
-                          <dd>
-                            A {{double}} that represents the longitude
-                            coordinates on the Earth's surface in degrees,
-                            using the [[WGS84]] coordinate system. Longitude
-                            measures how far east or west a point is from the
-                            Prime Meridian.
-                          </dd>
-                          <dt>
-                            "altitude"
-                          </dt>
-                          <dd>
-                            A {{double?}} that represents the altitude in
-                            meters above the [[WGS84]] ellipsoid, or `null` if
-                            not available. Altitude measures the height above
-                            sea level.
-                          </dd>
-                          <dt>
-                            "accuracy"
-                          </dt>
-                          <dd>
-                            A non-negative {{double}} that represents the
-                            accuracy value indicating the 95% confidence level
-                            in meters. Accuracy measures how close the measured
-                            coordinates are to the true position.
-                          </dd>
-                          <dt>
-                            "altitudeAccuracy"
-                          </dt>
-                          <dd>
-                            A non-negative {{double?}} that represents the
-                            altitude accuracy, or `null` if not available,
-                            indicating the 95% confidence level in meters.
-                            Altitude accuracy measures how close the measured
-                            altitude is to the true altitude.
-                          </dd>
-                          <dt>
-                            "speed"
-                          </dt>
-                          <dd>
-                            A non-negative {{double?}} that represents the
-                            speed in meters per second, or `null` if not
-                            available. Speed measures how fast the device is
-                            moving.
-                          </dd>
-                          <dt>
-                            "heading"
-                          </dt>
-                          <dd>
-                            A {{double?}} that represents the heading in
-                            degrees, or `null` if not available or the device
-                            is stationary. Heading measures the direction in
-                            which the device is moving relative to true north.
-                          </dd>
-                        </dl>
-                      </li>
-                      <li>Set |position| to [=a new `GeolocationPosition`=]
-                      passing |positionData|, |acquisitionTime| and
+                      <li>If |effectiveAccuracy| is "precise", the user agent
+                      SHOULD acquire a position, optionally taking into
+                      consideration the value of
                       |options|.{{PositionOptions/enableHighAccuracy}}.
                       </li>
-                      <li>Set [=this=]'s {{Geolocation/[[cachedPosition]]}} to
-                      |position|.
-                      </li>
                     </ol>
                   </li>
+                </ol>
+              </li>
+              <li>If the |timeout| elapses during acquisition, or acquiring the
+              device's position results in failure:
+                <ol>
                   <li>Stop the |timeout|.
                   </li>
-                  <li>[=Queue a task=] on the [=geolocation task source=] with
-                  a step that [=invokes=] |successCallback| with « |position| »
-                  and "`report`".
+                  <li>Go to <a href="#errors-reasons">dealing with
+                  failures</a>.
+                  </li>
+                  <li>Terminate this algorithm.
                   </li>
                 </ol>
               </li>
-            </ol>
-            <dl class="switch">
-              <dt id="errors-reasons">
-                Dealing with failures:
-              </dt>
-              <dd>
-                <ul>
-                  <li>If acquiring a position fails, do one of the following
-                  based on the condition that matches the failure:
-                    <dl class="switch">
-                      <dt id="permission-denied">
-                        User or system denied permission:
+              <li data-cite="infra">If acquiring the position data from the
+              system succeeds:
+                <ol data-cite="infra">
+                  <li>Let |positionData| be a [=map=] with the following
+                  name/value pairs based on the acquired position data:
+                    <dl data-sort="">
+                      <dt>
+                        "latitude"
+                      </dt>
+                      <dd>
+                        A {{double}} that represents the latitude coordinates
+                        on the Earth's surface in degrees, using the [[WGS84]]
+                        coordinate system. Latitude measures how far north or
+                        south a point is from the Equator.
+                      </dd>
+                      <dt>
+                        "longitude"
+                      </dt>
+                      <dd>
+                        A {{double}} that represents the longitude coordinates
+                        on the Earth's surface in degrees, using the [[WGS84]]
+                        coordinate system. Longitude measures how far east or
+                        west a point is from the Prime Meridian.
+                      </dd>
+                      <dt>
+                        "altitude"
+                      </dt>
+                      <dd>
+                        A {{double?}} that represents the altitude in meters
+                        above the [[WGS84]] ellipsoid, or `null` if not
+                        available. Altitude measures the height above sea
+                        level.
+                      </dd>
+                      <dt>
+                        "accuracy"
+                      </dt>
+                      <dd>
+                        A non-negative {{double}} that represents the accuracy
+                        value indicating the 95% confidence level in meters.
+                        Accuracy measures how close the measured coordinates
+                        are to the true position.
+                      </dd>
+                      <dt>
+                        "altitudeAccuracy"
                       </dt>
                       <dd>
-                        <p>
-                          [=Call back with error=] passing |errorCallback| and
-                          {{GeolocationPositionError/PERMISSION_DENIED}}.
-                        </p>
-                        <aside class="note" title=
-                        "Browser permission VS OS permission">
-                          <p>
-                            On certain platforms, there can be a circumstance
-                            where the user has [=permission/granted=] the user
-                            agent permission to use Geolocation at the
-                            browser-level, but the permission to access
-                            location services has been denied at the OS level.
-                          </p>
-                        </aside>
+                        A non-negative {{double?}} that represents the altitude
+                        accuracy, or `null` if not available, indicating the
+                        95% confidence level in meters. Altitude accuracy
+                        measures how close the measured altitude is to the true
+                        altitude.
                       </dd>
                       <dt>
-                        Timeout elapsed:
+                        "speed"
                       </dt>
                       <dd>
-                        [=Call back with error=] with |errorCallback| and
-                        {{GeolocationPositionError/TIMEOUT}}.
+                        A non-negative {{double?}} that represents the speed in
+                        meters per second, or `null` if not available. Speed
+                        measures how fast the device is moving.
                       </dd>
                       <dt>
-                        Data acquisition error or any other reason:
+                        "heading"
                       </dt>
                       <dd>
-                        [=Call back with error=] passing |errorCallback| and
-                        {{GeolocationPositionError/POSITION_UNAVAILABLE}}.
+                        A {{double?}} that represents the heading in degrees,
+                        or `null` if not available or the device is stationary.
+                        Heading measures the direction in which the device is
+                        moving relative to true north.
                       </dd>
                     </dl>
                   </li>
-                </ul>
-              </dd>
-            </dl>
+                  <li>Set |position| to [=a new `GeolocationPosition`=] passing
+                  |positionData|, |acquisitionTime|,
+                  |options|.{{PositionOptions/enableHighAccuracy}} and
+                  |effectiveAccuracy|.
+                  </li>
+                  <li>Set [=this=]'s {{Geolocation/[[cachedPosition]]}} to
+                  |position|.
+                  </li>
+                </ol>
+              </li>
+              <li>Stop the |timeout|.
+              </li>
+              <li>[=Queue a task=] on the [=geolocation task source=] with a
+              step that [=invokes=] |successCallback| with « |position| » and
+              "`report`".
+              </li>
+            </ol>
           </li>
         </ol>
+        <dl class="switch">
+          <dt id="errors-reasons">
+            Dealing with failures:
+          </dt>
+          <dd>
+            <ul>
+              <li>If acquiring a position fails, do one of the following based
+              on the condition that matches the failure:
+                <dl class="switch">
+                  <dt id="permission-denied">
+                    User or system denied permission:
+                  </dt>
+                  <dd>
+                    <p>
+                      [=Call back with error=] passing |errorCallback| and
+                      {{GeolocationPositionError/PERMISSION_DENIED}}.
+                    </p>
+                    <aside class="note" title=
+                    "Browser permission VS OS permission">
+                      <p>
+                        On certain platforms, there can be a circumstance where
+                        the user has [=permission/granted=] the user agent
+                        permission to use Geolocation at the browser-level, but
+                        the permission to access location services has been
+                        denied at the OS level.
+                      </p>
+                    </aside>
+                  </dd>
+                  <dt>
+                    Timeout elapsed:
+                  </dt>
+                  <dd>
+                    [=Call back with error=] with |errorCallback| and
+                    {{GeolocationPositionError/TIMEOUT}}.
+                  </dd>
+                  <dt>
+                    Data acquisition error or any other reason:
+                  </dt>
+                  <dd>
+                    [=Call back with error=] passing |errorCallback| and
+                    {{GeolocationPositionError/POSITION_UNAVAILABLE}}.
+                  </dd>
+                </dl>
+              </li>
+            </ul>
+          </dd>
+        </dl>
       </section>
       <section>
         <h3>
@@ -1037,12 +1276,36 @@ <h2>
         <dfn>PositionOptions</dfn> dictionary
       </h2>
       <pre class="idl">
+        enum AccuracyMode {
+          "precise",
+          "approximate"
+        };
+
         dictionary PositionOptions {
+          AccuracyMode accuracyMode = "precise";
           boolean enableHighAccuracy = false;
           [Clamp] unsigned long timeout = 0xFFFFFFFF;
           [Clamp] unsigned long maximumAge = 0;
         };
         </pre>
+      <section>
+        <h3>
+          `accuracyMode` member
+        </h3>
+        <p>
+          The <dfn>accuracyMode</dfn> member is used to request a specific
+          level of accuracy. It can be set to "precise" to request the most
+          accurate location data available, or "approximate" to receive a less
+          accurate location that protects user privacy. The default value is
+          "precise".
+        </p>
+        <aside class="note" title="Interaction with enableHighAccuracy">
+          <p>
+            If `accuracyMode` is set to "approximate", the `enableHighAccuracy`
+            member has no effect.
+          </p>
+        </aside>
+      </section>
       <section>
         <h3>
           `enableHighAccuracy` member
@@ -1075,10 +1338,10 @@ <h3>
         </p>
         <p class="note" title="When is the timeout calculated?">
           The time spent waiting for the document to become visible and for
-          [=check permission|obtaining permission to use the API=] is not
-          included in the period covered by the {{PositionOptions/timeout}}
-          member. The {{PositionOptions/timeout}} member only applies when
-          [=acquiring a position=] begins.
+          [=request precise geolocation permission|obtaining permission to use
+          the API=] is not included in the period covered by the
+          {{PositionOptions/timeout}} member. The {{PositionOptions/timeout}}
+          member only applies when [=acquiring a position=] begins.
         </p>
         <aside class="note" title="Immediate cancellation">
           <p>
@@ -1107,6 +1370,7 @@ <h2>
         interface GeolocationPosition {
           readonly attribute GeolocationCoordinates coords;
           readonly attribute EpochTimeStamp timestamp;
+          readonly attribute AccuracyMode accuracyMode;
           [Default] object toJSON();
         };
       </pre>
@@ -1127,6 +1391,17 @@ <h3>
           geographic position of the device was acquired.
         </p>
       </section>
+      <section>
+        <h3>
+          `accuracyMode` attribute
+        </h3>
+        <p>
+          The <dfn>accuracyMode</dfn> attribute indicates the accuracy level of
+          the position, which can be either `"precise"` or `"approximate"`.
+          This reflects the level of accuracy that was granted and used to
+          obtain the position.
+        </p>
+      </section>
       <section>
         <h3>
           `toJSON()` method
@@ -1263,8 +1538,9 @@ <h3>
         </h3>
         <p>
           <dfn>A new `GeolocationPosition`</dfn> is constructed with [=map=]
-          |positionData|, {{EpochTimeStamp}} |timestamp:EpochTimeStamp| and
-          boolean |isHighAccuracy| by performing the following steps:
+          |positionData|, {{EpochTimeStamp}} |timestamp:EpochTimeStamp|,
+          boolean |isHighAccuracy|, and string |effectiveAccuracy| by
+          performing the following steps:
         </p>
         <ol class="algorithm">
           <li>Let |coords:GeolocationCoordinates| be a newly created
@@ -1277,10 +1553,11 @@ <h3>
             </ol>
           </li>
           <li>Return a newly created {{GeolocationPosition}} instance with its
-          {{GeolocationPosition/coords}} attribute initialized to |coords| and
+          {{GeolocationPosition/coords}} attribute initialized to |coords|,
           {{GeolocationPosition/timestamp}} attribute initialized to
-          |timestamp|, and its {{GeolocationPosition/[[isHighAccuracy]]}}
-          internal slot set to |isHighAccuracy|.
+          |timestamp|, {{GeolocationPosition/[[isHighAccuracy]]}} internal slot
+          set to |isHighAccuracy| and {{GeolocationPosition/accuracyMode}}
+          attribute initialized to |effectiveAccuracy|.
           </li>
         </ol>
       </section>

From 18496be808d4543d3031e6a1b193c3f288c6a2e0 Mon Sep 17 00:00:00 2001
From: Alvin Ji <alvinji@chromium.org>
Date: Wed, 25 Mar 2026 16:10:04 -0700
Subject: [PATCH 02/12] Apply PR feedback for approximate geolocation

- Define explicit coherence requirements between "geolocation" and "geolocation-approximate" permission states.

- Fix typos and clarify logic in the precise permission query algorithm.

- Update the 'set emulated position data' definition and 'Acquire a position' algorithm to consume an Infra map, aligning the Geolocation spec with the WebDriver BiDi implementation.

- Rename effectiveAccuracy to accuracyMode in the 'Constructing a GeolocationPosition' algorithm.
---
 index.html | 108 +++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 81 insertions(+), 27 deletions(-)

diff --git a/index.html b/index.html
index 40a4ab0..fc0b109 100644
--- a/index.html
+++ b/index.html
@@ -67,8 +67,8 @@ <h2>
         System (GPS) and location inferred from network signals such as IP
         address, RFID, WiFi and Bluetooth MAC addresses, and GSM/CDMA cell IDs,
         as well as user input. The API itself is agnostic of the underlying
-        <dfn>location information source</dfn>s, and no guarantee is given that
-        the API returns the device's actual location.
+        location information sources, and no guarantee is given that the API
+        returns the device's actual location.
       </p>
       <p>
         This specification provides two ways for users to share their location:
@@ -76,16 +76,16 @@ <h2>
       </p>
       <p>
         A <dfn>precise position</dfn> is a position returned by the underlying
-        [=location information source=]. By default, any location data is
+        location information source. By default, any location data is
         considered precise, regardless of its accuracy estimate, unless it has
-        been explicitly coarsened by an [=approximate location information
-        source=] to be an [=approximate position=].
+        been explicitly coarsened by an approximate location information source
+        to be an [=approximate position=].
       </p>
       <p>
         An <dfn>approximate position</dfn> is a less precise,
         privacy-preserving representation of the user's location. Instead of
-        providing precise coordinates, an [=approximate location information
-        source=] can return a location that is intentionally coarsened to a
+        providing precise coordinates, an approximate location information
+        source can return a location that is intentionally coarsened to a
         larger area, such as the nearest city, postal code, or a predefined
         region. This is often sufficient for applications that don't need to
         know the user's [=precise position=], for example, a weather
@@ -95,10 +95,9 @@ <h2>
         position=].
       </p>
       <p>
-        An <dfn>approximate location information source</dfn> is a [=location
-        information source=] that returns positions that have been
-        intentionally obfuscated to make it more difficult to recover the true
-        location.
+        An approximate location information source is a location information
+        source that returns positions that have been intentionally obfuscated
+        to make it more difficult to recover the true location.
       </p>
       <p>
         If an end user grants permission, <cite>Geolocation</cite>:
@@ -541,6 +540,44 @@ <h2>
           <code><dfn class="permission">"geolocation-approximate"</dfn></code>
           (for approximate location).
         </p>
+        <p>
+          There is a strict dependency between the [=permission state=]s of
+          <a>"geolocation"</a> and <a>"geolocation-approximate"</a>.
+          Specifically, granting precise location implies granting approximate
+          location, and denying approximate location implies denying precise
+          location. This results in the following allowed combinations of
+          states:
+        </p>
+        <ul>
+          <li>Both are [=permission/"granted"=].
+          </li>
+          <li>Both are [=permission/"prompt"=].
+          </li>
+          <li>Both are [=permission/"denied"=].
+          </li>
+          <li>
+            <a>"geolocation-approximate"</a> is [=permission/"granted"=] and
+            <a>"geolocation"</a> is [=permission/"prompt"=].
+          </li>
+          <li>
+            <a>"geolocation-approximate"</a> is [=permission/"granted"=] and
+            <a>"geolocation"</a> is [=permission/"denied"=].
+          </li>
+          <li>
+            <a>"geolocation-approximate"</a> is [=permission/"prompt"=] and
+            <a>"geolocation"</a> is [=permission/"denied"=].
+          </li>
+        </ul>
+        <p>
+          Implementers MUST ensure that these states remain coherent. For
+          example, if a user changes the [=permission state=] of
+          <a>"geolocation-approximate"</a> to [=permission/"denied"=] via site
+          settings, the user agent MUST automatically update
+          <a>"geolocation"</a> to [=permission/"denied"=] as well. Similarly,
+          if <a>"geolocation"</a> is changed to [=permission/"granted"=],
+          <a>"geolocation-approximate"</a> MUST also become
+          [=permission/"granted"=].
+        </p>
         <p>
           <code><a>"geolocation-approximate"</a></code> is a [=default powerful
           feature=], while <code><a>"geolocation"</a></code> is a [=powerful
@@ -569,9 +606,10 @@ <h2>
               </li>
               <li>If |approximatePermissionState| is [=permission/"granted"=]
               and |permissionDesc|'s [=permission state=] is
-              [=permission/"prompt"=], set |status|'s to
-              [=permission/"prompt"=]. Otherwise, set |status|'s
-              {{PermissionStatus/state}} to |appxorimatePermissionState|.
+              [=permission/"prompt"=], set |status|'s
+              {{PermissionStatus/state}} to [=permission/"prompt"=]. Otherwise,
+              set |status|'s {{PermissionStatus/state}} to
+              |approximatePermissionState|.
               </li>
               <li>If |status|'s {{PermissionStatus/state}} is equal to
               [=permission/"granted"=], set |status|'s
@@ -579,6 +617,14 @@ <h2>
               {{AccuracyMode/"precise"}} if also |permissionDesc|'s
               [=permission state=] is [=permission/"granted"=] or to
               {{AccuracyMode/"approximate"}} otherwise.
+                <aside class="note">
+                  <p>
+                    As noted above, there are only six valid combinations of
+                    [=permission state=]s for <a>"geolocation"</a> and
+                    <a>"geolocation-approximate"</a>. Implementers MUST ensure
+                    that these states remain coherent.
+                  </p>
+                </aside>
               </li>
             </ol>
           </li>
@@ -1030,21 +1076,31 @@ <h3>
                       </li>
                       <li>If |emulatedPositionData| is not null:
                         <ol>
-                          <li>If |emulatedPositionData| is a
-                          {{GeolocationPositionError}}:
+                          <li>If |emulatedPositionData|["error"]
+                          [=map/exists=]:
                             <ol>
+                              <li>Let |error| be a newly created
+                              {{GeolocationPositionError}} instance with its
+                              {{GeolocationPositionError/code}} attribute
+                              initialized to
+                              |emulatedPositionData|["error"]["code"].
+                              </li>
                               <li>[=Call back with error=] passing
-                              |errorCallback| and
-                              |emulatedPositionData|.{{GeolocationPositionError/code}}.
+                              |errorCallback| and |error|.
                               </li>
                               <li>Terminate this algorithm.
                               </li>
                             </ol>
                           </li>
+                          <li>Let |emulatedAccuracyMode| be
+                          |emulatedPositionData|["accuracyMode"] if it
+                          [=map/exists=]; otherwise "precise".
+                          </li>
                           <li>Let |position| be [=a new `GeolocationPosition`=]
-                          passing |emulatedPositionData|, |acquisitionTime|,
+                          passing |emulatedPositionData|["coordinate"],
+                          |acquisitionTime|,
                           |options|.{{PositionOptions/enableHighAccuracy}}, and
-                          |effectiveAccuracy|.
+                          |emulatedAccuracyMode|.
                           </li>
                           <li>[=Queue a task=] on the [=geolocation task
                           source=] with a step that [=invokes=]
@@ -1539,8 +1595,8 @@ <h3>
         <p>
           <dfn>A new `GeolocationPosition`</dfn> is constructed with [=map=]
           |positionData|, {{EpochTimeStamp}} |timestamp:EpochTimeStamp|,
-          boolean |isHighAccuracy|, and string |effectiveAccuracy| by
-          performing the following steps:
+          boolean |isHighAccuracy|, and string |accuracyMode| by performing the
+          following steps:
         </p>
         <ol class="algorithm">
           <li>Let |coords:GeolocationCoordinates| be a newly created
@@ -1557,7 +1613,7 @@ <h3>
           {{GeolocationPosition/timestamp}} attribute initialized to
           |timestamp|, {{GeolocationPosition/[[isHighAccuracy]]}} internal slot
           set to |isHighAccuracy| and {{GeolocationPosition/accuracyMode}}
-          attribute initialized to |effectiveAccuracy|.
+          attribute initialized to |accuracyMode|.
           </li>
         </ol>
       </section>
@@ -1656,16 +1712,14 @@ <h2>
       </p>
       <p>
         Each [=top-level traversable=] has an associated <dfn>emulated position
-        data</dfn>, which is data representing {{GeolocationCoordinates}},
-        {{GeolocationPositionError}} or null, initially null.
+        data</dfn>, which is a [=map=] or null, initially null.
       </p>
       <p>
         To <dfn class="export">set emulated position data</dfn>, given
         [=navigable=] |navigable| and an |emulatedPositionData|:
       </p>
       <ol class="algorithm">
-        <li>Assert |emulatedPositionData| is either null, a
-        {{GeolocationCoordinates}}, or a {{GeolocationPositionError}}.
+        <li>Assert |emulatedPositionData| is either null or a [=map=].
         </li>
         <li>Let |traversable| be |navigable|’s [=navigable/top-level
         traversable=].

From 0f52a5e5dc10bece32c5d45d29c7a8c886bcb7e3 Mon Sep 17 00:00:00 2001
From: Alvin Ji <alvinji@chromium.org>
Date: Wed, 25 Mar 2026 16:10:04 -0700
Subject: [PATCH 03/12] correct typo

---
 index.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/index.html b/index.html
index fc0b109..768af91 100644
--- a/index.html
+++ b/index.html
@@ -1097,7 +1097,7 @@ <h3>
                           [=map/exists=]; otherwise "precise".
                           </li>
                           <li>Let |position| be [=a new `GeolocationPosition`=]
-                          passing |emulatedPositionData|["coordinate"],
+                          passing |emulatedPositionData|["coordinates"],
                           |acquisitionTime|,
                           |options|.{{PositionOptions/enableHighAccuracy}}, and
                           |emulatedAccuracyMode|.

From 998176addea7cfc9f2ce161615b17ee43954f9bf Mon Sep 17 00:00:00 2001
From: Alvin Ji <alvinji@chromium.org>
Date: Tue, 7 Apr 2026 06:41:34 +0800
Subject: [PATCH 04/12] Move accuracyMode to GeolocationCoordinates

- Update GeolocationPosition and GeolocationCoordinates interfaces to move accuracyMode.
- Update 'Acquire a position' and 'Constructing a GeolocationPosition' algorithms to reflect the move.
- Align emulation logic with WebDriver BiDi by using 'type' for error codes and embedding accuracyMode in coordinates.
- Tidy index.html.
---
 index.html | 59 +++++++++++++++++++++++++++---------------------------
 1 file changed, 29 insertions(+), 30 deletions(-)

diff --git a/index.html b/index.html
index 768af91..1df30d1 100644
--- a/index.html
+++ b/index.html
@@ -1083,7 +1083,7 @@ <h3>
                               {{GeolocationPositionError}} instance with its
                               {{GeolocationPositionError/code}} attribute
                               initialized to
-                              |emulatedPositionData|["error"]["code"].
+                              |emulatedPositionData|["error"]["type"].
                               </li>
                               <li>[=Call back with error=] passing
                               |errorCallback| and |error|.
@@ -1092,15 +1092,10 @@ <h3>
                               </li>
                             </ol>
                           </li>
-                          <li>Let |emulatedAccuracyMode| be
-                          |emulatedPositionData|["accuracyMode"] if it
-                          [=map/exists=]; otherwise "precise".
-                          </li>
                           <li>Let |position| be [=a new `GeolocationPosition`=]
                           passing |emulatedPositionData|["coordinates"],
-                          |acquisitionTime|,
-                          |options|.{{PositionOptions/enableHighAccuracy}}, and
-                          |emulatedAccuracyMode|.
+                          |acquisitionTime|, and
+                          |options|.{{PositionOptions/enableHighAccuracy}}.
                           </li>
                           <li>[=Queue a task=] on the [=geolocation task
                           source=] with a step that [=invokes=]
@@ -1124,7 +1119,8 @@ <h3>
                       <li>If |cachedPosition|'s
                       {{GeolocationPosition/timestamp}}'s value is greater than
                       |cacheTime|, and |effectiveAccuracy| equals
-                      |cachedPosition|'s {{GeolocationPosition/accuracyMode}}:
+                      |cachedPosition|'s {{GeolocationPosition/coords}}'s
+                      {{GeolocationCoordinates/accuracyMode}}:
                         <ol>
                           <li>[=Queue a task=] on the [=geolocation task
                           source=] with a step that [=invokes=]
@@ -1236,12 +1232,17 @@ <h3>
                         Heading measures the direction in which the device is
                         moving relative to true north.
                       </dd>
+                      <dt>
+                        "accuracyMode"
+                      </dt>
+                      <dd>
+                        Set to |effectiveAccuracy|.
+                      </dd>
                     </dl>
                   </li>
                   <li>Set |position| to [=a new `GeolocationPosition`=] passing
-                  |positionData|, |acquisitionTime|,
-                  |options|.{{PositionOptions/enableHighAccuracy}} and
-                  |effectiveAccuracy|.
+                  |positionData|, |acquisitionTime|, and
+                  |options|.{{PositionOptions/enableHighAccuracy}}.
                   </li>
                   <li>Set [=this=]'s {{Geolocation/[[cachedPosition]]}} to
                   |position|.
@@ -1426,7 +1427,6 @@ <h2>
         interface GeolocationPosition {
           readonly attribute GeolocationCoordinates coords;
           readonly attribute EpochTimeStamp timestamp;
-          readonly attribute AccuracyMode accuracyMode;
           [Default] object toJSON();
         };
       </pre>
@@ -1447,17 +1447,6 @@ <h3>
           geographic position of the device was acquired.
         </p>
       </section>
-      <section>
-        <h3>
-          `accuracyMode` attribute
-        </h3>
-        <p>
-          The <dfn>accuracyMode</dfn> attribute indicates the accuracy level of
-          the position, which can be either `"precise"` or `"approximate"`.
-          This reflects the level of accuracy that was granted and used to
-          obtain the position.
-        </p>
-      </section>
       <section>
         <h3>
           `toJSON()` method
@@ -1529,6 +1518,7 @@ <h2>
           readonly attribute double? altitudeAccuracy;
           readonly attribute double? heading;
           readonly attribute double? speed;
+          readonly attribute AccuracyMode accuracyMode;
           [Default] object toJSON();
         };
       </pre>
@@ -1579,6 +1569,17 @@ <h3>
           meters per second.
         </p>
       </section>
+      <section>
+        <h3>
+          `accuracyMode` attribute
+        </h3>
+        <p>
+          The <dfn>accuracyMode</dfn> attribute indicates the accuracy level of
+          the position, which can be either `"precise"` or `"approximate"`.
+          This reflects the level of accuracy that was granted and used to
+          obtain the position.
+        </p>
+      </section>
       <section>
         <h3>
           `toJSON()` method
@@ -1594,9 +1595,8 @@ <h3>
         </h3>
         <p>
           <dfn>A new `GeolocationPosition`</dfn> is constructed with [=map=]
-          |positionData|, {{EpochTimeStamp}} |timestamp:EpochTimeStamp|,
-          boolean |isHighAccuracy|, and string |accuracyMode| by performing the
-          following steps:
+          |positionData|, {{EpochTimeStamp}} |timestamp:EpochTimeStamp|, and
+          boolean |isHighAccuracy| by performing the following steps:
         </p>
         <ol class="algorithm">
           <li>Let |coords:GeolocationCoordinates| be a newly created
@@ -1611,9 +1611,8 @@ <h3>
           <li>Return a newly created {{GeolocationPosition}} instance with its
           {{GeolocationPosition/coords}} attribute initialized to |coords|,
           {{GeolocationPosition/timestamp}} attribute initialized to
-          |timestamp|, {{GeolocationPosition/[[isHighAccuracy]]}} internal slot
-          set to |isHighAccuracy| and {{GeolocationPosition/accuracyMode}}
-          attribute initialized to |accuracyMode|.
+          |timestamp|, and {{GeolocationPosition/[[isHighAccuracy]]}} internal
+          slot set to |isHighAccuracy|.
           </li>
         </ol>
       </section>

From 50da35765b010df61c74b0cdeaf2192bcc17b580 Mon Sep 17 00:00:00 2001
From: Alvin Ji <alvinji@chromium.org>
Date: Wed, 8 Apr 2026 15:07:05 +0800
Subject: [PATCH 05/12] Address reviewer feedback for approximate geolocation

- Rephrase privacy risk mitigation and user choice framing for clarity and neutrality.
- Update terminology from 'powerful features' to 'permissions' and 'protecting' to 'obscuring'.
- Add cross-references to the 'acquire a position' algorithm and AccuracyMode enum values.
- Fix ReSpec linking errors and IDL formatting.
- Remove redundant MUST statements from informative notes.
- Tidy index.html.
---
 index.html | 217 +++++++++++++++++++++++++++++------------------------
 1 file changed, 119 insertions(+), 98 deletions(-)

diff --git a/index.html b/index.html
index 1df30d1..1e255c4 100644
--- a/index.html
+++ b/index.html
@@ -72,7 +72,7 @@ <h2>
       </p>
       <p>
         This specification provides two ways for users to share their location:
-        a <em>precise position</em> and an <em>approximate position</em>.
+        a [=precise position=] and an [=approximate position=].
       </p>
       <p>
         A <dfn>precise position</dfn> is a position returned by the underlying
@@ -87,7 +87,8 @@ <h2>
         providing precise coordinates, an approximate location information
         source can return a location that is intentionally coarsened to a
         larger area, such as the nearest city, postal code, or a predefined
-        region. This is often sufficient for applications that don't need to
+        region. What constitutes a coarsened area is left to the underlying
+        system. This is often sufficient for applications that don't need to
         know the user's [=precise position=], for example, a weather
         application that only needs a city-level location. By sharing an
         [=approximate position=], users can still get the benefit of a
@@ -100,7 +101,8 @@ <h2>
         to make it more difficult to recover the true location.
       </p>
       <p>
-        If an end user grants permission, <cite>Geolocation</cite>:
+        If an end user [=request permission to use|grants permission=],
+        <cite>Geolocation</cite>:
       </p>
       <ul>
         <li>Provides location data as latitude, longitude, altitude, speed, and
@@ -155,17 +157,12 @@ <h3>
           Get current position
         </h3>
         <p>
-          Request the user's current location. If the user grants permission,
-          the API will return a position object. The website can influence the
-          position's accuracy by using the {{PositionOptions}} dictionary's
-          {{PositionOptions/accuracyMode}} member. By default, the user agent
-          will provide a {{AccuracyMode/"precise"}} location. However, a
-          website can request an [=approximate position=] by setting
-          {{PositionOptions/accuracyMode}} to {{AccuracyMode/"approximate"}},
-          which helps protect user privacy if high accuracy is not required. In
-          addition, the user can instruct the user agent to only provide an
-          approximate position, even if the website requested a precise
-          position.
+          A website can request a user's location, choosing either a [=precise
+          position=] or an [=approximate position=] via the
+          {{PositionOptions/accuracyMode}} member. During the permission
+          request process, the end-user determines the actual level of accuracy
+          to grant, which the user agent then uses to provide the geographic
+          position accordingly.
         </p>
         <aside class="example" title="A one-shot position request">
           <pre class="js">
@@ -283,9 +280,10 @@ <h3>
           By default, the API always attempts to return a cached position so
           long as it has a previously acquired position that matches the
           requested {{PositionOptions/accuracyMode}}. In this example, we
-          accept a precise position whose age is no greater than 10 minutes. If
-          the user agent does not have a fresh enough cached position object of
-          the correct accuracy, it automatically acquires a new position.
+          accept a [=precise position=] whose age is no greater than 10
+          minutes. If the user agent does not have a fresh enough cached
+          position object of the correct accuracy, it automatically acquires a
+          new position.
         </p>
         <aside class="example" title="Getting a cached precise position">
           <pre class="js">
@@ -294,9 +292,6 @@ <h3>
               console.error,
               { maximumAge: 600_000 } // `accuracyMode` defaults to "precise"
             );
-
-            function successCallback(position) {
-            }
           </pre>
         </aside>
         <p>
@@ -307,12 +302,11 @@ <h3>
             navigator.geolocation.getCurrentPosition(
               successCallback,
               console.error,
-              { maximumAge: 600_000, accuracyMode: "approximate" }
+              { 
+                maximumAge: 600_000, 
+                accuracyMode: "approximate",
+              }
             );
-
-            function successCallback(position) {
-              // This position is approximate and at most 10 minutes old.
-            }
           </pre>
         </aside>
       </section>
@@ -406,24 +400,24 @@ <h2>
         thereby potentially compromising the user's privacy.
       </p>
       <p>
-        To mitigate this privacy risk, this specification introduces the
-        {{PositionOptions/accuracyMode}} option, which allows the application
-        to request an [=approximate position=]. This allows applications to
-        function without needing the user's [=precise position=], thus offering
-        a more privacy-friendly alternative. When an application requests an
-        [=approximate position=], the user agent can provide a less precise
-        location that still meets the application's needs while protecting the
-        user's [=precise position=]. Even when a [=precise position=] is
-        requested, the user agent can provide an [=approximate position=]
-        instead, for example, if the user has only granted permission for
-        approximate accuracy.
+        The {{PositionOptions/accuracyMode}} option enhances user privacy by
+        providing websites with the choice to request an [=approximate
+        position=]. This allows applications to function without needing the
+        user's [=precise position=], thus offering a more privacy-friendly
+        alternative. When an application requests an [=approximate position=],
+        the user agent can provide a less precise location that still meets the
+        application's needs while obscuring the user's [=precise position=].
+        Even when a [=precise position=] is requested, the user agent can
+        provide an [=approximate position=] instead (as defined in the
+        [=acquire a position=] algorithm), for example, if the user has only
+        granted permission for approximate accuracy.
       </p>
       <section class="informative">
         <h3>
           User consent
         </h3>
         <p>
-          <cite>Geolocation</cite> uses the [=powerful feature=]s
+          <cite>Geolocation</cite> uses the [=permission=]
           <a>"geolocation-approximate"</a> and <a>"geolocation"</a>, which
           require [=express permission=] from an end-user before any location
           data is shared with a web application. This requirement is
@@ -432,11 +426,12 @@ <h3>
           geolocation permission=] steps, on which the
           {{Geolocation/getCurrentPosition()}} and
           {{Geolocation/watchPosition()}} methods rely. [=User agents=] with
-          support for [=approximate position=] are strongly encouraged to allow
-          the user to choose between sharing a [=precise position=] or an
-          [=approximate position=]. This choice gives users more control over
-          their privacy, allowing them to share a less precise location when
-          they are not comfortable sharing their [=precise position=].
+          support for [=approximate position=] are strongly encouraged to
+          provide users with the option to grant access to either a [=precise
+          position=] or an [=approximate position=]. This choice gives users
+          more control over their privacy, allowing them to share a less
+          precise location when they are not comfortable sharing their
+          [=precise position=].
         </p>
         <p>
           An end-user will generally give [=express permission=] through a user
@@ -487,9 +482,10 @@ <h3>
           request the lowest level of location accuracy that is sufficient for
           their application's functionality. For instance, if an application
           only needs to know the user's city, it can respect user privacy by
-          requesting an [=approximate position=] by setting the `accuracyMode`
-          option to `"approximate"`. This practice of data minimization is a
-          key aspect of respecting user privacy.
+          requesting an [=approximate position=] by setting the
+          {{PositionOptions/accuracyMode}} option to
+          {{AccuracyMode/"approximate"}}. This practice of data minimization is
+          a key aspect of respecting user privacy.
         </p>
         <p>
           The recipients of location information need to refrain from
@@ -530,23 +526,22 @@ <h3>
         </p>
       </section>
       <section id="permission">
-        <h2>
+        <h3>
           Geolocation permissions
-        </h2>
+        </h3>
         <p>
-          <cite>Geolocation</cite> defines two [=powerful features=] identified
-          by the [=powerful feature/name=]s <code><dfn class=
-          "permission">"geolocation"</dfn></code> (for precise location) and
-          <code><dfn class="permission">"geolocation-approximate"</dfn></code>
+          <cite>Geolocation</cite> defines two [=permissions=] identified by
+          the names <dfn class="permission">"geolocation"</dfn> (for precise
+          location) and <dfn class="permission">"geolocation-approximate"</dfn>
           (for approximate location).
         </p>
         <p>
           There is a strict dependency between the [=permission state=]s of
           <a>"geolocation"</a> and <a>"geolocation-approximate"</a>.
-          Specifically, granting precise location implies granting approximate
-          location, and denying approximate location implies denying precise
-          location. This results in the following allowed combinations of
-          states:
+          Specifically, granting a [=precise position=] implies granting an
+          [=approximate position=], and denying an [=approximate position=]
+          implies denying a [=precise position=]. This results in the following
+          allowed combinations of states:
         </p>
         <ul>
           <li>Both are [=permission/"granted"=].
@@ -569,7 +564,7 @@ <h2>
           </li>
         </ul>
         <p>
-          Implementers MUST ensure that these states remain coherent. For
+          User agents MUST ensure that these states remain coherent. For
           example, if a user changes the [=permission state=] of
           <a>"geolocation-approximate"</a> to [=permission/"denied"=] via site
           settings, the user agent MUST automatically update
@@ -579,9 +574,8 @@ <h2>
           [=permission/"granted"=].
         </p>
         <p>
-          <code><a>"geolocation-approximate"</a></code> is a [=default powerful
-          feature=], while <code><a>"geolocation"</a></code> is a [=powerful
-          feature=] with:
+          <a>"geolocation-approximate"</a> is a [=default powerful feature=],
+          while <a>"geolocation"</a> is a [=powerful feature=] with:
         </p>
         <ul>
           <li>A custom [=powerful feature/permission result type=]
@@ -591,7 +585,7 @@ <h2>
                 interface GeolocationPermissionStatus : PermissionStatus {
                   readonly attribute AccuracyMode accuracyMode;
                 };
-              </pre>
+            </pre>
           </li>
           <li>A custom <dfn>precise permission query algorithm</dfn>, which,
           given a {{PermissionDescriptor}} |permissionDesc| and a
@@ -621,8 +615,7 @@ <h2>
                   <p>
                     As noted above, there are only six valid combinations of
                     [=permission state=]s for <a>"geolocation"</a> and
-                    <a>"geolocation-approximate"</a>. Implementers MUST ensure
-                    that these states remain coherent.
+                    <a>"geolocation-approximate"</a>.
                   </p>
                 </aside>
               </li>
@@ -661,7 +654,7 @@ <h2>
               <p>
                 The user agent is free to group the two resulting questions for
                 the user into a single permission prompt, asking the user
-                whether they want to expression permission to grant either
+                whether they want to express permission to grant either
                 approximate or precise geolocation (or none).
               </p>
             </aside>
@@ -682,14 +675,13 @@ <h3>
           Preventing Precise Location Reconstruction
         </h3>
         <p>
-          A malicious actor could potentially infer a user's [=precise
-          position=] by collecting and correlating multiple, distinct
-          [=approximate positions=]. To mitigate this risk of a refinement
-          attack, when a site receives an [=approximate position=], any
-          subsequent calls from that same site within a user-agent-defined time
-          window SHOULD return the exact same, cached [=approximate position=]
-          data. A user agent might, for example, use a time window of 15
-          minutes.
+          A recipient could potentially infer a user's [=precise position=] by
+          collecting and correlating multiple, distinct [=approximate
+          positions=]. To mitigate this risk of a refinement attack, when a
+          site receives an [=approximate position=], any subsequent calls from
+          that same site within a user-agent-defined time window SHOULD return
+          the exact same, cached [=approximate position=] data. A user agent
+          might, for example, use a time window of 15 minutes.
         </p>
       </section>
     </section>
@@ -925,14 +917,16 @@ <h3>
             <ol>
               <li>Let |resolvedPermissionState| be `null`.
               </li>
-              <li>If |permissionName| is <a>"geolocation-approximate"</a>:
+              <li>If |descriptor|.{{PermissionDescriptor/name}} is
+              <a>"geolocation-approximate"</a>:
                 <ol>
                   <li>Set |resolvedPermissionState| to the result of running
                   [=request permission to use=] |descriptor|.
                   </li>
                 </ol>
               </li>
-              <li>Otherwise (|permissionName| is <a>"geolocation"</a>):
+              <li>Otherwise (|descriptor|.{{PermissionDescriptor/name}} is <a>
+                "geolocation"</a>):
                 <ol>
                   <li>Let |precisePermissionStatus:GeolocationPermissionStatus|
                   be [=request precise geolocation permission=].
@@ -1029,8 +1023,8 @@ <h3>
           by running the following steps:
             <ol>
               <li>Let |permissionStatus:GeolocationPermissionStatus| be the
-              result of running the [=geolocation/precise permission query
-              algorithm=] given a new {{PermissionDescriptor}} with its
+              result of running the [=precise permission query algorithm=]
+              given a new {{PermissionDescriptor}} with its
               {{PermissionDescriptor/name}} set to "geolocation".
               </li>
               <li>Let |effectiveAccuracy:AccuracyMode?| be `null`.
@@ -1039,14 +1033,15 @@ <h3>
               [=permission/granted=]:
                 <ol>
                   <li>If |options|.{{PositionOptions/accuracyMode}} is
-                  "approximate":
+                  {{AccuracyMode/"approximate"}}:
                     <ol>
-                      <li>Set |effectiveAccuracy| to "approximate".
+                      <li>Set |effectiveAccuracy| to
+                      {{AccuracyMode/"approximate"}}.
                       </li>
                     </ol>
                   </li>
                   <li>Otherwise (|options|.{{PositionOptions/accuracyMode}} is
-                  "precise"):
+                  {{AccuracyMode/"precise"}}):
                     <ol>
                       <li>Set |effectiveAccuracy| to
                       |permissionStatus|.{{GeolocationPermissionStatus/accuracyMode}}.
@@ -1066,7 +1061,7 @@ <h3>
                   </li>
                 </ol>
               </li>
-              <li>Otherwise, run belows steps to determine |position|:
+              <li>Otherwise, run the following steps to determine |position|:
                 <ol>
                   <li>Check if an emulated position should be used by running
                   the following steps:
@@ -1136,15 +1131,16 @@ <h3>
                   <li>Otherwise, try to acquire position data from the
                   underlying system, with the following considerations:
                     <ol>
-                      <li>If |effectiveAccuracy| is "approximate", the user
-                      agent SHOULD acquire a position with a level of accuracy
-                      that is sufficient to protect user privacy (e.g.,
-                      city-level accuracy). The
+                      <li>If |effectiveAccuracy| is
+                      {{AccuracyMode/"approximate"}}, the user agent SHOULD
+                      acquire an [=approximate position=] with a level of
+                      accuracy that is sufficient to protect user privacy
+                      (e.g., city-level accuracy). The
                       {{PositionOptions/enableHighAccuracy}} member is ignored.
                       </li>
-                      <li>If |effectiveAccuracy| is "precise", the user agent
-                      SHOULD acquire a position, optionally taking into
-                      consideration the value of
+                      <li>If |effectiveAccuracy| is {{AccuracyMode/"precise"}},
+                      the user agent SHOULD acquire a [=precise position=],
+                      optionally taking into consideration the value of
                       |options|.{{PositionOptions/enableHighAccuracy}}.
                       </li>
                     </ol>
@@ -1236,7 +1232,8 @@ <h3>
                         "accuracyMode"
                       </dt>
                       <dd>
-                        Set to |effectiveAccuracy|.
+                        An {{AccuracyMode}} that indicates the accuracy level
+                        of the position. Set to |effectiveAccuracy|.
                       </dd>
                     </dl>
                   </li>
@@ -1351,15 +1348,17 @@ <h3>
         </h3>
         <p>
           The <dfn>accuracyMode</dfn> member is used to request a specific
-          level of accuracy. It can be set to "precise" to request the most
-          accurate location data available, or "approximate" to receive a less
-          accurate location that protects user privacy. The default value is
-          "precise".
+          level of accuracy. It can be set to {{AccuracyMode/"precise"}} to
+          request the most accurate location data available, or
+          {{AccuracyMode/"approximate"}} to receive a less accurate location
+          that protects user privacy. The default value is
+          {{AccuracyMode/"precise"}}.
         </p>
         <aside class="note" title="Interaction with enableHighAccuracy">
           <p>
-            If `accuracyMode` is set to "approximate", the `enableHighAccuracy`
-            member has no effect.
+            If {{PositionOptions/accuracyMode}} is set to
+            {{AccuracyMode/"approximate"}}, the `enableHighAccuracy` member has
+            no effect.
           </p>
         </aside>
       </section>
@@ -1575,9 +1574,9 @@ <h3>
         </h3>
         <p>
           The <dfn>accuracyMode</dfn> attribute indicates the accuracy level of
-          the position, which can be either `"precise"` or `"approximate"`.
-          This reflects the level of accuracy that was granted and used to
-          obtain the position.
+          the position, which can be either {{AccuracyMode/"precise"}} or
+          {{AccuracyMode/"approximate"}}. This reflects the level of accuracy
+          that was granted and used to obtain the position.
         </p>
       </section>
       <section>
@@ -1600,7 +1599,9 @@ <h3>
         </p>
         <ol class="algorithm">
           <li>Let |coords:GeolocationCoordinates| be a newly created
-          {{GeolocationCoordinates}} instance.
+          {{GeolocationCoordinates}} instance with its
+          {{GeolocationCoordinates/accuracyMode}} attribute initialized to
+          {{AccuracyMode/"precise"}}.
           </li>
           <li>[=map/For each=] |key| → |value| in |positionData|:
             <ol>
@@ -1711,8 +1712,28 @@ <h2>
       </p>
       <p>
         Each [=top-level traversable=] has an associated <dfn>emulated position
-        data</dfn>, which is a [=map=] or null, initially null.
+        data</dfn>, which is a [=map=] or null, initially null. When it is a
+        [=map=], it can contain the following optional keys:
       </p>
+      <dl>
+        <dt>
+          "coordinates"
+        </dt>
+        <dd>
+          A [=map=] representing the position's geographic coordinates and
+          accuracy. It SHOULD contain the same name/value pairs as defined in
+          the |positionData| map of the <a>acquire a position</a> algorithm.
+        </dd>
+        <dt>
+          "error"
+        </dt>
+        <dd>
+          A [=map=] representing an error state. It MUST contain a "type" key
+          whose value is an {{unsigned short}} representing one of the codes
+          defined in {{GeolocationPositionError}} (e.g.,
+          {{GeolocationPositionError/PERMISSION_DENIED}}).
+        </dd>
+      </dl>
       <p>
         To <dfn class="export">set emulated position data</dfn>, given
         [=navigable=] |navigable| and an |emulatedPositionData|:

From fd08f20d2cc5b92e7e9b8db8857508cd88126a52 Mon Sep 17 00:00:00 2001
From: Alvin Ji <alvinji@chromium.org>
Date: Tue, 28 Apr 2026 11:43:54 -0700
Subject: [PATCH 06/12] Remove GeolocationPermissionStatus and
 coords.accuracyMode

---
 index.html | 406 ++++++++++++++++++++---------------------------------
 1 file changed, 156 insertions(+), 250 deletions(-)

diff --git a/index.html b/index.html
index 1e255c4..a74d470 100644
--- a/index.html
+++ b/index.html
@@ -280,30 +280,28 @@ <h3>
           By default, the API always attempts to return a cached position so
           long as it has a previously acquired position that matches the
           requested {{PositionOptions/accuracyMode}}. In this example, we
-          accept a [=precise position=] whose age is no greater than 10
-          minutes. If the user agent does not have a fresh enough cached
-          position object of the correct accuracy, it automatically acquires a
-          new position.
+          request a cached position whose age is no greater than 10 minutes. If
+          the user agent does not have a fresh enough cached position object of
+          the correct accuracy, it automatically acquires a new position.
         </p>
-        <aside class="example" title="Getting a cached precise position">
+        <aside class="example" title="Getting a cached position">
           <pre class="js">
+            // Requesting a cached precise position.
+            // Note: `accuracyMode` defaults to "precise".
             navigator.geolocation.getCurrentPosition(
               successCallback,
               console.error,
-              { maximumAge: 600_000 } // `accuracyMode` defaults to "precise"
+              { 
+                maximumAge: 600_000,
+              }
             );
-          </pre>
-        </aside>
-        <p>
-          Similarly, you can request a cached approximate position.
-        </p>
-        <aside class="example" title="Getting a cached approximate position">
-          <pre class="js">
+
+            // Requesting a cached approximate position.
             navigator.geolocation.getCurrentPosition(
               successCallback,
               console.error,
-              { 
-                maximumAge: 600_000, 
+              {
+                maximumAge: 600_000,
                 accuracyMode: "approximate",
               }
             );
@@ -389,7 +387,7 @@ <h3>
         </p>
       </section>
     </section>
-    <section id="privacy" class="informative">
+    <section id="privacy">
       <h2>
         Privacy considerations
       </h2>
@@ -403,16 +401,16 @@ <h2>
         The {{PositionOptions/accuracyMode}} option enhances user privacy by
         providing websites with the choice to request an [=approximate
         position=]. This allows applications to function without needing the
-        user's [=precise position=], thus offering a more privacy-friendly
+        user's [=precise position=], thus offering a more privacy-preserving
         alternative. When an application requests an [=approximate position=],
-        the user agent can provide a less precise location that still meets the
-        application's needs while obscuring the user's [=precise position=].
-        Even when a [=precise position=] is requested, the user agent can
-        provide an [=approximate position=] instead (as defined in the
-        [=acquire a position=] algorithm), for example, if the user has only
-        granted permission for approximate accuracy.
+        a supporting user agent MUST provide a less precise location, obscuring
+        the user's [=precise position=]. Even when a [=precise position=] is
+        requested, the user agent MAY provide an [=approximate position=]
+        instead (as defined in the [=acquire a position=] algorithm), for
+        example, if the user has only granted permission for approximate
+        accuracy.
       </p>
-      <section class="informative">
+      <section>
         <h3>
           User consent
         </h3>
@@ -421,17 +419,14 @@ <h3>
           <a>"geolocation-approximate"</a> and <a>"geolocation"</a>, which
           require [=express permission=] from an end-user before any location
           data is shared with a web application. This requirement is
-          normatively enforced by the [=request permission to use=] algorithm,
-          which is customized for precise location by the [=request precise
-          geolocation permission=] steps, on which the
-          {{Geolocation/getCurrentPosition()}} and
+          normatively enforced by the [=request permission to use=] algorithm
+          on which the {{Geolocation/getCurrentPosition()}} and
           {{Geolocation/watchPosition()}} methods rely. [=User agents=] with
-          support for [=approximate position=] are strongly encouraged to
-          provide users with the option to grant access to either a [=precise
-          position=] or an [=approximate position=]. This choice gives users
-          more control over their privacy, allowing them to share a less
-          precise location when they are not comfortable sharing their
-          [=precise position=].
+          support for [=approximate position=] MUST provide users with the
+          option to grant access to either a [=precise position=] or an
+          [=approximate position=]. This choice gives users more control over
+          their privacy, allowing them to share a less precise location when
+          they are not comfortable sharing their [=precise position=].
         </p>
         <p>
           An end-user will generally give [=express permission=] through a user
@@ -533,140 +528,89 @@ <h3>
           <cite>Geolocation</cite> defines two [=permissions=] identified by
           the names <dfn class="permission">"geolocation"</dfn> (for precise
           location) and <dfn class="permission">"geolocation-approximate"</dfn>
-          (for approximate location).
-        </p>
-        <p>
-          There is a strict dependency between the [=permission state=]s of
-          <a>"geolocation"</a> and <a>"geolocation-approximate"</a>.
-          Specifically, granting a [=precise position=] implies granting an
-          [=approximate position=], and denying an [=approximate position=]
-          implies denying a [=precise position=]. This results in the following
-          allowed combinations of states:
-        </p>
-        <ul>
-          <li>Both are [=permission/"granted"=].
-          </li>
-          <li>Both are [=permission/"prompt"=].
-          </li>
-          <li>Both are [=permission/"denied"=].
-          </li>
-          <li>
-            <a>"geolocation-approximate"</a> is [=permission/"granted"=] and
-            <a>"geolocation"</a> is [=permission/"prompt"=].
-          </li>
-          <li>
-            <a>"geolocation-approximate"</a> is [=permission/"granted"=] and
-            <a>"geolocation"</a> is [=permission/"denied"=].
-          </li>
-          <li>
-            <a>"geolocation-approximate"</a> is [=permission/"prompt"=] and
-            <a>"geolocation"</a> is [=permission/"denied"=].
-          </li>
-        </ul>
-        <p>
-          User agents MUST ensure that these states remain coherent. For
-          example, if a user changes the [=permission state=] of
-          <a>"geolocation-approximate"</a> to [=permission/"denied"=] via site
-          settings, the user agent MUST automatically update
-          <a>"geolocation"</a> to [=permission/"denied"=] as well. Similarly,
-          if <a>"geolocation"</a> is changed to [=permission/"granted"=],
-          <a>"geolocation-approximate"</a> MUST also become
-          [=permission/"granted"=].
+          (for approximate location). Both <a>"geolocation"</a> and
+          <a>"geolocation-approximate"</a> are [=default powerful features=].
         </p>
         <p>
-          <a>"geolocation-approximate"</a> is a [=default powerful feature=],
-          while <a>"geolocation"</a> is a [=powerful feature=] with:
+          There is a strict dependency between the [=permission states=] of
+          <a>"geolocation"</a> and <a>"geolocation-approximate"</a>, resulting
+          in the following allowed combinations of states:
         </p>
-        <ul>
-          <li>A custom [=powerful feature/permission result type=]
-          {{GeolocationPermissionStatus}}:
-            <pre class="idl">
-                [Exposed=(Window,Worker)]
-                interface GeolocationPermissionStatus : PermissionStatus {
-                  readonly attribute AccuracyMode accuracyMode;
-                };
-            </pre>
-          </li>
-          <li>A custom <dfn>precise permission query algorithm</dfn>, which,
-          given a {{PermissionDescriptor}} |permissionDesc| and a
-          {{GeolocationPermissionStatus}} |status|, runs the following steps:
-            <ol class="algorithm">
-              <li>Let |approximatePermissionDesc| be a {{PermissionDescriptor}}
-              with {{PermissionDescriptor/name}} set to
-              <a>"geolocation-approximate"</a>.
-              </li>
-              <li>Let |approximatePermissionState| be
-              |approximatePermissionDesc|'s [=permission state=].
-              </li>
-              <li>If |approximatePermissionState| is [=permission/"granted"=]
-              and |permissionDesc|'s [=permission state=] is
-              [=permission/"prompt"=], set |status|'s
-              {{PermissionStatus/state}} to [=permission/"prompt"=]. Otherwise,
-              set |status|'s {{PermissionStatus/state}} to
-              |approximatePermissionState|.
-              </li>
-              <li>If |status|'s {{PermissionStatus/state}} is equal to
-              [=permission/"granted"=], set |status|'s
-              {{GeolocationPermissionStatus/accuracyMode}} to
-              {{AccuracyMode/"precise"}} if also |permissionDesc|'s
-              [=permission state=] is [=permission/"granted"=] or to
-              {{AccuracyMode/"approximate"}} otherwise.
-                <aside class="note">
-                  <p>
-                    As noted above, there are only six valid combinations of
-                    [=permission state=]s for <a>"geolocation"</a> and
-                    <a>"geolocation-approximate"</a>.
-                  </p>
-                </aside>
-              </li>
-            </ol>
-          </li>
-        </ul>
+        <table class="data">
+          <thead>
+            <tr>
+              <th>
+                <a>"geolocation"</a>
+              </th>
+              <th>
+                <a>"geolocation-approximate"</a>
+              </th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>
+                [=permission/"granted"=]
+              </td>
+              <td>
+                [=permission/"granted"=]
+              </td>
+            </tr>
+            <tr>
+              <td>
+                [=permission/"prompt"=]
+              </td>
+              <td>
+                [=permission/"prompt"=]
+              </td>
+            </tr>
+            <tr>
+              <td>
+                [=permission/"denied"=]
+              </td>
+              <td>
+                [=permission/"denied"=]
+              </td>
+            </tr>
+            <tr>
+              <td>
+                [=permission/"prompt"=]
+              </td>
+              <td>
+                [=permission/"granted"=]
+              </td>
+            </tr>
+            <tr>
+              <td>
+                [=permission/"denied"=]
+              </td>
+              <td>
+                [=permission/"granted"=]
+              </td>
+            </tr>
+            <tr>
+              <td>
+                [=permission/"denied"=]
+              </td>
+              <td>
+                [=permission/"prompt"=]
+              </td>
+            </tr>
+          </tbody>
+        </table>
         <p>
-          To <dfn>request precise geolocation permission</dfn>, the user agent
-          MUST run the following steps.
+          To maintain coherence, user agents MUST run the following steps when
+          the [=permission state=] of either <a>"geolocation"</a> or
+          <a>"geolocation-approximate"</a> changes:
         </p>
         <ol class="algorithm">
-          <li>Let |preciseLocationDescriptor| be a new {{PermissionDescriptor}}
-          with {{PermissionDescriptor/name}} set to <a>"geolocation"</a>.
-          </li>
-          <li>Run the [=precise permission query algorithm=] given
-          |preciseLocationDescriptor| and a new {{GeolocationPermissionStatus}}
-          |status|.
+          <li>If the [=permission state=] of <a>"geolocation"</a> is changed to
+          [=permission/"granted"=], set the [=permission state=] of
+          <a>"geolocation-approximate"</a> to [=permission/"granted"=].
           </li>
-          <li>If |status|'s {{PermissionStatus/state}} is not
-          [=permission/"prompt"=], return |status|.
-          </li>
-          <li>Let |approximateLocationDescriptor| be a new
-          {{PermissionDescriptor}} with {{PermissionDescriptor/name}} set to
-          <a>"geolocation-approximate"</a>.
-          </li>
-          <li>Run the [=powerful feature/permission query algorithm=] given
-          |approximateLocationDescriptor| and a new {{PermissionStatus}}
-          |approximateStatus|.
-          </li>
-          <li>If |approximateStatus|.{{PermissionStatus/state}} is
-          [=permission/"granted"=], [=request permission to use=]
-          |preciseLocationDescriptor|. Otherwise, [=request permission to use=]
-          |approximateLocationDescriptor| and [=request permission to use=]
-          |preciseLocationDescriptor|.
-            <aside class="note">
-              <p>
-                The user agent is free to group the two resulting questions for
-                the user into a single permission prompt, asking the user
-                whether they want to express permission to grant either
-                approximate or precise geolocation (or none).
-              </p>
-            </aside>
-          </li>
-          <li>Run the [=precise permission query algorithm=] given
-          |preciseLocationDescriptor| and a new {{GeolocationPermissionStatus}}
-          |newGeolocationStatus|.
-          </li>
-          <li>Assert: |newGeolocationStatus|'s state is not
-          [=permission/"prompt"=].
-          </li>
-          <li>Return |newGeolocationStatus|.
+          <li>If the [=permission state=] of <a>"geolocation-approximate"</a>
+          is changed to [=permission/"denied"=], set the [=permission state=]
+          of <a>"geolocation"</a> to [=permission/"denied"=].
           </li>
         </ol>
       </section>
@@ -915,24 +859,21 @@ <h3>
           </li>
           <li>[=In parallel=]:
             <ol>
-              <li>Let |resolvedPermissionState| be `null`.
+              <li>Let |resolvedPermissionState| be the result of running
+              [=request permission to use=] |descriptor|.
               </li>
               <li>If |descriptor|.{{PermissionDescriptor/name}} is
-              <a>"geolocation-approximate"</a>:
-                <ol>
-                  <li>Set |resolvedPermissionState| to the result of running
-                  [=request permission to use=] |descriptor|.
-                  </li>
-                </ol>
-              </li>
-              <li>Otherwise (|descriptor|.{{PermissionDescriptor/name}} is <a>
-                "geolocation"</a>):
+              <a>"geolocation"</a> and |resolvedPermissionState| is not
+              [=permission/"granted"=]:
                 <ol>
-                  <li>Let |precisePermissionStatus:GeolocationPermissionStatus|
-                  be [=request precise geolocation permission=].
+                  <li>Let |approximateDescriptor| be a new
+                  {{PermissionDescriptor}} whose {{PermissionDescriptor/name}}
+                  is <a>"geolocation-approximate"</a>.
                   </li>
-                  <li>Set |resolvedPermissionState| to
-                  |precisePermissionStatus|.state.
+                  <li>If the [=permission state=] of |approximateDescriptor| is
+                  [=permission/"granted"=], set |resolvedPermissionState| to
+                  [=permission/"granted"=]. Otherwise, set
+                  |resolvedPermissionState| to [=permission/"denied"=].
                   </li>
                 </ol>
               </li>
@@ -1022,29 +963,41 @@ <h3>
           |timeoutTime|, during which it tries to acquire the device's position
           by running the following steps:
             <ol>
-              <li>Let |permissionStatus:GeolocationPermissionStatus| be the
-              result of running the [=precise permission query algorithm=]
-              given a new {{PermissionDescriptor}} with its
-              {{PermissionDescriptor/name}} set to "geolocation".
-              </li>
               <li>Let |effectiveAccuracy:AccuracyMode?| be `null`.
               </li>
-              <li>If |permissionStatus|.{{PermissionStatus/state}} is
-              [=permission/granted=]:
+              <li>Let |preciseDescriptor| be a new {{PermissionDescriptor}}
+              with its {{PermissionDescriptor/name}} set to
+              <a>"geolocation"</a>.
+              </li>
+              <li>Let |approximateDescriptor| be a new {{PermissionDescriptor}}
+              with its {{PermissionDescriptor/name}} set to
+              <a>"geolocation-approximate"</a>.
+              </li>
+              <li>If |options|.{{PositionOptions/accuracyMode}} is
+              {{AccuracyMode/"approximate"}}:
+                <ol>
+                  <li>If the [=permission state=] of |approximateDescriptor| is
+                  [=permission/"granted"=], set |effectiveAccuracy| to
+                  {{AccuracyMode/"approximate"}}.
+                  </li>
+                </ol>
+              </li>
+              <li>Otherwise (|options|.{{PositionOptions/accuracyMode}} is
+              {{AccuracyMode/"precise"}}):
                 <ol>
-                  <li>If |options|.{{PositionOptions/accuracyMode}} is
-                  {{AccuracyMode/"approximate"}}:
+                  <li>If the [=permission state=] of |preciseDescriptor| is
+                  [=permission/"granted"=]:
                     <ol>
                       <li>Set |effectiveAccuracy| to
-                      {{AccuracyMode/"approximate"}}.
+                      {{AccuracyMode/"precise"}}.
                       </li>
                     </ol>
                   </li>
-                  <li>Otherwise (|options|.{{PositionOptions/accuracyMode}} is
-                  {{AccuracyMode/"precise"}}):
+                  <li>Otherwise, if the [=permission state=] of
+                  |approximateDescriptor| is [=permission/"granted"=]:
                     <ol>
                       <li>Set |effectiveAccuracy| to
-                      |permissionStatus|.{{GeolocationPermissionStatus/accuracyMode}}.
+                      {{AccuracyMode/"approximate"}}.
                       </li>
                     </ol>
                   </li>
@@ -1071,25 +1024,19 @@ <h3>
                       </li>
                       <li>If |emulatedPositionData| is not null:
                         <ol>
-                          <li>If |emulatedPositionData|["error"]
-                          [=map/exists=]:
+                          <li>If |emulatedPositionData| is a
+                          {{GeolocationPositionError}}:
                             <ol>
-                              <li>Let |error| be a newly created
-                              {{GeolocationPositionError}} instance with its
-                              {{GeolocationPositionError/code}} attribute
-                              initialized to
-                              |emulatedPositionData|["error"]["type"].
-                              </li>
                               <li>[=Call back with error=] passing
-                              |errorCallback| and |error|.
+                              |errorCallback| and
+                              |emulatedPositionData|.{{GeolocationPositionError/code}}.
                               </li>
                               <li>Terminate this algorithm.
                               </li>
                             </ol>
                           </li>
                           <li>Let |position| be [=a new `GeolocationPosition`=]
-                          passing |emulatedPositionData|["coordinates"],
-                          |acquisitionTime|, and
+                          passing |emulatedPositionData|, |acquisitionTime| and
                           |options|.{{PositionOptions/enableHighAccuracy}}.
                           </li>
                           <li>[=Queue a task=] on the [=geolocation task
@@ -1113,9 +1060,7 @@ <h3>
                       </li>
                       <li>If |cachedPosition|'s
                       {{GeolocationPosition/timestamp}}'s value is greater than
-                      |cacheTime|, and |effectiveAccuracy| equals
-                      |cachedPosition|'s {{GeolocationPosition/coords}}'s
-                      {{GeolocationCoordinates/accuracyMode}}:
+                      |cacheTime|:
                         <ol>
                           <li>[=Queue a task=] on the [=geolocation task
                           source=] with a step that [=invokes=]
@@ -1228,13 +1173,6 @@ <h3>
                         Heading measures the direction in which the device is
                         moving relative to true north.
                       </dd>
-                      <dt>
-                        "accuracyMode"
-                      </dt>
-                      <dd>
-                        An {{AccuracyMode}} that indicates the accuracy level
-                        of the position. Set to |effectiveAccuracy|.
-                      </dd>
                     </dl>
                   </li>
                   <li>Set |position| to [=a new `GeolocationPosition`=] passing
@@ -1394,10 +1332,10 @@ <h3>
         </p>
         <p class="note" title="When is the timeout calculated?">
           The time spent waiting for the document to become visible and for
-          [=request precise geolocation permission|obtaining permission to use
-          the API=] is not included in the period covered by the
-          {{PositionOptions/timeout}} member. The {{PositionOptions/timeout}}
-          member only applies when [=acquiring a position=] begins.
+          [=request permission to use|obtaining permission to use the API=] is
+          not included in the period covered by the {{PositionOptions/timeout}}
+          member. The {{PositionOptions/timeout}} member only applies when
+          [=acquiring a position=] begins.
         </p>
         <aside class="note" title="Immediate cancellation">
           <p>
@@ -1517,7 +1455,6 @@ <h2>
           readonly attribute double? altitudeAccuracy;
           readonly attribute double? heading;
           readonly attribute double? speed;
-          readonly attribute AccuracyMode accuracyMode;
           [Default] object toJSON();
         };
       </pre>
@@ -1568,17 +1505,6 @@ <h3>
           meters per second.
         </p>
       </section>
-      <section>
-        <h3>
-          `accuracyMode` attribute
-        </h3>
-        <p>
-          The <dfn>accuracyMode</dfn> attribute indicates the accuracy level of
-          the position, which can be either {{AccuracyMode/"precise"}} or
-          {{AccuracyMode/"approximate"}}. This reflects the level of accuracy
-          that was granted and used to obtain the position.
-        </p>
-      </section>
       <section>
         <h3>
           `toJSON()` method
@@ -1599,9 +1525,7 @@ <h3>
         </p>
         <ol class="algorithm">
           <li>Let |coords:GeolocationCoordinates| be a newly created
-          {{GeolocationCoordinates}} instance with its
-          {{GeolocationCoordinates/accuracyMode}} attribute initialized to
-          {{AccuracyMode/"precise"}}.
+          {{GeolocationCoordinates}} instance.
           </li>
           <li>[=map/For each=] |key| → |value| in |positionData|:
             <ol>
@@ -1712,34 +1636,16 @@ <h2>
       </p>
       <p>
         Each [=top-level traversable=] has an associated <dfn>emulated position
-        data</dfn>, which is a [=map=] or null, initially null. When it is a
-        [=map=], it can contain the following optional keys:
+        data</dfn>, which is data representing {{GeolocationCoordinates}},
+        {{GeolocationPositionError}} or null, initially null.
       </p>
-      <dl>
-        <dt>
-          "coordinates"
-        </dt>
-        <dd>
-          A [=map=] representing the position's geographic coordinates and
-          accuracy. It SHOULD contain the same name/value pairs as defined in
-          the |positionData| map of the <a>acquire a position</a> algorithm.
-        </dd>
-        <dt>
-          "error"
-        </dt>
-        <dd>
-          A [=map=] representing an error state. It MUST contain a "type" key
-          whose value is an {{unsigned short}} representing one of the codes
-          defined in {{GeolocationPositionError}} (e.g.,
-          {{GeolocationPositionError/PERMISSION_DENIED}}).
-        </dd>
-      </dl>
       <p>
         To <dfn class="export">set emulated position data</dfn>, given
         [=navigable=] |navigable| and an |emulatedPositionData|:
       </p>
       <ol class="algorithm">
-        <li>Assert |emulatedPositionData| is either null or a [=map=].
+        <li>Assert |emulatedPositionData| is either null, a
+        {{GeolocationCoordinates}}, or a {{GeolocationPositionError}}.
         </li>
         <li>Let |traversable| be |navigable|’s [=navigable/top-level
         traversable=].

From 8f4bc68a75cddb8fd822ea04355f2f180b9057d6 Mon Sep 17 00:00:00 2001
From: Alvin Ji <alvinji@chromium.org>
Date: Tue, 28 Apr 2026 13:09:29 -0700
Subject: [PATCH 07/12] Clean up

---
 index.html | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/index.html b/index.html
index a74d470..fc08351 100644
--- a/index.html
+++ b/index.html
@@ -1060,7 +1060,9 @@ <h3>
                       </li>
                       <li>If |cachedPosition|'s
                       {{GeolocationPosition/timestamp}}'s value is greater than
-                      |cacheTime|:
+                      |cacheTime|, and
+                      |cachedPosition|.{{GeolocationPosition/[[isHighAccuracy]]}}
+                      equals |options|.{{PositionOptions/enableHighAccuracy}}:
                         <ol>
                           <li>[=Queue a task=] on the [=geolocation task
                           source=] with a step that [=invokes=]
@@ -1520,7 +1522,7 @@ <h3>
         </h3>
         <p>
           <dfn>A new `GeolocationPosition`</dfn> is constructed with [=map=]
-          |positionData|, {{EpochTimeStamp}} |timestamp:EpochTimeStamp|, and
+          |positionData|, {{EpochTimeStamp}} |timestamp:EpochTimeStamp| and
           boolean |isHighAccuracy| by performing the following steps:
         </p>
         <ol class="algorithm">
@@ -1534,10 +1536,10 @@ <h3>
             </ol>
           </li>
           <li>Return a newly created {{GeolocationPosition}} instance with its
-          {{GeolocationPosition/coords}} attribute initialized to |coords|,
+          {{GeolocationPosition/coords}} attribute initialized to |coords| and
           {{GeolocationPosition/timestamp}} attribute initialized to
-          |timestamp|, and {{GeolocationPosition/[[isHighAccuracy]]}} internal
-          slot set to |isHighAccuracy|.
+          |timestamp|, and its {{GeolocationPosition/[[isHighAccuracy]]}}
+          internal slot set to |isHighAccuracy|.
           </li>
         </ol>
       </section>

From c6a6e2e6e8978d3f05fdd21db1670829544861db Mon Sep 17 00:00:00 2001
From: Alvin Ji <alvinji@chromium.org>
Date: Wed, 13 May 2026 20:05:19 -0700
Subject: [PATCH 08/12] Add note clarifying geolocation-approximate
 queryability

Clarifies that exposing the "geolocation-approximate" permission is not strictly enforced, and implementations may choose to only make "geolocation" queryable.
---
 index.html | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/index.html b/index.html
index fc08351..cd86e02 100644
--- a/index.html
+++ b/index.html
@@ -613,6 +613,12 @@ <h3>
           of <a>"geolocation"</a> to [=permission/"denied"=].
           </li>
         </ol>
+        <p class="note" title="Querying 'geolocation-approximate'">
+          The <a>"geolocation-approximate"</a> permission is not guaranteed to
+          be queryable in all user agents. Implementations that wish to expose
+          only necessary information can choose to make only <a>"geolocation"</a>
+          queryable; exposing <a>"geolocation-approximate"</a> is not enforced.
+        </p>
       </section>
       <section>
         <h3>

From fd1dd48de45749dce73b62c9857241a6de1ff882 Mon Sep 17 00:00:00 2001
From: Alvin Ji <alvinji@chromium.org>
Date: Fri, 15 May 2026 15:19:24 -0700
Subject: [PATCH 09/12] Update Geolocation permissions queryability note

This update correctly links to the Permissions API using ReSpec citing conventions and resolves a missing definition error by using the correct 'query a permission' algorithm term.
---
 index.html | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/index.html b/index.html
index cd86e02..756b602 100644
--- a/index.html
+++ b/index.html
@@ -614,10 +614,10 @@ <h3>
           </li>
         </ol>
         <p class="note" title="Querying 'geolocation-approximate'">
-          The <a>"geolocation-approximate"</a> permission is not guaranteed to
-          be queryable in all user agents. Implementations that wish to expose
-          only necessary information can choose to make only <a>"geolocation"</a>
-          queryable; exposing <a>"geolocation-approximate"</a> is not enforced.
+          When [=query a permission|querying a permission=] via the
+          [[[Permissions]]] API, implementations might mask the returned states
+          of <a>"geolocation"</a> and <a>"geolocation-approximate"</a> in order
+          to hide the user choice from websites.
         </p>
       </section>
       <section>

From 5a86822177cd85fa7699faea4c4d77e1a833613f Mon Sep 17 00:00:00 2001
From: Alvin Ji <alvinji@chromium.org>
Date: Mon, 18 May 2026 22:22:36 -0700
Subject: [PATCH 10/12] Address reviewer comments on position definitions and
 normative language

- Use <dl>, <dt>, and <dd> for precise and approximate position definitions.
- Convert informative note on permission masking to a normative statement.
- Tidy index.html.
---
 index.html | 110 +++++++++++++++++++++++++++++------------------------
 1 file changed, 60 insertions(+), 50 deletions(-)

diff --git a/index.html b/index.html
index 756b602..b7d5e7c 100644
--- a/index.html
+++ b/index.html
@@ -72,29 +72,35 @@ <h2>
       </p>
       <p>
         This specification provides two ways for users to share their location:
-        a [=precise position=] and an [=approximate position=].
-      </p>
-      <p>
-        A <dfn>precise position</dfn> is a position returned by the underlying
-        location information source. By default, any location data is
-        considered precise, regardless of its accuracy estimate, unless it has
-        been explicitly coarsened by an approximate location information source
-        to be an [=approximate position=].
-      </p>
-      <p>
-        An <dfn>approximate position</dfn> is a less precise,
-        privacy-preserving representation of the user's location. Instead of
-        providing precise coordinates, an approximate location information
-        source can return a location that is intentionally coarsened to a
-        larger area, such as the nearest city, postal code, or a predefined
-        region. What constitutes a coarsened area is left to the underlying
-        system. This is often sufficient for applications that don't need to
-        know the user's [=precise position=], for example, a weather
-        application that only needs a city-level location. By sharing an
-        [=approximate position=], users can still get the benefit of a
-        location-aware application without revealing their [=precise
-        position=].
       </p>
+      <dl>
+        <dt>
+          <dfn>precise position</dfn>
+        </dt>
+        <dd>
+          A position returned by the underlying location information source. By
+          default, any location data is considered precise, regardless of its
+          accuracy estimate, unless it has been explicitly coarsened by an
+          approximate location information source to be an [=approximate
+          position=].
+        </dd>
+        <dt>
+          <dfn>approximate position</dfn>
+        </dt>
+        <dd>
+          A less precise, privacy-preserving representation of the user's
+          location. Instead of providing precise coordinates, an approximate
+          location information source can return a location that is coarsened
+          to a larger area, such as the nearest city, postal code, or a
+          predefined region. What constitutes a coarsened area is left to the
+          underlying system. This is often sufficient for applications that
+          don't need to know the user's [=precise position=], for example, a
+          weather application that only needs a city-level location. By sharing
+          an [=approximate position=], users can still get the benefit of a
+          location-aware application without revealing their [=precise
+          position=].
+        </dd>
+      </dl>
       <p>
         An approximate location information source is a location information
         source that returns positions that have been intentionally obfuscated
@@ -161,8 +167,8 @@ <h3>
           position=] or an [=approximate position=] via the
           {{PositionOptions/accuracyMode}} member. During the permission
           request process, the end-user determines the actual level of accuracy
-          to grant, which the user agent then uses to provide the geographic
-          position accordingly.
+          to grant, which the [=user agent=] then uses to provide the
+          geographic position accordingly.
         </p>
         <aside class="example" title="A one-shot position request">
           <pre class="js">
@@ -403,8 +409,8 @@ <h2>
         position=]. This allows applications to function without needing the
         user's [=precise position=], thus offering a more privacy-preserving
         alternative. When an application requests an [=approximate position=],
-        a supporting user agent MUST provide a less precise location, obscuring
-        the user's [=precise position=]. Even when a [=precise position=] is
+        a supporting [=user agent=], or underlying platform, attempts to
+        provides a less precise location. Even when a [=precise position=] is
         requested, the user agent MAY provide an [=approximate position=]
         instead (as defined in the [=acquire a position=] algorithm), for
         example, if the user has only granted permission for approximate
@@ -425,8 +431,7 @@ <h3>
           support for [=approximate position=] MUST provide users with the
           option to grant access to either a [=precise position=] or an
           [=approximate position=]. This choice gives users more control over
-          their privacy, allowing them to share a less precise location when
-          they are not comfortable sharing their [=precise position=].
+          their privacy, allowing them to share an [=approximate position=].
         </p>
         <p>
           An end-user will generally give [=express permission=] through a user
@@ -445,7 +450,7 @@ <h3>
           Although the granularity of the permission [=permission/lifetime=]
           varies across user-agents, this specification urges user agents to
           limit the lifetime to a single browsing session by default (see
-          [[[#permission]]] for normative requirements).
+          [=checking permission=] for normative requirements).
         </p>
       </section>
       <section id="privacy_for_recipients" class="informative">
@@ -613,11 +618,22 @@ <h3>
           of <a>"geolocation"</a> to [=permission/"denied"=].
           </li>
         </ol>
-        <p class="note" title="Querying 'geolocation-approximate'">
+        <p title="Querying 'geolocation-approximate'">
           When [=query a permission|querying a permission=] via the
-          [[[Permissions]]] API, implementations might mask the returned states
-          of <a>"geolocation"</a> and <a>"geolocation-approximate"</a> in order
-          to hide the user choice from websites.
+          [[[Permissions]]] API, a user agent MAY mask the returned states of
+          <a>"geolocation"</a> and <a>"geolocation-approximate"</a> in order to
+          hide the user choice from websites.
+        </p>
+        <p>
+          When <dfn>checking permission</dfn> to use the API, a user agent MAY
+          suggest time-based [=permission=] [=permission/lifetimes=], such as
+          "24 hours", "1 week", or choose to remember the permission
+          [=permission/grant=] indefinitely. However, it is RECOMMENDED that a
+          user agent prioritize restricting the [=permission=]
+          [=permission/lifetime=] to a single session: This can be, for
+          example, until the [=environment settings object/realm=] is
+          destroyed, the end-user [=navigates=] away from the [=origin=], or
+          the relevant browser tab is closed.
         </p>
       </section>
       <section>
@@ -1085,15 +1101,14 @@ <h3>
                   underlying system, with the following considerations:
                     <ol>
                       <li>If |effectiveAccuracy| is
-                      {{AccuracyMode/"approximate"}}, the user agent SHOULD
-                      acquire an [=approximate position=] with a level of
-                      accuracy that is sufficient to protect user privacy
-                      (e.g., city-level accuracy). The
+                      {{AccuracyMode/"approximate"}}, acquire an [=approximate
+                      position=] with a level of accuracy that is sufficient to
+                      protect user privacy (e.g., city-level accuracy). The
                       {{PositionOptions/enableHighAccuracy}} member is ignored.
                       </li>
                       <li>If |effectiveAccuracy| is {{AccuracyMode/"precise"}},
-                      the user agent SHOULD acquire a [=precise position=],
-                      optionally taking into consideration the value of
+                      acquire a [=precise position=], optionally taking into
+                      consideration the value of
                       |options|.{{PositionOptions/enableHighAccuracy}}.
                       </li>
                     </ol>
@@ -1105,8 +1120,7 @@ <h3>
                 <ol>
                   <li>Stop the |timeout|.
                   </li>
-                  <li>Go to <a href="#errors-reasons">dealing with
-                  failures</a>.
+                  <li>[=Deal with failure=].
                   </li>
                   <li>Terminate this algorithm.
                   </li>
@@ -1114,7 +1128,7 @@ <h3>
               </li>
               <li data-cite="infra">If acquiring the position data from the
               system succeeds:
-                <ol data-cite="infra">
+                <ol>
                   <li>Let |positionData| be a [=map=] with the following
                   name/value pairs based on the acquired position data:
                     <dl data-sort="">
@@ -1203,7 +1217,7 @@ <h3>
         </ol>
         <dl class="switch">
           <dt id="errors-reasons">
-            Dealing with failures:
+            <dfn>Deal with failure</dfn>:
           </dt>
           <dd>
             <ul>
@@ -1294,17 +1308,13 @@ <h3>
         </h3>
         <p>
           The <dfn>accuracyMode</dfn> member is used to request a specific
-          level of accuracy. It can be set to {{AccuracyMode/"precise"}} to
-          request the most accurate location data available, or
-          {{AccuracyMode/"approximate"}} to receive a less accurate location
-          that protects user privacy. The default value is
-          {{AccuracyMode/"precise"}}.
+          level of accuracy.
         </p>
         <aside class="note" title="Interaction with enableHighAccuracy">
           <p>
             If {{PositionOptions/accuracyMode}} is set to
-            {{AccuracyMode/"approximate"}}, the `enableHighAccuracy` member has
-            no effect.
+            {{AccuracyMode/"approximate"}}, the [=user agent=] ignores the
+            {{PositionOptions/enableHighAccuracy}} member.
           </p>
         </aside>
       </section>

From f24e2768cfb720ac71851b92c842cf5ce8e8e6fb Mon Sep 17 00:00:00 2001
From: Alvin Ji <alvinji@chromium.org>
Date: Mon, 18 May 2026 22:33:58 -0700
Subject: [PATCH 11/12] Update wording for permission states combinations

---
 index.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/index.html b/index.html
index b7d5e7c..29a692d 100644
--- a/index.html
+++ b/index.html
@@ -539,7 +539,7 @@ <h3>
         <p>
           There is a strict dependency between the [=permission states=] of
           <a>"geolocation"</a> and <a>"geolocation-approximate"</a>, resulting
-          in the following allowed combinations of states:
+          in the following combinations of [=permission states=]:
         </p>
         <table class="data">
           <thead>

From bb774d31d916b89877885a5eccf5cebd2a22cf94 Mon Sep 17 00:00:00 2001
From: Alvin Ji <alvinji@chromium.org>
Date: Wed, 20 May 2026 18:28:09 -0700
Subject: [PATCH 12/12] Remove permission coherence steps and add tracker for
 #231

---
 index.html | 16 +---------------
 1 file changed, 1 insertion(+), 15 deletions(-)

diff --git a/index.html b/index.html
index 29a692d..29c42cf 100644
--- a/index.html
+++ b/index.html
@@ -603,21 +603,7 @@ <h3>
             </tr>
           </tbody>
         </table>
-        <p>
-          To maintain coherence, user agents MUST run the following steps when
-          the [=permission state=] of either <a>"geolocation"</a> or
-          <a>"geolocation-approximate"</a> changes:
-        </p>
-        <ol class="algorithm">
-          <li>If the [=permission state=] of <a>"geolocation"</a> is changed to
-          [=permission/"granted"=], set the [=permission state=] of
-          <a>"geolocation-approximate"</a> to [=permission/"granted"=].
-          </li>
-          <li>If the [=permission state=] of <a>"geolocation-approximate"</a>
-          is changed to [=permission/"denied"=], set the [=permission state=]
-          of <a>"geolocation"</a> to [=permission/"denied"=].
-          </li>
-        </ol>
+        <aside class="issue" data-number="231"></aside>
         <p title="Querying 'geolocation-approximate'">
           When [=query a permission|querying a permission=] via the
           [[[Permissions]]] API, a user agent MAY mask the returned states of