@synapseone/sdk 0.0.0-stage → 0.7.0-dev.43

package/dist/services.test.js

@@ -0,0 +1,666 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * Copyright 2026 SynapseOne Contributors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * Offline tests for the split service SDKs — local mock gateway, no platform.
+ *
+ * Covers the base/faststore/queue namespaces, the typed BaseCollection
+ * object<->data mapping, tenant headers and the deprecated flat wrappers.
+ */
+const node_test_1 = require("node:test");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_http_1 = __importDefault(require("node:http"));
+const index_1 = require("./index");
+let base = '';
+let lastHeaders = {};
+let lastPath = '';
+let lastMethod = '';
+let lastBody = '';
+function payload(method, path, body) {
+    const p = path.split('?')[0];
+    if (method === 'GET' && (p === '/v1/base/collections' || p === '/v1/lds/licenses'))
+        return [];
+    if (method === 'GET' && p === '/v1/base/collections/parks/documents') {
+        return [{
+                id: 'd1',
+                data: { profile: { name: 'Central', capacity: 10 } },
+                version: 1,
+                createdAt: 't',
+                updatedAt: 't',
+            }];
+    }
+    if (method === 'GET' && p === '/v1/base/collections/parks/documents/d1') {
+        return {
+            id: 'd1',
+            object: { name: 'Central', capacity: 10 },
+            data: { profile: { name: 'Central', capacity: 10 } },
+            version: 3,
+            createdAt: 't',
+            updatedAt: 't',
+            collection: 'parks',
+        };
+    }
+    if (p.endsWith('/query')) {
+        return {
+            items: [{
+                    id: 'p1',
+                    version: 1,
+                    data: { profile: { name: 'Central', capacity: 10 } },
+                    object: { name: 'Central', capacity: 10 },
+                    createdAt: 't',
+                    updatedAt: 't',
+                }],
+            total: 1,
+            limit: 100,
+            offset: 0,
+            nextCursor: 'abc',
+        };
+    }
+    if (p.endsWith('/changes')) {
+        return { changes: [], nextSince: '2026-01-01T00:00:00.000Z', hasMore: false };
+    }
+    if (p.endsWith('/vector-search')) {
+        return {
+            items: [{
+                    id: 'p1',
+                    similarity: 0.99,
+                    distance: 0.01,
+                    version: 1,
+                    data: { profile: { name: 'Central', capacity: 10 } },
+                    object: { name: 'Central', capacity: 10 },
+                    createdAt: 't',
+                    updatedAt: 't',
+                }],
+            total: 1,
+            limit: 10,
+            metric: 'cosine',
+        };
+    }
+    if (method !== 'GET' && p.startsWith('/v1/base/collections/parks/documents') && !p.endsWith(':batch')) {
+        return {
+            id: 'p1',
+            data: { profile: { name: 'Central', capacity: 10 } },
+            version: 1,
+            createdAt: 't',
+            updatedAt: 't',
+        };
+    }
+    if (method === 'GET' && p === '/v1/faststore/keys') {
+        return { keys: [], cursor: null, truncated: false };
+    }
+    if (method === 'GET' && p.startsWith('/v1/faststore/keys/') && !p.endsWith('/ttl')) {
+        return { key: 'user:1', type: 'string', value: 'v', ttlSeconds: 60 };
+    }
+    if (p.endsWith('/ttl'))
+        return { key: 'user:1', ttlSeconds: 42 };
+    if (method === 'GET' && p === '/v1/queue/queues')
+        return [];
+    if (p.endsWith('/consume')) {
+        return {
+            queue: 'emails',
+            count: 1,
+            visibilityTimeoutSeconds: 30,
+            messages: [{
+                    id: 'm1',
+                    payload: { to: 'a@b.c' },
+                    attempts: 1,
+                    maxAttempts: 5,
+                    publishedAt: 't',
+                    receipt: 'r1',
+                    leaseExpiresAt: 't2',
+                }],
+        };
+    }
+    if (p.endsWith('/ack')) {
+        if (body && Array.isArray(body.receipts)) {
+            return {
+                queue: 'emails',
+                results: body.receipts.map((r) => ({ ok: true, receipt: r, id: 'm1' })),
+                ok: true,
+            };
+        }
+        return { ok: true, queue: 'emails', receipt: body?.receipt, id: 'm1' };
+    }
+    if (p.endsWith('/nack')) {
+        return { ok: true, queue: 'emails', id: 'm1', state: 'ready', attempts: 2 };
+    }
+    if (p.endsWith('/heartbeat')) {
+        return { ok: true, queue: 'emails', receipt: 'r1', leaseExpiresAt: 't3', visibilityTimeoutSeconds: 30 };
+    }
+    if (method === 'GET' && (p.endsWith('/messages') || p.endsWith('/dead'))) {
+        return { queue: 'emails', count: 0, messages: [] };
+    }
+    if (p.endsWith('/replay')) {
+        return { ok: true, queue: 'emails', message: { id: 'm1', attempts: 0 } };
+    }
+    return { ok: true };
+}
+(0, node_test_1.before)(() => new Promise((resolve) => {
+    const server = node_http_1.default.createServer((req, res) => {
+        lastHeaders = { ...req.headers };
+        lastPath = req.url || '';
+        lastMethod = req.method || '';
+        let raw = '';
+        req.on('data', (c) => (raw += c));
+        req.on('end', () => {
+            lastBody = raw;
+            let parsed;
+            try {
+                parsed = raw ? JSON.parse(raw) : undefined;
+            }
+            catch {
+                parsed = undefined;
+            }
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify(payload(req.method || '', req.url || '', parsed)));
+        });
+    });
+    server.listen(0, '127.0.0.1', () => {
+        const a = server.address();
+        base = `http://127.0.0.1:${typeof a === 'object' && a ? a.port : 0}`;
+        // Keep the server alive for the whole suite; node exits when tests end.
+        server.unref();
+        resolve();
+    });
+}));
+(0, node_test_1.after)(() => {
+    /* server is unref'd so the test runner can exit cleanly */
+});
+(0, node_test_1.describe)('service facade', () => {
+    (0, node_test_1.it)('exposes every service namespace and the baseUrl getter', () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: 'http://localhost:8080/' });
+        strict_1.default.equal(c.baseUrl, 'http://localhost:8080');
+        for (const name of ['iam', 'workflow', 'lds', 'base', 'faststore', 'queue']) {
+            strict_1.default.ok(c[name], name);
+        }
+        strict_1.default.ok(c.base.collection('parks') instanceof index_1.BaseCollection);
+    });
+    (0, node_test_1.it)('deprecated wrappers warn and forward to the service namespace', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        const messages = [];
+        const original = process.emitWarning;
+        process.emitWarning = (warning) => {
+            messages.push(typeof warning === 'string' ? warning : warning.message);
+        };
+        try {
+            await c.listTemplates();
+            strict_1.default.equal(lastPath, '/v1/templates');
+            await c.ldsLicenses();
+            strict_1.default.equal(lastPath, '/v1/lds/licenses');
+        }
+        finally {
+            process.emitWarning = original;
+        }
+        strict_1.default.ok(messages.some((m) => m.includes('client.workflow.listTemplates()')), String(messages));
+        strict_1.default.ok(messages.some((m) => m.includes('client.lds.licenses()')), String(messages));
+    });
+});
+(0, node_test_1.describe)('SynapseBase', () => {
+    (0, node_test_1.it)('collection lifecycle paths and bodies', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.base.createCollection({
+            name: 'parks',
+            description: 'city parks',
+            mapping: { name: 'profile.name' },
+        });
+        strict_1.default.equal(lastPath, '/v1/base/collections');
+        strict_1.default.equal(lastMethod, 'POST');
+        strict_1.default.deepEqual(JSON.parse(lastBody), {
+            name: 'parks',
+            description: 'city parks',
+            mapping: { name: 'profile.name' },
+        });
+        await c.base.updateCollection('parks', { name: 'parks2', description: null });
+        strict_1.default.equal(lastMethod, 'PATCH');
+        strict_1.default.equal(lastPath, '/v1/base/collections/parks');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { name: 'parks2', description: null });
+        await c.base.getCollection('parks');
+        strict_1.default.equal(lastPath, '/v1/base/collections/parks');
+        await c.base.collectionStats('parks');
+        strict_1.default.equal(lastPath, '/v1/base/collections/parks/stats');
+        await c.base.deleteCollection('parks');
+        strict_1.default.equal(lastMethod, 'DELETE');
+    });
+    (0, node_test_1.it)('documents accept exactly one of data or object', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.base.createDocument('parks', { object: { name: 'Central' }, id: 'p1' });
+        strict_1.default.equal(lastPath, '/v1/base/collections/parks/documents');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { object: { name: 'Central' }, id: 'p1' });
+        await c.base.createDocument('parks', { data: { profile: { name: 'Central' } } });
+        strict_1.default.deepEqual(JSON.parse(lastBody), { data: { profile: { name: 'Central' } } });
+        strict_1.default.throws(() => c.base.createDocument('parks', {}), /exactly one of data or object/);
+        strict_1.default.throws(() => c.base.createDocument('parks', { data: {}, object: {} }), /exactly one of data or object/);
+        await c.base.getDocument('parks', 'p1', { as: 'object' });
+        strict_1.default.equal(lastPath, '/v1/base/collections/parks/documents/p1?as=object');
+        await c.base.setDocument('parks', 'p1', { data: { a: 1 }, ifVersion: 2, merge: true });
+        strict_1.default.equal(lastMethod, 'PUT');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { data: { a: 1 }, ifVersion: 2, merge: true });
+        await c.base.updateDocument('parks', 'p1', {
+            data: { b: 2 },
+            unset: ['profile.old'],
+            ifVersion: 3,
+        });
+        strict_1.default.equal(lastMethod, 'PATCH');
+        strict_1.default.deepEqual(JSON.parse(lastBody), {
+            data: { b: 2 },
+            unset: ['profile.old'],
+            ifVersion: 3,
+        });
+        strict_1.default.throws(() => c.base.updateDocument('parks', 'p1', {}), /provide data\/object/);
+        await c.base.deleteDocument('parks', 'p1', { ifVersion: 2 });
+        strict_1.default.equal(lastPath, '/v1/base/collections/parks/documents/p1?ifVersion=2');
+        strict_1.default.equal(lastMethod, 'DELETE');
+    });
+    (0, node_test_1.it)('query, increment, batch and changes', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        const result = await c.base.queryDocuments('parks', {
+            where: { status: 'active' },
+            orderBy: [{ field: 'name', direction: 'desc' }],
+            limit: 10,
+            offset: 5,
+            select: ['name'],
+            as: 'object',
+        });
+        strict_1.default.equal(lastPath, '/v1/base/collections/parks/query');
+        strict_1.default.deepEqual(JSON.parse(lastBody), {
+            as: 'object',
+            where: { status: 'active' },
+            orderBy: [{ field: 'name', direction: 'desc' }],
+            limit: 10,
+            offset: 5,
+            select: ['name'],
+        });
+        strict_1.default.equal(result.total, 1);
+        strict_1.default.equal(result.nextCursor, 'abc');
+        await c.base.increment('parks', 'p1', { field: 'counter', by: 3, ifVersion: 2 });
+        strict_1.default.equal(lastPath, '/v1/base/collections/parks/documents/p1/increment');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { field: 'counter', by: 3, ifVersion: 2 });
+        const ops = [{ op: 'create', object: { name: 'x' } }];
+        await c.base.batch('parks', ops);
+        strict_1.default.equal(lastPath, '/v1/base/collections/parks/documents:batch');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { operations: ops });
+        const out = await c.base.changes('parks', {
+            since: '2026-01-01T00:00:00Z',
+            limit: 50,
+            as: 'object',
+        });
+        const changedPath = lastPath;
+        strict_1.default.ok(changedPath.startsWith('/v1/base/collections/parks/changes?'), changedPath);
+        strict_1.default.ok(changedPath.includes('since=2026-01-01T00%3A00%3A00Z'), changedPath);
+        strict_1.default.ok(changedPath.includes('limit=50'), changedPath);
+        strict_1.default.ok(changedPath.includes('as=object'), changedPath);
+        strict_1.default.equal(out.nextSince, '2026-01-01T00:00:00.000Z');
+        await c.base.listDocuments('parks', { limit: 10, offset: 20 });
+        strict_1.default.equal(lastPath, '/v1/base/collections/parks/documents?limit=10&offset=20');
+    });
+    (0, node_test_1.it)('mapping helpers project both directions', () => {
+        const data = { profile: { name: 'Central', capacity: 10 } };
+        const mapping = {
+            name: 'profile.name',
+            capacity: { path: 'profile.capacity', type: 'number' },
+        };
+        strict_1.default.deepEqual((0, index_1.dataToObject)(data, mapping), { name: 'Central', capacity: 10 });
+        strict_1.default.deepEqual((0, index_1.objectToData)({ name: 'Central' }, mapping), { profile: { name: 'Central' } });
+        strict_1.default.deepEqual((0, index_1.dataToObject)(data), data);
+        strict_1.default.deepEqual((0, index_1.objectToData)({ any: 1 }), { any: 1 });
+    });
+    (0, node_test_1.it)('typed BaseCollection converts models, writes objects and reads data', async () => {
+        class Park {
+            name;
+            capacity;
+            constructor(name, capacity) {
+                this.name = name;
+                this.capacity = capacity;
+            }
+        }
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        const col = c.base.collection('parks', {
+            model: (obj) => new Park(String(obj.name), Number(obj.capacity)),
+            mapping: { name: 'profile.name', capacity: 'profile.capacity' },
+        });
+        strict_1.default.deepEqual({ ...col.toObject(new Park('Central', 10)) }, { name: 'Central', capacity: 10 });
+        strict_1.default.deepEqual(col.fromObject({ name: 'Central', capacity: 10 }), new Park('Central', 10));
+        strict_1.default.deepEqual(col.fromData({ profile: { name: 'Central', capacity: 10 } }), new Park('Central', 10));
+        const created = await col.create(new Park('Central', 10), { id: 'p1' });
+        strict_1.default.deepEqual(JSON.parse(lastBody), {
+            object: { name: 'Central', capacity: 10 },
+            id: 'p1',
+        });
+        strict_1.default.deepEqual(created, new Park('Central', 10));
+        const fetched = await col.get('d1');
+        strict_1.default.equal(lastPath, '/v1/base/collections/parks/documents/d1?as=object');
+        strict_1.default.deepEqual(fetched, new Park('Central', 10));
+        const listed = await col.list({ limit: 5 });
+        strict_1.default.equal(lastPath, '/v1/base/collections/parks/documents?limit=5');
+        strict_1.default.deepEqual(listed, [new Park('Central', 10)]);
+        const queried = await col.query({ where: { name: 'Central' } });
+        strict_1.default.equal(JSON.parse(lastBody).as, 'object');
+        strict_1.default.deepEqual(queried.items, [new Park('Central', 10)]);
+        const updated = await col.update('d1', new Park('Central', 11), { unset: ['profile.old'] });
+        strict_1.default.deepEqual(JSON.parse(lastBody), {
+            object: { name: 'Central', capacity: 11 },
+            unset: ['profile.old'],
+        });
+        strict_1.default.deepEqual(updated, new Park('Central', 10));
+        strict_1.default.throws(() => col.create(), /exactly one of value or data/);
+        strict_1.default.throws(() => col.create(new Park('x', 1), { data: { name: 'x' } }), /exactly one of value or data/);
+        const raw = await col.getDocument('d1', 'data');
+        strict_1.default.equal(lastPath, '/v1/base/collections/parks/documents/d1?as=data');
+        strict_1.default.ok(raw.data);
+        const vsRes = await c.base.vectorSearch('parks', {
+            vector: [0.1, 0.2, 0.3],
+            limit: 5,
+            metric: 'cosine',
+            where: { name: 'Central' },
+        });
+        strict_1.default.equal(lastPath, '/v1/base/collections/parks/vector-search');
+        strict_1.default.equal(lastMethod, 'POST');
+        strict_1.default.deepEqual(JSON.parse(lastBody), {
+            vector: [0.1, 0.2, 0.3],
+            as: 'data',
+            limit: 5,
+            metric: 'cosine',
+            where: { name: 'Central' },
+        });
+        strict_1.default.equal(vsRes.items.length, 1);
+        strict_1.default.equal(vsRes.items[0].id, 'p1');
+        strict_1.default.equal(vsRes.items[0].similarity, 0.99);
+        const colVs = await col.vectorSearch({ vector: [0.1, 0.2, 0.3], limit: 5 });
+        strict_1.default.equal(colVs.items.length, 1);
+        strict_1.default.deepEqual(colVs.items[0].object, new Park('Central', 10));
+    });
+});
+(0, node_test_1.describe)('Synapse Faststore', () => {
+    (0, node_test_1.it)('key/value bodies and the tenant header', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        c.setTenant('acme');
+        await c.faststore.set('user:1', { a: 1 }, { ttlSeconds: 60, ifNotExists: true });
+        strict_1.default.equal(lastPath, '/v1/faststore/keys/user%3A1');
+        strict_1.default.equal(lastMethod, 'PUT');
+        strict_1.default.equal(lastHeaders['x-synapseone-tenant'], 'acme');
+        strict_1.default.deepEqual(JSON.parse(lastBody), {
+            value: { a: 1 },
+            ttlSeconds: 60,
+            ifNotExists: true,
+        });
+        const got = await c.faststore.get('user:1');
+        strict_1.default.equal(got.value, 'v');
+        await c.faststore.expire('user:1', 30);
+        strict_1.default.equal(lastPath, '/v1/faststore/keys/user%3A1/expire');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { ttlSeconds: 30 });
+        await c.faststore.incr('counter', { by: 2 });
+        strict_1.default.deepEqual(JSON.parse(lastBody), { by: 2 });
+        const ttl = await c.faststore.ttl('user:1');
+        strict_1.default.equal(ttl.ttlSeconds, 42);
+        await c.faststore.listKeys({ prefix: 'user:', limit: 5, cursor: '10' });
+        strict_1.default.equal(lastPath, '/v1/faststore/keys?prefix=user%3A&limit=5&cursor=10');
+        const ops = [{ op: 'set', key: 'a', value: 1 }];
+        await c.faststore.batch(ops);
+        strict_1.default.deepEqual(JSON.parse(lastBody), { operations: ops });
+        await c.faststore.delete('user:1');
+        strict_1.default.equal(lastMethod, 'DELETE');
+        c.setTenant(undefined);
+    });
+    (0, node_test_1.it)('collections and locks', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.faststore.hashSet('h1', { a: 1 }, { ttlSeconds: 10 });
+        strict_1.default.equal(lastPath, '/v1/faststore/hashes/h1');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { values: { a: 1 }, ttlSeconds: 10 });
+        await c.faststore.hashGetField('h1', 'a');
+        strict_1.default.equal(lastPath, '/v1/faststore/hashes/h1/a');
+        await c.faststore.hashIncr('h1', 'a', { by: 2 });
+        strict_1.default.equal(lastPath, '/v1/faststore/hashes/h1/incr');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { field: 'a', by: 2 });
+        await c.faststore.hashLength('h1');
+        strict_1.default.equal(lastPath, '/v1/faststore/hashes/h1/length');
+        await c.faststore.hashDeleteField('h1', 'a');
+        strict_1.default.equal(lastMethod, 'DELETE');
+        strict_1.default.equal(lastPath, '/v1/faststore/hashes/h1/a');
+        await c.faststore.listPush('l1', ['x', 'y'], { side: 'left' });
+        strict_1.default.deepEqual(JSON.parse(lastBody), { values: ['x', 'y'], side: 'left' });
+        await c.faststore.listPop('l1', { side: 'right', count: 2 });
+        strict_1.default.deepEqual(JSON.parse(lastBody), { side: 'right', count: 2 });
+        await c.faststore.listRange('l1', 0, -1);
+        strict_1.default.equal(lastPath, '/v1/faststore/lists/l1?start=0&stop=-1');
+        await c.faststore.listTrim('l1', 0, 9);
+        strict_1.default.deepEqual(JSON.parse(lastBody), { start: 0, stop: 9 });
+        await c.faststore.setAdd('s1', ['a'], { ttlSeconds: 5 });
+        strict_1.default.deepEqual(JSON.parse(lastBody), { members: ['a'], ttlSeconds: 5 });
+        await c.faststore.setContains('s1', 'a');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { member: 'a' });
+        await c.faststore.setRemove('s1', ['a']);
+        strict_1.default.deepEqual(JSON.parse(lastBody), { members: ['a'] });
+        await c.faststore.setCard('s1');
+        strict_1.default.equal(lastPath, '/v1/faststore/sets/s1/card');
+        await c.faststore.zsetAdd('z1', [{ member: 'a', score: 2 }]);
+        strict_1.default.deepEqual(JSON.parse(lastBody), { members: [{ member: 'a', score: 2 }] });
+        await c.faststore.zsetRange('z1', { start: 0, stop: -1, rev: true, withScores: true });
+        strict_1.default.equal(lastPath, '/v1/faststore/zsets/z1?start=0&stop=-1&rev=true&withScores=true');
+        await c.faststore.zsetIncr('z1', 'a', { by: 1.5 });
+        strict_1.default.deepEqual(JSON.parse(lastBody), { member: 'a', by: 1.5 });
+        await c.faststore.zsetRank('z1', 'a', { rev: true });
+        strict_1.default.deepEqual(JSON.parse(lastBody), { member: 'a', rev: true });
+        await c.faststore.lockAcquire('job', { ttlSeconds: 60, waitMs: 500, token: 'tok' });
+        strict_1.default.equal(lastPath, '/v1/faststore/locks/job/acquire');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { waitMs: 500, ttlSeconds: 60, token: 'tok' });
+        await c.faststore.lockExtend('job', 'tok', { ttlSeconds: 60 });
+        strict_1.default.deepEqual(JSON.parse(lastBody), { token: 'tok', ttlSeconds: 60 });
+        await c.faststore.lockRelease('job', 'tok');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { token: 'tok' });
+    });
+});
+(0, node_test_1.describe)('SynapseQueue', () => {
+    (0, node_test_1.it)('queue config and publish', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.queue.createQueue('emails', { maxAttempts: 7, visibilityTimeoutSeconds: 45 });
+        strict_1.default.equal(lastPath, '/v1/queue/queues/emails');
+        strict_1.default.equal(lastMethod, 'PUT');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { maxAttempts: 7, visibilityTimeoutSeconds: 45 });
+        await c.queue.listQueues();
+        strict_1.default.equal(lastPath, '/v1/queue/queues');
+        await c.queue.publish('emails', { to: 'a@b.c' }, {
+            delaySeconds: 30,
+            maxAttempts: 3,
+            headers: { trace: 't1' },
+            id: 'm1',
+            dedupeKey: 'welcome:a@b.c',
+        });
+        strict_1.default.equal(lastPath, '/v1/queue/queues/emails/messages');
+        strict_1.default.deepEqual(JSON.parse(lastBody), {
+            payload: { to: 'a@b.c' },
+            delaySeconds: 30,
+            maxAttempts: 3,
+            headers: { trace: 't1' },
+            id: 'm1',
+            dedupeKey: 'welcome:a@b.c',
+        });
+        const msgs = [{ payload: 1 }, { payload: 2, dedupeKey: 'k' }];
+        await c.queue.publishBatch('emails', msgs);
+        strict_1.default.equal(lastPath, '/v1/queue/queues/emails/messages:batch');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { messages: msgs });
+        await c.queue.queueStats('emails');
+        strict_1.default.equal(lastPath, '/v1/queue/queues/emails/stats');
+        await c.queue.purgeQueue('emails');
+        strict_1.default.equal(lastPath, '/v1/queue/queues/emails/purge');
+        await c.queue.deleteQueue('emails');
+        strict_1.default.equal(lastMethod, 'DELETE');
+    });
+    (0, node_test_1.it)('consume, ack, nack and heartbeat', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        const out = await c.queue.consume('emails', {
+            maxMessages: 5,
+            visibilityTimeoutSeconds: 20,
+            consumer: 'w1',
+        });
+        strict_1.default.equal(lastPath, '/v1/queue/queues/emails/consume');
+        strict_1.default.deepEqual(JSON.parse(lastBody), {
+            maxMessages: 5,
+            visibilityTimeoutSeconds: 20,
+            consumer: 'w1',
+        });
+        strict_1.default.equal(out.count, 1);
+        const receipt = out.messages[0].receipt;
+        strict_1.default.equal(receipt, 'r1');
+        await c.queue.ack('emails', receipt);
+        strict_1.default.deepEqual(JSON.parse(lastBody), { receipt: 'r1' });
+        await c.queue.ackMany('emails', ['r1', 'r2']);
+        strict_1.default.deepEqual(JSON.parse(lastBody), { receipts: ['r1', 'r2'] });
+        await c.queue.nack('emails', 'r1', { requeue: false, delaySeconds: 5, error: 'boom' });
+        strict_1.default.equal(lastPath, '/v1/queue/queues/emails/nack');
+        strict_1.default.deepEqual(JSON.parse(lastBody), {
+            receipt: 'r1',
+            requeue: false,
+            delaySeconds: 5,
+            error: 'boom',
+        });
+        await c.queue.heartbeat('emails', 'r1', { visibilityTimeoutSeconds: 60 });
+        strict_1.default.deepEqual(JSON.parse(lastBody), {
+            receipt: 'r1',
+            visibilityTimeoutSeconds: 60,
+        });
+    });
+    (0, node_test_1.it)('inspection and dead letters', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.queue.peek('emails', { limit: 10, ready: true });
+        strict_1.default.equal(lastPath, '/v1/queue/queues/emails/messages?limit=10&ready=true');
+        await c.queue.deadLetters('emails', { limit: 5 });
+        strict_1.default.equal(lastPath, '/v1/queue/queues/emails/dead?limit=5');
+        await c.queue.replayDead('emails', 'm1', { delaySeconds: 0, resetAttempts: true });
+        strict_1.default.equal(lastPath, '/v1/queue/queues/emails/dead/m1/replay');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { delaySeconds: 0, resetAttempts: true });
+        await c.queue.deleteDead('emails', 'm1');
+        strict_1.default.equal(lastMethod, 'DELETE');
+        strict_1.default.equal(lastPath, '/v1/queue/queues/emails/dead/m1');
+    });
+});
+(0, node_test_1.describe)('SynapseStream', () => {
+    (0, node_test_1.it)('topics, publish, read, consumer groups and range', async () => {
+        const c = new index_1.SynapseOneClient({ baseUrl: base });
+        await c.stream.createTopic('telemetry', { maxLen: 5000 });
+        strict_1.default.equal(lastPath, '/v1/stream/topics/telemetry');
+        strict_1.default.equal(lastMethod, 'PUT');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { maxLen: 5000 });
+        await c.stream.listTopics();
+        strict_1.default.equal(lastPath, '/v1/stream/topics');
+        await c.stream.getTopic('telemetry');
+        strict_1.default.equal(lastPath, '/v1/stream/topics/telemetry');
+        await c.stream.topicStats('telemetry');
+        strict_1.default.equal(lastPath, '/v1/stream/topics/telemetry/stats');
+        await c.stream.publish('telemetry', { temp: 24.5 }, { key: 's1' });
+        strict_1.default.equal(lastPath, '/v1/stream/topics/telemetry/events');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { payload: { temp: 24.5 }, key: 's1' });
+        await c.stream.publishBatch('telemetry', [{ payload: { a: 1 } }, { payload: { a: 2 } }]);
+        strict_1.default.equal(lastPath, '/v1/stream/topics/telemetry/events:batch');
+        await c.stream.read('telemetry', { fromId: '0-0', count: 10 });
+        strict_1.default.equal(lastPath, '/v1/stream/topics/telemetry/read');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { fromId: '0-0', count: 10 });
+        await c.stream.range('telemetry', { start: '0-0', end: '+', count: 5 });
+        strict_1.default.equal(lastPath, '/v1/stream/topics/telemetry/range?start=0-0&end=%2B&count=5');
+        await c.stream.createGroup('telemetry', 'workers', { startId: '$' });
+        strict_1.default.equal(lastPath, '/v1/stream/topics/telemetry/groups/workers');
+        strict_1.default.equal(lastMethod, 'PUT');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { startId: '$' });
+        await c.stream.readGroup('telemetry', 'workers', { consumer: 'w1', count: 5 });
+        strict_1.default.equal(lastPath, '/v1/stream/topics/telemetry/groups/workers/read');
+        await c.stream.ack('telemetry', 'workers', ['id-1', 'id-2']);
+        strict_1.default.equal(lastPath, '/v1/stream/topics/telemetry/groups/workers/ack');
+        strict_1.default.deepEqual(JSON.parse(lastBody), { ids: ['id-1', 'id-2'] });
+        await c.stream.destroyGroup('telemetry', 'workers');
+        strict_1.default.equal(lastPath, '/v1/stream/topics/telemetry/groups/workers');
+        strict_1.default.equal(lastMethod, 'DELETE');
+        await c.stream.deleteTopic('telemetry');
+        strict_1.default.equal(lastPath, '/v1/stream/topics/telemetry');
+        strict_1.default.equal(lastMethod, 'DELETE');
+    });
+});
+(0, node_test_1.describe)('Synapse Inference Engine', () => {
+    (0, node_test_1.it)('covers health, chat, embeddings, decision and routing paths', async () => {
+        const hits = [];
+        const server = node_http_1.default.createServer((req, res) => {
+            let raw = '';
+            req.on('data', (c) => { raw += c; });
+            req.on('end', () => {
+                hits.push({
+                    method: req.method || 'GET',
+                    path: req.url || '/',
+                    body: raw ? JSON.parse(raw) : null,
+                });
+                res.setHeader('Content-Type', 'application/json');
+                if (req.url === '/v1/inference/health') {
+                    res.end(JSON.stringify({ status: 'ok', service: 'inference' }));
+                }
+                else if (req.url === '/v1/inference/chat/completions') {
+                    res.end(JSON.stringify({ id: 'chat-1', choices: [{ message: { role: 'assistant', content: 'pong' } }] }));
+                }
+                else if (req.url === '/v1/inference/embeddings') {
+                    res.end(JSON.stringify({ object: 'list', data: [{ index: 0, embedding: [0.1, 0.2] }] }));
+                }
+                else if (req.url === '/v1/inference/decision') {
+                    res.end(JSON.stringify({ model: 'decision-0.8B', results: { team: { best_choice: 'support' } } }));
+                }
+                else if (req.url === '/v1/inference/decision/route') {
+                    res.end(JSON.stringify({ best_choice: 'workflow', confidence: 0.95 }));
+                }
+                else {
+                    res.statusCode = 404;
+                    res.end(JSON.stringify({ error: 'not_found' }));
+                }
+            });
+        });
+        await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+        const a = server.address();
+        const url = `http://127.0.0.1:${typeof a === 'object' && a ? a.port : 0}`;
+        try {
+            const c = new index_1.SynapseOneClient({ baseUrl: url });
+            const h = await c.inference.health();
+            strict_1.default.equal(h.service, 'inference');
+            const chat = await c.inference.chat([{ role: 'user', content: 'ping' }]);
+            strict_1.default.equal(chat.choices[0].message.content, 'pong');
+            const emb = await c.inference.embeddings('hello');
+            strict_1.default.equal(emb.data.length, 1);
+            const dec = await c.inference.decision('test state', { team: { type: 'choice', instructions: 'pick' } });
+            strict_1.default.equal(dec.results.team.best_choice, 'support');
+            const r = await c.inference.route('run workflow', { workflow: 'DAGs', iam: 'Users' });
+            strict_1.default.equal(r.best_choice, 'workflow');
+            strict_1.default.equal(hits.length, 5);
+            strict_1.default.equal(hits[0].path, '/v1/inference/health');
+            strict_1.default.equal(hits[1].path, '/v1/inference/chat/completions');
+            strict_1.default.equal(hits[2].path, '/v1/inference/embeddings');
+            strict_1.default.equal(hits[3].path, '/v1/inference/decision');
+            strict_1.default.equal(hits[4].path, '/v1/inference/decision/route');
+        }
+        finally {
+            await new Promise((resolve) => server.close(() => resolve()));
+        }
+    });
+});
+(0, node_test_1.describe)('error mapping', () => {
+    (0, node_test_1.it)('carries status and parsed body', async () => {
+        const server = node_http_1.default.createServer((_req, res) => {
+            res.statusCode = 404;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ error: 'boom' }));
+        });
+        await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+        const a = server.address();
+        const url = `http://127.0.0.1:${typeof a === 'object' && a ? a.port : 0}`;
+        try {
+            const c = new index_1.SynapseOneClient({ baseUrl: url });
+            await strict_1.default.rejects(() => c.base.getCollection('parks'), (err) => {
+                strict_1.default.ok(err instanceof index_1.SynapseOneError);
+                strict_1.default.equal(err.status, 404);
+                strict_1.default.deepEqual(err.body, { error: 'boom' });
+                strict_1.default.match(String(err.message), /synapseone 404/);
+                return true;
+            });
+            strict_1.default.equal(await c.faststore.exists('missing'), false);
+        }
+        finally {
+            await new Promise((resolve) => server.close(() => resolve()));
+        }
+    });
+});