@riffdb/client 0.2.1 → 0.2.3

package/README.md

@@ -7,8 +7,8 @@ compiler IDs, storage keys, or an authorization bypass.
 ## Install
 
 ```bash
-npm install --save-dev @riffdb/cli@0.2.1
-npm install @riffdb/client@0.2.1
+npm install --save-dev @riffdb/cli@0.2.3
+npm install @riffdb/client@0.2.3
 ```
 
 ## Four-step application story

package/dist/driver.d.ts

@@ -61,11 +61,11 @@ export declare function exactMoney<const Currency extends string>(currency: Curr
 export interface DriverApplicationIdentity {
     readonly applicationManifestHash?: string;
     readonly operationCatalogHash?: string;
-    readonly contractLineage: string;
-    readonly contractVersion: bigint;
-    readonly contractBundleHash: string;
+    readonly contractLineage?: string;
+    readonly contractVersion?: bigint;
+    readonly contractBundleHash?: string;
     readonly database?: string;
-    readonly role: string;
+    readonly role?: string;
     readonly roleDefinitionHash?: string;
     readonly remoteIdentityHash?: string;
     readonly tenant?: string;
@@ -84,7 +84,7 @@ export interface ResolvedDriverApplicationIdentity {
 }
 export interface DriverApplicationTransportOptions {
     readonly socketPath: string;
-    readonly identity: DriverApplicationIdentity;
+    readonly identity?: DriverApplicationIdentity;
     readonly tenant?: string;
 }
 export interface DriverConnectFromEnvOptions {
@@ -95,6 +95,7 @@ export interface DriverConnectFromEnvOptions {
     readonly tenant?: string;
     readonly prefix?: string;
     readonly envPrefix?: string;
+    readonly env?: Readonly<Record<string, string | undefined>>;
 }
 export interface DriverOperation {
     readonly name: string;

package/dist/driver.js

@@ -61,6 +61,7 @@ export class DriverApplicationError extends Error {
  * surface. Those semantics remain owned by the Rust host.
  */
 export class DriverApplicationTransport {
+    #socketPath;
     #socket;
     #identity;
     #resolvedIdentity;
@@ -71,15 +72,39 @@ export class DriverApplicationTransport {
     #inputLength = 0;
     #nextRequest = 1;
     #closed = false;
-    constructor(socket, identity, tenant) {
+    #disconnected = false;
+    #reconnecting;
+    constructor(socketPath, socket, identity, tenant) {
+        this.#socketPath = socketPath;
         this.#socket = socket;
         this.#identity = identity;
         this.#tenant = tenant;
         nextSession = nextSession === Number.MAX_SAFE_INTEGER ? 1 : nextSession + 1;
         this.#requestPrefix = `ts.${process.pid}.${nextSession}`;
-        socket.on("data", (chunk) => this.#receive(chunk));
-        socket.on("error", () => this.#fail(new Error("RiffDB driver session failed")));
-        socket.on("close", () => this.#fail(new Error("RiffDB driver session closed")));
+        this.#attachSocket(socket);
+    }
+    #attachSocket(socket) {
+        socket.on("data", (chunk) => {
+            if (this.#socket !== socket)
+                return;
+            this.#receive(chunk);
+        });
+        socket.on("error", () => {
+            if (this.#socket !== socket)
+                return;
+            this.#disconnected = true;
+            this.#inputChunks.length = 0;
+            this.#inputLength = 0;
+            this.#fail(new Error("RiffDB driver session failed"));
+        });
+        socket.on("close", () => {
+            if (this.#socket !== socket)
+                return;
+            this.#disconnected = true;
+            this.#inputChunks.length = 0;
+            this.#inputLength = 0;
+            this.#fail(new Error("RiffDB driver session closed"));
+        });
     }
     /** Returns the bound tenant identifier when this session is tenant-scoped. */
     get tenant() {
@@ -101,7 +126,7 @@ export class DriverApplicationTransport {
             socket.once("connect", () => { socket.off("error", onError); resolve(); });
             socket.once("error", onError);
         });
-        const transport = new DriverApplicationTransport(socket, options.identity, tenant);
+        const transport = new DriverApplicationTransport(options.socketPath, socket, options.identity ?? {}, tenant);
         try {
             await transport.#handshake();
             return transport;
@@ -117,6 +142,12 @@ export class DriverApplicationTransport {
     async invoke(operation, input, options = {}) {
         validateOperation(operation);
         validateDriverRecord(input);
+        const lowered = lowerOptions(options);
+        if (options.signal?.aborted)
+            throw new Error("RiffDB driver request aborted");
+        if (this.#disconnected || this.#socket.destroyed) {
+            await this.#ensureConnected();
+        }
         const requestId = this.#requestId("invoke");
         const response = await this.#request({
             type: "invoke",
@@ -124,7 +155,7 @@ export class DriverApplicationTransport {
             operation: operation.name,
             input_schema_hash: operation.inputSchemaHash,
             input,
-            options: lowerOptions(options),
+            options: lowered,
         }, requestId, options.signal);
         return decodeResult(response);
     }
@@ -139,6 +170,12 @@ export class DriverApplicationTransport {
         }
         for (const input of items)
             validateDriverRecord(input);
+        const lowered = lowerOptions(options);
+        if (options.signal?.aborted)
+            throw new Error("RiffDB driver request aborted");
+        if (this.#disconnected || this.#socket.destroyed) {
+            await this.#ensureConnected();
+        }
         const requestId = this.#requestId("batch");
         const response = await this.#request({
             type: "batch",
@@ -148,7 +185,7 @@ export class DriverApplicationTransport {
             items,
             concurrency,
             checkpoint,
-            options: lowerOptions(options),
+            options: lowered,
         }, requestId, options.signal);
         return decodeBatchResult(response, items.length, checkpoint);
     }
@@ -157,6 +194,7 @@ export class DriverApplicationTransport {
         if (this.#closed)
             return;
         this.#closed = true;
+        this.#disconnected = true;
         this.#fail(new Error("RiffDB driver session closed"));
         await new Promise((resolve) => {
             if (this.#socket.destroyed) {
@@ -166,12 +204,60 @@ export class DriverApplicationTransport {
             this.#socket.end(resolve);
         });
     }
+    async #ensureConnected() {
+        if (this.#closed)
+            throw new Error("RiffDB driver session closed");
+        if (!this.#disconnected && !this.#socket.destroyed)
+            return;
+        if (this.#reconnecting !== undefined) {
+            await this.#reconnecting;
+            return;
+        }
+        const task = (async () => {
+            const socket = createConnection({ path: this.#socketPath });
+            await new Promise((resolve, reject) => {
+                const onError = () => reject(new Error("RiffDB driver session failed"));
+                socket.once("connect", () => { socket.off("error", onError); resolve(); });
+                socket.once("error", onError);
+            });
+            if (this.#closed) {
+                socket.destroy();
+                throw new Error("RiffDB driver session closed");
+            }
+            this.#socket = socket;
+            this.#inputChunks.length = 0;
+            this.#inputLength = 0;
+            this.#disconnected = false;
+            this.#attachSocket(socket);
+            try {
+                await this.#handshake();
+            }
+            catch (error) {
+                this.#disconnected = true;
+                socket.destroy();
+                throw error;
+            }
+        })();
+        this.#reconnecting = task;
+        try {
+            await task;
+        }
+        finally {
+            if (this.#reconnecting === task) {
+                this.#reconnecting = undefined;
+            }
+        }
+    }
     async #handshake() {
         const requestId = this.#requestId("handshake");
         const identity = this.#identity;
         const manifestHash = identity.applicationManifestHash ?? "";
         const catalogHash = identity.operationCatalogHash ?? "";
+        const contractLineage = identity.contractLineage ?? "";
+        const contractVersion = identity.contractVersion ?? 0n;
+        const contractBundleHash = identity.contractBundleHash ?? "";
         const database = identity.database ?? "";
+        const role = identity.role ?? "";
         const roleDefinitionHash = identity.roleDefinitionHash ?? "";
         const remoteIdentityHash = identity.remoteIdentityHash ?? "";
         const response = await this.#request({
@@ -180,16 +266,17 @@ export class DriverApplicationTransport {
             protocol_version: DRIVER_PROTOCOL_VERSION,
             application_manifest_hash: manifestHash,
             operation_catalog_hash: catalogHash,
-            contract_lineage: identity.contractLineage,
-            contract_version: identity.contractVersion,
-            contract_bundle_hash: identity.contractBundleHash,
+            contract_lineage: contractLineage,
+            contract_version: contractVersion,
+            contract_bundle_hash: contractBundleHash,
             value_registry_hash: DRIVER_VALUE_REGISTRY_HASH,
             error_registry_hash: DRIVER_ERROR_REGISTRY_HASH,
             database,
-            role: identity.role,
+            role,
             role_definition_hash: roleDefinitionHash,
             remote_identity_hash: remoteIdentityHash,
         }, requestId);
+        const resolvedContractVersion = requiredPositiveBigInt(response.contract_version);
         if (response.type !== "handshake"
             || response.protocol_version !== DRIVER_PROTOCOL_VERSION
             || typeof response.application_manifest_hash !== "string"
@@ -198,13 +285,19 @@ export class DriverApplicationTransport {
             || typeof response.operation_catalog_hash !== "string"
             || !HASH.test(response.operation_catalog_hash)
             || (catalogHash !== "" && response.operation_catalog_hash !== catalogHash)
-            || response.contract_lineage !== identity.contractLineage
-            || requiredPositiveBigInt(response.contract_version) !== identity.contractVersion
-            || response.contract_bundle_hash !== identity.contractBundleHash
+            || typeof response.contract_lineage !== "string"
+            || !SYMBOL.test(response.contract_lineage)
+            || (contractLineage !== "" && response.contract_lineage !== contractLineage)
+            || (contractVersion !== 0n && resolvedContractVersion !== contractVersion)
+            || typeof response.contract_bundle_hash !== "string"
+            || !HASH.test(response.contract_bundle_hash)
+            || (contractBundleHash !== "" && response.contract_bundle_hash !== contractBundleHash)
             || typeof response.database !== "string"
             || !SYMBOL.test(response.database)
             || (database !== "" && response.database !== database)
-            || response.role !== identity.role
+            || typeof response.role !== "string"
+            || !SYMBOL.test(response.role)
+            || (role !== "" && response.role !== role)
             || typeof response.role_definition_hash !== "string"
             || !HASH.test(response.role_definition_hash)
             || (roleDefinitionHash !== "" && response.role_definition_hash !== roleDefinitionHash)
@@ -216,11 +309,11 @@ export class DriverApplicationTransport {
         this.#resolvedIdentity = {
             applicationManifestHash: response.application_manifest_hash,
             operationCatalogHash: response.operation_catalog_hash,
-            contractLineage: identity.contractLineage,
-            contractVersion: identity.contractVersion,
-            contractBundleHash: identity.contractBundleHash,
+            contractLineage: response.contract_lineage,
+            contractVersion: resolvedContractVersion,
+            contractBundleHash: response.contract_bundle_hash,
             database: response.database,
-            role: identity.role,
+            role: response.role,
             roleDefinitionHash: response.role_definition_hash,
             remoteIdentityHash: response.remote_identity_hash,
             ...(this.#tenant === undefined ? {} : { tenant: this.#tenant }),
@@ -277,6 +370,7 @@ export class DriverApplicationTransport {
         while (this.#inputLength >= 4) {
             const length = this.#peekFrameLength();
             if (length < 2 || length > MAX_FRAME_BYTES) {
+                this.#closed = true;
                 this.#inputChunks.length = 0;
                 this.#inputLength = 0;
                 this.#fail(new Error("RiffDB driver returned an invalid frame"));
@@ -291,6 +385,7 @@ export class DriverApplicationTransport {
                 response = exactObject(decodeJson(UTF8_DECODER.decode(body)));
             }
             catch {
+                this.#closed = true;
                 this.#inputChunks.length = 0;
                 this.#inputLength = 0;
                 this.#fail(new Error("RiffDB driver returned an invalid message"));
@@ -299,6 +394,7 @@ export class DriverApplicationTransport {
             }
             const requestId = response.request_id;
             if (typeof requestId !== "string" || !REQUEST_ID.test(requestId)) {
+                this.#closed = true;
                 this.#inputChunks.length = 0;
                 this.#inputLength = 0;
                 this.#fail(new Error("RiffDB driver returned an invalid request identity"));
@@ -878,7 +974,7 @@ const ENV_RESOLVED = Symbol("riffdb.envResolved");
 function resolveTransportTenant(options) {
     const allowEnvFallback = !(ENV_RESOLVED in options);
     const envTenant = allowEnvFallback ? process.env.RIFFDB_TENANT : undefined;
-    const candidate = options.tenant ?? options.identity.tenant ?? (envTenant && envTenant.length > 0 ? envTenant : undefined);
+    const candidate = options.tenant ?? options.identity?.tenant ?? (envTenant && envTenant.length > 0 ? envTenant : undefined);
     if (candidate === undefined)
         return undefined;
     if (typeof candidate !== "string" || candidate.length < 1 || candidate.length > 128 || !/^[\x21-\x7e]+$/.test(candidate)) {
@@ -907,9 +1003,10 @@ export function resolveTransportOptionsFromEnv(options = {}) {
     const candidatePrefixes = normalizedPrefix === "RIFFDB_" || normalizedPrefix.endsWith("RIFFDB_")
         ? [normalizedPrefix]
         : [`${normalizedPrefix}RIFFDB_`, normalizedPrefix];
+    const envSource = options.env ?? process.env;
     const readEnv = (suffix) => {
         for (const candidatePrefix of candidatePrefixes) {
-            const raw = process.env[`${candidatePrefix}${suffix}`];
+            const raw = envSource[`${candidatePrefix}${suffix}`];
             if (raw !== undefined && raw.trim().length > 0) {
                 return raw.trim();
             }
@@ -924,7 +1021,10 @@ export function resolveTransportOptionsFromEnv(options = {}) {
     if (typeof rawVersion === "bigint") {
         contractVersion = rawVersion;
     }
-    else if (typeof rawVersion === "string" && /^[0-9]+$/.test(rawVersion)) {
+    else if (typeof rawVersion === "string") {
+        if (!/^[1-9][0-9]*$/.test(rawVersion)) {
+            throw new Error("invalid RiffDB driver identity");
+        }
         contractVersion = BigInt(rawVersion);
     }
     const contractBundleHash = base.contractBundleHash ?? readEnv("BUNDLE_HASH") ?? "";
@@ -960,10 +1060,10 @@ function validateTransportOptions(options) {
         throw new Error("invalid RiffDB driver socket path");
     }
     const identity = options.identity;
-    if (!HASH.test(identity.contractBundleHash)) {
-        throw new Error("invalid RiffDB driver identity");
-    }
+    if (identity === undefined)
+        return;
     for (const value of [
+        identity.contractBundleHash,
         identity.applicationManifestHash, identity.operationCatalogHash,
         identity.roleDefinitionHash, identity.remoteIdentityHash,
     ]) {
@@ -971,12 +1071,14 @@ function validateTransportOptions(options) {
             throw new Error("invalid RiffDB driver identity");
         }
     }
-    if (identity.database !== undefined && identity.database !== "" && !SYMBOL.test(identity.database)) {
-        throw new Error("invalid RiffDB driver identity");
+    for (const value of [identity.database, identity.contractLineage, identity.role]) {
+        if (value !== undefined && value !== "" && !SYMBOL.test(value)) {
+            throw new Error("invalid RiffDB driver identity");
+        }
     }
-    if (!SYMBOL.test(identity.contractLineage)
-        || !SYMBOL.test(identity.role) || identity.contractVersion < 1n
-        || identity.contractVersion > 18446744073709551615n) {
+    if (identity.contractVersion !== undefined
+        && identity.contractVersion !== 0n
+        && (identity.contractVersion < 1n || identity.contractVersion > 18446744073709551615n)) {
         throw new Error("invalid RiffDB driver identity");
     }
 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { DriverApplicationTransport, type DriverApplicationError, type DriverApplicationTransportOptions, type DriverConnectFromEnvOptions, type DriverCompactQueryResult, type DriverPackedQueryResult, type DriverOperation } from "./driver.js";
+import { DriverApplicationTransport, type DriverApplicationError, type DriverApplicationTransportOptions, type DriverBatchResult, type DriverConnectFromEnvOptions, type DriverCompactQueryResult, type DriverInvokeOptions, type DriverPackedQueryResult, type DriverOperation, type DriverResult, type DriverValue, type ResolvedDriverApplicationIdentity } from "./driver.js";
 export type ApplicationValueSchema = {
     readonly kind: "bool" | "i64" | "u64" | "string" | "uuid" | "bytes" | "date" | "timestamp" | "cursor" | "limit";
     readonly maximumBytes?: number;
@@ -26,6 +26,7 @@ export type ApplicationValueSchema = {
     readonly value: ApplicationValueSchema;
     readonly minimum?: number;
     readonly maximum?: number;
+    readonly unique?: boolean;
     readonly aggregateCanonicalElementBytes?: number;
 } | {
     readonly kind: "record";
@@ -340,6 +341,10 @@ export declare class DriverGeneratedApplicationTransport {
     static connectFromEnv(options?: DriverConnectFromEnvOptions): Promise<DriverGeneratedApplicationTransport>;
     /** Returns the bound tenant identifier when this session is tenant-scoped. */
     get tenant(): string | undefined;
+    /** Returns the resolved application identity verified during driver handshake. */
+    get identity(): ResolvedDriverApplicationIdentity;
+    invoke(operation: DriverOperation, input: Readonly<Record<string, DriverValue>>, options?: DriverInvokeOptions): Promise<DriverResult>;
+    batch(operation: DriverOperation, items: ReadonlyArray<Readonly<Record<string, DriverValue>>>, concurrency: number, checkpoint: number, options?: DriverInvokeOptions): Promise<DriverBatchResult>;
     shutdown(): Promise<void>;
     executeNamedQuery<P, R>(request: NamedQueryRequest<P, R>, options?: QueryOptions): Promise<TypedQueryResult<R>>;
     executeCommand<I, R>(request: CommandRequest<I, R>, attemptBudget: number): Promise<TypedCommandResult<R>>;
@@ -373,5 +378,39 @@ export declare class DriverGeneratedApplicationTransport {
     }): AsyncIterable<LiveQueryUpdate<T>>;
     private mutateDriverLease;
 }
+declare module "./driver.js" {
+    interface DriverApplicationTransport {
+        executeNamedQuery<P, R>(request: NamedQueryRequest<P, R>, options?: QueryOptions): Promise<TypedQueryResult<R>>;
+        executeCommand<I, R>(request: CommandRequest<I, R>, attemptBudget: number): Promise<TypedCommandResult<R>>;
+        executeVectorInspection<P, R>(request: VectorInspectionRequest<P, R>, options?: VectorInspectionOptions): Promise<TypedVectorInspectionResult<R>>;
+        executeCommandBatch<I, R>(request: CommandRequest<I, R>, inputs: ReadonlyArray<I>, concurrency: number, checkpoint: number, attemptBudget: number): Promise<{
+            readonly items: ReadonlyArray<{
+                readonly index: number;
+                readonly result?: TypedCommandResult<R>;
+                readonly error?: DriverApplicationError;
+            }>;
+            readonly checkpoint: number;
+        }>;
+        consumeEventStream<P, E>(request: ReactiveConsumerRequest<P>, options?: ReactiveConsumerOptions): AsyncIterable<ReactiveConsumerBatch<E>>;
+        acknowledgeEvent<P>(request: ReactiveConsumerRequest<P>, delivery: ReactiveEventDelivery<unknown>): Promise<ReactiveEventMutationResult>;
+        negativeAcknowledgeEvent<P>(request: ReactiveConsumerRequest<P>, delivery: ReactiveEventDelivery<unknown>, retryDelayMs?: number): Promise<ReactiveEventMutationResult>;
+        seekEventConsumer<P>(request: ReactiveConsumerRequest<P>, checkpoint: string): Promise<ReactiveEventMutationResult>;
+        eventConsumerStatus<P>(request: ReactiveConsumerRequest<P>): Promise<ReactiveConsumerStatus | undefined>;
+        consumeContextualSubscription<P, E>(request: ReactiveConsumerRequest<P>, maximumWaitMs?: number, signal?: AbortSignal): Promise<ContextualBatch<E>>;
+        acknowledgeContextualItem<P>(request: ReactiveConsumerRequest<P>, item: ContextualWorkItem<unknown>): Promise<ReactiveEventMutationResult>;
+        negativeAcknowledgeContextualItem<P>(request: ReactiveConsumerRequest<P>, item: ContextualWorkItem<unknown>, retryDelayMs?: number): Promise<ReactiveEventMutationResult>;
+        contextualSubscriptionStatus<P>(request: ReactiveConsumerRequest<P>): Promise<ReactiveConsumerStatus | undefined>;
+        executeContextualReaction<P, I, R>(request: ReactiveConsumerRequest<P>, reaction: ContextualReaction, command: CommandRequest<I, R>): Promise<TypedCommandResult<R>>;
+        watchNamedQuery<P, T>(request: {
+            readonly driverOperations?: Readonly<Record<string, DriverOperation>>;
+            readonly reactiveModuleHash: string;
+            readonly operationName: string;
+            readonly parameters: P;
+            readonly parameterSchema: ApplicationValueSchema;
+            readonly cursor?: string;
+            readonly signal?: AbortSignal;
+        }): AsyncIterable<LiveQueryUpdate<T>>;
+    }
+}
 export { DRIVER_ERROR_REGISTRY_HASH, DRIVER_PROTOCOL_VERSION, DRIVER_VALUE_REGISTRY_HASH, DriverApplicationError, DriverApplicationTransport, resolveTransportOptionsFromEnv, } from "./driver.js";
 export type { DriverApplicationIdentity, DriverApplicationTransportOptions, DriverConnectFromEnvOptions, DriverBatchItem, DriverBatchResult, DriverBatchSuccess, DriverDecimal, DriverErrorDetails, DriverInvokeOptions, DriverMoney, DriverOperation, DriverPackedColumn, DriverPackedQueryResult, DriverResult, DriverTimestamp, DriverValue, ResolvedDriverApplicationIdentity, } from "./driver.js";

package/dist/index.js

@@ -647,6 +647,16 @@ export class DriverGeneratedApplicationTransport {
     get tenant() {
         return this.driver.tenant;
     }
+    /** Returns the resolved application identity verified during driver handshake. */
+    get identity() {
+        return this.driver.identity;
+    }
+    async invoke(operation, input, options = {}) {
+        return this.driver.invoke(operation, input, options);
+    }
+    async batch(operation, items, concurrency, checkpoint, options = {}) {
+        return this.driver.batch(operation, items, concurrency, checkpoint, options);
+    }
     async shutdown() {
         await this.driver.shutdown();
     }
@@ -821,6 +831,33 @@ export class DriverGeneratedApplicationTransport {
         return decodeDriverMutationResult(requireDriverValue(result));
     }
 }
+for (const methodName of [
+    "executeNamedQuery",
+    "executeCommand",
+    "executeVectorInspection",
+    "executeCommandBatch",
+    "consumeEventStream",
+    "acknowledgeEvent",
+    "negativeAcknowledgeEvent",
+    "seekEventConsumer",
+    "eventConsumerStatus",
+    "consumeContextualSubscription",
+    "acknowledgeContextualItem",
+    "negativeAcknowledgeContextualItem",
+    "contextualSubscriptionStatus",
+    "executeContextualReaction",
+    "watchNamedQuery",
+]) {
+    Object.defineProperty(DriverApplicationTransport.prototype, methodName, {
+        configurable: true,
+        writable: true,
+        value(...args) {
+            const adapter = new DriverGeneratedApplicationTransport(this);
+            const fn = adapter[methodName];
+            return fn.apply(adapter, args);
+        },
+    });
+}
 function validateDriverReactiveRequest(value) {
     if (!HASH.test(value.reactiveModuleHash) || !SYMBOL.test(value.operationName)) {
         throw new Error("invalid generated reactive operation identity");

package/package.json

@@ -1 +1 @@
-{"description":"First-party application runtime for the Rust-owned RiffDB driver host","engines":{"node":">=22"},"exports":{".":"./dist/index.js","./operator":"./dist/operator.js"},"files":["dist","README.md","conformance-manifest-v1.json"],"license":"MIT OR Apache-2.0","name":"@riffdb/client","repository":{"type":"git","url":"git+https://github.com/riffdb/riffdb.git"},"type":"module","types":"./dist/index.d.ts","version":"0.2.1"}
+{"description":"First-party application runtime for the Rust-owned RiffDB driver host","engines":{"node":">=22"},"exports":{".":"./dist/index.js","./operator":"./dist/operator.js"},"files":["dist","README.md","conformance-manifest-v1.json"],"license":"MIT OR Apache-2.0","name":"@riffdb/client","repository":{"type":"git","url":"git+https://github.com/riffdb/riffdb.git"},"type":"module","types":"./dist/index.d.ts","version":"0.2.3"}