@reventlessdev/rescript-node 2.0.0-alpha.0

package/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+# 2.0.0-alpha.0 (2026-07-31)
+
+* feat(rescript)!: one Node bindings package, not two ([1258d8c](https://github.com/ReventlessDev/reventless-core/commit/1258d8c2b2ff2636b36a849fc5bdf9005c6fb0eb))
+
+### BREAKING CHANGES
+
+* `@reventlessdev/rescript-node-streams` and
+`@reventlessdev/rescript-node-zlib` are replaced by
+`@reventlessdev/rescript-node`. Module names are unchanged.
+
+
+
+This package continues the version line of `@reventlessdev/rescript-node-streams` (1.1.0-alpha.13)
+and `@reventlessdev/rescript-node-zlib` (1.1.0-alpha.14), which it replaces. Their changelogs up to
+those versions are the history of the modules `NodeStreams` and `NodeZlib`; both module names are
+unchanged, so the merge is a dependency swap for consumers.

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2019-2026 Martin Lorenz
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,288 @@
+[![npm](https://img.shields.io/npm/v/@reventlessdev/rescript-node.svg?label=npm)](https://www.npmjs.com/package/@reventlessdev/rescript-node)
+[![License: Apache-2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![Docs](https://img.shields.io/badge/docs-reventless.dev-blue)](https://docs.reventless.dev)
+
+# @reventlessdev/rescript-node
+
+> ⚠️ **Alpha.** APIs can change without notice between releases.
+> Pin exact versions and expect breaking changes.
+
+ReScript bindings for the [Node.js](https://nodejs.org) standard library.
+
+This package has **no dependencies** and performs **no work at module scope** — it is safe to import
+from a Lambda entry point without pulling anything into the runtime module graph.
+
+It replaces `@reventlessdev/rescript-node-streams` and `@reventlessdev/rescript-node-zlib`, which
+were one binding surface published as two artifacts. The package is `namespace: false`, so the module
+names are unchanged: code that used `NodeStreams` or `NodeZlib` needs only a dependency swap.
+
+## Install
+
+```bash
+pnpm add @reventlessdev/rescript-node
+```
+
+Add it to your `rescript.json` dependencies:
+
+```json
+{
+  "dependencies": ["@reventlessdev/rescript-node"]
+}
+```
+
+## Modules
+
+| Module | Binds |
+|---|---|
+| `NodeStreams` | `node:stream`, plus the stream-shaped parts of `node:fs` and `node:readline` |
+| `NodeZlib` | `node:zlib` |
+
+---
+
+## `NodeStreams`
+
+### Stream types
+
+- **`Readable.t`** — readable streams (file read streams, HTTP requests)
+- **`Writable.t`** — writable streams (file write streams, HTTP responses)
+- **`Transform.t`** — transform streams (streams that modify data as it passes through)
+- **`Duplex.t`** — duplex streams (both readable and writable)
+
+### Readable streams
+
+```rescript
+module Readable = {
+  type t = readableStream
+
+  // Piping
+  let pipe: (t, writableStream) => writableStream
+
+  // Encoding
+  let setEncoding: (t, string) => t
+
+  // Event handlers
+  let onDataFromBuffer: (t, @as("data") _, buffer => unit) => t
+  let onDataFromString: (t, @as("data") _, string => unit) => t
+  let onDataFromArbitary: (t, @as("data") _, 'd => unit) => t
+  let onEnd: (t, @as("end") _, unit => unit) => t
+  let onReadable: (t, @as("readable") _, unit => unit) => t
+  let onError: (t, @as("error") _, JsExn.t => unit) => t
+  let onClose: (t, @as("close") _, unit => unit) => t
+}
+```
+
+**Key events:**
+- `data` — emitted when data is available to read
+- `end` — emitted when no more data is available
+- `readable` — emitted when data is ready to be read
+- `error` — emitted on errors
+- `close` — emitted when the stream is closed
+
+### Writable streams
+
+```rescript
+module Writable = {
+  type t = writableStream
+
+  // Operations
+  let close: t => unit
+  let pipe: (t, t) => t
+
+  // Event handlers
+  let onData: (t, @as("data") _, 'd => unit) => t
+  let onDrain: (t, @as("drain") _, unit => unit) => t
+  let onFinish: (t, @as("finish") _, unit => unit) => t
+  let onPipe: (t, @as("pipe") _, readableStream => unit) => t
+  let onUnpipe: (t, @as("unpipe") _, readableStream => unit) => t
+  let onError: (t, @as("error") _, JsExn.t => unit) => t
+  let onClose: (t, @as("close") _, unit => unit) => t
+}
+```
+
+**Key events:**
+- `drain` — emitted when it is safe to resume writing after `write()` returns false
+- `finish` — emitted after `end()` is called and all data is flushed
+- `pipe` — emitted when a readable stream pipes into this writable
+- `unpipe` — emitted when `unpipe()` is called on a readable stream
+
+### Transform streams
+
+```rescript
+module Transform = {
+  type t
+  let pipe: (t, readableStream) => writableStream
+}
+```
+
+### File-system streams
+
+```rescript
+let createReadStream: string => Readable.t
+let createWriteStream: string => Writable.t
+let unlink: string => promise<unit>
+```
+
+### Pipeline
+
+The `pipeline` functions pipe streams together with automatic error handling and cleanup:
+
+```rescript
+// Direct pipe (no transforms)
+let pipeline0: (Readable.t, Writable.t) => promise<unit>
+
+// With 1 transform
+let pipeline: (Readable.t, Transform.t, Writable.t) => promise<unit>
+
+// With 2 transforms
+let pipeline2: (Readable.t, Transform.t, Transform.t, Writable.t) => promise<unit>
+
+// With 3 transforms
+let pipeline3: (Readable.t, Transform.t, Transform.t, Transform.t, Writable.t) => promise<unit>
+```
+
+### Readline
+
+```rescript
+module Readline = {
+  type t
+  type options = {input: Readable.t}
+
+  let createInterface: options => t
+  let onLine: (t, @as("line") _, string => unit) => t
+}
+```
+
+### Examples
+
+#### File copy with piping
+
+```rescript
+open NodeStreams
+
+let copyFile = (source, dest) => {
+  let readStream = createReadStream(source)
+  let writeStream = createWriteStream(dest)
+
+  readStream
+  ->Readable.pipe(writeStream)
+  ->Writable.onFinish(() => Console.log("Copy completed"))
+  ->Writable.onError(err => Console.log2("Error:", err))
+  ->ignore
+}
+```
+
+#### Reading a file line by line
+
+```rescript
+open NodeStreams
+
+let processFileLines = filename => {
+  let readStream = createReadStream(filename)
+  let rl = Readline.createInterface({input: readStream})
+
+  rl->Readline.onLine(line => Console.log(line))->ignore
+
+  readStream
+  ->Readable.onEnd(() => Console.log("Finished reading file"))
+  ->Readable.onError(err => Console.log2("Error:", err))
+  ->ignore
+}
+```
+
+#### Reading data with an encoding
+
+```rescript
+open NodeStreams
+
+let readTextFile = filename =>
+  createReadStream(filename)
+  ->Readable.setEncoding("utf8")
+  ->Readable.onDataFromString(chunk => Console.log2("Received chunk:", chunk))
+  ->Readable.onEnd(() => Console.log("File read complete"))
+  ->Readable.onError(err => Console.log2("Error reading file:", err))
+  ->ignore
+```
+
+#### Safe composition with `pipeline`
+
+```rescript
+open NodeStreams
+
+let copyFileWithPipeline = async (source, dest) => {
+  let readStream = createReadStream(source)
+  let writeStream = createWriteStream(dest)
+
+  try {
+    await pipeline0(readStream, writeStream)
+    Console.log("Copy completed successfully")
+  } catch {
+  | JsExn.Error(err) => Console.log2("Pipeline error:", err)
+  }
+}
+```
+
+### Event handling
+
+All stream types support event-based programming. Events are registered with `on*` functions that
+return the stream, so they chain:
+
+```rescript
+stream
+->onEvent1(handler1)
+->onEvent2(handler2)
+->ignore
+```
+
+Notes:
+
+- Always handle `error` events, or an error becomes an uncaught exception.
+- Prefer the `pipeline` functions over manual `pipe` chains — they clean up on failure.
+- Readable streams switch to flowing mode as soon as a `data` handler is attached.
+
+---
+
+## `NodeZlib`
+
+Bindings for [`node:zlib`](https://nodejs.org/api/zlib.html). Decompression is what this covers
+today; the compression-only options are deliberately absent from `opts` rather than bound and
+ignored.
+
+```rescript
+type opts = {
+  flush?: flush,
+  finishFlush?: flush,
+  chunkSize?: int, // default 16 * 1024
+  windowBits?: int,
+  info?: bool,
+}
+
+let createUnzip: (~options: opts=?) => NodeStreams.Transform.t
+```
+
+`Constants.Flush`, `Constants.ReturnCodes`, `Constants.CompressionLevels` and
+`Constants.CompressionStrategy` bind `zlib.constants`.
+
+### Example
+
+```rescript
+open NodeZlib
+
+let gunzip = async (source, dest) =>
+  await NodeStreams.pipeline(
+    NodeStreams.createReadStream(source),
+    createUnzip(),
+    NodeStreams.createWriteStream(dest),
+  )
+```
+
+A runnable version is in [./src/example/ZlibExample.res](./src/example/ZlibExample.res).
+
+## Links
+
+- 📚 Documentation — [docs.reventless.dev](https://docs.reventless.dev)
+- 📦 Repository — [ReventlessDev/reventless-core](https://github.com/ReventlessDev/reventless-core)
+- 📋 [Changelog](./CHANGELOG.md)
+
+## License
+
+[Apache-2.0](https://opensource.org/licenses/Apache-2.0)

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@reventlessdev/rescript-node",
+  "version": "2.0.0-alpha.0",
+  "description": "ReScript bindings for the Node.js standard library",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "rescript": "12.3.0"
+  },
+  "peerDependencies": {
+    "rescript": "12.3.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ReventlessDev/reventless-core.git",
+    "directory": "rescript/node"
+  },
+  "scripts": {
+    "build": "rescript build",
+    "start": "rescript watch",
+    "clean": "rescript clean",
+    "test": "echo \"There are no tests for rescript-node.\""
+  }
+}

package/rescript.json

@@ -0,0 +1,32 @@
+{
+  "name": "@reventlessdev/rescript-node",
+  "package-specs": {
+    "module": "esmodule",
+    "in-source": true
+  },
+  "namespace": false,
+  "suffix": ".res.mjs",
+  "ppx-flags": [],
+  "warnings": {
+    "error": "-44+101"
+  },
+  "sources": [
+    {
+      "dir": "src",
+      "subdirs": true,
+      "public": [
+        "NodeChildProcess",
+        "NodeCrypto",
+        "NodeFs",
+        "NodeModule",
+        "NodeOs",
+        "NodePath",
+        "NodeProcess",
+        "NodeStreams",
+        "NodeUrl",
+        "NodeZlib"
+      ]
+    }
+  ],
+  "dependencies": []
+}

package/src/NodeChildProcess.res

@@ -0,0 +1,18 @@
+/** Bindings for
+    [`node:child_process`](https://nodejs.org/api/child_process.html). */
+
+type execOptions = {
+  cwd?: string,
+  encoding?: string,
+  env?: dict<string>,
+  stdio?: array<string>,
+  maxBuffer?: int,
+}
+
+@module("node:child_process")
+external execSync: (string, execOptions) => string = "execSync"
+
+/** Takes the arguments as an array rather than interpolating them into a shell
+    string, so an argument containing shell metacharacters stays one argument. */
+@module("node:child_process")
+external execFileSync: (string, array<string>, execOptions) => string = "execFileSync"

package/src/NodeChildProcess.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/NodeCrypto.res

@@ -0,0 +1,42 @@
+/** Bindings for [`node:crypto`](https://nodejs.org/api/crypto.html). */
+
+/** A Node `Buffer`. Abstract rather than aliased to `Uint8Array.t`: a digest
+    buffer is only ever fed back into `createHmac` or stringified, and giving it
+    its own type keeps those two uses from being confused with file bytes. */
+type buffer
+@send external bufferToString: (buffer, string) => string = "toString"
+
+// ── Hashing ──────────────────────────────────────────────────────────────────
+
+type hash
+
+@module("node:crypto")
+external createHash: string => hash = "createHash"
+
+@send external hashUpdate: (hash, string) => hash = "update"
+@send external hashUpdateBuffer: (hash, Uint8Array.t) => hash = "update"
+@send external hashDigest: (hash, string) => string = "digest"
+
+// ── HMAC ─────────────────────────────────────────────────────────────────────
+
+type hmac
+
+@module("node:crypto")
+external createHmac: (string, string) => hmac = "createHmac"
+
+/** The chained form: each round of an AWS SigV4 signing key takes the previous
+    round's raw digest as its key. */
+@module("node:crypto")
+external createHmacFromBuffer: (string, buffer) => hmac = "createHmac"
+
+@send external hmacUpdate: (hmac, string) => hmac = "update"
+@send external hmacDigest: (hmac, string) => string = "digest"
+@send external hmacDigestBuffer: hmac => buffer = "digest"
+
+// ── Random ───────────────────────────────────────────────────────────────────
+
+@module("node:crypto")
+external randomBytes: int => buffer = "randomBytes"
+
+@module("node:crypto")
+external randomUUID: unit => string = "randomUUID"

package/src/NodeCrypto.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/NodeFs.res

@@ -0,0 +1,83 @@
+/** Bindings for [`node:fs`](https://nodejs.org/api/fs.html).
+
+    Every specifier here is `node:`-prefixed. Bare `"fs"` is what bundlers alias
+    to a browser polyfill shim, and this repository bundles Lambda code archives;
+    `node:fs` is unambiguous to Node and to every bundler.
+
+    `readFileSync` bakes the encoding in rather than taking it, so it cannot be
+    passed wrongly — the `(string, string)` form is the one that permits
+    `readFileSync(path, "utf-8")`, a different string, silently. Use
+    {!readFileSyncBuffer} when the bytes are wanted rather than text. */
+
+// ── Existence and metadata ───────────────────────────────────────────────────
+
+@module("node:fs")
+external existsSync: string => bool = "existsSync"
+
+@module("node:fs")
+external realpathSync: string => string = "realpathSync"
+
+// ── Reading ──────────────────────────────────────────────────────────────────
+
+@module("node:fs")
+external readFileSync: (string, @as("utf8") _) => string = "readFileSync"
+
+/** The same call without an encoding, which is what makes Node return the raw
+    bytes rather than a decoded string. */
+@module("node:fs")
+external readFileSyncBuffer: string => Uint8Array.t = "readFileSync"
+
+// ── Writing ──────────────────────────────────────────────────────────────────
+
+@module("node:fs")
+external writeFileSync: (string, string, @as("utf8") _) => unit = "writeFileSync"
+
+// ── Directories ──────────────────────────────────────────────────────────────
+
+type dirent
+@send external isDirectory: dirent => bool = "isDirectory"
+@send external isFile: dirent => bool = "isFile"
+@get external direntName: dirent => string = "name"
+
+type readdirOptions = {withFileTypes: bool}
+
+@module("node:fs")
+external readdirSync: (string, readdirOptions) => array<dirent> = "readdirSync"
+
+type mkdirOptions = {recursive?: bool}
+
+@module("node:fs")
+external mkdirSync: (string, mkdirOptions) => unit = "mkdirSync"
+
+@module("node:fs")
+external mkdtempSync: string => string = "mkdtempSync"
+
+// ── Removing and copying ─────────────────────────────────────────────────────
+
+@module("node:fs")
+external unlinkSync: string => unit = "unlinkSync"
+
+type rmOptions = {recursive?: bool, force?: bool}
+
+@module("node:fs")
+external rmSync: (string, rmOptions) => unit = "rmSync"
+
+type cpOptions = {recursive?: bool}
+
+@module("node:fs")
+external cpSync: (string, string, cpOptions) => unit = "cpSync"
+
+/** Bindings for [`node:fs/promises`](https://nodejs.org/api/fs.html#promises-api).
+
+    A separate module specifier, so a separate module here — the promise API is
+    not a wrapper this package adds over the sync one. */
+module Promises = {
+  @module("node:fs/promises")
+  external writeFile: (string, string) => promise<unit> = "writeFile"
+
+  @module("node:fs/promises")
+  external mkdir: (string, mkdirOptions) => promise<Nullable.t<string>> = "mkdir"
+
+  @module("node:fs/promises")
+  external rm: (string, rmOptions) => promise<unit> = "rm"
+}

package/src/NodeFs.res.mjs

@@ -0,0 +1,9 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let Promises = {};
+
+export {
+  Promises,
+}
+/* No side effect */

package/src/NodeModule.res

@@ -0,0 +1,12 @@
+/** Bindings for [`node:module`](https://nodejs.org/api/module.html).
+
+    `createRequire` is how an ESM module gets at CommonJS resolution, which is
+    what `require.resolve` is wanted for here — locating a dependency's on-disk
+    path without importing it. */
+
+type require
+
+@module("node:module")
+external createRequire: string => require = "createRequire"
+
+@send external requireResolve: (require, string) => string = "resolve"

package/src/NodeModule.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/NodeOs.res

@@ -0,0 +1,4 @@
+/** Bindings for [`node:os`](https://nodejs.org/api/os.html). */
+
+@module("node:os")
+external tmpdir: unit => string = "tmpdir"

package/src/NodeOs.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/NodePath.res

@@ -0,0 +1,25 @@
+/** Bindings for [`node:path`](https://nodejs.org/api/path.html).
+
+    `join` and `resolve` are variadic, which is a strict superset of the
+    two-argument form they replace, so no call site loses expressiveness. A
+    two-argument `join` and a variadic one are not duplicates of each other —
+    they are different functions with the same name, and which one a call site
+    got used to depend on which inline binding block it happened to sit near. */
+
+@module("node:path") @variadic
+external join: array<string> => string = "join"
+
+@module("node:path") @variadic
+external resolve: array<string> => string = "resolve"
+
+@module("node:path")
+external dirname: string => string = "dirname"
+
+@module("node:path")
+external basename: string => string = "basename"
+
+@module("node:path")
+external relative: (string, string) => string = "relative"
+
+@module("node:path") @val
+external sep: string = "sep"

package/src/NodePath.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/NodeProcess.res

@@ -0,0 +1,43 @@
+/** Bindings for the [`process`](https://nodejs.org/api/process.html) global.
+
+    `process` is a global rather than a module specifier, so these are `@val`
+    bindings under `@scope("process")` — `@val external env: dict<string> =
+    "process.env"` and `@val @scope("process") external env: dict<string> =
+    "env"` compile to the same access, and the tree had both spellings. This is
+    the one. */
+
+@val @scope("process")
+external argv: array<string> = "argv"
+
+@val @scope("process")
+external env: dict<string> = "env"
+
+@val @scope("process")
+external cwd: unit => string = "cwd"
+
+@val @scope("process")
+external chdir: string => unit = "chdir"
+
+@val @scope("process")
+external exit: int => unit = "exit"
+
+/** The standard streams. `write`, `isTTY`, `pause` and `unref` are what the
+    interactive prompts in this repository reach for; the type is abstract so it
+    can also be handed to `readline.createInterface`. */
+type stream
+
+@val @scope("process")
+external stdin: stream = "stdin"
+
+@val @scope("process")
+external stdout: stream = "stdout"
+
+@send external write: (stream, string) => unit = "write"
+@send external pause: stream => unit = "pause"
+@send external unref: stream => unit = "unref"
+
+/** `option<bool>`, not `bool`: Node sets `isTTY` to `true` on an interactive
+    stream and leaves it **undefined** otherwise — it is never `false`. A
+    `bool`-typed binding reads that undefined as a valid `false`, which happens
+    to work and is still lying about the value. */
+@get external isTTY: stream => option<bool> = "isTTY"

package/src/NodeProcess.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/NodeStreams.res

@@ -0,0 +1,129 @@
+type readableStream
+type writableStream
+type buffer
+
+module EventHandler = {
+  @send
+  external onError: ('a, @as("error") _, JsExn.t => unit) => 'a = "on"
+  @send
+  external onClose: ('a, @as("close") _, unit => unit) => 'a = "on"
+  @send external onEvent: ('a, string, 'b => unit) => 'a = "on"
+}
+
+module Writable = {
+  type t = writableStream
+  @send external close: t => unit = "end"
+  @send external pipe: (t, t) => t = "pipe"
+
+  include EventHandler // onError & onClose & onEvent
+
+  @send
+  external onData: (t, @as("data") _, 'd => unit) => t = "on"
+
+  /** If a call to stream.write(chunk) returns false, the 'drain' event will be emitted when it is appropriate to resume writing data to the stream.
+    see: https://nodejs.org/docs/latest-v8.x/api/stream.html#stream_event_drain */
+  @send
+  external onDrain: (t, @as("drain") _, unit => unit) => t = "on"
+
+  /** The 'finish' event is emitted after the stream.end() method has been called, and all data has been flushed to the underlying system.
+    see: https://nodejs.org/docs/latest-v8.x/api/stream.html#stream_event_finish */
+  @send
+  external onFinish: (t, @as("finish") _, unit => unit) => t = "on"
+
+  /** The 'pipe' event is emitted when the stream.pipe() method is called on a readable stream, adding this writable to its set of destinations.
+    see: https://nodejs.org/docs/latest-v8.x/api/stream.html#stream_event_pipe */
+  @send
+  external onPipe: (t, @as("pipe") _, readableStream => unit) => t = "on"
+
+  /** The 'unpipe' event is emitted when the stream.unpipe() method is called on a Readable stream, removing this Writable from its set of destinations.
+		This is also emitted in case this Writable stream emits an error when a Readable stream pipes into it.
+		see: https://nodejs.org/docs/latest-v8.x/api/stream.html#stream_event_unpipe */
+  @send
+  external onUnpipe: (t, @as("unpipe") _, readableStream => unit) => t = "on"
+}
+
+module Readable = {
+  type t = readableStream
+  @send external pipe: (t, writableStream) => writableStream = "pipe"
+
+  @send
+  external setEncoding: (t, string) => t = "setEncoding"
+
+  include EventHandler // onError & onClose & onEvent
+
+  /** The 'data' event is emitted whenever the stream is relinquishing ownership of a chunk of data to a consumer. This may occur whenever the stream is switched in flowing mode by calling readable.pipe(), readable.resume(), or by attaching a listener callback to the 'data' event. The 'data' event will also be emitted whenever the readable.read() method is called and a chunk of data is available to be returned.
+		Attaching a 'data' event listener to a stream that has not been explicitly paused will switch the stream into flowing mode. Data will then be passed as soon as it is available.
+		The listener callback will be passed the chunk of data as a string if a default encoding has been specified for the stream using the readable.setEncoding() method; otherwise the data will be passed as a Buffer.
+	 see: https://nodejs.org/docs/latest-v8.x/api/stream.html#stream_event_data */
+  @send
+  external onDataFromBuffer: (t, @as("data") _, buffer => unit) => t = "on"
+
+  /** The 'data' event is emitted whenever the stream is relinquishing ownership of a chunk of data to a consumer. This may occur whenever the stream is switched in flowing mode by calling readable.pipe(), readable.resume(), or by attaching a listener callback to the 'data' event. The 'data' event will also be emitted whenever the readable.read() method is called and a chunk of data is available to be returned.
+		Attaching a 'data' event listener to a stream that has not been explicitly paused will switch the stream into flowing mode. Data will then be passed as soon as it is available.
+		The listener callback will be passed the chunk of data as a string if a default encoding has been specified for the stream using the readable.setEncoding() method; otherwise the data will be passed as a Buffer.
+	 see: https://nodejs.org/docs/latest-v8.x/api/stream.html#stream_event_data */
+  @send
+  external onDataFromString: (t, @as("data") _, string => unit) => t = "on"
+
+  /** The 'data' event is emitted whenever the stream is relinquishing ownership of a chunk of data to a consumer. This may occur whenever the stream is switched in flowing mode by calling readable.pipe(), readable.resume(), or by attaching a listener callback to the 'data' event. The 'data' event will also be emitted whenever the readable.read() method is called and a chunk of data is available to be returned.
+		Attaching a 'data' event listener to a stream that has not been explicitly paused will switch the stream into flowing mode. Data will then be passed as soon as it is available.
+		The listener callback will be passed the chunk of data as a string if a default encoding has been specified for the stream using the readable.setEncoding() method; otherwise the data will be passed as a Buffer.
+		Note: The 'end' event will not be emitted unless the data is completely consumed. This can be accomplished by switching the stream into flowing mode, or by calling stream.read() repeatedly until all data has been consumed.
+	 see: https://nodejs.org/docs/latest-v8.x/api/stream.html#stream_event_data */
+  @send
+  external onDataFromArbitary: (t, @as("data") _, 'd => unit) => t = "on"
+
+  /** The 'end' event is emitted when there is no more data to be consumed from the stream.
+		see: https://nodejs.org/docs/latest-v8.x/api/stream.html#stream_event_end */
+  @send
+  external onEnd: (t, @as("end") _, unit => unit) => t = "on"
+
+  /** The 'readable' event is emitted when there is data available to be read from the stream. In some cases, attaching a listener for the 'readable' event will cause some amount of data to be read into an internal buffer.
+		see: https://nodejs.org/docs/latest-v8.x/api/stream.html#stream_event_readable */
+  @send
+  external onReadable: (t, @as("readable") _, unit => unit) => t = "on"
+}
+
+module Duplex = {
+  type t
+}
+
+module Transform = {
+  type t
+  @send external pipe: (t, readableStream) => writableStream = "pipe"
+}
+
+@val @module("node:fs")
+external createWriteStream: string => Writable.t = "createWriteStream"
+@val @module("node:fs")
+external createReadStream: string => Readable.t = "createReadStream"
+@val @module("node:fs")
+external unlink: string => promise<unit> = "unlink"
+
+module Readline = {
+  type t
+  type options = {input: Readable.t}
+
+  @val @module("node:readline")
+  external createInterface: options => t = "createInterface"
+
+  @send
+  external onLine: (t, @as("line") _, string => unit) => t = "on"
+}
+
+// NOTE: This node function is variadic (=takes n transform streams)
+// NOTE: documentation says, this returns <Stream>, we just bind to unit
+@val @module("node:stream") @scope("promises")
+external pipeline0: (Readable.t, Writable.t) => promise<unit> = "pipeline"
+@val @module("node:stream") @scope("promises")
+external pipeline: (Readable.t, Transform.t, Writable.t) => promise<unit> = "pipeline"
+@val @module("node:stream") @scope("promises")
+external pipeline2: (Readable.t, Transform.t, Transform.t, Writable.t) => promise<unit> = "pipeline"
+@val @module("node:stream") @scope("promises")
+external pipeline3: (
+  Readable.t,
+  Transform.t,
+  Transform.t,
+  Transform.t,
+  Writable.t,
+) => promise<unit> = "pipeline"

package/src/NodeStreams.res.mjs

@@ -0,0 +1,24 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let EventHandler = {};
+
+let Writable = {};
+
+let Readable = {};
+
+let Duplex = {};
+
+let Transform = {};
+
+let Readline = {};
+
+export {
+  EventHandler,
+  Writable,
+  Readable,
+  Duplex,
+  Transform,
+  Readline,
+}
+/* No side effect */

package/src/NodeUrl.res

@@ -0,0 +1,10 @@
+/** Bindings for [`node:url`](https://nodejs.org/api/url.html).
+
+    Only the two path/URL converters — the `URL` class itself is a WHATWG global
+    rather than a `node:` import, so it belongs to `rescript-web`, not here. */
+
+@module("node:url")
+external fileURLToPath: string => string = "fileURLToPath"
+
+@module("node:url")
+external pathToFileURL: string => {"href": string} = "pathToFileURL"

package/src/NodeUrl.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/NodeZlib.res

@@ -0,0 +1,75 @@
+type flush
+type returnCode
+type compressionLevel
+type compressionStrategy
+
+module Constants = {
+  module Flush = {
+    @val @module("node:zlib") @scope("constants")
+    external z_no_flush: flush = "Z_NO_FLUSH"
+    @val @module("node:zlib") @scope("constants")
+    external z_partial_flush: flush = "Z_PARTIAL_FLUSH"
+    @val @module("node:zlib") @scope("constants")
+    external z_sync_flush: flush = "Z_SYNC_FLUSH"
+    @val @module("node:zlib") @scope("constants")
+    external z_full_flush: flush = "Z_FULL_FLUSH"
+    @val @module("node:zlib") @scope("constants")
+    external z_finish: flush = "Z_FINISH"
+    @val @module("node:zlib") @scope("constants")
+    external z_block: flush = "Z_BLOCK"
+    @val @module("node:zlib") @scope("constants")
+    external z_trees: flush = "Z_TREES"
+  }
+
+  module ReturnCodes = {
+    @val @module("node:zlib") @scope("constants")
+    external z_ok: returnCode = "Z_OK"
+    @val @module("node:zlib") @scope("constants")
+    external z_stream_end: returnCode = "Z_STREAM_END"
+    @val @module("node:zlib") @scope("constants")
+    external z_need_dict: returnCode = "Z_NEED_DICT"
+    @val @module("node:zlib") @scope("constants")
+    external z_errno: returnCode = "Z_ERRNO"
+    @val @module("node:zlib") @scope("constants")
+    external z_stream_error: returnCode = "Z_STREAM_ERROR"
+    @val @module("node:zlib") @scope("constants")
+    external z_data_error: returnCode = "Z_DATA_ERROR"
+    @val @module("node:zlib") @scope("constants")
+    external z_mem_error: returnCode = "Z_MEM_ERROR"
+    @val @module("node:zlib") @scope("constants")
+    external z_buf_error: returnCode = "Z_BUF_ERROR"
+    @val @module("node:zlib") @scope("constants")
+    external z_version_error: returnCode = "Z_VERSION_ERROR"
+  }
+
+  module CompressionLevels = {
+    @val @module("node:zlib") @scope("constants")
+    external z_no_compression: compressionLevel = "Z"
+    @val @module("node:zlib") @scope("constants")
+    external z_best_speed: compressionLevel = "Z_BEST_SPEED"
+    @val @module("node:zlib") @scope("constants")
+    external z_best_compression: compressionLevel = "Z_BEST_COMPRESSION"
+    @val @module("node:zlib") @scope("constants")
+    external z_default_compression: compressionLevel = "Z_DEFAULT_COMPRESSION"
+  }
+
+  module CompressionStrategy = {
+    external z_filtered: compressionStrategy = "Z_FILTERED"
+    external z_huffman_only: compressionStrategy = "Z_HUFFMAN_ONLY"
+    external z_rle: compressionStrategy = "Z_RLE"
+    external z_fixed: compressionStrategy = "Z_FIXED"
+    external z_default_strategy: compressionStrategy = "Z_DEFAULT_STRATEGY"
+  }
+}
+
+// NOTE: props not relevant for decompression have been skipped
+type opts = {
+  flush?: flush,
+  finishFlush?: flush,
+  chunkSize?: int, // Default: 16 * 1024
+  windowBits?: int,
+  info?: bool,
+}
+
+@val @module("node:zlib")
+external createUnzip: (~options: opts=?) => NodeStreams.Transform.t = "createUnzip"

package/src/NodeZlib.res.mjs

@@ -0,0 +1,22 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let Flush = {};
+
+let ReturnCodes = {};
+
+let CompressionLevels = {};
+
+let CompressionStrategy = {};
+
+let Constants = {
+  Flush: Flush,
+  ReturnCodes: ReturnCodes,
+  CompressionLevels: CompressionLevels,
+  CompressionStrategy: CompressionStrategy
+};
+
+export {
+  Constants,
+}
+/* No side effect */

package/src/example/ZlibExample.res

@@ -0,0 +1,20 @@
+/*
+ * To run this example:
+ *  - build this package
+ *  - cd into the example directory
+ *  - run `node Example.bs.js`
+ *  - Test was successfull if:
+ *    - no exception was raised (and outputed during program execution)
+ *    - testResult.txt file is now present in the example directory
+ */
+
+open NodeZlib
+
+let f = async () => {
+  let readFile = NodeStreams.createReadStream("./test.txt.gz")
+  let unzipFile = createUnzip()
+  let writeFile = NodeStreams.createWriteStream("./testResult.txt")
+  await NodeStreams.pipeline(readFile, unzipFile, writeFile)
+}
+
+f()->ignore

package/src/example/ZlibExample.res.mjs

@@ -0,0 +1,19 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodezlib from "node:zlib";
+import * as Nodestream from "node:stream";
+
+async function f() {
+  let readFile = Nodefs.createReadStream("./test.txt.gz");
+  let unzipFile = Nodezlib.createUnzip();
+  let writeFile = Nodefs.createWriteStream("./testResult.txt");
+  return await Nodestream.promises.pipeline(readFile, unzipFile, writeFile);
+}
+
+f();
+
+export {
+  f,
+}
+/*  Not a pure module */