@camstack/types 1.1.8 → 1.1.9

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

@@ -112,10 +112,12 @@ export declare const ReleaseInputSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const ResyncInputSchema: z.ZodObject<{
     camDeviceId: z.ZodNumber;
+    resetToSource: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const ResyncResultSchema: z.ZodObject<{
     changed: z.ZodBoolean;
     rebuiltChildren: z.ZodNumber;
+    removedChildren: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export declare const deviceAdoptionCapability: {
     readonly name: "device-adoption";
@@ -192,9 +194,11 @@ export declare const deviceAdoptionCapability: {
         }, z.core.$strip>, z.ZodVoid, "mutation">;
         readonly resync: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             camDeviceId: z.ZodNumber;
+            resetToSource: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>, z.ZodObject<{
             changed: z.ZodBoolean;
             rebuiltChildren: z.ZodNumber;
+            removedChildren: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>, "mutation">;
     };
 };

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

@@ -107,6 +107,7 @@ export declare const DeviceMetaSchema: z.ZodObject<{
     addonId: z.ZodString;
     type: z.ZodString;
     name: z.ZodString;
+    userNamed: z.ZodOptional<z.ZodBoolean>;
     location: z.ZodNullable<z.ZodString>;
     disabled: z.ZodBoolean;
     parentDeviceId: z.ZodNullable<z.ZodNumber>;
@@ -231,6 +232,7 @@ export declare const deviceManagerCapability: {
             addonId: z.ZodString;
             type: z.ZodString;
             name: z.ZodString;
+            userNamed: z.ZodOptional<z.ZodBoolean>;
             location: z.ZodNullable<z.ZodString>;
             disabled: z.ZodBoolean;
             parentDeviceId: z.ZodNullable<z.ZodNumber>;
@@ -1135,9 +1137,11 @@ export declare const deviceManagerCapability: {
          */
         readonly adoptionResync: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             camDeviceId: z.ZodNumber;
+            resetToSource: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>, z.ZodObject<{
             changed: z.ZodBoolean;
             rebuiltChildren: z.ZodNumber;
+            removedChildren: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>, "mutation">;
         /**
          * Test a field value on an existing device (e.g. probe an RTSP URL).

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

@@ -236,7 +236,14 @@ export declare abstract class BaseDevice<T extends z.ZodObject<z.core.$ZodLooseS
      * is open (Reolink writes `hasPtz/hasIntercom`, Hikvision writes
      * `hasSupplementalLight/hasAlarmIo`, etc).
      *
-     * Default: no-op (driver had no probe to run).
+     * Default: nothing to probe → mark the device PROBED (set `lastProbedAt`) so
+     * the kernel treats it as ready immediately. A device that derives its shape
+     * from a spec (a container, or an accessory sensor) rather than from a
+     * hardware probe has no probe to "complete"; without stamping `lastProbedAt`
+     * it would look perpetually un-probed — logging "Initial probe did not
+     * complete" on every boot and spinning a pointless retry chain. Drivers that
+     * DO probe override this and write their own `feature-probe` slice (including
+     * `lastProbedAt`) once their probe actually succeeds.
      */
     onProbe(): Promise<void>;
     /**

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

@@ -140,6 +140,14 @@ export interface DeviceMeta {
     readonly addonId: string;
     readonly type: DeviceType;
     readonly name: string;
+    /** True once an operator has explicitly renamed this device via `setName`.
+     *  Drives the reconcile name-precedence: when set, a re-registration PRESERVES
+     *  the operator's name; when unset, the provider's fresh construction-time name
+     *  wins (so an improved auto-name propagates instead of being frozen forever).
+     *  Absent ⇒ treated as user-named (PRESERVE) for safety on legacy rows that
+     *  predate this flag, so an operator's manual rename is never reset. New
+     *  auto-derived children land with the flag unset and self-heal their names. */
+    readonly userNamed?: boolean;
     readonly location: string | null;
     readonly disabled: boolean;
     readonly parentDeviceId: number | null;

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

@@ -6201,10 +6201,12 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
             input: {
                 [x: string]: unknown;
                 camDeviceId: number;
+                resetToSource?: boolean | undefined;
             };
             output: {
                 changed: boolean;
                 rebuiltChildren: number;
+                removedChildren?: number | undefined;
             };
             meta: object;
         }>;
@@ -6461,6 +6463,7 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                 location: string | null;
                 disabled: boolean;
                 parentDeviceId: number | null;
+                userNamed?: boolean | undefined;
                 metadata?: Record<string, unknown> | null | undefined;
                 sourceInfo?: {
                     id: string;
@@ -7414,8 +7417,16 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
             meta: object;
         }>;
         adoptionResync: import("@trpc/server").TRPCMutationProcedure<{
-            input: any;
-            output: any;
+            input: {
+                [x: string]: unknown;
+                camDeviceId: number;
+                resetToSource?: boolean | undefined;
+            };
+            output: {
+                changed: boolean;
+                rebuiltChildren: number;
+                removedChildren?: number | undefined;
+            };
             meta: object;
         }>;
         testField: import("@trpc/server").TRPCMutationProcedure<{
@@ -19899,10 +19910,12 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
             input: {
                 [x: string]: unknown;
                 camDeviceId: number;
+                resetToSource?: boolean | undefined;
             };
             output: {
                 changed: boolean;
                 rebuiltChildren: number;
+                removedChildren?: number | undefined;
             };
             meta: object;
         }>;
@@ -20159,6 +20172,7 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                 location: string | null;
                 disabled: boolean;
                 parentDeviceId: number | null;
+                userNamed?: boolean | undefined;
                 metadata?: Record<string, unknown> | null | undefined;
                 sourceInfo?: {
                     id: string;
@@ -21112,8 +21126,16 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
             meta: object;
         }>;
         adoptionResync: import("@trpc/server").TRPCMutationProcedure<{
-            input: any;
-            output: any;
+            input: {
+                [x: string]: unknown;
+                camDeviceId: number;
+                resetToSource?: boolean | undefined;
+            };
+            output: {
+                changed: boolean;
+                rebuiltChildren: number;
+                removedChildren?: number | undefined;
+            };
             meta: object;
         }>;
         testField: import("@trpc/server").TRPCMutationProcedure<{

package/dist/index.js

@@ -9215,9 +9215,29 @@ var BaseDevice = class {
 	* is open (Reolink writes `hasPtz/hasIntercom`, Hikvision writes
 	* `hasSupplementalLight/hasAlarmIo`, etc).
 	*
-	* Default: no-op (driver had no probe to run).
+	* Default: nothing to probe → mark the device PROBED (set `lastProbedAt`) so
+	* the kernel treats it as ready immediately. A device that derives its shape
+	* from a spec (a container, or an accessory sensor) rather than from a
+	* hardware probe has no probe to "complete"; without stamping `lastProbedAt`
+	* it would look perpetually un-probed — logging "Initial probe did not
+	* complete" on every boot and spinning a pointless retry chain. Drivers that
+	* DO probe override this and write their own `feature-probe` slice (including
+	* `lastProbedAt`) once their probe actually succeeds.
 	*/
-	async onProbe() {}
+	async onProbe() {
+		const base = this.runtimeState.getCapState("feature-probe") ?? {
+			flags: {},
+			deviceType: null,
+			model: null,
+			channelCount: null,
+			lastProbedAt: 0,
+			lastFetchedAt: 0
+		};
+		this.runtimeState.setCapState("feature-probe", {
+			...base,
+			lastProbedAt: Date.now()
+		});
+	}
 	/**
 	* Phase 5 — fired after the device + its accessories are registered.
 	* Drivers publish streams to the broker, kick off background tasks,
@@ -12481,17 +12501,32 @@ var ReleaseInputSchema = zod.z.object({
 	*  the parent cascades into every accessory. */
 	camDeviceId: zod.z.number().int().nonnegative()
 });
-var ResyncInputSchema = zod.z.object({ 
-/** Parent CamStack device id of an adopted device. The provider resolves its
-*  source (integration/broker + native id) and re-aligns the device's
-*  structural spec (type/role/capabilities/units) with the live mapping,
-*  rebuilding any child whose class changed while preserving operator edits. */
-camDeviceId: zod.z.number().int().nonnegative() });
+var ResyncInputSchema = zod.z.object({
+	/** Parent CamStack device id of an adopted device. The provider resolves its
+	*  source (integration/broker + native id) and re-aligns the device's
+	*  structural spec (type/role/capabilities/units) with the live mapping,
+	*  rebuilding any child whose class changed while preserving operator edits. */
+	camDeviceId: zod.z.number().int().nonnegative(),
+	/** "Resync from zero" (#19). When true, the kernel PURGES every accessory
+	*  child of `camDeviceId` BEFORE the provider re-derives the device, so the
+	*  children are rebuilt fresh from source — correct names, coords, and units —
+	*  instead of being preserved by the incremental reconcile. Use to recover from
+	*  legacy generic/placeholder names that the normal name-precedence keeps frozen
+	*  (the operator's explicit reset). Push-driven integrations (no-op resync)
+	*  rebuild on their next snapshot; pull/command integrations rebuild in `resync`.
+	*  Operator edits on the PARENT (its name, layout, primary-child pick) survive —
+	*  only the children are torn down. Omitted/false ⇒ the normal incremental
+	*  re-sync that preserves children. */
+	resetToSource: zod.z.boolean().optional()
+});
 var ResyncResultSchema = zod.z.object({
 	/** True when the persisted spec actually changed (children may have been rebuilt). */
 	changed: zod.z.boolean(),
 	/** Number of child devices rebuilt into a new class by this re-sync. */
-	rebuiltChildren: zod.z.number().int().nonnegative()
+	rebuiltChildren: zod.z.number().int().nonnegative(),
+	/** Number of accessory children torn down by a `resetToSource` purge before the
+	*  provider re-derived the device. 0/absent for a normal incremental re-sync. */
+	removedChildren: zod.z.number().int().nonnegative().optional()
 });
 var deviceAdoptionCapability = {
 	name: "device-adoption",
@@ -14937,6 +14972,11 @@ var DeviceMetaSchema = zod.z.object({
 	addonId: zod.z.string(),
 	type: zod.z.string(),
 	name: zod.z.string(),
+	/** True once an operator explicitly renamed the device via `setName`. Drives
+	*  reconcile name-precedence (preserve operator name vs adopt fresh provider
+	*  name). Absent ⇒ treated as user-named (PRESERVE) for legacy rows. See
+	*  `DeviceMeta.userNamed`. */
+	userNamed: zod.z.boolean().optional(),
 	location: zod.z.string().nullable(),
 	disabled: zod.z.boolean(),
 	parentDeviceId: zod.z.number().nullable(),

package/dist/index.mjs

@@ -9214,9 +9214,29 @@ var BaseDevice = class {
 	* is open (Reolink writes `hasPtz/hasIntercom`, Hikvision writes
 	* `hasSupplementalLight/hasAlarmIo`, etc).
 	*
-	* Default: no-op (driver had no probe to run).
+	* Default: nothing to probe → mark the device PROBED (set `lastProbedAt`) so
+	* the kernel treats it as ready immediately. A device that derives its shape
+	* from a spec (a container, or an accessory sensor) rather than from a
+	* hardware probe has no probe to "complete"; without stamping `lastProbedAt`
+	* it would look perpetually un-probed — logging "Initial probe did not
+	* complete" on every boot and spinning a pointless retry chain. Drivers that
+	* DO probe override this and write their own `feature-probe` slice (including
+	* `lastProbedAt`) once their probe actually succeeds.
 	*/
-	async onProbe() {}
+	async onProbe() {
+		const base = this.runtimeState.getCapState("feature-probe") ?? {
+			flags: {},
+			deviceType: null,
+			model: null,
+			channelCount: null,
+			lastProbedAt: 0,
+			lastFetchedAt: 0
+		};
+		this.runtimeState.setCapState("feature-probe", {
+			...base,
+			lastProbedAt: Date.now()
+		});
+	}
 	/**
 	* Phase 5 — fired after the device + its accessories are registered.
 	* Drivers publish streams to the broker, kick off background tasks,
@@ -12480,17 +12500,32 @@ var ReleaseInputSchema = z.object({
 	*  the parent cascades into every accessory. */
 	camDeviceId: z.number().int().nonnegative()
 });
-var ResyncInputSchema = z.object({ 
-/** Parent CamStack device id of an adopted device. The provider resolves its
-*  source (integration/broker + native id) and re-aligns the device's
-*  structural spec (type/role/capabilities/units) with the live mapping,
-*  rebuilding any child whose class changed while preserving operator edits. */
-camDeviceId: z.number().int().nonnegative() });
+var ResyncInputSchema = z.object({
+	/** Parent CamStack device id of an adopted device. The provider resolves its
+	*  source (integration/broker + native id) and re-aligns the device's
+	*  structural spec (type/role/capabilities/units) with the live mapping,
+	*  rebuilding any child whose class changed while preserving operator edits. */
+	camDeviceId: z.number().int().nonnegative(),
+	/** "Resync from zero" (#19). When true, the kernel PURGES every accessory
+	*  child of `camDeviceId` BEFORE the provider re-derives the device, so the
+	*  children are rebuilt fresh from source — correct names, coords, and units —
+	*  instead of being preserved by the incremental reconcile. Use to recover from
+	*  legacy generic/placeholder names that the normal name-precedence keeps frozen
+	*  (the operator's explicit reset). Push-driven integrations (no-op resync)
+	*  rebuild on their next snapshot; pull/command integrations rebuild in `resync`.
+	*  Operator edits on the PARENT (its name, layout, primary-child pick) survive —
+	*  only the children are torn down. Omitted/false ⇒ the normal incremental
+	*  re-sync that preserves children. */
+	resetToSource: z.boolean().optional()
+});
 var ResyncResultSchema = z.object({
 	/** True when the persisted spec actually changed (children may have been rebuilt). */
 	changed: z.boolean(),
 	/** Number of child devices rebuilt into a new class by this re-sync. */
-	rebuiltChildren: z.number().int().nonnegative()
+	rebuiltChildren: z.number().int().nonnegative(),
+	/** Number of accessory children torn down by a `resetToSource` purge before the
+	*  provider re-derived the device. 0/absent for a normal incremental re-sync. */
+	removedChildren: z.number().int().nonnegative().optional()
 });
 var deviceAdoptionCapability = {
 	name: "device-adoption",
@@ -14936,6 +14971,11 @@ var DeviceMetaSchema = z.object({
 	addonId: z.string(),
 	type: z.string(),
 	name: z.string(),
+	/** True once an operator explicitly renamed the device via `setName`. Drives
+	*  reconcile name-precedence (preserve operator name vs adopt fresh provider
+	*  name). Absent ⇒ treated as user-named (PRESERVE) for legacy rows. See
+	*  `DeviceMeta.userNamed`. */
+	userNamed: z.boolean().optional(),
 	location: z.string().nullable(),
 	disabled: z.boolean(),
 	parentDeviceId: z.number().nullable(),

package/package.json

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