goscript 0.0.20 → 0.0.22

package/builtin/builtin.ts

@@ -724,12 +724,29 @@ export interface BaseTypeInfo {
   zeroValue?: any
 }
 
+/**
+ * Represents an argument or a return value of a method.
+ */
+export interface MethodArg {
+  name?: string; // Name of the argument/return value, if available
+  type: TypeInfo | string; // TypeInfo object or string name of the type
+}
+
+/**
+ * Represents the signature of a method, including its name, arguments, and return types.
+ */
+export interface MethodSignature {
+  name: string;
+  args: MethodArg[];
+  returns: MethodArg[];
+}
+
 /**
  * Type information for struct types
  */
 export interface StructTypeInfo extends BaseTypeInfo {
   kind: TypeKind.Struct
-  methods: Set<string>
+  methods: MethodSignature[] // Array of method signatures
   ctor?: new (...args: any[]) => any
   fields: Record<string, TypeInfo | string> // Field names and types for struct fields
 }
@@ -739,7 +756,7 @@ export interface StructTypeInfo extends BaseTypeInfo {
  */
 export interface InterfaceTypeInfo extends BaseTypeInfo {
   kind: TypeKind.Interface
-  methods: Set<string>
+  methods: MethodSignature[] // Array of method signatures
 }
 
 /**
@@ -790,6 +807,7 @@ export interface FunctionTypeInfo extends BaseTypeInfo {
   kind: TypeKind.Function
   params?: (string | TypeInfo)[]
   results?: (string | TypeInfo)[]
+  isVariadic?: boolean // True if the function is variadic (e.g., ...T)
 }
 
 /**
@@ -860,14 +878,15 @@ const typeRegistry = new Map<string, TypeInfo>()
  *
  * @param name The name of the type.
  * @param zeroValue The zero value for the type.
- * @param methods Set of method names for the struct.
+ * @param methods Array of method signatures for the struct.
  * @param ctor Constructor for the struct.
+ * @param fields Record of field names and their types.
  * @returns The struct type information object.
  */
 export const registerStructType = (
   name: string,
   zeroValue: any,
-  methods: Set<string>,
+  methods: MethodSignature[],
   ctor: new (...args: any[]) => any,
   fields: Record<string, TypeInfo | string> = {},
 ): StructTypeInfo => {
@@ -888,13 +907,13 @@ export const registerStructType = (
  *
  * @param name The name of the type.
  * @param zeroValue The zero value for the type (usually null).
- * @param methods Set of method names the interface requires.
+ * @param methods Array of method signatures for the interface.
  * @returns The interface type information object.
  */
 export const registerInterfaceType = (
   name: string,
   zeroValue: any,
-  methods: Set<string>,
+  methods: MethodSignature[],
 ): InterfaceTypeInfo => {
   const typeInfo: InterfaceTypeInfo = {
     name,
@@ -935,6 +954,147 @@ function normalizeTypeInfo(info: string | TypeInfo): TypeInfo {
   return info
 }
 
+function compareOptionalTypeInfo(
+  type1?: string | TypeInfo,
+  type2?: string | TypeInfo,
+): boolean {
+  if (type1 === undefined && type2 === undefined) return true
+  if (type1 === undefined || type2 === undefined) return false
+  // Assuming areTypeInfosIdentical will handle normalization if needed, 
+  // but type1 and type2 here are expected to be direct fields from TypeInfo objects.
+  return areTypeInfosIdentical(type1, type2)
+}
+
+function areFuncParamOrResultArraysIdentical(
+  arr1?: (string | TypeInfo)[],
+  arr2?: (string | TypeInfo)[]
+): boolean {
+  if (arr1 === undefined && arr2 === undefined) return true
+  if (arr1 === undefined || arr2 === undefined) return false
+  if (arr1.length !== arr2.length) return false
+  for (let i = 0; i < arr1.length; i++) {
+    if (!areTypeInfosIdentical(arr1[i], arr2[i])) {
+      return false
+    }
+  }
+  return true
+}
+
+function areFuncSignaturesIdentical(
+  func1: FunctionTypeInfo,
+  func2: FunctionTypeInfo,
+): boolean {
+  if ((func1.isVariadic || false) !== (func2.isVariadic || false)) {
+    return false
+  }
+  return (
+    areFuncParamOrResultArraysIdentical(func1.params, func2.params) &&
+    areFuncParamOrResultArraysIdentical(func1.results, func2.results)
+  )
+}
+
+function areMethodArgsArraysIdentical(
+  args1?: MethodArg[],
+  args2?: MethodArg[],
+): boolean {
+  if (args1 === undefined && args2 === undefined) return true
+  if (args1 === undefined || args2 === undefined) return false
+  if (args1.length !== args2.length) return false
+  for (let i = 0; i < args1.length; i++) {
+    // Compare based on type only, names of args/results don't affect signature identity here.
+    if (!areTypeInfosIdentical(args1[i].type, args2[i].type)) {
+      return false
+    }
+  }
+  return true
+}
+
+export function areTypeInfosIdentical(
+  type1InfoOrName: string | TypeInfo,
+  type2InfoOrName: string | TypeInfo,
+): boolean {
+  const t1Norm = normalizeTypeInfo(type1InfoOrName)
+  const t2Norm = normalizeTypeInfo(type2InfoOrName)
+
+  if (t1Norm === t2Norm) return true // Object identity
+  if (t1Norm.kind !== t2Norm.kind) return false
+
+  // If types have names, the names must match for identity.
+  // If one has a name and the other doesn't, they are not identical.
+  if (t1Norm.name !== t2Norm.name) return false
+
+  // If both are named and names match, for Basic, Struct, Interface, this is sufficient for identity.
+  if (t1Norm.name !== undefined /* && t2Norm.name is also defined and equal */) {
+    if (
+      t1Norm.kind === TypeKind.Basic ||
+      t1Norm.kind === TypeKind.Struct ||
+      t1Norm.kind === TypeKind.Interface
+    ) {
+      return true
+    }
+  }
+  // For other types (Pointer, Slice, etc.), or if both are anonymous (name is undefined),
+  // structural comparison is needed.
+
+  switch (t1Norm.kind) {
+    case TypeKind.Basic:
+      // Names matched if they were defined, or both undefined (which means true by t1Norm.name !== t2Norm.name being false)
+      return true
+    case TypeKind.Pointer:
+      return compareOptionalTypeInfo(
+        (t1Norm as PointerTypeInfo).elemType,
+        (t2Norm as PointerTypeInfo).elemType,
+      )
+    case TypeKind.Slice:
+      return compareOptionalTypeInfo(
+        (t1Norm as SliceTypeInfo).elemType,
+        (t2Norm as SliceTypeInfo).elemType,
+      )
+    case TypeKind.Array:
+      return (
+        (t1Norm as ArrayTypeInfo).length === (t2Norm as ArrayTypeInfo).length &&
+        compareOptionalTypeInfo(
+          (t1Norm as ArrayTypeInfo).elemType,
+          (t2Norm as ArrayTypeInfo).elemType,
+        )
+      )
+    case TypeKind.Map:
+      return (
+        compareOptionalTypeInfo(
+          (t1Norm as MapTypeInfo).keyType,
+          (t2Norm as MapTypeInfo).keyType,
+        ) &&
+        compareOptionalTypeInfo(
+          (t1Norm as MapTypeInfo).elemType,
+          (t2Norm as MapTypeInfo).elemType,
+        )
+      )
+    case TypeKind.Channel:
+      return (
+        // Ensure direction property exists before comparing, or handle undefined if it can be
+        ((t1Norm as ChannelTypeInfo).direction || 'both') === ((t2Norm as ChannelTypeInfo).direction || 'both') &&
+        compareOptionalTypeInfo(
+          (t1Norm as ChannelTypeInfo).elemType,
+          (t2Norm as ChannelTypeInfo).elemType,
+        )
+      )
+    case TypeKind.Function:
+      return areFuncSignaturesIdentical(
+        t1Norm as FunctionTypeInfo,
+        t2Norm as FunctionTypeInfo,
+      )
+    case TypeKind.Struct:
+    case TypeKind.Interface:
+      // If we reach here, names were undefined (both anonymous) or names matched but was not Basic/Struct/Interface.
+      // For anonymous Struct/Interface, strict identity means full structural comparison.
+      // For now, we consider anonymous types not identical unless they are the same object (caught above).
+      // If they were named and matched, 'return true' was hit earlier for these kinds.
+      return false
+    default:
+      return false
+  }
+}
+
 /**
  * Validates that a map key matches the expected type info.
  *
@@ -993,16 +1153,20 @@ function matchesStructType(value: any, info: TypeInfo): boolean {
     return true
   }
 
+  // Check if the value has all methods defined in the struct's TypeInfo
+  // This is a structural check, not a signature check here.
+  // Signature checks are more relevant for interface satisfaction.
   if (info.methods && typeof value === 'object' && value !== null) {
-    const allMethodsMatch = Array.from(info.methods).every(
-      (method) => typeof value[method] === 'function',
+    const allMethodsExist = info.methods.every(
+      (methodSig) => typeof (value as any)[methodSig.name] === 'function',
     )
-    if (allMethodsMatch) {
-      return true
+    if (!allMethodsExist) {
+      return false
     }
+    // Further signature checking could be added here if needed for struct-to-struct assignability
   }
 
-  if (typeof value === 'object' && value !== null) {
+  if (typeof value === 'object' && value !== null && info.fields) {
     const fieldNames = Object.keys(info.fields || {})
     const valueFields = Object.keys(value)
 
@@ -1034,19 +1198,96 @@ function matchesStructType(value: any, info: TypeInfo): boolean {
  * @param info The interface type info to match against.
  * @returns True if the value matches the interface type, false otherwise.
  */
+/**
+ * Checks if a value matches an interface type info by verifying it implements
+ * all required methods with compatible signatures.
+ *
+ * @param value The value to check.
+ * @param info The interface type info to match against.
+ * @returns True if the value matches the interface type, false otherwise.
+ */
 function matchesInterfaceType(value: any, info: TypeInfo): boolean {
-  // For interfaces, check if the value has all the required methods
-  if (
-    isInterfaceTypeInfo(info) &&
-    info.methods &&
-    typeof value === 'object' &&
-    value !== null
-  ) {
-    return Array.from(info.methods).every(
-      (method) => typeof (value as any)[method] === 'function',
-    )
+  // Check basic conditions first
+  if (!isInterfaceTypeInfo(info) || typeof value !== 'object' || value === null) {
+    return false
   }
-  return false
+
+  // For interfaces, check if the value has all the required methods with compatible signatures
+  return info.methods.every((requiredMethodSig) => {
+    const actualMethod = (value as any)[requiredMethodSig.name]
+    
+    // Method must exist and be a function
+    if (typeof actualMethod !== 'function') {
+      return false
+    }
+
+    // Check parameter count (basic arity check)
+    // Note: This is a simplified check as JavaScript functions can have optional/rest parameters
+    const declaredParamCount = actualMethod.length
+    const requiredParamCount = requiredMethodSig.args.length
+    
+    // Strict arity checking can be problematic in JS, so we'll be lenient
+    // A method with fewer params than required is definitely incompatible
+    if (declaredParamCount < requiredParamCount) {
+      return false
+    }
+    
+    // Check return types if we can determine them
+    // This is challenging in JavaScript without runtime type information
+    
+    // If the value has a __goTypeName property, it might be a registered type
+    // with more type information available
+    if (value.__goTypeName) {
+      const valueTypeInfo = typeRegistry.get(value.__goTypeName)
+      if (valueTypeInfo && isStructTypeInfo(valueTypeInfo)) {
+        // Find the matching method in the value's type info
+        const valueMethodSig = valueTypeInfo.methods.find(
+          m => m.name === requiredMethodSig.name
+        )
+        
+        if (valueMethodSig) {
+          // Compare return types
+          if (valueMethodSig.returns.length !== requiredMethodSig.returns.length) {
+            return false
+          }
+          
+          // Compare each return type for compatibility
+          for (let i = 0; i < requiredMethodSig.returns.length; i++) {
+            const requiredReturnType = normalizeTypeInfo(
+              requiredMethodSig.returns[i].type
+            )
+            const valueReturnType = normalizeTypeInfo(
+              valueMethodSig.returns[i].type
+            )
+            
+            // For interface return types, we need to check if the value's return type
+            // implements the required interface
+            if (isInterfaceTypeInfo(requiredReturnType)) {
+              // This would be a recursive check, but we'll simplify for now
+              // by just checking if the types are the same or if the value type
+              // is registered as implementing the interface
+              if (requiredReturnType.name !== valueReturnType.name) {
+                // Check if valueReturnType implements requiredReturnType
+                // This would require additional implementation tracking
+                return false
+              }
+            } 
+            // For non-interface types, check direct type compatibility
+            else if (requiredReturnType.name !== valueReturnType.name) {
+              return false
+            }
+          }
+          
+          // Similarly, we could check parameter types for compatibility
+          // but we'll skip that for brevity
+        }
+      }
+    }
+    
+    // If we can't determine detailed type information, we'll accept the method
+    // as long as it exists with a compatible arity
+    return true
+  })
 }
 
 /**
@@ -1297,22 +1538,46 @@ export function typeAssert<T>(
 
   if (
     isStructTypeInfo(normalizedType) &&
-    normalizedType.methods &&
+    normalizedType.methods && normalizedType.methods.length > 0 &&
     typeof value === 'object' &&
     value !== null
   ) {
-    // Check if the value implements all methods of the struct type
-    const allMethodsMatch = Array.from(normalizedType.methods).every(
-      (method) => typeof value[method] === 'function',
-    )
+    // Check if the value implements all methods of the struct type with compatible signatures.
+    // This is more for interface satisfaction by a struct.
+    // For struct-to-struct assertion, usually instanceof or field checks are primary.
+    const allMethodsMatch = normalizedType.methods.every((requiredMethodSig) => {
+      const actualMethod = (value as any)[requiredMethodSig.name];
+      if (typeof actualMethod !== 'function') {
+        return false;
+      }
+      const valueTypeInfoVal = (value as any).$typeInfo
+      if (valueTypeInfoVal) {
+        const normalizedValueType = normalizeTypeInfo(valueTypeInfoVal)
+        if (isStructTypeInfo(normalizedValueType) || isInterfaceTypeInfo(normalizedValueType)) {
+          const actualValueMethodSig = normalizedValueType.methods.find(m => m.name === requiredMethodSig.name)
+          if (actualValueMethodSig) {
+            // Perform full signature comparison using MethodSignatures
+            const paramsMatch = areMethodArgsArraysIdentical(requiredMethodSig.args, actualValueMethodSig.args)
+            const resultsMatch = areMethodArgsArraysIdentical(requiredMethodSig.returns, actualValueMethodSig.returns)
+            return paramsMatch && resultsMatch
+          } else {
+            // Value has TypeInfo listing methods, but this specific method isn't listed.
+            // This implies a mismatch for strict signature check based on TypeInfo.
+            return false
+          }
+        }
+      }
 
-    const hasAnyMethod = Array.from(normalizedType.methods).some(
-      (method) => typeof value[method] === 'function',
-    )
+      // Fallback: Original behavior if value has no TypeInfo that lists methods,
+      // or if the method wasn't found in its TypeInfo (covered by 'else' returning false above).
+      // The original comment was: "For now, presence and function type is checked by matchesStructType/matchesInterfaceType"
+      // This 'return true' implies that if we couldn't do a full signature check via TypeInfo,
+      // we still consider it a match if the function simply exists on the object.
+      return true;
+    });
 
-    if (allMethodsMatch && hasAnyMethod && normalizedType.methods.size > 0) {
-      // For interface-to-concrete type assertions, we just need to check methods
-      return { value: value as T, ok: true }
+    if (allMethodsMatch) {
+      return { value: value as T, ok: true };
     }
   }
 
@@ -1498,182 +1763,182 @@ export interface Channel<T> {
 
 // A simple implementation of buffered channels
 class BufferedChannel<T> implements Channel<T> {
-  private buffer: T[] = [];
-  private closed: boolean = false;
-  private capacity: number;
-  public zeroValue: T; // Made public for access by ChannelRef or for type inference
+  private buffer: T[] = []
+  private closed: boolean = false
+  private capacity: number
+  public zeroValue: T // Made public for access by ChannelRef or for type inference
 
   // Senders queue: stores { value, resolve for send, reject for send }
   private senders: Array<{
-    value: T;
-    resolveSend: () => void;
-    rejectSend: (e: Error) => void;
-  }> = [];
+    value: T
+    resolveSend: () => void
+    rejectSend: (e: Error) => void
+  }> = []
 
   // Receivers queue for receive(): stores { resolve for receive, reject for receive }
   private receivers: Array<{
-    resolveReceive: (value: T) => void;
-    rejectReceive: (e: Error) => void;
-  }> = [];
+    resolveReceive: (value: T) => void
+    rejectReceive: (e: Error) => void
+  }> = []
 
   // Receivers queue for receiveWithOk(): stores { resolve for receiveWithOk }
   private receiversWithOk: Array<{
-    resolveReceive: (result: ChannelReceiveResult<T>) => void;
-  }> = [];
+    resolveReceive: (result: ChannelReceiveResult<T>) => void
+  }> = []
 
   constructor(capacity: number, zeroValue: T) {
     if (capacity < 0) {
-      throw new Error('Channel capacity cannot be negative');
+      throw new Error('Channel capacity cannot be negative')
     }
-    this.capacity = capacity;
-    this.zeroValue = zeroValue;
+    this.capacity = capacity
+    this.zeroValue = zeroValue
   }
 
   async send(value: T): Promise<void> {
     if (this.closed) {
-      throw new Error('send on closed channel');
+      throw new Error('send on closed channel')
     }
 
     // Attempt to hand off to a waiting receiver (rendezvous)
     if (this.receivers.length > 0) {
-      const receiverTask = this.receivers.shift()!;
-      queueMicrotask(() => receiverTask.resolveReceive(value));
-      return;
+      const receiverTask = this.receivers.shift()!
+      queueMicrotask(() => receiverTask.resolveReceive(value))
+      return
     }
     if (this.receiversWithOk.length > 0) {
-      const receiverTask = this.receiversWithOk.shift()!;
-      queueMicrotask(() => receiverTask.resolveReceive({ value, ok: true }));
-      return;
+      const receiverTask = this.receiversWithOk.shift()!
+      queueMicrotask(() => receiverTask.resolveReceive({ value, ok: true }))
+      return
     }
 
     // If no waiting receivers, try to buffer if space is available
     if (this.buffer.length < this.capacity) {
-      this.buffer.push(value);
-      return;
+      this.buffer.push(value)
+      return
     }
 
     // Buffer is full (or capacity is 0 and no receivers are waiting). Sender must block.
     return new Promise<void>((resolve, reject) => {
-      this.senders.push({ value, resolveSend: resolve, rejectSend: reject });
-    });
+      this.senders.push({ value, resolveSend: resolve, rejectSend: reject })
+    })
   }
 
   async receive(): Promise<T> {
     // Attempt to get from buffer first
     if (this.buffer.length > 0) {
-      const value = this.buffer.shift()!;
+      const value = this.buffer.shift()!
       // If a sender was waiting because the buffer was full, unblock it.
       if (this.senders.length > 0) {
-        const senderTask = this.senders.shift()!;
-        this.buffer.push(senderTask.value); // Sender's value now goes into buffer
-        queueMicrotask(() => senderTask.resolveSend()); // Unblock sender
+        const senderTask = this.senders.shift()!
+        this.buffer.push(senderTask.value) // Sender's value now goes into buffer
+        queueMicrotask(() => senderTask.resolveSend()) // Unblock sender
       }
-      return value;
+      return value
     }
 
     // Buffer is empty.
     // If channel is closed (and buffer is empty), subsequent receives panic.
     if (this.closed) {
-      throw new Error('receive on closed channel');
+      throw new Error('receive on closed channel')
     }
 
     // Buffer is empty, channel is open.
     // Attempt to rendezvous with a waiting sender.
     if (this.senders.length > 0) {
-      const senderTask = this.senders.shift()!;
-      queueMicrotask(() => senderTask.resolveSend()); // Unblock the sender
-      return senderTask.value; // Return the value from sender
+      const senderTask = this.senders.shift()!
+      queueMicrotask(() => senderTask.resolveSend()) // Unblock the sender
+      return senderTask.value // Return the value from sender
     }
 
     // Buffer is empty, channel is open, no waiting senders. Receiver must block.
     return new Promise<T>((resolve, reject) => {
-      this.receivers.push({ resolveReceive: resolve, rejectReceive: reject });
-    });
+      this.receivers.push({ resolveReceive: resolve, rejectReceive: reject })
+    })
   }
 
   async receiveWithOk(): Promise<ChannelReceiveResult<T>> {
     // Attempt to get from buffer first
     if (this.buffer.length > 0) {
-      const value = this.buffer.shift()!;
+      const value = this.buffer.shift()!
       if (this.senders.length > 0) {
-        const senderTask = this.senders.shift()!;
-        this.buffer.push(senderTask.value);
-        queueMicrotask(() => senderTask.resolveSend());
+        const senderTask = this.senders.shift()!
+        this.buffer.push(senderTask.value)
+        queueMicrotask(() => senderTask.resolveSend())
       }
-      return { value, ok: true };
+      return { value, ok: true }
     }
 
     // Buffer is empty.
     // Attempt to rendezvous with a waiting sender.
     if (this.senders.length > 0) {
-      const senderTask = this.senders.shift()!;
-      queueMicrotask(() => senderTask.resolveSend());
-      return { value: senderTask.value, ok: true };
+      const senderTask = this.senders.shift()!
+      queueMicrotask(() => senderTask.resolveSend())
+      return { value: senderTask.value, ok: true }
     }
 
     // Buffer is empty, no waiting senders.
     // If channel is closed, return zero value with ok: false.
     if (this.closed) {
-      return { value: this.zeroValue, ok: false };
+      return { value: this.zeroValue, ok: false }
     }
 
     // Buffer is empty, channel is open, no waiting senders. Receiver must block.
     return new Promise<ChannelReceiveResult<T>>((resolve) => {
-      this.receiversWithOk.push({ resolveReceive: resolve });
-    });
+      this.receiversWithOk.push({ resolveReceive: resolve })
+    })
   }
 
   async selectReceive(id: number): Promise<SelectResult<T>> {
     if (this.buffer.length > 0) {
-      const value = this.buffer.shift()!;
+      const value = this.buffer.shift()!
       if (this.senders.length > 0) {
-        const senderTask = this.senders.shift()!;
-        this.buffer.push(senderTask.value);
-        queueMicrotask(() => senderTask.resolveSend());
+        const senderTask = this.senders.shift()!
+        this.buffer.push(senderTask.value)
+        queueMicrotask(() => senderTask.resolveSend())
       }
-      return { value, ok: true, id };
+      return { value, ok: true, id }
     }
 
     if (this.senders.length > 0) {
-      const senderTask = this.senders.shift()!;
-      queueMicrotask(() => senderTask.resolveSend());
-      return { value: senderTask.value, ok: true, id };
+      const senderTask = this.senders.shift()!
+      queueMicrotask(() => senderTask.resolveSend())
+      return { value: senderTask.value, ok: true, id }
     }
 
     if (this.closed) {
-      return { value: this.zeroValue, ok: false, id };
+      return { value: this.zeroValue, ok: false, id }
     }
 
     return new Promise<SelectResult<T>>((resolve) => {
       this.receiversWithOk.push({
         resolveReceive: (result: ChannelReceiveResult<T>) => {
-          resolve({ ...result, id });
+          resolve({ ...result, id })
         },
-      });
-    });
+      })
+    })
   }
 
   async selectSend(value: T, id: number): Promise<SelectResult<boolean>> {
     if (this.closed) {
       // A select case sending on a closed channel panics in Go.
       // This will cause Promise.race in selectStatement to reject.
-      throw new Error('send on closed channel');
+      throw new Error('send on closed channel')
     }
 
     if (this.receivers.length > 0) {
-      const receiverTask = this.receivers.shift()!;
-      queueMicrotask(() => receiverTask.resolveReceive(value));
-      return { value: true, ok: true, id };
+      const receiverTask = this.receivers.shift()!
+      queueMicrotask(() => receiverTask.resolveReceive(value))
+      return { value: true, ok: true, id }
     }
     if (this.receiversWithOk.length > 0) {
-      const receiverTask = this.receiversWithOk.shift()!;
-      queueMicrotask(() => receiverTask.resolveReceive({ value, ok: true }));
-      return { value: true, ok: true, id };
+      const receiverTask = this.receiversWithOk.shift()!
+      queueMicrotask(() => receiverTask.resolveReceive({ value, ok: true }))
+      return { value: true, ok: true, id }
     }
 
     if (this.buffer.length < this.capacity) {
-      this.buffer.push(value);
-      return { value: true, ok: true, id };
+      this.buffer.push(value)
+      return { value: true, ok: true, id }
     }
 
     return new Promise<SelectResult<boolean>>((resolve, reject) => {
@@ -1681,48 +1946,54 @@ class BufferedChannel<T> implements Channel<T> {
         value,
         resolveSend: () => resolve({ value: true, ok: true, id }),
         rejectSend: (e) => reject(e), // Propagate error if channel closes
-      });
-    });
+      })
+    })
   }
 
   close(): void {
     if (this.closed) {
-      throw new Error('close of closed channel');
+      throw new Error('close of closed channel')
     }
-    this.closed = true;
+    this.closed = true
 
-    const sendersToNotify = [...this.senders]; // Shallow copy for iteration
-    this.senders = [];
+    const sendersToNotify = [...this.senders] // Shallow copy for iteration
+    this.senders = []
     for (const senderTask of sendersToNotify) {
-      queueMicrotask(() => senderTask.rejectSend(new Error('send on closed channel')));
+      queueMicrotask(() =>
+        senderTask.rejectSend(new Error('send on closed channel')),
+      )
     }
 
-    const receiversToNotify = [...this.receivers];
-    this.receivers = [];
+    const receiversToNotify = [...this.receivers]
+    this.receivers = []
     for (const receiverTask of receiversToNotify) {
-      queueMicrotask(() => receiverTask.rejectReceive(new Error('receive on closed channel')));
+      queueMicrotask(() =>
+        receiverTask.rejectReceive(new Error('receive on closed channel')),
+      )
     }
 
-    const receiversWithOkToNotify = [...this.receiversWithOk];
-    this.receiversWithOk = [];
+    const receiversWithOkToNotify = [...this.receiversWithOk]
+    this.receiversWithOk = []
     for (const receiverTask of receiversWithOkToNotify) {
-      queueMicrotask(() => receiverTask.resolveReceive({ value: this.zeroValue, ok: false }));
+      queueMicrotask(() =>
+        receiverTask.resolveReceive({ value: this.zeroValue, ok: false }),
+      )
     }
   }
 
   canReceiveNonBlocking(): boolean {
-    return this.buffer.length > 0 || this.senders.length > 0 || this.closed;
+    return this.buffer.length > 0 || this.senders.length > 0 || this.closed
   }
 
   canSendNonBlocking(): boolean {
     if (this.closed) {
-      return true; // Ready to panic
+      return true // Ready to panic
     }
     return (
       this.buffer.length < this.capacity ||
       this.receivers.length > 0 ||
       this.receiversWithOk.length > 0
-    );
+    )
   }
 }