@based/db 0.0.64 → 0.0.67

package/dist/src/native.js

@@ -4,21 +4,19 @@ import db from '../../basedDbNative.cjs';
 const DECODER = new TextDecoder('utf-8');
 const ENCODER = new TextEncoder();
 const selvaIoErrlog = new Uint8Array(256);
-var compressor = db.createCompressor();
+var compressor = db.createCompressor(); // put on threadCtx
 var decompressor = db.createDecompressor();
 function SelvaIoErrlogToString(buf) {
     let i;
     let len = (i = buf.indexOf(0)) >= 0 ? i : buf.byteLength;
     return DECODER.decode(selvaIoErrlog.slice(0, len));
 }
+// add worker CTX HERE
+// then add it to every function
+// worker should allways be here
+// then add ThreadCtx to modify ctx and query ctx
 const native = {
-    historyAppend(history, typeId, nodeId, dbCtx) {
-        return db.historyAppend(history, typeId, nodeId, dbCtx);
-    },
-    historyCreate(pathname, mainLen) {
-        const pathBuf = ENCODER.encode(pathname + '\0');
-        return db.historyCreate(pathBuf, mainLen + 16 - (mainLen % 16));
-    },
+    threadCtx: null, // add compressors here as well!
     workerCtxInit: () => {
         return db.workerCtxInit();
     },
@@ -45,9 +43,9 @@ const native = {
         const pathBuf = ENCODER.encode(path + '\0');
         return db.saveCommon(pathBuf, dbCtx);
     },
-    saveRange: (path, typeCode, start, end, dbCtx, hashOut) => {
+    saveBlock: (path, typeCode, start, dbCtx, hashOut) => {
         const pathBuf = ENCODER.encode(path + '\0');
-        return db.saveRange(pathBuf, typeCode, start, end, dbCtx, hashOut);
+        return db.saveBlock(pathBuf, typeCode, start, dbCtx, hashOut);
     },
     loadCommon: (path, dbCtx) => {
         const pathBuf = ENCODER.encode(path + '\0');
@@ -56,13 +54,16 @@ const native = {
             throw new Error(`Failed to load common. selvaError: ${err} cause:\n${SelvaIoErrlogToString(selvaIoErrlog)}`);
         }
     },
-    loadRange: (path, dbCtx) => {
+    loadBlock: (path, dbCtx) => {
         const pathBuf = ENCODER.encode(path + '\0');
-        const err = db.loadRange(pathBuf, dbCtx, selvaIoErrlog);
+        const err = db.loadBlock(pathBuf, dbCtx, selvaIoErrlog);
         if (err) {
-            throw new Error(`Failed to load a range. selvaError: ${err} cause:\n${SelvaIoErrlogToString(selvaIoErrlog)}`);
+            throw new Error(`Failed to load a range "${path}". selvaError: ${err} cause:\n${SelvaIoErrlogToString(selvaIoErrlog)}`);
         }
     },
+    delBlock: (dbCtx, typeId, block) => {
+        db.delBlock(dbCtx, typeId, block);
+    },
     updateSchemaType: (prefix, buf, dbCtx) => {
         return db.updateSchema(prefix, buf, dbCtx);
     },
@@ -93,6 +94,15 @@ const native = {
     equals: (a, b) => {
         return !!db.equals(a, b);
     },
+    membarSyncRead: () => {
+        db.membarSyncRead();
+    },
+    membarSyncWrite: () => {
+        db.membarSyncWrite();
+    },
+    colvecTest: (dbCtx, typeId, field, nodeId, len) => {
+        return db.colvecTest(dbCtx, typeId, field, nodeId, len);
+    }
 };
 global.__basedDb__native__ = native;
 export default native;

package/dist/src/server/IoWorker.d.ts

@@ -0,0 +1,8 @@
+import { DbWorker } from './workers/DbWorker.js';
+import { DbServer } from './index.js';
+export declare class IoWorker extends DbWorker {
+    constructor(address: BigInt, db: DbServer);
+    handleMsg(_buf: any): void;
+    loadBlock(filepath: string): Promise<void>;
+    unloadBlock(filepath: string, typeId: number, start: number): Promise<Uint8Array>;
+}

package/dist/src/server/IoWorker.js

@@ -0,0 +1,39 @@
+import { DbWorker } from './workers/DbWorker.js';
+import { DECODER, readInt32 } from '@saulx/utils';
+export class IoWorker extends DbWorker {
+    constructor(address, db) {
+        const onExit = (_code) => {
+            this.db.ioWorker = new IoWorker(address, db);
+        };
+        super(address, db, onExit, 'io_worker.js');
+    }
+    handleMsg(_buf) {
+    }
+    async loadBlock(filepath) {
+        const job = {
+            type: 'load',
+            filepath
+        };
+        const resBuf = await this.call(job);
+        if (resBuf.length) {
+            throw new Error(DECODER.decode(resBuf));
+        }
+    }
+    async unloadBlock(filepath, typeId, start) {
+        const job = {
+            type: 'unload',
+            filepath,
+            typeId,
+            start
+        };
+        const resBuf = await this.call(job);
+        const err = readInt32(resBuf, 0);
+        if (err) {
+            throw new Error(`selva error: ${err}`);
+        }
+        // Note that this shares the original buffer which may not be 100% optimal,
+        // as the first 4 bytes are no longer needed.
+        return new Uint8Array(resBuf.buffer, 4);
+    }
+}
+//# sourceMappingURL=IoWorker.js.map

package/dist/src/server/QueryWorker.d.ts

@@ -0,0 +1,8 @@
+import { DbWorker } from './workers/DbWorker.js';
+import { DbServer } from './index.js';
+export declare class QueryWorker extends DbWorker {
+    constructor(address: BigInt, db: DbServer, workerIndex: number);
+    handleMsg(_buf: any): void;
+    protected callback: (resolve: (x: any) => any) => void;
+    getQueryBuf(buf: Uint8Array): Promise<Uint8Array>;
+}

package/dist/src/server/QueryWorker.js

@@ -0,0 +1,26 @@
+import { DbWorker } from './workers/DbWorker.js';
+import { readUint64 } from '@saulx/utils';
+export class QueryWorker extends DbWorker {
+    constructor(address, db, workerIndex) {
+        const onExit = (_code) => {
+            this.db.workers[workerIndex] = new QueryWorker(address, db, workerIndex);
+        };
+        super(address, db, onExit, 'query_worker.js');
+    }
+    handleMsg(_buf) {
+        this.db.processingQueries--;
+        this.db.onQueryEnd();
+    }
+    callback = (resolve) => {
+        this.db.processingQueries++;
+        this.resolvers.push(resolve);
+    };
+    getQueryBuf(buf) {
+        const schemaChecksum = readUint64(buf, buf.byteLength - 8);
+        if (schemaChecksum !== this.db.schema?.hash) {
+            return Promise.resolve(new Uint8Array(1));
+        }
+        return this.call(buf);
+    }
+}
+//# sourceMappingURL=QueryWorker.js.map

package/dist/src/server/blocks.d.ts

@@ -0,0 +1,24 @@
+import { SchemaTypeDef } from '@based/schema/def';
+import { DbServer } from './index.js';
+/**
+ * Save a block.
+ */
+export declare function saveBlock(db: DbServer, typeId: number, start: number, end: number): void;
+/**
+ * Load a block (typically of a partial type) back to memory.
+ */
+export declare function loadBlock(db: DbServer, def: SchemaTypeDef, start: number): Promise<void>;
+/**
+ * Save a block and remove it from memory.
+ */
+export declare function unloadBlock(db: DbServer, def: SchemaTypeDef, start: number): Promise<void>;
+/**
+ * Execute cb() for each block in memory.
+ */
+export declare function foreachBlock(db: DbServer, def: SchemaTypeDef, cb: (start: number, end: number, hash: Uint8Array) => void, includeEmptyBlocks?: boolean): void;
+/**
+ * Execute cb() for each dirty block.
+ * A dirty block is one that is changed in memory but not yet persisted in the
+ * file system.
+ */
+export declare function foreachDirtyBlock(db: DbServer, cb: (mtKey: number, typeId: number, start: number, end: number) => void): void;

package/dist/src/server/blocks.js

@@ -0,0 +1,112 @@
+import native from '../native.js';
+import { join } from 'node:path';
+import { equals } from '@saulx/utils';
+import { VerifTree, destructureTreeKey, makeTreeKey, } from './tree.js';
+/**
+ * Save a block.
+ */
+export function saveBlock(db, typeId, start, end) {
+    const hash = new Uint8Array(16);
+    const mtKey = makeTreeKey(typeId, start);
+    const file = VerifTree.blockSdbFile(typeId, start, end);
+    const path = join(db.fileSystemPath, file);
+    const err = native.saveBlock(path, typeId, start, db.dbCtxExternal, hash);
+    if (err == -8) {
+        // TODO ENOENT
+        db.verifTree.remove(mtKey);
+    }
+    else if (err) {
+        // TODO print the error string
+        console.error(`Save ${typeId}:${start}-${end} failed: ${err}`);
+    }
+    else {
+        db.verifTree.update(mtKey, hash);
+    }
+}
+/**
+ * Load a block (typically of a partial type) back to memory.
+ */
+export async function loadBlock(db, def, start) {
+    const key = makeTreeKey(def.id, start);
+    const block = db.verifTree.getBlock(key);
+    if (!block) {
+        throw new Error(`No such block: ${key}`);
+    }
+    if (block.loadPromise) {
+        return block.loadPromise;
+    }
+    const prevHash = block.hash;
+    const filename = db.verifTree.getBlockFile(block);
+    const p = db.ioWorker.loadBlock(join(db.fileSystemPath, filename));
+    block.loadPromise = p;
+    await p;
+    delete block.loadPromise;
+    // Update and verify the hash
+    const hash = new Uint8Array(16);
+    const end = start + def.blockCapacity - 1;
+    const res = native.getNodeRangeHash(def.id, start, end, hash, db.dbCtxExternal);
+    if (res) {
+        const key = makeTreeKey(def.id, start);
+        db.verifTree.update(key, hash);
+        if (!equals(prevHash, hash)) {
+            throw new Error('Block hash mismatch');
+        }
+    }
+}
+/**
+ * Save a block and remove it from memory.
+ */
+export async function unloadBlock(db, def, start) {
+    const typeId = def.id;
+    const end = start + def.blockCapacity - 1;
+    const key = makeTreeKey(typeId, start);
+    const block = db.verifTree.getBlock(key);
+    if (!block) {
+        throw new Error(`No such block: ${key}`);
+    }
+    const filepath = join(db.fileSystemPath, VerifTree.blockSdbFile(typeId, start, end));
+    try {
+        const hash = await db.ioWorker.unloadBlock(filepath, typeId, start);
+        native.delBlock(db.dbCtxExternal, typeId, start);
+        db.verifTree.update(key, hash, false);
+    }
+    catch (e) {
+        // TODO Proper logging
+        // TODO err == -8 == SELVA_ENOENT => db.verifTree.remove(key) ??
+        console.error(`Save ${typeId}:${start}-${end} failed`);
+        console.error(e);
+    }
+}
+/**
+ * Execute cb() for each block in memory.
+ */
+export function foreachBlock(db, def, cb, includeEmptyBlocks = false) {
+    const step = def.blockCapacity;
+    for (let start = 1; start <= def.lastId; start += step) {
+        const end = start + step - 1;
+        const hash = new Uint8Array(16);
+        const res = native.getNodeRangeHash(def.id, start, end, hash, db.dbCtxExternal);
+        if (res || includeEmptyBlocks) {
+            cb(start, end, hash);
+        }
+    }
+}
+/**
+ * Execute cb() for each dirty block.
+ * A dirty block is one that is changed in memory but not yet persisted in the
+ * file system.
+ */
+export function foreachDirtyBlock(db, cb) {
+    const typeIdMap = {};
+    for (const typeName in db.schemaTypesParsed) {
+        const type = db.schemaTypesParsed[typeName];
+        const typeId = type.id;
+        typeIdMap[typeId] = type;
+    }
+    for (const mtKey of db.dirtyRanges) {
+        const [typeId, start] = destructureTreeKey(mtKey);
+        const end = start + typeIdMap[typeId].blockCapacity - 1;
+        cb(mtKey, typeId, start, end);
+    }
+}
+//# sourceMappingURL=blocks.js.map

package/dist/src/server/dbHash.d.ts

@@ -1,5 +1,5 @@
 export default function createHash(): {
-    update: (buf: Uint8Array) => any;
+    update: (buf: Uint8Array) => /*elided*/ any;
     digest: (encoding?: "hex") => Uint8Array | string;
     reset: () => void;
 };

package/dist/src/server/index.d.ts

@@ -1,11 +1,11 @@
 import { LangName, StrictSchema } from '@based/schema';
-import { createTree } from './csmt/index.js';
 import { StartOpts } from './start.js';
-import { CsmtNodeRange } from './tree.js';
+import { VerifTree } from './tree.js';
 import { TransformFns } from './migrate/index.js';
 import exitHook from 'exit-hook';
 import { SchemaChecksum } from '../schema.js';
-import { DbWorker } from './DbWorker.js';
+import { IoWorker } from './IoWorker.js';
+import { QueryWorker } from './QueryWorker.js';
 import { DbShared } from '../shared/DbBase.js';
 declare class SortIndex {
     constructor(buf: Uint8Array, dbCtxExternal: any);
@@ -17,17 +17,14 @@ export declare class DbServer extends DbShared {
     #private;
     modifyDirtyRanges: Float64Array;
     dbCtxExternal: any;
+    threadCtxExternal: any;
     migrating: number;
     saveInProgress: boolean;
     fileSystemPath: string;
-    merkleTree: ReturnType<typeof createTree<CsmtNodeRange>>;
+    verifTree: VerifTree;
     dirtyRanges: Set<number>;
-    csmtHashFun: {
-        update: (buf: Uint8Array) => any;
-        digest: (encoding?: "hex") => Uint8Array | string;
-        reset: () => void;
-    };
-    workers: DbWorker[];
+    ioWorker: IoWorker;
+    workers: QueryWorker[];
     availableWorkerIndex: number;
     processingQueries: number;
     modifyQueue: Uint8Array[];
@@ -46,11 +43,8 @@ export declare class DbServer extends DbShared {
     save(opts?: {
         forceFullDump?: boolean;
     }): Promise<void>;
-    createCsmtHashFun: () => {
-        update: (buf: Uint8Array) => any;
-        digest: (encoding?: "hex") => Uint8Array | string;
-        reset: () => void;
-    };
+    loadBlock(typeName: string, nodeId: number): Promise<void>;
+    unloadBlock(typeName: string, nodeId: number): Promise<void>;
     sortIndexes: {
         [type: number]: {
             [field: number]: {
@@ -68,7 +62,7 @@ export declare class DbServer extends DbShared {
     createSortIndexBuffer(typeId: number, field: number, start: number, lang: number): SortIndex;
     setSchema(strictSchema: StrictSchema, transformFns?: TransformFns): Promise<SchemaChecksum>;
     modify(bufWithHash: Uint8Array): Record<number, number> | null;
-    addToQueryQueue(resolve: any, buf: any): Promise<Uint8Array>;
+    addToQueryQueue(resolve: any, buf: any): Promise<Uint8Array<ArrayBuffer>>;
     getQueryBuf(buf: Uint8Array, fromQueue?: boolean): Promise<Uint8Array>;
     onQueryEnd(): any;
     stop(noSave?: boolean): Promise<void>;

package/dist/src/server/index.js

@@ -1,9 +1,8 @@
 import native from '../native.js';
-import createDbHash from './dbHash.js';
 import { rm } from 'node:fs/promises';
 import { langCodesMap } from '@based/schema';
 import { start } from './start.js';
-import { makeCsmtKeyFromNodeId } from './tree.js';
+import { destructureTreeKey, makeTreeKeyFromNodeId } from './tree.js';
 import { save } from './save.js';
 import { setTimeout } from 'node:timers/promises';
 import { migrate } from './migrate/index.js';
@@ -14,6 +13,7 @@ import { strictSchemaToDbSchema } from './schema.js';
 import { DbShared } from '../shared/DbBase.js';
 import { setNativeSchema, setSchemaOnServer, writeSchemaFile, } from './schema.js';
 import { resizeModifyDirtyRanges } from './resizeModifyDirtyRanges.js';
+import { loadBlock, unloadBlock } from './blocks.js';
 const emptyUint8Array = new Uint8Array(0);
 class SortIndex {
     constructor(buf, dbCtxExternal) {
@@ -27,15 +27,16 @@ class SortIndex {
 export class DbServer extends DbShared {
     modifyDirtyRanges;
     dbCtxExternal; // pointer to zig dbCtx
+    threadCtxExternal; // pointer to zig dbCtx
     migrating = null;
     saveInProgress = false;
     fileSystemPath;
-    merkleTree;
+    verifTree;
     dirtyRanges = new Set();
-    csmtHashFun = createDbHash();
+    ioWorker;
     workers = [];
     availableWorkerIndex = -1;
-    processingQueries = 0;
+    processingQueries = 0; // semaphore for locking writes
     modifyQueue = [];
     queryQueue = new Map();
     stopped; // = true does not work
@@ -59,11 +60,34 @@ export class DbServer extends DbShared {
     save(opts) {
         return save(this, false, opts?.forceFullDump ?? false);
     }
-    createCsmtHashFun = () => {
-        // We can just reuse it as long as we only have one tree.
-        this.csmtHashFun.reset();
-        return this.csmtHashFun;
-    };
+    async loadBlock(typeName, nodeId) {
+        const def = this.schemaTypesParsed[typeName];
+        if (!def) {
+            throw new Error('Type not found');
+        }
+        const typeId = def.id;
+        const key = makeTreeKeyFromNodeId(typeId, def.blockCapacity, nodeId);
+        const [, start] = destructureTreeKey(key);
+        const block = this.verifTree.getBlock(key);
+        if (!block) {
+            throw new Error('Block not found');
+        }
+        await loadBlock(this, def, start);
+    }
+    async unloadBlock(typeName, nodeId) {
+        const def = this.schemaTypesParsed[typeName];
+        if (!def) {
+            throw new Error('Type not found');
+        }
+        const typeId = def.id;
+        const key = makeTreeKeyFromNodeId(typeId, def.blockCapacity, nodeId);
+        const [, start] = destructureTreeKey(key);
+        const block = this.verifTree.getBlock(key);
+        if (!block) {
+            throw new Error('Block not found');
+        }
+        await unloadBlock(this, def, start);
+    }
     sortIndexes;
     cleanupTimer;
     cleanup() {
@@ -298,15 +322,15 @@ export class DbServer extends DbShared {
         while (typesSize--) {
             const typeId = readUint16(buf, i);
             const def = this.schemaTypesParsedById[typeId];
-            const key = makeCsmtKeyFromNodeId(def.id, def.blockCapacity, def.lastId);
+            const key = makeTreeKeyFromNodeId(def.id, def.blockCapacity, def.lastId);
             this.dirtyRanges.add(key);
             i += 10;
         }
         const view = new DataView(buf.buffer, buf.byteOffset);
         while (i < end) {
-            const key = view.getFloat64(i, true);
+            // const key = view.getFloat64(i, true)
             // These node ranges may not actually exist
-            //this.dirtyRanges.add(key)
+            // this.dirtyRanges.add(key)
             i += 8;
         }
         resizeModifyDirtyRanges(this);
@@ -387,7 +411,6 @@ export class DbServer extends DbShared {
         }
     }
     onQueryEnd() {
-        this.processingQueries--;
         if (this.processingQueries === 0) {
             if (this.modifyQueue.length) {
                 const modifyQueue = this.modifyQueue;
@@ -430,7 +453,8 @@ export class DbServer extends DbShared {
             if (!noSave) {
                 await this.save();
             }
-            await Promise.all(this.workers.map(({ worker }) => worker.terminate()));
+            await this.ioWorker.terminate();
+            await Promise.all(this.workers.map((worker) => worker.terminate()));
             this.workers = [];
             native.stop(this.dbCtxExternal);
             await setTimeout(100);

package/dist/src/server/migrate/index.d.ts

@@ -1,5 +1,10 @@
 import { DbServer } from '../index.js';
 import { DbSchema } from '../../schema.js';
+export type MigrateRange = {
+    typeId: number;
+    start: number;
+    end: number;
+};
 type TransformFn = (node: Record<string, any>) => Record<string, any> | [string, Record<string, any>];
 export type TransformFns = Record<string, TransformFn>;
 export declare const migrate: (server: DbServer, fromSchema: DbSchema, toSchema: DbSchema, transform?: TransformFns) => Promise<void>;

package/dist/src/server/migrate/index.js

@@ -2,7 +2,8 @@ import { BasedDb, save } from '../../index.js';
 import { dirname, join } from 'path';
 import { Worker, MessageChannel, receiveMessageOnPort, } from 'node:worker_threads';
 import native from '../../native.js';
-import { destructureCsmtKey, foreachDirtyBlock, specialBlock } from '../tree.js';
+import { destructureTreeKey } from '../tree.js';
+import { foreachDirtyBlock } from '../blocks.js';
 import { fileURLToPath } from 'url';
 import { setNativeSchema, setSchemaOnServer, writeSchemaFile, } from '../schema.js';
 import { setToAwake, waitUntilSleeping } from './utils.js';
@@ -90,11 +91,11 @@ export const migrate = async (server, fromSchema, toSchema, transform) => {
     let i = 0;
     let rangesToMigrate = [];
     await save(server, false, false, true);
-    server.merkleTree.visitLeafNodes((leaf) => {
-        const [_typeId, start] = destructureCsmtKey(leaf.key);
-        if (start == specialBlock)
-            return; // skip the type specialBlock
-        rangesToMigrate.push(leaf.data);
+    server.verifTree.foreachBlock((block) => {
+        const [typeId, start] = destructureTreeKey(block.key);
+        const def = server.schemaTypesParsedById[typeId];
+        const end = start + def.blockCapacity - 1;
+        rangesToMigrate.push({ typeId, start, end });
     });
     await waitUntilSleeping(workerState);
     while (i < rangesToMigrate.length) {
@@ -108,12 +109,13 @@ export const migrate = async (server, fromSchema, toSchema, transform) => {
         setToAwake(workerState, true);
         await waitUntilSleeping(workerState);
         // exec queued modifies
+        server.processingQueries--;
         server.onQueryEnd();
         if (i === rangesToMigrate.length) {
             if (server.dirtyRanges.size) {
                 rangesToMigrate = [];
                 i = 0;
-                void foreachDirtyBlock(server, (_mtKey, typeId, start, end) => {
+                foreachDirtyBlock(server, (_mtKey, typeId, start, end) => {
                     rangesToMigrate.push({
                         typeId,
                         start,
@@ -140,6 +142,7 @@ export const migrate = async (server, fromSchema, toSchema, transform) => {
     // pass last node IDS { type: lastId }
     setSchemaOnServer(server, toSchema);
     for (const key in schemaTypesParsed) {
+        // maybe only send the lastId
         const def = server.schemaTypesParsed[key];
         def.lastId = schemaTypesParsed[key].lastId;
     }
@@ -152,6 +155,7 @@ export const migrate = async (server, fromSchema, toSchema, transform) => {
     if (abort()) {
         return;
     }
+    native.membarSyncRead();
     await save(server, false, true, true);
     await writeSchemaFile(server, toSchema);
     server.migrating = 0;

package/dist/src/server/migrate/worker.js

@@ -13,6 +13,8 @@ else if (workerData?.isDbMigrateWorker) {
     const { from, to, fromSchema, toSchema, channel, workerState, transformFns } = workerData;
     const fromCtx = native.externalFromInt(from);
     const toCtx = native.externalFromInt(to);
+    // worker ctx init - maybe instead of this just add it on native
+    // instead of here just do this in native.js
     native.workerCtxInit();
     const fromDb = new BasedDb({ path: null });
     const toDb = new BasedDb({ path: null });
@@ -109,6 +111,7 @@ else if (workerData?.isDbMigrateWorker) {
             }
         }
         await toDb.drain();
+        native.membarSyncWrite();
         // WE ARE ONLY GOING TO SEND { type: lastNodeId }
         channel.postMessage(cp(toDb.server.schemaTypesParsed));
         setToSleep(workerState);

package/dist/src/server/save.d.ts

@@ -1,4 +1,10 @@
 import { DbServer } from './index.js';
+type RangeDump = {
+    file: string;
+    hash: string;
+    start: number;
+    end: number;
+};
 export type Writelog = {
     ts: number;
     types: {
@@ -10,12 +16,8 @@ export type Writelog = {
     hash: string;
     commonDump: string;
     rangeDumps: {
-        [t: number]: {
-            file: string;
-            hash: string;
-            start: number;
-            end: number;
-        }[];
+        [t: number]: RangeDump[];
     };
 };
 export declare function save<T extends boolean>(db: DbServer, sync?: T, forceFullDump?: boolean, skipMigrationCheck?: boolean): T extends true ? void : Promise<void>;
+export {};