hlquery-node-client 1.0.6 → 1.0.7

package/README.md

@@ -16,13 +16,13 @@
 
 ### What is the hlquery Node.js API?
 
-The hlquery Node.js API is the official Node.js client for [hlquery](https://github.com/hlquery/hlquery). It wraps the REST interface in a modular service-style client with helpers for collections, documents, search, SQL, and SAM.
+The hlquery Node.js API is the official Node.js client for [hlquery](https://github.com/hlquery/hlquery). It wraps the REST interface in a modular service-style client with helpers for collections, documents, search, and SQL.
 
 It is a good fit for backend services, scripts, dashboards, and apps that want hlquery integration without repeating request code.
 
 ### Why use it?
 
-Use the Node.js client when you want hlquery calls to read like regular application code. The client is organized around familiar modules such as `client.collections()`, `client.documents()`, and `client.sam()`, with Redis-style dynamic route helpers for module APIs and custom endpoints.
+Use the Node.js client when you want hlquery calls to read like regular application code. The client is organized around familiar modules such as `client.collections()` and `client.documents()`, with Redis-style dynamic route helpers for module APIs and custom endpoints.
 
 It also keeps the repetitive parts in one place: authentication, request parameters, endpoint paths, and parsed responses are handled consistently across the client. Common hlquery workflows are covered by default, while raw request access is still available when you need a custom route.
 
@@ -88,6 +88,16 @@ const disconnect = await client.linksDisconnect('http://node-b:9200');
 const flush = await client.flush();
 ```
 
+Maintenance actions default to `POST`, and can explicitly use either server-supported method:
+
+```javascript
+await client.updateCounters({ force: true });
+await client.updateCounters({ force: true }, 'GET');
+await client.repair({}, 'POST');
+```
+
+The client also wraps readiness, startup, metrics, connection, storage, integrity, counter, user, key, module, and analytics routes through `client.system()`, `client.users()`, `client.keys()`, `client.modules()`, and `client.analytics()`.
+
 Routes that do not have a dedicated wrapper can still be called through `executeRequest()`:
 
 ```javascript
@@ -122,25 +132,43 @@ console.log(syntax.body);
 console.log(raw.body);
 ```
 
-### SAM
-
-SAM is separate from vector search. It performs term and intent-style lookup, not vector similarity search.
+### Collections, documents, and search
 
 ```javascript
-const sam = client.sam();
+const metadata = await client.collections().get('products');
+const language = await client.collections().language('products');
+
+// getFields() is a compatibility alias for collection metadata. The server has
+// no /collections/{name}/fields route.
+const metadataAgain = await client.collections().getFields('products');
+
+const context = await client.documents().context('products', 'prod_1');
+const facets = await client.documents().facetCounts('products', { facet_by: 'brand' });
+const exported = await client.documents().export('products', { filter_by: 'active:true' });
+const suggestions = await client.documents().maybe('products', { q: 'keybaord' });
 
-const status = await sam.status('books');
-const history = await sam.history('books', 5);
-const results = await sam.search('books', 'distributed systems', {
-  limit: 10
+await client.documents().updateByQuery('products', {
+  filter_by: 'active:false',
+  set: { archived: true }
 });
+await client.documents().deleteByQuery('products', { filter_by: 'expired:true' });
 
-/* Print the SAM status response body. */
-console.log(status.body);
-/* Print the SAM search history response body. */
-console.log(history.body);
-/* Print the SAM search results response body. */
-console.log(results.body);
+const searches = [{ collection: 'products', q: 'keyboard', query_by: 'title' }];
+await client.searchApi().multiSearch(searches);        // POST (default)
+await client.searchApi().multiSearch(searches, 'GET');
+await client.globalSearch({ collection: 'products', q: 'keyboard' });
+```
+
+Synonyms, overrides, and aliases expose separate `create()` (`POST`) and `update()` (`PUT`) helpers; `upsert()` uses the client's default upsert verb. Stopwords use their collection or global create/delete routes.
+
+### Request safety and errors
+
+`executeRequest()` accepts a relative path on the configured hlquery origin. Absolute cross-origin URLs are rejected with `RequestException` code `CROSS_ORIGIN_REQUEST`; this prevents credentials from being forwarded to another host. HTTP error bodies retain the server's `error`, optional `message`, numeric `code`, and stable `code_text` fields.
+
+Run the offline route-contract suite with:
+
+```bash
+npm test
 ```
 
 ### SQL
@@ -169,17 +197,19 @@ We welcome contributions from the community! All contributions must be released
 
 ### How to Contribute
 
-- Check existing [issues](https://github.com/hlquery/hlquery/issues) or create new ones
-- Contribute to client libraries (Node.js, Go, Java, Python, PHP, Ruby, Rust, Perl, C++)
-- Test and report bugs
-- Improve documentation
+- Check existing [Node.js API issues](https://github.com/hlquery/node-api/issues) or create new ones
+- Contribute Node.js client changes to [hlquery/node-api](https://github.com/hlquery/node-api)
+- Contribute shared server/API changes to [hlquery/hlquery](https://github.com/hlquery/hlquery)
+- Test and report bugs against the Node.js client
+- Improve Node.js-specific documentation and examples
 
 ### Community
 
-- 📖 [Documentation](https://docs.hlquery.com)
-- 🐦 [X (Twitter)](https://x.com/hlquery)
-- 📦 [GitHub](https://github.com/hlquery/hlquery)
+- [Documentation](https://docs.hlquery.com)
+- [X (Twitter)](https://x.com/hlquery)
+- [Node.js API GitHub](https://github.com/hlquery/node-api)
+- [hlquery GitHub](https://github.com/hlquery/hlquery)
 
 ### License
 
-hlquery is licensed under the [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause).
+The hlquery Node.js API is licensed under the [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause).

package/lib/Client.js

@@ -17,7 +17,6 @@ const Overrides = require('./Overrides');
 const Synonyms = require('./Synonyms');
 const Stopwords = require('./Stopwords');
 const System = require('./System');
-const SAM = require('./SAM');
 const Modules = require('./Modules');
 const Users = require('./Users');
 const Analytics = require('./Analytics');
@@ -55,7 +54,6 @@ class Client {
         this._synonyms = new Synonyms(this.request);
         this._stopwords = new Stopwords(this.request);
         this._system = new System(this.request);
-        this._sam = new SAM(this.request);
         this._modules = new Modules(this.request);
         this._users = new Users(this.request);
         this._analytics = new Analytics(this.request);
@@ -262,20 +260,16 @@ class Client {
         return await this._system.searchConfig();
     }
 
-    async llm() {
-        return await this._system.llm();
-    }
-
-    async updateCounters(params = {}) {
-        return await this._system.updateCounters(params);
+    async updateCounters(params = {}, method = 'POST') {
+        return await this._system.updateCounters(params, method);
     }
 
     async debugCounters() {
         return await this._system.debugCounters();
     }
 
-    async repair(params = {}) {
-        return await this._system.repair(params);
+    async repair(params = {}, method = 'POST') {
+        return await this._system.repair(params, method);
     }
 
     /**
@@ -305,7 +299,7 @@ class Client {
      * @returns {Promise<Response>}
      */
     async clusterHealth() {
-        return await this.request.execute('GET', '/cluster/health');
+        return await this._system.health();
     }
     
     /**
@@ -314,7 +308,7 @@ class Client {
      * @returns {Promise<Response>}
      */
     async clusterStats() {
-        return await this.request.execute('GET', '/cluster/stats');
+        return await this._system.stats();
     }
     
     /**
@@ -323,7 +317,7 @@ class Client {
      * @returns {Promise<Response>}
      */
     async clusterNodes() {
-        return await this.request.execute('GET', '/cluster/nodes');
+        return await this.links();
     }
 
     /**
@@ -618,71 +612,6 @@ class Client {
         return this._search;
     }
 
-    /**
-     * Get SAM API instance
-     *
-     * @returns {SAM}
-     */
-    sam() {
-        return this._sam;
-    }
-
-    async samSearch(collectionName, query, params = {}) {
-        return await this._sam.search(collectionName, query, params);
-    }
-
-    async samSearchAll(query, params = {}) {
-        return await this._sam.searchAll(query, params);
-    }
-
-    async samRebuild(collectionName, params = {}) {
-        return await this._sam.rebuild(collectionName, params);
-    }
-
-    async samStatus(collectionName = null, params = {}) {
-        return await this._sam.status(collectionName, params);
-    }
-
-    async samDebug(collectionName = null, params = {}) {
-        return await this._sam.debug(collectionName, params);
-    }
-
-    async samHistory(collectionName = null, limit = 100, params = {}) {
-        return await this._sam.history(collectionName, limit, params);
-    }
-
-    async samPause(pauseUntilMs, params = {}) {
-        return await this._sam.pause(pauseUntilMs, params);
-    }
-
-    async samClearPause(params = {}) {
-        return await this._sam.clearPause(params);
-    }
-
-    async samImprove(params = {}) {
-        return await this._sam.improve(params);
-    }
-
-    async samFlushActorMetadata() {
-        return await this._sam.flushActorMetadata();
-    }
-
-    async samDocuments(collectionName, offset = 0, limit = 20, params = {}) {
-        return await this._sam.listDocuments(collectionName, offset, limit, params);
-    }
-
-    async samDocument(collectionName, documentId, params = {}) {
-        return await this._sam.getDocument(collectionName, documentId, params);
-    }
-
-    async samOpenDocument(collectionName, documentId, interactionQuery = null, params = {}) {
-        return await this._sam.openDocument(collectionName, documentId, interactionQuery, params);
-    }
-
-    async samAddDocumentLabel(collectionName, documentId, labels) {
-        return await this._sam.addDocumentLabel(collectionName, documentId, labels);
-    }
-
     /**
      * Get aliases API instance
      *

package/lib/Request.js

@@ -58,7 +58,14 @@ class Request {
      * @throws {RequestException}
      */
     async execute(method, path, body = null, queryParams = {}, requestOptions = {}) {
-        const url = new URL(path, `${this.baseUrl}/`);
+        const baseUrl = new URL(`${this.baseUrl}/`);
+        const url = new URL(path, baseUrl);
+        if (url.origin !== baseUrl.origin) {
+            throw new RequestException('Request URL must use the configured server origin', 0, null, {
+                code: 'CROSS_ORIGIN_REQUEST',
+                retryable: false
+            });
+        }
         const signal = requestOptions.signal || this.signal;
         const maxResponseBytes = requestOptions.max_response_bytes || requestOptions.maxResponseBytes || this.maxResponseBytes;
         const throwOnError = requestOptions.throw_on_error !== undefined

package/lib/Search.js

@@ -218,10 +218,16 @@ class Search {
      * Multi-search across multiple collections
      * 
      * @param {Array} searches Array of search requests
+     * @param {string} method GET or POST
      * @returns {Promise<Response>}
      */
-    async multiSearch(searches) {
-        return await this.request.execute('POST', '/multi_search', { searches: searches });
+    async multiSearch(searches, method = 'POST') {
+        method = String(method).toUpperCase();
+        if (method !== 'GET' && method !== 'POST') {
+            throw new Error('Multi-search method must be GET or POST');
+        }
+
+        return await this.request.execute(method, '/multi_search', { searches: searches });
     }
 
     /**

package/lib/System.js

@@ -122,20 +122,26 @@ class System {
         return await this.request.execute('GET', '/search-config');
     }
 
-    async llm() {
-        return await this.request.execute('GET', '/llm');
-    }
-
-    async updateCounters(params = {}) {
-        return await this.request.execute('POST', '/update-counters', null, params);
+    async updateCounters(params = {}, method = 'POST') {
+        method = this._getOrPostMethod(method, 'Update counters');
+        return await this.request.execute(method, '/update-counters', null, params);
     }
 
     async debugCounters() {
         return await this.request.execute('GET', '/debug/counters');
     }
 
-    async repair(params = {}) {
-        return await this.request.execute('POST', '/repair', null, params);
+    async repair(params = {}, method = 'POST') {
+        method = this._getOrPostMethod(method, 'Repair');
+        return await this.request.execute(method, '/repair', null, params);
+    }
+
+    _getOrPostMethod(method, operation) {
+        method = String(method).toUpperCase();
+        if (method !== 'GET' && method !== 'POST') {
+            throw new Error(`${operation} method must be GET or POST`);
+        }
+        return method;
     }
 }
 

package/lib/conformance.js

@@ -26,9 +26,6 @@ const NODE_CLIENT_ROUTE_COVERAGE = [
     { path: '/consistency', methods: ['GET'], status: 'supported', client: 'system.consistency' },
     { path: '/self-check', methods: ['GET'], status: 'supported', client: 'system.selfCheck' },
     { path: '/admin/storage_status', methods: ['GET'], status: 'supported', client: 'system.storageStatus' },
-    { path: '/cluster/health', methods: ['GET'], status: 'supported', client: 'client.clusterHealth' },
-    { path: '/cluster/stats', methods: ['GET'], status: 'supported', client: 'client.clusterStats' },
-    { path: '/cluster/nodes', methods: ['GET'], status: 'supported', client: 'client.clusterNodes' },
     { path: '/links', methods: ['GET'], status: 'supported', client: 'client.links' },
     { path: '/links/ping', methods: ['GET'], status: 'supported', client: 'client.linksPing' },
     { path: '/links/connect', methods: ['POST'], status: 'supported', client: 'client.linksConnect' },
@@ -53,17 +50,6 @@ const NODE_CLIENT_ROUTE_COVERAGE = [
     { path: '/multi_search', methods: ['GET', 'POST'], status: 'supported', client: 'search.multiSearch' },
     { path: '/search', methods: ['GET', 'POST'], status: 'supported', client: 'search.globalSearch' },
     { path: '/sql', methods: ['GET', 'POST'], status: 'supported', client: 'system.sql/execSql' },
-    { path: '/sam/rebuild', methods: ['POST'], status: 'supported', client: 'sam.rebuild' },
-    { path: '/sam/search', methods: ['GET'], status: 'supported', client: 'sam.search' },
-    { path: '/sam/status', methods: ['GET'], status: 'supported', client: 'sam.status' },
-    { path: '/sam/debug', methods: ['GET'], status: 'supported', client: 'sam.debug' },
-    { path: '/sam/history', methods: ['GET'], status: 'supported', client: 'sam.history' },
-    { path: '/sam/pause', methods: ['POST'], status: 'supported', client: 'sam.pause/clearPause' },
-    { path: '/sam/improve', methods: ['POST'], status: 'supported', client: 'sam.improve' },
-    { path: '/sam/flush_actor_metadata', methods: ['POST'], status: 'supported', client: 'sam.flushActorMetadata' },
-    { path: '/sam/documents', methods: ['GET'], status: 'supported', client: 'sam.listDocuments' },
-    { path: '/sam/documents/{collection}/{id}', methods: ['GET'], status: 'supported', client: 'sam.getDocument/openDocument' },
-    { path: '/sam/label/add/{collection}/{id}', methods: ['POST'], status: 'supported', client: 'sam.addDocumentLabel' },
     { path: '/collections/{name}/documents/facet_counts', methods: ['GET', 'POST'], status: 'supported', client: 'documents.facetCounts' },
     { path: '/collections/{name}/documents/export', methods: ['GET', 'POST'], status: 'supported', client: 'documents.export' },
     { path: '/collections/{name}/synonyms', methods: ['GET'], status: 'supported', client: 'synonyms.list' },
@@ -90,7 +76,6 @@ const NODE_CLIENT_ROUTE_COVERAGE = [
     { path: '/query', methods: ['GET'], status: 'omitted', reason: 'Alias of /status; client exposes status() instead of duplicate naming.' },
     { path: '/search-config', methods: ['GET'], status: 'supported', client: 'system.searchConfig' },
     { path: '/ready', methods: ['GET'], status: 'supported', client: 'system.ready' },
-    { path: '/llm', methods: ['GET'], status: 'supported', client: 'system.llm' },
     { path: '/repair', methods: ['GET', 'POST'], status: 'supported', client: 'system.repair' },
     { path: '/modules', methods: ['GET'], status: 'supported', client: 'modules.list' },
     { path: '/modules/load', methods: ['POST'], status: 'omitted', reason: 'Prefix alias; modules.load(name) uses the explicit /loadmodule/{name} form.' },

package/package.json

@@ -1,34 +1,23 @@
 {
   "name": "hlquery-node-client",
-  "version": "1.0.6",
-  "description": "Node.js client library for hlquery search engine",
-  "main": "index.js",
-  "type": "commonjs",
+  "version": "1.0.7",
+  "description": "Node.js client for hlquery",
+  "main": "lib/Client.js",
   "scripts": {
-    "test": "node ../tests/test_node_client_conformance.js",
-    "test:conformance": "node ../tests/test_node_client_conformance.js",
-    "test:offline": "node test/offline-smoke.js",
-    "example": "node example.js",
-    "example:sql": "node examples/sql.js",
-    "example:pdf": "node examples/pdf.js",
-    "example:csv": "node examples/csv.js"
-  },
-  "dependencies": {
-    "pdf-parse": "^2.4.5"
+    "test": "node test/route-conformance.test.js",
+    "test:offline": "npm test"
   },
   "keywords": [
     "hlquery",
     "search",
-    "client",
-    "api"
+    "client"
   ],
   "author": "Carlos F. Ferry <carlos.ferry@gmail.com>",
   "license": "BSD-3-Clause",
+  "dependencies": {
+    "pdf-parse": "^2.4.5"
+  },
   "engines": {
     "node": ">=12.0.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/cferry/hlquery"
   }
 }

package/test/route-conformance.test.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const assert = require('assert');
+const Request = require('../lib/Request');
+const Search = require('../lib/Search');
+const System = require('../lib/System');
+const { NODE_CLIENT_ROUTE_COVERAGE } = require('../lib/conformance');
+
+class RecordingRequest {
+    constructor() {
+        this.calls = [];
+    }
+
+    async execute(method, path, body = null, query = {}) {
+        const call = { method, path, body, query };
+        this.calls.push(call);
+        return call;
+    }
+
+    last() {
+        return this.calls[this.calls.length - 1];
+    }
+}
+
+function route(path) {
+    const matches = NODE_CLIENT_ROUTE_COVERAGE.filter(entry => entry.path === path);
+    assert.strictEqual(matches.length, 1, `${path} must have exactly one conformance entry`);
+    return matches[0];
+}
+
+async function main() {
+    const routeKeys = new Set();
+    for (const entry of NODE_CLIENT_ROUTE_COVERAGE) {
+        assert.ok(entry.path.startsWith('/'), `route must be absolute-path scoped: ${entry.path}`);
+        assert.ok(Array.isArray(entry.methods) && entry.methods.length > 0, `route must declare methods: ${entry.path}`);
+        const key = `${entry.path}:${entry.methods.join(',')}`;
+        assert.ok(!routeKeys.has(key), `duplicate conformance route: ${key}`);
+        routeKeys.add(key);
+    }
+
+    const recorder = new RecordingRequest();
+    const search = new Search(recorder, null);
+    const system = new System(recorder);
+
+    assert.deepStrictEqual(route('/multi_search').methods, ['GET', 'POST']);
+    await search.multiSearch([], 'GET');
+    assert.deepStrictEqual(recorder.last(), {
+        method: 'GET', path: '/multi_search', body: { searches: [] }, query: {}
+    });
+    await search.multiSearch([], 'POST');
+    assert.strictEqual(recorder.last().method, 'POST');
+
+    for (const [path, invoke] of [
+        ['/update-counters', method => system.updateCounters({ force: 1 }, method)],
+        ['/repair', method => system.repair({ collection: 'books' }, method)]
+    ]) {
+        assert.deepStrictEqual(route(path).methods, ['GET', 'POST']);
+        await invoke('GET');
+        assert.strictEqual(recorder.last().method, 'GET');
+        assert.strictEqual(recorder.last().path, path);
+        await invoke('POST');
+        assert.strictEqual(recorder.last().method, 'POST');
+    }
+
+    const request = new Request('https://search.example.test', {
+        token: 'secret-token'
+    });
+    await assert.rejects(
+        request.execute('GET', 'https://attacker.example.test/collect'),
+        error => error && error.code === 'CROSS_ORIGIN_REQUEST'
+    );
+    await assert.rejects(
+        request.execute('GET', '//attacker.example.test/collect'),
+        error => error && error.code === 'CROSS_ORIGIN_REQUEST'
+    );
+
+    console.log(`route conformance passed (${NODE_CLIENT_ROUTE_COVERAGE.length} manifest entries)`);
+}
+
+main().catch(error => {
+    console.error(error);
+    process.exitCode = 1;
+});

package/examples/sam.js

@@ -1,39 +0,0 @@
-/**
- * Basic SAM example for the hlquery Node.js client.
- */
-
-const Client = require('../index');
-
-async function main() {
-    const baseUrl = process.env.HLQ_BASE_URL || process.env.HLQUERY_BASE_URL || 'http://localhost:9200';
-    const token = process.argv[2] || null;
-    const collection = process.argv[3] || 'music';
-    const query = process.argv[4] || 'queen of pop';
-
-    const client = new Client(baseUrl);
-
-    if (token) {
-        client.setAuthToken(token, 'bearer');
-    }
-
-    const sam = client.sam();
-
-    const status = await sam.status(collection);
-    console.log('=== SAM STATUS ===');
-    console.log(status.getBody());
-    console.log('');
-
-    const history = await sam.history(collection, 5);
-    console.log('=== SAM HISTORY ===');
-    console.log(history.getBody());
-    console.log('');
-
-    const results = await sam.search(collection, query, { limit: 10 });
-    console.log('=== SAM SEARCH ===');
-    console.log(results.getBody());
-}
-
-main().catch((error) => {
-    console.error(error);
-    process.exit(1);
-});

package/index.js

@@ -1,44 +0,0 @@
-/**
- * hlquery Node.js Client - Main Entry Point
- * 
- * Copyright (C) 2021-2026, Carlos F. Ferry <carlos.ferry@gmail.com>
- * 
- * This file is part of hlquery, released under the BSD License version 3.
- */
-
-const Client = require('./lib/Client');
-
-// Export main client class
-module.exports = Client;
-
-// Export all classes for advanced usage
-module.exports.Client = Client;
-module.exports.Request = require('./lib/Request');
-module.exports.Response = require('./lib/Response');
-module.exports.Collections = require('./lib/Collections');
-module.exports.Documents = require('./lib/Documents');
-module.exports.Search = require('./lib/Search');
-module.exports.Keys = require('./lib/Keys');
-module.exports.Aliases = require('./lib/Aliases');
-module.exports.Overrides = require('./lib/Overrides');
-module.exports.Synonyms = require('./lib/Synonyms');
-module.exports.Stopwords = require('./lib/Stopwords');
-module.exports.System = require('./lib/System');
-module.exports.SAM = require('./lib/SAM');
-module.exports.Modules = require('./lib/Modules');
-module.exports.Users = require('./lib/Users');
-module.exports.Analytics = require('./lib/Analytics');
-module.exports.Route = require('./lib/Route');
-
-// Export exceptions
-module.exports.Exceptions = require('./lib/Exceptions');
-
-// Export utilities
-module.exports.Utils = {
-    Config: require('./utils/Config'),
-    Validator: require('./utils/Validator'),
-    Auth: require('./utils/Auth'),
-    Ranker: require('./utils/ranker'),
-    PDFParser: require('./utils/PDFParser'),
-    CSVParser: require('./utils/CSVParser')
-};

package/lib/SAM.js

@@ -1,199 +0,0 @@
-/**
- * hlquery Node.js Client - SAM API
- *
- * Copyright (C) 2021-2026, Carlos F. Ferry <carlos.ferry@gmail.com>
- *
- * This file is part of hlquery, released under the BSD License version 3.
- */
-
-const Validator = require('../utils/Validator');
-
-/**
- * SAM API operations
- */
-class SAM {
-    constructor(request) {
-        this.request = request;
-    }
-
-    _validateParams(params, label) {
-        if (params === null || typeof params !== 'object' || Array.isArray(params)) {
-            throw new Error(`${label} must be an object`);
-        }
-    }
-
-    async search(collectionName, query, params = {}) {
-        if (typeof query !== 'string' || query.trim() === '') {
-            throw new Error('SAM query must be a non-empty string');
-        }
-
-        this._validateParams(params, 'SAM search params');
-
-        const queryParams = {
-            ...params,
-            q: query
-        };
-
-        if (collectionName !== null && collectionName !== undefined && collectionName !== '') {
-            Validator.validateCollectionName(collectionName);
-            queryParams.collection = collectionName;
-        } else if (!queryParams.all && !queryParams.collections) {
-            throw new Error('Collection name is required unless all=true or collections is provided');
-        }
-
-        return await this.request.execute('GET', '/sam/search', null, queryParams);
-    }
-
-    async searchAll(query, params = {}) {
-        this._validateParams(params, 'SAM search params');
-        return await this.search(null, query, { ...params, all: true });
-    }
-
-    async rebuild(collectionName, params = {}) {
-        Validator.validateCollectionName(collectionName);
-        this._validateParams(params, 'SAM rebuild params');
-
-        return await this.request.execute('POST', '/sam/rebuild', null, {
-            ...params,
-            collection: collectionName
-        });
-    }
-
-    async status(collectionName = null, params = {}) {
-        this._validateParams(params, 'SAM status params');
-
-        const queryParams = { ...params };
-
-        if (collectionName !== null && collectionName !== undefined && collectionName !== '') {
-            Validator.validateCollectionName(collectionName);
-            queryParams.collection = collectionName;
-        }
-
-        return await this.request.execute('GET', '/sam/status', null, queryParams);
-    }
-
-    async debug(collectionName = null, params = {}) {
-        this._validateParams(params, 'SAM debug params');
-
-        const queryParams = { ...params };
-
-        if (collectionName !== null && collectionName !== undefined && collectionName !== '') {
-            Validator.validateCollectionName(collectionName);
-            queryParams.collection = collectionName;
-        }
-
-        return await this.request.execute('GET', '/sam/debug', null, queryParams);
-    }
-
-    async history(collectionName = null, limit = 100, params = {}) {
-        this._validateParams(params, 'SAM history params');
-        const safeLimit = Number(limit);
-        if (!Number.isInteger(safeLimit) || safeLimit < 1) {
-            throw new Error('SAM history limit must be a positive integer');
-        }
-
-        const queryParams = {
-            ...params,
-            limit: safeLimit
-        };
-
-        if (collectionName !== null && collectionName !== undefined && collectionName !== '') {
-            Validator.validateCollectionName(collectionName);
-            queryParams.collection = collectionName;
-        }
-
-        return await this.request.execute('GET', '/sam/history', null, queryParams);
-    }
-
-    async pause(pauseUntilMs, params = {}) {
-        this._validateParams(params, 'SAM pause params');
-
-        const pause = Number(pauseUntilMs);
-        if (!Number.isFinite(pause) || pause < 0) {
-            throw new Error('SAM pause value must be a non-negative unix millisecond timestamp, or 0 to clear');
-        }
-
-        return await this.request.execute('POST', '/sam/pause', null, {
-            ...params,
-            pause
-        });
-    }
-
-    async clearPause(params = {}) {
-        return await this.pause(0, params);
-    }
-
-    async improve(params = {}) {
-        this._validateParams(params, 'SAM improve params');
-        return await this.request.execute('POST', '/sam/improve', null, params);
-    }
-
-    async flushActorMetadata() {
-        return await this.request.execute('POST', '/sam/flush_actor_metadata');
-    }
-
-    async listDocuments(collectionName, offset = 0, limit = 20, params = {}) {
-        Validator.validateCollectionName(collectionName);
-        this._validateParams(params, 'SAM document list params');
-        const safeOffset = Number(offset);
-        const safeLimit = Number(limit);
-
-        if (!Number.isInteger(safeOffset) || safeOffset < 0) {
-            throw new Error('SAM document offset must be a non-negative integer');
-        }
-        if (!Number.isInteger(safeLimit) || safeLimit < 1) {
-            throw new Error('SAM document limit must be a positive integer');
-        }
-
-        return await this.request.execute('GET', '/sam/documents', null, {
-            ...params,
-            collection: collectionName,
-            offset: safeOffset,
-            limit: safeLimit
-        });
-    }
-
-    async getDocument(collectionName, documentId, params = {}) {
-        Validator.validateCollectionName(collectionName);
-        Validator.validateDocumentId(documentId);
-        this._validateParams(params, 'SAM document params');
-
-        return await this.request.execute(
-            'GET',
-            `/sam/documents/${encodeURIComponent(collectionName)}/${encodeURIComponent(documentId)}`,
-            null,
-            params
-        );
-    }
-
-    async openDocument(collectionName, documentId, interactionQuery = null, params = {}) {
-        const queryParams = { ...params };
-
-        if (interactionQuery !== null && interactionQuery !== undefined && interactionQuery !== '') {
-            if (typeof interactionQuery !== 'string') {
-                throw new Error('SAM interaction query must be a string');
-            }
-            queryParams.interaction_query = interactionQuery;
-        }
-
-        return await this.getDocument(collectionName, documentId, queryParams);
-    }
-
-    async addDocumentLabel(collectionName, documentId, labels) {
-        Validator.validateCollectionName(collectionName);
-        Validator.validateDocumentId(documentId);
-
-        const normalizedLabels = Array.isArray(labels) ? labels : [labels];
-        if (normalizedLabels.length === 0 || normalizedLabels.some(label => typeof label !== 'string' || label.trim() === '')) {
-            throw new Error('SAM document labels must contain at least one non-empty string');
-        }
-
-        return await this.request.execute(
-            'POST',
-            `/sam/label/add/${encodeURIComponent(collectionName)}/${encodeURIComponent(documentId)}`,
-            { labels: normalizedLabels }
-        );
-    }
-}
-
-module.exports = SAM;

package/test/offline-smoke.js

@@ -1,455 +0,0 @@
-#!/usr/bin/env node
-
-const assert = require('assert');
-const http = require('http');
-
-const Hlquery = require('..');
-const Client = require('../lib/Client');
-const Collections = require('../lib/Collections');
-const Documents = require('../lib/Documents');
-const Aliases = require('../lib/Aliases');
-const Request = require('../lib/Request');
-const Response = require('../lib/Response');
-const SAM = require('../lib/SAM');
-const Search = require('../lib/Search');
-const System = require('../lib/System');
-const Modules = require('../lib/Modules');
-const Users = require('../lib/Users');
-const Analytics = require('../lib/Analytics');
-const Config = require('../utils/Config');
-const Validator = require('../utils/Validator');
-const CSVParser = require('../utils/CSVParser');
-
-async function main() {
-  assert.strictEqual(typeof Hlquery, 'function', 'default export should be the Client constructor');
-  assert.strictEqual(Hlquery.Client, Client, 'named Client export should match default export');
-
-  assert.strictEqual(Config.normalizeUrl('localhost:9200/'), 'http://localhost:9200');
-  assert.strictEqual(Config.normalizeUrl(new URL('http://localhost:9200///')), 'http://localhost:9200');
-  assert.strictEqual(Config.isValidUrl('http://localhost:9200'), true);
-  assert.strictEqual(Config.isValidUrl('http://'), false);
-  assert.strictEqual(Config.isValidUrl('notaurl'), false);
-
-  Validator.validateCollectionName('books');
-  Validator.validateDocumentId('doc_123');
-  Validator.validateDocumentId('doc/with space+plus');
-  Validator.validateSearchParams({ limit: 10, offset: 0 });
-  Validator.validateDocumentFields({ title: 'good,value' });
-
-  assert.throws(() => Validator.validateCollectionName('123bad'), /letter or underscore/);
-  assert.throws(() => Validator.validateSearchParams(null), /object/);
-  assert.throws(() => Validator.validateSearchParams({ limit: NaN }), /positive integer/);
-  assert.throws(() => Validator.validateSearchParams({ offset: 1.5 }), /non-negative integer/);
-  assert.throws(() => Validator.validateDocumentId('bad\nid'), /control characters/);
-  assert.throws(() => Validator.validateDocumentFields({ '': 'bad field' }), /field names/);
-  assert.throws(() => CSVParser.parseCSV('a||b', '||'), /single character/);
-
-  const response = new Response(200, { ok: true }, { 'content-type': 'application/json' }, {
-    statusMessage: 'OK',
-    rawBody: Buffer.from('{"ok":true}'),
-    request: { method: 'GET', url: 'http://localhost/health' }
-  });
-  assert.strictEqual(response.isSuccess(), true);
-  assert.deepStrictEqual(response.getBody(), { ok: true });
-  assert.strictEqual(response.getStatusMessage(), 'OK');
-  assert.strictEqual(response.getContentType(), 'application/json');
-  assert.strictEqual(response.getRawBody().toString(), '{"ok":true}');
-
-  const server = http.createServer((req, res) => {
-    if (req.url === '/health') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ status: 'ok' }));
-      return;
-    }
-
-    if (req.url === '/status') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ status: 'ready' }));
-      return;
-    }
-
-    if (req.url === '/etc') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ protocol: 'http' }));
-      return;
-    }
-
-    if (req.url === '/modules') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ modules: ['demo'] }));
-      return;
-    }
-
-    if (req.url === '/modules/demo/syntax') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ name: 'demo', syntax: 'demo <q>' }));
-      return;
-    }
-
-    if (req.url.startsWith('/modules/demo/search') && req.method === 'GET') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ module: 'demo', route: 'search', url: req.url }));
-      return;
-    }
-
-    if (req.url === '/modules/demo/index' && req.method === 'POST') {
-      let body = '';
-      req.on('data', chunk => {
-        body += chunk.toString();
-      });
-      req.on('end', () => {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ indexed: JSON.parse(body) }));
-      });
-      return;
-    }
-
-    if (req.url === '/links') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ links: [] }));
-      return;
-    }
-
-    if (req.url === '/links/ping') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ ok: true }));
-      return;
-    }
-
-    if (req.url === '/links/connect' && req.method === 'POST') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ connected: true }));
-      return;
-    }
-
-    if (req.url === '/links/disconnect' && req.method === 'POST') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ disconnected: true }));
-      return;
-    }
-
-    if (req.url === '/slow') {
-      setTimeout(() => {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ done: true }));
-      }, 100);
-      return;
-    }
-
-    if (req.url === '/large') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ data: 'x'.repeat(128) }));
-      return;
-    }
-
-    if (req.url === '/plain') {
-      res.writeHead(200, { 'Content-Type': 'text/plain' });
-      res.end('plain response');
-      return;
-    }
-
-    if (req.url === '/flush' && req.method === 'POST') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ flushed: true }));
-      return;
-    }
-
-    if (req.url.startsWith('/echo-auth')) {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        authorization: req.headers.authorization || null,
-        apiKey: req.headers['x-api-key'] || null,
-        contentType: req.headers['content-type'] || null,
-        url: req.url
-      }));
-      return;
-    }
-
-    if (req.url === '/keys/key%2Fwith%20space') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ id: 'key/with space' }));
-      return;
-    }
-
-    res.writeHead(404, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ error: 'not found' }));
-  });
-
-  await new Promise((resolve, reject) => {
-    server.listen(0, '127.0.0.1', (err) => (err ? reject(err) : resolve()));
-  });
-
-  const { port } = server.address();
-
-  try {
-    const request = new Request(`http://127.0.0.1:${port}`);
-    const health = await request.execute('GET', '/health');
-    assert.strictEqual(health.getStatusCode(), 200);
-    assert.deepStrictEqual(health.getBody(), { status: 'ok' });
-
-    request.setAuthToken('secret-token', 'bearer');
-    const bearerEcho = await request.execute('GET', '/echo-auth');
-    assert.strictEqual(bearerEcho.getBody().authorization, 'Bearer secret-token');
-
-    request.setAuthToken('scoped-key', 'api-key');
-    const apiKeyEcho = await request.execute('GET', '/echo-auth');
-    assert.strictEqual(apiKeyEcho.getBody().apiKey, 'scoped-key');
-
-    const queryEcho = await request.execute('GET', '/echo-auth', undefined, {
-      fields: ['title', 'body'],
-      filter: { published: true },
-      skip: null
-    });
-    assert.strictEqual(queryEcho.getBody().contentType, null);
-    assert.match(queryEcho.getBody().url, /fields=title%2Cbody/);
-    assert.match(queryEcho.getBody().url, /filter=%7B%22published%22%3Atrue%7D/);
-    assert.doesNotMatch(queryEcho.getBody().url, /skip=/);
-
-    const repeatedQueryEcho = await request.execute('GET', '/echo-auth', undefined, {
-      fields: ['title', 'body']
-    }, {
-      query_array_format: 'repeat'
-    });
-    assert.match(repeatedQueryEcho.getBody().url, /fields=title&fields=body/);
-
-    const plain = await request.execute('GET', '/plain');
-    assert.strictEqual(plain.isParsed(), false);
-    assert.strictEqual(plain.getBody(), 'plain response');
-    assert.strictEqual(plain.getRawBody().toString(), 'plain response');
-    assert.match(plain.getRequest().url, /\/plain$/);
-
-    await assert.rejects(
-      () => request.execute('GET', '/large', null, {}, { max_response_bytes: 32 }),
-      (error) => error.code === 'MAX_RESPONSE_BYTES' && error.statusCode === 200
-    );
-
-    await assert.rejects(
-      () => request.execute('GET', '/missing', null, {}, { throw_on_error: true }),
-      (error) => error.statusCode === 404 && error.response && error.response.getError() === 'not found'
-    );
-
-    const controller = typeof AbortController === 'function' ? new AbortController() : null;
-    if (controller) {
-      const aborted = request.execute('GET', '/slow', null, {}, { signal: controller.signal });
-      controller.abort();
-      await assert.rejects(aborted, (error) => error.code === 'ABORT_ERR');
-    }
-
-    const keepAliveAgent = new http.Agent({ keepAlive: true });
-    const agentRequest = new Request(`http://127.0.0.1:${port}`, {
-      http_agent: keepAliveAgent,
-      headers: { 'X-Test-Default': '1' }
-    });
-    const agentEcho = await agentRequest.execute('GET', '/echo-auth');
-    assert.strictEqual(agentEcho.getStatusCode(), 200);
-    keepAliveAgent.destroy();
-
-    const client = new Client(`http://127.0.0.1:${port}`);
-    const clientHealth = await client.health();
-    assert.strictEqual(clientHealth.isSuccess(), true);
-    assert.deepStrictEqual(clientHealth.getBody(), { status: 'ok' });
-
-    const clientStatus = await client.status();
-    assert.deepStrictEqual(clientStatus.getBody(), { status: 'ready' });
-
-    const clientEtc = await client.etc();
-    assert.deepStrictEqual(clientEtc.getBody(), { protocol: 'http' });
-
-    const routeEtc = await client.route('etc').get();
-    assert.deepStrictEqual(routeEtc.body, { protocol: 'http' });
-
-    const modulesList = await client.modules().list();
-    assert.deepStrictEqual(modulesList.body, { modules: ['demo'] });
-
-    const moduleSyntax = await client.modules().syntax('demo');
-    assert.deepStrictEqual(moduleSyntax.body, { name: 'demo', syntax: 'demo <q>' });
-
-    const moduleSearch = await client.module('demo').route('search').get({
-      q: 'example query'
-    });
-    assert.strictEqual(moduleSearch.body.module, 'demo');
-    assert.strictEqual(moduleSearch.body.route, 'search');
-    assert.match(moduleSearch.body.url, /q=example\+query|q=example%20query/);
-
-    const modulePost = await client.module('demo').route('index').post({
-      id: 'doc_1'
-    });
-    assert.deepStrictEqual(modulePost.body.indexed, { id: 'doc_1' });
-
-    const moduleCall = await client.modules().call('demo', 'search', 'GET', null, {
-      q: 'from call'
-    });
-    assert.match(moduleCall.body.url, /q=from\+call|q=from%20call/);
-
-    const clientLinks = await client.links();
-    assert.deepStrictEqual(clientLinks.getBody(), { links: [] });
-
-    const clientLinksPing = await client.linksPing();
-    assert.deepStrictEqual(clientLinksPing.getBody(), { ok: true });
-
-    const clientLinksConnect = await client.linksConnect('http://node-b:9200');
-    assert.deepStrictEqual(clientLinksConnect.getBody(), { connected: true });
-
-    const clientLinksDisconnect = await client.linksDisconnect('http://node-b:9200');
-    assert.deepStrictEqual(clientLinksDisconnect.getBody(), { disconnected: true });
-
-    const clientFlush = await client.flush();
-    assert.deepStrictEqual(clientFlush.getBody(), { flushed: true });
-
-    assert.strictEqual(typeof client.executeRequest, 'function');
-    assert.strictEqual(typeof client.sql, 'function');
-    assert.strictEqual(typeof client.execSql, 'function');
-    assert.strictEqual(typeof client.sqlSearch, 'function');
-    assert.strictEqual(typeof client.sam().search, 'function');
-    assert.strictEqual(typeof client.sam().searchAll, 'function');
-    assert.strictEqual(typeof client.sam().rebuild, 'function');
-    assert.strictEqual(typeof client.sam().status, 'function');
-    assert.strictEqual(typeof client.sam().debug, 'function');
-    assert.strictEqual(typeof client.sam().history, 'function');
-    assert.strictEqual(typeof client.sam().pause, 'function');
-    assert.strictEqual(typeof client.sam().clearPause, 'function');
-    assert.strictEqual(typeof client.sam().improve, 'function');
-    assert.strictEqual(typeof client.sam().flushActorMetadata, 'function');
-    assert.strictEqual(typeof client.sam().listDocuments, 'function');
-    assert.strictEqual(typeof client.sam().getDocument, 'function');
-    assert.strictEqual(typeof client.sam().openDocument, 'function');
-    assert.strictEqual(typeof client.sam().addDocumentLabel, 'function');
-    assert.strictEqual(typeof client.users().list, 'function');
-    assert.strictEqual(typeof client.analytics().click, 'function');
-    await assert.rejects(() => client.sam().history(null, 0), /positive integer/);
-    await assert.rejects(() => client.sam().listDocuments('books', NaN, 20), /non-negative integer/);
-
-    const keyResponse = await client.keys().get('key/with space');
-    assert.deepStrictEqual(keyResponse.getBody(), { id: 'key/with space' });
-    await assert.rejects(() => client.documents().import('books', { id: 'not-array' }), /array/);
-
-    const strictClient = new Client(`http://127.0.0.1:${port}`, { throw_on_error: true });
-    await assert.rejects(
-      () => strictClient.executeRequest('GET', '/missing'),
-      (error) => error.statusCode === 404 && error.response.getStatusCode() === 404
-    );
-
-    const fakeCollections = new Collections({
-      async execute(method, path, body) {
-        assert.strictEqual(body.name, 'books');
-        assert.strictEqual(body.extra, true);
-        return new Response(201, body);
-      }
-    });
-    const created = await fakeCollections.create('books', { name: 'books', extra: true });
-    assert.strictEqual(created.getBody().name, 'books');
-    await assert.rejects(() => fakeCollections.create('books', { name: 'other' }), /must match/);
-
-    const fieldsApi = new Collections({
-      async execute() {
-        return new Response(200, {
-          fields: [{ name: 'title', type: 'string' }],
-          searchable_fields: ['body'],
-          filterable_fields: ['author']
-        });
-      }
-    });
-    const fields = await fieldsApi.getFields('books');
-    assert.deepStrictEqual(fields.getBody().fields.map(field => field.name), ['title', 'body', 'author']);
-
-    const capturedRequests = [];
-    const captureRequest = {
-      async execute(method, path, body = null, queryParams = {}) {
-        capturedRequests.push({ method, path, body, queryParams });
-        return new Response(200, { ok: true });
-      }
-    };
-    const capturedCollections = new Collections(captureRequest);
-    const capturedDocuments = new Documents(captureRequest);
-    const capturedAliases = new Aliases(captureRequest);
-    const capturedSam = new SAM(captureRequest);
-    const capturedSystem = new System(captureRequest);
-    const capturedModules = new Modules(captureRequest);
-    const capturedUsers = new Users(captureRequest);
-    const capturedAnalytics = new Analytics(captureRequest);
-
-    await capturedCollections.language('books');
-    await capturedAliases.listCollection('books');
-    await capturedDocuments.context('books', 'doc/one');
-    await capturedDocuments.maybe('books', { q: 'bok' });
-    await capturedDocuments.updateByQuery('books', { filter_by: 'author:alice', update: { featured: true } });
-    await capturedDocuments.deleteByQuery('books', { filter_by: 'author:alice' });
-    await capturedSam.improve({ limit: 2, force: true });
-    await capturedSam.flushActorMetadata();
-    await capturedSam.addDocumentLabel('books', 'doc/one', ['featured']);
-    await capturedUsers.list();
-    await capturedUsers.get('alice smith');
-    await capturedUsers.create({ name: 'alice smith', flags: ['user'] });
-    await capturedUsers.update('alice smith', { description: 'Updated' });
-    await capturedUsers.delete('alice smith');
-    await capturedAnalytics.click({ collection: 'books', doc_id: 'doc/one', query: 'book', rank: 1 });
-    await capturedSystem.ready();
-    await capturedSystem.metricsHistory();
-    await capturedSystem.metricsHistoryAlias();
-    await capturedSystem.searchConfig();
-    await capturedSystem.llm();
-    await capturedSystem.updateCounters({ prefix: 'bench_' });
-    await capturedSystem.debugCounters();
-    await capturedSystem.repair({ collection: 'books', rebuild_index: true });
-    await capturedModules.load('demo');
-    await capturedModules.unload('demo');
-
-    assert.deepStrictEqual(capturedRequests, [
-      { method: 'GET', path: '/collections/books/lang', body: null, queryParams: {} },
-      { method: 'GET', path: '/collections/books/aliases', body: null, queryParams: {} },
-      { method: 'GET', path: '/collections/books/documents/doc%2Fone/context', body: null, queryParams: {} },
-      { method: 'GET', path: '/collections/books/documents/maybe', body: null, queryParams: { q: 'bok' } },
-      { method: 'POST', path: '/collections/books/documents/_update_by_query', body: { filter_by: 'author:alice', update: { featured: true } }, queryParams: {} },
-      { method: 'POST', path: '/collections/books/documents/_delete_by_query', body: { filter_by: 'author:alice' }, queryParams: {} },
-      { method: 'POST', path: '/sam/improve', body: null, queryParams: { limit: 2, force: true } },
-      { method: 'POST', path: '/sam/flush_actor_metadata', body: null, queryParams: {} },
-      { method: 'POST', path: '/sam/label/add/books/doc%2Fone', body: { labels: ['featured'] }, queryParams: {} },
-      { method: 'GET', path: '/users', body: null, queryParams: {} },
-      { method: 'GET', path: '/users/alice%20smith', body: null, queryParams: {} },
-      { method: 'POST', path: '/users', body: { name: 'alice smith', flags: ['user'] }, queryParams: {} },
-      { method: 'PUT', path: '/users/alice%20smith', body: { description: 'Updated' }, queryParams: {} },
-      { method: 'DELETE', path: '/users/alice%20smith', body: null, queryParams: {} },
-      { method: 'POST', path: '/analytics/click', body: { collection: 'books', doc_id: 'doc/one', query: 'book', rank: 1 }, queryParams: {} },
-      { method: 'GET', path: '/ready', body: null, queryParams: {} },
-      { method: 'GET', path: '/metrics/history', body: null, queryParams: {} },
-      { method: 'GET', path: '/metrics-history', body: null, queryParams: {} },
-      { method: 'GET', path: '/search-config', body: null, queryParams: {} },
-      { method: 'GET', path: '/llm', body: null, queryParams: {} },
-      { method: 'POST', path: '/update-counters', body: null, queryParams: { prefix: 'bench_' } },
-      { method: 'GET', path: '/debug/counters', body: null, queryParams: {} },
-      { method: 'POST', path: '/repair', body: null, queryParams: { collection: 'books', rebuild_index: true } },
-      { method: 'POST', path: '/loadmodule/demo', body: null, queryParams: {} },
-      { method: 'POST', path: '/unloadmodule/demo', body: null, queryParams: {} }
-    ]);
-
-    let collectionFetches = 0;
-    const searchApi = new Search({
-      async execute(method, path, body, queryParams) {
-        return new Response(200, { queryParams });
-      }
-    }, {
-      async get() {
-        collectionFetches += 1;
-        return new Response(200, { searchable_fields: ['title', 'body'] });
-      }
-    });
-    await searchApi.search('books', { q: 'one' });
-    await searchApi.search('books', { q: 'two' });
-    assert.strictEqual(collectionFetches, 1);
-
-    const noAutoDetect = await searchApi.search('books', {
-      q: 'three',
-      auto_detect_query_by: false
-    });
-    assert.strictEqual(noAutoDetect.getBody().queryParams.query_by, undefined);
-  } finally {
-    await new Promise((resolve) => server.close(resolve));
-  }
-
-  process.stdout.write('Node offline smoke tests passed.\n');
-}
-
-main().catch((error) => {
-  process.stderr.write(`${error.stack || error.message}\n`);
-  process.exit(1);
-});