@yydb/yydb-client 0.0.0 → 0.0.1

package/README.md

@@ -1,4 +1,26 @@
-# @yydb/yydb-client
+# `@yydb/yydb-client`
 
-Placeholder 0.0.0 for npm Trusted Publisher bootstrap.
-Real releases replace this from CI (`release-npm.yml`).
+TypeScript client for the **YY wire protocol**. Used by `yydb-webui` and
+`homepage`.
+
+Frame prefix:
+
+- product magic: **`YYDB`** or **`YYDS`** — backend self-claim; **same wire
+  effect**; client accepts either and does not require consistency
+- version digits: **`0000`** now; later **`0001`**, … (this is what matters)
+
+| Entry | Transport |
+| --- | --- |
+| `@yydb/yydb-client` | WebSocket (`/wire`) — browsers / WebUI |
+| `@yydb/yydb-client/node` | Node TCP (or `ws://` WebSocket) |
+
+Rust crates in this repo:
+
+- `backends/yydb` — YYDB **embedded** facade
+- `backends/yydb-client` — YYDB **remote** TCP client for `yydb serve`
+
+## Security
+
+Reference serve has **no ACL**. Only connect to loopback endpoints you control.
+
+See [`../../documentation/serve-protocol.md`](../../documentation/serve-protocol.md).

package/dist/client.d.ts

@@ -0,0 +1,32 @@
+import { SchemaVersion } from "./wire.js";
+import type { Transport } from "./transport.js";
+export type { Frame, MsgTypeCode, SchemaVersion, } from "./wire.js";
+export { MsgType, encodeFrame, decodeFrame } from "./wire.js";
+export interface ConnectOptions {
+    /** `ws://127.0.0.1:7700/wire` or `127.0.0.1:7700` (upgraded to `/wire`). */
+    endpoint: string;
+}
+/**
+ * TypeScript client for YY wire (browser = WebSocket `/wire`).
+ * Accepts product magic `YYDB` or `YYDS` as equivalent self-claims (same wire);
+ * does not require the magic to match a preferred product. Version gate: `0000`.
+ */
+export declare class Client {
+    readonly endpoint: string;
+    private transport;
+    private nextId;
+    private constructor();
+    /** Construct from an already-open transport (used by Node TCP entry). */
+    static fromTransport(endpoint: string, transport: Transport): Client;
+    /** Open WebSocket to `yydb serve` `/wire` and Hello-handshake. */
+    static connect(options: ConnectOptions | string): Promise<Client>;
+    close(): void;
+    hello(): Promise<string>;
+    serverVersion(): Promise<string>;
+    info(): Promise<string>;
+    getSchema(): Promise<SchemaVersion | null>;
+    ensureSchema(version: number, document: string): Promise<void>;
+    get(key: string): Promise<Uint8Array | null>;
+    put(key: string, value: Uint8Array | string): Promise<void>;
+    private roundtrip;
+}

package/dist/client.js

@@ -0,0 +1,89 @@
+import { decodeKvGetOk, decodeSchemaGetOk, encodeKvGet, encodeKvPut, encodeSchemaEnsure, MsgType, } from "./wire.js";
+import { openWebSocketTransport } from "./ws.js";
+export { MsgType, encodeFrame, decodeFrame } from "./wire.js";
+/**
+ * TypeScript client for YY wire (browser = WebSocket `/wire`).
+ * Accepts product magic `YYDB` or `YYDS` as equivalent self-claims (same wire);
+ * does not require the magic to match a preferred product. Version gate: `0000`.
+ */
+export class Client {
+    endpoint;
+    transport;
+    nextId = 1;
+    constructor(endpoint, transport) {
+        this.endpoint = endpoint;
+        this.transport = transport;
+    }
+    /** Construct from an already-open transport (used by Node TCP entry). */
+    static fromTransport(endpoint, transport) {
+        return new Client(endpoint, transport);
+    }
+    /** Open WebSocket to `yydb serve` `/wire` and Hello-handshake. */
+    static async connect(options) {
+        const endpoint = typeof options === "string" ? options : options.endpoint;
+        if (!endpoint.trim()) {
+            throw new Error("empty serve endpoint");
+        }
+        const transport = await openWebSocketTransport(endpoint);
+        const client = new Client(endpoint, transport);
+        await client.hello();
+        return client;
+    }
+    close() {
+        this.transport.close();
+    }
+    async hello() {
+        const response = await this.roundtrip(MsgType.Hello, new Uint8Array());
+        return new TextDecoder().decode(response.body);
+    }
+    async serverVersion() {
+        return this.hello();
+    }
+    async info() {
+        const response = await this.roundtrip(MsgType.Info, new Uint8Array());
+        return new TextDecoder().decode(response.body);
+    }
+    async getSchema() {
+        const response = await this.roundtrip(MsgType.SchemaGet, new Uint8Array());
+        return decodeSchemaGetOk(response.body);
+    }
+    async ensureSchema(version, document) {
+        await this.roundtrip(MsgType.SchemaEnsure, encodeSchemaEnsure(version, document));
+    }
+    async get(key) {
+        const response = await this.roundtrip(MsgType.KvGet, encodeKvGet(key));
+        return decodeKvGetOk(response.body);
+    }
+    async put(key, value) {
+        const bytes = typeof value === "string" ? new TextEncoder().encode(value) : value;
+        await this.roundtrip(MsgType.KvPut, encodeKvPut(key, bytes));
+    }
+    async roundtrip(msgType, body) {
+        const requestId = this.nextId++;
+        const response = await this.transport.send({
+            msgType,
+            flags: 0,
+            requestId,
+            body,
+        });
+        if (response.requestId !== requestId) {
+            throw new Error("wire response request_id mismatch");
+        }
+        if (response.msgType === MsgType.Error) {
+            throw new Error(new TextDecoder().decode(response.body));
+        }
+        const expectedOk = {
+            [MsgType.Hello]: MsgType.HelloOk,
+            [MsgType.Info]: MsgType.InfoOk,
+            [MsgType.SchemaGet]: MsgType.SchemaGetOk,
+            [MsgType.SchemaEnsure]: MsgType.SchemaEnsureOk,
+            [MsgType.KvGet]: MsgType.KvGetOk,
+            [MsgType.KvPut]: MsgType.KvPutOk,
+        };
+        const want = expectedOk[msgType];
+        if (want !== undefined && response.msgType !== want) {
+            throw new Error(`unexpected wire response type ${response.msgType}`);
+        }
+        return response;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+/** Browser-safe entry (WebSocket). For Node TCP use `@yydb/yydb-client/node`. */
+export { Client } from "./client.js";
+export type { ConnectOptions } from "./client.js";
+export { MAGIC, MAGIC_YYDB, MAGIC_YYDS, WIRE_VERSION, WIRE_VERSION_NEXT, HEADER_LEN, MsgType, encodeFrame, decodeFrame, encodeSchemaEnsure, encodeKvGet, encodeKvPut, decodeSchemaGetOk, decodeKvGetOk, } from "./wire.js";
+export type { Frame, MsgTypeCode, ProductMagic, SchemaVersion } from "./wire.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+/** Browser-safe entry (WebSocket). For Node TCP use `@yydb/yydb-client/node`. */
+export { Client } from "./client.js";
+export { MAGIC, MAGIC_YYDB, MAGIC_YYDS, WIRE_VERSION, WIRE_VERSION_NEXT, HEADER_LEN, MsgType, encodeFrame, decodeFrame, encodeSchemaEnsure, encodeKvGet, encodeKvPut, decodeSchemaGetOk, decodeKvGetOk, } from "./wire.js";

package/dist/node.d.ts

@@ -0,0 +1,7 @@
+import { Client, type ConnectOptions } from "./client.js";
+export { Client } from "./client.js";
+export type { ConnectOptions } from "./client.js";
+export { MsgType, encodeFrame, decodeFrame, encodeSchemaEnsure, encodeKvGet, encodeKvPut, decodeSchemaGetOk, decodeKvGetOk, } from "./wire.js";
+export type { Frame, MsgTypeCode, SchemaVersion } from "./wire.js";
+/** Node entry: TCP by default; `ws://` uses WebSocket. */
+export declare function connect(options: ConnectOptions | string): Promise<Client>;

package/dist/node.js

@@ -0,0 +1,23 @@
+import { Client } from "./client.js";
+import { openTcpTransport } from "./tcp.js";
+import { openWebSocketTransport } from "./ws.js";
+import { normalizeWsUrl } from "./transport.js";
+export { Client } from "./client.js";
+export { MsgType, encodeFrame, decodeFrame, encodeSchemaEnsure, encodeKvGet, encodeKvPut, decodeSchemaGetOk, decodeKvGetOk, } from "./wire.js";
+function wantsWebSocket(endpoint) {
+    const trimmed = endpoint.trim();
+    return trimmed.startsWith("ws://") || trimmed.startsWith("wss://");
+}
+/** Node entry: TCP by default; `ws://` uses WebSocket. */
+export async function connect(options) {
+    const endpoint = typeof options === "string" ? options : options.endpoint;
+    if (!endpoint.trim()) {
+        throw new Error("empty serve endpoint");
+    }
+    const transport = wantsWebSocket(endpoint)
+        ? await openWebSocketTransport(endpoint)
+        : await openTcpTransport(endpoint);
+    const client = Client.fromTransport(wantsWebSocket(endpoint) ? normalizeWsUrl(endpoint) : endpoint, transport);
+    await client.hello();
+    return client;
+}

package/dist/tcp.d.ts

@@ -0,0 +1,3 @@
+import { type Transport } from "./transport.js";
+/** Node.js TCP transport for `yydb serve` binary frames. */
+export declare function openTcpTransport(endpoint: string): Promise<Transport>;

package/dist/tcp.js

@@ -0,0 +1,65 @@
+import { decodeFrame, encodeFrame } from "./wire.js";
+import { normalizeTcpHostPort } from "./transport.js";
+/** Node.js TCP transport for `yydb serve` binary frames. */
+export async function openTcpTransport(endpoint) {
+    const net = await import("node:net");
+    const hostport = normalizeTcpHostPort(endpoint);
+    const [host, portText] = hostport.includes("]:")
+        ? (() => {
+            const rest = hostport.slice(1);
+            const idx = rest.indexOf("]:");
+            return [rest.slice(0, idx), rest.slice(idx + 2)];
+        })()
+        : hostport.split(":");
+    const port = Number(portText);
+    if (!host || !Number.isFinite(port)) {
+        throw new Error(`invalid TCP endpoint: ${endpoint}`);
+    }
+    const socket = net.createConnection({ host, port });
+    await new Promise((resolve, reject) => {
+        socket.once("connect", () => resolve());
+        socket.once("error", reject);
+    });
+    let buffer = new Uint8Array(0);
+    const waiters = [];
+    socket.on("data", (chunk) => {
+        const next = new Uint8Array(buffer.byteLength + chunk.byteLength);
+        next.set(buffer, 0);
+        next.set(chunk, buffer.byteLength);
+        buffer = next;
+        for (const wake of waiters.splice(0)) {
+            wake();
+        }
+    });
+    async function readExact(n) {
+        while (buffer.byteLength < n) {
+            await new Promise((resolve) => waiters.push(resolve));
+        }
+        const out = buffer.slice(0, n);
+        buffer = buffer.slice(n);
+        return out;
+    }
+    return {
+        async send(frame) {
+            const encoded = encodeFrame(frame);
+            await new Promise((resolve, reject) => {
+                socket.write(Buffer.from(encoded), (error) => {
+                    if (error)
+                        reject(error);
+                    else
+                        resolve();
+                });
+            });
+            const header = await readExact(20);
+            const bodyLen = new DataView(header.buffer, header.byteOffset, header.byteLength).getUint32(16, true);
+            const body = bodyLen > 0 ? await readExact(bodyLen) : new Uint8Array();
+            const full = new Uint8Array(20 + body.byteLength);
+            full.set(header, 0);
+            full.set(body, 20);
+            return decodeFrame(full);
+        },
+        close() {
+            socket.end();
+        },
+    };
+}

package/dist/transport.d.ts

@@ -0,0 +1,7 @@
+import type { Frame } from "./wire.js";
+export type Transport = {
+    send(frame: Frame): Promise<Frame>;
+    close(): void;
+};
+export declare function normalizeWsUrl(endpoint: string): string;
+export declare function normalizeTcpHostPort(endpoint: string): string;

package/dist/transport.js

@@ -0,0 +1,23 @@
+export function normalizeWsUrl(endpoint) {
+    const trimmed = endpoint.trim();
+    if (trimmed.startsWith("ws://") || trimmed.startsWith("wss://")) {
+        if (trimmed.includes("/wire")) {
+            return trimmed;
+        }
+        return trimmed.replace(/\/$/, "") + "/wire";
+    }
+    const hostport = trimmed
+        .replace(/^tcp:\/\//, "")
+        .replace(/^http:\/\//, "")
+        .split("/")[0];
+    return `ws://${hostport}/wire`;
+}
+export function normalizeTcpHostPort(endpoint) {
+    const trimmed = endpoint
+        .trim()
+        .replace(/^tcp:\/\//, "")
+        .replace(/^http:\/\//, "")
+        .replace(/^ws:\/\//, "")
+        .replace(/^wss:\/\//, "");
+    return trimmed.split("/")[0];
+}

package/dist/wire.d.ts

@@ -0,0 +1,54 @@
+/**
+ * YY wire protocol — VOS-native serve frames.
+ * Prefix: product magic `YYDB` | `YYDS` (backend self-claim only; same effect),
+ * then four ASCII version digits (`0000` current, `0001` next).
+ * Frontends accept either magic and do not require product consistency.
+ */
+export declare const MAGIC_YYDB: Uint8Array;
+export declare const MAGIC_YYDS: Uint8Array;
+/** @deprecated Use MAGIC_YYDB — encode default product. */
+export declare const MAGIC: Uint8Array;
+/** Current wire version digits. */
+export declare const WIRE_VERSION: Uint8Array;
+/** Next planned wire version (not spoken yet). */
+export declare const WIRE_VERSION_NEXT: Uint8Array;
+export declare const HEADER_LEN = 20;
+export declare const MAX_BODY_LEN: number;
+export declare const MsgType: {
+    readonly Hello: 1;
+    readonly HelloOk: 2;
+    readonly Info: 3;
+    readonly InfoOk: 4;
+    readonly SchemaGet: 5;
+    readonly SchemaGetOk: 6;
+    readonly SchemaEnsure: 7;
+    readonly SchemaEnsureOk: 8;
+    readonly KvGet: 9;
+    readonly KvGetOk: 10;
+    readonly KvPut: 11;
+    readonly KvPutOk: 12;
+    readonly Error: 255;
+};
+export type MsgTypeCode = (typeof MsgType)[keyof typeof MsgType];
+export type ProductMagic = "YYDB" | "YYDS";
+export interface Frame {
+    msgType: number;
+    flags: number;
+    requestId: number;
+    body: Uint8Array;
+    /** Product magic observed on decode (backend self-claim; optional to ignore). */
+    product?: ProductMagic;
+}
+export declare function encodeFrame(frame: Frame, product?: ProductMagic): Uint8Array;
+export declare function decodeFrame(bytes: Uint8Array): Frame;
+export declare function pushU32(out: number[], value: number): void;
+export declare function pushBytes(out: number[], bytes: Uint8Array): void;
+export declare function encodeSchemaEnsure(version: number, document: string): Uint8Array;
+export declare function encodeKvGet(key: string): Uint8Array;
+export declare function encodeKvPut(key: string, value: Uint8Array): Uint8Array;
+export interface SchemaVersion {
+    version: number;
+    document: string;
+}
+export declare function decodeSchemaGetOk(body: Uint8Array): SchemaVersion | null;
+export declare function decodeKvGetOk(body: Uint8Array): Uint8Array | null;

package/dist/wire.js

@@ -0,0 +1,167 @@
+/**
+ * YY wire protocol — VOS-native serve frames.
+ * Prefix: product magic `YYDB` | `YYDS` (backend self-claim only; same effect),
+ * then four ASCII version digits (`0000` current, `0001` next).
+ * Frontends accept either magic and do not require product consistency.
+ */
+export const MAGIC_YYDB = new TextEncoder().encode("YYDB");
+export const MAGIC_YYDS = new TextEncoder().encode("YYDS");
+/** @deprecated Use MAGIC_YYDB — encode default product. */
+export const MAGIC = MAGIC_YYDB;
+/** Current wire version digits. */
+export const WIRE_VERSION = new TextEncoder().encode("0000");
+/** Next planned wire version (not spoken yet). */
+export const WIRE_VERSION_NEXT = new TextEncoder().encode("0001");
+export const HEADER_LEN = 20;
+export const MAX_BODY_LEN = 16 * 1024 * 1024;
+export const MsgType = {
+    Hello: 1,
+    HelloOk: 2,
+    Info: 3,
+    InfoOk: 4,
+    SchemaGet: 5,
+    SchemaGetOk: 6,
+    SchemaEnsure: 7,
+    SchemaEnsureOk: 8,
+    KvGet: 9,
+    KvGetOk: 10,
+    KvPut: 11,
+    KvPutOk: 12,
+    Error: 255,
+};
+function writeU16(view, offset, value) {
+    view.setUint16(offset, value, true);
+}
+function writeU32(view, offset, value) {
+    view.setUint32(offset, value, true);
+}
+function readU16(view, offset) {
+    return view.getUint16(offset, true);
+}
+function readU32(view, offset) {
+    return view.getUint32(offset, true);
+}
+function productBytes(product) {
+    return product === "YYDS" ? MAGIC_YYDS : MAGIC_YYDB;
+}
+function parseProduct(bytes) {
+    const text = new TextDecoder().decode(bytes.subarray(0, 4));
+    if (text === "YYDB" || text === "YYDS") {
+        return text;
+    }
+    throw new Error("wire frame bad product magic (want YYDB|YYDS)");
+}
+function checkVersion(bytes) {
+    const version = new TextDecoder().decode(bytes.subarray(4, 8));
+    if (version !== "0000") {
+        throw new Error(`wire version not supported (got ${version}, want 0000)`);
+    }
+}
+export function encodeFrame(frame, product = "YYDB") {
+    if (frame.body.byteLength > MAX_BODY_LEN) {
+        throw new Error("wire body too large");
+    }
+    const out = new Uint8Array(HEADER_LEN + frame.body.byteLength);
+    out.set(productBytes(product), 0);
+    out.set(WIRE_VERSION, 4);
+    const view = new DataView(out.buffer);
+    writeU16(view, 8, frame.msgType);
+    writeU16(view, 10, frame.flags);
+    writeU32(view, 12, frame.requestId);
+    writeU32(view, 16, frame.body.byteLength);
+    out.set(frame.body, HEADER_LEN);
+    return out;
+}
+export function decodeFrame(bytes) {
+    if (bytes.byteLength < HEADER_LEN) {
+        throw new Error("wire frame truncated header");
+    }
+    const product = parseProduct(bytes);
+    checkVersion(bytes);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const msgType = readU16(view, 8);
+    const flags = readU16(view, 10);
+    const requestId = readU32(view, 12);
+    const bodyLen = readU32(view, 16);
+    if (bodyLen > MAX_BODY_LEN) {
+        throw new Error("wire body too large");
+    }
+    const need = HEADER_LEN + bodyLen;
+    if (bytes.byteLength < need) {
+        throw new Error("wire frame truncated body");
+    }
+    return {
+        msgType,
+        flags,
+        requestId,
+        body: bytes.slice(HEADER_LEN, need),
+        product,
+    };
+}
+export function pushU32(out, value) {
+    out.push(value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff, (value >> 24) & 0xff);
+}
+export function pushBytes(out, bytes) {
+    pushU32(out, bytes.byteLength);
+    for (let i = 0; i < bytes.byteLength; i++) {
+        out.push(bytes[i]);
+    }
+}
+export function encodeSchemaEnsure(version, document) {
+    const out = [];
+    pushU32(out, version >>> 0);
+    pushBytes(out, new TextEncoder().encode(document));
+    return Uint8Array.from(out);
+}
+export function encodeKvGet(key) {
+    const out = [];
+    pushBytes(out, new TextEncoder().encode(key));
+    return Uint8Array.from(out);
+}
+export function encodeKvPut(key, value) {
+    const out = [];
+    pushBytes(out, new TextEncoder().encode(key));
+    pushBytes(out, value);
+    return Uint8Array.from(out);
+}
+function readU32At(body, offset) {
+    if (offset.n + 4 > body.byteLength) {
+        throw new Error("wire body truncated u32");
+    }
+    const view = new DataView(body.buffer, body.byteOffset, body.byteLength);
+    const value = readU32(view, offset.n);
+    offset.n += 4;
+    return value;
+}
+function readBytesAt(body, offset, len) {
+    if (offset.n + len > body.byteLength) {
+        throw new Error("wire body truncated bytes");
+    }
+    const slice = body.slice(offset.n, offset.n + len);
+    offset.n += len;
+    return slice;
+}
+export function decodeSchemaGetOk(body) {
+    if (body.byteLength === 0) {
+        throw new Error("schema get ok empty");
+    }
+    if (body[0] === 0) {
+        return null;
+    }
+    const offset = { n: 1 };
+    const version = readU32At(body, offset);
+    const docLen = readU32At(body, offset);
+    const doc = readBytesAt(body, offset, docLen);
+    return { version, document: new TextDecoder().decode(doc) };
+}
+export function decodeKvGetOk(body) {
+    if (body.byteLength === 0) {
+        throw new Error("kv get ok empty");
+    }
+    if (body[0] === 0) {
+        return null;
+    }
+    const offset = { n: 1 };
+    const valLen = readU32At(body, offset);
+    return readBytesAt(body, offset, valLen);
+}

package/dist/ws.d.ts

@@ -0,0 +1,3 @@
+import { type Transport } from "./transport.js";
+/** Browser / any host with WebSocket — path `/wire`, binary frames. */
+export declare function openWebSocketTransport(endpoint: string): Promise<Transport>;

package/dist/ws.js

@@ -0,0 +1,48 @@
+import { decodeFrame, encodeFrame } from "./wire.js";
+import { normalizeWsUrl } from "./transport.js";
+/** Browser / any host with WebSocket — path `/wire`, binary frames. */
+export async function openWebSocketTransport(endpoint) {
+    const url = normalizeWsUrl(endpoint);
+    const ws = new WebSocket(url);
+    ws.binaryType = "arraybuffer";
+    await new Promise((resolve, reject) => {
+        ws.addEventListener("open", () => resolve(), { once: true });
+        ws.addEventListener("error", () => reject(new Error(`websocket failed: ${url}`)), { once: true });
+    });
+    let pending = null;
+    ws.addEventListener("message", (event) => {
+        try {
+            const data = event.data instanceof ArrayBuffer
+                ? new Uint8Array(event.data)
+                : new Uint8Array(event.data);
+            const frame = decodeFrame(data);
+            if (pending) {
+                const slot = pending;
+                pending = null;
+                slot.resolve(frame);
+            }
+        }
+        catch (error) {
+            if (pending) {
+                const slot = pending;
+                pending = null;
+                slot.reject(error);
+            }
+        }
+    });
+    return {
+        send(frame) {
+            return new Promise((resolve, reject) => {
+                if (pending) {
+                    reject(new Error("overlapping websocket requests"));
+                    return;
+                }
+                pending = { resolve, reject };
+                ws.send(encodeFrame(frame));
+            });
+        },
+        close() {
+            ws.close();
+        },
+    };
+}

package/package.json

@@ -1,14 +1,53 @@
 {
   "name": "@yydb/yydb-client",
-  "version": "0.0.0",
-  "description": "Placeholder — YY wire TypeScript client",
+  "version": "0.0.1",
+  "description": "TypeScript client for YY wire protocol v1 (VOS-native; YYDB/YYDS/compatible hosts)",
   "license": "MIT",
-  "private": false,
-  "publishConfig": {
-    "access": "public"
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "node --experimental-strip-types --test src/wire.test.ts"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/yy-database/yydb.git"
+    "url": "git+https://github.com/yy-database/yydb.rs.git",
+    "directory": "frontends/yydb-client"
+  },
+  "homepage": "https://github.com/yy-database/yydb.rs/tree/dev/frontends/yydb-client#readme",
+  "bugs": {
+    "url": "https://github.com/yy-database/yydb.rs/issues"
+  },
+  "keywords": [
+    "yydb",
+    "yyds",
+    "vos",
+    "wire-protocol",
+    "typescript"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "~5.3.0"
+  },
+  "engines": {
+    "node": ">=18"
   }
 }