@yydb/yydb 0.0.12 → 0.0.16

package/dist/api/database.d.ts

@@ -43,6 +43,38 @@ export interface MigrateOptions {
         toField: string;
     }>;
 }
+/** One consistency finding from {@link Database.doctor}. */
+export interface DoctorIssue {
+    severity: 'warn' | 'error';
+    code: string;
+    message: string;
+    key_hint?: string | null;
+}
+/** Per-namespace usage snapshot from {@link Database.doctor}. */
+export interface DoctorNamespaceStats {
+    prefix: string;
+    record_count: number;
+    bytes_used: number;
+    object_bytes: number;
+    quota_max_bytes?: number | null;
+    ttl_expired_pending: number;
+}
+/** Read-only consistency report. */
+export interface DoctorReport {
+    file_path?: string | null;
+    last_commit_sequence: number;
+    last_checkpoint_sequence: number;
+    checkpoint_lag_records: number;
+    wal_bytes_uncheckpointed: number;
+    orphan_object_count: number;
+    namespaces: DoctorNamespaceStats[];
+    issues: DoctorIssue[];
+}
+/** Summary of a v0 `.yydx` compaction pass. */
+export interface CompactReport {
+    checkpointed: boolean;
+    orphans_reclaimed: number;
+}
 /**
  * Transaction-local handle passed to {@link Database.transaction} callbacks.
  * All CRUD methods forward to the underlying native handle while the
@@ -108,6 +140,14 @@ export declare class Database {
     compareExchange(key: string, expected: Uint8Array | string | null, replacement: Uint8Array | string | null): Promise<boolean>;
     /** Fold the WAL into the main file and truncate the sidecar. */
     checkpoint(): Promise<void>;
+    /** Checkpoint then copy a self-contained `.yydb` main file to `dest`. */
+    backup(dest: string): Promise<void>;
+    /** Copy main + WAL + SHM without checkpoint; opening `dest` replays the WAL tail. */
+    backupWithWal(dest: string): Promise<void>;
+    /** Run read-only consistency probes against the database. */
+    doctor(): Promise<DoctorReport>;
+    /** Fold WAL + reclaim orphan blobs (`.yydx` layouts only). */
+    compactYydx(): Promise<CompactReport>;
     /**
      * Run `fn` inside an explicit transaction. The transaction commits on
      * normal return and rolls back on throw. Nested calls are not supported.

package/dist/api/database.js

@@ -150,6 +150,22 @@ export class Database {
     async checkpoint() {
         this.native.checkpoint();
     }
+    /** Checkpoint then copy a self-contained `.yydb` main file to `dest`. */
+    async backup(dest) {
+        this.native.backup(dest);
+    }
+    /** Copy main + WAL + SHM without checkpoint; opening `dest` replays the WAL tail. */
+    async backupWithWal(dest) {
+        this.native.backupWithWal(dest);
+    }
+    /** Run read-only consistency probes against the database. */
+    async doctor() {
+        return JSON.parse(this.native.doctor());
+    }
+    /** Fold WAL + reclaim orphan blobs (`.yydx` layouts only). */
+    async compactYydx() {
+        return JSON.parse(this.native.compactYydx());
+    }
     /**
      * Run `fn` inside an explicit transaction. The transaction commits on
      * normal return and rolls back on throw. Nested calls are not supported.

package/dist/cli/cli.js

@@ -1,16 +1,22 @@
-import { dirname, join } from 'node:path';
+import fs from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createCli } from '@vmz/commander';
+import { formatDiagnostic } from '@vmz/diagnostic';
+import { YydbError } from '../shared/errors.js';
 import { registerInfoCommand } from './info-cmd.js';
 import { registerInitCommand } from './init-cmd.js';
 import { registerServeCommand } from './serve-cmd.js';
+import { registerVerifyCommand } from './verify-cmd.js';
 import { registerVersionCommand } from './version-cmd.js';
+const CLI_CATALOG = JSON.parse(fs.readFileSync(resolve(import.meta.dirname, '../../locales/en-US/cli.json'), 'utf8'));
 function buildYydbCli() {
     const localesRoot = join(dirname(fileURLToPath(import.meta.url)), '../../locales');
     const cli = createCli('yydb').locales(localesRoot).intro('cli.intro');
     registerVersionCommand(cli);
     registerInitCommand(cli);
     registerInfoCommand(cli);
+    registerVerifyCommand(cli);
     registerServeCommand(cli);
     return cli;
 }
@@ -19,6 +25,27 @@ export async function runCli(argv) {
         return await buildYydbCli().parse(argv);
     }
     catch (error) {
+        const parsed = error instanceof Error
+            ? YydbError.fromDiagnosticJson(error.message)
+            : null;
+        if (parsed) {
+            // Structured engine error from N-API / wire / WASM envelope.
+            const severity = parsed.retryable ? 'warning' : 'error';
+            const text = formatDiagnostic({
+                path: '',
+                severity,
+                code: parsed.code,
+                args: parsed.params,
+                message: error instanceof Error ? error.message : String(error),
+            }, {
+                locale: 'en-US',
+                catalog: CLI_CATALOG,
+                style: 'compact',
+            });
+            console.error(text);
+            return parsed.retryable ? 13 : 1;
+        }
+        // Plain text fallback (commander parse failures, unknown errors).
         console.error(`error: ${error instanceof Error ? error.message : String(error)}`);
         return 1;
     }

package/dist/cli/info-cmd.js

@@ -1,10 +1,17 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { formatDiagnostic } from '@vmz/diagnostic';
 import { loadNative } from '../native/binding.js';
 import { requiredPositional } from './options.js';
+const CLI_CATALOG = JSON.parse(fs.readFileSync(path.resolve(import.meta.dirname, '../../locales/en-US/cli.json'), 'utf8'));
 export function registerInfoCommand(cli) {
-    cli.command('info', 'cli.cmd.info').action((options) => cmdInfo(options));
+    cli.command('info', 'cli.cmd.info')
+        .option('--doctor', 'cli.opt.doctor')
+        .action((options) => cmdInfo(options));
 }
 export function cmdInfo(options) {
     const dbPath = requiredPositional(options, 'info');
+    const wantDoctor = Boolean(options.doctor);
     const database = loadNative().Database.open(dbPath);
     const lines = [`path=${database.path() ?? '<memory>'}`];
     const schemaVersion = database.schemaVersion();
@@ -25,6 +32,28 @@ export function cmdInfo(options) {
         lines.push(`shm=${shm}`);
     lines.push(`wal_frames=${database.walFrameCount()}`);
     console.log(lines.join('\n'));
+    if (wantDoctor) {
+        const report = JSON.parse(database.doctor());
+        if (report.issues.length === 0) {
+            console.log(`doctor=clean orphan_objects=${report.orphan_object_count}`);
+        }
+        else {
+            for (const issue of report.issues) {
+                const severity = issue.severity === 'error' ? 'error' : 'warning';
+                console.error(formatDiagnostic({
+                    path: dbPath,
+                    severity,
+                    code: issue.code,
+                    message: issue.message,
+                }, {
+                    locale: 'en-US',
+                    catalog: CLI_CATALOG,
+                    style: 'compact',
+                }));
+            }
+            console.error(`doctor=issues(${report.issues.length}) orphans=${report.orphan_object_count}`);
+        }
+    }
     return 0;
 }
 function summarizeDocument(document) {

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

@@ -0,0 +1,11 @@
+import type { Cli, ParsedOptions } from '@vmz/commander';
+export declare function registerVerifyCommand(cli: Cli): void;
+/**
+ * Run read-only consistency probes against a YYDB database file.
+ *
+ * Exit codes:
+ *   0  — clean (no issues)
+ *   1  — doctor found at least one error (database may be corrupt)
+ *   13 — only warnings present (readable but should be inspected)
+ */
+export declare function cmdVerify(options: ParsedOptions): number;

package/dist/cli/verify-cmd.js

@@ -0,0 +1,73 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { formatDiagnostic } from '@vmz/diagnostic';
+import { loadNative } from '../native/binding.js';
+import { requiredPositional } from './options.js';
+/**
+ * Inline CLI catalog — commander's `.locales()` resolution is not exposed
+ * outside the CLI builder, so we ship a static copy here. Only one locale is
+ * loaded at runtime; future locale awareness should resolve the chosen locale
+ * from commander internals once they surface it.
+ */
+const CLI_CATALOG = JSON.parse(fs.readFileSync(path.resolve(import.meta.dirname, '../../locales/en-US/cli.json'), 'utf8'));
+const DIAGNOSTIC_STYLE = 'compact';
+const DIAGNOSTIC_LOCALE = 'en-US';
+export function registerVerifyCommand(cli) {
+    cli.command('verify', 'cli.cmd.verify').action((options) => cmdVerify(options));
+}
+/**
+ * Run read-only consistency probes against a YYDB database file.
+ *
+ * Exit codes:
+ *   0  — clean (no issues)
+ *   1  — doctor found at least one error (database may be corrupt)
+ *   13 — only warnings present (readable but should be inspected)
+ */
+export function cmdVerify(options) {
+    const dbPath = requiredPositional(options, 'verify');
+    let report;
+    try {
+        const native = loadNative();
+        const db = native.Database.open(dbPath);
+        report = JSON.parse(db.doctor());
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(formatDiagnostic({
+            path: dbPath,
+            severity: 'error',
+            code: 'cli.err.open_failed',
+            args: { path: dbPath, reason: message },
+        }, {
+            locale: DIAGNOSTIC_LOCALE,
+            catalog: CLI_CATALOG,
+            style: DIAGNOSTIC_STYLE,
+        }));
+        return 1;
+    }
+    for (const issue of report.issues) {
+        const severity = issue.severity === 'error' ? 'error' : 'warning';
+        console.error(formatDiagnostic({
+            path: dbPath,
+            severity,
+            code: issue.code,
+            message: issue.message,
+        }, {
+            locale: DIAGNOSTIC_LOCALE,
+            catalog: CLI_CATALOG,
+            style: DIAGNOSTIC_STYLE,
+        }));
+    }
+    const errCount = report.issues.filter((i) => i.severity === 'error').length;
+    const warnCount = report.issues.length - errCount;
+    if (errCount > 0) {
+        console.log(`exit=1 errors=${errCount} warnings=${warnCount}`);
+        return 1;
+    }
+    if (warnCount > 0) {
+        console.log(`exit=13 errors=0 warnings=${warnCount}`);
+        return 13;
+    }
+    console.log(`exit=0 clean last_commit=${report.last_commit_sequence}`);
+    return 0;
+}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { Database, type OpenOptions, type SchemaVersion } from './api/database.js';
-export { YydbError, YydbErrorCodes, isRetryableYydbCode, isYydbError } from './shared/errors.js';
+export { YydbError, YydbErrorCodes, YydbClientErrorCodes, 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';

package/dist/index.js

@@ -1,5 +1,5 @@
 export { Database } from './api/database.js';
-export { YydbError, YydbErrorCodes, isRetryableYydbCode, isYydbError } from './shared/errors.js';
+export { YydbError, YydbErrorCodes, YydbClientErrorCodes, 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

@@ -38,6 +38,14 @@ export interface NativeDatabase {
     executeVosWrite(source: string): void;
     /** Publish a new schema version, optionally with rename map. */
     migrateSchema(document: string, renamesJson?: string | null): void;
+    /** Checkpoint + copy self-contained `.yydb` main file (no WAL sidecars). */
+    backup(dest: string): void;
+    /** Copy main + WAL + SHM without checkpoint (opening replays the tail). */
+    backupWithWal(dest: string): void;
+    /** Read-only consistency probe; returns DoctorReport JSON. */
+    doctor(): string;
+    /** Fold WAL + reclaim orphan blobs (`.yydx` only); returns CompactReport JSON. */
+    compactYydx(): string;
     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;
 }

package/dist/shared/errors.d.ts

@@ -2,12 +2,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.
+ * 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 declare const YydbClientErrorCodes: {
+    /** serve() endpoint is empty or invalid. */
+    readonly clientInvalidEndpoint: "yydb.client.invalid_endpoint";
+    /** connect() socket / transport layer failure. */
+    readonly clientTransportFailure: "yydb.client.transport_failure";
+    /** Server replied with a request id we did not send. */
+    readonly clientRequestIdMismatch: "yydb.client.request_id_mismatch";
+    /** Server replied with a msg_type we did not request. */
+    readonly clientUnexpectedResponse: "yydb.client.unexpected_response";
+    /** Could not parse an Error frame body from the wire. */
+    readonly clientDecodeFailure: "yydb.client.decode_failure";
+    /** The YYDB session is already closed. */
+    readonly 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 declare const YydbErrorCodes: {
+    /** serve() endpoint is empty or invalid. */
+    readonly clientInvalidEndpoint: "yydb.client.invalid_endpoint";
+    /** connect() socket / transport layer failure. */
+    readonly clientTransportFailure: "yydb.client.transport_failure";
+    /** Server replied with a request id we did not send. */
+    readonly clientRequestIdMismatch: "yydb.client.request_id_mismatch";
+    /** Server replied with a msg_type we did not request. */
+    readonly clientUnexpectedResponse: "yydb.client.unexpected_response";
+    /** Could not parse an Error frame body from the wire. */
+    readonly clientDecodeFailure: "yydb.client.decode_failure";
+    /** The YYDB session is already closed. */
+    readonly sessionClosed: "yydb.session.closed";
     readonly io: "yydb.io";
     readonly corrupt: "yydb.corrupt";
     readonly schemaConflict: "yydb.schema.conflict";
@@ -25,21 +70,23 @@ export declare const YydbErrorCodes: {
     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;
+/** Any stable YYDB error code string — engine, client, or future variant. */
+export type YydbErrorCode = string;
 /** Options carried by a {@link YydbError}. */
 export interface YydbErrorOptions {
     /** Operation that failed (`schemaGet`, `kvPut`, `query`, …). */
     operation?: string;
+    /**
+     * Whether the caller may retry with the same arguments.
+     *
+     * When omitted, constructor defaults to `false` (conservative). Callers
+     * that mint their own errors (especially client-local retryable ones like
+     * `yydb.client.transport_failure`) **must** set this explicitly. Engine
+     * errors coming through {@link fromDiagnosticJson} always carry the Rust-
+     * authoritative `retryable` value and override the default.
+     */
+    retryable?: boolean;
     /** Structured parameters for catalog templating (when present). */
     params?: Readonly<Record<string, string>>;
     /** Underlying failure when this error wraps one. */
@@ -47,7 +94,7 @@ export interface YydbErrorOptions {
 }
 /** YYDB failure with a stable machine-readable {@link YydbError.code}. */
 export declare class YydbError extends Error {
-    /** Stable code — engine code or `yydb.client.*`. */
+    /** Stable code — engine code (from Rust) or `yydb.client.*`. */
     readonly code: string;
     /** Operation that failed. */
     readonly operation: string;

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,30 +59,12 @@ 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;
@@ -61,8 +77,10 @@ export class YydbError extends Error {
         this.name = 'YydbError';
         this.code = code;
         this.operation = options.operation ?? 'unknown';
-        this.retryable = isRetryableYydbCode(code);
-        this.params = options.params;
+        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
@@ -106,23 +124,28 @@ export class YydbError extends Error {
         else {
             return null;
         }
-        const code = typeof obj.code === 'string' ? obj.code : null;
-        const message = typeof obj.message === 'string' ? obj.message : '';
+        // 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 obj.operation === 'string' ? obj.operation : undefined;
-        const retryable = typeof obj.retryable === 'boolean' ? obj.retryable : undefined;
-        const params = obj.params && typeof obj.params === 'object'
-            ? obj.params
+        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 err = new YydbError(code, message, {
-            operation,
-            params,
-        });
-        if (typeof retryable === 'boolean') {
-            err.retryable = retryable;
-        }
-        return err;
+        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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yydb/yydb",
-  "version": "0.0.12",
+  "version": "0.0.16",
   "description": "YYDB Node embedded engine and CLI",
   "license": "MPL-2.0",
   "type": "module",
@@ -59,9 +59,9 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@yydb/yydb-darwin-arm64": "0.0.12",
-    "@yydb/yydb-darwin-x64": "0.0.12",
-    "@yydb/yydb-linux-x64": "0.0.12",
-    "@yydb/yydb-win32-x64": "0.0.12"
+    "@yydb/yydb-darwin-arm64": "0.0.16",
+    "@yydb/yydb-darwin-x64": "0.0.16",
+    "@yydb/yydb-linux-x64": "0.0.16",
+    "@yydb/yydb-win32-x64": "0.0.16"
   }
 }