From 4400af71623c6906243c26bb78cc1a53b69a4fe1 Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Wed, 10 Apr 2024 15:31:28 +0200
Subject: [PATCH 01/24] formalize component value definitions

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Binary.md    |  75 ++++++++++++++++-
 design/mvp/Explainer.md | 175 ++++++++++++++++++++++++++++++++++++----
 2 files changed, 233 insertions(+), 17 deletions(-)

diff --git a/design/mvp/Binary.md b/design/mvp/Binary.md
index 550b9c43..750cb1b3 100644
--- a/design/mvp/Binary.md
+++ b/design/mvp/Binary.md
@@ -36,6 +36,7 @@ section   ::=    section_0(<core:custom>)         => ϵ
             | s: section_9(<start>)               => [s]
             | i*:section_10(vec(<import>))        => i*
             | e*:section_11(vec(<export>))        => e*
+            | v*:section_12(vec(<value>))         => v* 🪙
 ```
 Notes:
 * Reused Core binary rules: [`core:section`], [`core:custom`], [`core:module`]
@@ -218,12 +219,14 @@ importdecl    ::= in:<importname'> ed:<externdesc>        => (import in ed)
 exportdecl    ::= en:<exportname'> ed:<externdesc>        => (export en ed)
 externdesc    ::= 0x00 0x11 i:<core:typeidx>              => (core module (type i))
                 | 0x01 i:<typeidx>                        => (func (type i))
-                | 0x02 t:<valtype>                        => (value t) 🪙
+                | 0x02 b:<valuebound>                     => (value b) 🪙
                 | 0x03 b:<typebound>                      => (type b)
                 | 0x04 i:<typeidx>                        => (component (type i))
                 | 0x05 i:<typeidx>                        => (instance (type i))
 typebound     ::= 0x00 i:<typeidx>                        => (eq i)
                 | 0x01                                    => (sub resource)
+valuebound    ::= 0x00 i:<valueidx>                       => (eq i) 🪙
+                | 0x01 t:<valtype>                        => t 🪙
 ```
 Notes:
 * The type opcodes follow the same negative-SLEB128 scheme as Core WebAssembly,
@@ -350,6 +353,64 @@ Notes:
 * `<integrity-metadata>` is as defined by the
   [SRI](https://www.w3.org/TR/SRI/#dfn-integrity-metadata) spec.
 
+## 🪙 Value Definitions
+
+(See [Value Definitions](Explainer.md#value-definitions) in the explainer.)
+
+```ebnf
+value                      ::= t:<valtype> v:<val(t)>                  => (value t v)
+val(bool)                  ::= 0x00                                    => false
+                             | 0x01                                    => true
+val(u8)                    ::= v:<core:u8>                             => v
+val(s8)                    ::= v:<core:s8>                             => v
+val(s16)                   ::= v:<core:s16>                            => v
+val(u16)                   ::= v:<core:u16>                            => v
+val(s32)                   ::= v:<core:s32>                            => v
+val(u32)                   ::= v:<core:u32>                            => v
+val(s64)                   ::= v:<core:s64>                            => v
+val(u64)                   ::= v:<core:u64>                            => v
+val(f32)                   ::= v:<core:f32>                            => v (if !isnan(v))
+                             | 0x00 0x00 0xC0 0x7F                     => nan
+val(f64)                   ::= v:<core:f64>                            => v (if !isnan(v))
+                             | 0x00 0x00 0x00 0x00 0x00 0x00 0xF8 0x7F => nan
+val(char)                  ::= v:<core:u32>                            => v (if v < 0xD800 or 0xE000 <= v <= 0x10FFFF)
+val(string)                ::= v:<core:name>                           => v
+val(i:<typeidx>)           ::= v:<val(type-index-space[i])>            => v
+val((record (field l t)+)) ::= v+:<val(t)>+                            => (record v+)
+val((variant (case l t?)+) ::= i:<core:u32> v?:<val(t[i])>?            => (variant l[i] v?)
+val((list t))              ::= v:vec(<val(t)>)                         => (list v)
+val((tuple t+))            ::= v+:<val(t)>+                            => (tuple v+)
+val((flags l+))            ::= v:<core:uN>                             => (flags (l[i] for i in 0..N-1 if v & 2^i > 0)) (where N = |l+|)
+val((enum l+))             ::= i:<core:u32>                            => (enum l[i])
+val((option t))            ::= 0x00                                    => none
+                             | 0x01 v:<val(t)>                         => (some v)
+val((result))              ::= 0x00                                    => ok
+                             | 0x01                                    => error
+val((result t))            ::= 0x00 v:<val(t)>                         => (ok v)
+                             | 0x01                                    => error
+val((result (error u)))    ::= 0x00                                    => ok
+                             | 0x01 v:<val(u)>                         => (error v)
+val((result t (error u)))  ::= 0x00 v:<val(t)>                         => (ok v)
+                             | 0x01 v:<val(u)>                         => (error v)
+```
+
+Notes:
+* Reused Core binary rules:
+    - [`core:name`]
+    - [`core:s8`]
+    - [`core:s16`]
+    - [`core:s32`]
+    - [`core:s64`]
+    - [`core:u8`]
+    - [`core:u16`]
+    - [`core:u32`]
+    - [`core:u64`]
+    - [`core:uN`]
+    - [`core:f32`]
+    - [`core:f64`]
+* `&` operator is used to denote bitwise AND operation, which performs AND on every bit of two numbers in their binary form
+* `isnan` is a function, which takes a floating point number as a parameter and returns `true` iff it represents a NaN as defined in [IEEE 754 standard]
+
 ## Name Section
 
 Like the core wasm [name
@@ -379,7 +440,17 @@ appear once within a `name` section, for example component instances can only be
 named once.
 
 
+[`core:s8`]: https://webassembly.github.io/spec/core/binary/values.html#integers
+[`core:u8`]: https://webassembly.github.io/spec/core/binary/values.html#integers
+[`core:s16`]: https://webassembly.github.io/spec/core/binary/values.html#integers
+[`core:u16`]: https://webassembly.github.io/spec/core/binary/values.html#integers
+[`core:s32`]: https://webassembly.github.io/spec/core/binary/values.html#integers
 [`core:u32`]: https://webassembly.github.io/spec/core/binary/values.html#integers
+[`core:s64`]: https://webassembly.github.io/spec/core/binary/values.html#integers
+[`core:u64`]: https://webassembly.github.io/spec/core/binary/values.html#integers
+[`core:uN`]: https://webassembly.github.io/spec/core/binary/values.html#integers
+[`core:f32`]: https://webassembly.github.io/spec/core/binary/values.html#floating-point
+[`core:f64`]: https://webassembly.github.io/spec/core/binary/values.html#floating-point
 [`core:section`]: https://webassembly.github.io/spec/core/binary/modules.html#binary-section
 [`core:custom`]: https://webassembly.github.io/spec/core/binary/modules.html#custom-section
 [`core:module`]: https://webassembly.github.io/spec/core/binary/modules.html#binary-module
@@ -391,3 +462,5 @@ named once.
 
 [type-imports]: https://github.com/WebAssembly/proposal-type-imports/blob/master/proposals/type-imports/Overview.md
 [module-linking]: https://github.com/WebAssembly/module-linking/blob/main/proposals/module-linking/Explainer.md
+
+[IEEE 754 standard]: https://ieeexplore.ieee.org/document/8766229
diff --git a/design/mvp/Explainer.md b/design/mvp/Explainer.md
index d7b6f2a6..bf47dbce 100644
--- a/design/mvp/Explainer.md
+++ b/design/mvp/Explainer.md
@@ -23,7 +23,8 @@ JavaScript runtimes. For a more user-focused explanation, take a look at the
   * [Canonical definitions](#canonical-definitions)
     * [Canonical ABI](#canonical-built-ins)
     * [Canonical built-ins](#canonical-built-ins)
-  * [Start definitions](#-start-definitions)
+  * [Value definitions](#value-definitions)
+  * [Start definitions](#start-definitions)
   * [Import and export definitions](#import-and-export-definitions)
 * [Component invariants](#component-invariants)
 * [JavaScript embedding](#JavaScript-embedding)
@@ -87,6 +88,7 @@ definition ::= core-prefix(<core:module>)
              | <start> 🪺
              | <import>
              | <export>
+             | <value> 🪙
 
 where core-prefix(X) parses '(' 'core' Y ')' when X parses '(' Y ')'
 ```
@@ -296,7 +298,7 @@ contain any valid UTF-8 string).
 
 🪙 The `value` sort refers to a value that is provided and consumed during
 instantiation. How this works is described in the
-[start definitions](#start-definitions) section.
+[value definitions](#value-definitions) section.
 
 To see a non-trivial example of component instantiation, we'll first need to
 introduce a few other definitions below that allow components to import, define
@@ -568,10 +570,12 @@ externdesc    ::= (<sort> (type <u32>) )
                 | <functype>
                 | <componenttype>
                 | <instancetype>
-                | (value <valtype>) 🪙
+                | (value <valuebound>) 🪙
                 | (type <typebound>)
 typebound     ::= (eq <typeidx>)
                 | (sub resource)
+valuebound    ::= (eq <valueidx>) 🪙
+                | <valtype> 🪙
 
 where bind-id(X) parses '(' sort <id>? Y ')' when X parses '(' sort Y ')'
 ```
@@ -737,7 +741,7 @@ definitions.
 
 🪙 The `value` case of `externdesc` describes a runtime value that is imported or
 exported at instantiation time as described in the
-[start definitions](#start-definitions) section below.
+[value definitions](#value-definitions) section below.
 
 The `type` case of `externdesc` describes an imported or exported type along
 with its "bound":
@@ -1355,22 +1359,100 @@ number of threads that can be expected to execute concurrently.
 See the [CanonicalABI.md](CanonicalABI.md#canonical-definitions) for detailed
 definitions of each of these built-ins and their interactions.
 
+### 🪙 Value Definitions
 
-### 🪙 Start Definitions
+Value definitions (in the value index space) are like immutable `global` definitions
+in Core WebAssembly except that validation requires them to be consumed exactly
+once at instantiation-time (i.e., they are [linear]).
+
+Components may define values in the value index space using following syntax:
 
-Like modules, components can have start functions that are called during
-instantiation. Unlike modules, components can call start functions at multiple
-points during instantiation with each such call having parameters and results.
-Thus, `start` definitions in components look like function calls:
 ```ebnf
-start ::= (start <funcidx> (value <valueidx>)* (result (value <id>?))*)
+value ::= (value <id>? <valtype> <val>)
+val   ::= false | true
+        | <core:i64>
+        | <core:f64> | NaN
+        | '<core:char>'
+        | <core:name>
+        | (record <val>+)
+        | (variant "<label>" <val>?)
+        | (list <val>*)
+        | (tuple <val>+)
+        | (flags "<label>"*)
+        | (enum "<label>")
+        | none | (some <val>)
+        | ok | (ok <val>) | error | (error <val>)
+```
+
+The validation rules for `value` require the `val` to match the `valtype`.  For example:
+```wasm
+(component
+  (value $a bool true)
+  (value $b u8 1)
+  (value $c u16 2)
+  (value $d u32 3)
+  (value $e u64 4)
+  (value $f u8 5)
+  (value $g u16 6)
+  (value $h u32 7)
+  (value $i u64 8)
+  (value $j f32 9.1)
+  (value $k f64 9.2)
+  (value $l char 'a')
+  (value $m string "hello")
+  (value $n (record (field "a" bool) (field "b" u8)) (record true 1))
+  (value $o (variant (case "a" bool) (case "b" u8)) (variant "b" 1))
+  (value $p (list (result (option u8)))
+    (list
+      error
+      (ok (some 1))
+      (ok none)
+      error
+      (ok (some 2))
+    )
+  )
+  (value $q (tuple u8 u16 u32) (tuple 1 2 3))
+
+  (type $abc (flags "a" "b" "c"))
+  (value $r $abc (flags "a" "c"))
+
+  (value $s (enum "a" "b" "c") (enum "b"))
+
+  (type $complex
+    (tuple
+      (record
+        (field "a" (option string))
+        (field "b" (tuple (option u8) string))
+      )
+      (list char)
+      $abc
+      string
+    )
+  )
+  (value $complex1 (type $complex)
+    (tuple
+      (record
+        none
+        (tuple none "empty")
+      )
+      (list)
+      (flags)
+      ""
+    )
+  )
+  (value $complex2 (type $complex)
+    (tuple
+      (record
+        (some "example")
+        (tuple (some 42) "hello")
+      )
+      (list 'a' 'b' 'c')
+      (flags "b" "a")
+      "hi"
+    )
+  )
+)
 ```
-The `(value <valueidx>)*` list specifies the arguments passed to `funcidx` by
-indexing into the *value index space*. Value definitions (in the value index
-space) are like immutable `global` definitions in Core WebAssembly except that
-validation requires them to be consumed exactly once at instantiation-time
-(i.e., they are [linear]). The arity and types of the two value lists are
-validated to match the signature of `funcidx`.
 
 As with all definition sorts, values may be imported and exported by
 components. As an example value import:
@@ -1380,6 +1462,45 @@ components. As an example value import:
 As this example suggests, value imports can serve as generalized [environment
 variables], allowing not just `string`, but the full range of `valtype`.
 
+Values can also be exported.  For example:
+```wasm
+(component
+  (import "system-port" (value $port u16))
+  (value $url string "https://example.com")
+  (export "default-url" (value $url))
+  (export "default-port" (value $port))
+)
+```
+The inferred type of this component is:
+```wasm
+(component
+  (import "system-port" (value $port u16))
+  (value $url string "https://example.com")
+  (export "default-url" (value (eq $url)))
+  (export "default-port" (value (eq $port)))
+)
+```
+Thus, by default, the precise constant or import being exported is propagated
+into the component's type and thus its public interface.  In this way, value exports
+can act as semantic configuration data provided by the component to the host
+or other client tooling.
+Components can also keep the exact value being exported abstract (so that the
+precise value is not part of the type and public interface) using the "type ascription"
+feature mentioned in the [imports and exports](#import-and-export-definitions) section below.
+
+### 🪙 Start Definitions
+
+Like modules, components can have start functions that are called during
+instantiation. Unlike modules, components can call start functions at multiple
+points during instantiation with each such call having parameters and results.
+Thus, `start` definitions in components look like function calls:
+```ebnf
+start ::= (start <funcidx> (value <valueidx>)* (result (value <id>?))*)
+```
+The `(value <valueidx>)*` list specifies the arguments passed to `funcidx` by
+indexing into the *value index space*. The arity and types of the two value lists are
+validated to match the signature of `funcidx`.
+
 With this, we can define a component that imports a string and computes a new
 exported string at instantiation time:
 ```wasm
@@ -1657,6 +1778,25 @@ the standard [avoidance problem] that appears in module systems with abstract
 types. In particular, it ensures that a client of a component is able to
 externally define a type compatible with the exports of the component.
 
+Similar to type exports, value exports may also ascribe a type to keep the precise
+value from becoming part of the type and public interface.
+
+For example:
+```wasm
+(component
+  (value $url string "https://example.com")
+  (export "default-url" (value $url) (value string))
+)
+```
+
+The inferred type of this component is:
+```wasm
+(component
+  (export "default-url" (value string))
+)
+```
+
+Note, that the `url` value definition is absent from the component type
 
 ## Component Invariants
 
@@ -1941,6 +2081,9 @@ and will be added over the coming months to complete the MVP proposal:
 [Index Space]: https://webassembly.github.io/spec/core/syntax/modules.html#indices
 [Abbreviations]: https://webassembly.github.io/spec/core/text/conventions.html#abbreviations
 
+[`core:i64`]: https://webassembly.github.io/spec/core/syntax/values.html#integers
+[`core:f64`]: https://webassembly.github.io/spec/core/syntax/values.html#floating-point
+[`core:char`]: https://webassembly.github.io/spec/core/syntax/values.html#syntax-name
 [`core:name`]: https://webassembly.github.io/spec/core/syntax/values.html#syntax-name
 [`core:module`]: https://webassembly.github.io/spec/core/text/modules.html#text-module
 [`core:type`]: https://webassembly.github.io/spec/core/text/modules.html#types

From 42cb5fec0864405bba7746110fa026580825cdd2 Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Fri, 26 Apr 2024 21:19:21 +0200
Subject: [PATCH 02/24] special-case `s8` and `u8` in `Binary.md`

Special case `s8` and `u8` to ensure that exactly 1 byte is used
to represent values of those types

https://github.com/WebAssembly/component-model/pull/336#discussion_r1581432010

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Binary.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/design/mvp/Binary.md b/design/mvp/Binary.md
index 750cb1b3..c74b62ab 100644
--- a/design/mvp/Binary.md
+++ b/design/mvp/Binary.md
@@ -361,8 +361,8 @@ Notes:
 value                      ::= t:<valtype> v:<val(t)>                  => (value t v)
 val(bool)                  ::= 0x00                                    => false
                              | 0x01                                    => true
-val(u8)                    ::= v:<core:u8>                             => v
-val(s8)                    ::= v:<core:s8>                             => v
+val(u8)                    ::= v:<core:byte>                           => v
+val(s8)                    ::= v:<core:byte>                           => v if v < 128 else (v - 256)
 val(s16)                   ::= v:<core:s16>                            => v
 val(u16)                   ::= v:<core:u16>                            => v
 val(s32)                   ::= v:<core:s32>                            => v

From d2f1335c8839568373e9e92c86d666a228988f31 Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Fri, 26 Apr 2024 21:38:15 +0200
Subject: [PATCH 03/24] add `value` case to `instancedecl`

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Explainer.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/design/mvp/Explainer.md b/design/mvp/Explainer.md
index bf47dbce..f3308bdd 100644
--- a/design/mvp/Explainer.md
+++ b/design/mvp/Explainer.md
@@ -563,6 +563,7 @@ instancedecl  ::= core-prefix(<core:type>)
                 | <type>
                 | <alias>
                 | <exportdecl>
+                | <value> 🪙
 importdecl    ::= (import <importname> bind-id(<externdesc>))
 exportdecl    ::= (export <exportname> bind-id(<externdesc>))
 externdesc    ::= (<sort> (type <u32>) )

From 76cb9558cb0d1bd07b60758cec93bb266389c8bf Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Fri, 26 Apr 2024 21:38:52 +0200
Subject: [PATCH 04/24] introduce `f64canon` rule

https://github.com/WebAssembly/component-model/pull/336#discussion_r1581450741

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Explainer.md | 29 +++++++++++++++--------------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/design/mvp/Explainer.md b/design/mvp/Explainer.md
index f3308bdd..7531ad89 100644
--- a/design/mvp/Explainer.md
+++ b/design/mvp/Explainer.md
@@ -1369,20 +1369,21 @@ once at instantiation-time (i.e., they are [linear]).
 Components may define values in the value index space using following syntax:
 
 ```ebnf
-value ::= (value <id>? <valtype> <val>)
-val   ::= false | true
-        | <core:i64>
-        | <core:f64> | NaN
-        | '<core:char>'
-        | <core:name>
-        | (record <val>+)
-        | (variant "<label>" <val>?)
-        | (list <val>*)
-        | (tuple <val>+)
-        | (flags "<label>"*)
-        | (enum "<label>")
-        | none | (some <val>)
-        | ok | (ok <val>) | error | (error <val>)
+value    ::= (value <id>? <valtype> <val>)
+val      ::= false | true
+           | <core:i64>
+           | <f64canon>
+           | '<core:char>'
+           | <core:name>
+           | (record <val>+)
+           | (variant "<label>" <val>?)
+           | (list <val>*)
+           | (tuple <val>+)
+           | (flags "<label>"*)
+           | (enum "<label>")
+           | none | (some <val>)
+           | ok | (ok <val>) | error | (error <val>)
+f64canon ::= <core:f64> without the `nan:0x` case.
 ```
 
 The validation rules for `value` require the `val` to match the `valtype`.  For example:

From b58579e9089338b6cd08017c287e6045ceddec3a Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Tue, 7 May 2024 21:57:01 +0200
Subject: [PATCH 05/24] record value byte length

Refs https://github.com/WebAssembly/component-model/issues/352

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Binary.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/design/mvp/Binary.md b/design/mvp/Binary.md
index c74b62ab..5767c5b4 100644
--- a/design/mvp/Binary.md
+++ b/design/mvp/Binary.md
@@ -358,7 +358,7 @@ Notes:
 (See [Value Definitions](Explainer.md#value-definitions) in the explainer.)
 
 ```ebnf
-value                      ::= t:<valtype> v:<val(t)>                  => (value t v)
+value                      ::= t:<valtype> len:<uN> v:<val(t)>         => (value t v) (where len = |v+|)
 val(bool)                  ::= 0x00                                    => false
                              | 0x01                                    => true
 val(u8)                    ::= v:<core:byte>                           => v

From dc2859f513d54c3c6e144ae78199160697412fab Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Wed, 8 May 2024 16:05:25 +0200
Subject: [PATCH 06/24] represent byte length using `||v||` notation

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Binary.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/design/mvp/Binary.md b/design/mvp/Binary.md
index 5767c5b4..a697d9dd 100644
--- a/design/mvp/Binary.md
+++ b/design/mvp/Binary.md
@@ -358,7 +358,7 @@ Notes:
 (See [Value Definitions](Explainer.md#value-definitions) in the explainer.)
 
 ```ebnf
-value                      ::= t:<valtype> len:<uN> v:<val(t)>         => (value t v) (where len = |v+|)
+value                      ::= t:<valtype> len:<uN> v:<val(t)>         => (value t v) (where len = ||v||)
 val(bool)                  ::= 0x00                                    => false
                              | 0x01                                    => true
 val(u8)                    ::= v:<core:byte>                           => v
@@ -410,6 +410,7 @@ Notes:
     - [`core:f64`]
 * `&` operator is used to denote bitwise AND operation, which performs AND on every bit of two numbers in their binary form
 * `isnan` is a function, which takes a floating point number as a parameter and returns `true` iff it represents a NaN as defined in [IEEE 754 standard]
+* `||B||` is the length of the byte sequence generated from the production `B` in a derivation as defined in [Core convention auxilary notation]
 
 ## Name Section
 
@@ -464,3 +465,4 @@ named once.
 [module-linking]: https://github.com/WebAssembly/module-linking/blob/main/proposals/module-linking/Explainer.md
 
 [IEEE 754 standard]: https://ieeexplore.ieee.org/document/8766229
+[Core convention auxilary notation]: https://webassembly.github.io/spec/core/binary/conventions.html#auxiliary-notation

From 88e6d8fd597a1e2cac4d30a43a4bb053692a84e7 Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Mon, 13 May 2024 16:59:18 +0200
Subject: [PATCH 07/24] include type in scalar value definitions

https://github.com/WebAssembly/component-model/pull/336#issuecomment-2103594158

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Binary.md    | 24 ++++++++++++------------
 design/mvp/Explainer.md | 32 ++++++++++++++++----------------
 2 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/design/mvp/Binary.md b/design/mvp/Binary.md
index a697d9dd..b38a01d0 100644
--- a/design/mvp/Binary.md
+++ b/design/mvp/Binary.md
@@ -361,18 +361,18 @@ Notes:
 value                      ::= t:<valtype> len:<uN> v:<val(t)>         => (value t v) (where len = ||v||)
 val(bool)                  ::= 0x00                                    => false
                              | 0x01                                    => true
-val(u8)                    ::= v:<core:byte>                           => v
-val(s8)                    ::= v:<core:byte>                           => v if v < 128 else (v - 256)
-val(s16)                   ::= v:<core:s16>                            => v
-val(u16)                   ::= v:<core:u16>                            => v
-val(s32)                   ::= v:<core:s32>                            => v
-val(u32)                   ::= v:<core:u32>                            => v
-val(s64)                   ::= v:<core:s64>                            => v
-val(u64)                   ::= v:<core:u64>                            => v
-val(f32)                   ::= v:<core:f32>                            => v (if !isnan(v))
-                             | 0x00 0x00 0xC0 0x7F                     => nan
-val(f64)                   ::= v:<core:f64>                            => v (if !isnan(v))
-                             | 0x00 0x00 0x00 0x00 0x00 0x00 0xF8 0x7F => nan
+val(u8)                    ::= v:<core:byte>                           => (u8 v)
+val(s8)                    ::= v:<core:byte>                           => (s8 v) if v < 128 else (v - 256)
+val(s16)                   ::= v:<core:s16>                            => (s16 v)
+val(u16)                   ::= v:<core:u16>                            => (u16 v)
+val(s32)                   ::= v:<core:s32>                            => (s32 v)
+val(u32)                   ::= v:<core:u32>                            => (u32 v)
+val(s64)                   ::= v:<core:s64>                            => (s64 v)
+val(u64)                   ::= v:<core:u64>                            => (u64 v)
+val(f32)                   ::= v:<core:f32>                            => (f32 v) (if !isnan(v))
+                             | 0x00 0x00 0xC0 0x7F                     => (f32 nan)
+val(f64)                   ::= v:<core:f64>                            => (f64 v) (if !isnan(v))
+                             | 0x00 0x00 0x00 0x00 0x00 0x00 0xF8 0x7F => (f64 nan)
 val(char)                  ::= v:<core:u32>                            => v (if v < 0xD800 or 0xE000 <= v <= 0x10FFFF)
 val(string)                ::= v:<core:name>                           => v
 val(i:<typeidx>)           ::= v:<val(type-index-space[i])>            => v
diff --git a/design/mvp/Explainer.md b/design/mvp/Explainer.md
index 7531ad89..01f34a55 100644
--- a/design/mvp/Explainer.md
+++ b/design/mvp/Explainer.md
@@ -1390,30 +1390,30 @@ The validation rules for `value` require the `val` to match the `valtype`.  For
 ```wasm
 (component
   (value $a bool true)
-  (value $b u8 1)
-  (value $c u16 2)
-  (value $d u32 3)
-  (value $e u64 4)
-  (value $f u8 5)
-  (value $g u16 6)
-  (value $h u32 7)
-  (value $i u64 8)
-  (value $j f32 9.1)
-  (value $k f64 9.2)
+  (value $b u8 (u8 1))
+  (value $c u16 (u16 2))
+  (value $d u32 (u32 3))
+  (value $e u64 (u64 4))
+  (value $f s8 (s8 5))
+  (value $g s16 (s16 6))
+  (value $h s32 (s32 7))
+  (value $i s64 (s64 8))
+  (value $j f32 (f32 9.1))
+  (value $k f64 (f64 9.2))
   (value $l char 'a')
   (value $m string "hello")
-  (value $n (record (field "a" bool) (field "b" u8)) (record true 1))
-  (value $o (variant (case "a" bool) (case "b" u8)) (variant "b" 1))
+  (value $n (record (field "a" bool) (field "b" u8)) (record true (u8 1)))
+  (value $o (variant (case "a" bool) (case "b" u8)) (variant "b" (u8 1)))
   (value $p (list (result (option u8)))
     (list
       error
-      (ok (some 1))
+      (ok (some (u8 1)))
       (ok none)
       error
-      (ok (some 2))
+      (ok (some (u8 2)))
     )
   )
-  (value $q (tuple u8 u16 u32) (tuple 1 2 3))
+  (value $q (tuple u8 u16 u32) (tuple (u8 1) (u16 2) (u32 3)))
 
   (type $abc (flags "a" "b" "c"))
   (value $r $abc (flags "a" "c"))
@@ -1446,7 +1446,7 @@ The validation rules for `value` require the `val` to match the `valtype`.  For
     (tuple
       (record
         (some "example")
-        (tuple (some 42) "hello")
+        (tuple (some (u8 42)) "hello")
       )
       (list 'a' 'b' 'c')
       (flags "b" "a")

From 1747d40733834de985bd968ccb1f3fb89812af18 Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Mon, 20 May 2024 15:17:04 +0200
Subject: [PATCH 08/24] encode flags as u8^N

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Binary.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/design/mvp/Binary.md b/design/mvp/Binary.md
index b38a01d0..e07f2c6f 100644
--- a/design/mvp/Binary.md
+++ b/design/mvp/Binary.md
@@ -380,7 +380,7 @@ val((record (field l t)+)) ::= v+:<val(t)>+                            => (recor
 val((variant (case l t?)+) ::= i:<core:u32> v?:<val(t[i])>?            => (variant l[i] v?)
 val((list t))              ::= v:vec(<val(t)>)                         => (list v)
 val((tuple t+))            ::= v+:<val(t)>+                            => (tuple v+)
-val((flags l+))            ::= v:<core:uN>                             => (flags (l[i] for i in 0..N-1 if v & 2^i > 0)) (where N = |l+|)
+val((flags l+))            ::= (v:<core:byte>)^N                       => (flags (l[i] for i in 0..N-1 if v & 2^i > 0)) (where N = ceil(|l+| / 8))
 val((enum l+))             ::= i:<core:u32>                            => (enum l[i])
 val((option t))            ::= 0x00                                    => none
                              | 0x01 v:<val(t)>                         => (some v)

From d63fa291fbbf80fed5321db5a58c6760071056ef Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Mon, 20 May 2024 15:54:35 +0200
Subject: [PATCH 09/24] sync text format with value binary encoding changes

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Explainer.md | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/design/mvp/Explainer.md b/design/mvp/Explainer.md
index 01f34a55..3a483e4e 100644
--- a/design/mvp/Explainer.md
+++ b/design/mvp/Explainer.md
@@ -1371,8 +1371,18 @@ Components may define values in the value index space using following syntax:
 ```ebnf
 value    ::= (value <id>? <valtype> <val>)
 val      ::= false | true
-           | <core:i64>
-           | <f64canon>
+           | (u8  <core:u8>)
+           | (u16 <core:u16>)
+           | (u32 <core:u32>)
+           | (u64 <core:u64>)
+           | (s8  <core:s8>)
+           | (s16 <core:s16>)
+           | (s32 <core:s32>)
+           | (s64 <core:s64>)
+           | (f32 <f32canon>)
+           | (f32 nan)
+           | (f64 <f64canon>)
+           | (f64 nan)
            | '<core:char>'
            | <core:name>
            | (record <val>+)
@@ -1383,6 +1393,7 @@ val      ::= false | true
            | (enum "<label>")
            | none | (some <val>)
            | ok | (ok <val>) | error | (error <val>)
+f32canon ::= <core:f32> without the `nan:0x` case.
 f64canon ::= <core:f64> without the `nan:0x` case.
 ```
 

From 3cd3dc844a5e96fc769bbf13a6b76d8af8b6c824 Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Tue, 28 May 2024 13:23:09 +0200
Subject: [PATCH 10/24] encode discriminants as LE uints

https://github.com/WebAssembly/component-model/pull/336/files/88e6d8fd597a1e2cac4d30a43a4bb053692a84e7#diff-59f6b20b0bd073593bb31d6338e2186f876564ffe0bb67b8740b37dabf8e5636

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Binary.md | 76 ++++++++++++++++++++++++--------------------
 1 file changed, 42 insertions(+), 34 deletions(-)

diff --git a/design/mvp/Binary.md b/design/mvp/Binary.md
index e07f2c6f..705dc08b 100644
--- a/design/mvp/Binary.md
+++ b/design/mvp/Binary.md
@@ -358,40 +358,46 @@ Notes:
 (See [Value Definitions](Explainer.md#value-definitions) in the explainer.)
 
 ```ebnf
-value                      ::= t:<valtype> len:<uN> v:<val(t)>         => (value t v) (where len = ||v||)
-val(bool)                  ::= 0x00                                    => false
-                             | 0x01                                    => true
-val(u8)                    ::= v:<core:byte>                           => (u8 v)
-val(s8)                    ::= v:<core:byte>                           => (s8 v) if v < 128 else (v - 256)
-val(s16)                   ::= v:<core:s16>                            => (s16 v)
-val(u16)                   ::= v:<core:u16>                            => (u16 v)
-val(s32)                   ::= v:<core:s32>                            => (s32 v)
-val(u32)                   ::= v:<core:u32>                            => (u32 v)
-val(s64)                   ::= v:<core:s64>                            => (s64 v)
-val(u64)                   ::= v:<core:u64>                            => (u64 v)
-val(f32)                   ::= v:<core:f32>                            => (f32 v) (if !isnan(v))
-                             | 0x00 0x00 0xC0 0x7F                     => (f32 nan)
-val(f64)                   ::= v:<core:f64>                            => (f64 v) (if !isnan(v))
-                             | 0x00 0x00 0x00 0x00 0x00 0x00 0xF8 0x7F => (f64 nan)
-val(char)                  ::= v:<core:u32>                            => v (if v < 0xD800 or 0xE000 <= v <= 0x10FFFF)
-val(string)                ::= v:<core:name>                           => v
-val(i:<typeidx>)           ::= v:<val(type-index-space[i])>            => v
-val((record (field l t)+)) ::= v+:<val(t)>+                            => (record v+)
-val((variant (case l t?)+) ::= i:<core:u32> v?:<val(t[i])>?            => (variant l[i] v?)
-val((list t))              ::= v:vec(<val(t)>)                         => (list v)
-val((tuple t+))            ::= v+:<val(t)>+                            => (tuple v+)
-val((flags l+))            ::= (v:<core:byte>)^N                       => (flags (l[i] for i in 0..N-1 if v & 2^i > 0)) (where N = ceil(|l+| / 8))
-val((enum l+))             ::= i:<core:u32>                            => (enum l[i])
-val((option t))            ::= 0x00                                    => none
-                             | 0x01 v:<val(t)>                         => (some v)
-val((result))              ::= 0x00                                    => ok
-                             | 0x01                                    => error
-val((result t))            ::= 0x00 v:<val(t)>                         => (ok v)
-                             | 0x01                                    => error
-val((result (error u)))    ::= 0x00                                    => ok
-                             | 0x01 v:<val(u)>                         => (error v)
-val((result t (error u)))  ::= 0x00 v:<val(t)>                         => (ok v)
-                             | 0x01 v:<val(u)>                         => (error v)
+value                      ::= t:<valtype> len:<uN> v:<val(t)>                                         => (value t v) (where len = ||v||)
+val(bool)                  ::= 0x00                                                                    => false
+                             | 0x01                                                                    => true
+val(u8)                    ::= v:<core:byte>                                                           => (u8 v)
+val(s8)                    ::= v:<core:byte>                                                           => (s8 v) if v < 128 else (v - 256)
+val(s16)                   ::= v:<core:s16>                                                            => (s16 v)
+val(u16)                   ::= v:<core:u16>                                                            => (u16 v)
+val(s32)                   ::= v:<core:s32>                                                            => (s32 v)
+val(u32)                   ::= v:<core:u32>                                                            => (u32 v)
+val(s64)                   ::= v:<core:s64>                                                            => (s64 v)
+val(u64)                   ::= v:<core:u64>                                                            => (u64 v)
+val(f32)                   ::= v:<core:f32>                                                            => (f32 v) (if !isnan(v))
+                             | 0x00 0x00 0xC0 0x7F                                                     => (f32 nan)
+val(f64)                   ::= v:<core:f64>                                                            => (f64 v) (if !isnan(v))
+                             | 0x00 0x00 0x00 0x00 0x00 0x00 0xF8 0x7F                                 => (f64 nan)
+val(char)                  ::= v:<core:u32>                                                            => v (if v < 0xD800 or 0xE000 <= v <= 0x10FFFF)
+val(string)                ::= v:<core:name>                                                           => v
+val(i:<typeidx>)           ::= v:<val(type-index-space[i])>                                            => v
+val((record (field l t)+)) ::= v+:<val(t)>+                                                            => (record v+)
+val((variant (case l t?)+) ::= a:<core:byte> v?:<val(t[i])>?                                           => (variant l[a] v?)                              (if |l| <= 255)
+                             | a:<core:byte> b:<core:byte> v?:<val(t[i])>?                             => (variant l[a | b << 8] v?)                     (if |l| <= 65535)
+                             | a:<core:byte> b:<core:byte> c:<core:byte> v?:<val(t[i])>?               => (variant l[a | b << 8 | c << 16] v?)           (if |l| <= 16777215)
+                             | a:<core:byte> b:<core:byte> c:<core:byte> d:<core:byte> v?:<val(t[i])>? => (variant l[a | b << 8 | c << 16 | d << 24] v?) (if |l| > 16777215)
+val((list t))              ::= v:vec(<val(t)>)                                                         => (list v)
+val((tuple t+))            ::= v+:<val(t)>+                                                            => (tuple v+)
+val((flags l+))            ::= (v:<core:byte>)^N                                                       => (flags (l[i] for i in 0..N-1 if v & 2^i > 0)) (where N = ceil(|l+| / 8))
+val((enum l+))             ::= a:<core:byte>                                                           => (enum l[a])                              (if |l| <= 255)
+                             | a:<core:byte> b:<core:byte>                                             => (enum l[a | b << 8])                     (if |l| <= 65535)
+                             | a:<core:byte> b:<core:byte> c:<core:byte>                               => (enum l[a | b << 8 | c << 16])           (if |l| <= 16777215)
+                             | a:<core:byte> b:<core:byte> c:<core:byte> d:<core:byte>                 => (enum l[a | b << 8 | c << 16 | d << 24]) (if |l| > 16777215)
+val((option t))            ::= 0x00                                                                    => none
+                             | 0x01 v:<val(t)>                                                         => (some v)
+val((result))              ::= 0x00                                                                    => ok
+                             | 0x01                                                                    => error
+val((result t))            ::= 0x00 v:<val(t)>                                                         => (ok v)
+                             | 0x01                                                                    => error
+val((result (error u)))    ::= 0x00                                                                    => ok
+                             | 0x01 v:<val(u)>                                                         => (error v)
+val((result t (error u)))  ::= 0x00 v:<val(t)>                                                         => (ok v)
+                             | 0x01 v:<val(u)>                                                         => (error v)
 ```
 
 Notes:
@@ -408,7 +414,9 @@ Notes:
     - [`core:uN`]
     - [`core:f32`]
     - [`core:f64`]
+* `|` operator is used to denote bitwise OR operation, which performs OR on every bit of two numbers in their binary form
 * `&` operator is used to denote bitwise AND operation, which performs AND on every bit of two numbers in their binary form
+* `<<` operator is used to denote a bitwise left shift operation, which appends `0` at LSB position
 * `isnan` is a function, which takes a floating point number as a parameter and returns `true` iff it represents a NaN as defined in [IEEE 754 standard]
 * `||B||` is the length of the byte sequence generated from the production `B` in a derivation as defined in [Core convention auxilary notation]
 

From 0c9a3d42108196eb44a59c3ae9384232793cfcb8 Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Wed, 29 May 2024 20:09:58 +0200
Subject: [PATCH 11/24] revert: "encode discriminants as LE uints"

This reverts commit 3cd3dc844a5e96fc769bbf13a6b76d8af8b6c824.

After further discussion we have reached concensus on
LEB128-encoding the discriminants
---
 design/mvp/Binary.md | 76 ++++++++++++++++++++------------------------
 1 file changed, 34 insertions(+), 42 deletions(-)

diff --git a/design/mvp/Binary.md b/design/mvp/Binary.md
index 705dc08b..e07f2c6f 100644
--- a/design/mvp/Binary.md
+++ b/design/mvp/Binary.md
@@ -358,46 +358,40 @@ Notes:
 (See [Value Definitions](Explainer.md#value-definitions) in the explainer.)
 
 ```ebnf
-value                      ::= t:<valtype> len:<uN> v:<val(t)>                                         => (value t v) (where len = ||v||)
-val(bool)                  ::= 0x00                                                                    => false
-                             | 0x01                                                                    => true
-val(u8)                    ::= v:<core:byte>                                                           => (u8 v)
-val(s8)                    ::= v:<core:byte>                                                           => (s8 v) if v < 128 else (v - 256)
-val(s16)                   ::= v:<core:s16>                                                            => (s16 v)
-val(u16)                   ::= v:<core:u16>                                                            => (u16 v)
-val(s32)                   ::= v:<core:s32>                                                            => (s32 v)
-val(u32)                   ::= v:<core:u32>                                                            => (u32 v)
-val(s64)                   ::= v:<core:s64>                                                            => (s64 v)
-val(u64)                   ::= v:<core:u64>                                                            => (u64 v)
-val(f32)                   ::= v:<core:f32>                                                            => (f32 v) (if !isnan(v))
-                             | 0x00 0x00 0xC0 0x7F                                                     => (f32 nan)
-val(f64)                   ::= v:<core:f64>                                                            => (f64 v) (if !isnan(v))
-                             | 0x00 0x00 0x00 0x00 0x00 0x00 0xF8 0x7F                                 => (f64 nan)
-val(char)                  ::= v:<core:u32>                                                            => v (if v < 0xD800 or 0xE000 <= v <= 0x10FFFF)
-val(string)                ::= v:<core:name>                                                           => v
-val(i:<typeidx>)           ::= v:<val(type-index-space[i])>                                            => v
-val((record (field l t)+)) ::= v+:<val(t)>+                                                            => (record v+)
-val((variant (case l t?)+) ::= a:<core:byte> v?:<val(t[i])>?                                           => (variant l[a] v?)                              (if |l| <= 255)
-                             | a:<core:byte> b:<core:byte> v?:<val(t[i])>?                             => (variant l[a | b << 8] v?)                     (if |l| <= 65535)
-                             | a:<core:byte> b:<core:byte> c:<core:byte> v?:<val(t[i])>?               => (variant l[a | b << 8 | c << 16] v?)           (if |l| <= 16777215)
-                             | a:<core:byte> b:<core:byte> c:<core:byte> d:<core:byte> v?:<val(t[i])>? => (variant l[a | b << 8 | c << 16 | d << 24] v?) (if |l| > 16777215)
-val((list t))              ::= v:vec(<val(t)>)                                                         => (list v)
-val((tuple t+))            ::= v+:<val(t)>+                                                            => (tuple v+)
-val((flags l+))            ::= (v:<core:byte>)^N                                                       => (flags (l[i] for i in 0..N-1 if v & 2^i > 0)) (where N = ceil(|l+| / 8))
-val((enum l+))             ::= a:<core:byte>                                                           => (enum l[a])                              (if |l| <= 255)
-                             | a:<core:byte> b:<core:byte>                                             => (enum l[a | b << 8])                     (if |l| <= 65535)
-                             | a:<core:byte> b:<core:byte> c:<core:byte>                               => (enum l[a | b << 8 | c << 16])           (if |l| <= 16777215)
-                             | a:<core:byte> b:<core:byte> c:<core:byte> d:<core:byte>                 => (enum l[a | b << 8 | c << 16 | d << 24]) (if |l| > 16777215)
-val((option t))            ::= 0x00                                                                    => none
-                             | 0x01 v:<val(t)>                                                         => (some v)
-val((result))              ::= 0x00                                                                    => ok
-                             | 0x01                                                                    => error
-val((result t))            ::= 0x00 v:<val(t)>                                                         => (ok v)
-                             | 0x01                                                                    => error
-val((result (error u)))    ::= 0x00                                                                    => ok
-                             | 0x01 v:<val(u)>                                                         => (error v)
-val((result t (error u)))  ::= 0x00 v:<val(t)>                                                         => (ok v)
-                             | 0x01 v:<val(u)>                                                         => (error v)
+value                      ::= t:<valtype> len:<uN> v:<val(t)>         => (value t v) (where len = ||v||)
+val(bool)                  ::= 0x00                                    => false
+                             | 0x01                                    => true
+val(u8)                    ::= v:<core:byte>                           => (u8 v)
+val(s8)                    ::= v:<core:byte>                           => (s8 v) if v < 128 else (v - 256)
+val(s16)                   ::= v:<core:s16>                            => (s16 v)
+val(u16)                   ::= v:<core:u16>                            => (u16 v)
+val(s32)                   ::= v:<core:s32>                            => (s32 v)
+val(u32)                   ::= v:<core:u32>                            => (u32 v)
+val(s64)                   ::= v:<core:s64>                            => (s64 v)
+val(u64)                   ::= v:<core:u64>                            => (u64 v)
+val(f32)                   ::= v:<core:f32>                            => (f32 v) (if !isnan(v))
+                             | 0x00 0x00 0xC0 0x7F                     => (f32 nan)
+val(f64)                   ::= v:<core:f64>                            => (f64 v) (if !isnan(v))
+                             | 0x00 0x00 0x00 0x00 0x00 0x00 0xF8 0x7F => (f64 nan)
+val(char)                  ::= v:<core:u32>                            => v (if v < 0xD800 or 0xE000 <= v <= 0x10FFFF)
+val(string)                ::= v:<core:name>                           => v
+val(i:<typeidx>)           ::= v:<val(type-index-space[i])>            => v
+val((record (field l t)+)) ::= v+:<val(t)>+                            => (record v+)
+val((variant (case l t?)+) ::= i:<core:u32> v?:<val(t[i])>?            => (variant l[i] v?)
+val((list t))              ::= v:vec(<val(t)>)                         => (list v)
+val((tuple t+))            ::= v+:<val(t)>+                            => (tuple v+)
+val((flags l+))            ::= (v:<core:byte>)^N                       => (flags (l[i] for i in 0..N-1 if v & 2^i > 0)) (where N = ceil(|l+| / 8))
+val((enum l+))             ::= i:<core:u32>                            => (enum l[i])
+val((option t))            ::= 0x00                                    => none
+                             | 0x01 v:<val(t)>                         => (some v)
+val((result))              ::= 0x00                                    => ok
+                             | 0x01                                    => error
+val((result t))            ::= 0x00 v:<val(t)>                         => (ok v)
+                             | 0x01                                    => error
+val((result (error u)))    ::= 0x00                                    => ok
+                             | 0x01 v:<val(u)>                         => (error v)
+val((result t (error u)))  ::= 0x00 v:<val(t)>                         => (ok v)
+                             | 0x01 v:<val(u)>                         => (error v)
 ```
 
 Notes:
@@ -414,9 +408,7 @@ Notes:
     - [`core:uN`]
     - [`core:f32`]
     - [`core:f64`]
-* `|` operator is used to denote bitwise OR operation, which performs OR on every bit of two numbers in their binary form
 * `&` operator is used to denote bitwise AND operation, which performs AND on every bit of two numbers in their binary form
-* `<<` operator is used to denote a bitwise left shift operation, which appends `0` at LSB position
 * `isnan` is a function, which takes a floating point number as a parameter and returns `true` iff it represents a NaN as defined in [IEEE 754 standard]
 * `||B||` is the length of the byte sequence generated from the production `B` in a derivation as defined in [Core convention auxilary notation]
 

From 54d551f1fd2c79f813f48cf185402cc2eaa48109 Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Wed, 29 May 2024 20:49:57 +0200
Subject: [PATCH 12/24] ensure `char` it utf8-encoded

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Binary.md    | 6 ++++--
 design/mvp/Explainer.md | 2 +-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/design/mvp/Binary.md b/design/mvp/Binary.md
index e07f2c6f..982a47e0 100644
--- a/design/mvp/Binary.md
+++ b/design/mvp/Binary.md
@@ -373,7 +373,7 @@ val(f32)                   ::= v:<core:f32>                            => (f32 v
                              | 0x00 0x00 0xC0 0x7F                     => (f32 nan)
 val(f64)                   ::= v:<core:f64>                            => (f64 v) (if !isnan(v))
                              | 0x00 0x00 0x00 0x00 0x00 0x00 0xF8 0x7F => (f64 nan)
-val(char)                  ::= v:<core:u32>                            => v (if v < 0xD800 or 0xE000 <= v <= 0x10FFFF)
+val(char)                  ::= b*:<core:byte>*                         => c (where b* = core:utf8(c))
 val(string)                ::= v:<core:name>                           => v
 val(i:<typeidx>)           ::= v:<val(type-index-space[i])>            => v
 val((record (field l t)+)) ::= v+:<val(t)>+                            => (record v+)
@@ -395,7 +395,7 @@ val((result t (error u)))  ::= 0x00 v:<val(t)>                         => (ok v)
 ```
 
 Notes:
-* Reused Core binary rules:
+* Reused Core binary rules and functions:
     - [`core:name`]
     - [`core:s8`]
     - [`core:s16`]
@@ -408,6 +408,7 @@ Notes:
     - [`core:uN`]
     - [`core:f32`]
     - [`core:f64`]
+    - [`core:utf8`]
 * `&` operator is used to denote bitwise AND operation, which performs AND on every bit of two numbers in their binary form
 * `isnan` is a function, which takes a floating point number as a parameter and returns `true` iff it represents a NaN as defined in [IEEE 754 standard]
 * `||B||` is the length of the byte sequence generated from the production `B` in a derivation as defined in [Core convention auxilary notation]
@@ -452,6 +453,7 @@ named once.
 [`core:uN`]: https://webassembly.github.io/spec/core/binary/values.html#integers
 [`core:f32`]: https://webassembly.github.io/spec/core/binary/values.html#floating-point
 [`core:f64`]: https://webassembly.github.io/spec/core/binary/values.html#floating-point
+[`core:utf8`]: https://webassembly.github.io/spec/core/binary/values.html#binary-utf8
 [`core:section`]: https://webassembly.github.io/spec/core/binary/modules.html#binary-section
 [`core:custom`]: https://webassembly.github.io/spec/core/binary/modules.html#custom-section
 [`core:module`]: https://webassembly.github.io/spec/core/binary/modules.html#binary-module
diff --git a/design/mvp/Explainer.md b/design/mvp/Explainer.md
index 3a483e4e..db9644ec 100644
--- a/design/mvp/Explainer.md
+++ b/design/mvp/Explainer.md
@@ -1383,7 +1383,7 @@ val      ::= false | true
            | (f32 nan)
            | (f64 <f64canon>)
            | (f64 nan)
-           | '<core:char>'
+           | '<core:stringchar>'
            | <core:name>
            | (record <val>+)
            | (variant "<label>" <val>?)

From 5098ffcd0422062c694fd669801d0920b353aea2 Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Wed, 29 May 2024 20:54:55 +0200
Subject: [PATCH 13/24] revert: "include type in scalar value definitions"

This reverts commit 88e6d8fd597a1e2cac4d30a43a4bb053692a84e7.

After discussion we agreed that this is not required and parsers will
have to rely on type information, however a "raw" byte value
representation will be introduced in the text format for simplicity
---
 design/mvp/Binary.md    | 24 +++++++++---------
 design/mvp/Explainer.md | 56 ++++++++++++++++++++---------------------
 2 files changed, 40 insertions(+), 40 deletions(-)

diff --git a/design/mvp/Binary.md b/design/mvp/Binary.md
index 982a47e0..64ad2f22 100644
--- a/design/mvp/Binary.md
+++ b/design/mvp/Binary.md
@@ -361,18 +361,18 @@ Notes:
 value                      ::= t:<valtype> len:<uN> v:<val(t)>         => (value t v) (where len = ||v||)
 val(bool)                  ::= 0x00                                    => false
                              | 0x01                                    => true
-val(u8)                    ::= v:<core:byte>                           => (u8 v)
-val(s8)                    ::= v:<core:byte>                           => (s8 v) if v < 128 else (v - 256)
-val(s16)                   ::= v:<core:s16>                            => (s16 v)
-val(u16)                   ::= v:<core:u16>                            => (u16 v)
-val(s32)                   ::= v:<core:s32>                            => (s32 v)
-val(u32)                   ::= v:<core:u32>                            => (u32 v)
-val(s64)                   ::= v:<core:s64>                            => (s64 v)
-val(u64)                   ::= v:<core:u64>                            => (u64 v)
-val(f32)                   ::= v:<core:f32>                            => (f32 v) (if !isnan(v))
-                             | 0x00 0x00 0xC0 0x7F                     => (f32 nan)
-val(f64)                   ::= v:<core:f64>                            => (f64 v) (if !isnan(v))
-                             | 0x00 0x00 0x00 0x00 0x00 0x00 0xF8 0x7F => (f64 nan)
+val(u8)                    ::= v:<core:byte>                           => v
+val(s8)                    ::= v:<core:byte>                           => v if v < 128 else (v - 256)
+val(s16)                   ::= v:<core:s16>                            => v
+val(u16)                   ::= v:<core:u16>                            => v
+val(s32)                   ::= v:<core:s32>                            => v
+val(u32)                   ::= v:<core:u32>                            => v
+val(s64)                   ::= v:<core:s64>                            => v
+val(u64)                   ::= v:<core:u64>                            => v
+val(f32)                   ::= v:<core:f32>                            => v (if !isnan(v))
+                             | 0x00 0x00 0xC0 0x7F                     => nan
+val(f64)                   ::= v:<core:f64>                            => v (if !isnan(v))
+                             | 0x00 0x00 0x00 0x00 0x00 0x00 0xF8 0x7F => nan
 val(char)                  ::= b*:<core:byte>*                         => c (where b* = core:utf8(c))
 val(string)                ::= v:<core:name>                           => v
 val(i:<typeidx>)           ::= v:<val(type-index-space[i])>            => v
diff --git a/design/mvp/Explainer.md b/design/mvp/Explainer.md
index db9644ec..90b82de7 100644
--- a/design/mvp/Explainer.md
+++ b/design/mvp/Explainer.md
@@ -1371,18 +1371,18 @@ Components may define values in the value index space using following syntax:
 ```ebnf
 value    ::= (value <id>? <valtype> <val>)
 val      ::= false | true
-           | (u8  <core:u8>)
-           | (u16 <core:u16>)
-           | (u32 <core:u32>)
-           | (u64 <core:u64>)
-           | (s8  <core:s8>)
-           | (s16 <core:s16>)
-           | (s32 <core:s32>)
-           | (s64 <core:s64>)
-           | (f32 <f32canon>)
-           | (f32 nan)
-           | (f64 <f64canon>)
-           | (f64 nan)
+           | <core:u8>
+           | <core:u16>
+           | <core:u32>
+           | <core:u64>
+           | <core:s8>
+           | <core:s16>
+           | <core:s32>
+           | <core:s64>
+           | <f32canon>
+           | nan
+           | <f64canon>
+           | nan
            | '<core:stringchar>'
            | <core:name>
            | (record <val>+)
@@ -1401,30 +1401,30 @@ The validation rules for `value` require the `val` to match the `valtype`.  For
 ```wasm
 (component
   (value $a bool true)
-  (value $b u8 (u8 1))
-  (value $c u16 (u16 2))
-  (value $d u32 (u32 3))
-  (value $e u64 (u64 4))
-  (value $f s8 (s8 5))
-  (value $g s16 (s16 6))
-  (value $h s32 (s32 7))
-  (value $i s64 (s64 8))
-  (value $j f32 (f32 9.1))
-  (value $k f64 (f64 9.2))
+  (value $b u8  1)
+  (value $c u16 2)
+  (value $d u32 3)
+  (value $e u64 4)
+  (value $f s8  5)
+  (value $g s16 6)
+  (value $h s32 7)
+  (value $i s64 8)
+  (value $j f32 9.1)
+  (value $k f64 9.2)
   (value $l char 'a')
   (value $m string "hello")
-  (value $n (record (field "a" bool) (field "b" u8)) (record true (u8 1)))
-  (value $o (variant (case "a" bool) (case "b" u8)) (variant "b" (u8 1)))
+  (value $n (record (field "a" bool) (field "b" u8)) (record true 1))
+  (value $o (variant (case "a" bool) (case "b" u8)) (variant "b" 1))
   (value $p (list (result (option u8)))
     (list
       error
-      (ok (some (u8 1)))
+      (ok (some 1))
       (ok none)
       error
-      (ok (some (u8 2)))
+      (ok (some 2))
     )
   )
-  (value $q (tuple u8 u16 u32) (tuple (u8 1) (u16 2) (u32 3)))
+  (value $q (tuple u8 u16 u32) (tuple 1 2 3))
 
   (type $abc (flags "a" "b" "c"))
   (value $r $abc (flags "a" "c"))
@@ -1457,7 +1457,7 @@ The validation rules for `value` require the `val` to match the `valtype`.  For
     (tuple
       (record
         (some "example")
-        (tuple (some (u8 42)) "hello")
+        (tuple (some 42) "hello")
       )
       (list 'a' 'b' 'c')
       (flags "b" "a")

From 5a349e3b905f57805a7651de2d2f35669e027735 Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Wed, 29 May 2024 21:06:53 +0200
Subject: [PATCH 14/24] allow `(binary <datastring>)` value definitions

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Explainer.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/design/mvp/Explainer.md b/design/mvp/Explainer.md
index 90b82de7..727b606e 100644
--- a/design/mvp/Explainer.md
+++ b/design/mvp/Explainer.md
@@ -1393,6 +1393,7 @@ val      ::= false | true
            | (enum "<label>")
            | none | (some <val>)
            | ok | (ok <val>) | error | (error <val>)
+           | (binary <core:datastring>)
 f32canon ::= <core:f32> without the `nan:0x` case.
 f64canon ::= <core:f64> without the `nan:0x` case.
 ```
@@ -1431,6 +1432,9 @@ The validation rules for `value` require the `val` to match the `valtype`.  For
 
   (value $s (enum "a" "b" "c") (enum "b"))
 
+  (value $t bool (binary "\00"))
+  (value $u string (binary "\07example"))
+
   (type $complex
     (tuple
       (record
@@ -2105,6 +2109,7 @@ and will be added over the coming months to complete the MVP proposal:
 [`core:valtype`]: https://webassembly.github.io/spec/core/text/types.html#value-types
 [`core:typeuse`]: https://webassembly.github.io/spec/core/text/modules.html#type-uses
 [`core:functype`]: https://webassembly.github.io/spec/core/text/types.html#function-types
+[`core:datastring`]: https://webassembly.github.io/spec/core/text/modules.html#text-datastring
 [func-import-abbrev]: https://webassembly.github.io/spec/core/text/modules.html#text-func-abbrev
 [`core:version`]: https://webassembly.github.io/spec/core/binary/modules.html#binary-version
 

From 7c0c34f94d8a91dd07036e421d4de174d4b46bf7 Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Thu, 30 May 2024 11:34:27 +0200
Subject: [PATCH 15/24] collapse text format scalar definition rules

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Explainer.md | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/design/mvp/Explainer.md b/design/mvp/Explainer.md
index 727b606e..3e21ddcf 100644
--- a/design/mvp/Explainer.md
+++ b/design/mvp/Explainer.md
@@ -1371,16 +1371,8 @@ Components may define values in the value index space using following syntax:
 ```ebnf
 value    ::= (value <id>? <valtype> <val>)
 val      ::= false | true
-           | <core:u8>
-           | <core:u16>
-           | <core:u32>
            | <core:u64>
-           | <core:s8>
-           | <core:s16>
-           | <core:s32>
            | <core:s64>
-           | <f32canon>
-           | nan
            | <f64canon>
            | nan
            | '<core:stringchar>'
@@ -1394,7 +1386,6 @@ val      ::= false | true
            | none | (some <val>)
            | ok | (ok <val>) | error | (error <val>)
            | (binary <core:datastring>)
-f32canon ::= <core:f32> without the `nan:0x` case.
 f64canon ::= <core:f64> without the `nan:0x` case.
 ```
 

From c3f309b9c43853812c2dac74ea977dac2414ff71 Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Thu, 30 May 2024 11:34:51 +0200
Subject: [PATCH 16/24] remove `{u,s}8` rule references from the binary spec

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Binary.md | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/design/mvp/Binary.md b/design/mvp/Binary.md
index 64ad2f22..7723e5d5 100644
--- a/design/mvp/Binary.md
+++ b/design/mvp/Binary.md
@@ -397,11 +397,10 @@ val((result t (error u)))  ::= 0x00 v:<val(t)>                         => (ok v)
 Notes:
 * Reused Core binary rules and functions:
     - [`core:name`]
-    - [`core:s8`]
+    - [`core:byte`]
     - [`core:s16`]
     - [`core:s32`]
     - [`core:s64`]
-    - [`core:u8`]
     - [`core:u16`]
     - [`core:u32`]
     - [`core:u64`]
@@ -442,8 +441,7 @@ appear once within a `name` section, for example component instances can only be
 named once.
 
 
-[`core:s8`]: https://webassembly.github.io/spec/core/binary/values.html#integers
-[`core:u8`]: https://webassembly.github.io/spec/core/binary/values.html#integers
+[`core:byte`]: https://webassembly.github.io/spec/core/binary/values.html#binary-byte
 [`core:s16`]: https://webassembly.github.io/spec/core/binary/values.html#integers
 [`core:u16`]: https://webassembly.github.io/spec/core/binary/values.html#integers
 [`core:s32`]: https://webassembly.github.io/spec/core/binary/values.html#integers

From b8c31b05eb094efcd0190d210da2d3950f5f9f44 Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Thu, 30 May 2024 11:45:24 +0200
Subject: [PATCH 17/24] adapt flag rule definition to LE byte sequence

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Binary.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/design/mvp/Binary.md b/design/mvp/Binary.md
index 7723e5d5..6a6c66df 100644
--- a/design/mvp/Binary.md
+++ b/design/mvp/Binary.md
@@ -380,7 +380,7 @@ val((record (field l t)+)) ::= v+:<val(t)>+                            => (recor
 val((variant (case l t?)+) ::= i:<core:u32> v?:<val(t[i])>?            => (variant l[i] v?)
 val((list t))              ::= v:vec(<val(t)>)                         => (list v)
 val((tuple t+))            ::= v+:<val(t)>+                            => (tuple v+)
-val((flags l+))            ::= (v:<core:byte>)^N                       => (flags (l[i] for i in 0..N-1 if v & 2^i > 0)) (where N = ceil(|l+| / 8))
+val((flags l+))            ::= (v:<core:byte>)^N                       => (flags (l[i] for i in 0..|l+|-1 if v[floor(i / 8)] & 2^(i mod 8) > 0)) (where N = ceil(|l+| / 8))
 val((enum l+))             ::= i:<core:u32>                            => (enum l[i])
 val((option t))            ::= 0x00                                    => none
                              | 0x01 v:<val(t)>                         => (some v)

From 82a66f80320ffb20ab93e22f9333361eab1323ca Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Thu, 30 May 2024 11:46:28 +0200
Subject: [PATCH 18/24] bind `N` in `value` rule

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Binary.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/design/mvp/Binary.md b/design/mvp/Binary.md
index 6a6c66df..b22db368 100644
--- a/design/mvp/Binary.md
+++ b/design/mvp/Binary.md
@@ -358,7 +358,7 @@ Notes:
 (See [Value Definitions](Explainer.md#value-definitions) in the explainer.)
 
 ```ebnf
-value                      ::= t:<valtype> len:<uN> v:<val(t)>         => (value t v) (where len = ||v||)
+value                      ::= t:<valtype> len:<uN> v:<val(t)>         => (value t v) (where len = ||v|| and N = ceil(sqrt(||v||)))
 val(bool)                  ::= 0x00                                    => false
                              | 0x01                                    => true
 val(u8)                    ::= v:<core:byte>                           => v

From 2c77edb94d21e9318f4384825bd1bbc070d85f19 Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Thu, 30 May 2024 11:51:57 +0200
Subject: [PATCH 19/24] document `(binary ...)` expression

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Explainer.md | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/design/mvp/Explainer.md b/design/mvp/Explainer.md
index 3e21ddcf..13ecfc02 100644
--- a/design/mvp/Explainer.md
+++ b/design/mvp/Explainer.md
@@ -1389,7 +1389,13 @@ val      ::= false | true
 f64canon ::= <core:f64> without the `nan:0x` case.
 ```
 
-The validation rules for `value` require the `val` to match the `valtype`.  For example:
+The validation rules for `value` require the `val` to match the `valtype`.
+
+`(binary ...)` expression provides an alternative syntax allowing the binary contents
+of the value definition to be written directly in the text format, analogous to data segments,
+avoiding the need to understand type information when encoding or decoding.
+
+For example:
 ```wasm
 (component
   (value $a bool true)

From a56e79239b8f7a989e8c6f7def1803c8bf19e0d8 Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Thu, 30 May 2024 11:55:25 +0200
Subject: [PATCH 20/24] bind `v'` in `s8` rule

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Binary.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/design/mvp/Binary.md b/design/mvp/Binary.md
index b22db368..cd6c3601 100644
--- a/design/mvp/Binary.md
+++ b/design/mvp/Binary.md
@@ -362,7 +362,7 @@ value                      ::= t:<valtype> len:<uN> v:<val(t)>         => (value
 val(bool)                  ::= 0x00                                    => false
                              | 0x01                                    => true
 val(u8)                    ::= v:<core:byte>                           => v
-val(s8)                    ::= v:<core:byte>                           => v if v < 128 else (v - 256)
+val(s8)                    ::= v:<core:byte>                           => v' (where v' = v if v < 128 else (v - 256))
 val(s16)                   ::= v:<core:s16>                            => v
 val(u16)                   ::= v:<core:u16>                            => v
 val(s32)                   ::= v:<core:s32>                            => v

From ba58e56fdb5484a38b99a18729549baba331192a Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Thu, 30 May 2024 12:01:57 +0200
Subject: [PATCH 21/24] use uninterpreted integers in value definition text
 format

Uninterpreted integers can be written as either signed or unsigned and
therefore elliminate the need for distinction between the two rules

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Explainer.md | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/design/mvp/Explainer.md b/design/mvp/Explainer.md
index 13ecfc02..4b19ff78 100644
--- a/design/mvp/Explainer.md
+++ b/design/mvp/Explainer.md
@@ -1371,8 +1371,7 @@ Components may define values in the value index space using following syntax:
 ```ebnf
 value    ::= (value <id>? <valtype> <val>)
 val      ::= false | true
-           | <core:u64>
-           | <core:s64>
+           | <core:i64>
            | <f64canon>
            | nan
            | '<core:stringchar>'
@@ -2095,7 +2094,7 @@ and will be added over the coming months to complete the MVP proposal:
 [Index Space]: https://webassembly.github.io/spec/core/syntax/modules.html#indices
 [Abbreviations]: https://webassembly.github.io/spec/core/text/conventions.html#abbreviations
 
-[`core:i64`]: https://webassembly.github.io/spec/core/syntax/values.html#integers
+[`core:i64`]: https://webassembly.github.io/spec/core/text/values.html#text-int
 [`core:f64`]: https://webassembly.github.io/spec/core/syntax/values.html#floating-point
 [`core:char`]: https://webassembly.github.io/spec/core/syntax/values.html#syntax-name
 [`core:name`]: https://webassembly.github.io/spec/core/syntax/values.html#syntax-name

From 6c8e7b412a88a30d8f0d9b83fe3def1f61533ce7 Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Thu, 30 May 2024 12:02:38 +0200
Subject: [PATCH 22/24] refer to `stringchar`, not `char`

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Explainer.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/design/mvp/Explainer.md b/design/mvp/Explainer.md
index 4b19ff78..3bd658aa 100644
--- a/design/mvp/Explainer.md
+++ b/design/mvp/Explainer.md
@@ -2096,7 +2096,7 @@ and will be added over the coming months to complete the MVP proposal:
 
 [`core:i64`]: https://webassembly.github.io/spec/core/text/values.html#text-int
 [`core:f64`]: https://webassembly.github.io/spec/core/syntax/values.html#floating-point
-[`core:char`]: https://webassembly.github.io/spec/core/syntax/values.html#syntax-name
+[`core:stringchar`]: https://webassembly.github.io/spec/core/text/values.html#text-string
 [`core:name`]: https://webassembly.github.io/spec/core/syntax/values.html#syntax-name
 [`core:module`]: https://webassembly.github.io/spec/core/text/modules.html#text-module
 [`core:type`]: https://webassembly.github.io/spec/core/text/modules.html#types

From c5573919bd78672ec16aa2659cc4512e442d3aa4 Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Thu, 30 May 2024 21:37:25 +0200
Subject: [PATCH 23/24] reword `(binary ...)` doc section

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Explainer.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/design/mvp/Explainer.md b/design/mvp/Explainer.md
index 3bd658aa..68b10203 100644
--- a/design/mvp/Explainer.md
+++ b/design/mvp/Explainer.md
@@ -1390,7 +1390,7 @@ f64canon ::= <core:f64> without the `nan:0x` case.
 
 The validation rules for `value` require the `val` to match the `valtype`.
 
-`(binary ...)` expression provides an alternative syntax allowing the binary contents
+The `(binary ...)` expression form provides an alternative syntax allowing the binary contents
 of the value definition to be written directly in the text format, analogous to data segments,
 avoiding the need to understand type information when encoding or decoding.
 

From 043b923e5e17853e34bc9df1387b8476fcec1342 Mon Sep 17 00:00:00 2001
From: Roman Volosatovs <rvolosatovs@riseup.net>
Date: Thu, 30 May 2024 21:39:47 +0200
Subject: [PATCH 24/24] replace unsized `uN` by a `u32`

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>
---
 design/mvp/Binary.md | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/design/mvp/Binary.md b/design/mvp/Binary.md
index cd6c3601..a3aa1574 100644
--- a/design/mvp/Binary.md
+++ b/design/mvp/Binary.md
@@ -358,7 +358,7 @@ Notes:
 (See [Value Definitions](Explainer.md#value-definitions) in the explainer.)
 
 ```ebnf
-value                      ::= t:<valtype> len:<uN> v:<val(t)>         => (value t v) (where len = ||v|| and N = ceil(sqrt(||v||)))
+value                      ::= t:<valtype> len:<core:u32> v:<val(t)>   => (value t v) (where len = ||v||)
 val(bool)                  ::= 0x00                                    => false
                              | 0x01                                    => true
 val(u8)                    ::= v:<core:byte>                           => v
@@ -404,7 +404,6 @@ Notes:
     - [`core:u16`]
     - [`core:u32`]
     - [`core:u64`]
-    - [`core:uN`]
     - [`core:f32`]
     - [`core:f64`]
     - [`core:utf8`]
@@ -448,7 +447,6 @@ named once.
 [`core:u32`]: https://webassembly.github.io/spec/core/binary/values.html#integers
 [`core:s64`]: https://webassembly.github.io/spec/core/binary/values.html#integers
 [`core:u64`]: https://webassembly.github.io/spec/core/binary/values.html#integers
-[`core:uN`]: https://webassembly.github.io/spec/core/binary/values.html#integers
 [`core:f32`]: https://webassembly.github.io/spec/core/binary/values.html#floating-point
 [`core:f64`]: https://webassembly.github.io/spec/core/binary/values.html#floating-point
 [`core:utf8`]: https://webassembly.github.io/spec/core/binary/values.html#binary-utf8