Data & utility modules

Reference for Cruft's Node data and utility modules, node:buffer, node:util, node:querystring, node:zlib, node:crypto, and node:assert, listing exactly which exports are installed and their gaps (for example, the zstd family throws and util.styleText returns text unstyled).

This page is the reference for Cruft's data-handling and utility Node modules: node:buffer, node:util (and node:util/types), node:querystring, node:zlib, node:crypto, and node:assert (and node:assert/strict). None of these has a dedicated guide page; the compatibility map classes them as focused-or-partial, so this page documents only what is actually installed in the host. Every export listed below is installed; anything not listed is not present. All modules resolve under both the node: prefix and the bare name (require("util") works), from both require and import.

node:buffer, focused

Buffer is a real binary type: a Uint8Array subclass with the Node read/write/encode surface. The module namespace is small compared to Node's, but the Buffer class itself carries the common ecosystem surface.

Example:

$ cruft -e 'console.log(Buffer.from("hi").toString("base64"), Buffer.from([0,0,1,0]).readUInt32BE(0))'
aGk= 256

Not implemented / gaps: SlowBuffer, Buffer.copyBytesFrom. Buffer is also a global; importing the module is optional.

node:util, focused

Eagerly installed (not lazy) because nearly every real package imports it. The formatter/inspector core is real and matches Node's common output shapes.

Example:

$ cruft -e 'const u=require("util"); console.log(u.format("%s=%d %o","n",42,{a:1}))'
n=42 { a: 1 }

Not implemented / gaps: getSystemErrorMessage-family fidelity is untested against real errnos; the deprecated is* predicate family (isBuffer, isDate, isRegExp, ...) is absent from the top-level namespace except isArray (use util.types). node:sys resolves to this module as in Node.

node:util/types, focused

All 43 Node util.types predicates are installed: isAnyArrayBuffer, isArrayBuffer, isSharedArrayBuffer, isArrayBufferView, isTypedArray, every per-typed-array predicate (isInt8Array ... isBigUint64Array, including isFloat16Array), isDataView, isDate, isRegExp, isMap/isSet and their iterator predicates, isWeakMap/isWeakSet, isPromise, isProxy, isNativeError, isGeneratorFunction/isGeneratorObject, isAsyncFunction, isModuleNamespaceObject, isArgumentsObject, boxed-primitive predicates (isNumberObject, isStringObject, isBooleanObject, isBigIntObject, isSymbolObject, isBoxedPrimitive), plus isExternal, isCryptoKey, isKeyObject.

node:querystring, focused

The classic (non-WHATWG) query codec. Small surface, fully present.

$ cruft -e 'const qs=require("querystring"); console.log(JSON.stringify(qs.parse("a=1&b=2&b=3")), qs.stringify({a:"x y",b:[1,2]}))'
{"a":"1","b":["2","3"]} a=x%20y&b=1&b=2

Custom sep/eq/decodeURIComponent/maxKeys options exist per the host compatibility-exception note. Not implemented / gaps: none at the namespace level.

node:zlib, partial

Gzip, deflate/deflate-raw, and brotli are real, in both sync and async (callback) forms, backed by Cruft's compression layer. Zstd throws not yet implemented.

$ cruft -e 'const z=require("zlib"); console.log(z.gunzipSync(z.gzipSync("hello world")).toString())'
hello world

Not implemented / gaps: the entire zstd family throws not yet implemented (see above); dictionary options and flush-level fidelity are untested.

node:crypto, focused

The Node-flavored crypto module (distinct from the WebCrypto global, which is re-exported here as webcrypto/subtle). The primitive core is real: hashing, HMAC, key derivation, AES ciphers, sign/verify, key generation.

$ cruft -e 'const c=require("crypto"); console.log(c.createHash("sha256").update("abc").digest("hex"))'
ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad

Not implemented / gaps: no streaming Cipher/Decipher legacy (createCipher without iv), use the iv forms; per-algorithm coverage beyond the listed set (exotic curves, cipher modes) is not guaranteed; setEngine/FIPS toggles are inert.

node:assert / node:assert/strict, partial

assert resolves to a callable function (alias of ok) carrying the method surface; assert/strict is the same surface with the loose methods remapped to strict semantics (strict.equal(1, "1") throws ERR_ASSERTION).

Known compatibility exceptions:

• AssertionError.operator is populated with the comparison operator (e.g. strictEqual), matching Node; actual/expected diff-rendering in messages is minimal (e.g. "deepStrictEqual failed").
• assert.rejects(promise) succeeds; passing a rejected promise directly resolves cleanly (exit code 0), no unhandled-rejection workaround needed.

Not implemented / gaps: CallTracker (absent, deprecated in Node), rich diff messages.