@based/db 0.0.21 → 0.0.23

package/dist/src/native.js

@@ -1,21 +1,22 @@
 // @ts-ignore
 import db from '../../basedDbNative.cjs';
-import { bufToHex } from './utils.js';
+// Can't import these from utils or it would be a cyclic import.
+const DECODER = new TextDecoder('utf-8');
+const ENCODER = new TextEncoder();
 const selvaIoErrlog = new Uint8Array(256);
-const textEncoder = new TextEncoder();
 var compressor = db.createCompressor();
 var decompressor = db.createDecompressor();
 function SelvaIoErrlogToString(buf) {
     let i;
     let len = (i = buf.indexOf(0)) >= 0 ? i : buf.byteLength;
-    return new TextDecoder().decode(selvaIoErrlog.slice(0, len));
+    return DECODER.decode(selvaIoErrlog.slice(0, len));
 }
 export default {
     historyAppend(history, typeId, nodeId, dbCtx) {
         return db.historyAppend(history, typeId, nodeId, dbCtx);
     },
     historyCreate(pathname, mainLen) {
-        const pathBuf = textEncoder.encode(pathname + '\0');
+        const pathBuf = ENCODER.encode(pathname + '\0');
         return db.historyCreate(pathBuf, mainLen + 16 - (mainLen % 16));
     },
     workerCtxInit: () => {
@@ -41,22 +42,22 @@ export default {
         return db.stop(dbCtx);
     },
     saveCommon: (path, dbCtx) => {
-        const pathBuf = textEncoder.encode(path + '\0');
+        const pathBuf = ENCODER.encode(path + '\0');
         return db.saveCommon(pathBuf, dbCtx);
     },
     saveRange: (path, typeCode, start, end, dbCtx, hashOut) => {
-        const pathBuf = textEncoder.encode(path + '\0');
+        const pathBuf = ENCODER.encode(path + '\0');
         return db.saveRange(pathBuf, typeCode, start, end, dbCtx, hashOut);
     },
     loadCommon: (path, dbCtx) => {
-        const pathBuf = textEncoder.encode(path + '\0');
+        const pathBuf = ENCODER.encode(path + '\0');
         const err = db.loadCommon(pathBuf, dbCtx, selvaIoErrlog);
         if (err) {
             throw new Error(`Failed to load common. selvaError: ${err} cause:\n${SelvaIoErrlogToString(selvaIoErrlog)}`);
         }
     },
     loadRange: (path, dbCtx) => {
-        const pathBuf = textEncoder.encode(path + '\0');
+        const pathBuf = ENCODER.encode(path + '\0');
         const err = db.loadRange(pathBuf, dbCtx, selvaIoErrlog);
         if (err) {
             throw new Error(`Failed to load a range. selvaError: ${err} cause:\n${SelvaIoErrlogToString(selvaIoErrlog)}`);
@@ -71,29 +72,6 @@ export default {
     getNodeRangeHash: (typeId, start, end, bufOut, dbCtx) => {
         return db.getNodeRangeHash(typeId, start, end, bufOut, dbCtx);
     },
-    createHash: () => {
-        const state = db.hashCreate();
-        const hash = {
-            update: (buf) => {
-                db.hashUpdate(state, buf);
-                return hash;
-            },
-            digest: (encoding) => {
-                const buf = new Uint8Array(16);
-                db.hashDigest(state, buf);
-                if (encoding === 'hex') {
-                    return bufToHex(buf);
-                }
-                else {
-                    return buf;
-                }
-            },
-            reset: () => {
-                db.hashReset(state);
-            },
-        };
-        return hash;
-    },
     compress: (buf, offset, stringSize) => {
         return db.compress(compressor, buf, offset, stringSize);
     },

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

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

package/dist/src/server/dbHash.js

@@ -0,0 +1,27 @@
+// @ts-ignore
+import db from '../../../basedDbNative.cjs';
+import { bufToHex } from '../utils.js';
+export default function createHash() {
+    const state = db.hashCreate();
+    const hash = {
+        update: (buf) => {
+            db.hashUpdate(state, buf);
+            return hash;
+        },
+        digest: (encoding) => {
+            const buf = new Uint8Array(16);
+            db.hashDigest(state, buf);
+            if (encoding === 'hex') {
+                return bufToHex(buf);
+            }
+            else {
+                return buf;
+            }
+        },
+        reset: () => {
+            db.hashReset(state);
+        },
+    };
+    return hash;
+}
+//# sourceMappingURL=dbHash.js.map

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

@@ -5,8 +5,8 @@ import { Worker, MessagePort } from 'node:worker_threads';
 import { TransformFns } from './migrate/index.js';
 import exitHook from 'exit-hook';
 declare class SortIndex {
-    constructor(buf: Buffer, dbCtxExternal: any);
-    buf: Buffer;
+    constructor(buf: Uint8Array, dbCtxExternal: any);
+    buf: Uint8Array;
     idx: any;
     cnt: number;
 }
@@ -18,7 +18,7 @@ export declare class DbWorker {
     resolvers: any[];
     callback: (resolve: any) => void;
     updateCtx(address: BigInt): Promise<void>;
-    getQueryBuf(buf: Buffer): Promise<Uint8Array>;
+    getQueryBuf(buf: Uint8Array): Promise<Uint8Array>;
 }
 type OnSchemaChange = (schema: StrictSchema) => void;
 export declare class DbServer {
@@ -36,15 +36,15 @@ export declare class DbServer {
     merkleTree: ReturnType<typeof createTree>;
     dirtyRanges: Set<number>;
     csmtHashFun: {
-        update: (buf: Buffer | Uint8Array) => any;
+        update: (buf: Uint8Array) => any;
         digest: (encoding?: "hex") => Uint8Array | string;
         reset: () => void;
     };
     workers: DbWorker[];
     availableWorkerIndex: number;
     processingQueries: number;
-    modifyQueue: Buffer[];
-    queryQueue: Map<Function, Buffer>;
+    modifyQueue: Uint8Array[];
+    queryQueue: Map<Function, Uint8Array>;
     stopped: boolean;
     onSchemaChange: OnSchemaChange;
     unlistenExit: ReturnType<typeof exitHook>;
@@ -59,7 +59,7 @@ export declare class DbServer {
     }): Promise<void>;
     save(): void | Promise<void>;
     createCsmtHashFun: () => {
-        update: (buf: Buffer | Uint8Array) => any;
+        update: (buf: Uint8Array) => any;
         digest: (encoding?: "hex") => Uint8Array | string;
         reset: () => void;
     };
@@ -82,13 +82,13 @@ export declare class DbServer {
     }>;
     createSortIndexBuffer(typeId: number, field: number, start: number, lang: number): SortIndex;
     updateMerkleTree(): void;
-    putSchema(strictSchema: StrictSchema, fromStart?: boolean, transformFns?: TransformFns): (StrictSchema & {
+    setSchema(strictSchema: StrictSchema, fromStart?: boolean, transformFns?: TransformFns): (StrictSchema & {
         lastId: number;
     }) | Promise<StrictSchema & {
         lastId: number;
     }>;
-    modify(buf: Buffer): Record<number, number>;
-    getQueryBuf(buf: Buffer): Promise<Uint8Array>;
+    modify(buf: Uint8Array): Record<number, number>;
+    getQueryBuf(buf: Uint8Array): Promise<Uint8Array>;
     onQueryEnd(): void;
     stop(noSave?: boolean): Promise<void>;
     destroy(): Promise<void>;

package/dist/src/server/index.js

@@ -1,4 +1,5 @@
 import native from '../native.js';
+import createDbHash from './dbHash.js';
 import { rm, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { getPropType, langCodesMap, } from '@based/schema';
@@ -24,6 +25,12 @@ class SortIndex {
     idx;
     cnt = 0;
 }
+function readUint16LE(buf, off) {
+    return buf[off] | (buf[off + 1] << 8);
+}
+function readUint32LE(buf, off) {
+    return (buf[off] | (buf[off + 1] << 8) | (buf[off + 2] << 16) | (buf[off + 3] << 24));
+}
 export class DbWorker {
     constructor(address, db) {
         const { port1, port2 } = new MessageChannel();
@@ -73,7 +80,7 @@ export class DbServer {
     maxModifySize;
     merkleTree;
     dirtyRanges = new Set();
-    csmtHashFun = native.createHash();
+    csmtHashFun = createDbHash();
     workers = [];
     availableWorkerIndex = -1;
     processingQueries = 0;
@@ -152,13 +159,16 @@ export class DbServer {
         if (sortIndex) {
             return sortIndex;
         }
-        const buf = Buffer.allocUnsafe(8);
+        const buf = new Uint8Array(8);
         // size [2 type] [1 field]  [2 start] [2 len] [propIndex] [lang]
         // call createSortBuf here
-        buf.writeUint16LE(t.id, 0);
+        buf[0] = t.id;
+        buf[1] = t.id >>> 8;
         buf[2] = prop.prop;
-        buf.writeUint16LE(prop.start, 3);
-        buf.writeUint16LE(prop.len, 5);
+        buf[3] = prop.start;
+        buf[4] = prop.start >>> 8;
+        buf[5] = prop.len;
+        buf[6] = prop.len >>> 8;
         buf[7] = prop.typeIndex;
         buf[8] = langCode;
         sortIndex = new SortIndex(buf, this.dbCtxExternal);
@@ -179,10 +189,12 @@ export class DbServer {
         let sortIndex = fields[prop.start];
         if (sortIndex) {
             // [2 type] [1 field] [2 start] [1 lang]
-            const buf = Buffer.allocUnsafe(6);
-            buf.writeUint16LE(t.id, 0);
+            const buf = new Uint8Array(6);
+            buf[0] = t.id;
+            buf[1] = t.id >>> 8;
             buf[2] = prop.prop;
-            buf.writeUint16LE(prop.start, 3);
+            buf[3] = prop.start;
+            buf[4] = prop.start >>> 8;
             buf[5] =
                 langCodesMap.get(lang ?? Object.keys(this.schema?.locales ?? 'en')[0]) ?? 0;
             native.destroySortIndex(buf, this.dbCtxExternal);
@@ -208,10 +220,12 @@ export class DbServer {
         return migrate(this, schema, transform);
     }
     createSortIndexBuffer(typeId, field, start, lang) {
-        const buf = Buffer.allocUnsafe(9);
-        buf.writeUint16LE(typeId, 0);
+        const buf = new Uint8Array(9);
+        buf[0] = typeId;
+        buf[1] = typeId >>> 8;
         buf[2] = field;
-        buf.writeUint16LE(start, 3);
+        buf[3] = start;
+        buf[4] = start >>> 8;
         let typeDef;
         let prop;
         for (const t in this.schemaTypesParsed) {
@@ -233,7 +247,8 @@ export class DbServer {
         if (!prop) {
             throw new Error(`Cannot find prop on db from query for sort ${field}`);
         }
-        buf.writeUint16LE(prop.len, 5);
+        buf[5] = prop.len;
+        buf[6] = prop.len >>> 8;
         buf[7] = prop.typeIndex;
         buf[8] = lang;
         // put in modify stuff
@@ -247,7 +262,7 @@ export class DbServer {
     updateMerkleTree() {
         foreachDirtyBlock(this, (mtKey, typeId, start, end) => {
             const oldLeaf = this.merkleTree.search(mtKey);
-            const hash = Buffer.allocUnsafe(16);
+            const hash = new Uint8Array(16);
             native.getNodeRangeHash(typeId, start, end, hash, this.dbCtxExternal);
             if (oldLeaf) {
                 if (hashEq(oldLeaf.hash, hash)) {
@@ -267,7 +282,7 @@ export class DbServer {
             this.merkleTree.insert(mtKey, hash, data);
         });
     }
-    putSchema(strictSchema, fromStart = false, transformFns) {
+    setSchema(strictSchema, fromStart = false, transformFns) {
         if (!fromStart && Object.keys(this.schema.types).length > 0) {
             return this.migrateSchema(strictSchema, transformFns);
         }
@@ -338,17 +353,18 @@ export class DbServer {
             }
             if (strictSchema.props) {
                 // insert a root node
-                const data = [2, 1, 0, 0, 0, 17, 9, 1, 0, 0, 0, 7, 1, 0, 1];
+                const data = [2, 1, 0, 0, 0, 1, 9, 1, 0, 0, 0, 7, 1, 0, 1];
                 const blockKey = makeCsmtKey(1, 1);
-                const buf = Buffer.alloc(data.length + 2 + 8 + 4);
+                const buf = new Uint8Array(data.length + 2 + 8 + 4);
+                const view = new DataView(buf.buffer, 0, buf.byteLength);
                 // add content
                 buf.set(data);
                 // add typesLen
-                buf.writeDoubleLE(0, data.length);
+                view.setFloat64(data.length, 0, true);
                 // add dirty key
-                buf.writeDoubleLE(blockKey, data.length + 2);
+                view.setFloat64(data.length + 2, blockKey, true);
                 // add dataLen
-                buf.writeUint32LE(data.length, buf.length - 4);
+                view.setUint32(buf.length - 4, data.length, true);
                 this.modify(buf);
             }
         }
@@ -357,24 +373,26 @@ export class DbServer {
     }
     modify(buf) {
         const offsets = {};
-        const dataLen = buf.readUint32LE(buf.length - 4);
-        let typesSize = buf.readUint16LE(dataLen);
+        const dataLen = readUint32LE(buf, buf.length - 4);
+        let typesSize = readUint16LE(buf, dataLen);
         let i = dataLen + 2;
         while (typesSize--) {
-            const typeId = buf.readUint16LE(i);
+            const typeId = readUint16LE(buf, i);
             i += 2;
-            const startId = buf.readUint32LE(i);
+            const startId = readUint32LE(buf, i);
             const def = this.schemaTypesParsedById[typeId];
             const offset = def.lastId - startId;
-            buf.writeUint32LE(offset, i);
-            i += 4;
-            const lastId = buf.readUint32LE(i);
+            buf[i++] = offset;
+            buf[i++] = offset >>> 8;
+            buf[i++] = offset >>> 16;
+            buf[i++] = offset >>> 24;
+            const lastId = readUint32LE(buf, i);
             i += 4;
             def.lastId = lastId + offset;
             offsets[typeId] = offset;
         }
         if (this.processingQueries) {
-            this.modifyQueue.push(Buffer.from(buf));
+            this.modifyQueue.push(new Uint8Array(buf));
         }
         else {
             this.#modify(buf);
@@ -383,21 +401,22 @@ export class DbServer {
     }
     #modify(buf) {
         const end = buf.length - 4;
-        const dataLen = buf.readUint32LE(end);
-        let typesSize = buf.readUint16LE(dataLen);
+        const dataLen = readUint32LE(buf, end);
+        let typesSize = readUint16LE(buf, dataLen);
         const typesLen = typesSize * 10;
         const types = buf.subarray(dataLen + 2, dataLen + typesLen + 2);
         const data = buf.subarray(0, dataLen);
         let i = dataLen + 2;
         while (typesSize--) {
-            const typeId = buf.readUint16LE(i);
+            const typeId = readUint16LE(buf, i);
             const def = this.schemaTypesParsedById[typeId];
             const key = makeCsmtKeyFromNodeId(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 = buf.readDoubleLE(i);
+            const key = view.getFloat64(i, true);
             this.dirtyRanges.add(key);
             i += 8;
         }
@@ -412,13 +431,13 @@ export class DbServer {
         else {
             const queryType = buf[0];
             if (queryType == 2) {
-                const s = 13 + buf.readUint16LE(11);
-                const sortLen = buf.readUint16LE(s);
+                const s = 13 + readUint16LE(buf, 11);
+                const sortLen = readUint16LE(buf, s);
                 if (sortLen) {
-                    const typeId = buf.readUint16LE(1);
+                    const typeId = readUint16LE(buf, 1);
                     const sort = buf.slice(s + 2, s + 2 + sortLen);
                     const field = sort[1];
-                    const start = sort.readUint16LE(2 + 1);
+                    const start = readUint16LE(sort, 3);
                     let sortIndex = this.getSortIndex(typeId, field, start, 0);
                     if (!sortIndex) {
                         if (this.processingQueries) {

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

@@ -39,7 +39,7 @@ export const migrate = async (fromDbServer, toSchema, transform) => {
         await toDb.destroy();
         return fromDbServer.schema;
     }
-    toSchema = await toDb.putSchema(toSchema);
+    toSchema = await toDb.setSchema(toSchema);
     const fromSchema = fromDbServer.schema;
     const fromCtx = fromDbServer.dbCtxExternal;
     const toCtx = toDb.server.dbCtxExternal;

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

@@ -14,8 +14,8 @@ else {
     const toDb = new BasedDb({ path });
     fromDb.server.dbCtxExternal = fromCtx;
     toDb.server.dbCtxExternal = toCtx;
-    await fromDb.putSchema(fromSchema, true);
-    await toDb.putSchema(toSchema, true);
+    await fromDb.setSchema(fromSchema, true);
+    await toDb.setSchema(toSchema, true);
     const map = {};
     for (const type in fromDb.client.schemaTypesParsed) {
         const { id, props } = fromDb.client.schemaTypesParsed[type];

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

@@ -1,2 +1,2 @@
 import { DbServer } from './index.js';
-export declare function save(db: DbServer, sync?: boolean): void | Promise<void>;
+export declare function save<T extends boolean>(db: DbServer, sync?: T): T extends true ? void : Promise<void>;

package/dist/src/server/save.js

@@ -42,25 +42,25 @@ export function save(db, sync = false) {
     });
     db.dirtyRanges.clear();
     const types = {};
+    const rangeDumps = {};
     for (const key in db.schemaTypesParsed) {
-        const def = db.schemaTypesParsed[key];
-        types[def.id] = { lastId: def.lastId, blockCapacity: def.blockCapacity };
-    }
-    const dumps = {};
-    for (const key in db.schemaTypesParsed) {
-        const def = db.schemaTypesParsed[key];
-        dumps[def.id] = [];
+        const { id, lastId, blockCapacity } = db.schemaTypesParsed[key];
+        types[id] = { lastId, blockCapacity };
+        rangeDumps[id] = [];
     }
     db.merkleTree.visitLeafNodes((leaf) => {
-        const [typeId] = destructureCsmtKey(leaf.key);
+        const [typeId, start] = destructureCsmtKey(leaf.key);
         const data = leaf.data;
-        dumps[typeId].push({ ...data, hash: bufToHex(leaf.hash) });
+        if (start != data.start) {
+            console.error(`csmtKey start and range start mismatch: ${start} != ${data.start}`);
+        }
+        rangeDumps[typeId].push({ ...data, hash: bufToHex(leaf.hash) });
     });
     const data = {
         ts,
         types,
         commonDump: COMMON_SDB_FILE,
-        rangeDumps: dumps,
+        rangeDumps,
     };
     const mtRoot = db.merkleTree.getRoot();
     if (mtRoot) {

package/dist/src/server/start.js

@@ -52,7 +52,7 @@ export async function start(db, opts) {
         const schema = await readFile(join(path, SCHEMA_FILE));
         if (schema) {
             // Prop need to not call setting in selva
-            db.putSchema(JSON.parse(schema.toString()), true);
+            db.setSchema(JSON.parse(schema.toString()), true);
         }
     }
     catch (err) {
@@ -65,7 +65,9 @@ export async function start(db, opts) {
     // FDN-791 CSMT is unstable (not history independent)
     // For now we just sort the types to ensure that we always
     // load in the same order.
-    const types = Object.keys(db.schemaTypesParsed).sort((a, b) => db.schemaTypesParsed[a].id - db.schemaTypesParsed[b].id).reduce((obj, key) => {
+    const types = Object.keys(db.schemaTypesParsed)
+        .sort((a, b) => db.schemaTypesParsed[a].id - db.schemaTypesParsed[b].id)
+        .reduce((obj, key) => {
         obj[key] = db.schemaTypesParsed[key];
         return obj;
     }, {});

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

@@ -6,8 +6,8 @@ export type CsmtNodeRange = {
     start: number;
     end: number;
 };
-export declare const makeCsmtKey: (typeId: number, start: number) => number;
 export declare const destructureCsmtKey: (key: number) => number[];
+export declare const makeCsmtKey: (typeId: number, start: number) => number;
 export declare const makeCsmtKeyFromNodeId: (typeId: number, blockCapacity: number, nodeId: number) => number;
 export declare function foreachBlock(db: DbServer, def: SchemaTypeDef, cb: (start: number, end: number, hash: Uint8Array) => void): Promise<void>;
 export declare function foreachDirtyBlock(db: DbServer, cb: (mtKey: number, typeId: number, start: number, end: number) => void): Promise<void>;

package/dist/src/server/tree.js

@@ -1,9 +1,9 @@
 import native from '../native.js';
-export const makeCsmtKey = (typeId, start) => typeId * 4294967296 + start;
 export const destructureCsmtKey = (key) => [
     (key / 4294967296) | 0, // typeId
     (key >>> 31) * 2147483648 + (key & 0x7fffffff), // start_node_id
 ];
+export const makeCsmtKey = (typeId, start) => typeId * 4294967296 + start;
 export const makeCsmtKeyFromNodeId = (typeId, blockCapacity, nodeId) => {
     const tmp = nodeId - +!(nodeId % blockCapacity);
     return typeId * 4294967296 + ((tmp / blockCapacity) | 0) * blockCapacity + 1;

package/dist/src/utils.d.ts

@@ -1,4 +1,7 @@
+export declare const DECODER: TextDecoder;
+export declare const ENCODER: TextEncoder;
 export declare const equals: (aB: Uint8Array, bB: Uint8Array) => boolean;
+export declare function concatUint8Arr(bufs: Uint8Array[], totalByteLength?: number): Uint8Array;
 export declare const bufToHex: (a: Uint8Array) => string;
 export declare const hexToBuf: (s: string) => Uint8Array;
 export declare const base64encode: (a: Uint8Array, lineMax?: number) => string;

package/dist/src/utils.js

@@ -1,11 +1,14 @@
-import native from './native.js';
+import { encodeBase64 } from '@saulx/utils';
+const native = (typeof window === 'undefined') ? (await import('./native.js')).default : null;
+export const DECODER = new TextDecoder('utf-8');
+export const ENCODER = new TextEncoder();
 export const equals = (aB, bB) => {
     const len = aB.byteLength;
     if (len != bB.byteLength) {
         return false;
     }
     let i = 0;
-    if (len < 50) {
+    if (len < 50 || !native) {
         while (i < len) {
             if (aB[i] != bB[i]) {
                 return false;
@@ -24,8 +27,18 @@ export const equals = (aB, bB) => {
         return native.equals(aB, bB);
     }
 };
-const charMap = new TextEncoder().encode("0123456789abcdef");
-const DECODER = new TextDecoder();
+export function concatUint8Arr(bufs, totalByteLength) {
+    totalByteLength = totalByteLength ?? bufs.reduce((acc, cur) => acc + cur.byteLength, 0);
+    const res = new Uint8Array(totalByteLength);
+    let off = 0;
+    for (let i = 0; i < bufs.length; i++) {
+        const buf = bufs[i];
+        res.set(buf, off);
+        off += buf.byteLength;
+    }
+    return res;
+}
+const charMap = ENCODER.encode('0123456789abcdef');
 // Uint8Array.fromHex() and Uint8Array.toHex() are not available in V8
 // https://issues.chromium.org/issues/42204568
 export const bufToHex = (a) => {
@@ -79,6 +92,11 @@ function base64OutLen(n, lineMax) {
 export const base64encode = (a, lineMax = 72) => {
     // TODO Could fallback to @saulx/utils if native is not available
     const tmp = new Uint8Array(base64OutLen(a.byteLength, lineMax));
-    return DECODER.decode(native.base64encode(tmp, a, lineMax));
+    if ((a.length < 10 && lineMax === 72) || !native) {
+        return encodeBase64(a);
+    }
+    else {
+        return DECODER.decode(native.base64encode(tmp, a, lineMax));
+    }
 };
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/db",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "license": "MIT",
   "type": "module",
   "main": "./dist/src/index.js",
@@ -17,6 +17,7 @@
     "test": "npm run build && LOCPATH=../locale/locale-x86_64-gnu/locale ./scripts/lldb-node ./scripts/test.js",
     "test-gdb": "npm run build && LOCPATH=../locale/locale-x86_64-gnu/locale gdb -ex run --args node ./scripts/test.js",
     "test-fast": "LOCPATH=../locale/locale-x86_64-gnu/locale node ./scripts/test.js",
+    "test-fast-linux_aarch64": "podman run --rm -v \"$PWD/../..:/usr/src/based-db\" based-db-clibs-build-linux_aarch64 sh -c '\\. \"/usr/local/nvm/nvm.sh\"; cd /usr/src/based-db/packages/db; npm run test-fast'",
     "test-zig": "npm run build-zig -- debug && tsc && npm run test-fast",
     "test-ts": "tsc && node ./scripts/test.js",
     "perf": "npm run build && node benchmarks/references.js && node benchmarks/transfermarkt/transfermarkt-based.js"
@@ -31,7 +32,7 @@
     "basedDbNative.cjs"
   ],
   "dependencies": {
-    "@based/schema": "5.0.0-alpha.5",
+    "@based/schema": "5.0.0-alpha.6",
     "@saulx/hash": "^3.0.0",
     "@saulx/utils": "^4.3.2",
     "exit-hook": "^4.0.0",

package/dist/src/client/query/read/types.d.ts

@@ -1,4 +0,0 @@
-export declare const READ_ID = 255;
-export declare const READ_EDGE = 252;
-export declare const READ_REFERENCES = 253;
-export declare const READ_REFERENCE = 254;

package/dist/src/client/query/read/types.js

@@ -1,5 +0,0 @@
-export const READ_ID = 255;
-export const READ_EDGE = 252;
-export const READ_REFERENCES = 253;
-export const READ_REFERENCE = 254;
-//# sourceMappingURL=types.js.map