diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0c6026e..6fb6fa6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -49,6 +49,8 @@ Bugfixes:
 
 Other improvements:
 - Format code with `purs-tidy`; enforce in CI (#52 by @JordanMartinez)
+- Update FFI to use uncurried functions (#54 by @JordanMartinez)
+- Removed `Internal.purs` file (#54 by @JordanMartinez)
 
 ## [v8.0.0](https://github.com/purescript-node/purescript-node-buffer/releases/tag/v8.0.0) - 2022-04-27
 
diff --git a/bower.json b/bower.json
index 0d182ef..840fb17 100644
--- a/bower.json
+++ b/bower.json
@@ -17,7 +17,8 @@
     "purescript-effect": "^4.0.0",
     "purescript-maybe": "^6.0.0",
     "purescript-st": "^6.0.0",
-    "purescript-unsafe-coerce": "^6.0.0"
+    "purescript-unsafe-coerce": "^6.0.0",
+    "purescript-nullable": "^6.0.0"
   },
   "devDependencies": {
     "purescript-assert": "^6.0.0",
diff --git a/src/Node/Buffer.js b/src/Node/Buffer.js
new file mode 100644
index 0000000..8061884
--- /dev/null
+++ b/src/Node/Buffer.js
@@ -0,0 +1,19 @@
+import { Buffer } from "node:buffer";
+
+export const freezeImpl = (a) => Buffer.from(a);
+export const thawImpl = (a) => Buffer.from(a);
+
+export const writeInternal = (ty, value, offset, buf) => buf["write" + ty](value, offset);
+
+export const writeStringInternal = (encoding, offset, length, value, buff) =>
+  buff.write(value, offset, length, encoding);
+
+export const setAtOffsetImpl = (value, offset, buff) => {
+  buff[offset] = value;
+};
+
+export const copyImpl = (srcStart, srcEnd, src, targStart, targ) =>
+  src.copy(targ, targStart, srcStart, srcEnd);
+
+export const fillImpl = (octet, start, end, buf) =>
+  buf.fill(octet, start, end);
diff --git a/src/Node/Buffer.purs b/src/Node/Buffer.purs
index dcff4e0..a6fe78f 100644
--- a/src/Node/Buffer.purs
+++ b/src/Node/Buffer.purs
@@ -32,12 +32,14 @@ import Prelude
 import Data.ArrayBuffer.Types (ArrayBuffer)
 import Data.Maybe (Maybe)
 import Effect (Effect)
+import Effect.Uncurried (EffectFn1, EffectFn3, EffectFn4, EffectFn5, runEffectFn1, runEffectFn3, runEffectFn4, runEffectFn5)
 import Node.Buffer.Class (class MutableBuffer)
 import Node.Buffer.Immutable (ImmutableBuffer)
-import Node.Buffer.Internal as Internal
+import Node.Buffer.Immutable as Immutable
 import Node.Buffer.Types (BufferValueType(..), Octet, Offset) as TypesExports
-import Node.Buffer.Types (BufferValueType)
-import Node.Encoding (Encoding)
+import Node.Buffer.Types (BufferValueType, Octet, Offset)
+import Node.Encoding (Encoding, encodingToNode)
+import Unsafe.Coerce (unsafeCoerce)
 
 -- | A reference to a mutable buffer for use with `Effect`
 foreign import data Buffer :: Type
@@ -67,71 +69,94 @@ instance mutableBufferEffect :: MutableBuffer Buffer Effect where
   copy = copy
   fill = fill
 
+unsafeFreeze :: Buffer -> Effect ImmutableBuffer
+unsafeFreeze = pure <<< unsafeCoerce
+
+unsafeThaw :: ImmutableBuffer -> Effect Buffer
+unsafeThaw = pure <<< unsafeCoerce
+
+usingFromImmutable :: forall a. (ImmutableBuffer -> a) -> Buffer -> Effect a
+usingFromImmutable f buf = f <$> unsafeFreeze buf
+
+usingToImmutable :: forall a. (a -> ImmutableBuffer) -> a -> Effect Buffer
+usingToImmutable f x = unsafeThaw $ f x
+
 create :: Int -> Effect Buffer
-create = Internal.create
+create = usingToImmutable Immutable.create
 
 freeze :: Buffer -> Effect ImmutableBuffer
-freeze = Internal.copyAll
+freeze = runEffectFn1 freezeImpl
 
-unsafeFreeze :: Buffer -> Effect ImmutableBuffer
-unsafeFreeze = Internal.unsafeFreeze
+foreign import freezeImpl :: EffectFn1 Buffer ImmutableBuffer
 
 thaw :: ImmutableBuffer -> Effect Buffer
-thaw = Internal.copyAll
+thaw = runEffectFn1 thawImpl
 
-unsafeThaw :: ImmutableBuffer -> Effect Buffer
-unsafeThaw = Internal.unsafeThaw
+foreign import thawImpl :: EffectFn1 ImmutableBuffer Buffer
 
-fromArray :: Array Int -> Effect Buffer
-fromArray = Internal.fromArray
+fromArray :: Array Octet -> Effect Buffer
+fromArray = usingToImmutable Immutable.fromArray
 
 fromString :: String -> Encoding -> Effect Buffer
-fromString = Internal.fromString
+fromString s = usingToImmutable $ Immutable.fromString s
 
 fromArrayBuffer :: ArrayBuffer -> Effect Buffer
-fromArrayBuffer = Internal.fromArrayBuffer
+fromArrayBuffer = usingToImmutable Immutable.fromArrayBuffer
 
 toArrayBuffer :: Buffer -> Effect ArrayBuffer
-toArrayBuffer = Internal.toArrayBuffer
+toArrayBuffer = usingFromImmutable Immutable.toArrayBuffer
 
-read :: BufferValueType -> Int -> Buffer -> Effect Number
-read = Internal.read
+read :: BufferValueType -> Offset -> Buffer -> Effect Number
+read t o = usingFromImmutable $ Immutable.read t o
 
-readString :: Encoding -> Int -> Int -> Buffer -> Effect String
-readString = Internal.readString
+readString :: Encoding -> Offset -> Offset -> Buffer -> Effect String
+readString enc o o' = usingFromImmutable $ Immutable.readString enc o o'
 
 toString :: Encoding -> Buffer -> Effect String
-toString = Internal.toString
+toString enc = usingFromImmutable $ Immutable.toString enc
+
+write :: BufferValueType -> Number -> Offset -> Buffer -> Effect Unit
+write ty value offset buf = runEffectFn4 writeInternal (show ty) value offset buf
+
+foreign import writeInternal :: EffectFn4 String Number Offset Buffer Unit
 
-write :: BufferValueType -> Number -> Int -> Buffer -> Effect Unit
-write = Internal.write
+writeString :: Encoding -> Offset -> Int -> String -> Buffer -> Effect Int
+writeString enc offset len value buf =
+  runEffectFn5 writeStringInternal (encodingToNode enc) offset len value buf
 
-writeString :: Encoding -> Int -> Int -> String -> Buffer -> Effect Int
-writeString = Internal.writeString
+foreign import writeStringInternal :: EffectFn5 String Offset Int String Buffer Int
 
-toArray :: Buffer -> Effect (Array Int)
-toArray = Internal.toArray
+toArray :: Buffer -> Effect (Array Octet)
+toArray = usingFromImmutable Immutable.toArray
 
-getAtOffset :: Int -> Buffer -> Effect (Maybe Int)
-getAtOffset = Internal.getAtOffset
+getAtOffset :: Offset -> Buffer -> Effect (Maybe Octet)
+getAtOffset o = usingFromImmutable $ Immutable.getAtOffset o
 
-setAtOffset :: Int -> Int -> Buffer -> Effect Unit
-setAtOffset = Internal.setAtOffset
+setAtOffset :: Octet -> Offset -> Buffer -> Effect Unit
+setAtOffset val off buff = runEffectFn3 setAtOffsetImpl val off buff
 
-slice :: Int -> Int -> Buffer -> Buffer
-slice = Internal.slice
+foreign import setAtOffsetImpl :: EffectFn3 Octet Offset Buffer Unit
+
+slice :: Offset -> Offset -> Buffer -> Buffer
+slice = unsafeCoerce Immutable.slice
 
 size :: Buffer -> Effect Int
-size = Internal.size
+size = usingFromImmutable Immutable.size
 
 concat :: Array Buffer -> Effect Buffer
-concat = Internal.concat
+concat arrs = unsafeCoerce \_ -> Immutable.concat (unsafeCoerce arrs)
 
 concat' :: Array Buffer -> Int -> Effect Buffer
-concat' = Internal.concat'
+concat' arrs n = unsafeCoerce \_ -> Immutable.concat' (unsafeCoerce arrs) n
+
+copy :: Offset -> Offset -> Buffer -> Offset -> Buffer -> Effect Int
+copy srcStart srcEnd src targStart targ = do
+  runEffectFn5 copyImpl srcStart srcEnd src targStart targ
+
+foreign import copyImpl :: EffectFn5 Offset Offset Buffer Offset Buffer Int
 
-copy :: Int -> Int -> Buffer -> Int -> Buffer -> Effect Int
-copy = Internal.copy
+fill :: Octet -> Offset -> Offset -> Buffer -> Effect Unit
+fill octet start end buf = do
+  runEffectFn4 fillImpl octet start end buf
 
-fill :: Int -> Int -> Int -> Buffer -> Effect Unit
-fill = Internal.fill
+foreign import fillImpl :: EffectFn4 Octet Offset Offset Buffer Unit
diff --git a/src/Node/Buffer/Immutable.js b/src/Node/Buffer/Immutable.js
index 48517b7..4dd1c00 100644
--- a/src/Node/Buffer/Immutable.js
+++ b/src/Node/Buffer/Immutable.js
@@ -1,99 +1,40 @@
-/* global Buffer */
+import { Buffer } from "node:buffer";
+
 import { inspect } from "util";
 export const showImpl = inspect;
 
-export function eqImpl(a) {
-  return b => {
-    return a.equals(b);
-  };
-}
+export const eqImpl = (a, b) => a.equals(b);
 
-export function compareImpl(a) {
-  return b => {
-    return a.compare(b);
-  };
-}
+export const compareImpl = (a, b) => a.compare(b);
 
-export function create(size) {
-  return Buffer.alloc(size);
-}
+export const create = (size) => Buffer.alloc(size);
 
-export function fromArray(octets) {
-  return Buffer.from(octets);
-}
+export const fromArray = (octets) => Buffer.from(octets);
 
-export function size(buff) {
-  return buff.length;
-}
+export const size = (buff) => buff.length;
 
 export function toArray(buff) {
   var json = buff.toJSON();
   return json.data || json;
 }
 
-export function toArrayBuffer(buff) {
-  return buff.buffer.slice(buff.byteOffset, buff.byteOffset + buff.byteLength);
-}
+export const toArrayBuffer = (buff) =>
+  buff.buffer.slice(buff.byteOffset, buff.byteOffset + buff.byteLength);
 
-export function fromArrayBuffer(ab) {
-  return Buffer.from(ab);
-}
+export const fromArrayBuffer = (ab) => Buffer.from(ab);
 
-export function fromStringImpl(str) {
-  return encoding => {
-    return Buffer.from(str, encoding);
-  };
-}
+export const fromStringImpl = (str, encoding) => Buffer.from(str, encoding);
 
-export function readImpl(ty) {
-  return offset => {
-    return buf => {
-      return buf["read" + ty](offset);
-    };
-  };
-}
+export const readImpl = (ty, offset, buf) => buf["read" + ty](offset);
 
-export function readStringImpl(enc) {
-  return start => {
-    return end => {
-      return buff => {
-        return buff.toString(enc, start, end);
-      };
-    };
-  };
-}
+export const readStringImpl = (enc, start, end, buff) => buff.toString(enc, start, end);
 
-export function getAtOffsetImpl(just) {
-  return nothing => {
-    return offset => {
-      return buff => {
-        var octet = buff[offset];
-        return octet == null ? nothing : just(octet);
-      };
-    };
-  };
-}
+export const getAtOffsetImpl = (offset, buff) => buff[offset];
 
-export function toStringImpl(enc) {
-  return buff => {
-    return buff.toString(enc);
-  };
-}
+export const toStringImpl = (enc, buff) => buff.toString(enc);
 
-export function slice(start) {
-  return end => {
-    return buff => {
-      return buff.slice(start, end);
-    };
-  };
-}
+export const sliceImpl = (start, end, buff) => buff.slice(start, end);
 
-export function concat(buffs) {
-  return Buffer.concat(buffs);
-}
+export const concat = (buffs) => Buffer.concat(buffs);
 
-export function concatToLength(buffs) {
-  return totalLength => {
-    return Buffer.concat(buffs, totalLength);
-  };
-}
+export const concatToLength = (buffs, totalLength) => Buffer.concat(buffs, totalLength);
diff --git a/src/Node/Buffer/Immutable.purs b/src/Node/Buffer/Immutable.purs
index 9d5d731..285c32c 100644
--- a/src/Node/Buffer/Immutable.purs
+++ b/src/Node/Buffer/Immutable.purs
@@ -20,7 +20,9 @@ module Node.Buffer.Immutable
 import Prelude
 
 import Data.ArrayBuffer.Types (ArrayBuffer)
-import Data.Maybe (Maybe(..))
+import Data.Function.Uncurried (Fn2, Fn3, Fn4, runFn2, runFn3, runFn4)
+import Data.Maybe (Maybe)
+import Data.Nullable (Nullable, toMaybe)
 import Node.Buffer.Types (BufferValueType, Octet, Offset)
 import Node.Encoding (Encoding, encodingToNode)
 
@@ -33,18 +35,18 @@ instance showBuffer :: Show ImmutableBuffer where
 foreign import showImpl :: ImmutableBuffer -> String
 
 instance eqBuffer :: Eq ImmutableBuffer where
-  eq = eqImpl
+  eq a b = runFn2 eqImpl a b
 
-foreign import eqImpl :: ImmutableBuffer -> ImmutableBuffer -> Boolean
+foreign import eqImpl :: Fn2 ImmutableBuffer ImmutableBuffer Boolean
 
 instance ordBuffer :: Ord ImmutableBuffer where
   compare a b =
-    case compareImpl a b of
+    case runFn2 compareImpl a b of
       x | x < 0 -> LT
       x | x > 0 -> GT
       _ -> EQ
 
-foreign import compareImpl :: ImmutableBuffer -> ImmutableBuffer -> Int
+foreign import compareImpl :: Fn2 ImmutableBuffer ImmutableBuffer Int
 
 -- | Creates a new buffer of the specified size.
 foreign import create :: Int -> ImmutableBuffer
@@ -59,28 +61,27 @@ foreign import fromArrayBuffer :: ArrayBuffer -> ImmutableBuffer
 
 -- | Creates a new buffer from a string with the specified encoding, sized to match the string.
 fromString :: String -> Encoding -> ImmutableBuffer
-fromString str = fromStringImpl str <<< encodingToNode
+fromString str = runFn2 fromStringImpl str <<< encodingToNode
 
-foreign import fromStringImpl :: String -> String -> ImmutableBuffer
+foreign import fromStringImpl :: Fn2 String String ImmutableBuffer
 
 -- | Reads a numeric value from a buffer at the specified offset.
 read :: BufferValueType -> Offset -> ImmutableBuffer -> Number
-read = readImpl <<< show
+read ty off buf = runFn3 readImpl (show ty) off buf
 
-foreign import readImpl :: String -> Offset -> ImmutableBuffer -> Number
+foreign import readImpl :: Fn3 String Offset ImmutableBuffer Number
 
 -- | Reads a section of a buffer as a string with the specified encoding.
 readString :: Encoding -> Offset -> Offset -> ImmutableBuffer -> String
-readString = readStringImpl <<< encodingToNode
+readString enc start end buf = runFn4 readStringImpl (encodingToNode enc) start end buf
 
-foreign import readStringImpl
-  :: String -> Offset -> Offset -> ImmutableBuffer -> String
+foreign import readStringImpl :: Fn4 String Offset Offset ImmutableBuffer String
 
 -- | Reads the buffer as a string with the specified encoding.
 toString :: Encoding -> ImmutableBuffer -> String
-toString = toStringImpl <<< encodingToNode
+toString enc buf = runFn2 toStringImpl (encodingToNode enc) buf
 
-foreign import toStringImpl :: String -> ImmutableBuffer -> String
+foreign import toStringImpl :: Fn2 String ImmutableBuffer String
 
 -- | Creates an array of octets from a buffer's contents.
 foreign import toArray :: ImmutableBuffer -> Array Octet
@@ -90,10 +91,9 @@ foreign import toArrayBuffer :: ImmutableBuffer -> ArrayBuffer
 
 -- | Reads an octet from a buffer at the specified offset.
 getAtOffset :: Offset -> ImmutableBuffer -> Maybe Octet
-getAtOffset = getAtOffsetImpl Just Nothing
+getAtOffset off buf = toMaybe $ runFn2 getAtOffsetImpl off buf
 
-foreign import getAtOffsetImpl
-  :: (Octet -> Maybe Octet) -> Maybe Octet -> Offset -> ImmutableBuffer -> Maybe Octet
+foreign import getAtOffsetImpl :: Fn2 Offset ImmutableBuffer (Nullable Octet)
 
 -- | Concatenates a list of buffers.
 foreign import concat :: Array ImmutableBuffer -> ImmutableBuffer
@@ -101,12 +101,15 @@ foreign import concat :: Array ImmutableBuffer -> ImmutableBuffer
 -- | Concatenates a list of buffers, combining them into a new buffer of the
 -- | specified length.
 concat' :: Array ImmutableBuffer -> Int -> ImmutableBuffer
-concat' = concatToLength
+concat' a i = runFn2 concatToLength a i
 
-foreign import concatToLength :: Array ImmutableBuffer -> Int -> ImmutableBuffer
+foreign import concatToLength :: Fn2 (Array ImmutableBuffer) Int ImmutableBuffer
 
 -- | Creates a new buffer slice that shares the memory of the original buffer.
-foreign import slice :: Offset -> Offset -> ImmutableBuffer -> ImmutableBuffer
+slice :: Offset -> Offset -> ImmutableBuffer -> ImmutableBuffer
+slice start end buf = runFn3 sliceImpl start end buf
+
+foreign import sliceImpl :: Fn3 Offset Offset ImmutableBuffer ImmutableBuffer
 
 -- | Returns the size of a buffer.
 foreign import size :: ImmutableBuffer -> Int
diff --git a/src/Node/Buffer/Internal.js b/src/Node/Buffer/Internal.js
deleted file mode 100644
index 2af2886..0000000
--- a/src/Node/Buffer/Internal.js
+++ /dev/null
@@ -1,68 +0,0 @@
-/* global Buffer */
-export function copyAll(a) {
-  return () => {
-    return Buffer.from(a);
-  };
-}
-
-export function writeInternal(ty) {
-  return value => {
-    return offset => {
-      return buf => {
-        return () => {
-          buf["write" + ty](value, offset);
-        };
-      };
-    };
-  };
-}
-
-export function writeStringInternal(encoding) {
-  return offset => {
-    return length => {
-      return value => {
-        return buff => {
-          return () => {
-            return buff.write(value, offset, length, encoding);
-          };
-        };
-      };
-    };
-  };
-}
-
-export function setAtOffset(value) {
-  return offset => {
-    return buff => {
-      return () => {
-        buff[offset] = value;
-      };
-    };
-  };
-}
-
-export function copy(srcStart) {
-  return srcEnd => {
-    return src => {
-      return targStart => {
-        return targ => {
-          return () => {
-            return src.copy(targ, targStart, srcStart, srcEnd);
-          };
-        };
-      };
-    };
-  };
-}
-
-export function fill(octet) {
-  return start => {
-    return end => {
-      return buf => {
-        return () => {
-          buf.fill(octet, start, end);
-        };
-      };
-    };
-  };
-}
diff --git a/src/Node/Buffer/Internal.purs b/src/Node/Buffer/Internal.purs
deleted file mode 100644
index 94b40ff..0000000
--- a/src/Node/Buffer/Internal.purs
+++ /dev/null
@@ -1,110 +0,0 @@
--- | Functions and types to support the other modules. Not for public use.
-module Node.Buffer.Internal
-  ( unsafeFreeze
-  , unsafeThaw
-  , usingFromImmutable
-  , usingToImmutable
-  , create
-  , copyAll
-  , fromArray
-  , fromString
-  , fromArrayBuffer
-  , toArrayBuffer
-  , read
-  , readString
-  , toString
-  , write
-  , writeString
-  , toArray
-  , getAtOffset
-  , setAtOffset
-  , slice
-  , size
-  , concat
-  , concat'
-  , copy
-  , fill
-  ) where
-
-import Prelude
-
-import Data.ArrayBuffer.Types (ArrayBuffer)
-import Data.Maybe (Maybe)
-import Node.Buffer.Immutable (ImmutableBuffer)
-import Node.Buffer.Immutable as Immutable
-import Node.Buffer.Types (BufferValueType, Octet, Offset)
-import Node.Encoding (Encoding, encodingToNode)
-import Unsafe.Coerce (unsafeCoerce)
-
-unsafeFreeze :: forall buf m. Monad m => buf -> m ImmutableBuffer
-unsafeFreeze = pure <<< unsafeCoerce
-
-unsafeThaw :: forall buf m. Monad m => ImmutableBuffer -> m buf
-unsafeThaw = pure <<< unsafeCoerce
-
-usingFromImmutable :: forall buf m a. Monad m => (ImmutableBuffer -> a) -> buf -> m a
-usingFromImmutable f buf = f <$> unsafeFreeze buf
-
-usingToImmutable :: forall buf m a. Monad m => (a -> ImmutableBuffer) -> a -> m buf
-usingToImmutable f x = unsafeThaw $ f x
-
-create :: forall buf m. Monad m => Int -> m buf
-create = usingToImmutable Immutable.create
-
-foreign import copyAll :: forall a buf m. a -> m buf
-
-fromArray :: forall buf m. Monad m => Array Octet -> m buf
-fromArray = usingToImmutable Immutable.fromArray
-
-fromString :: forall buf m. Monad m => String -> Encoding -> m buf
-fromString s = usingToImmutable $ Immutable.fromString s
-
-fromArrayBuffer :: forall buf m. Monad m => ArrayBuffer -> m buf
-fromArrayBuffer = usingToImmutable Immutable.fromArrayBuffer
-
-toArrayBuffer :: forall buf m. Monad m => buf -> m ArrayBuffer
-toArrayBuffer = usingFromImmutable Immutable.toArrayBuffer
-
-read :: forall buf m. Monad m => BufferValueType -> Offset -> buf -> m Number
-read t o = usingFromImmutable $ Immutable.read t o
-
-readString :: forall buf m. Monad m => Encoding -> Offset -> Offset -> buf -> m String
-readString m o o' = usingFromImmutable $ Immutable.readString m o o'
-
-toString :: forall buf m. Monad m => Encoding -> buf -> m String
-toString m = usingFromImmutable $ Immutable.toString m
-
-write :: forall buf m. Monad m => BufferValueType -> Number -> Offset -> buf -> m Unit
-write = writeInternal <<< show
-
-foreign import writeInternal :: forall buf m. String -> Number -> Offset -> buf -> m Unit
-
-writeString :: forall buf m. Monad m => Encoding -> Offset -> Int -> String -> buf -> m Int
-writeString = writeStringInternal <<< encodingToNode
-
-foreign import writeStringInternal
-  :: forall buf m. String -> Offset -> Int -> String -> buf -> m Int
-
-toArray :: forall buf m. Monad m => buf -> m (Array Octet)
-toArray = usingFromImmutable Immutable.toArray
-
-getAtOffset :: forall buf m. Monad m => Offset -> buf -> m (Maybe Octet)
-getAtOffset o = usingFromImmutable $ Immutable.getAtOffset o
-
-foreign import setAtOffset :: forall buf m. Octet -> Offset -> buf -> m Unit
-
-slice :: forall buf. Offset -> Offset -> buf -> buf
-slice = unsafeCoerce Immutable.slice
-
-size :: forall buf m. Monad m => buf -> m Int
-size = usingFromImmutable Immutable.size
-
-concat :: forall buf m. Array buf -> m buf
-concat arrs = unsafeCoerce \_ -> Immutable.concat (unsafeCoerce arrs)
-
-concat' :: forall buf m. Monad m => Array buf -> Int -> m buf
-concat' arrs n = unsafeCoerce \_ -> Immutable.concat' (unsafeCoerce arrs) n
-
-foreign import copy :: forall buf m. Offset -> Offset -> buf -> Offset -> buf -> m Int
-
-foreign import fill :: forall buf m. Octet -> Offset -> Offset -> buf -> m Unit
diff --git a/src/Node/Buffer/ST.purs b/src/Node/Buffer/ST.purs
index 40d3e2f..80e1d9d 100644
--- a/src/Node/Buffer/ST.purs
+++ b/src/Node/Buffer/ST.purs
@@ -33,10 +33,11 @@ import Control.Monad.ST as ST
 import Data.ArrayBuffer.Types (ArrayBuffer)
 import Data.Maybe (Maybe)
 import Node.Buffer (BufferValueType)
+import Node.Buffer as Buffer
 import Node.Buffer.Class (class MutableBuffer)
 import Node.Buffer.Immutable (ImmutableBuffer)
-import Node.Buffer.Internal as Internal
 import Node.Encoding (Encoding)
+import Unsafe.Coerce (unsafeCoerce)
 
 -- | A reference to a mutable buffer for use with `ST`
 -- |
@@ -74,70 +75,70 @@ instance mutableBufferST :: MutableBuffer (STBuffer h) (ST h) where
   fill = fill
 
 create :: forall h. Int -> ST h (STBuffer h)
-create = Internal.create
+create = unsafeCoerce Buffer.create
 
 freeze :: forall h. STBuffer h -> ST h ImmutableBuffer
-freeze = Internal.copyAll
+freeze = unsafeCoerce Buffer.freeze
 
 unsafeFreeze :: forall h. STBuffer h -> ST h ImmutableBuffer
-unsafeFreeze = Internal.unsafeFreeze
+unsafeFreeze = unsafeCoerce Buffer.unsafeFreeze
 
 thaw :: forall h. ImmutableBuffer -> ST h (STBuffer h)
-thaw = Internal.copyAll
+thaw = unsafeCoerce Buffer.thaw
 
 unsafeThaw :: forall h. ImmutableBuffer -> ST h (STBuffer h)
-unsafeThaw = Internal.unsafeThaw
+unsafeThaw = unsafeCoerce Buffer.unsafeThaw
 
 fromArray :: forall h. Array Int -> ST h (STBuffer h)
-fromArray = Internal.fromArray
+fromArray = unsafeCoerce Buffer.fromArray
 
 fromString :: forall h. String -> Encoding -> ST h (STBuffer h)
-fromString = Internal.fromString
+fromString = unsafeCoerce Buffer.fromString
 
 fromArrayBuffer :: forall h. ArrayBuffer -> ST h (STBuffer h)
-fromArrayBuffer = Internal.fromArrayBuffer
+fromArrayBuffer = unsafeCoerce Buffer.fromArrayBuffer
 
 toArrayBuffer :: forall h. STBuffer h -> ST h ArrayBuffer
-toArrayBuffer = Internal.toArrayBuffer
+toArrayBuffer = unsafeCoerce Buffer.toArrayBuffer
 
 read :: forall h. BufferValueType -> Int -> STBuffer h -> ST h Number
-read = Internal.read
+read = unsafeCoerce Buffer.read
 
 readString :: forall h. Encoding -> Int -> Int -> STBuffer h -> ST h String
-readString = Internal.readString
+readString = unsafeCoerce Buffer.readString
 
 toString :: forall h. Encoding -> STBuffer h -> ST h String
-toString = Internal.toString
+toString = unsafeCoerce Buffer.toString
 
 write :: forall h. BufferValueType -> Number -> Int -> STBuffer h -> ST h Unit
-write = Internal.write
+write = unsafeCoerce Buffer.write
 
 writeString :: forall h. Encoding -> Int -> Int -> String -> STBuffer h -> ST h Int
-writeString = Internal.writeString
+writeString = unsafeCoerce Buffer.writeString
 
 toArray :: forall h. STBuffer h -> ST h (Array Int)
-toArray = Internal.toArray
+toArray = unsafeCoerce Buffer.toArray
 
 getAtOffset :: forall h. Int -> STBuffer h -> ST h (Maybe Int)
-getAtOffset = Internal.getAtOffset
+getAtOffset = unsafeCoerce Buffer.getAtOffset
 
 setAtOffset :: forall h. Int -> Int -> STBuffer h -> ST h Unit
-setAtOffset = Internal.setAtOffset
+setAtOffset = unsafeCoerce Buffer.setAtOffset
 
 slice :: forall h. Int -> Int -> STBuffer h -> STBuffer h
-slice = Internal.slice
+slice = unsafeCoerce Buffer.slice
 
 size :: forall h. STBuffer h -> ST h Int
-size = Internal.size
+size = unsafeCoerce Buffer.size
 
 concat :: forall h. Array (STBuffer h) -> ST h (STBuffer h)
-concat = Internal.concat
+concat = unsafeCoerce Buffer.concat
 
 concat' :: forall h. Array (STBuffer h) -> Int -> ST h (STBuffer h)
-concat' = Internal.concat'
+concat' = unsafeCoerce Buffer.concat'
 
 copy :: forall h. Int -> Int -> STBuffer h -> Int -> STBuffer h -> ST h Int
-copy = Internal.copy
+copy = unsafeCoerce Buffer.copy
 
 fill :: forall h. Int -> Int -> Int -> STBuffer h -> ST h Unit
-fill = Internal.fill
+fill = unsafeCoerce Buffer.fill
diff --git a/src/Node/Encoding.js b/src/Node/Encoding.js
index 608e31d..dcfecb9 100644
--- a/src/Node/Encoding.js
+++ b/src/Node/Encoding.js
@@ -1,6 +1,3 @@
-/* global Buffer */
-export function byteLengthImpl(str) {
-  return enc => {
-    return Buffer.byteLength(str, enc);
-  };
-}
+import { Buffer } from "node:buffer";
+
+export const byteLengthImpl = (str, enc) => Buffer.byteLength(str, enc);
diff --git a/src/Node/Encoding.purs b/src/Node/Encoding.purs
index 86c53c5..97ec62e 100644
--- a/src/Node/Encoding.purs
+++ b/src/Node/Encoding.purs
@@ -6,6 +6,8 @@ module Node.Encoding
 
 import Prelude
 
+import Data.Function.Uncurried (Fn2, runFn2)
+
 data Encoding
   = ASCII
   | UTF8
@@ -38,7 +40,7 @@ encodingToNode Latin1 = "latin1"
 encodingToNode Binary = "binary"
 encodingToNode Hex = "hex"
 
-foreign import byteLengthImpl :: String -> String -> Int
+foreign import byteLengthImpl :: Fn2 String String Int
 
 byteLength :: String -> Encoding -> Int
-byteLength str enc = byteLengthImpl str (encodingToNode enc)
+byteLength str enc = runFn2 byteLengthImpl str (encodingToNode enc)