@camstack/types 1.2.171 → 1.2.172

package/dist/addon.js

@@ -149,6 +149,8 @@ var CAP_INPUT_DEFAULTS = Object.freeze({
 			"pipelineEnabled": true,
 			"zones": [],
 			"onboardMotionDrivesAnalyzer": true,
+			"preRollInferenceEnabled": true,
+			"preRollInferenceFrames": 12,
 			"occupancyRecheckEnabled": true,
 			"occupancyRecheckSec": 300,
 			"occupancyRecheckFrames": 4,

package/dist/addon.mjs

@@ -148,6 +148,8 @@ var CAP_INPUT_DEFAULTS = Object.freeze({
 			"pipelineEnabled": true,
 			"zones": [],
 			"onboardMotionDrivesAnalyzer": true,
+			"preRollInferenceEnabled": true,
+			"preRollInferenceFrames": 12,
 			"occupancyRecheckEnabled": true,
 			"occupancyRecheckSec": 300,
 			"occupancyRecheckFrames": 4,

package/dist/capabilities/pipeline-runner.cap.d.ts

@@ -256,6 +256,8 @@ declare const RunnerCameraConfigSchema: z.ZodObject<{
         color: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>>>>;
     onboardMotionDrivesAnalyzer: z.ZodDefault<z.ZodBoolean>;
+    preRollInferenceEnabled: z.ZodDefault<z.ZodBoolean>;
+    preRollInferenceFrames: z.ZodDefault<z.ZodNumber>;
     occupancyRecheckEnabled: z.ZodDefault<z.ZodBoolean>;
     occupancyRecheckSec: z.ZodDefault<z.ZodNumber>;
     occupancyRecheckFrames: z.ZodDefault<z.ZodNumber>;
@@ -516,6 +518,8 @@ export declare const pipelineRunnerCapability: {
                 color: z.ZodDefault<z.ZodString>;
             }, z.core.$strip>>>>;
             onboardMotionDrivesAnalyzer: z.ZodDefault<z.ZodBoolean>;
+            preRollInferenceEnabled: z.ZodDefault<z.ZodBoolean>;
+            preRollInferenceFrames: z.ZodDefault<z.ZodNumber>;
             occupancyRecheckEnabled: z.ZodDefault<z.ZodBoolean>;
             occupancyRecheckSec: z.ZodDefault<z.ZodNumber>;
             occupancyRecheckFrames: z.ZodDefault<z.ZodNumber>;

package/dist/index.js

@@ -21324,6 +21324,22 @@ var occupancyRecheckFramesField = {
 	step: 1
 };
 /**
+* Frames one PRE-ROLL catch-up burst may send to inference at session open.
+*
+* The default of 12 over a ~4 s retained window is one frame per ~333 ms of
+* footage, and costs ~480 ms of ONE inference permit at the 40 ms/frame this
+* fleet measures — one-shot, and only ever taken while a permit would still be
+* spare for live. `0` turns the burst off entirely (the history is still
+* decoded, because that is how the dial reaches a decodable GOP, and is then
+* discarded — the pre-D411 behaviour).
+*/
+var preRollInferenceFramesField = {
+	min: 0,
+	max: 30,
+	default: 12,
+	step: 1
+};
+/**
 * Source enum for motion signals fed to the runner. Extensible — add
 * new variants here when new motion-trigger paths are wired in
 * (`wasm-cross-camera`, `event-bus-relay`, etc.). The runner uses
@@ -21564,6 +21580,31 @@ var RunnerCameraConfigSchema = zod.z.object({
 	* to every occupancy rule until something moved in front of it. The churn is
 	* now paid on the interval instead — see `occupancyRecheckSecField`.
 	*/
+	/**
+	* Infer the session's PRE-ROLL — the retained history the restreamer replays
+	* at session open — instead of decoding it and throwing it away.
+	*
+	* DEFAULT `true`, and the default is the argument. This is not a new
+	* capability being offered cautiously: the pre-roll is ALREADY requested,
+	* already served, already decoded and already paid for on every on-motion
+	* detection session that asks for history. What shipped was a last-moment
+	* discard — `FrameSlot`'s throttle compares wall clocks, and ~4 s of media
+	* arriving inside a few hundred ms of wall clock looks to it like one frame's
+	* worth. Device 617, 2026-09-08: a re-run of the SAME model over the stored
+	* recording scored the subject `vehicle 0.5669` — above the 0.50 floor —
+	* 1.68 s BEFORE the live track was born, on a frame that was in the pre-roll,
+	* was decoded, and was freed.
+	*
+	* Shipping that as opt-in would ship the bug: an operator cannot discover a
+	* setting whose absence looks exactly like a camera that noticed the cyclist
+	* late. What makes ON safe is not a switch but the BOUND —
+	* `preRollInferenceFrames`, a wall-clock ceiling, and a lane that never takes
+	* the last inference permit — so the switch exists for the camera where the
+	* history is worthless (a doorbell whose subject is always already at the
+	* door), not as a hedge against the feature.
+	*/
+	preRollInferenceEnabled: zod.z.boolean().default(true),
+	preRollInferenceFrames: zod.z.number().min(preRollInferenceFramesField.min).max(preRollInferenceFramesField.max).default(preRollInferenceFramesField.default),
 	occupancyRecheckEnabled: zod.z.boolean().default(true),
 	occupancyRecheckSec: zod.z.number().min(occupancyRecheckSecField.min).max(occupancyRecheckSecField.max).default(occupancyRecheckSecField.default),
 	occupancyRecheckFrames: zod.z.number().min(occupancyRecheckFramesField.min).max(occupancyRecheckFramesField.max).default(occupancyRecheckFramesField.default),
@@ -21718,6 +21759,29 @@ var RunnerCameraDeviceUIFields = [
 			includes: "onboard"
 		}
 	},
+	{
+		key: "preRollInferenceEnabled",
+		type: "boolean",
+		style: "checkbox",
+		label: "Detect in the pre-roll",
+		description: "Run detection over the few seconds of footage the camera had already buffered when motion fired, so a subject that was in view before the trigger is found at the moment it appeared rather than seconds later. The burst is bounded and never delays live detection.",
+		default: true
+	},
+	{
+		key: "preRollInferenceFrames",
+		type: "slider",
+		label: "Pre-roll frames",
+		description: "How many frames of buffered history may be detected on, per session. Higher samples the history more densely; 0 disables the pass.",
+		min: preRollInferenceFramesField.min,
+		max: preRollInferenceFramesField.max,
+		step: preRollInferenceFramesField.step,
+		default: preRollInferenceFramesField.default,
+		showValue: true,
+		showWhen: {
+			field: "preRollInferenceEnabled",
+			equals: true
+		}
+	},
 	{
 		key: "occupancyRecheckEnabled",
 		type: "boolean",

package/dist/index.mjs

@@ -21323,6 +21323,22 @@ var occupancyRecheckFramesField = {
 	step: 1
 };
 /**
+* Frames one PRE-ROLL catch-up burst may send to inference at session open.
+*
+* The default of 12 over a ~4 s retained window is one frame per ~333 ms of
+* footage, and costs ~480 ms of ONE inference permit at the 40 ms/frame this
+* fleet measures — one-shot, and only ever taken while a permit would still be
+* spare for live. `0` turns the burst off entirely (the history is still
+* decoded, because that is how the dial reaches a decodable GOP, and is then
+* discarded — the pre-D411 behaviour).
+*/
+var preRollInferenceFramesField = {
+	min: 0,
+	max: 30,
+	default: 12,
+	step: 1
+};
+/**
 * Source enum for motion signals fed to the runner. Extensible — add
 * new variants here when new motion-trigger paths are wired in
 * (`wasm-cross-camera`, `event-bus-relay`, etc.). The runner uses
@@ -21563,6 +21579,31 @@ var RunnerCameraConfigSchema = z.object({
 	* to every occupancy rule until something moved in front of it. The churn is
 	* now paid on the interval instead — see `occupancyRecheckSecField`.
 	*/
+	/**
+	* Infer the session's PRE-ROLL — the retained history the restreamer replays
+	* at session open — instead of decoding it and throwing it away.
+	*
+	* DEFAULT `true`, and the default is the argument. This is not a new
+	* capability being offered cautiously: the pre-roll is ALREADY requested,
+	* already served, already decoded and already paid for on every on-motion
+	* detection session that asks for history. What shipped was a last-moment
+	* discard — `FrameSlot`'s throttle compares wall clocks, and ~4 s of media
+	* arriving inside a few hundred ms of wall clock looks to it like one frame's
+	* worth. Device 617, 2026-09-08: a re-run of the SAME model over the stored
+	* recording scored the subject `vehicle 0.5669` — above the 0.50 floor —
+	* 1.68 s BEFORE the live track was born, on a frame that was in the pre-roll,
+	* was decoded, and was freed.
+	*
+	* Shipping that as opt-in would ship the bug: an operator cannot discover a
+	* setting whose absence looks exactly like a camera that noticed the cyclist
+	* late. What makes ON safe is not a switch but the BOUND —
+	* `preRollInferenceFrames`, a wall-clock ceiling, and a lane that never takes
+	* the last inference permit — so the switch exists for the camera where the
+	* history is worthless (a doorbell whose subject is always already at the
+	* door), not as a hedge against the feature.
+	*/
+	preRollInferenceEnabled: z.boolean().default(true),
+	preRollInferenceFrames: z.number().min(preRollInferenceFramesField.min).max(preRollInferenceFramesField.max).default(preRollInferenceFramesField.default),
 	occupancyRecheckEnabled: z.boolean().default(true),
 	occupancyRecheckSec: z.number().min(occupancyRecheckSecField.min).max(occupancyRecheckSecField.max).default(occupancyRecheckSecField.default),
 	occupancyRecheckFrames: z.number().min(occupancyRecheckFramesField.min).max(occupancyRecheckFramesField.max).default(occupancyRecheckFramesField.default),
@@ -21717,6 +21758,29 @@ var RunnerCameraDeviceUIFields = [
 			includes: "onboard"
 		}
 	},
+	{
+		key: "preRollInferenceEnabled",
+		type: "boolean",
+		style: "checkbox",
+		label: "Detect in the pre-roll",
+		description: "Run detection over the few seconds of footage the camera had already buffered when motion fired, so a subject that was in view before the trigger is found at the moment it appeared rather than seconds later. The burst is bounded and never delays live detection.",
+		default: true
+	},
+	{
+		key: "preRollInferenceFrames",
+		type: "slider",
+		label: "Pre-roll frames",
+		description: "How many frames of buffered history may be detected on, per session. Higher samples the history more densely; 0 disables the pass.",
+		min: preRollInferenceFramesField.min,
+		max: preRollInferenceFramesField.max,
+		step: preRollInferenceFramesField.step,
+		default: preRollInferenceFramesField.default,
+		showValue: true,
+		showWhen: {
+			field: "preRollInferenceEnabled",
+			equals: true
+		}
+	},
 	{
 		key: "occupancyRecheckEnabled",
 		type: "boolean",

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

@@ -83,6 +83,15 @@ export interface RunnerCameraConfig {
      * to disable the dynamic analyzer for this camera.
      */
     readonly onboardMotionDrivesAnalyzer: boolean;
+    /**
+     * Infer the session's PRE-ROLL — the retained history the restreamer replays
+     * at session open — instead of decoding it and discarding it. Mirrors
+     * `RunnerCameraConfigSchema.preRollInferenceEnabled` (default true; see the
+     * schema for why the default is the argument).
+     */
+    readonly preRollInferenceEnabled: boolean;
+    /** Frames one pre-roll catch-up burst may send to inference. `0` disables it. */
+    readonly preRollInferenceFrames: number;
     /** Master toggle — when false the occupancy recheck never arms (default). */
     readonly occupancyRecheckEnabled: boolean;
     /** Seconds between occupancy re-check bursts in watching phase. */

package/dist/interfaces/stream-broker.d.ts

@@ -149,6 +149,18 @@ export interface DecodedFrame {
     readonly capturedAt?: number;
     /** Process-local lazy source. Present with an empty `data` buffer on the co-located path. */
     readonly frameRef?: FrameRef;
+    /**
+     * True when this frame came out of a session's PRE-ROLL catch-up burst —
+     * retained history replayed at session open rather than live footage.
+     *
+     * It exists so a consumer can ROUTE the frame, not merely label it: history
+     * belongs in the runner's bounded pre-roll lane (FIFO, drained strictly
+     * behind live), never in the latest-only live detection queue, which would
+     * collapse a whole burst to its newest frame. A frame carrying this ALWAYS
+     * carries a `capturedAt` measured on the session media clock, not a fresh
+     * wall clock.
+     */
+    readonly preRoll?: boolean;
 }
 export interface DecodedAudioChunk {
     readonly data: Buffer;
@@ -446,4 +458,12 @@ export interface CameraDetectionConfig {
     readonly occupancyRecheckEnabled: boolean;
     readonly occupancyRecheckSec: number;
     readonly occupancyRecheckFrames: number;
+    /**
+     * Whether the session's already-decoded PRE-ROLL is inferred rather than
+     * dropped as stale, and how many of its frames the catch-up burst may spend
+     * (D411). Carried here because the orchestrator resolves it per camera and
+     * the runner is the one that spends it.
+     */
+    readonly preRollInferenceEnabled: boolean;
+    readonly preRollInferenceFrames: number;
 }

package/package.json

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