@camstack/types 1.2.387 → 1.2.389

package/dist/inference/coral-units.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Coral Edge TPU units — the ONE place a probed {@link CoralInfo} becomes
+ * addressable units, and a unit's device-key suffix becomes the device string
+ * the libedgetpu delegate is opened with. Pure: no I/O.
+ *
+ * Key suffix (what `edgetpu:<suffix>` carries, and what the pool's `device`
+ * holds until the delegate opens):  `usb`, `usb:1`, …, `pci`, `pci:1`, …
+ * The first unit of a bus keeps the bare bus name, so a node's first USB Coral
+ * keeps the `edgetpu:usb` key every stored setting already uses.
+ *
+ * Delegate device string (libedgetpu's `device` option): ALWAYS an explicit
+ * ordinal, `usb:0` / `usb:1` / `pci:0` / `pci:1`. A bare or omitted device
+ * means "the first Edge TPU of any bus" to libedgetpu, which on a node with
+ * both buses would let two pools open the same unit.
+ */
+import type { CoralBus, CoralInfo } from '../interfaces/platform.js';
+/** One usable Coral unit: its bus, its ordinal on that bus, its key suffix. */
+export interface CoralUnitAddress {
+    readonly bus: CoralBus;
+    readonly index: number;
+    /** The device-key suffix: `usb`, `usb:1`, `pci`, `pci:1`, … */
+    readonly device: string;
+}
+/** Every usable Coral unit on a node, USB first then PCIe, in ordinal order. */
+export declare function coralUsableUnits(coral: CoralInfo | null | undefined): readonly CoralUnitAddress[];
+/**
+ * Map an edgetpu key suffix (`usb`, `usb:1`, `pci`, `pci:1`) to the explicit
+ * libedgetpu device string (`usb:0`, `usb:1`, `pci:0`, `pci:1`). Throws on any
+ * other string — a pool must never open "whichever Edge TPU comes first".
+ */
+export declare function edgetpuDelegateDevice(device: string): string;

package/dist/inference/runtime-capabilities.d.ts

@@ -54,7 +54,7 @@ interface ScoreRuntimesResult {
  * - coreml:   score 95, darwin+arm64
  * - cuda:     score 85, nvidia gpu
  * - openvino: score 90 if intel-npu present, else 80 if intel gpu
- * - edgetpu:  score 70, coral usb present
+ * - edgetpu:  score 70, a usable Coral unit (USB or PCIe)
  * - cpu:      score 50 (universal floor, always included)
  *
  * All hardware-matched entries are `available: true`.

package/dist/interfaces/addon.d.ts

@@ -3,6 +3,7 @@ import type { CapabilityDefinition, InferProvider } from '../capabilities/capabi
 import type { CustomActionCaller, CustomActionsSpec } from '../capabilities/custom-actions.js';
 import type { PipelineSlot } from '../types/pipeline.js';
 import type { AddonDataPlane } from './addon-data-plane.js';
+import type { CoralInfo } from './platform.js';
 import type { AddonPeerBytes } from './addon-peer-bytes.js';
 import type { SecretsAccess } from '../keychain/secrets-access.js';
 import type { RecordsAccess } from '../records/records-access.js';
@@ -383,10 +384,8 @@ export interface KernelInferenceHardware {
     readonly npu: {
         readonly type: string;
     } | null;
-    /** Coral USB Edge TPU, when present (gates the `edgetpu` runtime). */
-    readonly coral?: {
-        readonly type: string;
-    } | null;
+    /** Coral Edge TPU hardware (USB and/or PCIe), when found — whole, units included. */
+    readonly coral?: CoralInfo | null;
 }
 export interface IKernelInferenceEngine {
     /**

package/dist/interfaces/logging.d.ts

@@ -1,3 +1,4 @@
+import type { LogReadCapabilities, LogReadQuery, LogReadResult } from '../capabilities/log-destination.cap.js';
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 /**
  * Severity ordering. Declared once here because it had already been re-declared
@@ -75,6 +76,13 @@ export interface LogTags {
     readonly [key: string]: string | number | undefined;
 }
 export interface LogEntry {
+    /**
+     * `<bootId>.<seq>`, minted by the LogManager that FIRST accepted the line
+     * on this process (D898). Identical in the in-memory tail, the live
+     * subscription and the rotated file, so a page read from disk and a line
+     * pushed live dedupe exactly. Absent only on an entry built by hand.
+     */
+    id?: string;
     timestamp: Date;
     level: LogLevel;
     /** Single free-form label (e.g. 'EventPersistence', 'rtsp', 'AddonRegistry').
@@ -98,7 +106,14 @@ export interface ILogDestination {
     initialize(): Promise<void>;
     shutdown(): Promise<void>;
     write(entry: LogEntry): void;
-    query?(filter: LogFilter): Promise<readonly LogEntry[]>;
+    /** Absent ⇒ this destination only ships lines (D898). */
+    describeRead?(): Promise<LogReadCapabilities>;
+    read?(query: LogReadQuery): Promise<LogReadResult>;
+    cancelRead?(input: {
+        readonly requestId: string;
+    }): Promise<{
+        readonly cancelled: boolean;
+    }>;
 }
 /**
  * Inline, per-call extras passed to every `IScopedLogger` method.

package/dist/interfaces/platform.d.ts

@@ -10,9 +10,10 @@ export interface HardwareInfo {
     readonly gpu: GpuInfo | null;
     readonly npu: NpuInfo | null;
     /**
-     * Coral USB Edge TPU, when present. Optional so existing HardwareInfo
-     * construction sites and older cross-node probe reports stay valid; absent /
-     * null ⇒ no Coral ⇒ the `edgetpu` runtime is withheld.
+     * Coral Edge TPU hardware (USB and/or PCIe), when found. Optional so existing
+     * HardwareInfo construction sites and older cross-node probe reports stay
+     * valid; absent / null ⇒ no Coral. Non-null with no usable unit (driver
+     * missing, device not accessible) ⇒ the `edgetpu` runtime is withheld too.
      */
     readonly coral?: CoralInfo | null;
 }
@@ -31,24 +32,61 @@ export interface NpuInfo {
      */
     readonly generation?: 'xdna1' | 'xdna2';
 }
+/** The bus a Coral Edge TPU sits on — libedgetpu's own device-family names. */
+export type CoralBus = 'usb' | 'pci';
+/** Usable Coral units on one bus: enumerated, and their device node opens. */
+export interface CoralBusUnits {
+    readonly bus: CoralBus;
+    readonly count: number;
+}
+/**
+ * Why a Coral that IS physically present cannot run (D393/D315: present but
+ * unusable is never reported as absent).
+ *  - `driver-missing`: the PCI function (`1ac1:089a`) is enumerated but no
+ *    `/sys/class/apex/apex_N` exists — the gasket/apex kernel driver is not
+ *    loaded on the host.
+ *  - `device-not-accessible`: the driver is loaded but `/dev/apex_N` is absent
+ *    from this process's view (not passed into the container) or cannot be
+ *    opened read/write (permissions).
+ */
+export type CoralUnavailableReason = 'driver-missing' | 'device-not-accessible';
+/** Present-but-unusable Coral units on one bus, with the typed reason. */
+export interface CoralUnavailableUnits {
+    readonly bus: CoralBus;
+    readonly count: number;
+    readonly reason: CoralUnavailableReason;
+}
 /**
- * Coral USB Edge TPU (Google Coral). A discrete USB inference accelerator that
- * coexists with the host GPU/NPU (e.g. the Unraid hub carries both an Intel NPU
- * and a Coral). Tracked separately from {@link NpuInfo} so its presence gates
- * the `edgetpu` inference runtime without colliding with the Intel-NPU signal.
+ * Coral Edge TPU (Google Coral), USB and/or PCIe/M.2. A discrete inference
+ * accelerator that coexists with the host GPU/NPU (e.g. the Unraid hub carries
+ * both an Intel NPU and a USB Coral). Tracked separately from {@link NpuInfo} so
+ * its presence gates the `edgetpu` inference runtime without colliding with the
+ * Intel-NPU signal.
+ *
+ * Non-null ⇒ Coral hardware was FOUND — usable or not. Only `units` (read
+ * through `coralUsableUnits`) gates the runtime and the device keys; a unit in
+ * `unavailable` is reported, never enumerated.
  */
 export interface CoralInfo {
     readonly type: 'coral-edgetpu';
-    /** Bus location hint (e.g. `usb`), informational. */
+    /**
+     * @deprecated Legacy single-bus report (older nodes). Read only through
+     * `coralUsableUnits`, which falls back to it when `units` is absent.
+     */
     readonly bus?: string;
     /**
-     * Number of physically attached Coral Edge TPUs. Multiple Corals coexist on
-     * one host and run CONCURRENTLY, one inference pool each — the enumerator emits
-     * one device descriptor per unit (`edgetpu:usb`, `edgetpu:usb:1`, …). Omitted /
-     * undefined ⇒ treat as a single Coral (the probe couldn't count them, e.g. a
-     * container with a limited `/sys` USB view — the delegate-presence fallback).
+     * @deprecated Legacy USB unit count (older nodes); undefined ⇒ one Coral.
+     * Read only through `coralUsableUnits`.
      */
     readonly count?: number;
+    /**
+     * Usable units per bus. Each unit is its own concurrent pool — the enumerator
+     * emits one device descriptor per unit (`edgetpu:usb`, `edgetpu:usb:1`,
+     * `edgetpu:pci`, `edgetpu:pci:1`, …). Absent ⇒ a legacy report (see `bus`).
+     */
+    readonly units?: readonly CoralBusUnits[];
+    /** Units that are present but cannot run, each with its typed reason. */
+    readonly unavailable?: readonly CoralUnavailableUnits[];
 }
 /** A probed backend with availability and score */
 export interface PlatformScore {

package/dist/notification/media-image.d.ts

@@ -0,0 +1,67 @@
+/**
+ * media-image — the ONE media choice of a notification rule (D897).
+ *
+ * A rule used to state its picture as three fields — `attach` (which stored
+ * kind to look for), `frame` (cropped / full / boxed) and `zoneCrop` — and the
+ * ladders those fed picked a STORED kind, so one rule shipped a subject crop on
+ * one event and a boxed scene on the next depending on what had landed. The
+ * picture is now rendered at send time from a clean frame, and the rule says
+ * only what it wants to SEE: `image` (`scene-boxes` | `crop` | `clean` |
+ * `none`) plus `showTriggerZone`.
+ *
+ * This module is the only reader of the legacy triple. The rule store applies
+ * {@link normalizeNcMediaPolicy} on load (a READ projection, like the retired
+ * delivery fields of D692) and on every write, so a stored rule converges on
+ * `image` the first time it is saved, and an editor that still sends the
+ * triple (the viewer, until it follows) is folded on the way in.
+ */
+import type { NcConditions, NcMediaImage, NcMediaPolicy } from '../capabilities/notification-rules.cap.js';
+import { type NcRuleKind, type NcRuleSectionSubject } from './rule-kinds.js';
+/** Every mode, in the order an editor offers them. */
+export declare const NC_MEDIA_IMAGE_MODES: readonly NcMediaImage[];
+/**
+ * The modes a rule of this kind can honour. A kind that carries no media gets
+ * none (its row ships text, or — an alarm — its SOURCE rule's picture); a kind
+ * whose subject has no region of the frame (a sound) is never offered `crop`.
+ */
+export declare function imageModesForKind(kind: NcRuleKind): readonly NcMediaImage[];
+/**
+ * The zone ids that FIRE a rule: its `zones` condition, or an occupancy rule's
+ * own scoped zone. Empty when the trigger is not a zone — and then
+ * `showTriggerZone` has nothing to draw and is refused on save.
+ */
+export declare function ruleTriggerZoneIds(conditions: NcConditions): readonly string[];
+/**
+ * What the legacy triple MEANT, as a mode. `zoneCrop` forced the clean
+ * keyFrame ladder and dropped `frame`, so it is `clean` whatever else was set;
+ * `frame` decided over `attach` when present; `keyFrame` was the clean scene;
+ * every other still (`best`, `best-matching`, the default) was the subject.
+ */
+export declare function legacyImageMode(media: NcMediaPolicy): NcMediaImage;
+/**
+ * The mode a rule's picture is rendered in. `image` when stored; else what the
+ * legacy triple meant — and, for a SENSOR rule written before D897, `clean`
+ * whatever it stored (even `attach: 'none'`), because its stored triple was
+ * ignored and one plain snapshot always shipped (operator ruling, 2026-10-01):
+ * the migration keeps what the rule actually DID. Clamped to what the kind can
+ * honour.
+ */
+export declare function resolveNcMediaImage(media: NcMediaPolicy, kind: NcRuleKind): NcMediaImage;
+/** The rule fields the normalisation reads. */
+export interface NcMediaRuleSubject extends NcRuleSectionSubject {
+    readonly conditions: NcConditions;
+}
+/**
+ * The stored shape of a media policy: `image` set, the legacy triple gone.
+ * `showTriggerZone` survives only where it can be drawn — a zone trigger and a
+ * mode other than `crop`/`none`; a legacy `zoneCrop` on a zone rule becomes it.
+ * Every other field (gif, clip, rolls, speed, profile, linked cameras) is
+ * carried through untouched. Pure; never throws.
+ */
+export declare function normalizeNcMediaPolicy(media: NcMediaPolicy, rule: NcMediaRuleSubject): NcMediaPolicy;
+/**
+ * Why a media policy cannot be SAVED on this rule, or null. Server-side and
+ * editor alike: `showTriggerZone` on a rule whose trigger is not a zone, and a
+ * mode the rule's kind cannot honour.
+ */
+export declare function ncMediaPolicyError(media: NcMediaPolicy, rule: NcMediaRuleSubject): string | null;

package/dist/{sleep-yKL5gfrH.mjs → sleep-BSuCCFjf.mjs}

@@ -5402,7 +5402,9 @@ var HISTORY_UNIT_LABELS = {
 	ms: "ms",
 	s: "s",
 	days: "days",
-	bytes: "bytes"
+	bytes: "bytes",
+	kbps: "kbps",
+	fps: "fps"
 };
 /** Capture floor (ms) applied to `gauge` / `counter` series when a field states none. */
 var HISTORY_DEFAULT_MIN_INTERVAL_MS = 1e4;

package/dist/{sleep-6sOPE0EV.js → sleep-DKtoyk6X.js}

@@ -5402,7 +5402,9 @@ var HISTORY_UNIT_LABELS = {
 	ms: "ms",
 	s: "s",
 	days: "days",
-	bytes: "bytes"
+	bytes: "bytes",
+	kbps: "kbps",
+	fps: "fps"
 };
 /** Capture floor (ms) applied to `gauge` / `counter` series when a field states none. */
 var HISTORY_DEFAULT_MIN_INTERVAL_MS = 1e4;

package/package.json

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