diff --git a/docs/content/docs/contributing/api-modelling.mdx b/docs/content/docs/contributing/api-modelling.mdx
index 1b7aedb2..032b32cc 100644
--- a/docs/content/docs/contributing/api-modelling.mdx
+++ b/docs/content/docs/contributing/api-modelling.mdx
@@ -58,6 +58,48 @@ external addEventListenerWithCapture: (
 
 When naming an overloaded function, we can use the `With` suffix to indicate that it is an overloaded function.
 
+### Constructor overloads
+
+Constructors follow a different naming rule than methods.
+
+- Keep singleton constructors named `make`.
+- Keep true default constructors named `make`, even when the constructor family also has typed overloads.
+- When a constructor family does not have a default constructor, use `from*` names for every overload, including the first one.
+- Base `from*` names on the source input type: `fromString`, `fromArrayBuffer`, `fromMediaStream`, `fromURLWithProtocols`, and so on.
+- If an optional labeled argument hides a real default constructor, split that binding into `make()` plus typed `from*` overloads instead of keeping the optional argument on `make`.
+
+For example, these constructor families are easier to understand than numbered overloads:
+
+```ReScript
+@new
+external fromString: (~family: string, ~source: string) => fontFace = "FontFace"
+
+@new
+external fromDataView: (~family: string, ~source: DataView.t) => fontFace = "FontFace"
+
+@new
+external fromArrayBuffer: (~family: string, ~source: ArrayBuffer.t) => fontFace = "FontFace"
+```
+
+And if a constructor really does have a default form, split it instead of hiding it:
+
+```ReScript
+@new
+external make: unit => domMatrix = "DOMMatrix"
+
+@new
+external fromString: string => domMatrix = "DOMMatrix"
+
+@new
+external fromArray: array<float> => domMatrix = "DOMMatrix"
+```
+
+Single-source constructor variants should take the source value directly without a label.
+
+Keep `makeWith*` names for non-default convenience constructors that are not part of a source-type overload family.
+
+Constructor naming is currently verified with compile-coverage tests. Runtime verification for these constructor families will be added later when the Vitest and happy-dom harness lands.
+
 ### Decoded variants
 
 We can be pragmatic with overloaded functions and use model them in various creative ways.  
diff --git a/docs/content/docs/contributing/documentation.mdx b/docs/content/docs/contributing/documentation.mdx
index 2f75358a..44333490 100644
--- a/docs/content/docs/contributing/documentation.mdx
+++ b/docs/content/docs/contributing/documentation.mdx
@@ -21,7 +21,7 @@ It keeps the user inside the IDE and avoids context switching.
 The documentation for each binding should roughly follow this structure:
 
 - signature
-- key description (tip: check MDN for inspiration)
+- short description focused on the ReScript side of the API
 - example usage
 - link to the MDN documentation
 
@@ -44,3 +44,25 @@ window->Window.fetch("https://rescript-lang.org")
 external fetch: (window, string, ~init: requestInit=?)
   => promise<response> = "fetch"
 ````
+
+Constructor overloads should use the same structure, but keep the description concise and let the signature and example show the input shape.
+Use backticks for specific types and names.
+If a constructor variant has a single source input, show it as a direct unlabeled argument in both the signature and example.
+
+````ReScript
+/*
+`fromArray(array<float>)`
+
+Creates a new `DOMMatrix` from an array of matrix component values.
+
+```res
+let matrix = DOMMatrix.fromArray([1., 0., 0., 1., 0., 0.])
+```
+
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/DOMMatrix)
+*/
+@new
+external fromArray: array<float> => domMatrix = "DOMMatrix"
+````
+
+For now, these examples stay compile-coverage oriented. Runtime verification of constructor behavior will be handled later via Vitest and happy-dom.
diff --git a/packages/CSSFontLoading/src/FontFace.res b/packages/CSSFontLoading/src/FontFace.res
index d777e109..6c34da55 100644
--- a/packages/CSSFontLoading/src/FontFace.res
+++ b/packages/CSSFontLoading/src/FontFace.res
@@ -1,28 +1,55 @@
 /**
+`fromString(~family: string, ~source: string, ~descriptors: fontFaceDescriptors=?)`
+
+Creates a new `FontFace` from CSS source text.
+
+```res
+let fontFace =
+  FontFace.fromString(~family="Inter", ~source="url(/fonts/inter.woff2)")
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/FontFace)
 */
 @new
-external make: (
+external fromString: (
   ~family: string,
   ~source: string,
   ~descriptors: Types.fontFaceDescriptors=?,
 ) => Types.fontFace = "FontFace"
 
 /**
+`fromDataView(~family: string, ~source: DataView.t, ~descriptors: fontFaceDescriptors=?)`
+
+Creates a new `FontFace` from `DataView`-backed font data.
+
+```res
+let fontFace =
+  FontFace.fromDataView(~family="Inter", ~source=myDataView)
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/FontFace)
 */
 @new
-external make2: (
+external fromDataView: (
   ~family: string,
   ~source: DataView.t,
   ~descriptors: Types.fontFaceDescriptors=?,
 ) => Types.fontFace = "FontFace"
 
 /**
+`fromArrayBuffer(~family: string, ~source: ArrayBuffer.t, ~descriptors: fontFaceDescriptors=?)`
+
+Creates a new `FontFace` from `ArrayBuffer`-backed font data.
+
+```res
+let fontFace =
+  FontFace.fromArrayBuffer(~family="Inter", ~source=myArrayBuffer)
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/FontFace)
 */
 @new
-external make3: (
+external fromArrayBuffer: (
   ~family: string,
   ~source: ArrayBuffer.t,
   ~descriptors: Types.fontFaceDescriptors=?,
diff --git a/packages/Canvas/src/Path2D.res b/packages/Canvas/src/Path2D.res
index 663b2453..5c8417c4 100644
--- a/packages/Canvas/src/Path2D.res
+++ b/packages/Canvas/src/Path2D.res
@@ -1,16 +1,46 @@
 type domMatrix2DInit = WebApiDOM.Types.domMatrix2DInit
 
 /**
+`make()`
+
+Creates a new empty `Path2D`.
+
+```res
+let path = Path2D.make()
+```
+
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/Path2D)
+*/
+@new
+external make: unit => Types.path2D = "Path2D"
+
+/**
+`fromPath2D(path2D)`
+
+Creates a new `Path2D` by copying another `Path2D`.
+
+```res
+let copiedPath = Path2D.fromPath2D(existingPath)
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/Path2D)
 */
 @new
-external make: (~path: Types.path2D=?) => Types.path2D = "Path2D"
+external fromPath2D: Types.path2D => Types.path2D = "Path2D"
 
 /**
+`fromString(string)`
+
+Creates a new `Path2D` from SVG path data text.
+
+```res
+let path = Path2D.fromString("M0 0 L10 10")
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/Path2D)
 */
 @new
-external make2: (~path: string=?) => Types.path2D = "Path2D"
+external fromString: string => Types.path2D = "Path2D"
 
 /**
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/CanvasRenderingContext2D/closePath)
diff --git a/packages/Canvas/src/VideoFrame.res b/packages/Canvas/src/VideoFrame.res
index 10fb9cdd..8e1756ec 100644
--- a/packages/Canvas/src/VideoFrame.res
+++ b/packages/Canvas/src/VideoFrame.res
@@ -1,89 +1,177 @@
+type sharedArrayBuffer = unknown
+
 /**
+`fromHTMLImageElement(~image: HTMLImageElement.t, ~init: videoFrameInit=?)`
+
+Creates a new `VideoFrame` from an `HTMLImageElement`.
+
+```res
+let frame = VideoFrame.fromHTMLImageElement(~image=myImageElement)
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/VideoFrame)
 */
 @new
-external make: (
+external fromHTMLImageElement: (
   ~image: WebApiDOM.Types.htmlImageElement,
   ~init: WebApiDOM.Types.videoFrameInit=?,
 ) => WebApiDOM.Types.videoFrame = "VideoFrame"
 
 /**
+`fromSVGImageElement(~image: SVGImageElement.t, ~init: videoFrameInit=?)`
+
+Creates a new `VideoFrame` from an `SVGImageElement`.
+
+```res
+let frame = VideoFrame.fromSVGImageElement(~image=mySvgImageElement)
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/VideoFrame)
 */
 @new
-external make2: (
+external fromSVGImageElement: (
   ~image: WebApiDOM.Types.svgImageElement,
   ~init: WebApiDOM.Types.videoFrameInit=?,
 ) => WebApiDOM.Types.videoFrame = "VideoFrame"
 
 /**
+`fromHTMLVideoElement(~image: HTMLVideoElement.t, ~init: videoFrameInit=?)`
+
+Creates a new `VideoFrame` from an `HTMLVideoElement`.
+
+```res
+let frame = VideoFrame.fromHTMLVideoElement(~image=myVideoElement)
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/VideoFrame)
 */
 @new
-external make3: (
+external fromHTMLVideoElement: (
   ~image: WebApiDOM.Types.htmlVideoElement,
   ~init: WebApiDOM.Types.videoFrameInit=?,
 ) => WebApiDOM.Types.videoFrame = "VideoFrame"
 
 /**
+`fromHTMLCanvasElement(~image: HTMLCanvasElement.t, ~init: videoFrameInit=?)`
+
+Creates a new `VideoFrame` from an `HTMLCanvasElement`.
+
+```res
+let frame = VideoFrame.fromHTMLCanvasElement(~image=myCanvasElement)
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/VideoFrame)
 */
 @new
-external make4: (
+external fromHTMLCanvasElement: (
   ~image: WebApiDOM.Types.htmlCanvasElement,
   ~init: WebApiDOM.Types.videoFrameInit=?,
 ) => WebApiDOM.Types.videoFrame = "VideoFrame"
 
 /**
+`fromImageBitmap(~image: ImageBitmap.t, ~init: videoFrameInit=?)`
+
+Creates a new `VideoFrame` from an `ImageBitmap`.
+
+```res
+let frame = VideoFrame.fromImageBitmap(~image=myImageBitmap)
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/VideoFrame)
 */
 @new
-external make5: (
+external fromImageBitmap: (
   ~image: Types.imageBitmap,
   ~init: WebApiDOM.Types.videoFrameInit=?,
 ) => WebApiDOM.Types.videoFrame = "VideoFrame"
 
 /**
+`fromOffscreenCanvas(~image: OffscreenCanvas.t, ~init: videoFrameInit=?)`
+
+Creates a new `VideoFrame` from an `OffscreenCanvas`.
+
+```res
+let frame = VideoFrame.fromOffscreenCanvas(~image=myOffscreenCanvas)
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/VideoFrame)
 */
 @new
-external make6: (
+external fromOffscreenCanvas: (
   ~image: Types.offscreenCanvas,
   ~init: WebApiDOM.Types.videoFrameInit=?,
 ) => WebApiDOM.Types.videoFrame = "VideoFrame"
 
 /**
+`fromVideoFrame(~image: VideoFrame.t, ~init: videoFrameInit=?)`
+
+Creates a new `VideoFrame` from another `VideoFrame`.
+
+```res
+let frame = VideoFrame.fromVideoFrame(~image=otherFrame)
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/VideoFrame)
 */
 @new
-external make7: (
+external fromVideoFrame: (
   ~image: WebApiDOM.Types.videoFrame,
   ~init: WebApiDOM.Types.videoFrameInit=?,
 ) => WebApiDOM.Types.videoFrame = "VideoFrame"
 
 /**
+`fromArrayBuffer(~data: ArrayBuffer.t, ~init: videoFrameBufferInit)`
+
+Creates a new `VideoFrame` from `ArrayBuffer`-backed pixel data.
+
+```res
+let frame =
+  VideoFrame.fromArrayBuffer(~data=myArrayBuffer, ~init=myVideoFrameBufferInit)
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/VideoFrame)
 */
 @new
-external make8: (
+external fromArrayBuffer: (
   ~data: ArrayBuffer.t,
   ~init: WebApiDOM.Types.videoFrameBufferInit,
 ) => WebApiDOM.Types.videoFrame = "VideoFrame"
 
 /**
+`fromSharedArrayBuffer(~data: sharedArrayBuffer, ~init: videoFrameBufferInit)`
+
+Creates a new `VideoFrame` from `SharedArrayBuffer`-backed pixel data.
+
+```res
+let frame =
+  VideoFrame.fromSharedArrayBuffer(
+    ~data=mySharedArrayBuffer,
+    ~init=myVideoFrameBufferInit,
+  )
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/VideoFrame)
 */
 @new
-external make9: (
-  ~data: WebApiBase.ArrayBufferTypedArrayOrDataView.t,
+external fromSharedArrayBuffer: (
+  ~data: sharedArrayBuffer,
   ~init: WebApiDOM.Types.videoFrameBufferInit,
 ) => WebApiDOM.Types.videoFrame = "VideoFrame"
 
 /**
+`fromDataView(~data: DataView.t, ~init: videoFrameBufferInit)`
+
+Creates a new `VideoFrame` from `DataView`-backed pixel data.
+
+```res
+let frame =
+  VideoFrame.fromDataView(~data=myDataView, ~init=myVideoFrameBufferInit)
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/VideoFrame)
 */
 @new
-external make10: (
+external fromDataView: (
   ~data: DataView.t,
   ~init: WebApiDOM.Types.videoFrameBufferInit,
 ) => WebApiDOM.Types.videoFrame = "VideoFrame"
diff --git a/packages/DOM/src/DOMMatrix.res b/packages/DOM/src/DOMMatrix.res
index f9e85641..97484a02 100644
--- a/packages/DOM/src/DOMMatrix.res
+++ b/packages/DOM/src/DOMMatrix.res
@@ -1,14 +1,44 @@
 /**
+`make()`
+
+Creates a new identity `DOMMatrix`.
+
+```res
+let matrix = DOMMatrix.make()
+```
+
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/DOMMatrix)
+*/
+@new
+external make: unit => Types.domMatrix = "DOMMatrix"
+
+/**
+`fromString(string)`
+
+Creates a new `DOMMatrix` from a transform string.
+
+```res
+let matrix = DOMMatrix.fromString("matrix(1, 0, 0, 1, 0, 0)")
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/DOMMatrix)
 */
 @new
-external make: (~init: string=?) => Types.domMatrix = "DOMMatrix"
+external fromString: string => Types.domMatrix = "DOMMatrix"
 
 /**
+`fromArray(array<float>)`
+
+Creates a new `DOMMatrix` from an array of matrix component values.
+
+```res
+let matrix = DOMMatrix.fromArray([1., 0., 0., 1., 0., 0.])
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/DOMMatrix)
 */
 @new
-external make2: (~init: array<float>=?) => Types.domMatrix = "DOMMatrix"
+external fromArray: array<float> => Types.domMatrix = "DOMMatrix"
 
 external asDOMMatrixReadOnly: Types.domMatrix => Types.domMatrixReadOnly = "%identity"
 @scope("DOMMatrix")
diff --git a/packages/DOM/src/DOMMatrixReadOnly.res b/packages/DOM/src/DOMMatrixReadOnly.res
index 1c5cc270..c747744d 100644
--- a/packages/DOM/src/DOMMatrixReadOnly.res
+++ b/packages/DOM/src/DOMMatrixReadOnly.res
@@ -1,14 +1,44 @@
 /**
+`make()`
+
+Creates a new identity `DOMMatrixReadOnly`.
+
+```res
+let matrix = DOMMatrixReadOnly.make()
+```
+
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly)
+*/
+@new
+external make: unit => Types.domMatrixReadOnly = "DOMMatrixReadOnly"
+
+/**
+`fromString(string)`
+
+Creates a new `DOMMatrixReadOnly` from a transform string.
+
+```res
+let matrix = DOMMatrixReadOnly.fromString("matrix(1, 0, 0, 1, 0, 0)")
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly)
 */
 @new
-external make: (~init: string=?) => Types.domMatrixReadOnly = "DOMMatrixReadOnly"
+external fromString: string => Types.domMatrixReadOnly = "DOMMatrixReadOnly"
 
 /**
+`fromArray(array<float>)`
+
+Creates a new `DOMMatrixReadOnly` from an array of matrix component values.
+
+```res
+let matrix = DOMMatrixReadOnly.fromArray([1., 0., 0., 1., 0., 0.])
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly)
 */
 @new
-external make2: (~init: array<float>=?) => Types.domMatrixReadOnly = "DOMMatrixReadOnly"
+external fromArray: array<float> => Types.domMatrixReadOnly = "DOMMatrixReadOnly"
 
 @scope("DOMMatrixReadOnly")
 external fromMatrix: (~other: Types.domMatrixInit=?) => Types.domMatrixReadOnly = "fromMatrix"
diff --git a/packages/File/src/ReadableStream.res b/packages/File/src/ReadableStream.res
index 205e4fca..6084b8d3 100644
--- a/packages/File/src/ReadableStream.res
+++ b/packages/File/src/ReadableStream.res
@@ -4,22 +4,53 @@
 type t<'r> = Types.readableStream<'r>
 
 /**
+`make()`
+
+Creates a new empty `ReadableStream`.
+
+```res
+let stream: ReadableStream.t<string> = ReadableStream.make()
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/ReadableStream)
 */
 @new
-external make: unit => t<array<int>> = "ReadableStream"
+external make: unit => t<'t> = "ReadableStream"
 
 /**
+`fromUnderlyingSource(underlyingSource<'t>)`
+
+Creates a new `ReadableStream` from an `underlyingSource`.
+
+```res
+let stream = ReadableStream.fromUnderlyingSource(myUnderlyingSource)
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/ReadableStream)
 */
 @new
-external make2: unit => unknown = "ReadableStream"
+external fromUnderlyingSource: Types.underlyingSource<'t> => t<'t> = "ReadableStream"
 
 /**
+`fromUnderlyingSourceWithStrategy(~underlyingSource: underlyingSource<'t>, ~strategy: queuingStrategy<'t>)`
+
+Creates a new `ReadableStream` from an `underlyingSource` and `queuingStrategy`.
+
+```res
+let stream =
+  ReadableStream.fromUnderlyingSourceWithStrategy(
+    ~underlyingSource=myUnderlyingSource,
+    ~strategy=myQueuingStrategy,
+  )
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/ReadableStream)
 */
 @new
-external make3: unit => unknown = "ReadableStream"
+external fromUnderlyingSourceWithStrategy: (
+  ~underlyingSource: Types.underlyingSource<'t>,
+  ~strategy: Types.queuingStrategy<'t>,
+) => t<'t> = "ReadableStream"
 
 /**
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/ReadableStream/cancel)
diff --git a/packages/File/src/Types.res b/packages/File/src/Types.res
index 44c9d3ac..fee2c9af 100644
--- a/packages/File/src/Types.res
+++ b/packages/File/src/Types.res
@@ -137,6 +137,8 @@ type queuingStrategy<'t> = unknown
 
 type underlyingSink<'t> = unknown
 
+type underlyingSource<'t> = unknown
+
 type readableStreamReader<'t> = unknown
 
 type writableStreamDefaultWriter<'t> = unknown
diff --git a/packages/MediaCaptureAndStreams/src/MediaStream.res b/packages/MediaCaptureAndStreams/src/MediaStream.res
index 518205e7..f56ff1f9 100644
--- a/packages/MediaCaptureAndStreams/src/MediaStream.res
+++ b/packages/MediaCaptureAndStreams/src/MediaStream.res
@@ -1,22 +1,46 @@
 type t = Types.mediaStream = private {...Types.mediaStream}
 
 /**
+`make()`
+
+Creates a new empty `MediaStream`.
+
+```res
+let stream = MediaStream.make()
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/MediaStream)
 */
 @new
 external make: unit => t = "MediaStream"
 
 /**
+`fromMediaStream(mediaStream)`
+
+Creates a new `MediaStream` by copying another `MediaStream`.
+
+```res
+let copiedStream = MediaStream.fromMediaStream(existingStream)
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/MediaStream)
 */
 @new
-external makeFromMediaStream: t => t = "MediaStream"
+external fromMediaStream: t => t = "MediaStream"
 
 /**
+`fromTracks(array<MediaStreamTrack.t>)`
+
+Creates a new `MediaStream` from an array of `MediaStreamTrack.t` values.
+
+```res
+let stream = MediaStream.fromTracks([audioTrack, videoTrack])
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/MediaStream)
 */
 @new
-external makeFromMediaStreams: array<MediaStreamTrack.t> => t = "MediaStream"
+external fromTracks: array<MediaStreamTrack.t> => t = "MediaStream"
 
 include WebApiEvent.EventTarget.Impl({type t = t})
 
diff --git a/packages/WebAudio/src/OfflineAudioContext.res b/packages/WebAudio/src/OfflineAudioContext.res
index 3598e9d4..a87224ca 100644
--- a/packages/WebAudio/src/OfflineAudioContext.res
+++ b/packages/WebAudio/src/OfflineAudioContext.res
@@ -1,16 +1,38 @@
 include BaseAudioContext.Impl({type t = Types.offlineAudioContext})
 
 /**
+`fromOptions(offlineAudioContextOptions)`
+
+Creates a new `OfflineAudioContext` from `offlineAudioContextOptions`.
+
+```res
+let context = OfflineAudioContext.fromOptions(myOfflineAudioContextOptions)
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/OfflineAudioContext)
 */
 @new
-external make: Types.offlineAudioContextOptions => Types.offlineAudioContext = "OfflineAudioContext"
+external fromOptions: Types.offlineAudioContextOptions => Types.offlineAudioContext =
+  "OfflineAudioContext"
 
 /**
+`fromChannelCountLengthAndSampleRate(~numberOfChannels: int, ~length: int, ~sampleRate: float)`
+
+Creates a new `OfflineAudioContext` from explicit channel, length, and sample-rate values.
+
+```res
+let context =
+  OfflineAudioContext.fromChannelCountLengthAndSampleRate(
+    ~numberOfChannels=2,
+    ~length=44_100,
+    ~sampleRate=44_100.,
+  )
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/OfflineAudioContext)
 */
 @new
-external make2: (
+external fromChannelCountLengthAndSampleRate: (
   ~numberOfChannels: int,
   ~length: int,
   ~sampleRate: float,
diff --git a/packages/WebSockets/src/WebSocket.res b/packages/WebSockets/src/WebSocket.res
index 455ec50c..23520624 100644
--- a/packages/WebSockets/src/WebSocket.res
+++ b/packages/WebSockets/src/WebSocket.res
@@ -7,16 +7,36 @@ type closeEvent = Types.closeEvent = private {...Types.closeEvent}
 type messageEventSource = Types.messageEventSource
 
 /**
+`fromURL(~url: string, ~protocols: string=?)`
+
+Creates a new `WebSocket` from a URL and an optional single protocol.
+
+```res
+let socket = WebSocket.fromURL(~url="wss://example.com/socket")
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/WebSocket)
 */
 @new
-external make: (~url: string, ~protocols: string=?) => t = "WebSocket"
+external fromURL: (~url: string, ~protocols: string=?) => t = "WebSocket"
 
 /**
+`fromURLWithProtocols(~url: string, ~protocols: array<string>)`
+
+Creates a new `WebSocket` from a URL and multiple protocols.
+
+```res
+let socket =
+  WebSocket.fromURLWithProtocols(
+    ~url="wss://example.com/socket",
+    ~protocols=["chat", "superchat"],
+  )
+```
+
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/WebSocket)
 */
 @new
-external makeWithProtocols: (~url: string, ~protocols: array<string>=?) => t = "WebSocket"
+external fromURLWithProtocols: (~url: string, ~protocols: array<string>) => t = "WebSocket"
 
 include WebApiEvent.EventTarget.Impl({type t = t})
 
diff --git a/tests/CSSFontLoadingAPI/FontFace__test.res b/tests/CSSFontLoadingAPI/FontFace__test.res
new file mode 100644
index 00000000..d5700b2a
--- /dev/null
+++ b/tests/CSSFontLoadingAPI/FontFace__test.res
@@ -0,0 +1,14 @@
+let dataView: DataView.t = Obj.magic()
+let arrayBuffer: ArrayBuffer.t = Obj.magic()
+
+let _fromString = WebApiCSSFontLoading.FontFace.fromString(
+  ~family="Inter",
+  ~source="url(/fonts/inter.woff2)",
+)
+
+let _fromDataView = WebApiCSSFontLoading.FontFace.fromDataView(~family="Inter", ~source=dataView)
+
+let _fromArrayBuffer = WebApiCSSFontLoading.FontFace.fromArrayBuffer(
+  ~family="Inter",
+  ~source=arrayBuffer,
+)
diff --git a/tests/CanvasAPI/Path2D__test.res b/tests/CanvasAPI/Path2D__test.res
new file mode 100644
index 00000000..9e954d7a
--- /dev/null
+++ b/tests/CanvasAPI/Path2D__test.res
@@ -0,0 +1,5 @@
+let path2D: WebApiCanvas.Types.path2D = Obj.magic()
+
+let _make = WebApiCanvas.Path2D.make()
+let _fromPath2D = WebApiCanvas.Path2D.fromPath2D(path2D)
+let _fromString = WebApiCanvas.Path2D.fromString("M0 0 L10 10")
diff --git a/tests/DOMAPI/DOMMatrixReadOnly__test.res b/tests/DOMAPI/DOMMatrixReadOnly__test.res
new file mode 100644
index 00000000..24dcba03
--- /dev/null
+++ b/tests/DOMAPI/DOMMatrixReadOnly__test.res
@@ -0,0 +1,5 @@
+let _make = WebApiDOM.DOMMatrixReadOnly.make()
+
+let _fromString = WebApiDOM.DOMMatrixReadOnly.fromString("matrix(1, 0, 0, 1, 0, 0)")
+
+let _fromArray = WebApiDOM.DOMMatrixReadOnly.fromArray([1., 0., 0., 1., 0., 0.])
diff --git a/tests/DOMAPI/DOMMatrix__test.res b/tests/DOMAPI/DOMMatrix__test.res
new file mode 100644
index 00000000..512f98db
--- /dev/null
+++ b/tests/DOMAPI/DOMMatrix__test.res
@@ -0,0 +1,3 @@
+let _make = WebApiDOM.DOMMatrix.make()
+let _fromString = WebApiDOM.DOMMatrix.fromString("matrix(1, 0, 0, 1, 0, 0)")
+let _fromArray = WebApiDOM.DOMMatrix.fromArray([1., 0., 0., 1., 0., 0.])
diff --git a/tests/DOMAPI/VideoFrame__test.res b/tests/DOMAPI/VideoFrame__test.res
new file mode 100644
index 00000000..96962763
--- /dev/null
+++ b/tests/DOMAPI/VideoFrame__test.res
@@ -0,0 +1,59 @@
+let htmlImageElement: WebApiDOM.Types.htmlImageElement = Obj.magic()
+let svgImageElement: WebApiDOM.Types.svgImageElement = Obj.magic()
+let htmlVideoElement: WebApiDOM.Types.htmlVideoElement = Obj.magic()
+let htmlCanvasElement: WebApiDOM.Types.htmlCanvasElement = Obj.magic()
+let imageBitmap: WebApiCanvas.Types.imageBitmap = Obj.magic()
+let offscreenCanvas: WebApiCanvas.Types.offscreenCanvas = Obj.magic()
+let videoFrame: WebApiDOM.Types.videoFrame = Obj.magic()
+let arrayBuffer: ArrayBuffer.t = Obj.magic()
+let sharedArrayBuffer = Obj.magic()
+let dataView: DataView.t = Obj.magic()
+let videoFrameInit: WebApiDOM.Types.videoFrameInit = Obj.magic()
+let videoFrameBufferInit: WebApiDOM.Types.videoFrameBufferInit = Obj.magic()
+
+let _fromHTMLImageElement = WebApiCanvas.VideoFrame.fromHTMLImageElement(
+  ~image=htmlImageElement,
+  ~init=videoFrameInit,
+)
+
+let _fromSVGImageElement = WebApiCanvas.VideoFrame.fromSVGImageElement(
+  ~image=svgImageElement,
+  ~init=videoFrameInit,
+)
+
+let _fromHTMLVideoElement = WebApiCanvas.VideoFrame.fromHTMLVideoElement(
+  ~image=htmlVideoElement,
+  ~init=videoFrameInit,
+)
+
+let _fromHTMLCanvasElement = WebApiCanvas.VideoFrame.fromHTMLCanvasElement(
+  ~image=htmlCanvasElement,
+  ~init=videoFrameInit,
+)
+
+let _fromImageBitmap = WebApiCanvas.VideoFrame.fromImageBitmap(
+  ~image=imageBitmap,
+  ~init=videoFrameInit,
+)
+
+let _fromOffscreenCanvas = WebApiCanvas.VideoFrame.fromOffscreenCanvas(
+  ~image=offscreenCanvas,
+  ~init=videoFrameInit,
+)
+
+let _fromVideoFrame = WebApiCanvas.VideoFrame.fromVideoFrame(
+  ~image=videoFrame,
+  ~init=videoFrameInit,
+)
+
+let _fromArrayBuffer = WebApiCanvas.VideoFrame.fromArrayBuffer(
+  ~data=arrayBuffer,
+  ~init=videoFrameBufferInit,
+)
+
+let _fromSharedArrayBuffer = WebApiCanvas.VideoFrame.fromSharedArrayBuffer(
+  ~data=sharedArrayBuffer,
+  ~init=videoFrameBufferInit,
+)
+
+let _fromDataView = WebApiCanvas.VideoFrame.fromDataView(~data=dataView, ~init=videoFrameBufferInit)
diff --git a/tests/FileAPI/ReadableStream__test.res b/tests/FileAPI/ReadableStream__test.res
new file mode 100644
index 00000000..2696edbd
--- /dev/null
+++ b/tests/FileAPI/ReadableStream__test.res
@@ -0,0 +1,11 @@
+let underlyingSource: WebApiFile.Types.underlyingSource<string> = Obj.magic()
+let strategy: WebApiFile.Types.queuingStrategy<string> = Obj.magic()
+
+let _make: WebApiFile.ReadableStream.t<string> = WebApiFile.ReadableStream.make()
+
+let _fromUnderlyingSource = WebApiFile.ReadableStream.fromUnderlyingSource(underlyingSource)
+
+let _fromUnderlyingSourceWithStrategy = WebApiFile.ReadableStream.fromUnderlyingSourceWithStrategy(
+  ~underlyingSource,
+  ~strategy,
+)
diff --git a/tests/MediaCaptureAndStreamsAPI/MediaStream__test.res b/tests/MediaCaptureAndStreamsAPI/MediaStream__test.res
new file mode 100644
index 00000000..00fd70db
--- /dev/null
+++ b/tests/MediaCaptureAndStreamsAPI/MediaStream__test.res
@@ -0,0 +1,8 @@
+let mediaStream: WebApiMediaCaptureAndStreams.Types.mediaStream = Obj.magic()
+let mediaStreamTrack: WebApiMediaCaptureAndStreams.Types.mediaStreamTrack = Obj.magic()
+
+let _make = WebApiMediaCaptureAndStreams.MediaStream.make()
+
+let _fromMediaStream = WebApiMediaCaptureAndStreams.MediaStream.fromMediaStream(mediaStream)
+
+let _fromTracks = WebApiMediaCaptureAndStreams.MediaStream.fromTracks([mediaStreamTrack])
diff --git a/tests/WebAudioAPI/OfflineAudioContext__test.res b/tests/WebAudioAPI/OfflineAudioContext__test.res
new file mode 100644
index 00000000..e9f38c67
--- /dev/null
+++ b/tests/WebAudioAPI/OfflineAudioContext__test.res
@@ -0,0 +1,9 @@
+let offlineAudioContextOptions: WebApiWebAudio.Types.offlineAudioContextOptions = Obj.magic()
+
+let _fromOptions = WebApiWebAudio.OfflineAudioContext.fromOptions(offlineAudioContextOptions)
+
+let _fromChannelCountLengthAndSampleRate = WebApiWebAudio.OfflineAudioContext.fromChannelCountLengthAndSampleRate(
+  ~numberOfChannels=2,
+  ~length=1024,
+  ~sampleRate=44_100.,
+)
diff --git a/tests/WebSocketsAPI/WebSocket__test.res b/tests/WebSocketsAPI/WebSocket__test.res
new file mode 100644
index 00000000..03bcbdfe
--- /dev/null
+++ b/tests/WebSocketsAPI/WebSocket__test.res
@@ -0,0 +1,6 @@
+let _fromURL = WebApiWebSockets.WebSocket.fromURL(~url="wss://example.com/socket")
+
+let _fromURLWithProtocols = WebApiWebSockets.WebSocket.fromURLWithProtocols(
+  ~url="wss://example.com/socket",
+  ~protocols=["chat", "superchat"],
+)