@yydb/yydb 0.0.1 → 0.0.2

package/README.md

@@ -1,30 +1,90 @@
 # `@yydb/yydb`
 
-TypeScript / Node **product surface** for YYDB. One dependency:
+**All-in-one YYDB for Node.js: CLI, embedded engine, and local `serve`.**
+
+Open a `.yydb` file with one dependency — `@yydb/yydb` spawns a private loopback server and talks to it over the YY
+wire protocol. For a **lightweight client only** (browser, renderer, or an app that already runs `yydb serve`), use
+[`@yydb/yydb-client`](../yydb-client).
+
+[![npm](https://img.shields.io/npm/v/@yydb/yydb)](https://www.npmjs.com/package/@yydb/yydb)
+[![Node.js](https://img.shields.io/node/v/@yydb/yydb)](https://www.npmjs.com/package/@yydb/yydb)
+[![Check Rust](https://github.com/yy-database/yydb/actions/workflows/check-rust.yml/badge.svg?branch=dev)](https://github.com/yy-database/yydb/actions/workflows/check-rust.yml)
+[![Check TypeScript](https://github.com/yy-database/yydb/actions/workflows/check-typescript.yml/badge.svg?branch=dev)](https://github.com/yy-database/yydb/actions/workflows/check-typescript.yml)
+
+## Install
+
+```bash
+npm install @yydb/yydb
+```
+
+Node.js 18 or newer is supported. The matching `yydb-napi` binding is installed as an optional platform dependency and
+is
+started on a private loopback endpoint when `Database.open()` runs.
+
+## Example
 
 ```ts
-import { Database } from "@yydb/yydb";
+import {Database} from "@yydb/yydb";
+
+const db = await Database.open("./data/app.yydb");
+
+await db.ensureSchema(
+    1,
+    `table Setting {
+        @@id: uuid,
+        key: utf8,
+        value: utf8,
+    }`,
+);
 
-const db = await Database.open("app.yydb");
-await db.ensureSchema(1, "table Setting { @@id: uuid, key: utf8, value: utf8 }");
 await db.put("theme", "dark");
+const value = await db.get("theme");
+console.log(value && new TextDecoder().decode(value));
+
 await db.close();
 ```
 
-You do **not** download `yydb.exe`, configure PATH, or call `serve` yourself.
-This package starts a loopback engine process behind the API (same Rust kernel
-as `backends/yydb`). Platform binaries ship as optionalDependencies
-(`@yydb/yydb-<platform>-<arch>`); npm installs only your OS’s package.
+The database file is created if it does not exist. The VOS schema and its version are stored with the data, so reopening
+the file does not depend on a separate schema registry.
+
+## API
+
+```ts
+const db = await Database.open(path, options ?);
+
+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.close();
+```
+
+`OpenOptions` supports `cli` (an explicit CLI script path), `port` (a preferred loopback port), and `serveArgs` (extra
+arguments forwarded to `yydb serve`). `binary` is a deprecated alias for `cli`.
+
+## Use a different package when
+
+| Need                                   | Package                                   |
+|----------------------------------------|-------------------------------------------|
+| Node all-in-one (CLI + engine + serve) | **`@yydb/yydb`** (this package)           |
+| Lightweight wire client only           | [`@yydb/yydb-client`](../yydb-client)     |
+| In-process Rust embed                  | [`yydb`](https://crates.io/crates/yydb)   |
+| Rust wire server crate (used by N-API) | [`yydb-server`](../../crates/yydb-server) |
+| Rust remote client                     | [`yydb-client`](../../crates/yydb-client) |
+
+For Electron, the main process can use `@yydb/yydb`; renderer code can use
+`@yydb/yydb-client` against the main process endpoint.
 
-| Package | Role |
-| --- | --- |
-| `@yydb/yydb` | High-level `Database.open` (this package) |
-| `@yydb/yydb-client` | Low-level YY wire (also used by WebUI) |
-| `@yydb/yydb-<os>-<arch>` | Prebuilt `yydb` binary (publish pipeline) |
+## Security
 
-Local monorepo/dev: falls back to `target/release|debug/yydb` or `YYDB_BIN`.
+The managed engine listens on `127.0.0.1` and has no authentication layer. Keep the endpoint private and use the
+operating system's file permissions for the `.yydb` file.
 
-Browser: still use `@yydb/yydb-client` against a host that already runs
-the engine (e.g. Electron main used `@yydb/yydb`, renderer talks WS).
+## Links
 
-Security: engine binds **loopback only**. No ACL — do not expose the port.
+- [YYDB overview](https://github.com/yy-database/yydb.rs)
+- [User guides](https://github.com/yy-database/yydb.rs/tree/dev/projects/packages/homepage/documentation/zh-hans)
+- [API documentation](https://docs.rs/yydb)
+- [License](https://github.com/yy-database/yydb.rs/blob/dev/License.md)

package/dist/cli/cli.d.ts

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

package/dist/cli/cli.js

@@ -0,0 +1,27 @@
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createCli } from '@vmz/commander';
+import { registerGenerateCommand } from './generate-cmd.js';
+import { registerInfoCommand } from './info-cmd.js';
+import { registerInitCommand } from './init-cmd.js';
+import { registerServeCommand } from './serve-cmd.js';
+import { registerVersionCommand } from './version-cmd.js';
+function buildYydbCli() {
+    const localesRoot = join(dirname(fileURLToPath(import.meta.url)), '../../locales');
+    const cli = createCli('yydb').locales(localesRoot).intro('cli.intro');
+    registerVersionCommand(cli);
+    registerInitCommand(cli);
+    registerInfoCommand(cli);
+    registerServeCommand(cli);
+    registerGenerateCommand(cli);
+    return cli;
+}
+export async function runCli(argv) {
+    try {
+        return await buildYydbCli().parse(argv);
+    }
+    catch (error) {
+        console.error(`error: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
+    }
+}

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

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

package/dist/cli/generate-cmd.js

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

package/dist/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/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/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;

package/dist/cli/init-cmd.js

@@ -0,0 +1,18 @@
+import { loadNative } from '../native.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);
+    console.log(`initialized ${dbPath}`);
+    return 0;
+}

package/dist/cli/options.d.ts

@@ -0,0 +1,4 @@
+import type { ParsedOptions } from '@vmz/commander';
+export declare function str(options: ParsedOptions, key: string): string | undefined;
+export declare function flag(options: ParsedOptions, key: string): boolean;
+export declare function requiredPositional(options: ParsedOptions, label: string): string;

package/dist/cli/options.js

@@ -0,0 +1,14 @@
+export function str(options, key) {
+    const value = options[key];
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+export function flag(options, key) {
+    return options[key] === true;
+}
+export function requiredPositional(options, label) {
+    const value = options._[0];
+    if (!value) {
+        throw new Error(`${label} requires a path argument`);
+    }
+    return value;
+}

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

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

package/dist/cli/serve-cmd.js

@@ -0,0 +1,14 @@
+import { loadNative } from '../native.js';
+import { flag, requiredPositional, str } from './options.js';
+export function registerServeCommand(cli) {
+    cli.command('serve', 'cli.cmd.serve')
+        .option('--bind <host:port>', 'cli.opt.bind')
+        .option('--insecure-bind', 'cli.opt.insecure-bind')
+        .action((options) => cmdServe(options));
+}
+export function cmdServe(options) {
+    const dbPath = requiredPositional(options, 'serve');
+    const bind = str(options, 'bind') ?? '127.0.0.1:7700';
+    loadNative().serve(dbPath, bind, flag(options, 'insecure-bind'));
+    return 0;
+}

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

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

package/dist/cli/version-cmd.js

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

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { runCli } from './cli/cli.js';
+const code = await runCli(process.argv);
+if (code !== 0) {
+    process.exitCode = code;
+}

package/dist/database.d.ts

@@ -1,6 +1,10 @@
-export type { SchemaVersion } from "@yydb/yydb-client";
+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 engine binary (tests / special installs). */
+    /** 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;
@@ -16,6 +20,7 @@ export declare class Database {
     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.
@@ -27,6 +32,19 @@ export declare class Database {
     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

@@ -1,17 +1,26 @@
-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 { resolveYydbBinary } from "./resolve-bin.js";
+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", () => {
+        server.listen(0, '127.0.0.1', () => {
             const address = server.address();
-            if (!address || typeof address === "string") {
+            if (!address || typeof address === 'string') {
                 server.close();
-                reject(new Error("could not allocate loopback port"));
+                reject(new Error('could not allocate loopback port'));
                 return;
             }
             const { port } = address;
@@ -22,7 +31,7 @@ async function freeLoopbackPort() {
                     resolve(port);
             });
         });
-        server.on("error", reject);
+        server.on('error', reject);
     });
 }
 async function waitForTcp(host, port, timeoutMs) {
@@ -34,7 +43,7 @@ async function waitForTcp(host, port, timeoutMs) {
                     socket.end();
                     resolve();
                 });
-                socket.on("error", reject);
+                socket.on('error', reject);
             });
             return;
         }
@@ -53,11 +62,14 @@ export class Database {
     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.
@@ -65,37 +77,37 @@ export class Database {
     static async open(dbPath, options = {}) {
         const resolved = path.resolve(dbPath);
         fs.mkdirSync(path.dirname(resolved), { recursive: true });
-        const binary = options.binary ?? resolveYydbBinary();
+        const cli = options.cli ?? options.binary ?? resolveYydbCli();
         const port = options.port ?? (await freeLoopbackPort());
         const bind = `127.0.0.1:${port}`;
-        const args = ["serve", resolved, "--bind", bind, ...(options.serveArgs ?? [])];
-        const child = spawn(binary, args, {
-            stdio: "pipe",
+        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) => {
+        let stderr = '';
+        child.stderr?.setEncoding('utf8');
+        child.stderr?.on('data', (chunk) => {
             stderr += chunk;
         });
         const exitPromise = new Promise((_, reject) => {
-            child.once("exit", (code, signal) => {
+            child.once('exit', (code, signal) => {
                 reject(new Error(`yydb engine exited early (code=${code}, signal=${signal}): ${stderr.trim()}`));
             });
-            child.once("error", reject);
+            child.once('error', reject);
         });
         try {
-            await Promise.race([waitForTcp("127.0.0.1", port, 8000), exitPromise]);
+            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", () => {
+            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");
+            child.kill('SIGTERM');
             throw error;
         }
     }
@@ -117,6 +129,36 @@ export class Database {
     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();
@@ -126,11 +168,11 @@ export class Database {
             return;
         }
         await new Promise((resolve) => {
-            child.once("exit", () => resolve());
-            child.kill("SIGTERM");
+            child.once('exit', () => resolve());
+            child.kill('SIGTERM');
             setTimeout(() => {
                 if (child.exitCode === null && !child.killed) {
-                    child.kill("SIGKILL");
+                    child.kill('SIGKILL');
                 }
                 resolve();
             }, 2000);

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

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

package/dist/generator/emit-typescript.js

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

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

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

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

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

package/dist/generator/index.d.ts

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

package/dist/generator/index.js

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

package/dist/generator/ir.d.ts

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

package/dist/generator/ir.js

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

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

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