@yydb/yydb 0.0.11 → 0.0.15

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/database.d.ts

@@ -0,0 +1,50 @@
+import { defineMicro as buildMicro, type DefinedMicro, type MicroHandle } from './micro.js';
+import type { UdfTypeDescriptor } from './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 UdfTypeDescriptor[], TReturn extends UdfTypeDescriptor>(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 UdfTypeDescriptor[], TReturn extends UdfTypeDescriptor>(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/database.js

@@ -0,0 +1,181 @@
+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, MicroSessionRegistry } from './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();
+        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((arg) => arg.kind),
+            returns: definition.returns.kind,
+            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/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/micro.d.ts

@@ -0,0 +1,63 @@
+import type { InferUdfArgs, InferUdfReturn, MicroEffect, MicroInvocationMode, UdfTypeDescriptor } from './udf-types.js';
+/** Input accepted by [`Database.defineMicro`](./database.ts). */
+export interface TsMicroDefinitionInput<TArgs extends readonly UdfTypeDescriptor[], TReturn extends UdfTypeDescriptor> {
+    readonly name: string;
+    readonly version: number;
+    readonly args: TArgs;
+    readonly returns: TReturn;
+    readonly effect: MicroEffect;
+    readonly deterministic: boolean;
+    readonly mode?: MicroInvocationMode;
+    readonly fn: (...args: InferUdfArgs<TArgs>) => InferUdfReturn<TReturn>;
+}
+/** Opaque definition produced by `defineMicro` before session registration. */
+export interface DefinedMicro<TArgs extends readonly UdfTypeDescriptor[] = readonly UdfTypeDescriptor[], TReturn extends UdfTypeDescriptor = UdfTypeDescriptor> {
+    readonly name: string;
+    readonly version: number;
+    readonly args: TArgs;
+    readonly returns: TReturn;
+    readonly effect: MicroEffect;
+    readonly deterministic: boolean;
+    readonly mode: MicroInvocationMode;
+    readonly placement: 'host';
+    readonly fn: (...args: InferUdfArgs<TArgs>) => InferUdfReturn<TReturn>;
+}
+/** Handle returned after `registerMicro` installs a micro into the session. */
+export interface MicroHandle {
+    readonly name: string;
+    readonly version: number;
+    readonly functionId: string;
+    readonly hostId: number;
+    /** Monotonic host implementation version for opaque handle checks. */
+    readonly implementationVersion: number;
+}
+type AnyDefinedMicro = DefinedMicro<readonly UdfTypeDescriptor[], UdfTypeDescriptor>;
+/**
+ * Process-local registry for JS functions behind opaque host handles.
+ * Rust keeps `host_id + function_id + version`, not the closure.
+ */
+export declare class MicroSessionRegistry {
+    readonly hostId: number;
+    private nextFunctionId;
+    private readonly byKey;
+    private readonly byFunctionId;
+    constructor(hostId?: number);
+    /** Installs a defined micro into the current session registry. */
+    register<TArgs extends readonly UdfTypeDescriptor[], TReturn extends UdfTypeDescriptor>(definition: DefinedMicro<TArgs, TReturn>): MicroHandle;
+    /** Returns a registered micro by opaque host handle. */
+    resolve(handle: MicroHandle): AnyDefinedMicro | undefined;
+    /** Invokes a registered micro from a wire `MicroHostInvoke` payload. */
+    invokeFromWire(payload: {
+        hostId: number;
+        handleVersion: number;
+        functionId: string;
+        args: readonly unknown[];
+    }): string | number | boolean | null;
+    /** Invokes a registered scalar micro (host adapter entry point). */
+    invokeScalar(handle: MicroHandle, args: unknown[]): unknown;
+    /** Lists logical names currently registered in this session. */
+    list(): string[];
+}
+/** 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>;
+export {};

package/dist/micro.js

@@ -0,0 +1,160 @@
+let nextHostId = 1;
+/**
+ * Process-local registry for JS functions behind opaque host handles.
+ * Rust keeps `host_id + function_id + version`, not the closure.
+ */
+export class MicroSessionRegistry {
+    hostId;
+    nextFunctionId = 1;
+    byKey = new Map();
+    byFunctionId = new Map();
+    constructor(hostId = nextHostId++) {
+        this.hostId = hostId;
+    }
+    /** Installs a defined micro into the current session registry. */
+    register(definition) {
+        const key = logicalKey(definition.name, definition.version);
+        if (this.byKey.has(key)) {
+            throw new Error(`micro already registered: ${definition.name}@${definition.version}`);
+        }
+        const functionId = String(this.nextFunctionId++);
+        const handle = {
+            name: definition.name,
+            version: definition.version,
+            functionId,
+            hostId: this.hostId,
+            implementationVersion: 1,
+        };
+        const entry = { handle, definition: definition };
+        this.byKey.set(key, entry);
+        this.byFunctionId.set(functionId, entry);
+        return handle;
+    }
+    /** Returns a registered micro by opaque host handle. */
+    resolve(handle) {
+        if (handle.hostId !== this.hostId) {
+            return undefined;
+        }
+        return this.byFunctionId.get(handle.functionId)?.definition;
+    }
+    /** Invokes a registered micro from a wire `MicroHostInvoke` payload. */
+    invokeFromWire(payload) {
+        const handle = {
+            hostId: payload.hostId,
+            functionId: payload.functionId,
+            implementationVersion: payload.handleVersion,
+            name: '',
+            version: 0,
+        };
+        return this.invokeScalar(handle, [...payload.args]);
+    }
+    /** Invokes a registered scalar micro (host adapter entry point). */
+    invokeScalar(handle, args) {
+        const definition = this.resolve(handle);
+        if (!definition) {
+            throw new Error(`micro not found: ${handle.functionId}`);
+        }
+        if (definition.mode !== 'scalar') {
+            throw new Error(`micro ${definition.name} is not scalar mode`);
+        }
+        if (args.length !== definition.args.length) {
+            throw new Error(`micro ${definition.name} arity mismatch: expected ${definition.args.length}, got ${args.length}`);
+        }
+        validateArgTypes(definition, args);
+        const result = definition.fn(...args);
+        validateReturnType(definition.returns, result);
+        return result;
+    }
+    /** Lists logical names currently registered in this session. */
+    list() {
+        return [...this.byKey.values()].map((entry) => entry.definition.name).sort();
+    }
+}
+/** Builds a session-local micro definition without registering it. */
+export function defineMicro(input) {
+    if (!input.name.trim()) {
+        throw new Error('micro name must not be empty');
+    }
+    if (!Number.isInteger(input.version) || input.version <= 0) {
+        throw new Error('micro version must be a positive integer');
+    }
+    if (input.effect !== 'pure') {
+        throw new Error('TS micro effect must be pure in Phase 1');
+    }
+    if (!input.deterministic) {
+        throw new Error('TS micro must be deterministic in Phase 1');
+    }
+    if (typeof input.fn !== 'function') {
+        throw new Error('micro fn must be a function');
+    }
+    return {
+        name: input.name,
+        version: input.version,
+        args: input.args,
+        returns: input.returns,
+        effect: input.effect,
+        deterministic: input.deterministic,
+        mode: input.mode ?? 'scalar',
+        placement: 'host',
+        fn: input.fn,
+    };
+}
+function logicalKey(name, version) {
+    return `${name}@${version}`;
+}
+function validateArgTypes(definition, args) {
+    for (let index = 0; index < definition.args.length; index += 1) {
+        const kind = definition.args[index]?.kind;
+        const value = args[index];
+        switch (kind) {
+            case 'i64':
+                if (typeof value !== 'number' || !Number.isInteger(value)) {
+                    throw new Error(`micro ${definition.name} arg ${index} expects i64`);
+                }
+                break;
+            case 'bool':
+                if (typeof value !== 'boolean') {
+                    throw new Error(`micro ${definition.name} arg ${index} expects bool`);
+                }
+                break;
+            case 'text':
+                if (typeof value !== 'string') {
+                    throw new Error(`micro ${definition.name} arg ${index} expects text`);
+                }
+                break;
+            case 'null':
+                if (value !== null) {
+                    throw new Error(`micro ${definition.name} arg ${index} expects null`);
+                }
+                break;
+            default:
+                throw new Error(`unsupported micro arg kind: ${kind}`);
+        }
+    }
+}
+function validateReturnType(descriptor, value) {
+    switch (descriptor.kind) {
+        case 'i64':
+            if (typeof value !== 'number' || !Number.isInteger(value)) {
+                throw new Error('micro return expects i64');
+            }
+            break;
+        case 'bool':
+            if (typeof value !== 'boolean') {
+                throw new Error('micro return expects bool');
+            }
+            break;
+        case 'text':
+            if (typeof value !== 'string') {
+                throw new Error('micro return expects text');
+            }
+            break;
+        case 'null':
+            if (value !== null) {
+                throw new Error('micro return expects null');
+            }
+            break;
+        default:
+            throw new Error(`unsupported micro return kind: ${descriptor.kind}`);
+    }
+}

package/dist/native/binding.d.ts

@@ -18,6 +18,34 @@ export interface NativeDatabase {
     walFrameCount(): number;
     get(key: string): Uint8Array | null;
     put(key: string, value: Uint8Array): void;
+    /** Delete one record by key. */
+    delete(key: string): void;
+    /** Scan keys with a prefix; returns JSON `[{ key, value }, ...]`. */
+    scanPrefix(prefix: string, after: string | null, limit: number): string;
+    /** Atomically write or delete many keys; body is JSON `[{ key, value|null }, ...]`. */
+    writeBatch(changesJson: string): void;
+    /** Compare-and-swap; returns true on success. */
+    compareExchange(key: string, expected: Uint8Array | null, replacement: Uint8Array | null): boolean;
+    /** Begin an explicit transaction. */
+    begin(): void;
+    /** Commit the current transaction. */
+    commit(): void;
+    /** Roll back the current transaction. */
+    rollback(): void;
+    /** Execute a VOS read pipeline; returns JSON rows. */
+    queryVos(source: string): string;
+    /** Execute a VOS write program. */
+    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/native.d.ts

@@ -0,0 +1,9 @@
+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/native.js

@@ -0,0 +1,32 @@
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { platformKey } from './resolve-bin.js';
+function loadModule(specifier) {
+    const require = createRequire(import.meta.url);
+    const loaded = require(specifier);
+    return (loaded.default ?? loaded);
+}
+/** Load the platform native binding used by the `yydb` CLI. */
+export function loadNative() {
+    const fromEnv = process.env.YYDB_NATIVE?.trim();
+    if (fromEnv) {
+        const bindingPath = path.resolve(fromEnv);
+        if (!fs.existsSync(bindingPath)) {
+            throw new Error(`YYDB_NATIVE points to missing binding: ${fromEnv}`);
+        }
+        return loadModule(bindingPath);
+    }
+    const key = platformKey();
+    if (!key) {
+        throw new Error(`YYDB native binding not available for ${process.platform}-${process.arch}`);
+    }
+    const pkg = `@yydb/yydb-${key}`;
+    try {
+        return loadModule(pkg);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`YYDB native binding not found. Reinstall @yydb/yydb with optional dependencies, set YYDB_NATIVE, or stage ${pkg}. ${message}`);
+    }
+}

package/dist/node/cli/cli.d.ts

@@ -0,0 +1 @@
+export declare function runCli(argv: string[]): Promise<number>;

package/dist/node/cli/cli.js

@@ -0,0 +1,25 @@
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createCli } from '@vmz/commander';
+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 cli = createCli('yydb').locales(localesRoot).intro('cli.intro');
+    registerVersionCommand(cli);
+    registerInitCommand(cli);
+    registerInfoCommand(cli);
+    registerServeCommand(cli);
+    return cli;
+}
+export async function runCli(argv) {
+    try {
+        return await buildYydbCli().parse(argv);
+    }
+    catch (error) {
+        console.error(`error: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
+    }
+}

package/dist/node/cli/info-cmd.d.ts

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

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

@@ -0,0 +1,10 @@
+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/cli/init-cmd.d.ts

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