Clarify structured clone behavior for WebAssembly objects.

Author: flagxor

JS.md

@@ -164,7 +164,7 @@ with the resulting `WebAssembly.Instance` object. On failure, the `Promise` is
 A `WebAssembly.Module` object represents the stateless result of compiling a
 WebAssembly binary-format module and contains one internal slot:
 
- * [[Module]] : an [`Ast.module`](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/ast.ml#L176)
+ * [[WebAssembly.Module]] : an [`Ast.module`](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/ast.ml#L176)
    which is the spec definition of a module
 
 ### `WebAssembly.Module` Constructor
@@ -190,7 +190,7 @@ Otherwise, this function performs synchronous compilation of the `BufferSource`:
    according to the rules in [spec/valid.ml](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/valid.ml#L415).
 1. The spec `string` values inside `Ast.module` are decoded as UTF8 as described in 
    [Web.md](Web.md#names).
-1. On success, a new `WebAssembly.Module` object is returned with [[Module]] set to
+1. On success, a new `WebAssembly.Module` object is returned with [[WebAssembly.Module]] set to
    the validated `Ast.module`.
 1. On failure, a new `WebAssembly.CompileError` is thrown.
 
@@ -214,7 +214,7 @@ is thrown.
 
 This function returns a new `Array` every time it is called. Each such `Array` is produced by mapping each
 [`Ast.export`](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/ast.ml#L152)
-`e` of [moduleObject.[[Module]].exports](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/ast.ml#L187)
+`e` of [moduleObject.[[WebAssemby.Module]].exports](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/ast.ml#L187)
 to the Object `{ name: String(e.name), kind: e.ekind }` where `e.name` is [decoded as UTF8](Web.md#names)
 and `e.ekind` is mapped to one of the String values `"function"`, `"table"`, `"memory"`, `"global"`.
 
@@ -235,7 +235,7 @@ is thrown.
 
 This function returns a new `Array` every time it is called. Each such `Array` is produced by mapping each
 [`Ast.import`](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/ast.ml#L167)
-`i` of [moduleObject.[[Module]].imports](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/ast.ml#L203)
+`i` of [moduleObject.[[WebAssembly.Module]].imports](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/ast.ml#L203)
 to the Object `{ module: String(i.module_name), name: String(i.item_name), kind: i.ikind }` where
 `i.module_name` and `i.item_name` are  [decoded as UTF8](Web.md#names) and
 `i.ikind` is mapped to one of the String values `"function"`, `"table"`, `"memory"`, `"global"`.
@@ -265,22 +265,6 @@ This function returns a new `Array` every time it is called. Each such `Array` i
 
 The `Array` is populated in the same order custom sections appear in the WebAssembly binary.
 
-### Structured Clone of a `WebAssembly.Module`
-
-A `WebAssembly.Module` is a
-[cloneable object](https://html.spec.whatwg.org/multipage/infrastructure.html#cloneable-objects)
-which means it can be cloned between windows/workers and also
-stored/retrieved into/from an [IDBObjectStore](https://w3c.github.io/IndexedDB/#object-store).
-The semantics of a structured clone is as-if the binary source, from which the
-`WebAssembly.Module` was compiled, were cloned and recompiled into the target realm.
-Engines should attempt to share/reuse internal compiled code when performing
-a structured clone although, in corner cases like CPU upgrade or browser
-update, this may not be possible and full recompilation may be necessary.
-
-Given the above engine optimizations, structured cloning provides developers
-explicit control over both compiled-code caching and cross-window/worker code
-sharing.
-
 ## `WebAssembly.Instance` Objects
 
 A `WebAssembly.Instance` object represents the instantiation of a 
@@ -308,7 +292,7 @@ If `moduleObject` is not a `WebAssembly.Module`, a [`TypeError`](https://tc39.gi
 is thrown.
 
 Let `module` be the [`Ast.module`](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/ast.ml#L176)
-`moduleObject.[[Module]]`.
+`moduleObject.[[WebAssembly.Module]]`.
 
 If the `importObject` parameter is not `undefined` and `Type(importObject)` is
 not Object, a [`TypeError`](https://tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror)
@@ -366,7 +350,7 @@ For each [`import`](https://github.com/WebAssembly/spec/blob/master/interpreter/
       [`memory_type`](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#memory_type)
       by `Eval.init` below.)
    1. Append `v` to `memories`.
-   1. Append `v.[[Memory]]` to `imports`.
+   1. Append `v.[[WebAssembly.Memory]]` to `imports`.
 1. Otherwise (`i` is a table import):
    1. If `v` is not a [`WebAssembly.Table` object](#webassemblytable-objects),
       throw a `WebAssembly.LinkError`.
@@ -441,7 +425,7 @@ each [external](https://github.com/WebAssembly/spec/blob/master/interpreter/spec
    1. If `v` is an `i64`, throw a `WebAssembly.LinkError`.
    1. Return [`ToJSValue`](#tojsvalue)`(v)`.
 1. If `e` is a [memory](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/instance.ml#L14) `m`:
-   1. If there is an element `memory` in `memories` whose `memory.[[Memory]]` is `m`, then return `memory`.
+   1. If there is an element `memory` in `memories` whose `memory.[[WebAssembly.Memory]]` is `m`, then return `memory`.
    1. (Note: At most one `WebAssembly.Memory` object is created for any memory, so the above `memory` is unique, even if there are multiple occurrances in the list. Moreover, if the item was an import, the original object will be found.)
    1. Otherwise:
       1. Let `memory` be a new `WebAssembly.Memory` object created via [`CreateMemoryObject`](#creatememoryobject) from `m`.
@@ -532,9 +516,9 @@ A `WebAssembly.Memory` object contains a single [linear memory](Semantics.md#lin
 which can be simultaneously referenced by multiple `Instance` objects. Each
 `Memory` object has two internal slots:
 
- * [[Memory]] : a [`Memory.memory`](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/memory.mli)
- * [[BufferObject]] : the current `ArrayBuffer` whose [[ArrayBufferByteLength]]
-   matches the current byte length of [[Memory]]
+ * [[WebAssembly.Memory]] : a [`Memory.memory`](https://github.com/WebAssembly/spec/blob/master/interpreter/spec/memory.mli)
+ * [[BufferObject]] : the current `ArrayBuffer` or `SharedArrayBuffer` whose [[ArrayBufferByteLength]]
+   matches the current byte length of [[WebAssembly.Memory]]
 
 ### `WebAssembly.Memory` Constructor
 
@@ -579,7 +563,7 @@ Any attempts to [`detach`](http://tc39.github.io/ecma262/#sec-detacharraybuffer)
 the detachment performed by [`m.grow`](#webassemblymemoryprototypegrow) shall throw a 
 [`TypeError`](https://tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror)
 
-Return a new `WebAssembly.Memory` instance with [[Memory]] set to `m` and
+Return a new `WebAssembly.Memory` instance with [[WebAssembly.Memory]] set to `m` and
 [[BufferObject]] set to `buffer`.
 
 ### `WebAssembly.Memory.prototype [ @@toStringTag ]` Property
@@ -614,9 +598,9 @@ Perform [`DetachArrayBuffer`](http://tc39.github.io/ecma262/#sec-detacharraybuff
 
 Assign to `M.[[BufferObject]]` a new `ArrayBuffer` whose
 [[[ArrayBufferData]]](http://tc39.github.io/ecma262/#sec-properties-of-the-arraybuffer-prototype-object)
-aliases `M.[[Memory]]` and whose 
+aliases `M.[[WebAssembly.Memory]]` and whose
 [[[ArrayBufferByteLength]]](http://tc39.github.io/ecma262/#sec-properties-of-the-arraybuffer-prototype-object)
-is set to the new byte length of `M.[[Memory]]`.
+is set to the new byte length of `M.[[WebAssembly.Memory]]`.
 
 Return `ret` as a Number value.
 

Web.md

@@ -124,6 +124,103 @@ MIME type mismatch or `opaque` response types
 [reject](http://tc39.github.io/ecma262/#sec-rejectpromise) the Promise with a
 `WebAssembly.CompileError`.
 
+### Structured serialization of a `WebAssembly.Memory`
+
+A `WebAssembly.Memory` is a
+[serializable object](https://html.spec.whatwg.org/multipage/infrastructure.html#serializable-objects), and will require changes to the
+[HTML Standard](https://html.spec.whatwg.org/multipage/infrastructure.html#serialization-steps) as follows:
+
+[StructuredSerializeInternal](https://html.spec.whatwg.org/multipage/infrastructure.html#structuredserializeinternal) adds a new step after step 12:
+
+* Otherwise, if *value* has a [[WebAssembly.Memory]] internal slot, then:
+  1. Let *size* be the number value.[[BufferObject]].[[ArrayBufferByteLength]].
+  2. If ! [IsSharedArrayBuffer](https://tc39.github.io/ecma262/#sec-issharedarraybuffer)(*value*.[[BufferObject]]) is true, then:
+    1. If *forStorage* is true, then throw a
+       "`[DataCloneError](https://heycam.github.io/webidl/#datacloneerror)`"
+       `[DOMException](https://heycam.github.io/webidl/#dfn-DOMException)`.
+    2. Otherwise:
+       1. Set *serialized* to { [[Type]]: "WebAssembly.Memory",
+          [[ArrayBufferData]]: value.[[BufferObject]].[[ArrayBufferData]],
+          [[ArrayBufferByteLength]]: size,
+          [[AgentCluster]]: the [current Realm Record](https://tc39.github.io/ecma262/#current-realm)'s corresponding [agent cluster](https://tc39.github.io/ecma262/#sec-agent-clusters) }.
+       2. Otherwise:
+         1. Let *dataCopy* be [CreateByteDataBlock](https://tc39.github.io/ecma262/#sec-createbytedatablock)(size).
+            NOTE: This can throw a RangeError exception on allocation failure.
+         2. Perform [CopyDataBlockBytes](https://tc39.github.io/ecma262/#sec-copydatablockbytes)
+            (dataCopy, 0,
+            value.[[BufferObject]].[[ArrayBufferData]], 0, size).
+         3. Set *serialized* to { [[Type]]: "WebAssembly.Memory",
+            [[ArrayBufferData]]: dataCopy, [[ArrayBufferByteLength]]: size }.
+
+[StructuredDeserialize](https://html.spec.whatwg.org/multipage/infrastructure.html#structureddeserialize) adds a new step after step 12:
+
+* Otherwise, if *serialized*.[[Type]] is "WebAssembly.Memory", then:
+  1. If *targetRealm*'s corresponding [agent cluster](https://tc39.github.io/ecma262/#sec-agent-clusters) is not
+     *serialized*.[[AgentCluster]], then throw a
+     "`[DataCloneError](https://heycam.github.io/webidl/#datacloneerror)`"
+     `[DOMException](https://heycam.github.io/webidl/#dfn-DOMException)`.
+  2. Otherwise,
+     if ! [IsSharedArrayBuffer](https://tc39.github.io/ecma262/#sec-issharedarraybuffer)(*serialized*.[[ArrayBufferData]]) is true, then:
+     Set *value* to a new WebAssembly.Memory object in *targetRealm*
+     whose [[BufferObject]] internal slot is set to a new
+     [[ArrayBufferData]] internal slot value is
+     set to a new `SharedArrayBuffer`, where:
+     1. The `SharedArrayBuffer`'s internal slot [[ArrayBufferData]]
+        if set to *serialized*.[[BufferObject]].[[ArrayBufferData]].
+     2. The `SharedArrayBuffer`'s internal slot [[ArrayBufferByteLength]]
+        is set to *serialized*.[[BufferObject]].[[ArrayBufferByteLength]].
+  3. Otherwise,
+     Set *value* to a new WebAssembly.Memory object in *targetRealm*
+     whose [[BufferObject]] internal slot is set to a new
+     [[ArrayBufferData]] internal slot value is
+     set to a new `ArrayBuffer` *mem*, where:
+     1. *mem*'s internal slot [[ArrayBufferData]]
+        is set to *serialized*.[[BufferObject]].[[ArrayBufferData]].
+     2. *mem*'s internal slot [[ArrayBufferByteLength]]
+        is set to *serialized*.[[BufferObject]].[[ArrayBufferByteLength]].
+
+
+### Structured serialization of a `WebAssembly.Module`
+
+A `WebAssembly.Module` is a
+[serializable object](https://html.spec.whatwg.org/multipage/infrastructure.html#serializable-objects), and will require changes to the
+[HTML Standard](https://html.spec.whatwg.org/multipage/infrastructure.html#serialization-steps) as follows:
+
+[StructuredSerializeInternal](https://html.spec.whatwg.org/multipage/infrastructure.html#structuredserializeinternal) adds a new step after step 12:
+
+* Otherwise, if *value* has a [[WebAssembly.Module]] internal slot, then:
+  1. If *forStorage* is true and the relevant settings
+     object of *value* is not "Secure" per the
+     ["Is the environment settings object a secure context?"](https://w3c.github.io/webappsec-secure-contexts/#settings-object)
+     algorithm, throw a
+     "`[DataCloneError](https://heycam.github.io/webidl/#datacloneerror)`"
+     `[DOMException](https://heycam.github.io/webidl/#dfn-DOMException)`.
+  2. Otherwise:
+     Set *serialized* to { [[Type]]: "WebAssembly.Module",
+     [[Module]]: value.[[Module]],
+     [[AgentCluster]]: the [current Realm Record](https://tc39.github.io/ecma262/#current-realm)'s corresponding [agent cluster](https://tc39.github.io/ecma262/#sec-agent-clusters) }.
+
+[StructuredDeserialize](https://html.spec.whatwg.org/multipage/infrastructure.html#structureddeserialize) adds a new step after step 12:
+
+* Otherwise, if *serialized*.[[Type]] is "WebAssembly.Module", then:
+  1. If *targetRealm*'s corresponding [agent cluster](https://tc39.github.io/ecma262/#sec-agent-clusters) is not
+     *serialized*.[[AgentCluster]], then throw a
+     "`[DataCloneError](https://heycam.github.io/webidl/#datacloneerror)`"
+     `[DOMException](https://heycam.github.io/webidl/#dfn-DOMException)`.
+  2. Otherwise, set *value* to a new WebAssembly.Module object in *targetRealm*
+     whose [[Module]] internal slot value is *serialized*.[[Module]].
+
+The semantics of a structured serialization is as-if the binary source, from which the
+`WebAssembly.Module` was compiled, is serialized, then deserialized, and recompiled into the target realm.
+Engines should attempt to share/reuse internal compiled code when performing
+a structured seraialization, although in corner cases like CPU upgrade or browser
+update, this may not be possible and full recompilation may be necessary.
+
+Given the above engine optimizations, structured serialization provides developers
+explicit control over both compiled-code caching and cross-window/worker code
+sharing.
+
+
 ## Developer-facing display conventions
 
 Browsers, JavaScript engines, and offline tools have common ways of referring to