@yydb/yydb 0.0.7 → 0.0.10

package/README.md

@@ -1,8 +1,10 @@
 # `@yydb/yydb`
 
-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
-and schema on memory or OPFS paths.
+Node embedded engine and CLI. `Database.open` starts a private loopback `yydb serve` process and talks over the YY
+wire protocol; platform `.node` bindings install through optional dependencies.
+
+Browsers are served by the pure TypeScript [`@yydb/light-db`](../light-db/readme.md) package. This package no longer
+ships a WebAssembly entry.
 
 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).
@@ -14,18 +16,14 @@ For a wire client only (renderer or an app that already runs `yydb serve`), use
 
 | 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` | Node | `Database.open`, micro helpers, VOS re-exports |
 | `@yydb/yydb/cli` | Node | CLI (`version`, `init`, `info`, `serve`) |
 
-Node.js 18+. Platform `.node` bindings install via optional dependencies.
+Node.js 18+.
 
-Schema truth lives in the `.yydb` file via `ensureSchema` and VOS documents. Wasm sessions mirror KV and schema calls
-on the embedded core.
+Schema truth lives in the `.yydb` file via `ensureSchema` and VOS documents.
 
-## Node example
+## Example
 
 ```ts
 import { Database } from '@yydb/yydb';
@@ -48,47 +46,7 @@ await db.close();
 
 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.
-
-## 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.close();
-```
-
-## Node API
+## API
 
 ```ts
 const db = await Database.open(path, options?);
@@ -107,17 +65,20 @@ await db.close();
 `OpenOptions`: `cli` (explicit CLI script path), `port` (preferred loopback port), `serveArgs` (extra `yydb serve`
 arguments). `binary` is a deprecated alias for `cli`.
 
+The native binding exposes additive operations (`schemaVersion`, `schemaDocument`, `recordCount`, `journalMode`,
+`checkpoint`, `walFrameCount`, `get`, `put`); the CLI composes commands from them.
+
 ## Related packages
 
 | Need | Package |
 |------|---------|
-| Node all-in-one (this package) | **`@yydb/yydb`** or `@yydb/yydb/node` |
-| Browser wasm entry | **`@yydb/yydb/wasm`** |
+| Node embedded engine and CLI (this package) | **`@yydb/yydb`** |
+| Browser, pure TypeScript | **`@yydb/light-db`** |
 | 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/node`; renderer code can use `@yydb/yydb-client` against the main-process
+Electron: main process can use `@yydb/yydb`; 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/api/database.d.ts

@@ -0,0 +1,73 @@
+import { type EmittableItem } from '@voml/vos';
+import { defineMicro as buildMicro, type DefinedMicro, type MicroHandle } from '../shared/micro.js';
+import type { UdfScalarDescriptor } from '../shared/udf-types.js';
+/** Published schema metadata. */
+export interface SchemaVersion {
+    version: number;
+    document: string;
+}
+/** Options for opening a local YYDB file. */
+export interface OpenOptions {
+    /** Create parent directories when missing (default: true). */
+    mkdir?: boolean;
+}
+/**
+ * Node-facing YYDB local database handle.
+ *
+ * Directly owns a native `yydb::Connection` via the Node-API binding. No
+ * child process, no loopback TCP, no wire protocol in the hot path.
+ */
+export declare class Database {
+    readonly path: string;
+    private readonly native;
+    private readonly microRegistry;
+    private constructor();
+    /** Open (create when missing) the database at `dbPath`. */
+    static open(dbPath: string, options?: OpenOptions): Promise<Database>;
+    /** Engine version string (same as `yydb --version`). */
+    serverVersion(): string;
+    /** Basic diagnostics: path, schema, record count, journal mode. */
+    info(): string;
+    /** Published schema metadata, or `null` before the first schema. */
+    getSchema(): Promise<{
+        version: number;
+        document: string;
+    } | null>;
+    /**
+     * Validate and publish a VOS schema document.
+     *
+     * Accepts either a raw `.vos` source string, one `@voml/vos` descriptor
+     * (`v.table()`, `v.class()`) or a list of descriptors. When descriptors
+     * are supplied, they are rendered to source via `emitSource` first.
+     *
+     * ```ts
+     * // Raw source (unchanged behaviour):
+     * await db.ensureSchema('namespace demo { table User { @@id: uuid } }');
+     *
+     * // Zod-like builder — the Vos schema-ecosystem sweet spot:
+     * const User = v.table('User', { id: v.uuid().primary(), name: v.utf8() });
+     * await db.ensureSchema(User);
+     *
+     * // Multiple declarations in one shot:
+     * await db.ensureSchema(TableA, TableB, ClassC);
+     * ```
+     */
+    ensureSchema(...input: [string] | [string, ...EmittableItem[]] | EmittableItem[]): Promise<void>;
+    /** Read one record, or `null` when the key is absent. */
+    get(key: string): Promise<Uint8Array | null>;
+    /** Insert or replace one record. */
+    put(key: string, value: Uint8Array | string): Promise<void>;
+    /** Fold the WAL into the main file and truncate the sidecar. */
+    checkpoint(): Promise<void>;
+    /** Build a typed session-local micro definition (without registering). */
+    defineMicro<TArgs extends readonly UdfScalarDescriptor[], TReturn extends UdfScalarDescriptor>(definition: Parameters<typeof buildMicro<TArgs, TReturn>>[0]): DefinedMicro<TArgs, TReturn>;
+    /**
+     * Install a session-local host micro into both the local registry and the
+     * native engine. Host micros never persist across processes.
+     */
+    registerMicro<TArgs extends readonly UdfScalarDescriptor[], TReturn extends UdfScalarDescriptor>(definition: DefinedMicro<TArgs, TReturn>): Promise<MicroHandle>;
+    /** Invoke a registered scalar UDF on the native engine. */
+    callScalar(name: string, version: number, args: readonly (string | number | boolean | null)[]): Promise<string | number | boolean | null>;
+    /** Release the native handle (best-effort; the engine also drops on GC). */
+    close(): Promise<void>;
+}

package/dist/api/database.js

@@ -0,0 +1,124 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { emitSource, } from '@voml/vos';
+import { defineMicro as buildMicro, microFingerprint, udfWireKind, MicroSessionRegistry, } from '../shared/micro.js';
+import { loadNative } from '../native/binding.js';
+/**
+ * Node-facing YYDB local database handle.
+ *
+ * Directly owns a native `yydb::Connection` via the Node-API binding. No
+ * child process, no loopback TCP, no wire protocol in the hot path.
+ */
+export class Database {
+    path;
+    native;
+    microRegistry;
+    constructor(dbPath, native) {
+        this.path = dbPath;
+        this.native = native;
+        this.microRegistry = new MicroSessionRegistry();
+    }
+    /** Open (create when missing) the database at `dbPath`. */
+    static async open(dbPath, options = {}) {
+        const resolved = path.resolve(dbPath);
+        if (options.mkdir !== false) {
+            fs.mkdirSync(path.dirname(resolved), { recursive: true });
+        }
+        const native = loadNative();
+        const db = native.Database.open(resolved);
+        return new Database(resolved, db);
+    }
+    /** Engine version string (same as `yydb --version`). */
+    serverVersion() {
+        return loadNative().version();
+    }
+    /** Basic diagnostics: path, schema, record count, journal mode. */
+    info() {
+        const lines = [
+            `path=${this.native.path() ?? '<memory>'}`,
+            `schema.version=${this.native.schemaVersion() ?? ''}`,
+            `records=${this.native.recordCount()}`,
+            `journal_mode=${this.native.journalMode()}`,
+        ];
+        return lines.join('\n') + '\n';
+    }
+    /** Published schema metadata, or `null` before the first schema. */
+    async getSchema() {
+        const version = this.native.schemaVersion();
+        const document = this.native.schemaDocument();
+        if (version === null || document === null) {
+            return null;
+        }
+        return { version, document };
+    }
+    /**
+     * Validate and publish a VOS schema document.
+     *
+     * Accepts either a raw `.vos` source string, one `@voml/vos` descriptor
+     * (`v.table()`, `v.class()`) or a list of descriptors. When descriptors
+     * are supplied, they are rendered to source via `emitSource` first.
+     *
+     * ```ts
+     * // Raw source (unchanged behaviour):
+     * await db.ensureSchema('namespace demo { table User { @@id: uuid } }');
+     *
+     * // Zod-like builder — the Vos schema-ecosystem sweet spot:
+     * const User = v.table('User', { id: v.uuid().primary(), name: v.utf8() });
+     * await db.ensureSchema(User);
+     *
+     * // Multiple declarations in one shot:
+     * await db.ensureSchema(TableA, TableB, ClassC);
+     * ```
+     */
+    async ensureSchema(...input) {
+        let document;
+        if (typeof input[0] === 'string') {
+            // Raw source string, optionally followed by descriptors we just ignore.
+            document = input[0];
+        }
+        else {
+            // One or more Vos descriptor items → render to source.
+            document = emitSource(input);
+        }
+        this.native.ensureSchema(document);
+    }
+    /** Read one record, or `null` when the key is absent. */
+    async get(key) {
+        return this.native.get(key);
+    }
+    /** Insert or replace one record. */
+    async put(key, value) {
+        const bytes = typeof value === 'string' ? new TextEncoder().encode(value) : value;
+        this.native.put(key, bytes);
+    }
+    /** Fold the WAL into the main file and truncate the sidecar. */
+    async checkpoint() {
+        this.native.checkpoint();
+    }
+    /** Build a typed session-local micro definition (without registering). */
+    defineMicro(definition) {
+        return buildMicro(definition);
+    }
+    /**
+     * Install a session-local host micro into both the local registry and the
+     * native engine. Host micros never persist across processes.
+     */
+    async registerMicro(definition) {
+        const handle = this.microRegistry.register(definition);
+        const argTypes = definition.args.map((d) => udfWireKind(d));
+        const returnType = udfWireKind(definition.returns);
+        this.native.registerMicro(definition.name, definition.version, argTypes, returnType, handle.hostId, handle.functionId, handle.implementationVersion, microFingerprint(definition.name, definition.version));
+        return handle;
+    }
+    /** Invoke a registered scalar UDF on the native engine. */
+    async callScalar(name, version, args) {
+        const argsJson = JSON.stringify(args);
+        const resultJson = this.native.callScalar(name, version, argsJson);
+        return JSON.parse(resultJson);
+    }
+    /** Release the native handle (best-effort; the engine also drops on GC). */
+    async close() {
+        // Native connections drop cleanly when the handle is garbage-collected.
+        // No explicit close() is exposed from yydb::Connection.
+    }
+}

package/dist/{node/cli → 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/cli/info-cmd.js

@@ -0,0 +1,37 @@
+import { loadNative } from '../native/binding.js';
+import { requiredPositional } from './options.js';
+export function registerInfoCommand(cli) {
+    cli.command('info', 'cli.cmd.info').action((options) => cmdInfo(options));
+}
+export function cmdInfo(options) {
+    const dbPath = requiredPositional(options, 'info');
+    const database = loadNative().Database.open(dbPath);
+    const lines = [`path=${database.path() ?? '<memory>'}`];
+    const schemaVersion = database.schemaVersion();
+    if (schemaVersion === null) {
+        lines.push('schema=(none)');
+    }
+    else {
+        lines.push(`schema.version=${schemaVersion}`);
+        lines.push(`schema.document=${summarizeDocument(database.schemaDocument())}`);
+    }
+    lines.push(`records=${database.recordCount()}`);
+    lines.push(`journal_mode=${database.journalMode()}`);
+    const wal = database.walPath();
+    const shm = database.shmPath();
+    if (wal !== null)
+        lines.push(`wal=${wal}`);
+    if (shm !== null)
+        lines.push(`shm=${shm}`);
+    lines.push(`wal_frames=${database.walFrameCount()}`);
+    console.log(lines.join('\n'));
+    return 0;
+}
+function summarizeDocument(document) {
+    const trimmed = (document ?? '').trim();
+    if (trimmed.length === 0)
+        return '(empty)';
+    const limit = 120;
+    const flat = trimmed.replace(/\n/g, ' ');
+    return flat.length <= limit ? flat : `${flat.slice(0, limit)}…`;
+}

package/dist/{node/cli → cli}/init-cmd.js

@@ -1,18 +1,18 @@
-import { loadNative } from '../native.js';
+import fs from 'node:fs';
+import { loadNative } from '../native/binding.js';
 import { requiredPositional, str } from './options.js';
 export function registerInitCommand(cli) {
     cli.command('init', 'cli.cmd.init')
-        .option('--schema-version <n>', 'cli.opt.schema-version')
         .option('--schema-file <path>', 'cli.opt.schema-file')
         .action((options) => cmdInit(options));
 }
 export function cmdInit(options) {
     const dbPath = requiredPositional(options, 'init');
-    const schemaVersion = Number.parseInt(str(options, 'schema-version') ?? '1', 10);
     const schemaFile = str(options, 'schema-file');
-    const native = loadNative();
-    const schemaDocument = schemaFile ? native.readSchemaFile(schemaFile) : null;
-    native.initDb(dbPath, schemaVersion, schemaDocument);
+    const database = loadNative().Database.open(dbPath);
+    if (schemaFile) {
+        database.ensureSchema(fs.readFileSync(schemaFile, 'utf8'));
+    }
     console.log(`initialized ${dbPath}`);
     return 0;
 }

package/dist/{node/cli → cli}/serve-cmd.js

@@ -1,4 +1,4 @@
-import { loadNative } from '../native.js';
+import { loadNative } from '../native/binding.js';
 import { flag, requiredPositional, str } from './options.js';
 export function registerServeCommand(cli) {
     cli.command('serve', 'cli.cmd.serve')

package/dist/{node/cli → cli}/version-cmd.js

@@ -1,4 +1,4 @@
-import { loadNative } from '../native.js';
+import { loadNative } from '../native/binding.js';
 export function registerVersionCommand(cli) {
     cli.command('version', 'cli.cmd.version').action(() => cmdVersion());
 }

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { Database, type OpenOptions, type SchemaVersion } from './api/database.js';
+export { YydbError, YydbErrorCodes, isRetryableYydbCode, isYydbError } from './shared/errors.js';
+export type { YydbErrorCode, YydbErrorOptions } from './shared/errors.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 { nativeBindingName, platformKey, resolveYydbBinary, resolveYydbCli } from './native/resolve.js';
+export * from './shared/vos.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export { Database } from './api/database.js';
+export { YydbError, YydbErrorCodes, isRetryableYydbCode, isYydbError } from './shared/errors.js';
+export { defineMicro, MicroSessionRegistry } from './shared/micro.js';
+export { nativeBindingName, platformKey, resolveYydbBinary, resolveYydbCli } from './native/resolve.js';
+export * from './shared/vos.js';

package/dist/native/binding.d.ts

@@ -0,0 +1,50 @@
+/** Schema version returned by N-API Database.schema_version / Client.schema_version. */
+export interface NativeSchemaVersion {
+    version: number;
+    document: string;
+}
+/** One open `.yydb` handle exposed by the native binding. */
+export interface NativeDatabase {
+    path(): string | null;
+    walPath(): string | null;
+    shmPath(): string | null;
+    schemaVersion(): number | null;
+    schemaDocument(): string | null;
+    ensureSchema(document: string): void;
+    recordCount(): number;
+    journalMode(): string;
+    setJournalMode(mode: string): void;
+    checkpoint(): void;
+    walFrameCount(): number;
+    get(key: string): Uint8Array | null;
+    put(key: string, value: Uint8Array): void;
+    registerMicro(name: string, version: number, args: string[], returns: string, hostId: number, functionId: string, handleVersion: number, fingerprint: Uint8Array): void;
+    callScalar(name: string, version: number, argsJson: string): string;
+}
+/** One remote `yydb serve` handle exposed by the native binding. */
+export interface NativeClient {
+    endpoint(): string;
+    serverVersion(): string;
+    info(): string;
+    schemaVersion(): number | null;
+    schemaDocument(): string | null;
+    ensureSchema(document: string): void;
+    get(key: string): Uint8Array | null;
+    put(key: string, value: Uint8Array): void;
+    registerMicro(name: string, version: number, args: string[], returns: string, hostId: number, functionId: string, handleVersion: number, fingerprint: Uint8Array): void;
+    callScalar(name: string, version: number, argsJson: string): string;
+    close(): void;
+}
+/** Atomic operations exported by the Node-API binding. */
+export interface YydbNative {
+    version(): string;
+    serve(dbPath: string, bind: string, insecureBind?: boolean): void;
+    Database: {
+        open(dbPath: string): NativeDatabase;
+    };
+    Client: {
+        connect(endpoint: string): NativeClient;
+    };
+}
+/** Load the platform native binding used by the `yydb` CLI. */
+export declare function loadNative(): YydbNative;

package/dist/{node/native.js → native/binding.js}

@@ -1,7 +1,7 @@
 import { createRequire } from 'node:module';
 import fs from 'node:fs';
 import path from 'node:path';
-import { platformKey } from './resolve-bin.js';
+import { platformKey } from './resolve.js';
 function loadModule(specifier) {
     const require = createRequire(import.meta.url);
     const loaded = require(specifier);

package/dist/{node/resolve-bin.js → native/resolve.js}

@@ -48,7 +48,7 @@ export function resolveYydbCli() {
         return path.resolve(fromEnv);
     }
     const here = path.dirname(fileURLToPath(import.meta.url));
-    const candidate = path.join(here, 'cli.js');
+    const candidate = path.join(here, '..', 'cli.js');
     if (!existsFile(candidate)) {
         throw new Error('YYDB CLI script not found. Build `@yydb/yydb` (`pnpm --filter @yydb/yydb build`) or set YYDB_CLI.');
     }

package/dist/shared/errors.d.ts

@@ -0,0 +1,57 @@
+/**
+ * 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.
+ */
+/** Stable codes known to the TypeScript hosts. */
+export declare const YydbErrorCodes: {
+    readonly io: "yydb.io";
+    readonly corrupt: "yydb.corrupt";
+    readonly schemaConflict: "yydb.schema.conflict";
+    readonly schemaInvalid: "yydb.schema.invalid";
+    readonly udfNotFound: "yydb.udf.not_found";
+    readonly udfArity: "yydb.udf.arity";
+    readonly udfFailed: "yydb.udf.failed";
+    readonly udfVersionMismatch: "yydb.udf.version_mismatch";
+    readonly objectNotFound: "yydb.object.not_found";
+    readonly objectCorrupt: "yydb.object.corrupt";
+    readonly unsupported: "yydb.unsupported";
+    readonly protocol: "yydb.protocol";
+    readonly casConflict: "yydb.cas.conflict";
+    readonly leaseUnavailable: "yydb.lease.unavailable";
+    readonly fencingMismatch: "yydb.fencing.mismatch";
+    readonly leaseExpired: "yydb.lease.expired";
+    readonly quotaExceeded: "yydb.quota.exceeded";
+    readonly sessionClosed: "yydb.session.closed";
+    readonly clientInvalidEndpoint: "yydb.client.invalid_endpoint";
+    readonly clientTransportFailure: "yydb.client.transport_failure";
+    readonly clientRequestIdMismatch: "yydb.client.request_id_mismatch";
+    readonly clientUnexpectedResponse: "yydb.client.unexpected_response";
+    readonly clientDecodeFailure: "yydb.client.decode_failure";
+};
+/** A known code, or any future code the engine introduces. */
+export type YydbErrorCode = (typeof YydbErrorCodes)[keyof typeof YydbErrorCodes] | (string & {});
+/** Whether `code` may be retried with the same arguments. */
+export declare function isRetryableYydbCode(code: string): boolean;
+/** Options carried by a {@link YydbError}. */
+export interface YydbErrorOptions {
+    /** Operation that failed (`schemaGet`, `kvPut`, `query`, …). */
+    operation?: string;
+    /** Underlying failure when this error wraps one. */
+    cause?: unknown;
+}
+/** YYDB failure with a stable machine-readable {@link YydbError.code}. */
+export declare class YydbError extends Error {
+    /** Stable code — engine code or `yydb.client.*`. */
+    readonly code: string;
+    /** Operation that failed. */
+    readonly operation: string;
+    /** Whether the same call may be retried. */
+    readonly retryable: boolean;
+    constructor(code: YydbErrorCode, message: string, options?: YydbErrorOptions);
+}
+/** Narrowing helper so callers can branch without `instanceof` imports. */
+export declare function isYydbError(value: unknown): value is YydbError;

package/dist/shared/errors.js

@@ -0,0 +1,68 @@
+/**
+ * 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.
+ */
+/** Stable codes known to the TypeScript hosts. */
+export const YydbErrorCodes = {
+    io: 'yydb.io',
+    corrupt: 'yydb.corrupt',
+    schemaConflict: 'yydb.schema.conflict',
+    schemaInvalid: 'yydb.schema.invalid',
+    udfNotFound: 'yydb.udf.not_found',
+    udfArity: 'yydb.udf.arity',
+    udfFailed: 'yydb.udf.failed',
+    udfVersionMismatch: 'yydb.udf.version_mismatch',
+    objectNotFound: 'yydb.object.not_found',
+    objectCorrupt: 'yydb.object.corrupt',
+    unsupported: 'yydb.unsupported',
+    protocol: 'yydb.protocol',
+    casConflict: 'yydb.cas.conflict',
+    leaseUnavailable: 'yydb.lease.unavailable',
+    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',
+};
+/**
+ * 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.*`. */
+    code;
+    /** Operation that failed. */
+    operation;
+    /** Whether the same call may be retried. */
+    retryable;
+    constructor(code, message, options = {}) {
+        super(message, { cause: options.cause });
+        this.name = 'YydbError';
+        this.code = code;
+        this.operation = options.operation ?? 'unknown';
+        this.retryable = isRetryableYydbCode(code);
+    }
+}
+/** Narrowing helper so callers can branch without `instanceof` imports. */
+export function isYydbError(value) {
+    return value instanceof YydbError;
+}

package/dist/shared/micro.d.ts

@@ -12,7 +12,7 @@ type UdfWireKind = 'i64' | 'bool' | 'text';
  * subset instead of letting it reach the engine.
  */
 export declare function udfWireKind(descriptor: AnyTypeDescriptor): UdfWireKind;
-/** Input accepted by [`Database.defineMicro`](./database.ts). */
+/** Input accepted by [`Database.defineMicro`](../api/database.ts). */
 export interface TsMicroDefinitionInput<TArgs extends readonly UdfScalarDescriptor[], TReturn extends UdfScalarDescriptor> {
     readonly name: string;
     readonly version: number;

package/package.json

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

package/dist/node/cli/info-cmd.js

@@ -1,10 +0,0 @@
-import { loadNative } from '../native.js';
-import { requiredPositional } from './options.js';
-export function registerInfoCommand(cli) {
-    cli.command('info', 'cli.cmd.info').action((options) => cmdInfo(options));
-}
-export function cmdInfo(options) {
-    const dbPath = requiredPositional(options, 'info');
-    console.log(loadNative().infoText(dbPath));
-    return 0;
-}

package/dist/node/database.d.ts

@@ -1,50 +0,0 @@
-import { defineMicro as buildMicro, type DefinedMicro, type MicroHandle } from '../shared/micro.js';
-import type { UdfScalarDescriptor } from '../shared/udf-types.js';
-export type { SchemaVersion } from '@yydb/yydb-client';
-export interface OpenOptions {
-    /** Override CLI script path (tests / special installs). */
-    cli?: string;
-    /** @deprecated Use `cli`. */
-    binary?: string;
-    /** Prefer a specific loopback port; default = ephemeral free port. */
-    port?: number;
-    /** Extra args after `serve <path> --bind …`. */
-    serveArgs?: string[];
-}
-/**
- * Node-facing YYDB handle. Looks like one library; owns a private loopback
- * `yydb serve` child under the hood.
- */
-export declare class Database {
-    readonly path: string;
-    readonly endpoint: string;
-    private client;
-    private child;
-    private readonly microRegistry;
-    private constructor();
-    /**
-     * Open (create) a `.yydb` file. Spawns the engine on `127.0.0.1` automatically.
-     */
-    static open(dbPath: string, options?: OpenOptions): Promise<Database>;
-    serverVersion(): Promise<string>;
-    info(): Promise<string>;
-    getSchema(): Promise<import("@yydb/yydb-client").SchemaVersion | null>;
-    ensureSchema(version: number, document: string): Promise<void>;
-    get(key: string): Promise<Uint8Array | null>;
-    put(key: string, value: Uint8Array | string): Promise<void>;
-    /**
-     * Build a typed session-local micro definition. Does not register it with
-     * the engine until [`registerMicro`](./database.ts) is called.
-     */
-    defineMicro<TArgs extends readonly UdfScalarDescriptor[], TReturn extends UdfScalarDescriptor>(definition: Parameters<typeof buildMicro<TArgs, TReturn>>[0]): DefinedMicro<TArgs, TReturn>;
-    /**
-     * Install a [`defineMicro`](./database.ts) definition into the current
-     * session registry and sync metadata to the private engine. Host micros are
-     * session-local and never written to `.yydb`.
-     */
-    registerMicro<TArgs extends readonly UdfScalarDescriptor[], TReturn extends UdfScalarDescriptor>(definition: DefinedMicro<TArgs, TReturn>): Promise<MicroHandle>;
-    /** Invoke a registered scalar UDF on the private engine. */
-    callScalar(name: string, version: number, args: readonly (string | number | boolean | null)[]): Promise<string | number | boolean | null>;
-    /** Stop the private engine process. */
-    close(): Promise<void>;
-}

package/dist/node/database.js

@@ -1,173 +0,0 @@
-import { spawn } from 'node:child_process';
-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, microFingerprint, udfWireKind, MicroSessionRegistry, } from '../shared/micro.js';
-import { resolveYydbCli } from './resolve-bin.js';
-async function freeLoopbackPort() {
-    return await new Promise((resolve, reject) => {
-        const server = net.createServer();
-        server.listen(0, '127.0.0.1', () => {
-            const address = server.address();
-            if (!address || typeof address === 'string') {
-                server.close();
-                reject(new Error('could not allocate loopback port'));
-                return;
-            }
-            const { port } = address;
-            server.close((error) => {
-                if (error)
-                    reject(error);
-                else
-                    resolve(port);
-            });
-        });
-        server.on('error', reject);
-    });
-}
-async function waitForTcp(host, port, timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        try {
-            await new Promise((resolve, reject) => {
-                const socket = net.connect({ host, port }, () => {
-                    socket.end();
-                    resolve();
-                });
-                socket.on('error', reject);
-            });
-            return;
-        }
-        catch {
-            await new Promise((r) => setTimeout(r, 40));
-        }
-    }
-    throw new Error(`yydb engine did not accept connections on ${host}:${port}`);
-}
-/**
- * Node-facing YYDB handle. Looks like one library; owns a private loopback
- * `yydb serve` child under the hood.
- */
-export class Database {
-    path;
-    endpoint;
-    client;
-    child;
-    microRegistry;
-    constructor(dbPath, endpoint, client, child) {
-        this.path = dbPath;
-        this.endpoint = endpoint;
-        this.client = client;
-        this.child = child;
-        this.microRegistry = new MicroSessionRegistry();
-        this.client.setMicroHostHandler((payload) => this.microRegistry.invokeFromWire(payload));
-    }
-    /**
-     * Open (create) a `.yydb` file. Spawns the engine on `127.0.0.1` automatically.
-     */
-    static async open(dbPath, options = {}) {
-        const resolved = path.resolve(dbPath);
-        fs.mkdirSync(path.dirname(resolved), { recursive: true });
-        const cli = options.cli ?? options.binary ?? resolveYydbCli();
-        const port = options.port ?? (await freeLoopbackPort());
-        const bind = `127.0.0.1:${port}`;
-        const args = [cli, 'serve', resolved, '--bind', bind, ...(options.serveArgs ?? [])];
-        const child = spawn(process.execPath, args, {
-            stdio: 'pipe',
-            windowsHide: true,
-        });
-        let stderr = '';
-        child.stderr?.setEncoding('utf8');
-        child.stderr?.on('data', (chunk) => {
-            stderr += chunk;
-        });
-        const exitPromise = new Promise((_, reject) => {
-            child.once('exit', (code, signal) => {
-                reject(new Error(`yydb engine exited early (code=${code}, signal=${signal}): ${stderr.trim()}`));
-            });
-            child.once('error', reject);
-        });
-        try {
-            await Promise.race([waitForTcp('127.0.0.1', port, 8000), exitPromise]);
-            const client = await connect(bind);
-            child.removeAllListeners('exit');
-            child.removeAllListeners('error');
-            child.on('exit', () => {
-                /* closed via Database.close or crash */
-            });
-            return new Database(resolved, bind, client, child);
-        }
-        catch (error) {
-            child.kill('SIGTERM');
-            throw error;
-        }
-    }
-    async serverVersion() {
-        return this.client.serverVersion();
-    }
-    async info() {
-        return this.client.info();
-    }
-    async getSchema() {
-        return this.client.getSchema();
-    }
-    async ensureSchema(version, document) {
-        await this.client.ensureSchema(version, document);
-    }
-    async get(key) {
-        return this.client.get(key);
-    }
-    async put(key, value) {
-        await this.client.put(key, value);
-    }
-    /**
-     * Build a typed session-local micro definition. Does not register it with
-     * the engine until [`registerMicro`](./database.ts) is called.
-     */
-    defineMicro(definition) {
-        return buildMicro(definition);
-    }
-    /**
-     * Install a [`defineMicro`](./database.ts) definition into the current
-     * session registry and sync metadata to the private engine. Host micros are
-     * session-local and never written to `.yydb`.
-     */
-    async registerMicro(definition) {
-        const handle = this.microRegistry.register(definition);
-        await this.client.registerMicro({
-            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),
-        });
-        return handle;
-    }
-    /** Invoke a registered scalar UDF on the private engine. */
-    async callScalar(name, version, args) {
-        return this.client.callScalar(name, version, args);
-    }
-    /** Stop the private engine process. */
-    async close() {
-        this.client.close();
-        const child = this.child;
-        this.child = null;
-        if (!child || child.exitCode !== null || child.killed) {
-            return;
-        }
-        await new Promise((resolve) => {
-            child.once('exit', () => resolve());
-            child.kill('SIGTERM');
-            setTimeout(() => {
-                if (child.exitCode === null && !child.killed) {
-                    child.kill('SIGKILL');
-                }
-                resolve();
-            }, 2000);
-        });
-    }
-}

package/dist/node/index.d.ts

@@ -1,7 +0,0 @@
-export { Database, type OpenOptions } from './database.js';
-export { YydbError, YydbErrorCodes, isRetryableYydbCode, isYydbError } from '@yydb/yydb-client';
-export type { YydbErrorCode, YydbErrorOptions } from '@yydb/yydb-client';
-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 { nativeBindingName, platformKey, resolveYydbBinary, resolveYydbCli } from './resolve-bin.js';
-export * from '../shared/vos.js';

package/dist/node/index.js

@@ -1,5 +0,0 @@
-export { Database } from './database.js';
-export { YydbError, YydbErrorCodes, isRetryableYydbCode, isYydbError } from '@yydb/yydb-client';
-export { defineMicro, MicroSessionRegistry } from '../shared/micro.js';
-export { nativeBindingName, platformKey, resolveYydbBinary, resolveYydbCli } from './resolve-bin.js';
-export * from '../shared/vos.js';

package/dist/node/native.d.ts

@@ -1,9 +0,0 @@
-export interface YydbNative {
-    version(): string;
-    serve(dbPath: string, bind: string, insecureBind?: boolean): void;
-    initDb(dbPath: string, schemaVersion: number, schemaDocument?: string | null): void;
-    infoText(dbPath: string): string;
-    readSchemaFile(schemaPath: string): string;
-}
-/** Load the platform native binding used by the `yydb` CLI. */
-export declare function loadNative(): YydbNative;

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

@@ -1,40 +0,0 @@
-/** Parsed `{ ok, rows, error, code }` envelope from wasm unit-valued 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 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

@@ -1,49 +0,0 @@
-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 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/wasm/binding.d.ts

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

package/dist/wasm/binding.js

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

package/dist/wasm/database.d.ts

@@ -1,50 +0,0 @@
-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>;
-    /**
-     * 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

@@ -1,110 +0,0 @@
-import { encodeMicroRegister, encodeScalarCall, YydbError, YydbErrorCodes } from '@yydb/yydb-client';
-import { defineMicro as buildMicro, microFingerprint, udfWireKind, MicroSessionRegistry, } from '../shared/micro.js';
-import { parseWasmKvGetResult, 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');
-    }
-    /**
-     * 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

@@ -1,8 +0,0 @@
-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, 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

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