@camstack/types 1.2.43 → 1.2.45

package/dist/types/detection.d.ts

@@ -70,6 +70,24 @@ export interface ScoredLabel {
      * that carries it.
      */
     readonly detectionId?: string;
+    /**
+     * WHICH label slot this text may occupy on a track / ObjectEvent, copied
+     * VERBATIM from the producing step's `StepDefinition.labelTier` (roadmap
+     * 4g). 1 = sub-class (`dog`), 2 = instance (`Turdus migratorius`, `Alice`,
+     * a plate read).
+     *
+     * Absent means the producing step declares no tier — an internal marker
+     * (`embedding:512d`), or a step that was never given a declaration. The
+     * persistence write rule REFUSES an undeclared label rather than inferring
+     * a tier from the text or the step name, and says so in the log. Inheriting
+     * a label onto a parent copies the tier unchanged: the tier belongs to the
+     * step that decided the text, not to the entry that carries it.
+     */
+    readonly tier?: 1 | 2;
+    /** Step that decided this text — the tier's attribution. */
+    readonly stepId?: string;
+    /** Model that decided this text — the tier's attribution. */
+    readonly modelId?: string;
 }
 /** What kind of entry a detection is at the root of `detections[]`. */
 export type DetectionKind = 'first-level' | 'detail' | 'audio';
@@ -110,6 +128,19 @@ export interface DetectionDebug {
      * mapped to `macroClass: 'animal'`).
      */
     readonly originalClass?: string;
+    /**
+     * The label tier {@link originalClass} may occupy, from the ROOT detector
+     * step's `StepDefinition.labelTier` (roadmap 4g). Ships in the same
+     * `verbosity: 'full'` bag as the value it qualifies, so it costs nothing
+     * where `originalClass` costs nothing.
+     *
+     * Without it the raw class is a label with no declared tier and the write
+     * rule refuses it — which is the correct outcome, because outside
+     * `verbosity: 'full'` the FrameProcessor substitutes `det.macroClass` for a
+     * missing `originalClass` and a tier guessed here would put a MACRO class in
+     * a label slot. That is the exact regression the 2026-08-07 rule refuses.
+     */
+    readonly originalClassTier?: 1 | 2;
     /**
      * Full top-N ranked alternatives per source (classifier / recognizer).
      * The winner of each list already appears in `detection.labels[]` —

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

@@ -12,7 +12,7 @@ export interface IPipelineStep {
     readonly definition: StepDefinition;
     getConfigSchema(): readonly ConfigField[];
 }
-export type PostprocessorType = 'yolo' | 'ssd' | 'yolo-seg' | 'scrfd' | 'arcface' | 'clip' | 'softmax' | 'ctc' | 'saliency' | 'yamnet';
+export type PostprocessorType = 'yolo' | 'ssd' | 'rfdetr' | 'yolo-seg' | 'scrfd' | 'arcface' | 'clip' | 'softmax' | 'ctc' | 'saliency' | 'yamnet';
 export interface StepDefinition {
     /** Unique step identifier (e.g., 'object-detection', 'face-detection') */
     readonly id: string;
@@ -42,6 +42,27 @@ export interface StepDefinition {
     readonly inputClasses: readonly string[] | null;
     /** Classes this step outputs (e.g., ['person','vehicle','animal'] for YOLO) */
     readonly outputClasses: readonly string[];
+    /**
+     * WHICH label tier this step's answer occupies on a track / ObjectEvent
+     * (roadmap 4g). **Declared here and nowhere else** — a consumer never infers
+     * a tier from `outputClasses`, from the step id, or from the shape of the
+     * text. A step that produces a label and declares no tier has its answer
+     * REFUSED and logged, because a guess here is exactly how a species ends up
+     * in the coarse slot and blocks the sub-class that should have gone there.
+     *
+     *  - `1` — a SUB-CLASS, finer than the macro class but still a taxonomy
+     *    token: `animal-classifier` (`animal-type`), `vehicle-classifier`
+     *    (`vehicle-type`), and `object-detection` itself (its raw class, when
+     *    finer than the macro it maps to — `dog` under `animal`).
+     *  - `2` — an INSTANCE, the finest thing sayable about this subject:
+     *    `bird-classifier` (`species`), `face-embedding` (`identity`),
+     *    `plate-ocr` (`plate-text`).
+     *
+     * Absent on a step that produces no label at all (a detector whose classes
+     * ARE macro classes, an embedder, a segmenter). Absence is not tier 0 — it
+     * means "this step never fills a label slot".
+     */
+    readonly labelTier?: 1 | 2;
     /** Available models for this step */
     readonly models: readonly ModelCatalogEntry[];
     /** Default model when no user preference is set */

package/package.json

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

package/dist/canonical-hash-7nfBbEqR.mjs

@@ -1,35 +0,0 @@
-import { createHash } from "node:crypto";
-//#region src/utils/canonical-hash.ts
-/**
-* Deterministic SHA-256 hash of an arbitrary serialisable value. The
-* canonical form sorts object keys alphabetically at every depth so two
-* structurally-equal inputs with different key insertion orders produce
-* the same hash. Returns a 64-char lowercase hex digest.
-*
-* Used by export adapters (Alexa, HAP) to short-circuit re-discovery /
-* accessory-rebuild work when the upstream shape is byte-identical to
-* the last applied state — preventing user-visible "re-discovery"
-* notifications on every addon-runner respawn. Each respawn re-fires
-* `DeviceBindingsChanged` for every cap registration, which without
-* this guard would propagate redundant pushes.
-*
-* Note: this is a SYMPTOMATIC fix layered on top of the binding-change
-* subscription. The proper fix is a single "device ready" lifecycle
-* barrier so exports react only when the full cap set has landed —
-* tracked separately for post-HA-integration work.
-*/
-function canonicalHash(value) {
-	const canonical = JSON.stringify(value, replaceWithSortedKeys);
-	return createHash("sha256").update(canonical ?? "").digest("hex");
-}
-function replaceWithSortedKeys(_key, value) {
-	if (value && typeof value === "object" && !Array.isArray(value)) {
-		const obj = value;
-		const out = {};
-		for (const k of Object.keys(obj).toSorted()) out[k] = obj[k];
-		return out;
-	}
-	return value;
-}
-//#endregion
-export { canonicalHash as t };

package/dist/canonical-hash-BcZHRHIx.js

@@ -1,40 +0,0 @@
-let node_crypto = require("node:crypto");
-//#region src/utils/canonical-hash.ts
-/**
-* Deterministic SHA-256 hash of an arbitrary serialisable value. The
-* canonical form sorts object keys alphabetically at every depth so two
-* structurally-equal inputs with different key insertion orders produce
-* the same hash. Returns a 64-char lowercase hex digest.
-*
-* Used by export adapters (Alexa, HAP) to short-circuit re-discovery /
-* accessory-rebuild work when the upstream shape is byte-identical to
-* the last applied state — preventing user-visible "re-discovery"
-* notifications on every addon-runner respawn. Each respawn re-fires
-* `DeviceBindingsChanged` for every cap registration, which without
-* this guard would propagate redundant pushes.
-*
-* Note: this is a SYMPTOMATIC fix layered on top of the binding-change
-* subscription. The proper fix is a single "device ready" lifecycle
-* barrier so exports react only when the full cap set has landed —
-* tracked separately for post-HA-integration work.
-*/
-function canonicalHash(value) {
-	const canonical = JSON.stringify(value, replaceWithSortedKeys);
-	return (0, node_crypto.createHash)("sha256").update(canonical ?? "").digest("hex");
-}
-function replaceWithSortedKeys(_key, value) {
-	if (value && typeof value === "object" && !Array.isArray(value)) {
-		const obj = value;
-		const out = {};
-		for (const k of Object.keys(obj).toSorted()) out[k] = obj[k];
-		return out;
-	}
-	return value;
-}
-//#endregion
-Object.defineProperty(exports, "canonicalHash", {
-	enumerable: true,
-	get: function() {
-		return canonicalHash;
-	}
-});