corebasic 1.0.232 → 1.0.233

package/libs/elabase.ts

@@ -15,7 +15,7 @@ export const shard_stats = ShardStats
 
 
 let Events = {
-    send: function(topic?: string, data?: any) { }
+    send: function(_topic?: string, _data?: any) { }
 }
 
 
@@ -24,7 +24,7 @@ let Events = {
 const url = process.env.DIP_URL || "http://127.0.0.1"; // Set DIP_URL to "http://dip" (Prod) or http://dip-dev (Dev) in CI/CD
 let port = process.env.DIP_PORT || 9401
 let api = 'execute'
-let fullurl = `${url}:${port}/${api}`
+// let fullurl = `${url}:${port}/${api}`
 
 
 let Elabase = {
@@ -38,8 +38,10 @@ let Elabase = {
     }
 }
 
+type Internal = {db: undefined | string, engineName: "lmdb" | "sled" | "sanakirja"}
+
 let engine = Elabase.Engine.Lmdb
-let internal = {
+let internal: Internal = {
     db: undefined,
     engineName: engine === Elabase.Engine.Lmdb ? "lmdb" : (engine === Elabase.Engine.Sled ? "sled" : engine === Elabase.Engine.Sanakirja ? "sanakirja" : "lmdb")
 }
@@ -47,14 +49,14 @@ let internal = {
 let db = internal.db // default database
 
 
-export function start(dbName) {
+export function start(dbName: string) {
     if (!Utils.isEmpty(dbName) && Utils.isEmpty(db)) {
         internal.db = "data/" + dbName
         db = "data/" + dbName
     }
 }
 
-function deepFreeze(obj) {
+function deepFreeze(obj: Record<string, any>) {
     if (obj && typeof obj === "object" && !Object.isFrozen(obj)) {
         Object.freeze(obj);
 
@@ -65,20 +67,28 @@ function deepFreeze(obj) {
     return obj;
 }
 export class DipMeta {
-    declare company?: string;
-    declare outlet?: string;
-
-    constructor(obj) {
+    declare company?: string | string[];
+    declare outlet?: string | string[];
+    declare suffix?: string | string[];
+    declare syncMode?: boolean;
+    declare db?: string;
+    declare DIP_DB?: string;
+    declare DIP_URL?: string;
+    declare executor?: "native" | "raw";
+    declare batch?: string;
+    declare allowDangerousRemove?: boolean;
+
+    constructor(obj: Record<string, unknown>) {
         Object.assign(this, deepFreeze(obj));
         Object.freeze(this);
     }
 }
-export const isDipMeta = meta => meta instanceof DipMeta
+export const isDipMeta = (meta: DipMeta) => meta instanceof DipMeta
 
 export const globalMeta = (args?: any) => {
     return new DipMeta({ ...args, company: "GLOBAL", outlet: "GLOBAL" })
 }
-export const companyMeta = (company, args?: any) => {
+export const companyMeta = (company: string | string[], args?: any) => {
     if (typeof company !== "string" && !Array.isArray(company))
         throw new Error("Error: Invalid company provided in Dip.companyMeta()")
     if (!company || (typeof company === "string" && company.trim() === "") ||  company === "GLOBAL" || (Array.isArray(company) && (!company.length || company.some(item => typeof item !== "string" || item.trim() === "" || item === "GLOBAL")) ))
@@ -86,7 +96,7 @@ export const companyMeta = (company, args?: any) => {
 
     return new DipMeta({...args, outlet: "GLOBAL", company})
 }
-export const outletMeta = (outlet, args?: any) => {
+export const outletMeta = (outlet: string | string[], args?: any) => {
     if (typeof outlet !== "string" && !Array.isArray(outlet))
         throw new Error("Error: Invalid outlet provided in Dip.outletMeta()")
     if (!outlet || (typeof outlet === "string" && outlet.trim() === "") ||  outlet === "GLOBAL" || (Array.isArray(outlet) && (!outlet.length || outlet.some(item => typeof item !== "string" || item.trim() === "" || item === "GLOBAL")) ))
@@ -95,7 +105,7 @@ export const outletMeta = (outlet, args?: any) => {
     return new DipMeta({...args, company: "GLOBAL", outlet})
 }
 
-export const customMeta = (company, outlet, args?: any) => {
+export const customMeta = (company: string | string[], outlet: string | string[], args?: any) => {
 
     if (typeof company !== "string" && !Array.isArray(company))
         throw new Error("Error: Invalid company provided in Dip.customMeta()")
@@ -110,13 +120,13 @@ export const customMeta = (company, outlet, args?: any) => {
     return new DipMeta({...args, company, outlet})
 }
 
-function validate_collection(collection, fn_name) {
+function validate_collection(collection: string | string[], fn_name: string) {
     if ((typeof collection === 'string' && collection.trim() === "") || (typeof collection !== 'string' && !Array.isArray(collection)) || (Array.isArray(collection) && (!collection.length || collection.some(item => typeof item !== "string" || item.trim() === "")))) {
         throw new Error(`Error: Invalid collection ${fn_name}`)
     }
 }
 
-function validate_meta(meta, fn_name) {
+function validate_meta(meta: DipMeta, fn_name: string) {
     if (!meta || typeof meta !== 'object') {
         throw new Error(`Error: Invalid meta ${fn_name}`)
     }
@@ -132,7 +142,7 @@ function validate_meta(meta, fn_name) {
         throw new Error(`Error: Invalid meta.suffix ${fn_name}`)
 }
 
-function generate_suffix(meta) {
+function generate_suffix(meta: DipMeta) {
 
     // Assuming validate_meta() is called before reaching here. If not then this is intentional validation bypass
 
@@ -148,9 +158,9 @@ function generate_suffix(meta) {
     outlet = outlet.length ? outlet : [""]
     suffix = suffix.length ? suffix : [""]
 
-    company = new Set(company)
-    outlet = new Set(outlet)
-    suffix = new Set(suffix)
+    company = [...new Set(company)]
+    outlet = [...new Set(outlet)]
+    suffix = [...new Set(suffix)]
 
     // console.log(company, outlet, suffix)
     let suffixes = []
@@ -170,21 +180,36 @@ function generate_suffix(meta) {
 
 // Ported
 let BATCH_COUNTER = 0n;
-let batches = {}
+let batches: Record<string, (InsertRequest | QueryRequest | UpdateRequest | RemoveRequest)[]> = {}
 
 // Ported
-export function batchBegin() { // Manual Lifecycle. If you forget to batchSubmit() or batchAbort(), then memory leak due to dangling batch
-    const uid = ++BATCH_COUNTER; // Safe. No skew in async ++BATCH_COUNTER as single thread and ++COUNTER is atomic in event loop sense. ⚠️ Only breaks on worker_threads or cluster (multi-process)
-    batches[uid.toString()] = []
+export function batchBegin(): string { // Manual Lifecycle. If you forget to batchSubmit() or batchAbort(), then memory leak due to dangling batch
+    const uid = (++BATCH_COUNTER).toString(); // Safe. No skew in async ++BATCH_COUNTER. Single thread ++COUNTER is atomic in event loop sense. ⚠️ Breaks on worker_threads or cluster (multi-process)
+    batches[uid] = []
     return uid
 }
 // Ported
-export function batchAbort(batch_id) { // Mandatory  to prevent meory leak due to dangling batch if batchBegin() is called without batchSubmit()
+export function batchAbort(batch_id: string) { // Mandatory  to prevent meory leak due to dangling batch if batchBegin() is called without batchSubmit()
     delete batches[batch_id]
 }
 
+
+type BufferItem = {buf: Buffer | Uint8Array; vlq: Uint8Array}
+type HashItem = {buf: Buffer | Uint8Array; offset: number}
+type RawManager = {
+    buffers: BufferItem[];
+    size: number;
+    hashes: Map<bigint, HashItem[]>;
+    add: (value: Buffer | string | number | any) => number | undefined;
+}
+
+type BatchArg = {
+    db?: string, collection?: string | string[], suffix?: string | string[],
+    executor?: "native" | "raw" | undefined, syncMode?: false | undefined, raw?: RawManager | undefined, engine?: string | undefined, port?: number | undefined, timeout?: number | undefined, version?: boolean | undefined, compression?: boolean | undefined
+}
+
 // Ported
-export const batch = async (callback, arg) => { // Convenience function with auto lifecyle management and auto submit when callback returns. abort is called appropriately.
+export const batch = async (callback: (batch_id: string) => Promise<void>, arg: BatchArg) => { // Convenience function with auto lifecyle management and auto submit when callback returns. abort is called appropriately.
     /**
      * Usage:
      * const result = await Dip.batch(async batch => {
@@ -205,8 +230,9 @@ export const batch = async (callback, arg) => { // Convenience function with aut
     }
 }
 
+
 // Ported
-export function batchSubmit(batch_id, arg) {
+export function batchSubmit(batch_id: string, arg: BatchArg) {
     if (!batch_id || !batches[batch_id] || !batches[batch_id].length)
         throw new Error(`Error: Invalid batch in Dip.batchSubmit()`)
     let txns = batches[batch_id]
@@ -217,8 +243,8 @@ export function batchSubmit(batch_id, arg) {
     const port = arg?.port
     const timeout = arg?.timeout
     delete batches[batch_id]
-    return new Promise<void>((resolve, reject) => resolve())
-    .then(() => execute({ "batch": txns, version: arg?.version, raw, engine, compression: arg?.compression, executor, syncMode, port, timeout }))
+    return new Promise<void>((resolve, _reject) => resolve())
+    .then(() => execute({ "batch": txns, version: arg?.version, raw, engine, compression: arg?.compression, executor: executor ?? "native", syncMode: syncMode ?? false, port, timeout }))
     .then (result => {
         Events.send("Dip.batchSubmit", { response: result })
         return result
@@ -229,8 +255,8 @@ let PROJECT_ROOT_URL = new URL('../../..', import.meta.url)
 if (String(PROJECT_ROOT_URL).endsWith('node_modules/'))
     PROJECT_ROOT_URL = new URL('..', PROJECT_ROOT_URL)
 
-const SCHEMAS_JSON_PROMISES = {}
-export const schema = async (name) => {
+const SCHEMAS_JSON_PROMISES: Record<string, Promise<unknown>> = {}
+export const schema = async (name: string) => {
     // Cache the loading promise right away so parallel requests share it
     if (!SCHEMAS_JSON_PROMISES[name])
         SCHEMAS_JSON_PROMISES[name] = Utils.fileToJson(PROJECT_ROOT_URL, `schemas/${name}.json`)
@@ -245,18 +271,26 @@ export const schema = async (name) => {
     }
 }
 
-const COLLECTIONS_JSON = await (async () => {
+
+type CoreConfig = { company?: string | {}, outlet?: string | {}, }
+type CollectionConfig = CoreConfig & { suffix?: Record<string, CoreConfig>  }
+
+type SuffixItem = { key?: string; value?: string; type: string; ls_threshold?: number; min?: number; max?: number }
+type CollectionsJsonType = Record<string, CollectionConfig & {policy?: {when: object, suffix: SuffixItem[]}[]}>
+
+const COLLECTIONS_JSON: CollectionsJsonType = await (async () => {
     try {
-        return await Utils.fileToJson(PROJECT_ROOT_URL, 'collections.json')
+        return await Utils.fileToJson(PROJECT_ROOT_URL, 'collections.json') as CollectionsJsonType
     } catch(e) {
         console.error(e)
         console.warn("Warn: Dip Failed to load collections.json. Semantics, topology and legality enforcement is not active")
     }
+    return {}
 })();
 
 function init_collections_config() {
     for (let collection in COLLECTIONS_JSON) {
-        let config = COLLECTIONS_JSON[collection]
+        let config = COLLECTIONS_JSON[collection]!
         if (config.suffix !== undefined && (typeof config.suffix !== "object" || Array.isArray(config.suffix)) ) {
             throw new Error(`Error: Initiating collection configs failed. Invalid suffix in collection: ${collection}`)
         }
@@ -265,15 +299,16 @@ function init_collections_config() {
 if (COLLECTIONS_JSON)
     init_collections_config()
 
-const EXCLUDED_COLLECTIONS_CONFIG = {}
-export function excludeCollectionConfig(collection) {
+const EXCLUDED_COLLECTIONS_CONFIG: Record<string, boolean> = {}
+export function excludeCollectionConfig(collection: string) {
     EXCLUDED_COLLECTIONS_CONFIG[collection] = true
 }
-export function includeCollectionConfig(collection) {
+export function includeCollectionConfig(collection: string) {
     delete EXCLUDED_COLLECTIONS_CONFIG[collection]
 }
 
-function validate_topology(meta, collection, fn_name) {
+function validate_topology(meta: DipMeta, cols: string | string[], fn_name: string) {
+    const collection = typeof cols === "string" ? cols : cols[0]! // TODO: arrays
 
     let new_meta = meta
 
@@ -284,7 +319,7 @@ function validate_topology(meta, collection, fn_name) {
         return new_meta
     }
 
-    function check_core_meta(config, meta, suffix?: string) {
+    function check_core_meta(config: CoreConfig, meta: DipMeta, suffix?: string) {
         if (config.company !== meta.company && typeof config.company !== "object")
             throw new Error(`Error: Incompatible meta.company config for collection: ${collection}${suffix ? ' suffix: ' + suffix : ''}${fn_name ? ` ${fn_name}` : ''}`)
         if (config.outlet !== meta.outlet && typeof config.outlet !== "object")
@@ -293,13 +328,14 @@ function validate_topology(meta, collection, fn_name) {
 
     check_core_meta(config, meta)
 
-    if (config.suffix && meta.suffix) {
-        if (!config.suffix[meta.suffix]) {
-            console.warn(`Warn: Missing suffix config for collection: ${collection} suffix:${meta.suffix}${fn_name ? ` ${fn_name}` : ''}`)
+    const meta_suffix = meta.suffix as string // TODO: use loop
+    if (config.suffix && meta_suffix) {
+        if (!config.suffix[meta_suffix]) {
+            console.warn(`Warn: Missing suffix config for collection: ${collection} suffix:${meta_suffix}${fn_name ? ` ${fn_name}` : ''}`)
             return new_meta
         }
-        check_core_meta(config.suffix[meta.suffix], meta, meta.suffix)
-        new_meta = Object.assign({}, {...config, suffix: undefined, company: undefined, outlet: undefined}, {...config.suffix[meta.suffix], company: undefined, outlet: undefined}, meta)
+        check_core_meta(config.suffix[meta_suffix], meta, meta_suffix)
+        new_meta = Object.assign({}, {...config, suffix: undefined, company: undefined, outlet: undefined}, {...config.suffix[meta_suffix], company: undefined, outlet: undefined}, meta)
     } else {
         new_meta = Object.assign({}, {...config, suffix: undefined, company: undefined, outlet: undefined}, {company: undefined, outlet: undefined}, meta)
     }
@@ -308,7 +344,7 @@ function validate_topology(meta, collection, fn_name) {
 }
 
 // Ported
-export const operation = async (name, extras) => {
+export const operation = async (name: string, extras: BatchArg) => {
     return execute({ operation: name, ...extras })
 }
 
@@ -318,6 +354,8 @@ type Options = {
     idempotent: boolean;
     $orderby: any;
     $fields: any;
+    $rangeFrom: any;
+    $rangeTo: any;
     _id?: string | number;
 }
 type InsertRequest = {
@@ -325,11 +363,11 @@ type InsertRequest = {
     executor: "native" | "raw";
     collection: string[];
     suffix: string | string[];
-    _id?: string | number;
+    _id?: string | number | undefined;
     insert: number | any;
     options: Options;
-    syncMode: boolean;
-    DIP_URL?: string;
+    syncMode?: boolean;
+    DIP_URL?: string | undefined;
     DIP_DB?: string;
 }
 
@@ -337,8 +375,22 @@ type QueryRequest = Omit<InsertRequest, "_id" | "insert"> & { query: any }
 type UpdateRequest = Omit<InsertRequest, "insert"> & { query: any, update: any }
 type RemoveRequest = QueryRequest & { delete: true }
 
+type BatchItem = (InsertRequest | QueryRequest | UpdateRequest | RemoveRequest)
+type DipRequest = Omit<BatchItem, "syncMode" | "collection" | "suffix" | "options" | "executor" | "db" | "_id"> &
+                  Omit<BatchArg, "syncMode" | "collection" | "suffix" | "options" | "executor" | "db" | "_id"> &  {
+    batch?: BatchItem[],
+    syncMode?: boolean | undefined,
+    operation?: string,
+    options?: Options,
+    executor?: "native" | "raw" | undefined,
+    db?: string,
+    collection?: string | string[],
+    suffix?: string | string[],
+    _id?: string | number | undefined,
+}
+
 // Ported
-export const insert = async (meta, collection, value, options?: any, extras?: any) => {
+export const insert = async (meta: DipMeta, collection: string | string[], value: any, options?: any, extras?: any) => {
 
     if (!(meta instanceof DipMeta)) console.warn('Warn: Provided meta is not an instance of DipMeta in Dip.insert()') // TODO: throw error once review completes
 
@@ -352,7 +404,7 @@ export const insert = async (meta, collection, value, options?: any, extras?: an
         collection: typeof collection === "string" ? [collection] : collection,
         insert: value,
         options: options ? options : {},
-        syncMode: meta.syncMode,
+        syncMode: meta.syncMode ?? false,
         db: extras?.db ?? meta?.db ?? db,
         ...(meta.DIP_URL ? {DIP_URL: meta.DIP_URL} : {}),
         ...(meta.DIP_DB ? {db: meta.DIP_DB} : {}),
@@ -373,10 +425,10 @@ export const insert = async (meta, collection, value, options?: any, extras?: an
     if (meta.batch) {
         if (!batches[meta.batch])
             throw new Error('Error: Invalid batch in Dip.insert()')
-        batches[meta.batch].push(arg)
+        batches[meta.batch]!.push(arg)
         return
     }
-    return new Promise<void>((resolve, reject) => resolve())
+    return new Promise<void>((resolve, _reject) => resolve())
     .then(() => execute(arg))
     .then(result => {
         Events.send("Dip.insert", { collection: collectionArray(collection), response: result })
@@ -385,7 +437,7 @@ export const insert = async (meta, collection, value, options?: any, extras?: an
 }
 
 // Ported
-export const query = async (meta, collection, query, options?: any, extras?: any) => {
+export const query = async (meta: DipMeta, collection: string | string[], query: any, options?: any, extras?: any) => {
 
     if (!(meta instanceof DipMeta)) console.warn('Warn: Provided meta is not an instance of DipMeta in Dip.query()') // TODO: throw error once review completes
 
@@ -399,7 +451,7 @@ export const query = async (meta, collection, query, options?: any, extras?: any
         collection: typeof collection === "string" ? [collection] : collection,
         query: query,
         options: options ? options : {},
-        syncMode: meta.syncMode,
+        syncMode: meta.syncMode ?? false,
         db: extras?.db ?? meta?.db ?? db,
         ...(meta.DIP_URL ? {DIP_URL: meta.DIP_URL} : {}),
         ...(meta.DIP_DB ? {db: meta.DIP_DB} : {}),
@@ -415,32 +467,21 @@ export const query = async (meta, collection, query, options?: any, extras?: any
     if (meta.batch) {
         if (!batches[meta.batch])
             throw new Error('Error: Invalid batch in Dip.query()')
-        batches[meta.batch].push(arg)
+        batches[meta.batch]!.push(arg)
         return
     }
-    return new Promise<void>((resolve, reject) => resolve())
+    return new Promise<void>((resolve, _reject) => resolve())
     .then(() => execute(arg))
 }
 
 
-function collectionArray(col) {
-    let type = Object.prototype.toString.call(col)
-    if (type === '[object Array]') {
-        let newcol = []
-        for (let i in col) {
-            if (!Utils.isEmpty(col[i]))
-                newcol.push(col[i])
-        }
-        return newcol
-    } else if (type === '[object String]') {
-        if (!Utils.isEmpty(col))
-            return [col]
-    }
-    return []
+function collectionArray(col: string | string[]) {
+    const collections = typeof col === 'string' ? [col] : Array.isArray(col) ? col : []
+    return collections.filter(collection => collection.trim())
 }
 
 // Ported
-export const update = async (meta, collection, query, update, options?: any, extras?: any) => {
+export const update = async (meta: DipMeta, collection: string | string[], query: any, update: any, options?: any, extras?: any) => {
 
     if (!(meta instanceof DipMeta)) console.warn('Warn: Provided meta is not an instance of DipMeta in Dip.update()') // TODO: throw error once review completes
 
@@ -455,7 +496,7 @@ export const update = async (meta, collection, query, update, options?: any, ext
         query: query,
         update: update,
         options: options ? options : {},
-        syncMode: meta.syncMode,
+        syncMode: meta.syncMode ?? false,
         db: extras?.db ?? meta?.db ?? db,
         ...(meta.DIP_URL ? {DIP_URL: meta.DIP_URL} : {}),
         ...(meta.DIP_DB ? {db: meta.DIP_DB} : {}),
@@ -471,10 +512,10 @@ export const update = async (meta, collection, query, update, options?: any, ext
     if (meta.batch) {
         if (!batches[meta.batch])
             throw new Error('Error: Invalid batch in Dip.update()')
-        batches[meta.batch].push(arg)
+        batches[meta.batch]!.push(arg)
         return
     }
-    return new Promise<void>((resolve, reject) => resolve())
+    return new Promise<void>((resolve, _reject) => resolve())
     .then(() => execute(arg))
     .then (result => {
         Events.send("Dip.update", { collection: collectionArray(collection), response: result })
@@ -483,7 +524,7 @@ export const update = async (meta, collection, query, update, options?: any, ext
 }
 
 // Ported
-export const remove = async (meta, collection, query, options?: any, extras?: any) => {
+export const remove = async (meta: DipMeta, collection: string | string[], query: any, options?: any, extras?: any) => {
 
     if (!(meta instanceof DipMeta)) console.warn('Warn: Provided meta is not an instance of DipMeta in Dip.remove()') // TODO: throw error once review completes
 
@@ -501,7 +542,7 @@ export const remove = async (meta, collection, query, options?: any, extras?: an
         query: query,
         options: options ? options : {},
         delete: true,
-        syncMode: meta.syncMode,
+        syncMode: meta.syncMode ?? false,
         db: extras?.db ?? meta?.db ?? db,
         ...(meta.DIP_URL ? {DIP_URL: meta.DIP_URL} : {}),
         ...(meta.DIP_DB ? {db: meta.DIP_DB} : {}),
@@ -517,10 +558,10 @@ export const remove = async (meta, collection, query, options?: any, extras?: an
     if (meta.batch) {
         if (!batches[meta.batch])
             throw new Error('Error: Invalid batch in Dip.query()')
-        batches[meta.batch].push(arg)
+        batches[meta.batch]!.push(arg)
         return
     }
-    return new Promise<void>((resolve, reject) => resolve())
+    return new Promise<void>((resolve, _reject) => resolve())
     .then(() => execute(arg))
     .then(result => {
         Events.send("Dip.remove", { collection: collectionArray(collection), response: result })
@@ -528,13 +569,19 @@ export const remove = async (meta, collection, query, options?: any, extras?: an
     })
 }
 
-
+type BinaryResponse = {metadata: any, content: any}
+type DipResponse = AxiosResponse & {
+    body: any;
+    getSliceAsText(offset: number, length: number): string;
+    getSliceAsArrayBuffer(offset: number, length: number): Buffer;
+    "Content-Type"?: string;
+};
 
 export let config = {
     useDipper: false
 }
 
-function execute(arg) {
+function execute(arg: DipRequest) {
 //         arg example
 //        {
 //            db: "middle-earth",
@@ -546,7 +593,7 @@ function execute(arg) {
 
 //            _id: 1 // Optional. Used with insert
 //        }
-        arg.db = arg.db ?? db
+        arg.db = arg.db ? arg.db : db ? db : ''
         arg.executor = arg.executor ?? "native"
         arg.engine = arg.engine ?? internal.engineName
         if (arg.compression === undefined)
@@ -559,20 +606,14 @@ function execute(arg) {
         delete arg.timeout
 
 
-        return config.useDipper  ? dipper(arg)
+        return config.useDipper ? dipper(arg)
         : axios
         .post(arg.DIP_URL ?? fullurl, buildHybridRequest({...arg, DIP_URL: undefined}), { responseType: 'arraybuffer', timeout: timeout ?? 5000, headers: {"Content-Type": "application/dip"} })
-        .then(dip_result => {
+        .then((dip_result: AxiosResponse) => {
             // console.log(res.status);
             // console.log(JSON.stringify(res.header, null, 4));
             // console.log(JSON.stringify(res.body, null, 4));
 
-            type DipResponse = AxiosResponse & {
-                body: any;
-                getSliceAsText(offset: number, length: number): string;
-                getSliceAsArrayBuffer(offset: number, length: number): Buffer;
-                "Content-Type"?: string;
-            };
 
             const result = dip_result as DipResponse
 
@@ -608,7 +649,7 @@ let Essentials = {
 
 
 
-function prepareResult(result) {
+function prepareResult(result: BinaryResponse) {
     let res = result.content?.length === 1  ? result.content[0].items : result.content // For raw, this resolves to result.content which is ArrayBuffer
     res.metadata = () => result.metadata
     if (result.metadata.executor === "raw")
@@ -616,7 +657,7 @@ function prepareResult(result) {
         return res
 }
 
-function parseBinaryResponse(result) {
+function parseBinaryResponse(result: DipResponse): BinaryResponse {
     const contentType = (result["Content-Type"] || "").toLowerCase()
     if (contentType.includes("application/json")) {
         return {metadata: result.body, content: result.body.items}
@@ -639,7 +680,7 @@ function parseBinaryResponse(result) {
 
     // parseWireFormat() equivalent
     // =============================
-    let dataView = new DataView(arrayBuffer.buffer,  arrayBuffer.byteOffset,  arrayBuffer.byteLength);
+    // let dataView = new DataView(arrayBuffer.buffer,  arrayBuffer.byteOffset,  arrayBuffer.byteLength);
     let offset = 0;
 
     // 1. Read the metadata size header
@@ -659,9 +700,20 @@ function parseBinaryResponse(result) {
     return { metadata: nativeResponse, content: content }
 }
 
+type RawBatchBuffer = Uint8Array & {
+    metadata(): {
+        items: {
+            offset: number
+            size: number
+            count: number
+            kv: () => void
+        }[]
+    }
+    items?: unknown
+}
 
-function setRawBatchIterator(arrayBuffer) {
-    arrayBuffer.metadata().items.forEach(batch => {
+function setRawBatchIterator(arrayBuffer: RawBatchBuffer) {
+    arrayBuffer.metadata().items.forEach((batch: {offset: number, size: number, count: number, kv: () => void}) => {
         batch.kv = () => {
             const batchItem = {
                 count: batch.count,
@@ -695,7 +747,7 @@ function setRawBatchIterator(arrayBuffer) {
 
 
 
-function convert_to_array_buffer(value) {
+function convert_to_array_buffer(value: ArrayBuffer | string | number | any) {
     if (typeof value === "string")
         return Essentials.stringToUtf8ArrayBuffer(value)
     else if (typeof value === "number")
@@ -703,20 +755,12 @@ function convert_to_array_buffer(value) {
     return Essentials.stringToUtf8ArrayBuffer(JSON.stringify(value))
 }
 
-export function newRaw() {
-    type BufferItem = {buf: ArrayBuffer | Uint8Array; vlq: Uint8Array}
-    type HashItem = {buf: ArrayBuffer | Uint8Array; offset: number}
-    type RawManager = {
-        buffers: BufferItem[];
-        size: number;
-        hashes: Map<bigint, HashItem[]>;
-        add: (value: ArrayBuffer | string | number | any) => number;
-    }
-    let obj: RawManager = {buffers: [], size: 0, hashes: new Map()} as RawManager
-    obj.add = (value: ArrayBuffer | string | number | any): number => {
+export function newRaw(): RawManager {
+    let obj: RawManager = {buffers: [], size: 0, hashes: new Map(), add: (_value: Buffer | string | number | any) => 0} as RawManager
+    obj.add = (value: Buffer | string | number | any): number | undefined => {
         if (value === undefined)
             return undefined
-            const buf = (value instanceof ArrayBuffer) ? value : convert_to_array_buffer(value);
+            const buf = (value instanceof Buffer) ? value : convert_to_array_buffer(value);
 
         const hash = Essentials.defaultHash(buf)
         for (const item of obj.hashes.get(hash) ?? []) { // Conflict. Fallback to verify
@@ -732,14 +776,16 @@ export function newRaw() {
 
         if (!obj.hashes.get(hash))
             obj.hashes.set(hash, [])
-        obj.hashes.get(hash).push({offset, buf})
+        obj.hashes.get(hash)!.push({offset, buf})
 
         return offset
     }
     return obj
 }
 
-function buildHybridRequest(request) {
+
+
+function buildHybridRequest(request: DipRequest) {
     const batch = request.batch ?? [request];
 
     let raw = request.raw ?? newRaw()
@@ -747,23 +793,23 @@ function buildHybridRequest(request) {
 
     // Pass 1: Direct offset assignment & exact size calculation (Zero allocation)
     for (let i = 0; i < batch.length; i++) {
-        const item = batch[i];
-        delete item.batch
-        if (item.update) {
-            if ( item._id === undefined && item.options?.upsert && item.query?._id !== undefined)
-                item._id = item.query._id
-            item.update = raw.add(item.update)
-        } else if (item.insert) {
-            if (item._id === undefined && item.insert?._id !== undefined)
-                item._id = item.insert._id
-            item.insert = raw.add(item.insert)
+        const item = batch[i]!;
+        delete (item as DipRequest).batch
+        if ((item as UpdateRequest).update) {
+            if ( (item as UpdateRequest)._id === undefined && (item as UpdateRequest).options?.upsert && (item as UpdateRequest).query?._id !== undefined)
+                (item as UpdateRequest)._id = (item as UpdateRequest).query._id;
+            (item as UpdateRequest).update = raw.add((item as UpdateRequest).update)
+        } else if ((item as InsertRequest).insert) {
+            if ((item as InsertRequest)._id === undefined && (item as InsertRequest).insert?._id !== undefined)
+                (item as InsertRequest)._id = (item as InsertRequest).insert._id;
+            (item as InsertRequest).insert = raw.add((item as InsertRequest).insert)
         }
-        item._id = raw.add(item._id)
+        (item as InsertRequest | UpdateRequest)._id = raw.add((item as InsertRequest | UpdateRequest)._id)
 
         if (item.options?.$rangeFrom !== undefined)
             item.options.$rangeFrom = raw.add(item.options.$rangeFrom)
-            if (item.options?.$rangeTo !== undefined)
-                item.options.$rangeTo = raw.add(item.options.$rangeTo)
+        if (item.options?.$rangeTo !== undefined)
+            item.options.$rangeTo = raw.add(item.options.$rangeTo)
     }
 
     // Pass 2: Generate the final JSON payload string
@@ -815,12 +861,12 @@ function buildHybridRequest(request) {
 
 
 
-function bufferToString(arrayBuffer) {
-    return Essentials.arrayBufferToString(arrayBuffer)
+function bufferToString(arrayBuffer: string | undefined | ArrayBuffer | SharedArrayBuffer | Buffer) {
+    return Essentials.arrayBufferToString(arrayBuffer as Buffer)
 }
 
-function getRawKeyValue(arrayBuffer, offset) {
-    let dataView = new DataView(arrayBuffer.buffer,  arrayBuffer.byteOffset,  arrayBuffer.byteLength);
+function getRawKeyValue(arrayBuffer: Uint8Array, offset: number) {
+    // let dataView = new DataView(arrayBuffer.buffer,  arrayBuffer.byteOffset,  arrayBuffer.byteLength);
     let masterView = new Uint8Array(arrayBuffer);
 
     // 1. Extract Key Size and Key
@@ -834,7 +880,7 @@ function getRawKeyValue(arrayBuffer, offset) {
 
     // Zero-copy view window bounded strictly to the key bytes
     let _id = masterView.subarray(offset, offset + keySize) as EnhancedUint8Array;
-    let _id_string
+    let _id_string: string | undefined | ArrayBuffer | SharedArrayBuffer
     _id.toText = () => {
         // Fix: Pass the typed array view itself, NOT the underlying root buffer
         _id_string = _id_string === undefined ? _id.buffer.slice(_id.byteOffset, _id.byteOffset + _id.byteLength) : _id_string