@tlockney/cdp-kernel 0.2.0 → 0.4.0

package/runtime/introspect.mjs

@@ -0,0 +1,120 @@
+// What inspect_request (#10) shows for a value: the text of a JupyterLab
+// tooltip (Shift-Tab) or inspector panel. Shared by every target; the host
+// decides how the value is found (src/target.ts: CDP's throwOnSideEffect;
+// in-process targets: resolvePath, below).
+//
+// No imports: this file must load in every target. `inspect` (util.inspect
+// or Deno.inspect) is passed in.
+
+const PREVIEW_CHARS = 1500;
+const SOURCE_CHARS = 4000;
+const MAX_PROPERTIES = 40;
+
+const IDENTIFIER_PATH = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/;
+
+/**
+ * Looks up a dotted path such as "a.b.c" from globalThis, by property
+ * descriptor, so nothing runs: a getter along the way is reported rather
+ * than called. In-process targets (Bun, workerd, celld) have no way to
+ * evaluate without side effects, so inspection and completion use this.
+ */
+export function resolvePath(path, root = globalThis) {
+  if (!IDENTIFIER_PATH.test(path)) return { found: false };
+  let value = root;
+  for (const name of path.split(".")) {
+    if (value === null || value === undefined) return { found: false };
+    let descriptor;
+    for (let o = Object(value); o !== null && descriptor === undefined; o = Object.getPrototypeOf(o)) {
+      descriptor = Object.getOwnPropertyDescriptor(o, name);
+    }
+    if (descriptor === undefined) return { found: false };
+    if (!("value" in descriptor)) return { found: true, accessor: true, name };
+    value = descriptor.value;
+  }
+  return { found: true, value };
+}
+
+function truncate(text, limit) {
+  return text.length > limit ? `${text.slice(0, limit)}… (${text.length - limit} more characters)` : text;
+}
+
+/** "function add(a, b) {...}" -> "add(a, b)"; "class K {...}" -> "class K". */
+export function signatureOf(fn) {
+  let source;
+  try {
+    source = Function.prototype.toString.call(fn);
+  } catch {
+    return `${fn.name || "anonymous"}(…)`;
+  }
+  if (/^class\b/.test(source)) return `class ${fn.name || "(anonymous)"}`;
+  const params = /^[^(]*\(([^)]*)\)/.exec(source)?.[1];
+  const native = /\{\s*\[native code\]\s*\}$/.test(source);
+  // One line, however the parameters were spread over the source.
+  const written = (params ?? "").replace(/\s+/g, " ").replace(/\s*,\s*/g, ", ").trim();
+  const args = native ? Array.from({ length: fn.length }, (_, i) => `arg${i}`).join(", ") : written;
+  const arrow = !/^(?:async\s+)?function\b/.test(source) && /=>/.test(source.split("{")[0] ?? "");
+  const name = fn.name || (arrow ? "(arrow function)" : "anonymous");
+  const prefix = /^async\b/.test(source) ? "async " : "";
+  return `${prefix}${name}(${args})`;
+}
+
+function typeOf(value) {
+  if (value === null) return "null";
+  if (typeof value !== "object" && typeof value !== "function") return typeof value;
+  const name = Object.getPrototypeOf(value)?.constructor?.name;
+  if (typeof value === "function") return /^class\b/.test(safeSource(value)) ? "class" : "function";
+  return name && name !== "Object" ? `object (${name})` : "object";
+}
+
+function safeSource(fn) {
+  try {
+    return Function.prototype.toString.call(fn);
+  } catch {
+    return "";
+  }
+}
+
+function propertyNames(value) {
+  if ((typeof value !== "object" && typeof value !== "function") || value === null) return [];
+  try {
+    // A function's own internals aren't worth listing; older V8 (Node 24)
+    // also gives sloppy-mode functions own `arguments` and `caller`.
+    const internal = ["length", "name", "prototype", "arguments", "caller"];
+    return Object.getOwnPropertyNames(value).filter((n) => !(typeof value === "function" && internal.includes(n)));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * The tooltip text for a value. `detail` 1 (Shift-Tab twice, or the
+ * inspector panel) adds a function's source.
+ */
+export function describeValue(value, { inspect, detail = 0 }) {
+  const lines = [`Type: ${typeOf(value)}`];
+  if (typeof value === "function") lines.push(`Signature: ${signatureOf(value)}`);
+  let preview;
+  try {
+    preview = inspect(value);
+  } catch (err) {
+    preview = `(inspect failed: ${err instanceof Error ? err.message : String(err)})`;
+  }
+  lines.push(`Value: ${truncate(preview, PREVIEW_CHARS)}`);
+  const names = propertyNames(value);
+  if (names.length > 0) {
+    const shown = names.slice(0, MAX_PROPERTIES).join(", ");
+    lines.push(`Properties: ${shown}${names.length > MAX_PROPERTIES ? `, … (${names.length - MAX_PROPERTIES} more)` : ""}`);
+  }
+  if (detail > 0 && typeof value === "function") lines.push(`Source:\n${truncate(safeSource(value), SOURCE_CHARS)}`);
+  return lines.join("\n");
+}
+
+/** inspect_request for in-process targets: resolvePath, then describeValue. */
+export function inspectPath(path, { inspect, detail = 0, root = globalThis }) {
+  const resolved = resolvePath(path, root);
+  if (!resolved.found) return null;
+  if (resolved.accessor) {
+    return `Type: accessor property\n${resolved.name} has a getter, which isn't called for inspection: it could have side effects.`;
+  }
+  return describeValue(resolved.value, { inspect, detail });
+}

package/runtime/node-hooks.d.mts

@@ -7,4 +7,33 @@ export interface PackageSpecifier {
 export function parsePackageSpecifier(spec: string): PackageSpecifier;
 export function jsrToNpm(spec: string): PackageSpecifier;
 export function aliasFor(name: string, range: string): string;
+export type Installer = "npm" | "bun";
+export function installCommand(
+  installer: Installer,
+  alias: string,
+  name: string,
+  range: string,
+): { cmd: string; args: string[]; env?: { [name: string]: string } };
+/** Runs an install; `env` is added to the process environment. */
+export type InstallRunner = (
+  cmd: string,
+  args: string[],
+  cwd: string,
+  env?: { [name: string]: string },
+) => { status: number | null; stderr?: string; error?: Error };
+export function ensureInstalled(
+  pkg: { name: string; range: string },
+  installer?: Installer,
+  options?: { lockFile?: string | null; run?: InstallRunner },
+): { dir: string; alias: string };
+
+export const LOCK_FILE: string;
+export interface Lock {
+  version: 1;
+  packages: { [nameAtRange: string]: string };
+}
+export function findLockFile(dir: string): string | null;
+export function readLock(path: string): Lock;
+export function writeLock(path: string, lock: Lock): void;
+export function withInstallLock<T>(dir: string, fn: () => T, options?: { timeoutMs?: number }): T;
 export function installNodeResolveHooks(urls: { shimUrl: string; replUrl: string }): void;

package/runtime/node-hooks.mjs

@@ -1,3 +1,4 @@
+// @ts-self-types="./node-hooks.d.mts"
 // Node-only module resolution for cell code: the part of Deno's module
 // loader a notebook leans on most.
 //   - Imports issued by cell code arrive with the bootstrap module as their
@@ -11,13 +12,15 @@
 // Uses module.registerHooks (synchronous, in-thread; Node >= 23.5), so the
 // install can run with spawnSync inside resolve.
 
-import { registerHooks } from "node:module";
+// Not a named import: Bun, which loads this file for its npm:/jsr: helpers,
+// has no registerHooks, and a missing named export fails at link time.
+import module from "node:module";
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
-import { pathToFileURL } from "node:url";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 const SPEC_RE = /^((?:@[^/@]+\/)?[^/@]+)(?:@([^/]+))?(\/.*)?$/;
 
@@ -41,8 +44,12 @@ export function aliasFor(name, range) {
   return `cdpk-${digest}`;
 }
 
-function cacheDir() {
-  const dir = process.env.CDPK_CACHE_DIR ?? join(homedir(), ".cache", "cdp-kernel", "npm");
+// Each installer keeps its own cache, so npm's and Bun's lockfiles never
+// meet; both read the @jsr registry from .npmrc.
+function cacheDir(installer) {
+  const dir = installer === "npm"
+    ? process.env.CDPK_CACHE_DIR ?? join(homedir(), ".cache", "cdp-kernel", "npm")
+    : join(homedir(), ".cache", "cdp-kernel", installer);
   if (!existsSync(join(dir, "package.json"))) {
     mkdirSync(dir, { recursive: true });
     writeFileSync(join(dir, "package.json"), '{ "private": true }\n');
@@ -51,30 +58,163 @@ function cacheDir() {
   return dir;
 }
 
-function ensureInstalled({ name, range }) {
-  const dir = cacheDir();
-  const alias = aliasFor(name, range);
-  if (!existsSync(join(dir, "node_modules", alias, "package.json"))) {
-    const result = spawnSync(
-      "npm",
-      ["install", "--no-audit", "--no-fund", "--loglevel=error", `${alias}@npm:${name}@${range}`],
-      { cwd: dir, encoding: "utf8" },
-    );
-    if (result.status !== 0) {
-      throw new Error(`npm install ${name}@${range} failed:\n${result.stderr || result.error}`);
+/** The command that installs name@range under `alias` with `installer`. */
+//   - Saved exactly (#40): npm records `npm:react@19.0.0` as `^19.0.0` by
+//     default, and every later install into the shared cache re-resolves the
+//     ranges, so pinned packages drifted (react 19.3.1 beside react-dom
+//     19.0.0). With an exact save, a version stays put and a range is frozen
+//     at what it first resolved to. Bun already saves exactly; the flag says so.
+//   - JSR packages come as tarballs from npm.jsr.io, which npm 12 refuses as
+//     "remote" unless allowed (#39). `root` is the narrowest value that works
+//     (`true`, which looks right, is invalid and warns), and only the JSR
+//     install gets it.
+export function installCommand(installer, alias, name, range) {
+  const spec = `${alias}@npm:${name}@${range}`;
+  // The Bun target runs this inside Bun, so it uses its own binary.
+  if (installer === "bun") return { cmd: process.execPath, args: ["add", "--silent", "--exact", spec] };
+  const args = ["install", "--no-audit", "--no-fund", "--loglevel=error", "--save-exact", spec];
+  return name.startsWith("@jsr/") ? { cmd: "npm", args, env: { npm_config_allow_remote: "root" } } : { cmd: "npm", args };
+}
+
+// --- Lockfile (#14) -----------------------------------------------------------
+// A cdp-kernel.lock.json at or above the notebook pins each npm:/jsr:
+// request to the exact version it first resolved to, so the same notebook
+// gets the same packages on another machine. Opt-in: create the file (with
+// `{}` in it) to start locking; the kernel then fills it in.
+
+export const LOCK_FILE = "cdp-kernel.lock.json";
+
+/** The nearest cdp-kernel.lock.json at or above `dir`, or null. */
+export function findLockFile(dir) {
+  for (let at = dir;; at = dirname(at)) {
+    if (existsSync(join(at, LOCK_FILE))) return join(at, LOCK_FILE);
+    if (dirname(at) === at) return null;
+  }
+}
+
+/** `{ version: 1, packages: { "name@range": "exact version" } }`; `{}` counts as empty. */
+export function readLock(path) {
+  const parsed = JSON.parse(readFileSync(path, "utf8") || "{}");
+  const packages = parsed && typeof parsed.packages === "object" && parsed.packages !== null ? parsed.packages : {};
+  return { version: 1, packages };
+}
+
+/** Sorted, so a lockfile's diff shows only what changed. */
+export function writeLock(path, lock) {
+  const packages = Object.fromEntries(Object.entries(lock.packages).sort(([a], [b]) => a.localeCompare(b)));
+  writeFileSync(path, JSON.stringify({ version: 1, packages }, null, 2) + "\n");
+}
+
+// --- Serialized installs (#14) -------------------------------------------------
+// Kernels share one cache per installer, and npm/bun both rewrite its
+// package.json and node_modules, so installs take a lock: a directory, which
+// mkdir creates atomically. A lock left by a process that died is taken over.
+
+const LOCK_DIR = ".install-lock";
+const STALE_MS = 10 * 60 * 1000;
+
+function sleep(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function holderAlive(lockDir) {
+  try {
+    const pid = Number(readFileSync(join(lockDir, "pid"), "utf8"));
+    if (!Number.isInteger(pid) || pid <= 0) return false;
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    // EPERM: alive, but someone else's.
+    return err?.code === "EPERM";
+  }
+}
+
+/** Runs `fn` holding the cache's install lock. Synchronous, like the resolve hook. */
+export function withInstallLock(dir, fn, { timeoutMs = STALE_MS } = {}) {
+  const lockDir = join(dir, LOCK_DIR);
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    try {
+      mkdirSync(lockDir);
+      writeFileSync(join(lockDir, "pid"), String(process.pid));
+      break;
+    } catch (err) {
+      if (err?.code !== "EEXIST") throw err;
+      let age = 0;
+      try {
+        age = Date.now() - statSync(lockDir).mtimeMs;
+      } catch {
+        continue; // released meanwhile
+      }
+      // A holder that died, or one stuck for longer than any install takes.
+      if ((age > 1000 && !holderAlive(lockDir)) || age > STALE_MS) {
+        rmSync(lockDir, { recursive: true, force: true });
+        continue;
+      }
+      if (Date.now() > deadline) throw new Error(`timed out waiting for the install lock ${lockDir}`);
+      sleep(100);
     }
   }
-  return { dir, alias };
+  try {
+    return fn();
+  } finally {
+    rmSync(lockDir, { recursive: true, force: true });
+  }
+}
+
+function installedVersion(dir, alias) {
+  try {
+    return JSON.parse(readFileSync(join(dir, "node_modules", alias, "package.json"), "utf8")).version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function spawnInstall(cmd, args, cwd, env = {}) {
+  return spawnSync(cmd, args, { cwd, encoding: "utf8", env: { ...process.env, ...env } });
+}
+
+/**
+ * Installs a package into the installer's cache unless it's there already.
+ * With a lockfile, a locked request installs its exact version, and an
+ * unlocked one is recorded once installed. `run` is the install command
+ * runner, replaceable in tests.
+ */
+export function ensureInstalled({ name, range }, installer = "npm", { lockFile = null, run = spawnInstall } = {}) {
+  const dir = cacheDir(installer);
+  const key = `${name}@${range}`;
+  return withInstallLock(dir, () => {
+    const lock = lockFile ? readLock(lockFile) : null;
+    const locked = lock?.packages[key];
+    const version = typeof locked === "string" ? locked : range;
+    const alias = aliasFor(name, version);
+    if (installedVersion(dir, alias) === null) {
+      const { cmd, args, env } = installCommand(installer, alias, name, version);
+      const result = run(cmd, args, dir, env);
+      if (result.status !== 0) {
+        throw new Error(`${installer} install ${name}@${version} failed:\n${result.stderr || result.error}`);
+      }
+    }
+    if (lock && typeof locked !== "string") {
+      const resolved = installedVersion(dir, alias);
+      if (resolved !== null) {
+        lock.packages[key] = resolved;
+        writeLock(lockFile, lock);
+      }
+    }
+    return { dir, alias };
+  });
 }
 
 export function installNodeResolveHooks({ shimUrl, replUrl }) {
-  registerHooks({
+  module.registerHooks({
     resolve(specifier, context, nextResolve) {
       let pkg = null;
       if (specifier.startsWith("npm:")) pkg = parsePackageSpecifier(specifier.slice(4));
       else if (specifier.startsWith("jsr:")) pkg = jsrToNpm(specifier.slice(4));
       if (pkg) {
-        const { dir, alias } = ensureInstalled(pkg);
+        const lockFile = findLockFile(fileURLToPath(new URL(".", replUrl)));
+        const { dir, alias } = ensureInstalled(pkg, "npm", { lockFile });
         const parentURL = pathToFileURL(join(dir, "package.json")).href;
         return nextResolve(alias + pkg.subpath, { ...context, parentURL });
       }

package/runtime/workerd-worker.mjs

@@ -0,0 +1,194 @@
+// The driver Worker for the workerd target (#8).
+//
+// workerd's inspector can evaluate code, but outside a request there is no
+// IoContext: timers, fetch and crypto.randomUUID throw "Disallowed operation
+// called within global scope". So the host opens one WebSocket session to
+// this Worker (over a Unix socket only it can reach, or through a project's
+// Miniflare) and every request runs inside that session's request. The cell
+// code itself comes from transformCellForEval and is run by the UnsafeEval
+// binding as global code, so its declarations persist (see evaluator.mjs).
+//
+// Console output, iopub messages and replies all go back over the one
+// socket, in order, so no barrier markers are needed.
+//
+// workerd can't load modules at runtime beyond its builtins, so the host
+// bundles anything else a cell imports (src/workerd-target.ts) and sends it
+// with the cell.
+
+import { formatWithOptions, inspect } from "node:util";
+import { createJupyter } from "./display.mjs";
+import { createHandler } from "./evaluator.mjs";
+import { describeValue, inspectPath, resolvePath } from "./introspect.mjs";
+
+const BUILTIN = /^(?:node|cloudflare|workerd):/;
+
+function base64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 0x8000) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+  }
+  return btoa(binary);
+}
+
+// --- Output -----------------------------------------------------------------
+// Lines go to the host's session. Anything emitted before it connects waits.
+let sink = null;
+const outbox = [];
+
+function emit(message) {
+  const line = JSON.stringify(message);
+  if (sink) sink(line);
+  else outbox.push(line);
+}
+
+const stream = (name) => (...args) => emit({ kind: "stream", name, text: formatWithOptions({ colors: true }, ...args) + "\n" });
+Object.assign(console, {
+  log: stream("stdout"),
+  info: stream("stdout"),
+  debug: stream("stdout"),
+  dir: (value) => emit({ kind: "stream", name: "stdout", text: inspect(value, { colors: true, depth: 4 }) + "\n" }),
+  warn: stream("stderr"),
+  error: stream("stderr"),
+});
+
+const jupyter = createJupyter({
+  inspect: (value) => inspect(value, { colors: true, depth: 4 }),
+  base64,
+  readFile() {
+    throw new Error("workerd has no file system to read from; pass the image bytes instead");
+  },
+  send(msgType, content, metadata, buffers) {
+    emit({ kind: "iopub", msg_type: msgType, content, metadata, buffers: buffers.map(base64), barrier: 0 });
+  },
+  // A request can't block for an answer, so prompt() and confirm() behave
+  // as when the frontend has no stdin.
+  input: () => null,
+});
+
+// --- Modules ----------------------------------------------------------------
+const modules = new Map();
+
+/** `require` for a host-built bundle's external imports (builtins). */
+async function requireFor(specifiers) {
+  const loaded = new Map();
+  for (const specifier of specifiers) {
+    // Packages require Node builtins by bare name too ("fs").
+    const ns = await import(BUILTIN.test(specifier) ? specifier : `node:${specifier}`);
+    loaded.set(specifier, ns.default ?? ns);
+  }
+  return (specifier) => {
+    if (!loaded.has(specifier)) throw new Error(`cannot require ${specifier} in workerd`);
+    return loaded.get(specifier);
+  };
+}
+
+function cellImport(specifier, options) {
+  if (BUILTIN.test(specifier)) return import(specifier, options);
+  if (modules.has(specifier)) return modules.get(specifier);
+  return Promise.reject(new TypeError(`Cannot import "${specifier}": the host didn't bundle it`));
+}
+
+// --- The shim cells and the evaluator use -----------------------------------
+let handle = null;
+
+function install(env) {
+  const meta = JSON.parse(env.META);
+  globalThis.__cdpk = {
+    import: cellImport,
+    meta: { ...meta, resolve: (specifier) => new URL(specifier, meta.url).href },
+    requireFor,
+    // inspect_request (#10): by descriptor, so nothing runs.
+    describeForInspect: (value, detail) => describeValue(value, { inspect: (v) => inspect(v, { colors: false, depth: 2 }), detail }),
+    inspectPath: (path, detail) => inspectPath(path, { inspect: (v) => inspect(v, { colors: false, depth: 2 }), detail }),
+    resolvePath,
+    barrier: () => 0,
+    broadcastResult: jupyter.broadcastResult,
+    async commDispatch(msgType, content, metadata, buffers64) {
+      const buffers = buffers64.map((b) => Uint8Array.from(atob(b), (c) => c.charCodeAt(0)));
+      return await jupyter.commDispatch(msgType, content, metadata, buffers);
+    },
+    describeError(value) {
+      if (value instanceof Error) {
+        return JSON.stringify({ name: value.name, message: value.message, stack: value.stack ?? "" });
+      }
+      return JSON.stringify({ name: "Error", message: inspect(value), stack: "" });
+    },
+  };
+  Object.defineProperty(globalThis, "__cdpk", { enumerable: false });
+  globalThis.jupyter = jupyter.namespace;
+  globalThis.prompt = jupyter.prompt;
+  globalThis.confirm = jupyter.confirm;
+  // A cell has no fetch(request, env), so the Worker's bindings (#26) are a
+  // global, without the kernel's own.
+  const { UNSAFE, TOKEN, META, ...bindings } = env;
+  globalThis.env = bindings;
+  // workerd forbids eval without its UnsafeEval binding; celld (#25) allows
+  // a plain global eval and has no such binding.
+  const evaluate = env.UNSAFE ? (code) => env.UNSAFE.eval(code, "cell") : (code) => (0, eval)(code);
+  handle = createHandler(globalThis.__cdpk, evaluate);
+  return evaluate;
+}
+
+let evaluate = null;
+
+/** Evaluates the bundles a cell brings, once each. */
+async function loadModules(bundles = {}) {
+  for (const [specifier, script] of Object.entries(bundles)) {
+    if (modules.has(specifier)) continue;
+    const loading = Promise.resolve().then(() => evaluate(script));
+    // A module that failed to load is retried by the next import of it.
+    loading.catch(() => modules.delete(specifier));
+    modules.set(specifier, loading);
+  }
+}
+
+async function answer(req) {
+  if (req.op === "info") {
+    return {
+      v8: globalThis.process?.versions?.v8 ?? "",
+      bindings: Object.keys(globalThis.env),
+      // A Workers project's default export (src/workers-project.ts).
+      worker: globalThis.worker !== undefined,
+    };
+  }
+  if (req.op === "eval") await loadModules(req.modules);
+  return await handle(req);
+}
+
+export default {
+  async fetch(request, env) {
+    // A header, or the query string for a WebSocket client that can't set
+    // headers (celld's session uses the host's built-in WebSocket).
+    const token = request.headers.get("x-cdpk-token") ?? new URL(request.url).searchParams.get("token");
+    if (token !== env.TOKEN) return new Response("forbidden", { status: 403 });
+    if (request.headers.get("upgrade") !== "websocket") return new Response("expected a WebSocket", { status: 426 });
+    evaluate ??= install(env);
+
+    // The session: every request from the host arrives as a message, and
+    // all of them run in this one request's IoContext. So I/O objects (a
+    // Durable Object stub, a stream) made in one cell work in the next, and
+    // work a cell leaves running outlives it (#26).
+    const { 0: client, 1: server } = new WebSocketPair();
+    server.accept();
+    const send = (line) => {
+      try {
+        server.send(line);
+      } catch {
+        // The host is gone.
+      }
+    };
+    sink = send;
+    for (const line of outbox.splice(0)) send(line);
+    server.addEventListener("message", (event) => {
+      const req = JSON.parse(event.data);
+      answer(req).then(
+        (reply) => send(JSON.stringify({ kind: "reply", id: req.id, ...reply })),
+        (err) => send(JSON.stringify({ kind: "reply", id: req.id, failure: String(err?.stack ?? err) })),
+      );
+    });
+    server.addEventListener("close", () => {
+      if (sink === send) sink = null;
+    });
+    return new Response(null, { status: 101, webSocket: client });
+  },
+};