diff --git a/EXPLAINER.md b/EXPLAINER.md
index 764f67b..1f259b7 100644
--- a/EXPLAINER.md
+++ b/EXPLAINER.md
@@ -6,7 +6,7 @@ Authors:
 - Francois Beaufort
 
 Participate
-- https://github.com/w3c/web-nfc/issues/ 
+- https://github.com/w3c/web-nfc/issues/
 - https://lists.w3.org/Archives/Public/public-web-nfc/
 
 ## Introduction
@@ -92,15 +92,13 @@ when required, about granting access to Web NFC. It means sending and receiving
 info when users tap NFC devices can be done smoothly once permission is granted.
 
 ```js
-const reader = new NDEFReader();
- 
 async function startScanning() {
-  await reader.scan();
-  reader.onreading = event => {
+  await navigator.nfc.ndef.scan();
+  navigator.nfc.ndef.onreading = event => {
     /* handle NDEF messages */
   };
 }
- 
+
 const nfcPermissionStatus = await navigator.permissions.query({ name: "nfc" });
 if (permissionStatus.state === "granted") {
   // NFC access was previously granted, so we can start NFC scanning now.
@@ -123,13 +121,11 @@ USB](https://wicg.github.io/webusb/) in that it offers secure low level access
 with no magic and instead exposes data as a DataView as well as requires text to
 be encoded and decoded using TextEncoder/TextDecoder, which allows handling
 cases where the text might even be in UTF-16 do to existing real life
-implementations. 
+implementations.
 
 ```js
-const reader = new NDEFReader();
-
-await reader.scan({ recordType: "example.com:smart-poster" });
-reader.onreading = event => {
+await navigator.nfc.ndef.scan();
+navigator.nfc.ndef.onreading = event => {
   const externalRecord = event.message.records.find(
     record => record.type == "example.com:smart-poster"
   );
@@ -162,13 +158,11 @@ const abortController = new AbortController();
 abortController.signal.onabort = event => {
   // All NFC operations have been aborted.
 };
- 
-const reader = new NDEFReader();
-await reader.scan({ signal: abortController.signal });
- 
-const writer = new NDEFWriter();
-await writer.push("foo", { signal: abortController.signal });
- 
+
+navigator.nfc.ndef.scan({ signal: abortController.signal });
+
+navigator.nfc.ndef.write("foo", { signal: abortController.signal });
+
 document.querySelector("#abortButton").onclick = event => {
   abortController.abort();
 };
@@ -223,18 +217,20 @@ object/namespace, like Web Bluetooth, Web USB, etc. Unlike these APIs, the newer
 Generic Sensor APIs don’t attach themselves to the navigator object/namespace
 and have separate and dedicated objects like Accelerometer, Gyroscope, etc.
 
-We decided to follow this newer pattern as it allows node.js to implement the
+The newer pattern allows node.js to implement the
 same API, and have it loaded as a separate module. People working on Web
 Assembly are also advocating for this patterns as it might be able to turn such
 globals into modules in the future, at least when accessed from WASM.
 
+However, since Web NFC is close to Web Bluetooth and Web USB, and because scan
+filters were abandoned after Origin Trials feedback, attaching to the navigator
+object seemed to be a proper alignment.
+
 ### Separate objects for reader/writer
 
-The reader and writer objects could have been merged into one single object, but
-as we allow multiple scans with filters to be active at the same time (maybe in
-multiple places/view of the app/site) then it makes more sense to be able to use
-separate objects.
- 
+The reader and writer objects existed separately when scan filters were supported,
+but after filters have been abandoned, they have been merged into one single object.
+
 ## Considered alternatives
 
 ### Restrict to NDEF and name accordingly
diff --git a/index.html b/index.html
index dbcf36b..1ad6db8 100644
--- a/index.html
+++ b/index.html
@@ -9,8 +9,9 @@
   'remove'></script>
   <script class="remove">
     var respecConfig = {
-      specStatus: "CG-DRAFT",
       shortName: "web-nfc",
+      group: "cg/web-nfc",
+      specStatus: "CG-DRAFT",
       editors: [
         {
           name: "Kenneth Rohde Christiansen",
@@ -54,8 +55,6 @@
         }
       ],
       testSuiteURI: "https://wpt.fyi/web-nfc/",
-      wg: "Web NFC Community Group",
-      wgURI: "https://www.w3.org/community/web-nfc/",
       github: "w3c/web-nfc",
       xref: "web-platform",
       localBiblio: {
@@ -980,13 +979,14 @@ <h4>
 
   <section><h3>Feature support</h3>
     <p>
-      Detecting if Web NFC is supported can be done by checking NDEFReader
-      and/or NDEFWriter objects. Note that this does not guarantee that NFC
-      hardware is available.
+      Detecting if Web NFC is supported can be done by checking the {{Navigator}}
+      object. Note that this does not guarantee that NFC hardware is available.
+      The example checks if {{NDEFReader}} is available.
     </p>
     <pre class="example">
-      if ('NDEFReader' in window) { /* ... Scan NDEF Tags */ }
-      if ('NDEFWriter' in window) { /* ... Write NDEF Tags */ }
+      if (navigator.nfc?.ndef) {
+        /* ... Scan and write NDEF Tags */
+      }
     </pre>
   </section>
 
@@ -1001,33 +1001,20 @@ <h4>
       means that polling needs to be initialized first.
     </p>
     <p>
-      If polling is not initiated already by first calling `scan()`,
-      then the `write()` method will initiate it temporarily until a
-      tag was found and read, and writing to it was attempted.
-    </p>
-    <p>
-      This means that the flow is that first a read it performed
-      as the tag is first found, then followed by a write.
-    </p>
-    <p>
-      This means that if `scan()` is running and you have an event
-      listener for the `reading` event, it will be dispatched once
-      during a `write()` operation, which might not be the intended
-      behavior.
-    </p>
-    <p>
-      In the following sections we will discuss how you can easily
-      deal with this behavior, but first a few simple examples.
+      If polling is not initiated already by first calling `navigator.nfc.start()`,
+      then the `navigator.nfc.ndef.write()` and `navigator.nfc.ndef.read()` 
+      methods will initiate it temporarily until a tag was found and the 
+      operation was attempted.
     </p>
   </section>
 
   <section><h3>Write a text string</h3>
     <p>
       Writing a text string to an NFC tag is straightforward.
+      NFC polling is started by `write()` and stopped after writing.
     </p>
     <pre class="example">
-      const writer = new NDEFWriter();
-      writer.write(
+      navigator.nfc.ndef.write(
         "Hello World"
       ).then(() => {
         console.log("Message written.");
@@ -1043,9 +1030,8 @@ <h4>
       we rely on async/await.
     </p>
     <pre class="example">
-      const ndef = new NDEFReader();
       try {
-        ndef.write({
+        navigator.nfc.ndef.write({
           records: [{ recordType: "url", data: "https://w3c.github.io/web-nfc/" }]
         });
       } catch {
@@ -1060,41 +1046,20 @@ <h4>
       you the ability to check whether it is actually a tag that you want to
       write to or not, by checking existing data or serial number.
     </p>
-    <p>
-      For this reason, it is recommended calling `write()` from a `reading`
-      event.
-    </p>
-      The below example shows how to coordinate between a common `reading`
-      handler and one used specifically for a single write.
-    </p>
     <pre class="example">
-      const reader = new NDEFReader();
-      let ignoreRead = false;
-
-      reader.onreading(event => {
-        if (ignoreRead) {
-          return; // write pending, ignore read.
+      await navigator.nfc.start();
+      navigator.nfc.ontagfound(event => {
+        if (event.serialNumber !== myDesiredSerial) {
+          console.log("We found a tag, but not the one we want!");
+          return;
+        }
+        try {
+          await navigator.nfc.ndef.write(data);
+          // read back the data;
+          let readData = await navigator.nfc.ndef.read();
+        } catch (err) {
+          console.error("Something went wrong", err);
         }
-
-        console.log("We read a tag, but not during pending write!");
-      }
-
-      function write(data) {
-        ignoreRead = true;
-        return new Promise((resolve, reject) => {
-          reader.addEventListener("reading", event => {
-            // Check if we want to write to this tag, or reject.
-            reader.write(data).then(resolve, reject).finally(() => ignoreRead = false);
-          }, { once: true });
-        });
-      }
-
-      await reader.scan();
-      try {
-        await write("Hello World");
-        console.log("We wrote to a tag!")
-      } catch(err) {
-        console.error("Something went wrong", err);
       }
     </pre>
   </section>
@@ -1106,9 +1071,6 @@ <h4>
       a certain amount of time, then you time out.
     </p>
     <pre class="example">
-      const reader = new NDEFReader();
-      reader.onreading(event => console.log("We read a tag!"));
-
       function write(data, { timeout } = {}) {
         return new Promise((resolve, reject) => {
           const ctlr = new AbortController();
@@ -1117,13 +1079,13 @@ <h4>
             setTimeout(() => ctlr.abort(), timeout);
           }
 
-          reader.addEventListener("reading", event => {
-            reader.write(data, { signal: ctlr.signal }).then(resolve, reject);
+          navigator.nfc.addEventListener("tagfound", event => {
+            navigator.nfc.ndef.write(data, { signal: ctlr.signal })
+              .then(resolve, reject);
           }, { once: true });
         });
       }
 
-      await reader.scan();
       try {
         // Let's wait for 5 seconds only.
         write("Hello World", { timeout: 5_000 });}
@@ -1137,21 +1099,20 @@ <h4>
 
   <section> <h3>Handle scanning errors</h3>
     <p>
-      This example shows what happens when {{NDEFReader/scan}} promise rejects and
-      {{NDEFReader/onerror}} is fired.
+      This example shows what happens when `navigator.nfc.onerror` is fired.
     </p>
     <pre class="example">
-      const reader = new NDEFReader();
-      reader.scan().then(() => {
-        console.log("Scan started successfully.");
-        reader.onerror = event => {
-          console.log("Error! Cannot read data from the NFC tag. Try a different one?");
+      navigator.nfc.start().then(() => {
+        console.log("NFC polling started successfully.");
+        navigator.nfc.onerror = event => {
+          console.log("Error! NFC tag found, but is not supported " +
+            "or cannot be read. Try a different one?");
         };
-        reader.onreading = event => {
-          console.log("NDEF message read.");
+        navigator.nfc.ontagfound = event => {
+          console.log("NFC tag found" + event.serialNumber);
         };
       }).catch(error => {
-        console.log(`Error! Scan failed to start: ${error}.`);
+        console.log(`Error! NFC polling failed to start: ${error}.`);
       });
     </pre>
   </section>
@@ -1163,27 +1124,34 @@ <h4>
       battery life by cutting unneeded work.
     </p>
     <p>
-      The example could easily be extended to time out after a given
-      amount of milliseconds.
+      First it is done the simplest way, using the temporary NFC polling
+      built into the `read()` function,
+      then by manually aborting NFC polling after reading.
     </p>
     <pre class="example">
-      const reader = new NDEFReader();
-
-      function read() {
+      navigator.nfc.ontagfound = event => {
+        console.log("Read the NFC tag " + serialNumber);
+      };
+      const message = await navigator.nfc.ndef.read();
+    </pre>
+    <pre class="example">
+      async function readOnce() {
         return new Promise((resolve, reject) => {
           const ctlr = new AbortController();
           ctlr.signal.onabort = reject;
-          reader.addEventListener("reading", event => {
-            ctlr.abort();
-            resolve(event);
+          await navigator.nfc.start({ signal: ctlr.signal });
+          navigator.nfc.addEventListener("tagfound", event => {
+            event.data = await navigator.nfc.ndef.read();
+              .then(resolve(event))
+              .catch(err => reject(err));
+          ctlr.abort();
           }, { once: true });
-          reader.scan({ signal: ctlr.signal }).catch(err => reject(err));
         });
       }
 
-      read().then(({ serialNumber }) => {
-        console.log(serialNumber);
-      })
+      readOnce().then(({ serialNumber }) => {
+        console.log("Read the NFC tag " + serialNumber);
+      });
     </pre>
   </section>
 
@@ -1194,15 +1162,13 @@ <h4>
       a text message is written with the value "Hello World".
     </p>
     <pre class="example">
-      const reader = new NDEFReader();
-      await reader.scan();
-      reader.onreading = event => {
-        const message = event.message;
+      await navigator.nfc.start();
+      navigator.nfc.ontagfound = event => {
+        const message = await navigator.nfc.ndef.read();
 
         if (message.records.length == 0 ||     // unformatted tag
             message.records[0].recordType == 'empty' ) {  // empty record
-          const writer = new NDEFWriter();
-          writer.write({
+          navigator.nfc.ndef.write({
             records: [{ recordType: "text", data: 'Hello World' }]
           });
           return;
@@ -1246,16 +1212,17 @@ <h4>
   <section> <h3>Save and restore game progress with an NFC tag</h3>
     <p>
       Filtering of relevant data sources can be done by the use of
-      the <a>NDEFScanOptions</a>. Below we use the custom record identifier
-      "`my-game-progress`" as a relative URL so that when we read the data, we
-      immediately update the game progress by issuing a write with a custom NDEF
-      data layout.
+      a custom record identifier, in this case "`my-game-progress`".
+      When we read the data, we immediately update the game progress by issuing
+      a write with a custom NDEF data layout.
     </p>
     <pre class="example">
-      const reader = new NDEFReader();
-      await reader.scan({ id: "my-game-progress" });
-      reader.onreading = async event => {
-        console.log(`Game state: ${ JSON.stringify(event.message.records) }`);
+      await navigator.nfc.start();
+      navigator.nfc.ontagfound = async event => {
+        let message = await navigator.nfc.ndef.read();
+        if (message.id !== "my-game-progress")
+          return;
+        console.log(`Game state: ${ JSON.stringify(message.records) }`);
 
         const encoder = new TextEncoder();
         const newMessage = {
@@ -1270,8 +1237,7 @@ <h4>
             }))
           }]
         };
-        const writer = new NDEFWriter();
-        await writer.write(newMessage);
+        await navigator.nfc.ndef.write(newMessage);
         console.log("Message written");
       };
     </pre>
@@ -1282,13 +1248,11 @@ <h4>
       Storing and receiving JSON data is easy with serialization and deserialization.
     </p>
     <pre class="example">
-      const reader = new NDEFReader();
-      await reader.scan({
-        mediaType: "application/*json"
-      });
-      reader.onreading = event => {
+      await navigator.nfc.start();
+      navigator.nfc.ontagfound = event => {
+        let message = await navigator.nfc.ndef.read();
         const decoder = new TextDecoder();
-        for (const record of event.message.records) {
+        for (const record of message.records) {
           if (record.mediaType === 'application/json') {
             const json = JSON.parse(decoder.decode(record.data));
             const article =/^[aeio]/i.test(json.title) ? "an" : "a";
@@ -1297,9 +1261,8 @@ <h4>
         }
       };
 
-      const writer = new NDEFWriter();
       const encoder = new TextEncoder();
-      writer.write({
+      navigator.nfc.ndef.write({
         records: [
           {
             recordType: "mime",
@@ -1326,54 +1289,51 @@ <h4>
       Writing data requires tapping an <a>NFC tag</a>.
     </p>
     <pre class="example">
-      const ndef = new NDEFReader();
-
-      ndef.onreading = async event => {
+      navigator.nfc.ontagfound = async event => {
+        let message = await navigator.nfc.ndef.read();
         const decoder = new TextDecoder();
-        for (const record of event.message.records) {
+        for (const record of message.records) {
           console.log("Record type:  " + record.recordType);
           console.log("MIME type:    " + record.mediaType);
           console.log("=== data ===\n" + decoder.decode(record.data));
         }
 
         try {
-          await ndef.write("Overriding data is fun!");
+          await navigator.nfc.ndef.write("Overriding data is fun!");
         } catch(error) {
           console.log(`Write failed :-( try again: ${error}.`);
         }
       };
 
-      ndef.scan();
+      navigator.nfc.ndef.start();
     </pre>
   </section>
 
   <section> <h3>Stop listening to NDEF messages</h3>
     <p>
-      Read NDEF messages for 3 seconds by using {{NDEFScanOptions/signal}}.
+      Read NDEF messages with a timeout by using {{NDEFReadOptions/signal}}.
     </p>
     <pre class="example">
-      const reader = new NDEFReader();
       const controller = new AbortController();
+      controller.signal.onabort = event => {
+        console.log("We're done waiting for NDEF messages.");
+      };
 
-      await reader.scan({ signal: controller.signal });
-      reader.onreading = event => {
+      navigator.nfc.ontagfound = event => {
         console.log("NDEF message read.");
       };
 
-      controller.signal.onabort = event => {
-        console.log("We're done waiting for NDEF messages.");
-      };
+      // Wait 10 seconds for a tag, then abort.
+      setTimeout(() => controller.abort(), 10_000);
 
-      // Stop listening to NDEF messages after 3s.
-      setTimeout(() => controller.abort(), 3_000);
+      await navigator.nfc.ndef.read({ signal: controller.signal });
     </pre>
   </section>
 
   <section> <h3>Write a smart poster message</h3>
     <pre class="example">
-      const writer = new NDEFWriter();
       const encoder = new TextEncoder();
-      writer.write({ records: [
+      navigator.nfc.ndef.write({ records: [
         {
           recordType: "smart-poster",  // Sp
           data: { records: [
@@ -1437,10 +1397,10 @@ <h4>
       borrowed from <a>smart poster</a>, but used in local application context.
     </p>
     <pre class="example">
-      const reader = new NDEFReader();
-      await reader.scan({ recordType: "example.com:smart-poster" });
-      reader.onreading = event => {
-        const externalRecord = event.message.records.find(
+      await navigator.nfc.start();
+      navigator.nfc.ontagfound = event => {
+        const message = await navigator.nfc.ndef.read();
+        const externalRecord = message.records.find(
           record => record.type == "example.com:smart-poster"
         );
 
@@ -1476,8 +1436,7 @@ <h4>
       that may even contain an <a>NDEF message</a> as payload.
     </p>
     <pre class="example">
-      const writer = new NDEFWriter();
-      writer.write({ records: [
+      navigator.nfc.ndef.write({ records: [
         {
           recordType: "example.game:a",
           data: {
@@ -1510,8 +1469,7 @@ <h4>
     </p>
     <pre class="example">
       const encoder = new TextEncoder();
-      const writer = new NDEFWriter();
-      writer.write({ records: [
+      navigator.nfc.ndef.write({ records: [
         {
           recordType: "example.com:shoppingItem", // External record
           data: {
@@ -1530,11 +1488,12 @@ <h4>
       ]});
     </pre>
     <pre class="example">
-      const reader = new NDEFReader();
-      await reader.scan({ recordType: "example.com:shoppingItem" });
-      reader.onreading = event => {
-        const shoppingItemRecord = event.message.records[0];
-        if (!shoppingItemRecord) {
+      await navigator.nfc.start();
+      navigator.nfc.ontagfound = event => {
+        const message = await navigator.nfc.ndef.read();
+        const shoppingItemRecord = message.records[0];
+        if (!shoppingItemRecord ||
+            shoppingItemRecord.recordType !== "example.com:shoppingItem") {
           return;
         }
 
@@ -1682,7 +1641,7 @@ <h4>
       The mapping from data types of an
       <a>NDEFRecordInit</a> to <a>NDEF record</a> types is presented
       in the algorithmic steps which handle the data and described in the
-      [[[#steps-receiving]]] and [[[#writing-content]]] sections.
+      [[[#steps-parse]]] and [[[#steps-write]]] sections.
     </p>
     <p>
       To <dfn>convert NDEFRecord.data bytes</dfn>
@@ -1802,7 +1761,7 @@ <h2>The <dfn>record type</dfn> string</h2>
   <section id="data-mapping"><h3>Data mapping</h3>
   <p>
     The mapping from data types of an <a>NDEFRecordInit</a> to
-    <a>NDEF record</a> types, as used in the [[[#writing-content]]]
+    <a>NDEF record</a> types, as used in the [[[#steps-write]]]
     section is as follows:
   </p>
   <table class="simple" data-link-for="NDEFRecordInit">
@@ -1902,7 +1861,7 @@ <h2>The <dfn>record type</dfn> string</h2>
   <p>
     The mapping from <a>NDEF record</a> types to <a>NDEFRecord</a>,
     as used for incoming <a>NDEF message</a>s described in the
-    [[[#steps-receiving]]] section, is as follows.
+    [[[#steps-parse]]] section, is as follows.
   </p>
   <table class="simple" data-link-for="NDEFRecord">
     <tr>
@@ -1979,59 +1938,62 @@ <h2>The <dfn>record type</dfn> string</h2>
   </section>
 </section> <!-- Data types and content -->
 
-
-<section> <h2>The NDEFReader and NDEFWriter objects</h2>
-  The objects provide a way for the <a>browsing context</a> to
-  use NFC functionality.
-  They allow for writing <a>NDEF message</a>s to <a>NFC tag</a>s within range,
-  and to act on incoming <a>NDEF message</a>s from <a>NFC tag</a>s.
+<section> <h2>Extensions to the Navigator interface</h2>
   <pre class="idl">
-    typedef (DOMString or BufferSource or NDEFMessageInit) NDEFMessageSource;
-
-    [SecureContext, Exposed=Window]
-    interface NDEFWriter {
-      constructor();
-
-      Promise&lt;undefined&gt; write(NDEFMessageSource message, optional NDEFWriteOptions options={});
+    [SecureContext]
+    partial interface Navigator {
+      [SameObject]
+      readonly attribute NFC nfc;
     };
+  </pre>
+</section>
 
+<section data-dfn-for="NFC">
+<h2>The NFC object</h2>
+  <pre class="idl">
     [SecureContext, Exposed=Window]
-    interface NDEFReader : EventTarget {
-      constructor();
-
+    interface NFC {
+      readonly attribute NDEFReader ndef;
+      attribute EventHandler ontagfound;
       attribute EventHandler onerror;
-      attribute EventHandler onreading;
-
-      Promise&lt;undefined&gt; scan(optional NDEFScanOptions options={});
+      Promise&lt;undefined&gt; start(optional NFCOptions options={});
     };
 
     [SecureContext, Exposed=Window]
-    interface NDEFReadingEvent : Event {
-      constructor(DOMString type, NDEFReadingEventInit readingEventInitDict);
-
+    interface NFCTagFoundEvent : Event {
+      constructor(DOMString type, NFCTagFoundEventInit tagfoundEventInitDict);
       readonly attribute DOMString serialNumber;
-      [SameObject] readonly attribute NDEFMessage message;
     };
 
-    dictionary NDEFReadingEventInit : EventInit {
+    dictionary NFCTagFoundEventInit : EventInit {
       DOMString? serialNumber = "";
-      required NDEFMessageInit message;
     };
   </pre>
+  <p>The
+    <dfn>ndef</dfn> property is an {{NDEFReader}} object that provides
+    <a>NFC tag</a> read and write functionality.
+  </p>
   <p>
-    The <dfn>NDEFMessageSource</dfn> is a union type representing argument types
-    accepted by the {{NDEFWriter/write()}} method.
+    The <dfn data-dfn-for="NFC">ontagfound</dfn> is an {{EventHandler}}
+    which is called to notify that an NFC tag has been detected.
+  </p>
+  <p>
+    The <dfn data-dfn-for="NFC">onerror</dfn> is an {{EventHandler}}
+    which is called to notify that an error happened during <a>NFC tag</a>
+    operations.
+  </p>
+  <p data-dfn-for="NFCTagFoundEvent">
+    The <dfn>NFCTagFoundEvent</dfn> is the event being dispatched when an
+    <a>NFC tag</a> appears in NFC proximity range.
   </p>
-  <p data-dfn-for="NDEFReadingEvent">
-    The <dfn>NDEFReadingEvent</dfn> is the event being dispatched on new NFC readings.
-    The <dfn>serialNumber</dfn> property represents the serial number of
-    the device used for anti-collision and identification, or empty string in case none
-    is available. The <dfn>message</dfn> is an <a>NDEFMessage</a> object.
+  <p data-dfn-for="NFCTagFoundEvent">
+    The <dfn>serialNumber</dfn> property represents the 
+    serial number of the device used for anti-collision and identification, 
+    or empty string in case none is available.
   </p>
-  <p data-dfn-for="NDEFReadingEventInit">
-    <dfn>NDEFReadingEventInit</dfn> is used to initialize a new event with a serial number
-    and the <a>NDEFMessageInit</a> data via the <dfn>message</dfn> member.
-    If <dfn>serialNumber</dfn> is not present or is `null`,
+  <p data-dfn-for="NFCTagFoundEvent">
+    <dfn>NFCTagFoundEventInit</dfn> is used to initialize a new event with a
+    serial number. If {{NFCTagFoundEvent/serialNumber}} is not present or is `null`,
     empty string will be used to init the event.
   </p>
   <p class="note">
@@ -2039,49 +2001,13 @@ <h2>The <dfn>record type</dfn> string</h2>
     have one and some tags even create a random number on each read.
     The serial number usually consists of 4 or 7 numbers, separated by `:`.
   </p>
-  <p>
-    The <dfn>NDEFWriter</dfn> is an object used for writing data to an <a>NFC tag</a>.
-  </p>
-  <p>
-    An {{NDEFWriter}} object has the following <a data-cite=
-    "ECMASCRIPT#sec-object-internal-methods-and-internal-slots">
-    internal slots</a>:
-  </p>
-  <table class="simple">
-    <thead>
-     <tr>
-      <th>Internal Slot</th>
-      <th>Initial value</th>
-      <th>Description (<em>non-normative</em>)</th>
-     </tr>
-    </thead>
-    <tbody data-link-for="NDEFWriter">
-     <tr>
-      <td><dfn>[[\WriteOptions]]</dfn></td>
-      <td>`null`</td>
-      <td>
-        The {{NDEFWriteOptions}} value for writer.
-      </td>
-     </tr>
-     <tr>
-      <td><dfn>[[\WriteMessage]]</dfn></td>
-      <td>`null`</td>
-      <td>
-        The {{NDEFMessage}} to be written.
-        It is initially unset.
-      </td>
-     </tr>
-    </tbody>
-  </table>
 
+  <section><h3>NFC state</h3>
   <p>
-    The <dfn>NDEFReader</dfn> is an object used for reading data when a device,
-    such as a tag, is within the magnetic induction field.
-  </p>
-  <p>
-    An {{NDEFReader}} object has the following <a data-cite=
-    "ECMASCRIPT#sec-object-internal-methods-and-internal-slots">
-    internal slots</a>:
+    The <a>NFC</a> object has an associated
+    <dfn>NFC state</dfn> record with the following <a data-cite=
+    "ECMASCRIPT#sec-object-internal-methods-and-internal-slots">internal
+    slots</a>:
   </p>
   <table class="simple">
     <thead>
@@ -2091,121 +2017,52 @@ <h2>The <dfn>record type</dfn> string</h2>
       <th>Description (<em>non-normative</em>)</th>
      </tr>
     </thead>
-    <tbody data-link-for="NDEFScanOptions">
-     <tr>
-      <td><dfn>[[\Id]]</dfn></td>
-      <td>`undefined`</td>
-      <td>
-        The {{NDEFScanOptions}}.<a>id</a> value.
-      </td>
-     </tr>
-     <tr>
-      <td><dfn>[[\RecordType]]</dfn></td>
-      <td>`undefined`</td>
-      <td>
-        The {{NDEFScanOptions}}.<a>recordType</a> value.
-      </td>
-     </tr>
-     <tr>
-      <td><dfn>[[\MediaType]]</dfn></td>
-      <td>`undefined`</td>
-      <td>
-        The {{NDEFScanOptions}}.<a>mediaType</a> value.
-      </td>
+    <tbody>
+      <tr>
+        <td><dfn>[[\Suspended]]</dfn></td>
+        <td>`false`</td>
+        <td>
+          A boolean flag indicating whether NFC functionality is
+          <a href="#nfc-suspended">suspended</a> or not, initially
+          `false`.
+        </td>
       </tr>
       <tr>
-        <td><dfn>[[\Signal]]</dfn></td>
-        <td>`undefined`</td>
+        <td><dfn>[[\PollingActive]]</dfn></td>
+        <td>`false`</td>
         <td>
-          The {{NDEFScanOptions}}.<a>signal</a> to abort the operation.
+          Set to `true` when NFC polling is active, to `false` otherwise when
+          it is not active and to `undefined` when {{NFC/start()}} has been invoked
+          but its {{Promise}} is not yet settled.
         </td>
       </tr>
     </tbody>
   </table>
-
   <p class="note">
-    Note that the internal slots of {{NDEFReader}} come from the
-    |options:NDEFScanOptions| passed to <a>NDEFReader.scan()</a>.
-    Therefore there is maximum one filter associated with any given
-    {{NDEFReader}} object and successive invocations of <a>NDEFReader.scan()</a>
-    with new |options:NDEFScanOptions| will replace existing filters.
+    Internal slots are used only as a notation in this specification, and
+    implementations do not necessarily have to map them to explicit internal
+    properties.
   </p>
   <p>
-    The <dfn data-dfn-for="NDEFReader">onreading</dfn> is an {{EventHandler}}
-    which is called to notify that new reading is available.
+    <dfn id="nfc-is-active">NFC polling is active</dfn> if the
+    <a>[[\PollingActive]]</a> internal slot is not `false`.
   </p>
   <p>
-    The <dfn data-dfn-for="NDEFReader">onerror</dfn> is an {{EventHandler}}
-    which is called to notify that an error happened during reading.
-  </p>
-  <section><h3>NFC state associated with the settings object</h3>
-  <p>
-    The <a>relevant settings object</a> of the <a>active document</a> of a
-    <a>browsing context</a> which supports NFC has an associated
-    <dfn>NFC state</dfn> record with the following <a data-cite=
-    "ECMASCRIPT#sec-object-internal-methods-and-internal-slots">internal
-    slots</a>:
-  </p>
-  <table class="simple">
-    <thead>
-     <tr>
-      <th>Internal Slot</th>
-      <th>Initial value</th>
-      <th>Description (<em>non-normative</em>)</th>
-     </tr>
-    </thead>
-    <tbody>
-     <tr>
-      <td><dfn>[[\Suspended]]</dfn></td>
-      <td>`false`</td>
-      <td>
-        A boolean flag indicating whether NFC functionality is
-        <a href="#nfc-suspended">suspended</a> or not, initially
-        `false`.
-      </td>
-     </tr>
-     <tr>
-      <td><dfn>[[\ActivatedReaderList]]</dfn></td>
-      <td>empty <a>set</a></td>
-      <td>
-        A <a>set</a> of {{NDEFReader}} instances.
-      </td>
-     </tr>
-     <tr>
-      <td><dfn>[[\PendingWrite]]</dfn></td>
-      <td>empty</td>
-      <td>
-        A &lt;|promise:Promise|, |writer:NDEFWriter|&gt; tuple where |promise|
-        holds a pending {{Promise}} and |writer| holds an {{NDEFWriter}}.
-      </td>
-      </tr>
-    </tbody>
-  </table>
-  <p>
-    The <dfn>activated reader objects</dfn> is the value of the
-    <a>[[\ActivatedReaderList]]</a> internal slot.
-  </p>
-  <p>
-    The <dfn>pending write tuple</dfn> is the value of the
-    <a>[[\PendingWrite]]</a> internal slot.
+    <dfn id="nfc-is-active">NFC polling is inactive</dfn> if the
+    <a>[[\PollingActive]]</a> internal slot is `false`.
   </p>
   <p>
     <dfn id="nfc-is-suspended">NFC is suspended</dfn> if the
     <a>[[\Suspended]]</a> internal slot is `true`.
   </p>
   <p>
-    To <dfn id="suspend-nfc">suspend NFC</dfn>, set the <a>[[\Suspended]]</a>
+    To <dfn id="suspend-nfc">suspend NFC</dfn>,set the <a>[[\Suspended]]</a>
     internal slot to `true`.
   </p>
   <p>
     To <dfn id="resume-nfc">resume NFC</dfn>, set the <a>[[\Suspended]]</a>
     internal slot to `false`.
   </p>
-  <p class="note">
-    Internal slots are used only as a notation in this specification, and
-    implementations do not necessarily have to map them to explicit internal
-    properties.
-  </p>
   </section>
 
   <section> <h3>Handling NFC adapters</h3>
@@ -2275,70 +2132,241 @@ <h2>The <dfn>record type</dfn> string</h2>
         <a>resume NFC</a> and abort these steps.
       </li>
       <li>
-        Otherwise, <a>suspend NFC</a> and attempt to <a>abort a pending
-        write operation</a>.
+        Otherwise, <a>suspend NFC</a>.
       </li>
     </ol>
     <p>
       The term <dfn id="nfc-suspended">suspended</dfn> refers to NFC
       operations being suspended, which means that no <a>NFC content</a> is
-      written by <a>NDEFWriter</a>s, and no received <a>NFC content</a> is
-      presented to any {{NDEFReader}} while being suspended.
+      written, and no received <a>NFC content</a> is
+      presented to applications while being suspended.
     </p>
   </section>
 
-  <section><h3>Aborting pending write operation</h3>
-  <div>
-    To attempt to <dfn>abort a pending write operation</dfn> on an
-    <a>environment settings object</a>, perform the following steps:
-    <ol class=algorithm>
+  <section> <h3>The <strong>start()</strong> method</h3>
+    <p>
+      Requests starting NFC polling, unless already active and unless it has
+      been requested, but not completed yet.
+    </p>
+
+    <section data-dfn-for="NFCOptions">
+      <h3>The <dfn>NFCOptions</dfn> dictionary</h3>
+        <p>
+          To stop polling for <a>NFC tags</a>, an [= AbortSignal/aborted flag =]
+          can be used in the <a>NFCOptions</a> dictionary:
+        </p>
+        <pre class="idl">
+          dictionary NFCOptions {
+            AbortSignal signal;
+          };
+        </pre>
+        <p>
+          The <dfn>signal</dfn> property allows to abort the {{NFC/start()}}
+          operation.
+        </p>
+    </section>
+    
+    <section data-dfn-for="NFC"> <h3>NFC polling</h3>
+      When the {{NFC.start()}}</dfn> method is invoked, run the
+      <dfn>start NFC polling</dfn> steps:
+      <ol class=algorithm>
+        <li>
+          Let |p:Promise| be a new {{Promise}} object.
+          Return |p| and run the next steps <a>in parallel</a>.
+        </li>
+        <li>
+          If <a>NFC polling is active</a>, attempt to <a>abort NFC polling</a>.
+        </li>
+        <li>
+          Set <a>[[\PollingActive]]</a> to `undefined`.
+        </li>
+        <li>
+          Let |options| be first argument.
+        </li>
+        <li>
+          Let |signal:AbortSignal| be the |options|’ dictionary member
+          of the same name if present, or `null` otherwise.
+        </li>
+        <li>
+          If |signal|’s [= AbortSignal/aborted flag =] is set, then reject |p|
+          with an {{"AbortError"}} {{DOMException}} and return |p|.
+        </li>
+        <li>
+          If |signal| is not `null`, then
+          <a data-cite="dom#abortsignal-abort-algorithms">add the following
+          abort steps</a> to |signal|:
+          <ol>
+            <li>
+              Attempt to <a>abort NFC polling</a>.
+            </li>
+          </ol>
+        </li>
+        <li>
+          If the <a>obtain permission</a> steps return `false`, then
+          reject |p| with a {{"NotAllowedError"}} {{DOMException}} and
+          abort these steps.
+        </li>
+        <li>
+          Request starting polling <a>NFC</a> on all available <a>NFC Adapters</a>.
+        </li>
+        <li>
+          If no connection can be established with any <a>NFC Adapter</a>s,
+          reject |p| with a {{"NotSupportedError"}} {{DOMException}}
+          and abort these steps.
+        </li>
+        <li>
+          If the UA is not allowed to access any underlying <a>NFC Adapter</a>
+          (e.g. a user preference), then reject |p| with a
+          {{"NotReadableError"}} {{DOMException}}
+          and abort these steps.
+        </li>
+        <li>
+          If the request fails on all <a>NFC Adapters</a>, then
+          reject |p| with an {{NotFoundError}} {{DOMException}} and abort these steps.
+        </li>
+        <li>
+          Save the list of <a>NFC Adapters</a> that are polling for this
+          <a>browsing context</a> as <dfn>active adapter list</dfn>, to be referred
+          in the <a>abort NFC polling</a> steps.
+        </li>
+        <li>
+          Set [[\PollingActive]]</a> to `true`.
+        </li>
+        <li>
+          Resolve |p|.
+        </li>
+        <li>
+          Whenever the <a>UA</a> detects NFC technology, run the
+          <a>NFC detection algorithm</a>.
+        </li>
+      </ol>
+    </section>
+
+    <section><h3>The NFC detection algorithm</h3>
+      To run the <dfn>NFC detection algorithm</dfn>:
+      <ol class=algorithm id="parse-ndef">
+        <li>
+          If <a>NFC is suspended</a>, abort these steps.
+        </li>
+        <li>
+          Let |serialNumber:serialNumber| be the device identifier as a series of
+          numbers, or `null` if unavailable.
+        </li>
+        <li>
+          If |serialNumber| is not `null`, set it to the
+          <a>string</a> of U+003A (`:`) concatenating each number represented as
+          <a>ASCII hex digit</a>, in the same order.
+        </li>
+        <li>
+          <a>Fire an event</a> named "`tagfound`" at |navigator.nfc| using
+          <a>NFCTagFoundEvent</a> with its {{NFCTagFoundEvent/serialNumber}}
+          attribute initialized to |serialNumber|.
+        </li>
+        <li>
+          If |navigator.nfc.ndef|.<a>[[\PendingRead]]</a> is not `null`,
+          notify the {{NDEFReader.read}} algorithm to <dfn>resume reading</dfn>.
+        </li>
+        <li>
+          If |navigator.nfc.ndef|.<a>[[\PendingWrite]]</a> is not `null`,
+          notify the {{NDEFReader.write}} algorithm to <dfn>resume writing</dfn>.
+        </li>
+      </ol>
+    </section>
+
+    <section><h3>Aborting NFC polling</h3>
+      To attempt to <dfn>abort NFC polling</dfn>, run the following steps:
+      <ol class=algorithm>
+        <li>
+          Make a request to stop polling for <a>NFC tag</a>s on all
+          <a>NFC adapter</a>s in the <a>active adapter list</a>
+        </li>
+        <li>
+          Set <a>[[\PollingActive]]</a> to `false`.
+        </li>
+      </ol>
+    </section>
+  </section>
+
+  <section><h3>Releasing NFC</h3>
+    <p>
+      To <dfn>release NFC</dfn> on an <a>environment settings object</a>,
+      perform the following steps:
+    </p>
+    <ol id="steps-nfc-release">
       <li>
-        If there is no <a>pending write tuple</a> |tuple|, abort these steps.
+        Attempt to <a>abort NFC polling</a>.
       </li>
       <li>
-        If |tuple|'s writer has already initiated an ongoing NFC data transfer,
-        abort these steps.
+        Attempt to <a>abort pending NDEF operations</a>.
       </li>
       <li>
-        Reject |tuple|'s promise with an {{"AbortError"}} {{DOMException}}
-        and abort these steps.
-        <p class=note>
-          Rejecting the promise will clear the <a>pending write tuple</a>.
-        </p>
+        Release the NFC resources associated with the <a>browsing context</a>.
+      </li>
+      <li>
+        Clear all internal slots on |navigator.nfc| and |navigator.nfc.ndef|.
       </li>
     </ol>
-  </div>
+    <p>
+      The UA must <a>release NFC</a> given the document's
+      <a>relevant settings object</a> as additional
+      <a>unloading document cleanup steps</a>.
+    </p>
+    </section>
   </section>
 
-  <section><h3>Releasing NFC</h3>
+<section> <h2>The NDEFReader object</h2>
   <p>
-    To <dfn>release NFC</dfn> on an <a>environment settings object</a>,
-    perform the following steps:
+    The <dfn>NDEFReader</dfn> is an object attached to |navigator.nfc| that
+    exposes NFC functionality to the
+    <a>browsing context</a>: reading <a>NDEF messages</a> when a device, such
+    as a tag, is within the magnetic induction field. Also, it is used for
+    writing <a>NDEF messages</a> to <a>NFC tag</a>s within range.
   </p>
-  <ol id="steps-nfc-release">
-    <li>
-      <a>Suspend NFC</a>.
-    </li>
-    <li>
-      Attempt to <a>abort a pending write operation</a>.
-    </li>
-    <li>
-      Stop the <a>dispatch NFC content</a> steps.
-    </li>
-    <li>
-      Clear the <a>activated reader objects</a>.
-    </li>
-    <li>
-      Release the NFC resources associated with |nfc| on the
-      underlying platform.
-    </li>
-  </ol>
+  <pre class="idl">
+    typedef (DOMString or BufferSource or NDEFMessageInit) NDEFMessageSource;
+
+    [SecureContext, Exposed=Window]
+    interface NDEFReader {
+      Promise&lt;NDEFMessage&gt; read(optional NDEFReadOptions options={});
+      Promise&lt;undefined&gt; write(NDEFMessageSource message,
+                                     optional NDEFWriteOptions options={});
+    };
+  </pre>
   <p>
-    The UA must <a>release NFC</a> given the document's
-    <a>relevant settings object</a> as additional
-    <a>unloading document cleanup steps</a>.
+    The <dfn>NDEFMessageSource</dfn> is a union type representing argument types
+    accepted by the {{NDEFReader/write()}} method.
   </p>
-  </section> <!-- release NFC -->
+
+  <p>
+    An {{NDEFReader}} object has the following <a data-cite=
+    "ECMASCRIPT#sec-object-internal-methods-and-internal-slots">
+    internal slots</a>:
+  </p>
+  <table class="simple">
+    <thead>
+     <tr>
+      <th>Internal Slot</th>
+      <th>Initial value</th>
+      <th>Description (<em>non-normative</em>)</th>
+     </tr>
+    </thead>
+    <tbody data-link-for="NDEFReader">
+     <tr>
+       <td><dfn>[[\PendingRead]]</dfn></td>
+       <td>`null`</td>
+       <td>
+         The pending |promise:Promise| of a {{NDEFReader/read()}}.
+       </td>
+     </tr>
+     <tr>
+       <td><dfn>[[\PendingWrite]]</dfn></td>
+       <td>`null`</td>
+       <td>
+         The pending |promise:Promise| of a {{NDEFReader/write()}}.
+       </td>
+     </tr>
+    </tbody>
+  </table>
 
   <section data-dfn-for="NDEFWriteOptions">
     <h3>The <dfn>NDEFWriteOptions</dfn> dictionary</h3>
@@ -2352,91 +2380,140 @@ <h3>The <dfn>NDEFWriteOptions</dfn> dictionary</h3>
       When the value of the <dfn>overwrite</dfn> property is
       `false`, the <a href="#steps-write">write algorithm</a>
       will read the <a>NFC tag</a> to determine if it has
-      <a>NDEF</a> records on it, and if yes, it will not
-      execute any pending write.
+      <a>NDEF</a> records on it, and if yes, it will not write to it.
     </p>
     <p>
       The <dfn>signal</dfn> property allows to abort
-      the {{NDEFWriter/write()}} operation.
+      the {{NDEFReader/write()}} operation.
     </p>
   </section>
 
-  <section data-dfn-for="NDEFScanOptions">
-    <h3>The <dfn>NDEFScanOptions</dfn> dictionary</h3>
+  <section data-dfn-for="NDEFReadOptions">
+    <h3>The <dfn>NDEFReadOptions</dfn> dictionary</h3>
       <p>
-        To describe which messages an application is interested in, the
-        <a>NDEFScanOptions</a> dictionary is used:
+        To stop listening to NDEF messages, an [= AbortSignal/aborted flag =]
+        can be used in the <a>NDEFReadOptions</a> dictionary:
       </p>
       <pre class="idl">
-        dictionary NDEFScanOptions {
-          USVString id;
-          USVString recordType;
-          USVString mediaType;
-          AbortSignal? signal;
+        dictionary NDEFReadOptions {
+          AbortSignal signal;
         };
       </pre>
       <p>
         The <dfn>signal</dfn> property allows to abort the
-      {{NDEFReader/scan()}} operation.
-      </p>
-      <p>
-        The <dfn>id</dfn> property
-        denotes the string value which is used for matching the
-        <a>record identifier</a> of each
-        <a>NDEFRecord</a> object in an <a>NDEF message</a>.
-        If the dictionary member is not present,
-        then it will be ignored by the
-        <a href="#steps-listen">NFC listen algorithm</a>.
-      </p>
-      <p>
-        The <dfn>recordType</dfn> property
-        denotes the string value which is used for matching the
-        <a>record type</a> of each
-        <a>NDEFRecord</a> object in an <a>NDEF message</a>.
-        If the dictionary member is not present,
-        then it will be ignored by the
-        <a href="#steps-listen">NFC listen algorithm</a>.
-      </p>
-      <p>
-        The <dfn>mediaType</dfn> property
-        denotes the <a>match pattern</a> which is used for matching the
-        {{NDEFRecord/mediaType}} property of each
-        <a>NDEFRecord</a> object in an <a>NDEF message</a>.
+      {{NDEFReader/read()}} operation.
       </p>
-      <pre
-        title="Filter accepting only JSON content"
-        class="example highlight">
-        const options = {
-          mediaType: "application/*json"  // any JSON-based MIME type
-        }
-      </pre>
-      <pre
-        title="Filter which only accepts binary content for a custom record identifier"
-        class="example highlight">
-        const options = {
-          id: "my-restaurant-daily-menu",
-          mediaType: "application/octet-stream"
-        }
-      </pre>
-  </section> <!-- NDEFScanOptions -->
+  </section>
 
-  <section id="writing-content">
-    <h3><dfn>Writing content</dfn></h3>
+  <section><h3>Aborting NDEF operations</h3>
+    <div>
+      To attempt to <dfn>abort a pending write</dfn> on |reader|,
+      run the following steps:
+      <ol class=algorithm>
+        <li>
+          If |reader|.<a>[[\PendingWrite]]</a> is `null`, abort
+          these steps.
+        </li>
+        <li>
+          If there is an ongoing NFC write data transfer, request the underlying
+          platform to cancel the write operation. If that is successful,
+          reject |reader|.<a>[[\PendingWrite]]</a> with an
+          {{"AbortError"}} {{DOMException}}.
+        </li>
+        <li>
+          Set |reader|.<a>[[\PendingWrite]]</a> to `null`.
+        </li>
+      </ol>
+    </div>
+    <div>
+      To attempt to <dfn>abort a pending read</dfn> on |reader|,
+      run the following steps:
+      <ol class=algorithm>
+        <li>
+          If |reader|.<a>[[\PendingRead]]</a> is `null`, abort
+          these steps.
+        </li>
+        <li>
+          If there is an ongoing NFC write data transfer, request the underlying
+          platform to cancel the write operation. If that is successful,
+          reject |reader|.<a>[[\PendingRead]]</a> with an
+          {{"AbortError"}} {{DOMException}}.
+        </li>
+        <li>
+          Set |reader|.<a>[[\PendingRead]]</a> to `null`.
+        </li>
+      </ol>
+    </div>
+    <div>
+      To attempt to <dfn>abort pending NDEF operations</dfn>, run the following steps:
+      <ol class=algorithm>
+        <li>Attempt to <a>abort a pending write</a> on |navigator.nfc.ndef|.</li>
+        <li>Attempt to <a>abort a pending read</a> on |navigator.nfc.ndef|.</li>
+      </ol>
+    </div>
+  </section>
+
+  <section id="steps-write"><h3>The <strong>write()</strong> method</h3>
     <p>
       This section describes how to write an <a>NDEF message</a>
-      to an <a>NFC tag</a> when it is next time in proximity range before a
-      timer expires. At any time there is a maximum of one
-      <a>NDEF message</a> that can be set for writing for an <a>origin</a> until
-      the current message is sent or the write is aborted.
+      to an <a>NFC tag</a> when comes into proximity range.
+      At any time there is a maximum of one <a>NDEF message</a> that can be set
+      for writing for an <a>origin</a> until the current message is sent or the
+      write is aborted.
     </p>
-    <section><h3>The <strong>write()</strong> method</h3>
-      <div id="steps-write">
-        The
-        <dfn>NDEFWriter.write</dfn> method, when invoked, MUST run the
-        <dfn>write a message</dfn> algorithm:
+    <div>
+      The <dfn>NDEFReader.write</dfn> method, when invoked, MUST run the
+      following steps:
         <ol class=algorithm>
           <li>
-            Let |p:Promise| be a new {{Promise}} object.
+            Let |p:Promise| be a new {{Promise}} object. Return |p| and
+            execute the next steps <a>in parallel</a>.
+          </li>
+          <li>
+            If <a>NFC is suspended</a>, reject |p| with a {{"NotAllowedError"}}
+            {{DOMException}} and abort these steps.
+          </li>
+          <li>
+            If the <a>obtain permission</a> steps return `false`, then
+            reject |p| with a {{"NotAllowedError"}} {{DOMException}} and
+            abort these steps.
+          </li>
+          <li>
+            If there is no underlying <a>NFC Adapter</a>, or if a connection
+            cannot be established, then reject |p| with a
+            {{"NotSupportedError"}} {{DOMException}}
+            and abort these steps.
+          </li>
+          <li>
+            If the UA is not allowed to access the underlying <a>NFC Adapter</a>
+            (e.g. a user preference), then reject |p| with a
+            {{"NotReadableError"}} {{DOMException}}
+            and abort these steps.
+          </li>
+          <li>
+            Let |startPolling:boolean| be `true` if <a>NFC polling is inactive</a> 
+            and otherwise to `false`.
+            <p class="note">
+              Writing will temporarily <a>start NFC polling</a> if that is not
+              active, until the first writing is done, when the temporary polling is
+              aborted.
+            </p>
+          </li>
+          <li>
+            [=promise/React=] to |p|:
+            If |p| was settled (fulfilled or rejected), then:
+            <ol>
+              <li>
+                Set |navigator.nfc.ndef|.<a>[[\PendingWrite]]</a> to `null`.
+              </li>
+              <li>
+                If |startPolling| is `true`, attempt to <a>abort NFC polling</a>.
+              </li>
+            </ol>
+          </li>
+          <li>
+            If |startPolling| is `true`, <a>start NFC polling</a>.
+            If that fails, reject |p| and abort these steps.
           </li>
           <li>
             Let |message:NDEFMessageSource| be the first argument.
@@ -2458,180 +2535,103 @@ <h3><dfn>Writing content</dfn></h3>
             add the following abort steps</a> to |signal|:
               <ol>
                 <li>
-                  Run the <a>abort a pending write operation</a> on the
-                  <a>environment settings object</a>.
+                  Run the <a>abort a pending write</a> on |navigator.nfc.ndef|.
                 </li>
               </ol>
           </li>
           <li>
-            [=promise/React=] to |p|:
-            <ol>
-              <li>
-                If |p| was settled (fulfilled or rejected), then clear the
-                <a>pending write tuple</a> if it exists.
-              </li>
-            </ol>
+            An implementation MAY reject |p| with
+            a {{"NotSupportedError"}} {{DOMException}}
+            and abort these steps.
+            <p class="note">
+              The UA might abort message write at this point. The reasons
+              for termination are implementation details. For example, the
+              implementation might be unable to support the requested
+              operation.
+            </p>
           </li>
           <li>
-            Return |p| and run the following steps <a>in parallel</a>:
-            <ol>
-              <li>
-                If the <a>obtain permission</a> steps return `false`, then
-                reject |p| with a {{"NotAllowedError"}} {{DOMException}} and
-                abort these steps.
-              </li>
-              <li>
-                If there is no underlying <a>NFC Adapter</a>, or if a connection
-                cannot be established, then reject |p| with a
-                {{"NotSupportedError"}} {{DOMException}}
-                and abort these steps.
-              </li>
-              <li>
-                If the UA is not allowed to access the underlying <a>NFC Adapter</a>
-                (e.g. a user preference), then reject |p| with a
-                {{"NotReadableError"}} {{DOMException}}
-                and abort these steps.
-              </li>
-              <li>
-                If pushing data is not supported by the underlying
-                <a>NFC Adapter</a>, then reject |p| with a {{"NotSupportedError"}}
-                {{DOMException}} and abort these steps.
-              </li>
-              <li>
-                An implementation MAY reject |p| with
-                a {{"NotSupportedError"}} {{DOMException}}
-                and abort these steps.
-                <p class="note">
-                  The UA might abort message write at this point. The reasons
-                  for termination are implementation details. For example, the
-                  implementation might be unable to support the requested
-                  operation.
-                </p>
-              </li>
-              <li>
-                Let |output| be the notation for the <a>NDEF message</a>
-                to be created by UA, as the result of invoking
-                <a>create NDEF message</a> with |message| and `""`.
-                If this throws an exception, reject |p| with that
-                exception and abort these steps.
-              </li>
-              <li>
-                Attempt to <a>abort a pending write operation</a>.
-                <p class="note">
-                  A write replaces all previously configured write operations.
-                </p>
-              </li>
-              <li>
-                Set `this`.[[\WriteOptions]] to |options|.
-              </li>
-              <li>
-                Set `this`.[[\WriteMessage]] to |output|.
-              </li>
-              <li>
-                Set <a>pending write tuple</a> to (`this`, |p|).
-              </li>
-              <li>
-                Run the <a>start the NFC write</a> steps whenever an
-                <a>NFC tag</a> |device| comes within communication range.
-                <p class="note">
-                  If <a>NFC is suspended</a>, continue waiting until promise is
-                  aborted by the user or an <a>NFC tag</a> comes within
-                  communication range.
-                </p>
-              </li>
-            </ol>
-            </li>
+            Let |output| be the notation for the {{NDEFMessage}}
+            to be created by UA, as the result of invoking
+            <a>create NDEF message</a> with |message| and `""`.
+            If this throws an exception, reject |p| with that
+            exception and abort these steps.
           </li>
-        </ol>
-      </div>
-
-      <div id="steps-start-nfc-write">
-        To <dfn>start the NFC write</dfn>, run these steps:
-        <ol class=algorithm>
           <li>
-            Let |p:Promise| be the <a>pending write tuple</a>'s promise.
+            Attempt to <a>abort a pending write</a> on |navigator.nfc.ndef|.
+            <p class="note">
+              A write invocation replaces all previously configured write operations.
+            </p>
           </li>
           <li>
-            Let |writer| be the <a>pending write tuple</a>'s writer.
+            Set |reader|.<a>[[\PendingWrite]]</a> to |p|.
           </li>
           <li>
-            Let |options:NDEFWriteOptions| be |writer|.[[\WriteOptions]].
+            Wait until the <a>NFC detection algorithm</a> runs the 
+            <a>resume writing</a> step.
           </li>
           <li>
             If the <a>NFC tag</a> in proximity range does not expose
-            <a>NDEF</a> technology for formatting or writing, then
-            reject |p| with a {{"NotSupportedError"}} {{DOMException}} and
-            return |p|.
+            <a>NDEF</a> technology for NDEF formatting or writing, then
+            reject |p| with a {{"NotSupportedError"}} {{DOMException}}.
           </li>
           <li>
-            Verify that <a href="#nfc-is-suspended">NFC is not suspended</a>.
+            If |device| is an <a>NFC tag</a> and if |options|'s overwrite is
+            `false`, read the tag to check whether there are <a>NDEF</a>
+            records on the tag. If yes, then reject |p| with a
+            {{"NotAllowedError"}} {{DOMException}} and return |p|.
           </li>
           <li>
-            In case of success, run the following steps:
-            <ol>
-              <li>
-                If |device| is an <a>NFC tag</a> and if |options|'s overwrite is
-                `false`, read the tag to check whether there are <a>NDEF</a>
-                records on the tag. If yes, then reject |p| with a
-                {{"NotAllowedError"}} {{DOMException}} and return |p|.
-              </li>
-              <li>
-                Let |output:NDEFMessage| be |writer|.[[\WriteMessage]].
-              </li>
-              <li>
-                Initiate data transfer to |device| using
-                |output| as buffer, using the <a>NFC adapter</a>
-                in communication range with |device|.
-                <p class="note">
-                  If the <a>NFC tag</a> in proximity range is unformatted and
-                  <a>NDEF</a>-formatable, format it and write |output| as
-                  buffer.
-                </p>
-                <p class="note">
-                  Multiple adapters should be used sequentially by users.
-                  There is very little likelihood that a simultaneous tap
-                  will happen on two or multiple different and connected
-                  <a>NFC adapter</a>s.
-                  If it happens, the user will likely need to repeat the
-                  taps until success, preferably one device at a time.
-                  The error here gives an indication that the operation
-                  needs to be repeated. Otherwise the user may think the
-                  operation succeeded on all connected <a>NFC adapter</a>s.
-                </p>
-              </li>
-              <li>
-                If the transfer fails, reject |p| with
-                {{"NetworkError"}} {{DOMException}}
-                and abort these steps.
-              </li>
-              <li>
-                When the transfer has completed, resolve |p|.
-              </li>
-            </ol>
+            Initiate data transfer to |device| using
+            |output| as buffer, using the <a>NFC adapter</a>
+            in communication range with |device|.
+            <p class="note">
+              If the <a>NFC tag</a> in proximity range is unformatted and
+              <a>NDEF</a>-formatable, format it and write |output| as
+              buffer.
+            </p>
+            <p class="note">
+              Multiple adapters should be used sequentially by users.
+              There is very little likelihood that a simultaneous tap
+              will happen on two or multiple different and connected
+              <a>NFC adapter</a>s.
+              If it happens, the user will likely need to repeat the
+              taps until success, preferably one device at a time.
+              The error here gives an indication that the operation
+              needs to be repeated. Otherwise the user may think the
+              operation succeeded on all connected <a>NFC adapter</a>s.
+            </p>
+          </li>
+          <li>
+            If the transfer fails, reject |p| with {{"NetworkError"}}
+            {{DOMException}} and abort these steps.
+          </li>
+          <li>
+            When the transfer has completed, resolve |p|.
           </li>
         </ol>
-      </div>
-    </section>
-  </section> <!-- Writing content -->
+    </div>
+  </section>
 
   <section><h3>Creating NDEF message</h3>
     <div>
       To <dfn>create NDEF message</dfn> given a
       |source:NDEFMessageSource| and |context:string|, run these steps:
-      <ol class=algorithm id="create-web-nfc-message">
+      <ol class=algorithm id="create-web-nfc-message"
+          data-link-for="NDEFMessageSource">
         <li>Switch on |source:NDEFMessageSource|'s type:
           <dl>
             <dt>{{DOMString}}</dt>
             <ul>
               <li>
-                Let |textRecord| be an <a>NDEFrecord</a> initialized with its
+                Let |textRecord| be an <a>NDEFRecord</a> initialized with its
                 |recordType| set to "`text`" and |data| set to |source|.
               </li>
               <li>
                 Let |records| be the list « |textRecord| ».
               </li>
               <li>
-                Set |source|'s records to |records|.
+                Set |source|'s <a>records</a> to |records|.
               </li>
             </ul>
             <dt>{{BufferSource}}</dt>
@@ -2645,13 +2645,13 @@ <h3><dfn>Writing content</dfn></h3>
                   Let |records| be the list « |mimeRecord| ».
                 </li>
                 <li>
-                  Set |source|'s records to |records|.
+                  Set |source|'s <a>records</a> to |records|.
                 </li>
             </ul>
             <dt>{{NDEFMessageInit}}</dt>
             <ul>
               <li>
-                If |source|'s records [= list/is empty =], [= exception/throw =]
+                If |source|'s <a>records</a> [= list/is empty =], [= exception/throw =]
                 a {{TypeError}} and abort these steps.
               </li>
             </ul>
@@ -2669,7 +2669,7 @@ <h3><dfn>Writing content</dfn></h3>
         </li>
         <li>
           [= list/For each =] |record:NDEFRecordInit| in the <a>list</a>
-          |source|'s records, run the following steps:
+          |source|'s <a>records</a>, run the following steps:
           <ol>
             <li>
               Let |ndef| be the result of running <a>create NDEF record</a>
@@ -3510,273 +3510,153 @@ <h3><dfn>Writing content</dfn></h3>
     </section>
   </section>
 
-  <section> <h3>Listening for content</h3>
-    <p>
-      To listen for <a>NFC content</a>, the client MUST activate an
-      {{NDEFReader}} instance by calling <a>NDEFReader.scan()</a>. When attaching
-      an event listener for the "`reading`" event on it, <a>NFC content</a> is
-      accessible to the client.
-    </p>
-    <p>
-      If there are any {{NDEFReader}} instances in <a>activated reader objects</a>
-      then the <a>UA</a> MUST listen to <a>NDEF message</a>s on all connected
-      NFC adapters.
-    </p>
+  <section> <h3>The <strong>read()</strong> method</h3>
     <p>
-      Each {{NDEFReader}} can accept <a>NDEF message</a>s based on
-      data type, and record identifier filters.
+      As opposed to <a>NDEFReader.write</a>, which will temporarily
+      <a>start NFC polling</a> if that is not active, in order to listen for
+      <a>NFC content</a>, clients should make sure to <a>start NFC polling</a>
+      before being able to read <a>NFC content</a>.
     </p>
-
-    <section> <h3>Match patterns</h3>
-      <div>
-        A <dfn>match pattern</dfn> is defined by the following ABNF:
-        <pre class="abnf">
-          match-pattern  = top-level-type "/" [ tree "." ] subtype [ "+" suffix ] [ ";" parameters ]
-          top-level-type = "*" / &lt; VCHAR except "/" and "*" &gt;
-          subtype        = "*" / &lt; VCHAR except "+" &gt;
-        </pre>
-        A <a>match pattern</a> is a
-        <a href="http://pubs.opengroup.org/onlinepubs/007904875/utilities/xcu_chap02.html#tag_02_13_03">
-        glob</a> used for matching <a>MIME type</a>s,
-        for instance the pattern "`application/*+json`" matches
-        "`application/calendar+json`", but does not match
-        "`application/json`". The pattern
-        "`*/*json`", on the other hand, matches both.
-      </div>
-    </section>
-
-    <section> <h3>The <strong>scan()</strong> method</h3>
-      <p>
-        Incoming <a>NFC content</a> is matched using {{NDEFReader}} instances.
-      </p>
-      <div>
-        When the <dfn>NDEFReader.scan</dfn> method is invoked, the UA
-        MUST run the following
-        <dfn id="steps-listen">NFC listen algorithm</dfn>:
+    <div>
+      When the <dfn>NDEFReader.read</dfn> method is invoked, the UA
+      MUST run the following steps:
         <ol class=algorithm>
           <li>
-            Let |p:Promise| be a new {{Promise}} object.
+            Let |p:Promise| be a new {{Promise}} object. Return |p| and run
+            the next steps <a>in parallel</a>.
           </li>
           <li>
-            Let |reader:NDEFReader| be the {{NDEFReader}} instance.
+            If <a>NFC is suspended</a>, reject |p| with a {{"NotAllowedError"}}
+            {{DOMException}} and abort these steps.
           </li>
           <li>
-            Let |options| be first argument.
+            If the <a>obtain permission</a> steps return `false`, then
+            reject |p| with a {{"NotAllowedError"}} {{DOMException}} and
+            abort these steps.
+          </li>
+          <li>
+            If there is no underlying <a>NFC Adapter</a>, or if a connection
+            cannot be established, then reject |p| with a
+            {{"NotSupportedError"}} {{DOMException}}
+            and abort these steps.
+          </li>
+          <li>
+            If the UA is not allowed to access the underlying <a>NFC Adapter</a>
+            (e.g. a user preference), then reject |p| with a
+            {{"NotReadableError"}} {{DOMException}}
+            and abort these steps.
           </li>
           <li>
-            [= list/For each =] |key| → |value| of |options|:
+            Let |startPolling:boolean| be `true` if <a>NFC polling is inactive</a> 
+            and otherwise to `false`.
+            <p class="note">
+              Reading will temporarily <a>start NFC polling</a> if that is not
+              active, until the first reading is done, when the temporary polling is
+              aborted.
+            </p>
+          </li>
+          <li>
+            [=promise/React=] to |p|:
+            If |p| was settled (fulfilled or rejected), then:
             <ol>
               <li>
-                If |key| equals "`signal`" and |value| is not `undefined`, set
-                |reader|.<a>[[\Signal]]</a> to |value|.
-              </li>
-              <li>
-                Otherwise, if |key| equals "`id`", set
-                |reader|.<a>[[\Id]]</a> to |value|.
-              </li>
-              <li>
-                Otherwise, if |key| equals "`recordType`", set
-                |reader|.<a>[[\RecordType]]</a> to |value|.
+                Set |navigator.nfc.ndef|.<a>[[\PendingRead]]</a> to `null`.
               </li>
               <li>
-                Otherwise, if |key| equals "`mediaType`", set
-                |reader|.<a>[[\MediaType]]</a> to |value|.
+                If |startPolling| is `true`, attempt to <a>abort NFC polling</a>.
               </li>
             </ol>
           </li>
           <li>
-            If |reader|.<a>[[\Signal]]</a>'s [= AbortSignal/aborted flag =] is
-            set, then reject |p| with a {{"AbortError"}} {{DOMException}}
-            and return |p|.
+            If |startPolling| is `true`, <a>start NFC polling</a>.
+            If that fails, reject |p| with a {{"NotReadableError"}} {{DOMException}} and abort 
+            these steps.
+          </li>
+          <li>
+            Let |reader:NDEFReader| be the |navigator.nfc.ndef| instance.
           </li>
           <li>
-            If |reader|.<a>[[\Signal]]</a> is not `null`, then
+            Let |options| be first argument.
+          </li>
+          <li>
+            Let |signal:AbortSignal| be the |options|’ dictionary member
+            of the same name if present, or `null` otherwise.
+          </li>
+          <li>
+            If |signal|'s [= AbortSignal/aborted flag =] is
+            set, then reject |p| with a {{"AbortError"}} {{DOMException}}.
+          </li>
+          <li>
+            If |signal| is not `null`, then
             <a data-cite="dom#abortsignal-abort-algorithms">add the following
-            abort steps</a> to |reader|.<a>[[\Signal]]</a>:
+            abort steps</a> to |signal|:
             <ol>
               <li>
-                Remove the {{NDEFReader}} instance from the
-                <a>activated reader objects</a>.
-              </li>
-              <li>
-                If the <a>activated reader objects</a> [= list/is empty =],
-                then make a request to stop listening to <a>NDEF message</a>s
-                on all <a>NFC adapter</a>s.
+                Attempt to <a>abort a pending read</a> on |reader|.
               </li>
             </ol>
           </li>
           <li>
-            Return |p| and run the following steps <a>in parallel</a>:
-            <ol>
-              <li>
-                If the <a>obtain permission</a> steps return `false`, then
-                reject |p| with a {{"NotAllowedError"}} {{DOMException}} and
-                abort these steps.
-              </li>
-              <li>
-                If there is no underlying <a>NFC Adapter</a>, or if a connection
-                cannot be established, then reject |p| with a
-                {{"NotSupportedError"}} {{DOMException}}
-                and abort these steps.
-              </li>
-              <li>
-                If the UA is not allowed to access the underlying <a>NFC Adapter</a>
-                (e.g. a user preference), then reject |p| with a
-                {{"NotReadableError"}} {{DOMException}}
-                and abort these steps.
-              </li>
-              <li>
-                Add |reader| to the <a>activated reader objects</a>.
-              </li>
-              <li>
-                Resolve |p|.
-              </li>
-              <li>
-                Whenever the <a>UA</a> detects NFC technology, run the
-                <a>NFC reading algorithm</a>.
-              </li>
-            </ol>
+            Set |navigator.nfc.ndef|.<a>[[\PendingRead]]</a> to |p|.
           </li>
-        </ol>
-      </div>
-    </section>
-
-    <section><h3>The NFC reading algorithm</h3>
-    To receive <a>NDEF</a> content, run the <dfn>NFC reading algorithm</dfn>:
-    <ol class=algorithm id="parse-ndef">
-      <li>
-        If <a>NFC is suspended</a>, abort these steps.
-      </li>
-      <li>
-        If the <a>NFC tag</a> in proximity range does not expose <a>NDEF</a>
-        technology for reading or formatting, run the following sub-steps:
-        <ol>
-          <li>[= list/For each =]
-            {{NDEFReader}} instance |reader:NDEFReader| in the
-            <a>activated reader objects</a>, run the following sub-steps:
-            <ol>
-              <li>
-                <a>Fire an event</a> named "`error`" at |reader|.
-              </li>
-            </ol>
+          <li>
+            Attempt to <a>abort a pending read</a> on |navigator.nfc.ndef|.
+            <p class="note">
+              A read invocation replaces all previously started read operations.
+            </p>
           </li>
           <li>
-            Abort these steps.
+            Wait until the <a>NFC detection algorithm</a> runs the 
+            <a>resume reading</a> step.
           </li>
-        </ol>
-      </li>
-      <li>
-        Let |serialNumber:serialNumber| be the device identifier as a series of
-        numbers, or `null` if unavailable.
-      </li>
-      <li>
-        If |serialNumber| is not `null`, set it to the
-        <a>string</a> of U+003A (`:`) concatenating each number represented as
-        <a>ASCII hex digit</a>, in the same order.
-      </li>
-      <li>
-        Let |message:NDEFMessage| be a new <a>NDEFMessage</a> object, with
-        |message|'s records set to the empty <a>list</a>.
-      </li>
-      <li>
-        If the <a>NFC tag</a> in proximity range is unformatted and is
-        NDEF-formattable, let |input| be `null`.
-        Otherwise, let |input| be the notation for the <a>NDEF message</a>
-        which has been received.
-        <p class="note">
-           The UA SHOULD represent an unformatted <a>NFC tag</a> as an
-           <a>NDEF message</a> containing no <a>NDEF record</a>s, i.e. an empty
-           array for its {{NDEFMessage/records}} property.
-        </p>
-      </li>
-      <li>
-        [= list/For each =] <a>NDEF record</a> which is part of |input|, run the
-        following sub-steps:
-        <ol>
           <li>
-            Let |ndef| be the notation for the current <a>NDEF record</a> with
-            |typeNameField:number| corresponding to the <a>TNF field</a> and
-            |payload:byte sequence| corresponding to the <a>PAYLOAD field</a>
-            data.
+            If the <a>NFC tag</a> in proximity range does not expose <a>NDEF</a>
+            technology for reading or formatting, reject |p| with a {{"NotSupportedError"}} 
+            {{DOMException}} and abort these steps.
           </li>
           <li>
-            Let |record:NDEFRecord| be the result of <a>parse an NDEF record</a>
-            given |ndef| and `""`.
+            Let |message:NDEFMessage| be a new <a>NDEFMessage</a> object, with
+            |message|'s records set to the empty <a>list</a>.
           </li>
           <li>
-             If |record| is not `null`, <a>append</a> |record| to |message|'s
-             records.
+            If the <a>NFC tag</a> in proximity range is unformatted and is
+            NDEF-formattable, let |input| be `null`.
+            Otherwise, let |input| be the notation for the <a>NDEF message</a>
+            which has been received.
+            <p class="note">
+               The UA SHOULD represent an unformatted <a>NFC tag</a> as an
+               <a>NDEF message</a> containing no <a>NDEF record</a>s, i.e. an empty
+               array for its {{NDEFMessage/records}} property.
+            </p>
           </li>
-        </ol>
-      </li>
-      <li>
-        If <a href="#nfc-is-suspended">NFC is not suspended</a>, run the
-        <a>dispatch NFC content</a> steps with given |serialNumber|
-        and |message|.
-      </li>
-    </ol>
-    </section>
-
-    <section data-link-for="NDEFReadingEvent"><h3>Dispatching NFC content</h3>
-    <p>
-      To <dfn>dispatch NFC content</dfn> given a |serialNumber:serialNumber|
-      of type <a>serialNumber</a> and a |message:NDEFMessage|
-      of type <a>NDEFMessage</a>, run these steps:
-    </p>
-    <ol class=algorithm>
-      <li>
-        [= list/For each =] {{NDEFReader}} instance |reader:NDEFReader| in
-        the <a>activated reader objects</a>, run the following sub-steps:
-        <ol>
           <li>
-            [= list/For each =] |record:NDEFRecord| in |message:NDEFMessage|,
+            [= list/For each =] <a>NDEF record</a> which is part of |input|, run the
+            following sub-steps:
             <ol>
               <li>
-                Let |matched:boolean| be `false`.
-              </li>
-              <li>
-                If |reader|.<a>[[\Id]]</a> is not `undefined` and is not equal
-                to |record|'s <a href="#dom-ndefrecord-id">id</a>,
-                [= iteration/continue =].
-                If it is equal, set |matched| to `true`.
+                Let |ndef| be the notation for the current <a>NDEF record</a> with
+                |typeNameField:number| corresponding to the <a>TNF field</a> and
+                |payload:byte sequence| corresponding to the <a>PAYLOAD field</a>
+                data.
               </li>
               <li>
-                If |reader|.<a>[[\RecordType]]</a> is not `undefined` and is
-                not equal to |record|'s
-                <a href="#dom-ndefrecord-recordtype">recordType</a>,
-                [= iteration/continue =].
-                If it is equal, set |matched| to `true`.
+                Let |record:NDEFRecord| be the result of <a>parse an NDEF record</a>
+                given |ndef| and `""`.
               </li>
               <li>
-                If |reader|.<a>[[\MediaType]]</a> is not `undefined` and is not
-                equal to
-                |record|'s <a href="#dom-ndefrecord-mediatype">mediaType</a>,
-                [= iteration/continue =].
-                If it is equal, set |matched| to `true`.
-              </li>
-              <li>
-                If |matched| is `true`,
-                <ol>
-                  <li>
-                    <a>fire an event</a> named "`reading`"
-                    at |reader| using <a>NDEFReadingEvent</a> with its
-                    <a>serialNumber</a> attribute initialized to |serialNumber|
-                    and <a>message</a> attribute initialized to |message|.
-                  </li>
-                  <li>
-                    [= iteration/Break =].
-                  </li>
-                </ol>
+                 If |record| is not `null`, <a>append</a> |record| to |message|'s
+                 records.
               </li>
             </ol>
           </li>
+          <li>
+            Resolve |p| with |message|.
+          </li>
         </ol>
-      </li>
-    </ol>
-    </section>
+      </div>
   </section>
 
-  <section id="steps-receiving">
+  <section id="steps-parse">
   <h3>Parsing content</h3>
 
   <section><h3>Parsing records from bytes</h3>
@@ -5052,7 +4932,7 @@ <h4>Multiple tags may be within the reading field at the same time</h4>
       <p>
         Writing <a>NFC content</a> to an <a>NFC tag</a> MUST
         <a>obtain permission</a>.
-        See the [[[#writing-content]]] section.
+        See the [[[#steps-write]]] section.
       </p>
       <p>
         All permission that are preserved beyond the current
diff --git a/web-nfc.d.ts b/web-nfc.d.ts
index f3b959c..4be7636 100644
--- a/web-nfc.d.ts
+++ b/web-nfc.d.ts
@@ -6,6 +6,12 @@
 // This type definitions referenced to WebIDL.
 // https://w3c.github.io/web-nfc/#actual-idl-index
 
+interface Navigator {
+  readonly nfc: NFC
+}
+declare class NFC {
+  readonly ndef: NDEFReader
+}
 interface Window {
   NDEFMessage: NDEFMessage
 }
@@ -43,27 +49,17 @@ declare interface NDEFRecordInit {
 
 declare type NDEFMessageSource = string | BufferSource | NDEFMessageInit
 
-interface Window {
-  NDEFWriter: NDEFWriter
-}
-declare class NDEFWriter {
+declare class NDEFReader extends EventTarget {
   constructor()
+  onreading: (event: NDEFReadingEvent) => void
+  onreadingerror: (error: any) => void
+  scan: (options?: NDEFScanOptions) => Promise<void>
   write: (
     message: NDEFMessageSource,
     options?: NDEFWriteOptions
   ) => Promise<void>
 }
 
-interface Window {
-  NDEFReader: NDEFReader
-}
-declare class NDEFReader extends EventTarget {
-  constructor()
-  onerror: (error: any) => void
-  onreading: (event: NDEFReadingEvent) => void
-  scan: (options?: NDEFScanOptions) => Promise<void>
-}
-
 interface Window {
   NDEFReadingEvent: NDEFReadingEvent
 }
@@ -78,13 +74,9 @@ interface NDEFReadingEventInit extends EventInit {
 }
 
 interface NDEFWriteOptions {
-  ignoreRead?: boolean
   overwrite?: boolean
   signal?: AbortSignal
 }
 interface NDEFScanOptions {
-  id?: string
-  recordType?: string
-  mediaType?: string
-  signal?: AbortSignal
+  signal: AbortSignal
 }