To expand a TD given |td:ThingDescription|, run the following steps:

1. For each item in the TD default values table from [[!WOT-TD]], if the term is not defined in |td|, add the term definition with the default value specified in [[!WOT-TD]].

To validate a TD given |td:ThingDescription|, run the following steps:

1. If JSON Schema validation fails on |td|, [= exception/throw =] a {{"TypeError"}} and stop.

Additional steps may be added to fill the default values of mandatory fields.

      partial namespace WOT {
        Promise<ConsumedThing> consume(ThingDescription td);
      };
    

Belongs to the WoT Consumer conformance class. Expects an |td:ThingDescription| argument and returns a {{Promise}} that resolves with a {{ConsumedThing}} object that represents a client interface to operate with the Thing. The method MUST run the following steps:

1. Return a {{Promise}} |promise:Promise| and execute the next steps [=in parallel=].
2. If invoking this method is not allowed for the current scripting context for security reasons, [=reject=] |promise| with a {{SecurityError}} and stop.
3. Let |thing:ConsumedThing| be a new {{ConsumedThing}} object constructed from |td|.
4. Set up the WoT Interactions based on introspecting td as explained in [[!WOT-TD]] and [[!WOT-PROTOCOL-BINDINGS]]. Make a request to the underlying platform to initialize the Protocol Bindings.

   Implementations encapsulate the complexity of how to use the Protocol Bindings for implementing WoT interactions. In the future elements of that could be standardized.

5. [=Resolve=] |promise| with |thing|.

Note the difference between constructing ConsumedThing and using the consume() method: the latter also initializes the protocol bindings, whereas a simple constructed object will not have WoT Interactions initialized until they are invoked.

      typedef object ExposedThingInit;

      partial namespace WOT {
        Promise<ExposedThing> produce(ExposedThingInit init);
      };
    

Belongs to the WoT Producer conformance class. Expects a |init:ExposedThingInit| argument and returns a {{Promise}} that resolves with an {{ExposedThing}} object that extends {{ConsumedThing}} with a server interface, i.e. the ability to define request handlers. The |init:ExposedThingInit| object is an instance of the ExposedThingInit type. Specifically, an ExposedThingInit value is a dictionary used for the initialization of an ExposedThing and it represents a Partial TD as described in the [[!WOT-ARCHITECTURE]]. As such, it has the same structure of a Thing Description but it may omit some information. The method MUST run the following steps:

1. Return a {{Promise}} |promise:Promise| and execute the next steps [=in parallel=].
2. If invoking this method is not allowed for the current scripting context for security reasons, [=reject=] |promise| with a {{SecurityError}} and stop.
3. Let |thing:ExposedThing| be a new {{ExposedThing}} object constructed with |init|.
4. [=Resolve=] |promise| with |thing|.

      partial namespace WOT {
        Promise<ThingDiscoveryProcess> discover(optional ThingFilter filter = {});
      };
    

Belongs to the WoT Discovery conformance class. Starts the discovery process that will provide {{ThingDescription}} objects for Thing Descriptions that match an optional |filter:ThingFilter| argument of type {{ThingFilter}}. The method MUST run the following steps:

1. Return a {{Promise}} |promise:Promise| and execute the next steps [=in parallel=].
2. If invoking this method is not allowed for the current scripting context for security reasons, [=reject=] |promise| with a {{SecurityError}} and stop.
3. If discovery is not supported by the implementation, [=reject=] |promise| with {{NotSupportedError}} and stop.
4. Let |discovery:ThingDiscoveryProcess| be a new {{ThingDiscoveryProcess}} object.
5. Set |discovery|.{{ThingDiscoveryProcess/[[filter]]}} to |filter:ThingFilter|.
6. Set |discovery|.{{ThingDiscoveryProcess/[[url]]}} to `undefined`.
7. If filters in general are not supported by the implementation and |filter| is not `undefined` or `null`, [=reject=] |promise| with {{NotSupportedError}} and stop.
8. If discovery cannot be started by the underlying platform, [=reject=] |promise| with {{OperationError}} and stop.
9. Request the underlying platform to start the discovery process by any means supported and provisioned in the WoT Runtime for which the script has access to, passing |discovery| to it.
10. [=Resolve=] |promise| with |discovery|.

      partial namespace WOT {
        Promise<ThingDiscoveryProcess> exploreDirectory(USVString url,
            optional ThingFilter filter = {});
      };
    

Belongs to the WoT Discovery conformance class. Starts the discovery process that given a TD Directory URL, will provide {{ThingDescription}} objects for Thing Descriptions that match an optional |filter:ThingFilter| argument of type {{ThingFilter}}. The method MUST run the following steps:

1. Return a {{Promise}} |promise:Promise| and execute the next steps [=in parallel=].
2. If invoking this method is not allowed for the current scripting context for security reasons, [=reject=] |promise| with a {{SecurityError}} and stop.
3. If directory discovery is not supported by the implementation, [=reject=] |promise| with {{NotSupportedError}} and stop.
4. Let |discovery:ThingDiscoveryProcess| be a new {{ThingDiscoveryProcess}} object.
5. Set |discovery|.{{ThingDiscoveryProcess/[[url]]}} to |url:USVString|.
6. Set |discovery|.{{ThingDiscoveryProcess/[[filter]]}} to |filter:ThingFilter|.
7. Request the underlying platform to start the directory discovery process.

   This is a placeholder for more details in the discovery algorithm. Implementations should follow the procedures described in the [[WOT-DISCOVERY]] and [WOT-PROTOCOL-BINDINGS] specifications. Some normative steps are indicated below.

   1. If |url| is not a TD Directory or if the underlying implementation cannot support the Protocol Binding indicated by |url|, [=reject=] |promise| with {{NotSupportedError}} and terminate these steps.
   2. If filters in general are not supported by the implementation and |filter| is not `undefined` or `null`, [=reject=] |promise| with {{NotSupportedError}} and stop.
   3. Run the discovery process given |discovery|.

      From this point on, errors are recorded only on {{ThingDiscoveryProcess/error}}, but don't affect |promise| any longer.

8. [=Resolve=] |promise| with |discovery|.

      partial namespace WOT {
        Promise<ThingDescription> requestThingDescription(USVString url);
      };
    

Belongs to the WoT Discovery conformance class. Requests a Thing Description from the given URL. The method MUST run the following steps:

1. Return a {{Promise}} |promise:Promise| and execute the next steps [=in parallel=].
2. If invoking this method is not allowed for the current scripting context for security reasons, [=reject=] |promise| with a {{SecurityError}} and stop.
3. If fetching a Thing Description is not supported by the implementation, [=reject=] |promise| with {{NotSupportedError}} and stop.
4. Let |td:ThingDescription| be the result of making a request to the underlying platform to retrieve the Thing Description using the Protocol Binding specified by |url|. If retrieving |td| fails, [=reject=] |promise| with {{NotFoundError}} and stop.
5. [=Resolve=] |promise| with |td|.

To create {{ConsumedThing}} with the {{ThingDescription}} |td:ThingDescription|, run the following steps:

1. Run the validate a TD steps on |td|. If that fails, [= exception/throw =] {{SyntaxError}} and stop.
2. Run the expand a TD steps on |td|. If that fails, re-[= exception/throw =] the error and stop.
3. Let |thing:ConsumedThing| be a new {{ConsumedThing}} object.
4. Set the internal slot {{ConsumedThing/[[td]]}} of |thing| to |td|.
5. Return |thing|.

Reads a Property value. Takes as arguments |propertyName:string| and optionally |options:InteractionOptions|. It returns a {{Promise}} that resolves with a Property value represented as an {{InteractionOutput}} object or rejects on error. The method MUST run the following steps:

1. Return a {{Promise}} |promise:Promise| and execute the next steps [=in parallel=].
2. If invoking this method is not allowed for the current scripting context for security reasons, [=reject=] |promise| with a {{SecurityError}} and stop.
3. Let |interaction| be {{ConsumedThing/[[td]]}}.|properties|.|propertyName|.
4. If |interaction| is `undefined`, [=reject=] |promise| with a {{NotFoundError}} and stop.
5. If |option|.|formIndex| is defined, let |form| be the Form associated with |formIndex| in |interaction|.|forms| array, otherwise let |form| be a Form in |interaction|.|forms| whose |op| is `readproperty`, selected by the implementation.
6. If |form| is failure, [=reject=] |promise| with a {{SyntaxError}} and stop.
7. Make a request to the underlying platform (via the Protocol Bindings) to retrieve the value of the |propertyName| Property using |form| and the optional URI templates given in |options|.|uriVariables|.
8. If the request fails, [=reject=] |promise| with the error received from the Protocol Bindings and stop.
9. Let |response| be the response received to the request.
10. Let |data| be the result of running parse interaction response on |response|, |form| and |interaction|. If that fails, [=reject=] |promise| with a {{SyntaxError}} and stop.
11. [=Resolve=] |promise| with |data|.

Reads multiple Property values with one request. Takes as arguments |propertyNames: string sequence| and optionally |options:InteractionOptions|. It returns a {{Promise}} that resolves with a {{PropertyReadMap}} object that maps keys from |propertyNames| to values returned by this algorithm. The method MUST run the following steps:

1. Return a {{Promise}} |promise:Promise| and execute the next steps [=in parallel=].
2. If invoking this method is not allowed for the current scripting context for security reasons, [=reject=] |promise| with a {{SecurityError}} and stop.
3. If |option|.|formIndex| is defined, let |form| be the Form associated with |formIndex| in the {{ConsumedThing/[[td]]}}.|forms| array, otherwise let |form| be the Form in {{ConsumedThing/[[td]]}}.|forms| array whose |op| is `readmultipleproperties`, as selected by the implementation.
4. If |form| is failure, [=reject=] |promise| with a {{SyntaxError}} and stop.
5. Let |result:object| be an object and for each string |name:string| in |propertyNames| add a property with key |name| and the value `null`.
6. Make a request to the underlying platform (via the Protocol Bindings) to retrieve the Property values given by |propertyNames| with |form| and optional URI templates given in |options|' |uriVariables|.
7. If this cannot be done with a single request with the Protocol Bindings, [=reject=] |promise| with a {{NotSupportedError}} and stop.
8. Process the response and for each |key| in |result|, run the following sub-steps:
   1. Let |value| be |result|[|key|].
   2. Let |schema| be |this|.{{ConsumedThing/[[td]]}}.|properties|[|key|].
   3. Let |property| be the result of running parse interaction response on |value|, |form| and |schema|.
9. If the above step throws at any point, [=reject=] |promise| with that exception and stop.
10. [=Resolve=] |promise| with |result|.

Reads all properties of the Thing with one request. Takes |options:InteractionOptions| as optional argument. It returns a {{Promise}} that resolves with a {{PropertyReadMap}} object that maps keys from Property names to values returned by this algorithm. The method MUST run the following steps:

1. Return a {{Promise}} |promise:Promise| and execute the next steps [=in parallel=].
2. If invoking this method is not allowed for the current scripting context for security reasons, [=reject=] |promise| with a {{SecurityError}} and stop.
3. Let |forms| be |subscription|.{{Subscription/[[interaction]]}}.|forms|.
4. If |forms| is `undefined`, [=reject=] |promise| with a {{SyntaxError}} and stop.
5. If |option|.|formIndex| is not `undefined` and is less than |forms|.|length|, set |subscription|.{{Subscription/[[form]]}} to |forms|.[|formIndex|].
6. Otherwise, set |subscription|.{{Subscription/[[form]]}} to a Form in |forms| whose |op| is `"readallproperties"`, as selected by the implementation.
7. If |subscription|.{{Subscription/[[form]]}} is failure, [=reject=] |promise| with a {{SyntaxError}} and stop.
8. Make a request to the underlying platform using the Protocol Bindings to retrieve all the Property definitions from the TD given |form| and optional URI templates in |options|.|uriVariables|.
9. If this cannot be done with a single request with the Protocol Bindings of the Thing, then [=reject=] |promise| with a {{NotSupportedError}} and stop.
10. If the request fails, [=reject=] |promise| with the error received from the Protocol Bindings and stop.
11. Process the reply and let |result:object| be an object with the keys and values obtained in the reply.
12. Process the response and for each |key| in |result|, run the following sub-steps:
    1. Let |value| be |result|[|key|].
    2. Let |schema| be |this|.{{ConsumedThing/[[td]]}}.|properties|[|key|].
    3. Let |property| be the result of running parse interaction response on |value|, |form| and |schema|.
13. [=Resolve=] |promise| with |result|.

Writes a single Property. Takes as arguments |propertyName:string|, |value:InteractionInput| and optionally |options:InteractionOptions|. It returns a {{Promise}} that resolves on success and rejects on failure. The method MUST run the following steps:

1. Return a {{Promise}} |promise:Promise| and execute the next steps [=in parallel=].
2. If invoking this method is not allowed for the current scripting context for security reasons, [=reject=] |promise| with a {{SecurityError}} and stop.
3. Let |interaction| be |this|.{{ConsumedThing/[[td]]}}.|properties|[|propertyName|].
4. If |interaction| is `undefined`, [=reject=] |promise| with a {{NotFoundError}} and stop.
5. If |option|.|formIndex| is not `undefined`, let |form| be the Form associated with |formIndex| in the |interaction|.|forms| array, otherwise let |form| be a Form in |interaction|.|forms| whose |op| is `writeproperty`, as selected by the implementation.
6. If |form| is failure, [=reject=] |promise| with a {{SyntaxError}} and stop.
7. Let |data| be the result of running the create interaction request steps given |value|, |form| and |interaction|. If that throws, [=reject=] promise with that exception and stop.
8. Make a request to the underlying platform (via the Protocol Bindings) to write the Property given by |propertyName| using |data:InteractionOutput| and the optional URI templates given in |options|' |uriVariables|.
9. If the request fails, [=reject=] |promise| with the error received from the Protocol Bindings and stop.
10. Otherwise [=resolve=] |promise|.

Writes a multiple Property values with one request. Takes as arguments |properties:object| - as an object with keys being Property names and values as Property values - and optionally |options:InteractionOptions|. It returns a {{Promise}} that resolves on success and rejects on failure. The method MUST run the following steps:

1. Return a {{Promise}} |promise:Promise| and execute the next steps [=in parallel=].
2. If invoking this method is not allowed for the current scripting context for security reasons, [=reject=] |promise| with a {{SecurityError}} and stop.
3. If |option|.|formIndex| is defined, let |form| be the Form associated with |formIndex| in the {{ConsumedThing/[[td]]}}.|forms| array, otherwise let |form| be a Form in {{ConsumedThing/[[td]]}}.|forms| array whose |op| is `writemultipleproperties`, as selected by the implementation.
4. If |form| is failure, [=reject=] |promise| with a {{SyntaxError}} and stop.
5. Let |propertyNames| be an array of |string| with as elements the keys of the |properties| object.
6. For each |name:string| in |propertyNames|, let |property| be |this|.{{ConsumedThing/[[td]]}}.|properties|[|name|].
7. If |property| is `null` or `undefined` or is not `writeable` [=reject=] |promise| with {{NotSupportedError}} and stop.
8. Let |result:object| be an object and for each string |name:string| in |propertyNames| add a property with key |name| and let its value be `null`.
9. Let |schemas:object| be an object and for each |name:string| in |propertyNames| add a property with key |name| and let its value be |this|.{{ConsumedThing/[[td]]}}.|properties|[|name|].
10. For each key |key:string| in |properties|, run the create interaction request steps given |properties|[|key|], |form| and the value for |schema|[|key|]. If that throws for any |name|, [=reject=] promise with that exception and stop.
11. Make a single request to the underlying platform (via the Protocol Bindings) to write each Property provided in |properties| with optional URI templates given in |options|' |uriVariables|.
12. If this cannot be done with a single request with the Protocol Bindings of the Thing, then [=reject=] |promise| with a {{NotSupportedError}} and stop.
13. If the request fails, return the error received from the Protocol Bindings and stop.
14. Otherwise [=resolve=] |promise|.

Makes a request for Property value change notifications. Takes as arguments |propertyName:string|, |listener:InteractionListener| and optionally |onerror:ErrorListener| and |options:InteractionOptions|. It returns a {{Promise}} that resolves on success and rejects on failure.

This algorithm allows for only one active {{Subscription}} per Property. If a new {{Subscription}} is made while an existing {{Subscription}} is active the runtime will throw an {{NotAllowedError}}.

The method MUST run the following steps:

1. Let |thing| be the reference of this {{ConsumedThing}} object.
2. Return a {{Promise}} |promise:Promise| and execute the next steps [=in parallel=].
3. If invoking this method is not allowed for the current scripting context for security reasons, [=reject=] |promise| with a {{SecurityError}} and stop.
4. If |listener| is not a {{Function}}, [=reject=] |promise| with a {{TypeError}} and stop.
5. If |onerror| is not `null` and is not a {{Function}}, [=reject=] |promise| with a {{TypeError}} and stop.
6. If |thing|.{{ConsumedThing/[[activeObservations]]}}[|propertyName|] [=map/exists], [=reject=] |promise| with a {{NotAllowedError}} and stop.
7. Let |subscription| be a new {{Subscription}} object with its internal slots set as follows:
   • Let |subscription|.{{Subscription/[[type]]}} be `"property"`.
   • Let |subscription|.{{Subscription/[[name]]}} be |propertyName|.
   • Let |subscription|.{{Subscription/[[interaction]]}} be {{ConsumedThing/[[td]]}}.|properties|[|propertyName|].
   • Let |subscription|.{{Subscription/[[thing]]}} be |thing|.
   • Let |forms| be |subscription|.{{Subscription/[[interaction]]}}.|forms|.
   • If |forms| is `undefined`, [=reject=] |promise| with a {{SyntaxError}} and stop.
   • If |option|.|formIndex| is not `undefined` and is less than |forms|.|length|, set |subscription|.{{Subscription/[[form]]}} to |forms|.[|formIndex|].
   • Otherwise, set |subscription|.{{Subscription/[[form]]}} to a Form in |forms| whose |op| is `"observeproperty"`, as selected by the implementation.
   • If |subscription|.{{Subscription/[[form]]}} is failure, [=reject=] |promise| with a {{SyntaxError}} and stop.
   • If |subscription|.{{Subscription/[[interaction]]}} is `undefined`, [=reject=] |promise| with a {{NotFoundError}} and stop.
8. Make a request to the underlying platform to observe the Property identified by |propertyName| with |form| and optional URI templates given in |options|' |uriVariables|.
9. If the request fails, [=reject=] |promise| with the error received from the Protocol Bindings and stop.
10. [=map/Set=] |thing|.{{ConsumedThing/[[activeObservations]]}}[|propertyName] to |subscription| and [=resolve=] |promise|.
11. Whenever the underlying platform detects a notification for this |subscription| [=map/keyed=] on |propertyName| with a new Property value |value|, run the following sub-steps:
    • Let |reply| be the result of running parse interaction response with |value|, |subscription|.{{Subscription/[[form]]}} and |subscription|.{{Subscription/[[interaction]]}}. If that throws, [=reject=] |promise| with that exception and stop.
    • Invoke |listener| given |reply|.
12. Whenever the underlying platform detects an error for this subscription, run the following sub-steps:
    • If the error is irrecoverable and stops the subscription, set |subscription|.|active| to `false` and suppress further notifications.
    • Let |error| be a new {{NetworkError}} and set its |message| to reflect the underlying error condition.
    • If |onerror| is a {{Function}}, invoke it given |error|.

Makes a request for invoking an Action and return the result. Takes as arguments |actionName:string|, optionally |params:InteractionInput| and optionally |options:InteractionOptions|. It returns a {{Promise}} that resolves with the result of the Action represented as an {{InteractionOutput}} object, or rejects with an error. The method MUST run the following steps:

1. Return a {{Promise}} |promise:Promise| and execute the next steps [=in parallel=].
2. If invoking this method is not allowed for the current scripting context for security reasons, [=reject=] |promise| with a {{SecurityError}} and stop.
3. Let |interaction| be |this|.{{ConsumedThing/[[td]]}}.|actions|[|actionName|].
4. If |interaction| is not an {{object}}, [=reject=] |promise| with a {{NotFoundError}} and stop.
5. Let |forms| be |subscription|.{{Subscription/[[interaction]]}}.|forms|.
6. If |forms| is `undefined`, [=reject=] |promise| with a {{SyntaxError}} and stop.
7. If |option|.|formIndex| is not `undefined` and is less than |forms|.|length|, set |subscription|.{{Subscription/[[form]]}} to |forms|.[|formIndex|].
8. Otherwise, set |subscription|.{{Subscription/[[form]]}} to a Form in |forms| whose |op| is `"invokeaction"`, as selected by the implementation.
9. If |subscription|.{{Subscription/[[form]]}} is failure, [=reject=] |promise| with a {{SyntaxError}} and stop.
10. Let |args| be the result of running the create interaction request steps on |params|, |form| and |interaction|. If that throws, [=reject=] promise with that exception and stop.
11. Make a request to the underlying platform (via the Protocol Bindings) to invoke the Action identified by |actionName| given |args| and |options|.|uriVariables|.
12. If the request fails locally or returns an error over the network, [=reject=] |promise| with the error received from the Protocol Bindings and stop.
13. Let |value| be the reply returned in the reply.
14. Let |result| be the result of running parse interaction response with |value|, |form| and |interaction|. If that throws, [=reject=] |promise| with that exception and stop.
15. [=Resolve=] |promise| with |result|.

Makes a request for subscribing to Event notifications. Takes as arguments |eventName:string|, |listener:WoTListener| and optionally |onerror:ErrorListener| and |options:InteractionOptions|. It returns a {{Promise}} to signal success or failure.

This algorithm allows for only one active {{Subscription}} per Event. If a new {{Subscription}} is made while an existing {{Subscription}} is active the runtime will throw an {{NotAllowedError}}.

The method MUST run the following steps:

1. Let |thing| be the reference of this {{ConsumedThing}} object.
2. Return a {{Promise}} |promise:Promise| and execute the next steps [=in parallel=].
3. If invoking this method is not allowed for the current scripting context for security reasons, [=reject=] |promise| with a {{SecurityError}} and stop.
4. If |listener| is not a {{Function}}, [=reject=] |promise| with a {{TypeError}} and stop.
5. If |onerror| is not `null` and is not a {{Function}}, [=reject=] |promise| with a {{TypeError}} and stop.
6. If |thing|.{{ConsumedThing/[[activeSubscriptions]]}}[|eventName|] does not [=map/exist=], [=reject=] |promise| with a {{NotAllowedError}} and stop.
7. Let |subscription| be a new {{Subscription}} object with its internal slots set as follows:
   • Let |subscription|.{{Subscription/[[type]]}} be `"event"`.
   • Let |subscription|.{{Subscription/[[name]]}} be |eventName|.
   • Let |subscription|.{{Subscription/[[interaction]]}} be |thing|. {{ConsumedThing/[[td]]}}.|events|[|eventName|].
   • If |subscription|.{{Subscription/[[interaction]]}} is `undefined`, [=reject=] |promise| with a {{NotFoundError}} and stop.
   • Let |subscription|.{{Subscription/[[thing]]}} be |thing|.
   • If |options|.|formIndex| [=map/exists=], then let |subscription|.{{Subscription/[[form]]}} be |thing|.{{Subscription/[[interaction]]}}.|forms|[|formIndex|].
   • Otherwise, let |subscription|.{{Subscription/[[form]]}} be an [=implementation-defined=] Form from the |subscription|.{{Subscription/[[interaction]]}}.|forms| array whose |op| is `"subscribeevent"`.
   • If |subscription|.{{Subscription/[[form]]}} does not [=map/exist=], [=reject=] |promise| with a {{SyntaxError}} and stop.
8. Make a request to the underlying platform via the Protocol Bindings to subscribe to the Event identified by |eventName:string| with {{Subscription/[[form]]}}, optional URI templates given in |options|.|uriVariables| and optional subscription data given in |options|.|data|.
9. If the request fails, [=reject=] |promise| with the error received from the Protocol Bindings and stop.
10. [=map/Set=] |eventName| to |thing|.{{ConsumedThing/[[activeSubscriptions]]}}[|eventName|] to |subscription|.
11. [=Resolve=] |promise|.
12. Whenever the underlying platform detects a notification for the Event |subscription| [=map/keyed=] on |eventName|, run the following sub-steps:
    1. Invoke |listener| given the result of running parse interaction response on the data provided with the Event, |subscription|.{{Subscription/[[form]]}} and |subscription|.{{Subscription/[[interaction]]}}.
13. Whenever the underlying platform detects an error for Event |subscription| [=map/keyed=] on |eventName|, run the following sub-steps:
    • If the error is irrecoverable and stops the subscription, set |subscription|.|active| to `false` and suppress further notifications.
    • Let |error| be a new {{NetworkError}} and set its |message| to reflect the underlying error condition.
    • If |onerror| is a {{Function}}, invoke it given |error|.

To construct an {{ExposedThing}} with the {{ExposedThingInit}} |init:ExposedThingInit|, run the following steps:

1. If invoking this method is not allowed for the current scripting context for security reasons, [= exception/throw =] a {{SecurityError}} and stop.
2. Run the expand an ExposedThingInit steps on |init|. if that fails re-[= exception/throw =] the error and stop. Otherwise store the obtained |td:ThingDescription|
3. Run the expand a TD steps on |td|. If that fails, re-[= exception/throw =] the error and stop.
4. Let |thing:ExposedThing| be a new {{ExposedThing}} object.
5. Set the {{ExposedThing/[[td]]}} of |thing| to |td|.
6. Return |thing|.

When the method is invoked given |name:string| and |handler:PropertyReadHandler|, implementations MUST run the following steps:

1. If invoking this method is not allowed for the current scripting context for security reasons, [= exception/throw =] a {{SecurityError}} and stop.
2. If {{ExposedThing/[[td]]}}.|properties|[|name|] does not [=map/exist=], [= exception/throw =] {{NotFoundError}} and stop.
3. Set |this|.{{ExposedThing/[[readHandlers]]}}[|name|] to |handler|.

When a network request for reading Property |name:string| is received by the implementation with |options:InteractionOptions|, run the following steps:

1. If this operation is not supported, send back a {{NotSupportedError}} according to the Protocol Bindings and stop.
2. If this operation is not allowed, send back a {{NotAllowedError}} according to the Protocol Bindings and stop.
3. Let |value| be the result of running the read server property steps with |name:string| and |options:InteractionOptions|:
   1. Let |interaction| be {{ExposedThing/[[td]]}}.|properties|.|name|.
   2. If a Property with |name| does not exist, throw {{NotFoundError}} and stop.
   3. Let |handler:function| be `null`.
   4. If there is a user provided {{PropertyReadHandler}} in {{ExposedThing/[[readHandlers]]}} internal slot for |interaction|, let |handler| be that.
   5. Otherwise, if there is a default read handler provided by the implementation, let |handler| be that.
   6. If |handler| is `null`, throw {{NotSupportedError}} and stop.
   7. Let |value| be the result of invoking |handler| given |options|. If that fails, throw the error and stop.
   8. Return |value|.

      The |value| returned here SHOULD either conform to DataSchema or it SHOULD be an {{ReadableStream}} object created by the |handler|.

4. If the previous step has thrown an error, send the error back with the reply created by following the Protocol Bindings and stop.
5. Serialize and add the returned |value| to the reply created by following the Protocol Bindings.

When a network request for reading multiple Properties given in an object |propertyNames| is received with |options:InteractionOptions|, run the following read multiple properties steps on |propertyNames| and |options|:

1. If this operation is not supported, send back a {{NotSupportedError}} according to the Protocol Bindings and stop.
2. If this operation is not allowed, send back a {{NotAllowedError}} according to the Protocol Bindings and stop.
3. For each property with key |name| defined in |propertyNames|,
   1. Let |value| be the result of running the read server property steps on |name| and |options|. If that throws, send back the error in the reply created by following the Protocol Bindings and stop.
   2. Set |propertyNames|.|name| to |value|.
4. Reply to the request by sending a single reply created from |propertyNames| according to the Protocol Bindings.

When a network request for reading all Properties is received with |options:InteractionOptions|, run the following steps:

1. If this operation is not supported, send back a {{NotSupportedError}} according to the Protocol Bindings and stop.
2. If this operation is not allowed, send back a {{NotAllowedError}} according to the Protocol Bindings and stop.
3. Let |properties| be an object created with all properties defined in the Thing with values set to `null`.
4. Run the read multiple properties steps on |properties| and |options|.

When the method is invoked given |name:string| and |handler:PropertyReadHandler|, implementations MUST run the following steps:

1. If invoking this method is not allowed for the current scripting context for security reasons, [= exception/throw =] a {{SecurityError}} and stop.
2. If |this|.{{ExposedThing/[[td]]}}.|properties|[|name|] does not [=map/exist=], [= exception/throw =] {{NotFoundError}} and stop.
3. Set |this|{{ExposedThing/[[observeHandlers]]}}[|name|] to |handler|.

When a network request for observing a Property |name:string| is received by the implementation with |options:InteractionOptions|, run the following steps:

1. If this operation is not supported, send back a {{NotSupportedError}} according to the Protocol Bindings and stop.
2. If this operation is not allowed, send back a {{NotAllowedError}} according to the Protocol Bindings and stop.
3. If |this|.{{ExposedThing/[[td]]}}.|properties|[|name|] does not [=map/exist=], send back a {{NotFoundError}} in the reply and stop.
4. Internally save the request sender information together with |options| and |this|.{{ExposedThing/[[propertyObservers]]}}[|name|], in order to be able to notify about Property value changes.

When the method is invoked given |name:string| and |handler:PropertyReadHandler|, implementations MUST run the following steps:

1. If invoking this method is not allowed for the current scripting context for security reasons, [= exception/throw =] a {{SecurityError}} and stop.
2. If |this|.{{ExposedThing/[[td]]}}.|properties|[|name|] does not [=map/exist=], [= exception/throw =] {{NotFoundError}} and stop.
3. Set |this|.{{ExposedThing/[[unobserveHandlers]]}}[|name|] to |handler|.

When a network request for unobserving a Property |name:string| with |options:InteractionOptions| is received by the implementation, run the following steps:

1. If this operation is not supported, send back a {{NotSupportedError}} according to the Protocol Bindings and stop.
2. If this operation is not allowed, send back a {{NotAllowedError}} according to the Protocol Bindings and stop.
3. If |this|.{{ExposedThing/[[td]]}}.|properties|[|name|] does not [=map/exist=], send back a {{NotFoundError}} in the reply and stop.
4. Let |handler| be |this|.{{ExposedThing/[[unobserveHandlers]]}}[|name|];
5. If |handler| is a {{Function}}, invoke that given |options|, then send back a reply following the Protocol Bindings and stop.
6. Otherwise, if |this|.{{ExposedThing/[[propertyObservers]]}}[|name|] [=map/exists=], remove it from |this|.{{ExposedThing/[[propertyObservers]]}}, send back a reply as defined in the Protocol Bindings and stop.
7. Otherwise, send back a {{NotFoundError}} in the reply as defined in the Protocol Bindings and stop.

Takes the |name:string| argument, denoting a Property name, and optionally the |data:InteractionInput| argument. Triggers emitting a notification to all observers of the specified Property with the data provided by the |data| argument, or if not provided, it is obtained by the observe handler or the by read handler associated with that Property. The method MUST run the following steps:

1. Let |promise:Promise| be a new {{Promise}}.
2. Return |promise| and execute the next steps [=in parallel=].
3. If invoking this method is not allowed for the current scripting context for security reasons, [=reject=] |promise| with a {{SecurityError}} and stop.
4. Let |name| be the first argument.
5. Let |property| be |this|.{{ExposedThing/[[td]]}}.|properties|[|name|].
6. If |property| is `undefined`, [=reject=] |promise| with {{NotFoundError}} and stop.
7. Let |data| be the second argument.
8. If |data| is `undefined`, run the following sub-steps:
   1. Let |handler:function| be `null.`
   2. If |name| does not [=map/exist=] in {{ExposedThing/[[readHandlers]]}}, [=reject=] |promise| and stop.
   3. Let |handler| be {{ExposedThing/[[readHandlers]]}}[|name|].
   4. If |handler| is `null` or `undefined`, [=reject=] |promise| and stop.
   5. Let |handled| be the result of invoking |handler| given `null`.
   6. If |handled| is [=rejected=], then [=reject=] |promise| and stop.
   7. Otherwise if |handled| [=resolved=] with |value|, let |data| be |value|.
9. For each |observer| in {{ExposedThing/[[propertyObservers]]}}[|name|], run the following sub-steps:
   1. Let |options| be the interaction options saved with |observer|.
   2. Request the underlying platform to create a |reply| from |data| and |options| according to the Protocol Bindings.

      This clause needs expanding and/or refer to an algorithm in [[WOT-PROTOCOL-BINDINGS]].

   3. Send |reply| to |observer|.
10. [=Resolve=] |promise|.

When the method is invoked given |name:string| and |handler:PropertyWriteHandler|, implementations MUST run the following steps:

1. If invoking this method is not allowed for the current scripting context for security reasons, [= exception/throw =] a {{SecurityError}} and stop.
2. If |this|.{{ExposedThing/[[td]]}}.|properties|[|name|] does not [=map/exist=], [= exception/throw =] {{NotFoundError}} and stop.
3. Set |this|.{{ExposedThing/[[writeHandlers]]}}[|name|] to |handler|.

When a network request for writing a Property |name:string| with a new value |value:InteractionOutput| and |options:InteractionOptions| is received, implementations MUST run the following update property steps, given |name|, |value|, |options| and |mode| set to `"single"`:

1. If this operation is not supported, send back a {{NotSupportedError}} according to the Protocol Bindings and stop.
2. If this operation is not allowed, send back a {{NotAllowedError}} according to the Protocol Bindings and stop.
3. Let |interaction| be |this|.{{ExposedThing/[[td]]}}.|properties|[|name|].
4. If |interaction| is `undefined`, return a {{NotFoundError}} in the reply and stop.
5. Let |handler:function| be |this|.{{ExposedThing/[[writeHandlers]]}}[|name|].
6. If |handler| is `undefined` and if there is a default write handler provided by the implementation, let |handler| be that.
7. If |handler| is `undefined`, send back a {{NotSupportedError}} with the reply and stop.
8. Let |promise| be the result of invoking |handler| given |name| and |options|. If it fails, return the error in the reply and stop.
9. If |mode| is `"single"`, reply to the request reporting success, following the Protocol Bindings and stop.

When a network request for writing multiple Properties given in an object |propertyNames| is received with |options:InteractionOptions|, run the following steps:

1. If this operation is not supported, send back a {{NotSupportedError}} according to the Protocol Bindings and stop.
2. If this operation is not allowed, send back a {{NotAllowedError}} according to the Protocol Bindings and stop.
3. For each property with key |name| and value |value| defined in |propertyNames|, run the update property steps with |name|, |value|, |options| and |mode| set to `"multiple"`. If that fails, reply to the request with that error and stop.
4. Reply to the request by sending a single reply according to the Protocol Bindings.

When the method is invoked given |name:string| and |action:ActionHandler|, run the following steps:

1. If invoking this method is not allowed for the current scripting context for security reasons, [= exception/throw =] a {{SecurityError}} and stop.
2. Let |interaction| be |this|.{{ExposedThing/[[td]]}}.|actions|[|name|].
3. If |interaction| is `undefined`, [= exception/throw =] a {{NotFoundError}} and stop.
4. Set |this|.{{ExposedThing/[[actionHandlers]]}}[|name|] to |action|.

When a network request for invoking the Action identified by |name:string| is received given |inputs| and optionally |options:InteractionOptions|, run the following steps:

1. If this operation is not supported, send back a {{NotSupportedError}} according to the Protocol Bindings and stop.
2. If this operation is not allowed, send back a {{NotAllowedError}} according to the Protocol Bindings and stop.
3. Let |interaction| be |this|.{{ExposedThing/[[td]]}}.|properties|[|name|].
4. If |interaction| is `undefined`, return a {{NotFoundError}} in the reply and stop.
5. Let |handler:function| be |this|.{{ExposedThing/[[actionHandlers]]}}[|name|].
6. If |handler| is `undefined`, return a {{NotSupportedError}} with the reply created by following the Protocol Bindings and stop.
7. Let |promise| be the result of invoking |handler| given |name|, |inputs| and |options|.
8. If |promise| rejects, send the error with the reply and stop.
9. When |promise| resolves with |data:InteractionInput|, use |data| to create and send the reply according to the Protocol Bindings.

When the method is invoked given |name:string| and |handler:EventSubscriptionHandler|, run the following steps:

1. If invoking this method is not allowed for the current scripting context for security reasons, [= exception/throw =] a {{SecurityError}} and stop.
2. Let |interaction| be |this|.{{ExposedThing/[[td]]}}.|events|[|name|].
3. If |interaction| is `undefined`, [= exception/throw =] a {{NotFoundError}} and stop.
4. Set |this|.{{ExposedThing/[[subscribeHandlers]]}}[|name|] to |handler|.
5. Return `this`.

When an Event subscription request for |name| is received by the underlying platform with optional |options:InteractionOptions|, run the following steps:

1. If this operation is not supported, send back a {{NotSupportedError}} according to the Protocol Bindings and stop.
2. If this operation is not allowed, send back a {{NotAllowedError}} according to the Protocol Bindings and stop.
3. Let |interaction| be |this|.{{ExposedThing/[[td]]}}.|events|[|name|].
4. If |interaction| is `undefined`, send back a {{NotFoundError}} and stop.
5. If |this|.{{ExposedThing/[[subscribeHandlers]]}}[|name|] is a {{Function}}, invoke it given |options| and stop.
6. Otherwise implement the default subscriber mechanism:
   1. Let |subscriber| be a tuple formed of |options| (from which |uriVariables| and |data| may be used) and the subscriber information needed to create an Event notification response.
   2. Set |this|.{{ExposedThing/[[eventListeners]]}}[|name|] to |subscriber|.

When the method is invoked given |name:string| and |handler:EventSubscriptionHandler|, run the following steps:

1. If invoking this method is not allowed for the current scripting context for security reasons, [= exception/throw =] a {{SecurityError}} and stop.
2. Let |interaction| be |this|.{{ExposedThing/[[td]]}}.|events|[|name|].
3. If |interaction| is `undefined`, [= exception/throw =] a {{NotFoundError}} and stop.
4. Set |this|.{{ExposedThing/[[unsubscribeHandlers]]}}[|name|] to |handler|.
5. Return `this`.

When an Event unsubscribe request for |name| is received by the underlying platform optionally with |options:InteractionOptions|, run the following steps:

1. If this operation is not supported, send back a {{NotSupportedError}} according to the Protocol Bindings and stop.
2. If this operation is not allowed, send back a {{NotAllowedError}} according to the Protocol Bindings and stop.
3. Let |interaction| be |this|.{{ExposedThing/[[td]]}}.|events|[|name|].
4. If |interaction| is `undefined`, send back a {{NotFoundError}} and stop.
5. If |this|.{{ExposedThing/[[unsubscribeHandlers]]}}[|name|] [=map/exists=] and is a {{Function}}, invoke it given |options| and stop.
6. Otherwise |name| [=map/exists] in |this|.{{ExposedThing/[[eventListeners]]}}, [=map/remove=] |name|.
7. Return `this`.

When an Event with name |name| is emitted with |data:InteractionInput| by the emitEvent() method, run the following steps:

1. Let |listeners| be {{ExposedThing/[[eventListeners]]}}.|name|.
2. For each |subscriber| in |listeners|, run the following sub-steps:
   1. Create an Event notification |response| according to the Protocol Bindings from |data| and |subscriber|, including its |options|.
   2. If |data| is `undefined`, assume that the notification |response| will contain an empty data payload as specified by Protocol Bindings.
   3. If the underlying protocol stack permits conveying event errors and if an error condition has been detected by the UA, create |response| as an error notification according to the Protocol Bindings, using |data|, |subscriber| and its |options|.

      The error reporting is protocol specific and it is encapsulated by implementations. On the client end, the error listener passed with the subscription will be invoked if the client UA detects the error.

   4. Send |response| to the subscriber identified by |subscriber|.

Takes as arguments |name:string| denoting an Event name and optionally |data:InteractionInput|. Triggers emitting the Event with the optional data. The method MUST run the following steps:

1. Return a {{Promise}} |promise:Promise| and execute the next steps [=in parallel=].
2. If invoking this method is not allowed for the current scripting context for security reasons, [=reject=] |promise| with a {{SecurityError}} and stop.
3. Let |interaction| be {{ExposedThing/[[td]]}}.|events|.|name|.
4. If an Event with the name |name| is not found, [=reject=] |promise| with {{NotFoundError}} and stop.
5. Make a request to the underlying platform to emit an Event with optional |data|. Call the handling events steps.

Start serving external requests for the Thing, so that WoT Interactions using Properties, Actions and Events will be possible. The method MUST run the following steps:

1. Return a {{Promise}} |promise:Promise| and execute the next steps [=in parallel=].
2. If invoking this method is not allowed for the current scripting context for security reasons, [=reject=] |promise| with a {{SecurityError}} and stop.
3. Run the expand a TD steps on the {{ExposedThing/[[td]]}}.
4. Run the validate a TD on {{ExposedThing/[[td]]}}. If that fails, [=reject=] |promise| with a {{TypeError}} and stop.
5. For each |key| in {{ExposedThing/[[td]]}}.|properties| initialize |this|.{{ExposedThing/[[propertyObservers]]}}.|key| to an empty {{Array}} in order to store observe request data needed to notify the observers on value changes.
6. For each |key| in |this|.{{ExposedThing/[[td]]}}.|events| initialize |this|.{{ExposedThing/[[eventListeners]]}}.|key| to an empty {{Array}} in order to store subscribe request data needed to notify the subscribers on event emission.
7. Set up the WoT Interactions based on introspecting {{ExposedThing/[[td]]}} as explained in [[!WOT-TD]] and [[!WOT-PROTOCOL-BINDINGS]]. Make a request to the underlying platform to initialize the Protocol Bindings and then start serving external requests for WoT Interactions (read, write and observe Properties, invoke Actions and manage Event subscriptions), based on the Protocol Bindings. Implementations MAY reject this step for any reason (e.g. if they want to enforce further checks and constraints on interaction forms).
8. If there was an error during the request, [=reject=] |promise| with an {{Error}} object |error| with |error|.|message| set to the error code seen by the Protocol Bindings and stop.
9. Otherwise [=resolve=] |promise| and stop.

Stop serving external requests for the Thing and destroy the object. Note that eventual unregistering should be done before invoking this method. The method MUST run the following steps:

1. Return a {{Promise}} |promise:Promise| and execute the next steps [=in parallel=].
2. If invoking this method is not allowed for the current scripting context for security reasons, [=reject=] |promise| with a {{SecurityError}} and stop.
3. Make a request to the underlying platform to stop serving external requests for WoT Interactions, based on the Protocol Bindings.
4. If there was an error during the request, [=reject=] |promise| with an {{Error}} object |error| with its |message| set to the error code seen by the Protocol Bindings and stop.
5. Otherwise [=resolve=] |promise| and stop.

To create {{ThingDiscoveryProcess}} with a |filter:ThingFilter|, run the following steps:

1. If |filter| is not an object or `null`, [= exception/throw =] a {{TypeError}} and stop.
2. Let |discovery:ThingDiscoveryProcess| be a new {{ThingDiscoveryProcess}} object.
3. Set |discovery|.{{ThingDiscoveryProcess/[[filter]]}} to |filter|.
4. Set |discovery|.{{ThingDiscoveryProcess/done}} to `false`.
5. Set |discovery|.{{ThingDiscoveryProcess/error}} to `null`.
6. Return |discovery|.

Describes what to do during a discovery process that has already started. The algorithm, given |discovery:ThingDiscoveryProcess|, runs the following steps:

1. Whenever a new |link| to a Thing Description is discovered and provided by the underlying platform, run the following sub-steps:
   1. Retrieve |td:ThingDescription| as a JSON object, using the Protocol Binding used by the underlying discovery process (as specified by |link|). In the case of an HTTP(S) Binding, this process could use the Fetch API for the |td|'s retrieval.
   2. If that fails, set the |discovery|.{{ThingDiscoveryProcess/error}} property to {{SyntaxError}}, discard |td| and continue the discovery process.
2. Whenever a Thing Description |td| is discovered and provided by the underlying platform or by the previous step, run the following sub-steps:

   At this point implementations MAY control the flow of the discovery process (depending on memory constraints, for instance queue the results, or temporarily stop discovery if the queue is getting too large, or resume discovery when the queue is emptied sufficiently). These steps are run for each discovered/fetched |td|.

   1. Let |fragment| be |discovery|.{{ThingDiscoveryProcess/[[filter]]}}.{{ThingFilter/fragment}}.
   2. If |fragment| is an {{object}}, then for each |key| defined in it:
      1. Check if that |key| [=map/exists=] in |json| and |json|[|key| is equal to |fragment|.|key|.
      2. If this is fails in any checks, discard |td| and continue the discovery process.
   3. Yield |td| using {{Symbol/asyncIterator}}.

      Improve this step using proper asyncIterator terminology.

3. Whenever an error occurs during the discovery process, run the following sub-steps:

   The last error is retained. Implementations MAY choose to stop the discovery process if they consider it should be reported.

   1. Let |error| be a new {{Error}} object. Set |error|.|name| to `"DiscoveryError"`.
   2. If there was an error code or message provided by the Protocol Bindings, set |error|.|message| to that value as string.
   3. Set |discovery|.{{ThingDiscoveryProcess/error}} to |error|.
   4. If the error is irrecoverable and discovery has been stopped by the underlying platform, or if the implementation decided to stop the discovery process and report the error, set |discovery|.{{ThingDiscoveryProcess/done}} to `true` and terminate these steps.

Stops or suppresses the discovery process. It might not be supported by all discovery methods and endpoints, however, any further discovery results or errors will be discarded and the discovery is marked as done. The method MUST run the following steps:

1. If invoking this method is not allowed for the current scripting context for security reasons, [= exception/throw =] a {{SecurityError}} and stop.
2. Request the underlying platform to stop the discovery process. If this returns an error, or if it is not possible, for instance when discovery is based on open ended multicast requests, the implementation SHOULD discard subsequent discovered items.
3. Set the {{ThingDiscoveryProcess/done}} property to `true`.