Web of Things (WoT) Scripting API

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

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

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

1. If JSON Schema validation fails on td, throw a "TypeError" and stop.

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

Belongs to the WoT Consumer conformance class. Expects an td 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 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 be a new ConsumedThing object constructed from td.
4. Set up the WoT Interactions based on introspecting td as explained in [wot-thing-description11] and [wot-binding-templates]. Make a request to the underlying platform to initialize the Protocol Bindings.
   Editor's note

   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.

WebIDLtypedef object ExposedThingInit;

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

Belongs to the WoT Producer conformance class. Expects a init 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 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-architecture11]. 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 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 be a new ExposedThing object constructed with init.
4. Resolve promise with thing.

WebIDLpartial 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 argument of type ThingFilter. The method MUST run the following steps:

1. Return a 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 be a new ThingDiscoveryProcess object.
5. Set discovery.[[filter]] to filter.
6. Set discovery.[[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.

Note that the details of the discovery process depend on the underlying implementation which needs to be preconfigured in order to use, for example, the appropriate Introduction methods as defined in the Web of Things (WoT) Discovery specification. Since the discover() method outputs Thing Descriptions and not URLs, it is expected to cover both the Introduction and the Exploration phase.

WebIDLpartial 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 argument of type ThingFilter. The method MUST run the following steps:

1. Return a 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 be a new ThingDiscoveryProcess object.
5. Set discovery.[[url]] to url.
6. Set discovery.[[filter]] to filter.
7. Request the underlying platform to start the directory discovery process.
   Note

   This is a placeholder for more details in the discovery algorithm. Implementations should follow the procedures described in the [wot-discovery] and [wot-binding-templates] 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.
      Note

      From this point on, errors are recorded only on error, but don't affect promise any longer.

8. Resolve promise with discovery.

WebIDLpartial 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 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 requesting a Thing Description is not supported by the implementation, reject promise with NotSupportedError and stop.
4. Let td 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, run the following steps:

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

Reads a Property value. Takes as arguments propertyName and optionally options. 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 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 [[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 and optionally options. 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 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 [[td]].forms array, otherwise let form be the Form in [[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 be an object and for each string name 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.[[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 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 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.[[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.[[form]] to forms.[formIndex].
6. Otherwise, set subscription.[[form]] to a Form in forms whose op is "readallproperties", as selected by the implementation.
7. If 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 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.[[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, value and optionally options. It returns a Promise that resolves on success and rejects on failure. The method MUST run the following steps:

1. Return a 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.[[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 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 - as an object with keys being Property names and values as Property values - and optionally options. It returns a Promise that resolves on success and rejects on failure. The method MUST run the following steps:

1. Return a 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 [[td]].forms array, otherwise let form be a Form in [[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 in propertyNames, let property be this.[[td]].properties[name].
7. If property is null or undefined or is not writeable reject promise with NotSupportedError and stop.
8. Let result be an object and for each string name in propertyNames add a property with key name and let its value be null.
9. Let schemas be an object and for each name in propertyNames add a property with key name and let its value be this.[[td]].properties[name].
10. For each key key 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, listener and optionally onerror and options. It returns a Promise that resolves on success and rejects on failure. The method MUST run the following steps:

1. Let thing be the reference of this ConsumedThing object.
2. Return a 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.[[activeObservations]][propertyName] 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.[[type]] be "property".
   • Let subscription.[[name]] be propertyName.
   • Let subscription.[[interaction]] be [[td]].properties[propertyName].
   • Let subscription.[[thing]] be thing.
   • Let forms be 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.[[form]] to forms.[formIndex].
   • Otherwise, set subscription.[[form]] to a Form in forms whose op is "observeproperty", as selected by the implementation.
   • If subscription.[[form]] is failure, reject promise with a SyntaxError and stop.
   • If 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. Set thing.[[activeObservations]][|propertyName] to subscription and resolve promise.
11. Whenever the underlying platform detects a notification for this subscription 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.[[form]] and 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, optionally params and optionally options. It returns a Promise that resolves with the result of the Action represented as an ActionInteractionOutput object, or rejects with an error. The method MUST run the following steps:

1. Return a 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.[[td]].actions[actionName].
4. If interaction is not an object, reject promise with a NotFoundError and stop.
5. Let forms be 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.[[form]] to forms.[formIndex].
8. Otherwise, set subscription.[[form]] to a Form in forms whose op is "invokeaction", as selected by the implementation.
9. If 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, listener and optionally onerror and options. It returns a Promise to signal success or failure. The method MUST run the following steps:

1. Let thing be the reference of this ConsumedThing object.
2. Return a 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.[[activeSubscriptions]][eventName] 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.[[type]] be "event".
   • Let subscription.[[name]] be eventName.
   • Let subscription.[[interaction]] be thing. [[td]].events[eventName].
   • If subscription.[[interaction]] is undefined, reject promise with a NotFoundError and stop.
   • Let subscription.[[thing]] be thing.
   • If options.formIndex exists, then let subscription.[[form]] be thing.[[interaction]].forms[formIndex].
   • Otherwise, let subscription.[[form]] be an implementation-defined Form from the subscription.[[interaction]].forms array whose op is "subscribeevent".
   • If subscription.[[form]] does not 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 with [[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. Set eventName to thing.[[activeSubscriptions]][eventName] to subscription.
11. Resolve promise.
12. Whenever the underlying platform detects a notification for the Event subscription 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.[[form]] and subscription.[[interaction]].
13. Whenever the underlying platform detects an error for Event subscription 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 create an ExposedThing with the ExposedThingInit init, run the following steps:

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

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

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

When a network request for reading Property name is received by the implementation with options, 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 and options:
   1. Let interaction be [[td]].properties.name.
   2. If a Property with name does not exist, throw NotFoundError and stop.
   3. Let handler be null.
   4. If there is a user provided PropertyReadHandler in [[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.
      Note

      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, 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, 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 and handler, implementations MUST run the following steps:

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

When a network request for observing a Property name is received by the implementation with options, 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.[[td]].properties[name] does not exist, send back a NotFoundError in the reply and stop.
4. Internally save the request sender information together with options and this.[[propertyObservers]][name], in order to be able to notify about Property value changes.

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

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

When a network request for unobserving a Property name with options 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.[[td]].properties[name] does not exist, send back a NotFoundError in the reply and stop.
4. Let handler be this.[[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.[[propertyObservers]][name] exists, remove it from this.[[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 argument, denoting a Property name, and optionally the data 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 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.[[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 be null.
   2. If name does not exist in [[readHandlers]], reject promise and stop.
   3. Let handler be [[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 [[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.
      Editor's note

      This clause needs expanding and/or refer to an algorithm in [wot-binding-templates].

   3. Send reply to observer.
10. Resolve promise.

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

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

When a network request for writing a Property name with a new value value and options 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.[[td]].properties[name].
4. If interaction is undefined, return a NotFoundError in the reply and stop.
5. Let handler be this.[[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, 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 and action, run the following steps:

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

When a network request for invoking the Action identified by name is received given inputs and optionally options, 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.[[td]].properties[name].
4. If interaction is undefined, return a NotFoundError in the reply and stop.
5. Let handler be this.[[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, use data to create and send the reply according to the Protocol Bindings.

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

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

When an Event subscription request for name is received by the underlying platform with optional options, 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.[[td]].events[name].
4. If interaction is undefined, send back a NotFoundError and stop.
5. If this.[[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.[[eventListeners]][name] to subscriber.

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

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

When an Event unsubscribe request for name is received by the underlying platform optionally with options, 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.[[td]].events[name].
4. If interaction is undefined, send back a NotFoundError and stop.
5. If this.[[unsubscribeHandlers]][name] exists and is a Function, invoke it given options and stop.
6. Otherwise name [=map/exists] in this.[[eventListeners]], remove name.
7. Return this.

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

1. Let listeners be [[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.
      Note

      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 denoting an Event name and optionally data. Triggers emitting the Event with the optional data. The method MUST run the following steps:

1. Return a 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 [[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 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 [[td]].
4. Run the validate a TD on [[td]]. If that fails, reject promise with a TypeError and stop.
5. For each key in [[td]].properties initialize this.[[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.[[td]].events initialize this.[[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 [[td]] as explained in [wot-thing-description11] and [wot-binding-templates]. 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 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, run the following steps:

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

Describes what to do during a discovery process that has already started. The algorithm, given discovery, 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 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.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:
   Note

   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.[[filter]].fragment.
   2. If fragment is an object, then for each key defined in it:
      1. Check if that key 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 asyncIterator.
      Editor's note

      Improve this step using proper asyncIterator terminology.

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

   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.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.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, 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 done property to true.