@camstack/types 1.2.398 → 1.2.400

package/dist/pipeline/auto-tune/detector-performance.d.ts

@@ -7,7 +7,8 @@
  * `docs/benchmarks/model-floors.json` (person precision / recall at the
  * shipped floor). `__tests__/detector-performance.spec.ts` holds both tables
  * equal to those files, so a re-measurement replaces the JSON and this file
- * together. Only the YOLOv9 t/s/m family is here: the cluster runs ONE family
+ * together. Only the YOLOv9 t/s/m family is here (plus, in each `coral` column,
+ * the one Edge TPU build a Coral runs by default, `yolov9s-320-edgetpu`, D912): the cluster runs ONE family
  * (YOLOv9 — the one that runs well on every accelerator class measured), and
  * tier c is not offered (a few recall points for 25–50 % more latency).
  */

package/dist/pipeline/auto-tune/plan-schemas.d.ts

@@ -52,8 +52,6 @@ export declare const RecommendationReasonSchema: z.ZodDiscriminatedUnion<[z.ZodO
     modelId: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"cpu-device">;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"coral-untouched">;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"device-disabled">;
 }, z.core.$strip>, z.ZodObject<{
@@ -172,8 +170,6 @@ export declare const DeviceRecommendationSchema: z.ZodObject<{
         modelId: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"cpu-device">;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"coral-untouched">;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"device-disabled">;
     }, z.core.$strip>, z.ZodObject<{
@@ -276,8 +272,6 @@ export declare const NodeRecommendationSchema: z.ZodObject<{
             modelId: z.ZodString;
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"cpu-device">;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<"coral-untouched">;
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"device-disabled">;
         }, z.core.$strip>, z.ZodObject<{
@@ -334,8 +328,6 @@ export declare const NodeRecommendationSchema: z.ZodObject<{
         modelId: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"cpu-device">;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"coral-untouched">;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"device-disabled">;
     }, z.core.$strip>, z.ZodObject<{
@@ -411,10 +403,6 @@ export declare const AutoTuneWarningSchema: z.ZodDiscriminatedUnion<[z.ZodObject
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"detector-store-unreadable">;
     error: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"coral-enabled">;
-    nodeId: z.ZodString;
-    deviceKey: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"custom-pin-kept">;
     nodeId: z.ZodString;
@@ -504,8 +492,6 @@ export declare const AutoTunePlanSchema: z.ZodObject<{
                 modelId: z.ZodString;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"cpu-device">;
-            }, z.core.$strip>, z.ZodObject<{
-                kind: z.ZodLiteral<"coral-untouched">;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"device-disabled">;
             }, z.core.$strip>, z.ZodObject<{
@@ -562,8 +548,6 @@ export declare const AutoTunePlanSchema: z.ZodObject<{
             modelId: z.ZodString;
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"cpu-device">;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<"coral-untouched">;
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"device-disabled">;
         }, z.core.$strip>, z.ZodObject<{
@@ -634,10 +618,6 @@ export declare const AutoTunePlanSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"detector-store-unreadable">;
         error: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"coral-enabled">;
-        nodeId: z.ZodString;
-        deviceKey: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"custom-pin-kept">;
         nodeId: z.ZodString;
@@ -769,8 +749,6 @@ export declare const AutoTuneApplyResultSchema: z.ZodDiscriminatedUnion<[z.ZodOb
                     modelId: z.ZodString;
                 }, z.core.$strip>, z.ZodObject<{
                     kind: z.ZodLiteral<"cpu-device">;
-                }, z.core.$strip>, z.ZodObject<{
-                    kind: z.ZodLiteral<"coral-untouched">;
                 }, z.core.$strip>, z.ZodObject<{
                     kind: z.ZodLiteral<"device-disabled">;
                 }, z.core.$strip>, z.ZodObject<{
@@ -827,8 +805,6 @@ export declare const AutoTuneApplyResultSchema: z.ZodDiscriminatedUnion<[z.ZodOb
                 modelId: z.ZodString;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"cpu-device">;
-            }, z.core.$strip>, z.ZodObject<{
-                kind: z.ZodLiteral<"coral-untouched">;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"device-disabled">;
             }, z.core.$strip>, z.ZodObject<{
@@ -899,10 +875,6 @@ export declare const AutoTuneApplyResultSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"detector-store-unreadable">;
             error: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<"coral-enabled">;
-            nodeId: z.ZodString;
-            deviceKey: z.ZodString;
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"custom-pin-kept">;
             nodeId: z.ZodString;

package/dist/pipeline/auto-tune/recommend.d.ts

@@ -25,7 +25,10 @@
  *     variant down from m-640 is s-640-int8, not m-320. When nothing fits,
  *     the candidate with the most capacity is used and the plan says so.
  *  5. An enabled CPU device (the fallback pool) gets its own pick the same
- *     way; a Coral is never touched (no YOLOv9 build), only reported.
+ *     way. An ENABLED Coral is sized at its one default build
+ *     (`CORAL_DEFAULT_MODEL_ID`) from the `coral` column, outside the
+ *     accelerator group — it shares no model with it. A DISABLED Coral stays
+ *     out like any disabled device; a Coral is enabled by default (D912).
  *  6. A device whose root detector is pinned to a CUSTOM-registry model (a
  *     fine-tune, a canary) is KEPT (D786): no model is chosen for it, so Apply
  *     writes nothing there. One kept accelerator keeps the whole accelerator
@@ -37,6 +40,11 @@ import { type DetectorPerfTable } from './detector-performance.js';
 import { type NodeRecommendation } from './plan-schemas.js';
 /** The family the cluster runs. */
 export declare const AUTO_TUNE_FAMILY = "yolov9";
+/**
+ * The model a Coral runs by default (D908) and the only one Auto tune sizes it
+ * at (D912). Auto tune never enables a device; it sizes the enabled ones.
+ */
+export declare const CORAL_DEFAULT_MODEL_ID = "yolov9s-320-edgetpu";
 /** Recall within this of the best counts as a tie — the faster one wins. */
 export declare const RECALL_TIE = 0.02;
 /** Default share of an accelerator's throughput kept free. */

package/dist/pipeline/load-balancing/capacity-shares.d.ts

@@ -7,6 +7,12 @@ export interface DeviceMeasuredCapacity {
     readonly maxSessions: number;
     readonly modelId: string | null;
     readonly measuredAtMs: number;
+    /**
+     * Which measurement the number comes from: a `pipeline` cell's sessions, or
+     * a `device` cell's `kMax` read as sessions (an upper bound — see
+     * `sessionsOfDeviceCell`). Absent = a source that does not say.
+     */
+    readonly phase?: 'pipeline' | 'device';
 }
 /** One node's measured capacity. */
 export interface NodeMeasuredCapacity {
@@ -22,6 +28,27 @@ export interface NodeCapacitySource {
     /** The usable (fresh) measured capacity of each asked node that has any. */
     readMeasuredCapacity(nodeIds: readonly string[]): Promise<ReadonlyMap<string, NodeMeasuredCapacity>>;
 }
+/**
+ * The measured capacity of `deviceKey` for the model it runs NOW, or
+ * undefined. A cell measured for another model says nothing about this one
+ * (a failed load of a heavier build is not this build's capacity), and a cell
+ * that names no model cannot be matched. The ONE predicate behind both the
+ * automatic shares and the automatic benchmark's "has results".
+ */
+export declare function capacityForModel(node: NodeMeasuredCapacity | undefined, deviceKey: string, modelId: string | null): DeviceMeasuredCapacity | undefined;
+/** A measured cell the shares ignore: it is for a model the device does not run now. */
+export interface ForeignCapacityCell {
+    readonly nodeId: string;
+    readonly deviceKey: string;
+    readonly measuredModelId: string;
+    /** The model Auto tune pins on the device now, or null = none chosen. */
+    readonly runsModelId: string | null;
+}
+/**
+ * Every measured (device × model) cell that no device runs now — what
+ * {@link capacityForModel} skips, so the caller can say so once.
+ */
+export declare function foreignCapacityCells(recommendations: readonly NodeRecommendation[], measured: ReadonlyMap<string, NodeMeasuredCapacity>): readonly ForeignCapacityCell[];
 /** A source that has no results — the benchmark store before it exists. */
 export declare const NO_MEASURED_CAPACITY: NodeCapacitySource;
 /** Integer shares summing to 100 (largest remainder); ties broken by key. */

package/dist/pipeline/load-balancing/share-election.d.ts

@@ -29,6 +29,13 @@ export interface ShareCandidate {
     readonly share: number;
     /** Sessions running on this candidate now. */
     readonly running: number;
+    /**
+     * Recent elections that are not running now, decayed over time (default 0).
+     * Sessions that never overlap leave `running` at 0 at every election, so the
+     * deficits tie forever and the key order hands every session to the same
+     * candidate; counting history makes the CUMULATIVE split follow the shares.
+     */
+    readonly recent?: number;
     /** At an explicit cap — never elected. */
     readonly capped: boolean;
     /** Drowning (pool queue at its shed cap) — stepped over while another is free. */

package/dist/pipeline/node-benchmark/results.d.ts

@@ -46,7 +46,21 @@ export interface MeasuredDetectorCell {
 /** deviceKey → modelId → the fresh `device` measurement on `nodeId`. */
 export declare function measuredDetectorCells(rows: readonly NodeBenchmarkResult[], nodeId: string, ctx: StandingContext): Readonly<Record<string, Readonly<Record<string, MeasuredDetectorCell>>>>;
 /**
- * Per node, each device at its newest fresh `pipeline` measurement — the
- * `NodeCapacitySource` answer the automatic shares read.
+ * Parallel sessions a `device`-phase cell stands for.
+ *
+ * Both numbers are "streams at the camera rate the hardware carried inside
+ * the frame interval" (`kMax` for the detector alone, `maxSessions` for the
+ * detector plus its enrichment steps) and the benchmark page already shows
+ * `kMax` as "streams", so the unit is the same and the conversion is the
+ * identity. It is an UPPER bound for a session that also runs enrichment —
+ * which is why a `pipeline` cell for the same model always wins over it.
+ */
+export declare function sessionsOfDeviceCell(kMax: number): number;
+/**
+ * Per node, every (device × model) at its best fresh measurement: the newest
+ * `pipeline` cell, else the newest `device` cell read as
+ * {@link sessionsOfDeviceCell}. Several models of one device are kept apart —
+ * the caller picks the one the device runs NOW (a cell for another model says
+ * nothing about it).
  */
 export declare function measuredCapacityFromResults(rows: readonly NodeBenchmarkResult[], nodeIds: readonly string[], ctx: StandingContext): ReadonlyMap<string, NodeMeasuredCapacity>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/types",
-  "version": "1.2.398",
+  "version": "1.2.400",
   "description": "Shared types, interfaces, and model catalogs for the CamStack detection ecosystem",
   "keywords": [
     "camstack",