doover-js 0.5.4 → 0.6.0

package/dist/rpc/rpc-dispatcher.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcDispatcher = void 0;
+const errors_1 = require("./errors");
+function isRpcMessageData(data) {
+    return (typeof data === "object" &&
+        data !== null &&
+        "status" in data &&
+        "method" in data &&
+        "request" in data);
+}
+class RpcDispatcher {
+    constructor(gateway, messages) {
+        this.gateway = gateway;
+        this.messages = messages;
+        this.pending = new Map();
+        this.channelRefs = new Map();
+        this.stats = null;
+    }
+    setStats(collector) {
+        this.stats = collector;
+    }
+    send(channel, request, options) {
+        return new Promise((resolve, reject) => {
+            const channelRef = {
+                agent_id: channel.agentId,
+                name: channel.channelName,
+            };
+            const channelKey = `${channelRef.agent_id}/${channelRef.name}`;
+            this.acquireChannel(channelKey, channelRef);
+            const startedAt = this.stats?.recordRpcStart() ?? null;
+            this.messages
+                .postMessage(channel.agentId, channel.channelName, {
+                type: "rpc",
+                ...request,
+            })
+                .then((message) => {
+                const pending = {
+                    resolve: resolve,
+                    reject,
+                    onStatus: options?.onStatus,
+                    request: request,
+                    channelKey,
+                    channel: channelRef,
+                    startedAt,
+                };
+                if (options?.signal) {
+                    const onAbort = () => this.settle(message.id, "abort", undefined, options.signal?.reason);
+                    if (options.signal.aborted) {
+                        this.releaseChannel(channelKey);
+                        this.stats?.recordRpcEnd(startedAt, "abort");
+                        reject(options.signal.reason ?? new Error("Aborted"));
+                        return;
+                    }
+                    options.signal.addEventListener("abort", onAbort);
+                    pending.signal = options.signal;
+                    pending.abortListener = onAbort;
+                }
+                if (options?.timeoutMs !== undefined) {
+                    pending.timer = setTimeout(() => {
+                        this.settle(message.id, "timeout", undefined, new Error("RPC timed out"));
+                    }, options.timeoutMs);
+                }
+                this.pending.set(message.id, pending);
+            })
+                .catch((err) => {
+                // postMessage failed before we registered pending — release and reject.
+                this.releaseChannel(channelKey);
+                this.stats?.recordRpcEnd(startedAt, "error");
+                reject(err);
+            });
+        });
+    }
+    acquireChannel(channelKey, channelRef) {
+        const existing = this.channelRefs.get(channelKey);
+        if (existing) {
+            existing.refCount += 1;
+            return;
+        }
+        const handlers = {
+            onMessageUpdate: (msg, requestData) => this.route(msg, requestData),
+        };
+        const unsubscribe = this.gateway.subscribeToChannel(channelRef, handlers);
+        this.channelRefs.set(channelKey, { unsubscribe, refCount: 1 });
+    }
+    releaseChannel(channelKey) {
+        const entry = this.channelRefs.get(channelKey);
+        if (!entry)
+            return;
+        entry.refCount -= 1;
+        if (entry.refCount <= 0) {
+            entry.unsubscribe();
+            this.channelRefs.delete(channelKey);
+        }
+    }
+    route(msg, _requestData) {
+        const pending = this.pending.get(msg.id);
+        if (!pending)
+            return;
+        if (!isRpcMessageData(msg.data))
+            return;
+        const status = msg.data.status;
+        pending.onStatus?.(status);
+        if (status.code === "success") {
+            this.settle(msg.id, "success", msg.data.response);
+        }
+        else if (status.code === "error") {
+            this.settle(msg.id, "error", undefined, new errors_1.DooverRpcError(status, pending.request));
+        }
+    }
+    settle(messageId, outcome, response, rejection) {
+        const pending = this.pending.get(messageId);
+        if (!pending)
+            return;
+        this.pending.delete(messageId);
+        if (pending.timer)
+            clearTimeout(pending.timer);
+        if (pending.signal && pending.abortListener) {
+            pending.signal.removeEventListener("abort", pending.abortListener);
+        }
+        this.releaseChannel(pending.channelKey);
+        this.stats?.recordRpcEnd(pending.startedAt, outcome);
+        if (outcome === "success")
+            pending.resolve(response);
+        else
+            pending.reject(rejection);
+    }
+}
+exports.RpcDispatcher = RpcDispatcher;

package/dist/test/api-args.test.d.ts

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

package/dist/test/api-args.test.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const _args_1 = require("../apis/_args");
+describe("resolveChannelArgs", () => {
+    it("parses positional (agentId, channelName)", () => {
+        const result = (0, _args_1.resolveChannelArgs)(["a1", "c1"]);
+        (0, chai_1.expect)(result).to.deep.equal({ agentId: "a1", channelName: "c1", options: undefined });
+    });
+    it("parses positional with options", () => {
+        const result = (0, _args_1.resolveChannelArgs)(["a1", "c1", { x: 7 }]);
+        (0, chai_1.expect)(result).to.deep.equal({ agentId: "a1", channelName: "c1", options: { x: 7 } });
+    });
+    it("parses identifier object", () => {
+        const result = (0, _args_1.resolveChannelArgs)([
+            { agentId: "a1", channelName: "c1" },
+        ]);
+        (0, chai_1.expect)(result).to.deep.equal({ agentId: "a1", channelName: "c1", options: undefined });
+    });
+    it("parses identifier object with options", () => {
+        const result = (0, _args_1.resolveChannelArgs)([
+            { agentId: "a1", channelName: "c1" },
+            { x: 7 },
+        ]);
+        (0, chai_1.expect)(result).to.deep.equal({ agentId: "a1", channelName: "c1", options: { x: 7 } });
+    });
+});
+describe("resolveAgentArgs", () => {
+    it("parses positional agentId", () => {
+        const result = (0, _args_1.resolveAgentArgs)(["a1"]);
+        (0, chai_1.expect)(result).to.deep.equal({ agentId: "a1", options: undefined });
+    });
+    it("parses positional with options", () => {
+        const result = (0, _args_1.resolveAgentArgs)(["a1", { archived: true }]);
+        (0, chai_1.expect)(result).to.deep.equal({ agentId: "a1", options: { archived: true } });
+    });
+    it("parses identifier object", () => {
+        const result = (0, _args_1.resolveAgentArgs)([{ agentId: "a1" }]);
+        (0, chai_1.expect)(result).to.deep.equal({ agentId: "a1", options: undefined });
+    });
+    it("parses identifier object with options", () => {
+        const result = (0, _args_1.resolveAgentArgs)([
+            { agentId: "a1" },
+            { archived: true },
+        ]);
+        (0, chai_1.expect)(result).to.deep.equal({ agentId: "a1", options: { archived: true } });
+    });
+});

package/dist/test/api-overloads.test.d.ts

@@ -0,0 +1,9 @@
+import type { RestClient } from "../http/rest-client";
+interface RecordedCall {
+    method: "get" | "post" | "put" | "patch" | "delete" | "request";
+    args: unknown[];
+}
+export declare function makeRestStub(): RestClient & {
+    calls: RecordedCall[];
+};
+export {};

package/dist/test/api-overloads.test.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRestStub = makeRestStub;
+const chai_1 = require("chai");
+const channels_api_1 = require("../apis/channels-api");
+const messages_api_1 = require("../apis/messages-api");
+function makeRestStub() {
+    const calls = [];
+    const stub = {
+        calls,
+        get: (...args) => {
+            calls.push({ method: "get", args });
+            return Promise.resolve([]);
+        },
+        post: (...args) => {
+            calls.push({ method: "post", args });
+            return Promise.resolve(undefined);
+        },
+        put: (...args) => {
+            calls.push({ method: "put", args });
+            return Promise.resolve(undefined);
+        },
+        patch: (...args) => {
+            calls.push({ method: "patch", args });
+            return Promise.resolve(undefined);
+        },
+        delete: (...args) => {
+            calls.push({ method: "delete", args });
+            return Promise.resolve(undefined);
+        },
+        request: (...args) => {
+            calls.push({ method: "request", args });
+            return Promise.resolve(undefined);
+        },
+    };
+    return stub;
+}
+describe("ChannelsApi overloads", () => {
+    it("getChannel positional and identifier-object produce identical requests", async () => {
+        const restA = makeRestStub();
+        const restB = makeRestStub();
+        const apiA = new channels_api_1.ChannelsApi(restA);
+        const apiB = new channels_api_1.ChannelsApi(restB);
+        await apiA.getChannel("a1", "c1", { include_aggregate: true });
+        await apiB.getChannel({ agentId: "a1", channelName: "c1" }, { include_aggregate: true });
+        (0, chai_1.expect)(restA.calls).to.deep.equal(restB.calls);
+    });
+    it("listChannels positional and identifier-object produce identical requests", async () => {
+        const restA = makeRestStub();
+        const restB = makeRestStub();
+        const apiA = new channels_api_1.ChannelsApi(restA);
+        const apiB = new channels_api_1.ChannelsApi(restB);
+        await apiA.listChannels("a1", { include_archived: true });
+        await apiB.listChannels({ agentId: "a1" }, { include_archived: true });
+        (0, chai_1.expect)(restA.calls).to.deep.equal(restB.calls);
+    });
+    it("archiveChannel posts to /archive", async () => {
+        const rest = makeRestStub();
+        const api = new channels_api_1.ChannelsApi(rest);
+        await api.archiveChannel("a1", "c1");
+        (0, chai_1.expect)(rest.calls).to.deep.equal([
+            { method: "post", args: ["/agents/a1/channels/c1/archive", {}] },
+        ]);
+    });
+    it("unarchiveChannel posts to /unarchive", async () => {
+        const rest = makeRestStub();
+        const api = new channels_api_1.ChannelsApi(rest);
+        await api.unarchiveChannel({ agentId: "a1", channelName: "c1" });
+        (0, chai_1.expect)(rest.calls).to.deep.equal([
+            { method: "post", args: ["/agents/a1/channels/c1/unarchive", {}] },
+        ]);
+    });
+});
+describe("MessagesApi overloads + defaults", () => {
+    it("listMessages positional and identifier-object produce identical requests", async () => {
+        const restA = makeRestStub();
+        const restB = makeRestStub();
+        const apiA = new messages_api_1.MessagesApi(restA);
+        const apiB = new messages_api_1.MessagesApi(restB);
+        await apiA.listMessages("a1", "c1", { limit: 5, order: "desc" });
+        await apiB.listMessages({ agentId: "a1", channelName: "c1" }, { limit: 5, order: "desc" });
+        (0, chai_1.expect)(restA.calls).to.deep.equal(restB.calls);
+    });
+    it("listMessages defaults limit to 10 when omitted", async () => {
+        const rest = makeRestStub();
+        const api = new messages_api_1.MessagesApi(rest);
+        await api.listMessages("a1", "c1");
+        (0, chai_1.expect)(rest.calls).to.have.lengthOf(1);
+        const params = rest.calls[0].args[1];
+        (0, chai_1.expect)(params.limit).to.equal(10);
+        (0, chai_1.expect)(params.before, "before should be set to a snowflake id").to.be.a("string");
+    });
+    it("listMessages with order='asc' reverses the response array", async () => {
+        const rest = makeRestStub();
+        rest.get = ((..._args) => Promise.resolve([
+            { id: "3", data: {}, attachments: [], author_id: "a", channel: { agent_id: "a1", name: "c1" } },
+            { id: "2", data: {}, attachments: [], author_id: "a", channel: { agent_id: "a1", name: "c1" } },
+            { id: "1", data: {}, attachments: [], author_id: "a", channel: { agent_id: "a1", name: "c1" } },
+        ]));
+        const api = new messages_api_1.MessagesApi(rest);
+        const result = await api.listMessages("a1", "c1", { order: "asc", limit: 3 });
+        (0, chai_1.expect)(result.map((m) => m.id)).to.deep.equal(["1", "2", "3"]);
+    });
+    it("listMessages with order='desc' (default) preserves server order", async () => {
+        const rest = makeRestStub();
+        rest.get = ((..._args) => Promise.resolve([
+            { id: "3", data: {}, attachments: [], author_id: "a", channel: { agent_id: "a1", name: "c1" } },
+            { id: "2", data: {}, attachments: [], author_id: "a", channel: { agent_id: "a1", name: "c1" } },
+        ]));
+        const api = new messages_api_1.MessagesApi(rest);
+        const result = await api.listMessages("a1", "c1", { limit: 2 });
+        (0, chai_1.expect)(result.map((m) => m.id)).to.deep.equal(["3", "2"]);
+    });
+    it("getTimeseries strips order before sending to server", async () => {
+        const rest = makeRestStub();
+        const api = new messages_api_1.MessagesApi(rest);
+        await api.getTimeseries("a1", "c1", { limit: 5, order: "asc" });
+        (0, chai_1.expect)(rest.calls).to.have.lengthOf(1);
+        const wireParams = rest.calls[0].args[1];
+        (0, chai_1.expect)(wireParams.order).to.equal(undefined);
+        (0, chai_1.expect)(wireParams.limit).to.equal(5);
+    });
+});
+const aggregates_api_1 = require("../apis/aggregates-api");
+describe("AggregatesApi overloads", () => {
+    it("getAggregate positional and identifier-object produce identical requests", async () => {
+        const restA = makeRestStub();
+        const restB = makeRestStub();
+        const apiA = new aggregates_api_1.AggregatesApi(restA);
+        const apiB = new aggregates_api_1.AggregatesApi(restB);
+        await apiA.getAggregate("a1", "c1");
+        await apiB.getAggregate({ agentId: "a1", channelName: "c1" });
+        (0, chai_1.expect)(restA.calls).to.deep.equal(restB.calls);
+    });
+    it("patchAggregate identifier form passes through body and params", async () => {
+        const rest = makeRestStub();
+        const api = new aggregates_api_1.AggregatesApi(rest);
+        await api.patchAggregate({ agentId: "a1", channelName: "c1" }, { x: 1 }, { suppress_response: true });
+        (0, chai_1.expect)(rest.calls).to.deep.equal([
+            {
+                method: "patch",
+                args: ["/agents/a1/channels/c1/aggregate", { x: 1 }, { suppress_response: true }],
+            },
+        ]);
+    });
+});
+const alarms_api_1 = require("../apis/alarms-api");
+describe("AlarmsApi overloads", () => {
+    it("listAlarms positional and identifier-object produce identical requests", async () => {
+        const restA = makeRestStub();
+        const restB = makeRestStub();
+        const apiA = new alarms_api_1.AlarmsApi(restA);
+        const apiB = new alarms_api_1.AlarmsApi(restB);
+        await apiA.listAlarms("a1", "c1");
+        await apiB.listAlarms({ agentId: "a1", channelName: "c1" });
+        (0, chai_1.expect)(restA.calls).to.deep.equal(restB.calls);
+    });
+    it("getAlarm via identifier hits expected path", async () => {
+        const rest = makeRestStub();
+        const api = new alarms_api_1.AlarmsApi(rest);
+        await api.getAlarm({ agentId: "a1", channelName: "c1" }, "alm1");
+        (0, chai_1.expect)(rest.calls).to.deep.equal([
+            { method: "get", args: ["/agents/a1/channels/c1/alarms/alm1"] },
+        ]);
+    });
+});
+const connections_api_1 = require("../apis/connections-api");
+describe("ConnectionsApi overloads", () => {
+    it("getAgentConnections positional and identifier-object produce identical requests", async () => {
+        const restA = makeRestStub();
+        const restB = makeRestStub();
+        const apiA = new connections_api_1.ConnectionsApi(restA);
+        const apiB = new connections_api_1.ConnectionsApi(restB);
+        await apiA.getAgentConnections("a1");
+        await apiB.getAgentConnections({ agentId: "a1" });
+        (0, chai_1.expect)(restA.calls).to.deep.equal(restB.calls);
+    });
+    it("getChannelSubscriptions identifier form hits expected path", async () => {
+        const rest = makeRestStub();
+        const api = new connections_api_1.ConnectionsApi(rest);
+        await api.getChannelSubscriptions({ agentId: "a1", channelName: "c1" });
+        (0, chai_1.expect)(rest.calls).to.deep.equal([
+            { method: "get", args: ["/agents/a1/channels/c1/subscriptions"] },
+        ]);
+    });
+});
+const notifications_api_1 = require("../apis/notifications-api");
+describe("NotificationsApi overloads", () => {
+    it("getAgentNotifications positional and identifier-object produce identical requests", async () => {
+        const restA = makeRestStub();
+        const restB = makeRestStub();
+        const apiA = new notifications_api_1.NotificationsApi(restA);
+        const apiB = new notifications_api_1.NotificationsApi(restB);
+        await apiA.getAgentNotifications("a1");
+        await apiB.getAgentNotifications({ agentId: "a1" });
+        (0, chai_1.expect)(restA.calls).to.deep.equal(restB.calls);
+    });
+    it("updateNotificationEndpoint identifier form preserves endpointId and body", async () => {
+        const rest = makeRestStub();
+        const api = new notifications_api_1.NotificationsApi(rest);
+        await api.updateNotificationEndpoint({ agentId: "a1" }, "ep1", { name: "x" });
+        (0, chai_1.expect)(rest.calls).to.deep.equal([
+            {
+                method: "patch",
+                args: ["/agents/a1/notifications/endpoints/ep1", { name: "x" }],
+            },
+        ]);
+    });
+});
+const permissions_api_1 = require("../apis/permissions-api");
+describe("PermissionsApi overloads", () => {
+    it("getAgentPermission positional and identifier-object produce identical requests", async () => {
+        const restA = makeRestStub();
+        const restB = makeRestStub();
+        const apiA = new permissions_api_1.PermissionsApi(restA);
+        const apiB = new permissions_api_1.PermissionsApi(restB);
+        await apiA.getAgentPermission("a1");
+        await apiB.getAgentPermission({ agentId: "a1" });
+        (0, chai_1.expect)(restA.calls).to.deep.equal(restB.calls);
+    });
+});
+const processors_api_1 = require("../apis/processors-api");
+describe("ProcessorsApi overloads", () => {
+    it("createProcessorSchedule identifier form hits expected path", async () => {
+        const rest = makeRestStub();
+        const api = new processors_api_1.ProcessorsApi(rest);
+        await api.createProcessorSchedule({ agentId: "a1" }, "sch1", { foo: "bar" });
+        (0, chai_1.expect)(rest.calls).to.deep.equal([
+            {
+                method: "put",
+                args: ["/agents/a1/processors/schedules/sch1", { foo: "bar" }],
+            },
+        ]);
+    });
+});
+const agents_api_1 = require("../apis/agents-api");
+describe("AgentsApi listAgents", () => {
+    it("calls /agents/ on controlApiUrl with omitSharingHeader", async () => {
+        const rest = makeRestStub();
+        const api = new agents_api_1.AgentsApi(rest, "https://control.example.com");
+        rest.request = ((...args) => {
+            rest.calls.push({ method: "request", args });
+            return Promise.resolve({ agents: [] });
+        });
+        await api.listAgents({ includeArchived: true });
+        (0, chai_1.expect)(rest.calls).to.have.lengthOf(1);
+        (0, chai_1.expect)(rest.calls[0].method).to.equal("request");
+        const req = rest.calls[0].args[0];
+        (0, chai_1.expect)(req.path).to.equal("/agents/");
+        (0, chai_1.expect)(req.baseUrl).to.equal("https://control.example.com");
+        (0, chai_1.expect)(req.omitSharingHeader).to.equal(true);
+        (0, chai_1.expect)(req.query).to.deep.equal({ "include-archived": true });
+    });
+    it("normalises agent entries and merges organisations/users when requested", async () => {
+        const rest = makeRestStub();
+        rest.request = ((..._args) => Promise.resolve({
+            agents: [
+                { id: "a1", name: "Agent One", type: "device" },
+            ],
+            organisations: [{ id: "o1", name: "Org One" }],
+            users: [{ id: "u1", name: "User One" }],
+        }));
+        const api = new agents_api_1.AgentsApi(rest);
+        const result = await api.listAgents({
+            includeOrganisations: true,
+            includeUsers: true,
+            mergeIncludedAsAgents: true,
+        });
+        (0, chai_1.expect)(result.results).to.have.lengthOf(3);
+        (0, chai_1.expect)(result.count).to.equal(3);
+        const ids = (result.results ?? []).map((a) => a.id).sort();
+        (0, chai_1.expect)(ids).to.deep.equal(["a1", "o1", "u1"]);
+        const types = (result.results ?? []).map((a) => a.type).sort();
+        (0, chai_1.expect)(types).to.deep.equal(["device", "organisation", "user"]);
+    });
+});

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

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

package/dist/test/capabilities.test.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const capabilities_1 = require("../client/capabilities");
+(0, mocha_1.describe)("Capability", () => {
+    (0, mocha_1.it)("ALL_CAPABILITIES has no duplicates and includes the core set", () => {
+        (0, chai_1.expect)(new Set(capabilities_1.ALL_CAPABILITIES).size).to.equal(capabilities_1.ALL_CAPABILITIES.length);
+        for (const cap of [
+            "agents.list",
+            "channels.list",
+            "channels.get",
+            "channels.create",
+            "channels.archive",
+            "aggregates.get",
+            "aggregates.put",
+            "aggregates.patch",
+            "messages.list",
+            "messages.listHistorical",
+            "messages.post",
+            "gateway.subscribe",
+            "gateway.realtime",
+        ]) {
+            (0, chai_1.expect)(capabilities_1.ALL_CAPABILITIES).to.include(cap);
+        }
+    });
+});

package/dist/test/data-client-errors.test.d.ts

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

package/dist/test/data-client-errors.test.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const errors_1 = require("../client/errors");
+const errors_2 = require("../http/errors");
+(0, mocha_1.describe)("DataClient errors", () => {
+    (0, mocha_1.it)("UnsupportedCapabilityError carries the capability and clientId", () => {
+        const err = new errors_1.UnsupportedCapabilityError("messages.listHistorical", "local:1");
+        (0, chai_1.expect)(err).to.be.instanceOf(errors_2.DooverApiError);
+        (0, chai_1.expect)(err.capability).to.equal("messages.listHistorical");
+        (0, chai_1.expect)(err.clientId).to.equal("local:1");
+        (0, chai_1.expect)(err.message).to.include("messages.listHistorical");
+        (0, chai_1.expect)(err.name).to.equal("UnsupportedCapabilityError");
+    });
+    (0, mocha_1.it)("AmbiguousWriteError lists candidate source ids", () => {
+        const err = new errors_1.AmbiguousWriteError("messages.post", ["cloud", "local:1"]);
+        (0, chai_1.expect)(err).to.be.instanceOf(errors_2.DooverApiError);
+        (0, chai_1.expect)(err.capability).to.equal("messages.post");
+        (0, chai_1.expect)(err.candidateSourceIds).to.deep.equal(["cloud", "local:1"]);
+        (0, chai_1.expect)(err.message).to.include("cloud");
+        (0, chai_1.expect)(err.message).to.include("local:1");
+    });
+});

package/dist/test/data-client-shape.test.d.ts

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

package/dist/test/data-client-shape.test.js

@@ -0,0 +1,28 @@
+"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");
+(0, mocha_1.describe)("DataClient shape", () => {
+    (0, mocha_1.it)("DooverClient is assignable to DataClient (compile-time) and has the contract methods", () => {
+        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)(),
+            webSocketImpl: helpers_1.MockWebSocket,
+            disableBrowserLifecycleHooks: true,
+        });
+        (0, chai_1.expect)(client.agents).to.exist;
+        (0, chai_1.expect)(client.gateway).to.exist;
+        (0, chai_1.expect)(client.rpc).to.exist;
+        (0, chai_1.expect)(typeof client.getCapabilities).to.equal("function");
+        (0, chai_1.expect)(typeof client.supports).to.equal("function");
+        (0, chai_1.expect)(typeof client.isConnected).to.equal("function");
+        (0, chai_1.expect)(typeof client.getStatus).to.equal("function");
+        (0, chai_1.expect)(typeof client.onStatusChange).to.equal("function");
+        (0, chai_1.expect)(typeof client.getAgentScope).to.equal("function");
+        (0, chai_1.expect)(typeof client.getKnownAgentScope).to.equal("function");
+    });
+});

package/dist/test/doover-client-dataclient.test.d.ts

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

package/dist/test/doover-client-dataclient.test.js

@@ -0,0 +1,58 @@
+"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 capabilities_1 = require("../client/capabilities");
+const helpers_1 = require("./helpers");
+function makeClient(extra = {}) {
+    return 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)(),
+        webSocketImpl: helpers_1.MockWebSocket,
+        disableBrowserLifecycleHooks: true,
+        ...extra,
+    });
+}
+(0, mocha_1.describe)("DooverClient as DataClient", () => {
+    (0, mocha_1.it)("advertises the full capability set", () => {
+        const caps = makeClient().getCapabilities();
+        for (const c of capabilities_1.ALL_CAPABILITIES)
+            (0, chai_1.expect)(caps.has(c)).to.equal(true);
+        (0, chai_1.expect)(makeClient().supports("messages.listHistorical")).to.equal(true);
+    });
+    (0, mocha_1.it)("getAgentScope resolves to { mode: 'all' } with no network call", async () => {
+        const fetchMock = (0, helpers_1.createFetchMock)();
+        const client = makeClient({ fetchImpl: fetchMock });
+        (0, chai_1.expect)(await client.getAgentScope()).to.deep.equal({ mode: "all" });
+        (0, chai_1.expect)(client.getKnownAgentScope()).to.deep.equal({ mode: "all" });
+        (0, chai_1.expect)(fetchMock.called).to.equal(false);
+    });
+    (0, mocha_1.it)("isConnected mirrors the gateway; getStatus reflects it; clientId defaults to 'cloud'", () => {
+        const client = makeClient();
+        (0, chai_1.expect)(client.isConnected()).to.equal(false);
+        const status = client.getStatus();
+        (0, chai_1.expect)(status.clientId).to.equal("cloud");
+        (0, chai_1.expect)(status.connected).to.equal(false);
+        (0, chai_1.expect)(status.agentScope).to.deep.equal({ mode: "all" });
+    });
+    (0, mocha_1.it)("honours a custom sourceId", () => {
+        (0, chai_1.expect)(makeClient({ sourceId: "cloud-eu" }).getStatus().clientId).to.equal("cloud-eu");
+    });
+    (0, mocha_1.it)("onStatusChange fires on gateway lifecycle and unsubscribes", async () => {
+        const client = makeClient();
+        const seen = [];
+        const off = client.onStatusChange(() => seen.push(1));
+        // Connect gateway and drive a lifecycle event
+        await client.gateway.connect();
+        const ws = helpers_1.MockWebSocket.instances[helpers_1.MockWebSocket.instances.length - 1];
+        ws?.open?.();
+        (0, chai_1.expect)(seen.length).to.be.greaterThan(0);
+        off();
+        const len = seen.length;
+        ws?.close?.();
+        (0, chai_1.expect)(seen.length).to.equal(len);
+    });
+});

package/dist/test/doover-client-provenance.test.d.ts

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

package/dist/test/doover-client-provenance.test.js

@@ -0,0 +1,32 @@
+"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");
+(0, mocha_1.describe)("DooverClient REST provenance", () => {
+    (0, mocha_1.it)("stamps __source on REST results", async () => {
+        const fetchMock = (0, helpers_1.createFetchMock)((url) => {
+            if (url.includes("/channels/c1"))
+                return (0, helpers_1.createJsonResponse)({ name: "c1", is_private: false, owner_id: "o" });
+            return (0, helpers_1.createJsonResponse)({});
+        });
+        const client = new doover_client_1.DooverClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+            webSocketImpl: helpers_1.MockWebSocket,
+            disableBrowserLifecycleHooks: true,
+            sourceId: "cloud",
+        });
+        const channel = await client.channels.getChannel("a1", "c1");
+        (0, chai_1.expect)(channel.name).to.equal("c1");
+        (0, chai_1.expect)(channel.__source?.client).to.deep.include({ id: "cloud", kind: "cloud" });
+        (0, chai_1.expect)(channel.__source?.via).to.include({ transport: "rest", method: "channels.getChannel" });
+        if (channel.__source?.via.transport === "rest") {
+            (0, chai_1.expect)(channel.__source.via.durationMs).to.be.a("number");
+            (0, chai_1.expect)(channel.__source.via.request).to.have.property("args");
+        }
+    });
+});

package/dist/test/exports.test.d.ts

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