@camstack/types 1.2.403 → 1.2.405

package/dist/interfaces/birth-decision-ledger.d.ts

@@ -121,6 +121,9 @@ export declare const BirthDecisionRecordSchema: z.ZodObject<{
     decidedByBirthEvidence: z.ZodBoolean;
     bestScore: z.ZodNullable<z.ZodNumber>;
     appliedMinConfidence: z.ZodNullable<z.ZodNumber>;
+    detectorModelId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    detectorDeviceKey: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    detectorNodeId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     firstSeen: z.ZodNullable<z.ZodNumber>;
     motionOnsetAt: z.ZodNullable<z.ZodNumber>;
     birthLatencyMs: z.ZodNullable<z.ZodNumber>;

package/dist/interfaces/pipeline-executor-capability.d.ts

@@ -1,6 +1,6 @@
-import type { PipelineEngineChoice, PipelineConfig } from '../types/pipeline.js';
+import type { PipelineEngineChoice } from '../types/pipeline.js';
 import type { PipelineExecutionPlane } from '../types/pipeline-step.js';
-import type { PipelineSchema, PipelineDefaultStep } from '../types/pipeline-schema.js';
+import type { PipelineSchema } from '../types/pipeline-schema.js';
 import type { ModelFormat } from '../types/models.js';
 import type { FrameInput } from '../types/io.js';
 import type { FrameRef } from '../types/frame-view.js';
@@ -112,12 +112,6 @@ export interface IPipelineExecutorProvider {
     getSchema(engine?: PipelineEngineChoice): Promise<PipelineSchema>;
     /** Get all available engines probed on this agent */
     getAvailableEngines(): Promise<PipelineEngineChoice[]>;
-    /** Build default step tree for an engine */
-    getDefaultSteps(engine: PipelineEngineChoice): Promise<PipelineDefaultStep[]>;
-    /** Compute this node's hardware-aware default step tree (null when the catalog yields no steps). */
-    getGlobalSteps(): Promise<PipelineDefaultStep[] | null>;
-    /** Get the runner-ready pipeline config */
-    getGlobalPipelineConfig(): Promise<PipelineConfig | null>;
     /**
      * Gate B (pre-init config-correctness gate). PURE COMPUTE against this
      * node's `currentEngine.format` — resolves `steps` the same way the

package/dist/interfaces/platform.d.ts

@@ -1,4 +1,5 @@
 import type { InferenceDeviceDescriptor } from '../inference/runtime-capabilities.js';
+import type { AcceleratorCompute } from '../pipeline/auto-tune/accelerator-compute.js';
 /** Hardware information detected at boot */
 export interface HardwareInfo {
     readonly platform: 'darwin' | 'linux' | 'win32';
@@ -9,6 +10,12 @@ export interface HardwareInfo {
     readonly availableRAM_MB: number;
     readonly gpu: GpuInfo | null;
     readonly npu: NpuInfo | null;
+    /**
+     * Per-accelerator compute the probe reported (D930). Absent when the probe
+     * did not run; an empty list means it ran and found no accelerator. A
+     * failed field inside an entry is null, never 0.
+     */
+    readonly accelerators?: readonly AcceleratorCompute[];
     /**
      * Coral Edge TPU hardware (USB and/or PCIe), when found. Optional so existing
      * HardwareInfo construction sites and older cross-node probe reports stay

package/dist/node-color.d.ts

@@ -1,7 +1,6 @@
 import { z } from 'zod';
 /** Fixed cluster node palette ids (maps to `--color-node-*` theme tokens). */
 export declare const NODE_COLOR_IDS: readonly ['node-a', 'node-b', 'node-c', 'node-d', 'node-e', 'node-f', 'node-g', 'node-h'];
-export type NodeColorId = (typeof NODE_COLOR_IDS)[number];
 export declare const NodeColorIdSchema: z.ZodEnum<{
     "node-a": "node-a";
     "node-b": "node-b";
@@ -12,4 +11,5 @@ export declare const NodeColorIdSchema: z.ZodEnum<{
     "node-g": "node-g";
     "node-h": "node-h";
 }>;
+export type NodeColorId = z.infer<typeof NodeColorIdSchema>;
 export declare function assignNodeColorId(nodeId: string): NodeColorId;

package/dist/pipeline/auto-tune/accelerator-compute.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Capacity of an accelerator we have not measured (D930).
+ *
+ * The latency table stays the measured columns. A device that reports compute
+ * (OpenVINO GOPS, or execution units × clock, or compute units, or TOPS) is
+ * estimated from the nearest measured column of the same accelerator kind,
+ * scaled by the compute ratio and clamped. A node benchmark still replaces
+ * the estimate. A device that reports neither compute nor a known class stays
+ * `unknown`.
+ *
+ * A failed probe field is `null`, never `0` (D393): zero would be a compute
+ * ratio of zero and would size the device as if it could not run.
+ */
+import { z } from 'zod';
+import type { AcceleratorKind, HardwareClassId } from './plan-schemas.js';
+import { type DetectorLatencyColumn, type DetectorPerfTable } from './detector-performance.js';
+/**
+ * An unmeasured device is never estimated outside this band of its reference.
+ *
+ * Peak GOPS and detector latency do not move together: a 640 model is memory
+ * bound, a 320 model less so, and the N100→N305 public EU×clock ratio is
+ * about 2.2×. 2× is the widest that spread justifies without a measurement
+ * on the device; 0.5× is the symmetric floor so a tiny iGPU is not told it
+ * is many times slower than the weakest column we measured. A node benchmark
+ * replaces the estimate and is not clamped.
+ */
+export declare const ESTIMATE_COMPUTE_RATIO_MIN = 0.5;
+export declare const ESTIMATE_COMPUTE_RATIO_MAX = 2;
+/**
+ * Within this of 1.0, a device whose class IS the reference is that measured
+ * machine (a probe clock a few percent off the spec), not a different chip.
+ * An unknown class is still estimated, so the plan says so.
+ */
+export declare const REFERENCE_MATCH_FRACTION = 0.05;
+/** N100 iGPU: 24 execution units, 750 MHz graphics max (Intel specification). */
+export declare const N100_IGPU_EU = 24;
+export declare const N100_IGPU_CLOCK_MHZ = 750;
+/**
+ * Core Ultra 7 265K iGPU: 4 Xe-cores. OpenVINO's execution-unit count for
+ * Xe-LP is 16 per Xe-core, and the graphics max dynamic frequency is 2000 MHz.
+ * Used only to choose the nearest column for a chip that is not itself a
+ * Core Ultra — that class is the measurement and is never scaled.
+ */
+export declare const CORE_ULTRA_265K_IGPU_EU = 64;
+export declare const CORE_ULTRA_265K_IGPU_CLOCK_MHZ = 2000;
+/** Phoenix / Hawk Point Radeon 780M: 12 compute units. */
+export declare const PHOENIX_780M_CU = 12;
+export declare const PrecisionGopsSchema: z.ZodObject<{
+    int8: z.ZodPipe<z.ZodNullable<z.ZodNumber>, z.ZodTransform<number | null, number | null>>;
+    fp16: z.ZodPipe<z.ZodNullable<z.ZodNumber>, z.ZodTransform<number | null, number | null>>;
+}, z.core.$strip>;
+export type PrecisionGops = z.infer<typeof PrecisionGopsSchema>;
+/** What one accelerator device reported. Every failed query is null. */
+export declare const AcceleratorComputeSchema: z.ZodObject<{
+    deviceKey: z.ZodString;
+    fullDeviceName: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+    executionUnits: z.ZodPipe<z.ZodNullable<z.ZodNumber>, z.ZodTransform<number | null, number | null>>;
+    clockMHz: z.ZodPipe<z.ZodNullable<z.ZodNumber>, z.ZodTransform<number | null, number | null>>;
+    gops: z.ZodNullable<z.ZodObject<{
+        int8: z.ZodPipe<z.ZodNullable<z.ZodNumber>, z.ZodTransform<number | null, number | null>>;
+        fp16: z.ZodPipe<z.ZodNullable<z.ZodNumber>, z.ZodTransform<number | null, number | null>>;
+    }, z.core.$strip>>;
+    architecture: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+    npuName: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+    tops: z.ZodPipe<z.ZodNullable<z.ZodNumber>, z.ZodTransform<number | null, number | null>>;
+    vendor: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+    webgpuArchitecture: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+    webgpuDevice: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+    computeUnits: z.ZodPipe<z.ZodNullable<z.ZodNumber>, z.ZodTransform<number | null, number | null>>;
+}, z.core.$strip>;
+export type AcceleratorCompute = z.infer<typeof AcceleratorComputeSchema>;
+/** The unit a compute ratio is taken in. Two scores of different units are not compared. */
+export type ComputeMetric = 'gops-int8' | 'gops-fp16' | 'eu-mhz' | 'cu' | 'tops';
+export interface ComputeScore {
+    readonly metric: ComputeMetric;
+    readonly value: number;
+}
+/** The compute of one measured column, in the unit the probe reports. */
+export interface ReferenceCompute {
+    readonly hardwareClass: HardwareClassId;
+    readonly accelerator: AcceleratorKind;
+    readonly score: ComputeScore;
+}
+/**
+ * Compute of the machines the latency columns were measured on.
+ * GOPS is preferred when a column carries it; none of these do yet — the
+ * boxes were measured before the probe reported `DEVICE_GOPS` — so the scale
+ * uses execution units × clock (Intel) or compute units (AMD) until a
+ * re-measure locks a GOPS figure on the column.
+ */
+export declare const REFERENCE_COMPUTE: readonly ReferenceCompute[];
+export interface ResolveLatencyInput {
+    readonly hardwareClass: HardwareClassId;
+    readonly accelerator: AcceleratorKind;
+    readonly report: AcceleratorCompute | null;
+    readonly perf?: DetectorPerfTable;
+    readonly references?: readonly ReferenceCompute[];
+}
+export interface ResolvedLatencyColumn {
+    readonly column: DetectorLatencyColumn;
+    /** Null when the column is the measurement itself. */
+    readonly estimatedFrom: HardwareClassId | null;
+}
+/** Parse a probe payload. `null` means the probe failed — not "no accelerators". */
+export declare function parseAcceleratorFactsJson(raw: unknown): readonly AcceleratorCompute[] | null;
+/** Scores in the order the estimate prefers. A non-positive field is absent. */
+export declare function computeScores(report: AcceleratorCompute): readonly ComputeScore[];
+/** True when this report can scale a measured column of `kind`. */
+export declare function reportIsScalable(report: AcceleratorCompute, kind: AcceleratorKind, references?: readonly ReferenceCompute[]): boolean;
+/**
+ * The latency column for one device. A measured class other than the N-series
+ * spread is returned unchanged — one class there is one measured machine.
+ * `intel-n-series` is the N100 column; a different reported compute scales it.
+ * An unknown class scales from the nearest reference of the same kind.
+ */
+export declare function resolveLatencyColumn(input: ResolveLatencyInput): ResolvedLatencyColumn | null;

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

@@ -21,6 +21,11 @@ export interface DetectorLatencyCell {
     readonly fps: number;
     /** False for a cell derived from another column (scaled), not measured. */
     readonly measured: boolean;
+    /**
+     * Set when this cell was scaled from another class's measured column (D930).
+     * Absent on a measured cell and on a cell derived inside the same column.
+     */
+    readonly estimatedFrom?: HardwareClassId;
 }
 /** `modelId → cell` for one (hardware class, accelerator) column. */
 export type DetectorLatencyColumn = Readonly<Record<string, DetectorLatencyCell>>;

package/dist/pipeline/auto-tune/hardware-class.d.ts

@@ -1,11 +1,12 @@
 /**
- * Static hardware classification for the Auto tune recommender (D745).
+ * Static hardware classification for the Auto tune recommender (D745, D930).
  *
  * A node is classified from the facts its platform probe already reports —
  * `cpuModel`, `arch`, `gpu`, `npu` — never from a benchmark. The class picks a
- * column of the measured latency table (`detector-performance.ts`); a node
- * whose CPU matches no measured class is `unknown` and the recommender leaves
- * it alone, saying so.
+ * column of the measured latency table (`detector-performance.ts`). A CPU that
+ * matches no measured class is `unknown`: the recommender then scales from
+ * reported accelerator compute when the probe supplied it, and leaves the
+ * node alone only when it has neither.
  *
  * `cpuModel` is the host's CPU string even inside Docker (`os.cpus()`), which
  * is why it is the discriminator: "Intel(R) Core(TM) Ultra 7 265K",

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

@@ -5,5 +5,6 @@
  */
 export * from './hardware-class.js';
 export * from './detector-performance.js';
+export * from './accelerator-compute.js';
 export * from './recommend.js';
 export * from './plan-schemas.js';

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

@@ -99,6 +99,16 @@ export declare const LatencySourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"node-benchmark">;
     resultId: z.ZodString;
     measuredAtMs: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"estimated">;
+    estimatedFrom: z.ZodEnum<{
+        "amd-phoenix": "amd-phoenix";
+        "apple-m-base": "apple-m-base";
+        "apple-m-pro": "apple-m-pro";
+        "intel-core-ultra": "intel-core-ultra";
+        "intel-n-series": "intel-n-series";
+        unknown: "unknown";
+    }>;
 }, z.core.$strip>], "kind">;
 export type LatencySource = z.infer<typeof LatencySourceSchema>;
 export declare const DeviceModelChoiceSchema: z.ZodObject<{
@@ -112,7 +122,25 @@ export declare const DeviceModelChoiceSchema: z.ZodObject<{
         kind: z.ZodLiteral<"node-benchmark">;
         resultId: z.ZodString;
         measuredAtMs: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"estimated">;
+        estimatedFrom: z.ZodEnum<{
+            "amd-phoenix": "amd-phoenix";
+            "apple-m-base": "apple-m-base";
+            "apple-m-pro": "apple-m-pro";
+            "intel-core-ultra": "intel-core-ultra";
+            "intel-n-series": "intel-n-series";
+            unknown: "unknown";
+        }>;
     }, z.core.$strip>], "kind">>;
+    estimatedFrom: z.ZodOptional<z.ZodEnum<{
+        "amd-phoenix": "amd-phoenix";
+        "apple-m-base": "apple-m-base";
+        "apple-m-pro": "apple-m-pro";
+        "intel-core-ultra": "intel-core-ultra";
+        "intel-n-series": "intel-n-series";
+        unknown: "unknown";
+    }>>;
     capacitySessions: z.ZodNumber;
     personRecall: z.ZodNumber;
 }, z.core.$strip>;
@@ -141,7 +169,25 @@ export declare const DeviceRecommendationSchema: z.ZodObject<{
             kind: z.ZodLiteral<"node-benchmark">;
             resultId: z.ZodString;
             measuredAtMs: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"estimated">;
+            estimatedFrom: z.ZodEnum<{
+                "amd-phoenix": "amd-phoenix";
+                "apple-m-base": "apple-m-base";
+                "apple-m-pro": "apple-m-pro";
+                "intel-core-ultra": "intel-core-ultra";
+                "intel-n-series": "intel-n-series";
+                unknown: "unknown";
+            }>;
         }, z.core.$strip>], "kind">>;
+        estimatedFrom: z.ZodOptional<z.ZodEnum<{
+            "amd-phoenix": "amd-phoenix";
+            "apple-m-base": "apple-m-base";
+            "apple-m-pro": "apple-m-pro";
+            "intel-core-ultra": "intel-core-ultra";
+            "intel-n-series": "intel-n-series";
+            unknown: "unknown";
+        }>>;
         capacitySessions: z.ZodNumber;
         personRecall: z.ZodNumber;
     }, z.core.$strip>>;
@@ -243,7 +289,25 @@ export declare const NodeRecommendationSchema: z.ZodObject<{
                 kind: z.ZodLiteral<"node-benchmark">;
                 resultId: z.ZodString;
                 measuredAtMs: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"estimated">;
+                estimatedFrom: z.ZodEnum<{
+                    "amd-phoenix": "amd-phoenix";
+                    "apple-m-base": "apple-m-base";
+                    "apple-m-pro": "apple-m-pro";
+                    "intel-core-ultra": "intel-core-ultra";
+                    "intel-n-series": "intel-n-series";
+                    unknown: "unknown";
+                }>;
             }, z.core.$strip>], "kind">>;
+            estimatedFrom: z.ZodOptional<z.ZodEnum<{
+                "amd-phoenix": "amd-phoenix";
+                "apple-m-base": "apple-m-base";
+                "apple-m-pro": "apple-m-pro";
+                "intel-core-ultra": "intel-core-ultra";
+                "intel-n-series": "intel-n-series";
+                unknown: "unknown";
+            }>>;
             capacitySessions: z.ZodNumber;
             personRecall: z.ZodNumber;
         }, z.core.$strip>>;
@@ -381,33 +445,15 @@ export declare const NodeDeviceChangeSchema: z.ZodObject<{
         keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
-export declare const CameraOverrideClearSchema: z.ZodObject<{
-    deviceId: z.ZodNumber;
-    source: z.ZodEnum<{
-        "step-override": "step-override";
-        wholesale: "wholesale";
-    }>;
-    nodeId: z.ZodString;
-    deviceKey: z.ZodNullable<z.ZodString>;
-    stepId: z.ZodString;
-    modelIdBefore: z.ZodNullable<z.ZodString>;
-    keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-export declare const DetectorStoreClearSchema: z.ZodObject<{
-    deviceId: z.ZodNumber;
-    keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
+/**
+ * Every model and model-bound threshold lives on the accelerator that runs it
+ * (D927), so the plan writes node / device entries only — there is no camera
+ * layer for it to clear.
+ */
 export declare const AutoTuneWarningSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"detector-store-cluster-wide">;
-    skippedNodes: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"detector-store-unreadable">;
-    error: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"custom-pin-kept">;
     nodeId: z.ZodString;
-    deviceKey: z.ZodNullable<z.ZodString>;
-    deviceId: z.ZodNullable<z.ZodNumber>;
+    deviceKey: z.ZodString;
     modelId: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"custom-registry-unreadable">;
@@ -463,7 +509,25 @@ export declare const AutoTunePlanSchema: z.ZodObject<{
                     kind: z.ZodLiteral<"node-benchmark">;
                     resultId: z.ZodString;
                     measuredAtMs: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"estimated">;
+                    estimatedFrom: z.ZodEnum<{
+                        "amd-phoenix": "amd-phoenix";
+                        "apple-m-base": "apple-m-base";
+                        "apple-m-pro": "apple-m-pro";
+                        "intel-core-ultra": "intel-core-ultra";
+                        "intel-n-series": "intel-n-series";
+                        unknown: "unknown";
+                    }>;
                 }, z.core.$strip>], "kind">>;
+                estimatedFrom: z.ZodOptional<z.ZodEnum<{
+                    "amd-phoenix": "amd-phoenix";
+                    "apple-m-base": "apple-m-base";
+                    "apple-m-pro": "apple-m-pro";
+                    "intel-core-ultra": "intel-core-ultra";
+                    "intel-n-series": "intel-n-series";
+                    unknown: "unknown";
+                }>>;
                 capacitySessions: z.ZodNumber;
                 personRecall: z.ZodNumber;
             }, z.core.$strip>>;
@@ -596,33 +660,10 @@ export declare const AutoTunePlanSchema: z.ZodObject<{
             keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>>;
-    cameraClears: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-        deviceId: z.ZodNumber;
-        source: z.ZodEnum<{
-            "step-override": "step-override";
-            wholesale: "wholesale";
-        }>;
-        nodeId: z.ZodString;
-        deviceKey: z.ZodNullable<z.ZodString>;
-        stepId: z.ZodString;
-        modelIdBefore: z.ZodNullable<z.ZodString>;
-        keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>>;
-    detectorStoreClears: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-        deviceId: z.ZodNumber;
-        keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>>;
     warnings: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"detector-store-cluster-wide">;
-        skippedNodes: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"detector-store-unreadable">;
-        error: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"custom-pin-kept">;
         nodeId: z.ZodString;
-        deviceKey: z.ZodNullable<z.ZodString>;
-        deviceId: z.ZodNullable<z.ZodNumber>;
+        deviceKey: z.ZodString;
         modelId: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"custom-registry-unreadable">;
@@ -636,8 +677,6 @@ export declare const AutoTuneApplyInputSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const AutoTunePhaseResultSchema: z.ZodObject<{
     phase: z.ZodEnum<{
-        "camera-overrides": "camera-overrides";
-        "detector-thresholds": "detector-thresholds";
         download: "download";
         "node-models": "node-models";
         redispatch: "redispatch";
@@ -650,8 +689,6 @@ export declare const AutoTuneApplyResultSchema: z.ZodDiscriminatedUnion<[z.ZodOb
     planHash: z.ZodString;
     phases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         phase: z.ZodEnum<{
-            "camera-overrides": "camera-overrides";
-            "detector-thresholds": "detector-thresholds";
             download: "download";
             "node-models": "node-models";
             redispatch: "redispatch";
@@ -663,8 +700,6 @@ export declare const AutoTuneApplyResultSchema: z.ZodDiscriminatedUnion<[z.ZodOb
     kind: z.ZodLiteral<"aborted">;
     phases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         phase: z.ZodEnum<{
-            "camera-overrides": "camera-overrides";
-            "detector-thresholds": "detector-thresholds";
             download: "download";
             "node-models": "node-models";
             redispatch: "redispatch";
@@ -720,7 +755,25 @@ export declare const AutoTuneApplyResultSchema: z.ZodDiscriminatedUnion<[z.ZodOb
                         kind: z.ZodLiteral<"node-benchmark">;
                         resultId: z.ZodString;
                         measuredAtMs: z.ZodNumber;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"estimated">;
+                        estimatedFrom: z.ZodEnum<{
+                            "amd-phoenix": "amd-phoenix";
+                            "apple-m-base": "apple-m-base";
+                            "apple-m-pro": "apple-m-pro";
+                            "intel-core-ultra": "intel-core-ultra";
+                            "intel-n-series": "intel-n-series";
+                            unknown: "unknown";
+                        }>;
                     }, z.core.$strip>], "kind">>;
+                    estimatedFrom: z.ZodOptional<z.ZodEnum<{
+                        "amd-phoenix": "amd-phoenix";
+                        "apple-m-base": "apple-m-base";
+                        "apple-m-pro": "apple-m-pro";
+                        "intel-core-ultra": "intel-core-ultra";
+                        "intel-n-series": "intel-n-series";
+                        unknown: "unknown";
+                    }>>;
                     capacitySessions: z.ZodNumber;
                     personRecall: z.ZodNumber;
                 }, z.core.$strip>>;
@@ -853,33 +906,10 @@ export declare const AutoTuneApplyResultSchema: z.ZodDiscriminatedUnion<[z.ZodOb
                 keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
             }, z.core.$strip>>>;
         }, z.core.$strip>>>;
-        cameraClears: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-            deviceId: z.ZodNumber;
-            source: z.ZodEnum<{
-                "step-override": "step-override";
-                wholesale: "wholesale";
-            }>;
-            nodeId: z.ZodString;
-            deviceKey: z.ZodNullable<z.ZodString>;
-            stepId: z.ZodString;
-            modelIdBefore: z.ZodNullable<z.ZodString>;
-            keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>>;
-        detectorStoreClears: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-            deviceId: z.ZodNumber;
-            keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>>;
         warnings: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"detector-store-cluster-wide">;
-            skippedNodes: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<"detector-store-unreadable">;
-            error: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"custom-pin-kept">;
             nodeId: z.ZodString;
-            deviceKey: z.ZodNullable<z.ZodString>;
-            deviceId: z.ZodNullable<z.ZodNumber>;
+            deviceKey: z.ZodString;
             modelId: z.ZodString;
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"custom-registry-unreadable">;
@@ -898,8 +928,6 @@ export type AutoTuneApplyInput = z.infer<typeof AutoTuneApplyInputSchema>;
 export type AutoTuneApplyResult = z.infer<typeof AutoTuneApplyResultSchema>;
 export type AutoTunePhaseResult = z.infer<typeof AutoTunePhaseResultSchema>;
 export type AutoTuneWarning = z.infer<typeof AutoTuneWarningSchema>;
-export type DetectorStoreClear = z.infer<typeof DetectorStoreClearSchema>;
-export type AutoTuneCameraOverrideClear = z.infer<typeof CameraOverrideClearSchema>;
 export type AutoTuneNodeDeviceChange = z.infer<typeof NodeDeviceChangeSchema>;
 export type HardwareClassId = z.infer<typeof HardwareClassIdSchema>;
 export type AcceleratorKind = z.infer<typeof AcceleratorKindSchema>;

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

@@ -7,18 +7,21 @@
  * Per node:
  *  1. Classify the hardware (`classifyInferenceHardware`). An unknown class,
  *     an offline node or a node with nothing to recommend is left untouched —
- *     unless the node has its own measurements (below).
- *  1b. MEASURED ON THE NODE BEATS THE TABLE (D791): a fresh node benchmark
- *     result for (device, model) replaces the table's cell, and the choice
- *     names it as its source. A node of unknown hardware with measurements is
- *     recommended from them alone.
+ *     unless the node has its own measurements (below) or a device reported
+ *     compute that can be scaled from a measured column (D930).
+ *  1b. MEASURED ON THE NODE BEATS THE TABLE (D791), and the table beats an
+ *     estimate: a fresh node benchmark result for (device, model) replaces
+ *     whatever cell the class or the compute scale produced. A node of
+ *     unknown hardware with measurements is recommended from them alone.
  *  2. The node's ACCELERATORS (NPU, iGPU, Neural Engine) that are enabled and
  *     available share ONE model — so a camera's floors never flip with the
  *     device the balancer rotated it onto. A candidate must have a build for
  *     every accelerator's format and a latency cell for each.
  *  3. A candidate FITS a device when the device sustains at least
  *     `minSessionsPerDevice` parallel sessions with it:
- *     ⌊fps × (1 − headroom) / camera fps⌋ ≥ minSessionsPerDevice.
+ *     ⌊fps × factor × (1 − headroom) / camera fps⌋ ≥ minSessionsPerDevice.
+ *     factor is 1 at 10 fps; below that an Intel iGPU uses the measured
+ *     overlap (D930).
  *  4. Among candidates that fit everywhere, the most accurate wins (person
  *     recall at the shipped floor); within `RECALL_TIE` of the best, the
  *     fastest wins. That IS the step-down order the data gives: the first
@@ -37,7 +40,7 @@
 import type { HardwareInfo } from '../../interfaces/platform.js';
 import type { ModelFormat } from '../../types/models.js';
 import { type DetectorPerfTable } from './detector-performance.js';
-import { type NodeRecommendation } from './plan-schemas.js';
+import { type AcceleratorKind, type NodeRecommendation } from './plan-schemas.js';
 /** The family the cluster runs. */
 export declare const AUTO_TUNE_FAMILY = "yolov9";
 /**
@@ -51,8 +54,27 @@ export declare const RECALL_TIE = 0.02;
 export declare const DEFAULT_HEADROOM = 0.4;
 /** Detection rate a session is counted at when no camera says otherwise. */
 export declare const DEFAULT_CAMERA_FPS = 10;
-/** Parallel sessions one device sustains at `fps` with `headroom` kept free. */
-export declare function capacitySessionsOf(fps: number, headroom: number, cameraFps: number): number;
+/**
+ * Camera rate at which serial `1000/p50` matched the cameras that held
+ * (N100 iGPU, 2026-10-24). Below this the second InferRequest's overlap
+ * becomes extra sessions; at and above it the serial ceiling is the count.
+ */
+export declare const SERIAL_CAPACITY_CAMERA_FPS = 10;
+/**
+ * Aggregate throughput ÷ serial throughput when the frame interval is wide
+ * enough to hide the second request. intel-igpu is the N100 measurement
+ * (~1.4× under LATENCY with 2 InferRequests). Every other kind stays 1
+ * until it is measured the same way.
+ */
+export declare const AGGREGATE_THROUGHPUT_BY_KIND: Readonly<Partial<Record<AcceleratorKind, number>>>;
+/** The overlap factor for this kind at this camera rate. 1 at {@link SERIAL_CAPACITY_CAMERA_FPS} and above. */
+export declare function aggregateThroughputFactor(kind: AcceleratorKind, cameraFps: number): number;
+/**
+ * Parallel sessions one device sustains at `fps` with `headroom` kept free.
+ * `aggregateFactor` is the kind's overlap (1 unless the caller measured
+ * extra throughput at this camera rate).
+ */
+export declare function capacitySessionsOf(fps: number, headroom: number, cameraFps: number, aggregateFactor?: number): number;
 /** A latency measured on the node itself (a fresh node benchmark result, D791). */
 export interface MeasuredLatencyCell {
     readonly p50Ms: number;

package/dist/pipeline/second-pass/index.d.ts

@@ -0,0 +1,2 @@
+export * from './small-subject-recovery.js';
+export * from './motion-crop-plan.js';