@yydb/yydb 0.1.1 → 0.1.2

package/dist/api/database.js

@@ -1,173 +1,351 @@
-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 { emitSource, } from '@voml/vos';
 import { defineMicro as buildMicro, microFingerprint, udfWireKind, MicroSessionRegistry, } from '../shared/micro.js';
-import { resolveYydbCli } from '../native/resolve.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;
+import { loadNative } from '../native/binding.js';
+import { YydbError } from '../shared/errors.js';
+/**
+ * A pre-parsed, pre-lowered VOS query plan.
+ *
+ * Created by {@link Database.prepare}. The actual lowered op tree lives on
+ * the native side in a thread-local registry keyed by `statementId`; this
+ * class is a thin JS handle. Bind parameters and re-execute via
+ * {@link Statement.execute} without re-parsing or re-lowering the source.
+ *
+ * ```ts
+ * const stmt = await db.prepare('User.all().take($limit).collect()');
+ * const rows = await stmt.execute({ limit: 100 });
+ * // re-execute with different bind
+ * const rows2 = await stmt.execute({ limit: 50 });
+ * // release when done
+ * stmt.close();
+ * ```
+ */
+export class Statement {
+    native;
+    db;
+    closed = false;
+    constructor(native, db) {
+        this.native = native;
+        this.db = db;
+    }
+    /** The fingerprint-prefixed unique id for this statement. */
+    get statementId() { return this.native.statementId(); }
+    /** Parameter descriptors — empty array when the statement takes no parameters. */
+    get parameters() {
+        return JSON.parse(this.native.parametersJson());
+    }
+    /** Full statement metadata. */
+    get info() {
+        return JSON.parse(this.native.info());
+    }
+    /** Whether this statement has been closed and can no longer execute. */
+    get isClosed() { return this.closed; }
+    /**
+     * Execute this prepared statement with optional named parameter bindings.
+     *
+     * Missing parameters, extraneous parameters or mistyped parameters raise
+     * `YydbError` with code `yydb.query.bind`.
+     *
+     * @param params Named parameter values — keys match the parameter names
+     * in the VOS source (`$name` → `{ name: value }`). Omit when the statement
+     * takes no parameters.
+     */
+    async execute(params) {
+        if (this.closed) {
+            throw new YydbError('yydb.statement.closed', 'statement has been closed');
         }
-        catch {
-            await new Promise((r) => setTimeout(r, 40));
+        const paramsJson = params !== undefined && params !== null ? JSON.stringify(params) : null;
+        const rowsJson = this.db.queryPrepared(this.native, paramsJson);
+        return JSON.parse(rowsJson);
+    }
+    /** Release this statement's plan from the native registry. */
+    close() {
+        if (!this.closed) {
+            this.native.close();
+            this.closed = true;
         }
     }
-    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.
+ * Transaction-local handle passed to {@link Database.transaction} callbacks.
+ * All CRUD methods forward to the underlying native handle while the
+ * transaction is in flight. Commit/rollback are owned by {@link Database}.
+ */
+export class TransactionHandle {
+    native;
+    constructor(native) {
+        this.native = native;
+    }
+    async get(key) { return this.native.get(key); }
+    async put(key, value) {
+        const bytes = typeof value === 'string' ? new TextEncoder().encode(value) : value;
+        this.native.put(key, bytes);
+    }
+    async delete(key) { this.native.delete(key); }
+    async scan(options = {}) {
+        const rowsJson = this.native.scanPrefix(options.prefix ?? '', options.after ?? null, options.limit ?? 1000);
+        const rows = JSON.parse(rowsJson);
+        return rows.map((r) => ({ key: r.key, value: new Uint8Array(r.value) }));
+    }
+    async batch(changes) {
+        const body = changes.map((c) => ({
+            key: c.key,
+            value: c.value === null ? null : typeof c.value === 'string' ? Array.from(new TextEncoder().encode(c.value)) : Array.from(c.value),
+        }));
+        this.native.writeBatch(JSON.stringify(body));
+    }
+    async compareExchange(key, expected, replacement) {
+        const toBytes = (v) => v === null ? null : typeof v === 'string' ? new TextEncoder().encode(v) : v;
+        return this.native.compareExchange(key, toBytes(expected), toBytes(replacement));
+    }
+    async query(source) {
+        return JSON.parse(this.native.queryVos(source));
+    }
+    async execute(source) { this.native.executeVosWrite(source); }
+}
+/**
+ * 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;
-    endpoint;
-    client;
-    child;
+    native;
     microRegistry;
-    constructor(dbPath, endpoint, client, child) {
+    constructor(dbPath, native) {
         this.path = dbPath;
-        this.endpoint = endpoint;
-        this.client = client;
-        this.child = child;
+        this.native = native;
         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.
-     */
+    /** Open (create when missing) the database at `dbPath`. */
     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;
+        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);
     }
-    async serverVersion() {
-        return this.client.serverVersion();
+    /** Engine version string (same as `yydb --version`). */
+    serverVersion() {
+        return loadNative().version();
     }
-    async info() {
-        return this.client.info();
+    /** 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() {
-        return this.client.getSchema();
+        const version = this.native.schemaVersion();
+        const document = this.native.schemaDocument();
+        if (version === null || document === null) {
+            return null;
+        }
+        return { version, document };
     }
-    async ensureSchema(version, document) {
-        await this.client.ensureSchema(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.
+     */
+    async ensureSchema(...input) {
+        let document;
+        if (typeof input[0] === 'string') {
+            document = input[0];
+        }
+        else {
+            document = emitSource(input);
+        }
+        this.native.ensureSchema(document);
     }
+    /** Read one record, or `null` when the key is absent. */
     async get(key) {
-        return this.client.get(key);
+        return this.native.get(key);
     }
+    /** Insert or replace one record. */
     async put(key, value) {
-        await this.client.put(key, value);
+        const bytes = typeof value === 'string' ? new TextEncoder().encode(value) : value;
+        this.native.put(key, bytes);
+    }
+    /** Delete one record by key. Silently succeeds when the key is absent. */
+    async delete(key) {
+        this.native.delete(key);
+    }
+    /** List key/value pairs in lexical order. `prefix` defaults to `""` (all keys). */
+    async scan(options = {}) {
+        const rowsJson = this.native.scanPrefix(options.prefix ?? '', options.after ?? null, options.limit ?? 1000);
+        const rows = JSON.parse(rowsJson);
+        return rows.map((r) => ({ key: r.key, value: new Uint8Array(r.value) }));
+    }
+    /** Atomically write or delete many keys in one call. */
+    async batch(changes) {
+        const body = changes.map((c) => ({
+            key: c.key,
+            value: c.value === null
+                ? null
+                : typeof c.value === 'string'
+                    ? Array.from(new TextEncoder().encode(c.value))
+                    : Array.from(c.value),
+        }));
+        this.native.writeBatch(JSON.stringify(body));
     }
     /**
-     * Build a typed session-local micro definition. Does not register it with
-     * the engine until [`registerMicro`](./database.ts) is called.
+     * Compare-and-swap: replace or delete `key` only when its current value
+     * exactly equals `expected`. Both `expected` and `replacement` may be
+     * `null` (meaning absent / delete). Returns `true` when the swap applied.
      */
+    async compareExchange(key, expected, replacement) {
+        const toBytes = (v) => v === null ? null : typeof v === 'string' ? new TextEncoder().encode(v) : v;
+        return this.native.compareExchange(key, toBytes(expected), toBytes(replacement));
+    }
+    /** Fold the WAL into the main file and truncate the sidecar. */
+    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.
+     *
+     * ```ts
+     * await db.transaction(async (tx) => {
+     *     await tx.put('a', '1');
+     *     await tx.put('b', '2');
+     * });
+     * ```
+     */
+    async transaction(fn) {
+        this.native.begin();
+        const tx = new TransactionHandle(this.native);
+        try {
+            const result = await fn(tx);
+            this.native.commit();
+            return result;
+        }
+        catch (err) {
+            try {
+                this.native.rollback();
+            }
+            catch {
+                // rollback already failed, don't mask the original error
+            }
+            throw YydbError.fromDiagnosticJson(err instanceof Error ? err.message : String(err)) ?? err;
+        }
+    }
+    /**
+     * Prepare a VOS read pipeline into a reusable query plan.
+     *
+     * Returns a {@link Statement} handle. The actual lowered op tree lives
+     * on the native side in a thread-local registry — you can call
+     * `statement.execute({ paramName: value })` cheaply multiple times
+     * without re-parsing or re-lowering the source.
+     *
+     * Prepare requires no schema binding; plan building is a pure parse +
+     * lower pass. Execute still needs `ensureSchema` first.
+     *
+     * ```ts
+     * const stmt = await db.prepare('User.all().take($limit).collect()');
+     * const rows = await stmt.execute({ limit: 100 });
+     * const rows2 = await stmt.execute({ limit: 50 });
+     * stmt.close();
+     * ```
+     */
+    async prepare(source) {
+        const nativeStmt = this.native.prepare(source);
+        return new Statement(nativeStmt, this.native);
+    }
+    /** Execute a VOS read pipeline and return typed rows. */
+    async query(source) {
+        const rowsJson = this.native.queryVos(source);
+        return JSON.parse(rowsJson);
+    }
+    /** Execute a VOS write program. */
+    async execute(source) {
+        this.native.executeVosWrite(source);
+    }
+    /**
+     * Publish a new schema version, migrating existing records when their
+     * shape no longer matches.
+     *
+     * Accepts raw `.vos` source or `@voml/vos` descriptors (same as
+     * {@link Database.ensureSchema}). Use `renames` to tell the engine which
+     * old type/field names map to the new ones — records that would otherwise
+     * look structurally unrelated get preserved.
+     */
+    async migrateSchema(documentOrSource, ...rest) {
+        let document;
+        let options = {};
+        const all = [documentOrSource, ...rest];
+        const last = all[all.length - 1];
+        if (last &&
+            typeof last === 'object' &&
+            !('table' in last) &&
+            !('class' in last) &&
+            !('emit' in last) &&
+            ('renames' in last || Object.keys(last).length === 0)) {
+            options = all.pop() ?? {};
+        }
+        if (typeof all[0] === 'string') {
+            document = all[0];
+        }
+        else {
+            document = emitSource(all);
+        }
+        const renamesJson = options.renames?.length
+            ? JSON.stringify(options.renames)
+            : null;
+        this.native.migrateSchema(document, renamesJson);
+    }
+    /** Build a typed session-local micro definition (without registering). */
     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`.
+     * 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);
-        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),
-        });
+        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 private engine. */
+    /** Invoke a registered scalar UDF on the native engine. */
     async callScalar(name, version, args) {
-        return this.client.callScalar(name, version, args);
+        const argsJson = JSON.stringify(args);
+        const resultJson = this.native.callScalar(name, version, argsJson);
+        return JSON.parse(resultJson);
     }
-    /** Stop the private engine process. */
+    /** Release the native handle (best-effort; the engine also drops on GC). */
     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);
-        });
+        // Native connections drop cleanly when the handle is garbage-collected.
+        // No explicit close() is exposed from yydb::Connection.
     }
 }

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;
+}