@ruvector/rvf 0.1.3 → 0.1.5

package/dist/backend.d.ts

@@ -0,0 +1,110 @@
+import type { RvfOptions, RvfQueryOptions, RvfSearchResult, RvfIngestResult, RvfIngestEntry, RvfDeleteResult, RvfCompactionResult, RvfStatus, RvfFilterExpr, RvfKernelData, RvfEbpfData, RvfSegmentInfo, BackendType } from './types';
+/**
+ * Abstract backend that wraps either the native (N-API) or WASM build of
+ * rvf-runtime.  The `RvfDatabase` class delegates all I/O to a backend
+ * instance, keeping the public API identical regardless of runtime.
+ */
+export interface RvfBackend {
+    /** Create a new store file at `path` with the given options. */
+    create(path: string, options: RvfOptions): Promise<void>;
+    /** Open an existing store at `path` for read-write access. */
+    open(path: string): Promise<void>;
+    /** Open an existing store at `path` for read-only access. */
+    openReadonly(path: string): Promise<void>;
+    /** Ingest a batch of vectors. */
+    ingestBatch(entries: RvfIngestEntry[]): Promise<RvfIngestResult>;
+    /** Query the k nearest neighbors. */
+    query(vector: Float32Array, k: number, options?: RvfQueryOptions): Promise<RvfSearchResult[]>;
+    /** Soft-delete vectors by ID. */
+    delete(ids: string[]): Promise<RvfDeleteResult>;
+    /** Soft-delete vectors matching a filter. */
+    deleteByFilter(filter: RvfFilterExpr): Promise<RvfDeleteResult>;
+    /** Run compaction to reclaim dead space. */
+    compact(): Promise<RvfCompactionResult>;
+    /** Get the current store status. */
+    status(): Promise<RvfStatus>;
+    /** Close the store, releasing locks. */
+    close(): Promise<void>;
+    fileId(): Promise<string>;
+    parentId(): Promise<string>;
+    lineageDepth(): Promise<number>;
+    derive(childPath: string, options?: RvfOptions): Promise<RvfBackend>;
+    embedKernel(arch: number, kernelType: number, flags: number, image: Uint8Array, apiPort: number, cmdline?: string): Promise<number>;
+    extractKernel(): Promise<RvfKernelData | null>;
+    embedEbpf(programType: number, attachType: number, maxDimension: number, bytecode: Uint8Array, btf?: Uint8Array): Promise<number>;
+    extractEbpf(): Promise<RvfEbpfData | null>;
+    segments(): Promise<RvfSegmentInfo[]>;
+    dimension(): Promise<number>;
+}
+/**
+ * Backend that delegates to the `@ruvector/rvf-node` native N-API addon.
+ *
+ * The native addon is loaded lazily on first use so that the SDK package can
+ * be imported in environments where the native build is unavailable (e.g.
+ * browsers) without throwing at import time.
+ */
+export declare class NodeBackend implements RvfBackend {
+    private native;
+    private handle;
+    private loadNative;
+    private ensureHandle;
+    create(path: string, options: RvfOptions): Promise<void>;
+    open(path: string): Promise<void>;
+    openReadonly(path: string): Promise<void>;
+    ingestBatch(entries: RvfIngestEntry[]): Promise<RvfIngestResult>;
+    query(vector: Float32Array, k: number, options?: RvfQueryOptions): Promise<RvfSearchResult[]>;
+    delete(ids: string[]): Promise<RvfDeleteResult>;
+    deleteByFilter(filter: RvfFilterExpr): Promise<RvfDeleteResult>;
+    compact(): Promise<RvfCompactionResult>;
+    status(): Promise<RvfStatus>;
+    close(): Promise<void>;
+    fileId(): Promise<string>;
+    parentId(): Promise<string>;
+    lineageDepth(): Promise<number>;
+    derive(childPath: string, options?: RvfOptions): Promise<RvfBackend>;
+    embedKernel(arch: number, kernelType: number, flags: number, image: Uint8Array, apiPort: number, cmdline?: string): Promise<number>;
+    extractKernel(): Promise<RvfKernelData | null>;
+    embedEbpf(programType: number, attachType: number, maxDimension: number, bytecode: Uint8Array, btf?: Uint8Array): Promise<number>;
+    extractEbpf(): Promise<RvfEbpfData | null>;
+    segments(): Promise<RvfSegmentInfo[]>;
+    dimension(): Promise<number>;
+}
+/**
+ * Backend that delegates to the `@ruvector/rvf-wasm` WASM build.
+ *
+ * Suitable for browser environments. The WASM module is loaded lazily.
+ */
+export declare class WasmBackend implements RvfBackend {
+    private wasm;
+    private handle;
+    private loadWasm;
+    private ensureHandle;
+    create(path: string, options: RvfOptions): Promise<void>;
+    open(path: string): Promise<void>;
+    openReadonly(path: string): Promise<void>;
+    ingestBatch(entries: RvfIngestEntry[]): Promise<RvfIngestResult>;
+    query(vector: Float32Array, k: number, options?: RvfQueryOptions): Promise<RvfSearchResult[]>;
+    delete(ids: string[]): Promise<RvfDeleteResult>;
+    deleteByFilter(filter: RvfFilterExpr): Promise<RvfDeleteResult>;
+    compact(): Promise<RvfCompactionResult>;
+    status(): Promise<RvfStatus>;
+    close(): Promise<void>;
+    fileId(): Promise<string>;
+    parentId(): Promise<string>;
+    lineageDepth(): Promise<number>;
+    derive(_childPath: string, _options?: RvfOptions): Promise<RvfBackend>;
+    embedKernel(): Promise<number>;
+    extractKernel(): Promise<RvfKernelData | null>;
+    embedEbpf(): Promise<number>;
+    extractEbpf(): Promise<RvfEbpfData | null>;
+    segments(): Promise<RvfSegmentInfo[]>;
+    dimension(): Promise<number>;
+}
+/**
+ * Resolve a `BackendType` to a concrete `RvfBackend` instance.
+ *
+ * - `'node'`  Always returns a `NodeBackend`.
+ * - `'wasm'`  Always returns a `WasmBackend`.
+ * - `'auto'`  Tries `node` first, falls back to `wasm`.
+ */
+export declare function resolveBackend(type: BackendType): RvfBackend;

package/dist/backend.js

@@ -0,0 +1,580 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WasmBackend = exports.NodeBackend = void 0;
+exports.resolveBackend = resolveBackend;
+const errors_1 = require("./errors");
+// ---------------------------------------------------------------------------
+// NodeBackend — wraps @ruvector/rvf-node (N-API)
+// ---------------------------------------------------------------------------
+/**
+ * Backend that delegates to the `@ruvector/rvf-node` native N-API addon.
+ *
+ * The native addon is loaded lazily on first use so that the SDK package can
+ * be imported in environments where the native build is unavailable (e.g.
+ * browsers) without throwing at import time.
+ */
+class NodeBackend {
+    constructor() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.native = null;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.handle = null;
+    }
+    async loadNative() {
+        if (this.native)
+            return;
+        try {
+            // Dynamic import so the SDK can be bundled for browsers without
+            // pulling in the native addon at compile time.
+            this.native = await Promise.resolve().then(() => __importStar(require('@ruvector/rvf-node')));
+        }
+        catch {
+            throw new errors_1.RvfError(errors_1.RvfErrorCode.BackendNotFound, 'Could not load @ruvector/rvf-node — is it installed?');
+        }
+    }
+    ensureHandle() {
+        if (!this.handle) {
+            throw new errors_1.RvfError(errors_1.RvfErrorCode.StoreClosed);
+        }
+    }
+    async create(path, options) {
+        await this.loadNative();
+        try {
+            this.handle = await this.native.create(path, mapOptionsToNative(options));
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async open(path) {
+        await this.loadNative();
+        try {
+            this.handle = await this.native.open(path);
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async openReadonly(path) {
+        await this.loadNative();
+        try {
+            this.handle = await this.native.openReadonly(path);
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async ingestBatch(entries) {
+        this.ensureHandle();
+        try {
+            const ids = entries.map((e) => e.id);
+            const vectors = entries.map((e) => e.vector instanceof Float32Array ? e.vector : new Float32Array(e.vector));
+            const metadata = entries.some((e) => e.metadata)
+                ? entries.map((e) => e.metadata ?? {})
+                : undefined;
+            const result = await this.native.ingestBatch(this.handle, ids, vectors, metadata);
+            return {
+                accepted: result.accepted,
+                rejected: result.rejected,
+                epoch: result.epoch,
+            };
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async query(vector, k, options) {
+        this.ensureHandle();
+        try {
+            const nativeOpts = options ? mapQueryOptionsToNative(options) : undefined;
+            const results = await this.native.query(this.handle, vector, k, nativeOpts);
+            return results.map((r) => ({
+                id: r.id,
+                distance: r.distance,
+            }));
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async delete(ids) {
+        this.ensureHandle();
+        try {
+            const result = await this.native.delete(this.handle, ids);
+            return { deleted: result.deleted, epoch: result.epoch };
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async deleteByFilter(filter) {
+        this.ensureHandle();
+        try {
+            const result = await this.native.deleteByFilter(this.handle, filter);
+            return { deleted: result.deleted, epoch: result.epoch };
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async compact() {
+        this.ensureHandle();
+        try {
+            const result = await this.native.compact(this.handle);
+            return {
+                segmentsCompacted: result.segmentsCompacted ?? result.segments_compacted,
+                bytesReclaimed: result.bytesReclaimed ?? result.bytes_reclaimed,
+                epoch: result.epoch,
+            };
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async status() {
+        this.ensureHandle();
+        try {
+            const s = await this.native.status(this.handle);
+            return mapNativeStatus(s);
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async close() {
+        if (!this.handle)
+            return;
+        try {
+            await this.native.close(this.handle);
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+        finally {
+            this.handle = null;
+        }
+    }
+    async fileId() {
+        this.ensureHandle();
+        try {
+            return this.handle.fileId();
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async parentId() {
+        this.ensureHandle();
+        try {
+            return this.handle.parentId();
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async lineageDepth() {
+        this.ensureHandle();
+        try {
+            return this.handle.lineageDepth();
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async derive(childPath, options) {
+        this.ensureHandle();
+        try {
+            const nativeOpts = options ? mapOptionsToNative(options) : undefined;
+            const childHandle = this.handle.derive(childPath, nativeOpts);
+            const child = new NodeBackend();
+            child.native = this.native;
+            child.handle = childHandle;
+            return child;
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async embedKernel(arch, kernelType, flags, image, apiPort, cmdline) {
+        this.ensureHandle();
+        try {
+            return this.handle.embedKernel(arch, kernelType, flags, Buffer.from(image), apiPort, cmdline);
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async extractKernel() {
+        this.ensureHandle();
+        try {
+            const result = this.handle.extractKernel();
+            if (!result)
+                return null;
+            return {
+                header: new Uint8Array(result.header),
+                image: new Uint8Array(result.image),
+            };
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async embedEbpf(programType, attachType, maxDimension, bytecode, btf) {
+        this.ensureHandle();
+        try {
+            return this.handle.embedEbpf(programType, attachType, maxDimension, Buffer.from(bytecode), btf ? Buffer.from(btf) : undefined);
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async extractEbpf() {
+        this.ensureHandle();
+        try {
+            const result = this.handle.extractEbpf();
+            if (!result)
+                return null;
+            return {
+                header: new Uint8Array(result.header),
+                payload: new Uint8Array(result.payload),
+            };
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async segments() {
+        this.ensureHandle();
+        try {
+            const segs = this.handle.segments();
+            return segs.map((s) => ({
+                id: s.id,
+                offset: s.offset,
+                payloadLength: s.payloadLength ?? s.payload_length,
+                segType: s.segType ?? s.seg_type,
+            }));
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async dimension() {
+        this.ensureHandle();
+        try {
+            return this.handle.dimension();
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+}
+exports.NodeBackend = NodeBackend;
+// ---------------------------------------------------------------------------
+// WasmBackend — wraps @ruvector/rvf-wasm
+// ---------------------------------------------------------------------------
+/**
+ * Backend that delegates to the `@ruvector/rvf-wasm` WASM build.
+ *
+ * Suitable for browser environments. The WASM module is loaded lazily.
+ */
+class WasmBackend {
+    constructor() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.wasm = null;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.handle = null;
+    }
+    async loadWasm() {
+        if (this.wasm)
+            return;
+        try {
+            this.wasm = await Promise.resolve().then(() => __importStar(require('@ruvector/rvf-wasm')));
+            if (typeof this.wasm.default === 'function') {
+                await this.wasm.default();
+            }
+        }
+        catch {
+            throw new errors_1.RvfError(errors_1.RvfErrorCode.BackendNotFound, 'Could not load @ruvector/rvf-wasm — is it installed?');
+        }
+    }
+    ensureHandle() {
+        if (!this.handle) {
+            throw new errors_1.RvfError(errors_1.RvfErrorCode.StoreClosed);
+        }
+    }
+    async create(path, options) {
+        await this.loadWasm();
+        try {
+            this.handle = this.wasm.create(path, mapOptionsToNative(options));
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async open(path) {
+        await this.loadWasm();
+        try {
+            this.handle = this.wasm.open(path);
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async openReadonly(path) {
+        await this.loadWasm();
+        try {
+            this.handle = this.wasm.open_readonly(path);
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async ingestBatch(entries) {
+        this.ensureHandle();
+        try {
+            const ids = entries.map((e) => e.id);
+            const vectors = entries.map((e) => e.vector instanceof Float32Array ? e.vector : new Float32Array(e.vector));
+            const metadata = entries.some((e) => e.metadata)
+                ? entries.map((e) => e.metadata ?? {})
+                : undefined;
+            const result = this.wasm.ingest_batch(this.handle, ids, vectors, metadata);
+            return {
+                accepted: result.accepted,
+                rejected: result.rejected,
+                epoch: result.epoch,
+            };
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async query(vector, k, options) {
+        this.ensureHandle();
+        try {
+            const nativeOpts = options ? mapQueryOptionsToNative(options) : undefined;
+            const results = this.wasm.query(this.handle, vector, k, nativeOpts);
+            return results.map((r) => ({
+                id: r.id,
+                distance: r.distance,
+            }));
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async delete(ids) {
+        this.ensureHandle();
+        try {
+            const result = this.wasm.delete(this.handle, ids);
+            return { deleted: result.deleted, epoch: result.epoch };
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async deleteByFilter(filter) {
+        this.ensureHandle();
+        try {
+            const result = this.wasm.delete_by_filter(this.handle, filter);
+            return { deleted: result.deleted, epoch: result.epoch };
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async compact() {
+        this.ensureHandle();
+        try {
+            const result = this.wasm.compact(this.handle);
+            return {
+                segmentsCompacted: result.segments_compacted ?? result.segmentsCompacted,
+                bytesReclaimed: result.bytes_reclaimed ?? result.bytesReclaimed,
+                epoch: result.epoch,
+            };
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async status() {
+        this.ensureHandle();
+        try {
+            const s = this.wasm.status(this.handle);
+            return mapNativeStatus(s);
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+    }
+    async close() {
+        if (!this.handle)
+            return;
+        try {
+            this.wasm.close(this.handle);
+        }
+        catch (err) {
+            throw errors_1.RvfError.fromNative(err);
+        }
+        finally {
+            this.handle = null;
+        }
+    }
+    async fileId() {
+        throw new errors_1.RvfError(errors_1.RvfErrorCode.BackendNotFound, 'fileId not supported in WASM backend');
+    }
+    async parentId() {
+        throw new errors_1.RvfError(errors_1.RvfErrorCode.BackendNotFound, 'parentId not supported in WASM backend');
+    }
+    async lineageDepth() {
+        throw new errors_1.RvfError(errors_1.RvfErrorCode.BackendNotFound, 'lineageDepth not supported in WASM backend');
+    }
+    async derive(_childPath, _options) {
+        throw new errors_1.RvfError(errors_1.RvfErrorCode.BackendNotFound, 'derive not supported in WASM backend');
+    }
+    async embedKernel() {
+        throw new errors_1.RvfError(errors_1.RvfErrorCode.BackendNotFound, 'embedKernel not supported in WASM backend');
+    }
+    async extractKernel() {
+        throw new errors_1.RvfError(errors_1.RvfErrorCode.BackendNotFound, 'extractKernel not supported in WASM backend');
+    }
+    async embedEbpf() {
+        throw new errors_1.RvfError(errors_1.RvfErrorCode.BackendNotFound, 'embedEbpf not supported in WASM backend');
+    }
+    async extractEbpf() {
+        throw new errors_1.RvfError(errors_1.RvfErrorCode.BackendNotFound, 'extractEbpf not supported in WASM backend');
+    }
+    async segments() {
+        throw new errors_1.RvfError(errors_1.RvfErrorCode.BackendNotFound, 'segments not supported in WASM backend');
+    }
+    async dimension() {
+        throw new errors_1.RvfError(errors_1.RvfErrorCode.BackendNotFound, 'dimension not supported in WASM backend');
+    }
+}
+exports.WasmBackend = WasmBackend;
+// ---------------------------------------------------------------------------
+// Backend resolution
+// ---------------------------------------------------------------------------
+/**
+ * Resolve a `BackendType` to a concrete `RvfBackend` instance.
+ *
+ * - `'node'`  Always returns a `NodeBackend`.
+ * - `'wasm'`  Always returns a `WasmBackend`.
+ * - `'auto'`  Tries `node` first, falls back to `wasm`.
+ */
+function resolveBackend(type) {
+    switch (type) {
+        case 'node':
+            return new NodeBackend();
+        case 'wasm':
+            return new WasmBackend();
+        case 'auto': {
+            // In Node.js environments, prefer native; in browsers, prefer WASM.
+            const isNode = typeof process !== 'undefined' &&
+                typeof process.versions !== 'undefined' &&
+                typeof process.versions.node === 'string';
+            return isNode ? new NodeBackend() : new WasmBackend();
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Mapping helpers (TS options -> native/wasm shapes)
+// ---------------------------------------------------------------------------
+function mapMetricToNative(metric) {
+    switch (metric) {
+        case 'cosine':
+            return 'Cosine';
+        case 'dotproduct':
+            return 'InnerProduct';
+        case 'l2':
+        default:
+            return 'L2';
+    }
+}
+function mapCompressionToNative(compression) {
+    switch (compression) {
+        case 'scalar':
+            return 'Scalar';
+        case 'product':
+            return 'Product';
+        case 'none':
+        default:
+            return 'None';
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function mapOptionsToNative(options) {
+    return {
+        dimension: options.dimensions,
+        metric: mapMetricToNative(options.metric),
+        profile: options.profile ?? 0,
+        compression: mapCompressionToNative(options.compression),
+        signing: options.signing ?? false,
+        m: options.m ?? 16,
+        ef_construction: options.efConstruction ?? 200,
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function mapQueryOptionsToNative(options) {
+    return {
+        ef_search: options.efSearch ?? 100,
+        filter: options.filter,
+        timeout_ms: options.timeoutMs ?? 0,
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function mapNativeStatus(s) {
+    return {
+        totalVectors: s.total_vectors ?? s.totalVectors ?? 0,
+        totalSegments: s.total_segments ?? s.totalSegments ?? 0,
+        fileSizeBytes: s.file_size ?? s.fileSizeBytes ?? 0,
+        epoch: s.current_epoch ?? s.epoch ?? 0,
+        profileId: s.profile_id ?? s.profileId ?? 0,
+        compactionState: mapCompactionState(s.compaction_state ?? s.compactionState),
+        deadSpaceRatio: s.dead_space_ratio ?? s.deadSpaceRatio ?? 0,
+        readOnly: s.read_only ?? s.readOnly ?? false,
+    };
+}
+function mapCompactionState(state) {
+    if (typeof state === 'string') {
+        const lower = state.toLowerCase();
+        if (lower === 'running')
+            return 'running';
+        if (lower === 'emergency')
+            return 'emergency';
+    }
+    return 'idle';
+}
+//# sourceMappingURL=backend.js.map