@yydb/yydb 0.0.3 → 0.0.5

package/README.md

@@ -1,32 +1,36 @@
 # `@yydb/yydb`
 
-**All-in-one YYDB for Node.js: CLI, embedded engine, and local `serve`.**
+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.
 
-Open a `.yydb` file with one dependency — `@yydb/yydb` spawns a private loopback server and 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`](../yydb-client).
+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)
-[![Check Rust](https://github.com/yy-database/yydb/actions/workflows/check-rust.yml/badge.svg?branch=dev)](https://github.com/yy-database/yydb/actions/workflows/check-rust.yml)
-[![Check TypeScript](https://github.com/yy-database/yydb/actions/workflows/check-typescript.yml/badge.svg?branch=dev)](https://github.com/yy-database/yydb/actions/workflows/check-typescript.yml)
 
-## Install
+## Exports
 
-```bash
-npm install @yydb/yydb
-```
+| 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+. Platform `.node` bindings install via optional dependencies.
 
-Node.js 18 or newer is supported. The matching `yydb-napi` binding is installed as an optional platform dependency and
-is
-started on a private loopback endpoint when `Database.open()` runs.
+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,
@@ -37,20 +41,41 @@ await db.ensureSchema(
     }`,
 );
 
-await db.put("theme", "dark");
-const value = await db.get("theme");
-console.log(value && new TextDecoder().decode(value));
-
+await db.put('theme', 'dark');
+console.log(await db.get('theme'));
 await db.close();
 ```
 
-The database file is created if it does not exist. The VOS schema and its version are stored with the data, so reopening
-the file does not depend on a separate schema registry.
+The file is created when missing. Schema version and VOS document persist with the data.
+
+## 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.
 
-## API
+## Wasm API
 
 ```ts
-const db = await Database.open(path, options ?);
+const db = await Database.openInMemory();
+// or: const db = await Database.open('app.yydb');
 
 await db.ensureSchema(version, vosDocument);
 await db.getSchema();
@@ -58,33 +83,45 @@ await db.put(key, stringOrBytes);
 await db.get(key);
 await db.info();
 await db.serverVersion();
-await db.close();
+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();
 ```
 
-`OpenOptions` supports `cli` (an explicit CLI script path), `port` (a preferred loopback port), and `serveArgs` (extra
-arguments forwarded to `yydb serve`). `binary` is a deprecated alias for `cli`.
+## Node API
+
+```ts
+const db = await Database.open(path, options?);
 
-## Use a different package when
+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]);
+await db.close();
+```
 
-| Need                                   | Package                                   |
-|----------------------------------------|-------------------------------------------|
-| Node all-in-one (CLI + engine + serve) | **`@yydb/yydb`** (this package)           |
-| Lightweight wire client only           | [`@yydb/yydb-client`](../yydb-client)     |
-| In-process Rust embed                  | [`yydb`](https://crates.io/crates/yydb)   |
-| Rust wire server crate (used by N-API) | [`yydb-server`](../../crates/yydb-server) |
-| Rust remote client                     | [`yydb-client`](../../crates/yydb-client) |
+`OpenOptions`: `cli` (explicit CLI script path), `port` (preferred loopback port), `serveArgs` (extra `yydb serve`
+arguments). `binary` is a deprecated alias for `cli`.
 
-For Electron, the main process can use `@yydb/yydb`; renderer code can use
-`@yydb/yydb-client` against the main process endpoint.
+## Related packages
 
-## Security
+| 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) |
 
-The managed engine listens on `127.0.0.1` and has no authentication layer. Keep the endpoint private and use the
-operating system's file permissions for the `.yydb` file.
+Electron: main process can use `@yydb/yydb/node`; renderer code can use `@yydb/yydb-client` against the main-process
+endpoint.
 
-## Links
+The managed engine listens on `127.0.0.1` with no authentication — keep the endpoint private.
 
-- [YYDB overview](https://github.com/yy-database/yydb.rs)
-- [User guides](https://github.com/yy-database/yydb.rs/tree/dev/projects/packages/homepage/documentation/zh-hans)
-- [API documentation](https://docs.rs/yydb)
-- [License](https://github.com/yy-database/yydb.rs/blob/dev/License.md)
+[YYDB overview](https://github.com/yy-database/yydb.rs) · [User guides](https://github.com/yy-database/yydb.rs/tree/dev/projects/packages/homepage/documentation/zh-hans)

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

@@ -1,19 +1,17 @@
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createCli } from '@vmz/commander';
-import { registerGenerateCommand } from './generate-cmd.js';
 import { registerInfoCommand } from './info-cmd.js';
 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);
     registerInfoCommand(cli);
     registerServeCommand(cli);
-    registerGenerateCommand(cli);
     return cli;
 }
 export async function runCli(argv) {

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,26 +1,31 @@
 {
   "name": "@yydb/yydb",
-  "version": "0.0.3",
-  "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"
     },
-    "./cli": {
-      "types": "./dist/cli.d.ts",
-      "import": "./dist/cli.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"
     },
-    "./generator": {
-      "types": "./dist/generator/index.d.ts",
-      "import": "./dist/generator/index.js"
+    "./cli": {
+      "types": "./dist/node/cli.d.ts",
+      "import": "./dist/node/cli.js"
     }
   },
   "files": [
@@ -28,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",
@@ -52,7 +57,8 @@
   },
   "dependencies": {
     "@vmz/commander": "^0.2.0",
-    "@yydb/yydb-client": "0.0.3"
+    "@yydb/yydb-client": "0.0.5",
+    "@yydb/yydb-unknown-wasm32": "0.0.5"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",
@@ -62,9 +68,9 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@yydb/yydb-win32-x64": "0.0.3",
-    "@yydb/yydb-linux-x64": "0.0.3",
-    "@yydb/yydb-darwin-x64": "0.0.3",
-    "@yydb/yydb-darwin-arm64": "0.0.3"
+    "@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"
   }
 }

package/dist/cli/generate-cmd.d.ts

@@ -1,3 +0,0 @@
-import type { Cli, ParsedOptions } from '@vmz/commander';
-export declare function registerGenerateCommand(cli: Cli): void;
-export declare function cmdGenerate(options: ParsedOptions): number;

package/dist/cli/generate-cmd.js

@@ -1,25 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { generateTypeScript } from '../generator/index.js';
-import { requiredPositional, str } from './options.js';
-export function registerGenerateCommand(cli) {
-    cli.command('generate', 'cli.cmd.generate')
-        .option('-o, --output <path>', 'cli.opt.output')
-        .option('--schema-version <n>', 'cli.opt.schema-version')
-        .action((options) => cmdGenerate(options));
-}
-export function cmdGenerate(options) {
-    const input = requiredPositional(options, 'generate');
-    const output = str(options, 'output');
-    if (!output) {
-        throw new Error('generate requires --output <path>');
-    }
-    const schemaVersion = Number.parseInt(str(options, 'schema-version') ?? '1', 10);
-    const source = fs.readFileSync(input, 'utf8');
-    const ts = generateTypeScript(source, schemaVersion);
-    const outPath = path.resolve(output);
-    fs.mkdirSync(path.dirname(outPath), { recursive: true });
-    fs.writeFileSync(outPath, ts);
-    console.log(`wrote ${outPath}`);
-    return 0;
-}

package/dist/generator/emit-typescript.d.ts

@@ -1,3 +0,0 @@
-import { type TsSchemaIr } from './ir.js';
-/** Generate `schema.generated.ts` source from IR. */
-export declare function emitTypeScript(ir: TsSchemaIr): string;

package/dist/generator/emit-typescript.js

@@ -1,26 +0,0 @@
-import { scalarToTs } from './ir.js';
-const BANNER = '// @generated by `yydb generate`, do not edit!';
-/** Generate `schema.generated.ts` source from IR. */
-export function emitTypeScript(ir) {
-    const lines = [BANNER];
-    lines.push(`export const APP_SCHEMA_VERSION = ${ir.schemaVersion};`);
-    lines.push(`export const APP_SCHEMA = ${JSON.stringify(ir.vosSource)};`);
-    for (const table of ir.tables) {
-        lines.push(emitInterfaceRow(table));
-    }
-    lines.push(emitInterfaceAppDb(ir));
-    lines.push(`export type AppDbTableName = keyof AppDb["tables"];`);
-    return `${lines.join('\n')}\n`;
-}
-function emitInterfaceRow(table) {
-    const lines = [`export interface ${table.name}Row {`];
-    for (const field of table.fields) {
-        lines.push(`    ${field.name}: ${scalarToTs(field.ty)};`);
-    }
-    lines.push('}');
-    return lines.join('\n');
-}
-function emitInterfaceAppDb(ir) {
-    const tableLines = ir.tables.map((table) => `        ${table.name}: ${table.name}Row;`);
-    return ['export interface AppDb {', '    tables: {', ...tableLines, '    };', '}'].join('\n');
-}

package/dist/generator/fixtures/setting.generated.d.ts

@@ -1,13 +0,0 @@
-export declare const APP_SCHEMA_VERSION = 1;
-export declare const APP_SCHEMA = "table Setting {\n    @@id: uuid,\n    key: utf8,\n    value: utf8,\n}\n";
-export interface SettingRow {
-    id: string;
-    key: string;
-    value: string;
-}
-export interface AppDb {
-    tables: {
-        Setting: SettingRow;
-    };
-}
-export type AppDbTableName = keyof AppDb["tables"];

package/dist/generator/fixtures/setting.generated.js

@@ -1,3 +0,0 @@
-// @generated by `yydb generate`, do not edit!
-export const APP_SCHEMA_VERSION = 1;
-export const APP_SCHEMA = "table Setting {\n    @@id: uuid,\n    key: utf8,\n    value: utf8,\n}\n";

package/dist/generator/index.d.ts

@@ -1,6 +0,0 @@
-export type { SchemaField, SchemaTable, ScalarType, TsSchemaIr } from './ir.js';
-export { emitTypeScript } from './emit-typescript.js';
-export { parseVosSubset, VosParseError } from './parse-vos.js';
-/** Generate TypeScript from a VOS document. */
-export declare function generateTypeScript(vosSource: string, schemaVersion: number): string;
-export { generateTypeScript as generateTypescript };

package/dist/generator/index.js

@@ -1,10 +0,0 @@
-import { emitTypeScript } from './emit-typescript.js';
-import { parseVosSubset } from './parse-vos.js';
-export { emitTypeScript } from './emit-typescript.js';
-export { parseVosSubset, VosParseError } from './parse-vos.js';
-/** Generate TypeScript from a VOS document. */
-export function generateTypeScript(vosSource, schemaVersion) {
-    const ir = parseVosSubset(vosSource, schemaVersion);
-    return emitTypeScript(ir);
-}
-export { generateTypeScript as generateTypescript };

package/dist/generator/ir.d.ts

@@ -1,20 +0,0 @@
-/** Scalar types supported by the MVP emitter (expand with `vos-parser`). */
-export type ScalarType = 'uuid' | 'utf8' | 'bool' | 'i64' | 'f64';
-export interface SchemaField {
-    readonly name: string;
-    readonly ty: ScalarType;
-    /** True when this field is declared via `@@id`. */
-    readonly isId: boolean;
-}
-export interface SchemaTable {
-    readonly name: string;
-    readonly fields: readonly SchemaField[];
-}
-/** One schema document ready for TypeScript emission. */
-export interface TsSchemaIr {
-    /** Original VOS source (database truth embedded into generated module). */
-    readonly vosSource: string;
-    readonly schemaVersion: number;
-    readonly tables: readonly SchemaTable[];
-}
-export declare function scalarToTs(ty: ScalarType): string;

package/dist/generator/ir.js

@@ -1,12 +0,0 @@
-export function scalarToTs(ty) {
-    switch (ty) {
-        case 'uuid':
-        case 'utf8':
-            return 'string';
-        case 'bool':
-            return 'boolean';
-        case 'i64':
-        case 'f64':
-            return 'number';
-    }
-}

package/dist/generator/parse-vos.d.ts

@@ -1,6 +0,0 @@
-import type { TsSchemaIr } from './ir.js';
-export declare class VosParseError extends Error {
-    constructor(message: string);
-}
-/** Interim VOS subset parser for `yydb generate` (MVP). */
-export declare function parseVosSubset(source: string, schemaVersion: number): TsSchemaIr;

package/dist/generator/parse-vos.js

@@ -1,149 +0,0 @@
-export class VosParseError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'VosParseError';
-    }
-}
-/** Interim VOS subset parser for `yydb generate` (MVP). */
-export function parseVosSubset(source, schemaVersion) {
-    if (source.includes('\0')) {
-        throw new VosParseError('VOS document must not contain NUL bytes');
-    }
-    let normalized = source.startsWith('\uFEFF') ? source.slice(1) : source;
-    normalized = normalized.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-    const lexer = new Lexer(normalized);
-    const tables = [];
-    while (!lexer.eof()) {
-        lexer.skipWsAndComments();
-        if (lexer.eof()) {
-            break;
-        }
-        tables.push(parseTable(lexer));
-    }
-    if (tables.length === 0) {
-        throw new VosParseError('expected at least one `table` declaration');
-    }
-    return {
-        vosSource: normalized,
-        schemaVersion,
-        tables,
-    };
-}
-function parseTable(lexer) {
-    lexer.expectIdent('table');
-    const name = lexer.expectAnyIdent();
-    lexer.expectPunct('{');
-    const fields = [];
-    while (true) {
-        lexer.skipWsAndComments();
-        if (lexer.eatPunct('}')) {
-            break;
-        }
-        if (lexer.eatPunct('@')) {
-            lexer.expectPunct('@');
-            const attr = lexer.expectAnyIdent();
-            if (attr !== 'id') {
-                throw new VosParseError(`unsupported table attribute \`@@${attr}\` (MVP supports \`@@id\` only)`);
-            }
-            lexer.expectPunct(':');
-            const ty = parseScalar(lexer);
-            fields.push({ name: 'id', ty, isId: true });
-        }
-        else {
-            const fieldName = lexer.expectAnyIdent();
-            lexer.expectPunct(':');
-            const ty = parseScalar(lexer);
-            fields.push({ name: fieldName, ty, isId: false });
-        }
-        lexer.skipWsAndComments();
-        lexer.eatPunct(',');
-    }
-    if (!fields.some((field) => field.isId)) {
-        throw new VosParseError(`table \`${name}\` requires \`@@id: <type>\``);
-    }
-    return { name, fields };
-}
-function parseScalar(lexer) {
-    const name = lexer.expectAnyIdent();
-    switch (name) {
-        case 'uuid':
-            return 'uuid';
-        case 'utf8':
-            return 'utf8';
-        case 'bool':
-            return 'bool';
-        case 'i64':
-            return 'i64';
-        case 'f64':
-            return 'f64';
-        default:
-            throw new VosParseError(`unsupported scalar type \`${name}\` (MVP: uuid, utf8, bool, i64, f64)`);
-    }
-}
-class Lexer {
-    src;
-    i = 0;
-    constructor(src) {
-        this.src = src;
-    }
-    eof() {
-        return this.i >= this.src.length;
-    }
-    peek() {
-        return this.src[this.i];
-    }
-    bump() {
-        const ch = this.peek();
-        if (ch === undefined) {
-            return undefined;
-        }
-        this.i += 1;
-        return ch;
-    }
-    skipWsAndComments() {
-        while (true) {
-            while (this.peek() !== undefined && /\s/.test(this.peek())) {
-                this.bump();
-            }
-            if (this.src.startsWith('//', this.i)) {
-                while (this.peek() !== undefined && this.peek() !== '\n') {
-                    this.bump();
-                }
-                continue;
-            }
-            break;
-        }
-    }
-    eatPunct(expected) {
-        this.skipWsAndComments();
-        if (this.peek() === expected) {
-            this.bump();
-            return true;
-        }
-        return false;
-    }
-    expectPunct(expected) {
-        if (!this.eatPunct(expected)) {
-            throw new VosParseError(`expected \`${expected}\` at byte ${this.i}`);
-        }
-    }
-    expectIdent(expected) {
-        const got = this.expectAnyIdent();
-        if (got !== expected) {
-            throw new VosParseError(`expected \`${expected}\`, found \`${got}\``);
-        }
-    }
-    expectAnyIdent() {
-        this.skipWsAndComments();
-        const start = this.i;
-        const first = this.peek();
-        if (first === undefined || !/[A-Za-z_]/.test(first)) {
-            throw new VosParseError(`expected identifier at byte ${this.i}`);
-        }
-        this.bump();
-        while (this.peek() !== undefined && /[A-Za-z0-9_]/.test(this.peek())) {
-            this.bump();
-        }
-        return this.src.slice(start, this.i);
-    }
-}