feat(bindgen): more stream tests

crates/js-component-bindgen/src/esm_bindgen.rs

@@ -396,9 +396,6 @@ impl EsmBindgen {
                             maybe_quote_member(specifier)
                         );
                         for (external_name, local_name) in bound_external_names {
-                            // For imports that are functions, ensure that they are noted as host provided
-                            uwriteln!(output, "{local_name}._isHostProvided = true;");
-
                             uwriteln!(
                                 output,
                                 r#"
@@ -409,6 +406,9 @@ impl EsmBindgen {
                                 }}
                                 "#,
                             );
+
+                            // For imports that are functions, ensure that they are noted as host provided
+                            uwriteln!(output, "{local_name}._isHostProvided = true;");
                         }
                     } else if let Some(idl_binding) = idl_binding {
                         uwrite!(
@@ -480,9 +480,6 @@ impl EsmBindgen {
 
             // Process all external host-provided imports
             for (member_name, local_name) in generated_member_names {
-                // For imports that are functions, ensure that they are noted as host provided
-                uwriteln!(output, "{local_name}._isHostProvided = true;");
-
                 // Ensure that the imports we destructured were defined
                 // (if they were not, the user is likely missing an import @ instantiation time)
                 uwriteln!(
@@ -495,6 +492,8 @@ impl EsmBindgen {
                     }}
                     "#,
                 );
+                // For imports that are functions, ensure that they are noted as host provided
+                uwriteln!(output, "{local_name}._isHostProvided = true;");
             }
         }
     }

crates/js-component-bindgen/src/intrinsics/component.rs

@@ -130,6 +130,8 @@ impl ComponentIntrinsic {
                 let waitable_class = Intrinsic::Waitable(WaitableIntrinsic::WaitableClass).name();
                 let get_or_create_async_state_fn = Self::GetOrCreateAsyncState.name();
                 let promise_with_resolvers_fn = Intrinsic::PromiseWithResolversPonyfill.name();
+                let stream_readable_end_class =
+                    Intrinsic::AsyncStream(AsyncStreamIntrinsic::StreamReadableEndClass).name();
 
                 output.push_str(&format!(
                     r#"
@@ -466,9 +468,48 @@ impl ComponentIntrinsic {
                             return new {waitable_class}({{ target: args?.target, }});
                         }}
 
+                        createReadableStreamEnd(args) {{
+                            {debug_log_fn}('[{component_async_state_class}#createStreamEnd()] args', args);
+                            const {{ tableIdx, elemMeta, hostInjectFn }} = args;
+
+                            const {{ table: localStreamTable, componentIdx }} = {global_stream_table_map}[tableIdx];
+                            if (!localStreamTable) {{
+                                throw new Error(`missing global stream table lookup for table [${{tableIdx}}] while creating stream`);
+                            }}
+                            if (componentIdx !== this.#componentIdx) {{
+                                throw new Error('component idx mismatch while creating stream');
+                            }}
+
+                            const waitable = this.createWaitable();
+                            const streamEnd = new {stream_readable_end_class}({{
+                                tableIdx,
+                                elemMeta,
+                                hostInjectFn,
+                                pendingBufferMeta: {{}},
+                                target: `stream read end (lowered, @init)`,
+                                waitable,
+                            }});
+
+                            streamEnd.setWaitableIdx(this.handles.insert(streamEnd));
+                            streamEnd.setHandle(localStreamTable.insert(streamEnd));
+                            if (streamEnd.streamTableIdx() !== tableIdx) {{
+                                throw new Error("unexpectedly mismatched stream table");
+                            }}
+                            const streamEndWaitableIdx = streamEnd.waitableIdx();
+                            const streamEndHandle = streamEnd.handle();
+                            waitable.setTarget(`waitable for stream read end (lowered, waitable [${{streamEndWaitableIdx}}])`);
+                            streamEnd.setTarget(`stream read end (lowered, waitable [${{streamEndWaitableIdx}}])`);
+
+                            return {{
+                                waitableIdx: streamEndWaitableIdx,
+                                handle: streamEndHandle,
+                                streamEnd,
+                            }};
+                        }}
+
                         createStream(args) {{
                             {debug_log_fn}('[{component_async_state_class}#createStream()] args', args);
-                            const {{ tableIdx, elemMeta }} = args;
+                            const {{ tableIdx, elemMeta, hostInjectFn }} = args;
                             if (tableIdx === undefined) {{ throw new Error("missing table idx while adding stream"); }}
                             if (elemMeta === undefined) {{ throw new Error("missing element metadata while adding stream"); }}
 
@@ -485,10 +526,10 @@ impl ComponentIntrinsic {
 
                             const stream = new {internal_stream_class}({{
                                 tableIdx,
-                                componentIdx: this.#componentIdx,
                                 elemMeta,
                                 readWaitable,
                                 writeWaitable,
+                                hostInjectFn,
                             }});
                             stream.setGlobalStreamMapRep({global_stream_map}.insert(stream));
 
@@ -513,17 +554,21 @@ impl ComponentIntrinsic {
                             readEnd.setTarget(`stream read end (waitable [${{readEndWaitableIdx}}])`);
 
                             return {{
+                                writeEnd,
                                 writeEndWaitableIdx,
                                 writeEndHandle,
                                 readEndWaitableIdx,
                                 readEndHandle,
+                                readEnd,
                             }};
                         }}
 
                         getStreamEnd(args) {{
                             {debug_log_fn}('[{component_async_state_class}#getStreamEnd()] args', args);
                             const {{ tableIdx, streamEndHandle, streamEndWaitableIdx }} = args;
-                            if (tableIdx === undefined) {{ throw new Error('missing table idx while getting stream end'); }}
+                            if (tableIdx === undefined) {{
+                                throw new Error('missing table idx while getting stream end');
+                            }}
 
                             const {{ table, componentIdx }} = {global_stream_table_map}[tableIdx];
                             const cstate = {get_or_create_async_state_fn}(componentIdx);

crates/js-component-bindgen/src/intrinsics/conversion.rs

@@ -34,6 +34,12 @@ pub enum ConversionIntrinsic {
     ToUint8,
 
     ToResultString,
+
+    /// Function that requires validity of various numeric primitive types (or throws a `TypeError`)
+    RequireValidNumericPrimitive,
+
+    /// Function that checks validity of various numeric primitive types
+    IsValidNumericPrimitive,
 }
 
 impl ConversionIntrinsic {
@@ -61,6 +67,8 @@ impl ConversionIntrinsic {
             "toUint64",
             "toUint64",
             "toUint8",
+            Self::RequireValidNumericPrimitive.name(),
+            Self::IsValidNumericPrimitive.name(),
         ]
     }
 
@@ -82,6 +90,8 @@ impl ConversionIntrinsic {
             Self::I64ToF64 => "i64ToF64",
             Self::F32ToI32 => "f32ToI32",
             Self::F64ToI64 => "f64ToI64",
+            Self::RequireValidNumericPrimitive => "_requireValidNumericPrimitive",
+            Self::IsValidNumericPrimitive => "_isValidNumericPrimitive",
         }
     }
 
@@ -199,6 +209,60 @@ impl ConversionIntrinsic {
                 ");
             }
 
+            Self::RequireValidNumericPrimitive => {
+                let name = self.name();
+                let is_valid_numeric_primitive_fn = Self::IsValidNumericPrimitive.name();
+
+                output.push_str(&format!(r#"
+                    function {name}(ty, v) {{
+                        if (v === undefined  || v === null || !{is_valid_numeric_primitive_fn}(ty, v)) {{
+                            throw new TypeError(`invalid ${{ty}} value [${{v}}]`);
+                        }}
+                        return true;
+                    }}
+                "#))
+            }
+
+            Self::IsValidNumericPrimitive => {
+                let name = self.name();
+                output.push_str(&format!(r#"
+                    function {name}(ty, v) {{
+                        if (v === undefined || v === null) {{ return false; }}
+                        switch (ty) {{
+                            case 'bool':
+                                return v === 0 || v === 1;
+                                break;
+                            case 'u8':
+                                return v >= 0 && v <= 255;
+                                break;
+                            case 's8':
+                                return v >= -128 && v <= 127;
+                                break;
+                            case 'u16':
+                                return v >= 0 && v <= 65535;
+                                break;
+                            case 's16':
+                                return v >= -32768 && v <= 32767;
+                            case 'u32':
+                                return v >= 0 && v <= 4_294_967_295;
+                            case 's32':
+                                return v >= -2_147_483_648 && v <= 2_147_483_647;
+                            case 'u64':
+                                return typeof v === 'bigint' && v >= 0 && v <= 18_446_744_073_709_551_615n;
+                            case 's64':
+                                return typeof v === 'bigint' && v >= -9223372036854775808n && v <= 9223372036854775807n;
+                                break;
+                            case 'f32':
+                            case 'f64': return typeof v === 'number';
+                            default:
+                                return false;
+                        }}
+                        return true;
+                    }}
+               "#
+                ));
+            }
+
         }
     }
 }