doover-js 0.5.3 → 0.6.0

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

@@ -0,0 +1,82 @@
+"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 });
+// src/test/multiplex-noncore.test.ts
+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 multiplex_client_1 = require("../client/multiplex-client");
+const errors_1 = require("../client/errors");
+chai.use(chai_as_promised_1.default);
+const { expect: xp } = chai;
+function member(id, caps, impl) {
+    const noop = new Proxy({}, { get: () => () => Promise.resolve(undefined) });
+    const make = (name) => (impl[name] ?? noop);
+    return {
+        agents: noop, channels: noop, messages: noop, aggregates: noop,
+        alarms: make("alarms"), connections: make("connections"), notifications: make("notifications"),
+        permissions: make("permissions"), processors: make("processors"), turn: make("turn"), users: make("users"), 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: { mode: "all" }, at: Date.now() }),
+        onStatusChange: () => () => { },
+        getAgentScope: async () => ({ mode: "all" }), getKnownAgentScope: () => ({ mode: "all" }),
+    };
+}
+(0, mocha_1.describe)("MultiplexClient non-core methods", () => {
+    function mk(members) {
+        const factory = (d) => members[d.id];
+        return new multiplex_client_1.MultiplexClient({ factory, register: Object.keys(members).map((id) => ({ id, kind: "cloud" })), enableAll: true });
+    }
+    (0, mocha_1.it)("users.getMe returns the first member's result; throws if no member supports it", async () => {
+        const mux = mk({ cloud: member("cloud", ["users.me"], { users: { getMe: async () => ({ id: "u1" }) } }) });
+        (0, chai_1.expect)((await mux.users.getMe()).id).to.equal("u1");
+        const mux2 = mk({ cloud: member("cloud", [], {}) });
+        await xp(mux2.users.getMe()).to.be.rejectedWith(errors_1.UnsupportedCapabilityError);
+    });
+    (0, mocha_1.it)("alarms.listAlarms fans out; alarms.deleteAlarm routes to one", async () => {
+        const sink = [];
+        const mux = mk({ cloud: member("cloud", ["alarms.read", "alarms.write"], {
+                alarms: { listAlarms: async () => [{ id: "al1", name: "x" }], deleteAlarm: async (a) => { sink.push(`del:${a}`); } },
+            }) });
+        (0, chai_1.expect)((await mux.alarms.listAlarms("dev7", "c"))[0].id).to.equal("al1");
+        await mux.alarms.deleteAlarm("dev7", "c", "al1");
+        (0, chai_1.expect)(sink).to.deep.equal(["del:dev7"]);
+    });
+});

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

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

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// src/test/multiplex-passthrough.test.ts — reuses the dataMember helper pattern from multiplex-reads.test.ts
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const multiplex_client_1 = require("../client/multiplex-client");
+function dataMember(id, channels) {
+    const src = { client: { id, kind: id.startsWith("local") ? "local" : "cloud" }, retrievedAt: Date.now(), via: { transport: "rest", method: "channels.listChannels", request: {}, startedAt: 0, durationMs: 1 } };
+    const noop = new Proxy({}, { get: () => () => Promise.resolve(undefined) });
+    return {
+        agents: noop, channels: { listChannels: async () => channels.map((c) => ({ ...c, is_private: false, owner_id: "o", __source: src })) },
+        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(["channels.list"]), supports: (c) => c === "channels.list",
+        isConnected: () => false, getStatus: () => ({ clientId: id, connected: false, state: "disconnected", agentScope: { mode: "all" }, at: Date.now() }),
+        onStatusChange: () => () => { }, getAgentScope: async () => ({ mode: "all" }), getKnownAgentScope: () => ({ mode: "all" }),
+    };
+}
+(0, mocha_1.describe)("MultiplexClient pass-through & re-enable", () => {
+    (0, mocha_1.it)("merged items keep their member __source (no re-stamp); disabled member drops out; re-enable rejoins (no rebuild)", async () => {
+        let builds = 0;
+        const factory = (d) => { builds += 1; return dataMember(d.id, d.id === "cloud" ? [{ name: "cloudch" }] : [{ name: "localch" }]); };
+        const mux = new multiplex_client_1.MultiplexClient({ factory, register: [{ id: "cloud", kind: "cloud" }, { id: "local:7", kind: "local" }], enableAll: true });
+        let list = await mux.channels.listChannels("dev7");
+        (0, chai_1.expect)(list.map((c) => c.name).sort()).to.deep.equal(["cloudch", "localch"]);
+        (0, chai_1.expect)(list.find((c) => c.name === "localch").__source?.client.id).to.equal("local:7");
+        mux.disableSource("local:7");
+        list = await mux.channels.listChannels("dev7");
+        (0, chai_1.expect)(list.map((c) => c.name)).to.deep.equal(["cloudch"]); // local dropped out
+        mux.enableSource("local:7");
+        list = await mux.channels.listChannels("dev7");
+        (0, chai_1.expect)(list.map((c) => c.name).sort()).to.deep.equal(["cloudch", "localch"]); // rejoined
+        (0, chai_1.expect)(builds).to.equal(2); // never rebuilt
+    });
+});

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

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

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// src/test/multiplex-reads.test.ts
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const multiplex_client_1 = require("../client/multiplex-client");
+// Helper that builds a member whose subclients return canned values + record __source.
+function dataMember(id, opts) {
+    const scope = opts.scope ?? { mode: "all" };
+    const caps = new Set(opts.caps ?? ["agents.list", "channels.list", "channels.get", "aggregates.get", "messages.list"]);
+    const src = (method) => ({ client: { id, kind: id.startsWith("local") ? "local" : "cloud" }, retrievedAt: Date.now(), via: { transport: "rest", method, request: {}, startedAt: 0, durationMs: 1 } });
+    const noop = new Proxy({}, { get: () => () => Promise.resolve(undefined) });
+    return {
+        agents: { listAgents: async () => ({ agents: (opts.agents ?? []).map((a) => ({ ...a, __source: src("agents.listAgents") })) }) },
+        channels: {
+            listChannels: async (agentId) => (opts.channels?.[agentId] ?? []).map((c) => ({ ...c, __source: src("channels.listChannels") })),
+            getChannel: async (agentId, name) => { const c = opts.channel?.[`${agentId}/${name}`]; if (!c) {
+                const e = new Error("404");
+                e.status = 404;
+                throw e;
+            } return { ...c, __source: src("channels.getChannel") }; },
+        },
+        aggregates: {
+            getAggregate: async (agentId, name) => { const a = opts.aggregate?.[`${agentId}/${name}`]; if (!a) {
+                const e = new Error("404");
+                e.status = 404;
+                throw e;
+            } return { ...a, __source: src("aggregates.getAggregate") }; },
+        },
+        messages: {
+            listMessages: async (agentId, name) => (opts.messages?.[`${agentId}/${name}`] ?? []).map((m) => ({ ...m, data: {}, attachments: [], author_id: "a", channel: { agent_id: agentId, name }, __source: src("messages.listMessages") })),
+        },
+        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: () => caps, supports: (c) => caps.has(c),
+        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 reads", () => {
+    function mk(members) {
+        const factory = (d) => members[d.id];
+        return new multiplex_client_1.MultiplexClient({ factory, register: Object.keys(members).map((id) => ({ id, kind: id.startsWith("local") ? "local" : "cloud" })), enableAll: true });
+    }
+    (0, mocha_1.it)("listChannels merges + dedupes by name across owning members; items keep their member __source", async () => {
+        const mux = mk({
+            cloud: dataMember("cloud", { scope: { mode: "all" }, channels: { dev7: [{ name: "a", is_private: false, owner_id: "o" }, { name: "shared", is_private: false, owner_id: "o" }] } }),
+            "local:1": dataMember("local:1", { scope: { mode: "list", agentIds: ["dev7"] }, channels: { dev7: [{ name: "b", is_private: false, owner_id: "o" }, { name: "shared", is_private: false, owner_id: "o" }] } }),
+        });
+        const list = await mux.channels.listChannels("dev7");
+        (0, chai_1.expect)(list.map((c) => c.name).sort()).to.deep.equal(["a", "b", "shared"]);
+        const shared = list.find((c) => c.name === "shared");
+        (0, chai_1.expect)(shared.__source?.client.id).to.equal("cloud"); // first member wins
+        // sources-scoped → only local:1
+        const onlyLocal = await mux.channels.listChannels("dev7", { sources: ["local:1"] });
+        (0, chai_1.expect)(onlyLocal.map((c) => c.name).sort()).to.deep.equal(["b", "shared"]);
+    });
+    (0, mocha_1.it)("getChannel: only the local member owns dev9 → returns its value", async () => {
+        const mux = mk({
+            cloud: dataMember("cloud", { scope: { mode: "all" }, channel: { "dev7/c": { name: "c", v: 1 } } }),
+            "local:9": dataMember("local:9", { scope: { mode: "list", agentIds: ["dev9"] }, channel: { "dev9/c": { name: "c", v: 99 } } }),
+        });
+        // cloud is 'all' so it's also asked for dev9, but its getChannel 404s → ignored.
+        const ch = await mux.channels.getChannel("dev9", "c");
+        (0, chai_1.expect)(ch.v).to.equal(99);
+        (0, chai_1.expect)(ch.__source?.client.id).to.equal("local:9");
+    });
+    (0, mocha_1.it)("listMessages merges by id, dedupes, re-applies limit", async () => {
+        const mux = mk({
+            cloud: dataMember("cloud", { scope: { mode: "all" }, messages: { "dev7/c": [{ id: "5" }, { id: "3" }, { id: "1" }] } }),
+            "local:1": dataMember("local:1", { scope: { mode: "list", agentIds: ["dev7"] }, caps: ["messages.list", "channels.get"], messages: { "dev7/c": [{ id: "4" }, { id: "3" }, { id: "2" }] } }),
+        });
+        const msgs = await mux.messages.listMessages("dev7", "c", { limit: 4, order: "desc" });
+        (0, chai_1.expect)(msgs.map((m) => m.id)).to.deep.equal(["5", "4", "3", "2"]);
+        const m3 = msgs.find((m) => m.id === "3");
+        (0, chai_1.expect)(m3.__source?.client.id).to.equal("cloud");
+    });
+    (0, mocha_1.it)("listAgents concatenates members' agents and dedupes by id", async () => {
+        const mux = mk({
+            cloud: dataMember("cloud", { agents: [{ id: "dev7" }, { id: "dev8" }] }),
+            "local:7": dataMember("local:7", { agents: [{ id: "dev7" }] }),
+        });
+        const res = await mux.agents.listAgents();
+        (0, chai_1.expect)((res.agents ?? []).map((a) => a.id).sort()).to.deep.equal(["dev7", "dev8"]);
+    });
+});

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

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

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

@@ -0,0 +1,81 @@
+"use strict";
+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 mocha_1 = require("mocha");
+const sinon_1 = __importDefault(require("sinon"));
+const multiplex_client_1 = require("../client/multiplex-client");
+// A no-op DataClient stub with a controllable connected flag + gateway events.
+function stubMember(id) {
+    let connected = false;
+    const gwListeners = new Set();
+    const noop = new Proxy({}, { get: () => () => Promise.resolve(undefined) });
+    const statusListeners = new Set();
+    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: () => { connected = false; }, reconnect: async () => { },
+            on: (_e, h) => gwListeners.add(h), off: (_e, h) => gwListeners.delete(h),
+            subscribe: () => { }, unsubscribe: () => { }, subscribeToChannel: () => () => { }, syncChannel: () => { },
+            sendOneShotMessage: () => { }, getSession: () => null, isConnected: () => connected,
+            getSubscriptionCount: () => 0, getSubscriptions: () => [], setStats: () => { } },
+        getCapabilities: () => new Set(["channels.list", "channels.get"]),
+        supports: (c) => c === "channels.list" || c === "channels.get",
+        isConnected: () => connected,
+        getStatus: () => ({ clientId: id, connected, state: connected ? "connected" : "disconnected", agentScope: "all", at: Date.now() }),
+        onStatusChange: (l) => { statusListeners.add(l); return () => statusListeners.delete(l); },
+        getAgentScope: async () => ({ mode: "all" }),
+        getKnownAgentScope: () => ({ mode: "all" }),
+        _setConnected(v) { connected = v; statusListeners.forEach((l) => l(undefined)); },
+        _emit() { gwListeners.forEach((h) => h()); },
+        gatewayListeners: gwListeners,
+    };
+}
+(0, mocha_1.describe)("MultiplexClient registry & activation", () => {
+    (0, mocha_1.it)("builds a member via factory exactly once and reuses it on re-enable", () => {
+        const built = {};
+        const factory = sinon_1.default.spy((d) => { built[d.id] = (built[d.id] ?? 0) + 1; return stubMember(d.id); });
+        const mux = new multiplex_client_1.MultiplexClient({ factory, register: [{ id: "cloud", kind: "cloud" }], enable: ["cloud"] });
+        (0, chai_1.expect)(built.cloud).to.equal(1);
+        mux.disableSource("cloud");
+        mux.enableSource("cloud");
+        (0, chai_1.expect)(built.cloud).to.equal(1); // not rebuilt
+        (0, chai_1.expect)(mux.getActiveSources().map((s) => s.descriptor.id)).to.deep.equal(["cloud"]);
+    });
+    (0, mocha_1.it)("registerSource is idempotent on id (updates metadata only)", () => {
+        const factory = sinon_1.default.spy((d) => stubMember(d.id));
+        const mux = new multiplex_client_1.MultiplexClient({ factory });
+        mux.registerSource({ id: "local:1", kind: "local", label: "A" });
+        mux.registerSource({ id: "local:1", kind: "local", label: "B" });
+        (0, chai_1.expect)(mux.getRegisteredSources()).to.have.length(1);
+        (0, chai_1.expect)(mux.getRegisteredSources()[0].descriptor.label).to.equal("B");
+        (0, chai_1.expect)(factory.called).to.equal(false); // registering doesn't build
+    });
+    (0, mocha_1.it)("setActiveSources enables/disables to match exactly and is a no-op when unchanged", () => {
+        const factory = sinon_1.default.spy((d) => stubMember(d.id));
+        const mux = new multiplex_client_1.MultiplexClient({ factory });
+        mux.setActiveSources([{ id: "cloud", kind: "cloud" }, { id: "local:1", kind: "local" }]);
+        (0, chai_1.expect)(mux.getActiveSources().map((s) => s.descriptor.id).sort()).to.deep.equal(["cloud", "local:1"]);
+        const before = factory.callCount;
+        mux.setActiveSources(["local:1", "cloud"]);
+        (0, chai_1.expect)(factory.callCount).to.equal(before);
+        mux.setActiveSources(["cloud"]);
+        (0, chai_1.expect)(mux.getActiveSources().map((s) => s.descriptor.id)).to.deep.equal(["cloud"]);
+        (0, chai_1.expect)(mux.getRegisteredSources()).to.have.length(2);
+    });
+    (0, mocha_1.it)("disableSource keeps the client and (default) disconnects its gateway; removeSource discards", () => {
+        const member = stubMember("local:1");
+        const factory = () => member;
+        const mux = new multiplex_client_1.MultiplexClient({ factory, register: [{ id: "local:1", kind: "local" }], enable: ["local:1"] });
+        member._setConnected(true);
+        const disc = sinon_1.default.spy(member.gateway, "disconnect");
+        mux.disableSource("local:1");
+        (0, chai_1.expect)(disc.called).to.equal(true);
+        (0, chai_1.expect)(mux.getRegisteredSources()[0].client).to.equal(member);
+        mux.removeSource("local:1");
+        (0, chai_1.expect)(mux.getRegisteredSources()).to.have.length(0);
+    });
+});

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

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

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

@@ -0,0 +1,45 @@
+"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 member(id, scope, caps = ["channels.get"]) {
+    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: scope(), at: Date.now() }),
+        onStatusChange: () => () => { },
+        getAgentScope: async () => { const s = scope(); return s === "unknown" ? { mode: "list", agentIds: [] } : s; },
+        getKnownAgentScope: scope,
+    };
+}
+(0, mocha_1.describe)("MultiplexClient agent-scope routing", () => {
+    (0, mocha_1.it)("membersForAgent: cloud (scope 'all') always included; local iff its list has the agent; 'unknown' included optimistically", () => {
+        let localScope = "unknown";
+        const factory = (d) => d.id === "cloud" ? member("cloud", () => ({ mode: "all" }))
+            : member("local", () => localScope);
+        const mux = new multiplex_client_1.MultiplexClient({ factory, register: [{ id: "cloud", kind: "cloud" }, { id: "local", kind: "local" }], enableAll: true });
+        const m = mux;
+        (0, chai_1.expect)(m.membersForAgent("dev7").map((x) => x.id).sort()).to.deep.equal(["cloud", "local"]);
+        localScope = { mode: "list", agentIds: ["dev9"] };
+        (0, chai_1.expect)(m.membersForAgent("dev7").map((x) => x.id)).to.deep.equal(["cloud"]);
+        localScope = { mode: "list", agentIds: ["dev7"] };
+        (0, chai_1.expect)(m.membersForAgent("dev7").map((x) => x.id).sort()).to.deep.equal(["cloud", "local"]);
+    });
+    (0, mocha_1.it)("getAgentScope rollup: 'all' if any enabled member is 'all'; else union list", async () => {
+        const factory = (d) => d.id === "cloud" ? member("cloud", () => ({ mode: "all" }))
+            : member(d.id, () => ({ mode: "list", agentIds: [d.id.replace("local:", "")] }));
+        const mux = new multiplex_client_1.MultiplexClient({ factory, register: [{ id: "cloud", kind: "cloud" }, { id: "local:a", kind: "local" }, { id: "local:b", kind: "local" }], enableAll: true });
+        (0, chai_1.expect)(await mux.getAgentScope()).to.deep.equal({ mode: "all" });
+        mux.disableSource("cloud");
+        const rolled = await mux.getAgentScope();
+        (0, chai_1.expect)(rolled).to.deep.equal({ mode: "list", agentIds: ["a", "b"] });
+        (0, chai_1.expect)(mux.getKnownAgentScope()).to.deep.equal({ mode: "list", agentIds: ["a", "b"] });
+    });
+});

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

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

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

@@ -0,0 +1,63 @@
+"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 statefulMember(id) {
+    let connected = false;
+    let state = "disconnected";
+    const listeners = new Set();
+    const fire = () => listeners.forEach((l) => l({ clientId: id, connected, state, agentScope: { mode: "all" }, at: Date.now() }));
+    const noop = new Proxy({}, { get: () => () => Promise.resolve(undefined) });
+    return {
+        member: {
+            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: () => connected, getSubscriptionCount: () => 0, getSubscriptions: () => [], setStats: () => { } },
+            getCapabilities: () => new Set(["gateway.subscribe"]), supports: (c) => c === "gateway.subscribe",
+            isConnected: () => connected,
+            getStatus: () => ({ clientId: id, connected, state, agentScope: { mode: "all" }, at: Date.now() }),
+            onStatusChange: (l) => { listeners.add(l); return () => listeners.delete(l); },
+            getAgentScope: async () => ({ mode: "all" }), getKnownAgentScope: () => ({ mode: "all" }),
+        },
+        setConnected(v) { connected = v; state = v ? "connected" : "disconnected"; fire(); },
+        setState(s) { state = s; fire(); },
+    };
+}
+(0, mocha_1.describe)("MultiplexClient status rollup", () => {
+    (0, mocha_1.it)("isConnected = all gateway-subscribe members connected; state degrades; members[] present; onStatusChange fires", () => {
+        const a = statefulMember("cloud");
+        const b = statefulMember("local:7");
+        const factory = (d) => d.id === "cloud" ? a.member : b.member;
+        const mux = new multiplex_client_1.MultiplexClient({ factory, register: [{ id: "cloud", kind: "cloud", label: "Cloud" }, { id: "local:7", kind: "local" }], enableAll: true });
+        const seen = [];
+        const off = mux.onStatusChange((s) => seen.push(s));
+        (0, chai_1.expect)(mux.isConnected()).to.equal(false);
+        let st = mux.getStatus();
+        (0, chai_1.expect)(st.clientId).to.equal("multiplex");
+        (0, chai_1.expect)(st.members).to.have.length(2);
+        (0, chai_1.expect)(st.state).to.equal("disconnected");
+        a.setConnected(true);
+        st = mux.getStatus();
+        (0, chai_1.expect)(st.connected).to.equal(false); // not ALL connected
+        (0, chai_1.expect)(st.state).to.equal("degraded");
+        b.setConnected(true);
+        st = mux.getStatus();
+        (0, chai_1.expect)(st.connected).to.equal(true);
+        (0, chai_1.expect)(st.state).to.equal("connected");
+        a.setState("error");
+        (0, chai_1.expect)(mux.getStatus().state).to.equal("error");
+        (0, chai_1.expect)(seen.length).to.be.greaterThan(2);
+        off();
+        const n = seen.length;
+        b.setState("error");
+        (0, chai_1.expect)(seen.length).to.equal(n); // unsubscribed
+    });
+    (0, mocha_1.it)("disabled members appear in members[] as 'disconnected'", () => {
+        const a = statefulMember("cloud");
+        const factory = (d) => d.id === "cloud" ? a.member : statefulMember(d.id).member;
+        const mux = new multiplex_client_1.MultiplexClient({ factory, register: [{ id: "cloud", kind: "cloud" }, { id: "local:7", kind: "local" }], enable: ["cloud"] });
+        const st = mux.getStatus();
+        const local = st.members.find((m) => m.sourceId === "local:7");
+        (0, chai_1.expect)(local.status.state).to.equal("disconnected");
+    });
+});

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

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

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

@@ -0,0 +1,93 @@
+"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 });
+// src/test/multiplex-writes.test.ts
+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 multiplex_client_1 = require("../client/multiplex-client");
+const errors_1 = require("../client/errors");
+chai.use(chai_as_promised_1.default);
+const { expect: xp } = chai;
+function writeMember(id, scope, caps, sink) {
+    const noop = new Proxy({}, { get: () => () => Promise.resolve(undefined) });
+    const post = async (agentId) => { sink.push(`${id}:${agentId}`); return { id: "m", data: {}, attachments: [], author_id: "a", channel: { agent_id: agentId, name: "c" } }; };
+    return {
+        agents: noop, channels: noop,
+        messages: { postMessage: (a) => post(a) },
+        aggregates: { putAggregate: async (a) => { sink.push(`${id}:put:${a}`); return { data: {}, attachments: [] }; } },
+        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: scope, at: Date.now() }),
+        onStatusChange: () => () => { },
+        getAgentScope: async () => scope, getKnownAgentScope: () => scope,
+    };
+}
+(0, mocha_1.describe)("MultiplexClient writes", () => {
+    function mk(members) {
+        const factory = (d) => members[d.id];
+        return new multiplex_client_1.MultiplexClient({ factory, register: Object.keys(members).map((id) => ({ id, kind: id.startsWith("local") ? "local" : "cloud" })), enableAll: true });
+    }
+    (0, mocha_1.it)("routes to the single member that owns the agent and has the write cap", async () => {
+        const sink = [];
+        const mux = mk({
+            cloud: writeMember("cloud", { mode: "all" }, ["messages.post"], sink),
+            "local:7": writeMember("local:7", { mode: "list", agentIds: ["dev7"] }, ["messages.post"], sink),
+        });
+        // dev99 only owned by cloud (local:7 owns dev7) → routes to cloud
+        await mux.messages.postMessage("dev99", "c", { x: 1 });
+        (0, chai_1.expect)(sink).to.deep.equal(["cloud:dev99"]);
+    });
+    (0, mocha_1.it)("ambiguous when 2+ members own the agent and have the cap → AmbiguousWriteError", async () => {
+        const sink = [];
+        const mux = mk({
+            cloud: writeMember("cloud", { mode: "all" }, ["messages.post"], sink),
+            "local:7": writeMember("local:7", { mode: "list", agentIds: ["dev7"] }, ["messages.post"], sink),
+        });
+        await xp(mux.messages.postMessage("dev7", "c", { x: 1 })).to.be.rejectedWith(errors_1.AmbiguousWriteError);
+        // …unless scoped to one:
+        await mux.messages.postMessage("dev7", "c", { x: 1 }, { sources: ["local:7"] });
+        (0, chai_1.expect)(sink).to.deep.equal(["local:7:dev7"]);
+    });
+    (0, mocha_1.it)("no member with the cap → UnsupportedCapabilityError", async () => {
+        const mux = mk({ cloud: writeMember("cloud", { mode: "all" }, ["messages.list"], []) });
+        await xp(mux.messages.postMessage("dev7", "c", {})).to.be.rejectedWith(errors_1.UnsupportedCapabilityError);
+    });
+});

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

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

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const doover_client_1 = require("../client/doover-client");
+const helpers_1 = require("./helpers");
+function stripSource(v) {
+    return JSON.parse(JSON.stringify(v, (k, val) => (k === "__source" ? undefined : val)));
+}
+(0, mocha_1.describe)("provenance is additive only", () => {
+    (0, mocha_1.it)("REST payloads equal the wire body once __source is stripped", async () => {
+        const wire = { name: "c1", is_private: false, owner_id: "o", id: "ch1" };
+        const client = new doover_client_1.DooverClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: (0, helpers_1.createFetchMock)(() => (0, helpers_1.createJsonResponse)(wire)),
+            webSocketImpl: helpers_1.MockWebSocket,
+            disableBrowserLifecycleHooks: true,
+        });
+        const channel = await client.channels.getChannel("a1", "c1");
+        (0, chai_1.expect)(channel.__source).to.exist; // it IS stamped
+        (0, chai_1.expect)(stripSource(channel)).to.deep.equal(wire); // …but otherwise byte-identical
+    });
+    (0, mocha_1.it)("listMessages stamps each element, leaving the array shape intact", async () => {
+        const wire = [
+            { id: "2", data: { v: 2 }, attachments: [], author_id: "a", channel: { agent_id: "a1", name: "c1" } },
+            { id: "1", data: { v: 1 }, attachments: [], author_id: "a", channel: { agent_id: "a1", name: "c1" } },
+        ];
+        const client = new doover_client_1.DooverClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: (0, helpers_1.createFetchMock)(() => (0, helpers_1.createJsonResponse)(wire)),
+            webSocketImpl: helpers_1.MockWebSocket,
+            disableBrowserLifecycleHooks: true,
+        });
+        const msgs = await client.messages.listMessages("a1", "c1", { limit: 2 });
+        (0, chai_1.expect)(msgs).to.have.length(2);
+        (0, chai_1.expect)(msgs[0].__source?.via).to.include({ method: "messages.listMessages" });
+        // shape minus __source and the client-added `timestamp` matches the wire item
+        const { __source: _s, timestamp: _t, ...rest } = msgs[0];
+        (0, chai_1.expect)(rest).to.deep.equal(wire[0]);
+    });
+});

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

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

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const provenance_1 = require("../client/provenance");
+(0, mocha_1.describe)("ProvenanceStamper", () => {
+    const stamper = new provenance_1.ProvenanceStamper({ id: "cloud", kind: "cloud", meta: { x: 1 } });
+    (0, mocha_1.it)("stamps a plain object top-level", () => {
+        const out = stamper.stampRest({ a: 1 }, { method: "x.y", request: { z: 2 }, startedAt: 0, durationMs: 5, status: 200 });
+        (0, chai_1.expect)(out).to.include({ a: 1 });
+        (0, chai_1.expect)(out.__source?.client.id).to.equal("cloud");
+        (0, chai_1.expect)(out.__source?.via).to.deep.include({ transport: "rest", method: "x.y", durationMs: 5, status: 200 });
+    });
+    (0, mocha_1.it)("stamps each element of an array", () => {
+        const out = stamper.stampRest([{ a: 1 }, { a: 2 }], { method: "x.list", request: {}, startedAt: 0, durationMs: 1 });
+        (0, chai_1.expect)(out[0].__source?.client.kind).to.equal("cloud");
+        (0, chai_1.expect)(out[1].__source?.client.kind).to.equal("cloud");
+    });
+    (0, mocha_1.it)("stamps array-valued props one level deep (e.g. { results: [...] })", () => {
+        const out = stamper.stampRest({ results: [{ a: 1 }], count: 1 }, { method: "x.batch", request: {}, startedAt: 0, durationMs: 1 });
+        (0, chai_1.expect)(out.__source?.client.id).to.equal("cloud");
+        (0, chai_1.expect)(out.results[0].__source?.client.id).to.equal("cloud");
+    });
+    (0, mocha_1.it)("leaves Blobs and primitives untouched", () => {
+        const blob = new Blob(["x"]);
+        (0, chai_1.expect)(stamper.stampRest(blob, { method: "m", request: {}, startedAt: 0, durationMs: 1 })).to.equal(blob);
+        (0, chai_1.expect)(stamper.stampRest(undefined, { method: "m", request: {}, startedAt: 0, durationMs: 1 })).to.equal(undefined);
+    });
+    (0, mocha_1.it)("wrapSubclient stamps awaited results with subclient.method", async () => {
+        const api = { thing: async () => ({ a: 1 }), sync: () => 42 };
+        const wrapped = (0, provenance_1.wrapSubclient)(api, "channels", stamper);
+        const r = await wrapped.thing();
+        (0, chai_1.expect)(r.__source?.via).to.include({ method: "channels.thing", transport: "rest" });
+        (0, chai_1.expect)(wrapped.sync()).to.equal(42); // sync passthrough
+    });
+    (0, mocha_1.it)("stampGatewayEvent stamps payload + nested aggregate/message", () => {
+        const out = stamper.stampGatewayEvent({ author_id: "a", channel: { agent_id: "x", name: "c" }, aggregate: { data: {}, attachments: [] } }, { event: "aggregateUpdate", sessionId: "s1" });
+        (0, chai_1.expect)(out.__source?.via).to.deep.include({ transport: "gateway", event: "aggregateUpdate", sessionId: "s1" });
+        (0, chai_1.expect)(out.aggregate.__source?.via).to.deep.include({ transport: "gateway", event: "aggregateUpdate" });
+    });
+});

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

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

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+(0, mocha_1.describe)("SourceProvenance", () => {
+    (0, mocha_1.it)("is structurally usable on existing data shapes (compile-time)", () => {
+        const prov = {
+            client: { id: "cloud", kind: "cloud" },
+            retrievedAt: Date.now(),
+            via: { transport: "rest", method: "aggregates.getAggregate", request: {}, startedAt: 0, durationMs: 1 },
+        };
+        const agg = { data: {}, attachments: [], __source: prov };
+        (0, chai_1.expect)(agg.__source?.client.kind).to.equal("cloud");
+    });
+});

package/dist/test/react-client-status.test.d.ts

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