@sudobility/sider_client 0.0.2 → 0.1.2

package/dist/core.d.ts

@@ -1,2 +1,3 @@
-export * from "./client";
-export type { CaptureRequest, CaptureResponse, PlannerStep, PlanStartResponse, PlanStepResponse, SiteLookupResult, StatsResponse, ToolCatalog, } from "@sudobility/sider_types";
+export { SiderClient } from "./network/SiderClient";
+export { createFetchNetworkClient } from "./network/fetchClient";
+export type * from "@sudobility/sider_types";

package/dist/core.js

@@ -1,2 +1,3 @@
-// React-free entry point (for service workers / non-React contexts).
-export * from "./client";
+// React-free entry for service workers / non-React contexts.
+export { SiderClient } from "./network/SiderClient";
+export { createFetchNetworkClient } from "./network/fetchClient";

package/dist/hooks.d.ts

@@ -1,6 +1,23 @@
+import { type UseQueryOptions } from "@tanstack/react-query";
+import type { NetworkClient } from "@sudobility/types";
 import type { CaptureRequest } from "@sudobility/sider_types";
-export declare function useSiteLookup(origin: string): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@sudobility/sider_types").SiteLookupResult>, Error>;
-export declare function useStats(): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@sudobility/sider_types").StatsResponse>, Error>;
-export declare function useSites(): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@sudobility/sider_types").Site[]>, Error>;
-export declare function useToolCatalog(siteId: string | undefined, includeProvisional?: boolean): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@sudobility/sider_types").ToolCatalog>, Error>;
-export declare function useCaptureUpload(): import("@tanstack/react-query").UseMutationResult<import("@sudobility/sider_types").CaptureResponse, Error, CaptureRequest, unknown>;
+import { SiderClient } from "./network/SiderClient";
+type QueryOpts<T> = Omit<UseQueryOptions<T>, "queryKey" | "queryFn">;
+export declare function useSiteLookup(networkClient: NetworkClient, baseUrl: string, _token: string, origin: string | null, options?: QueryOpts<Awaited<ReturnType<SiderClient["lookup"]>>>): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@sudobility/sider_types").SiteLookupResult>, Error>;
+export declare function useSites(networkClient: NetworkClient, baseUrl: string, _token: string, options?: QueryOpts<Awaited<ReturnType<SiderClient["listSites"]>>>): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@sudobility/sider_types").Site[]>, Error>;
+export declare function useSite(networkClient: NetworkClient, baseUrl: string, _token: string, siteId: string | null, options?: QueryOpts<Awaited<ReturnType<SiderClient["getSite"]>>>): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@sudobility/sider_types").Site>, Error>;
+export declare function useStats(networkClient: NetworkClient, baseUrl: string, _token: string, options?: QueryOpts<Awaited<ReturnType<SiderClient["getStats"]>>>): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@sudobility/sider_types").StatsResponse>, Error>;
+export declare function useToolCatalog(networkClient: NetworkClient, baseUrl: string, _token: string, siteId: string | null, opts?: {
+    includeProvisional?: boolean;
+    includeFlagged?: boolean;
+}, options?: QueryOpts<Awaited<ReturnType<SiderClient["getTools"]>>>): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@sudobility/sider_types").ToolCatalog>, Error>;
+export declare function useSiteTemplates(networkClient: NetworkClient, baseUrl: string, _token: string, siteId: string | null, options?: QueryOpts<Awaited<ReturnType<SiderClient["getSiteTemplates"]>>>): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@sudobility/sider_types").EndpointTemplate[]>, Error>;
+export declare function useSiteSlots(networkClient: NetworkClient, baseUrl: string, _token: string, siteId: string | null, options?: QueryOpts<Awaited<ReturnType<SiderClient["getSiteSlots"]>>>): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@sudobility/sider_types").SecretSlot[]>, Error>;
+export declare function useSiteGraph(networkClient: NetworkClient, baseUrl: string, _token: string, siteId: string | null, options?: QueryOpts<Awaited<ReturnType<SiderClient["getSiteGraph"]>>>): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@sudobility/sider_types").EndpointGraphEdge[]>, Error>;
+export declare function useToolDetail(networkClient: NetworkClient, baseUrl: string, _token: string, toolId: string | null, options?: QueryOpts<Awaited<ReturnType<SiderClient["getToolDetail"]>>>): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@sudobility/sider_types").ToolDetailResponse>, Error>;
+export declare function useMe(networkClient: NetworkClient, baseUrl: string, token: string, options?: QueryOpts<Awaited<ReturnType<SiderClient["getMe"]>>>): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@sudobility/sider_types").MeResponse>, Error>;
+export declare function useMyCaptureBatches(networkClient: NetworkClient, baseUrl: string, token: string, siteId?: string, options?: QueryOpts<Awaited<ReturnType<SiderClient["getMyCaptureBatches"]>>>): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@sudobility/sider_types").MyCaptureBatchSummary[]>, Error>;
+export declare function useMyCaptureBatch(networkClient: NetworkClient, baseUrl: string, token: string, batchId: string | null, options?: QueryOpts<Awaited<ReturnType<SiderClient["getMyCaptureBatch"]>>>): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@sudobility/sider_types").MyCaptureBatchDetail>, Error>;
+export declare function useMyTools(networkClient: NetworkClient, baseUrl: string, token: string, options?: QueryOpts<Awaited<ReturnType<SiderClient["getMyTools"]>>>): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@sudobility/sider_types").MyToolEntry[]>, Error>;
+export declare function useCaptureUpload(networkClient: NetworkClient, baseUrl: string, _token: string): import("@tanstack/react-query").UseMutationResult<import("@sudobility/sider_types").CaptureResponse, Error, CaptureRequest, unknown>;
+export {};

package/dist/hooks.js

@@ -1,30 +1,120 @@
 import { useMutation, useQuery } from "@tanstack/react-query";
-import { useSiderClient } from "./context";
-export function useSiteLookup(origin) {
-    const client = useSiderClient();
+import { SiderClient } from "./network/SiderClient";
+function client(networkClient, baseUrl) {
+    return new SiderClient(networkClient, baseUrl);
+}
+// --- public data: enabled regardless of token ------------------------------
+export function useSiteLookup(networkClient, baseUrl, _token, origin, options) {
     return useQuery({
         queryKey: ["sider", "lookup", origin],
-        queryFn: () => client.lookup(origin),
-        enabled: Boolean(origin),
+        queryFn: () => client(networkClient, baseUrl).lookup(origin),
+        ...options,
+        enabled: !!origin && (options?.enabled ?? true),
     });
 }
-export function useStats() {
-    const client = useSiderClient();
-    return useQuery({ queryKey: ["sider", "stats"], queryFn: () => client.getStats() });
+export function useSites(networkClient, baseUrl, _token, options) {
+    return useQuery({
+        queryKey: ["sider", "sites"],
+        queryFn: () => client(networkClient, baseUrl).listSites(),
+        ...options,
+    });
+}
+export function useSite(networkClient, baseUrl, _token, siteId, options) {
+    return useQuery({
+        queryKey: ["sider", "site", siteId],
+        queryFn: () => client(networkClient, baseUrl).getSite(siteId),
+        ...options,
+        enabled: !!siteId && (options?.enabled ?? true),
+    });
+}
+export function useStats(networkClient, baseUrl, _token, options) {
+    return useQuery({
+        queryKey: ["sider", "stats"],
+        queryFn: () => client(networkClient, baseUrl).getStats(),
+        ...options,
+    });
 }
-export function useSites() {
-    const client = useSiderClient();
-    return useQuery({ queryKey: ["sider", "sites"], queryFn: () => client.listSites() });
+export function useToolCatalog(networkClient, baseUrl, _token, siteId, opts, options) {
+    return useQuery({
+        queryKey: [
+            "sider",
+            "tools",
+            siteId,
+            opts?.includeProvisional ?? false,
+            opts?.includeFlagged ?? false,
+        ],
+        queryFn: () => client(networkClient, baseUrl).getTools(siteId, opts),
+        ...options,
+        enabled: !!siteId && (options?.enabled ?? true),
+    });
+}
+export function useSiteTemplates(networkClient, baseUrl, _token, siteId, options) {
+    return useQuery({
+        queryKey: ["sider", "templates", siteId],
+        queryFn: () => client(networkClient, baseUrl).getSiteTemplates(siteId),
+        ...options,
+        enabled: !!siteId && (options?.enabled ?? true),
+    });
+}
+export function useSiteSlots(networkClient, baseUrl, _token, siteId, options) {
+    return useQuery({
+        queryKey: ["sider", "slots", siteId],
+        queryFn: () => client(networkClient, baseUrl).getSiteSlots(siteId),
+        ...options,
+        enabled: !!siteId && (options?.enabled ?? true),
+    });
 }
-export function useToolCatalog(siteId, includeProvisional = false) {
-    const client = useSiderClient();
+export function useSiteGraph(networkClient, baseUrl, _token, siteId, options) {
     return useQuery({
-        queryKey: ["sider", "tools", siteId, includeProvisional],
-        queryFn: () => client.getTools(siteId, includeProvisional),
-        enabled: Boolean(siteId),
+        queryKey: ["sider", "graph", siteId],
+        queryFn: () => client(networkClient, baseUrl).getSiteGraph(siteId),
+        ...options,
+        enabled: !!siteId && (options?.enabled ?? true),
     });
 }
-export function useCaptureUpload() {
-    const client = useSiderClient();
-    return useMutation({ mutationFn: (v) => client.uploadCapture(v) });
+export function useToolDetail(networkClient, baseUrl, _token, toolId, options) {
+    return useQuery({
+        queryKey: ["sider", "tool", toolId],
+        queryFn: () => client(networkClient, baseUrl).getToolDetail(toolId),
+        ...options,
+        enabled: !!toolId && (options?.enabled ?? true),
+    });
+}
+// --- per-user data: gated on the token -------------------------------------
+export function useMe(networkClient, baseUrl, token, options) {
+    return useQuery({
+        queryKey: ["sider", "me", token ? "authed" : "anon"],
+        queryFn: () => client(networkClient, baseUrl).getMe(),
+        ...options,
+        enabled: !!token && (options?.enabled ?? true),
+    });
+}
+export function useMyCaptureBatches(networkClient, baseUrl, token, siteId, options) {
+    return useQuery({
+        queryKey: ["sider", "my-batches", siteId ?? "all"],
+        queryFn: () => client(networkClient, baseUrl).getMyCaptureBatches(siteId),
+        ...options,
+        enabled: !!token && (options?.enabled ?? true),
+    });
+}
+export function useMyCaptureBatch(networkClient, baseUrl, token, batchId, options) {
+    return useQuery({
+        queryKey: ["sider", "my-batch", batchId],
+        queryFn: () => client(networkClient, baseUrl).getMyCaptureBatch(batchId),
+        ...options,
+        enabled: !!token && !!batchId && (options?.enabled ?? true),
+    });
+}
+export function useMyTools(networkClient, baseUrl, token, options) {
+    return useQuery({
+        queryKey: ["sider", "my-tools"],
+        queryFn: () => client(networkClient, baseUrl).getMyTools(),
+        ...options,
+        enabled: !!token && (options?.enabled ?? true),
+    });
+}
+export function useCaptureUpload(networkClient, baseUrl, _token) {
+    return useMutation({
+        mutationFn: (body) => client(networkClient, baseUrl).uploadCapture(body),
+    });
 }

package/dist/index.d.ts

@@ -1,4 +1,2 @@
-export * from "./client";
-export * from "./context";
+export * from "./core";
 export * from "./hooks";
-export type { CaptureRequest, CaptureResponse, PlannerStep, PlanStartResponse, PlanStepResponse, SiteLookupResult, StatsResponse, ToolCatalog, } from "@sudobility/sider_types";

package/dist/index.js

@@ -1,4 +1,3 @@
-// @sudobility/sider_client — typed API client + React Query hooks for sider_api.
-export * from "./client";
-export * from "./context";
+// @sudobility/sider_client — injected NetworkClient + React Query hooks for sider_api.
+export * from "./core";
 export * from "./hooks";

package/dist/network/SiderClient.d.ts

@@ -0,0 +1,31 @@
+import type { NetworkClient } from "@sudobility/types";
+import type { CaptureRequest, CaptureResponse, EndpointGraphEdge, EndpointTemplate, MeResponse, MyCaptureBatchDetail, MyCaptureBatchSummary, MyToolEntry, SecretSlot, Site, SiteLookupResult, StatsResponse, ToolCatalog, ToolDetailResponse } from "@sudobility/sider_types";
+/**
+ * Typed wrapper over the Sider API. Auth is the injected NetworkClient's
+ * concern (e.g. auth_lib's Firebase Bearer client); this class only builds
+ * URLs and unwraps the ApiResponse envelope.
+ */
+export declare class SiderClient {
+    private readonly network;
+    private readonly baseUrl;
+    constructor(network: NetworkClient, baseUrl: string);
+    private unwrap;
+    private get;
+    lookup(origin: string): Promise<SiteLookupResult>;
+    listSites(): Promise<Site[]>;
+    getSite(id: string): Promise<Site>;
+    getStats(): Promise<StatsResponse>;
+    getTools(siteId: string, opts?: {
+        includeProvisional?: boolean;
+        includeFlagged?: boolean;
+    }): Promise<ToolCatalog>;
+    uploadCapture(body: CaptureRequest): Promise<CaptureResponse>;
+    getMe(): Promise<MeResponse>;
+    getMyCaptureBatches(siteId?: string): Promise<MyCaptureBatchSummary[]>;
+    getMyCaptureBatch(id: string): Promise<MyCaptureBatchDetail>;
+    getMyTools(): Promise<MyToolEntry[]>;
+    getSiteTemplates(siteId: string): Promise<EndpointTemplate[]>;
+    getSiteSlots(siteId: string): Promise<SecretSlot[]>;
+    getSiteGraph(siteId: string): Promise<EndpointGraphEdge[]>;
+    getToolDetail(toolId: string): Promise<ToolDetailResponse>;
+}

package/dist/network/SiderClient.js

@@ -0,0 +1,71 @@
+/**
+ * Typed wrapper over the Sider API. Auth is the injected NetworkClient's
+ * concern (e.g. auth_lib's Firebase Bearer client); this class only builds
+ * URLs and unwraps the ApiResponse envelope.
+ */
+export class SiderClient {
+    network;
+    baseUrl;
+    constructor(network, baseUrl) {
+        this.network = network;
+        this.baseUrl = baseUrl;
+    }
+    unwrap(res) {
+        const body = res.data;
+        if (!body || body.success !== true) {
+            throw new Error(body?.error ?? `sider api error (${res.status})`);
+        }
+        return body.data;
+    }
+    async get(path) {
+        return this.unwrap(await this.network.get(`${this.baseUrl}${path}`));
+    }
+    lookup(origin) {
+        return this.get(`/api/v1/sites/lookup?origin=${encodeURIComponent(origin)}`);
+    }
+    listSites() {
+        return this.get("/api/v1/sites");
+    }
+    getSite(id) {
+        return this.get(`/api/v1/sites/${id}`);
+    }
+    getStats() {
+        return this.get("/api/v1/stats");
+    }
+    getTools(siteId, opts) {
+        const q = new URLSearchParams();
+        if (opts?.includeProvisional)
+            q.set("includeProvisional", "1");
+        if (opts?.includeFlagged)
+            q.set("includeFlagged", "1");
+        const qs = q.toString();
+        return this.get(`/api/v1/sites/${siteId}/tools${qs ? `?${qs}` : ""}`);
+    }
+    async uploadCapture(body) {
+        return this.unwrap(await this.network.post(`${this.baseUrl}/api/v1/capture`, body));
+    }
+    getMe() {
+        return this.get("/api/v1/me");
+    }
+    getMyCaptureBatches(siteId) {
+        return this.get(`/api/v1/me/capture-batches${siteId ? `?siteId=${encodeURIComponent(siteId)}` : ""}`);
+    }
+    getMyCaptureBatch(id) {
+        return this.get(`/api/v1/me/capture-batches/${id}`);
+    }
+    getMyTools() {
+        return this.get("/api/v1/me/tools");
+    }
+    getSiteTemplates(siteId) {
+        return this.get(`/api/v1/sites/${siteId}/templates`);
+    }
+    getSiteSlots(siteId) {
+        return this.get(`/api/v1/sites/${siteId}/slots`);
+    }
+    getSiteGraph(siteId) {
+        return this.get(`/api/v1/sites/${siteId}/graph`);
+    }
+    getToolDetail(toolId) {
+        return this.get(`/api/v1/tools/${toolId}`);
+    }
+}

package/dist/network/SiderClient.test.d.ts

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

package/dist/network/SiderClient.test.js

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import { SiderClient } from "./SiderClient";
+function stubNetwork(data, ok = true) {
+    const calls = [];
+    const respond = (url) => {
+        calls.push(url);
+        return Promise.resolve({
+            ok,
+            status: ok ? 200 : 500,
+            statusText: ok ? "OK" : "ERR",
+            headers: {},
+            data: { success: ok, data, error: ok ? undefined : "boom" },
+        });
+    };
+    const client = {
+        request: (url) => respond(url),
+        get: (url) => respond(url),
+        post: (url) => respond(url),
+        put: (url) => respond(url),
+        delete: (url) => respond(url),
+    };
+    return { client, calls };
+}
+describe("SiderClient", () => {
+    test("builds URLs and unwraps the ApiResponse envelope", async () => {
+        const { client, calls } = stubNetwork([{ id: "s1" }]);
+        const sider = new SiderClient(client, "http://localhost:8090");
+        const sites = await sider.listSites();
+        expect(sites).toEqual([{ id: "s1" }]);
+        expect(calls[0]).toBe("http://localhost:8090/api/v1/sites");
+    });
+    test("encodes query params", async () => {
+        const { client, calls } = stubNetwork({ known: false });
+        const sider = new SiderClient(client, "http://localhost:8090");
+        await sider.lookup("https://a.example");
+        expect(calls[0]).toBe("http://localhost:8090/api/v1/sites/lookup?origin=https%3A%2F%2Fa.example");
+    });
+    test("getTools flags map to query params", async () => {
+        const { client, calls } = stubNetwork({ tools: [] });
+        const sider = new SiderClient(client, "http://localhost:8090");
+        await sider.getTools("s1", { includeProvisional: true });
+        expect(calls[0]).toBe("http://localhost:8090/api/v1/sites/s1/tools?includeProvisional=1");
+    });
+    test("throws the envelope error on failure", async () => {
+        const { client } = stubNetwork(null, false);
+        const sider = new SiderClient(client, "http://localhost:8090");
+        await expect(sider.getStats()).rejects.toThrow("boom");
+    });
+});

package/dist/network/fetchClient.d.ts

@@ -0,0 +1,9 @@
+import type { NetworkClient } from "@sudobility/types";
+type HeaderSource = Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+/**
+ * Plain fetch-backed NetworkClient for non-React contexts (service worker,
+ * tests, Node scripts). `getHeaders` is merged into every request — e.g.
+ * `async () => ({ authorization: `Bearer ${token}` })`.
+ */
+export declare function createFetchNetworkClient(getHeaders?: HeaderSource): NetworkClient;
+export {};

package/dist/network/fetchClient.js

@@ -0,0 +1,51 @@
+/**
+ * Plain fetch-backed NetworkClient for non-React contexts (service worker,
+ * tests, Node scripts). `getHeaders` is merged into every request — e.g.
+ * `async () => ({ authorization: `Bearer ${token}` })`.
+ */
+export function createFetchNetworkClient(getHeaders) {
+    async function request(url, options) {
+        const extra = typeof getHeaders === "function" ? await getHeaders() : (getHeaders ?? {});
+        const res = await fetch(url, {
+            method: options?.method ?? "GET",
+            headers: { "content-type": "application/json", ...extra, ...options?.headers },
+            body: options?.body ?? undefined,
+            signal: options?.signal ?? undefined,
+        });
+        const headers = {};
+        res.headers.forEach((v, k) => {
+            headers[k] = v;
+        });
+        let data;
+        try {
+            data = (await res.json());
+        }
+        catch {
+            data = undefined;
+        }
+        return {
+            success: res.ok,
+            timestamp: new Date().toISOString(),
+            ok: res.ok,
+            status: res.status,
+            statusText: res.statusText,
+            headers,
+            data: data,
+        };
+    }
+    return {
+        request,
+        get: (url, o) => request(url, { ...o, method: "GET" }),
+        post: (url, body, o) => request(url, {
+            ...o,
+            method: "POST",
+            body: body === undefined ? undefined : JSON.stringify(body),
+        }),
+        put: (url, body, o) => request(url, {
+            ...o,
+            method: "PUT",
+            body: body === undefined ? undefined : JSON.stringify(body),
+        }),
+        delete: (url, o) => request(url, { ...o, method: "DELETE" }),
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sudobility/sider_client",
-  "version": "0.0.2",
-  "description": "Sider frontend network library — typed API client + React Query hooks.",
+  "version": "0.1.2",
+  "description": "Sider frontend network library — injected NetworkClient + React Query hooks.",
   "license": "BUSL-1.1",
   "publishConfig": {
     "access": "restricted"
@@ -25,17 +25,20 @@
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "@sudobility/sider_types": "^0.0.2"
+    "typecheck": "tsc --noEmit",
+    "test": "bun test"
   },
   "peerDependencies": {
+    "@sudobility/sider_types": "^0.0.5",
+    "@sudobility/types": "^1.9.62",
     "@tanstack/react-query": "^5",
     "react": "^18 || ^19"
   },
   "devDependencies": {
+    "@sudobility/sider_types": "^0.0.5",
+    "@sudobility/types": "^1.9.62",
     "@tanstack/react-query": "^5.62.7",
+    "@types/bun": "^1.2.23",
     "@types/react": "^18.3.12",
     "react": "^18.3.1",
     "typescript": "^5.9.3"

package/src/core.ts

@@ -1,12 +1,4 @@
-// React-free entry point (for service workers / non-React contexts).
-export * from "./client";
-export type {
-  CaptureRequest,
-  CaptureResponse,
-  PlannerStep,
-  PlanStartResponse,
-  PlanStepResponse,
-  SiteLookupResult,
-  StatsResponse,
-  ToolCatalog,
-} from "@sudobility/sider_types";
+// React-free entry for service workers / non-React contexts.
+export { SiderClient } from "./network/SiderClient";
+export { createFetchNetworkClient } from "./network/fetchClient";
+export type * from "@sudobility/sider_types";

package/src/hooks.ts

@@ -1,36 +1,216 @@
-import { useMutation, useQuery } from "@tanstack/react-query";
+import { useMutation, useQuery, type UseQueryOptions } from "@tanstack/react-query";
+import type { NetworkClient } from "@sudobility/types";
 import type { CaptureRequest } from "@sudobility/sider_types";
-import { useSiderClient } from "./context";
+import { SiderClient } from "./network/SiderClient";
 
-export function useSiteLookup(origin: string) {
-  const client = useSiderClient();
+type QueryOpts<T> = Omit<UseQueryOptions<T>, "queryKey" | "queryFn">;
+
+function client(networkClient: NetworkClient, baseUrl: string): SiderClient {
+  return new SiderClient(networkClient, baseUrl);
+}
+
+// --- public data: enabled regardless of token ------------------------------
+
+export function useSiteLookup(
+  networkClient: NetworkClient,
+  baseUrl: string,
+  _token: string,
+  origin: string | null,
+  options?: QueryOpts<Awaited<ReturnType<SiderClient["lookup"]>>>,
+) {
   return useQuery({
     queryKey: ["sider", "lookup", origin],
-    queryFn: () => client.lookup(origin),
-    enabled: Boolean(origin),
+    queryFn: () => client(networkClient, baseUrl).lookup(origin as string),
+    ...options,
+    enabled: !!origin && (options?.enabled ?? true),
+  });
+}
+
+export function useSites(
+  networkClient: NetworkClient,
+  baseUrl: string,
+  _token: string,
+  options?: QueryOpts<Awaited<ReturnType<SiderClient["listSites"]>>>,
+) {
+  return useQuery({
+    queryKey: ["sider", "sites"],
+    queryFn: () => client(networkClient, baseUrl).listSites(),
+    ...options,
+  });
+}
+
+export function useSite(
+  networkClient: NetworkClient,
+  baseUrl: string,
+  _token: string,
+  siteId: string | null,
+  options?: QueryOpts<Awaited<ReturnType<SiderClient["getSite"]>>>,
+) {
+  return useQuery({
+    queryKey: ["sider", "site", siteId],
+    queryFn: () => client(networkClient, baseUrl).getSite(siteId as string),
+    ...options,
+    enabled: !!siteId && (options?.enabled ?? true),
+  });
+}
+
+export function useStats(
+  networkClient: NetworkClient,
+  baseUrl: string,
+  _token: string,
+  options?: QueryOpts<Awaited<ReturnType<SiderClient["getStats"]>>>,
+) {
+  return useQuery({
+    queryKey: ["sider", "stats"],
+    queryFn: () => client(networkClient, baseUrl).getStats(),
+    ...options,
+  });
+}
+
+export function useToolCatalog(
+  networkClient: NetworkClient,
+  baseUrl: string,
+  _token: string,
+  siteId: string | null,
+  opts?: { includeProvisional?: boolean; includeFlagged?: boolean },
+  options?: QueryOpts<Awaited<ReturnType<SiderClient["getTools"]>>>,
+) {
+  return useQuery({
+    queryKey: [
+      "sider",
+      "tools",
+      siteId,
+      opts?.includeProvisional ?? false,
+      opts?.includeFlagged ?? false,
+    ],
+    queryFn: () => client(networkClient, baseUrl).getTools(siteId as string, opts),
+    ...options,
+    enabled: !!siteId && (options?.enabled ?? true),
+  });
+}
+
+export function useSiteTemplates(
+  networkClient: NetworkClient,
+  baseUrl: string,
+  _token: string,
+  siteId: string | null,
+  options?: QueryOpts<Awaited<ReturnType<SiderClient["getSiteTemplates"]>>>,
+) {
+  return useQuery({
+    queryKey: ["sider", "templates", siteId],
+    queryFn: () => client(networkClient, baseUrl).getSiteTemplates(siteId as string),
+    ...options,
+    enabled: !!siteId && (options?.enabled ?? true),
+  });
+}
+
+export function useSiteSlots(
+  networkClient: NetworkClient,
+  baseUrl: string,
+  _token: string,
+  siteId: string | null,
+  options?: QueryOpts<Awaited<ReturnType<SiderClient["getSiteSlots"]>>>,
+) {
+  return useQuery({
+    queryKey: ["sider", "slots", siteId],
+    queryFn: () => client(networkClient, baseUrl).getSiteSlots(siteId as string),
+    ...options,
+    enabled: !!siteId && (options?.enabled ?? true),
   });
 }
 
-export function useStats() {
-  const client = useSiderClient();
-  return useQuery({ queryKey: ["sider", "stats"], queryFn: () => client.getStats() });
+export function useSiteGraph(
+  networkClient: NetworkClient,
+  baseUrl: string,
+  _token: string,
+  siteId: string | null,
+  options?: QueryOpts<Awaited<ReturnType<SiderClient["getSiteGraph"]>>>,
+) {
+  return useQuery({
+    queryKey: ["sider", "graph", siteId],
+    queryFn: () => client(networkClient, baseUrl).getSiteGraph(siteId as string),
+    ...options,
+    enabled: !!siteId && (options?.enabled ?? true),
+  });
 }
 
-export function useSites() {
-  const client = useSiderClient();
-  return useQuery({ queryKey: ["sider", "sites"], queryFn: () => client.listSites() });
+export function useToolDetail(
+  networkClient: NetworkClient,
+  baseUrl: string,
+  _token: string,
+  toolId: string | null,
+  options?: QueryOpts<Awaited<ReturnType<SiderClient["getToolDetail"]>>>,
+) {
+  return useQuery({
+    queryKey: ["sider", "tool", toolId],
+    queryFn: () => client(networkClient, baseUrl).getToolDetail(toolId as string),
+    ...options,
+    enabled: !!toolId && (options?.enabled ?? true),
+  });
 }
 
-export function useToolCatalog(siteId: string | undefined, includeProvisional = false) {
-  const client = useSiderClient();
+// --- per-user data: gated on the token -------------------------------------
+
+export function useMe(
+  networkClient: NetworkClient,
+  baseUrl: string,
+  token: string,
+  options?: QueryOpts<Awaited<ReturnType<SiderClient["getMe"]>>>,
+) {
   return useQuery({
-    queryKey: ["sider", "tools", siteId, includeProvisional],
-    queryFn: () => client.getTools(siteId as string, includeProvisional),
-    enabled: Boolean(siteId),
+    queryKey: ["sider", "me", token ? "authed" : "anon"],
+    queryFn: () => client(networkClient, baseUrl).getMe(),
+    ...options,
+    enabled: !!token && (options?.enabled ?? true),
   });
 }
 
-export function useCaptureUpload() {
-  const client = useSiderClient();
-  return useMutation({ mutationFn: (v: CaptureRequest) => client.uploadCapture(v) });
+export function useMyCaptureBatches(
+  networkClient: NetworkClient,
+  baseUrl: string,
+  token: string,
+  siteId?: string,
+  options?: QueryOpts<Awaited<ReturnType<SiderClient["getMyCaptureBatches"]>>>,
+) {
+  return useQuery({
+    queryKey: ["sider", "my-batches", siteId ?? "all"],
+    queryFn: () => client(networkClient, baseUrl).getMyCaptureBatches(siteId),
+    ...options,
+    enabled: !!token && (options?.enabled ?? true),
+  });
+}
+
+export function useMyCaptureBatch(
+  networkClient: NetworkClient,
+  baseUrl: string,
+  token: string,
+  batchId: string | null,
+  options?: QueryOpts<Awaited<ReturnType<SiderClient["getMyCaptureBatch"]>>>,
+) {
+  return useQuery({
+    queryKey: ["sider", "my-batch", batchId],
+    queryFn: () => client(networkClient, baseUrl).getMyCaptureBatch(batchId as string),
+    ...options,
+    enabled: !!token && !!batchId && (options?.enabled ?? true),
+  });
+}
+
+export function useMyTools(
+  networkClient: NetworkClient,
+  baseUrl: string,
+  token: string,
+  options?: QueryOpts<Awaited<ReturnType<SiderClient["getMyTools"]>>>,
+) {
+  return useQuery({
+    queryKey: ["sider", "my-tools"],
+    queryFn: () => client(networkClient, baseUrl).getMyTools(),
+    ...options,
+    enabled: !!token && (options?.enabled ?? true),
+  });
+}
+
+export function useCaptureUpload(networkClient: NetworkClient, baseUrl: string, _token: string) {
+  return useMutation({
+    mutationFn: (body: CaptureRequest) => client(networkClient, baseUrl).uploadCapture(body),
+  });
 }

package/src/index.ts

@@ -1,14 +1,3 @@
-// @sudobility/sider_client — typed API client + React Query hooks for sider_api.
-export * from "./client";
-export * from "./context";
+// @sudobility/sider_client — injected NetworkClient + React Query hooks for sider_api.
+export * from "./core";
 export * from "./hooks";
-export type {
-  CaptureRequest,
-  CaptureResponse,
-  PlannerStep,
-  PlanStartResponse,
-  PlanStepResponse,
-  SiteLookupResult,
-  StatsResponse,
-  ToolCatalog,
-} from "@sudobility/sider_types";

package/src/network/SiderClient.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, test } from "bun:test";
+import type { NetworkClient, NetworkResponse } from "@sudobility/types";
+import { SiderClient } from "./SiderClient";
+
+function stubNetwork(data: unknown, ok = true): { client: NetworkClient; calls: string[] } {
+  const calls: string[] = [];
+  const respond = <T>(url: string): Promise<NetworkResponse<T>> => {
+    calls.push(url);
+    return Promise.resolve({
+      ok,
+      status: ok ? 200 : 500,
+      statusText: ok ? "OK" : "ERR",
+      headers: {},
+      data: { success: ok, data, error: ok ? undefined : "boom" } as T,
+    } as NetworkResponse<T>);
+  };
+  const client: NetworkClient = {
+    request: (url) => respond(url),
+    get: (url) => respond(url),
+    post: (url) => respond(url),
+    put: (url) => respond(url),
+    delete: (url) => respond(url),
+  };
+  return { client, calls };
+}
+
+describe("SiderClient", () => {
+  test("builds URLs and unwraps the ApiResponse envelope", async () => {
+    const { client, calls } = stubNetwork([{ id: "s1" }]);
+    const sider = new SiderClient(client, "http://localhost:8090");
+    const sites = await sider.listSites();
+    expect(sites as unknown).toEqual([{ id: "s1" }]);
+    expect(calls[0]).toBe("http://localhost:8090/api/v1/sites");
+  });
+
+  test("encodes query params", async () => {
+    const { client, calls } = stubNetwork({ known: false });
+    const sider = new SiderClient(client, "http://localhost:8090");
+    await sider.lookup("https://a.example");
+    expect(calls[0]).toBe(
+      "http://localhost:8090/api/v1/sites/lookup?origin=https%3A%2F%2Fa.example",
+    );
+  });
+
+  test("getTools flags map to query params", async () => {
+    const { client, calls } = stubNetwork({ tools: [] });
+    const sider = new SiderClient(client, "http://localhost:8090");
+    await sider.getTools("s1", { includeProvisional: true });
+    expect(calls[0]).toBe("http://localhost:8090/api/v1/sites/s1/tools?includeProvisional=1");
+  });
+
+  test("throws the envelope error on failure", async () => {
+    const { client } = stubNetwork(null, false);
+    const sider = new SiderClient(client, "http://localhost:8090");
+    await expect(sider.getStats()).rejects.toThrow("boom");
+  });
+});

package/src/network/SiderClient.ts

@@ -0,0 +1,109 @@
+import type { NetworkClient, NetworkResponse } from "@sudobility/types";
+import type {
+  ApiResponse,
+  CaptureRequest,
+  CaptureResponse,
+  EndpointGraphEdge,
+  EndpointTemplate,
+  MeResponse,
+  MyCaptureBatchDetail,
+  MyCaptureBatchSummary,
+  MyToolEntry,
+  SecretSlot,
+  Site,
+  SiteLookupResult,
+  StatsResponse,
+  ToolCatalog,
+  ToolDetailResponse,
+} from "@sudobility/sider_types";
+
+/**
+ * Typed wrapper over the Sider API. Auth is the injected NetworkClient's
+ * concern (e.g. auth_lib's Firebase Bearer client); this class only builds
+ * URLs and unwraps the ApiResponse envelope.
+ */
+export class SiderClient {
+  constructor(
+    private readonly network: NetworkClient,
+    private readonly baseUrl: string,
+  ) {}
+
+  private unwrap<T>(res: NetworkResponse<ApiResponse<T>>): T {
+    const body = res.data;
+    if (!body || body.success !== true) {
+      throw new Error(body?.error ?? `sider api error (${res.status})`);
+    }
+    return body.data as T;
+  }
+
+  private async get<T>(path: string): Promise<T> {
+    return this.unwrap(await this.network.get<ApiResponse<T>>(`${this.baseUrl}${path}`));
+  }
+
+  lookup(origin: string): Promise<SiteLookupResult> {
+    return this.get(`/api/v1/sites/lookup?origin=${encodeURIComponent(origin)}`);
+  }
+
+  listSites(): Promise<Site[]> {
+    return this.get("/api/v1/sites");
+  }
+
+  getSite(id: string): Promise<Site> {
+    return this.get(`/api/v1/sites/${id}`);
+  }
+
+  getStats(): Promise<StatsResponse> {
+    return this.get("/api/v1/stats");
+  }
+
+  getTools(
+    siteId: string,
+    opts?: { includeProvisional?: boolean; includeFlagged?: boolean },
+  ): Promise<ToolCatalog> {
+    const q = new URLSearchParams();
+    if (opts?.includeProvisional) q.set("includeProvisional", "1");
+    if (opts?.includeFlagged) q.set("includeFlagged", "1");
+    const qs = q.toString();
+    return this.get(`/api/v1/sites/${siteId}/tools${qs ? `?${qs}` : ""}`);
+  }
+
+  async uploadCapture(body: CaptureRequest): Promise<CaptureResponse> {
+    return this.unwrap(
+      await this.network.post<ApiResponse<CaptureResponse>>(`${this.baseUrl}/api/v1/capture`, body),
+    );
+  }
+
+  getMe(): Promise<MeResponse> {
+    return this.get("/api/v1/me");
+  }
+
+  getMyCaptureBatches(siteId?: string): Promise<MyCaptureBatchSummary[]> {
+    return this.get(
+      `/api/v1/me/capture-batches${siteId ? `?siteId=${encodeURIComponent(siteId)}` : ""}`,
+    );
+  }
+
+  getMyCaptureBatch(id: string): Promise<MyCaptureBatchDetail> {
+    return this.get(`/api/v1/me/capture-batches/${id}`);
+  }
+
+  getMyTools(): Promise<MyToolEntry[]> {
+    return this.get("/api/v1/me/tools");
+  }
+
+  getSiteTemplates(siteId: string): Promise<EndpointTemplate[]> {
+    return this.get(`/api/v1/sites/${siteId}/templates`);
+  }
+
+  getSiteSlots(siteId: string): Promise<SecretSlot[]> {
+    return this.get(`/api/v1/sites/${siteId}/slots`);
+  }
+
+  getSiteGraph(siteId: string): Promise<EndpointGraphEdge[]> {
+    return this.get(`/api/v1/sites/${siteId}/graph`);
+  }
+
+  getToolDetail(toolId: string): Promise<ToolDetailResponse> {
+    return this.get(`/api/v1/tools/${toolId}`);
+  }
+}

package/src/network/fetchClient.ts

@@ -0,0 +1,62 @@
+import type { NetworkClient, NetworkRequestOptions, NetworkResponse } from "@sudobility/types";
+
+type HeaderSource =
+  | Record<string, string>
+  | (() => Record<string, string> | Promise<Record<string, string>>);
+
+/**
+ * Plain fetch-backed NetworkClient for non-React contexts (service worker,
+ * tests, Node scripts). `getHeaders` is merged into every request — e.g.
+ * `async () => ({ authorization: `Bearer ${token}` })`.
+ */
+export function createFetchNetworkClient(getHeaders?: HeaderSource): NetworkClient {
+  async function request<T>(
+    url: string,
+    options?: NetworkRequestOptions | null,
+  ): Promise<NetworkResponse<T>> {
+    const extra = typeof getHeaders === "function" ? await getHeaders() : (getHeaders ?? {});
+    const res = await fetch(url, {
+      method: options?.method ?? "GET",
+      headers: { "content-type": "application/json", ...extra, ...options?.headers },
+      body: options?.body ?? undefined,
+      signal: options?.signal ?? undefined,
+    });
+    const headers: Record<string, string> = {};
+    res.headers.forEach((v, k) => {
+      headers[k] = v;
+    });
+    let data: T | undefined;
+    try {
+      data = (await res.json()) as T;
+    } catch {
+      data = undefined;
+    }
+    return {
+      success: res.ok,
+      timestamp: new Date().toISOString(),
+      ok: res.ok,
+      status: res.status,
+      statusText: res.statusText,
+      headers,
+      data: data as T,
+    };
+  }
+
+  return {
+    request,
+    get: (url, o) => request(url, { ...o, method: "GET" }),
+    post: (url, body, o) =>
+      request(url, {
+        ...o,
+        method: "POST",
+        body: body === undefined ? undefined : JSON.stringify(body),
+      }),
+    put: (url, body, o) =>
+      request(url, {
+        ...o,
+        method: "PUT",
+        body: body === undefined ? undefined : JSON.stringify(body),
+      }),
+    delete: (url, o) => request(url, { ...o, method: "DELETE" }),
+  };
+}

package/dist/client.d.ts

@@ -1,17 +0,0 @@
-import type { CaptureRequest, CaptureResponse, Site, SiteLookupResult, StatsResponse, ToolCatalog } from "@sudobility/sider_types";
-export interface SiderClientConfig {
-    baseUrl: string;
-    /** Supplies auth headers (dev uid now, Firebase bearer later). */
-    getAuthHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
-}
-export declare class SiderClient {
-    private readonly config;
-    constructor(config: SiderClientConfig);
-    private req;
-    lookup(origin: string): Promise<SiteLookupResult>;
-    getSite(id: string): Promise<Site>;
-    listSites(): Promise<Site[]>;
-    getStats(): Promise<StatsResponse>;
-    getTools(siteId: string, includeProvisional?: boolean): Promise<ToolCatalog>;
-    uploadCapture(body: CaptureRequest): Promise<CaptureResponse>;
-}

package/dist/client.js

@@ -1,38 +0,0 @@
-// SiderClient — the typed transport over sider_api. Usable in any JS context
-// (React or a service worker); the React hooks in ./hooks wrap it. It unwraps
-// the ApiResponse envelope and throws on error.
-export class SiderClient {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    async req(path, init) {
-        const auth = (await this.config.getAuthHeaders?.()) ?? {};
-        const res = await fetch(`${this.config.baseUrl}${path}`, {
-            ...init,
-            headers: { "content-type": "application/json", ...auth, ...(init?.headers ?? {}) },
-        });
-        const json = (await res.json());
-        if (!json.success)
-            throw new Error(json.error);
-        return json.data;
-    }
-    lookup(origin) {
-        return this.req(`/api/v1/sites/lookup?origin=${encodeURIComponent(origin)}`);
-    }
-    getSite(id) {
-        return this.req(`/api/v1/sites/${id}`);
-    }
-    listSites() {
-        return this.req(`/api/v1/sites`);
-    }
-    getStats() {
-        return this.req(`/api/v1/stats`);
-    }
-    getTools(siteId, includeProvisional = false) {
-        return this.req(`/api/v1/sites/${siteId}/tools${includeProvisional ? "?includeProvisional=1" : ""}`);
-    }
-    uploadCapture(body) {
-        return this.req(`/api/v1/capture`, { method: "POST", body: JSON.stringify(body) });
-    }
-}

package/dist/context.d.ts

@@ -1,7 +0,0 @@
-import { type ReactNode } from "react";
-import { SiderClient } from "./client";
-export declare function SiderClientProvider({ client, children }: {
-    client: SiderClient;
-    children: ReactNode;
-}): import("react").JSX.Element;
-export declare function useSiderClient(): SiderClient;

package/dist/context.js

@@ -1,13 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext } from "react";
-import { SiderClient } from "./client";
-const SiderClientContext = createContext(null);
-export function SiderClientProvider({ client, children }) {
-    return _jsx(SiderClientContext.Provider, { value: client, children: children });
-}
-export function useSiderClient() {
-    const c = useContext(SiderClientContext);
-    if (!c)
-        throw new Error("useSiderClient must be used within a <SiderClientProvider>");
-    return c;
-}

package/src/client.ts

@@ -1,60 +0,0 @@
-// SiderClient — the typed transport over sider_api. Usable in any JS context
-// (React or a service worker); the React hooks in ./hooks wrap it. It unwraps
-// the ApiResponse envelope and throws on error.
-
-import type {
-  ApiResponse,
-  CaptureRequest,
-  CaptureResponse,
-  Site,
-  SiteLookupResult,
-  StatsResponse,
-  ToolCatalog,
-} from "@sudobility/sider_types";
-
-export interface SiderClientConfig {
-  baseUrl: string;
-  /** Supplies auth headers (dev uid now, Firebase bearer later). */
-  getAuthHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
-}
-
-export class SiderClient {
-  constructor(private readonly config: SiderClientConfig) {}
-
-  private async req<T>(path: string, init?: RequestInit): Promise<T> {
-    const auth = (await this.config.getAuthHeaders?.()) ?? {};
-    const res = await fetch(`${this.config.baseUrl}${path}`, {
-      ...init,
-      headers: { "content-type": "application/json", ...auth, ...(init?.headers ?? {}) },
-    });
-    const json = (await res.json()) as ApiResponse<T>;
-    if (!json.success) throw new Error(json.error);
-    return json.data;
-  }
-
-  lookup(origin: string) {
-    return this.req<SiteLookupResult>(`/api/v1/sites/lookup?origin=${encodeURIComponent(origin)}`);
-  }
-
-  getSite(id: string) {
-    return this.req<Site>(`/api/v1/sites/${id}`);
-  }
-
-  listSites() {
-    return this.req<Site[]>(`/api/v1/sites`);
-  }
-
-  getStats() {
-    return this.req<StatsResponse>(`/api/v1/stats`);
-  }
-
-  getTools(siteId: string, includeProvisional = false) {
-    return this.req<ToolCatalog>(
-      `/api/v1/sites/${siteId}/tools${includeProvisional ? "?includeProvisional=1" : ""}`,
-    );
-  }
-
-  uploadCapture(body: CaptureRequest) {
-    return this.req<CaptureResponse>(`/api/v1/capture`, { method: "POST", body: JSON.stringify(body) });
-  }
-}

package/src/context.tsx

@@ -1,14 +0,0 @@
-import { createContext, useContext, type ReactNode } from "react";
-import { SiderClient } from "./client";
-
-const SiderClientContext = createContext<SiderClient | null>(null);
-
-export function SiderClientProvider({ client, children }: { client: SiderClient; children: ReactNode }) {
-  return <SiderClientContext.Provider value={client}>{children}</SiderClientContext.Provider>;
-}
-
-export function useSiderClient(): SiderClient {
-  const c = useContext(SiderClientContext);
-  if (!c) throw new Error("useSiderClient must be used within a <SiderClientProvider>");
-  return c;
-}