@camstack/types 1.2.234 → 1.2.236

package/dist/addon.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-DImve4HM.js");
+const require_sleep = require("./sleep-Cqxm5OIN.js");
 const require_event_category = require("./event-category-BVfsrBYA.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
 //#region src/generated/cap-input-defaults.ts

package/dist/addon.mjs

@@ -1,4 +1,4 @@
-import { A as DeviceType, At as emitReadiness, Ct as DATAPLANE_SECRET_HEADER, Dt as normalizeAddonInitResult, Et as BaseAddon, G as ReadinessRegistry, H as nodePin, I as expandCapMethods, K as ReadinessTimeoutError, S as DEVICE_CHILDREN_BATCH_MAX, T as describeCustomActions, Tt as DisposerChain, U as readNodePin, Y as scopeKey, a as asJsonObject, b as deviceOpsCapability, d as BOOT_RECOVERY_BACKOFF_MS, f as DEVICE_SCOPED_CAPS, h as createEventBusSliceSource, j as adminUiCapability, m as createDeviceProxy, p as isDeviceScopedCap, s as asString, t as sleep, u as parseJsonUnknown, x as viewerUiCapability } from "./sleep-CopaBJss.mjs";
+import { A as DeviceType, At as emitReadiness, Ct as DATAPLANE_SECRET_HEADER, Dt as normalizeAddonInitResult, Et as BaseAddon, G as ReadinessRegistry, H as nodePin, I as expandCapMethods, K as ReadinessTimeoutError, S as DEVICE_CHILDREN_BATCH_MAX, T as describeCustomActions, Tt as DisposerChain, U as readNodePin, Y as scopeKey, a as asJsonObject, b as deviceOpsCapability, d as BOOT_RECOVERY_BACKOFF_MS, f as DEVICE_SCOPED_CAPS, h as createEventBusSliceSource, j as adminUiCapability, m as createDeviceProxy, p as isDeviceScopedCap, s as asString, t as sleep, u as parseJsonUnknown, x as viewerUiCapability } from "./sleep-CaB_hL5g.mjs";
 import { t as EventCategory } from "./event-category-BVDXG4tB.mjs";
 import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 //#region src/generated/cap-input-defaults.ts

package/dist/capabilities/device-manager.cap.d.ts

@@ -1361,29 +1361,30 @@ export declare const deviceManagerCapability: {
             }, z.core.$strip>>;
         }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
-         * Activate (or deactivate) a wrapper addon — or ONE of its sources — for a
-         * (device, cap) pair.
+         * Activate (or deactivate) a wrapper addon for a (device, cap) pair — the
+         * per-camera function switch's ONE authority (D62).
          *
-         * Persists the binding via ctx.settings; `active: false` on a SINGLETON cap
-         * clears the wrapper (falling back to native if one is registered). On a
-         * COLLECTION cap it adds to the per-device DENY set instead, and the
-         * wrapper binding is left exactly as it was — a cap with several sources
-         * has no "which one" for `getBindings` to answer (D556).
+         * SINGLETON capabilities only. Persists the binding via ctx.settings;
+         * `active: false` clears the wrapper (falling back to native if one is
+         * registered) by persisting the explicit `{ wrapperAddonId: null }` marker,
+         * which is what stops `getBindings` re-binding a `defaultActive` wrapper.
          *
-         * `sourceId` is what makes the switch match its label. One addon can serve
-         * several of a device's sources (`addon-provider-reolink` answers a hub
-         * child with `native:reolink:onboard` AND `native:reolink:hub`), so a
-         * toggle keyed by addon would turn off both while saying it turned off one
-         * — the D62 defect with the polarity reversed (D557). Naming the source
-         * denies exactly that source. OMITTING it keeps the cap-wide meaning
-         * D556 shipped: every source this addon serves for this device, which is
-         * also how a deny entry persisted before the re-key is still read.
+         * **A COLLECTION capability is REFUSED by name.** It briefly took a
+         * `sourceId` and wrote a per-device DENY set, so one of an addon's several
+         * sources could be switched off without switching off the rest (D556, then
+         * D555's re-key by source). The operator removed the whole idea the same
+         * day: *"tutti i providers funzionano sempre, non serve
+         * disattivarli/attivarli … loro vivono lì"* (D557 amended, third). A
+         * collection cap's providers are a DERIVED set — every addon that provides
+         * the cap for this device type, computed on every read and persisted
+         * nowhere — so there is nothing here to activate, and a verb that accepted
+         * the call could only write a field the enumeration does not read. That is
+         * the D62 shape, and this repo has shipped it four times.
          */
         readonly setWrapperActive: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
             capName: z.ZodString;
             wrapperAddonId: z.ZodString;
-            sourceId: z.ZodOptional<z.ZodString>;
             active: z.ZodBoolean;
         }, z.core.$strip>, z.ZodVoid, "mutation">;
         /**

package/dist/capabilities/index.d.ts

@@ -116,8 +116,8 @@ export type { IUserPasskeysProvider, PasskeySummary } from './user-passkeys.cap.
 export { PasskeySummarySchema, userPasskeysCapability } from './user-passkeys.cap.js';
 export type { IVectorStoreProvider } from './vector-store.cap.js';
 export { VectorDeclareIndexInputSchema, VectorDeleteByFilterInputSchema, VectorDeleteInputSchema, VectorDeleteResultSchema, type VectorFilter, VectorFilterSchema, VectorGetInputSchema, VectorGetResultSchema, type VectorItem, VectorItemSchema, type VectorMatch, VectorMatchSchema, type VectorMetadata, VectorMetadataSchema, type VectorMetric, VectorMetricSchema, VectorQueryInputSchema, VectorQueryResultSchema, VectorStatsInputSchema, VectorStatsResultSchema, VectorUpsertInputSchema, VectorUpsertResultSchema, vectorStoreCapability, } from './vector-store.cap.js';
-export type { Clip, ClipPlayback, ClipSource, ClipSourceAvailability, IVideoclipsProvider, } from './videoclips.cap.js';
-export { ClipPlaybackSchema, ClipSchema, ClipSourceAvailabilitySchema, ClipSourceSchema, MAX_CLIP_EVENT_IDS, MAX_CLIP_LABELS, videoclipsCapability, } from './videoclips.cap.js';
+export type { Clip, ClipPlayback, ClipSource, ClipSourceAvailability, ClipStillDisposition, ClipStillRefusalCode, IVideoclipsProvider, } from './videoclips.cap.js';
+export { CLIP_STILL_DISPOSITION_HEADER, CLIP_STILL_REASON_CODE_HEADER, CLIP_STILL_REASON_HEADER, ClipPlaybackSchema, ClipSchema, ClipSourceAvailabilitySchema, ClipSourceSchema, ClipStillDispositionSchema, ClipStillRefusalCodeSchema, MAX_CLIP_EVENT_IDS, MAX_CLIP_LABELS, videoclipsCapability, } from './videoclips.cap.js';
 export type { IViewerUiProvider } from './viewer-ui.cap.js';
 export { viewerUiCapability } from './viewer-ui.cap.js';
 export { type IWebrtcSessionProvider, type WebrtcClientHints, type WebrtcLadderDecision, WebrtcLadderDecisionSchema, type WebrtcSessionDebug, WebrtcSessionDebugSchema, type WebrtcStreamChoice, WebrtcStreamChoiceSchema, type WebrtcStreamTarget, WebrtcStreamTargetSchema, type WebrtcTierFailure, WebrtcTierFailureSchema, webrtcClientHintsSchema, webrtcSessionCapability, } from './webrtc-session.cap.js';

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

@@ -4264,6 +4264,40 @@ export declare const pipelineAnalyticsCapability: {
             mediaId: z.ZodNumber;
             sizeBytes: z.ZodNumber;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Which of `ownerIds` hold at least ONE media row — an INDEX read, never a
+         * blob read, and the LICENCE `videoclips` needs to publish a `thumbnail`.
+         *
+         * The event-media URL is stamped from a template for every event in the
+         * system, so "the plane is up" was being served as "there are bytes": 64 of
+         * one camera's 179 clips pointed at a 404 (device 3836, 2026-08-17). This
+         * is the question that turns the stamp into a claim.
+         *
+         * It is on the WIRE because the clip source is registered by the addon that
+         * owns the FOOTAGE, not by this one (D560) — the probe used to be an
+         * in-process `MediaStore` read. One call per OWNER KIND, never one per
+         * owner: that N+1 is what `MediaStore.ownersWithMedia` was written to
+         * prevent, and crossing a process boundary makes it worse, not better.
+         * `ownerIds` is bounded at the same 5 000 the annotation fetch is bounded
+         * at, so one pathological camera-day cannot mint an unbounded request.
+         *
+         * THROWS rather than answering partially. A probe that quietly
+         * under-reports reads as "these owners have nothing" and the caller drops
+         * thumbnails that exist — the opposite failure to the one above, and
+         * equally invisible.
+         *
+         * `deviceId` is the authorization subject, exactly as on `getEventMedia`.
+         */
+        readonly ownersWithMedia: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            ownerKind: z.ZodEnum<{
+                motion: "motion";
+                object: "object";
+                audio: "audio";
+                track: "track";
+            }>;
+            ownerIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodString>>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
          * Search object events by text query using CLIP cosine similarity.
          * Encodes `text` via the `embedding-encoder` cap, queries the

package/dist/capabilities/videoclips.cap.d.ts

@@ -6,20 +6,26 @@ import { type InferProvider } from './capability-definition.js';
  *
  * A device-scoped wrapper COLLECTION (D549 decision 2, D554): every provider a
  * camera has is a SOURCE, and they are listed beside each other — never one
- * substituted for another. The DEFAULT provider (registered by
- * `addon-post-analysis`, `defaultActive: true`) composes the analytics event
- * log (markers + thumbnails) with the recorder's `getPlaybackManifest` — a clip
- * is a time-WINDOW over existing footage, never a separate file. A camera that
- * exposes NATIVE onboard clips (Reolink SD card, a hub's storage, HKSV) adds
- * its own catalog ALONGSIDE that one.
+ * substituted for another. The DEFAULT provider (`analytics`, registered by
+ * the RECORDER — the addon that owns the footage, D560 — `defaultActive: true`)
+ * composes the analytics event log (markers + thumbnails, read over `ctx.api`)
+ * with the recorder's own `getPlaybackManifest` — a clip is a time-WINDOW over
+ * existing footage, never a separate file. A camera that exposes NATIVE onboard
+ * clips (Reolink SD card, a hub's storage, HKSV) adds its own catalog
+ * ALONGSIDE that one.
  *
- * The mount stays per-device (`resolveCapMount` → `device-scoped`): the fan-out
- * is over the DEVICE's sources, resolved from the registry's per-device
- * collection, never over every provider in the cluster. `listClips` is the
- * union of those sources, in newest-first order, with NO dedup and no
- * best-source pick — a clip held in two storages appears twice, once per
- * source, and every row's {@link ClipSchema.source} says which. That is the
- * operator's decision, stated so it is not "fixed" later.
+ * The mount stays per-device (`resolveCapMount` → `device-scoped`), and a
+ * device's SOURCES are its BINDINGS: `deviceManager.getBindings(deviceId)` is
+ * what says a provider serves this camera, never the set of addons that
+ * happen to have registered the capability somewhere in the cluster. That is
+ * what stopped one addon appearing three times on 592 — as the device's
+ * native provider, as the hub-local registration and as an
+ * `<addonId>@<nodeId>` one (D554 amended 2026-09-20).
+ *
+ * `listClips` is asked of ONE provider at a time
+ * ({@link videoclipsCapability.methods.listClips} `provider`), defaulting to
+ * the bound one, which is CamStack on every camera today. It is NOT a union
+ * over everything a camera has: *"l'utilizzatore è uno solo"*.
  * {@link videoclipsCapability.methods.getClipPlayback} dispatches by the
  * source namespace inside the clip id, which is why ids are self-contained.
  *
@@ -35,6 +41,52 @@ import { type InferProvider } from './capability-definition.js';
 export declare const MAX_CLIP_EVENT_IDS = 24;
 /** Cap on {@link ClipSchema.labels} — the ribbon row has space for ~3 words. */
 export declare const MAX_CLIP_LABELS = 3;
+/**
+ * Every reason a still-mint route may refuse, as a TOKEN — never prose.
+ *
+ * The route also sends the prose (`x-camstack-reason`), because a firmware's
+ * own words are the only thing that explains a `camera-refused`. But the token
+ * is what a surface may key a table on, and the code and the prose are
+ * separate headers precisely because they had been the same one: the route
+ * sent `queue-full: 16 thumbnail mints already waiting for host …` and the
+ * surface's table was keyed by `queue-full`, so every refusal on this fleet
+ * rendered as `Refused: <prose>`.
+ */
+export declare const ClipStillRefusalCodeSchema: z.ZodEnum<{
+    sleeping: "sleeping";
+    unsupported: "unsupported";
+    "camera-refused": "camera-refused";
+    "no-keyframe": "no-keyframe";
+    "queue-full": "queue-full";
+    "camera-backoff": "camera-backoff";
+    "no-catalog-row": "no-catalog-row";
+    "unknown-device": "unknown-device";
+    "uid-missing": "uid-missing";
+}>;
+export type ClipStillRefusalCode = z.infer<typeof ClipStillRefusalCodeSchema>;
+/**
+ * Whether a refusal is "not yet" or "never" — decided by the BRANCH that
+ * refused and carried on the wire, never inferred by the client from the code.
+ *
+ * `deferred` means the work is queued or the host is resting: the surface
+ * shows LOADING and comes back, under a bound. `final` means no retry can
+ * change the answer: the surface shows the reason and stops.
+ *
+ * A response that carries no disposition is read as `final`, which is exactly
+ * how every build before this one behaved — an old provider under a new
+ * surface keeps the old, safe behaviour rather than gaining a retry loop.
+ */
+export declare const ClipStillDispositionSchema: z.ZodEnum<{
+    deferred: "deferred";
+    final: "final";
+}>;
+export type ClipStillDisposition = z.infer<typeof ClipStillDispositionSchema>;
+/** The camera's / provider's own words. Kept verbatim, never parsed. */
+export declare const CLIP_STILL_REASON_HEADER = "x-camstack-reason";
+/** One {@link ClipStillRefusalCodeSchema} token, alone. */
+export declare const CLIP_STILL_REASON_CODE_HEADER = "x-camstack-reason-code";
+/** One {@link ClipStillDispositionSchema} token, alone. */
+export declare const CLIP_STILL_DISPOSITION_HEADER = "x-camstack-disposition";
 export declare const ClipSchema: z.ZodObject<{
     id: z.ZodString;
     source: z.ZodString;
@@ -82,6 +134,7 @@ export declare const ClipSchema: z.ZodObject<{
     supportSub: z.ZodOptional<z.ZodBoolean>;
     playable: z.ZodOptional<z.ZodBoolean>;
     unplayableReason: z.ZodOptional<z.ZodString>;
+    inProgress: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type Clip = z.infer<typeof ClipSchema>;
 export declare const ClipPlaybackSchema: z.ZodObject<{
@@ -141,7 +194,6 @@ export declare const ClipSourceSchema: z.ZodObject<{
     source: z.ZodString;
     label: z.ZodString;
     addonId: z.ZodOptional<z.ZodString>;
-    via: z.ZodOptional<z.ZodString>;
     availability: z.ZodObject<{
         state: z.ZodEnum<{
             ok: "ok";
@@ -153,7 +205,6 @@ export declare const ClipSourceSchema: z.ZodObject<{
         reason: z.ZodOptional<z.ZodString>;
         catalogAsOf: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
-    switchedOff: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type ClipSource = z.infer<typeof ClipSourceSchema>;
 export declare const videoclipsCapability: {
@@ -174,18 +225,32 @@ export declare const videoclipsCapability: {
      * `device-config-widget-wrapped-binding.spec.ts` pins that a `kind:'wrapped'`
      * binding entry derives the same section a native one does.
      *
-     * `topTab` because the browser owns the whole pane (a day's clips, a source
-     * list and a player), exactly as `ptz` does; the widget itself is
-     * `host/clips-browser` in ui-library's `HOST_WIDGETS`.
+     * **It is a SECTION of the Recording tab, at the end of it — not a tab of
+     * its own.** It shipped as a `clips` top-tab and the operator rejected the
+     * placement: *"utilizzerei la stessa tab recordings, lì abbiamo già tutto il
+     * necessario, una nuova sezione alla fine per le clips"*. The Recording tab
+     * already holds the recorder's panel, the schedule bands and the unified
+     * retention policy; footage the camera itself holds is the same question,
+     * asked of a different store. `order: 100` puts it after all of them with
+     * room left in front. The `clips` entry in `WELL_KNOWN_TABS` went with it —
+     * a well-known id nobody declares is an invitation to mint the tab again.
+     *
+     * `topTab` stays: the browser owns a pane (a day's tiles, a source list and
+     * a player) and the Config tab's inner bar has no room for one. The widget
+     * itself is `host/clips-browser` in ui-library's `HOST_WIDGETS`, and because
+     * the admin Recordings page renders every `location:'top-tab'` +
+     * `tab:'recording'` section behind its camera picker
+     * (`CameraRecordingSettingsSection`), this declaration lands the section on
+     * BOTH surfaces with no second wiring.
      */
     readonly deviceConfig: {
         readonly ui: {
             readonly kind: "widget";
             readonly widgetId: "host/clips-browser";
-            readonly tab: "clips";
+            readonly tab: "recording";
             readonly topTab: true;
             readonly label: "Clips";
-            readonly order: 0;
+            readonly order: 100;
         };
     };
     readonly methods: {
@@ -194,7 +259,7 @@ export declare const videoclipsCapability: {
             since: z.ZodNumber;
             until: z.ZodNumber;
             limit: z.ZodOptional<z.ZodNumber>;
-            sources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            provider: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             source: z.ZodString;
@@ -242,6 +307,7 @@ export declare const videoclipsCapability: {
             supportSub: z.ZodOptional<z.ZodBoolean>;
             playable: z.ZodOptional<z.ZodBoolean>;
             unplayableReason: z.ZodOptional<z.ZodString>;
+            inProgress: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>>, "query">;
         /**
          * The sources this camera has, WITH the reason any of them cannot answer.
@@ -258,7 +324,6 @@ export declare const videoclipsCapability: {
             source: z.ZodString;
             label: z.ZodString;
             addonId: z.ZodOptional<z.ZodString>;
-            via: z.ZodOptional<z.ZodString>;
             availability: z.ZodObject<{
                 state: z.ZodEnum<{
                     ok: "ok";
@@ -270,7 +335,6 @@ export declare const videoclipsCapability: {
                 reason: z.ZodOptional<z.ZodString>;
                 catalogAsOf: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>;
-            switchedOff: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>>, "query">;
         readonly getClipPlayback: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;

package/dist/generated/addon-api.d.ts

@@ -5630,6 +5630,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof pipelineAnalyticsCapability.methods.listEventMedia.output>;
             meta: object;
         }>;
+        ownersWithMedia: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.ownersWithMedia.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.ownersWithMedia.output>;
+            meta: object;
+        }>;
         searchObjectEvents: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;

package/dist/generated/method-access-map.d.ts

@@ -6,7 +6,7 @@
  * scope+access check inside `protectedProcedure` (see
  * `server/backend/src/api/trpc/trpc.middleware.ts`).
  *
- * Coverage: 1057 method paths across 131 capabilities.
+ * Coverage: 1058 method paths across 131 capabilities.
  */
 import type { CapabilityMethodAccess } from '../capabilities/capability-definition.js';
 export interface MethodAccessRecord {

package/dist/generated/method-device-selectors.d.ts

@@ -6,7 +6,7 @@
  * system-scope cap that takes a deviceId was previously never device-filtered
  * — see the generator header).
  *
- * Coverage: 389 methods carry a device reference, of which
+ * Coverage: 390 methods carry a device reference, of which
  * 141 are on SYSTEM-scope caps.
  *
  * Top-level fields, number arrays, and one-level arrays of objects carrying

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export * from './audio/audio-chunk-format.js';
-export type { EventOwnerType, MediaOwnerKey, MediaOwnerKeyInput, MediaOwnerType, } from './media/media-owner-key.js';
-export { EVENT_OWNER_TYPES, EventOwnerTypeSchema, MEDIA_OWNER_TYPES, formatMediaOwnerKey, isEventOwnerType, isMediaOwnerType, parseMediaOwnerKey, } from './media/media-owner-key.js';
+export type { EventOwnerType, MediaOwnerKey, MediaOwnerKeyInput, MediaOwnerType, MediaPresenceOwnerKind, } from './media/media-owner-key.js';
+export { EVENT_OWNER_TYPES, EventOwnerTypeSchema, MEDIA_OWNER_TYPES, MEDIA_PRESENCE_OWNER_KINDS, MediaPresenceOwnerKindSchema, formatMediaOwnerKey, isEventOwnerType, isMediaOwnerType, parseMediaOwnerKey, } from './media/media-owner-key.js';
 export type { CapabilitiesAccess } from './addon/base-addon.js';
 export { BaseAddon, normalizeAddonInitResult } from './addon/base-addon.js';
 export type { AddonRouteInvokeRequest, AddonRouteReplyEnvelope, } from './addon/build-addon-route-provider.js';