@camstack/types 1.2.379 → 1.2.381

package/dist/client.js

@@ -25895,6 +25895,50 @@ function isSource(x) {
 	return typeof x.read === "function" && typeof x.watch === "function";
 }
 //#endregion
+//#region src/helpers/addon-slice-handle.ts
+/** Structural bridge: every `AddonApi` client carries `deviceState` (+ optional `live`). */
+function addonSliceHandleApi(api) {
+	return api;
+}
+//#endregion
+//#region src/helpers/trpc-leaf.ts
+function isTrpcProcedureLeaf(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value;
+	return (typeof record.query === "function" || typeof record.mutate === "function" || typeof record.subscribe === "function") && !Array.isArray(value);
+}
+function readCapRecord(api, capProp) {
+	const cap = Reflect.get(api, capProp);
+	if (typeof cap !== "object" || cap === null || Array.isArray(cap)) return void 0;
+	return cap;
+}
+function readTrpcLeaf(api, capProp, method) {
+	const capRecord = readCapRecord(api, capProp);
+	if (!capRecord) throw new Error(`tRPC client has no router '${capProp}'`);
+	const leaf = capRecord[method];
+	if (!isTrpcProcedureLeaf(leaf)) throw new Error(`tRPC client has no '${capProp}.${method}'`);
+	return leaf;
+}
+/**
+* Invoke `api.<capProp>.<method>.{query|mutate|subscribe}(input)`.
+* `Result` is the generated proxy method's return. The leaf itself is only
+* `unknown` (the client is a structural bag), so the assertion is the one
+* boundary between that bag and the typed proxy.
+*/
+function invokeTrpcLeaf(api, capProp, method, kind, input, push) {
+	const fn = readTrpcLeaf(api, capProp, method);
+	if (kind === "mutation") {
+		if (typeof fn.mutate !== "function") throw new Error(`tRPC '${capProp}.${method}' has no mutate()`);
+		return fn.mutate(input);
+	}
+	if (kind === "subscription") {
+		if (typeof fn.subscribe !== "function") throw new Error(`tRPC '${capProp}.${method}' has no subscribe()`);
+		return fn.subscribe(input, push);
+	}
+	if (typeof fn.query !== "function") throw new Error(`tRPC '${capProp}.${method}' has no query()`);
+	return fn.query(input);
+}
+//#endregion
 //#region src/generated/device-proxy.ts
 /**
 * Build a DeviceProxy that pre-binds deviceId + nodeId on every method call
@@ -25912,8 +25956,7 @@ function isSource(x) {
 * field on the returned object.
 */
 function createDeviceProxy(api, binding, opts) {
-	const typedApi = api;
-	const stateSource = opts?.stateSource ?? createLazyTrpcSource(api);
+	const stateSource = opts?.stateSource ?? createLazyTrpcSource(addonSliceHandleApi(api));
 	/** Merge `{deviceId, nodeId?}` into the caller-supplied input. */
 	function mergeInput(input, nodeId) {
 		const base = typeof input === "object" && input !== null ? input : {};
@@ -25926,20 +25969,8 @@ function createDeviceProxy(api, binding, opts) {
 			deviceId: binding.deviceId
 		};
 	}
-	/**
-	* Invoke `api.<capProp>.<method>.{query|mutate|subscribe}(merged)`.
-	* Returns `any` so the caller-side per-method declaration assigns
-	* cleanly into the strongly-typed `InferDeviceProxyCap<...>` shape on
-	* the `DeviceProxy` interface — the proxy's contract is enforced by
-	* the interface, not the dispatch helper.
-	*/
 	function callLeaf(capProp, method, kind, merged, push) {
-		const leaf = typedApi[capProp]?.[method];
-		if (!leaf) throw new Error(`DeviceProxy: api has no '${capProp}.${method}'`);
-		const fn = leaf;
-		if (kind === "mutation") return fn.mutate(merged);
-		if (kind === "subscription") return fn.subscribe(merged, push);
-		return fn.query(merged);
+		return invokeTrpcLeaf(api, capProp, method, kind, merged, push);
 	}
 	/**
 	* Device-scoped cap dispatch. Looks up the binding entry for `capName`
@@ -27252,9 +27283,10 @@ var SystemMirror = class {
 		for (let i = 0; i < targets.length; i += parallelism) {
 			const chunk = targets.slice(i, i + parallelism);
 			const settled = await Promise.allSettled(chunk.map(async (proxy) => {
-				const cap = proxy[capName];
-				if (!cap || typeof cap[methodName] !== "function") throw new Error(`device '${proxy.deviceId}' does not expose '${capName}.${methodName}'`);
-				return await cap[methodName](args);
+				const cap = Reflect.get(proxy, capName);
+				const method = typeof cap === "object" && cap !== null ? Reflect.get(cap, methodName) : void 0;
+				if (typeof method !== "function") throw new Error(`device '${proxy.deviceId}' does not expose '${capName}.${methodName}'`);
+				return await Reflect.apply(method, cap, [args]);
 			}));
 			for (let j = 0; j < settled.length; j++) {
 				const proxy = chunk[j];
@@ -27489,21 +27521,8 @@ function matchesString(haystack, match) {
 * dropping the reference.
 */
 function createSystemProxy(api) {
-	const typedApi = api;
-	/**
-	* Invoke `api.<capProp>.<method>.{query|mutate|subscribe}(input)`.
-	* Returns `any` so the caller-side per-method declaration assigns
-	* cleanly into the strongly-typed `Pick<InferProvider<...>, ...>`
-	* shape on the `SystemProxy` interface — the proxy's contract is
-	* enforced by the interface, not the dispatch helper.
-	*/
 	function dispatch(capProp, method, kind, input, push) {
-		const leaf = typedApi[capProp]?.[method];
-		if (!leaf) throw new Error(`SystemProxy: api has no '${capProp}.${method}'`);
-		const fn = leaf;
-		if (kind === "mutation") return fn.mutate(input);
-		if (kind === "subscription") return fn.subscribe(input, push);
-		return fn.query(input);
+		return invokeTrpcLeaf(api, capProp, method, kind, input, push);
 	}
 	return {
 		addonPages: { listPages: (input) => dispatch("addonPages", "listPages", "query", input) },
@@ -28076,6 +28095,12 @@ function createSystemProxy(api) {
 			assignPlates: (input) => dispatch("plateGallery", "assignPlates", "mutation", input),
 			unassignPlates: (input) => dispatch("plateGallery", "unassignPlates", "mutation", input)
 		},
+		recordEntries: {
+			listEntryKinds: (input) => dispatch("recordEntries", "listEntryKinds", "query", input),
+			listEntries: (input) => dispatch("recordEntries", "listEntries", "query", input),
+			putEntry: (input) => dispatch("recordEntries", "putEntry", "mutation", input),
+			deleteEntry: (input) => dispatch("recordEntries", "deleteEntry", "mutation", input)
+		},
 		recordingArchive: {
 			getAvailabilityBatch: (input) => dispatch("recordingArchive", "getAvailabilityBatch", "query", input),
 			getDaysWithRecordingsBatch: (input) => dispatch("recordingArchive", "getDaysWithRecordingsBatch", "query", input),

package/dist/client.mjs

@@ -25894,6 +25894,50 @@ function isSource(x) {
 	return typeof x.read === "function" && typeof x.watch === "function";
 }
 //#endregion
+//#region src/helpers/addon-slice-handle.ts
+/** Structural bridge: every `AddonApi` client carries `deviceState` (+ optional `live`). */
+function addonSliceHandleApi(api) {
+	return api;
+}
+//#endregion
+//#region src/helpers/trpc-leaf.ts
+function isTrpcProcedureLeaf(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value;
+	return (typeof record.query === "function" || typeof record.mutate === "function" || typeof record.subscribe === "function") && !Array.isArray(value);
+}
+function readCapRecord(api, capProp) {
+	const cap = Reflect.get(api, capProp);
+	if (typeof cap !== "object" || cap === null || Array.isArray(cap)) return void 0;
+	return cap;
+}
+function readTrpcLeaf(api, capProp, method) {
+	const capRecord = readCapRecord(api, capProp);
+	if (!capRecord) throw new Error(`tRPC client has no router '${capProp}'`);
+	const leaf = capRecord[method];
+	if (!isTrpcProcedureLeaf(leaf)) throw new Error(`tRPC client has no '${capProp}.${method}'`);
+	return leaf;
+}
+/**
+* Invoke `api.<capProp>.<method>.{query|mutate|subscribe}(input)`.
+* `Result` is the generated proxy method's return. The leaf itself is only
+* `unknown` (the client is a structural bag), so the assertion is the one
+* boundary between that bag and the typed proxy.
+*/
+function invokeTrpcLeaf(api, capProp, method, kind, input, push) {
+	const fn = readTrpcLeaf(api, capProp, method);
+	if (kind === "mutation") {
+		if (typeof fn.mutate !== "function") throw new Error(`tRPC '${capProp}.${method}' has no mutate()`);
+		return fn.mutate(input);
+	}
+	if (kind === "subscription") {
+		if (typeof fn.subscribe !== "function") throw new Error(`tRPC '${capProp}.${method}' has no subscribe()`);
+		return fn.subscribe(input, push);
+	}
+	if (typeof fn.query !== "function") throw new Error(`tRPC '${capProp}.${method}' has no query()`);
+	return fn.query(input);
+}
+//#endregion
 //#region src/generated/device-proxy.ts
 /**
 * Build a DeviceProxy that pre-binds deviceId + nodeId on every method call
@@ -25911,8 +25955,7 @@ function isSource(x) {
 * field on the returned object.
 */
 function createDeviceProxy(api, binding, opts) {
-	const typedApi = api;
-	const stateSource = opts?.stateSource ?? createLazyTrpcSource(api);
+	const stateSource = opts?.stateSource ?? createLazyTrpcSource(addonSliceHandleApi(api));
 	/** Merge `{deviceId, nodeId?}` into the caller-supplied input. */
 	function mergeInput(input, nodeId) {
 		const base = typeof input === "object" && input !== null ? input : {};
@@ -25925,20 +25968,8 @@ function createDeviceProxy(api, binding, opts) {
 			deviceId: binding.deviceId
 		};
 	}
-	/**
-	* Invoke `api.<capProp>.<method>.{query|mutate|subscribe}(merged)`.
-	* Returns `any` so the caller-side per-method declaration assigns
-	* cleanly into the strongly-typed `InferDeviceProxyCap<...>` shape on
-	* the `DeviceProxy` interface — the proxy's contract is enforced by
-	* the interface, not the dispatch helper.
-	*/
 	function callLeaf(capProp, method, kind, merged, push) {
-		const leaf = typedApi[capProp]?.[method];
-		if (!leaf) throw new Error(`DeviceProxy: api has no '${capProp}.${method}'`);
-		const fn = leaf;
-		if (kind === "mutation") return fn.mutate(merged);
-		if (kind === "subscription") return fn.subscribe(merged, push);
-		return fn.query(merged);
+		return invokeTrpcLeaf(api, capProp, method, kind, merged, push);
 	}
 	/**
 	* Device-scoped cap dispatch. Looks up the binding entry for `capName`
@@ -27251,9 +27282,10 @@ var SystemMirror = class {
 		for (let i = 0; i < targets.length; i += parallelism) {
 			const chunk = targets.slice(i, i + parallelism);
 			const settled = await Promise.allSettled(chunk.map(async (proxy) => {
-				const cap = proxy[capName];
-				if (!cap || typeof cap[methodName] !== "function") throw new Error(`device '${proxy.deviceId}' does not expose '${capName}.${methodName}'`);
-				return await cap[methodName](args);
+				const cap = Reflect.get(proxy, capName);
+				const method = typeof cap === "object" && cap !== null ? Reflect.get(cap, methodName) : void 0;
+				if (typeof method !== "function") throw new Error(`device '${proxy.deviceId}' does not expose '${capName}.${methodName}'`);
+				return await Reflect.apply(method, cap, [args]);
 			}));
 			for (let j = 0; j < settled.length; j++) {
 				const proxy = chunk[j];
@@ -27488,21 +27520,8 @@ function matchesString(haystack, match) {
 * dropping the reference.
 */
 function createSystemProxy(api) {
-	const typedApi = api;
-	/**
-	* Invoke `api.<capProp>.<method>.{query|mutate|subscribe}(input)`.
-	* Returns `any` so the caller-side per-method declaration assigns
-	* cleanly into the strongly-typed `Pick<InferProvider<...>, ...>`
-	* shape on the `SystemProxy` interface — the proxy's contract is
-	* enforced by the interface, not the dispatch helper.
-	*/
 	function dispatch(capProp, method, kind, input, push) {
-		const leaf = typedApi[capProp]?.[method];
-		if (!leaf) throw new Error(`SystemProxy: api has no '${capProp}.${method}'`);
-		const fn = leaf;
-		if (kind === "mutation") return fn.mutate(input);
-		if (kind === "subscription") return fn.subscribe(input, push);
-		return fn.query(input);
+		return invokeTrpcLeaf(api, capProp, method, kind, input, push);
 	}
 	return {
 		addonPages: { listPages: (input) => dispatch("addonPages", "listPages", "query", input) },
@@ -28075,6 +28094,12 @@ function createSystemProxy(api) {
 			assignPlates: (input) => dispatch("plateGallery", "assignPlates", "mutation", input),
 			unassignPlates: (input) => dispatch("plateGallery", "unassignPlates", "mutation", input)
 		},
+		recordEntries: {
+			listEntryKinds: (input) => dispatch("recordEntries", "listEntryKinds", "query", input),
+			listEntries: (input) => dispatch("recordEntries", "listEntries", "query", input),
+			putEntry: (input) => dispatch("recordEntries", "putEntry", "mutation", input),
+			deleteEntry: (input) => dispatch("recordEntries", "deleteEntry", "mutation", input)
+		},
 		recordingArchive: {
 			getAvailabilityBatch: (input) => dispatch("recordingArchive", "getAvailabilityBatch", "query", input),
 			getDaysWithRecordingsBatch: (input) => dispatch("recordingArchive", "getDaysWithRecordingsBatch", "query", input),

package/dist/device/device-context.d.ts

@@ -137,6 +137,8 @@ export interface DeviceContext {
  *  + persistInitialConfig + createContext + register` flow.
  */
 export type DeviceConstructor<T extends IDevice = IDevice> = new (ctx: DeviceContext) => T;
+/** Map entry helper — concrete camera/hub classes widen to `DeviceConstructor<IDevice>`. */
+export declare function widenDeviceConstructor<T extends IDevice>(ctor: DeviceConstructor<T>): DeviceConstructor<IDevice>;
 export interface DeviceManagerApi {
     /**
      * Create, register, and persist a device in one call.

package/dist/ffmpeg/fmp4-fragment-child.d.ts

@@ -35,14 +35,14 @@
  * request schema on purpose (see `egressTransportFromRequest`): a plane is a
  * live object, so an off-node caller could not use one anyway.
  */
-import type { spawn as nodeSpawn } from 'node:child_process';
 import type { IScopedLogger } from '../interfaces/logging.js';
 import type { FfmpegInvocation } from './invocation.js';
+import type { FfmpegSpawnFn } from './process.js';
 import type { Fmp4FragmentPlane } from './fmp4-fragment-plane.js';
 export interface Fmp4FragmentChildDeps {
     readonly logger: IScopedLogger;
     readonly ffmpegBinaryPath: string;
-    readonly spawnFn: typeof nodeSpawn;
+    readonly spawnFn: FfmpegSpawnFn;
     /** How long the child may produce no UNIT before it is declared dead. */
     readonly firstUnitTimeoutMs?: number;
     /** The child exited, or its output stopped parsing, AFTER it went live. */

package/dist/ffmpeg/process.d.ts

@@ -32,6 +32,27 @@
  */
 import { spawn, type ChildProcess, type SpawnOptions } from 'node:child_process';
 import type { IScopedLogger } from '../interfaces/logging.js';
+/** Subset of {@link ChildProcess} every live-media ffmpeg site reads. */
+export interface SpawnedFfmpegProcess {
+    readonly pid?: number;
+    readonly killed?: boolean;
+    readonly exitCode?: number | null;
+    readonly signalCode?: NodeJS.Signals | null;
+    readonly stdin?: {
+        on(event: string, listener: () => void): void;
+        end(): void;
+    } | null;
+    readonly stdout: NodeJS.ReadableStream | null;
+    readonly stderr: NodeJS.ReadableStream | null;
+    on(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    once(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+    once(event: 'error', listener: (err: Error) => void): this;
+    kill(signal?: NodeJS.Signals): boolean;
+}
+/** Injectable ffmpeg spawn — the three-arg shape live-media sites use. */
+export type FfmpegSpawnFn = (command: string, args: readonly string[], options?: SpawnOptions) => SpawnedFfmpegProcess;
+export declare function defaultFfmpegSpawn(command: string, args: readonly string[], options?: SpawnOptions): SpawnedFfmpegProcess;
 /** How a child ended. */
 export type FfmpegExitClass = 
 /** Exited 0. */

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

@@ -105,11 +105,13 @@ import type { privacyMaskCapability } from '../capabilities/privacy-mask.cap.js'
 import type { ptzAutotrackCapability } from '../capabilities/ptz-autotrack.cap.js';
 import type { ptzCapability } from '../capabilities/ptz.cap.js';
 import type { rebootCapability } from '../capabilities/reboot.cap.js';
+import type { recordEntriesCapability } from '../capabilities/record-entries.cap.js';
 import type { recordingArchiveCapability } from '../capabilities/recording-archive.cap.js';
 import type { recordingExportCapability } from '../capabilities/recording-export.cap.js';
 import type { recordingOnboardCapability } from '../capabilities/recording-onboard.cap.js';
 import type { recordingSignalCapability } from '../capabilities/recording-signal.cap.js';
 import type { recordingCapability } from '../capabilities/recording.cap.js';
+import type { recordsCapability } from '../capabilities/records.cap.js';
 import type { sceneMonitorCapability } from '../capabilities/scene-monitor.cap.js';
 import type { scriptRunnerCapability } from '../capabilities/script-runner.cap.js';
 import type { serverManagementCapability } from '../capabilities/server-management.cap.js';
@@ -7880,6 +7882,41 @@ export type AppRouter = TrpcCoreRouter<{
             meta: object;
         }>;
     }>>;
+    recordEntries: TRPCBuiltRouter<{
+        ctx: TrpcContext;
+        meta: object;
+        errorShape: AugmentedErrorShape;
+        transformer: true;
+    }, TRPCDecorateCreateRouterOptions<{
+        listEntryKinds: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordEntriesCapability.methods.listEntryKinds.input>;
+            output: z.infer<typeof recordEntriesCapability.methods.listEntryKinds.output>;
+            meta: object;
+        }>;
+        listEntries: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordEntriesCapability.methods.listEntries.input>;
+            output: z.infer<typeof recordEntriesCapability.methods.listEntries.output>;
+            meta: object;
+        }>;
+        putEntry: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordEntriesCapability.methods.putEntry.input>;
+            output: z.infer<typeof recordEntriesCapability.methods.putEntry.output>;
+            meta: object;
+        }>;
+        deleteEntry: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordEntriesCapability.methods.deleteEntry.input>;
+            output: z.infer<typeof recordEntriesCapability.methods.deleteEntry.output>;
+            meta: object;
+        }>;
+    }>>;
     recording: TRPCBuiltRouter<{
         ctx: TrpcContext;
         meta: object;
@@ -8265,6 +8302,125 @@ export type AppRouter = TrpcCoreRouter<{
             meta: object;
         }>;
     }>>;
+    records: TRPCBuiltRouter<{
+        ctx: TrpcContext;
+        meta: object;
+        errorShape: AugmentedErrorShape;
+        transformer: true;
+    }, TRPCDecorateCreateRouterOptions<{
+        declareKinds: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordsCapability.methods.declareKinds.input>;
+            output: z.infer<typeof recordsCapability.methods.declareKinds.output>;
+            meta: object;
+        }>;
+        get: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordsCapability.methods.get.input>;
+            output: z.infer<typeof recordsCapability.methods.get.output>;
+            meta: object;
+        }>;
+        getMany: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordsCapability.methods.getMany.input>;
+            output: z.infer<typeof recordsCapability.methods.getMany.output>;
+            meta: object;
+        }>;
+        secretRefs: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordsCapability.methods.secretRefs.input>;
+            output: z.infer<typeof recordsCapability.methods.secretRefs.output>;
+            meta: object;
+        }>;
+        put: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordsCapability.methods.put.input>;
+            output: z.infer<typeof recordsCapability.methods.put.output>;
+            meta: object;
+        }>;
+        putMany: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordsCapability.methods.putMany.input>;
+            output: z.infer<typeof recordsCapability.methods.putMany.output>;
+            meta: object;
+        }>;
+        patch: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordsCapability.methods.patch.input>;
+            output: z.infer<typeof recordsCapability.methods.patch.output>;
+            meta: object;
+        }>;
+        delete: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordsCapability.methods.delete.input>;
+            output: z.infer<typeof recordsCapability.methods.delete.output>;
+            meta: object;
+        }>;
+        deleteMany: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordsCapability.methods.deleteMany.input>;
+            output: z.infer<typeof recordsCapability.methods.deleteMany.output>;
+            meta: object;
+        }>;
+        query: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordsCapability.methods.query.input>;
+            output: z.infer<typeof recordsCapability.methods.query.output>;
+            meta: object;
+        }>;
+        count: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordsCapability.methods.count.input>;
+            output: z.infer<typeof recordsCapability.methods.count.output>;
+            meta: object;
+        }>;
+        histogram: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordsCapability.methods.histogram.input>;
+            output: z.infer<typeof recordsCapability.methods.histogram.output>;
+            meta: object;
+        }>;
+        aggregate: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordsCapability.methods.aggregate.input>;
+            output: z.infer<typeof recordsCapability.methods.aggregate.output>;
+            meta: object;
+        }>;
+        deleteWhere: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordsCapability.methods.deleteWhere.input>;
+            output: z.infer<typeof recordsCapability.methods.deleteWhere.output>;
+            meta: object;
+        }>;
+        deleteDevice: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordsCapability.methods.deleteDevice.input>;
+            output: z.infer<typeof recordsCapability.methods.deleteDevice.output>;
+            meta: object;
+        }>;
+        allocateId: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordsCapability.methods.allocateId.input>;
+            output: z.infer<typeof recordsCapability.methods.allocateId.output>;
+            meta: object;
+        }>;
+    }>>;
     sceneMonitor: TRPCBuiltRouter<{
         ctx: TrpcContext;
         meta: object;
@@ -8854,6 +9010,41 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof storageAdminCapability.methods.dropCollection.output>;
             meta: object;
         }>;
+        listKinds: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof storageAdminCapability.methods.listKinds.input>;
+            output: z.infer<typeof storageAdminCapability.methods.listKinds.output>;
+            meta: object;
+        }>;
+        readRecords: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof storageAdminCapability.methods.readRecords.input>;
+            output: z.infer<typeof storageAdminCapability.methods.readRecords.output>;
+            meta: object;
+        }>;
+        adoptRecords: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof storageAdminCapability.methods.adoptRecords.input>;
+            output: z.infer<typeof storageAdminCapability.methods.adoptRecords.output>;
+            meta: object;
+        }>;
+        readLegacyCollection: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof storageAdminCapability.methods.readLegacyCollection.input>;
+            output: z.infer<typeof storageAdminCapability.methods.readLegacyCollection.output>;
+            meta: object;
+        }>;
+        isAdoptedLegacyTable: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof storageAdminCapability.methods.isAdoptedLegacyTable.input>;
+            output: z.infer<typeof storageAdminCapability.methods.isAdoptedLegacyTable.output>;
+            meta: object;
+        }>;
     }>>;
     storageEvictable: TRPCBuiltRouter<{
         ctx: TrpcContext;

package/dist/generated/cap-input-defaults.d.ts

@@ -11,7 +11,7 @@
  * Plain data, zero Zod: a forked runner must not import the schema barrel
  * (~144MB RSS per runner — D28).
  *
- * Coverage: 27 caps, 69 methods with defaults.
+ * Coverage: 29 caps, 71 methods with defaults.
  */
 export declare const CAP_INPUT_DEFAULTS: Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, unknown>>>>>>;
 /**

package/dist/generated/capability-router-map.d.ts

@@ -126,11 +126,13 @@ export { privacyMaskCapability } from '../capabilities/privacy-mask.cap.js';
 export { ptzCapability } from '../capabilities/ptz.cap.js';
 export { ptzAutotrackCapability } from '../capabilities/ptz-autotrack.cap.js';
 export { rebootCapability } from '../capabilities/reboot.cap.js';
+export { recordEntriesCapability } from '../capabilities/record-entries.cap.js';
 export { recordingCapability } from '../capabilities/recording.cap.js';
 export { recordingArchiveCapability } from '../capabilities/recording-archive.cap.js';
 export { recordingExportCapability } from '../capabilities/recording-export.cap.js';
 export { recordingOnboardCapability } from '../capabilities/recording-onboard.cap.js';
 export { recordingSignalCapability } from '../capabilities/recording-signal.cap.js';
+export { recordsCapability } from '../capabilities/records.cap.js';
 export { sceneMonitorCapability } from '../capabilities/scene-monitor.cap.js';
 export { scriptRunnerCapability } from '../capabilities/script-runner.cap.js';
 export { serverManagementCapability } from '../capabilities/server-management.cap.js';
@@ -302,11 +304,13 @@ export declare const CAPABILITY_NAMES: {
     readonly ptz: 'ptz';
     readonly ptzAutotrack: 'ptz-autotrack';
     readonly reboot: 'reboot';
+    readonly recordEntries: 'record-entries';
     readonly recording: 'recording';
     readonly recordingArchive: 'recording-archive';
     readonly recordingExport: 'recording-export';
     readonly recordingOnboard: 'recording-onboard';
     readonly recordingSignal: 'recording-signal';
+    readonly records: 'records';
     readonly sceneMonitor: 'scene-monitor';
     readonly scriptRunner: 'script-runner';
     readonly serverManagement: 'server-management';
@@ -491,11 +495,13 @@ export interface CapabilityRouterMap<TRouter = unknown> {
     readonly ptz: TRouter;
     readonly ptzAutotrack: TRouter;
     readonly reboot: TRouter;
+    readonly recordEntries: TRouter;
     readonly recording: TRouter;
     readonly recordingArchive: TRouter;
     readonly recordingExport: TRouter;
     readonly recordingOnboard: TRouter;
     readonly recordingSignal: TRouter;
+    readonly records: TRouter;
     readonly sceneMonitor: TRouter;
     readonly scriptRunner: TRouter;
     readonly serverManagement: TRouter;
@@ -539,8 +545,8 @@ export interface CapabilityRouterMap<TRouter = unknown> {
     readonly zoneRules: TRouter;
     readonly zones: TRouter;
 }
-/** Capability names whose mode is `singleton` (141 caps). */
-export declare const SINGLETON_CAPABILITY_NAMES: readonly ['accessories', 'addon-pages', 'addon-settings', 'addon-widgets', 'addons', 'admin-ui', 'air-quality-sensor', 'alarm-panel', 'alerts', 'ambient-light-sensor', 'audio-analysis', 'audio-analyzer', 'audio-codec', 'audio-metrics', 'automation-control', 'backup', 'battery', 'binary', 'brightness', 'button', 'calendars', 'camera-credentials', 'camera-grid-layout', 'camera-pipeline-config', 'camera-streams', 'carbon-monoxide', 'climate-control', 'color', 'composer', 'connectivity', 'consumables', 'contact', 'control', 'core-blocks', 'cover', 'database-snapshot', 'day-night', 'decoder', 'detection-pipeline', 'device-admin-link', 'device-adoption', 'device-credentials', 'device-discovery', 'device-history', 'device-manager', 'device-ops', 'device-state', 'device-status', 'doorbell', 'enum-sensor', 'event-emitter', 'face-gallery', 'fan-control', 'feature-probe', 'filesystem-browse', 'flood', 'gas', 'humidifier', 'humidity-sensor', 'image', 'image-settings', 'integrations', 'intercom', 'keychain', 'keychain-admin', 'lawn-mower-control', 'llm-runtime', 'local-network', 'lock-control', 'media-player', 'metrics-provider', 'model-convert', 'model-distributor', 'motion', 'motion-detection', 'motion-trigger', 'motion-zones', 'native-object-detection', 'navigation', 'network-link', 'network-quality', 'node-certificates', 'nodes', 'notification-rules', 'notifier', 'numeric-sensor', 'oidc-connections', 'osd', 'osd-manager', 'pet-feeder', 'pipeline-analytics', 'pipeline-executor', 'pipeline-orchestrator', 'pipeline-runner', 'plate-gallery', 'platform-probe', 'power-meter', 'presence', 'pressure-sensor', 'privacy-mask', 'ptz', 'ptz-autotrack', 'reboot', 'recording-archive', 'recording-export', 'recording-onboard', 'recording-signal', 'scene-monitor', 'script-runner', 'server-management', 'settings-store', 'smoke', 'snapshot', 'sso-bridge', 'storage', 'storage-admin', 'storage-migration', 'stream-broker', 'stream-catalog', 'stream-params', 'stream-signals', 'switch', 'system', 'tamper', 'temperature-sensor', 'terminal-session', 'toast', 'training', 'update', 'user-management', 'vacuum-control', 'valve', 'vector-store', 'vibration', 'viewer-ui', 'water-heater', 'weather', 'webrtc-session', 'zone-analytics', 'zone-rules', 'zones'];
+/** Capability names whose mode is `singleton` (143 caps). */
+export declare const SINGLETON_CAPABILITY_NAMES: readonly ['accessories', 'addon-pages', 'addon-settings', 'addon-widgets', 'addons', 'admin-ui', 'air-quality-sensor', 'alarm-panel', 'alerts', 'ambient-light-sensor', 'audio-analysis', 'audio-analyzer', 'audio-codec', 'audio-metrics', 'automation-control', 'backup', 'battery', 'binary', 'brightness', 'button', 'calendars', 'camera-credentials', 'camera-grid-layout', 'camera-pipeline-config', 'camera-streams', 'carbon-monoxide', 'climate-control', 'color', 'composer', 'connectivity', 'consumables', 'contact', 'control', 'core-blocks', 'cover', 'database-snapshot', 'day-night', 'decoder', 'detection-pipeline', 'device-admin-link', 'device-adoption', 'device-credentials', 'device-discovery', 'device-history', 'device-manager', 'device-ops', 'device-state', 'device-status', 'doorbell', 'enum-sensor', 'event-emitter', 'face-gallery', 'fan-control', 'feature-probe', 'filesystem-browse', 'flood', 'gas', 'humidifier', 'humidity-sensor', 'image', 'image-settings', 'integrations', 'intercom', 'keychain', 'keychain-admin', 'lawn-mower-control', 'llm-runtime', 'local-network', 'lock-control', 'media-player', 'metrics-provider', 'model-convert', 'model-distributor', 'motion', 'motion-detection', 'motion-trigger', 'motion-zones', 'native-object-detection', 'navigation', 'network-link', 'network-quality', 'node-certificates', 'nodes', 'notification-rules', 'notifier', 'numeric-sensor', 'oidc-connections', 'osd', 'osd-manager', 'pet-feeder', 'pipeline-analytics', 'pipeline-executor', 'pipeline-orchestrator', 'pipeline-runner', 'plate-gallery', 'platform-probe', 'power-meter', 'presence', 'pressure-sensor', 'privacy-mask', 'ptz', 'ptz-autotrack', 'reboot', 'record-entries', 'recording-archive', 'recording-export', 'recording-onboard', 'recording-signal', 'records', 'scene-monitor', 'script-runner', 'server-management', 'settings-store', 'smoke', 'snapshot', 'sso-bridge', 'storage', 'storage-admin', 'storage-migration', 'stream-broker', 'stream-catalog', 'stream-params', 'stream-signals', 'switch', 'system', 'tamper', 'temperature-sensor', 'terminal-session', 'toast', 'training', 'update', 'user-management', 'vacuum-control', 'valve', 'vector-store', 'vibration', 'viewer-ui', 'water-heater', 'weather', 'webrtc-session', 'zone-analytics', 'zone-rules', 'zones'];
 /** Union of singleton capability names (literal string union). */
 export type SingletonCapabilityName = typeof SINGLETON_CAPABILITY_NAMES[number];
 /** Capability names whose mode is `collection` (34 caps). */

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: 1344 method paths across 175 capabilities.
+ * Coverage: 1369 method paths across 177 capabilities.
  */
 import type { CapabilityMethodAccess } from '../capabilities/capability-definition.js';
 export interface MethodAccessRecord {

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

@@ -6,8 +6,8 @@
  * system-scope cap that takes a deviceId was previously never device-filtered
  * — see the generator header).
  *
- * Coverage: 526 methods carry a device reference, of which
- * 171 are on SYSTEM-scope caps.
+ * Coverage: 534 methods carry a device reference, of which
+ * 179 are on SYSTEM-scope caps.
  *
  * Top-level fields, number arrays, and one-level arrays of objects carrying
  * a numeric device field (targets[].deviceId) are all mapped; the matcher