@camstack/types 1.2.403 → 1.2.404

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/pipeline/auto-tune/plan-schemas.d.ts

@@ -381,33 +381,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">;
@@ -596,33 +578,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 +595,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 +607,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 +618,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";
@@ -853,33 +806,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 +828,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/step-settings-layers.d.ts

@@ -1,13 +1,13 @@
 /**
  * The layers of a detection step's settings, and the field-level edits on them
- * (D754).
+ * (D754, D927).
  *
- * A step's settings reach a session through up to three stored layers, merged
- * key by key — a key in a higher layer wins:
+ * A step's settings reach a session through two stored layers, merged key by
+ * key — a key in the higher layer wins:
  *
- *   node         the node's folded base (`inferenceDevices[node][*].steps`)
- *   camera       `cameraSettings[cam].stepSettings[step]` — every accelerator
- *   accelerator  `cameraSettings[cam].stepOverridesByDevice[node][key][step].settings`
+ *   node         the node's base for the accelerator that runs the step
+ *   camera       `cameraSettings[cam].stepSettings[step]` — camera-semantic
+ *                keys only, on every accelerator (never a model-bound field)
  *
  * Below them sits the default: the running model's (D738) or the field's own.
  *
@@ -27,12 +27,11 @@
 export type StepSettingsBag = Readonly<Record<string, unknown>>;
 /** The stored layers, from the top. `undefined` = the layer stores nothing for this step. */
 export interface StepSettingsLayers {
-    readonly accelerator?: StepSettingsBag;
     readonly camera?: StepSettingsBag;
     readonly node?: StepSettingsBag;
 }
 /** Which stored layer supplies a field, or `default` when none does. */
-export type StepSettingSource = 'accelerator' | 'camera' | 'node' | 'default';
+export type StepSettingSource = 'camera' | 'node' | 'default';
 /**
  * The keys one field occupies in a bag: its own, plus its binding key when it
  * binds to a model. `boundKeys` = `collectModelBoundKeys(schema)`.

package/dist/{sleep-Ch67uumJ.js → sleep-BKS4OPMo.js}

@@ -1,4 +1,4 @@
-const require_event_category = require("./event-category-7AwNbPjm.js");
+const require_event_category = require("./event-category-CXrwjC3e.js");
 let zod = require("zod");
 //#region src/audio/audio-chunk-format.ts
 /**
@@ -7540,10 +7540,7 @@ function createDeviceProxy(api, binding, opts) {
 		setCameraStepToggle: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepToggle", "mutation", input),
 		getCameraDetectionSource: (input) => dispatchSystem("pipelineOrchestrator", "getCameraDetectionSource", "query", input),
 		setCameraDetectionSource: (input) => dispatchSystem("pipelineOrchestrator", "setCameraDetectionSource", "mutation", input),
-		getCameraStepOverrides: (input) => dispatchSystem("pipelineOrchestrator", "getCameraStepOverrides", "query", input),
-		setCameraStepOverride: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepOverride", "mutation", input),
 		setCameraStepSettings: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepSettings", "mutation", input),
-		setCameraPipelineForAgent: (input) => dispatchSystem("pipelineOrchestrator", "setCameraPipelineForAgent", "mutation", input),
 		resolvePipeline: (input) => dispatchSystem("pipelineOrchestrator", "resolvePipeline", "query", input),
 		getCameraSwitches: (input) => dispatchSystem("pipelineOrchestrator", "getCameraSwitches", "query", input),
 		setCameraSwitch: (input) => dispatchSystem("pipelineOrchestrator", "setCameraSwitch", "mutation", input),

package/dist/{sleep-6AqUnQIT.mjs → sleep-CHIEEJkY.mjs}

@@ -1,4 +1,4 @@
-import { t as EventCategory } from "./event-category-BfJwUd2S.mjs";
+import { t as EventCategory } from "./event-category-fDPduoeC.mjs";
 import { z } from "zod";
 //#region src/audio/audio-chunk-format.ts
 /**
@@ -7540,10 +7540,7 @@ function createDeviceProxy(api, binding, opts) {
 		setCameraStepToggle: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepToggle", "mutation", input),
 		getCameraDetectionSource: (input) => dispatchSystem("pipelineOrchestrator", "getCameraDetectionSource", "query", input),
 		setCameraDetectionSource: (input) => dispatchSystem("pipelineOrchestrator", "setCameraDetectionSource", "mutation", input),
-		getCameraStepOverrides: (input) => dispatchSystem("pipelineOrchestrator", "getCameraStepOverrides", "query", input),
-		setCameraStepOverride: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepOverride", "mutation", input),
 		setCameraStepSettings: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepSettings", "mutation", input),
-		setCameraPipelineForAgent: (input) => dispatchSystem("pipelineOrchestrator", "setCameraPipelineForAgent", "mutation", input),
 		resolvePipeline: (input) => dispatchSystem("pipelineOrchestrator", "resolvePipeline", "query", input),
 		getCameraSwitches: (input) => dispatchSystem("pipelineOrchestrator", "getCameraSwitches", "query", input),
 		setCameraSwitch: (input) => dispatchSystem("pipelineOrchestrator", "setCameraSwitch", "mutation", input),

package/dist/types/agent-pipeline-settings.d.ts

@@ -9,39 +9,21 @@
  *   2. Camera opts in or out of specific addonIds via a boolean overlay
  *      (`stepToggles`). Absent = inherit agent. Present = force.
  *
- *   3. Escape hatch: camera can pin a full pipeline wholesale for a
- *      specific agent via `pipelineByAgent[agentNodeId]`. When set, it
- *      bypasses addonDefaults + stepToggles entirely.
+ *   3. A model is chosen by the accelerator that runs it (D927): a camera
+ *      turns steps on or off and may carry camera-semantic step settings,
+ *      never a model, a model-bound threshold or a tree of its own.
  *
  * The resolver walks this chain and emits the existing
  * `CameraPipelineConfig` shape that the runner consumes — no changes
  * required downstream of the orchestrator.
  */
-import type { CameraPipelineConfig } from './camera-pipeline.js';
 import type { NodeColorId } from '../node-color.js';
-/**
- * LEGACY per-addon configuration (the removed per-node model layer,
- * `agent.addonDefaults[addonId]`). Retained ONLY for the one-shot boot
- * migration that strips `addonDefaults`, and for UI/library code pending
- * the per-(node,device) rework. New code carries model/settings per
- * `(node,device)` via {@link DeviceStepConfig}.
- *
- * modelId present ONLY when the operator explicitly chose a model;
- * absent = use this node's format default (resolved on-the-fly by the
- * provider).
- */
-export interface AgentAddonConfig {
-    readonly enabled: boolean;
-    readonly modelId?: string;
-    readonly settings: Readonly<Record<string, unknown>>;
-}
 /**
  * Per-(node,device) BASE provisioning for one step: the model + intrinsic
  * settings the executing node applies for EVERY camera landing on that
  * accelerator. Both fields optional — absent = the executor resolves its own
- * format default at runtime. This is the same shape carried by the
- * per-camera-device OVERRIDE ({@link CameraStepOverridePatch}); the dispatch
- * provisioning stage merges override on top of base (`override ?? base`).
+ * format default at runtime. The ONE authority over which model a step runs
+ * on an accelerator (D927) — no camera layer overrides it.
  */
 export interface DeviceStepConfig {
     readonly modelId?: string;
@@ -55,17 +37,6 @@ export interface DeviceStepConfig {
      */
     readonly jumpDeviceKey?: string;
 }
-/**
- * Per-(camera,node,device,step) override patch over the per-(node,device)
- * base ({@link DeviceStepConfig}). Both fields optional — unset means
- * "inherit from the device base". Enablement is NOT carried here: which
- * steps run is the per-camera `stepToggles` authority. When `settings` is
- * present it merges over the base `settings` (override keys win).
- */
-export interface CameraStepOverridePatch {
-    readonly modelId?: string;
-    readonly settings?: Readonly<Record<string, unknown>>;
-}
 /**
  * Per-agent pipeline settings. Phase 2f: engine + hwaccel + audio
  * ownership moved to per-addon global settings (detection-pipeline,
@@ -128,6 +99,15 @@ export interface AgentPipelineSettings {
      * `assignNodeColorId(nodeId)` when missing.
      */
     readonly color?: NodeColorId;
+    /**
+     * NODE-wide step settings (D927): `[stepId] → { fieldKey → value }`, the
+     * content that holds on every accelerator of this node (an allow-list of
+     * species, an IoU). Never a model or a model-bound threshold — those belong
+     * to the accelerator (`inferenceDevices[key].steps[step]`). Merged under
+     * the device's own settings at dispatch; a sibling device entry is never
+     * read.
+     */
+    readonly stepSettings?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
     /**
      * Multi-device inference opt-in (Phase 4 multi-device). Maps a device key
      * (`openvino:npu`, `openvino:gpu`, `edgetpu:usb`, `edgetpu:usb:1`, `cpu`, …
@@ -142,8 +122,8 @@ export interface AgentPipelineSettings {
      *
      * `steps` (per-(node,device) BASE provisioning) — an optional
      * `stepId → {modelId?, settings?}` map: the default model + intrinsic
-     * settings for EVERY camera landing on that accelerator, overridable
-     * per-camera via `cameraSettings.stepOverridesByDevice`. A stepId ABSENT ⇒
+     * settings for EVERY camera landing on that accelerator (no camera layer
+     * overrides the model, D927). A stepId ABSENT ⇒
      * that step uses the device format default. A pinned modelId MUST have a
      * build for the device's FORMAT, else the executor's `resolveInputSteps`
      * substitutes it back to the format default (the UI only offers
@@ -166,40 +146,27 @@ export interface AgentPipelineSettings {
 export interface CameraPipelineSettings {
     readonly stepToggles?: Readonly<Record<string, boolean>>;
     /**
-     * Camera-wide step SETTINGS (D754): `[addonId] → { fieldKey → value }`, the
-     * fields this camera overrides on EVERY accelerator it is balanced onto. A
-     * sparse, field-level bag — a key present here is an override, an absent key
-     * inherits the node. Merge order at dispatch, per key:
-     * node (folded base) ⊕ this ⊕ `stepOverridesByDevice[node][deviceKey]`.
-     * A model-bound field (D738) is always written with its binding key.
-     * Settings only: a model is a per-accelerator question (formats differ), so
-     * it stays in `stepOverridesByDevice`.
+     * Camera-wide step SETTINGS (D754, narrowed by D927): `[addonId] → { fieldKey
+     * → value }`, the CAMERA-SEMANTIC fields this camera overrides on every
+     * accelerator it is balanced onto (an allow-list of classes, a zone-driven
+     * option). A sparse, field-level bag — a key present here is an override, an
+     * absent key inherits the node. Merge order at dispatch, per key:
+     * node ⊕ this. Never a model and never a model-bound threshold
+     * ({@link isModelScopedStepSettingKey}): those belong to the accelerator that
+     * runs the model — the writer refuses them and dispatch ignores a stored one.
      */
     readonly stepSettings?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
-    /**
-     * Per-(camera,node,device) model/settings override. Addressed by
-     * `[agentNodeId][deviceKey][addonId]` because the camera is balanced onto
-     * one `(node,deviceKey)` per session and a node's accelerators share no
-     * format. Overrides the per-(node,device) base
-     * (`inferenceDevices[node][deviceKey].steps`) for one camera on one
-     * accelerator; the wholesale `pipelineByAgent[agent]` escape hatch, when
-     * present, still bypasses this. Enablement is orthogonal (`stepToggles`).
-     */
-    readonly stepOverridesByDevice?: Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, CameraStepOverridePatch>>>>>>;
-    /**
-     * Per-agent wholesale pipeline override. Engine is NOT stored here —
-     * the override runs under the engine selected on that agent via the
-     * detection-pipeline addon's global settings. Operator picks steps
-     * + audio model/enabled only. This keeps the override portable
-     * across agent-moves and prevents a camera from being pinned to an
-     * engine the agent doesn't host. `modelId` absent = data-only model
-     * selection — the executing node resolves its own format default.
-     */
-    readonly pipelineByAgent?: Readonly<Record<string, {
-        readonly steps: CameraPipelineConfig['steps'];
-        readonly audio: {
-            readonly modelId?: string;
-            readonly enabled: boolean;
-        } | null;
-    }>>;
 }
+/**
+ * Is `key` a step setting that only the accelerator running the model may
+ * carry (D927)? A model id, a model binding (`<key>ModelId`, D738) or a
+ * confidence floor (`minConfidence*` — every `bindsToModel` field). A camera
+ * layer never stores one: the floor of one model is wrong on the next, and a
+ * camera does not know which accelerator — or which model — it lands on.
+ * (Per-camera thresholds are a possible future extension, see D927.)
+ */
+export declare function isModelScopedStepSettingKey(key: string): boolean;
+/** The keys of `bag` a camera layer may not carry ({@link isModelScopedStepSettingKey}), sorted. */
+export declare function modelScopedStepSettingKeys(bag: Readonly<Record<string, unknown>>): string[];
+/** `bag` without its model-scoped keys — what a camera layer contributes at dispatch. Fresh object. */
+export declare function cameraScopedStepSettings(bag: Readonly<Record<string, unknown>>): Record<string, unknown>;

package/dist/types/camera-pipeline.d.ts

@@ -37,8 +37,8 @@ export interface CameraPipelineConfig {
         /**
          * Present ONLY when the operator explicitly chose an audio model;
          * absent = use this node's format default (resolved on-the-fly by
-         * the provider). Mirrors `AgentAddonConfig.modelId` (Task 4/5 of the
-         * engine-node-local refactor — model selection is data only).
+         * the provider). Model selection is data only (the engine-node-local
+         * refactor).
          */
         readonly modelId?: string;
         readonly enabled: boolean;

package/dist/types/detection.d.ts

@@ -545,13 +545,23 @@ export interface FrameResult {
      * track keeps it so a later replay can name the original model (D646).
      */
     readonly rootModelId?: string;
+    /**
+     * The step (addon id) of the root {@link rootModelId} names — the detector
+     * whose boxes this frame's tracks are born from. Stamped beside it, same
+     * absence rule. With {@link rootModelId} and {@link rootDeviceKey} it is the
+     * session's detector, which the birth confirmation gate re-judges a birth
+     * with (D925).
+     */
+    readonly rootStepId?: string;
     /**
      * The inference DEVICE the root ran on (`openvino:npu`, `edgetpu:pci`,
-     * `onnx:webgpu` …) — the pool the dispatch actually used, stamped beside
-     * {@link rootModelId}. A session can hop node or device between on-motion
-     * sessions (D916), so a stored track keeps the device of the frame that
-     * opened it and of the sighting that closed it. Absent on a frame no
-     * pipeline root produced, and from a runner older than the field.
+     * `onnx:webgpu` …) — the pool the dispatch actually used, after re-election
+     * and the capability fallback, stamped beside {@link rootModelId}. A session
+     * can hop node or device between on-motion sessions (D916), so a stored
+     * track keeps the device of the frame that opened it and of the sighting
+     * that closed it (D924); the confirmation gate re-judges a birth on this
+     * pool (D925). Absent on a frame no pipeline root produced, and from a
+     * runner older than the field.
      */
     readonly rootDeviceKey?: string;
     /**

package/dist/types/pipeline-step.d.ts

@@ -111,22 +111,6 @@ export interface StepDefinition {
      * rather than out).
      */
     readonly enabledByDefault?: boolean;
-    /**
-     * Opt-in: when `true`, this step is BACK-FILLED into a camera's stored
-     * wholesale pipeline override (`cameraSettings.pipelineByAgent`) at resolve
-     * time if it is absent from that snapshot — see
-     * `mergeEnabledByDefaultSteps`. Set this ONLY on a genuinely-NEW default
-     * step that shipped AFTER existing snapshots were captured and must reach
-     * them (e.g. `clip-embedding` for object semantic search).
-     *
-     * It exists because absence-from-a-snapshot is ambiguous: it can mean
-     * "predates this step" OR "operator deliberately pruned it". A broad
-     * "back-fill every default" would resurrect deliberate removals of
-     * long-existing steps (face-detection, etc.). This flag makes back-fill
-     * strictly opt-in so only a new step re-enters existing overrides; absent
-     * (the default) preserves operator intent verbatim. Absent = `false`.
-     */
-    readonly backfillIntoExistingOverrides?: boolean;
     /** Default confidence threshold */
     readonly defaultConfidence: number;
     /** Runtime label lookup (e.g., class name arrays for softmax, charset for CTC) */

package/package.json

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