From eb51b116780ff03a4e42b99ce24727a450e3d018 Mon Sep 17 00:00:00 2001
From: Keith Cirkel <keithamus@users.noreply.github.com>
Date: Sun, 21 Jul 2024 23:36:58 +0100
Subject: [PATCH 01/18] add from() spec

---
 spec.bs | 155 ++++++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 152 insertions(+), 3 deletions(-)

diff --git a/spec.bs b/spec.bs
index 4afbb0a..c7f69fd 100644
--- a/spec.bs
+++ b/spec.bs
@@ -26,6 +26,13 @@ WPT Display: open
 urlPrefix: https://tc39.es/ecma262/#; spec: ECMASCRIPT
   type: dfn
     text: current realm
+    text: an Object; url: sec-object-type
+    text: IsPromise; url: sec-ispromise
+    text: GetMethod; url: sec-getmethod
+    text: GetIteratorFromMethod; url: sec-getiteratorfrommethod
+    text: IteratorStepValue; url: sec-iteratorstepvalue
+    text: normal completion; url: sec-normalcompletion
+    text: throw completion; url: sec-throwcompletion
 urlPrefix: https://dom.spec.whatwg.org; spec: DOM
   type: dfn
     for: event listener
@@ -38,6 +45,11 @@ urlPrefix: https://dom.spec.whatwg.org; spec: DOM
       text: dependent signals; url: abortsignal-dependent-signals
       text: signal abort; url:abortsignal-signal-abort
       text: abort reason; url:abortsignal-abort-reason
+urlPrefix: https://webidl.spec.whatwg.org; spec: WEBIDL
+  type: dfn
+    text: a promise rejected with
+  type: dfn
+    text: react
 </pre>
 
 <style>
@@ -371,7 +383,7 @@ interface Observable {
   //
   // takeUntil() can consume promises, iterables, async iterables, and other
   // observables.
-  Observable takeUntil(any notifier);
+  Observable takeUntil(any value);
   Observable map(Mapper mapper);
   Observable filter(Predicate predicate);
   Observable take(unsigned long long amount);
@@ -461,6 +473,133 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
   [[#promise-returning-operators]] that make use of this, for example.</p>
 </div>
 
+<div algorithm>
+  To <dfn for=Observable>convert to an Observable</dfn> given an {{any}} |value|, run these steps:
+
+  Note: We split this algorithm out from the Web IDL {{Observable/from()}} method, so that
+  spec prose can <a for=Observable lt="convert to an observable">convert</a> an {{Observable}}
+  without going through the Web IDL bindings.
+
+  Note: The resolution of value to its descrete types happens before
+  [=Observable/subscribe callback=] is called. This means mutations of values, such as adding
+  the iterable protocols to the object, will not take affect between the creation of the returned
+  observable, and when it is subscribed to.
+
+    1. If |value| is not [=an Object=], throw a {{TypeError}}.
+
+    Note: This prevents primitive types from being coerced into iterables (e.g. String).
+
+    1. If |value| is an {{Observable}}, then return |value|.
+
+    1. Let |asyncIteratorMethodRecord| be ? [=GetMethod=](|value|, %Symbol.asyncIterator%).
+
+    1. If |asyncIteratorMethodRecord|'s \[[Value]] is not undefined, then:
+
+       Note: [=GetMethod=] might return a [=normal completion=] with an undefined value when the
+       object simply has no asyncIterator method.
+
+       1. Let |nextAlgorithm| be the following steps, given |subscriber| and |iterator|:
+
+          1. If |iterator|'s \[[Done]] is true, then:
+          
+             1. Run |subscriber|'s {{Subscriber/complete()}} method and abort these steps.
+
+          1. Let |nextRecord| be [=IteratorStepValue=](|iterator|).
+
+          1. Let |nextPromise| be undefined.
+
+          1.  If |nextRecord| is a [=throw completion=] then:
+
+              1. Set |nextPromise| to [=a promise rejected with=] |nextRecord|'s \[[Value]].
+
+          1. Otherwise, set |nextPromise| to |nextRecord|'s \[[Value]].
+
+          1. React to |nextPromise|:
+
+             1. If |nextPromise| was fulfilled with value |v|, then:
+
+                1. Run |subscriber|'s {{Subscriber/next()}} method, given |v|.
+
+                1. Run |nextAlgorithm|, given |subscriber| and |iterator|.
+
+             1. If |nextPromise| was rejected with reason |r|, then run |subscriber|'s
+                {{Subscriber/error()}} method, given |r|.
+
+       1. Return a [=new=] {{Observable}} whose [=Observable/subscribe callback=] is an
+          algorithm that takes a {{Subscriber}} |subscriber| and does the following:
+
+          1. Let |iteratorRecord| be [=GetIteratorFromMethod=](|value|, %Symbol.asyncIterator%).
+
+          1. If |iteratorRecord| is a [=throw completion=] then:
+
+             1. [=queue a microtask=] to perform the following steps:
+
+                1. Run |subscriber|'s {{Subscriber/error()}} method, given |iteratorRecord|'s \[[Value]].
+
+          1. Otherwise, [=queue a microtask=] to perform the following steps:
+
+             1. Run |nextAlgorithm| given |subscriber| and |iteratorRecord|'s \[[Value]].
+
+          Note: It is important to [=queue a microtask=] in both branches here to guarantee that
+          coercing an AsyncIterable never stops the Subscription synchronously, thereby releasing
+          Zalgo.
+
+    1. Let |iteratorMethodRecord| be ? [=GetMethod=](|value|, %Symbol.iterator%).
+
+    1. If |iteratorMethodRecord|'s \[[Value]] is not undefined, then:
+
+       Note: [=GetMethod=] might return a [=normal completion=] with an undefined value when the
+       object simply has no asyncIterator method.
+
+       1. Return a [=new=] {{Observable}} whose [=Observable/subscribe callback=] is an
+          algorithm that takes a {{Subscriber}} |subscriber| and does the following:
+
+          1. Let |iteratorRecord| be [=GetIteratorFromMethod=](|value|, %Symbol.iterator%).
+
+          1. If |iteratorRecord| is a [=throw completion=] then:
+
+             1. Run |subscriber|'s {{Subscriber/error()}} method, given |iteratorRecord|'s \[[Value]].
+
+             1. Abort these steps.
+
+          1. Let |iterator| be |iteratorRecord|'s \[[Value]].
+
+          1. Repeat:
+
+             1. If |iterator|'s \[[Done]] is true, then:
+
+                1. Run |subscriber|'s {{Subscriber/complete()}} method and abort these steps.
+
+             1. Let |nextRecord| be [=IteratorStepValue=](|iterator|).
+
+             1. If |nextRecord| is a [=throw completion=] then:
+
+                1. Run |subscriber|'s {{Subscriber/error()}} method, given |nextRecord|'s \[[Value]].
+
+                1. Abort these steps.
+
+             1. Run |subscriber|'s {{Subscriber/next()}} given |nextRecord|'s \[[Value]].
+
+    1. If [=IsPromise=](|value|) is true, then:
+
+       1. Return a [=new=] {{Observable}} whose [=Observable/subscribe callback=] is an
+          algorithm that takes a {{Subscriber}} |subscriber| and does the following:
+
+          1. React to |value|:
+
+             1. If |value| was fulfilled with value |v|, then:
+
+                1. Run |subscriber|'s {{Subscriber/next()}} method, given |v|.
+
+                1. Run |subscriber|'s {{Subscriber/complete()}} method.
+
+             1. If |value| was rejected with reason |r|, then run |subscriber|'s
+                {{Subscriber/error()}} method, given |r|.
+
+    1. Throw a {{TypeError}}.
+
+</div>
+
 <div algorithm>
   To <dfn for=Observable>subscribe to an {{Observable}}</dfn> given an
   {{ObserverUnion}}-or-[=internal observer=] |observer|, and a {{SubscribeOptions}} |options|, run
@@ -577,15 +716,25 @@ For now, see [https://github.com/wicg/observable#operators](https://github.com/w
 
 <h4 id=observable-from>{{Observable/from()}}</h4>
 
-<p class=XXX>Spec the exact semantics of {{Observable/from()}} conversion.</p>
+<div algorithm>
+  The <dfn for=Observable method><code>from(|value|)</code></dfn> method steps
+  are:
+
+    1. Return the result of <a for=Observable lt="convert to an Observable">
+       converting</a> |value| to an Observable.
+
+</div>
 
 <h4 id=observable-returning-operators>{{Observable}}-returning operators</h4>
 
 <div algorithm>
-  The <dfn for=Observable method><code>takeUntil(|notifier|)</code></dfn> method steps are:
+  The <dfn for=Observable method><code>takeUntil(|value|)</code></dfn> method steps are:
 
     1. Let |sourceObservable| be [=this=].
 
+    1. Let |notifier| be the result of <a for=Observable lt="convert to an Observable">
+       converting</a> |value| to an Observable.
+
     1. Let |observable| be a [=new=] {{Observable}} whose [=Observable/subscribe callback=] is an
        algorithm that takes a {{Subscriber}} |subscriber| and does the following:
 

From ca59164c7451a9a10df9712408791af0b7a82a84 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Wed, 28 Aug 2024 15:40:50 -0400
Subject: [PATCH 02/18] Fix-ups

---
 spec.bs | 57 ++++++++++++++++++++++++++++++++-------------------------
 1 file changed, 32 insertions(+), 25 deletions(-)

diff --git a/spec.bs b/spec.bs
index c7f69fd..32df529 100644
--- a/spec.bs
+++ b/spec.bs
@@ -26,13 +26,15 @@ WPT Display: open
 urlPrefix: https://tc39.es/ecma262/#; spec: ECMASCRIPT
   type: dfn
     text: current realm
-    text: an Object; url: sec-object-type
-    text: IsPromise; url: sec-ispromise
-    text: GetMethod; url: sec-getmethod
+    text: Object; url: sec-object-type
     text: GetIteratorFromMethod; url: sec-getiteratorfrommethod
     text: IteratorStepValue; url: sec-iteratorstepvalue
     text: normal completion; url: sec-normalcompletion
     text: throw completion; url: sec-throwcompletion
+    url: sec-returnifabrupt-shorthands
+      text: ?
+  type: abstract-op
+    text: Type; url: sec-ecmascript-data-types-and-values
 urlPrefix: https://dom.spec.whatwg.org; spec: DOM
   type: dfn
     for: event listener
@@ -485,18 +487,24 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
   the iterable protocols to the object, will not take affect between the creation of the returned
   observable, and when it is subscribed to.
 
-    1. If |value| is not [=an Object=], throw a {{TypeError}}.
+    1. If [$Type$](|value|) is not [=Object=], [=exception/throw=] a {{TypeError}}.
 
-    Note: This prevents primitive types from being coerced into iterables (e.g. String).
+       Note: This prevents primitive types from being coerced into iterables (e.g., String).
 
-    1. If |value| is an {{Observable}}, then return |value|.
+       Issue: See if this is even the behavior we want. See <a
+       href=https://github.com/WICG/observable/issues/125>WICG/observable#125</a>
 
-    1. Let |asyncIteratorMethodRecord| be ? [=GetMethod=](|value|, %Symbol.asyncIterator%).
+    1. If |value|'s [=specific type=] is an {{Observable}}, then return |value|.
+
+    1. Let |asyncIteratorMethodRecord| be [=?=] [$GetMethod$](|value|, {{%Symbol.asyncIterator%}}).
+
+       Issue: TODO(dom or keith): This looks wrong. We certainly cannot return abrupt completions
+       from this method directly to JS.
 
     1. If |asyncIteratorMethodRecord|'s \[[Value]] is not undefined, then:
 
-       Note: [=GetMethod=] might return a [=normal completion=] with an undefined value when the
-       object simply has no asyncIterator method.
+       Note: [$GetMethod$] might return a [=normal completion=] with an undefined value when the
+       object simply has no {{%Symbol.asyncIterator%}} method.
 
        1. Let |nextAlgorithm| be the following steps, given |subscriber| and |iterator|:
 
@@ -514,7 +522,7 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
 
           1. Otherwise, set |nextPromise| to |nextRecord|'s \[[Value]].
 
-          1. React to |nextPromise|:
+          1. [=React=] to |nextPromise|:
 
              1. If |nextPromise| was fulfilled with value |v|, then:
 
@@ -528,11 +536,11 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
        1. Return a [=new=] {{Observable}} whose [=Observable/subscribe callback=] is an
           algorithm that takes a {{Subscriber}} |subscriber| and does the following:
 
-          1. Let |iteratorRecord| be [=GetIteratorFromMethod=](|value|, %Symbol.asyncIterator%).
+          1. Let |iteratorRecord| be [=GetIteratorFromMethod=](|value|, {{%Symbol.asyncIterator%}}).
 
           1. If |iteratorRecord| is a [=throw completion=] then:
 
-             1. [=queue a microtask=] to perform the following steps:
+             1. [=Queue a microtask=] to perform the following steps:
 
                 1. Run |subscriber|'s {{Subscriber/error()}} method, given |iteratorRecord|'s \[[Value]].
 
@@ -544,11 +552,13 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
           coercing an AsyncIterable never stops the Subscription synchronously, thereby releasing
           Zalgo.
 
-    1. Let |iteratorMethodRecord| be ? [=GetMethod=](|value|, %Symbol.iterator%).
+    1. Let |iteratorMethodRecord| be [=?=] [$GetMethod$](|value|, %Symbol.iterator%).
+
+       Issue: TODO(dom or keith): Same issue as above with abrupt (throw) completions.
 
     1. If |iteratorMethodRecord|'s \[[Value]] is not undefined, then:
 
-       Note: [=GetMethod=] might return a [=normal completion=] with an undefined value when the
+       Note: [$GetMethod$] might return a [=normal completion=] with an undefined value when the
        object simply has no asyncIterator method.
 
        1. Return a [=new=] {{Observable}} whose [=Observable/subscribe callback=] is an
@@ -580,12 +590,12 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
 
              1. Run |subscriber|'s {{Subscriber/next()}} given |nextRecord|'s \[[Value]].
 
-    1. If [=IsPromise=](|value|) is true, then:
+    1. If [$IsPromise$](|value|) is true, then:
 
-       1. Return a [=new=] {{Observable}} whose [=Observable/subscribe callback=] is an
-          algorithm that takes a {{Subscriber}} |subscriber| and does the following:
+       1. Return a [=new=] {{Observable}} whose [=Observable/subscribe callback=] is an algorithm
+          that takes a {{Subscriber}} |subscriber| and does the following:
 
-          1. React to |value|:
+          1. [=React=] to |value|:
 
              1. If |value| was fulfilled with value |v|, then:
 
@@ -596,8 +606,7 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
              1. If |value| was rejected with reason |r|, then run |subscriber|'s
                 {{Subscriber/error()}} method, given |r|.
 
-    1. Throw a {{TypeError}}.
-
+    1. [=exception/Throw=] a {{TypeError}}.
 </div>
 
 <div algorithm>
@@ -717,12 +726,10 @@ For now, see [https://github.com/wicg/observable#operators](https://github.com/w
 <h4 id=observable-from>{{Observable/from()}}</h4>
 
 <div algorithm>
-  The <dfn for=Observable method><code>from(|value|)</code></dfn> method steps
-  are:
-
-    1. Return the result of <a for=Observable lt="convert to an Observable">
-       converting</a> |value| to an Observable.
+  The <dfn for=Observable method><code>from(|value|)</code></dfn> method steps are:
 
+    1. Return the result of <a for=Observable lt="convert to an Observable">converting</a> |value|
+       to an {{Observable}}. Rethrow any exceptions.
 </div>
 
 <h4 id=observable-returning-operators>{{Observable}}-returning operators</h4>

From 742a5a803cfdddf2e74749a74862488218c38926 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Wed, 28 Aug 2024 17:00:12 -0400
Subject: [PATCH 03/18] Remove TODOs now that domenic clarified the boundary

---
 spec.bs | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/spec.bs b/spec.bs
index 32df529..b9f4670 100644
--- a/spec.bs
+++ b/spec.bs
@@ -498,9 +498,6 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
 
     1. Let |asyncIteratorMethodRecord| be [=?=] [$GetMethod$](|value|, {{%Symbol.asyncIterator%}}).
 
-       Issue: TODO(dom or keith): This looks wrong. We certainly cannot return abrupt completions
-       from this method directly to JS.
-
     1. If |asyncIteratorMethodRecord|'s \[[Value]] is not undefined, then:
 
        Note: [$GetMethod$] might return a [=normal completion=] with an undefined value when the
@@ -554,8 +551,6 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
 
     1. Let |iteratorMethodRecord| be [=?=] [$GetMethod$](|value|, %Symbol.iterator%).
 
-       Issue: TODO(dom or keith): Same issue as above with abrupt (throw) completions.
-
     1. If |iteratorMethodRecord|'s \[[Value]] is not undefined, then:
 
        Note: [$GetMethod$] might return a [=normal completion=] with an undefined value when the

From 11ea95356e33169e0a1868a4db594e1ab5c66c6a Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Wed, 28 Aug 2024 22:41:17 -0400
Subject: [PATCH 04/18] Start to match more of the WPTs, including
 crrev.com/c/5824955

---
 spec.bs | 46 ++++++++++++++++++++++++++++++++++------------
 1 file changed, 34 insertions(+), 12 deletions(-)

diff --git a/spec.bs b/spec.bs
index b9f4670..3c59718 100644
--- a/spec.bs
+++ b/spec.bs
@@ -494,14 +494,27 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
        Issue: See if this is even the behavior we want. See <a
        href=https://github.com/WICG/observable/issues/125>WICG/observable#125</a>
 
-    1. If |value|'s [=specific type=] is an {{Observable}}, then return |value|.
+    1. <i id=from-observable-conversion>From Observable</i>: If |value|'s [=specific type=] is an
+       {{Observable}}, then return |value|.
 
-    1. Let |asyncIteratorMethodRecord| be [=?=] [$GetMethod$](|value|, {{%Symbol.asyncIterator%}}).
+    1. <i id=from-async-iterable-conversion>From async iterator</i>: Let |asyncIteratorMethodRecord|
+       be [=?=] [$GetMethod$](|value|, {{%Symbol.asyncIterator%}}).
 
-    1. If |asyncIteratorMethodRecord|'s \[[Value]] is not undefined, then:
+       Note: We have to use [$GetMethod$] directly instead of [$GetIterator$], because
+       [$GetIterator$] makes it impossible to distinguish between (a) the case where |value| simply
+       doesn't implement any iterable protocol, and (b) the case where |value| implements one of the
+       iterator protocols, and its method getter throws an exception.
 
-       Note: [$GetMethod$] might return a [=normal completion=] with an undefined value when the
-       object simply has no {{%Symbol.asyncIterator%}} method.
+       Note: This step is web-observable, and results in re-throwing any errors that the
+       {{%Symbol.iterator%}} method *getter* might have thrown.
+
+    1. If |asyncIteratorMethodRecord|'s \[[Value]] is undefined or null, then jump to the step
+       labeled <a href=#from-iterable-conversion>From iterable</a>.
+
+    1. If [$IsCallable$](|asyncIteratorMethodRecord|'s \[[Value]]) is false, then
+       [=exception/throw=] a {{TypeError}}.
+
+       Otherwise:
 
        1. Let |nextAlgorithm| be the following steps, given |subscriber| and |iterator|:
 
@@ -549,12 +562,19 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
           coercing an AsyncIterable never stops the Subscription synchronously, thereby releasing
           Zalgo.
 
-    1. Let |iteratorMethodRecord| be [=?=] [$GetMethod$](|value|, %Symbol.iterator%).
+    1. <i id=from-iterable-conversion>From iterable</i>: Let |iteratorMethodRecord| be [=?=]
+       [$GetMethod$](|value|, {{%Symbol.iterator%}}).
+
+       Note: This step is web-observable, and results in re-throwing any errors that the
+       {{%Symbol.iterator%}} method *getter* might have thrown.
+
+    1. If |iteratorMethodRecord|'s \[[Value]] is undefined or null, then jump to the step labeled <a
+       href=#from-promise-conversion>From Promise</a>.
 
-    1. If |iteratorMethodRecord|'s \[[Value]] is not undefined, then:
+    1. If [$IsCallable$](|iteratorMethodRecord|'s \[[Value]]) is false, then [=exception/throw=] a
+       {{TypeError}}.
 
-       Note: [$GetMethod$] might return a [=normal completion=] with an undefined value when the
-       object simply has no asyncIterator method.
+       Otherwise:
 
        1. Return a [=new=] {{Observable}} whose [=Observable/subscribe callback=] is an
           algorithm that takes a {{Subscriber}} |subscriber| and does the following:
@@ -563,7 +583,8 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
 
           1. If |iteratorRecord| is a [=throw completion=] then:
 
-             1. Run |subscriber|'s {{Subscriber/error()}} method, given |iteratorRecord|'s \[[Value]].
+             1. Run |subscriber|'s {{Subscriber/error()}} method, given |iteratorRecord|'s
+                \[[Value]].
 
              1. Abort these steps.
 
@@ -579,13 +600,14 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
 
              1. If |nextRecord| is a [=throw completion=] then:
 
-                1. Run |subscriber|'s {{Subscriber/error()}} method, given |nextRecord|'s \[[Value]].
+                1. Run |subscriber|'s {{Subscriber/error()}} method, given |nextRecord|'s
+                   \[[Value]].
 
                 1. Abort these steps.
 
              1. Run |subscriber|'s {{Subscriber/next()}} given |nextRecord|'s \[[Value]].
 
-    1. If [$IsPromise$](|value|) is true, then:
+    1. <i id=from-promise-conversion>From Promise</i>: If [$IsPromise$](|value|) is true, then:
 
        1. Return a [=new=] {{Observable}} whose [=Observable/subscribe callback=] is an algorithm
           that takes a {{Subscriber}} |subscriber| and does the following:

From e5c1c9addfbea817e9ea513c6f649be8a05f197a Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Wed, 28 Aug 2024 22:47:03 -0400
Subject: [PATCH 05/18] Link `{{%Symbol.iterator%}}`

---
 spec.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spec.bs b/spec.bs
index 3c59718..bb10c44 100644
--- a/spec.bs
+++ b/spec.bs
@@ -579,7 +579,7 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
        1. Return a [=new=] {{Observable}} whose [=Observable/subscribe callback=] is an
           algorithm that takes a {{Subscriber}} |subscriber| and does the following:
 
-          1. Let |iteratorRecord| be [=GetIteratorFromMethod=](|value|, %Symbol.iterator%).
+          1. Let |iteratorRecord| be [=GetIteratorFromMethod=](|value|, {{%Symbol.iterator%}}).
 
           1. If |iteratorRecord| is a [=throw completion=] then:
 

From d1aa196d124959151191ad09e3f0bae165fea9b1 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Thu, 29 Aug 2024 13:55:01 -0400
Subject: [PATCH 06/18] Iterator adjustments and indent/nesting

---
 spec.bs | 102 +++++++++++++++++++++++++++-----------------------------
 1 file changed, 49 insertions(+), 53 deletions(-)

diff --git a/spec.bs b/spec.bs
index bb10c44..fc71099 100644
--- a/spec.bs
+++ b/spec.bs
@@ -27,7 +27,6 @@ urlPrefix: https://tc39.es/ecma262/#; spec: ECMASCRIPT
   type: dfn
     text: current realm
     text: Object; url: sec-object-type
-    text: GetIteratorFromMethod; url: sec-getiteratorfrommethod
     text: IteratorStepValue; url: sec-iteratorstepvalue
     text: normal completion; url: sec-normalcompletion
     text: throw completion; url: sec-throwcompletion
@@ -494,11 +493,11 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
        Issue: See if this is even the behavior we want. See <a
        href=https://github.com/WICG/observable/issues/125>WICG/observable#125</a>
 
-    1. <i id=from-observable-conversion>From Observable</i>: If |value|'s [=specific type=] is an
-       {{Observable}}, then return |value|.
+    1. <i id=from-observable-conversion><b>From Observable</b></i>: If |value|'s [=specific type=]
+       is an {{Observable}}, then return |value|.
 
-    1. <i id=from-async-iterable-conversion>From async iterator</i>: Let |asyncIteratorMethodRecord|
-       be [=?=] [$GetMethod$](|value|, {{%Symbol.asyncIterator%}}).
+    1. <i id=from-async-iterable-conversion><b>From async iterator</b></i>: Let
+       |asyncIteratorMethodRecord| be [=?=] [$GetMethod$](|value|, {{%Symbol.asyncIterator%}}).
 
        Note: We have to use [$GetMethod$] directly instead of [$GetIterator$], because
        [$GetIterator$] makes it impossible to distinguish between (a) the case where |value| simply
@@ -514,55 +513,53 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
     1. If [$IsCallable$](|asyncIteratorMethodRecord|'s \[[Value]]) is false, then
        [=exception/throw=] a {{TypeError}}.
 
-       Otherwise:
+       Otherwise, let |nextAlgorithm| be the following steps, given |subscriber| and |iterator|:
 
-       1. Let |nextAlgorithm| be the following steps, given |subscriber| and |iterator|:
-
-          1. If |iterator|'s \[[Done]] is true, then:
+         1. If |iterator|'s \[[Done]] is true, then:
           
-             1. Run |subscriber|'s {{Subscriber/complete()}} method and abort these steps.
+            1. Run |subscriber|'s {{Subscriber/complete()}} method and abort these steps.
 
-          1. Let |nextRecord| be [=IteratorStepValue=](|iterator|).
+         1. Let |nextRecord| be [=IteratorStepValue=](|iterator|).
 
-          1. Let |nextPromise| be undefined.
+         1. Let |nextPromise| be undefined.
 
-          1.  If |nextRecord| is a [=throw completion=] then:
+         1.  If |nextRecord| is a [=throw completion=] then:
 
-              1. Set |nextPromise| to [=a promise rejected with=] |nextRecord|'s \[[Value]].
+             1. Set |nextPromise| to [=a promise rejected with=] |nextRecord|'s \[[Value]].
 
-          1. Otherwise, set |nextPromise| to |nextRecord|'s \[[Value]].
+         1. Otherwise, set |nextPromise| to |nextRecord|'s \[[Value]].
 
-          1. [=React=] to |nextPromise|:
+         1. [=React=] to |nextPromise|:
 
-             1. If |nextPromise| was fulfilled with value |v|, then:
+            1. If |nextPromise| was fulfilled with value |v|, then:
 
-                1. Run |subscriber|'s {{Subscriber/next()}} method, given |v|.
+               1. Run |subscriber|'s {{Subscriber/next()}} method, given |v|.
 
-                1. Run |nextAlgorithm|, given |subscriber| and |iterator|.
+               1. Run |nextAlgorithm|, given |subscriber| and |iterator|.
 
-             1. If |nextPromise| was rejected with reason |r|, then run |subscriber|'s
-                {{Subscriber/error()}} method, given |r|.
+            1. If |nextPromise| was rejected with reason |r|, then run |subscriber|'s
+               {{Subscriber/error()}} method, given |r|.
 
-       1. Return a [=new=] {{Observable}} whose [=Observable/subscribe callback=] is an
-          algorithm that takes a {{Subscriber}} |subscriber| and does the following:
+    1. Return a [=new=] {{Observable}} whose [=Observable/subscribe callback=] is an algorithm that
+       takes a {{Subscriber}} |subscriber| and does the following:
 
-          1. Let |iteratorRecord| be [=GetIteratorFromMethod=](|value|, {{%Symbol.asyncIterator%}}).
+       1. Let |iteratorRecord| be [$GetIteratorFromMethod$](|value|, {{%Symbol.asyncIterator%}}).
 
-          1. If |iteratorRecord| is a [=throw completion=] then:
+       1. If |iteratorRecord| is a [=throw completion=] then:
 
-             1. [=Queue a microtask=] to perform the following steps:
+          1. [=Queue a microtask=] to perform the following steps:
 
-                1. Run |subscriber|'s {{Subscriber/error()}} method, given |iteratorRecord|'s \[[Value]].
+             1. Run |subscriber|'s {{Subscriber/error()}} method, given |iteratorRecord|'s \[[Value]].
 
-          1. Otherwise, [=queue a microtask=] to perform the following steps:
+       1. Otherwise, [=queue a microtask=] to perform the following steps:
 
-             1. Run |nextAlgorithm| given |subscriber| and |iteratorRecord|'s \[[Value]].
+          1. Run |nextAlgorithm| given |subscriber| and |iteratorRecord|'s \[[Value]].
 
-          Note: It is important to [=queue a microtask=] in both branches here to guarantee that
-          coercing an AsyncIterable never stops the Subscription synchronously, thereby releasing
-          Zalgo.
+       Note: It is important to [=queue a microtask=] in both branches here to guarantee that
+       coercing an AsyncIterable never stops the Subscription synchronously, thereby releasing
+       Zalgo.
 
-    1. <i id=from-iterable-conversion>From iterable</i>: Let |iteratorMethodRecord| be [=?=]
+    1. <i id=from-iterable-conversion><b>From iterable</b></i>: Let |iteratorMethodRecord| be [=?=]
        [$GetMethod$](|value|, {{%Symbol.iterator%}}).
 
        Note: This step is web-observable, and results in re-throwing any errors that the
@@ -574,40 +571,39 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
     1. If [$IsCallable$](|iteratorMethodRecord|'s \[[Value]]) is false, then [=exception/throw=] a
        {{TypeError}}.
 
-       Otherwise:
-
-       1. Return a [=new=] {{Observable}} whose [=Observable/subscribe callback=] is an
-          algorithm that takes a {{Subscriber}} |subscriber| and does the following:
+       Otherwise, return a [=new=] {{Observable}} whose [=Observable/subscribe callback=] is an
+       algorithm that takes a {{Subscriber}} |subscriber| and does the following:
 
-          1. Let |iteratorRecord| be [=GetIteratorFromMethod=](|value|, {{%Symbol.iterator%}}).
+         1. Let |iteratorRecord| be [$GetIteratorFromMethod$](|value|, {{%Symbol.iterator%}}).
 
-          1. If |iteratorRecord| is a [=throw completion=] then:
+         1. If |iteratorRecord| is a [=throw completion=] then:
 
-             1. Run |subscriber|'s {{Subscriber/error()}} method, given |iteratorRecord|'s
-                \[[Value]].
+            1. Run |subscriber|'s {{Subscriber/error()}} method, given |iteratorRecord|'s
+               \[[Value]].
 
-             1. Abort these steps.
+            1. Abort these steps.
 
-          1. Let |iterator| be |iteratorRecord|'s \[[Value]].
+         1. Let |iterator| be |iteratorRecord|'s \[[Value]].
 
-          1. Repeat:
+         1. Repeat:
 
-             1. If |iterator|'s \[[Done]] is true, then:
+            1. If |iterator|'s \[[Done]] is true, then:
 
-                1. Run |subscriber|'s {{Subscriber/complete()}} method and abort these steps.
+               1. Run |subscriber|'s {{Subscriber/complete()}} method and abort these steps.
 
-             1. Let |nextRecord| be [=IteratorStepValue=](|iterator|).
+            1. Let |nextRecord| be [=IteratorStepValue=](|iterator|).
 
-             1. If |nextRecord| is a [=throw completion=] then:
+            1. If |nextRecord| is a [=throw completion=] then:
 
-                1. Run |subscriber|'s {{Subscriber/error()}} method, given |nextRecord|'s
-                   \[[Value]].
+               1. Run |subscriber|'s {{Subscriber/error()}} method, given |nextRecord|'s
+                  \[[Value]].
 
-                1. Abort these steps.
+               1. Abort these steps.
 
-             1. Run |subscriber|'s {{Subscriber/next()}} given |nextRecord|'s \[[Value]].
+            1. Run |subscriber|'s {{Subscriber/next()}} given |nextRecord|'s \[[Value]].
 
-    1. <i id=from-promise-conversion>From Promise</i>: If [$IsPromise$](|value|) is true, then:
+    1. <i id=from-promise-conversion><b>From Promise</b></i>: If [$IsPromise$](|value|) is true,
+       then:
 
        1. Return a [=new=] {{Observable}} whose [=Observable/subscribe callback=] is an algorithm
           that takes a {{Subscriber}} |subscriber| and does the following:

From 199ea622505d6548b7e84d30e5de9696b6141990 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Thu, 29 Aug 2024 15:51:59 -0400
Subject: [PATCH 07/18] Clean up and probably finish sync iterable conversion

---
 spec.bs | 37 +++++++++++++++++--------------------
 1 file changed, 17 insertions(+), 20 deletions(-)

diff --git a/spec.bs b/spec.bs
index fc71099..dc7e1a1 100644
--- a/spec.bs
+++ b/spec.bs
@@ -27,7 +27,6 @@ urlPrefix: https://tc39.es/ecma262/#; spec: ECMASCRIPT
   type: dfn
     text: current realm
     text: Object; url: sec-object-type
-    text: IteratorStepValue; url: sec-iteratorstepvalue
     text: normal completion; url: sec-normalcompletion
     text: throw completion; url: sec-throwcompletion
     url: sec-returnifabrupt-shorthands
@@ -519,7 +518,7 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
           
             1. Run |subscriber|'s {{Subscriber/complete()}} method and abort these steps.
 
-         1. Let |nextRecord| be [=IteratorStepValue=](|iterator|).
+         1. Let |nextRecord| be [$IteratorStepValue$](|iterator|).
 
          1. Let |nextPromise| be undefined.
 
@@ -574,33 +573,31 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
        Otherwise, return a [=new=] {{Observable}} whose [=Observable/subscribe callback=] is an
        algorithm that takes a {{Subscriber}} |subscriber| and does the following:
 
-         1. Let |iteratorRecord| be [$GetIteratorFromMethod$](|value|, {{%Symbol.iterator%}}).
+         1. Let |iteratorRecord| be [$GetIterator$](|value|, sync).
 
-         1. If |iteratorRecord| is a [=throw completion=] then:
+            Note: This re-invokes any method getters for the {{%Symbol.iterator%}} method on
+            |value|. Whether or not this is desirable is an extreme corner case, but this behavior
+            currently matches what is expected by tests. See <a
+            href=https://github.com/WICG/observable/issues/127>issue#127</a> for discussion.
 
-            1. Run |subscriber|'s {{Subscriber/error()}} method, given |iteratorRecord|'s
-               \[[Value]].
-
-            1. Abort these steps.
+         1. If |iteratorRecord| is a [=throw completion=], then run |subscriber|'s
+            {{Subscriber/error()}} method, given |iteratorRecord|'s \[[Value]], and abort these
+            steps.
 
          1. Let |iterator| be |iteratorRecord|'s \[[Value]].
 
-         1. Repeat:
-
-            1. If |iterator|'s \[[Done]] is true, then:
-
-               1. Run |subscriber|'s {{Subscriber/complete()}} method and abort these steps.
-
-            1. Let |nextRecord| be [=IteratorStepValue=](|iterator|).
+         1. [=iteration/While=] true:
 
-            1. If |nextRecord| is a [=throw completion=] then:
+            1. If |iterator|'s \[[Done]] is true, then run |subscriber|'s {{Subscriber/complete()}}
+               method, and [=iteration/break=].
 
-               1. Run |subscriber|'s {{Subscriber/error()}} method, given |nextRecord|'s
-                  \[[Value]].
+            1. Let |nextRecord| be [$IteratorStepValue$](|iterator|).
 
-               1. Abort these steps.
+            1. If |nextRecord| is a [=throw completion=], then run |subscriber|'s
+               {{Subscriber/error()}} method, given |nextRecord|'s \[[Value]], and
+               [=iteration/break=].
 
-            1. Run |subscriber|'s {{Subscriber/next()}} given |nextRecord|'s \[[Value]].
+               Otherwise, run |subscriber|'s {{Subscriber/next()}} given |nextRecord|'s \[[Value]].
 
     1. <i id=from-promise-conversion><b>From Promise</b></i>: If [$IsPromise$](|value|) is true,
        then:

From e28cc676b28ac104ebde662495b98c96c0d70f11 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Fri, 30 Aug 2024 11:57:21 -0400
Subject: [PATCH 08/18] Small changes, mostly readability

---
 spec.bs | 30 ++++++++++++------------------
 1 file changed, 12 insertions(+), 18 deletions(-)

diff --git a/spec.bs b/spec.bs
index dc7e1a1..a5a35cc 100644
--- a/spec.bs
+++ b/spec.bs
@@ -503,8 +503,8 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
        doesn't implement any iterable protocol, and (b) the case where |value| implements one of the
        iterator protocols, and its method getter throws an exception.
 
-       Note: This step is web-observable, and results in re-throwing any errors that the
-       {{%Symbol.iterator%}} method *getter* might have thrown.
+       Note: This step is web-observable, and re-throws any errors that the {{%Symbol.iterator%}}
+       method *getter* might have thrown.
 
     1. If |asyncIteratorMethodRecord|'s \[[Value]] is undefined or null, then jump to the step
        labeled <a href=#from-iterable-conversion>From iterable</a>.
@@ -514,17 +514,15 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
 
        Otherwise, let |nextAlgorithm| be the following steps, given |subscriber| and |iterator|:
 
-         1. If |iterator|'s \[[Done]] is true, then:
-          
-            1. Run |subscriber|'s {{Subscriber/complete()}} method and abort these steps.
+         1. If |iterator|'s \[[Done]] is true, then: run |subscriber|'s {{Subscriber/complete()}}
+            method and abort these steps.
 
          1. Let |nextRecord| be [$IteratorStepValue$](|iterator|).
 
          1. Let |nextPromise| be undefined.
 
-         1.  If |nextRecord| is a [=throw completion=] then:
-
-             1. Set |nextPromise| to [=a promise rejected with=] |nextRecord|'s \[[Value]].
+         1.  If |nextRecord| is a [=throw completion=], then set |nextPromise| to [=a promise
+             rejected with=] |nextRecord|'s \[[Value]].
 
          1. Otherwise, set |nextPromise| to |nextRecord|'s \[[Value]].
 
@@ -544,15 +542,11 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
 
        1. Let |iteratorRecord| be [$GetIteratorFromMethod$](|value|, {{%Symbol.asyncIterator%}}).
 
-       1. If |iteratorRecord| is a [=throw completion=] then:
-
-          1. [=Queue a microtask=] to perform the following steps:
-
-             1. Run |subscriber|'s {{Subscriber/error()}} method, given |iteratorRecord|'s \[[Value]].
-
-       1. Otherwise, [=queue a microtask=] to perform the following steps:
+       1. If |iteratorRecord| is a [=throw completion=], then [=queue a microtask=] to run
+          |subscriber|'s {{Subscriber/error()}} method, given |iteratorRecord|'s \[[Value]].
 
-          1. Run |nextAlgorithm| given |subscriber| and |iteratorRecord|'s \[[Value]].
+       1. Otherwise, [=queue a microtask=] to run |nextAlgorithm| given |subscriber| and
+          |iteratorRecord|'s \[[Value]].
 
        Note: It is important to [=queue a microtask=] in both branches here to guarantee that
        coercing an AsyncIterable never stops the Subscription synchronously, thereby releasing
@@ -561,8 +555,8 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
     1. <i id=from-iterable-conversion><b>From iterable</b></i>: Let |iteratorMethodRecord| be [=?=]
        [$GetMethod$](|value|, {{%Symbol.iterator%}}).
 
-       Note: This step is web-observable, and results in re-throwing any errors that the
-       {{%Symbol.iterator%}} method *getter* might have thrown.
+       Note: This step is web-observable, and re-throws any errors that the {{%Symbol.iterator%}}
+       method *getter* might have thrown.
 
     1. If |iteratorMethodRecord|'s \[[Value]] is undefined or null, then jump to the step labeled <a
        href=#from-promise-conversion>From Promise</a>.

From 5461f18345f210655b4afcc79c675a220978c942 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Fri, 30 Aug 2024 21:50:09 -0400
Subject: [PATCH 09/18] Spelling

---
 spec.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spec.bs b/spec.bs
index a5a35cc..44d7f01 100644
--- a/spec.bs
+++ b/spec.bs
@@ -482,7 +482,7 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
 
   Note: The resolution of value to its descrete types happens before
   [=Observable/subscribe callback=] is called. This means mutations of values, such as adding
-  the iterable protocols to the object, will not take affect between the creation of the returned
+  the iterable protocols to the object, will not take effect between the creation of the returned
   observable, and when it is subscribed to.
 
     1. If [$Type$](|value|) is not [=Object=], [=exception/throw=] a {{TypeError}}.

From 4c74aa8b0ab8046fe996855b0bcd69e941c1e6da Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Mon, 2 Sep 2024 10:22:24 -0400
Subject: [PATCH 10/18] GetIterator() instead of GetIteratorFromMethod()

---
 spec.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spec.bs b/spec.bs
index 44d7f01..59bf3eb 100644
--- a/spec.bs
+++ b/spec.bs
@@ -540,7 +540,7 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
     1. Return a [=new=] {{Observable}} whose [=Observable/subscribe callback=] is an algorithm that
        takes a {{Subscriber}} |subscriber| and does the following:
 
-       1. Let |iteratorRecord| be [$GetIteratorFromMethod$](|value|, {{%Symbol.asyncIterator%}}).
+       1. Let |iteratorRecord| be [$GetIterator$](|value|, async).
 
        1. If |iteratorRecord| is a [=throw completion=], then [=queue a microtask=] to run
           |subscriber|'s {{Subscriber/error()}} method, given |iteratorRecord|'s \[[Value]].

From d328e70c695e44a8f915971ac71580c2c78fb4ea Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Mon, 2 Sep 2024 10:44:14 -0400
Subject: [PATCH 11/18] Iterator Record

---
 spec.bs | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/spec.bs b/spec.bs
index 59bf3eb..853d7ca 100644
--- a/spec.bs
+++ b/spec.bs
@@ -512,19 +512,20 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
     1. If [$IsCallable$](|asyncIteratorMethodRecord|'s \[[Value]]) is false, then
        [=exception/throw=] a {{TypeError}}.
 
-       Otherwise, let |nextAlgorithm| be the following steps, given |subscriber| and |iterator|:
+    1. Let |nextAlgorithm| be the following steps, given a {{Subscriber}} |subscriber| and an
+       Iterator Record |iteratorRecord|:
 
-         1. If |iterator|'s \[[Done]] is true, then: run |subscriber|'s {{Subscriber/complete()}}
-            method and abort these steps.
+         1. If |iteratorRecord|'s \[[Done]] is true, then: run |subscriber|'s
+            {{Subscriber/complete()}} method and abort these steps.
 
-         1. Let |nextRecord| be [$IteratorStepValue$](|iterator|).
+         1. Let |nextRecord| be [$IteratorStepValue$](|iteratorRecord|).
 
          1. Let |nextPromise| be undefined.
 
-         1.  If |nextRecord| is a [=throw completion=], then set |nextPromise| to [=a promise
-             rejected with=] |nextRecord|'s \[[Value]].
+         1. If |nextRecord| is a [=throw completion=], then set |nextPromise| to [=a promise
+            rejected with=] |nextRecord|'s \[[Value]].
 
-         1. Otherwise, set |nextPromise| to |nextRecord|'s \[[Value]].
+            Otherwise, set |nextPromise| to |nextRecord|'s \[[Value]].
 
          1. [=React=] to |nextPromise|:
 
@@ -532,7 +533,7 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
 
                1. Run |subscriber|'s {{Subscriber/next()}} method, given |v|.
 
-               1. Run |nextAlgorithm|, given |subscriber| and |iterator|.
+               1. Run |nextAlgorithm|, given |subscriber| and |iteratorRecord|.
 
             1. If |nextPromise| was rejected with reason |r|, then run |subscriber|'s
                {{Subscriber/error()}} method, given |r|.
@@ -545,8 +546,8 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
        1. If |iteratorRecord| is a [=throw completion=], then [=queue a microtask=] to run
           |subscriber|'s {{Subscriber/error()}} method, given |iteratorRecord|'s \[[Value]].
 
-       1. Otherwise, [=queue a microtask=] to run |nextAlgorithm| given |subscriber| and
-          |iteratorRecord|'s \[[Value]].
+          Otherwise, [=queue a microtask=] to run |nextAlgorithm| given |subscriber| and
+          |iteratorRecord|.
 
        Note: It is important to [=queue a microtask=] in both branches here to guarantee that
        coercing an AsyncIterable never stops the Subscription synchronously, thereby releasing

From 4a34553cc13fe1e7b06c33db5b02e8051dca71bf Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Tue, 3 Sep 2024 12:13:32 -0400
Subject: [PATCH 12/18] Should finish async iterator

---
 spec.bs | 56 ++++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 36 insertions(+), 20 deletions(-)

diff --git a/spec.bs b/spec.bs
index 853d7ca..60d8fc1 100644
--- a/spec.bs
+++ b/spec.bs
@@ -474,7 +474,7 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
 </div>
 
 <div algorithm>
-  To <dfn for=Observable>convert to an Observable</dfn> given an {{any}} |value|, run these steps:
+  To <dfn for=Observable>convert to an Observable</dfn> an {{any}} |value|, run these steps:
 
   Note: We split this algorithm out from the Web IDL {{Observable/from()}} method, so that
   spec prose can <a for=Observable lt="convert to an observable">convert</a> an {{Observable}}
@@ -515,17 +515,32 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
     1. Let |nextAlgorithm| be the following steps, given a {{Subscriber}} |subscriber| and an
        Iterator Record |iteratorRecord|:
 
-         1. If |iteratorRecord|'s \[[Done]] is true, then: run |subscriber|'s
-            {{Subscriber/complete()}} method and abort these steps.
+         1. Let |nextPromise| be a {{Promise}}-or-undefined, initially undefined.
 
          1. Let |nextRecord| be [$IteratorStepValue$](|iteratorRecord|).
 
-         1. Let |nextPromise| be undefined.
+            Process |nextRecord| as follows:
 
-         1. If |nextRecord| is a [=throw completion=], then set |nextPromise| to [=a promise
-            rejected with=] |nextRecord|'s \[[Value]].
+            <dl class="switch">
+              <dt>If |nextRecord| is a [=throw completion=]</dt>
+              <dd>
+               <ol>
+                <li><p>[=Assert=]: |iteratorRecord|'s \[[Done]] is true.</p></li>
 
-            Otherwise, set |nextPromise| to |nextRecord|'s \[[Value]].
+                <li><p>Set |nextPromise| to [=a promise rejected with=] |nextRecord|'s \[[Value]].
+               </ol>
+              </dd>
+
+              <dt>If |nextRecord| is DONE</dt>
+              <dd>[=Queue a microtask=] to run |subscriber|'s {{Subscriber/complete()}} method, and
+              return from |nextAlgorithm|.
+
+              <dt>If |nextRecord| is [=normal completion=]</dt>
+              <dd>
+               <p>Set |nextPromise| to [=a promise resolved with=] |nextRecord|'s \[[Value]].</p>
+
+               Note: This is done in case |nextRecord|'s \[[Value]] is not *itself* already a {{Promise}}.
+            </dl>
 
          1. [=React=] to |nextPromise|:
 
@@ -543,22 +558,28 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
 
        1. Let |iteratorRecord| be [$GetIterator$](|value|, async).
 
+          Note: This re-invokes any method getters for the {{%Symbol.iterator%}} method on |value|.
+          Whether or not this is desirable is an extreme corner case, but this behavior currently
+          matches what is expected by tests. See <a
+          href=https://github.com/WICG/observable/issues/127>issue#127</a> for discussion.
+
+
        1. If |iteratorRecord| is a [=throw completion=], then [=queue a microtask=] to run
           |subscriber|'s {{Subscriber/error()}} method, given |iteratorRecord|'s \[[Value]].
 
-          Otherwise, [=queue a microtask=] to run |nextAlgorithm| given |subscriber| and
-          |iteratorRecord|.
+       1. [=Assert=]: |iteratorRecord| is an Iterator Record.
 
-       Note: It is important to [=queue a microtask=] in both branches here to guarantee that
-       coercing an AsyncIterable never stops the Subscription synchronously, thereby releasing
-       Zalgo.
+       1. Run |nextAlgorithm| given |subscriber| and |iteratorRecord|.
+
+       Issue: In the error case immediately above, and in the DONE case in |nextAlgorithm|, we
+       [=queue a microtask=] to invoke relevant callbacks. This was done so that subscription to an
+       AsyncIterable-coerced {{Observable}} never invokes callbacks synchronously, "thereby
+       releasing Zalgo". But ordinary Observables are allowed to invoke callbacks synchronously
+       during subscription, so it is not clear if this is needed at all.
 
     1. <i id=from-iterable-conversion><b>From iterable</b></i>: Let |iteratorMethodRecord| be [=?=]
        [$GetMethod$](|value|, {{%Symbol.iterator%}}).
 
-       Note: This step is web-observable, and re-throws any errors that the {{%Symbol.iterator%}}
-       method *getter* might have thrown.
-
     1. If |iteratorMethodRecord|'s \[[Value]] is undefined or null, then jump to the step labeled <a
        href=#from-promise-conversion>From Promise</a>.
 
@@ -570,11 +591,6 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
 
          1. Let |iteratorRecord| be [$GetIterator$](|value|, sync).
 
-            Note: This re-invokes any method getters for the {{%Symbol.iterator%}} method on
-            |value|. Whether or not this is desirable is an extreme corner case, but this behavior
-            currently matches what is expected by tests. See <a
-            href=https://github.com/WICG/observable/issues/127>issue#127</a> for discussion.
-
          1. If |iteratorRecord| is a [=throw completion=], then run |subscriber|'s
             {{Subscriber/error()}} method, given |iteratorRecord|'s \[[Value]], and abort these
             steps.

From 3b3312bd33d24d7983934df00b3d6caabd736ad1 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Tue, 3 Sep 2024 12:17:22 -0400
Subject: [PATCH 13/18] Wording

---
 spec.bs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/spec.bs b/spec.bs
index 60d8fc1..a8b08fa 100644
--- a/spec.bs
+++ b/spec.bs
@@ -477,8 +477,8 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
   To <dfn for=Observable>convert to an Observable</dfn> an {{any}} |value|, run these steps:
 
   Note: We split this algorithm out from the Web IDL {{Observable/from()}} method, so that
-  spec prose can <a for=Observable lt="convert to an observable">convert</a> an {{Observable}}
-  without going through the Web IDL bindings.
+  spec prose can <a for=Observable lt="convert to an observable">convert</a> values to without
+  going through the Web IDL bindings.
 
   Note: The resolution of value to its descrete types happens before
   [=Observable/subscribe callback=] is called. This means mutations of values, such as adding

From 06a1a66575808372a57a83be737af4b8aa61e025 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Tue, 3 Sep 2024 13:06:36 -0400
Subject: [PATCH 14/18] Remove note about mutating iterator protocols before
 subscription

---
 spec.bs | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/spec.bs b/spec.bs
index a8b08fa..01c118e 100644
--- a/spec.bs
+++ b/spec.bs
@@ -480,11 +480,6 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
   spec prose can <a for=Observable lt="convert to an observable">convert</a> values to without
   going through the Web IDL bindings.
 
-  Note: The resolution of value to its descrete types happens before
-  [=Observable/subscribe callback=] is called. This means mutations of values, such as adding
-  the iterable protocols to the object, will not take effect between the creation of the returned
-  observable, and when it is subscribed to.
-
     1. If [$Type$](|value|) is not [=Object=], [=exception/throw=] a {{TypeError}}.
 
        Note: This prevents primitive types from being coerced into iterables (e.g., String).

From 1b92dc5c14c6d80adb6a55e16231c1072ec7393d Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Wed, 4 Sep 2024 11:49:34 -0400
Subject: [PATCH 15/18] Iterator{Next(),Complete(),Value()}

---
 spec.bs | 47 ++++++++++++++++++++++++++---------------------
 1 file changed, 26 insertions(+), 21 deletions(-)

diff --git a/spec.bs b/spec.bs
index 01c118e..aa3a292 100644
--- a/spec.bs
+++ b/spec.bs
@@ -512,36 +512,41 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
 
          1. Let |nextPromise| be a {{Promise}}-or-undefined, initially undefined.
 
-         1. Let |nextRecord| be [$IteratorStepValue$](|iteratorRecord|).
+         1. Let |nextRecord| be [$IteratorNext$](|iteratorRecord|), and process it as follows:
 
-            Process |nextRecord| as follows:
+         1. If |nextRecord| is a [=throw completion=], then:
 
-            <dl class="switch">
-              <dt>If |nextRecord| is a [=throw completion=]</dt>
-              <dd>
-               <ol>
-                <li><p>[=Assert=]: |iteratorRecord|'s \[[Done]] is true.</p></li>
+            1. [=Assert=]: |iteratorRecord|'s \[[Done]] is true.
 
-                <li><p>Set |nextPromise| to [=a promise rejected with=] |nextRecord|'s \[[Value]].
-               </ol>
-              </dd>
+            1. Set |nextPromise| to [=a promise rejected with=] |nextRecord|'s \[[Value]].
 
-              <dt>If |nextRecord| is DONE</dt>
-              <dd>[=Queue a microtask=] to run |subscriber|'s {{Subscriber/complete()}} method, and
-              return from |nextAlgorithm|.
+         1. Otherwise, if |nextRecord| is [=normal completion=], then set |nextPromise| to [=a
+            promise resolved with=] |nextRecord|'s \[[Value]].
 
-              <dt>If |nextRecord| is [=normal completion=]</dt>
-              <dd>
-               <p>Set |nextPromise| to [=a promise resolved with=] |nextRecord|'s \[[Value]].</p>
-
-               Note: This is done in case |nextRecord|'s \[[Value]] is not *itself* already a {{Promise}}.
-            </dl>
+            Note: This is done in case |nextRecord|'s \[[Value]] is not *itself* already a
+            {{Promise}}.
 
          1. [=React=] to |nextPromise|:
 
-            1. If |nextPromise| was fulfilled with value |v|, then:
+            1. If |nextPromise| was fulfilled with value |iteratorResult|, then:
+
+               1. If [$Type$](|iteratorResult|) is not Object, then run |subscriber|'s
+                  {{Subscriber/error()}} method with a {{TypeError}} and abort these steps.
+
+               1. Let |done| be [$IteratorComplete$](iteratorResult).
+
+               1. If |done| is a [=throw completion=], then run |subscriber|'s
+                  {{Subscriber/error()}} method with a {{TypeError}} and abort these steps.
+
+                  Otherwise, if |done|'s \[[Value]] is true, then run |subscriber|'s
+                  {{Subscriber/complete()}} and abort these steps.
+
+               1. Let |value| be [$IteratorValue$](|iteratorResult).
+
+               1. If |value| is a [=throw completion=], then run |subscriber|'s
+                  {{Subscriber/error()}} method with a {{TypeError}} and abort these steps.
 
-               1. Run |subscriber|'s {{Subscriber/next()}} method, given |v|.
+               1. Run |subscriber|'s {{Subscriber/next()}} method, given |value|'s \[[Value]].
 
                1. Run |nextAlgorithm|, given |subscriber| and |iteratorRecord|.
 

From 4159a0455ca228462d0238162c5b59f152e8aeb3 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Wed, 4 Sep 2024 13:12:15 -0400
Subject: [PATCH 16/18] Fix variables

---
 spec.bs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/spec.bs b/spec.bs
index aa3a292..24f8fc4 100644
--- a/spec.bs
+++ b/spec.bs
@@ -533,7 +533,7 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
                1. If [$Type$](|iteratorResult|) is not Object, then run |subscriber|'s
                   {{Subscriber/error()}} method with a {{TypeError}} and abort these steps.
 
-               1. Let |done| be [$IteratorComplete$](iteratorResult).
+               1. Let |done| be [$IteratorComplete$](|iteratorResult|).
 
                1. If |done| is a [=throw completion=], then run |subscriber|'s
                   {{Subscriber/error()}} method with a {{TypeError}} and abort these steps.
@@ -541,7 +541,7 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
                   Otherwise, if |done|'s \[[Value]] is true, then run |subscriber|'s
                   {{Subscriber/complete()}} and abort these steps.
 
-               1. Let |value| be [$IteratorValue$](|iteratorResult).
+               1. Let |value| be [$IteratorValue$](|iteratorResult|).
 
                1. If |value| is a [=throw completion=], then run |subscriber|'s
                   {{Subscriber/error()}} method with a {{TypeError}} and abort these steps.

From 87450645eaafea1e26eec4ad71811b422d7d824f Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Wed, 4 Sep 2024 13:36:18 -0400
Subject: [PATCH 17/18] Use the correct exception

---
 spec.bs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/spec.bs b/spec.bs
index 24f8fc4..367a7be 100644
--- a/spec.bs
+++ b/spec.bs
@@ -536,7 +536,7 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
                1. Let |done| be [$IteratorComplete$](|iteratorResult|).
 
                1. If |done| is a [=throw completion=], then run |subscriber|'s
-                  {{Subscriber/error()}} method with a {{TypeError}} and abort these steps.
+                  {{Subscriber/error()}} method with |done|'s \[[Value]] and abort these steps.
 
                   Otherwise, if |done|'s \[[Value]] is true, then run |subscriber|'s
                   {{Subscriber/complete()}} and abort these steps.
@@ -544,7 +544,7 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
                1. Let |value| be [$IteratorValue$](|iteratorResult|).
 
                1. If |value| is a [=throw completion=], then run |subscriber|'s
-                  {{Subscriber/error()}} method with a {{TypeError}} and abort these steps.
+                  {{Subscriber/error()}} method with |value|'s \[[Value]] and abort these steps.
 
                1. Run |subscriber|'s {{Subscriber/next()}} method, given |value|'s \[[Value]].
 

From d7729418e30cb2f9f2f6e80e52569983543b63e9 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Wed, 4 Sep 2024 22:07:27 -0400
Subject: [PATCH 18/18] Synchronously invoke `error()` if
 `%Symbol.asyncIterator()` throws

---
 spec.bs | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/spec.bs b/spec.bs
index 367a7be..cc47487 100644
--- a/spec.bs
+++ b/spec.bs
@@ -563,20 +563,22 @@ An <dfn>internal observer</dfn> is a [=struct=] with the following [=struct/item
           matches what is expected by tests. See <a
           href=https://github.com/WICG/observable/issues/127>issue#127</a> for discussion.
 
-
-       1. If |iteratorRecord| is a [=throw completion=], then [=queue a microtask=] to run
-          |subscriber|'s {{Subscriber/error()}} method, given |iteratorRecord|'s \[[Value]].
+       1. If |iteratorRecord| is a [=throw completion=], then run |subscriber|'s
+          {{Subscriber/error()}} method with |iteratorRecord|'s \[[Value]].
+
+          Note: This means we invoke the {{Subscriber/error()}} method synchronously with respect to
+          subscription, which is the only time this can happen for async iterables that are
+          converted to {{Observable}}s. In all other cases, errors are propagated to the observer
+          asynchronously, with microtask timing, by virtue of being wrapped in a rejected
+          {{Promise}} that |nextAlgorithm| [=reacts=] to. This synchronous-error-propagation
+          behavior is hopefully OK, since it is consistent with language constructs (i.e.,
+          **for-await of** loops) that invoke {{%Symbol.asyncIterator%}} and synchronously re-throw
+          exceptions to catch blocks outside the loop, before any [$Await$]ing takes place.
 
        1. [=Assert=]: |iteratorRecord| is an Iterator Record.
 
        1. Run |nextAlgorithm| given |subscriber| and |iteratorRecord|.
 
-       Issue: In the error case immediately above, and in the DONE case in |nextAlgorithm|, we
-       [=queue a microtask=] to invoke relevant callbacks. This was done so that subscription to an
-       AsyncIterable-coerced {{Observable}} never invokes callbacks synchronously, "thereby
-       releasing Zalgo". But ordinary Observables are allowed to invoke callbacks synchronously
-       during subscription, so it is not clear if this is needed at all.
-
     1. <i id=from-iterable-conversion><b>From iterable</b></i>: Let |iteratorMethodRecord| be [=?=]
        [$GetMethod$](|value|, {{%Symbol.iterator%}}).