From 51ed7d7a85ea4b45eab8128aa66a95a96fc12576 Mon Sep 17 00:00:00 2001
From: litlighilit <litlighilit@foxmail.com>
Date: Mon, 28 Apr 2025 00:51:02 +0800
Subject: [PATCH 1/4] chore(ci): docs: allow workflow_dispatch

---
 .github/workflows/docs.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 9122088e0..83d1146dd 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -5,6 +5,8 @@ on:
   push:
     branches:
       - master
+  workflow_dispatch:
+
 env:
   nim-version: 'stable'
   git-url-arg: --git.url:https://github.com/${{ github.repository }} --git.commit:master

From c01b02025d5b5e9774e948aa57c982ad40f90dd5 Mon Sep 17 00:00:00 2001
From: litlighilit <litlighilit@foxmail.com>
Date: Tue, 29 Apr 2025 10:58:30 +0800
Subject: [PATCH 2/4] break(EXT): unexport io.raiseOsOrFileNotFoundError

---
 src/pylib/Lib/io.nim | 8 +-------
 src/pylib/io.nim     | 2 +-
 2 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/src/pylib/Lib/io.nim b/src/pylib/Lib/io.nim
index a1dbf4cd3..6ca56d659 100644
--- a/src/pylib/Lib/io.nim
+++ b/src/pylib/Lib/io.nim
@@ -636,13 +636,7 @@ proc openNoNonInhertFlag(f: var File, filehandle: FileHandle,
   f = c_fdopen(filehandle, fop)
   result = f != nil
 
-proc raiseOsOrFileNotFoundError*(file: int) =
-    let err = osLastError()
-    let fn = "fd: " & $file
-    raiseOSError(err,
-      "[Errno " & $err & "] " & "can't open " & fn)
-
-proc raiseOsOrFileNotFoundError*[T](file: PathLike[T]) =
+proc raiseOsOrFileNotFoundError[T](file: PathLike[T]) =
   file.raiseExcWithPath()
 
 proc initBufAsPy*(nfile: var File, buf: int) =
diff --git a/src/pylib/io.nim b/src/pylib/io.nim
index d8d6695be..5178ca75e 100644
--- a/src/pylib/io.nim
+++ b/src/pylib/io.nim
@@ -23,4 +23,4 @@ but Nim's `iterator lines` does not
 import ./Lib/io
 
 export io.open, io.close, io.seek, io.read, io.readline, io.write, io.truncate
-export io.raiseOsOrFileNotFoundError, io.initBufAsPy
+export io.initBufAsPy

From 153b94ab909426a0d86dbe2749f09ae5177964ff Mon Sep 17 00:00:00 2001
From: litlighilit <litlighilit@foxmail.com>
Date: Tue, 29 Apr 2025 11:06:44 +0800
Subject: [PATCH 3/4] refact(nimpatch): nim-lang/Nim#23456 to nimpatch/

---
 src/pylib/Lib/io.nim                     | 40 +++---------------------
 src/pylib/nimpatch/winOpenFileHandle.nim | 38 ++++++++++++++++++++++
 2 files changed, 42 insertions(+), 36 deletions(-)
 create mode 100644 src/pylib/nimpatch/winOpenFileHandle.nim

diff --git a/src/pylib/Lib/io.nim b/src/pylib/Lib/io.nim
index 6ca56d659..a8745f768 100644
--- a/src/pylib/Lib/io.nim
+++ b/src/pylib/Lib/io.nim
@@ -46,6 +46,7 @@ import ../pystring/[strimpl, strbltins]
 import ../pybytes/[bytesimpl, bytesbltins]
 import ./warnings
 import ./sys_impl/auditImpl as sys
+import ../nimpatch/winOpenFileHandle
 
 const
   SEEK_SET* = 0
@@ -603,39 +604,6 @@ let
   # NOTE: For Win32, the behavior is the same as _IOFBF - Full Buffering
   IONBF {.importc: "_IONBF", nodecl.}: cint
 
-# patch for system/io.nim or std/syncio.nim,
-# see https://github.com/nim-lang/Nim/pull/23456
-const
-  NoInheritFlag =
-    # Platform specific flag for creating a File without inheritance.
-    when not defined(nimInheritHandles):
-      when defined(windows): ""
-      elif defined(linux) or defined(bsd): "e"
-      else: ""
-    else: ""
-  FormatOpen: array[FileMode, cstring] = [
-    cstring("rb" & NoInheritFlag), "wb" & NoInheritFlag, "w+b" & NoInheritFlag,
-    "r+b" & NoInheritFlag, "ab" & NoInheritFlag
-  ]
-when defined(windows):
-  proc getOsfhandle(fd: cint): int {.
-    importc: "_get_osfhandle", header: "<io.h>".}
-  proc c_fdopen(filehandle: cint, mode: cstring): File {.
-    importc: "_fdopen", header: "<stdio.h>".}
-else:
-  proc c_fdopen(filehandle: cint, mode: cstring): File {.
-    importc: "fdopen", header: "<stdio.h>".}
-proc openNoNonInhertFlag(f: var File, filehandle: FileHandle,
-           mode: FileMode = fmRead): bool {.tags: [], raises: [].} =
-  when not defined(nimInheritHandles) and declared(setInheritable):
-    let oshandle = when defined(windows): FileHandle getOsfhandle(filehandle)
-                   else: filehandle
-    if not setInheritable(oshandle, false):
-      return false
-  let fop = FormatOpen[mode]
-  f = c_fdopen(filehandle, fop)
-  result = f != nil
-
 proc raiseOsOrFileNotFoundError[T](file: PathLike[T]) =
   file.raiseExcWithPath()
 
@@ -660,8 +628,8 @@ template openImpl(result: untyped;
 ) =
   bind genOpenInfo, initTextIO,
     FileMode, FileHandle,
-    openNoNonInhertFlag, `file=`
-    
+    open, `file=`
+
   var buf = buffering
   var
     nmode: FileMode
@@ -672,7 +640,7 @@ template openImpl(result: untyped;
   var nfile: File
   sys.audit("open", file, smode)  ## XXX: PY-DIFF: 3rd arg shall be flags
   when file is int:
-    let succ = openNoNonInhertFlag(nfile, FileHandle file, mode=nmode)
+    let succ = open(nfile, FileHandle file, mode=nmode)
   else:
     let succ = open(nfile, $file, mode=nmode)
   # Nim/Python:
diff --git a/src/pylib/nimpatch/winOpenFileHandle.nim b/src/pylib/nimpatch/winOpenFileHandle.nim
new file mode 100644
index 000000000..9c0173956
--- /dev/null
+++ b/src/pylib/nimpatch/winOpenFileHandle.nim
@@ -0,0 +1,38 @@
+{.used.}
+import ./utils
+addPatch((2,1,1), defined(windows)):
+  ## introduced in nim-lang/Nim#23456
+  # patch for system/io.nim or std/syncio.nim,
+  # see https://github.com/nim-lang/Nim/pull/23456
+  when defined(nimPreviewSlimSystem):
+    import std/syncio
+  const
+    NoInheritFlag =
+      # Platform specific flag for creating a File without inheritance.
+      when not defined(nimInheritHandles):
+        when defined(windows): ""
+        elif defined(linux) or defined(bsd): "e"
+        else: ""
+      else: ""
+    FormatOpen: array[FileMode, cstring] = [
+      cstring("rb" & NoInheritFlag), "wb" & NoInheritFlag, "w+b" & NoInheritFlag,
+      "r+b" & NoInheritFlag, "ab" & NoInheritFlag
+    ]
+  when defined(windows):
+    proc getOsfhandle(fd: cint): int {.
+      importc: "_get_osfhandle", header: "<io.h>".}
+    proc c_fdopen(filehandle: cint, mode: cstring): File {.
+      importc: "_fdopen", header: "<stdio.h>".}
+  else:
+    proc c_fdopen(filehandle: cint, mode: cstring): File {.
+      importc: "fdopen", header: "<stdio.h>".}
+  proc open*(f: var File, filehandle: FileHandle,
+            mode: FileMode = fmRead): bool {.tags: [], raises: [].} =
+    when not defined(nimInheritHandles) and declared(setInheritable):
+      let oshandle = when defined(windows): FileHandle getOsfhandle(filehandle)
+                    else: filehandle
+      if not setInheritable(oshandle, false):
+        return false
+    let fop = FormatOpen[mode]
+    f = c_fdopen(filehandle, fop)
+    result = f != nil

From 29dbd2baf46ab6c68feb1f3c02e83185541d3f23 Mon Sep 17 00:00:00 2001
From: litlighilit <litlighilit@foxmail.com>
Date: Tue, 29 Apr 2025 12:42:16 +0800
Subject: [PATCH 4/4] feat(js): supports io (wip) [skip ci]

---
 src/pylib/Lib/io.nim           |  40 ++--
 src/pylib/Lib/io_impl/jsio.nim | 420 +++++++++++++++++++++++++++++++++
 2 files changed, 445 insertions(+), 15 deletions(-)
 create mode 100644 src/pylib/Lib/io_impl/jsio.nim

diff --git a/src/pylib/Lib/io.nim b/src/pylib/Lib/io.nim
index a8745f768..5cb714dc7 100644
--- a/src/pylib/Lib/io.nim
+++ b/src/pylib/Lib/io.nim
@@ -63,6 +63,10 @@ type
     nlCarriageReturn
     nlCarriage
 
+const InJs = defined(js)
+when InJs:
+  import ./io_impl/jsio
+
 type
   IOBase* = ref object of RootObj
     closed*: bool
@@ -342,12 +346,15 @@ proc read*(self: TextIOWrapper, size: int): PyStr =
   result = self.readImpl(size)
   Iencode
 
-proc write(self: IOBase, s: string): int{.discardable.} =
-  self.file.write s
-  s.len
+proc writeRetI(self: IOBase, s: string): int =
+  when InJs:
+    self.file.writeRetI(s)
+  else:
+    self.file.write s
+    s.len
 
 proc write*(self: RawIOBase, s: PyBytes): int{.discardable.} =
-  write(IOBase(self), $s)
+  writeRetI(IOBase(self), $s)
 
 proc writeImpl(self: NoEncTextIOWrapper, s: string, cvtRet: proc(s: string): int): int{.discardable.} =
   proc retSubs(toNewLine: string): int = cvtRet(s.replace("\n", toNewLine))
@@ -361,7 +368,7 @@ proc writeImpl(self: NoEncTextIOWrapper, s: string, cvtRet: proc(s: string): int
 
 proc write*(self: NoEncTextIOWrapper, s: PyStr): int{.discardable.} =
   proc cvtRet(oriStr: string): int =
-    discard write(IOBase(self), s)
+    discard writeRetI(IOBase(self), s)
     s.len
   writeImpl(self, s, cvtRet)
 
@@ -391,11 +398,11 @@ proc write*(self: TextIOWrapper, s: PyStr): int{.discardable.} =
   
   proc cvtRet(oriStr: string): int =
     let t = self.codec.encode(oriStr)
-    discard write(IOBase(self), t.data)
+    discard writeRetI(IOBase(self), t.data)
     t.len
   writeImpl(self, s, cvtRet)
 
-proc truncate*(self: IOBase): int{.discardable.} =
+proc truncate*(self: IOBase, size: int64 = self.tell()): int64{.discardable.} =
   runnableExamples:
     const fn = "tempfiletest"
     var f = open(fn, "w+")
@@ -404,11 +411,11 @@ proc truncate*(self: IOBase): int{.discardable.} =
     f.truncate()
     assert f.read() == ""
     f.close()
-  result = self.tell().int
-  truncate self.fileno, result
-
-proc truncate*(self: IOBase, size: int64): int64{.discardable.} =
   truncate self.fileno, size
+  when InJs:
+    truncate self.file, size
+  else:
+    truncate self.fileno, result
   size
 
 # workaround,
@@ -461,10 +468,13 @@ proc isatty(p: CanIOOpenT): bool =
   when p is int:
     result = p.isatty()
   else:
-    var f: File
-    if f.open($p, fmRead):
-      result = f.isatty()
-      f.close()
+    when InJs:
+      result = p.isatty()
+    else:
+      var f: File
+      if f.open($p, fmRead):
+        result = f.isatty()
+        f.close()
 
 proc norm_buffering(file: CanIOOpenT, buffering: var int): bool =
   ## returns line_buffering
diff --git a/src/pylib/Lib/io_impl/jsio.nim b/src/pylib/Lib/io_impl/jsio.nim
new file mode 100644
index 000000000..647878ef9
--- /dev/null
+++ b/src/pylib/Lib/io_impl/jsio.nim
@@ -0,0 +1,420 @@
+# from $nim/lib/std/syncio
+{.pragma: benign, gcsafe.}
+proc raiseEIO(msg: string) {.noinline, noreturn.} =
+  raise newException(IOError, msg)
+
+proc raiseEOF() {.noinline, noreturn.} =
+  raise newException(EOFError, "EOF reached")
+
+# ---
+
+import ../../jsutils/denoAttrs
+
+import std/macros
+import std/jsffi
+when defined(nimPreviewSlimSystem):
+  import std/syncio except File
+type
+  JsNumber = cdouble
+  JsIntNumber = distinct int
+converter toInt(n: JsIntNumber): int = int(n)
+
+type File*{.pure.} = JsObject
+  ## unbuffered byte IO:
+  ## 
+  ##  - deno: Deno.FileInfo with additional attribute: name
+  ##  - node: {fd: <interger>, position: <integer>}
+
+template wrapStdio(ioe) =
+  let ioe*{.importDenoOrProcess(ioe).}: File ## ReadStream | WriteStream
+  ios.pos = 0.toJs  # unused, however
+
+wrapStdio stdin
+wrapStdio stdout
+wrapStdio stderr
+
+template denoOr(deno, node): untyped =
+  when defined(nodejs): node
+  else:
+    if inDeno: deno
+    else: node
+
+template nodeOr(node, deno): untyped = denoOr(deno, node)
+
+type
+  TextEncoder{.importjs.} = object of JsObject
+    encoding: cstring
+  Uint8Array{.importjs.} = object of JsObject
+    length: JsNumber
+
+using buffer: Uint8Array
+
+proc newUint8Array(len: int|Uint8Array = 0): Uint8Array{.importjs: "(new Uint8Array(@))".}
+proc subarray(buffer; n: JsNumber): Uint8Array{.importcpp.}
+proc len(buffer): int = int buffer.length
+
+proc `[]`(buffer; i: int): uint8 = buffer[i].to uint8
+iterator items(buffer): uint8 =
+  for i in 0..<buffer.len: yield buffer[i]
+
+proc getChar(buffer, i: int): char = cast[char](buffer[i])
+iterator chars(buffer): char =
+  for i in 0..<buffer.len: yield buffer.getChar i
+
+proc add(s: var string; buffer; n = buffer.len) =
+  for i in 0..<n:
+    s.add buffer.getChar i
+
+proc toBytesString(buffer): string =
+  when declared(newStringUninit):
+    result = newStringUninit(buffer.len)
+  result.add buffer
+
+proc `[]=`(buffer; i: int; u: uint8) = buffer[i] = u.toJs
+proc toUint8Array(s: string|cstring): Uint8Array =
+  result = newUint8Array(s.len)
+  for i, c in s:
+    result[i] = cast[uint8](c)
+
+using f: File
+using fp: cstring
+
+proc isatty*(fd): bool{.importNode(tty, isatty).}
+
+proc isatty*(f): bool =
+  nodeOr f.fd.isatty(), f.isTerminal().to bool
+
+proc getFileHandle*(f): FileHandle =
+  ## not available on Deno2
+  FileHandle (
+    nodeOr f.fd do:
+      let jsObj = f.rid
+      if jsObj.isUndefined:
+        raise newException(NotImplementedError, "not available on Deno, since v2")
+      jsObj
+  ).to JsIntNumber
+
+proc getFilePos*(f): int64
+template typeWithAttr(typ; attr; attrType) =
+  type typ = JsObject
+  proc attr(s: typ): attrType = s.attr.to attrType
+
+const DefBuf = 1024
+
+template writeSyncEnsureAllImpl(f; p: Uint8Array; writeSyncWithbuffer) =
+  ## fs.writeSync & FsFile.write[Sync]() does not guarantee that the full buffer will be written in a single call.
+  ## ref https://docs.deno.com/api/deno/~/Deno.FsFile.prototype.writeSync;
+  ## track https://github.com/denoland/deno/issues/28441
+  var written = JsNumber 0
+  catchJsErrAndRaise:
+    while written < data.length:
+      let buffer{.inject.} = newUint8Array(if written == 0: data else: data.subarray(written))
+      written += writeSyncWithbuffer
+
+## Deno
+proc name(f): string = $(f.name.to cstring)
+proc `name=`(f; n: cstring){.importcjs: "(#).name=#".}
+proc `name=`(f; n: string) = f.name = cstring n
+
+macro importDeno(def) =
+  def.addPragma nnkExprColonExpr.newTree(ident"importjs", newLit "Deno."&def.name&"(@)")
+
+proc openSync(fp): File{.importDeno.}  ## Deno's
+type OpenOptions = ref object
+  ## https://docs.deno.com/api/deno/~/Deno.OpenOptions
+  read = true
+  write, append, truncate, createNew: bool
+  mode: JsNumber
+proc openSync(fp; mode: OpenOptions): File{.importDeno.}
+
+proc createReadStream(fp; options: JsObject): File{.importFs.}
+proc createWriteStream(fp; options: JsObject): File{.importFs.}
+#stream.Duplex.from
+proc close_deno(f){.importjs: "#.close()".}
+
+#proc syncDataSync(f){.importcpp.}
+proc truncateSync(f; len: JsNumber){.importcpp.}
+
+proc readSync(f; p: Uint8Array): JsObject #[number|null]#{.importcpp.}
+proc writeSync(f; p: Uint8Array): JsIntNumber{.importcpp.}
+proc writeSyncEnsureAll(f; p: Uint8Array) =
+  writeSyncEnsureAllImpl(f, p):
+    f.writeSync(buffer)
+
+type SeekMode{.pure.} = enum
+  Current = JsIntNumber 1
+  End = 2
+  Start = 0
+
+proc seekSync(f;
+  offset: JsNumber | int64,
+  whence: SeekMode,
+): JsIntNumber{.importcpp.}
+
+
+proc readFileSync(fp): Uint8Array{.importDeno.}
+
+proc readAll_deno(f): string =
+  if f.getFilePos() == 0:
+    return readFileSync(f.name).toBytesString
+  else:
+    var buffer = newUint8Array(DefBuf)
+    while true:
+      let obj = not f.readSync(buffer)
+      if obj.isNull:
+        break
+      result.add(buffer, obj.to int)
+
+typeWithAttr FileInfo, size, JsIntNumber
+proc statSync(f): FileInfo{.importcpp.}
+proc getFileSize_deno(f): int64 = f.statSync().size.int64
+
+## Node
+proc position(f): JsIntNumber = f.position.to JsIntNumber
+template importFs(sym, def) = importNode(fs, sym, def)
+macro importFs(def) =
+  newCall(bindSym"importFs", def.name, def)
+
+type FD = JsIntNumber
+using fd: FD
+proc fd(f): FD{.importjs: "#.fd".}
+
+proc createReadStream(fp; options: JsObject): File{.importFs.}
+proc createWriteStream(fp; options: JsObject): File{.importFs.}
+#stream.Duplex.from
+
+proc fs_openSync(fp; flags: cstring|JsIntNumber = "r",
+  mode=JsIntNumber 0x666): FD{.importFs(openSync).}
+
+const NodeJsFormatOpen = [
+  fmRead: cstring"r",
+  fmAppend: "a",
+  fmReadWrite: "w+",
+  fmReadWriteExisting: "r+",
+]
+
+proc closeSync(fd){.importFs.}
+
+#proc datasync(f){.importcpp.}
+proc ftruncateSync(fd; len: JsIntNumber){.importFs.}
+
+template read_writeSync(sym){.dirty.} =
+  proc sym(fd; buffer: Uint8Array,
+    offset: JsIntNumber = 0, length: JsIntNumber = buffer.length - offset,
+    position: JsIntNumber = -1  # natural means use such a position with file's pos unchanged
+  ): JsIntNumber{.importFs.}
+
+read_writeSync readSync
+#proc readSync(fd; buffer[, options]){.importFs.}
+
+proc readChars*(f; a: var openArray[char]): int =
+  var buffer = newUint8Array(a.len)
+
+  let n = denoOr readSync(f, buffer) do:
+    let n = readSync(f.fd, buffer,
+      position=f.position
+    )
+    f.position += n
+  let nn = result + n
+  for i in n..<nn:
+    a[i] = buffer.getChar i
+  result = nn
+
+
+
+proc readAll_node(f): string =
+  var buffer = newUint8Array(DefBuf)
+  while true:
+    let n = readSync(f.fd, buffer,
+      position=f.position
+    )
+    result.add buffer, n.int
+    f.position += n
+    if n < buffer.length:
+      break
+
+read_writeSync writeSync
+
+proc writeSyncEnsureAll(fd; p: Uint8Array): JsIntNumber =
+  writeSyncEnsureAllImpl(f, p):
+    writeSync(fd, buffer)
+  JsIntNumber p.length
+
+## buffers: ArrayBufferView[]; ArrayBufferView = TypedArray|DataView
+using buffers: var Uint8Array  ## XXX: will be JS Array?
+proc writevSync(fd; buffers; position: JsIntNumber): JsIntNumber{.importFs.}
+proc writevSync(fd; buffers): JsIntNumber{.importFs.}
+
+
+type StatOptions = ref object
+  bigint: bool
+typeWithAttr BigIntStats, size, int64
+proc fstatSync(fd; options: StatOptions): JsObject{.importFs.}
+proc fstatSyncBigInt(fd): BigIntStats = BigIntStats fstatSync(fd, StatOptions{bigint: true})
+
+proc getFileSize_node(f): int64 = fstatSyncBigInt(f.fd).size
+
+##
+
+proc open*(f: var File, fp; mode: FileMode = fmRead,
+    ): bool{.tags: [], raises: [], benign.} =
+  catchJsErrAndRaise:
+    f = nodeOr(fs_openSync(fp.cstring, NodeJsFormatOpen[mode])):
+      var options = newJsObject()  ## OpenOptions
+      # https://docs.deno.com/api/deno/~/Deno.OpenOptions
+      template add(attr) =
+        options.attr = true
+      case mode
+      of fmRead: add read
+      of fmAppend: add append
+      of fmWrite: add write
+      of fmReadWrite:
+        add read
+        add write
+        add create
+        add truncate
+      of fmReadWriteExisting:
+        add read
+        add write
+      openSync(fp.cstring, options)
+
+  f.position = toJs JsIntNumber 0
+  f.name = fp
+
+proc close*(f){.tags: [], gcsafe, sideEffect.} =
+  denoOr close_deno(f), closeSync(f.fd)
+
+proc reopen*(f: var File, fp; mode: FileMode = fmRead): bool {.
+  tags: [], benign.} =
+  # NIMDIFF: `f: File` -> `f: var File`
+  if not f.isNull:
+    f.close()
+  f = open(fp)
+
+
+# REUSE ``open*(filename: string,``
+
+# NIMDIFF: `var f: File = nil` -> `var f = default(File)`
+#  readFile, writeFile, readLines
+
+# REUSE ``lines*(filename: string): strin``
+# REUSE ``lines*(f: File): string``
+
+proc truncate*(f; len=0){.
+  tags: [WriteIOEffect], benign.} =
+  denoOr(f.truncateSync(len), f.fd.ftruncateSync(len))
+
+proc flushFile*(f){.tags: [WriteIOEffect].} =
+  discard  # node/deno's writeSync is non-buffered
+#  catchJsErrAndRaise:
+
+proc readAll*(f): string{.
+  tags: [ReadIOEffect], benign.} =
+  denoOr(f.readAll_deno, f.readAll_node)
+
+proc getFileSize*(f): int64{.tags: [ReadIOEffect], benign.} =
+  denoOr(f.getFileSize_deno, f.getFileSize_node)
+
+proc setFilePos*(f; pos: int64, whence: FileSeekPos = fspSet){.benign, sideEffect.} =
+  denoOr f.seekSync(pos, SeekMode(whence)):
+    f.position = case whence
+    of fspSet: pos
+    of fspCur: pos + f.position
+    of fspEnd: f.getFileSize + pos
+
+
+proc getFilePos*(f): int64{.benign.} =
+  nodeOr f.position.to(JsNumber).int64:
+    f.seekSync(0, SeekMode.Current)
+
+template readOrWriteCharImpl(readOrWrite): JsIntNumber =
+  var buffer = newUint8Array(1)
+  nodeOr readOrWrite(f.fd, buffer) do:
+    let obj = f.readOrWrite(buffer)
+    if obj.isNull: 0 else: obj.to JsIntNumber
+
+proc readChar*(f): char{.
+  tags: [ReadIOEffect], benign.} =
+  case readOrWriteCharImpl readSync
+  of 0: raiseEOF()
+  of 1: return buffer[0].char
+  else: raiseIO("readChar")  ## FIXME: better msg
+
+proc readChars*(f; a: var openArray[char]): int{.
+  tags: [ReadIOEffect], benign.} =
+  var buffer = newUint8Array(a.len)
+
+  let n = denoOr readSync(f, buffer) do:
+    f.position += n
+    readSync(f.fd, buffer,
+      position=f.position
+    )
+  let nn = result + n
+  for i in n..<nn:
+    a[i] = buffer.getChar i
+  result = nn
+
+proc peekChar*(f): char =
+  ## NONIM
+  nodeOr:
+    var buffer = newUint8Array(1)
+    if readSync(f.fd, buffer, position = -1) != 1:
+      raiseEIO()
+    result = buffer.getChar 1
+  do:
+    result = f.readChar()
+    f.seek(-1)
+
+#proc readLine*(f: File, line: var string): bool {.tags: [ReadIOEffect], benign.} =
+
+proc writeRetI*(f; s: string): int{.tags: [WriteIOEffect], benign.} =
+  ## NONIM
+  let buffer = s.toUint8Array
+  result = denoOr f.writeSync(buffer).int do:
+    let n = writeSync(f.fd, buffer, position=f.position)
+    f.position += n
+    n
+
+proc write*(f; s: string|cstring){.tags: [WriteIOEffect], benign.} =
+  let buffer = s.toUint8Array
+  result = denoOr f.writeSyncEnsureAll(buffer) do:
+    f.position += writeSyncEnsureAll(f.fd, buffer, position=f.position)
+
+proc toString(o: JsObject): cstring{.importcpp.}
+
+template genWriteImpl(arg, T, resWithArg){.dirty.} =
+  proc write*(f; arg: T) {.tags: [WriteIOEffect], benign.} =
+    f.write resWithArg
+
+template genWriteJ(arg, T) =
+  ## using JS toString
+  genWriteImpl arg, T, arg.toJs.toString
+
+template genWriteN(arg, T) =
+  ## using Nim `$`
+  genWriteImpl arg, T, $arg
+
+genWriteJ i, int
+genWriteJ i, BiggestInt
+# REUSE: ``write*(f: File, b: bool)``
+genWriteN r, float32|BiggestFloat
+
+proc writeChar*(f; c: char){.
+  tags: [WriteIOEffect], benign.} =
+  if 1 == readOrWriteCharImpl writeSync:
+    return
+  else: raiseIO("writeChar")  ## FIXME: better msg
+
+# REUSE: ``write*(f: File, a: varargs[string, `$`])``
+
+proc endOfFile*(f: File): bool {.tags: [], benign.} =
+  0 == readOrWriteCharImpl readSync
+
+# REUSE ``writeLine*[Ty](f: File, x: varargs[Ty, `$`])``
+
+{.pragma: notImpl, error: "not impl for JS".}
+when defined(js):
+  proc setStdIoUnbuffered*() {.tags: [], benign, notImpl.}
+
+  proc readLine*(f: File, line: var string): bool {.tags: [ReadIOEffect],
+              benign, notImpl.}