@yydb/yydb 0.0.11 → 0.0.15

package/dist/shared/errors.js

@@ -2,12 +2,46 @@
  * Host-facing YYDB error surface.
  *
  * Every public failure carries a stable `code`: engine codes come from the
- * Rust core (`yydb.schema.invalid`, …) over N-API or the wire, client codes
- * are minted locally with the `yydb.client.` prefix. Branch on `code` —
- * `message` is display text only.
+ * Rust core (`yydb.schema.invalid`, …) over N-API or the wire; client codes
+ * are minted locally with the `yydb.client.` prefix. **Branch on `code`** —
+ * `message` is display text only and must never be used for retry decisions.
+ *
+ * ## Where codes live
+ *
+ * Engine codes live in Rust (`yydb_types::Error` variants → DiagnosticEnvelope).
+ * The TS side no longer keeps a hardcoded engine-code table — when Rust gains a
+ * new variant, hosts pick up the new code string via {@link fromDiagnosticJson}
+ * without any TS change. Client codes (`yydb.client.*`) are minted only on the
+ * host side and remain available as constants below.
+ */
+/**
+ * Client-side error codes that never originate from Rust.
+ *
+ * Engine codes (`yydb.schema.*`, `yydb.udf.*`, `yydb.io`, …) are emitted by
+ * Rust and should be matched via string literals or from the diagnostic JSON
+ * envelope — they are intentionally not duplicated here.
+ */
+export const YydbClientErrorCodes = {
+    /** serve() endpoint is empty or invalid. */
+    clientInvalidEndpoint: 'yydb.client.invalid_endpoint',
+    /** connect() socket / transport layer failure. */
+    clientTransportFailure: 'yydb.client.transport_failure',
+    /** Server replied with a request id we did not send. */
+    clientRequestIdMismatch: 'yydb.client.request_id_mismatch',
+    /** Server replied with a msg_type we did not request. */
+    clientUnexpectedResponse: 'yydb.client.unexpected_response',
+    /** Could not parse an Error frame body from the wire. */
+    clientDecodeFailure: 'yydb.client.decode_failure',
+    /** The YYDB session is already closed. */
+    sessionClosed: 'yydb.session.closed',
+};
+/**
+ * @deprecated Engine codes moved to Rust — use string literals or match on
+ * {@link YydbError.code} returned from {@link fromDiagnosticJson}. This table
+ * exists only for transition; new engine error variants will **not** be added here.
  */
-/** Stable codes known to the TypeScript hosts. */
 export const YydbErrorCodes = {
+    // Engine codes (deprecated)
     io: 'yydb.io',
     corrupt: 'yydb.corrupt',
     schemaConflict: 'yydb.schema.conflict',
@@ -25,41 +59,93 @@ export const YydbErrorCodes = {
     fencingMismatch: 'yydb.fencing.mismatch',
     leaseExpired: 'yydb.lease.expired',
     quotaExceeded: 'yydb.quota.exceeded',
-    sessionClosed: 'yydb.session.closed',
-    clientInvalidEndpoint: 'yydb.client.invalid_endpoint',
-    clientTransportFailure: 'yydb.client.transport_failure',
-    clientRequestIdMismatch: 'yydb.client.request_id_mismatch',
-    clientUnexpectedResponse: 'yydb.client.unexpected_response',
-    clientDecodeFailure: 'yydb.client.decode_failure',
+    // Client codes (still canonical for client-local errors)
+    ...YydbClientErrorCodes,
 };
-/**
- * Codes where retrying the same operation can legitimately succeed: a socket or
- * lease hiccup, or a compare-and-set that lost a benign race. Every other code
- * needs the caller to change input, schema, or wiring first.
- */
-const RETRYABLE_CODES = new Set([
-    YydbErrorCodes.clientTransportFailure,
-    YydbErrorCodes.casConflict,
-    YydbErrorCodes.leaseUnavailable,
-]);
-/** Whether `code` may be retried with the same arguments. */
-export function isRetryableYydbCode(code) {
-    return RETRYABLE_CODES.has(code);
-}
 /** YYDB failure with a stable machine-readable {@link YydbError.code}. */
 export class YydbError extends Error {
-    /** Stable code — engine code or `yydb.client.*`. */
+    /** Stable code — engine code (from Rust) or `yydb.client.*`. */
     code;
     /** Operation that failed. */
     operation;
     /** Whether the same call may be retried. */
     retryable;
+    /** Structured parameters for catalog templating (when present). */
+    params;
     constructor(code, message, options = {}) {
         super(message, { cause: options.cause });
         this.name = 'YydbError';
         this.code = code;
         this.operation = options.operation ?? 'unknown';
-        this.retryable = isRetryableYydbCode(code);
+        this.retryable = options.retryable ?? false;
+        if (options.params !== undefined) {
+            this.params = options.params;
+        }
+    }
+    /**
+     * Parse the diagnostic JSON that N-API and WASM surfaces embed in their
+     * `Error.message`. Every boundary surface (N-API reason field, WASM JSON
+     * envelope, wire protocol) carries the same `{ code, operation, retryable,
+     * message, params? }` contract produced by `yydb::Error::to_json`.
+     *
+     * Returns the parsed {@link YydbError} if `value` is a diagnostic object,
+     * or `null` when the input is plain text. Hosts typically use this as a
+     * fallback in catch blocks:
+     *
+     * ```ts
+     * try {
+     *     await db.put('key', value);
+     * } catch (err) {
+     *     const parsed = YydbError.fromDiagnosticJson(
+     *         err instanceof Error ? err.message : String(err),
+     *     );
+     *     if (parsed) {
+     *         // branch on parsed.code / retryable / operation
+     *     }
+     * }
+     * ```
+     */
+    static fromDiagnosticJson(value) {
+        let obj;
+        if (typeof value === 'string') {
+            try {
+                const parsed = JSON.parse(value);
+                if (!parsed || typeof parsed !== 'object')
+                    return null;
+                obj = parsed;
+            }
+            catch {
+                return null;
+            }
+        }
+        else if (value && typeof value === 'object') {
+            obj = value;
+        }
+        else {
+            return null;
+        }
+        // WASM envelopes nest the diagnostic under `{ ok, error: {...} }`.
+        let diag = obj;
+        if (typeof obj['ok'] === 'boolean' && !obj['ok'] && obj['error'] && typeof obj['error'] === 'object') {
+            diag = obj['error'];
+        }
+        const code = typeof diag['code'] === 'string' ? diag['code'] : null;
+        const message = typeof diag['message'] === 'string' ? diag['message'] : '';
+        if (!code)
+            return null;
+        const operation = typeof diag['operation'] === 'string' ? diag['operation'] : undefined;
+        const retryable = typeof diag['retryable'] === 'boolean' ? diag['retryable'] : undefined;
+        const params = diag['params'] && typeof diag['params'] === 'object'
+            ? diag['params']
+            : undefined;
+        const opts = {};
+        if (operation !== undefined)
+            opts.operation = operation;
+        if (retryable !== undefined)
+            opts.retryable = retryable;
+        if (params !== undefined)
+            opts.params = params;
+        return new YydbError(code, message, opts);
     }
 }
 /** Narrowing helper so callers can branch without `instanceof` imports. */

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

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

package/dist/shared/wasm-envelope.js

@@ -0,0 +1,56 @@
+import { YydbError, YydbErrorCodes } from '@yydb/yydb-client';
+function parseJson(payload, operation) {
+    try {
+        return JSON.parse(payload);
+    }
+    catch (cause) {
+        throw new YydbError(YydbErrorCodes.clientDecodeFailure, `${operation}: invalid JSON envelope`, { operation, cause });
+    }
+}
+/**
+ * Build the error for a failed wasm envelope. The Rust core always sends a
+ * stable `code`; a missing one means the wasm artifact is stale, which is a
+ * decode failure rather than an engine failure.
+ */
+function envelopeError(envelope, operation) {
+    const code = envelope.code ?? YydbErrorCodes.clientDecodeFailure;
+    const message = envelope.error ?? `${operation}: wasm envelope carried no message`;
+    return new YydbError(code, message, { operation });
+}
+export function parseWasmRowsResult(payload, operation) {
+    const parsed = parseJson(payload, operation);
+    if (!parsed.ok) {
+        throw envelopeError(parsed, operation);
+    }
+    return parsed;
+}
+export function parseWasmUnitResult(payload, operation) {
+    const parsed = parseJson(payload, operation);
+    if (!parsed.ok) {
+        throw envelopeError(parsed, operation);
+    }
+}
+export function parseWasmSchemaResult(payload, operation) {
+    const parsed = parseJson(payload, operation);
+    if (!parsed.ok) {
+        throw envelopeError(parsed, operation);
+    }
+    return parsed.schema;
+}
+export function parseWasmScalarResult(payload, operation) {
+    const parsed = parseJson(payload, operation);
+    if (!parsed.ok) {
+        throw envelopeError(parsed, operation);
+    }
+    return parsed.value;
+}
+export function parseWasmKvGetResult(payload, operation) {
+    const parsed = parseJson(payload, operation);
+    if (!parsed.ok) {
+        throw envelopeError(parsed, operation);
+    }
+    if (parsed.value === null) {
+        return null;
+    }
+    return Uint8Array.from(parsed.value);
+}

package/dist/udf-types.d.ts

@@ -0,0 +1,26 @@
+/** Phase-1 scalar UDF wire kinds aligned with `yydb-udf`. */
+export type UdfScalarKind = 'i64' | 'bool' | 'text' | 'null';
+/** Runtime type descriptor used in `defineMicro` contracts. */
+export interface UdfTypeDescriptor<T = unknown> {
+    readonly kind: UdfScalarKind;
+    /** Phantom type for author-side inference only. */
+    readonly _type?: T;
+}
+/** `i64` argument or return descriptor. */
+export declare function i64(): UdfTypeDescriptor<number>;
+/** `bool` argument or return descriptor. */
+export declare function bool(): UdfTypeDescriptor<boolean>;
+/** `text` argument or return descriptor. */
+export declare function text(): UdfTypeDescriptor<string>;
+/** `null` return descriptor. */
+export declare function nullType(): UdfTypeDescriptor<null>;
+/** Maps descriptor tuple types to positional argument types. */
+export type InferUdfArgs<T extends readonly UdfTypeDescriptor[]> = {
+    [K in keyof T]: T[K] extends UdfTypeDescriptor<infer V> ? V : never;
+};
+/** Maps a return descriptor to its value type. */
+export type InferUdfReturn<T extends UdfTypeDescriptor> = T extends UdfTypeDescriptor<infer V> ? V : never;
+/** Session micro effect surface (Phase 1: pure only). */
+export type MicroEffect = 'pure';
+/** Invocation mode stored with the definition for future batch host calls. */
+export type MicroInvocationMode = 'scalar' | 'batch';

package/dist/udf-types.js

@@ -0,0 +1,16 @@
+/** `i64` argument or return descriptor. */
+export function i64() {
+    return { kind: 'i64' };
+}
+/** `bool` argument or return descriptor. */
+export function bool() {
+    return { kind: 'bool' };
+}
+/** `text` argument or return descriptor. */
+export function text() {
+    return { kind: 'text' };
+}
+/** `null` return descriptor. */
+export function nullType() {
+    return { kind: 'null' };
+}

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,54 @@
+import { defineMicro as buildMicro, type DefinedMicro, type MicroHandle } from '../shared/micro.js';
+import type { UdfScalarDescriptor } 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 UdfScalarDescriptor[], TReturn extends UdfScalarDescriptor>(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 UdfScalarDescriptor[], TReturn extends UdfScalarDescriptor>(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 the embedded session. Idempotent; further calls fail with `yydb.session.closed`. */
+    close(): Promise<void>;
+    private requireSession;
+}

package/dist/wasm/database.js

@@ -0,0 +1,118 @@
+import { encodeMicroRegister, encodeScalarCall, YydbError, YydbErrorCodes } from '@yydb/yydb-client';
+import { defineMicro as buildMicro, microFingerprint, udfWireKind, 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').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('schemaEnsure').ensureSchema(document), 'schemaEnsure');
+    }
+    async getSchema() {
+        return parseWasmSchemaResult(this.requireSession('schemaGet').getSchema(), 'schemaGet');
+    }
+    async get(key) {
+        return parseWasmKvGetResult(this.requireSession('kvGet').get(key), 'kvGet');
+    }
+    async put(key, value) {
+        const bytes = typeof value === 'string' ? new TextEncoder().encode(value) : value;
+        parseWasmUnitResult(this.requireSession('kvPut').put(key, bytes), 'kvPut');
+    }
+    /** VOS read pipeline (for example `User.filter(x => x.active).collect()`). */
+    query(source) {
+        return parseWasmRowsResult(this.requireSession('query').query(source), 'query').rows;
+    }
+    /** Unit-valued VOS write programs (for example `User { … }.insert()`). */
+    execute(source) {
+        parseWasmUnitResult(this.requireSession('execute').execute(source), 'execute');
+    }
+    /**
+     * 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(udfWireKind),
+            returns: udfWireKind(definition.returns),
+            fingerprint: microFingerprint(definition.name, definition.version),
+        });
+        parseWasmUnitResult(this.requireSession('microRegister').registerMicro(body), 'microRegister');
+        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').callScalar(body), 'callScalar');
+    }
+    /** Whether this handle owns a persistent OPFS session. */
+    isPersistent() {
+        return this.kind === 'persistent';
+    }
+    /** Close the embedded session. Idempotent; further calls fail with `yydb.session.closed`. */
+    async close() {
+        const session = this.session;
+        this.session = null;
+        session?.close();
+    }
+    requireSession(operation) {
+        if (!this.session) {
+            throw new YydbError(YydbErrorCodes.sessionClosed, `${operation}: @yydb/yydb/wasm session is closed`, { operation });
+        }
+        return this.session;
+    }
+}

package/dist/wasm/index.d.ts

@@ -0,0 +1,8 @@
+export { Database, type WasmOpenOptions } from './database.js';
+export { YydbError, YydbErrorCodes, isRetryableYydbCode, isYydbError } from '@yydb/yydb-client';
+export type { YydbErrorCode, YydbErrorOptions } from '@yydb/yydb-client';
+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 { type InferUdfArgs, type InferUdfReturn, type MicroEffect, type MicroInvocationMode, type UdfScalarDescriptor, type UdfScalarKind, } from '../shared/udf-types.js';
+export type { SchemaVersion } from '../shared/wasm-envelope.js';
+export * from '../shared/vos.js';

package/dist/wasm/index.js

@@ -0,0 +1,5 @@
+export { Database } from './database.js';
+export { YydbError, YydbErrorCodes, isRetryableYydbCode, isYydbError } from '@yydb/yydb-client';
+export { checkSchema, createMemorySession, initWasm, introspectSchema, openPersistentSession, queryMemory, resetWasmBindingForTests, yydbVersion, } from './binding.js';
+export { defineMicro, MicroSessionRegistry } from '../shared/micro.js';
+export * from '../shared/vos.js';

package/package.json

@@ -1,41 +1,38 @@
 {
-  "name": "@yydb/yydb",
-  "version": "0.0.11",
-  "description": "YYDB Node embedded engine and CLI",
-  "license": "MPL-2.0",
-  "type": "module",
   "bin": {
     "yydb": "./dist/cli.js"
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "bugs": {
+    "url": "https://github.com/yy-database/yydb.rs/issues"
+  },
+  "dependencies": {
+    "@vmz/commander": "^0.3.5",
+    "@vmz/diagnostic": "^0.3.5",
+    "@voml/vos": "^0.0.1"
+  },
+  "description": "YYDB Node embedded engine and CLI",
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "~5.3.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
     },
     "./cli": {
-      "types": "./dist/cli.d.ts",
-      "import": "./dist/cli.js"
+      "import": "./dist/cli.js",
+      "types": "./dist/cli.d.ts"
     }
   },
   "files": [
     "dist",
     "README.md"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "pnpm run build && node --experimental-strip-types --test src/**/*.test.ts"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/yy-database/yydb.git",
-    "directory": "projects/packages/yydb"
-  },
-  "homepage": "https://github.com/yy-database/yydb/tree/dev/projects/packages/yydb#readme",
-  "bugs": {
-    "url": "https://github.com/yy-database/yydb/issues"
-  },
+  "homepage": "https://github.com/yy-database/yydb.rs/tree/dev/projects/packages/yydb#readme",
   "keywords": [
     "yydb",
     "vos",
@@ -43,25 +40,28 @@
     "embedded",
     "typescript"
   ],
+  "license": "MPL-2.0",
+  "main": "./dist/index.js",
+  "name": "@yydb/yydb",
+  "optionalDependencies": {
+    "@yydb/yydb-darwin-arm64": "0.0.15",
+    "@yydb/yydb-darwin-x64": "0.0.15",
+    "@yydb/yydb-linux-x64": "0.0.15",
+    "@yydb/yydb-win32-x64": "0.0.15"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "@vmz/commander": "^0.3.5",
-    "@vmz/diagnostic": "^0.3.5",
-    "@voml/vos": "^0.0.1"
-  },
-  "devDependencies": {
-    "@types/node": "^20.10.0",
-    "typescript": "~5.3.0"
+  "repository": {
+    "directory": "projects/packages/yydb",
+    "type": "git",
+    "url": "git+https://github.com/yy-database/yydb.rs.git"
   },
-  "engines": {
-    "node": ">=18"
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "pnpm run build && node --experimental-strip-types --test src/**/*.test.ts"
   },
-  "optionalDependencies": {
-    "@yydb/yydb-darwin-arm64": "0.0.11",
-    "@yydb/yydb-darwin-x64": "0.0.11",
-    "@yydb/yydb-linux-x64": "0.0.11",
-    "@yydb/yydb-win32-x64": "0.0.11"
-  }
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "version": "0.0.15"
 }