@adventurelabs/scout-core 1.4.96 → 1.5.0

package/dist/api_keys/actions.d.ts

@@ -1,7 +1,6 @@
 import { IApiKeyScout } from "../types/db";
-import { SupabaseClient } from "@supabase/supabase-js";
 export declare function test_api_key_loading(device_id: number): Promise<boolean>;
 export declare function server_list_api_keys(device_id: number): Promise<IApiKeyScout[]>;
-export declare function server_list_api_keys_batch(device_ids: number[], client?: SupabaseClient): Promise<{
+export declare function server_list_api_keys_batch(device_ids: number[]): Promise<{
     [device_id: number]: IApiKeyScout[];
 }>;

package/dist/api_keys/actions.js

@@ -1,5 +1,6 @@
 "use server";
 import { newServerClient } from "../supabase/server";
+import { list_api_keys_batch_query, list_api_keys_query } from "./queries";
 // Test function to verify individual API key loading works
 export async function test_api_key_loading(device_id) {
     try {
@@ -14,88 +15,8 @@ export async function test_api_key_loading(device_id) {
     }
 }
 export async function server_list_api_keys(device_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("load_api_keys", {
-        id_of_device: device_id,
-    });
-    if (error) {
-        console.error("Error listing API keys:", error.message);
-    }
-    if (!data)
-        return [];
-    const data_to_return = [];
-    for (let i = 0; i < data.length; i++) {
-        // Parse the JSON string from the text array
-        const converted_data = JSON.parse(data[i]);
-        data_to_return.push(converted_data);
-    }
-    return data_to_return;
+    return list_api_keys_query(await newServerClient(), device_id);
 }
-export async function server_list_api_keys_batch(device_ids, client) {
-    const supabase = client || (await newServerClient());
-    // Check if the batch function exists by trying a simple call
-    try {
-        const { data, error } = await supabase.rpc("load_api_keys_batch", {
-            device_ids: device_ids,
-        });
-        if (error) {
-            // Check if it's a "function does not exist" error
-            if (error.message.includes("function") &&
-                error.message.includes("does not exist")) {
-                console.log(`[API Keys Batch] Batch function not deployed, using individual calls...`);
-            }
-            else {
-                console.error(`[API Keys Batch] Database error:`, error.message);
-            }
-            console.log(`[API Keys Batch] Falling back to individual calls...`);
-            // Fallback to individual API key loading
-            const result = {};
-            const promises = device_ids.map(async (device_id) => {
-                try {
-                    const api_keys = await server_list_api_keys(device_id);
-                    result[device_id] = api_keys;
-                }
-                catch (err) {
-                    console.warn(`[API Keys Batch] Failed for device ${device_id}:`, err);
-                    result[device_id] = [];
-                }
-            });
-            await Promise.all(promises);
-            return result;
-        }
-        if (!data) {
-            return {};
-        }
-        const result = {};
-        // Group API keys by device_id
-        data.forEach((item) => {
-            const device_id = item.device_id;
-            if (!result[device_id]) {
-                result[device_id] = [];
-            }
-            result[device_id].push({
-                id: item.api_key_id, // Now a string, no need for toString()
-                key: item.api_key_key,
-            });
-        });
-        return result;
-    }
-    catch (err) {
-        console.error(`[API Keys Batch] Unexpected error:`, err);
-        console.log(`[API Keys Batch] Falling back to individual calls...`);
-        // Fallback to individual API key loading
-        const result = {};
-        const promises = device_ids.map(async (device_id) => {
-            try {
-                const api_keys = await server_list_api_keys(device_id);
-                result[device_id] = api_keys;
-            }
-            catch (err) {
-                console.warn(`[API Keys Batch] Failed for device ${device_id}:`, err);
-                result[device_id] = [];
-            }
-        });
-        await Promise.all(promises);
-        return result;
-    }
+export async function server_list_api_keys_batch(device_ids) {
+    return list_api_keys_batch_query(await newServerClient(), device_ids);
 }

package/dist/api_keys/queries.d.ts

@@ -0,0 +1,4 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IApiKeyScout } from "../types/db";
+export declare function list_api_keys_query(client: SupabaseClient, device_id: number): Promise<IApiKeyScout[]>;
+export declare function list_api_keys_batch_query(client: SupabaseClient, device_ids: number[]): Promise<Record<number, IApiKeyScout[]>>;

package/dist/api_keys/queries.js

@@ -0,0 +1,52 @@
+export async function list_api_keys_query(client, device_id) {
+    const { data, error } = await client.rpc("load_api_keys", {
+        id_of_device: device_id,
+    });
+    if (error)
+        console.error("Error listing API keys:", error.message);
+    return (data ?? []).map((value) => JSON.parse(value));
+}
+export async function list_api_keys_batch_query(client, device_ids) {
+    var _a;
+    try {
+        const { data, error } = await client.rpc("load_api_keys_batch", {
+            device_ids,
+        });
+        if (error) {
+            if (error.message.includes("function") &&
+                error.message.includes("does not exist")) {
+                console.log("[API Keys Batch] Batch function not deployed, using individual calls...");
+            }
+            else {
+                console.error("[API Keys Batch] Database error:", error.message);
+            }
+            return list_api_keys_individually(client, device_ids);
+        }
+        const result = {};
+        for (const item of data ?? []) {
+            (result[_a = item.device_id] ?? (result[_a] = [])).push({
+                id: item.api_key_id,
+                key: item.api_key_key,
+            });
+        }
+        return result;
+    }
+    catch (error) {
+        console.error("[API Keys Batch] Unexpected error:", error);
+        return list_api_keys_individually(client, device_ids);
+    }
+}
+async function list_api_keys_individually(client, device_ids) {
+    console.log("[API Keys Batch] Falling back to individual calls...");
+    const result = {};
+    await Promise.all(device_ids.map(async (device_id) => {
+        try {
+            result[device_id] = await list_api_keys_query(client, device_id);
+        }
+        catch (error) {
+            console.warn(`[API Keys Batch] Failed for device ${device_id}:`, error);
+            result[device_id] = [];
+        }
+    }));
+    return result;
+}

package/dist/helpers/artifacts.d.ts

@@ -1,30 +1,25 @@
 import { IArtifact, IArtifactWithMediaUrl, ArtifactInsert, ArtifactUpdate } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
-import { SupabaseClient } from "@supabase/supabase-js";
-export declare function server_get_artifact_by_id(id: number, client?: SupabaseClient): Promise<IWebResponseCompatible<IArtifactWithMediaUrl | null>>;
-export declare function server_get_artifacts_by_herd(herd_id: number, limit?: number, offset?: number, options?: {
+interface ArtifactTimeRangeOptions {
     start_timestamp?: string;
     end_timestamp?: string;
-    client?: SupabaseClient;
-}): Promise<IWebResponseCompatible<IArtifactWithMediaUrl[]>>;
-export declare function server_get_artifacts_by_device_id(device_id: number, limit?: number, offset?: number, client?: SupabaseClient): Promise<IWebResponseCompatible<IArtifactWithMediaUrl[]>>;
+}
+export declare function server_get_artifact_by_id(id: number): Promise<IWebResponseCompatible<IArtifactWithMediaUrl | null>>;
+export declare function server_get_artifacts_by_herd(herd_id: number, limit?: number, offset?: number, options?: ArtifactTimeRangeOptions): Promise<IWebResponseCompatible<IArtifactWithMediaUrl[]>>;
+export declare function server_get_artifacts_by_device_id(device_id: number, limit?: number, offset?: number): Promise<IWebResponseCompatible<IArtifactWithMediaUrl[]>>;
 export declare function server_get_total_artifacts_by_herd(herd_id: number): Promise<IWebResponseCompatible<number>>;
-export declare function server_get_artifacts_by_device_ids_batch(device_ids: number[], limit_per_device?: number, options?: {
-    start_timestamp?: string;
-    end_timestamp?: string;
-    client?: SupabaseClient;
-}): Promise<{
+export declare function server_get_artifacts_by_device_ids_batch(device_ids: number[], limit_per_device?: number, options?: ArtifactTimeRangeOptions): Promise<{
     [device_id: number]: IArtifactWithMediaUrl[];
 }>;
-export declare function server_insert_artifact(artifact: ArtifactInsert | ArtifactInsert[], client?: SupabaseClient): Promise<IWebResponseCompatible<IArtifact[]>>;
+export declare function server_insert_artifact(artifact: ArtifactInsert | ArtifactInsert[]): Promise<IWebResponseCompatible<IArtifact[]>>;
 export declare function server_update_artifact(artifact: (ArtifactUpdate & {
     id: number;
 }) | (ArtifactUpdate & {
     id: number;
-})[], client?: SupabaseClient): Promise<IWebResponseCompatible<IArtifact[]>>;
-export declare function server_delete_artifact(id: number | number[], client?: SupabaseClient): Promise<IWebResponseCompatible<boolean>>;
+})[]): Promise<IWebResponseCompatible<IArtifact[]>>;
+export declare function server_delete_artifact(id: number | number[]): Promise<IWebResponseCompatible<boolean>>;
 /** Semantic search over artifacts using Vertex multimodal embedding (embedding_vertex_mm_01). */
 export declare function server_match_artifacts_by_vertex_embedding(query_embedding: number[], match_threshold: number, match_count: number, options?: {
     herd_id?: number | null;
-    client?: SupabaseClient;
 }): Promise<IWebResponseCompatible<IArtifact[]>>;
+export {};

package/dist/helpers/artifacts.internal.d.ts

@@ -0,0 +1,22 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IArtifact, IArtifactWithMediaUrl, ArtifactInsert, ArtifactUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import type { Database } from "../types/supabase";
+export interface ArtifactTimeRangeOptions {
+    start_timestamp?: string;
+    end_timestamp?: string;
+}
+export declare function getArtifactByIdWithClient(client: SupabaseClient<Database>, id: number): Promise<IWebResponseCompatible<IArtifactWithMediaUrl | null>>;
+export declare function getArtifactsByHerdWithClient(client: SupabaseClient<Database>, herd_id: number, limit: number, offset: number, options: ArtifactTimeRangeOptions | undefined): Promise<IWebResponseCompatible<IArtifactWithMediaUrl[]>>;
+export declare function getArtifactsByDeviceIdWithClient(client: SupabaseClient<Database>, device_id: number, limit: number, offset: number): Promise<IWebResponseCompatible<IArtifactWithMediaUrl[]>>;
+export declare function getArtifactsByDeviceIdsBatchWithClient(client: SupabaseClient<Database>, device_ids: number[], limit_per_device: number, options: ArtifactTimeRangeOptions | undefined): Promise<{
+    [device_id: number]: IArtifactWithMediaUrl[];
+}>;
+export declare function insertArtifactWithClient(client: SupabaseClient<Database>, artifact: ArtifactInsert | ArtifactInsert[]): Promise<IWebResponseCompatible<IArtifact[]>>;
+export declare function updateArtifactWithClient(client: SupabaseClient<Database>, artifact: (ArtifactUpdate & {
+    id: number;
+}) | (ArtifactUpdate & {
+    id: number;
+})[]): Promise<IWebResponseCompatible<IArtifact[]>>;
+export declare function deleteArtifactWithClient(client: SupabaseClient<Database>, id: number | number[]): Promise<IWebResponseCompatible<boolean>>;
+export declare function matchArtifactsByVertexEmbeddingWithClient(client: SupabaseClient<Database>, query_embedding: number[], match_threshold: number, match_count: number, herd_id: number | null | undefined): Promise<IWebResponseCompatible<IArtifact[]>>;

package/dist/helpers/artifacts.internal.js

@@ -0,0 +1,151 @@
+import { IWebResponse } from "../types/requests";
+import { generateSignedUrlsBatchWithClient, generateSignedUrlWithClient, } from "./storage_internal";
+import { isNonEmptyStorageFilePath } from "./storagePath";
+async function addArtifactMediaUrls(data, client) {
+    const uniqueFilePaths = Array.from(new Set(data
+        .map((artifact) => artifact.file_path)
+        .filter(isNonEmptyStorageFilePath)));
+    if (uniqueFilePaths.length === 0) {
+        return data;
+    }
+    const signedUrls = await generateSignedUrlsBatchWithClient(client, uniqueFilePaths);
+    const urlMap = new Map();
+    uniqueFilePaths.forEach((path, index) => {
+        urlMap.set(path, signedUrls[index]);
+    });
+    return data.map((artifact) => ({
+        ...artifact,
+        media_url: isNonEmptyStorageFilePath(artifact.file_path)
+            ? urlMap.get(artifact.file_path) ?? null
+            : null,
+    }));
+}
+export async function getArtifactByIdWithClient(client, id) {
+    const { data, error } = await client
+        .from("artifacts")
+        .select("*")
+        .eq("id", id)
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.success(null).to_compatible();
+    }
+    const artifact = data;
+    let media_url = null;
+    if (isNonEmptyStorageFilePath(artifact.file_path)) {
+        media_url = await generateSignedUrlWithClient(client, artifact.file_path);
+    }
+    return IWebResponse.success({
+        ...artifact,
+        media_url,
+    }).to_compatible();
+}
+export async function getArtifactsByHerdWithClient(client, herd_id, limit, offset, options) {
+    const { data, error } = await client.rpc("get_artifacts_for_herd", {
+        herd_id_caller: herd_id,
+        limit_caller: limit,
+        offset_caller: offset,
+        start_timestamp: options?.start_timestamp,
+        end_timestamp: options?.end_timestamp,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("No artifacts found for herd").to_compatible();
+    }
+    const artifactsWithUrls = await addArtifactMediaUrls(data, client);
+    return IWebResponse.success(artifactsWithUrls).to_compatible();
+}
+export async function getArtifactsByDeviceIdWithClient(client, device_id, limit, offset) {
+    const { data, error } = await client.rpc("get_artifacts_for_device", {
+        device_id_caller: device_id,
+        limit_caller: limit,
+        offset_caller: offset,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("No artifacts found for device").to_compatible();
+    }
+    const artifactsWithUrls = await addArtifactMediaUrls(data, client);
+    return IWebResponse.success(artifactsWithUrls).to_compatible();
+}
+export async function getArtifactsByDeviceIdsBatchWithClient(client, device_ids, limit_per_device, options) {
+    if (device_ids.length === 0) {
+        return {};
+    }
+    const { data, error } = await client.rpc("get_artifacts_for_devices_batch", {
+        device_ids,
+        limit_per_device,
+        start_timestamp: options?.start_timestamp,
+        end_timestamp: options?.end_timestamp,
+    });
+    if (error || !data) {
+        console.warn("Error fetching artifacts batch:", error?.message);
+        return {};
+    }
+    const artifactsWithUrls = await addArtifactMediaUrls(data, client);
+    const artifactsByDevice = {};
+    artifactsWithUrls.forEach((artifact) => {
+        if (!artifactsByDevice[artifact.device_id]) {
+            artifactsByDevice[artifact.device_id] = [];
+        }
+        artifactsByDevice[artifact.device_id].push(artifact);
+    });
+    return artifactsByDevice;
+}
+export async function insertArtifactWithClient(client, artifact) {
+    const arr = Array.isArray(artifact) ? artifact : [artifact];
+    const { data, error } = await client
+        .from("artifacts")
+        .insert(arr)
+        .select("*");
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data || []).to_compatible();
+}
+export async function updateArtifactWithClient(client, artifact) {
+    const arr = Array.isArray(artifact) ? artifact : [artifact];
+    const results = [];
+    for (const record of arr) {
+        const { id, ...updateData } = record;
+        delete updateData.created_at;
+        const { data, error } = await client
+            .from("artifacts")
+            .update(updateData)
+            .eq("id", id)
+            .select("*")
+            .single();
+        if (error) {
+            return IWebResponse.error(error.message).to_compatible();
+        }
+        if (data)
+            results.push(data);
+    }
+    return IWebResponse.success(results).to_compatible();
+}
+export async function deleteArtifactWithClient(client, id) {
+    const ids = Array.isArray(id) ? id : [id];
+    const { error } = await client.from("artifacts").delete().in("id", ids);
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(true).to_compatible();
+}
+export async function matchArtifactsByVertexEmbeddingWithClient(client, query_embedding, match_threshold, match_count, herd_id) {
+    const { data, error } = await client.rpc("match_artifacts_by_vertex_embedding", {
+        query_embedding,
+        match_threshold,
+        match_count,
+        herd_id_caller: herd_id ?? null,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success((data ?? [])).to_compatible();
+}

package/dist/helpers/artifacts.js

@@ -1,11 +1,30 @@
 "use server";
 import { newServerClient } from "../supabase/server";
 import { IWebResponse } from "../types/requests";
-import { generateSignedUrlsBatch, generateSignedUrl, } from "./storage";
+import { generateSignedUrlsBatchWithClient, generateSignedUrlWithClient, } from "./storage_internal";
 import { isNonEmptyStorageFilePath } from "./storagePath";
-export async function server_get_artifact_by_id(id, client) {
-    const supabase = client || (await newServerClient());
-    const { data, error } = await supabase
+async function addArtifactMediaUrls(data, client) {
+    const uniqueFilePaths = Array.from(new Set(data
+        .map((artifact) => artifact.file_path)
+        .filter(isNonEmptyStorageFilePath)));
+    if (uniqueFilePaths.length === 0) {
+        return data;
+    }
+    const signedUrls = await generateSignedUrlsBatchWithClient(client, uniqueFilePaths);
+    const urlMap = new Map();
+    uniqueFilePaths.forEach((path, index) => {
+        urlMap.set(path, signedUrls[index]);
+    });
+    return data.map((artifact) => ({
+        ...artifact,
+        media_url: isNonEmptyStorageFilePath(artifact.file_path)
+            ? urlMap.get(artifact.file_path) ?? null
+            : null,
+    }));
+}
+export async function server_get_artifact_by_id(id) {
+    const client = await newServerClient();
+    const { data, error } = await client
         .from("artifacts")
         .select("*")
         .eq("id", id)
@@ -19,7 +38,7 @@ export async function server_get_artifact_by_id(id, client) {
     const artifact = data;
     let media_url = null;
     if (isNonEmptyStorageFilePath(artifact.file_path)) {
-        media_url = await generateSignedUrl(artifact.file_path, undefined, client);
+        media_url = await generateSignedUrlWithClient(client, artifact.file_path);
     }
     return IWebResponse.success({
         ...artifact,
@@ -27,8 +46,8 @@ export async function server_get_artifact_by_id(id, client) {
     }).to_compatible();
 }
 export async function server_get_artifacts_by_herd(herd_id, limit = 50, offset = 0, options) {
-    const supabase = options?.client || (await newServerClient());
-    const { data, error } = await supabase.rpc("get_artifacts_for_herd", {
+    const client = await newServerClient();
+    const { data, error } = await client.rpc("get_artifacts_for_herd", {
         herd_id_caller: herd_id,
         limit_caller: limit,
         offset_caller: offset,
@@ -41,29 +60,12 @@ export async function server_get_artifacts_by_herd(herd_id, limit = 50, offset =
     if (!data) {
         return IWebResponse.error("No artifacts found for herd").to_compatible();
     }
-    // Generate signed URLs for artifacts
-    const uniqueFilePaths = Array.from(new Set(data
-        .map((artifact) => artifact.file_path)
-        .filter(isNonEmptyStorageFilePath)));
-    if (uniqueFilePaths.length === 0) {
-        return IWebResponse.success(data).to_compatible();
-    }
-    const signedUrls = await generateSignedUrlsBatch(uniqueFilePaths, undefined, options?.client);
-    const urlMap = new Map();
-    uniqueFilePaths.forEach((path, index) => {
-        urlMap.set(path, signedUrls[index]);
-    });
-    const artifactsWithUrls = data.map((artifact) => ({
-        ...artifact,
-        media_url: isNonEmptyStorageFilePath(artifact.file_path)
-            ? urlMap.get(artifact.file_path) ?? null
-            : null,
-    }));
+    const artifactsWithUrls = await addArtifactMediaUrls(data, client);
     return IWebResponse.success(artifactsWithUrls).to_compatible();
 }
-export async function server_get_artifacts_by_device_id(device_id, limit = 50, offset = 0, client) {
-    const supabase = client || (await newServerClient());
-    const { data, error } = await supabase.rpc("get_artifacts_for_device", {
+export async function server_get_artifacts_by_device_id(device_id, limit = 50, offset = 0) {
+    const client = await newServerClient();
+    const { data, error } = await client.rpc("get_artifacts_for_device", {
         device_id_caller: device_id,
         limit_caller: limit,
         offset_caller: offset,
@@ -74,24 +76,7 @@ export async function server_get_artifacts_by_device_id(device_id, limit = 50, o
     if (!data) {
         return IWebResponse.error("No artifacts found for device").to_compatible();
     }
-    // Generate signed URLs for artifacts
-    const uniqueFilePaths = Array.from(new Set(data
-        .map((artifact) => artifact.file_path)
-        .filter(isNonEmptyStorageFilePath)));
-    if (uniqueFilePaths.length === 0) {
-        return IWebResponse.success(data).to_compatible();
-    }
-    const signedUrls = await generateSignedUrlsBatch(uniqueFilePaths, undefined, client);
-    const urlMap = new Map();
-    uniqueFilePaths.forEach((path, index) => {
-        urlMap.set(path, signedUrls[index]);
-    });
-    const artifactsWithUrls = data.map((artifact) => ({
-        ...artifact,
-        media_url: isNonEmptyStorageFilePath(artifact.file_path)
-            ? urlMap.get(artifact.file_path) ?? null
-            : null,
-    }));
+    const artifactsWithUrls = await addArtifactMediaUrls(data, client);
     return IWebResponse.success(artifactsWithUrls).to_compatible();
 }
 export async function server_get_total_artifacts_by_herd(herd_id) {
@@ -105,13 +90,13 @@ export async function server_get_total_artifacts_by_herd(herd_id) {
     return IWebResponse.success(data || 0).to_compatible();
 }
 export async function server_get_artifacts_by_device_ids_batch(device_ids, limit_per_device = 10, options) {
-    const supabase = options?.client || (await newServerClient());
     if (device_ids.length === 0) {
         return {};
     }
-    const { data, error } = await supabase.rpc("get_artifacts_for_devices_batch", {
-        device_ids: device_ids,
-        limit_per_device: limit_per_device,
+    const client = await newServerClient();
+    const { data, error } = await client.rpc("get_artifacts_for_devices_batch", {
+        device_ids,
+        limit_per_device,
         start_timestamp: options?.start_timestamp,
         end_timestamp: options?.end_timestamp,
     });
@@ -119,25 +104,7 @@ export async function server_get_artifacts_by_device_ids_batch(device_ids, limit
         console.warn("Error fetching artifacts batch:", error?.message);
         return {};
     }
-    // Generate signed URLs for artifacts
-    const uniqueFilePaths = Array.from(new Set(data
-        .map((artifact) => artifact.file_path)
-        .filter(isNonEmptyStorageFilePath)));
-    let artifactsWithUrls = data;
-    if (uniqueFilePaths.length > 0) {
-        const signedUrls = await generateSignedUrlsBatch(uniqueFilePaths, undefined, options?.client);
-        const urlMap = new Map();
-        uniqueFilePaths.forEach((path, index) => {
-            urlMap.set(path, signedUrls[index]);
-        });
-        artifactsWithUrls = data.map((artifact) => ({
-            ...artifact,
-            media_url: isNonEmptyStorageFilePath(artifact.file_path)
-                ? urlMap.get(artifact.file_path) ?? null
-                : null,
-        }));
-    }
-    // Group artifacts by device_id
+    const artifactsWithUrls = await addArtifactMediaUrls(data, client);
     const artifactsByDevice = {};
     artifactsWithUrls.forEach((artifact) => {
         if (!artifactsByDevice[artifact.device_id]) {
@@ -147,10 +114,10 @@ export async function server_get_artifacts_by_device_ids_batch(device_ids, limit
     });
     return artifactsByDevice;
 }
-export async function server_insert_artifact(artifact, client) {
-    const supabase = client || (await newServerClient());
+export async function server_insert_artifact(artifact) {
+    const client = await newServerClient();
     const arr = Array.isArray(artifact) ? artifact : [artifact];
-    const { data, error } = await supabase
+    const { data, error } = await client
         .from("artifacts")
         .insert(arr)
         .select("*");
@@ -159,14 +126,14 @@ export async function server_insert_artifact(artifact, client) {
     }
     return IWebResponse.success(data || []).to_compatible();
 }
-export async function server_update_artifact(artifact, client) {
-    const supabase = client || (await newServerClient());
+export async function server_update_artifact(artifact) {
+    const client = await newServerClient();
     const arr = Array.isArray(artifact) ? artifact : [artifact];
     const results = [];
     for (const record of arr) {
         const { id, ...updateData } = record;
         delete updateData.created_at;
-        const { data, error } = await supabase
+        const { data, error } = await client
             .from("artifacts")
             .update(updateData)
             .eq("id", id)
@@ -180,10 +147,10 @@ export async function server_update_artifact(artifact, client) {
     }
     return IWebResponse.success(results).to_compatible();
 }
-export async function server_delete_artifact(id, client) {
-    const supabase = client || (await newServerClient());
+export async function server_delete_artifact(id) {
+    const client = await newServerClient();
     const ids = Array.isArray(id) ? id : [id];
-    const { error } = await supabase.from("artifacts").delete().in("id", ids);
+    const { error } = await client.from("artifacts").delete().in("id", ids);
     if (error) {
         return IWebResponse.error(error.message).to_compatible();
     }
@@ -191,9 +158,9 @@ export async function server_delete_artifact(id, client) {
 }
 /** Semantic search over artifacts using Vertex multimodal embedding (embedding_vertex_mm_01). */
 export async function server_match_artifacts_by_vertex_embedding(query_embedding, match_threshold, match_count, options) {
-    const supabase = options?.client ?? (await newServerClient());
-    const { data, error } = await supabase.rpc("match_artifacts_by_vertex_embedding", {
-        query_embedding: query_embedding,
+    const client = await newServerClient();
+    const { data, error } = await client.rpc("match_artifacts_by_vertex_embedding", {
+        query_embedding,
         match_threshold,
         match_count,
         herd_id_caller: options?.herd_id ?? null,

package/dist/helpers/client_abilities_jwt_keys.d.ts

@@ -1,10 +1,9 @@
-import { SupabaseClient } from "@supabase/supabase-js";
-import { Database, Json } from "../types/supabase";
 import { IWebResponseCompatible } from "../types/requests";
+import { Json } from "../types/supabase";
 export type ClientAbilitiesPublicJwk = Record<string, Json | undefined> & {
     kty: string;
     kid?: string;
 };
 /** Register or rotate a verification key (service_role or platform superadmin). */
-export declare function server_upsert_client_abilities_jwt_public_key(kid: string, public_jwk: ClientAbilitiesPublicJwk, supabaseClient?: SupabaseClient<Database>): Promise<IWebResponseCompatible<null>>;
-export declare function server_revoke_client_abilities_jwt_public_key(kid: string, supabaseClient?: SupabaseClient<Database>): Promise<IWebResponseCompatible<null>>;
+export declare function server_upsert_client_abilities_jwt_public_key(kid: string, public_jwk: ClientAbilitiesPublicJwk): Promise<IWebResponseCompatible<null>>;
+export declare function server_revoke_client_abilities_jwt_public_key(kid: string): Promise<IWebResponseCompatible<null>>;

package/dist/helpers/client_abilities_jwt_keys.js

@@ -1,10 +1,10 @@
 "use server";
-import { IWebResponse } from "../types/requests";
 import { newServerClient } from "../supabase/server";
+import { IWebResponse } from "../types/requests";
 /** Register or rotate a verification key (service_role or platform superadmin). */
-export async function server_upsert_client_abilities_jwt_public_key(kid, public_jwk, supabaseClient) {
-    const supabase = supabaseClient ?? (await newServerClient());
-    const { error } = await supabase.rpc("upsert_client_abilities_jwt_public_key", {
+export async function server_upsert_client_abilities_jwt_public_key(kid, public_jwk) {
+    const client = await newServerClient();
+    const { error } = await client.rpc("upsert_client_abilities_jwt_public_key", {
         p_kid: kid,
         p_public_jwk: public_jwk,
     });
@@ -13,9 +13,9 @@ export async function server_upsert_client_abilities_jwt_public_key(kid, public_
     }
     return IWebResponse.success(null).to_compatible();
 }
-export async function server_revoke_client_abilities_jwt_public_key(kid, supabaseClient) {
-    const supabase = supabaseClient ?? (await newServerClient());
-    const { error } = await supabase.rpc("revoke_client_abilities_jwt_public_key", {
+export async function server_revoke_client_abilities_jwt_public_key(kid) {
+    const client = await newServerClient();
+    const { error } = await client.rpc("revoke_client_abilities_jwt_public_key", {
         p_kid: kid,
     });
     if (error) {

package/dist/helpers/client_abilities_jwt_keys_internal.d.ts

@@ -0,0 +1,9 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database, Json } from "../types/supabase";
+export type ClientAbilitiesPublicJwk = Record<string, Json | undefined> & {
+    kty: string;
+    kid?: string;
+};
+export declare function upsert_client_abilities_jwt_public_key(client: SupabaseClient<Database>, kid: string, publicJwk: ClientAbilitiesPublicJwk): Promise<IWebResponseCompatible<null>>;
+export declare function revoke_client_abilities_jwt_public_key(client: SupabaseClient<Database>, kid: string): Promise<IWebResponseCompatible<null>>;