@camstack/types 1.2.259 → 1.2.261

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.259",
+  "version": "1.2.261",
   "description": "Shared types, interfaces, and model catalogs for the CamStack detection ecosystem",
   "keywords": [
     "camstack",