@crvouga/mockingbird-service-redis 0.1.0

package/dist/chunk-7U5RQF7K.js

@@ -0,0 +1,144 @@
+import {
+  RedisConnectionError,
+  RespParser,
+  asCommand,
+  createRedis,
+  encodeReply
+} from "./chunk-4HDEOTYJ.js";
+
+// src/server.ts
+import { createServer } from "node:net";
+var DEFAULT_PORT = 8827;
+function serve(redis, options = {}) {
+  const host = options.host ?? "127.0.0.1";
+  const port = options.port ?? 6379;
+  const sockets = /* @__PURE__ */ new Set();
+  const server = createServer({ keepAlive: true }, (socket) => {
+    sockets.add(socket);
+    attach(redis, socket, () => sockets.delete(socket));
+  });
+  return new Promise((resolve, reject) => {
+    const fail = (error) => reject(error);
+    server.once("error", fail);
+    server.listen(port, host, () => {
+      server.off("error", fail);
+      const address = server.address();
+      const actual = address && typeof address === "object" ? address.port : port;
+      resolve({
+        host,
+        port: actual,
+        close: () => shutdown(server, sockets, redis)
+      });
+    });
+  });
+}
+function attach(redis, socket, onGone) {
+  const session = redis.createSession();
+  const parser = new RespParser();
+  const pending = [];
+  let pumping = false;
+  const write = (reply) => {
+    if (!socket.destroyed) socket.write(encodeReply(reply, session.protocol));
+  };
+  session.onPush = write;
+  const stop = redis.onDisconnect((dropped) => {
+    if (dropped === session) socket.destroy();
+  });
+  const finish = () => {
+    session.dead = true;
+    stop();
+    onGone();
+  };
+  socket.on("data", (chunk) => {
+    for (const reply of parser.push(chunk)) {
+      const command = asCommand(reply);
+      if ("t" in command) {
+        write(command);
+        continue;
+      }
+      pending.push(command);
+    }
+    void pump();
+  });
+  const pump = async () => {
+    if (pumping) return;
+    pumping = true;
+    try {
+      while (pending.length > 0) {
+        const command = pending.shift();
+        if (!command) break;
+        try {
+          const reply = await redis.perform(session, command.name, command.args);
+          write(reply);
+          if (session.quit) {
+            socket.end();
+            break;
+          }
+        } catch (error) {
+          if (error instanceof RedisConnectionError) {
+            socket.destroy();
+            break;
+          }
+          socket.destroy();
+          break;
+        }
+      }
+    } finally {
+      pumping = false;
+      if (pending.length > 0 && !socket.destroyed) void pump();
+    }
+  };
+  socket.on("close", finish);
+  socket.on("error", finish);
+}
+function shutdown(server, sockets, redis) {
+  redis.close();
+  for (const socket of sockets) socket.destroy();
+  return new Promise((resolve) => {
+    server.close(() => resolve());
+  });
+}
+var attachClose;
+var isHealth = (pathname) => {
+  const path = pathname.replace(/\/+$/, "") || "/";
+  return path === "/health" || /^\/ns\/[^/]+\/health$/.test(path);
+};
+var serveTarget = {
+  name: "redis",
+  defaultPort: DEFAULT_PORT,
+  async create() {
+    const redis = createRedis();
+    const tcp = await serve(redis, { host: "127.0.0.1", port: 0 });
+    const runtime = {
+      respPort: tcp.port,
+      close: () => tcp.close(),
+      fetch: async (request) => {
+        if (isHealth(new URL(request.url).pathname)) {
+          return Response.json({ status: "ok", service: "redis" });
+        }
+        return new Response("not found", { status: 404 });
+      }
+    };
+    attachClose = (http) => {
+      const closeHttp = http.close.bind(http);
+      http.close = async () => {
+        await runtime.close();
+        await closeHttp();
+      };
+    };
+    return runtime;
+  },
+  listening(http) {
+    attachClose?.(http);
+  },
+  banner(runtime) {
+    return [`resp: redis://127.0.0.1:${runtime.respPort}`];
+  }
+};
+
+export {
+  DEFAULT_PORT,
+  serve,
+  serveTarget
+};
+//# sourceMappingURL=chunk-7U5RQF7K.js.map

package/dist/chunk-7U5RQF7K.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/server.ts"],
+  "sourcesContent": ["import { createServer, type Server, type Socket } from \"node:net\"\nimport { createRedis, type Redis, RedisConnectionError } from \"./engine.ts\"\nimport { asCommand, encodeReply, type Reply, RespParser } from \"./protocol.ts\"\n\n/** HTTP port for `serve --config`. The RESP socket binds an ephemeral port. */\nexport const DEFAULT_PORT = 8827\n\nexport interface ServeOptions {\n  port?: number\n  host?: string\n}\n\nexport interface RedisListening {\n  host: string\n  port: number\n  close(): Promise<void>\n}\n\nexport function serve(redis: Redis, options: ServeOptions = {}): Promise<RedisListening> {\n  const host = options.host ?? \"127.0.0.1\"\n  const port = options.port ?? 6379\n  const sockets = new Set<Socket>()\n  const server = createServer({ keepAlive: true }, (socket) => {\n    sockets.add(socket)\n    attach(redis, socket, () => sockets.delete(socket))\n  })\n  return new Promise((resolve, reject) => {\n    const fail = (error: Error) => reject(error)\n    server.once(\"error\", fail)\n    server.listen(port, host, () => {\n      server.off(\"error\", fail)\n      const address = server.address()\n      const actual = address && typeof address === \"object\" ? address.port : port\n      resolve({\n        host,\n        port: actual,\n        close: () => shutdown(server, sockets, redis),\n      })\n    })\n  })\n}\n\nfunction attach(redis: Redis, socket: Socket, onGone: () => void): void {\n  const session = redis.createSession()\n  const parser = new RespParser()\n  const pending: Array<{ name: string; args: Uint8Array[] }> = []\n  let pumping = false\n  const write = (reply: Reply) => {\n    if (!socket.destroyed) socket.write(encodeReply(reply, session.protocol))\n  }\n  session.onPush = write\n  const stop = redis.onDisconnect((dropped) => {\n    if (dropped === session) socket.destroy()\n  })\n  const finish = () => {\n    session.dead = true\n    stop()\n    onGone()\n  }\n  socket.on(\"data\", (chunk: Uint8Array) => {\n    for (const reply of parser.push(chunk)) {\n      const command = asCommand(reply)\n      if (\"t\" in command) {\n        write(command)\n        continue\n      }\n      pending.push(command)\n    }\n    void pump()\n  })\n  const pump = async () => {\n    if (pumping) return\n    pumping = true\n    try {\n      while (pending.length > 0) {\n        const command = pending.shift()\n        if (!command) break\n        try {\n          const reply = await redis.perform(session, command.name, command.args)\n          write(reply)\n          if (session.quit) {\n            socket.end()\n            break\n          }\n        } catch (error) {\n          if (error instanceof RedisConnectionError) {\n            socket.destroy()\n            break\n          }\n          socket.destroy()\n          break\n        }\n      }\n    } finally {\n      pumping = false\n      if (pending.length > 0 && !socket.destroyed) void pump()\n    }\n  }\n  socket.on(\"close\", finish)\n  socket.on(\"error\", finish)\n}\n\nfunction shutdown(server: Server, sockets: Set<Socket>, redis: Redis): Promise<void> {\n  redis.close()\n  for (const socket of sockets) socket.destroy()\n  return new Promise((resolve) => {\n    server.close(() => resolve())\n  })\n}\n\ntype FleetRuntime = {\n  fetch(request: Request): Promise<Response>\n  respPort: number\n  close(): Promise<void>\n}\n\ntype HttpListening = {\n  close(): Promise<void>\n}\n\nlet attachClose: ((http: HttpListening) => void) | undefined\n\nconst isHealth = (pathname: string): boolean => {\n  const path = pathname.replace(/\\/+$/, \"\") || \"/\"\n  return path === \"/health\" || /^\\/ns\\/[^/]+\\/health$/.test(path)\n}\n\n/**\n * Fleet entry for `serve --config`. HTTP `GET /health` reports `service: redis`.\n * RESP listens on an ephemeral port named in the startup banner.\n */\nexport const serveTarget = {\n  name: \"redis\",\n  defaultPort: DEFAULT_PORT,\n  async create(): Promise<FleetRuntime> {\n    const redis = createRedis()\n    const tcp = await serve(redis, { host: \"127.0.0.1\", port: 0 })\n    const runtime: FleetRuntime = {\n      respPort: tcp.port,\n      close: () => tcp.close(),\n      fetch: async (request: Request) => {\n        if (isHealth(new URL(request.url).pathname)) {\n          return Response.json({ status: \"ok\", service: \"redis\" })\n        }\n        return new Response(\"not found\", { status: 404 })\n      },\n    }\n    attachClose = (http) => {\n      const closeHttp = http.close.bind(http)\n      http.close = async () => {\n        await runtime.close()\n        await closeHttp()\n      }\n    }\n    return runtime\n  },\n  listening(http: HttpListening) {\n    attachClose?.(http)\n  },\n  banner(runtime: FleetRuntime) {\n    return [`resp: redis://127.0.0.1:${runtime.respPort}`]\n  },\n}\n"],
+  "mappings": ";;;;;;;;;AAAA,SAAS,oBAA8C;AAKhD,IAAM,eAAe;AAarB,SAAS,MAAM,OAAc,UAAwB,CAAC,GAA4B;AACvF,QAAM,OAAO,QAAQ,QAAQ;AAC7B,QAAM,OAAO,QAAQ,QAAQ;AAC7B,QAAM,UAAU,oBAAI,IAAY;AAChC,QAAM,SAAS,aAAa,EAAE,WAAW,KAAK,GAAG,CAAC,WAAW;AAC3D,YAAQ,IAAI,MAAM;AAClB,WAAO,OAAO,QAAQ,MAAM,QAAQ,OAAO,MAAM,CAAC;AAAA,EACpD,CAAC;AACD,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,UAAM,OAAO,CAAC,UAAiB,OAAO,KAAK;AAC3C,WAAO,KAAK,SAAS,IAAI;AACzB,WAAO,OAAO,MAAM,MAAM,MAAM;AAC9B,aAAO,IAAI,SAAS,IAAI;AACxB,YAAM,UAAU,OAAO,QAAQ;AAC/B,YAAM,SAAS,WAAW,OAAO,YAAY,WAAW,QAAQ,OAAO;AACvE,cAAQ;AAAA,QACN;AAAA,QACA,MAAM;AAAA,QACN,OAAO,MAAM,SAAS,QAAQ,SAAS,KAAK;AAAA,MAC9C,CAAC;AAAA,IACH,CAAC;AAAA,EACH,CAAC;AACH;AAEA,SAAS,OAAO,OAAc,QAAgB,QAA0B;AACtE,QAAM,UAAU,MAAM,cAAc;AACpC,QAAM,SAAS,IAAI,WAAW;AAC9B,QAAM,UAAuD,CAAC;AAC9D,MAAI,UAAU;AACd,QAAM,QAAQ,CAAC,UAAiB;AAC9B,QAAI,CAAC,OAAO,UAAW,QAAO,MAAM,YAAY,OAAO,QAAQ,QAAQ,CAAC;AAAA,EAC1E;AACA,UAAQ,SAAS;AACjB,QAAM,OAAO,MAAM,aAAa,CAAC,YAAY;AAC3C,QAAI,YAAY,QAAS,QAAO,QAAQ;AAAA,EAC1C,CAAC;AACD,QAAM,SAAS,MAAM;AACnB,YAAQ,OAAO;AACf,SAAK;AACL,WAAO;AAAA,EACT;AACA,SAAO,GAAG,QAAQ,CAAC,UAAsB;AACvC,eAAW,SAAS,OAAO,KAAK,KAAK,GAAG;AACtC,YAAM,UAAU,UAAU,KAAK;AAC/B,UAAI,OAAO,SAAS;AAClB,cAAM,OAAO;AACb;AAAA,MACF;AACA,cAAQ,KAAK,OAAO;AAAA,IACtB;AACA,SAAK,KAAK;AAAA,EACZ,CAAC;AACD,QAAM,OAAO,YAAY;AACvB,QAAI,QAAS;AACb,cAAU;AACV,QAAI;AACF,aAAO,QAAQ,SAAS,GAAG;AACzB,cAAM,UAAU,QAAQ,MAAM;AAC9B,YAAI,CAAC,QAAS;AACd,YAAI;AACF,gBAAM,QAAQ,MAAM,MAAM,QAAQ,SAAS,QAAQ,MAAM,QAAQ,IAAI;AACrE,gBAAM,KAAK;AACX,cAAI,QAAQ,MAAM;AAChB,mBAAO,IAAI;AACX;AAAA,UACF;AAAA,QACF,SAAS,OAAO;AACd,cAAI,iBAAiB,sBAAsB;AACzC,mBAAO,QAAQ;AACf;AAAA,UACF;AACA,iBAAO,QAAQ;AACf;AAAA,QACF;AAAA,MACF;AAAA,IACF,UAAE;AACA,gBAAU;AACV,UAAI,QAAQ,SAAS,KAAK,CAAC,OAAO,UAAW,MAAK,KAAK;AAAA,IACzD;AAAA,EACF;AACA,SAAO,GAAG,SAAS,MAAM;AACzB,SAAO,GAAG,SAAS,MAAM;AAC3B;AAEA,SAAS,SAAS,QAAgB,SAAsB,OAA6B;AACnF,QAAM,MAAM;AACZ,aAAW,UAAU,QAAS,QAAO,QAAQ;AAC7C,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,WAAO,MAAM,MAAM,QAAQ,CAAC;AAAA,EAC9B,CAAC;AACH;AAYA,IAAI;AAEJ,IAAM,WAAW,CAAC,aAA8B;AAC9C,QAAM,OAAO,SAAS,QAAQ,QAAQ,EAAE,KAAK;AAC7C,SAAO,SAAS,aAAa,wBAAwB,KAAK,IAAI;AAChE;AAMO,IAAM,cAAc;AAAA,EACzB,MAAM;AAAA,EACN,aAAa;AAAA,EACb,MAAM,SAAgC;AACpC,UAAM,QAAQ,YAAY;AAC1B,UAAM,MAAM,MAAM,MAAM,OAAO,EAAE,MAAM,aAAa,MAAM,EAAE,CAAC;AAC7D,UAAM,UAAwB;AAAA,MAC5B,UAAU,IAAI;AAAA,MACd,OAAO,MAAM,IAAI,MAAM;AAAA,MACvB,OAAO,OAAO,YAAqB;AACjC,YAAI,SAAS,IAAI,IAAI,QAAQ,GAAG,EAAE,QAAQ,GAAG;AAC3C,iBAAO,SAAS,KAAK,EAAE,QAAQ,MAAM,SAAS,QAAQ,CAAC;AAAA,QACzD;AACA,eAAO,IAAI,SAAS,aAAa,EAAE,QAAQ,IAAI,CAAC;AAAA,MAClD;AAAA,IACF;AACA,kBAAc,CAAC,SAAS;AACtB,YAAM,YAAY,KAAK,MAAM,KAAK,IAAI;AACtC,WAAK,QAAQ,YAAY;AACvB,cAAM,QAAQ,MAAM;AACpB,cAAM,UAAU;AAAA,MAClB;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA,EACA,UAAU,MAAqB;AAC7B,kBAAc,IAAI;AAAA,EACpB;AAAA,EACA,OAAO,SAAuB;AAC5B,WAAO,CAAC,2BAA2B,QAAQ,QAAQ,EAAE;AAAA,EACvD;AACF;",
+  "names": []
+}

package/dist/chunk-BIMEYU5A.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-BIMEYU5A.js.map

package/dist/chunk-BIMEYU5A.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/cli.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import "./chunk-BIMEYU5A.js";
+import {
+  serve
+} from "./chunk-7U5RQF7K.js";
+import {
+  createRedis
+} from "./chunk-4HDEOTYJ.js";
+
+// src/cli.ts
+var usage = "mockingbird-redis [--port <n>] [--host <h>] [--password <p>]";
+var args = process.argv.slice(2);
+var port = 6379;
+var host = "127.0.0.1";
+var password;
+for (let i = 0; i < args.length; i++) {
+  const flag = args[i];
+  const next = args[i + 1];
+  if (flag === "--help" || flag === "-h") {
+    console.log(usage);
+    process.exit(0);
+  }
+  if (flag === "--port" || flag === "--host" || flag === "--password") {
+    if (next === void 0) {
+      console.error(`${flag} requires a value`);
+      process.exit(2);
+    }
+    i++;
+    if (flag === "--port") port = Number(next);
+    else if (flag === "--host") host = next;
+    else password = next;
+  } else {
+    console.error(usage);
+    process.exit(2);
+  }
+}
+var redis = createRedis(password === void 0 ? {} : { password });
+var listening = await serve(redis, { port, host });
+console.log(`redis://${listening.host}:${listening.port}`);
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/cli.ts"],
+  "sourcesContent": ["#!/usr/bin/env node\nimport { createRedis } from \"./index.ts\"\nimport { serve } from \"./server.ts\"\n\nconst usage = \"mockingbird-redis [--port <n>] [--host <h>] [--password <p>]\"\nconst args = process.argv.slice(2)\nlet port = 6379\nlet host = \"127.0.0.1\"\nlet password: string | undefined\n\nfor (let i = 0; i < args.length; i++) {\n  const flag = args[i]\n  const next = args[i + 1]\n  if (flag === \"--help\" || flag === \"-h\") {\n    console.log(usage)\n    process.exit(0)\n  }\n  if (flag === \"--port\" || flag === \"--host\" || flag === \"--password\") {\n    if (next === undefined) {\n      console.error(`${flag} requires a value`)\n      process.exit(2)\n    }\n    i++\n    if (flag === \"--port\") port = Number(next)\n    else if (flag === \"--host\") host = next\n    else password = next\n  } else {\n    console.error(usage)\n    process.exit(2)\n  }\n}\n\nconst redis = createRedis(password === undefined ? {} : { password })\nconst listening = await serve(redis, { port, host })\nconsole.log(`redis://${listening.host}:${listening.port}`)\n"],
+  "mappings": ";;;;;;;;;;AAIA,IAAM,QAAQ;AACd,IAAM,OAAO,QAAQ,KAAK,MAAM,CAAC;AACjC,IAAI,OAAO;AACX,IAAI,OAAO;AACX,IAAI;AAEJ,SAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,QAAM,OAAO,KAAK,CAAC;AACnB,QAAM,OAAO,KAAK,IAAI,CAAC;AACvB,MAAI,SAAS,YAAY,SAAS,MAAM;AACtC,YAAQ,IAAI,KAAK;AACjB,YAAQ,KAAK,CAAC;AAAA,EAChB;AACA,MAAI,SAAS,YAAY,SAAS,YAAY,SAAS,cAAc;AACnE,QAAI,SAAS,QAAW;AACtB,cAAQ,MAAM,GAAG,IAAI,mBAAmB;AACxC,cAAQ,KAAK,CAAC;AAAA,IAChB;AACA;AACA,QAAI,SAAS,SAAU,QAAO,OAAO,IAAI;AAAA,aAChC,SAAS,SAAU,QAAO;AAAA,QAC9B,YAAW;AAAA,EAClB,OAAO;AACL,YAAQ,MAAM,KAAK;AACnB,YAAQ,KAAK,CAAC;AAAA,EAChB;AACF;AAEA,IAAM,QAAQ,YAAY,aAAa,SAAY,CAAC,IAAI,EAAE,SAAS,CAAC;AACpE,IAAM,YAAY,MAAM,MAAM,OAAO,EAAE,MAAM,KAAK,CAAC;AACnD,QAAQ,IAAI,WAAW,UAAU,IAAI,IAAI,UAAU,IAAI,EAAE;",
+  "names": []
+}

package/dist/index.d.ts

@@ -0,0 +1,245 @@
+interface RedisClock {
+    now(): number;
+    advance(ms: number): void;
+    subscribe(listener: () => void): () => void;
+    readonly manual: boolean;
+}
+declare function manualClock(start?: number): RedisClock;
+declare function wallClock(): RedisClock;
+
+type Protocol = 2 | 3;
+type Reply = {
+    t: "simple";
+    v: string;
+} | {
+    t: "error";
+    v: string;
+} | {
+    t: "int";
+    v: number | bigint;
+} | {
+    t: "bulk";
+    v: Uint8Array | null;
+} | {
+    t: "array";
+    v: Reply[] | null;
+} | {
+    t: "null";
+} | {
+    t: "bool";
+    v: boolean;
+} | {
+    t: "double";
+    v: number;
+} | {
+    t: "map";
+    v: Array<[Reply, Reply]>;
+} | {
+    t: "push";
+    v: Reply[];
+};
+declare function encodeReply(reply: Reply, protocol?: Protocol): Uint8Array;
+
+declare class RedisConnectionError extends Error {
+    constructor(message: string);
+}
+declare class RedisReplyError extends Error {
+    constructor(message: string);
+}
+interface RedisUser {
+    name: string;
+    password: string;
+    readOnly?: boolean;
+}
+interface RedisOptions {
+    clock?: RedisClock;
+    databases?: number;
+    password?: string;
+    users?: RedisUser[];
+    maxmemory?: number;
+    maxmemoryPolicy?: "noeviction" | "allkeys-lru";
+    seed?: number;
+}
+type RedisFault = "readonly" | "oom" | "busy" | "disconnect" | "timeout" | {
+    latencyMs: number;
+} | null;
+interface Session {
+    id: number;
+    db: number;
+    protocol: 2 | 3;
+    name: string;
+    libName: string;
+    libVer: string;
+    authenticated: boolean;
+    username: string;
+    readOnly: boolean;
+    multi: Array<{
+        name: string;
+        args: Uint8Array[];
+    }> | null;
+    multiFailed: boolean;
+    watching: Array<{
+        db: number;
+        key: string;
+        gen: number;
+    }>;
+    channels: Set<string>;
+    patterns: Set<string>;
+    dead: boolean;
+    quit: boolean;
+    inExec: boolean;
+    onPush: (reply: Reply) => void;
+}
+declare class Redis {
+    readonly clock: RedisClock;
+    private readonly dbs;
+    private readonly password;
+    private readonly users;
+    private readonly authRequired;
+    readonly maxmemory: number;
+    private policy;
+    private rngState;
+    private faultValue;
+    private tail;
+    private sessions;
+    private nextClientId;
+    private waiters;
+    private channelSubs;
+    private patternSubs;
+    private scripts;
+    private invoked;
+    private scriptDepth;
+    private commandCount;
+    private closed;
+    consumersPaused: boolean;
+    private readonly disconnectListeners;
+    constructor(options?: RedisOptions);
+    client(): RedisClient;
+    advance(ms: number): void;
+    fault(value: RedisFault): void;
+    pauseConsumers(paused?: boolean): void;
+    waiterCount(): number;
+    inspect(db?: number): Array<{
+        key: string;
+        type: string;
+        pttl: number;
+    }>;
+    reset(): void;
+    close(): void;
+    onDisconnect(listener: (session: Session) => void): () => void;
+    createSession(): Session;
+    perform(session: Session, name: string, args: Uint8Array[]): Promise<Reply>;
+    private enqueue;
+    private applyLatency;
+    private dropSession;
+    private sessionOf;
+    private database;
+    private random;
+    private memory;
+    private dispatch;
+    private execCmd;
+    private guardWrite;
+    private cmdPing;
+    private cmdAuth;
+    private cmdHello;
+    private cmdSelect;
+    private cmdReset;
+    private cmdClient;
+    private clientInfo;
+    private info;
+    private keyspaceLines;
+    private cmdTime;
+    private cmdConfig;
+    private cmdRandomKey;
+    private cmdScan;
+    private cmdKeys;
+    private cmdType;
+    private cmdExists;
+    private cmdDel;
+    private cmdRename;
+    private cmdExpire;
+    private cmdTtl;
+    private cmdPersist;
+    private stringAt;
+    private cmdGet;
+    private cmdSet;
+    private cmdMget;
+    private cmdMset;
+    private cmdAppend;
+    private cmdStrlen;
+    private cmdGetRange;
+    private cmdSetRange;
+    private cmdIncr;
+    private cmdIncrBy;
+    private addInteger;
+    private cmdIncrByFloat;
+    private cmdGetDel;
+    private cmdGetEx;
+    private requireHash;
+    private cmdHash;
+    private requireList;
+    private cmdList;
+    private cmdBlockingList;
+    private takeList;
+    private requireSet;
+    private cmdSetFamily;
+    private requireZset;
+    private cmdZset;
+    private cmdZadd;
+    private cmdZrange;
+    private cmdBlockingZset;
+    private takeZset;
+    private cmdStream;
+    private stream;
+    private cmdXadd;
+    private nextId;
+    private cmdXrange;
+    private cmdXdel;
+    private cmdXtrim;
+    private cmdXgroup;
+    private cmdXread;
+    private readStreams;
+    private cmdXack;
+    private cmdXpending;
+    private cmdXclaim;
+    private cmdXinfo;
+    private cmdSub;
+    private cmdPublish;
+    private cmdPubsub;
+    private cmdExec;
+    private cmdDiscard;
+    private cmdWatch;
+    private cmdEval;
+    private cmdScript;
+    private runScript;
+    private luaDispatch;
+    private block;
+    private wake;
+    private wakeAll;
+    private satisfy;
+    private finishWaiter;
+    private failWaiter;
+    private leavePubsub;
+}
+declare class RedisClient {
+    private readonly redis;
+    private readonly session;
+    constructor(redis: Redis, session: Session);
+    get protocol(): 2 | 3;
+    onPush(listener: (reply: Reply) => void): void;
+    call(command: string, ...args: Array<string | number | Uint8Array>): Promise<unknown>;
+    raw(command: string, ...args: Array<string | number | Uint8Array>): Promise<Reply>;
+    pipeline(): RedisPipeline;
+    quit(): Promise<string>;
+}
+declare class RedisPipeline {
+    private readonly client;
+    private readonly commands;
+    constructor(client: RedisClient);
+    call(name: string, ...args: Array<string | number | Uint8Array>): this;
+    exec(): Promise<unknown[]>;
+}
+declare function createRedis(options?: RedisOptions): Redis;
+
+export { Redis, RedisClient, RedisConnectionError, RedisPipeline, RedisReplyError, createRedis, encodeReply, manualClock, wallClock };
+export type { RedisClock, RedisFault, RedisOptions, RedisUser, Reply };

package/dist/index.js

@@ -0,0 +1,24 @@
+import "./chunk-BIMEYU5A.js";
+import {
+  Redis,
+  RedisClient,
+  RedisConnectionError,
+  RedisPipeline,
+  RedisReplyError,
+  createRedis,
+  encodeReply,
+  manualClock,
+  wallClock
+} from "./chunk-4HDEOTYJ.js";
+export {
+  Redis,
+  RedisClient,
+  RedisConnectionError,
+  RedisPipeline,
+  RedisReplyError,
+  createRedis,
+  encodeReply,
+  manualClock,
+  wallClock
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}