@camstack/types 1.2.386 → 1.2.388

package/dist/interfaces/addon-data-plane.d.ts

@@ -40,9 +40,9 @@ export interface AddonDataPlane {
  *  transport in front of it (auth + reverse-proxy). */
 export type DataPlaneHandler = (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
 /**
- * The share-view scope kinds a `csv_*` share token can carry. The hub mints
- * and validates them (`share-token.service.ts` builds its enum from this
- * list); a data plane names the kinds it ACCEPTS in `share`.
+ * The share-view scope kinds a share-link token can carry. The hub mints
+ * and validates them (`ShareViewGrantSchema` builds its
+ * enum from this list); a data plane names the kinds it ACCEPTS in `share`.
  */
 export declare const SHARE_VIEW_KINDS: readonly ['grid-view', 'events-view'];
 export type ShareViewKind = (typeof SHARE_VIEW_KINDS)[number];
@@ -57,7 +57,7 @@ export interface AddonDataPlaneServeOptions {
     /** The addon's request handler — real `IncomingMessage`/`ServerResponse`. */
     readonly handler: DataPlaneHandler;
     /**
-     * Share-token scope kinds this plane serves. ABSENT means a `csv_*` share
+     * Share-token scope kinds this plane serves. ABSENT means a share-link
      * token is refused here (403), whatever `access` says: a share link is a
      * bearer credential for one view of a few devices, not a session, and a
      * plane that never read the scope headers would serve every device to it.

package/dist/interfaces/addon-peer-bytes.d.ts

@@ -9,7 +9,7 @@
  *
  * - the data-plane listener binds `127.0.0.1` behind a per-listener secret that
  *   **only the hub** presents, and the hub's `/addon/<id>/…` proxy in front of
- *   it takes a session cookie, a `cst_` token scoped `{type:'addon'}` or a JWT
+ *   it takes a session cookie, a token scoped `{type:'addon'}` or a JWT
  *   — an addon holds none of those;
  * - `ctx.api.<cap>.subscribe` is refused on an addon caller by design, so a
  *   streaming cap method is not available either;

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/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/schemas/auth-records.d.ts

@@ -22,7 +22,7 @@ import { DeviceType } from '../device/device-type.js';
  * `super_admin` — collapsed onto the single boolean because every
  * non-admin caller is governed by the same scope-check rules; the
  * distinction was only ever used to route role-specific procedures
- * which we no longer have. CLI / webhook integrations are `cst_*` tokens
+ * which we no longer have. CLI / webhook integrations are tokens (`auth.mintToken`)
  * with `isAdmin: false` + an explicit scope list.
  */
 /** Per-method access flavour. Materialised on every cap method via codegen. */

package/dist/schemas/user-preferences.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Per-user ACCOUNT preferences (D894): the hub-side half of the viewer's two
+ * settings levels.
+ *
+ *   - DEVICE settings never leave the phone.
+ *   - ACCOUNT settings live here: one row per `(user, namespace)`, private to
+ *     that user, synced across every device signed in as them, last write wins
+ *     unless the writer sends the revision it based its edit on.
+ *
+ * A setting lives in exactly ONE level; there are no overrides. The caller
+ * never names a user: the hub stamps the principal's own id, admin included.
+ *
+ * The contract the client codes against is the `preferences.*` tRPC router
+ * (`server/backend/src/api/core/preferences.router.ts`).
+ */
+import { z } from 'zod';
+/** `viewer.app`, `viewer.cameras`, `viewer.grids` … — lowercase, dot/dash separated. */
+export declare const PREFERENCES_NAMESPACE_PATTERN: RegExp;
+/** One row's value, measured as UTF-8 JSON. */
+export declare const PREFERENCES_MAX_VALUE_BYTES: number;
+/** Namespaces one user may hold. */
+export declare const PREFERENCES_MAX_NAMESPACES = 32;
+/** The opaque client id a writer stamps (`updatedByDevice`). */
+export declare const PREFERENCES_MAX_DEVICE_ID_LENGTH = 64;
+export declare const PreferenceNamespaceSchema: z.ZodString;
+export type PreferenceNamespace = z.infer<typeof PreferenceNamespaceSchema>;
+/** A namespace's value: a JSON object, opaque to the hub. */
+export declare const PreferenceValueSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type PreferenceValue = z.infer<typeof PreferenceValueSchema>;
+export declare const PreferenceDeviceIdSchema: z.ZodString;
+/** A stored row, as the owner reads it. */
+export declare const PreferenceRowSchema: z.ZodObject<{
+    namespace: z.ZodString;
+    value: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    revision: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    updatedByDevice: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type PreferenceRow = z.infer<typeof PreferenceRowSchema>;
+export declare const PreferencesGetInputSchema: z.ZodObject<{
+    namespaces: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type PreferencesGetInput = z.infer<typeof PreferencesGetInputSchema>;
+export declare const PreferencesGetOutputSchema: z.ZodObject<{
+    rows: z.ZodArray<z.ZodObject<{
+        namespace: z.ZodString;
+        value: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        revision: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+        updatedByDevice: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PreferencesGetOutput = z.infer<typeof PreferencesGetOutputSchema>;
+export declare const PreferencesPutInputSchema: z.ZodObject<{
+    namespace: z.ZodString;
+    value: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    baseRevision: z.ZodOptional<z.ZodNumber>;
+    deviceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PreferencesPutInput = z.infer<typeof PreferencesPutInputSchema>;
+export declare const PreferencesPutOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"saved">;
+    row: z.ZodObject<{
+        namespace: z.ZodString;
+        value: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        revision: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+        updatedByDevice: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"conflict">;
+    current: z.ZodNullable<z.ZodObject<{
+        namespace: z.ZodString;
+        value: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        revision: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+        updatedByDevice: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "status">;
+export type PreferencesPutOutput = z.infer<typeof PreferencesPutOutputSchema>;
+export declare const PreferencesDeleteInputSchema: z.ZodObject<{
+    namespace: z.ZodString;
+}, z.core.$strip>;
+export type PreferencesDeleteInput = z.infer<typeof PreferencesDeleteInputSchema>;
+export declare const PreferencesDeleteOutputSchema: z.ZodObject<{
+    deleted: z.ZodBoolean;
+}, z.core.$strip>;
+export type PreferencesDeleteOutput = z.infer<typeof PreferencesDeleteOutputSchema>;
+export declare const PreferencesChangedSinceInputSchema: z.ZodObject<{
+    revisionByNamespace: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+export type PreferencesChangedSinceInput = z.infer<typeof PreferencesChangedSinceInputSchema>;
+export declare const PreferencesChangedSinceOutputSchema: z.ZodObject<{
+    rows: z.ZodArray<z.ZodObject<{
+        namespace: z.ZodString;
+        value: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        revision: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+        updatedByDevice: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    deleted: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type PreferencesChangedSinceOutput = z.infer<typeof PreferencesChangedSinceOutputSchema>;

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

@@ -2804,9 +2804,9 @@ var DisposerChain = class {
 */
 var DATAPLANE_SECRET_HEADER = "x-camstack-dataplane-secret";
 /**
-* The share-view scope kinds a `csv_*` share token can carry. The hub mints
-* and validates them (`share-token.service.ts` builds its enum from this
-* list); a data plane names the kinds it ACCEPTS in `share`.
+* The share-view scope kinds a share-link token can carry. The hub mints
+* and validates them (`ShareViewGrantSchema` builds its
+* enum from this list); a data plane names the kinds it ACCEPTS in `share`.
 */
 var SHARE_VIEW_KINDS = ["grid-view", "events-view"];
 //#endregion
@@ -4203,6 +4203,20 @@ function parseSettingsArrayAdoptsFrom(from) {
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+/** RFC 7396: objects merge key by key, `null` removes, anything else replaces. */
+function mergePatch(target, patch) {
+	if (!isRecord(patch)) return target;
+	const out = { ...target };
+	for (const [key, value] of Object.entries(patch)) {
+		if (value === null) {
+			delete out[key];
+			continue;
+		}
+		const current = out[key];
+		out[key] = isRecord(value) && isRecord(current) ? mergePatch(current, value) : value;
+	}
+	return out;
+}
 function markersOf(decl, body) {
 	const out = /* @__PURE__ */ new Map();
 	mapSecretLeaves(body, decl.secretPaths, decl.secretArrayKeys, (leaf) => {
@@ -4384,7 +4398,20 @@ function makeInMemoryRecords(owner = "spec") {
 						releasedRefs: released
 					};
 				},
-				patch: async () => unimplemented("patch"),
+				patch: async ({ kind, id, data, at, ifRev }) => {
+					const prev = table(kind).get(id);
+					if (prev === void 0) throw new Error(`${kind}/${id}: no such record`);
+					if (ifRev !== void 0 && prev.rev !== ifRev) throw new Error("stale ifRev");
+					const { rev, released } = write(kind, {
+						id,
+						...at !== void 0 && at !== null ? { at } : prev.at !== null ? { at: prev.at } : {},
+						data: mergePatch(prev.data, data)
+					});
+					return {
+						rev,
+						releasedRefs: released
+					};
+				},
 				delete: async ({ kind, id }) => {
 					if (writesFail) throw new Error("records engine unreachable");
 					const row = table(kind).get(id);
@@ -5375,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-BE7_6UnC.js → sleep-DKtoyk6X.js}

@@ -2804,9 +2804,9 @@ var DisposerChain = class {
 */
 var DATAPLANE_SECRET_HEADER = "x-camstack-dataplane-secret";
 /**
-* The share-view scope kinds a `csv_*` share token can carry. The hub mints
-* and validates them (`share-token.service.ts` builds its enum from this
-* list); a data plane names the kinds it ACCEPTS in `share`.
+* The share-view scope kinds a share-link token can carry. The hub mints
+* and validates them (`ShareViewGrantSchema` builds its
+* enum from this list); a data plane names the kinds it ACCEPTS in `share`.
 */
 var SHARE_VIEW_KINDS = ["grid-view", "events-view"];
 //#endregion
@@ -4203,6 +4203,20 @@ function parseSettingsArrayAdoptsFrom(from) {
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+/** RFC 7396: objects merge key by key, `null` removes, anything else replaces. */
+function mergePatch(target, patch) {
+	if (!isRecord(patch)) return target;
+	const out = { ...target };
+	for (const [key, value] of Object.entries(patch)) {
+		if (value === null) {
+			delete out[key];
+			continue;
+		}
+		const current = out[key];
+		out[key] = isRecord(value) && isRecord(current) ? mergePatch(current, value) : value;
+	}
+	return out;
+}
 function markersOf(decl, body) {
 	const out = /* @__PURE__ */ new Map();
 	mapSecretLeaves(body, decl.secretPaths, decl.secretArrayKeys, (leaf) => {
@@ -4384,7 +4398,20 @@ function makeInMemoryRecords(owner = "spec") {
 						releasedRefs: released
 					};
 				},
-				patch: async () => unimplemented("patch"),
+				patch: async ({ kind, id, data, at, ifRev }) => {
+					const prev = table(kind).get(id);
+					if (prev === void 0) throw new Error(`${kind}/${id}: no such record`);
+					if (ifRev !== void 0 && prev.rev !== ifRev) throw new Error("stale ifRev");
+					const { rev, released } = write(kind, {
+						id,
+						...at !== void 0 && at !== null ? { at } : prev.at !== null ? { at: prev.at } : {},
+						data: mergePatch(prev.data, data)
+					});
+					return {
+						rev,
+						releasedRefs: released
+					};
+				},
 				delete: async ({ kind, id }) => {
 					if (writesFail) throw new Error("records engine unreachable");
 					const row = table(kind).get(id);
@@ -5375,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.386",
+  "version": "1.2.388",
   "description": "Shared types, interfaces, and model catalogs for the CamStack detection ecosystem",
   "keywords": [
     "camstack",