From 5153910db513355b960fd1d6dfb75eb0bdf88920 Mon Sep 17 00:00:00 2001
From: Nick Chomey <nick_chomey@hotmail.com>
Date: Mon, 2 Mar 2026 18:10:32 -0600
Subject: [PATCH 1/9] implement serializeDocument and compress/decompress

---
 doc/export-import.md | 179 ++++++++++++++++++++++++++++
 index.d.ts           |  16 +++
 src/bundle.js        |   5 +
 src/document.js      |   3 +-
 src/serialize.js     | 276 +++++++++++++++++++++++++++++++++++++++++++
 test/compress.js     | 178 ++++++++++++++++++++++++++++
 test/serialize.js    |  81 +++++++++++++
 7 files changed, 737 insertions(+), 1 deletion(-)
 create mode 100644 test/compress.js

diff --git a/doc/export-import.md b/doc/export-import.md
index 1c8aabf7..bfc8e951 100644
--- a/doc/export-import.md
+++ b/doc/export-import.md
@@ -101,6 +101,185 @@ const index = new Index();
 inject(index);
 ```
 
+<a name="document-serialize"></a>
+
+## Document Fast-Boot Serialization
+
+Document indexes can also be serialized for fast-boot on the client side. This works similarly to Index serialization but handles multiple fields, tags, and storage.
+
+### Serialize a Document Index
+
+```js
+const fn_string = document.serialize();
+```
+
+This produces a function string that looks like:
+
+```js
+function inject(doc){
+    doc.reg = new Set([/* ... */]);
+    doc.index.get("fieldName").map = new Map([/* ... */]);
+    doc.index.get("fieldName").ctx = new Map([/* ... */]);
+    // ... for each field
+}
+```
+
+### Restore the serialized Document
+
+On the client side, create a new Document with the same configuration and inject:
+
+```js
+const config = {
+    document: {
+        id: "id",
+        index: [{field: "title"}, {field: "body"}]
+    }
+};
+
+const doc = new Document(config);
+inject(doc);
+
+// Now search on the restored index
+const results = doc.search("your query");
+```
+
+### Without function wrapper
+
+Get just the body if you want to wrap it differently:
+
+```js
+const fn_body = document.serialize(false);
+const inject = new Function("doc", fn_body);
+```
+
+<a name="compression"></a>
+
+## Compression Utilities
+
+For large indexes, you can compress the serialized output using gzip compression to reduce payload size for delivery over the network or storage.
+
+### Compress Serialized Data
+
+```js
+import { compress, decompress } from "flexsearch";
+
+// Get compressed serialized output directly
+const compressed = await document.serialize(true, true);
+// Returns Uint8Array
+
+// Store or send the compressed data
+const buffer = Buffer.from(compressed);
+await fs.writeFile("./serialized.js.gz", buffer);
+```
+
+### Decompress and Restore
+
+```js
+// Load compressed data
+const buffer = await fs.readFile("./serialized.js.gz");
+const compressed = new Uint8Array(buffer);
+
+// Decompress
+const fn_string = await decompress(compressed);
+
+// Create inject function
+const inject = new Function("doc", fn_string.slice(17, -1)); // Remove "function inject(doc){" and "}"
+
+// Create document with same config and inject
+const doc = new Document(config);
+inject(doc);
+```
+
+### Compression Utilities API
+
+#### compress(data: string | Uint8Array): Promise<Uint8Array>
+
+Compress a string or binary data using gzip.
+
+```js
+const compressed = await compress("some string data");
+```
+
+#### decompress(data: Uint8Array): Promise<string>
+
+Decompress gzip-compressed data back to string.
+
+```js
+const decompressed = await decompress(compressed);
+```
+
+### Compression Ratios
+
+Typical compression ratios for serialized FlexSearch data:
+
+- Small indexes (< 10KB): 15-25% reduction
+- Medium indexes (10KB - 100KB): 25-35% reduction
+- Large indexes (> 100KB): 30-45% reduction
+
+Text-heavy content with repetitive terms compresses even better (40-50%+).
+
+### Streaming Architecture
+
+The compression is implemented with streaming to minimize memory overhead:
+
+1. **Serialization with compression toggle:**
+```js
+const compressed = await document.serialize(true, true);
+```
+
+2. **Standalone compression:**
+```js
+const data = "...";
+const compressed = await compress(data);
+```
+
+Both use efficient streaming to avoid allocating the entire uncompressed data in memory.
+
+### Deployment Patterns
+
+#### Pattern 1: Inline in HTML (small indexes)
+
+```html
+<script>
+const serialized = "function inject(doc){...}";
+const doc = new Document(config);
+const inject = new Function("doc", serialized.slice(17, -1));
+inject(doc);
+</script>
+```
+
+#### Pattern 2: External gzipped script (medium indexes)
+
+```html
+<!-- Application/gzip in response headers + CompressionStream for decompression -->
+<script src="serialized.js.gz"></script>
+<!-- Browser automatically decompresses, then executes -->
+```
+
+#### Pattern 3: Dynamic loader with compression (large indexes)
+
+```js
+async function loadSerializedIndex() {
+    const response = await fetch("serialized.js.gz");
+    const compressed = new Uint8Array(await response.arrayBuffer());
+    const fn_string = await decompress(compressed);
+    
+    const doc = new Document(config);
+    const inject = new Function("doc", fn_string.slice(17, -1));
+    inject(doc);
+    return doc;
+}
+
+const doc = await loadSerializedIndex();
+```
+
+#### Pattern 4: Data URLs (very small indexes)
+
+```js
+const fn_string = document.serialize(true, false);
+const dataUrl = "data:text/javascript;base64," + btoa(fn_string);
+// Use in <script src> or dynamic loading
+```
 
 <a name="export"></a>
 
diff --git a/index.d.ts b/index.d.ts
index 92edcf33..0f9fc6c9 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -148,6 +148,20 @@ declare module "flexsearch" {
         LatinDefault: EncoderOptions
     };
 
+    /**
+     * Compress data using gzip compression
+     * @param data - String or binary data to compress
+     * @returns Promise that resolves to compressed Uint8Array
+     */
+    export function compress(data: string | Uint8Array): Promise<Uint8Array>;
+
+    /**
+     * Decompress gzip-compressed data
+     * @param data - Compressed data as Uint8Array
+     * @returns Promise that resolves to decompressed string
+     */
+    export function decompress(data: Uint8Array): Promise<string>;
+
     /**
      * These options will determine how the contents will be indexed.
      *
@@ -747,6 +761,8 @@ declare module "flexsearch" {
 
         import(key: string, data: string): void;
 
+        serialize(with_function_wrapper?: boolean, compress?: boolean): SerializedFunctionString | Promise<Uint8Array>;
+
         // Persistent Index
         mount<S = StorageInterface<D>>(db: S): Promise<void>;
 
diff --git a/src/bundle.js b/src/bundle.js
index 4100f95e..e623fed2 100644
--- a/src/bundle.js
+++ b/src/bundle.js
@@ -37,6 +37,7 @@ import Encoder from "./encoder.js";
 import IdxDB from "./db/indexeddb/index.js";
 import Charset from "./charset.js";
 import { KeystoreMap, KeystoreArray, KeystoreSet } from "./keystore.js";
+import { compress, decompress } from "./serialize.js";
 
 /** @export */ Index.prototype.add;
 /** @export */ Index.prototype.append;
@@ -339,6 +340,8 @@ const FlexSearch = {
     "Worker": SUPPORT_WORKER ? WorkerIndex : null,
     "Resolver": SUPPORT_RESOLVER ? Resolver : null,
     "IndexedDB": SUPPORT_PERSISTENT ? IdxDB : null,
+    "compress": SUPPORT_SERIALIZE ? compress : null,
+    "decompress": SUPPORT_SERIALIZE ? decompress : null,
     "Language": {}
 };
 
@@ -386,6 +389,8 @@ export {
     Document,
     Encoder,
     Charset,
+    compress,
+    decompress,
     WorkerIndex as Worker,
     Resolver,
     IdxDB as IndexedDB
diff --git a/src/document.js b/src/document.js
index 325070f5..dce20a2c 100644
--- a/src/document.js
+++ b/src/document.js
@@ -38,7 +38,7 @@ import Encoder, { fallback_encoder } from "./encoder.js";
 import Cache, { searchCache } from "./cache.js";
 import { is_string, is_object, parse_simple } from "./common.js";
 import apply_async from "./async.js";
-import { exportDocument, importDocument } from "./serialize.js";
+import { exportDocument, importDocument, serializeDocument } from "./serialize.js";
 import { KeystoreMap, KeystoreSet } from "./keystore.js";
 import "./document/add.js";
 import "./document/search.js";
@@ -573,6 +573,7 @@ if(SUPPORT_SERIALIZE){
 
     Document.prototype.export = exportDocument;
     Document.prototype.import = importDocument;
+    Document.prototype.serialize = serializeDocument;
 }
 
 if(SUPPORT_ASYNC){
diff --git a/src/serialize.js b/src/serialize.js
index 2a280796..b77ee808 100644
--- a/src/serialize.js
+++ b/src/serialize.js
@@ -523,4 +523,280 @@ function parse_map(map, type){
         result += (result ? ',' : '') + res;
     }
     return result;
+}
+
+/**
+ * Helper: Serialize a Map<string, Map> for tags
+ * @param {Map} tagMap
+ * @param {string} type
+ * @return {string}
+ */
+function parse_tag_map(tagMap, type){
+    let result = '';
+    for(const item of tagMap.entries()){
+        const key = item[0];
+        const value = item[1]; // inner Map
+        let inner = '';
+        for(const innerItem of value.entries()){
+            const innerKey = innerItem[0];
+            const innerValue = innerItem[1];
+            let ids = '';
+            for(let j = 0; j < innerValue.length; j++){
+                ids += (ids ? ',' : '') + (type === "string" ? '"' + innerValue[j] + '"' : innerValue[j]);
+            }
+            ids = '["' + innerKey + '",[' + ids + ']]';
+            inner += (inner ? ',' : '') + ids;
+        }
+        inner = '["' + key + '",new Map([' + inner + '])]';
+        result += (result ? ',' : '') + inner;
+    }
+    return result;
+}
+
+/**
+ * Serialize a Document's multi-field indexes with optional streaming compression
+ * @this {Document}
+ * @param {boolean=} withFunctionWrapper - Wrap in function(doc) or return raw statements
+ * @param {boolean=} compress - Stream through gzip compression
+ * @return {string|Promise<Uint8Array>|Uint8Array}
+ */
+export function serializeDocument(withFunctionWrapper = true, compress = false){
+    
+    let statements = '';
+    let type = undefined;
+    
+    // Serialize shared registry once
+    if(this.reg && this.reg.size){
+        let reg = '';
+        for(const key of this.reg.keys()){
+            type || (type = typeof key);
+            reg += (reg ? ',' : '') + (type === "string" ? '"' + key + '"' : key);
+        }
+        statements += 'doc.reg=new Set([' + reg + ']);';
+    }
+    
+    // Serialize each field index
+    if(this.index && this.index.size){
+        for(const fieldName of this.field){
+            const index = this.index.get(fieldName);
+            if(!index) continue;
+            
+            // Only serialize if field index has map data
+            if(index.map && index.map.size){
+                let map = parse_map(index.map, type);
+                if(map){
+                    statements += 'doc.index.get("' + fieldName + '").map=new Map([' + map + ']);';
+                }
+                
+                // Serialize ctx if present
+                if(index.ctx && index.ctx.size){
+                    let ctx = '';
+                    for(const context of index.ctx.entries()){
+                        const key_ctx = context[0];
+                        const value_ctx = context[1];
+                        let ctx_map = parse_map(value_ctx, type);
+                        if(ctx_map){
+                            ctx_map = "new Map([" + ctx_map + "])";
+                            ctx_map = '["' + key_ctx + '",' + ctx_map + ']';
+                            ctx += (ctx ? ',' : '') + ctx_map;
+                        }
+                    }
+                    if(ctx){
+                        statements += 'doc.index.get("' + fieldName + '").ctx=new Map([' + ctx + ']);';
+                    }
+                }
+            }
+        }
+    }
+    
+    // Serialize tags if present
+    if(SUPPORT_TAGS && this.tag && this.tagfield){
+        for(let i = 0; i < this.tagfield.length; i++){
+            const tagField = this.tagfield[i];
+            const tagMap = this.tag.get(tagField);
+            if(tagMap && tagMap.size){
+                let tag = parse_tag_map(tagMap, type);
+                if(tag){
+                    statements += 'doc.tag.get("' + tagField + '").clear();' + 
+                                  'for(const [k,v] of new Map([' + tag + ']).entries()){doc.tag.get("' + tagField + '").set(k,v);}';
+                }
+            }
+        }
+    }
+    
+    // Serialize store if present
+    if(SUPPORT_STORE && this.store && this.store.size){
+        let storeData = '';
+        for(const item of this.store.entries()){
+            const key = item[0];
+            const value = item[1];
+            const valueJson = JSON.stringify(value);
+            storeData += (storeData ? ',' : '') + '[' + (typeof key === "string" ? '"' + key + '"' : key) + ',' + valueJson + ']';
+        }
+        if(storeData){
+            statements += 'for(const [k,v] of new Map([' + storeData + ']).entries()){doc.store.set(k,v);}';
+        }
+    }
+    
+    const body = withFunctionWrapper
+        ? "function inject(doc){" + statements + "}"
+        : statements;
+    
+    if(!compress){
+        return body;
+    }
+    
+    // Stream compression path with TransformStream
+    return new Promise(function(resolve, reject){
+        try {
+            const encoder = new TextEncoder();
+            const data = encoder.encode(body);
+            
+            const compressedChunks = [];
+            const stream = data.stream ? data.stream() : new ReadableStream({
+                start(controller){
+                    controller.enqueue(data);
+                    controller.close();
+                }
+            });
+            
+            const compressedStream = stream.pipeThrough(new CompressionStream('gzip'));
+            
+            const reader = compressedStream.getReader();
+            
+            (async function pump(){
+                try {
+                    while(true){
+                        const { done, value } = await reader.read();
+                        if(done) break;
+                        compressedChunks.push(value);
+                    }
+                    
+                    let totalLength = 0;
+                    for(let i = 0; i < compressedChunks.length; i++){
+                        totalLength += compressedChunks[i].length;
+                    }
+                    
+                    const result = new Uint8Array(totalLength);
+                    let offset = 0;
+                    for(let i = 0; i < compressedChunks.length; i++){
+                        result.set(compressedChunks[i], offset);
+                        offset += compressedChunks[i].length;
+                    }
+                    
+                    resolve(result);
+                } catch(err){
+                    reject(err);
+                }
+            })();
+        } catch(err){
+            reject(err);
+        }
+    });
+}
+
+/**
+ * Compress data using gzip
+ * @param {string|Uint8Array} data - String or ArrayBuffer to compress
+ * @return {Promise<Uint8Array>} Compressed data as Uint8Array
+ */
+export function compress(data){
+    
+    return new Promise(function(resolve, reject){
+        try {
+            const encoder = new TextEncoder();
+            let bytes = data instanceof Uint8Array ? data : encoder.encode(data);
+            
+            const stream = bytes.stream ? bytes.stream() : new ReadableStream({
+                start(controller){
+                    controller.enqueue(bytes);
+                    controller.close();
+                }
+            });
+            
+            const compressedStream = stream.pipeThrough(new CompressionStream('gzip'));
+            const compressedChunks = [];
+            const reader = compressedStream.getReader();
+            
+            (async function pump(){
+                try {
+                    while(true){
+                        const { done, value } = await reader.read();
+                        if(done) break;
+                        compressedChunks.push(value);
+                    }
+                    
+                    let totalLength = 0;
+                    for(let i = 0; i < compressedChunks.length; i++){
+                        totalLength += compressedChunks[i].length;
+                    }
+                    
+                    const result = new Uint8Array(totalLength);
+                    let offset = 0;
+                    for(let i = 0; i < compressedChunks.length; i++){
+                        result.set(compressedChunks[i], offset);
+                        offset += compressedChunks[i].length;
+                    }
+                    
+                    resolve(result);
+                } catch(err){
+                    reject(err);
+                }
+            })();
+        } catch(err){
+            reject(err);
+        }
+    });
+}
+
+/**
+ * Decompress gzip data
+ * @param {Uint8Array} data - Compressed data
+ * @return {Promise<string>} Decompressed string
+ */
+export function decompress(data){
+    
+    return new Promise(function(resolve, reject){
+        try {
+            const stream = data.stream ? data.stream() : new ReadableStream({
+                start(controller){
+                    controller.enqueue(data);
+                    controller.close();
+                }
+            });
+            
+            const decompressedStream = stream.pipeThrough(new DecompressionStream('gzip'));
+            const decompressedChunks = [];
+            const reader = decompressedStream.getReader();
+            
+            (async function pump(){
+                try {
+                    while(true){
+                        const { done, value } = await reader.read();
+                        if(done) break;
+                        decompressedChunks.push(value);
+                    }
+                    
+                    let totalLength = 0;
+                    for(let i = 0; i < decompressedChunks.length; i++){
+                        totalLength += decompressedChunks[i].length;
+                    }
+                    
+                    const result = new Uint8Array(totalLength);
+                    let offset = 0;
+                    for(let i = 0; i < decompressedChunks.length; i++){
+                        result.set(decompressedChunks[i], offset);
+                        offset += decompressedChunks[i].length;
+                    }
+                    
+                    const decoder = new TextDecoder();
+                    resolve(decoder.decode(result));
+                } catch(err){
+                    reject(err);
+                }
+            })();
+        } catch(err){
+            reject(err);
+        }
+    });
 }
\ No newline at end of file
diff --git a/test/compress.js b/test/compress.js
new file mode 100644
index 00000000..28cd893c
--- /dev/null
+++ b/test/compress.js
@@ -0,0 +1,178 @@
+global.self = global;
+const env = process.argv[process.argv.length - 1] === "--exit" ? "" : process.argv[process.argv.length - 1];
+import { expect } from "chai";
+let FlexSearch = await import(env ? "../dist/" + env + ".js" : "../src/bundle.js");
+if(FlexSearch.default) FlexSearch = FlexSearch.default;
+if(FlexSearch.FlexSearch) FlexSearch = FlexSearch.FlexSearch;
+const { Document, compress, decompress } = FlexSearch;
+const build_light = env && env.includes("light");
+
+if(!build_light) describe("Compression Utilities", function(){
+
+    this.timeout(10000); // Compression can take time
+
+    it("Should compress and decompress strings", async function(){
+
+        const testString = "Hello, this is a test string for compression!".repeat(100);
+        
+        const compressed = await compress(testString);
+        expect(compressed).to.be.instanceOf(Uint8Array);
+        expect(compressed.length).to.be.lessThan(testString.length);
+        
+        const decompressed = await decompress(compressed);
+        expect(decompressed).to.equal(testString);
+    });
+
+    it("Should compress and decompress binary data", async function(){
+
+        const testData = new Uint8Array(Array.from({length: 1000}, (_, i) => i % 256));
+        
+        const compressed = await compress(testData);
+        expect(compressed).to.be.instanceOf(Uint8Array);
+        expect(compressed.length).to.be.lessThan(testData.length);
+        
+        const decompressed = await decompress(compressed);
+        expect(decompressed.length).to.equal(testData.length);
+    });
+
+    it("Should achieve reasonable compression ratio", async function(){
+
+        const largeString = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. ".repeat(500);
+        
+        const compressed = await compress(largeString);
+        const ratio = (1 - (compressed.length / Buffer.byteLength(largeString))) * 100;
+        
+        // Typical gzip ratio for repeated text is 90-95%+
+        expect(ratio).to.be.greaterThan(75);
+    });
+
+    it("Should serialize Document with compression", async function(){
+
+        this.timeout(15000);
+
+        const config = {
+            document: {
+                id: "id",
+                store: true,
+                index: [{
+                    field: "title",
+                    tokenize: "forward"
+                },{
+                    field: "body",
+                    tokenize: "forward"
+                }]
+            }
+        };
+
+        let document = new Document(config);
+
+        // Generate large dataset (500+ documents)
+        for(let i = 0; i < 500; i++){
+            document.add({
+                id: i,
+                title: "Document " + i + " with keywords searching testing",
+                body: "This is document number " + i + " containing multiple paragraphs of text. ".repeat(5)
+            });
+        }
+
+        // Serialize without compression
+        const uncompressed = document.serialize(true, false);
+        expect(typeof uncompressed).to.equal('string');
+
+        // Serialize with compression
+        const compressed = await document.serialize(true, true);
+        expect(compressed).to.be.instanceOf(Uint8Array);
+        expect(compressed.length).to.be.lessThan(Buffer.byteLength(uncompressed));
+
+        // Verify compression ratio
+        const ratio = (1 - (compressed.length / Buffer.byteLength(uncompressed))) * 100;
+        expect(ratio).to.be.greaterThan(20); // At least 20% compression
+
+        // Decompress and verify it matches original (minus wrapper)
+        const decompressed = await decompress(compressed);
+        expect(decompressed).to.equal(uncompressed);
+    });
+
+    it("Should handle empty Document serialization", async function(){
+
+        const config = {
+            document: {
+                id: "id",
+                index: [{
+                    field: "title"
+                }]
+            }
+        };
+
+        let document = new Document(config);
+
+        // Serialize empty document
+        const uncompressed = document.serialize(false, false);
+        expect(uncompressed).to.equal('');
+
+        // Serialize empty document with compression (should still compress even empty/small)
+        const compressed = await document.serialize(false, true);
+        expect(compressed).to.be.instanceOf(Uint8Array);
+
+        const decompressed = await decompress(compressed);
+        expect(decompressed).to.equal('');
+    });
+
+    it("Should handle large multi-field Document", async function(){
+
+        this.timeout(20000);
+
+        const config = {
+            document: {
+                id: "id",
+                store: true,
+                index: [
+                    { field: "title" },
+                    { field: "description" },
+                    { field: "category" },
+                    { field: "tags" },
+                    { field: "author" }
+                ]
+            }
+        };
+
+        let document = new Document(config);
+
+        // Add 1000 documents with multiple fields
+        const keywords = ["search", "flex", "index", "database", "query", "fast"];
+        for(let i = 0; i < 1000; i++){
+            const docData = {
+                id: i,
+                title: keywords[i % keywords.length] + " document " + i,
+                description: "A longer description containing search keywords " + keywords[i % keywords.length].repeat(3),
+                category: ["tech", "search", "index"][i % 3],
+                tags: "tag" + (i % 10) + " tag" + (i % 20),
+                author: "Author " + (i % 50)
+            };
+            document.add(docData);
+        }
+
+        // Test serialization
+        const uncompressed = document.serialize(true, false);
+        expect(uncompressed.length).to.be.greaterThan(1000); // Should be substantial
+
+        // Test compression
+        const compressed = await document.serialize(true, true);
+        expect(compressed.length).to.be.lessThan(uncompressed.length);
+
+        // Decompress and inject to new document
+        const decompressed = await decompress(compressed);
+        const inject = new Function("doc", decompressed.slice(21, -1)); // Extract body from wrapper
+
+        let document2 = new Document(config);
+        inject(document2);
+
+        // Verify restored data
+        const search1 = document.search("search");
+        const search2 = document2.search("search");
+        if(search1 && search1.result && search2 && search2.result){
+            expect(search2.result.length).to.equal(search1.result.length);
+        }
+    });
+
+});
diff --git a/test/serialize.js b/test/serialize.js
index 3d595645..d3ae1738 100644
--- a/test/serialize.js
+++ b/test/serialize.js
@@ -244,6 +244,87 @@ if(!build_light) describe("Document Export/Import", function(){
             }] }
         ]);
     });
+
+    it("Should have been serialized Document-Index properly (Fast-Boot)", function(){
+
+        const config = {
+            document: {
+                id: "tconst",
+                store: true,
+                index: [{
+                    field: "primaryTitle",
+                    tokenize: "forward",
+                    encoder: Charset.LatinBalance
+                },{
+                    field: "originalTitle",
+                    tokenize: "forward",
+                    encoder: Charset.LatinBalance
+                }],
+                tag: [{
+                    field: "startYear"
+                },{
+                    field: "genres"
+                }]
+            }
+        };
+
+        let document = new Document(config);
+
+        for(let i = 0; i < data.length; i++){
+            document.add(data[i]);
+        }
+
+        // Test serialize without compression (string output)
+        const fn_string = document.serialize(true, false);
+        expect(typeof fn_string).to.equal('string');
+        expect(fn_string).to.match(/function inject\(doc\)/);
+
+        // Extract function body for new Function constructor
+        // The format is "function inject(doc){...}" so skip "function inject(doc){" (21 chars) and "}" at end (1 char)
+        const fnBody = fn_string.slice(21, -1);
+        const inject = new Function("doc", fnBody);
+
+        let document2 = new Document(config);
+        inject(document2);
+
+        // Verify indexes were restored correctly
+        const search1 = document.search({
+            query: "karmen",
+            tag: {
+                "startYear": "1894",
+                "genres": ["Documentary", "Short"]
+            },
+            suggest: true,
+            enrich: true
+        });
+
+        if(search1 && search1.field){
+            const search2 = document2.search({
+                query: "karmen",
+                tag: {
+                    "startYear": "1894",
+                    "genres": ["Documentary", "Short"]
+                },
+                suggest: true,
+                enrich: true
+            });
+
+            expect(search2).to.be.ok;
+            if(search2.field && search1.field){
+                expect(search2.field).to.equal(search1.field);
+            }
+        }
+
+        // Verify reg was restored
+        expect(document2.reg.size).to.equal(document.reg.size);
+
+        // Test storing and retrieving directly from inject function
+        let document3 = new Document(config);
+        eval("(function(){ (function inject(doc){" + fnBody + "})(document3); })()");
+        
+        expect(document3.reg.size).to.equal(document.reg.size);
+        expect(document3.store.size).to.equal(document.store.size);
+    });
 });
 
 function normalize_map(map){

From 3f2256d27d80797f7d39ebf849f477675ac51e76 Mon Sep 17 00:00:00 2001
From: Nick Chomey <nick_chomey@hotmail.com>
Date: Mon, 2 Mar 2026 18:39:08 -0600
Subject: [PATCH 2/9] fix tests and compress/decompress

---
 doc/export-import.md |  29 +------
 src/serialize.js     | 187 ++++++++++---------------------------------
 test/compress.js     | 163 ++++++++++++++-----------------------
 test/serialize.js    | 127 ++++++++++-------------------
 4 files changed, 147 insertions(+), 359 deletions(-)

diff --git a/doc/export-import.md b/doc/export-import.md
index bfc8e951..78376144 100644
--- a/doc/export-import.md
+++ b/doc/export-import.md
@@ -208,32 +208,9 @@ Decompress gzip-compressed data back to string.
 const decompressed = await decompress(compressed);
 ```
 
-### Compression Ratios
+### Compression Benefits
 
-Typical compression ratios for serialized FlexSearch data:
-
-- Small indexes (< 10KB): 15-25% reduction
-- Medium indexes (10KB - 100KB): 25-35% reduction
-- Large indexes (> 100KB): 30-45% reduction
-
-Text-heavy content with repetitive terms compresses even better (40-50%+).
-
-### Streaming Architecture
-
-The compression is implemented with streaming to minimize memory overhead:
-
-1. **Serialization with compression toggle:**
-```js
-const compressed = await document.serialize(true, true);
-```
-
-2. **Standalone compression:**
-```js
-const data = "...";
-const compressed = await compress(data);
-```
-
-Both use efficient streaming to avoid allocating the entire uncompressed data in memory.
+Gzip compression significantly reduces the size of serialized FlexSearch data, especially for larger indexes and text-heavy content. The actual compression ratio depends on factors like index size, data structure, and content repetitiveness.
 
 ### Deployment Patterns
 
@@ -261,7 +238,7 @@ inject(doc);
 ```js
 async function loadSerializedIndex() {
     const response = await fetch("serialized.js.gz");
-    const compressed = new Uint8Array(await response.arrayBuffer());
+    const compressed = await response.arrayBuffer();
     const fn_string = await decompress(compressed);
     
     const doc = new Document(config);
diff --git a/src/serialize.js b/src/serialize.js
index b77ee808..05fd0666 100644
--- a/src/serialize.js
+++ b/src/serialize.js
@@ -511,12 +511,17 @@ function parse_map(map, type){
         const value = item[1];
         let res = '';
         for(let i = 0, ids; i < value.length; i++){
-            ids = value[i] || [''];
+            ids = value[i];
             let str = '';
-            for(let j = 0; j < ids.length; j++){
-                str += (str ? ',' : '') + (type === "string" ? '"' + ids[j] + '"' : ids[j]);
+            if(ids && ids.length){
+                for(let j = 0; j < ids.length; j++){
+                    str += (str ? ',' : '') + (type === "string" ? '"' + ids[j] + '"' : ids[j]);
+                }
+                str = '[' + str + ']';
+            }
+            else{
+                str = 'null'; // Preserve null/empty for array structure
             }
-            str = '[' + str + ']';
             res += (res ? ',' : '') + str;
         }
         res = '["' + key + '",[' + res + ']]';
@@ -646,157 +651,47 @@ export function serializeDocument(withFunctionWrapper = true, compress = false){
         return body;
     }
     
-    // Stream compression path with TransformStream
-    return new Promise(function(resolve, reject){
-        try {
-            const encoder = new TextEncoder();
-            const data = encoder.encode(body);
-            
-            const compressedChunks = [];
-            const stream = data.stream ? data.stream() : new ReadableStream({
-                start(controller){
-                    controller.enqueue(data);
-                    controller.close();
-                }
-            });
-            
-            const compressedStream = stream.pipeThrough(new CompressionStream('gzip'));
-            
-            const reader = compressedStream.getReader();
-            
-            (async function pump(){
-                try {
-                    while(true){
-                        const { done, value } = await reader.read();
-                        if(done) break;
-                        compressedChunks.push(value);
-                    }
-                    
-                    let totalLength = 0;
-                    for(let i = 0; i < compressedChunks.length; i++){
-                        totalLength += compressedChunks[i].length;
-                    }
-                    
-                    const result = new Uint8Array(totalLength);
-                    let offset = 0;
-                    for(let i = 0; i < compressedChunks.length; i++){
-                        result.set(compressedChunks[i], offset);
-                        offset += compressedChunks[i].length;
-                    }
-                    
-                    resolve(result);
-                } catch(err){
-                    reject(err);
-                }
-            })();
-        } catch(err){
-            reject(err);
-        }
-    });
+    return compressString(body);
+}
+
+/**
+ * Compress a string using gzip
+ * @param {string} input - String to compress
+ * @return {Promise<Uint8Array>} Compressed data
+ */
+async function compressString(input){
+    const cs = new CompressionStream('gzip');
+    const encoder = new TextEncoder();
+    const inputBytes = encoder.encode(input);
+    const stream = new Blob([inputBytes]).stream().pipeThrough(cs);
+    const compressedBuffer = await new Response(stream).arrayBuffer();
+    return new Uint8Array(compressedBuffer);
 }
 
 /**
  * Compress data using gzip
- * @param {string|Uint8Array} data - String or ArrayBuffer to compress
- * @return {Promise<Uint8Array>} Compressed data as Uint8Array
+ * @param {string|Uint8Array} data - String or binary data to compress
+ * @return {Promise<Uint8Array>} Compressed data
  */
-export function compress(data){
-    
-    return new Promise(function(resolve, reject){
-        try {
-            const encoder = new TextEncoder();
-            let bytes = data instanceof Uint8Array ? data : encoder.encode(data);
-            
-            const stream = bytes.stream ? bytes.stream() : new ReadableStream({
-                start(controller){
-                    controller.enqueue(bytes);
-                    controller.close();
-                }
-            });
-            
-            const compressedStream = stream.pipeThrough(new CompressionStream('gzip'));
-            const compressedChunks = [];
-            const reader = compressedStream.getReader();
-            
-            (async function pump(){
-                try {
-                    while(true){
-                        const { done, value } = await reader.read();
-                        if(done) break;
-                        compressedChunks.push(value);
-                    }
-                    
-                    let totalLength = 0;
-                    for(let i = 0; i < compressedChunks.length; i++){
-                        totalLength += compressedChunks[i].length;
-                    }
-                    
-                    const result = new Uint8Array(totalLength);
-                    let offset = 0;
-                    for(let i = 0; i < compressedChunks.length; i++){
-                        result.set(compressedChunks[i], offset);
-                        offset += compressedChunks[i].length;
-                    }
-                    
-                    resolve(result);
-                } catch(err){
-                    reject(err);
-                }
-            })();
-        } catch(err){
-            reject(err);
-        }
-    });
+export async function compress(data){
+    const cs = new CompressionStream('gzip');
+    const encoder = new TextEncoder();
+    const inputBytes = data instanceof Uint8Array ? data : encoder.encode(data);
+    const stream = new Blob([inputBytes]).stream().pipeThrough(cs);
+    const compressedBuffer = await new Response(stream).arrayBuffer();
+    return new Uint8Array(compressedBuffer);
 }
 
 /**
  * Decompress gzip data
- * @param {Uint8Array} data - Compressed data
+ * @param {Uint8Array|ArrayBuffer} data - Compressed data
  * @return {Promise<string>} Decompressed string
  */
-export function decompress(data){
-    
-    return new Promise(function(resolve, reject){
-        try {
-            const stream = data.stream ? data.stream() : new ReadableStream({
-                start(controller){
-                    controller.enqueue(data);
-                    controller.close();
-                }
-            });
-            
-            const decompressedStream = stream.pipeThrough(new DecompressionStream('gzip'));
-            const decompressedChunks = [];
-            const reader = decompressedStream.getReader();
-            
-            (async function pump(){
-                try {
-                    while(true){
-                        const { done, value } = await reader.read();
-                        if(done) break;
-                        decompressedChunks.push(value);
-                    }
-                    
-                    let totalLength = 0;
-                    for(let i = 0; i < decompressedChunks.length; i++){
-                        totalLength += decompressedChunks[i].length;
-                    }
-                    
-                    const result = new Uint8Array(totalLength);
-                    let offset = 0;
-                    for(let i = 0; i < decompressedChunks.length; i++){
-                        result.set(decompressedChunks[i], offset);
-                        offset += decompressedChunks[i].length;
-                    }
-                    
-                    const decoder = new TextDecoder();
-                    resolve(decoder.decode(result));
-                } catch(err){
-                    reject(err);
-                }
-            })();
-        } catch(err){
-            reject(err);
-        }
-    });
+export async function decompress(data){
+    const ds = new DecompressionStream('gzip');
+    const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+    const stream = new Blob([bytes]).stream().pipeThrough(ds);
+    const decompressedBuffer = await new Response(stream).arrayBuffer();
+    const decoder = new TextDecoder();
+    return decoder.decode(decompressedBuffer);
 }
\ No newline at end of file
diff --git a/test/compress.js b/test/compress.js
index 28cd893c..5e2676f7 100644
--- a/test/compress.js
+++ b/test/compress.js
@@ -4,97 +4,116 @@ import { expect } from "chai";
 let FlexSearch = await import(env ? "../dist/" + env + ".js" : "../src/bundle.js");
 if(FlexSearch.default) FlexSearch = FlexSearch.default;
 if(FlexSearch.FlexSearch) FlexSearch = FlexSearch.FlexSearch;
-const { Document, compress, decompress } = FlexSearch;
+const { Document, compress, decompress, Charset } = FlexSearch;
 const build_light = env && env.includes("light");
 
 if(!build_light) describe("Compression Utilities", function(){
 
-    this.timeout(10000); // Compression can take time
+    this.timeout(10000);
 
     it("Should compress and decompress strings", async function(){
-
         const testString = "Hello, this is a test string for compression!".repeat(100);
-        
         const compressed = await compress(testString);
         expect(compressed).to.be.instanceOf(Uint8Array);
         expect(compressed.length).to.be.lessThan(testString.length);
-        
         const decompressed = await decompress(compressed);
         expect(decompressed).to.equal(testString);
     });
 
     it("Should compress and decompress binary data", async function(){
-
         const testData = new Uint8Array(Array.from({length: 1000}, (_, i) => i % 256));
-        
         const compressed = await compress(testData);
         expect(compressed).to.be.instanceOf(Uint8Array);
         expect(compressed.length).to.be.lessThan(testData.length);
-        
         const decompressed = await decompress(compressed);
         expect(decompressed.length).to.equal(testData.length);
     });
 
-    it("Should achieve reasonable compression ratio", async function(){
-
-        const largeString = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. ".repeat(500);
-        
-        const compressed = await compress(largeString);
-        const ratio = (1 - (compressed.length / Buffer.byteLength(largeString))) * 100;
-        
-        // Typical gzip ratio for repeated text is 90-95%+
-        expect(ratio).to.be.greaterThan(75);
-    });
-
     it("Should serialize Document with compression", async function(){
-
-        this.timeout(15000);
+        const data = [{
+            "tconst": "tt0000001",
+            "titleType": "short",
+            "primaryTitle": "Carmencita",
+            "originalTitle": "Carmencita",
+            "isAdult": 0,
+            "startYear": "1894",
+            "endYear": "",
+            "runtimeMinutes": "1",
+            "genres": ["Documentary", "Short"]
+        },{
+            "tconst": "tt0000002",
+            "titleType": "short",
+            "primaryTitle": "Le clown et ses chiens",
+            "originalTitle": "Le clown et ses chiens",
+            "isAdult": 0,
+            "startYear": "1892",
+            "endYear": "",
+            "runtimeMinutes": "5",
+            "genres": ["Animation", "Short"]
+        }];
 
         const config = {
             document: {
-                id: "id",
+                id: "tconst",
                 store: true,
                 index: [{
-                    field: "title",
-                    tokenize: "forward"
+                    field: "primaryTitle",
+                    tokenize: "forward",
+                    encoder: Charset.LatinBalance
                 },{
-                    field: "body",
-                    tokenize: "forward"
+                    field: "originalTitle",
+                    tokenize: "forward",
+                    encoder: Charset.LatinBalance
+                }],
+                tag: [{
+                    field: "startYear"
+                },{
+                    field: "genres"
                 }]
             }
         };
 
         let document = new Document(config);
-
-        // Generate large dataset (500+ documents)
-        for(let i = 0; i < 500; i++){
-            document.add({
-                id: i,
-                title: "Document " + i + " with keywords searching testing",
-                body: "This is document number " + i + " containing multiple paragraphs of text. ".repeat(5)
-            });
+        for(let i = 0; i < data.length; i++){
+            document.add(data[i]);
         }
 
         // Serialize without compression
-        const uncompressed = document.serialize(true, false);
+        const uncompressed = document.serialize(false, false);
         expect(typeof uncompressed).to.equal('string');
 
         // Serialize with compression
-        const compressed = await document.serialize(true, true);
+        const compressed = await document.serialize(false, true);
         expect(compressed).to.be.instanceOf(Uint8Array);
         expect(compressed.length).to.be.lessThan(Buffer.byteLength(uncompressed));
 
-        // Verify compression ratio
-        const ratio = (1 - (compressed.length / Buffer.byteLength(uncompressed))) * 100;
-        expect(ratio).to.be.greaterThan(20); // At least 20% compression
-
-        // Decompress and verify it matches original (minus wrapper)
+        // Decompress and inject
         const decompressed = await decompress(compressed);
         expect(decompressed).to.equal(uncompressed);
+
+        const inject = new Function("doc", decompressed);
+        let document2 = new Document(config);
+        inject(document2);
+
+        // Verify internal structures match
+        expect(document2.reg.size).to.equal(document.reg.size);
+        expect(document2.store.size).to.equal(document.store.size);
+        
+        // Check each field's index data
+        for(const field of document.field){
+            const idx1 = document.index.get(field);
+            const idx2 = document2.index.get(field);
+            expect(idx2.map.size).to.equal(idx1.map.size);
+            expect(idx2.ctx.size).to.equal(idx1.ctx.size);
+        }
+
+        // Test search results match
+        const search1 = document.search("karmen");
+        const search2 = document2.search("karmen");
+        expect(search2).to.eql(search1);
     });
 
     it("Should handle empty Document serialization", async function(){
-
         const config = {
             document: {
                 id: "id",
@@ -105,12 +124,9 @@ if(!build_light) describe("Compression Utilities", function(){
         };
 
         let document = new Document(config);
-
-        // Serialize empty document
         const uncompressed = document.serialize(false, false);
         expect(uncompressed).to.equal('');
 
-        // Serialize empty document with compression (should still compress even empty/small)
         const compressed = await document.serialize(false, true);
         expect(compressed).to.be.instanceOf(Uint8Array);
 
@@ -118,61 +134,4 @@ if(!build_light) describe("Compression Utilities", function(){
         expect(decompressed).to.equal('');
     });
 
-    it("Should handle large multi-field Document", async function(){
-
-        this.timeout(20000);
-
-        const config = {
-            document: {
-                id: "id",
-                store: true,
-                index: [
-                    { field: "title" },
-                    { field: "description" },
-                    { field: "category" },
-                    { field: "tags" },
-                    { field: "author" }
-                ]
-            }
-        };
-
-        let document = new Document(config);
-
-        // Add 1000 documents with multiple fields
-        const keywords = ["search", "flex", "index", "database", "query", "fast"];
-        for(let i = 0; i < 1000; i++){
-            const docData = {
-                id: i,
-                title: keywords[i % keywords.length] + " document " + i,
-                description: "A longer description containing search keywords " + keywords[i % keywords.length].repeat(3),
-                category: ["tech", "search", "index"][i % 3],
-                tags: "tag" + (i % 10) + " tag" + (i % 20),
-                author: "Author " + (i % 50)
-            };
-            document.add(docData);
-        }
-
-        // Test serialization
-        const uncompressed = document.serialize(true, false);
-        expect(uncompressed.length).to.be.greaterThan(1000); // Should be substantial
-
-        // Test compression
-        const compressed = await document.serialize(true, true);
-        expect(compressed.length).to.be.lessThan(uncompressed.length);
-
-        // Decompress and inject to new document
-        const decompressed = await decompress(compressed);
-        const inject = new Function("doc", decompressed.slice(21, -1)); // Extract body from wrapper
-
-        let document2 = new Document(config);
-        inject(document2);
-
-        // Verify restored data
-        const search1 = document.search("search");
-        const search2 = document2.search("search");
-        if(search1 && search1.result && search2 && search2.result){
-            expect(search2.result.length).to.equal(search1.result.length);
-        }
-    });
-
 });
diff --git a/test/serialize.js b/test/serialize.js
index d3ae1738..9ada7769 100644
--- a/test/serialize.js
+++ b/test/serialize.js
@@ -156,28 +156,28 @@ if(!build_light) describe("Document Export/Import", function(){
         ]
     }];
 
-    it("Should have been exported Document-Index properly", function(){
+    const config = {
+        document: {
+            id: "tconst",
+            store: true,
+            index: [{
+                field: "primaryTitle",
+                tokenize: "forward",
+                encoder: Charset.LatinBalance
+            },{
+                field: "originalTitle",
+                tokenize: "forward",
+                encoder: Charset.LatinBalance
+            }],
+            tag: [{
+                field: "startYear"
+            },{
+                field: "genres"
+            }]
+        }
+    };
 
-        const config = {
-            document: {
-                id: "tconst",
-                store: true,
-                index: [{
-                    field: "primaryTitle",
-                    tokenize: "forward",
-                    encoder: Charset.LatinBalance
-                },{
-                    field: "originalTitle",
-                    tokenize: "forward",
-                    encoder: Charset.LatinBalance
-                }],
-                tag: [{
-                    field: "startYear"
-                },{
-                    field: "genres"
-                }]
-            }
-        };
+    it("Should have been exported Document-Index properly", function(){
 
         let document = new Document(config);
 
@@ -247,89 +247,46 @@ if(!build_light) describe("Document Export/Import", function(){
 
     it("Should have been serialized Document-Index properly (Fast-Boot)", function(){
 
-        const config = {
-            document: {
-                id: "tconst",
-                store: true,
-                index: [{
-                    field: "primaryTitle",
-                    tokenize: "forward",
-                    encoder: Charset.LatinBalance
-                },{
-                    field: "originalTitle",
-                    tokenize: "forward",
-                    encoder: Charset.LatinBalance
-                }],
-                tag: [{
-                    field: "startYear"
-                },{
-                    field: "genres"
-                }]
-            }
-        };
-
         let document = new Document(config);
 
         for(let i = 0; i < data.length; i++){
             document.add(data[i]);
         }
 
-        // Test serialize without compression (string output)
-        const fn_string = document.serialize(true, false);
-        expect(typeof fn_string).to.equal('string');
-        expect(fn_string).to.match(/function inject\(doc\)/);
-
-        // Extract function body for new Function constructor
-        // The format is "function inject(doc){...}" so skip "function inject(doc){" (21 chars) and "}" at end (1 char)
-        const fnBody = fn_string.slice(21, -1);
-        const inject = new Function("doc", fnBody);
+        const fn_string = document.serialize(false);
+        const inject = new Function("doc", fn_string);
 
         let document2 = new Document(config);
         inject(document2);
 
-        // Verify indexes were restored correctly
-        const search1 = document.search({
-            query: "karmen",
-            tag: {
-                "startYear": "1894",
-                "genres": ["Documentary", "Short"]
-            },
-            suggest: true,
-            enrich: true
-        });
-
-        if(search1 && search1.field){
-            const search2 = document2.search({
-                query: "karmen",
-                tag: {
-                    "startYear": "1894",
-                    "genres": ["Documentary", "Short"]
-                },
-                suggest: true,
-                enrich: true
-            });
-
-            expect(search2).to.be.ok;
-            if(search2.field && search1.field){
-                expect(search2.field).to.equal(search1.field);
-            }
+        // Verify internal structures match
+        expect(document2.reg.size).to.equal(document.reg.size);
+        expect(document2.store.size).to.equal(document.store.size);
+        
+        // Check each field's index data
+        for(const field of document.field){
+            const idx1 = document.index.get(field);
+            const idx2 = document2.index.get(field);
+            expect(idx2.map.size).to.equal(idx1.map.size);
+            expect(idx2.ctx.size).to.equal(idx1.ctx.size);
+            expect(normalize_map(idx2.map)).to.eql(normalize_map(idx1.map));
+            expect(normalize_ctx(idx2.ctx)).to.eql(normalize_ctx(idx1.ctx));
         }
 
-        // Verify reg was restored
-        expect(document2.reg.size).to.equal(document.reg.size);
+        // Test search results match
+        const search1 = document.search("karmen");
+        const search2 = document2.search("karmen");
+        expect(search2).to.eql(search1);
 
-        // Test storing and retrieving directly from inject function
+        // Test with function wrapper
         let document3 = new Document(config);
-        eval("(function(){ (function inject(doc){" + fnBody + "})(document3); })()");
-        
-        expect(document3.reg.size).to.equal(document.reg.size);
-        expect(document3.store.size).to.equal(document.store.size);
+        expect(document.serialize()).to.equal("function inject(doc){" + fn_string + "}");
     });
 });
 
 function normalize_map(map){
     return Array.from(map.entries()).map(item => {
-        item[1].forEach((res, i) => res.length || delete item[1][i]);
+        item[1].forEach((res, i) => (res && res.length) || delete item[1][i]);
         return item;
     });
 }

From 8e3a26b393c27f0bfe28d40d1906a50cc502a19b Mon Sep 17 00:00:00 2001
From: Nick Chomey <nick_chomey@hotmail.com>
Date: Mon, 2 Mar 2026 19:15:25 -0600
Subject: [PATCH 3/9] more fixes

---
 index.d.ts        |   6 +-
 src/index.js      |   4 +-
 src/serialize.js  |  41 +++++---------
 test/compress.js  | 137 ----------------------------------------------
 test/serialize.js |  24 +++++++-
 5 files changed, 39 insertions(+), 173 deletions(-)
 delete mode 100644 test/compress.js

diff --git a/index.d.ts b/index.d.ts
index 0f9fc6c9..d049d091 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -149,11 +149,11 @@ declare module "flexsearch" {
     };
 
     /**
-     * Compress data using gzip compression
-     * @param data - String or binary data to compress
+     * Compress a string using gzip compression
+     * @param data - String data to compress
      * @returns Promise that resolves to compressed Uint8Array
      */
-    export function compress(data: string | Uint8Array): Promise<Uint8Array>;
+    export function compress(data: string): Promise<Uint8Array>;
 
     /**
      * Decompress gzip-compressed data
diff --git a/src/index.js b/src/index.js
index d7137c6f..37cd0dd4 100644
--- a/src/index.js
+++ b/src/index.js
@@ -29,7 +29,7 @@ import Cache, { searchCache } from "./cache.js";
 import Charset from "./charset.js";
 import { KeystoreMap, KeystoreSet } from "./keystore.js";
 import { is_array, is_string } from "./common.js";
-import { exportIndex, importIndex, serialize } from "./serialize.js";
+import { exportIndex, importIndex, serializeIndex } from "./serialize.js";
 import { remove_index } from "./index/remove.js";
 //import default_encoder from "./charset/latin/default.js";
 import apply_preset from "./preset.js";
@@ -281,7 +281,7 @@ if(SUPPORT_SERIALIZE){
 
     Index.prototype.export = exportIndex;
     Index.prototype.import = importIndex;
-    Index.prototype.serialize = serialize;
+    Index.prototype.serialize = serializeIndex;
 }
 
 if(SUPPORT_ASYNC){
diff --git a/src/serialize.js b/src/serialize.js
index 05fd0666..8e0a8005 100644
--- a/src/serialize.js
+++ b/src/serialize.js
@@ -470,7 +470,7 @@ ctx: "gulliver+travel:1,2,3|4,5,6|7,8,9;"
  * @return {string}
  */
 
-export function serialize(withFunctionWrapper = true){
+export function serializeIndex(withFunctionWrapper = true){
 
     let reg = '';
     let map = '';
@@ -562,10 +562,10 @@ function parse_tag_map(tagMap, type){
  * Serialize a Document's multi-field indexes with optional streaming compression
  * @this {Document}
  * @param {boolean=} withFunctionWrapper - Wrap in function(doc) or return raw statements
- * @param {boolean=} compress - Stream through gzip compression
+ * @param {boolean=} withCompression - Apply gzip compression
  * @return {string|Promise<Uint8Array>|Uint8Array}
  */
-export function serializeDocument(withFunctionWrapper = true, compress = false){
+export function serializeDocument(withFunctionWrapper = true, withCompression = false){
     
     let statements = '';
     let type = undefined;
@@ -647,50 +647,35 @@ export function serializeDocument(withFunctionWrapper = true, compress = false){
         ? "function inject(doc){" + statements + "}"
         : statements;
     
-    if(!compress){
+    if(!withCompression){
         return body;
     }
     
-    return compressString(body);
+    return compress(body);
 }
 
 /**
- * Compress a string using gzip
- * @param {string} input - String to compress
- * @return {Promise<Uint8Array>} Compressed data
- */
-async function compressString(input){
-    const cs = new CompressionStream('gzip');
-    const encoder = new TextEncoder();
-    const inputBytes = encoder.encode(input);
-    const stream = new Blob([inputBytes]).stream().pipeThrough(cs);
-    const compressedBuffer = await new Response(stream).arrayBuffer();
-    return new Uint8Array(compressedBuffer);
-}
-
-/**
- * Compress data using gzip
- * @param {string|Uint8Array} data - String or binary data to compress
+ * Compress string using gzip
+ * @param {string} data - String to compress
  * @return {Promise<Uint8Array>} Compressed data
  */
 export async function compress(data){
     const cs = new CompressionStream('gzip');
-    const encoder = new TextEncoder();
-    const inputBytes = data instanceof Uint8Array ? data : encoder.encode(data);
-    const stream = new Blob([inputBytes]).stream().pipeThrough(cs);
+    const blob = new Blob([data], { type: 'application/octet-stream' });
+    const stream = blob.stream().pipeThrough(cs);
     const compressedBuffer = await new Response(stream).arrayBuffer();
     return new Uint8Array(compressedBuffer);
 }
 
 /**
- * Decompress gzip data
- * @param {Uint8Array|ArrayBuffer} data - Compressed data
+ * Decompress gzip-compressed data
+ * @param {Uint8Array} data - Compressed data
  * @return {Promise<string>} Decompressed string
  */
 export async function decompress(data){
     const ds = new DecompressionStream('gzip');
-    const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
-    const stream = new Blob([bytes]).stream().pipeThrough(ds);
+    const blob = new Blob([data], { type: 'application/octet-stream' });
+    const stream = blob.stream().pipeThrough(ds);
     const decompressedBuffer = await new Response(stream).arrayBuffer();
     const decoder = new TextDecoder();
     return decoder.decode(decompressedBuffer);
diff --git a/test/compress.js b/test/compress.js
deleted file mode 100644
index 5e2676f7..00000000
--- a/test/compress.js
+++ /dev/null
@@ -1,137 +0,0 @@
-global.self = global;
-const env = process.argv[process.argv.length - 1] === "--exit" ? "" : process.argv[process.argv.length - 1];
-import { expect } from "chai";
-let FlexSearch = await import(env ? "../dist/" + env + ".js" : "../src/bundle.js");
-if(FlexSearch.default) FlexSearch = FlexSearch.default;
-if(FlexSearch.FlexSearch) FlexSearch = FlexSearch.FlexSearch;
-const { Document, compress, decompress, Charset } = FlexSearch;
-const build_light = env && env.includes("light");
-
-if(!build_light) describe("Compression Utilities", function(){
-
-    this.timeout(10000);
-
-    it("Should compress and decompress strings", async function(){
-        const testString = "Hello, this is a test string for compression!".repeat(100);
-        const compressed = await compress(testString);
-        expect(compressed).to.be.instanceOf(Uint8Array);
-        expect(compressed.length).to.be.lessThan(testString.length);
-        const decompressed = await decompress(compressed);
-        expect(decompressed).to.equal(testString);
-    });
-
-    it("Should compress and decompress binary data", async function(){
-        const testData = new Uint8Array(Array.from({length: 1000}, (_, i) => i % 256));
-        const compressed = await compress(testData);
-        expect(compressed).to.be.instanceOf(Uint8Array);
-        expect(compressed.length).to.be.lessThan(testData.length);
-        const decompressed = await decompress(compressed);
-        expect(decompressed.length).to.equal(testData.length);
-    });
-
-    it("Should serialize Document with compression", async function(){
-        const data = [{
-            "tconst": "tt0000001",
-            "titleType": "short",
-            "primaryTitle": "Carmencita",
-            "originalTitle": "Carmencita",
-            "isAdult": 0,
-            "startYear": "1894",
-            "endYear": "",
-            "runtimeMinutes": "1",
-            "genres": ["Documentary", "Short"]
-        },{
-            "tconst": "tt0000002",
-            "titleType": "short",
-            "primaryTitle": "Le clown et ses chiens",
-            "originalTitle": "Le clown et ses chiens",
-            "isAdult": 0,
-            "startYear": "1892",
-            "endYear": "",
-            "runtimeMinutes": "5",
-            "genres": ["Animation", "Short"]
-        }];
-
-        const config = {
-            document: {
-                id: "tconst",
-                store: true,
-                index: [{
-                    field: "primaryTitle",
-                    tokenize: "forward",
-                    encoder: Charset.LatinBalance
-                },{
-                    field: "originalTitle",
-                    tokenize: "forward",
-                    encoder: Charset.LatinBalance
-                }],
-                tag: [{
-                    field: "startYear"
-                },{
-                    field: "genres"
-                }]
-            }
-        };
-
-        let document = new Document(config);
-        for(let i = 0; i < data.length; i++){
-            document.add(data[i]);
-        }
-
-        // Serialize without compression
-        const uncompressed = document.serialize(false, false);
-        expect(typeof uncompressed).to.equal('string');
-
-        // Serialize with compression
-        const compressed = await document.serialize(false, true);
-        expect(compressed).to.be.instanceOf(Uint8Array);
-        expect(compressed.length).to.be.lessThan(Buffer.byteLength(uncompressed));
-
-        // Decompress and inject
-        const decompressed = await decompress(compressed);
-        expect(decompressed).to.equal(uncompressed);
-
-        const inject = new Function("doc", decompressed);
-        let document2 = new Document(config);
-        inject(document2);
-
-        // Verify internal structures match
-        expect(document2.reg.size).to.equal(document.reg.size);
-        expect(document2.store.size).to.equal(document.store.size);
-        
-        // Check each field's index data
-        for(const field of document.field){
-            const idx1 = document.index.get(field);
-            const idx2 = document2.index.get(field);
-            expect(idx2.map.size).to.equal(idx1.map.size);
-            expect(idx2.ctx.size).to.equal(idx1.ctx.size);
-        }
-
-        // Test search results match
-        const search1 = document.search("karmen");
-        const search2 = document2.search("karmen");
-        expect(search2).to.eql(search1);
-    });
-
-    it("Should handle empty Document serialization", async function(){
-        const config = {
-            document: {
-                id: "id",
-                index: [{
-                    field: "title"
-                }]
-            }
-        };
-
-        let document = new Document(config);
-        const uncompressed = document.serialize(false, false);
-        expect(uncompressed).to.equal('');
-
-        const compressed = await document.serialize(false, true);
-        expect(compressed).to.be.instanceOf(Uint8Array);
-
-        const decompressed = await decompress(compressed);
-        expect(decompressed).to.equal('');
-    });
-
-});
diff --git a/test/serialize.js b/test/serialize.js
index 9ada7769..df9f0271 100644
--- a/test/serialize.js
+++ b/test/serialize.js
@@ -4,7 +4,7 @@ import { expect } from "chai";
 let FlexSearch = await import(env ? "../dist/" + env + ".js" : "../src/bundle.js");
 if(FlexSearch.default) FlexSearch = FlexSearch.default;
 if(FlexSearch.FlexSearch) FlexSearch = FlexSearch.FlexSearch;
-const { Index, Document, Worker, Charset: _Charset, Encoder, Resolver } = FlexSearch;
+const { Index, Document, Worker, Charset: _Charset, Encoder, Resolver, decompress } = FlexSearch;
 const build_light = env && env.includes("light");
 const build_compact = env && env.includes("compact");
 const build_esm = !env || env.startsWith("module");
@@ -245,7 +245,7 @@ if(!build_light) describe("Document Export/Import", function(){
         ]);
     });
 
-    it("Should have been serialized Document-Index properly (Fast-Boot)", function(){
+    it("Should have been serialized Document-Index properly (Fast-Boot)", async function(){
 
         let document = new Document(config);
 
@@ -253,6 +253,7 @@ if(!build_light) describe("Document Export/Import", function(){
             document.add(data[i]);
         }
 
+        // Test basic serialization without compression
         const fn_string = document.serialize(false);
         const inject = new Function("doc", fn_string);
 
@@ -279,8 +280,25 @@ if(!build_light) describe("Document Export/Import", function(){
         expect(search2).to.eql(search1);
 
         // Test with function wrapper
-        let document3 = new Document(config);
         expect(document.serialize()).to.equal("function inject(doc){" + fn_string + "}");
+
+        // Test serialization with compression
+        const compressed = await document.serialize(false, true);
+        expect(compressed).to.be.instanceOf(Uint8Array);
+        expect(compressed.length).to.be.lessThan(Buffer.byteLength(fn_string));
+
+        // Decompress and verify
+        const decompressed = await decompress(compressed);
+        expect(decompressed).to.eql(fn_string);
+
+        // Inject decompressed function
+        const inject2 = new Function("doc", decompressed);
+        let document3 = new Document(config);
+        inject2(document3);
+
+        // Verify search results match after decompression
+        const search3 = document3.search("karmen");
+        expect(search3).to.eql(search1);
     });
 });
 

From 8e0539ccd7bf37abc3aba3a997ebf0b67976d3dc Mon Sep 17 00:00:00 2001
From: Nick Chomey <nick_chomey@hotmail.com>
Date: Mon, 2 Mar 2026 20:11:02 -0600
Subject: [PATCH 4/9] export/serialize the cfg, so dont need to create new
 Index/Document before import/inject

---
 src/document.js   |   1 +
 src/index.js      |   4 +
 src/serialize.js  | 267 +++++++++++++++++++++++++++++++++++++++++++---
 test/serialize.js | 108 +++++++++++++++++++
 4 files changed, 365 insertions(+), 15 deletions(-)

diff --git a/src/document.js b/src/document.js
index dce20a2c..b01c915d 100644
--- a/src/document.js
+++ b/src/document.js
@@ -66,6 +66,7 @@ export default function Document(options){
     this.field = [];
     this.marker = [];
     this.key = ((tmp = document.key || document.id) && parse_tree(tmp, this.marker)) || "id";
+    if(SUPPORT_SERIALIZE) this._cfgKey = document.key || document.id || null;
 
     keystore = SUPPORT_KEYSTORE && (options.keystore || 0);
     keystore && (this.keystore = keystore);
diff --git a/src/index.js b/src/index.js
index 37cd0dd4..8ff68537 100644
--- a/src/index.js
+++ b/src/index.js
@@ -88,6 +88,10 @@ export default function Index(options, _register){
             )
             : { encode: encoder };
 
+    if(SUPPORT_SERIALIZE){
+        this._encoderOpt = options.encoder || options.encode || null;
+    }
+
     if(SUPPORT_COMPRESSION){
         this.compress = options.compress || options.compression || false;
     }
diff --git a/src/serialize.js b/src/serialize.js
index 8e0a8005..dbc4e590 100644
--- a/src/serialize.js
+++ b/src/serialize.js
@@ -2,12 +2,17 @@
 import {
     SUPPORT_STORE,
     SUPPORT_TAGS,
-    SUPPORT_WORKER
+    SUPPORT_WORKER,
+    SUPPORT_SERIALIZE,
+    SUPPORT_CHARSET,
+    SUPPORT_ENCODER
 } from "./config.js";
 import { IntermediateSearchResults } from "./type.js";
 // <-- COMPILER BLOCK
 import Index from "./index.js";
 import Document from "./document.js";
+import Charset from "./charset.js";
+import Encoder from "./encoder.js";
 import { KeystoreMap, KeystoreSet } from "./keystore.js";
 import { is_string } from "./common.js";
 
@@ -134,6 +139,207 @@ function json_to_reg(json, reg){
     return /** @type {Set<string|number>} */ (reg);
 }
 
+/**
+ * Find the name of a Charset preset by object reference.
+ * @param {*} encoderOpt
+ * @return {string|null}
+ */
+function find_charset_name(encoderOpt){
+    if(!encoderOpt || typeof encoderOpt === "string") return null;
+    const keys = Object.keys(Charset);
+    for(let i = 0; i < keys.length; i++){
+        if(Charset[keys[i]] === encoderOpt) return keys[i];
+    }
+    return null;
+}
+
+/**
+ * Serialize an encoder option to a string key for JSON export/import.
+ * @param {*} encoderOpt
+ * @return {string|null}
+ */
+function serialize_encoder_to_str(encoderOpt){
+    if(!encoderOpt) return null;
+    if(typeof encoderOpt === "string") return encoderOpt;
+    const name = find_charset_name(encoderOpt);
+    if(name) return name;
+    if(typeof encoderOpt === "function") return encoderOpt.toString();
+    return null;
+}
+
+/**
+ * Serialize an encoder option to a JS expression for inject function bodies.
+ * @param {*} encoderOpt
+ * @param {string} charsetRef - JS variable name for Charset
+ * @return {string|null}
+ */
+function serialize_encoder_to_js(encoderOpt, charsetRef){
+    if(!encoderOpt) return null;
+    if(typeof encoderOpt === "string") return charsetRef + '["' + encoderOpt + '"]';
+    const name = find_charset_name(encoderOpt);
+    if(name) return charsetRef + '["' + name + '"]';
+    if(typeof encoderOpt === "function") return encoderOpt.toString();
+    return null;
+}
+
+/**
+ * Build an Index config as a JS object literal string.
+ * @param {Index} index
+ * @param {string} charsetRef
+ * @return {string}
+ */
+function index_config_to_js(index, charsetRef){
+    const parts = [];
+    if(index.tokenize && index.tokenize !== "strict"){
+        parts.push('tokenize:"' + index.tokenize + '"');
+    }
+    if(index.resolution !== undefined && index.resolution !== 9){
+        parts.push("resolution:" + index.resolution);
+    }
+    if(index.depth){
+        const ctxParts = ["depth:" + index.depth];
+        if(!index.bidirectional) ctxParts.push("bidirectional:false");
+        if(index.resolution_ctx !== undefined && index.resolution_ctx !== 3){
+            ctxParts.push("resolution:" + index.resolution_ctx);
+        }
+        parts.push("context:{" + ctxParts.join(",") + "}");
+    }
+    if(index.rtl) parts.push("rtl:true");
+    if(SUPPORT_SERIALIZE && index._encoderOpt){
+        const expr = serialize_encoder_to_js(index._encoderOpt, charsetRef);
+        if(expr) parts.push("encoder:" + expr);
+    }
+    return "{" + parts.join(",") + "}";
+}
+
+/**
+ * Build an Index config as a plain object for JSON export.
+ * @param {Index} index
+ * @return {Object}
+ */
+function index_config_to_obj(index){
+    const cfg = {};
+    if(index.tokenize && index.tokenize !== "strict") cfg.tokenize = index.tokenize;
+    if(index.resolution !== 9) cfg.resolution = index.resolution;
+    if(index.depth){
+        cfg.context = { depth: index.depth };
+        if(!index.bidirectional) cfg.context.bidirectional = false;
+        if(index.resolution_ctx !== 3) cfg.context.resolution = index.resolution_ctx;
+    }
+    if(index.rtl) cfg.rtl = true;
+    if(SUPPORT_SERIALIZE && index._encoderOpt){
+        const str = serialize_encoder_to_str(index._encoderOpt);
+        if(str) cfg.encoder = str;
+    }
+    return cfg;
+}
+
+/**
+ * Build a Document config as a JS object literal string for inject functions.
+ * @param {Document} doc
+ * @param {string} charsetRef
+ * @return {string}
+ */
+function document_config_to_js(doc, charsetRef){
+    const idField = (SUPPORT_SERIALIZE && doc._cfgKey) || doc.key || "id";
+    let indexFields = "";
+    for(let i = 0; i < doc.field.length; i++){
+        const fieldName = doc.field[i];
+        const fieldIdx = doc.index.get(fieldName);
+        const inner = fieldIdx ? index_config_to_js(fieldIdx, charsetRef).slice(1, -1) : "";
+        indexFields += (indexFields ? "," : "") + '{field:"' + fieldName + '"' + (inner ? "," + inner : "") + "}";
+    }
+    const parts = ['id:"' + idField + '"'];
+    if(indexFields) parts.push("index:[" + indexFields + "]");
+    if(SUPPORT_TAGS && doc.tagfield && doc.tagfield.length){
+        let tagFields = "";
+        for(let i = 0; i < doc.tagfield.length; i++){
+            tagFields += (tagFields ? "," : "") + '{field:"' + doc.tagfield[i] + '"}';
+        }
+        parts.push("tag:[" + tagFields + "]");
+    }
+    if(SUPPORT_STORE && doc.store !== null) parts.push("store:true");
+    return "{document:{" + parts.join(",") + "}}";
+}
+
+/**
+ * Build a Document config as a plain object for JSON export.
+ * @param {Document} doc
+ * @return {Object}
+ */
+function document_config_to_export_obj(doc){
+    const cfg = {
+        id: (SUPPORT_SERIALIZE && doc._cfgKey) || doc.key || "id",
+        fields: doc.field.slice()
+    };
+    if(SUPPORT_TAGS && doc.tagfield && doc.tagfield.length){
+        cfg.tagfields = doc.tagfield.slice();
+    }
+    if(SUPPORT_STORE && doc.store !== null) cfg.store = true;
+    return cfg;
+}
+
+/**
+ * Apply a serialized config object to an Index instance.
+ * @param {Index} index
+ * @param {Object} cfg
+ */
+function apply_index_cfg(index, cfg){
+    if(cfg.tokenize) index.tokenize = cfg.tokenize;
+    if(cfg.resolution !== undefined) index.resolution = cfg.resolution;
+    if(cfg.context){
+        index.depth = cfg.context.depth || 0;
+        if(cfg.context.bidirectional !== undefined) index.bidirectional = cfg.context.bidirectional;
+        if(cfg.context.resolution !== undefined) index.resolution_ctx = cfg.context.resolution;
+    }
+    if(cfg.rtl !== undefined) index.rtl = cfg.rtl;
+    if(cfg.encoder){
+        let encoderOpt;
+        const encoderStr = cfg.encoder;
+        if(typeof encoderStr === "string" && SUPPORT_CHARSET && Charset[encoderStr]){
+            encoderOpt = Charset[encoderStr];
+        } else if(typeof encoderStr === "string"){
+            try { encoderOpt = new Function("return (" + encoderStr + ")")(); } catch(e){}
+        }
+        if(encoderOpt){
+            index.encoder = encoderOpt.encode
+                ? encoderOpt
+                : (SUPPORT_ENCODER && typeof encoderOpt === "object"
+                    ? new Encoder(encoderOpt)
+                    : { encode: encoderOpt });
+            if(SUPPORT_SERIALIZE) index._encoderOpt = cfg.encoder;
+        }
+    }
+}
+
+/**
+ * Apply a serialized config object to a Document instance.
+ * Initializes fields/tags/store only when the document has no data yet.
+ * @param {Document} doc
+ * @param {Object} cfg
+ */
+function apply_document_cfg(doc, cfg){
+    if(cfg.id || cfg.key) doc.key = cfg.id || cfg.key;
+    if(!doc.field.length && cfg.fields && cfg.fields.length){
+        doc.field = cfg.fields;
+        for(let i = 0; i < cfg.fields.length; i++){
+            if(!doc.index.has(cfg.fields[i])){
+                doc.index.set(cfg.fields[i], new Index({}, doc.reg));
+            }
+        }
+    }
+    if(SUPPORT_TAGS && cfg.tagfields && cfg.tagfields.length && !doc.tag){
+        doc.tag = new Map();
+        doc.tagfield = cfg.tagfields;
+        for(let i = 0; i < cfg.tagfields.length; i++){
+            doc.tag.set(cfg.tagfields[i], new Map());
+        }
+    }
+    if(SUPPORT_STORE && cfg.store && !doc.store){
+        doc.store = new Map();
+    }
+}
+
 /**
  *
  * @param {function(string, string):Promise|void} callback
@@ -212,9 +418,8 @@ export function exportIndex(callback, _field, _index_doc = 0, _index_obj = 0){
 
         case 1:
 
-            // todo
             key = "cfg";
-            chunk = null;
+            chunk = [index_config_to_obj(this)];
             break;
 
         case 2:
@@ -273,7 +478,7 @@ export function importIndex(key, data){
     switch(key){
 
         case "cfg":
-            // todo
+            apply_index_cfg(this, data);
             break;
 
         case "reg":
@@ -303,7 +508,19 @@ export function importIndex(key, data){
  * @this {Document}
  */
 
-export function exportDocument(callback, _field, _index_doc = 0, _index_obj = 0){
+export function exportDocument(callback, _field, _index_doc = -1, _index_obj = 0){
+
+    if(_index_doc === -1){
+        const cfgObj = document_config_to_export_obj(this);
+        const res = callback("1.cfg", JSON.stringify(cfgObj));
+        if(res && res["then"]){
+            const self = this;
+            return res["then"](function(){
+                return self.export(callback, null, 0, 0);
+            });
+        }
+        return this.export(callback, null, 0, 0);
+    }
 
     if(_index_doc < this.field.length){
 
@@ -448,6 +665,7 @@ export function importDocument(key, data){
 
             case "cfg":
 
+                apply_document_cfg(this, data);
                 break;
 
         }
@@ -467,10 +685,11 @@ ctx: "gulliver+travel:1,2,3|4,5,6|7,8,9;"
 /**
  * @this {Index}
  * @param {boolean} withFunctionWrapper
+ * @param {boolean} withCfg - When true, embed config and return a self-contained function(FlexSearch)
  * @return {string}
  */
 
-export function serializeIndex(withFunctionWrapper = true){
+export function serializeIndex(withFunctionWrapper = true, withCfg = false){
 
     let reg = '';
     let map = '';
@@ -499,9 +718,17 @@ export function serializeIndex(withFunctionWrapper = true){
         ctx = "index.ctx=new Map([" + ctx + "]);";
     }
 
+    if(withCfg){
+        const cfgJs = index_config_to_js(this, "Charset");
+        const body = "const {Index,Charset}=FlexSearch;const index=new Index(" + cfgJs + ");" + reg + map + ctx + "return index;";
+        return withFunctionWrapper
+            ? "function inject(FlexSearch){" + body + "}"
+            : body;
+    }
+
     return withFunctionWrapper
         ? "function inject(index){" + reg + map + ctx + "}"
-        : reg + map + ctx
+        : reg + map + ctx;
 }
 
 function parse_map(map, type){
@@ -563,9 +790,10 @@ function parse_tag_map(tagMap, type){
  * @this {Document}
  * @param {boolean=} withFunctionWrapper - Wrap in function(doc) or return raw statements
  * @param {boolean=} withCompression - Apply gzip compression
+ * @param {boolean=} withCfg - When true, embed config and return a self-contained function(FlexSearch)
  * @return {string|Promise<Uint8Array>|Uint8Array}
  */
-export function serializeDocument(withFunctionWrapper = true, withCompression = false){
+export function serializeDocument(withFunctionWrapper = true, withCompression = false, withCfg = false){
     
     let statements = '';
     let type = undefined;
@@ -578,6 +806,10 @@ export function serializeDocument(withFunctionWrapper = true, withCompression =
             reg += (reg ? ',' : '') + (type === "string" ? '"' + key + '"' : key);
         }
         statements += 'doc.reg=new Set([' + reg + ']);';
+        // Sync the shared reg reference into each field index (mirrors importDocument "reg" case)
+        for(const fieldName of this.field){
+            statements += 'doc.index.get("' + fieldName + '").reg=doc.reg;';
+        }
     }
     
     // Serialize each field index
@@ -643,15 +875,20 @@ export function serializeDocument(withFunctionWrapper = true, withCompression =
         }
     }
     
-    const body = withFunctionWrapper
+    if(withCfg){
+        const cfgJs = document_config_to_js(this, "Charset");
+        const body = "const {Document,Charset}=FlexSearch;const doc=new Document(" + cfgJs + ");" + statements + "return doc;";
+        const result = withFunctionWrapper
+            ? "function inject(FlexSearch){" + body + "}"
+            : body;
+        return withCompression ? compress(result) : result;
+    }
+
+    const plain = withFunctionWrapper
         ? "function inject(doc){" + statements + "}"
         : statements;
-    
-    if(!withCompression){
-        return body;
-    }
-    
-    return compress(body);
+
+    return withCompression ? compress(plain) : plain;
 }
 
 /**
diff --git a/test/serialize.js b/test/serialize.js
index df9f0271..ff799c9c 100644
--- a/test/serialize.js
+++ b/test/serialize.js
@@ -34,6 +34,7 @@ if(!build_light) describe("Export / Import", function(){
 
         expect(payload).to.eql(new Map([
             ['1.reg', '[0,1,2]'],
+            ['1.cfg', '{"tokenize":"forward"}'],
             ['1.map', '[["f",[[0,2],[1]]],["fo",[[0,2],[1]]],["b",[[1],[0],[2]]],["ba",[[1],[0],[2]]],["bar",[[1],[0],[2]]],["fob",[[2],null,[0,1]]],["foba",[[2],null,[0,1]]],["fobar",[[2],null,[0,1]]]]']
         ]));
 
@@ -72,6 +73,7 @@ if(!build_light) describe("Export / Import", function(){
 
         expect(payload).to.eql(new Map([
             ['1.reg', '[0,1,2]'],
+            ['1.cfg', '{"context":{"depth":1}}'],
             ['1.map', '[["fo",[[0],[1,2]]],["bar",[[1],[0],[2]]],["fobar",[[2],null,[0,1]]]]'],
             ['1.ctx', '[["fo",[["bar",[[0,1],[2]]]]],["fobar",[["bar",[null,[0]]],["fo",[[2],[1]]]]]]']
         ]));
@@ -124,6 +126,51 @@ if(!build_light) describe("Export / Import", function(){
 
         expect(index3.serialize()).to.equal("function inject(index){}");
     });
+
+    it("Should have been serialized Index with self-contained inject (Fast-Boot)", function(){
+
+        let index = new Index({
+            tokenize: "forward",
+            encoder: Charset.LatinBalance
+        });
+
+        index.add(1, "Carmencita");
+        index.add(2, "Le clown et ses chiens");
+
+        const body = index.serialize(false, true);
+        const index2 = new Function("FlexSearch", body)(FlexSearch);
+
+        expect(index2).to.be.instanceOf(Index);
+        expect(index2.tokenize).to.equal(index.tokenize);
+        expect(index2.reg.size).to.equal(index.reg.size);
+        expect(Array.from(index2.reg)).to.eql(Array.from(index.reg));
+        expect(normalize_map(index2.map)).to.eql(normalize_map(index.map));
+    });
+
+    it("Should have been exported Index with cfg", function(){
+
+        let index = new Index({
+            tokenize: "forward",
+            encoder: Charset.LatinBalance
+        });
+
+        index.add(1, "Carmencita");
+        index.add(2, "Le clown et ses chiens");
+
+        const payload = new Map();
+        index.export(function(key, value){ payload.set(key, value); });
+
+        expect(Array.from(payload.keys())).to.include("1.cfg");
+
+        let index2 = new Index({});
+        for(const [key, value] of payload){
+            index2.import(key, value);
+        }
+
+        expect(index2.tokenize).to.equal(index.tokenize);
+        expect(index2.reg.size).to.equal(index.reg.size);
+        expect(normalize_map(index2.map)).to.eql(normalize_map(index.map));
+    });
 });
 
 if(!build_light) describe("Document Export/Import", function(){
@@ -300,6 +347,67 @@ if(!build_light) describe("Document Export/Import", function(){
         const search3 = document3.search("karmen");
         expect(search3).to.eql(search1);
     });
+
+    it("Should have been serialized Document with self-contained inject (Fast-Boot)", function(){
+
+        let document = new Document(config);
+
+        for(let i = 0; i < data.length; i++){
+            document.add(data[i]);
+        }
+
+        const body = document.serialize(false, false, true);
+        const document2 = new Function("FlexSearch", body)(FlexSearch);
+
+        expect(document2.field).to.eql(document.field);
+        expect(document2.reg.size).to.equal(document.reg.size);
+        expect(Array.from(document2.reg)).to.eql(Array.from(document.reg));
+        expect(document2.store.size).to.equal(document.store.size);
+        expect(Array.from(document2.store.entries())).to.eql(Array.from(document.store.entries()));
+
+        for(const field of document.field){
+            const idx1 = document.index.get(field);
+            const idx2 = document2.index.get(field);
+            expect(idx2.tokenize).to.equal(idx1.tokenize);
+            expect(idx2.reg.size).to.equal(idx1.reg.size);
+            expect(normalize_map(idx2.map)).to.eql(normalize_map(idx1.map));
+        }
+    });
+
+    it("Should have been exported Document with cfg", function(){
+
+        let document = new Document(config);
+
+        for(let i = 0; i < data.length; i++){
+            document.add(data[i]);
+        }
+
+        const payload = new Map();
+        document.export(function(key, value){ payload.set(key, value); });
+
+        // doc-level cfg must be first key
+        const keys = Array.from(payload.keys());
+        expect(keys[0]).to.equal("1.cfg");
+
+        // Restore without config
+        let document2 = new Document({});
+        for(const [key, value] of payload){
+            document2.import(key, value);
+        }
+
+        expect(document2.field).to.eql(document.field);
+        expect(document2.reg.size).to.equal(document.reg.size);
+        expect(Array.from(document2.reg)).to.eql(Array.from(document.reg));
+        expect(document2.store.size).to.equal(document.store.size);
+        expect(Array.from(document2.store.entries())).to.eql(Array.from(document.store.entries()));
+
+        for(const field of document.field){
+            const idx1 = document.index.get(field);
+            const idx2 = document2.index.get(field);
+            expect(idx2.tokenize).to.equal(idx1.tokenize);
+            expect(normalize_map(idx2.map)).to.eql(normalize_map(idx1.map));
+        }
+    });
 });
 
 function normalize_map(map){

From 7c49612c15c4bcf97e47ab140ed9e7628e43df67 Mon Sep 17 00:00:00 2001
From: Nick Chomey <nick_chomey@hotmail.com>
Date: Mon, 2 Mar 2026 21:34:53 -0600
Subject: [PATCH 5/9] expand cfg tests to cover full breadth of config options

kitchen sink tests + score function serialization
---
 doc/export-import.md | 243 ++++++++++---------------------------
 src/serialize.js     |  86 +++++++++-----
 test/serialize.js    | 277 +++++++++++++++++++++++++++++++++++--------
 3 files changed, 347 insertions(+), 259 deletions(-)

diff --git a/doc/export-import.md b/doc/export-import.md
index 78376144..ee29e772 100644
--- a/doc/export-import.md
+++ b/doc/export-import.md
@@ -15,7 +15,8 @@ await index.export(async function(key, data){
 Import from folder `/export/` into an `Index` or `Document-Index`:
 
 ```js
-const index = new Index({/* keep old config and place it here */});
+// Config is restored automatically from the export payload
+const index = new Index({});
 
 const files = await fs.readdir("./export/");
 for(let i = 0; i < files.length; i++){
@@ -24,14 +25,18 @@ for(let i = 0; i < files.length; i++){
 }
 ```
 
-> You'll need to use the same configuration as you used before the export. Any changes on the configuration needs to be re-indexed.
+The export payload includes a `.cfg` key that carries all index configuration (tokenizer, encoder, resolution, context, score, etc). A plain `new Index({})` or `new Document({})` is sufficient — no need to repeat the original options.
+
+> When a custom encoder or score function is defined **inline** in the original config it is serialized as source text and reconstructed on import. If the function closes over outer variables those bindings **will not** be available after restore — keep any required values inside the function body.
+
+> The feature "fastupdate" is automatically disabled on import.
 
 <a name="serialize"></a>
 ## Fast-Boot Serialization for Server-Side-Rendering (PHP, Python, Ruby, Rust, Java, Go, Node.js, ...)
 
 > This is an experimental feature with limited support which probably might drop in future release. You're welcome to give some feedback.
 
-When using Server-Side-Rendering you can create a different export which instantly boot up. Especially when using Server-side rendered content, this could help to restore a __<u>static</u>__ index on page load. Document-Indexes aren't supported yet for this method.
+When using Server-Side-Rendering you can create a different export which instantly boot up. Especially when using Server-side rendered content, this could help to restore a __<u>static</u>__ index on page load.
 
 > When your index is too large you should use the default export/import mechanism.
 
@@ -39,7 +44,7 @@ You'll need Javascript to create the serialized output. Alternatively just creat
 
 As the first step populate the FlexSearch index with your contents.
 
-You have two options:
+You have three options:
 
 ### 1. Create a function as string
 
@@ -70,8 +75,6 @@ inject(index);
 
 That's it.
 
-> You'll need to use the same configuration as you used before the export. Any changes on the configuration needs to be re-indexed.
-
 ### 2. Create just a function body as string
 
 Alternatively you can use lazy function declaration by passing `false` to the serialize function:
@@ -101,6 +104,17 @@ const index = new Index();
 inject(index);
 ```
 
+### 3. Self-contained inject (config embedded)
+
+Pass `true` as the second argument to embed the index configuration inside the serialized output. The restored index needs no external config at all:
+
+```js
+const fn_body = index.serialize(false, true);
+const index2 = new Function("FlexSearch", fn_body)(FlexSearch);
+```
+
+This is the recommended approach when the index was built with custom options (custom encoder, score function, tokenizer, etc.) and you cannot guarantee the consumer will supply the same config. The encoder and score functions are serialized as source text — the same caveat about closure variables applies as with export/import.
+
 <a name="document-serialize"></a>
 
 ## Document Fast-Boot Serialization
@@ -126,223 +140,94 @@ function inject(doc){
 
 ### Restore the serialized Document
 
-On the client side, create a new Document with the same configuration and inject:
+**Option A — self-contained inject (config embedded):**
 
 ```js
-const config = {
-    document: {
-        id: "id",
-        index: [{field: "title"}, {field: "body"}]
-    }
-};
-
-const doc = new Document(config);
-inject(doc);
+const fn_body = document.serialize(false, false, true);
+const doc = new Function("FlexSearch", fn_body)(FlexSearch);
 
-// Now search on the restored index
+// Ready to search immediately
 const results = doc.search("your query");
 ```
 
-### Without function wrapper
+Pass `true` as the third argument to embed all field configuration (encoders, tokenizers, score functions, etc.) in the serialized output. `FlexSearch` must be in scope when the function runs.
 
-Get just the body if you want to wrap it differently:
+**Option B — inject into a pre-created document (no config needed):**
 
 ```js
 const fn_body = document.serialize(false);
 const inject = new Function("doc", fn_body);
-```
-
-<a name="compression"></a>
-
-## Compression Utilities
-
-For large indexes, you can compress the serialized output using gzip compression to reduce payload size for delivery over the network or storage.
-
-### Compress Serialized Data
-
-```js
-import { compress, decompress } from "flexsearch";
-
-// Get compressed serialized output directly
-const compressed = await document.serialize(true, true);
-// Returns Uint8Array
 
-// Store or send the compressed data
-const buffer = Buffer.from(compressed);
-await fs.writeFile("./serialized.js.gz", buffer);
-```
-
-### Decompress and Restore
-
-```js
-// Load compressed data
-const buffer = await fs.readFile("./serialized.js.gz");
-const compressed = new Uint8Array(buffer);
-
-// Decompress
-const fn_string = await decompress(compressed);
-
-// Create inject function
-const inject = new Function("doc", fn_string.slice(17, -1)); // Remove "function inject(doc){" and "}"
-
-// Create document with same config and inject
-const doc = new Document(config);
+// A plain new Document({}) is enough — config is read from the serialized data
+const doc = new Document({});
 inject(doc);
-```
-
-### Compression Utilities API
-
-#### compress(data: string | Uint8Array): Promise<Uint8Array>
-
-Compress a string or binary data using gzip.
 
-```js
-const compressed = await compress("some string data");
+// Ready to search
+const results = doc.search("your query");
 ```
 
-#### decompress(data: Uint8Array): Promise<string>
+### Without function wrapper
 
-Decompress gzip-compressed data back to string.
+Get just the body if you want to wrap it differently:
 
 ```js
-const decompressed = await decompress(compressed);
-```
-
-### Compression Benefits
-
-Gzip compression significantly reduces the size of serialized FlexSearch data, especially for larger indexes and text-heavy content. The actual compression ratio depends on factors like index size, data structure, and content repetitiveness.
-
-### Deployment Patterns
-
-#### Pattern 1: Inline in HTML (small indexes)
-
-```html
-<script>
-const serialized = "function inject(doc){...}";
-const doc = new Document(config);
-const inject = new Function("doc", serialized.slice(17, -1));
-inject(doc);
-</script>
+const fn_body = document.serialize(false);
+const inject = new Function("doc", fn_body);
 ```
 
-#### Pattern 2: External gzipped script (medium indexes)
+<a name="compression"></a>
 
-```html
-<!-- Application/gzip in response headers + CompressionStream for decompression -->
-<script src="serialized.js.gz"></script>
-<!-- Browser automatically decompresses, then executes -->
-```
+## Compression
 
-#### Pattern 3: Dynamic loader with compression (large indexes)
+Compression is decoupled from export and import. Call `export()` to collect the payload, then `compress()` separately:
 
 ```js
-async function loadSerializedIndex() {
-    const response = await fetch("serialized.js.gz");
-    const compressed = await response.arrayBuffer();
-    const fn_string = await decompress(compressed);
-    
-    const doc = new Document(config);
-    const inject = new Function("doc", fn_string.slice(17, -1));
-    inject(doc);
-    return doc;
-}
-
-const doc = await loadSerializedIndex();
-```
+import { compress, decompress } from "flexsearch";
 
-#### Pattern 4: Data URLs (very small indexes)
+// export() with no args returns a Map<string, string> synchronously
+const payload = index.export();
 
-```js
-const fn_string = document.serialize(true, false);
-const dataUrl = "data:text/javascript;base64," + btoa(fn_string);
-// Use in <script src> or dynamic loading
+// compress() accepts a Map or a string
+const compressed = await compress(payload);   // Promise<Uint8Array>
 ```
 
-<a name="export"></a>
-
-## Export / Import (In-Memory)
-
-### Node.js
-
-> Persistent-Indexes and Worker-Indexes don't support Import/Export.
-
-Export an `Index` or `Document-Index` to the folder `/export/`:
+To restore:
 
 ```js
-import { promises as fs } from "fs";
+const json = await decompress(compressed);    // Promise<string>
+const entries = JSON.parse(json);             // Array<[key, value]>
 
-await index.export(async function(key, data){
-  await fs.writeFile("./export/" + key, data, "utf8");
-});
+const index2 = new Index({});                 // no config needed — cfg key restores it
+for(const [key, value] of entries) index2.import(key, value);
 ```
 
-Import from folder `/export/` into an `Index` or `Document-Index`:
+Same pattern for Document:
 
 ```js
-const index = new Index({/* keep old config and place it here */});
+const payload = doc.export();
+const compressed = await compress(payload);
 
-const files = await fs.readdir("./export/");
-for(let i = 0; i < files.length; i++){
-  const data = await fs.readFile("./export/" + files[i], "utf8");
-  await index.import(files[i], data);
-}
-```
-
-> You'll need to use the same configuration as you used before the export. Any changes on the configuration needs to be re-indexed.
-
-### Browser
-
-```js
-index.export(function(key, data){ 
-    
-    // you need to store both the key and the data!
-    // e.g. use the key for the filename and save your data
-    
-    localStorage.setItem(key, data);
-});
-```
-
-> The size of the export corresponds to the memory consumption of the library. To reduce export size you have to use a configuration which has less memory footprint (use the table at the bottom to get information about configs and its memory allocation).
-
-When your save routine runs asynchronously you have to use `async/await` or return a promise:
+// ...
 
-```js
-index.export(function(key, data){ 
-    
-    return new Promise(function(resolve){
-        
-        // do the saving as async
-
-        resolve();
-    });
-});
+const doc2 = new Document({});
+const entries = JSON.parse(await decompress(compressed));
+for(const [key, value] of entries) doc2.import(key, value);
 ```
 
-Before you can import data, you need to create your index first. For document indexes provide the same document descriptor you used when export the data. This configuration isn't stored in the export.
+Compressing serialized Fast-Boot output works the same way — pass the string directly:
 
 ```js
-const index = new Index({/* keep old config and place it here */});
-```
+const fn_string = index.serialize(false);
+const compressed = await compress(fn_string);   // string → Uint8Array
 
-To import the data just pass a key and data:
-
-```
-const data = localStorage.getItem(key);
-index.import(key, data);
+const restored = await decompress(compressed);  // Uint8Array → string
+const inject = new Function("index", restored);
 ```
 
-You need to import every key! Otherwise, your index does not work. You need to store the keys from the export and use this keys for the import (the order of the keys can differ).
+#### API
 
-> The feature "fastupdate" is automatically disabled on import.
+| Function | Signature | Returns |
+|---|---|---|
+| `compress` | `(data: string \| Map)` | `Promise<Uint8Array>` |
+| `decompress` | `(data: Uint8Array)` | `Promise<string>` |
 
-This is just for demonstration and is not recommended, because you might have other keys in your localStorage which aren't supported as an import:
-
-```js
-var keys = Object.keys(localStorage);
-
-for(let i = 0, key, data; i < keys.length; i++){
-    key = keys[i]
-    data = localStorage.getItem(key);
-    index.import(key, data);
-}
-```
diff --git a/src/serialize.js b/src/serialize.js
index dbc4e590..ee2a569c 100644
--- a/src/serialize.js
+++ b/src/serialize.js
@@ -5,7 +5,9 @@ import {
     SUPPORT_WORKER,
     SUPPORT_SERIALIZE,
     SUPPORT_CHARSET,
-    SUPPORT_ENCODER
+    SUPPORT_ENCODER,
+    SUPPORT_ASYNC,
+    SUPPORT_KEYSTORE
 } from "./config.js";
 import { IntermediateSearchResults } from "./type.js";
 // <-- COMPILER BLOCK
@@ -209,6 +211,9 @@ function index_config_to_js(index, charsetRef){
         const expr = serialize_encoder_to_js(index._encoderOpt, charsetRef);
         if(expr) parts.push("encoder:" + expr);
     }
+    if(index.score) parts.push("score:" + index.score.toString());
+    if(SUPPORT_ASYNC && index.priority && index.priority !== 4) parts.push("priority:" + index.priority);
+    if(SUPPORT_KEYSTORE && index.keystore) parts.push("keystore:" + index.keystore);
     return "{" + parts.join(",") + "}";
 }
 
@@ -231,6 +236,9 @@ function index_config_to_obj(index){
         const str = serialize_encoder_to_str(index._encoderOpt);
         if(str) cfg.encoder = str;
     }
+    if(index.score) cfg.score = index.score.toString();
+    if(SUPPORT_ASYNC && index.priority && index.priority !== 4) cfg.priority = index.priority;
+    if(SUPPORT_KEYSTORE && index.keystore) cfg.keystore = index.keystore;
     return cfg;
 }
 
@@ -270,8 +278,17 @@ function document_config_to_js(doc, charsetRef){
 function document_config_to_export_obj(doc){
     const cfg = {
         id: (SUPPORT_SERIALIZE && doc._cfgKey) || doc.key || "id",
-        fields: doc.field.slice()
+        fields: []
     };
+    for(let i = 0; i < doc.field.length; i++){
+        const fieldName = doc.field[i];
+        const fieldIdx = doc.index.get(fieldName);
+        const fieldCfg = { field: fieldName };
+        if(fieldIdx){
+            Object.assign(fieldCfg, index_config_to_obj(fieldIdx));
+        }
+        cfg.fields.push(fieldCfg);
+    }
     if(SUPPORT_TAGS && doc.tagfield && doc.tagfield.length){
         cfg.tagfields = doc.tagfield.slice();
     }
@@ -310,6 +327,20 @@ function apply_index_cfg(index, cfg){
             if(SUPPORT_SERIALIZE) index._encoderOpt = cfg.encoder;
         }
     }
+    if(cfg.score && typeof cfg.score === "string"){
+        try {
+            const scoreFn = new Function("return (" + cfg.score + ")")();
+            if(typeof scoreFn === "function") index.score = scoreFn;
+        } catch(e){}
+    }
+    if(SUPPORT_ASYNC && cfg.priority !== undefined) index.priority = cfg.priority;
+    if(SUPPORT_KEYSTORE && cfg.keystore){
+        const ks = cfg.keystore;
+        index.keystore = ks;
+        // Replace empty map/ctx with Keystore variants (populated in subsequent imports)
+        if(!index.map.size) index.map = new KeystoreMap(ks);
+        if(!index.ctx.size) index.ctx = new KeystoreMap(ks);
+    }
 }
 
 /**
@@ -321,17 +352,28 @@ function apply_index_cfg(index, cfg){
 function apply_document_cfg(doc, cfg){
     if(cfg.id || cfg.key) doc.key = cfg.id || cfg.key;
     if(!doc.field.length && cfg.fields && cfg.fields.length){
-        doc.field = cfg.fields;
         for(let i = 0; i < cfg.fields.length; i++){
-            if(!doc.index.has(cfg.fields[i])){
-                doc.index.set(cfg.fields[i], new Index({}, doc.reg));
+            const fc = cfg.fields[i];
+            // Support both old format (string) and new format (object with .field)
+            const fieldName = typeof fc === "string" ? fc : fc.field;
+            doc.field.push(fieldName);
+            // Reconstruct tree entry so new documents can be indexed after import
+            const parts = fieldName.split(":");
+            doc.tree[i] = parts.length > 1 ? parts : parts[0];
+            if(!doc.index.has(fieldName)){
+                const idx = new Index({}, doc.reg);
+                if(typeof fc === "object") apply_index_cfg(idx, fc);
+                doc.index.set(fieldName, idx);
             }
         }
     }
     if(SUPPORT_TAGS && cfg.tagfields && cfg.tagfields.length && !doc.tag){
+        if(!doc.tagtree) doc.tagtree = [];
         doc.tag = new Map();
         doc.tagfield = cfg.tagfields;
         for(let i = 0; i < cfg.tagfields.length; i++){
+            const parts = cfg.tagfields[i].split(":");
+            doc.tagtree[i] = parts.length > 1 ? parts : parts[0];
             doc.tag.set(cfg.tagfields[i], new Map());
         }
     }
@@ -567,13 +609,6 @@ export function exportDocument(callback, _field, _index_doc = -1, _index_obj = 0
                 _field = null;
                 break;
 
-            // case 3:
-            //
-            //     key = "cfg";
-            //     chunk = null;
-            //     _field = null;
-            //     break;
-
             default:
 
                 return;
@@ -758,29 +793,21 @@ function parse_map(map, type){
 }
 
 /**
- * Helper: Serialize a Map<string, Map> for tags
- * @param {Map} tagMap
- * @param {string} type
+ * Helper: Serialize a Map<tagValue, Array<ID>> for tags
+ * @param {Map} tagMap - inner map: tagValue → Array<ID>
+ * @param {string} type - "string" or "number"
  * @return {string}
  */
 function parse_tag_map(tagMap, type){
     let result = '';
     for(const item of tagMap.entries()){
-        const key = item[0];
-        const value = item[1]; // inner Map
-        let inner = '';
-        for(const innerItem of value.entries()){
-            const innerKey = innerItem[0];
-            const innerValue = innerItem[1];
-            let ids = '';
-            for(let j = 0; j < innerValue.length; j++){
-                ids += (ids ? ',' : '') + (type === "string" ? '"' + innerValue[j] + '"' : innerValue[j]);
-            }
-            ids = '["' + innerKey + '",[' + ids + ']]';
-            inner += (inner ? ',' : '') + ids;
+        const key = item[0];   // tag value (e.g., "1894")
+        const ids = item[1];   // flat Array<ID> (e.g., ["tt0000001"])
+        let idsStr = '';
+        for(let j = 0; j < ids.length; j++){
+            idsStr += (idsStr ? ',' : '') + (type === "string" ? '"' + ids[j] + '"' : ids[j]);
         }
-        inner = '["' + key + '",new Map([' + inner + '])]';
-        result += (result ? ',' : '') + inner;
+        result += (result ? ',' : '') + '["' + key + '",[' + idsStr + ']]';
     }
     return result;
 }
@@ -897,6 +924,7 @@ export function serializeDocument(withFunctionWrapper = true, withCompression =
  * @return {Promise<Uint8Array>} Compressed data
  */
 export async function compress(data){
+    if(data instanceof Map) data = JSON.stringify(Array.from(data.entries()));
     const cs = new CompressionStream('gzip');
     const blob = new Blob([data], { type: 'application/octet-stream' });
     const stream = blob.stream().pipeThrough(cs);
diff --git a/test/serialize.js b/test/serialize.js
index ff799c9c..ec778599 100644
--- a/test/serialize.js
+++ b/test/serialize.js
@@ -4,7 +4,7 @@ import { expect } from "chai";
 let FlexSearch = await import(env ? "../dist/" + env + ".js" : "../src/bundle.js");
 if(FlexSearch.default) FlexSearch = FlexSearch.default;
 if(FlexSearch.FlexSearch) FlexSearch = FlexSearch.FlexSearch;
-const { Index, Document, Worker, Charset: _Charset, Encoder, Resolver, decompress } = FlexSearch;
+const { Index, Document, Worker, Charset: _Charset, Encoder, Resolver, compress, decompress } = FlexSearch;
 const build_light = env && env.includes("light");
 const build_compact = env && env.includes("compact");
 const build_esm = !env || env.startsWith("module");
@@ -145,6 +145,14 @@ if(!build_light) describe("Export / Import", function(){
         expect(index2.reg.size).to.equal(index.reg.size);
         expect(Array.from(index2.reg)).to.eql(Array.from(index.reg));
         expect(normalize_map(index2.map)).to.eql(normalize_map(index.map));
+
+        // Encoder works: phonetic search results match original (proves LatinBalance restored)
+        expect(index2.search("karmen")).to.eql(index.search("karmen"));
+
+        // Encoder works for documents added to the restored index
+        index.add(3, "Carmelo");
+        index2.add(3, "Carmelo");
+        expect(index2.search("karm")).to.eql(index.search("karm"));
     });
 
     it("Should have been exported Index with cfg", function(){
@@ -170,10 +178,71 @@ if(!build_light) describe("Export / Import", function(){
         expect(index2.tokenize).to.equal(index.tokenize);
         expect(index2.reg.size).to.equal(index.reg.size);
         expect(normalize_map(index2.map)).to.eql(normalize_map(index.map));
+
+        // Encoder works: phonetic search results match original (proves LatinBalance restored)
+        expect(index2.search("karmen")).to.eql(index.search("karmen"));
+
+        // Encoder works for documents added to the restored index
+        index.add(3, "Carmelo");
+        index2.add(3, "Carmelo");
+        expect(index2.search("karm")).to.eql(index.search("karm"));
     });
-});
 
-if(!build_light) describe("Document Export/Import", function(){
+    it("Kitchen sink: Index - encoder, score, context, priority, keystore", function () {
+
+        // Inline encoder strips vowels ("alpha"→"lph", "tau"→"t").
+        // Score always returns 0 (best bucket) — a post-restore add to "sigma tau"
+        // must put "t" in bucket 0; the default scorer at resolution=4 puts i=1 → bucket 1.
+        // normalize_index covers config scalars + score source + map/ctx data in one eql.
+
+        function makeKsIndex() {
+            return new Index({
+                tokenize: "strict",
+                resolution: 4,
+                context: { depth: 1, bidirectional: false, resolution: 2 },
+                rtl: false,
+                priority: 2,
+                keystore: 4,
+                encoder: function (str) {
+                    return str.toLowerCase().replace(/[aeiou]/g, "").split(/\s+/).filter(Boolean);
+                },
+                score: function (content, term, i) { return 0; }
+            });
+        }
+
+        const ksRef = makeKsIndex();
+        ksRef.add(1, "alpha beta gamma");
+        ksRef.add(2, "delta epsilon");
+
+        // Serialize for inject BEFORE mutating ksRef with the post-restore liveness doc
+        const body = ksRef.serialize(false, true);
+        const ks3 = new Function("FlexSearch", body)(FlexSearch);
+
+        // Export / import
+        const payload = new Map();
+        ksRef.export(function (key, value) { payload.set(key, value); });
+        const ks2 = new Index({});
+        for (const [key, value] of payload) { ks2.import(key, value); }
+
+        // Single eql: config scalars + score source + full map/ctx data
+        expect(normalize_index(ks2)).to.eql(normalize_index(ksRef));
+        expect(normalize_index(ks3)).to.eql(normalize_index(ksRef));
+        expect(ks3).to.be.instanceOf(Index);
+
+        // One search tests encoder (strips vowels), context (depth=1 multi-term), tokenizer
+        // "alpha beta" → ["lph", "bt"] (vowels stripped), both in same doc (context), strict tokenize
+        expect(ks2.search("alpha beta")).to.eql(ksRef.search("alpha beta"));
+        expect(ks3.search("alpha beta")).to.eql(ksRef.search("alpha beta"));
+        expect(ks2.search("alpha beta")).to.eql([1]);
+
+        // Score liveness: "sigma tau" → "t" token. score()=0 → bucket 0.
+        // Default scorer at resolution=4 puts i=1 tokens in bucket > 0.
+        ksRef.add(3, "sigma tau");
+        ks2.add(3, "sigma tau");
+        ks3.add(3, "sigma tau");
+        expect(ks2.map.get("t")[0]).to.include(3);
+        expect(ks3.map.get("t")[0]).to.include(3);
+    });
 
     const data = [{
         "tconst": "tt0000001",
@@ -310,7 +379,7 @@ if(!build_light) describe("Document Export/Import", function(){
         // Verify internal structures match
         expect(document2.reg.size).to.equal(document.reg.size);
         expect(document2.store.size).to.equal(document.store.size);
-        
+
         // Check each field's index data
         for(const field of document.field){
             const idx1 = document.index.get(field);
@@ -348,66 +417,139 @@ if(!build_light) describe("Document Export/Import", function(){
         expect(search3).to.eql(search1);
     });
 
-    it("Should have been serialized Document with self-contained inject (Fast-Boot)", function(){
-
-        let document = new Document(config);
-
-        for(let i = 0; i < data.length; i++){
-            document.add(data[i]);
+    it("Kitchen sink: Document - deep nesting, per-field custom functions", function () {
+
+        // meta:title: nested field path, LatinBalance encoder, forward tokenize
+        // genre: inline vowel-stripping encoder, score always 0 (bucket liveness proof)
+        // year: tag field; store: enabled
+        // normalize_doc covers key, fields, tree, tagtree, store size + per-field map/ctx/config.
+
+        const ksDocData = [{
+            id: 1, meta: { title: "Carmencita" }, genre: "fantasy", year: "1865"
+        }, {
+            id: 2, meta: { title: "Gulliver" }, genre: "adventure", year: "1864"
+        }];
+
+        function makeKsDoc() {
+            return new Document({
+                document: {
+                    id: "id",
+                    store: true,
+                    index: [{
+                        field: "meta:title",
+                        tokenize: "forward",
+                        encoder: Charset.LatinBalance
+                    }, {
+                        field: "genre",
+                        tokenize: "strict",
+                        encoder: function (str) {
+                            return str.toLowerCase().replace(/[aeiou]/g, "").split(/\s+/).filter(Boolean);
+                        },
+                        score: function (content, term, i) { return 0; }
+                    }],
+                    tag: [{ field: "year" }]
+                }
+            });
         }
 
-        const body = document.serialize(false, false, true);
-        const document2 = new Function("FlexSearch", body)(FlexSearch);
+        const ksDocRef = makeKsDoc();
+        for (const record of ksDocData) ksDocRef.add(record);
 
-        expect(document2.field).to.eql(document.field);
-        expect(document2.reg.size).to.equal(document.reg.size);
-        expect(Array.from(document2.reg)).to.eql(Array.from(document.reg));
-        expect(document2.store.size).to.equal(document.store.size);
-        expect(Array.from(document2.store.entries())).to.eql(Array.from(document.store.entries()));
-
-        for(const field of document.field){
-            const idx1 = document.index.get(field);
-            const idx2 = document2.index.get(field);
-            expect(idx2.tokenize).to.equal(idx1.tokenize);
-            expect(idx2.reg.size).to.equal(idx1.reg.size);
-            expect(normalize_map(idx2.map)).to.eql(normalize_map(idx1.map));
-        }
+        // Export / import
+        const payload = new Map();
+        ksDocRef.export(function (key, value) { payload.set(key, value); });
+        expect(Array.from(payload.keys())[0]).to.equal("1.cfg");
+        const ksDoc2 = new Document({});
+        for (const [key, value] of payload) ksDoc2.import(key, value);
+
+        // Self-contained inject AFTER export/import
+        const body = ksDocRef.serialize(false, false, true);
+        const ksDoc3 = new Function("FlexSearch", body)(FlexSearch);
+
+        // Single eql: key, fields, tree, tagtree, store size, per-field config + map data
+        expect(normalize_doc(ksDoc2)).to.eql(normalize_doc(ksDocRef));
+        expect(normalize_doc(ksDoc3)).to.eql(normalize_doc(ksDocRef));
+
+        // Tag-filtered search tests: LatinBalance encoder on meta:title, tags live, store live
+        // Tests that field-specific config (encoder, tokenize, tags) all survived
+        const tagQ = { query: "karmen", tag: { year: "1865" } };
+        expect(ksDoc2.search(tagQ)).to.eql(ksDocRef.search(tagQ));
+        expect(ksDoc3.search(tagQ)).to.eql(ksDocRef.search(tagQ));
+        expect(ksDoc2.search(tagQ).some(r => r.result.includes(1))).to.equal(true);
+
+        // Per-field encoder: genre field uses vowel-stripping encoder
+        expect(ksDoc2.search("fntsy")).to.eql(ksDocRef.search("fntsy"));
+        expect(ksDoc3.search("fntsy")).to.eql(ksDocRef.search("fntsy"));
+
+        // Score liveness + tree/tagtree live after restore: add new doc to all three
+        const newDoc = { id: 3, meta: { title: "Alice in Wonderland" }, genre: "fantasy", year: "1866" };
+        ksDocRef.add(newDoc);
+        ksDoc2.add(newDoc);
+        ksDoc3.add(newDoc);
+
+        expect(ksDoc2.search("alice")).to.eql(ksDocRef.search("alice"));
+        expect(ksDoc3.search("alice")).to.eql(ksDocRef.search("alice"));
+        // score()=0 for genre → "fntsy" must land in bucket 0 for newDoc
+        expect(ksDoc2.index.get("genre").map.get("fntsy")[0]).to.include(3);
+        expect(ksDoc3.index.get("genre").map.get("fntsy")[0]).to.include(3);
+
+        const tagQ2 = { query: "alice", tag: { year: "1866" } };
+        expect(ksDoc2.search(tagQ2)).to.eql(ksDocRef.search(tagQ2));
+        expect(ksDoc3.search(tagQ2)).to.eql(ksDocRef.search(tagQ2));
     });
 
-    it("Should have been exported Document with cfg", function(){
+    it("Should compress/decompress export payload (Index)", async function(){
 
-        let document = new Document(config);
-
-        for(let i = 0; i < data.length; i++){
-            document.add(data[i]);
-        }
+        const idx = new Index({ tokenize: "forward", resolution: 3 });
+        idx.add(0, "foo bar foobar");
+        idx.add(1, "bar foo foobar");
+        idx.add(2, "foobar foo bar");
 
+        // collect via callback, then compress
         const payload = new Map();
-        document.export(function(key, value){ payload.set(key, value); });
+        idx.export(function(key, value){ payload.set(key, value); });
+        const compressed = await compress(payload);
+        expect(compressed).to.be.instanceOf(Uint8Array);
 
-        // doc-level cfg must be first key
-        const keys = Array.from(payload.keys());
-        expect(keys[0]).to.equal("1.cfg");
+        // decompress → parse → replay into a plain new Index
+        const entries = JSON.parse(await decompress(compressed));
+        const idx2 = new Index({});
+        for(const [key, value] of entries) idx2.import(key, value);
 
-        // Restore without config
-        let document2 = new Document({});
-        for(const [key, value] of payload){
-            document2.import(key, value);
-        }
+        expect(normalize_index(idx2)).to.eql(normalize_index(idx));
+        expect(idx2.search("foobar")).to.eql(idx.search("foobar"));
+    });
 
-        expect(document2.field).to.eql(document.field);
-        expect(document2.reg.size).to.equal(document.reg.size);
-        expect(Array.from(document2.reg)).to.eql(Array.from(document.reg));
-        expect(document2.store.size).to.equal(document.store.size);
-        expect(Array.from(document2.store.entries())).to.eql(Array.from(document.store.entries()));
+    it("Should compress/decompress export payload (Document)", async function(){
 
-        for(const field of document.field){
-            const idx1 = document.index.get(field);
-            const idx2 = document2.index.get(field);
-            expect(idx2.tokenize).to.equal(idx1.tokenize);
-            expect(normalize_map(idx2.map)).to.eql(normalize_map(idx1.map));
-        }
+        const doc = new Document({
+            document: {
+                id: "id",
+                store: true,
+                index: [{ field: "title", tokenize: "forward" }],
+                tag: [{ field: "year" }]
+            }
+        });
+        doc.add({ id: 1, title: "Carmencita", year: "1865" });
+        doc.add({ id: 2, title: "Gulliver", year: "1864" });
+
+        // collect via callback, then compress
+        const payload = new Map();
+        doc.export(function(key, value){ payload.set(key, value); });
+        const compressed = await compress(payload);
+        expect(compressed).to.be.instanceOf(Uint8Array);
+
+        // decompress → parse → replay
+        const entries = JSON.parse(await decompress(compressed));
+        const doc2 = new Document({});
+        for(const [key, value] of entries) doc2.import(key, value);
+
+        expect(normalize_doc(doc2)).to.eql(normalize_doc(doc));
+        const tagQ = { query: "carmen", tag: { year: "1865" } };
+        expect(doc2.search(tagQ)).to.eql(doc.search(tagQ));
+        expect(doc2.search(tagQ).some(r => r.result.includes(1))).to.equal(true);
     });
+
 });
 
 function normalize_map(map){
@@ -422,4 +564,37 @@ function normalize_ctx(ctx){
         item[1] = normalize_map(item[1]);
         return item;
     });
+}
+
+function normalize_index(idx) {
+    return {
+        tokenize: idx.tokenize,
+        resolution: idx.resolution,
+        depth: idx.depth,
+        bidirectional: idx.bidirectional,
+        resolution_ctx: idx.resolution_ctx,
+        rtl: idx.rtl,
+        priority: idx.priority,
+        keystore: idx.keystore || 0,
+        score: idx.score ? idx.score.toString() : null,
+        map: normalize_map(idx.map),
+        ctx: normalize_ctx(idx.ctx),
+        regSize: idx.reg.size
+    };
+}
+
+function normalize_doc(doc) {
+    const fields = {};
+    for (const field of doc.field) {
+        fields[field] = normalize_index(doc.index.get(field));
+    }
+    return {
+        key: doc.key,
+        field: doc.field.slice(),
+        tree: doc.tree.map(t => Array.isArray(t) ? t.slice() : t),
+        tagfield: (doc.tagfield || []).slice(),
+        tagtree: (doc.tagtree || []).map(t => Array.isArray(t) ? t.slice() : t),
+        store: doc.store ? Array.from(doc.store.entries()) : null,
+        fields
+    };
 }
\ No newline at end of file

From 2afefc92d02d0fb53a6cd0a9c7f1acfb43a755f5 Mon Sep 17 00:00:00 2001
From: Nick Chomey <nick_chomey@hotmail.com>
Date: Tue, 3 Mar 2026 07:01:38 -0600
Subject: [PATCH 6/9] no blob, only use json at the end

---
 doc/export-import.md |  56 ++++++++---------
 index.d.ts           |  13 ++++
 src/bundle.js        |   4 ++
 src/document.js      |   4 +-
 src/index.js         |   4 +-
 src/serialize.js     | 140 +++++++++++++++++++++++++++++++++----------
 test/serialize.js    |  38 ++++++------
 7 files changed, 180 insertions(+), 79 deletions(-)

diff --git a/doc/export-import.md b/doc/export-import.md
index ee29e772..b6cafc10 100644
--- a/doc/export-import.md
+++ b/doc/export-import.md
@@ -179,55 +179,57 @@ const inject = new Function("doc", fn_body);
 
 ## Compression
 
-Compression is decoupled from export and import. Call `export()` to collect the payload, then `compress()` separately:
+Use the built-in compressed APIs when you want a single compressed binary blob for transport or storage:
 
 ```js
-import { compress, decompress } from "flexsearch";
-
-// export() with no args returns a Map<string, string> synchronously
-const payload = index.export();
+const compressed = await index.exportCompressed();
 
-// compress() accepts a Map or a string
-const compressed = await compress(payload);   // Promise<Uint8Array>
+const restored = new Index({});
+await restored.importCompressed(compressed);
 ```
 
-To restore:
+Same pattern for `Document`:
 
 ```js
-const json = await decompress(compressed);    // Promise<string>
-const entries = JSON.parse(json);             // Array<[key, value]>
+const compressed = await doc.exportCompressed();
 
-const index2 = new Index({});                 // no config needed — cfg key restores it
-for(const [key, value] of entries) index2.import(key, value);
+const restoredDoc = new Document({});
+await restoredDoc.importCompressed(compressed);
 ```
 
-Same pattern for Document:
+These methods collect all export data into a Map, serialize to JSON, and compress with gzip. This leverages the same bulk import support and provides a simple, maintainable approach.
 
-```js
-const payload = doc.export();
-const compressed = await compress(payload);
+### Bulk import convenience
 
-// ...
+`import()` also accepts a full payload map or entries array and loops internally:
 
-const doc2 = new Document({});
-const entries = JSON.parse(await decompress(compressed));
-for(const [key, value] of entries) doc2.import(key, value);
+```js
+const payload = new Map();
+await index.export((key, data) => payload.set(key, data));
+
+const index2 = new Index({});
+index2.import(payload);            // or index2.import(Array.from(payload.entries()))
 ```
 
-Compressing serialized Fast-Boot output works the same way — pass the string directly:
+### Utility helpers for generic strings
+
+`compress()` and `decompress()` stay as convenience helpers for string payloads (for example serialized fast-boot function strings):
 
 ```js
-const fn_string = index.serialize(false);
-const compressed = await compress(fn_string);   // string → Uint8Array
+import { compress, decompress } from "flexsearch";
 
-const restored = await decompress(compressed);  // Uint8Array → string
-const inject = new Function("index", restored);
+const fnString = index.serialize(false);
+const compressed = await compress(fnString);
+const restored = await decompress(compressed);
 ```
 
 #### API
 
 | Function | Signature | Returns |
 |---|---|---|
-| `compress` | `(data: string \| Map)` | `Promise<Uint8Array>` |
-| `decompress` | `(data: Uint8Array)` | `Promise<string>` |
+| `exportCompressed` | `() => Promise<Uint8Array>` | Compressed binary payload |
+| `importCompressed` | `(source: Uint8Array) => Promise<void>` | Restores from compressed payload |
+| `import` | `(payload: Map<string, string> \| Array<[string, string]>) => void` | Bulk import convenience |
+| `compress` | `(data: string) => Promise<Uint8Array>` | Compress string data |
+| `decompress` | `(data: Uint8Array) => Promise<string>` | Decompress to string |
 
diff --git a/index.d.ts b/index.d.ts
index d049d091..c320533b 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -19,6 +19,9 @@ declare module "flexsearch" {
     export type Limit = number;
     export type ExportHandler = (key: string, data: string) => void;
     export type ExportHandlerAsync = (key: string, data: string) => Promise<void>;
+    export type ExportEntries = Array<[string, string]>;
+    export type ExportMap = Map<string, string>;
+    export type CompressedSource = Uint8Array | ArrayBuffer | ReadableStream<Uint8Array>;
     export type AsyncCallback<T> = (result?: T) => void;
 
     /************************************/
@@ -290,6 +293,11 @@ declare module "flexsearch" {
         export(handler: ExportHandlerAsync): Promise<void>;
 
         import(key: string, data: string): void;
+        import(payload: ExportMap): void;
+        import(payload: ExportEntries): void;
+
+        exportCompressed(): Promise<Uint8Array>;
+        importCompressed(source: CompressedSource): Promise<void>;
 
         serialize(with_function_wrapper?: boolean): SerializedFunctionString;
 
@@ -760,6 +768,11 @@ declare module "flexsearch" {
         export(handler: ExportHandlerAsync): Promise<void>;
 
         import(key: string, data: string): void;
+        import(payload: ExportMap): void;
+        import(payload: ExportEntries): void;
+
+        exportCompressed(): Promise<Uint8Array>;
+        importCompressed(source: CompressedSource): Promise<void>;
 
         serialize(with_function_wrapper?: boolean, compress?: boolean): SerializedFunctionString | Promise<Uint8Array>;
 
diff --git a/src/bundle.js b/src/bundle.js
index e623fed2..d4a5613b 100644
--- a/src/bundle.js
+++ b/src/bundle.js
@@ -56,6 +56,8 @@ import { compress, decompress } from "./serialize.js";
 /** @export */ Index.prototype.removeAsync;
 /** @export */ Index.prototype.export;
 /** @export */ Index.prototype.import;
+/** @export */ Index.prototype.exportCompressed;
+/** @export */ Index.prototype.importCompressed;
 /** @export */ Index.prototype.serialize;
 /** @export */ Index.prototype.mount;
 /** @export */ Index.prototype.commit;
@@ -109,6 +111,8 @@ if(SUPPORT_PERSISTENT){
 /** @export */ Document.prototype.destroy;
 /** @export */ Document.prototype.export;
 /** @export */ Document.prototype.import;
+/** @export */ Document.prototype.exportCompressed;
+/** @export */ Document.prototype.importCompressed;
 /** @export */ Document.prototype.get;
 /** @export */ Document.prototype.set;
 
diff --git a/src/document.js b/src/document.js
index b01c915d..6aba8fec 100644
--- a/src/document.js
+++ b/src/document.js
@@ -38,7 +38,7 @@ import Encoder, { fallback_encoder } from "./encoder.js";
 import Cache, { searchCache } from "./cache.js";
 import { is_string, is_object, parse_simple } from "./common.js";
 import apply_async from "./async.js";
-import { exportDocument, importDocument, serializeDocument } from "./serialize.js";
+import { exportDocument, importDocument, serializeDocument, exportCompressedDocument, importCompressedDocument } from "./serialize.js";
 import { KeystoreMap, KeystoreSet } from "./keystore.js";
 import "./document/add.js";
 import "./document/search.js";
@@ -574,6 +574,8 @@ if(SUPPORT_SERIALIZE){
 
     Document.prototype.export = exportDocument;
     Document.prototype.import = importDocument;
+    Document.prototype.exportCompressed = exportCompressedDocument;
+    Document.prototype.importCompressed = importCompressedDocument;
     Document.prototype.serialize = serializeDocument;
 }
 
diff --git a/src/index.js b/src/index.js
index 8ff68537..1b055ce0 100644
--- a/src/index.js
+++ b/src/index.js
@@ -29,7 +29,7 @@ import Cache, { searchCache } from "./cache.js";
 import Charset from "./charset.js";
 import { KeystoreMap, KeystoreSet } from "./keystore.js";
 import { is_array, is_string } from "./common.js";
-import { exportIndex, importIndex, serializeIndex } from "./serialize.js";
+import { exportIndex, importIndex, serializeIndex, exportCompressedIndex, importCompressedIndex } from "./serialize.js";
 import { remove_index } from "./index/remove.js";
 //import default_encoder from "./charset/latin/default.js";
 import apply_preset from "./preset.js";
@@ -285,6 +285,8 @@ if(SUPPORT_SERIALIZE){
 
     Index.prototype.export = exportIndex;
     Index.prototype.import = importIndex;
+    Index.prototype.exportCompressed = exportCompressedIndex;
+    Index.prototype.importCompressed = importCompressedIndex;
     Index.prototype.serialize = serializeIndex;
 }
 
diff --git a/src/serialize.js b/src/serialize.js
index ee2a569c..6b8190d8 100644
--- a/src/serialize.js
+++ b/src/serialize.js
@@ -394,7 +394,7 @@ function apply_document_cfg(doc, cfg){
  * @this {Index|Document}
  * @return {Promise}
  */
-function save(callback, field, key, chunk, index_doc, index_obj, index_prt = 0){
+function save(callback, field, key, chunk, index_doc, index_obj, index_prt = 0, raw = false){
 
     const is_arr = chunk && chunk.constructor === Array;
     const data = is_arr ? chunk.shift() : chunk;
@@ -403,13 +403,14 @@ function save(callback, field, key, chunk, index_doc, index_obj, index_prt = 0){
             callback,
             field,
             index_doc,
-            index_obj + 1
+            index_obj + 1,
+            raw
         );
     }
 
     const res = callback(
         (field ? field + "." : "") + (index_prt + 1) + "." + key,
-        JSON.stringify(data)
+        raw ? data : JSON.stringify(data)
     );
 
     if(res && res["then"]){
@@ -422,7 +423,8 @@ function save(callback, field, key, chunk, index_doc, index_obj, index_prt = 0){
                 is_arr ? chunk : null,
                 index_doc,
                 index_obj,
-                index_prt + 1
+                index_prt + 1,
+                raw
             );
         });
     }
@@ -434,7 +436,8 @@ function save(callback, field, key, chunk, index_doc, index_obj, index_prt = 0){
         is_arr ? chunk : null,
         index_doc,
         index_obj,
-        index_prt + 1
+        index_prt + 1,
+        raw
     );
 }
 
@@ -443,10 +446,11 @@ function save(callback, field, key, chunk, index_doc, index_obj, index_prt = 0){
  * @param {!string|null=} _field
  * @param {number=} _index_doc
  * @param {number=} _index_obj
+ * @param {boolean=} _raw
  * @this {Index}
  */
 
-export function exportIndex(callback, _field, _index_doc = 0, _index_obj = 0){
+export function exportIndex(callback, _field, _index_doc = 0, _index_obj = 0, _raw = false){
 
     let key, chunk;
 
@@ -487,7 +491,9 @@ export function exportIndex(callback, _field, _index_doc = 0, _index_obj = 0){
         key,
         chunk,
         _index_doc,
-        _index_obj
+        _index_obj,
+        0,
+        _raw
     );
 }
 
@@ -499,6 +505,13 @@ export function exportIndex(callback, _field, _index_doc = 0, _index_obj = 0){
 
 export function importIndex(key, data){
 
+    if(key && (key.constructor === Map || Array.isArray(key))){
+        for(const [k, v] of key){
+            importIndex.call(this, k, v);
+        }
+        return;
+    }
+
     if(!data){
         return;
     }
@@ -550,11 +563,11 @@ export function importIndex(key, data){
  * @this {Document}
  */
 
-export function exportDocument(callback, _field, _index_doc = -1, _index_obj = 0){
+export function exportDocument(callback, _field, _index_doc = -1, _index_obj = 0, _raw = false){
 
     if(_index_doc === -1){
         const cfgObj = document_config_to_export_obj(this);
-        const res = callback("1.cfg", JSON.stringify(cfgObj));
+        const res = callback("1.cfg", _raw ? cfgObj : JSON.stringify(cfgObj));
         if(res && res["then"]){
             const self = this;
             return res["then"](function(){
@@ -574,11 +587,11 @@ export function exportDocument(callback, _field, _index_doc = -1, _index_obj = 0
         if(res && res["then"]){
             const self = this;
             return res["then"](function(){
-                return self.export(callback, field, _index_doc + 1);
+                return self.export(callback, field, _index_doc + 1, 0);
             });
         }
 
-        return this.export(callback, field, _index_doc + 1);
+        return this.export(callback, field, _index_doc + 1, 0);
     }
     else{
 
@@ -620,7 +633,9 @@ export function exportDocument(callback, _field, _index_doc = -1, _index_obj = 0
             key,
             /** @type {Array|null} */ (chunk || null),
             _index_doc,
-            _index_obj
+            _index_obj,
+            0,
+            _raw
         );
     }
 }
@@ -633,6 +648,13 @@ export function exportDocument(callback, _field, _index_doc = -1, _index_obj = 0
 
 export function importDocument(key, data){
 
+    if(key && (key.constructor === Map || Array.isArray(key))){
+        for(const [k, v] of key){
+            importDocument.call(this, k, v);
+        }
+        return;
+    }
+
     const split = key.split(".");
     if(split[split.length - 1] === "json"){
         split.pop();
@@ -821,10 +843,10 @@ function parse_tag_map(tagMap, type){
  * @return {string|Promise<Uint8Array>|Uint8Array}
  */
 export function serializeDocument(withFunctionWrapper = true, withCompression = false, withCfg = false){
-    
+
     let statements = '';
     let type = undefined;
-    
+
     // Serialize shared registry once
     if(this.reg && this.reg.size){
         let reg = '';
@@ -838,20 +860,20 @@ export function serializeDocument(withFunctionWrapper = true, withCompression =
             statements += 'doc.index.get("' + fieldName + '").reg=doc.reg;';
         }
     }
-    
+
     // Serialize each field index
     if(this.index && this.index.size){
         for(const fieldName of this.field){
             const index = this.index.get(fieldName);
             if(!index) continue;
-            
+
             // Only serialize if field index has map data
             if(index.map && index.map.size){
                 let map = parse_map(index.map, type);
                 if(map){
                     statements += 'doc.index.get("' + fieldName + '").map=new Map([' + map + ']);';
                 }
-                
+
                 // Serialize ctx if present
                 if(index.ctx && index.ctx.size){
                     let ctx = '';
@@ -872,7 +894,7 @@ export function serializeDocument(withFunctionWrapper = true, withCompression =
             }
         }
     }
-    
+
     // Serialize tags if present
     if(SUPPORT_TAGS && this.tag && this.tagfield){
         for(let i = 0; i < this.tagfield.length; i++){
@@ -881,13 +903,13 @@ export function serializeDocument(withFunctionWrapper = true, withCompression =
             if(tagMap && tagMap.size){
                 let tag = parse_tag_map(tagMap, type);
                 if(tag){
-                    statements += 'doc.tag.get("' + tagField + '").clear();' + 
+                    statements += 'doc.tag.get("' + tagField + '").clear();' +
                                   'for(const [k,v] of new Map([' + tag + ']).entries()){doc.tag.get("' + tagField + '").set(k,v);}';
                 }
             }
         }
     }
-    
+
     // Serialize store if present
     if(SUPPORT_STORE && this.store && this.store.size){
         let storeData = '';
@@ -901,7 +923,7 @@ export function serializeDocument(withFunctionWrapper = true, withCompression =
             statements += 'for(const [k,v] of new Map([' + storeData + ']).entries()){doc.store.set(k,v);}';
         }
     }
-    
+
     if(withCfg){
         const cfgJs = document_config_to_js(this, "Charset");
         const body = "const {Document,Charset}=FlexSearch;const doc=new Document(" + cfgJs + ");" + statements + "return doc;";
@@ -919,29 +941,81 @@ export function serializeDocument(withFunctionWrapper = true, withCompression =
 }
 
 /**
- * Compress string using gzip
+ * Export compressed index data
+ * @this {Index}
+ * @return {Promise<Uint8Array>}
+ */
+export async function exportCompressedIndex(){
+    const map = new Map();
+    await exportIndex.call(this, (key, data) => {
+        map.set(key, data);
+    }, null, 0, 0, true);
+    return compress(JSON.stringify([...map]));
+}
+
+/**
+ * Export compressed document data
+ * @this {Document}
+ * @return {Promise<Uint8Array>}
+ */
+export async function exportCompressedDocument(){
+    const map = new Map();
+    await exportDocument.call(this, (key, data) => {
+        map.set(key, data);
+    }, null, -1, 0, true);
+    return compress(JSON.stringify([...map]));
+}
+
+/**
+ * Import compressed index data
+ * @param {Uint8Array} source - Compressed data
+ * @this {Index}
+ * @return {Promise<void>}
+ */
+export async function importCompressedIndex(source){
+    const json = await decompress(source);
+    const entries = JSON.parse(json);
+    return importIndex.call(this, entries);
+}
+
+/**
+ * Import compressed document data
+ * @param {Uint8Array} source - Compressed data
+ * @this {Document}
+ * @return {Promise<void>}
+ */
+export async function importCompressedDocument(source){
+    const json = await decompress(source);
+    const entries = JSON.parse(json);
+    return importDocument.call(this, entries);
+}
+
+/**
+ * Compress string using gzip (no intermediate Blob needed)
  * @param {string} data - String to compress
  * @return {Promise<Uint8Array>} Compressed data
  */
 export async function compress(data){
-    if(data instanceof Map) data = JSON.stringify(Array.from(data.entries()));
     const cs = new CompressionStream('gzip');
-    const blob = new Blob([data], { type: 'application/octet-stream' });
-    const stream = blob.stream().pipeThrough(cs);
-    const compressedBuffer = await new Response(stream).arrayBuffer();
-    return new Uint8Array(compressedBuffer);
+    const writer = cs.writable.getWriter();
+    const encoder = new TextEncoder();
+    await writer.write(encoder.encode(data));
+    await writer.close();
+    const compressed = await new Response(cs.readable).arrayBuffer();
+    return new Uint8Array(compressed);
 }
 
 /**
- * Decompress gzip-compressed data
+ * Decompress gzip-compressed data (no intermediate Blob needed)
  * @param {Uint8Array} data - Compressed data
  * @return {Promise<string>} Decompressed string
  */
 export async function decompress(data){
     const ds = new DecompressionStream('gzip');
-    const blob = new Blob([data], { type: 'application/octet-stream' });
-    const stream = blob.stream().pipeThrough(ds);
-    const decompressedBuffer = await new Response(stream).arrayBuffer();
-    const decoder = new TextDecoder();
-    return decoder.decode(decompressedBuffer);
+    const writer = ds.writable.getWriter();
+    await writer.write(data);
+    await writer.close();
+
+    const decompressed = await new Response(ds.readable).arrayBuffer();
+    return new TextDecoder().decode(decompressed);
 }
\ No newline at end of file
diff --git a/test/serialize.js b/test/serialize.js
index ec778599..09856d28 100644
--- a/test/serialize.js
+++ b/test/serialize.js
@@ -4,7 +4,7 @@ import { expect } from "chai";
 let FlexSearch = await import(env ? "../dist/" + env + ".js" : "../src/bundle.js");
 if(FlexSearch.default) FlexSearch = FlexSearch.default;
 if(FlexSearch.FlexSearch) FlexSearch = FlexSearch.FlexSearch;
-const { Index, Document, Worker, Charset: _Charset, Encoder, Resolver, compress, decompress } = FlexSearch;
+const { Index, Document, Worker, Charset: _Charset, Encoder, Resolver, decompress } = FlexSearch;
 const build_light = env && env.includes("light");
 const build_compact = env && env.includes("compact");
 const build_esm = !env || env.startsWith("module");
@@ -498,29 +498,31 @@ if(!build_light) describe("Export / Import", function(){
         expect(ksDoc3.search(tagQ2)).to.eql(ksDocRef.search(tagQ2));
     });
 
-    it("Should compress/decompress export payload (Index)", async function(){
+    it("Should exportCompressed/importCompressed (Index)", async function(){
 
         const idx = new Index({ tokenize: "forward", resolution: 3 });
         idx.add(0, "foo bar foobar");
         idx.add(1, "bar foo foobar");
         idx.add(2, "foobar foo bar");
 
-        // collect via callback, then compress
-        const payload = new Map();
-        idx.export(function(key, value){ payload.set(key, value); });
-        const compressed = await compress(payload);
+        const compressed = await idx.exportCompressed();
         expect(compressed).to.be.instanceOf(Uint8Array);
 
-        // decompress → parse → replay into a plain new Index
-        const entries = JSON.parse(await decompress(compressed));
         const idx2 = new Index({});
-        for(const [key, value] of entries) idx2.import(key, value);
+        await idx2.importCompressed(compressed);
 
         expect(normalize_index(idx2)).to.eql(normalize_index(idx));
         expect(idx2.search("foobar")).to.eql(idx.search("foobar"));
+
+        // bulk import still works from map payload
+        const payload = new Map();
+        idx.export(function(key, value){ payload.set(key, value); });
+        const idx3 = new Index({});
+        idx3.import(payload);
+        expect(normalize_index(idx3)).to.eql(normalize_index(idx));
     });
 
-    it("Should compress/decompress export payload (Document)", async function(){
+    it("Should exportCompressed/importCompressed (Document)", async function(){
 
         const doc = new Document({
             document: {
@@ -533,21 +535,23 @@ if(!build_light) describe("Export / Import", function(){
         doc.add({ id: 1, title: "Carmencita", year: "1865" });
         doc.add({ id: 2, title: "Gulliver", year: "1864" });
 
-        // collect via callback, then compress
-        const payload = new Map();
-        doc.export(function(key, value){ payload.set(key, value); });
-        const compressed = await compress(payload);
+        const compressed = await doc.exportCompressed();
         expect(compressed).to.be.instanceOf(Uint8Array);
 
-        // decompress → parse → replay
-        const entries = JSON.parse(await decompress(compressed));
         const doc2 = new Document({});
-        for(const [key, value] of entries) doc2.import(key, value);
+        await doc2.importCompressed(compressed);
 
         expect(normalize_doc(doc2)).to.eql(normalize_doc(doc));
         const tagQ = { query: "carmen", tag: { year: "1865" } };
         expect(doc2.search(tagQ)).to.eql(doc.search(tagQ));
         expect(doc2.search(tagQ).some(r => r.result.includes(1))).to.equal(true);
+
+        // bulk import still works from map payload
+        const payload = new Map();
+        doc.export(function(key, value){ payload.set(key, value); });
+        const doc3 = new Document({});
+        doc3.import(payload);
+        expect(normalize_doc(doc3)).to.eql(normalize_doc(doc));
     });
 
 });

From 4f9fbfed2167781a277ad90ee3fb171f537ac228 Mon Sep 17 00:00:00 2001
From: Nick Chomey <nick_chomey@hotmail.com>
Date: Tue, 3 Mar 2026 08:46:01 -0600
Subject: [PATCH 7/9] exportCompressed-> export__Bulk

---
 doc/export-import.md | 38 +++++++++++++++++---------
 index.d.ts           | 10 ++++---
 src/document.js      |  6 ++---
 src/index.js         |  6 ++---
 src/serialize.js     | 64 +++++++++++++++++++++++++++++---------------
 test/serialize.js    | 12 ++++-----
 6 files changed, 85 insertions(+), 51 deletions(-)

diff --git a/doc/export-import.md b/doc/export-import.md
index b6cafc10..c1b7bb9e 100644
--- a/doc/export-import.md
+++ b/doc/export-import.md
@@ -175,29 +175,37 @@ const fn_body = document.serialize(false);
 const inject = new Function("doc", fn_body);
 ```
 
-<a name="compression"></a>
+## Bulk Export / Import
 
-## Compression
-
-Use the built-in compressed APIs when you want a single compressed binary blob for transport or storage:
+Use the bulk export APIs when you want all index data in a single payload for transport or storage:
 
 ```js
-const compressed = await index.exportCompressed();
+// Export uncompressed (returns JSON string)
+const json = await index.exportIndexBulk();
+
+// Export compressed (returns gzip Uint8Array)
+const compressed = await index.exportIndexBulk(true);
+```
 
+```js
+// Import uncompressed JSON string
 const restored = new Index({});
-await restored.importCompressed(compressed);
+await restored.importIndexBulk(json);
+
+// Import compressed Uint8Array
+const restored2 = new Index({});
+await restored2.importIndexBulk(compressed, true);
 ```
 
 Same pattern for `Document`:
 
 ```js
-const compressed = await doc.exportCompressed();
-
-const restoredDoc = new Document({});
-await restoredDoc.importCompressed(compressed);
+const json = await doc.exportDocumentBulk();
+const docRestored = new Document({});
+await docRestored.importDocumentBulk(json);
 ```
 
-These methods collect all export data into a Map, serialize to JSON, and compress with gzip. This leverages the same bulk import support and provides a simple, maintainable approach.
+These methods collect all export data into a Map, serialize to JSON, and optionally compress with gzip. This leverages the same bulk import support and provides a simple, maintainable approach.
 
 ### Bulk import convenience
 
@@ -227,9 +235,13 @@ const restored = await decompress(compressed);
 
 | Function | Signature | Returns |
 |---|---|---|
-| `exportCompressed` | `() => Promise<Uint8Array>` | Compressed binary payload |
-| `importCompressed` | `(source: Uint8Array) => Promise<void>` | Restores from compressed payload |
+| `exportIndexBulk` | `(compressed?: boolean) => Promise<string \| Uint8Array>` | JSON string (uncompressed) or Uint8Array (compressed) |
+| `importIndexBulk` | `(source: string \| Uint8Array, compressed?: boolean) => Promise<void>` | Restores from bulk payload |
+| `exportDocumentBulk` | `(compressed?: boolean) => Promise<string \| Uint8Array>` | JSON string (uncompressed) or Uint8Array (compressed) |
+| `importDocumentBulk` | `(source: string \| Uint8Array, compressed?: boolean) => Promise<void>` | Restores from bulk payload |
 | `import` | `(payload: Map<string, string> \| Array<[string, string]>) => void` | Bulk import convenience |
+| `serialize` | **Index:** `(withFunctionWrapper?: boolean, withCfg?: boolean) => SerializedFunctionString` | **Index:** Fast-boot function string or body |
+| | **Document:** `(withFunctionWrapper?: boolean, withCompression?: boolean, withCfg?: boolean) => SerializedFunctionString \| Promise<Uint8Array>` | **Document:** Fast-boot function string/body or compressed data |
 | `compress` | `(data: string) => Promise<Uint8Array>` | Compress string data |
 | `decompress` | `(data: Uint8Array) => Promise<string>` | Decompress to string |
 
diff --git a/index.d.ts b/index.d.ts
index c320533b..8ba0d1b0 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -296,8 +296,9 @@ declare module "flexsearch" {
         import(payload: ExportMap): void;
         import(payload: ExportEntries): void;
 
-        exportCompressed(): Promise<Uint8Array>;
-        importCompressed(source: CompressedSource): Promise<void>;
+        exportIndexBulk(compressed?: boolean): Promise<string | Uint8Array>;
+        importIndexBulk(source: string | Uint8Array, compressed?: boolean): Promise<void>;
+
 
         serialize(with_function_wrapper?: boolean): SerializedFunctionString;
 
@@ -771,8 +772,9 @@ declare module "flexsearch" {
         import(payload: ExportMap): void;
         import(payload: ExportEntries): void;
 
-        exportCompressed(): Promise<Uint8Array>;
-        importCompressed(source: CompressedSource): Promise<void>;
+        exportDocumentBulk(compressed?: boolean): Promise<string | Uint8Array>;
+        importDocumentBulk(source: string | Uint8Array, compressed?: boolean): Promise<void>;
+
 
         serialize(with_function_wrapper?: boolean, compress?: boolean): SerializedFunctionString | Promise<Uint8Array>;
 
diff --git a/src/document.js b/src/document.js
index 6aba8fec..4168a6a3 100644
--- a/src/document.js
+++ b/src/document.js
@@ -38,7 +38,7 @@ import Encoder, { fallback_encoder } from "./encoder.js";
 import Cache, { searchCache } from "./cache.js";
 import { is_string, is_object, parse_simple } from "./common.js";
 import apply_async from "./async.js";
-import { exportDocument, importDocument, serializeDocument, exportCompressedDocument, importCompressedDocument } from "./serialize.js";
+import { exportDocument, importDocument, serializeDocument, exportDocumentBulk, importDocumentBulk } from "./serialize.js";
 import { KeystoreMap, KeystoreSet } from "./keystore.js";
 import "./document/add.js";
 import "./document/search.js";
@@ -574,8 +574,8 @@ if(SUPPORT_SERIALIZE){
 
     Document.prototype.export = exportDocument;
     Document.prototype.import = importDocument;
-    Document.prototype.exportCompressed = exportCompressedDocument;
-    Document.prototype.importCompressed = importCompressedDocument;
+    Document.prototype.exportDocumentBulk = exportDocumentBulk;
+    Document.prototype.importDocumentBulk = importDocumentBulk;
     Document.prototype.serialize = serializeDocument;
 }
 
diff --git a/src/index.js b/src/index.js
index 1b055ce0..f9125ed0 100644
--- a/src/index.js
+++ b/src/index.js
@@ -29,7 +29,7 @@ import Cache, { searchCache } from "./cache.js";
 import Charset from "./charset.js";
 import { KeystoreMap, KeystoreSet } from "./keystore.js";
 import { is_array, is_string } from "./common.js";
-import { exportIndex, importIndex, serializeIndex, exportCompressedIndex, importCompressedIndex } from "./serialize.js";
+import { exportIndex, importIndex, serializeIndex, exportIndexBulk, importIndexBulk } from "./serialize.js";
 import { remove_index } from "./index/remove.js";
 //import default_encoder from "./charset/latin/default.js";
 import apply_preset from "./preset.js";
@@ -285,8 +285,8 @@ if(SUPPORT_SERIALIZE){
 
     Index.prototype.export = exportIndex;
     Index.prototype.import = importIndex;
-    Index.prototype.exportCompressed = exportCompressedIndex;
-    Index.prototype.importCompressed = importCompressedIndex;
+    Index.prototype.exportIndexBulk = exportIndexBulk;
+    Index.prototype.importIndexBulk = importIndexBulk;
     Index.prototype.serialize = serializeIndex;
 }
 
diff --git a/src/serialize.js b/src/serialize.js
index 6b8190d8..d42eb785 100644
--- a/src/serialize.js
+++ b/src/serialize.js
@@ -930,68 +930,88 @@ export function serializeDocument(withFunctionWrapper = true, withCompression =
         const result = withFunctionWrapper
             ? "function inject(FlexSearch){" + body + "}"
             : body;
-        return withCompression ? compress(result) : result;
+        const compressed_result = withCompression ? compress(result) : result;
+    return compressed_result;
     }
 
     const plain = withFunctionWrapper
         ? "function inject(doc){" + statements + "}"
         : statements;
 
-    return withCompression ? compress(plain) : plain;
+    const compressed_plain = withCompression ? compress(plain) : plain;
+    return compressed_plain;
 }
 
 /**
- * Export compressed index data
+ * Export bulk index data with optional gzip compression
+ * Collects all index data into a single bulk format.
+ * @param {boolean=} compressed - Whether to apply gzip compression (default: false)
  * @this {Index}
- * @return {Promise<Uint8Array>}
+ * @return {Promise<string|Uint8Array>}
  */
-export async function exportCompressedIndex(){
+export async function exportIndexBulk(compressed = false){
     const map = new Map();
     await exportIndex.call(this, (key, data) => {
         map.set(key, data);
-    }, null, 0, 0, true);
-    return compress(JSON.stringify([...map]));
+    }, null, 0, 0, true);  // _raw = true
+    const json = JSON.stringify([...map]);
+    return compressed ? compress(json) : json;
 }
 
 /**
- * Export compressed document data
+ * Export bulk document data with optional gzip compression
+ * Collects all document data into a single bulk format.
+ * @param {boolean=} compressed - Whether to apply gzip compression (default: false)
  * @this {Document}
- * @return {Promise<Uint8Array>}
+ * @return {Promise<string|Uint8Array>}
  */
-export async function exportCompressedDocument(){
+export async function exportDocumentBulk(compressed = false){
     const map = new Map();
     await exportDocument.call(this, (key, data) => {
         map.set(key, data);
-    }, null, -1, 0, true);
-    return compress(JSON.stringify([...map]));
+    }, null, -1, 0, true);  // _raw = true
+    const json = JSON.stringify([...map]);
+    return compressed ? compress(json) : json;
 }
 
 /**
- * Import compressed index data
- * @param {Uint8Array} source - Compressed data
+ * Import bulk index data with optional gzip decompression
+ * @param {Uint8Array|string} source - Bulk data (compressed as Uint8Array, or uncompressed as string)
+ * @param {boolean=} compressed - Whether source is gzip compressed (default: false)
  * @this {Index}
  * @return {Promise<void>}
  */
-export async function importCompressedIndex(source){
-    const json = await decompress(source);
+export async function importIndexBulk(source, compressed = false){
+    let json;
+    if(compressed){
+        json = await decompress(source);
+    } else {
+        json = typeof source === "string" ? source : new TextDecoder().decode(source);
+    }
     const entries = JSON.parse(json);
     return importIndex.call(this, entries);
 }
 
 /**
- * Import compressed document data
- * @param {Uint8Array} source - Compressed data
+ * Import bulk document data with optional gzip decompression
+ * @param {Uint8Array|string} source - Bulk data (compressed as Uint8Array, or uncompressed as string)
+ * @param {boolean=} compressed - Whether source is gzip compressed (default: false)
  * @this {Document}
  * @return {Promise<void>}
  */
-export async function importCompressedDocument(source){
-    const json = await decompress(source);
+export async function importDocumentBulk(source, compressed = false){
+    let json;
+    if(compressed){
+        json = await decompress(source);
+    } else {
+        json = typeof source === "string" ? source : new TextDecoder().decode(source);
+    }
     const entries = JSON.parse(json);
     return importDocument.call(this, entries);
 }
 
 /**
- * Compress string using gzip (no intermediate Blob needed)
+ * Compress string using gzip
  * @param {string} data - String to compress
  * @return {Promise<Uint8Array>} Compressed data
  */
@@ -1006,7 +1026,7 @@ export async function compress(data){
 }
 
 /**
- * Decompress gzip-compressed data (no intermediate Blob needed)
+ * Decompress gzip-compressed data
  * @param {Uint8Array} data - Compressed data
  * @return {Promise<string>} Decompressed string
  */
diff --git a/test/serialize.js b/test/serialize.js
index 09856d28..9d9a8f64 100644
--- a/test/serialize.js
+++ b/test/serialize.js
@@ -498,18 +498,18 @@ if(!build_light) describe("Export / Import", function(){
         expect(ksDoc3.search(tagQ2)).to.eql(ksDocRef.search(tagQ2));
     });
 
-    it("Should exportCompressed/importCompressed (Index)", async function(){
+    it("Should exportIndexBulk/importIndexBulk with compression (Index)", async function(){
 
         const idx = new Index({ tokenize: "forward", resolution: 3 });
         idx.add(0, "foo bar foobar");
         idx.add(1, "bar foo foobar");
         idx.add(2, "foobar foo bar");
 
-        const compressed = await idx.exportCompressed();
+        const compressed = await idx.exportIndexBulk(true);
         expect(compressed).to.be.instanceOf(Uint8Array);
 
         const idx2 = new Index({});
-        await idx2.importCompressed(compressed);
+        await idx2.importIndexBulk(compressed, true);
 
         expect(normalize_index(idx2)).to.eql(normalize_index(idx));
         expect(idx2.search("foobar")).to.eql(idx.search("foobar"));
@@ -522,7 +522,7 @@ if(!build_light) describe("Export / Import", function(){
         expect(normalize_index(idx3)).to.eql(normalize_index(idx));
     });
 
-    it("Should exportCompressed/importCompressed (Document)", async function(){
+    it("Should exportDocumentBulk/importDocumentBulk with compression (Document)", async function(){
 
         const doc = new Document({
             document: {
@@ -535,11 +535,11 @@ if(!build_light) describe("Export / Import", function(){
         doc.add({ id: 1, title: "Carmencita", year: "1865" });
         doc.add({ id: 2, title: "Gulliver", year: "1864" });
 
-        const compressed = await doc.exportCompressed();
+        const compressed = await doc.exportDocumentBulk(true);
         expect(compressed).to.be.instanceOf(Uint8Array);
 
         const doc2 = new Document({});
-        await doc2.importCompressed(compressed);
+        await doc2.importDocumentBulk(compressed, true);
 
         expect(normalize_doc(doc2)).to.eql(normalize_doc(doc));
         const tagQ = { query: "carmen", tag: { year: "1865" } };

From 2e2e7356ce18334b5675c708d07722a1cbef0bfe Mon Sep 17 00:00:00 2001
From: Nick Chomey <nick_chomey@hotmail.com>
Date: Tue, 3 Mar 2026 17:15:24 -0600
Subject: [PATCH 8/9] review fixes: propagate _raw, escape strings, fix types,
 simplify serialize, add tests

---
 index.d.ts        |   2 +
 src/bundle.js     |   9 ++--
 src/serialize.js  |  59 +++++++++++++----------
 test/serialize.js | 119 ++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 159 insertions(+), 30 deletions(-)

diff --git a/index.d.ts b/index.d.ts
index 8ba0d1b0..71668660 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -301,6 +301,7 @@ declare module "flexsearch" {
 
 
         serialize(with_function_wrapper?: boolean): SerializedFunctionString;
+        serialize(with_function_wrapper: boolean, with_cfg: boolean): SerializedFunctionString;
 
         // Persistent Index
         mount(db: StorageInterface): Promise<void>;
@@ -777,6 +778,7 @@ declare module "flexsearch" {
 
 
         serialize(with_function_wrapper?: boolean, compress?: boolean): SerializedFunctionString | Promise<Uint8Array>;
+        serialize(with_function_wrapper: boolean, compress: boolean, with_cfg: boolean): SerializedFunctionString | Promise<Uint8Array>;
 
         // Persistent Index
         mount<S = StorageInterface<D>>(db: S): Promise<void>;
diff --git a/src/bundle.js b/src/bundle.js
index d4a5613b..21c22335 100644
--- a/src/bundle.js
+++ b/src/bundle.js
@@ -56,8 +56,8 @@ import { compress, decompress } from "./serialize.js";
 /** @export */ Index.prototype.removeAsync;
 /** @export */ Index.prototype.export;
 /** @export */ Index.prototype.import;
-/** @export */ Index.prototype.exportCompressed;
-/** @export */ Index.prototype.importCompressed;
+/** @export */ Index.prototype.exportIndexBulk;
+/** @export */ Index.prototype.importIndexBulk;
 /** @export */ Index.prototype.serialize;
 /** @export */ Index.prototype.mount;
 /** @export */ Index.prototype.commit;
@@ -111,8 +111,9 @@ if(SUPPORT_PERSISTENT){
 /** @export */ Document.prototype.destroy;
 /** @export */ Document.prototype.export;
 /** @export */ Document.prototype.import;
-/** @export */ Document.prototype.exportCompressed;
-/** @export */ Document.prototype.importCompressed;
+/** @export */ Document.prototype.exportDocumentBulk;
+/** @export */ Document.prototype.importDocumentBulk;
+/** @export */ Document.prototype.serialize;
 /** @export */ Document.prototype.get;
 /** @export */ Document.prototype.set;
 
diff --git a/src/serialize.js b/src/serialize.js
index d42eb785..2eb0e52c 100644
--- a/src/serialize.js
+++ b/src/serialize.js
@@ -22,6 +22,16 @@ const chunk_size_reg = 250000;
 const chunk_size_map = 5000;
 const chunk_size_ctx = 1000;
 
+/**
+ * Escape a string for safe embedding in a JS string literal.
+ * Handles backslash, double-quote, single-quote, newlines, and other control chars.
+ * @param {string} str
+ * @return {string}
+ */
+function escape_js_string(str) {
+    return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+}
+
 /**
  * @param {Map<IntermediateSearchResults>|KeystoreMap<IntermediateSearchResults>} map
  * @param {number=} size
@@ -505,7 +515,7 @@ export function exportIndex(callback, _field, _index_doc = 0, _index_obj = 0, _r
 
 export function importIndex(key, data){
 
-    if(key && (key.constructor === Map || Array.isArray(key))){
+    if (key && (key instanceof Map || Array.isArray(key))) {
         for(const [k, v] of key){
             importIndex.call(this, k, v);
         }
@@ -571,10 +581,10 @@ export function exportDocument(callback, _field, _index_doc = -1, _index_obj = 0
         if(res && res["then"]){
             const self = this;
             return res["then"](function(){
-                return self.export(callback, null, 0, 0);
+                return self.export(callback, null, 0, 0, _raw);
             });
         }
-        return this.export(callback, null, 0, 0);
+        return this.export(callback, null, 0, 0, _raw);
     }
 
     if(_index_doc < this.field.length){
@@ -582,16 +592,16 @@ export function exportDocument(callback, _field, _index_doc = -1, _index_obj = 0
         const field = this.field[_index_doc];
         const idx = this.index.get(field);
         // start from index 1, because document indexes does not additionally store register
-        const res = idx.export(callback, field, _index_doc, _index_obj = 1);
+        const res = idx.export(callback, field, _index_doc, _index_obj = 1, _raw);
 
         if(res && res["then"]){
             const self = this;
             return res["then"](function(){
-                return self.export(callback, field, _index_doc + 1, 0);
+                return self.export(callback, field, _index_doc + 1, 0, _raw);
             });
         }
 
-        return this.export(callback, field, _index_doc + 1, 0);
+        return this.export(callback, field, _index_doc + 1, 0, _raw);
     }
     else{
 
@@ -648,7 +658,7 @@ export function exportDocument(callback, _field, _index_doc = -1, _index_obj = 0
 
 export function importDocument(key, data){
 
-    if(key && (key.constructor === Map || Array.isArray(key))){
+    if (key && (key instanceof Map || Array.isArray(key))) {
         for(const [k, v] of key){
             importDocument.call(this, k, v);
         }
@@ -757,7 +767,7 @@ export function serializeIndex(withFunctionWrapper = true, withCfg = false){
         let type;
         for(const key of this.reg.keys()){
             type || (type = typeof key);
-            reg += (reg ? ',' : '') + (type === "string" ? '"' + key + '"' : key);
+            reg += (reg ? ',' : '') + (type === "string" ? '"' + escape_js_string(key) + '"' : key);
         }
         reg = 'index.reg=new Set([' + reg + ']);';
 
@@ -769,7 +779,7 @@ export function serializeIndex(withFunctionWrapper = true, withCfg = false){
             const value_ctx = context[1];
             let ctx_map = parse_map(value_ctx, type);
             ctx_map = "new Map([" + ctx_map + "])";
-            ctx_map = '["' + key_ctx + '",' + ctx_map + ']';
+            ctx_map = '["' + escape_js_string(key_ctx) + '",' + ctx_map + ']';
             ctx += (ctx ? ',' : '') + ctx_map;
         }
         ctx = "index.ctx=new Map([" + ctx + "]);";
@@ -799,7 +809,7 @@ function parse_map(map, type){
             let str = '';
             if(ids && ids.length){
                 for(let j = 0; j < ids.length; j++){
-                    str += (str ? ',' : '') + (type === "string" ? '"' + ids[j] + '"' : ids[j]);
+                    str += (str ? ',' : '') + (type === "string" ? '"' + escape_js_string(ids[j]) + '"' : ids[j]);
                 }
                 str = '[' + str + ']';
             }
@@ -808,7 +818,7 @@ function parse_map(map, type){
             }
             res += (res ? ',' : '') + str;
         }
-        res = '["' + key + '",[' + res + ']]';
+        res = '["' + escape_js_string(key) + '",[' + res + ']]';
         result += (result ? ',' : '') + res;
     }
     return result;
@@ -827,9 +837,9 @@ function parse_tag_map(tagMap, type){
         const ids = item[1];   // flat Array<ID> (e.g., ["tt0000001"])
         let idsStr = '';
         for(let j = 0; j < ids.length; j++){
-            idsStr += (idsStr ? ',' : '') + (type === "string" ? '"' + ids[j] + '"' : ids[j]);
+            idsStr += (idsStr ? ',' : '') + (type === "string" ? '"' + escape_js_string(ids[j]) + '"' : ids[j]);
         }
-        result += (result ? ',' : '') + '["' + key + '",[' + idsStr + ']]';
+        result += (result ? ',' : '') + '["' + escape_js_string(key) + '",[' + idsStr + ']]';
     }
     return result;
 }
@@ -852,12 +862,12 @@ export function serializeDocument(withFunctionWrapper = true, withCompression =
         let reg = '';
         for(const key of this.reg.keys()){
             type || (type = typeof key);
-            reg += (reg ? ',' : '') + (type === "string" ? '"' + key + '"' : key);
+            reg += (reg ? ',' : '') + (type === "string" ? '"' + escape_js_string(key) + '"' : key);
         }
         statements += 'doc.reg=new Set([' + reg + ']);';
         // Sync the shared reg reference into each field index (mirrors importDocument "reg" case)
         for(const fieldName of this.field){
-            statements += 'doc.index.get("' + fieldName + '").reg=doc.reg;';
+            statements += 'doc.index.get("' + escape_js_string(fieldName) + '").reg=doc.reg;';
         }
     }
 
@@ -871,7 +881,7 @@ export function serializeDocument(withFunctionWrapper = true, withCompression =
             if(index.map && index.map.size){
                 let map = parse_map(index.map, type);
                 if(map){
-                    statements += 'doc.index.get("' + fieldName + '").map=new Map([' + map + ']);';
+                    statements += 'doc.index.get("' + escape_js_string(fieldName) + '").map=new Map([' + map + ']);';
                 }
 
                 // Serialize ctx if present
@@ -883,12 +893,12 @@ export function serializeDocument(withFunctionWrapper = true, withCompression =
                         let ctx_map = parse_map(value_ctx, type);
                         if(ctx_map){
                             ctx_map = "new Map([" + ctx_map + "])";
-                            ctx_map = '["' + key_ctx + '",' + ctx_map + ']';
+                            ctx_map = '["' + escape_js_string(key_ctx) + '",' + ctx_map + ']';
                             ctx += (ctx ? ',' : '') + ctx_map;
                         }
                     }
                     if(ctx){
-                        statements += 'doc.index.get("' + fieldName + '").ctx=new Map([' + ctx + ']);';
+                        statements += 'doc.index.get("' + escape_js_string(fieldName) + '").ctx=new Map([' + ctx + ']);';
                     }
                 }
             }
@@ -903,8 +913,7 @@ export function serializeDocument(withFunctionWrapper = true, withCompression =
             if(tagMap && tagMap.size){
                 let tag = parse_tag_map(tagMap, type);
                 if(tag){
-                    statements += 'doc.tag.get("' + tagField + '").clear();' +
-                                  'for(const [k,v] of new Map([' + tag + ']).entries()){doc.tag.get("' + tagField + '").set(k,v);}';
+                    statements += 'doc.tag.set("' + escape_js_string(tagField) + '",new Map([' + tag + ']));';
                 }
             }
         }
@@ -917,10 +926,10 @@ export function serializeDocument(withFunctionWrapper = true, withCompression =
             const key = item[0];
             const value = item[1];
             const valueJson = JSON.stringify(value);
-            storeData += (storeData ? ',' : '') + '[' + (typeof key === "string" ? '"' + key + '"' : key) + ',' + valueJson + ']';
+            storeData += (storeData ? ',' : '') + '[' + (typeof key === "string" ? '"' + escape_js_string(key) + '"' : key) + ',' + valueJson + ']';
         }
         if(storeData){
-            statements += 'for(const [k,v] of new Map([' + storeData + ']).entries()){doc.store.set(k,v);}';
+            statements += 'doc.store=new Map([' + storeData + ']);';
         }
     }
 
@@ -930,16 +939,14 @@ export function serializeDocument(withFunctionWrapper = true, withCompression =
         const result = withFunctionWrapper
             ? "function inject(FlexSearch){" + body + "}"
             : body;
-        const compressed_result = withCompression ? compress(result) : result;
-    return compressed_result;
+        return withCompression ? compress(result) : result;
     }
 
     const plain = withFunctionWrapper
         ? "function inject(doc){" + statements + "}"
         : statements;
 
-    const compressed_plain = withCompression ? compress(plain) : plain;
-    return compressed_plain;
+    return withCompression ? compress(plain) : plain;
 }
 
 /**
diff --git a/test/serialize.js b/test/serialize.js
index 9d9a8f64..78d7f4ef 100644
--- a/test/serialize.js
+++ b/test/serialize.js
@@ -554,6 +554,125 @@ if(!build_light) describe("Export / Import", function(){
         expect(normalize_doc(doc3)).to.eql(normalize_doc(doc));
     });
 
+    it("Should handle special characters in IDs and indexed content (serialize)", function () {
+
+        // Special characters in both IDs and indexed content
+        const index = new Index({ tokenize: "forward" });
+        index.add('he"llo', 'text with "quotes"');
+        index.add("back\\slash", "path\\like\\content");
+        index.add("new\nline", "multi\nline\ntext");
+
+        const fn_body = index.serialize(false);
+        const inject = new Function("index", fn_body);
+
+        const index2 = new Index({ tokenize: "forward" });
+        inject(index2);
+
+        // Verify all IDs survived round-trip
+        expect(index2.reg.size).to.equal(3);
+        // Verify search still works for tokens from original content
+        expect(index2.search("quotes")).to.eql(index.search("quotes"));
+        expect(index2.search("path")).to.eql(index.search("path"));
+        expect(index2.search("multi")).to.eql(index.search("multi"));
+    });
+
+    it("Should handle special characters in IDs and indexed content (export/import)", function () {
+
+        let index = new Index({ tokenize: "forward" });
+        index.add('he"llo', 'text with "quotes"');
+        index.add("back\\slash", "path\\like\\content");
+
+        const payload = new Map();
+        index.export(function (key, value) { payload.set(key, value); });
+
+        let index2 = new Index({});
+        for (const [key, value] of payload) {
+            index2.import(key, value);
+        }
+
+        // Verify all IDs survived round-trip
+        expect(index2.reg.size).to.equal(2);
+        // Verify search works for tokens from original content
+        expect(index2.search("quotes")).to.eql(index.search("quotes"));
+        expect(index2.search("path")).to.eql(index.search("path"));
+    });
+
+
+    it("Should export/import uncompressed bulk (Document)", async function () {
+
+        const doc = new Document({
+            document: {
+                id: "id",
+                store: true,
+                index: [{ field: "title", tokenize: "forward" }],
+                tag: [{ field: "year" }]
+            }
+        });
+        doc.add({ id: 1, title: "Carmencita", year: "1865" });
+        doc.add({ id: 2, title: "Gulliver", year: "1864" });
+
+        const json = await doc.exportDocumentBulk(false);
+        expect(typeof json).to.equal("string");
+
+        const doc2 = new Document({});
+        await doc2.importDocumentBulk(json, false);
+
+        expect(normalize_doc(doc2)).to.eql(normalize_doc(doc));
+        expect(doc2.search("carmen")).to.eql(doc.search("carmen"));
+    });
+
+    it("Should export/import uncompressed bulk (Index)", async function () {
+
+        const idx = new Index({ tokenize: "forward" });
+        idx.add(0, "foo bar");
+        idx.add(1, "baz qux");
+
+        const json = await idx.exportIndexBulk(false);
+        expect(typeof json).to.equal("string");
+
+        const idx2 = new Index({});
+        await idx2.importIndexBulk(json, false);
+
+        expect(normalize_index(idx2)).to.eql(normalize_index(idx));
+        expect(idx2.search("foo")).to.eql(idx.search("foo"));
+    });
+
+    it("Should import from Array entries (same as Map)", function () {
+
+        const index = new Index({ tokenize: "forward" });
+        index.add(0, "foo bar foobar");
+        index.add(1, "bar foo foobar");
+
+        const payload = new Map();
+        index.export(function (key, value) { payload.set(key, value); });
+
+        const entries = Array.from(payload.entries());
+        const index2 = new Index({});
+        index2.import(entries);
+
+        expect(index2.reg.size).to.equal(index.reg.size);
+        expect(index2.search("foobar")).to.eql(index.search("foobar"));
+    });
+
+    it("Should serialize empty Index gracefully", function () {
+
+        const index = new Index({ tokenize: "forward" });
+        expect(index.serialize()).to.equal("function inject(index){}");
+        expect(index.serialize(false)).to.equal("");
+    });
+
+    it("Should serialize empty Document gracefully", function () {
+
+        const doc = new Document({
+            document: {
+                id: "id",
+                index: [{ field: "title" }]
+            }
+        });
+        expect(doc.serialize()).to.equal("function inject(doc){}");
+        expect(doc.serialize(false)).to.equal("");
+    });
+
 });
 
 function normalize_map(map){

From 6bbb70fe0ab42b67be319f44fc9631624c10970b Mon Sep 17 00:00:00 2001
From: Nick Chomey <nick_chomey@hotmail.com>
Date: Wed, 4 Mar 2026 06:53:58 -0600
Subject: [PATCH 9/9] Move serialize config type defs to type.js and simplify
 field config copy

fix Closure Compiler advanced mode tests
replace bracket notation with @export and fix bundle debug warnings
---
 src/bundle.js    |  41 +++++++++++++
 src/document.js  |   8 ++-
 src/serialize.js | 147 +++++++++++++++++++++++++++--------------------
 src/type.js      |  52 +++++++++++++++++
 4 files changed, 186 insertions(+), 62 deletions(-)

diff --git a/src/bundle.js b/src/bundle.js
index 21c22335..cdfade63 100644
--- a/src/bundle.js
+++ b/src/bundle.js
@@ -13,6 +13,10 @@ import {
 import {
     SearchOptions,
     ContextOptions,
+    SerializedIndexContext,
+    SerializedIndexConfig,
+    SerializedFieldConfig,
+    SerializedDocumentConfig,
     DocumentDescriptor,
     DocumentSearchOptions,
     FieldOptions,
@@ -68,6 +72,11 @@ if(SUPPORT_SERIALIZE || SUPPORT_PERSISTENT){
 /** @export */ Index.prototype.reg;
 /** @export */ Index.prototype.map;
 /** @export */ Index.prototype.ctx;
+/** @export */ Index.prototype.resolution_ctx;
+}
+
+if (SUPPORT_SERIALIZE) {
+/** @export */ Index.prototype._encoderOpt;
 }
 
 if(SUPPORT_PERSISTENT){
@@ -124,6 +133,10 @@ if(SUPPORT_SERIALIZE){
 /** @export */ Document.prototype.tag;
 /** @export */ Document.prototype.store;
 /** @export */ Document.prototype.fastupdate;
+/** @export */ Document.prototype._cfgKey;
+/** @export */ Document.prototype.tree;
+/** @export */ Document.prototype.tagtree;
+/** @export */ Document.prototype.tagfield;
 }
 
 /** @export */ Resolver.prototype.limit;
@@ -234,6 +247,34 @@ if(SUPPORT_SERIALIZE){
 /** @export */ ContextOptions.bidirectional;
 /** @export */ ContextOptions.resolution;
 
+/** @export */ SerializedIndexContext.depth;
+/** @export */ SerializedIndexContext.bidirectional;
+/** @export */ SerializedIndexContext.resolution;
+
+/** @export */ SerializedIndexConfig.tokenize;
+/** @export */ SerializedIndexConfig.resolution;
+/** @export */ SerializedIndexConfig.context;
+/** @export */ SerializedIndexConfig.rtl;
+/** @export */ SerializedIndexConfig.encoder;
+/** @export */ SerializedIndexConfig.score;
+/** @export */ SerializedIndexConfig.priority;
+/** @export */ SerializedIndexConfig.keystore;
+
+/** @export */ SerializedFieldConfig.field;
+/** @export */ SerializedFieldConfig.tokenize;
+/** @export */ SerializedFieldConfig.resolution;
+/** @export */ SerializedFieldConfig.context;
+/** @export */ SerializedFieldConfig.rtl;
+/** @export */ SerializedFieldConfig.encoder;
+/** @export */ SerializedFieldConfig.score;
+/** @export */ SerializedFieldConfig.priority;
+/** @export */ SerializedFieldConfig.keystore;
+
+/** @export */ SerializedDocumentConfig.id;
+/** @export */ SerializedDocumentConfig.fields;
+/** @export */ SerializedDocumentConfig.tagfields;
+/** @export */ SerializedDocumentConfig.store;
+
 /** @export */ DocumentDescriptor.field;
 /** @export */ DocumentDescriptor.index;
 /** @export */ DocumentDescriptor.tag;
diff --git a/src/document.js b/src/document.js
index 4168a6a3..bc97220d 100644
--- a/src/document.js
+++ b/src/document.js
@@ -63,10 +63,14 @@ export default function Document(options){
     let tmp, keystore;
 
     this.tree = [];
+    // Keep stable public property names for bundled/minified builds.
+    this["tree"] = this.tree;
     this.field = [];
     this.marker = [];
     this.key = ((tmp = document.key || document.id) && parse_tree(tmp, this.marker)) || "id";
-    if(SUPPORT_SERIALIZE) this._cfgKey = document.key || document.id || null;
+    if(SUPPORT_SERIALIZE){
+        this._cfgKey = document.key || document.id || null;
+    }
 
     keystore = SUPPORT_KEYSTORE && (options.keystore || 0);
     keystore && (this.keystore = keystore);
@@ -124,6 +128,8 @@ export default function Document(options){
                 this.tag = new Map();
                 this.tagtree = [];
                 this.tagfield = [];
+                this["tagtree"] = this.tagtree;
+                this["tagfield"] = this.tagfield;
                 for(let i = 0, params, field; i < tmp.length; i++){
                     params = tmp[i];
                     field = params.field || params;
diff --git a/src/serialize.js b/src/serialize.js
index 2eb0e52c..fcf1249c 100644
--- a/src/serialize.js
+++ b/src/serialize.js
@@ -13,6 +13,7 @@ import { IntermediateSearchResults } from "./type.js";
 // <-- COMPILER BLOCK
 import Index from "./index.js";
 import Document from "./document.js";
+import WorkerIndex from "./worker.js";
 import Charset from "./charset.js";
 import Encoder from "./encoder.js";
 import { KeystoreMap, KeystoreSet } from "./keystore.js";
@@ -22,6 +23,12 @@ const chunk_size_reg = 250000;
 const chunk_size_map = 5000;
 const chunk_size_ctx = 1000;
 
+// Runtime config records used for Closure @export protection in bundle builds.
+/** @constructor */ export function IndexContextRecord(){}
+/** @constructor */ export function IndexConfigRecord(){}
+/** @constructor */ export function FieldConfigRecord(){}
+/** @constructor */ export function DocumentConfigRecord(){}
+
 /**
  * Escape a string for safe embedding in a JS string literal.
  * Handles backslash, double-quote, single-quote, newlines, and other control chars.
@@ -196,7 +203,7 @@ function serialize_encoder_to_js(encoderOpt, charsetRef){
 
 /**
  * Build an Index config as a JS object literal string.
- * @param {Index} index
+ * @param {Index|WorkerIndex} index
  * @param {string} charsetRef
  * @return {string}
  */
@@ -229,26 +236,28 @@ function index_config_to_js(index, charsetRef){
 
 /**
  * Build an Index config as a plain object for JSON export.
- * @param {Index} index
- * @return {Object}
+ * @param {Index|WorkerIndex} index
+ * @return {IndexConfigRecord}
  */
 function index_config_to_obj(index){
-    const cfg = {};
-    if(index.tokenize && index.tokenize !== "strict") cfg.tokenize = index.tokenize;
-    if(index.resolution !== 9) cfg.resolution = index.resolution;
+    const cfg = new IndexConfigRecord();
+    if (index.tokenize && index.tokenize !== "strict") cfg.tokenize = index.tokenize;
+    if (index.resolution !== 9) cfg.resolution = index.resolution;
     if(index.depth){
-        cfg.context = { depth: index.depth };
-        if(!index.bidirectional) cfg.context.bidirectional = false;
-        if(index.resolution_ctx !== 3) cfg.context.resolution = index.resolution_ctx;
+        const ctx = new IndexContextRecord();
+        ctx.depth = index.depth;
+        if (!index.bidirectional) ctx.bidirectional = false;
+        if (index.resolution_ctx !== 3) ctx.resolution = index.resolution_ctx;
+        cfg.context = ctx;
     }
-    if(index.rtl) cfg.rtl = true;
+    if (index.rtl) cfg.rtl = true;
     if(SUPPORT_SERIALIZE && index._encoderOpt){
         const str = serialize_encoder_to_str(index._encoderOpt);
-        if(str) cfg.encoder = str;
+        if (str) cfg.encoder = str;
     }
-    if(index.score) cfg.score = index.score.toString();
-    if(SUPPORT_ASYNC && index.priority && index.priority !== 4) cfg.priority = index.priority;
-    if(SUPPORT_KEYSTORE && index.keystore) cfg.keystore = index.keystore;
+    if (index.score) cfg.score = index.score.toString();
+    if (SUPPORT_ASYNC && index.priority && index.priority !== 4) cfg.priority = index.priority;
+    if (SUPPORT_KEYSTORE && index.keystore) cfg.keystore = index.keystore;
     return cfg;
 }
 
@@ -283,17 +292,17 @@ function document_config_to_js(doc, charsetRef){
 /**
  * Build a Document config as a plain object for JSON export.
  * @param {Document} doc
- * @return {Object}
+ * @return {DocumentConfigRecord}
  */
 function document_config_to_export_obj(doc){
-    const cfg = {
-        id: (SUPPORT_SERIALIZE && doc._cfgKey) || doc.key || "id",
-        fields: []
-    };
+    const cfg = new DocumentConfigRecord();
+    cfg.id = (SUPPORT_SERIALIZE && doc._cfgKey) || doc.key || "id";
+    cfg.fields = [];
     for(let i = 0; i < doc.field.length; i++){
         const fieldName = doc.field[i];
         const fieldIdx = doc.index.get(fieldName);
-        const fieldCfg = { field: fieldName };
+        const fieldCfg = new FieldConfigRecord();
+        fieldCfg.field = fieldName;
         if(fieldIdx){
             Object.assign(fieldCfg, index_config_to_obj(fieldIdx));
         }
@@ -302,25 +311,25 @@ function document_config_to_export_obj(doc){
     if(SUPPORT_TAGS && doc.tagfield && doc.tagfield.length){
         cfg.tagfields = doc.tagfield.slice();
     }
-    if(SUPPORT_STORE && doc.store !== null) cfg.store = true;
+    if (SUPPORT_STORE && doc.store !== null) cfg.store = true;
     return cfg;
 }
 
 /**
  * Apply a serialized config object to an Index instance.
  * @param {Index} index
- * @param {Object} cfg
+ * @param {IndexConfigRecord|FieldConfigRecord|Object} cfg
  */
 function apply_index_cfg(index, cfg){
-    if(cfg.tokenize) index.tokenize = cfg.tokenize;
-    if(cfg.resolution !== undefined) index.resolution = cfg.resolution;
-    if(cfg.context){
+    if (cfg.tokenize) index.tokenize = cfg.tokenize;
+    if (cfg.resolution !== undefined) index.resolution = cfg.resolution;
+    if (cfg.context) {
         index.depth = cfg.context.depth || 0;
-        if(cfg.context.bidirectional !== undefined) index.bidirectional = cfg.context.bidirectional;
-        if(cfg.context.resolution !== undefined) index.resolution_ctx = cfg.context.resolution;
+        if (cfg.context.bidirectional !== undefined) index.bidirectional = cfg.context.bidirectional;
+        if (cfg.context.resolution !== undefined) index.resolution_ctx = cfg.context.resolution;
     }
-    if(cfg.rtl !== undefined) index.rtl = cfg.rtl;
-    if(cfg.encoder){
+    if (cfg.rtl !== undefined) index.rtl = cfg.rtl;
+    if (cfg.encoder) {
         let encoderOpt;
         const encoderStr = cfg.encoder;
         if(typeof encoderStr === "string" && SUPPORT_CHARSET && Charset[encoderStr]){
@@ -334,17 +343,17 @@ function apply_index_cfg(index, cfg){
                 : (SUPPORT_ENCODER && typeof encoderOpt === "object"
                     ? new Encoder(encoderOpt)
                     : { encode: encoderOpt });
-            if(SUPPORT_SERIALIZE) index._encoderOpt = cfg.encoder;
+            if (SUPPORT_SERIALIZE) index._encoderOpt = cfg.encoder;
         }
     }
-    if(cfg.score && typeof cfg.score === "string"){
+    if (cfg.score && typeof cfg.score === "string") {
         try {
             const scoreFn = new Function("return (" + cfg.score + ")")();
             if(typeof scoreFn === "function") index.score = scoreFn;
         } catch(e){}
     }
-    if(SUPPORT_ASYNC && cfg.priority !== undefined) index.priority = cfg.priority;
-    if(SUPPORT_KEYSTORE && cfg.keystore){
+    if (SUPPORT_ASYNC && cfg.priority !== undefined) index.priority = cfg.priority;
+    if (SUPPORT_KEYSTORE && cfg.keystore) {
         const ks = cfg.keystore;
         index.keystore = ks;
         // Replace empty map/ctx with Keystore variants (populated in subsequent imports)
@@ -357,12 +366,12 @@ function apply_index_cfg(index, cfg){
  * Apply a serialized config object to a Document instance.
  * Initializes fields/tags/store only when the document has no data yet.
  * @param {Document} doc
- * @param {Object} cfg
+ * @param {DocumentConfigRecord|Object} cfg
  */
 function apply_document_cfg(doc, cfg){
-    if(cfg.id || cfg.key) doc.key = cfg.id || cfg.key;
-    if(!doc.field.length && cfg.fields && cfg.fields.length){
-        for(let i = 0; i < cfg.fields.length; i++){
+    if (cfg.id || cfg.key) doc.key = cfg.id || cfg.key;
+    if (!doc.field.length && cfg.fields && cfg.fields.length) {
+        for (let i = 0; i < cfg.fields.length; i++) {
             const fc = cfg.fields[i];
             // Support both old format (string) and new format (object with .field)
             const fieldName = typeof fc === "string" ? fc : fc.field;
@@ -377,24 +386,24 @@ function apply_document_cfg(doc, cfg){
             }
         }
     }
-    if(SUPPORT_TAGS && cfg.tagfields && cfg.tagfields.length && !doc.tag){
+    if (SUPPORT_TAGS && cfg.tagfields && cfg.tagfields.length && !doc.tag) {
         if(!doc.tagtree) doc.tagtree = [];
         doc.tag = new Map();
         doc.tagfield = cfg.tagfields;
-        for(let i = 0; i < cfg.tagfields.length; i++){
+        for (let i = 0; i < cfg.tagfields.length; i++) {
             const parts = cfg.tagfields[i].split(":");
             doc.tagtree[i] = parts.length > 1 ? parts : parts[0];
             doc.tag.set(cfg.tagfields[i], new Map());
         }
     }
-    if(SUPPORT_STORE && cfg.store && !doc.store){
+    if (SUPPORT_STORE && cfg.store && !doc.store) {
         doc.store = new Map();
     }
 }
 
 /**
  *
- * @param {function(string, string):Promise|void} callback
+ * @param {function(string, (string|Array<Object>|Object)):Promise|void} callback
  * @param {string|null|void} field
  * @param {string} key
  * @param {Array|null} chunk
@@ -452,7 +461,7 @@ function save(callback, field, key, chunk, index_doc, index_obj, index_prt = 0,
 }
 
 /**
- * @param {function(string,string):Promise|void} callback
+ * @param {function(string,(string|Array<Object>|Object)):Promise|void} callback
  * @param {!string|null=} _field
  * @param {number=} _index_doc
  * @param {number=} _index_obj
@@ -508,8 +517,8 @@ export function exportIndex(callback, _field, _index_doc = 0, _index_obj = 0, _r
 }
 
 /**
- * @param {string} key
- * @param {string|Array<Object>=} data
+ * @param {string|Map<string,(string|Array<Object>|Object)>|Array<Array<*>>} key
+ * @param {string|Array<Object>|Object=} data
  * @this Index
  */
 
@@ -555,18 +564,18 @@ export function importIndex(key, data){
 
         case "map":
 
-            this.map = json_to_map(data, this.map);
+            this.map = json_to_map(/** @type {Array<(Object|null)>} */(data), this.map);
             break;
 
         case "ctx":
 
-            this.ctx = json_to_ctx(data, this.ctx);
+            this.ctx = json_to_ctx(/** @type {Array<(Object|null)>} */(data), this.ctx);
             break;
     }
 }
 
 /**
- * @param {function(string,string):Promise|void} callback
+ * @param {function(string,(string|Array<Object>|Object)):Promise|void} callback
  * @param {string|null=} _field
  * @param {number=} _index_doc
  * @param {number=} _index_obj
@@ -651,8 +660,8 @@ export function exportDocument(callback, _field, _index_doc = -1, _index_obj = 0
 }
 
 /**
- * @param {!string} key
- * @param {string|Array<Object>} data
+ * @param {string|Map<string,(string|Array<Object>|Object)>|Array<Array<*>>} key
+ * @param {string|Array<Object>|Object=} data
  * @this {Document}
  */
 
@@ -722,12 +731,12 @@ export function importDocument(key, data){
 
             case "tag":
 
-                this.tag = json_to_ctx(data, this.tag);
+                this.tag = json_to_ctx(/** @type {Array<(Object|null)>} */(data), this.tag);
                 break;
 
             case "doc":
 
-                this.store = json_to_map(data, this.store);
+                this.store = json_to_map(/** @type {Array<(Object|null)>} */(data), this.store);
                 break;
 
             case "cfg":
@@ -827,10 +836,10 @@ function parse_map(map, type){
 /**
  * Helper: Serialize a Map<tagValue, Array<ID>> for tags
  * @param {Map} tagMap - inner map: tagValue → Array<ID>
- * @param {string} type - "string" or "number"
+ * @param {string=} type - "string" or "number"
  * @return {string}
  */
-function parse_tag_map(tagMap, type){
+function parse_tag_map(tagMap, type = "string") {
     let result = '';
     for(const item of tagMap.entries()){
         const key = item[0];   // tag value (e.g., "1894")
@@ -960,6 +969,7 @@ export async function exportIndexBulk(compressed = false){
     const map = new Map();
     await exportIndex.call(this, (key, data) => {
         map.set(key, data);
+        return null;
     }, null, 0, 0, true);  // _raw = true
     const json = JSON.stringify([...map]);
     return compressed ? compress(json) : json;
@@ -976,6 +986,7 @@ export async function exportDocumentBulk(compressed = false){
     const map = new Map();
     await exportDocument.call(this, (key, data) => {
         map.set(key, data);
+        return null;
     }, null, -1, 0, true);  // _raw = true
     const json = JSON.stringify([...map]);
     return compressed ? compress(json) : json;
@@ -983,37 +994,51 @@ export async function exportDocumentBulk(compressed = false){
 
 /**
  * Import bulk index data with optional gzip decompression
- * @param {Uint8Array|string} source - Bulk data (compressed as Uint8Array, or uncompressed as string)
+ * @param {Uint8Array|string|null} source - Bulk data (compressed as Uint8Array, or uncompressed as string)
  * @param {boolean=} compressed - Whether source is gzip compressed (default: false)
  * @this {Index}
  * @return {Promise<void>}
  */
 export async function importIndexBulk(source, compressed = false){
-    let json;
+    /** @type {string} */
+    let json = "";
     if(compressed){
-        json = await decompress(source);
+        if (typeof source === "string" || !source) {
+            throw new TypeError("Compressed import expects a Uint8Array source.");
+        }
+        json = /** @type {string} */ (await decompress(source));
     } else {
+        if (source === null) {
+            throw new TypeError("Import source must not be null.");
+        }
         json = typeof source === "string" ? source : new TextDecoder().decode(source);
     }
-    const entries = JSON.parse(json);
+    const entries = /** @type {Array<Array<*>>} */ (JSON.parse(json));
     return importIndex.call(this, entries);
 }
 
 /**
  * Import bulk document data with optional gzip decompression
- * @param {Uint8Array|string} source - Bulk data (compressed as Uint8Array, or uncompressed as string)
+ * @param {Uint8Array|string|null} source - Bulk data (compressed as Uint8Array, or uncompressed as string)
  * @param {boolean=} compressed - Whether source is gzip compressed (default: false)
  * @this {Document}
  * @return {Promise<void>}
  */
 export async function importDocumentBulk(source, compressed = false){
-    let json;
+    /** @type {string} */
+    let json = "";
     if(compressed){
-        json = await decompress(source);
+        if (typeof source === "string" || !source) {
+            throw new TypeError("Compressed import expects a Uint8Array source.");
+        }
+        json = /** @type {string} */ (await decompress(source));
     } else {
+        if (source === null) {
+            throw new TypeError("Import source must not be null.");
+        }
         json = typeof source === "string" ? source : new TextDecoder().decode(source);
     }
-    const entries = JSON.parse(json);
+    const entries = /** @type {Array<Array<*>>} */ (JSON.parse(json));
     return importDocument.call(this, entries);
 }
 
diff --git a/src/type.js b/src/type.js
index de1ebb21..8477511d 100644
--- a/src/type.js
+++ b/src/type.js
@@ -87,6 +87,58 @@ export let DocumentOptions = {};
  */
 export let ContextOptions = {};
 
+/**
+ * Internal: serialized Index context payload used by export/import.
+ * @typedef {{
+ *   depth: (number|undefined),
+ *   bidirectional: (boolean|undefined),
+ *   resolution: (number|undefined)
+ * }}
+ */
+export let SerializedIndexContext = {};
+
+/**
+ * Internal: serialized Index payload used by export/import.
+ * @typedef {{
+ *   tokenize: (string|undefined),
+ *   resolution: (number|undefined),
+ *   context: (SerializedIndexContext|undefined),
+ *   rtl: (boolean|undefined),
+ *   encoder: (string|undefined),
+ *   score: (string|undefined),
+ *   priority: (number|undefined),
+ *   keystore: (string|undefined)
+ * }}
+ */
+export let SerializedIndexConfig = {};
+
+/**
+ * Internal: serialized Document field payload used by export/import.
+ * @typedef {{
+ *   field: (string|undefined),
+ *   tokenize: (string|undefined),
+ *   resolution: (number|undefined),
+ *   context: (SerializedIndexContext|undefined),
+ *   rtl: (boolean|undefined),
+ *   encoder: (string|undefined),
+ *   score: (string|undefined),
+ *   priority: (number|undefined),
+ *   keystore: (string|undefined)
+ * }}
+ */
+export let SerializedFieldConfig = {};
+
+/**
+ * Internal: serialized Document payload used by export/import.
+ * @typedef {{
+ *   id: (string|undefined),
+ *   fields: (Array<SerializedFieldConfig>|undefined),
+ *   tagfields: (Array<string>|undefined),
+ *   store: (boolean|undefined)
+ * }}
+ */
+export let SerializedDocumentConfig = {};
+
 /**
  * @typedef {{
  *   id: (string|undefined),