doover-js 0.5.3 → 0.6.0

package/dist/test/exports.test.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const doover = __importStar(require("../index"));
+(0, mocha_1.describe)("public exports (Phase 1–3)", () => {
+    (0, mocha_1.it)("exports LocalAgentClient", () => {
+        (0, chai_1.expect)(doover.LocalAgentClient).to.be.a("function");
+    });
+    (0, mocha_1.it)("exports MultiplexClient", () => {
+        (0, chai_1.expect)(doover.MultiplexClient).to.be.a("function");
+    });
+    (0, mocha_1.it)("exports the new capability/contract symbols", () => {
+        (0, chai_1.expect)(doover.ALL_CAPABILITIES).to.be.an("array");
+        (0, chai_1.expect)(doover.UnsupportedCapabilityError).to.be.a("function");
+        (0, chai_1.expect)(doover.AmbiguousWriteError).to.be.a("function");
+    });
+    (0, mocha_1.it)("type-only exports resolve (compile-time)", () => {
+        // If any of these types are removed from the public index the import above
+        // will fail at typecheck time (tsc --noEmit), catching broken type exports.
+        const _prov = {
+            client: { id: "cloud", kind: "cloud" },
+            retrievedAt: 0,
+            via: { transport: "rest", method: "test", request: {}, startedAt: 0, durationMs: 0 },
+        };
+        const _scope = { mode: "all" };
+        const _status = {
+            clientId: "cloud",
+            connected: true,
+        };
+        // DataClient is an interface — reference it via a typed variable declaration.
+        // We don't construct one; the assignment below is never reached at runtime.
+        void _prov;
+        void _scope;
+        void _status;
+        (0, chai_1.expect)(true).to.equal(true); // keep mocha happy
+    });
+    (0, mocha_1.it)("exports the full Phase-1..4 surface", () => {
+        for (const name of ["ALL_CAPABILITIES", "UnsupportedCapabilityError", "AmbiguousWriteError", "LocalAgentClient", "MultiplexClient", "DooverClient"]) {
+            (0, chai_1.expect)(doover[name], name).to.exist;
+        }
+    });
+});

package/dist/test/gateway-provenance.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/gateway-provenance.test.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const gateway_client_1 = require("../gateway/gateway-client");
+function makeConfig() {
+    return {
+        dataRestUrl: "https://example.com/api",
+        controlApiUrl: "https://example.com/control",
+        dataWssUrl: "wss://example.com/gateway",
+        disableBrowserLifecycleHooks: true,
+    };
+}
+(0, mocha_1.describe)("GatewayClient provenance hook", () => {
+    (0, mocha_1.it)("stamps emitted payloads when a hook is set; raw when not", () => {
+        const gw = new gateway_client_1.GatewayClient(makeConfig());
+        let stamped;
+        gw.on("messageCreate", (m) => { stamped = m; });
+        // Use a valid snowflake-format id (epoch-based numeric string)
+        const snowflake = String(BigInt(Date.now()) << 22n);
+        // no hook → raw
+        gw.handleMessage(JSON.stringify({ op: 0, t: "MessageCreate", d: { id: snowflake, data: {}, attachments: [], author_id: "a", channel: { agent_id: "x", name: "c" } } }));
+        (0, chai_1.expect)(stamped.__source).to.equal(undefined);
+        // with hook → stamped
+        gw.setProvenanceHook((value, ctx) => ({ ...value, __source: { client: { id: "cloud", kind: "cloud" }, retrievedAt: Date.now(), via: { transport: "gateway", event: ctx.event, receivedAt: Date.now() } } }));
+        gw.handleMessage(JSON.stringify({ op: 0, t: "MessageCreate", d: { id: snowflake, data: {}, attachments: [], author_id: "a", channel: { agent_id: "x", name: "c" } } }));
+        (0, chai_1.expect)(stamped.__source?.via.event).to.equal("messageCreate");
+    });
+});

package/dist/test/gateway-subscriptions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/gateway-subscriptions.test.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const gateway_client_1 = require("../gateway/gateway-client");
+function makeConfig() {
+    return {
+        dataRestUrl: "https://example.com/api",
+        controlApiUrl: "https://example.com/control",
+        dataWssUrl: "wss://example.com/gateway",
+        disableBrowserLifecycleHooks: true,
+    };
+}
+function fakeMessage(channel = { agent_id: "a1", name: "c1" }, id = "m1") {
+    return {
+        id,
+        data: {},
+        attachments: [],
+        author_id: "auth",
+        channel,
+        timestamp: 1,
+    };
+}
+describe("GatewayClient.subscribeToChannel", () => {
+    it("first handler triggers wire-level subscribe", () => {
+        const gw = new gateway_client_1.GatewayClient(makeConfig());
+        let subscribeCalls = 0;
+        gw.subscribe = () => {
+            subscribeCalls += 1;
+        };
+        gw.subscribeToChannel({ agent_id: "a1", name: "c1" }, { onMessage: () => { } });
+        (0, chai_1.expect)(subscribeCalls).to.equal(1);
+    });
+    it("second handler does not trigger another wire-level subscribe", () => {
+        const gw = new gateway_client_1.GatewayClient(makeConfig());
+        let subscribeCalls = 0;
+        gw.subscribe = () => {
+            subscribeCalls += 1;
+        };
+        gw.subscribeToChannel({ agent_id: "a1", name: "c1" }, { onMessage: () => { } });
+        gw.subscribeToChannel({ agent_id: "a1", name: "c1" }, { onMessage: () => { } });
+        (0, chai_1.expect)(subscribeCalls).to.equal(1);
+    });
+    it("returned unsubscribe drops the handler; last drop unsubscribes", () => {
+        const gw = new gateway_client_1.GatewayClient(makeConfig());
+        let unsubCalls = 0;
+        gw.subscribe = () => { };
+        gw.unsubscribe = () => {
+            unsubCalls += 1;
+        };
+        const off1 = gw.subscribeToChannel({ agent_id: "a1", name: "c1" }, { onMessage: () => { } });
+        const off2 = gw.subscribeToChannel({ agent_id: "a1", name: "c1" }, { onMessage: () => { } });
+        off1();
+        (0, chai_1.expect)(unsubCalls).to.equal(0);
+        off2();
+        (0, chai_1.expect)(unsubCalls).to.equal(1);
+    });
+    it("returned unsubscribe is idempotent", () => {
+        const gw = new gateway_client_1.GatewayClient(makeConfig());
+        let unsubCalls = 0;
+        gw.subscribe = () => { };
+        gw.unsubscribe = () => {
+            unsubCalls += 1;
+        };
+        const off = gw.subscribeToChannel({ agent_id: "a1", name: "c1" }, { onMessage: () => { } });
+        off();
+        off();
+        off();
+        (0, chai_1.expect)(unsubCalls).to.equal(1);
+    });
+    it("messageCreate event fans out to onMessage handlers for the matching channel", () => {
+        const gw = new gateway_client_1.GatewayClient(makeConfig());
+        gw.subscribe = () => { };
+        let received;
+        gw.subscribeToChannel({ agent_id: "a1", name: "c1" }, { onMessage: (m) => { received = m; } });
+        gw.emit("messageCreate", fakeMessage());
+        (0, chai_1.expect)(received?.id).to.equal("m1");
+    });
+    it("messageCreate for a different channel does not fire the handler", () => {
+        const gw = new gateway_client_1.GatewayClient(makeConfig());
+        gw.subscribe = () => { };
+        let received = false;
+        gw.subscribeToChannel({ agent_id: "a1", name: "c1" }, { onMessage: () => { received = true; } });
+        gw.emit("messageCreate", fakeMessage({ agent_id: "a1", name: "c2" }, "m2"));
+        (0, chai_1.expect)(received).to.equal(false);
+    });
+    it("aggregateUpdate fans out to onAggregate handlers", () => {
+        const gw = new gateway_client_1.GatewayClient(makeConfig());
+        gw.subscribe = () => { };
+        let received;
+        gw.subscribeToChannel({ agent_id: "a1", name: "c1" }, { onAggregate: (a) => { received = a; } });
+        const aggregate = { data: { x: 1 }, attachments: [] };
+        gw.emit("aggregateUpdate", { channel: { agent_id: "a1", name: "c1" }, aggregate });
+        (0, chai_1.expect)(received?.data).to.deep.equal({ x: 1 });
+    });
+});

package/dist/test/local-agent-client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/local-agent-client.test.js

@@ -0,0 +1,202 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const chai_as_promised_1 = __importDefault(require("chai-as-promised"));
+const chai = __importStar(require("chai"));
+const mocha_1 = require("mocha");
+const local_agent_client_1 = require("../client/local-agent-client");
+const errors_1 = require("../client/errors");
+const helpers_1 = require("./helpers");
+// Valid snowflake IDs for use in mock payloads (id must be a numeric string for BigInt conversion).
+const SNOWFLAKE_1 = "179418309739937792";
+const SNOWFLAKE_2 = "179418309744132096";
+chai.use(chai_as_promised_1.default);
+const { expect: xpect } = chai;
+function makeLocal(extra = {}) {
+    return new local_agent_client_1.LocalAgentClient({
+        baseUrl: "http://192.168.0.7:49100",
+        fetchImpl: (0, helpers_1.createFetchMock)(),
+        webSocketImpl: helpers_1.MockWebSocket,
+        disableBrowserLifecycleHooks: true,
+        sourceId: "local:192.168.0.7:49100",
+        ...extra,
+    });
+}
+(0, mocha_1.describe)("LocalAgentClient", () => {
+    (0, mocha_1.it)("advertises the v1 capability set and not the others", () => {
+        const caps = makeLocal().getCapabilities();
+        for (const c of ["agents.list", "channels.list", "channels.get", "aggregates.get",
+            "aggregates.put", "aggregates.patch", "messages.list", "messages.post", "messages.put",
+            "gateway.subscribe", "gateway.realtime", "gateway.oneShot"]) {
+            (0, chai_1.expect)(caps.has(c)).to.equal(true);
+        }
+        for (const c of ["messages.listHistorical", "messages.get", "channels.create",
+            "channels.archive", "rpc.send", "users.me", "alarms.read"]) {
+            (0, chai_1.expect)(caps.has(c)).to.equal(false);
+        }
+    });
+    (0, mocha_1.it)("throw-stubs every unadvertised method with UnsupportedCapabilityError", async () => {
+        const c = makeLocal();
+        await xpect(c.messages.getMessage("a", "ch", "m")).to.be.rejectedWith(errors_1.UnsupportedCapabilityError);
+        await xpect(c.channels.createChannel("a", "ch", {})).to.be.rejectedWith(errors_1.UnsupportedCapabilityError);
+        await xpect(c.users.getMe()).to.be.rejectedWith(errors_1.UnsupportedCapabilityError);
+        await xpect(c.rpc.send({ agentId: "a", channelName: "ch" }, { method: "x", request: {} })).to.be.rejectedWith(errors_1.UnsupportedCapabilityError);
+        try {
+            await c.alarms.listAlarms("a", "ch");
+            chai_1.expect.fail("should throw");
+        }
+        catch (e) {
+            (0, chai_1.expect)(e).to.be.instanceOf(errors_1.UnsupportedCapabilityError);
+            (0, chai_1.expect)(e.capability).to.equal("alarms.read");
+            (0, chai_1.expect)(e.clientId).to.equal("local:192.168.0.7:49100");
+        }
+    });
+    (0, mocha_1.it)("listChannels / getChannel / getAggregate / listMessages hit the local REST base and carry __source kind 'local'", async () => {
+        const fetchMock = (0, helpers_1.createFetchMock)((url) => {
+            if (url.endsWith("/channels"))
+                return (0, helpers_1.createJsonResponse)([{ name: "c1", is_private: false, owner_id: "o" }]);
+            if (url.includes("/channels/c1/aggregate"))
+                return (0, helpers_1.createJsonResponse)({ data: { v: 1 }, attachments: [] });
+            if (url.includes("/channels/c1/messages"))
+                return (0, helpers_1.createJsonResponse)([{ id: SNOWFLAKE_1, data: {}, attachments: [], author_id: "a", channel: { agent_id: "dev7", name: "c1" } }]);
+            if (url.includes("/channels/c1"))
+                return (0, helpers_1.createJsonResponse)({ name: "c1", is_private: false, owner_id: "o" });
+            return (0, helpers_1.createJsonResponse)({});
+        });
+        const c = makeLocal({ fetchImpl: fetchMock });
+        const list = await c.channels.listChannels("dev7");
+        (0, chai_1.expect)(list[0].__source?.client.kind).to.equal("local");
+        (0, chai_1.expect)(list[0].__source?.via).to.include({ transport: "rest", method: "channels.listChannels" });
+        const agg = await c.aggregates.getAggregate("dev7", "c1");
+        (0, chai_1.expect)(agg.__source?.client.id).to.equal("local:192.168.0.7:49100");
+        const msgs = await c.messages.listMessages("dev7", "c1");
+        (0, chai_1.expect)(msgs[0].__source?.via).to.include({ transport: "rest" });
+    });
+    (0, mocha_1.it)("postMessage / putMessage / putAggregate / patchAggregate go through to the local REST base", async () => {
+        const seen = [];
+        const fetchMock = (0, helpers_1.createFetchMock)((url, init) => {
+            seen.push({ method: init?.method, url });
+            if (url.includes("/messages"))
+                return (0, helpers_1.createJsonResponse)({ id: SNOWFLAKE_2, data: {}, attachments: [], author_id: "a", channel: { agent_id: "dev7", name: "c1" } });
+            return (0, helpers_1.createJsonResponse)({ data: {}, attachments: [] });
+        });
+        const c = makeLocal({ fetchImpl: fetchMock });
+        const m = await c.messages.postMessage("dev7", "c1", { hello: 1 });
+        (0, chai_1.expect)(m.__source?.client.kind).to.equal("local");
+        await c.aggregates.putAggregate("dev7", "c1", { v: 2 });
+        await c.aggregates.patchAggregate("dev7", "c1", { v: 3 });
+        await c.messages.putMessage("dev7", "c1", SNOWFLAKE_2, { v: 4 });
+        (0, chai_1.expect)(seen.some((s) => s.method === "POST" && s.url.includes("/messages"))).to.equal(true);
+        (0, chai_1.expect)(seen.some((s) => s.method === "PUT" && s.url.includes("/aggregate"))).to.equal(true);
+        (0, chai_1.expect)(seen.some((s) => s.method === "PATCH" && s.url.includes("/aggregate"))).to.equal(true);
+    });
+    (0, mocha_1.it)("status reflects the local gateway: disconnected before connect, connected after Ready", async () => {
+        const c = makeLocal();
+        (0, chai_1.expect)(c.isConnected()).to.equal(false);
+        (0, chai_1.expect)(c.getStatus().state).to.equal("disconnected");
+        await c.gateway.connect();
+        const ws = helpers_1.MockWebSocket.instances[helpers_1.MockWebSocket.instances.length - 1];
+        ws.open();
+        ws.receive({ op: 0, t: "Hello", d: {} });
+        ws.receive({ op: 0, t: "Ready", d: { session_id: "s1", session_token: "t", subscriptions: [] } });
+        (0, chai_1.expect)(c.isConnected()).to.equal(true);
+        (0, chai_1.expect)(c.getStatus().state).to.equal("connected");
+        (0, chai_1.expect)(c.getStatus().clientId).to.equal("local:192.168.0.7:49100");
+    });
+    (0, mocha_1.it)("realtime: subscribeToChannel handlers receive stamped MessageCreate", async () => {
+        const c = makeLocal();
+        await c.gateway.connect();
+        const ws = helpers_1.MockWebSocket.instances[helpers_1.MockWebSocket.instances.length - 1];
+        ws.open();
+        ws.receive({ op: 0, t: "Ready", d: { session_id: "s1", session_token: "t", subscriptions: [] } });
+        let got;
+        c.gateway.subscribeToChannel({ agent_id: "dev7", name: "c1" }, { onMessage: (m) => { got = m; } });
+        ws.receive({ op: 0, t: "MessageCreate", d: { id: SNOWFLAKE_1, data: {}, attachments: [], author_id: "a", channel: { agent_id: "dev7", name: "c1" } } });
+        (0, chai_1.expect)(got.__source?.client.kind).to.equal("local");
+    });
+    (0, mocha_1.it)("getAgentScope resolves to { mode: 'list', agentIds: [deviceId] } via listAgents, caches it, and getKnownAgentScope is 'unknown' first", async () => {
+        let agentCalls = 0;
+        const fetchMock = (0, helpers_1.createFetchMock)((url) => {
+            if (url.includes("/agents")) {
+                agentCalls += 1;
+                return (0, helpers_1.createJsonResponse)({ agents: [{ id: "dev7", name: "Device 7" }] });
+            }
+            return (0, helpers_1.createJsonResponse)({});
+        });
+        const c = makeLocal({ fetchImpl: fetchMock });
+        (0, chai_1.expect)(c.getKnownAgentScope()).to.equal("unknown");
+        const scope = await c.getAgentScope();
+        (0, chai_1.expect)(scope).to.deep.equal({ mode: "list", agentIds: ["dev7"] });
+        (0, chai_1.expect)(c.getKnownAgentScope()).to.deep.equal({ mode: "list", agentIds: ["dev7"] });
+        await c.getAgentScope(); // cached
+        (0, chai_1.expect)(agentCalls).to.equal(1);
+    });
+    (0, mocha_1.it)("reconnect (Ready frame) invalidates the scope cache and re-fetches the agent id", async () => {
+        let agentCalls = 0;
+        const fetchMock = (0, helpers_1.createFetchMock)((url) => {
+            if (url.includes("/agents")) {
+                agentCalls += 1;
+                return (0, helpers_1.createJsonResponse)({ agents: [{ id: "dev7", name: "Device 7" }] });
+            }
+            return (0, helpers_1.createJsonResponse)({});
+        });
+        const c = makeLocal({ fetchImpl: fetchMock });
+        // 1. Initial resolve — agentCalls becomes 1, scope is cached.
+        const scope1 = await c.getAgentScope();
+        (0, chai_1.expect)(scope1).to.deep.equal({ mode: "list", agentIds: ["dev7"] });
+        (0, chai_1.expect)(agentCalls).to.equal(1);
+        // 2. Connect the gateway, open the socket, and send a Ready frame — this
+        //    should null the cache and kick off a background re-fetch.
+        await c.gateway.connect();
+        const ws = helpers_1.MockWebSocket.instances[helpers_1.MockWebSocket.instances.length - 1];
+        ws.open();
+        ws.receive({ op: 0, t: "Hello", d: {} });
+        ws.receive({ op: 0, t: "Ready", d: { session_id: "s2", session_token: "t2", subscriptions: [] } });
+        // 3. The "ready" handler fires synchronously, nulling resolvedScope and
+        //    firing off an async re-fetch.  Flush the microtask queue so the async
+        //    listAgents() call has time to complete before we assert.
+        await new Promise((r) => setImmediate(r));
+        await new Promise((r) => setImmediate(r));
+        // 4. Re-fetch should have run: agentCalls === 2 and scope is still [dev7].
+        (0, chai_1.expect)(agentCalls).to.equal(2);
+        const scope2 = await c.getAgentScope(); // now served from refreshed cache
+        (0, chai_1.expect)(scope2).to.deep.equal({ mode: "list", agentIds: ["dev7"] });
+        (0, chai_1.expect)(agentCalls).to.equal(2); // no third fetch — cache hit
+    });
+});

package/dist/test/multiplex-capabilities.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/multiplex-capabilities.test.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const multiplex_client_1 = require("../client/multiplex-client");
+function memberWithCaps(id, caps) {
+    const noop = new Proxy({}, { get: () => () => Promise.resolve(undefined) });
+    return {
+        agents: noop, channels: noop, messages: noop, aggregates: noop, alarms: noop, connections: noop,
+        notifications: noop, permissions: noop, processors: noop, turn: noop, users: noop, rpc: noop,
+        gateway: { connect: async () => { }, disconnect: () => { }, reconnect: async () => { }, on: () => { }, off: () => { },
+            subscribe: () => { }, unsubscribe: () => { }, subscribeToChannel: () => () => { }, syncChannel: () => { },
+            sendOneShotMessage: () => { }, getSession: () => null, isConnected: () => false, getSubscriptionCount: () => 0,
+            getSubscriptions: () => [], setStats: () => { } },
+        getCapabilities: () => new Set(caps),
+        supports: (c) => caps.includes(c),
+        isConnected: () => false,
+        getStatus: () => ({ clientId: id, connected: false, state: "disconnected", agentScope: "all", at: Date.now() }),
+        onStatusChange: () => () => { },
+        getAgentScope: async () => ({ mode: "all" }),
+        getKnownAgentScope: () => ({ mode: "all" }),
+    };
+}
+(0, mocha_1.describe)("MultiplexClient capabilities", () => {
+    (0, mocha_1.it)("is the union over enabled members; recomputed on enable/disable", () => {
+        const factory = (d) => d.id === "cloud" ? memberWithCaps("cloud", ["channels.list", "messages.listHistorical"])
+            : memberWithCaps("local", ["channels.list", "messages.list"]);
+        const mux = new multiplex_client_1.MultiplexClient({ factory, register: [{ id: "cloud", kind: "cloud" }, { id: "local", kind: "local" }], enable: ["cloud"] });
+        (0, chai_1.expect)([...mux.getCapabilities()].sort()).to.deep.equal(["channels.list", "messages.listHistorical"]);
+        mux.enableSource("local");
+        (0, chai_1.expect)([...mux.getCapabilities()].sort()).to.deep.equal(["channels.list", "messages.list", "messages.listHistorical"]);
+        mux.disableSource("cloud");
+        (0, chai_1.expect)([...mux.getCapabilities()].sort()).to.deep.equal(["channels.list", "messages.list"]);
+        (0, chai_1.expect)(mux.supports("messages.list")).to.equal(true);
+        (0, chai_1.expect)(mux.supports("messages.listHistorical")).to.equal(false);
+    });
+});

package/dist/test/multiplex-conflicts.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/multiplex-conflicts.test.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// src/test/multiplex-conflicts.test.ts
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const multiplex_client_1 = require("../client/multiplex-client");
+function aggMember(id, scope, value) {
+    const noop = new Proxy({}, { get: () => () => Promise.resolve(undefined) });
+    return {
+        agents: noop, channels: noop, messages: noop,
+        aggregates: { getAggregate: async () => ({ ...value, __source: { client: { id, kind: "x" }, retrievedAt: 0, via: { transport: "rest", method: "aggregates.getAggregate", request: {}, startedAt: 0, durationMs: 0 } } }) },
+        alarms: noop, connections: noop, notifications: noop, permissions: noop, processors: noop, turn: noop, users: noop, rpc: noop,
+        gateway: { connect: async () => { }, disconnect: () => { }, reconnect: async () => { }, on: () => { }, off: () => { }, subscribe: () => { }, unsubscribe: () => { }, subscribeToChannel: () => () => { }, syncChannel: () => { }, sendOneShotMessage: () => { }, getSession: () => null, isConnected: () => false, getSubscriptionCount: () => 0, getSubscriptions: () => [], setStats: () => { } },
+        getCapabilities: () => new Set(["aggregates.get"]), supports: (c) => c === "aggregates.get",
+        isConnected: () => false, getStatus: () => ({ clientId: id, connected: false, state: "disconnected", agentScope: scope, at: Date.now() }),
+        onStatusChange: () => () => { },
+        getAgentScope: async () => scope, getKnownAgentScope: () => scope,
+    };
+}
+(0, mocha_1.describe)("MultiplexClient conflicts", () => {
+    (0, mocha_1.it)("getAggregate across two owning members → first wins, conflict emitted + snapshot recorded", async () => {
+        const factory = (d) => d.id === "cloud" ? aggMember("cloud", { mode: "all" }, { data: { v: 1 }, attachments: [] }) : aggMember("local:7", { mode: "list", agentIds: ["dev7"] }, { data: { v: 2 }, attachments: [] });
+        const mux = new multiplex_client_1.MultiplexClient({ factory, register: [{ id: "cloud", kind: "cloud" }, { id: "local:7", kind: "local" }], enableAll: true });
+        const events = [];
+        mux.on("conflict", (c) => events.push(c));
+        const agg = await mux.aggregates.getAggregate("dev7", "c");
+        (0, chai_1.expect)(agg.data.v).to.equal(1); // first member
+        (0, chai_1.expect)(agg.__source?.client.id).to.equal("cloud");
+        (0, chai_1.expect)(events).to.have.length(1);
+        const conflicts = mux.getLastConflicts();
+        (0, chai_1.expect)(conflicts).to.have.length(1);
+        (0, chai_1.expect)(conflicts[0].method).to.equal("aggregates.getAggregate");
+        (0, chai_1.expect)(conflicts[0].sourceIds.sort()).to.deep.equal(["cloud", "local:7"]);
+    });
+});

package/dist/test/multiplex-gateway.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/multiplex-gateway.test.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const multiplex_client_1 = require("../client/multiplex-client");
+// A member with a controllable fake gateway.
+function gwMember(id, scope) {
+    const subs = [];
+    let connected = false;
+    const channelHandlers = new Map();
+    const eventListeners = new Map();
+    const member = {
+        agents: {}, channels: {}, messages: {}, aggregates: {},
+        alarms: {}, connections: {}, notifications: {}, permissions: {},
+        processors: {}, turn: {}, users: {}, rpc: {},
+        gateway: {
+            connect: async () => { connected = true; }, disconnect: () => { connected = false; }, reconnect: async () => { },
+            on: (event, handler) => {
+                if (!eventListeners.has(event))
+                    eventListeners.set(event, new Set());
+                eventListeners.get(event).add(handler);
+            },
+            off: (event, handler) => {
+                eventListeners.get(event)?.delete(handler);
+            },
+            subscribe: (c) => subs.push(`${c.agent_id}/${c.name}`),
+            unsubscribe: (c) => { const i = subs.indexOf(`${c.agent_id}/${c.name}`); if (i >= 0)
+                subs.splice(i, 1); },
+            subscribeToChannel: (c, h) => {
+                const k = `${c.agent_id}/${c.name}`;
+                if (!channelHandlers.has(k)) {
+                    channelHandlers.set(k, new Set());
+                    subs.push(k); // mirrors real GatewayClient: subscribeToChannel calls subscribe internally
+                }
+                channelHandlers.get(k).add(h);
+                return () => {
+                    channelHandlers.get(k)?.delete(h);
+                    if ((channelHandlers.get(k)?.size ?? 0) === 0) {
+                        channelHandlers.delete(k);
+                        const i = subs.indexOf(k);
+                        if (i >= 0)
+                            subs.splice(i, 1); // mirrors real GatewayClient: last unsub triggers unsubscribe
+                    }
+                };
+            },
+            syncChannel: () => { }, sendOneShotMessage: () => { }, getSession: () => connected ? { session_id: `${id}-s` } : null,
+            isConnected: () => connected, getSubscriptionCount: () => subs.length, getSubscriptions: () => subs.map((s) => ({ agent_id: s.split("/")[0], name: s.split("/")[1] })), setStats: () => { },
+        },
+        getCapabilities: () => new Set(["gateway.subscribe", "gateway.realtime"]),
+        supports: (c) => c === "gateway.subscribe" || c === "gateway.realtime",
+        isConnected: () => connected, getStatus: () => ({ clientId: id, connected, state: connected ? "connected" : "disconnected", agentScope: scope, at: Date.now() }),
+        onStatusChange: () => () => { },
+        getAgentScope: async () => scope, getKnownAgentScope: () => scope,
+    };
+    return {
+        member, subs,
+        deliver(k, m) { channelHandlers.get(k)?.forEach((h) => h.onMessage?.(m)); },
+        emit(event, ...args) { eventListeners.get(event)?.forEach((h) => h(...args)); },
+        isConnected: () => connected,
+    };
+}
+(0, mocha_1.describe)("MultiplexGateway", () => {
+    (0, mocha_1.it)("subscribeToChannel routes to owning members; unsubscribe tears down; connect/isConnected aggregate", async () => {
+        const c = gwMember("cloud", { mode: "all" });
+        const l = gwMember("local:7", { mode: "list", agentIds: ["dev7"] });
+        const factory = (d) => d.id === "cloud" ? c.member : l.member;
+        const mux = new multiplex_client_1.MultiplexClient({ factory, register: [{ id: "cloud", kind: "cloud" }, { id: "local:7", kind: "local" }], enableAll: true });
+        await mux.gateway.connect();
+        (0, chai_1.expect)(mux.gateway.isConnected()).to.equal(true);
+        (0, chai_1.expect)(mux.isConnected()).to.equal(true);
+        let got;
+        const off = mux.gateway.subscribeToChannel({ agent_id: "dev7", name: "c1" }, { onMessage: (m) => { got = m; } });
+        // both cloud (all) and local:7 (owns dev7) subscribed
+        (0, chai_1.expect)(c.subs).to.deep.equal(["dev7/c1"]);
+        (0, chai_1.expect)(l.subs).to.deep.equal(["dev7/c1"]);
+        l.deliver("dev7/c1", { id: "m1" });
+        (0, chai_1.expect)(got).to.deep.equal({ id: "m1" });
+        off();
+        (0, chai_1.expect)(c.subs).to.deep.equal([]);
+        (0, chai_1.expect)(l.subs).to.deep.equal([]);
+    });
+    (0, mocha_1.it)("on/off forwards gateway events from all members and off deregisters", async () => {
+        const c = gwMember("cloud", { mode: "all" });
+        const l = gwMember("local:7", { mode: "list", agentIds: ["dev7"] });
+        const factory = (d) => d.id === "cloud" ? c.member : l.member;
+        const mux = new multiplex_client_1.MultiplexClient({ factory, register: [{ id: "cloud", kind: "cloud" }, { id: "local:7", kind: "local" }], enableAll: true });
+        let callCount = 0;
+        // open fires with no arguments; use a () => void signature to match the typed overload.
+        const handler = () => { callCount++; };
+        mux.gateway.on("open", handler);
+        // Emit from member A — handler should fire once.
+        c.emit("open");
+        (0, chai_1.expect)(callCount).to.equal(1);
+        // Emit from member B — handler should fire again.
+        l.emit("open");
+        (0, chai_1.expect)(callCount).to.equal(2);
+        // After off(), neither member triggers the handler.
+        mux.gateway.off("open", handler);
+        c.emit("open");
+        l.emit("open");
+        (0, chai_1.expect)(callCount).to.equal(2);
+    });
+});

package/dist/test/multiplex-merge.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/multiplex-merge.test.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const multiplex_merge_1 = require("../client/multiplex-merge");
+(0, mocha_1.describe)("multiplex merge helpers", () => {
+    (0, mocha_1.it)("dedupeBy keeps the first occurrence", () => {
+        const out = (0, multiplex_merge_1.dedupeBy)([{ id: "a", n: 1 }, { id: "b", n: 2 }, { id: "a", n: 3 }], (x) => x.id);
+        (0, chai_1.expect)(out).to.deep.equal([{ id: "a", n: 1 }, { id: "b", n: 2 }]);
+    });
+    (0, mocha_1.it)("mergeMessages: dedup by id, sort to requested order, re-apply limit", () => {
+        const a = [{ id: "5" }, { id: "3" }, { id: "1" }];
+        const b = [{ id: "4" }, { id: "3" }, { id: "2" }];
+        const desc = (0, multiplex_merge_1.mergeMessages)([a, b], { order: "desc", limit: 4 });
+        (0, chai_1.expect)(desc.map((m) => m.id)).to.deep.equal(["5", "4", "3", "2"]);
+        const asc = (0, multiplex_merge_1.mergeMessages)([a, b], { order: "asc", limit: 3 });
+        (0, chai_1.expect)(asc.map((m) => m.id)).to.deep.equal(["1", "2", "3"]);
+    });
+});

package/dist/test/multiplex-noncore.test.d.ts

@@ -0,0 +1 @@
+export {};