@camstack/types 1.2.258 → 1.2.260

package/dist/interfaces/event-bus.d.ts

@@ -1260,7 +1260,7 @@ export interface EventCatalog {
             readonly engine: PipelineEngineChoice;
             readonly modelsLoaded: readonly string[];
             readonly inUseByCameras: readonly number[];
-            readonly kind: 'runtime' | 'warm-override' | 'device-pool';
+            readonly kind: 'runtime' | 'device-pool';
             readonly poolPid: number | null;
             readonly idleMs: number | null;
             readonly idleTtlMs: number | null;

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

@@ -33,14 +33,12 @@ export interface PipelineStepInput {
  *  - `imageBase64`: one-shot benchmark (ImageTab "Run")
  *  - `referenceImage`: named file from the reference-image store
  *
- * `engine` + `deviceId` are optional contextual hints — the executor uses
- * `deviceId` for per-device overrides and traces, and `engine` to select
- * the factory (when absent, falls back to the executor's persisted
- * selection during the migration window).
+ * `deviceId` is an optional contextual hint — the executor uses it for
+ * per-device overrides and traces. There is no `engine` (D646): the pool is
+ * the node's own engine, or the `deviceKey` pool when one is named.
  */
 export interface PipelineRunInput {
     readonly steps: readonly PipelineStepInput[];
-    readonly engine?: PipelineEngineChoice;
     readonly frame?: FrameInput;
     /** Same-process lazy source; never forwarded over UDS/Moleculer. */
     readonly frameRef?: FrameRef;
@@ -93,6 +91,16 @@ export interface PipelineRunInput {
      * mutually-exclusive image inputs. Absent ⇒ tile-crop children.
      */
     readonly nativeCropRef?: NativeCropRef;
+    /**
+     * Offline REPLAY of stored media for `deviceId` (D56, D646). The call runs
+     * the camera's structure — its detection-stage zone gate and per-device
+     * overrides, exactly as a live frame — over a recorded image, and it is
+     * PINNED: every executing step runs the model it names on the `deviceKey`
+     * pool it names, or the call refuses (`model-not-servable` /
+     * `device-not-servable`) before any pool is touched. Nothing is emitted on
+     * the camera's live trace stream. Absent ⇒ unchanged behaviour.
+     */
+    readonly replay?: true;
 }
 /**
  * Singleton capability provided by the pipeline-executor addon.
@@ -121,6 +129,8 @@ export interface IPipelineExecutorProvider {
      */
     validatePipeline(input: {
         readonly steps: readonly PipelineStepInput[];
+        /** Validate against this device pool's format; absent ⇒ the node default. */
+        readonly deviceKey?: string;
     }): Promise<PipelineValidationResult>;
     /** Get the currently selected engine (bootstrap default on the node). */
     getSelectedEngine(): Promise<PipelineEngineChoice>;
@@ -172,7 +182,6 @@ export interface IPipelineExecutorProvider {
      */
     runPipelineBatch(input: {
         readonly steps: readonly PipelineStepInput[];
-        readonly engine?: PipelineEngineChoice;
         readonly frames: readonly FrameInput[];
         readonly deviceId?: number;
         readonly sessionId?: string;

package/dist/interfaces/platform.d.ts

@@ -47,7 +47,7 @@ export interface CoralInfo {
 }
 /** A probed backend with availability and score */
 export interface PlatformScore {
-    readonly runtime: 'node' | 'python';
+    readonly runtime: 'python';
     readonly backend: string;
     readonly format: 'onnx' | 'coreml' | 'openvino' | 'tflite';
     readonly score: number;
@@ -77,7 +77,7 @@ export interface ModelRequirement {
 /** Resolved config — the tripletta chosen by the scorer for an addon */
 export interface ResolvedInferenceConfig {
     readonly modelId: string;
-    readonly runtime: 'node' | 'python';
+    readonly runtime: 'python';
     readonly backend: string;
     readonly format: import('../types/models.js').ModelFormat;
     readonly reason: string;

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

@@ -18,11 +18,11 @@ export declare const DecoderSessionConfigSchema: z.ZodObject<{
     codec: z.ZodString;
     maxFps: z.ZodDefault<z.ZodNumber>;
     outputFormat: z.ZodDefault<z.ZodEnum<{
-        rgb: "rgb";
-        gray: "gray";
         jpeg: "jpeg";
+        rgb: "rgb";
         bgr: "bgr";
         yuv420: "yuv420";
+        gray: "gray";
     }>>;
     scale: z.ZodDefault<z.ZodNumber>;
     width: z.ZodOptional<z.ZodNumber>;

package/dist/notification/system-event-summary.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The STATE SUMMARY delivery of a system-event rule (D647): which rules may use
+ * it, and how an editor presents its schedule. One module, read by the hub's
+ * save guard, the notification centre's scheduler and both rule editors.
+ *
+ * A `device-events` or `system` rule may say `systemEventDelivery: { mode:
+ * 'summary', schedule }`: it then sends nothing per event, and at the END of
+ * each window of `schedule` it sends the current state of its kinds. The alarm
+ * stays instant (an alarm summarised at 08:00 is an alarm nobody heard), and a
+ * `mixed` rule is read-only (D637), so neither may carry it.
+ *
+ * Pure: no clock, no I/O.
+ */
+import type { NcDelivery, NcRuleActions, NcSchedule, NcSystemEventCondition, NcSystemEventDelivery } from '../capabilities/notification-rules.cap.js';
+import { type NcSystemEventFamily } from './system-event-families.js';
+/** The families a rule may summarise. The alarm is not one of them. */
+export declare const NC_SYSTEM_EVENT_SUMMARY_FAMILIES: readonly NcSystemEventFamily[];
+/** The part of a rule the summary delivery is judged on. */
+export interface NcSystemEventDeliverySubject {
+    readonly delivery: NcDelivery;
+    readonly conditions: {
+        readonly systemEvent?: NcSystemEventCondition;
+    };
+    readonly systemEventDelivery?: NcSystemEventDelivery;
+    readonly schedule?: NcSchedule;
+    readonly actions?: NcRuleActions;
+}
+export type NcSystemEventDeliveryProblem = {
+    readonly code: 'not-a-system-rule';
+    readonly delivery: NcDelivery;
+} | {
+    readonly code: 'family-not-summarisable';
+    readonly family: NcSystemEventFamily | 'mixed';
+} | {
+    readonly code: 'empty-schedule';
+} | {
+    readonly code: 'degenerate-window';
+    readonly index: number;
+} | {
+    readonly code: 'schedule-beside-summary';
+} | {
+    readonly code: 'actions-beside-summary';
+};
+/** The summary's schedule, or `null` for any rule that is not a summary system rule. */
+export declare function systemEventSummaryScheduleOf(rule: Pick<NcSystemEventDeliverySubject, 'delivery' | 'systemEventDelivery'>): NcSchedule | null;
+/** Absent and `instant` are the same answer: a notification per event. */
+export declare function isSystemEventSummaryRule(rule: Pick<NcSystemEventDeliverySubject, 'delivery' | 'systemEventDelivery'>): boolean;
+/**
+ * Why the hub refuses this rule's delivery. Empty = accepted. An instant rule
+ * (absent or `{ mode: 'instant' }`) is never refused here.
+ *
+ * Beside a summary, two fields are refused because they would do nothing:
+ * the rule's own `schedule` (the summary's schedule is the send time; a second
+ * active-hours gate would silently empty it) and `actions` (a summary is not a
+ * match, so nothing would ever run them).
+ */
+export declare function systemEventDeliveryProblems(rule: NcSystemEventDeliverySubject): readonly NcSystemEventDeliveryProblem[];
+export declare function describeSystemEventDeliveryProblem(problem: NcSystemEventDeliveryProblem): string;
+/** One send time as an editor presents it: the days it is sent on, and the minute. */
+export interface NcSummarySendTime {
+    readonly days: readonly number[];
+    /** Minute of the day, 0–1439. */
+    readonly minute: number;
+}
+/**
+ * A send time is a ONE-MINUTE window that closes at that minute: the summary is
+ * sent when a window ends. Midnight starts the window at 23:59 of the day
+ * BEFORE, because a window's `days` are the days it STARTS on.
+ */
+export declare function scheduleForSendTimes(times: readonly NcSummarySendTime[], timezone?: string): NcSchedule;
+/**
+ * The send times a schedule stands for, or `null` when it is not a list of
+ * one-minute windows (an inverted or a longer window): the editor then shows
+ * the raw windows and says the summary is sent when each one ENDS.
+ */
+export declare function sendTimesOfSchedule(schedule: NcSchedule): readonly NcSummarySendTime[] | null;
+/**
+ * Does a custom BODY carry the summary's content (`{{summaryText}}` or a
+ * section variable)? A body that does not would send a summary with nothing
+ * in it; the hub then appends `{{summaryText}}` and the admin warns (review
+ * M3). An absent or blank body uses the hub's own wording, which does.
+ */
+export declare function templateCarriesSummary(body: string | undefined): boolean;

package/dist/notification/template-vars.d.ts

@@ -36,6 +36,21 @@ export declare const NC_TEMPLATE_HELD_BACK_SYSTEM_EVENT_KINDS: readonly NcSystem
  * rule an installed viewer can author, which is exactly true.
  */
 export declare function servedTemplateVars(): NcTemplateVarDescriptor[];
+/**
+ * Is this descriptor held back from the SERVED catalog as a whole (D647)?
+ * A summary-only variable is: an installed viewer does not read the delivery
+ * axis, and would offer it on every instant system rule. The admin, built
+ * from the workspace, restores it from its own `NC_TEMPLATE_VARS`.
+ */
+export declare function isHeldBackTemplateVar(d: NcTemplateVarDescriptor): boolean;
+/**
+ * Does a descriptor have a value on a system rule of this DELIVERY (D647)?
+ * Read only for a system rule kind. An absent axis is `instant` for a
+ * descriptor that names `systemEventKinds` (a per-event fact: a summary row
+ * has no one device, node or package) and BOTH for one that does not
+ * (`{{rule}}`, `{{time}}`).
+ */
+export declare function templateVarDeliveryApplies(d: NcTemplateVarDescriptor, ctx: NcTemplateVarContext): boolean;
 /**
  * Does a descriptor declared for `declared` kinds have a value for a rule of
  * `kind`?

package/dist/{sleep-DtomDrRW.js → sleep-BDYxE1ax.js}

@@ -3748,6 +3748,7 @@ function createDeviceProxy(api, binding, opts) {
 			listDeviceMutes: (input) => dispatch("notification-rules", "notificationRules", "listDeviceMutes", "query", input),
 			setDeviceMuted: (input) => dispatch("notification-rules", "notificationRules", "setDeviceMuted", "mutation", input),
 			testRule: (input) => dispatch("notification-rules", "notificationRules", "testRule", "mutation", input),
+			previewStateSummary: (input) => dispatch("notification-rules", "notificationRules", "previewStateSummary", "mutation", input),
 			getConditionCatalog: (input) => dispatch("notification-rules", "notificationRules", "getConditionCatalog", "query", input),
 			getTemplateCatalog: (input) => dispatch("notification-rules", "notificationRules", "getTemplateCatalog", "query", input),
 			previewTemplate: (input) => dispatch("notification-rules", "notificationRules", "previewTemplate", "mutation", input),
@@ -3837,7 +3838,6 @@ function createDeviceProxy(api, binding, opts) {
 			deselectRetrainFrame: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "deselectRetrainFrame", "mutation", input),
 			getRetrainFrameImage: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getRetrainFrameImage", "query", input),
 			proposeRetrainAnnotations: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "proposeRetrainAnnotations", "mutation", input),
-			runReplayFrameProcessor: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "runReplayFrameProcessor", "mutation", input),
 			listRetrainAnnotations: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listRetrainAnnotations", "query", input),
 			saveRetrainAnnotations: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "saveRetrainAnnotations", "mutation", input),
 			completeRetrainTrack: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "completeRetrainTrack", "mutation", input),

package/dist/{sleep-DU7mu4wb.mjs → sleep-BaRu0bS5.mjs}

@@ -3748,6 +3748,7 @@ function createDeviceProxy(api, binding, opts) {
 			listDeviceMutes: (input) => dispatch("notification-rules", "notificationRules", "listDeviceMutes", "query", input),
 			setDeviceMuted: (input) => dispatch("notification-rules", "notificationRules", "setDeviceMuted", "mutation", input),
 			testRule: (input) => dispatch("notification-rules", "notificationRules", "testRule", "mutation", input),
+			previewStateSummary: (input) => dispatch("notification-rules", "notificationRules", "previewStateSummary", "mutation", input),
 			getConditionCatalog: (input) => dispatch("notification-rules", "notificationRules", "getConditionCatalog", "query", input),
 			getTemplateCatalog: (input) => dispatch("notification-rules", "notificationRules", "getTemplateCatalog", "query", input),
 			previewTemplate: (input) => dispatch("notification-rules", "notificationRules", "previewTemplate", "mutation", input),
@@ -3837,7 +3838,6 @@ function createDeviceProxy(api, binding, opts) {
 			deselectRetrainFrame: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "deselectRetrainFrame", "mutation", input),
 			getRetrainFrameImage: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getRetrainFrameImage", "query", input),
 			proposeRetrainAnnotations: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "proposeRetrainAnnotations", "mutation", input),
-			runReplayFrameProcessor: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "runReplayFrameProcessor", "mutation", input),
 			listRetrainAnnotations: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listRetrainAnnotations", "query", input),
 			saveRetrainAnnotations: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "saveRetrainAnnotations", "mutation", input),
 			completeRetrainTrack: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "completeRetrainTrack", "mutation", input),

package/dist/types/detection.d.ts

@@ -412,6 +412,15 @@ export interface ObjectDetection extends DetectionBase {
      * Present iff the face path cut its aligned crop from a native surface.
      */
     readonly nativeFaceShortSidePx?: number;
+    /**
+     * The five facial landmarks the face detector regressed for THIS `face`
+     * detail, in the same absolute pixel space as `bbox` (D644). Only a face
+     * detail carries them; never inherited onto the parent.
+     */
+    readonly landmarks?: readonly {
+        readonly x: number;
+        readonly y: number;
+    }[];
 }
 /** Audio detection — flat, time-localised within the window. */
 export interface AudioDetection extends DetectionBase {
@@ -505,6 +514,15 @@ export interface FrameResult {
     readonly shed?: true;
     /** Which bound shed the frame (e.g. `'worker-in-flight-cap'`). Present iff `shed` is. */
     readonly shedReason?: string;
+    /**
+     * The model the ROOT detector ACTUALLY ran for this frame — after the
+     * executor's format resolution, so a substituted model is named as what
+     * ran, not as what was asked (`object-detection` when it runs, else the
+     * first enabled root). Stamped by `pipelineExecutor.runPipeline`; absent on
+     * a frame no pipeline root produced (a camera's onboard detector). A stored
+     * track keeps it so a later replay can name the original model (D646).
+     */
+    readonly rootModelId?: string;
     readonly debug?: FrameDebug;
 }
 /**

package/dist/types/models.d.ts

@@ -22,7 +22,6 @@ export declare const ModelFormatEntrySchema: z.ZodObject<{
     isDirectory: z.ZodOptional<z.ZodBoolean>;
     files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
     runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-        node: "node";
         python: "python";
     }>>>>;
 }, z.core.$strip>;
@@ -50,7 +49,6 @@ export declare const ModelFormatsSchema: z.ZodObject<{
         isDirectory: z.ZodOptional<z.ZodBoolean>;
         files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
         runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-            node: "node";
             python: "python";
         }>>>>;
     }, z.core.$strip>>;
@@ -60,7 +58,6 @@ export declare const ModelFormatsSchema: z.ZodObject<{
         isDirectory: z.ZodOptional<z.ZodBoolean>;
         files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
         runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-            node: "node";
             python: "python";
         }>>>>;
     }, z.core.$strip>>;
@@ -70,7 +67,6 @@ export declare const ModelFormatsSchema: z.ZodObject<{
         isDirectory: z.ZodOptional<z.ZodBoolean>;
         files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
         runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-            node: "node";
             python: "python";
         }>>>>;
     }, z.core.$strip>>;
@@ -80,7 +76,6 @@ export declare const ModelFormatsSchema: z.ZodObject<{
         isDirectory: z.ZodOptional<z.ZodBoolean>;
         files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
         runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-            node: "node";
             python: "python";
         }>>>>;
     }, z.core.$strip>>;
@@ -90,7 +85,6 @@ export declare const ModelFormatsSchema: z.ZodObject<{
         isDirectory: z.ZodOptional<z.ZodBoolean>;
         files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
         runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-            node: "node";
             python: "python";
         }>>>>;
     }, z.core.$strip>>;
@@ -100,7 +94,6 @@ export declare const ModelFormatsSchema: z.ZodObject<{
         isDirectory: z.ZodOptional<z.ZodBoolean>;
         files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
         runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-            node: "node";
             python: "python";
         }>>>>;
     }, z.core.$strip>>;
@@ -164,7 +157,6 @@ export declare const ModelCatalogEntrySchema: z.ZodObject<{
             isDirectory: z.ZodOptional<z.ZodBoolean>;
             files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
             runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-                node: "node";
                 python: "python";
             }>>>>;
         }, z.core.$strip>>;
@@ -174,7 +166,6 @@ export declare const ModelCatalogEntrySchema: z.ZodObject<{
             isDirectory: z.ZodOptional<z.ZodBoolean>;
             files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
             runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-                node: "node";
                 python: "python";
             }>>>>;
         }, z.core.$strip>>;
@@ -184,7 +175,6 @@ export declare const ModelCatalogEntrySchema: z.ZodObject<{
             isDirectory: z.ZodOptional<z.ZodBoolean>;
             files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
             runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-                node: "node";
                 python: "python";
             }>>>>;
         }, z.core.$strip>>;
@@ -194,7 +184,6 @@ export declare const ModelCatalogEntrySchema: z.ZodObject<{
             isDirectory: z.ZodOptional<z.ZodBoolean>;
             files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
             runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-                node: "node";
                 python: "python";
             }>>>>;
         }, z.core.$strip>>;
@@ -204,7 +193,6 @@ export declare const ModelCatalogEntrySchema: z.ZodObject<{
             isDirectory: z.ZodOptional<z.ZodBoolean>;
             files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
             runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-                node: "node";
                 python: "python";
             }>>>>;
         }, z.core.$strip>>;
@@ -214,7 +202,6 @@ export declare const ModelCatalogEntrySchema: z.ZodObject<{
             isDirectory: z.ZodOptional<z.ZodBoolean>;
             files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
             runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-                node: "node";
                 python: "python";
             }>>>>;
         }, z.core.$strip>>;
@@ -411,7 +398,6 @@ export declare const ConvertResultSchema: z.ZodObject<{
                 isDirectory: z.ZodOptional<z.ZodBoolean>;
                 files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
                 runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-                    node: "node";
                     python: "python";
                 }>>>>;
             }, z.core.$strip>>;
@@ -421,7 +407,6 @@ export declare const ConvertResultSchema: z.ZodObject<{
                 isDirectory: z.ZodOptional<z.ZodBoolean>;
                 files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
                 runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-                    node: "node";
                     python: "python";
                 }>>>>;
             }, z.core.$strip>>;
@@ -431,7 +416,6 @@ export declare const ConvertResultSchema: z.ZodObject<{
                 isDirectory: z.ZodOptional<z.ZodBoolean>;
                 files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
                 runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-                    node: "node";
                     python: "python";
                 }>>>>;
             }, z.core.$strip>>;
@@ -441,7 +425,6 @@ export declare const ConvertResultSchema: z.ZodObject<{
                 isDirectory: z.ZodOptional<z.ZodBoolean>;
                 files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
                 runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-                    node: "node";
                     python: "python";
                 }>>>>;
             }, z.core.$strip>>;
@@ -451,7 +434,6 @@ export declare const ConvertResultSchema: z.ZodObject<{
                 isDirectory: z.ZodOptional<z.ZodBoolean>;
                 files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
                 runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-                    node: "node";
                     python: "python";
                 }>>>>;
             }, z.core.$strip>>;
@@ -461,7 +443,6 @@ export declare const ConvertResultSchema: z.ZodObject<{
                 isDirectory: z.ZodOptional<z.ZodBoolean>;
                 files: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
                 runtimes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-                    node: "node";
                     python: "python";
                 }>>>>;
             }, z.core.$strip>>;

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

@@ -13,7 +13,7 @@ export interface IPipelineStep {
     readonly definition: StepDefinition;
     getConfigSchema(): readonly ConfigField[];
 }
-export type PostprocessorType = 'yolo' | 'ssd' | 'rfdetr' | 'yolonas' | 'yolo-seg' | 'scrfd' | 'arcface' | 'clip' | 'softmax' | 'ctc' | 'plate-slots' | 'saliency' | 'yamnet';
+export type PostprocessorType = 'yolo' | 'ssd' | 'rfdetr' | 'yolonas' | 'yolo-seg' | 'scrfd' | 'yunet' | 'arcface' | 'clip' | 'softmax' | 'ctc' | 'plate-slots' | 'saliency' | 'yamnet';
 export interface StepDefinition {
     /** Unique step identifier (e.g., 'object-detection', 'face-detection') */
     readonly id: string;
@@ -350,9 +350,17 @@ export type TraceVerbosity = 'off' | 'summary' | 'full';
  * and served per-track via a separate detail-subtree call instead.
  */
 export type PipelineExecutionPlane = 'full' | 'frame';
+/**
+ * Why a frame is being run. `'replay'` is a session replay (D646): the camera's
+ * own tree over STORED pixels. Its log lines say so, and its drop sampling is
+ * kept apart from the live camera's — a replay must never use up the live
+ * first-example budget or read as a live line. Absent = `'live'`.
+ */
+export type PipelineRunOccasion = 'live' | 'replay';
 export interface PipelineRunOptions {
     readonly traceVerbosity?: TraceVerbosity;
     readonly plane?: PipelineExecutionPlane;
+    readonly occasion?: PipelineRunOccasion;
 }
 export interface StepTrace {
     readonly stepId: string;

package/dist/types/pipeline.d.ts

@@ -6,7 +6,8 @@ export type PipelineSlot = 'detector' | 'cropper' | 'classifier' | 'refiner' | '
  * User picks this; all pipeline steps run within it.
  */
 export interface PipelineEngineChoice {
-    readonly runtime: 'node' | 'python';
+    /** Every model runs in a Python pool; the `'node'` runtime is gone. */
+    readonly runtime: 'python';
     readonly backend: string;
     readonly format: ModelFormat;
     /** Target hardware device within the backend (e.g., 'cpu', 'gpu', 'npu', 'ane', 'auto', 'all') */

package/dist/utils/background-run-registry.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Start-then-poll for work that outlives one request.
+ *
+ * An addon's custom action rides the UDS addon-call plane, whose request
+ * timeout is 60 s (`DEFAULT_UDS_REQUEST_TIMEOUT_MS`) and which a custom action
+ * cannot raise. A run longer than that used to be ABANDONED by its caller
+ * while it kept running — the capacity ramp moved to fire-and-poll for exactly
+ * that reason, and every other long benchmark run had to follow (D646). This is
+ * the one shape they share: `start` validates nothing about the work itself, it
+ * registers it, answers at once with a `running` receipt, and the caller polls
+ * `status` for progress and, eventually, the result or the named failure.
+ *
+ * In RAM on purpose. A run belongs to the process that runs it; a restart ends
+ * it, and a finished run's result is the caller's to persist if it matters.
+ * The registry keeps a BOUNDED number of finished runs so a page reopened after
+ * the run ended can still read it, and it never drops a run that is still
+ * going.
+ */
+/** Where a run is. `aborted` keeps whatever result the work returned after the signal. */
+export type BackgroundRunState = 'running' | 'done' | 'failed' | 'aborted';
+export interface BackgroundRunStatus<TProgress, TResult> {
+    readonly runId: string;
+    readonly state: BackgroundRunState;
+    readonly startedAtMs: number;
+    /** `null` while running. */
+    readonly finishedAtMs: number | null;
+    /** The last progress the work reported; `null` until it reports any. */
+    readonly progress: TProgress | null;
+    /** Present once the work resolved (`done`, or `aborted` with what it had). */
+    readonly result: TResult | null;
+    /** The failure, verbatim — present iff `state === 'failed'`. */
+    readonly error: string | null;
+}
+/** What the work receives: how to be told to stop, and how to say how far it got. */
+export interface BackgroundRunContext<TProgress> {
+    readonly signal: AbortSignal;
+    report(progress: TProgress): void;
+}
+export interface BackgroundRunRegistryOptions<TProgress, TResult> {
+    /** Runs allowed at once. A start beyond it is REFUSED, never queued. */
+    readonly maxConcurrent: number;
+    /** Finished runs remembered for a late poll. */
+    readonly keepFinished: number;
+    readonly now?: () => number;
+    /** Called once per run when it leaves `running` — the caller's hook to log or persist. */
+    readonly onSettled?: (status: BackgroundRunStatus<TProgress, TResult>) => void;
+}
+export declare class BackgroundRunRegistry<TProgress, TResult> {
+    private readonly opts;
+    private readonly runs;
+    private readonly now;
+    constructor(opts: BackgroundRunRegistryOptions<TProgress, TResult>);
+    /** Runs still going. */
+    get runningCount(): number;
+    /**
+     * Register and start `work`. Returns the `running` receipt immediately.
+     * Throws only for a refusal the caller must see (duplicate id, busy) — a
+     * failure of the work itself lands in `status`, never here.
+     */
+    start(runId: string, work: (ctx: BackgroundRunContext<TProgress>) => Promise<TResult>): BackgroundRunStatus<TProgress, TResult>;
+    status(runId: string): BackgroundRunStatus<TProgress, TResult> | null;
+    /** Running runs first (newest start first), then finished ones (newest finish first). */
+    list(): readonly BackgroundRunStatus<TProgress, TResult>[];
+    /** Signal a running run to stop. `false` for an unknown or already finished run. */
+    abort(runId: string): boolean;
+    /** Abort every running run (shutdown). */
+    abortAll(): void;
+    private prune;
+}

package/dist/utils/runtime-mapping.d.ts

@@ -2,7 +2,7 @@
  * Canonical runtime/backend/format mapping utilities.
  *
  * This is the SINGLE SOURCE OF TRUTH for mapping between:
- * - Pipeline config (runtime: 'node'|'python', backend: 'cpu'|'coreml'|'cuda'|...)
+ * - Pipeline config (runtime: 'python', backend: 'cpu'|'coreml'|'openvino'|...)
  * - DetectionRuntime ('onnx'|'coreml'|'pytorch'|'openvino'|'tflite')
  * - ModelFormat ('onnx'|'coreml'|'openvino'|'tflite'|'pt')
  *
@@ -10,22 +10,17 @@
  */
 import type { ModelFormat } from '../types/models.js';
 import type { DetectionRuntime } from '../types/config.js';
-/** Pipeline-level runtime: 'node' (ONNX Runtime in Node.js) or 'python' (Python inference) */
-export type PipelineRuntime = 'node' | 'python';
 /**
- * Map a backend ID to the model format it requires.
- *
- * Node.js backends (cpu, coreml, cuda, tensorrt) all use ONNX format
- * because onnxruntime-node loads .onnx and uses execution providers internally.
- *
- * Python backends use their native format.
+ * Pipeline-level runtime. Only `'python'`: every model runs in a Python pool.
+ * The `'node'` runtime (onnxruntime-node in the addon process) is gone, and
+ * with it the node-backend → format map that turned `coreml` into `.onnx`.
  */
-declare const BACKEND_TO_FORMAT: Readonly<Record<string, ModelFormat>>;
+export type PipelineRuntime = 'python';
 /**
  * DEVICE-POOL backend → model format — the SSOT for the multi-device inference
- * DESCRIPTOR path (Python per-device pools), distinct from {@link BACKEND_TO_FORMAT}
- * above which is the legacy NODE runtime map (where `coreml → onnx` because
- * onnxruntime-node's CoreML EP loads `.onnx`). Here a device pool runs the
+ * DESCRIPTOR path (Python per-device pools),  distinct from the former BACKEND_TO_FORMAT,
+ * which was the removed NODE runtime map (where `coreml → onnx` because
+ * onnxruntime-node's CoreML EP loaded `.onnx`). A device pool runs the
  * backend NATIVELY, so `coreml → coreml` and `edgetpu → tflite`. Consumed by
  * `resolveDeviceEngine` (addon-pipeline) and the orchestrator's
  * `parseDeviceKey`/`getNodeInferenceDevices` — the previously-duplicated
@@ -46,46 +41,6 @@ declare const RUNTIME_TO_FORMAT: Readonly<Record<DetectionRuntime, ModelFormat>>
  * Map a Python backend to the Python inference script name.
  */
 declare const PYTHON_SCRIPT: Readonly<Record<string, string>>;
-/**
- * Resolve pipeline config (runtime + backend) to a DetectionRuntime.
- *
- * Pipeline config uses two levels:
- *   runtime: 'node' | 'python'
- *   backend: 'cpu' | 'coreml' | 'cuda' | 'openvino' | 'pytorch' | ...
- *
- * Addons expect a DetectionRuntime:
- *   'onnx' | 'coreml' | 'pytorch' | 'openvino' | 'tflite'
- *
- * Mapping rules:
- *   node + any backend   → 'onnx' (onnxruntime-node handles backend via EP)
- *   python + coreml      → 'coreml' (native .mlpackage via coremltools)
- *   python + openvino    → 'openvino'
- *   python + pytorch     → 'pytorch'
- *   python + onnx-py     → 'onnx'
- *   python + <other>     → backend as-is
- */
-export declare function resolveDetectionRuntime(pipelineRuntime: PipelineRuntime | string, backend: string): DetectionRuntime;
-/**
- * Resolve pipeline config (runtime + backend) to a ModelFormat.
- *
- * Determines which model file format is needed (.onnx, .mlpackage, etc.)
- */
-export declare function resolveModelFormat(pipelineRuntime: PipelineRuntime | string, backend: string): ModelFormat;
-/**
- * Resolve pipeline runtime string to 'auto' | DetectionRuntime for addon consumption.
- * Used when building addon addonConfig from pipeline step config.
- *
- *   'python' + 'coreml'   → 'coreml'
- *   'node'   + 'coreml'   → 'onnx'
- *   'node'   + 'cpu'      → 'onnx'
- *   'auto'                → 'auto'
- */
-export declare function resolveAddonRuntime(pipelineRuntime: string | undefined, backend: string | undefined): DetectionRuntime | 'auto';
-/**
- * Get the model format needed for a given backend.
- * Convenience wrapper for backend-only lookup (e.g., UI components).
- */
-export declare function formatForBackend(backend: string): ModelFormat;
 /**
  * Get the model format for a given DetectionRuntime.
  */
@@ -100,4 +55,4 @@ export declare function pythonScriptForBackend(backend: string): string | undefi
  * 'coreml', 'pytorch', 'openvino' need Python; 'onnx' and 'tflite' don't.
  */
 export declare function requiresPython(runtime: DetectionRuntime | string): boolean;
-export { BACKEND_TO_FORMAT, DEVICE_BACKEND_TO_FORMAT, deviceBackendToFormat, RUNTIME_TO_FORMAT, PYTHON_SCRIPT, };
+export { DEVICE_BACKEND_TO_FORMAT, deviceBackendToFormat, RUNTIME_TO_FORMAT, PYTHON_SCRIPT };

package/package.json

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