visaljs 0.0.7 → 0.0.8

package/node/prelude/vm.js

@@ -0,0 +1,86 @@
+// node:vm: contexts can be made and recognized, and memory measured, but running source text
+// needs a JavaScript engine a compiled program doesn't have: Script runs, compileFunction and the
+// run* functions throw ERR_VISALJS_UNSUPPORTED.
+import { processMemory } from "visaljs:host";
+import { invalidArgType, notSupported } from "./internal/errors.js";
+
+const contexts = new WeakSet();
+const kRunning = "vm (running source text)";
+
+export const constants = Object.freeze({
+  USE_MAIN_CONTEXT_DEFAULT_LOADER: Symbol("vm_dynamic_import_main_context_default"),
+  DONT_CONTEXTIFY: Symbol("vm_context_no_contextify"),
+});
+
+/** createContext([object]): the object, marked as a context. */
+export function createContext(contextObject = {}, options) {
+  void options;
+  if (contextObject === constants.DONT_CONTEXTIFY) contextObject = {};
+  if (contextObject === null || typeof contextObject !== "object") throw invalidArgType("contextObject", "of type object", contextObject);
+  contexts.add(contextObject);
+  return contextObject;
+}
+
+export function isContext(object) {
+  if (object === null || typeof object !== "object") throw invalidArgType("object", "of type object", object);
+  return contexts.has(object);
+}
+
+/** Source text to run: kept, but running it throws. */
+export class Script {
+  constructor(code, options) {
+    if (typeof code !== "string") throw invalidArgType("code", "of type string", code);
+    this.code = code;
+    this.filename = typeof options === "string" ? options : options?.filename ?? "evalmachine.<anonymous>";
+  }
+
+  runInThisContext() {
+    throw notSupported(kRunning);
+  }
+
+  runInContext() {
+    throw notSupported(kRunning);
+  }
+
+  runInNewContext() {
+    throw notSupported(kRunning);
+  }
+
+  createCachedData() {
+    return Buffer.alloc(0);
+  }
+}
+
+export function createScript(code, options) {
+  return new Script(code, options);
+}
+
+export function runInThisContext() {
+  throw notSupported(kRunning);
+}
+
+export function runInContext() {
+  throw notSupported(kRunning);
+}
+
+export function runInNewContext() {
+  throw notSupported(kRunning);
+}
+
+export function compileFunction() {
+  throw notSupported(kRunning);
+}
+
+/** The program's memory, as V8's estimate is reported: { total: { jsMemoryEstimate, jsMemoryRange } }. */
+let measureWarned = false;
+export function measureMemory(options = {}) {
+  if (!measureWarned) {
+    measureWarned = true;
+    process.emitWarning("vm.measureMemory is an experimental feature and might change at any time", "ExperimentalWarning");
+  }
+  if (options === null || typeof options !== "object") return Promise.reject(invalidArgType("options", "of type object", options));
+  const [, , heapUsed] = processMemory();
+  return Promise.resolve({ total: { jsMemoryEstimate: heapUsed, jsMemoryRange: [heapUsed, heapUsed] } });
+}
+
+export default { Script, compileFunction, constants, createContext, createScript, isContext, measureMemory, runInContext, runInNewContext, runInThisContext };

package/node/prelude/wasi.js

@@ -0,0 +1,10 @@
+// node:wasi: WASI runs WebAssembly modules, which visaljs doesn't provide.
+import { notSupported } from "./internal/errors.js";
+
+export class WASI {
+  constructor() {
+    throw notSupported("WASI (WebAssembly)");
+  }
+}
+
+export default { WASI };

package/node/prelude/worker_threads.js

@@ -0,0 +1,56 @@
+// node:worker_threads: a compiled program is one thread, the main one. What a
+// program reads to find that out is as in Node's main thread (isMainThread, threadId 0, no
+// parentPort or workerData), and the environment data and transfer marks work in it. Starting a
+// thread (Worker) and message ports throw ERR_VISALJS_UNSUPPORTED: libraries that only load the
+// module for a parallel mode (mocha's workerpool) run until asked for it.
+import { notSupported } from "./internal/errors.js";
+
+export const isMainThread = true;
+export const isInternalThread = false;
+export const parentPort = null;
+export const workerData = null;
+export const threadId = 0;
+export const threadName = "";
+export const resourceLimits = {};
+export const SHARE_ENV = Symbol.for("nodejs.worker_threads.SHARE_ENV");
+
+const environmentData = new Map();
+export function getEnvironmentData(key) {
+  return environmentData.get(key);
+}
+export function setEnvironmentData(key, value) {
+  if (value === undefined) environmentData.delete(key);
+  else environmentData.set(key, value);
+}
+
+const untransferable = new WeakSet();
+export function markAsUntransferable(object) {
+  if ((typeof object === "object" && object !== null) || typeof object === "function") untransferable.add(object);
+}
+export function isMarkedAsUntransferable(object) {
+  return ((typeof object === "object" && object !== null) || typeof object === "function") && untransferable.has(object);
+}
+/* nothing is sent between threads, so nothing to refuse to clone */
+export function markAsUncloneable() {}
+
+export class Worker {
+  constructor() { throw notSupported("worker_threads.Worker"); }
+}
+export class MessageChannel {
+  constructor() { throw notSupported("worker_threads.MessageChannel"); }
+}
+export class MessagePort {
+  constructor() { throw notSupported("worker_threads.MessagePort"); }
+}
+export class BroadcastChannel {
+  constructor() { throw notSupported("worker_threads.BroadcastChannel"); }
+}
+export function moveMessagePortToContext() { throw notSupported("worker_threads.moveMessagePortToContext"); }
+export function receiveMessageOnPort() { throw notSupported("worker_threads.receiveMessageOnPort"); }
+export function postMessageToThread() { throw notSupported("worker_threads.postMessageToThread"); }
+
+export default {
+  isMainThread, isInternalThread, parentPort, workerData, threadId, threadName, resourceLimits, SHARE_ENV,
+  getEnvironmentData, setEnvironmentData, markAsUntransferable, isMarkedAsUntransferable, markAsUncloneable,
+  Worker, MessageChannel, MessagePort, BroadcastChannel, moveMessagePortToContext, receiveMessageOnPort, postMessageToThread,
+};

package/node/prelude/zlib.js

@@ -1,12 +1,14 @@
-// node:zlib (ADR 0012, layer 3): Node's lib/zlib.js (v22) on Node's binding, which is C here
+// node:zlib: Node's lib/zlib.js (v24) on Node's binding, which is C here
 // (node/src/host_zlib.c over Chromium's zlib, the copy Node vendors): the same streams, the same
 // convenience functions, and the same compressed bytes, Brotli's and zstd's too (node/src/host_brotli.c
 // and host_zstd.c, linked into programs that name them: internal/zlib_engines.js). A write's
 // callback runs a turn later, where Node's thread pool would call it back.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import { timerStart, zlibClose, zlibCrc32, zlibInit, zlibNew, zlibParams, zlibReset, zlibWrite } from "visaljs:host";
 import { Buffer, kMaxLength } from "./buffer.js";
 import { codeError, invalidArgType, outOfRange } from "./internal/errors.js";
-import { finished, Transform } from "./stream.js";
+import { finished } from "./stream.js";
+import Transform from "./internal/streams/transform.js";
 import { deprecate } from "./util.js";
 import { engines } from "./internal/zlib_engines.js";
 
@@ -84,6 +86,8 @@ export const codes = {
 };
 for (const ckey of Object.keys(codes)) codes[codes[ckey]] = ckey;
 Object.freeze(codes);
+/* each constant read-only and permanent, as NODE_DEFINE_CONSTANT makes them */
+for (const key of Object.keys(constants)) Object.defineProperty(constants, key, { writable: false, configurable: false });
 
 const kFlushFlag = Symbol("kFlushFlag");
 const kError = Symbol("kError");
@@ -158,6 +162,7 @@ class CompressionHandle {
   }
 
   reset() {
+    if (this._writing) throw new Error("Cannot reset zlib stream while a write is in progress");
     const failure = this._ops.reset(this._native);
     if (failure !== 0) this._emitError(failure);
   }
@@ -179,10 +184,10 @@ class ZlibHandle extends CompressionHandle {
     super(zlibOps, zlibNew(mode));
   }
 
-  init(windowBits, level, memLevel, strategy, writeResult, writeCallback, dictionary) {
+  init(windowBits, level, memLevel, strategy, writeResult, writeCallback, dictionary, rejectGarbageAfterEnd) {
     this._writeResult = writeResult;
     this._writeCallback = writeCallback;
-    zlibInit(this._native, windowBits, level, memLevel, strategy, isArrayBufferView(dictionary) ? dictionary : undefined);
+    zlibInit(this._native, windowBits, level, memLevel, strategy, isArrayBufferView(dictionary) ? dictionary : undefined, rejectGarbageAfterEnd);
   }
 
   params(level, strategy) {
@@ -208,10 +213,10 @@ class BrotliHandle extends CompressionHandle {
     super(ops, ops.new(mode));
   }
 
-  init(params, writeResult, writeCallback) {
+  init(params, writeResult, writeCallback, dictionary) {
     this._writeResult = writeResult;
     this._writeCallback = writeCallback;
-    const failure = this._ops.init(this._native, params);
+    const failure = this._ops.init(this._native, params, dictionary);
     if (failure !== 0) {
       this._emitError(failure);
       throw codeError(Error, "ERR_ZLIB_INITIALIZATION_FAILED", "Initialization failed");
@@ -231,11 +236,11 @@ class ZstdHandle extends CompressionHandle {
   init(params, pledgedSrcSize, writeResult, writeCallback, dictionary) {
     this._writeResult = writeResult;
     this._writeCallback = writeCallback;
-    if (typeof pledgedSrcSize === "number") {
-      pledgedSrcSize = Number.isNaN(pledgedSrcSize) ? 0 : Math.trunc(pledgedSrcSize);
-      if (pledgedSrcSize < 0) throw codeError(TypeError, "ERR_INVALID_ARG_VALUE", "pledgedSrcSize may not be negative");
-    } else {
-      pledgedSrcSize = undefined;
+    /* Node 24's binding checks it: a number, a safe integer, not negative */
+    if (pledgedSrcSize !== undefined) {
+      if (typeof pledgedSrcSize !== "number") throw codeError(TypeError, "ERR_INVALID_ARG_TYPE", "pledgedSrcSize must be a number");
+      if (!Number.isSafeInteger(pledgedSrcSize)) throw codeError(RangeError, "ERR_OUT_OF_RANGE", "pledgedSrcSize must be a safe integer");
+      if (pledgedSrcSize < 0) throw codeError(RangeError, "ERR_OUT_OF_RANGE", "pledgedSrcSize must be non-negative");
     }
     const failure = this._ops.init(this._native, params, pledgedSrcSize, dictionary);
     if (failure !== 0) {
@@ -334,6 +339,7 @@ function ZlibBase(opts, mode, handle, { flush, finishFlush, fullFlush }) {
   assert(mode >= DEFLATE && mode <= ZSTD_DECOMPRESS);
   const brotli = mode === BROTLI_ENCODE || mode === BROTLI_DECODE;
   const zstd = mode === ZSTD_COMPRESS || mode === ZSTD_DECOMPRESS;
+  /* FLUSH_BOUND: the flush kinds each engine takes */
   const minFlush = brotli ? BROTLI_OPERATION_PROCESS : zstd ? ZSTD_e_continue : Z_NO_FLUSH;
   const maxFlushFlag = brotli ? BROTLI_OPERATION_EMIT_METADATA : zstd ? ZSTD_e_end : Z_BLOCK;
 
@@ -347,6 +353,9 @@ function ZlibBase(opts, mode, handle, { flush, finishFlush, fullFlush }) {
     flush = checkRangesOrGetDefault(opts.flush, "options.flush", minFlush, maxFlushFlag, flush);
     finishFlush = checkRangesOrGetDefault(opts.finishFlush, "options.finishFlush", minFlush, maxFlushFlag, finishFlush);
     maxOutputLength = checkRangesOrGetDefault(opts.maxOutputLength, "options.maxOutputLength", 1, kMaxLength, kMaxLength);
+    if (opts.rejectGarbageAfterEnd !== undefined && typeof opts.rejectGarbageAfterEnd !== "boolean") {
+      throw invalidArgType("options.rejectGarbageAfterEnd", "of type boolean", opts.rejectGarbageAfterEnd);
+    }
     if (opts.encoding || opts.objectMode || opts.writableObjectMode) {
       opts = { ...opts };
       opts.encoding = null;
@@ -367,6 +376,7 @@ function ZlibBase(opts, mode, handle, { flush, finishFlush, fullFlush }) {
   this._defaultFlushFlag = flush;
   this._finishFlushFlag = finishFlush;
   this._defaultFullFlushFlag = fullFlush;
+  this._flushBound = [minFlush, maxFlushFlag];
   this._info = opts?.info;
   this._maxOutputLength = maxOutputLength;
   this._rejectGarbageAfterEnd = opts?.rejectGarbageAfterEnd === true;
@@ -435,6 +445,7 @@ ZlibBase.prototype.flush = function (kind, callback) {
     callback = kind;
     kind = this._defaultFullFlushFlag;
   }
+  kind = checkRangesOrGetDefault(kind, "kind", this._flushBound[0], this._flushBound[1], this._defaultFullFlushFlag);
   if (this.writableFinished) {
     if (callback) process.nextTick(callback);
   } else if (this.writableEnded) {
@@ -531,6 +542,11 @@ function processChunkSync(self, chunk, flushFlag) {
     }
   }
 
+  if (availInAfter > 0 && self._rejectGarbageAfterEnd) {
+    _close(self);
+    throw codeError(TypeError, "ERR_TRAILING_JUNK_AFTER_STREAM_END", "Trailing junk found after the end of the compressed stream");
+  }
+
   self.bytesWritten = inputRead;
   _close(self);
 
@@ -662,7 +678,7 @@ function Zlib(opts, mode) {
 
   const handle = new ZlibHandle(mode);
   this._writeState = new Uint32Array(2);
-  handle.init(windowBits, level, memLevel, strategy, this._writeState, processCallback, dictionary);
+  handle.init(windowBits, level, memLevel, strategy, this._writeState, processCallback, dictionary, opts?.rejectGarbageAfterEnd === true);
 
   Reflect.apply(ZlibBase, this, [opts, mode, handle, zlibDefaultOpts]);
 
@@ -694,29 +710,39 @@ Zlib.prototype.params = function params(level, strategy, callback) {
   }
 };
 
+/* a constructor called without new: Node 24 deprecates it (DEP0184), warning once */
+let warnedInstantiation = false;
+function deprecateInstantiation(target, opts) {
+  if (!warnedInstantiation) {
+    warnedInstantiation = true;
+    process.emitWarning(`Instantiating ${target.name} without the 'new' keyword has been deprecated.`, "DeprecationWarning", "DEP0184");
+  }
+  return new target(opts);
+}
+
 export function Deflate(opts) {
-  if (!(this instanceof Deflate)) return new Deflate(opts);
+  if (!(this instanceof Deflate)) return deprecateInstantiation(Deflate, opts);
   Reflect.apply(Zlib, this, [opts, DEFLATE]);
 }
 Object.setPrototypeOf(Deflate.prototype, Zlib.prototype);
 Object.setPrototypeOf(Deflate, Zlib);
 
 export function Inflate(opts) {
-  if (!(this instanceof Inflate)) return new Inflate(opts);
+  if (!(this instanceof Inflate)) return deprecateInstantiation(Inflate, opts);
   Reflect.apply(Zlib, this, [opts, INFLATE]);
 }
 Object.setPrototypeOf(Inflate.prototype, Zlib.prototype);
 Object.setPrototypeOf(Inflate, Zlib);
 
 export function Gzip(opts) {
-  if (!(this instanceof Gzip)) return new Gzip(opts);
+  if (!(this instanceof Gzip)) return deprecateInstantiation(Gzip, opts);
   Reflect.apply(Zlib, this, [opts, GZIP]);
 }
 Object.setPrototypeOf(Gzip.prototype, Zlib.prototype);
 Object.setPrototypeOf(Gzip, Zlib);
 
 export function Gunzip(opts) {
-  if (!(this instanceof Gunzip)) return new Gunzip(opts);
+  if (!(this instanceof Gunzip)) return deprecateInstantiation(Gunzip, opts);
   Reflect.apply(Zlib, this, [opts, GUNZIP]);
 }
 Object.setPrototypeOf(Gunzip.prototype, Zlib.prototype);
@@ -724,21 +750,21 @@ Object.setPrototypeOf(Gunzip, Zlib);
 
 export function DeflateRaw(opts) {
   if (opts && opts.windowBits === 8) opts.windowBits = 9;
-  if (!(this instanceof DeflateRaw)) return new DeflateRaw(opts);
+  if (!(this instanceof DeflateRaw)) return deprecateInstantiation(DeflateRaw, opts);
   Reflect.apply(Zlib, this, [opts, DEFLATERAW]);
 }
 Object.setPrototypeOf(DeflateRaw.prototype, Zlib.prototype);
 Object.setPrototypeOf(DeflateRaw, Zlib);
 
 export function InflateRaw(opts) {
-  if (!(this instanceof InflateRaw)) return new InflateRaw(opts);
+  if (!(this instanceof InflateRaw)) return deprecateInstantiation(InflateRaw, opts);
   Reflect.apply(Zlib, this, [opts, INFLATERAW]);
 }
 Object.setPrototypeOf(InflateRaw.prototype, Zlib.prototype);
 Object.setPrototypeOf(InflateRaw, Zlib);
 
 export function Unzip(opts) {
-  if (!(this instanceof Unzip)) return new Unzip(opts);
+  if (!(this instanceof Unzip)) return deprecateInstantiation(Unzip, opts);
   Reflect.apply(Zlib, this, [opts, UNZIP]);
 }
 Object.setPrototypeOf(Unzip.prototype, Zlib.prototype);
@@ -781,9 +807,15 @@ function Brotli(opts, mode) {
     });
   }
 
+  let dictionary = opts?.dictionary;
+  if (dictionary !== undefined && !isArrayBufferView(dictionary)) {
+    if (isAnyArrayBuffer(dictionary)) dictionary = Buffer.from(dictionary);
+    else throw invalidArgType("options.dictionary", "an instance of Buffer, TypedArray, DataView, or ArrayBuffer", dictionary);
+  }
+
   const handle = new BrotliHandle(mode);
   this._writeState = new Uint32Array(2);
-  handle.init(brotliInitParamsArray, this._writeState, processCallback);
+  handle.init(brotliInitParamsArray, this._writeState, processCallback, dictionary);
 
   Reflect.apply(ZlibBase, this, [opts, mode, handle, brotliDefaultOpts]);
 }
@@ -791,14 +823,14 @@ Object.setPrototypeOf(Brotli.prototype, Zlib.prototype);
 Object.setPrototypeOf(Brotli, Zlib);
 
 export function BrotliCompress(opts) {
-  if (!(this instanceof BrotliCompress)) return new BrotliCompress(opts);
+  if (!(this instanceof BrotliCompress)) return deprecateInstantiation(BrotliCompress, opts);
   Reflect.apply(Brotli, this, [opts, BROTLI_ENCODE]);
 }
 Object.setPrototypeOf(BrotliCompress.prototype, Brotli.prototype);
 Object.setPrototypeOf(BrotliCompress, Brotli);
 
 export function BrotliDecompress(opts) {
-  if (!(this instanceof BrotliDecompress)) return new BrotliDecompress(opts);
+  if (!(this instanceof BrotliDecompress)) return deprecateInstantiation(BrotliDecompress, opts);
   Reflect.apply(Brotli, this, [opts, BROTLI_DECODE]);
 }
 Object.setPrototypeOf(BrotliDecompress.prototype, Brotli.prototype);
@@ -824,11 +856,12 @@ class Zstd extends ZlibBase {
       });
     }
 
+    let dictionary = opts?.dictionary;
+    if (dictionary !== undefined && !isArrayBufferView(dictionary)) dictionary = isAnyArrayBuffer(dictionary) ? new Uint8Array(dictionary) : undefined;
     const handle = new ZstdHandle(mode === ZSTD_COMPRESS);
-    const pledgedSrcSize = opts?.pledgedSrcSize ?? undefined;
+    const pledgedSrcSize = opts?.pledgedSrcSize;
     const writeState = new Uint32Array(2);
-    handle.init(initParamsArray, pledgedSrcSize, writeState, processCallback,
-      opts?.dictionary && isArrayBufferView(opts.dictionary) ? opts.dictionary : undefined);
+    handle.init(initParamsArray, pledgedSrcSize, writeState, processCallback, dictionary);
 
     super(opts, mode, handle, zstdDefaultOpts);
     this._writeState = writeState;

package/node/src/host_brotli.c

@@ -1,4 +1,4 @@
-/* Host primitives for node:zlib's Brotli streams (ADR 0012): Node's binding (src/node_zlib.cc, its
+/* Host primitives for node:zlib's Brotli streams: Node's binding (src/node_zlib.cc, its
  * BrotliEncoderContext and BrotliDecoderContext) over Brotli 1.1.0, the copy Node vendors. As
  * host_zlib.c: a stream is a handle object, and a failure is [message, errno, code]. */
 #include <stdio.h>
@@ -9,7 +9,9 @@
 #include "brotli/encode.h"
 #include "js_buffer.h"
 #include "js_exception.h"
+#include "js_gc.h"
 #include "js_node.h"
+#include "js_web.h"
 #include "js_object.h"
 #include "js_ops.h"
 #include "jsstring.h"
@@ -31,13 +33,26 @@ typedef struct BrotliObject {
     bool                      encode_result;  /* the encoder's last result */
     BrotliDecoderResult       decode_result;
     BrotliDecoderErrorCode    error;
+    JSRuntime                *rt;             /* the allocator's */
+    uint8_t                  *dictionary;     /* malloc'd; NULL when none (it outlives what uses it) */
+    size_t                    dictionary_len;
+    BrotliEncoderPreparedDictionary *prepared;  /* the encoder's, from the dictionary */
 } BrotliObject;
 
+/* Brotli's memory is the heap's external memory. */
+static void *brotli_alloc(void *rt, size_t n) { return js_gc_external_malloc(rt, n); }
+static void brotli_free(void *rt, void *p) { js_gc_external_free(rt, p); }
+
 static void brotli_end(BrotliObject *b) {
     if (b->encoder) BrotliEncoderDestroyInstance(b->encoder);
     if (b->decoder) BrotliDecoderDestroyInstance(b->decoder);
+    if (b->prepared) BrotliEncoderDestroyPreparedDictionary(b->prepared);
+    free(b->dictionary);
     b->encoder = NULL;
     b->decoder = NULL;
+    b->prepared = NULL;
+    b->dictionary = NULL;
+    b->dictionary_len = 0;
 }
 
 static void brotli_finalize(JSRuntime *rt, JSCell *cell) {
@@ -59,12 +74,30 @@ static JSValue failure(JSContext *ctx, const char *message, int err, const char
     return a;
 }
 
-/* Init (and ResetStream, which is Init again: the parameters set before are gone, as in Node) */
-static bool brotli_init(BrotliObject *b) {
+/* Init (and ResetStream, which is Init again: the parameters and the dictionary set before are
+ * gone, as in Node), with a raw shared dictionary when one is given: NULL, or a failure's message
+ * (its code in *code) */
+static const char *brotli_init(BrotliObject *b, const uint8_t *dictionary, size_t dictionary_len, const char **code) {
     brotli_end(b);
-    if (b->mode == BROTLI_ENCODE) b->encoder = BrotliEncoderCreateInstance(NULL, NULL, NULL);
-    else b->decoder = BrotliDecoderCreateInstance(NULL, NULL, NULL);
-    return b->encoder || b->decoder;
+    *code = "ERR_ZLIB_INITIALIZATION_FAILED";
+    if (b->mode == BROTLI_ENCODE) b->encoder = BrotliEncoderCreateInstance(brotli_alloc, brotli_free, b->rt);
+    else b->decoder = BrotliDecoderCreateInstance(brotli_alloc, brotli_free, b->rt);
+    if (!b->encoder && !b->decoder) return "Could not initialize Brotli instance";
+    if (!dictionary_len) return NULL;
+    b->dictionary = malloc(dictionary_len);
+    if (!b->dictionary) js_fatal("out of memory in Brotli");
+    memcpy(b->dictionary, dictionary, dictionary_len);
+    b->dictionary_len = dictionary_len;
+    *code = "ERR_ZLIB_DICTIONARY_LOAD_FAILED";
+    if (b->encoder) {
+        b->prepared = BrotliEncoderPrepareDictionary(BROTLI_SHARED_DICTIONARY_RAW, dictionary_len, b->dictionary, BROTLI_MAX_QUALITY,
+                                                     brotli_alloc, brotli_free, b->rt);
+        if (!b->prepared) return "Failed to prepare brotli dictionary";
+        if (!BrotliEncoderAttachPreparedDictionary(b->encoder, b->prepared)) return "Failed to attach brotli dictionary";
+    } else if (!BrotliDecoderAttachDictionary(b->decoder, BROTLI_SHARED_DICTIONARY_RAW, dictionary_len, b->dictionary)) {
+        return "Failed to attach brotli dictionary";
+    }
+    return NULL;
 }
 
 /* brotliNew(mode) → handle */
@@ -74,6 +107,10 @@ PRIMITIVE(js_host_brotli_new) {
     b->mode = js_is_number(ARG(0)) && js_as_number(ARG(0)) == BROTLI_ENCODE ? BROTLI_ENCODE : BROTLI_DECODE;
     b->encoder = NULL;
     b->decoder = NULL;
+    b->rt = ctx->rt;
+    b->dictionary = NULL;
+    b->dictionary_len = 0;
+    b->prepared = NULL;
     b->flush = BROTLI_OPERATION_PROCESS;
     b->encode_result = false;
     b->decode_result = BROTLI_DECODER_RESULT_SUCCESS;
@@ -81,7 +118,8 @@ PRIMITIVE(js_host_brotli_new) {
     return js_object_value(&b->obj);
 }
 
-/* brotliInit(handle, params): params a Uint32Array, by parameter number, 0xffffffff unset →
+/* brotliInit(handle, params, dictionary | undefined): params a Uint32Array, by parameter number,
+ * 0xffffffff unset; the dictionary a raw shared one →
  * 0 | failure */
 PRIMITIVE(js_host_brotli_init) {
     UNUSED_PRIMITIVE_ARGS;
@@ -89,7 +127,12 @@ PRIMITIVE(js_host_brotli_init) {
     uint8_t *p;
     size_t n;
     if (!b || !js_buffer_source_bytes(ARG(1), &p, &n)) return js_throw_type_error(ctx, "brotliInit: a handle and parameters expected");
-    if (!brotli_init(b)) return failure(ctx, "Could not initialize Brotli instance", -1, "ERR_ZLIB_INITIALIZATION_FAILED");
+    uint8_t *dict = NULL;
+    size_t dict_len = 0;
+    if (!js_is_undefined(ARG(2))) js_buffer_source_bytes(ARG(2), &dict, &dict_len);
+    const char *code;
+    const char *message = brotli_init(b, dict, dict_len, &code);
+    if (message) return failure(ctx, message, -1, code);
     for (size_t i = 0; i < n / sizeof(uint32_t); i++) {
         uint32_t value;
         memcpy(&value, p + i * sizeof value, sizeof value);
@@ -113,8 +156,11 @@ PRIMITIVE(js_host_brotli_write) {
         return js_throw_type_error(ctx, "brotliWrite: a handle, buffers and a state expected");
     double in_off = in ? js_as_number(ARG(3)) : 0, in_len = in ? js_as_number(ARG(4)) : 0;
     double out_off = js_as_number(ARG(6)), out_len = js_as_number(ARG(7));
-    if (!(in_off >= 0 && in_len >= 0 && in_off + in_len <= (double)in_n && out_off >= 0 && out_len >= 0 && out_off + out_len <= (double)out_n))
-        return js_throw_range_error(ctx, "brotliWrite: out of bounds");
+    /* node_zlib.cc's checks */
+    if (!(in_off >= 0 && in_len >= 0 && in_off + in_len <= (double)in_n))
+        return js_throw_node_error(ctx, JS_RANGE_ERROR, "ERR_OUT_OF_RANGE", "input buffer is out of bounds");
+    if (!(out_off >= 0 && out_len >= 0 && out_off + out_len <= (double)out_n))
+        return js_throw_node_error(ctx, JS_RANGE_ERROR, "ERR_OUT_OF_RANGE", "output buffer is out of bounds");
     const uint8_t *next_in = in ? in + (size_t)in_off : NULL;
     uint8_t *next_out = out + (size_t)out_off;
     size_t avail_in = (size_t)in_len, avail_out = (size_t)out_len;
@@ -144,7 +190,9 @@ PRIMITIVE(js_host_brotli_reset) {
     UNUSED_PRIMITIVE_ARGS;
     BrotliObject *b = brotli_arg(ARG(0));
     if (!b) return js_throw_type_error(ctx, "brotliReset: a handle expected");
-    if (!brotli_init(b)) return failure(ctx, "Could not initialize Brotli instance", -1, "ERR_ZLIB_INITIALIZATION_FAILED");
+    const char *code;
+    const char *message = brotli_init(b, NULL, 0, &code);
+    if (message) return failure(ctx, message, -1, code);
     return js_int32(0);
 }