Update availability values and add "downloading"

See webmachinelearning/writing-assistance-apis#29.

Author: domenic

README.md

@@ -91,23 +91,24 @@ This will allow the implementation to download additional resources like languag
 
 Both APIs provide the ability to know, before calling `create()`, what is possible with the implementation. This is done via `availability()` methods, which takes the same options as `create()`. They return a promise, which fulfills with one of the following values:
 
-* `"no"` means that the implementation does not support translation or language detection of the given language(s).
-* `"after-download"` means that the implementation supports translation or language detection of the given language(s), but it will have to download something (e.g., a machine learning model) as part of creating the associated object.
-* `"readily"` means that the implementation supports translation or language detection of the given language(s), without performing any downloads.
+* `"unavailable"` means that the implementation does not support translation or language detection of the given language(s).
+* `"downloadable"` means that the implementation supports translation or language detection of the given language(s), but it will have to download something (e.g., a machine learning model) as part of creating the associated object.
+* `"downloading"` means that the implementation supports translation or language detection of the given language(s), but it will have to finish an ongoing download as part of creating the associated object.
+* `"available"` means that the implementation supports translation or language detection of the given language(s), without performing any downloads.
 
 Here is an example that adds capability checking to log more information and fall back to cloud services, as part of a language detection plus translation task:
 
 ```js
 async function translateUnknownCustomerInput(textToTranslate, targetLanguage) {
-  const canDetect = await ai.languageDetector.availability();
+  const detectorAvailability = await ai.languageDetector.availability();
 
   // If there is no language detector, then assume the source language is the
   // same as the document language.
   let sourceLanguage = document.documentElement.lang;
 
   // Otherwise, let's detect the source language.
-  if (canDetect !== "no") {
-    if (canDetect === "after-download") {
+  if (detectorAvailability !== "unavailable") {
+    if (detectorAvailability !== "available") {
       console.log("Language detection is available, but something will have to be downloaded. Hold tight!");
     }
 
@@ -123,13 +124,13 @@ async function translateUnknownCustomerInput(textToTranslate, targetLanguage) {
   }
 
   // Now we've figured out the source language. Let's translate it!
-  const availability = await ai.translator.availability({ sourceLanguage, targetLanguage });
-  if (availability === "no") {
+  const translatorAvailability = await ai.translator.availability({ sourceLanguage, targetLanguage });
+  if (translatorAvailability === "unavailable") {
     console.warn("Translation is not available. Falling back to cloud API.");
     return await useSomeCloudAPIToTranslate(textToTranslate, { sourceLanguage, targetLanguage });
   }
 
-  if (availability === "after-download") {
+  if (translatorAvailability !== "available") {
     console.log("Translation is available, but something will have to be downloaded. Hold tight!");
   }
 
@@ -223,7 +224,7 @@ interface AICreateMonitor : EventTarget {
 
 callback AICreateMonitorCallback = undefined (AICreateMonitor monitor);
 
-enum AICapabilityAvailability { "readily", "after-download", "no" };
+enum AIAvailability { "unavailable", "downloadable", "downloading", "available" };
 ```
 
 ```webidl
@@ -232,7 +233,7 @@ enum AICapabilityAvailability { "readily", "after-download", "no" };
 [Exposed=(Window,Worker), SecureContext]
 interface AITranslatorFactory {
   Promise<AITranslator> create(AITranslatorCreateOptions options);
-  Promise<AICapabilityAvailability> availability(AITranslatorCreateCoreOptions options);
+  Promise<AIAvailability> availability(AITranslatorCreateCoreOptions options);
 };
 
 [Exposed=(Window,Worker), SecureContext]
@@ -267,7 +268,7 @@ dictionary AITranslatorTranslateOptions {
 [Exposed=(Window,Worker), SecureContext]
 interface AILanguageDetectorFactory {
   Promise<AILanguageDetector> create(optional AILanguageDetectorCreateOptions options = {});
-  Promise<AICapabilityAvailability> availability(optional AILanguageDetectorCreateCoreOptions = {});
+  Promise<AIAvailability> availability(optional AILanguageDetectorCreateCoreOptions = {});
 };
 
 [Exposed=(Window,Worker), SecureContext]
@@ -317,15 +318,15 @@ This design means that the implementation must have all information about the ca
 
 This proposal as-is has privacy issues, which we are actively thinking about how to address. They are all centered around how sites that use this API might be able to uniquely fingerprint the user.
 
-The most obvious identifier in the current API design is the list of supported languages, and especially their availability status (`"no"`, `"readily"`, or `"after-download"`). For example, as of the time of this writing [Firefox supports 9 languages](https://www.mozilla.org/firefox/features/translate/), which can each be [independently downloaded](https://support.mozilla.org/kb/website-translation#w_configure-installed-languages). With a naive implementation, this gives 9 bits of identifying information, which various sites can all correlate.
+The most obvious identifier in the current API design is the list of supported languages, and especially their availability status (`"unavailable"`, `"downloadable"`, `"downloading"`, and `"available"`). For example, as of the time of this writing [Firefox supports 9 languages](https://www.mozilla.org/firefox/features/translate/), which can each be [independently downloaded](https://support.mozilla.org/kb/website-translation#w_configure-installed-languages). With a naive implementation, this gives 9 bits of identifying information, which various sites can all correlate.
 
 Some sort of mitigation may be necessary here. We believe this is adjacent to other areas that have seen similar mitigation, such as the [Local Font Access API](https://github.com/WICG/local-font-access/blob/main/README.md). Possible techniques are:
 
 * Grouping language packs to reduce the number of bits, so that downloading one language also downloads others in its group.
 * Partitioning download status by top-level site, introducing a fake download (which takes time but does not actually download anything) for the second-onward site to download a language pack.
 * Only exposing a fixed set of languages to this API, e.g. based on the user's locale or the document's main language.
 
-As a first step, we require that detecting the availability of translation/detection be done via individual calls to `ai.translator.availability()` and `ai.languageDetector.availability()`. This allows browsers to implement possible mitigation techniques, such as detecting excessive calls to these methods and starting to return `"no"`.
+As a first step, we require that detecting the availability of translation/detection be done via individual calls to `ai.translator.availability()` and `ai.languageDetector.availability()`. This allows browsers to implement possible mitigation techniques, such as detecting excessive calls to these methods and starting to return `"unavailable"`.
 
 Another way in which this API might enhance the web's fingerprinting surface is if translation and language detection models are updated separately from browser versions. In that case, differing results from different versions of the model provide additional fingerprinting bits beyond those already provided by the browser's major version number. Mandating that older browser versions not receive updates or be able to download models from too far into the future might be a possible remediation for this.