@yydb/yydb 0.0.4 → 0.0.5

package/README.md

@@ -1,29 +1,36 @@
 # `@yydb/yydb`
 
-Opens a `.yydb` file in Node.js with one dependency: a private loopback `yydb serve` process starts automatically and
-the package talks to it over the YY wire protocol. For a lightweight client only (browser, renderer, or an app that
-already runs `yydb serve`), use [`@yydb/yydb-client`](https://www.npmjs.com/package/@yydb/yydb-client).
+Node all-in-one and browser wasm core from one package. On Node.js, `Database.open` starts a private loopback `yydb serve`
+process and talks over the YY wire protocol. In browsers, `@yydb/yydb/wasm` loads an in-process wasm session with KV,
+schema, and VOS `query` / `execute` on memory or OPFS paths.
+
+For a wire client only (renderer or an app that already runs `yydb serve`), use
+[`@yydb/yydb-client`](https://www.npmjs.com/package/@yydb/yydb-client).
 
 [![npm](https://img.shields.io/npm/v/@yydb/yydb)](https://www.npmjs.com/package/@yydb/yydb)
 [![Node.js](https://img.shields.io/node/v/@yydb/yydb)](https://www.npmjs.com/package/@yydb/yydb)
 
 ## Exports
 
-| Import           | Role                                     |
-|------------------|------------------------------------------|
-| `@yydb/yydb`     | `Database` API and default entry         |
-| `@yydb/yydb/cli` | CLI (`version`, `init`, `info`, `serve`) |
+| Import | Runtime | Role |
+|--------|---------|------|
+| `@yydb/yydb` | Node (`node` export condition) | `Database.open`, micro helpers |
+| `@yydb/yydb` | Browser / bundler (`default`) | wasm `Database` |
+| `@yydb/yydb/node` | Node (explicit) | Same as Node default |
+| `@yydb/yydb/wasm` | Browser (explicit) | wasm `Database`, `initWasm`, `checkSchema` |
+| `@yydb/yydb/cli` | Node | CLI (`version`, `init`, `info`, `serve`) |
 
-Node.js 18+. The matching platform `.node` binding installs via optional dependencies.
+Node.js 18+. Platform `.node` bindings install via optional dependencies.
 
-Schema truth lives in the `.yydb` file via `ensureSchema` and VOS documents.
+Schema truth lives in the `.yydb` file via `ensureSchema` and VOS documents. Wasm sessions mirror KV and schema calls
+and add VOS pipelines directly on the embedded core.
 
-## Example
+## Node example
 
 ```ts
-import {Database} from "@yydb/yydb";
+import { Database } from '@yydb/yydb';
 
-const db = await Database.open("./data/app.yydb");
+const db = await Database.open('./data/app.yydb');
 
 await db.ensureSchema(
     1,
@@ -34,14 +41,56 @@ await db.ensureSchema(
     }`,
 );
 
-await db.put("theme", "dark");
-console.log(await db.get("theme"));
+await db.put('theme', 'dark');
+console.log(await db.get('theme'));
 await db.close();
 ```
 
 The file is created when missing. Schema version and VOS document persist with the data.
 
-## API
+## Browser example
+
+```ts
+import { Database } from '@yydb/yydb/wasm';
+
+const db = await Database.openInMemory();
+
+await db.ensureSchema(
+    1,
+    `table Setting {
+        @@id: uuid,
+        key: utf8,
+        value: utf8,
+    }`,
+);
+
+await db.put('theme', 'dark');
+console.log(await db.get('theme'));
+db.close();
+```
+
+Use `Database.open('app.yydb')` for OPFS-backed paths in supported browsers.
+
+## Wasm API
+
+```ts
+const db = await Database.openInMemory();
+// or: const db = await Database.open('app.yydb');
+
+await db.ensureSchema(version, vosDocument);
+await db.getSchema();
+await db.put(key, stringOrBytes);
+await db.get(key);
+await db.info();
+await db.serverVersion();
+await db.registerMicro(microDefinition);
+await db.callScalar('double', 1, [21]);
+db.query('User.filter(x => x.active).collect()');
+db.execute('User { name: "Ada" }.insert()');
+db.close();
+```
+
+## Node API
 
 ```ts
 const db = await Database.open(path, options?);
@@ -52,6 +101,8 @@ await db.put(key, stringOrBytes);
 await db.get(key);
 await db.info();
 await db.serverVersion();
+await db.registerMicro(microDefinition);
+await db.callScalar('double', 1, [21]);
 await db.close();
 ```
 
@@ -60,14 +111,15 @@ arguments). `binary` is a deprecated alias for `cli`.
 
 ## Related packages
 
-| Need                           | Package                                                                |
-|--------------------------------|------------------------------------------------------------------------|
-| Node all-in-one (this package) | **`@yydb/yydb`**                                                       |
-| Wire client only               | [`@yydb/yydb-client`](https://www.npmjs.com/package/@yydb/yydb-client) |
-| In-process Rust embed          | [`yydb`](https://crates.io/crates/yydb)                                |
-| Agent skills (wire protocol)   | [`@yydb/yydb-skills`](https://www.npmjs.com/package/@yydb/yydb-skills) |
+| Need | Package |
+|------|---------|
+| Node all-in-one (this package) | **`@yydb/yydb`** or `@yydb/yydb/node` |
+| Browser wasm entry | **`@yydb/yydb/wasm`** |
+| Wire client only | [`@yydb/yydb-client`](https://www.npmjs.com/package/@yydb/yydb-client) |
+| In-process Rust embed | [`yydb`](https://crates.io/crates/yydb) |
+| Agent skills (wire protocol) | [`@yydb/yydb-skills`](https://www.npmjs.com/package/@yydb/yydb-skills) |
 
-Electron: main process can use `@yydb/yydb`; renderer code can use `@yydb/yydb-client` against the main-process
+Electron: main process can use `@yydb/yydb/node`; renderer code can use `@yydb/yydb-client` against the main-process
 endpoint.
 
 The managed engine listens on `127.0.0.1` with no authentication — keep the endpoint private.

package/dist/{cli → node/cli}/cli.js

@@ -6,7 +6,7 @@ import { registerInitCommand } from './init-cmd.js';
 import { registerServeCommand } from './serve-cmd.js';
 import { registerVersionCommand } from './version-cmd.js';
 function buildYydbCli() {
-    const localesRoot = join(dirname(fileURLToPath(import.meta.url)), '../../locales');
+    const localesRoot = join(dirname(fileURLToPath(import.meta.url)), '../../../locales');
     const cli = createCli('yydb').locales(localesRoot).intro('cli.intro');
     registerVersionCommand(cli);
     registerInitCommand(cli);

package/dist/{database.d.ts → node/database.d.ts}

@@ -1,5 +1,5 @@
-import { defineMicro as buildMicro, type DefinedMicro, type MicroHandle } from './micro.js';
-import type { UdfTypeDescriptor } from './udf-types.js';
+import { defineMicro as buildMicro, type DefinedMicro, type MicroHandle } from '../shared/micro.js';
+import type { UdfTypeDescriptor } from '../shared/udf-types.js';
 export type { SchemaVersion } from '@yydb/yydb-client';
 export interface OpenOptions {
     /** Override CLI script path (tests / special installs). */

package/dist/{database.js → node/database.js}

@@ -3,16 +3,8 @@ import fs from 'node:fs';
 import net from 'node:net';
 import path from 'node:path';
 import { connect } from '@yydb/yydb-client/node';
-import { defineMicro as buildMicro, MicroSessionRegistry } from './micro.js';
+import { defineMicro as buildMicro, microFingerprint, MicroSessionRegistry } from '../shared/micro.js';
 import { resolveYydbCli } from './resolve-bin.js';
-function microFingerprint(name, version) {
-    const bytes = new Uint8Array(32);
-    const seed = `${name}@${version}`;
-    for (let index = 0; index < bytes.byteLength; index += 1) {
-        bytes[index] = seed.charCodeAt(index % seed.length) & 0xff;
-    }
-    return bytes;
-}
 async function freeLoopbackPort() {
     return await new Promise((resolve, reject) => {
         const server = net.createServer();

package/dist/{index.d.ts → node/index.d.ts}

@@ -1,4 +1,4 @@
 export { Database, type OpenOptions } from './database.js';
-export { defineMicro, type DefinedMicro, type MicroHandle, type TsMicroDefinitionInput, MicroSessionRegistry } from './micro.js';
-export { bool, i64, nullType, text, type InferUdfArgs, type InferUdfReturn, type MicroEffect, type MicroInvocationMode, type UdfScalarKind, type UdfTypeDescriptor, } from './udf-types.js';
+export { defineMicro, type DefinedMicro, type MicroHandle, type TsMicroDefinitionInput, MicroSessionRegistry } from '../shared/micro.js';
+export { bool, i64, nullType, text, type InferUdfArgs, type InferUdfReturn, type MicroEffect, type MicroInvocationMode, type UdfScalarKind, type UdfTypeDescriptor, } from '../shared/udf-types.js';
 export { nativeBindingName, platformKey, resolveYydbBinary, resolveYydbCli } from './resolve-bin.js';

package/dist/{index.js → node/index.js}

@@ -1,4 +1,4 @@
 export { Database } from './database.js';
-export { defineMicro, MicroSessionRegistry } from './micro.js';
-export { bool, i64, nullType, text, } from './udf-types.js';
+export { defineMicro, MicroSessionRegistry } from '../shared/micro.js';
+export { bool, i64, nullType, text, } from '../shared/udf-types.js';
 export { nativeBindingName, platformKey, resolveYydbBinary, resolveYydbCli } from './resolve-bin.js';

package/dist/{micro.d.ts → shared/micro.d.ts}

@@ -60,4 +60,6 @@ export declare class MicroSessionRegistry {
 }
 /** Builds a session-local micro definition without registering it. */
 export declare function defineMicro<TArgs extends readonly UdfTypeDescriptor[], TReturn extends UdfTypeDescriptor>(input: TsMicroDefinitionInput<TArgs, TReturn>): DefinedMicro<TArgs, TReturn>;
+/** Stable 32-byte fingerprint for a logical micro name and version. */
+export declare function microFingerprint(name: string, version: number): Uint8Array;
 export {};

package/dist/{micro.js → shared/micro.js}

@@ -99,6 +99,15 @@ export function defineMicro(input) {
         fn: input.fn,
     };
 }
+/** Stable 32-byte fingerprint for a logical micro name and version. */
+export function microFingerprint(name, version) {
+    const bytes = new Uint8Array(32);
+    const seed = `${name}@${version}`;
+    for (let index = 0; index < bytes.byteLength; index += 1) {
+        bytes[index] = seed.charCodeAt(index % seed.length) & 0xff;
+    }
+    return bytes;
+}
 function logicalKey(name, version) {
     return `${name}@${version}`;
 }

package/dist/shared/wasm-envelope.d.ts

@@ -0,0 +1,37 @@
+/** Parsed `{ ok, rows, error }` envelope from wasm VOS calls. */
+export type WasmRowsResult = {
+    ok: boolean;
+    rows: Record<string, unknown>[];
+    error: string | null;
+};
+/** Parsed `{ ok, schema, error }` envelope from wasm `getSchema`. */
+export type WasmSchemaResult = {
+    ok: boolean;
+    schema: {
+        version: number;
+        document: string;
+    } | null;
+    error: string | null;
+};
+/** Parsed `{ ok, value, error }` envelope from wasm `get`. */
+export type WasmKvGetResult = {
+    ok: boolean;
+    value: number[] | null;
+    error: string | null;
+};
+/** Parsed `{ ok, value, error }` envelope from wasm `callScalar`. */
+export type WasmScalarResult = {
+    ok: boolean;
+    value: string | number | boolean | null;
+    error: string | null;
+};
+export type WireScalarValue = string | number | boolean | null;
+export type SchemaVersion = {
+    version: number;
+    document: string;
+};
+export declare function parseWasmRowsResult(payload: string): WasmRowsResult;
+export declare function parseWasmUnitResult(payload: string): void;
+export declare function parseWasmSchemaResult(payload: string): SchemaVersion | null;
+export declare function parseWasmScalarResult(payload: string): WireScalarValue;
+export declare function parseWasmKvGetResult(payload: string): Uint8Array | null;

package/dist/shared/wasm-envelope.js

@@ -0,0 +1,46 @@
+function parseJson(payload, label) {
+    try {
+        return JSON.parse(payload);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`${label}: invalid JSON (${message})`);
+    }
+}
+export function parseWasmRowsResult(payload) {
+    const parsed = parseJson(payload, 'wasm query/execute');
+    if (!parsed.ok) {
+        throw new Error(parsed.error ?? 'wasm query/execute failed');
+    }
+    return parsed;
+}
+export function parseWasmUnitResult(payload) {
+    const parsed = parseJson(payload, 'wasm unit call');
+    if (!parsed.ok) {
+        throw new Error(parsed.error ?? 'wasm unit call failed');
+    }
+}
+export function parseWasmSchemaResult(payload) {
+    const parsed = parseJson(payload, 'wasm getSchema');
+    if (!parsed.ok) {
+        throw new Error(parsed.error ?? 'wasm getSchema failed');
+    }
+    return parsed.schema;
+}
+export function parseWasmScalarResult(payload) {
+    const parsed = parseJson(payload, 'wasm callScalar');
+    if (!parsed.ok) {
+        throw new Error(parsed.error ?? 'wasm callScalar failed');
+    }
+    return parsed.value;
+}
+export function parseWasmKvGetResult(payload) {
+    const parsed = parseJson(payload, 'wasm get');
+    if (!parsed.ok) {
+        throw new Error(parsed.error ?? 'wasm get failed');
+    }
+    if (parsed.value === null) {
+        return null;
+    }
+    return Uint8Array.from(parsed.value);
+}

package/dist/wasm/binding.d.ts

@@ -0,0 +1 @@
+export { checkSchema, createMemorySession, initWasm, introspectSchema, openPersistentSession, queryMemory, resetWasmBindingForTests, yydbVersion, type CheckSchemaResult, type InitWasmOptions, type WasmInitInput, type WasmSession, } from '@yydb/yydb-unknown-wasm32';

package/dist/wasm/binding.js

@@ -0,0 +1 @@
+export { checkSchema, createMemorySession, initWasm, introspectSchema, openPersistentSession, queryMemory, resetWasmBindingForTests, yydbVersion, } from '@yydb/yydb-unknown-wasm32';

package/dist/wasm/database.d.ts

@@ -0,0 +1,53 @@
+import { defineMicro as buildMicro, type DefinedMicro, type MicroHandle } from '../shared/micro.js';
+import type { UdfTypeDescriptor } from '../shared/udf-types.js';
+import { type SchemaVersion } from '../shared/wasm-envelope.js';
+import { type CheckSchemaResult, type InitWasmOptions } from './binding.js';
+export type WasmOpenOptions = InitWasmOptions;
+/**
+ * Browser-facing YYDB handle backed by an in-process wasm session.
+ * Use `open` for OPFS-backed paths and `openInMemory` for ephemeral state.
+ */
+export declare class Database {
+    readonly path: string;
+    private session;
+    private readonly kind;
+    private readonly microRegistry;
+    private constructor();
+    /** Open an OPFS-backed database at `path` (for example `app.yydb`). */
+    static open(path: string, options?: WasmOpenOptions): Promise<Database>;
+    /** Open a stateful in-memory database session. */
+    static openInMemory(options?: WasmOpenOptions): Promise<Database>;
+    /** Library version from the wasm binding. */
+    version(): string;
+    /** Engine version string (Node API parity). */
+    serverVersion(): Promise<string>;
+    /** Database info text (`path=…\\n…`), matching the YY wire `Info` reply. */
+    info(): Promise<string>;
+    /** Parse and validate a VOS schema document without opening a session. */
+    checkSchema(source: string): CheckSchemaResult;
+    /** Persist schema document. `version` is accepted for Node API parity; wasm uses the document body. */
+    ensureSchema(_version: number, document: string): Promise<void>;
+    getSchema(): Promise<SchemaVersion | null>;
+    get(key: string): Promise<Uint8Array | null>;
+    put(key: string, value: Uint8Array | string): Promise<void>;
+    /** VOS read pipeline (for example `User.filter(x => x.active).collect()`). */
+    query(source: string): Record<string, unknown>[];
+    /** Unit-valued VOS write programs (for example `User { … }.insert()`). */
+    execute(source: string): void;
+    /**
+     * Build a typed session-local micro definition. Does not register it with
+     * the engine until `registerMicro` is called.
+     */
+    defineMicro<TArgs extends readonly UdfTypeDescriptor[], TReturn extends UdfTypeDescriptor>(definition: Parameters<typeof buildMicro<TArgs, TReturn>>[0]): DefinedMicro<TArgs, TReturn>;
+    /**
+     * Install a `defineMicro` definition into the current session registry and
+     * sync metadata to the embedded engine. Host micros are session-local.
+     */
+    registerMicro<TArgs extends readonly UdfTypeDescriptor[], TReturn extends UdfTypeDescriptor>(definition: DefinedMicro<TArgs, TReturn>): Promise<MicroHandle>;
+    /** Invoke a registered scalar UDF on the embedded engine. */
+    callScalar(name: string, version: number, args: readonly (string | number | boolean | null)[]): Promise<string | number | boolean | null>;
+    /** Whether this handle owns a persistent OPFS session. */
+    isPersistent(): boolean;
+    close(): void;
+    private requireSession;
+}

package/dist/wasm/database.js

@@ -0,0 +1,116 @@
+import { encodeMicroRegister, encodeScalarCall } from '@yydb/yydb-client';
+import { defineMicro as buildMicro, microFingerprint, MicroSessionRegistry } from '../shared/micro.js';
+import { parseWasmKvGetResult, parseWasmRowsResult, parseWasmScalarResult, parseWasmSchemaResult, parseWasmUnitResult, } from '../shared/wasm-envelope.js';
+import { checkSchema, createMemorySession, initWasm, openPersistentSession, yydbVersion, } from './binding.js';
+/**
+ * Browser-facing YYDB handle backed by an in-process wasm session.
+ * Use `open` for OPFS-backed paths and `openInMemory` for ephemeral state.
+ */
+export class Database {
+    path;
+    session;
+    kind;
+    microRegistry;
+    constructor(kind, path, session) {
+        this.kind = kind;
+        this.path = path;
+        this.session = session;
+        this.microRegistry = new MicroSessionRegistry();
+        session.setMicroHostInvoker((payload) => this.microRegistry.invokeFromWire(payload));
+    }
+    /** Open an OPFS-backed database at `path` (for example `app.yydb`). */
+    static async open(path, options = {}) {
+        await initWasm(options);
+        const session = openPersistentSession(path);
+        return new Database('persistent', session.path ?? path, session);
+    }
+    /** Open a stateful in-memory database session. */
+    static async openInMemory(options = {}) {
+        await initWasm(options);
+        const session = createMemorySession();
+        return new Database('memory', ':memory:', session);
+    }
+    /** Library version from the wasm binding. */
+    version() {
+        return yydbVersion();
+    }
+    /** Engine version string (Node API parity). */
+    async serverVersion() {
+        return yydbVersion();
+    }
+    /** Database info text (`path=…\\n…`), matching the YY wire `Info` reply. */
+    async info() {
+        return this.requireSession().info();
+    }
+    /** Parse and validate a VOS schema document without opening a session. */
+    checkSchema(source) {
+        return checkSchema(source);
+    }
+    /** Persist schema document. `version` is accepted for Node API parity; wasm uses the document body. */
+    async ensureSchema(_version, document) {
+        parseWasmUnitResult(this.requireSession().ensureSchema(document));
+    }
+    async getSchema() {
+        return parseWasmSchemaResult(this.requireSession().getSchema());
+    }
+    async get(key) {
+        return parseWasmKvGetResult(this.requireSession().get(key));
+    }
+    async put(key, value) {
+        const bytes = typeof value === 'string' ? new TextEncoder().encode(value) : value;
+        parseWasmUnitResult(this.requireSession().put(key, bytes));
+    }
+    /** VOS read pipeline (for example `User.filter(x => x.active).collect()`). */
+    query(source) {
+        return parseWasmRowsResult(this.requireSession().query(source)).rows;
+    }
+    /** Unit-valued VOS write programs (for example `User { … }.insert()`). */
+    execute(source) {
+        parseWasmUnitResult(this.requireSession().execute(source));
+    }
+    /**
+     * Build a typed session-local micro definition. Does not register it with
+     * the engine until `registerMicro` is called.
+     */
+    defineMicro(definition) {
+        return buildMicro(definition);
+    }
+    /**
+     * Install a `defineMicro` definition into the current session registry and
+     * sync metadata to the embedded engine. Host micros are session-local.
+     */
+    async registerMicro(definition) {
+        const handle = this.microRegistry.register(definition);
+        const body = encodeMicroRegister({
+            hostId: handle.hostId,
+            handleVersion: handle.implementationVersion,
+            udfVersion: definition.version,
+            name: definition.name,
+            functionId: handle.functionId,
+            args: definition.args.map((arg) => arg.kind),
+            returns: definition.returns.kind,
+            fingerprint: microFingerprint(definition.name, definition.version),
+        });
+        parseWasmUnitResult(this.requireSession().registerMicro(body));
+        return handle;
+    }
+    /** Invoke a registered scalar UDF on the embedded engine. */
+    async callScalar(name, version, args) {
+        const body = encodeScalarCall(name, version, args);
+        return parseWasmScalarResult(this.requireSession().callScalar(body));
+    }
+    /** Whether this handle owns a persistent OPFS session. */
+    isPersistent() {
+        return this.kind === 'persistent';
+    }
+    close() {
+        this.session?.close();
+        this.session = null;
+    }
+    requireSession() {
+        if (!this.session) {
+            throw new Error('@yydb/yydb/wasm: database session is closed');
+        }
+        return this.session;
+    }
+}

package/dist/wasm/index.d.ts

@@ -0,0 +1,5 @@
+export { Database, type WasmOpenOptions } from './database.js';
+export { checkSchema, createMemorySession, initWasm, introspectSchema, openPersistentSession, queryMemory, resetWasmBindingForTests, yydbVersion, type CheckSchemaResult, type InitWasmOptions, type WasmInitInput, type WasmSession, } from './binding.js';
+export { defineMicro, type DefinedMicro, type MicroHandle, type TsMicroDefinitionInput, MicroSessionRegistry } from '../shared/micro.js';
+export { bool, i64, nullType, text, type InferUdfArgs, type InferUdfReturn, type MicroEffect, type MicroInvocationMode, type UdfScalarKind, type UdfTypeDescriptor, } from '../shared/udf-types.js';
+export type { SchemaVersion } from '../shared/wasm-envelope.js';

package/dist/wasm/index.js

@@ -0,0 +1,4 @@
+export { Database } from './database.js';
+export { checkSchema, createMemorySession, initWasm, introspectSchema, openPersistentSession, queryMemory, resetWasmBindingForTests, yydbVersion, } from './binding.js';
+export { defineMicro, MicroSessionRegistry } from '../shared/micro.js';
+export { bool, i64, nullType, text, } from '../shared/udf-types.js';

package/package.json

@@ -1,22 +1,31 @@
 {
   "name": "@yydb/yydb",
-  "version": "0.0.4",
-  "description": "YYDB all-in-one for Node: embedded engine, CLI, and local serve",
+  "version": "0.0.5",
+  "description": "YYDB all-in-one: Node embedded engine and CLI, browser wasm core",
   "license": "MPL-2.0",
   "type": "module",
   "bin": {
-    "yydb": "./dist/cli.js"
+    "yydb": "./dist/node/cli.js"
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/node/index.js",
+  "types": "./dist/node/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "types": "./dist/node/index.d.ts",
+      "node": "./dist/node/index.js",
+      "default": "./dist/wasm/index.js"
+    },
+    "./node": {
+      "types": "./dist/node/index.d.ts",
+      "import": "./dist/node/index.js"
+    },
+    "./wasm": {
+      "types": "./dist/wasm/index.d.ts",
+      "import": "./dist/wasm/index.js"
     },
     "./cli": {
-      "types": "./dist/cli.d.ts",
-      "import": "./dist/cli.js"
+      "types": "./dist/node/cli.d.ts",
+      "import": "./dist/node/cli.js"
     }
   },
   "files": [
@@ -24,8 +33,8 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "pnpm run build && node --experimental-strip-types --test src/**/*.test.ts"
+    "build": "tsc -p tsconfig.node.json && tsc -p tsconfig.wasm.json",
+    "test": "pnpm run build && node --experimental-strip-types --test src/node/**/*.test.ts src/shared/**/*.test.ts"
   },
   "repository": {
     "type": "git",
@@ -48,7 +57,8 @@
   },
   "dependencies": {
     "@vmz/commander": "^0.2.0",
-    "@yydb/yydb-client": "0.0.4"
+    "@yydb/yydb-client": "0.0.5",
+    "@yydb/yydb-unknown-wasm32": "0.0.5"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",
@@ -58,9 +68,9 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@yydb/yydb-win32-x64": "0.0.4",
-    "@yydb/yydb-linux-x64": "0.0.4",
-    "@yydb/yydb-darwin-x64": "0.0.4",
-    "@yydb/yydb-darwin-arm64": "0.0.4"
+    "@yydb/yydb-win32-x64": "0.0.5",
+    "@yydb/yydb-linux-x64": "0.0.5",
+    "@yydb/yydb-darwin-x64": "0.0.5",
+    "@yydb/yydb-darwin-arm64": "0.0.5"
   }
 }