camstack 1.2.152 → 1.2.154

package/dist/cli.js

@@ -38,7 +38,7 @@ async function runServe(args) {
     ...typeof values.data === "string" ? { data: values.data } : {}
   };
   Object.assign(process.env, buildServeEnv(opts));
-  await import("./launcher-SQWBPN4O.js");
+  await import("./launcher-ZQZHWQ6F.js");
 }
 
 // src/commands/agent.ts
@@ -83,7 +83,7 @@ async function runAgent(args) {
     ...typeof values.port === "string" ? { port: values.port } : {}
   };
   Object.assign(process.env, buildAgentEnv(opts));
-  await import("./launcher-SQWBPN4O.js");
+  await import("./launcher-ZQZHWQ6F.js");
 }
 
 // src/commands/setup.ts

package/dist/{launcher-SQWBPN4O.js → launcher-ZQZHWQ6F.js}

@@ -66719,6 +66719,75 @@ var require_device_manager_addon = __commonJS({
         }
       }
     };
+    var CONTRIBUTION_BUDGET_MS = 1500;
+    var ContributionCache = class {
+      maxEntries;
+      entries = /* @__PURE__ */ new Map();
+      constructor(maxEntries = 512) {
+        this.maxEntries = maxEntries;
+      }
+      /**
+      * Resolve one provider's contribution within `budgetMs`.
+      *
+      * The call is never cancelled: it keeps running and its answer refreshes the
+      * cache, so the provider that overran this page pays for the next one.
+      */
+      async resolve(key, call, budgetMs = CONTRIBUTION_BUDGET_MS) {
+        const existing = this.entries.get(key);
+        if (existing?.inFlight) return existing.value !== null ? {
+          kind: "stale",
+          value: existing.value
+        } : {
+          kind: "absent",
+          reason: "slow"
+        };
+        const entry = existing ?? {
+          value: null,
+          inFlight: null
+        };
+        if (!existing) this.remember(key, entry);
+        let settled = false;
+        let answer = null;
+        let failed = false;
+        const refresh = call().then((value) => {
+          answer = value;
+          settled = true;
+          entry.value = value;
+          entry.inFlight = null;
+        }, () => {
+          failed = true;
+          settled = true;
+          entry.inFlight = null;
+        });
+        entry.inFlight = refresh;
+        await Promise.race([refresh, sleep(budgetMs)]);
+        if (settled && !failed) return {
+          kind: "fresh",
+          value: answer
+        };
+        if (entry.value !== null) return {
+          kind: "stale",
+          value: entry.value
+        };
+        return {
+          kind: "absent",
+          reason: failed ? "failed" : "slow"
+        };
+      }
+      remember(key, entry) {
+        this.entries.set(key, entry);
+        while (this.entries.size > this.maxEntries) {
+          const oldest = this.entries.keys().next();
+          if (oldest.done === true) break;
+          this.entries.delete(oldest.value);
+        }
+      }
+    };
+    function sleep(ms) {
+      return new Promise((resolve) => {
+        setTimeout(resolve, ms).unref?.();
+      });
+    }
     function tagContribution(contribution, capName, addonId, kind) {
       const source = kind === "settings" ? "settings" : "live";
       return {
@@ -68310,6 +68379,39 @@ var require_device_manager_addon = __commonJS({
         driverPatch
       };
     }
+    var contributionCache = new ContributionCache();
+    async function resolveContribution(deps, input) {
+      const { deviceId, kind, capName, addonId } = input;
+      const outcome = await contributionCache.resolve(`${String(deviceId)}:${kind}:${capName}:${addonId}`, input.call);
+      if (outcome.kind === "fresh") return outcome.value === null ? null : tagContribution(outcome.value, capName, addonId, kind);
+      if (outcome.kind === "stale") {
+        deps.ctx.logger.info("device contribution served from the last answer \u2014 the provider is slow", {
+          tags: {
+            deviceId,
+            addonId
+          },
+          meta: {
+            capName,
+            method: kind,
+            budgetMs: CONTRIBUTION_BUDGET_MS
+          }
+        });
+        return tagContribution(outcome.value, capName, addonId, kind);
+      }
+      deps.ctx.logger.warn("device contribution unavailable \u2014 the panel is missing this section", {
+        tags: {
+          deviceId,
+          addonId
+        },
+        meta: {
+          capName,
+          method: kind,
+          reason: outcome.reason,
+          budgetMs: CONTRIBUTION_BUDGET_MS
+        }
+      });
+      return null;
+    }
     async function getDeviceAggregate(deps, deviceId, kind) {
       const registry = deps.capabilityRegistry;
       if (!registry) {
@@ -68325,25 +68427,16 @@ var require_device_manager_addon = __commonJS({
         if (!def?.exposesDeviceSettings) return null;
         const provider = registry.getProviderByAddon(entry.capName, entry.providerAddonId);
         if (!provider) return null;
-        try {
-          const contribution = await provider[method]({ deviceId });
-          if (!contribution) return null;
-          return tagContribution(toWireShape(contribution), entry.capName, entry.providerAddonId, kind);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          deps.ctx.logger.warn("contribution method failed", {
-            tags: {
-              deviceId,
-              addonId: entry.providerAddonId
-            },
-            meta: {
-              capName: entry.capName,
-              method,
-              error: msg
-            }
-          });
-          return null;
-        }
+        return await resolveContribution(deps, {
+          deviceId,
+          kind,
+          capName: entry.capName,
+          addonId: entry.providerAddonId,
+          call: async () => {
+            const contribution = await provider[method]({ deviceId });
+            return contribution ? toWireShape(contribution) : null;
+          }
+        });
       }));
       const base = kind === "settings" ? await buildBaseDeviceSection(deps, deviceId) : null;
       const systemResults = await collectSystemDeviceContributions(deps, deviceId, kind, seenCaps);
@@ -68368,24 +68461,16 @@ var require_device_manager_addon = __commonJS({
         for (const addonId of addonIds) tasks.push((async () => {
           const provider = registry.getProviderByAddon(info.name, addonId);
           if (!provider) return null;
-          try {
-            const contribution = await provider[method]({ deviceId });
-            if (!contribution) return null;
-            return tagContribution(toWireShape(contribution), info.name, addonId, kind);
-          } catch (err) {
-            deps.ctx.logger.warn("system device-settings contribution skipped", {
-              tags: {
-                deviceId,
-                addonId
-              },
-              meta: {
-                capName: info.name,
-                method,
-                error: err instanceof Error ? err.message : String(err)
-              }
-            });
-            return null;
-          }
+          return await resolveContribution(deps, {
+            deviceId,
+            kind,
+            capName: info.name,
+            addonId,
+            call: async () => {
+              const contribution = await provider[method]({ deviceId });
+              return contribution ? toWireShape(contribution) : null;
+            }
+          });
         })());
       }
       return (await Promise.all(tasks)).filter((r) => r !== null);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "camstack",
-  "version": "1.2.152",
+  "version": "1.2.154",
   "description": "CLI tool for managing and running CamStack server",
   "keywords": [
     "camstack",