@camstack/types 1.2.404 → 1.2.406

package/dist/interfaces/config-ui.d.ts

@@ -86,7 +86,7 @@ export interface ConfigSection {
     readonly immediate?: boolean;
     readonly fields: readonly ConfigField[];
 }
-export type ConfigField = ConfigTextField | ConfigNumberField | ConfigBooleanField | ConfigSelectField | ConfigMultiSelectField | ConfigTimezoneField | ConfigDateTimeField | ConfigColorField | ConfigIconField | ConfigPasswordField | ConfigTextAreaField | ConfigSliderField | ConfigTagsField | ConfigScheduleField | ConfigGroupField | ConfigSubTabsField | ConfigSeparatorField | ConfigInfoField | ConfigQrCodeField | ConfigObjectArrayField | ConfigEditableArrayField | ConfigModelSelectorField | ConfigStorageLocationField | ConfigProbeField | ConfigButtonField | ConfigNodeSelectField | ConfigNodeMultiSelectField | ConfigDeviceSelectField | ConfigDeviceMultiSelectField | ConfigNotificationTargetSelectField | ConfigNotificationTargetMultiSelectField | ConfigWidgetField | ConfigAddonActionSelectField | ConfigAddonActionButtonField | ConfigDeviceActionButtonField;
+export type ConfigField = ConfigTextField | ConfigNumberField | ConfigBooleanField | ConfigSelectField | ConfigMultiSelectField | ConfigTimezoneField | ConfigDateTimeField | ConfigColorField | ConfigIconField | ConfigPasswordField | ConfigTextAreaField | ConfigSliderField | ConfigTagsField | ConfigScheduleField | ConfigGroupField | ConfigSubTabsField | ConfigSeparatorField | ConfigInfoField | ConfigQrCodeField | ConfigObjectArrayField | ConfigEditableArrayField | ConfigModelSelectorField | ConfigStorageLocationField | ConfigProbeField | ConfigButtonField | ConfigNodeSelectField | ConfigNodeMultiSelectField | ConfigDeviceSelectField | ConfigDeviceMultiSelectField | ConfigNotificationTargetSelectField | ConfigNotificationTargetMultiSelectField | ConfigWidgetField | ConfigAddonActionSelectField | ConfigAddonActionButtonField | ConfigDeviceActionButtonField | ConfigAccountSignInField | ConfigSecretPresenceField;
 /**
  * Per-MODEL applicability of a pipeline-step setting (D214).
  *
@@ -903,6 +903,18 @@ export interface ConfigAddonActionSelectField extends ConfigFieldBase {
     emptyParamsMessage?: string;
     /** Optional message shown when the action returns no results. */
     emptyResultsMessage?: string;
+    /**
+     * When the action returns fewer than this many rows, render nothing.
+     * A single row is written into `writesKey`, or into this field's key.
+     * The manual fallback next to it stays the control the operator sees.
+     */
+    hideWhenFewerThan?: number;
+    /**
+     * Settings key the chosen value is written to when it is not this field's
+     * key. Use it so a discovery select and a manual text field do not share
+     * one React key.
+     */
+    writesKey?: string;
 }
 /**
  * Button that invokes an addon customAction. Used for "Verify token /
@@ -957,6 +969,61 @@ export interface ConfigAddonActionButtonField extends ConfigFieldBase {
     /** Confirmation prompt before executing. */
     confirmMessage?: string;
 }
+/**
+ * "Sign in with <provider>". The button asks the addon for an authorize URL.
+ * PKCE verifier and state stay on the addon, keyed by `attemptId`. One paste
+ * box completes the sign-in. Tokens are written into secret fields and are
+ * not rendered here.
+ */
+export interface ConfigAccountSignInField extends ConfigFieldBase {
+    readonly type: 'account-sign-in';
+    /** The paste box is local. Stored keys are the sibling fields. */
+    readonly value?: undefined;
+    readonly addonId: string;
+    /** "Sign in with {providerLabel}". */
+    readonly providerLabel: string;
+    readonly beginAction: string;
+    readonly completeAction: string;
+    readonly signOutAction: string;
+    /** Non-secret settings key holding the account label. */
+    readonly accountKey: string;
+    /** Optional numeric settings key shown after the account. */
+    readonly countKey?: string;
+    /** Singular noun for `countKey` ("gateway" → "gateways"). */
+    readonly countNoun?: string;
+    /**
+     * Settings key holding an array or a JSON array string whose length is the
+     * count when `countKey` is empty.
+     */
+    readonly countFromKey?: string;
+    /** Placeholder for the paste box. */
+    readonly pastePlaceholder?: string;
+    /**
+     * Shown when the complete action returns more than one `choices` row.
+     * Picking one writes `choiceKey` plus `brand` and `region` when the row has them.
+     */
+    readonly choiceKey?: string;
+    readonly choiceLabel?: string;
+    /** Secret settings keys cleared with the keychain clear instruction on sign-out. */
+    readonly secretKeys: readonly string[];
+    /**
+     * Copy these result keys into the form after a successful paste.
+     * Secret values are stored for save and rendered only by their own fields.
+     */
+    readonly assignResult?: Readonly<Record<string, string>>;
+}
+/**
+ * "yes" / "no" for a secret that must not be shown. Reads another field's
+ * value: a non-empty string or a keychain view counts as present.
+ */
+export interface ConfigSecretPresenceField extends ConfigFieldBase {
+    readonly type: 'secret-presence';
+    /** Reads another field. This row stores nothing. */
+    readonly value?: undefined;
+    readonly sourceKey: string;
+    readonly yesLabel: string;
+    readonly noLabel: string;
+}
 /**
  * Button that invokes a DEVICE custom action (the device equivalent of
  * `addon-action-button`). The deviceId comes from the form context, so it is
@@ -1052,7 +1119,7 @@ export type ConfigFieldWithValue = (ConfigTextField & {
     readonly value: unknown;
 }) | ConfigWidgetField | (ConfigAddonActionSelectField & {
     readonly value: unknown;
-}) | ConfigAddonActionButtonField | ConfigDeviceActionButtonField;
+}) | ConfigAddonActionButtonField | ConfigDeviceActionButtonField | ConfigAccountSignInField | ConfigSecretPresenceField;
 /** Recursive version of `ConfigGroupField` with hydrated child fields. */
 export interface ConfigGroupFieldWithValue extends ConfigFieldBase {
     readonly type: 'group';

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/node.js

@@ -21,7 +21,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-const require_composition = require("./composition-eoYYVfOp.js");
+const require_composition = require("./composition-RmnnN39T.js");
 const require_err_msg = require("./err-msg-BhVbr0NX.js");
 let node_crypto = require("node:crypto");
 let node_fs = require("node:fs");

package/dist/node.mjs

@@ -1,4 +1,4 @@
-import { At as Fmp4BoxSplitter, Ct as FFMPEG_PATH_ENV, Dt as getFfmpegArtifact, Et as FFMPEG_RELEASE, Ot as getFfmpegDownloadUrl, P as compositionSourceKey, Pt as buildFfmpegArgs, Rt as isSoftwareDecode, Tt as ffmpegBinaryName, a as CUSTOMIZATION_BLOCK_NAME_PREFIX, kt as canonicalHash, wt as chooseFfmpegBinary } from "./composition-CB6PMT9p.mjs";
+import { At as Fmp4BoxSplitter, Ct as FFMPEG_PATH_ENV, Dt as getFfmpegArtifact, Et as FFMPEG_RELEASE, Ot as getFfmpegDownloadUrl, P as compositionSourceKey, Pt as buildFfmpegArgs, Rt as isSoftwareDecode, Tt as ffmpegBinaryName, a as CUSTOMIZATION_BLOCK_NAME_PREFIX, kt as canonicalHash, wt as chooseFfmpegBinary } from "./composition-xz-ud5EQ.mjs";
 import { t as errMsg } from "./err-msg-BXKzRBwg.mjs";
 import { createHash, createHmac, randomUUID, timingSafeEqual } from "node:crypto";
 import * as fs from "node:fs";

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>>;
@@ -445,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>>;
@@ -673,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>>;

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';