@camstack/types 1.1.20 → 1.1.22

package/dist/interfaces/addon.d.ts

@@ -262,8 +262,8 @@ export interface IKernelServices {
      * own probe because hwaccel is inherently hardware-bound: decoder
      * addons on an NVIDIA agent get `['cuda', 'nvdec']`, the same addon
      * on a Mac hub gets `['videotoolbox']`. Cross-node queries for the
-     * admin UI go via the `$hwaccel.resolve` Moleculer service
-     * registered on every node.
+     * admin UI go via the node-pinned `platform-probe` capability
+     * (`resolveHwAccel`), not a bespoke Moleculer service.
      */
     readonly hwaccel?: IKernelHwAccel;
     /**
@@ -437,6 +437,15 @@ export interface AddonContext<TConfig = Record<string, unknown>> {
          * and `global`-level values; they're disjoint by schema invariant so
          * they can share one physical store. No defaults merged in. Returns
          * an empty object if the addon has never written anything.
+         *
+         * @internal Low-level primitive — addons MUST NOT call this directly.
+         * Use the high-level, schema-driven, per-node-aware API instead:
+         * `this.getGlobalSettings()` / `this.updateGlobalSettings()`,
+         * `this.resolveGlobalStore()` (raw view for a `getGlobalSettings`
+         * override), or `this.state<T>()` (durable JSON blob). Enforced by the
+         * `no-raw-addon-store` biome guard over the addon source tree; the
+         * sanctioned `BaseAddon` wrappers (in `@camstack/types`) and the
+         * allowlisted engine-cascade holdouts are the only callers.
          */
         readAddonStore(): Promise<Record<string, unknown>>;
         /**
@@ -444,6 +453,10 @@ export interface AddonContext<TConfig = Record<string, unknown>> {
          * preserved. Keys explicitly set to `null` are preserved as-is (they
          * do NOT fall back to schema default on subsequent reads — that
          * layering happens only at `hydrateSchema` time).
+         *
+         * @internal Low-level primitive — addons MUST NOT call this directly.
+         * Use `this.updateGlobalSettings()` or `this.state<T>().set()`. Enforced
+         * by the `no-raw-addon-store` biome guard (see `readAddonStore`).
          */
         writeAddonStore(patch: Record<string, unknown>): Promise<void>;
         /**

package/dist/interfaces/agent.d.ts

@@ -152,3 +152,17 @@ export interface AgentListItem {
     /** Local IP addresses visible on the network */
     readonly localIps?: readonly string[];
 }
+/**
+ * Fan-out-free node liveness row for the `/health` surface, read from the
+ * hub's in-memory Moleculer node registry (`broker.registry.getNodeList`)
+ * — never a per-node RPC. `isOnline` is Moleculer's own availability
+ * verdict (`node.available`); a node that disconnected cleanly (or missed
+ * heartbeats) stays listed as offline until Moleculer purges it
+ * (~cleanOfflineNodesTimeout), which is what lets `/health` NAME the
+ * degraded node in `agents.offlineIds`.
+ */
+export interface NodeLiveness {
+    readonly id: string;
+    readonly isHub: boolean;
+    readonly isOnline: boolean;
+}

package/dist/interfaces/config-ui.d.ts

@@ -1,4 +1,4 @@
-import type { ModelCatalogEntry, ModelFormat, ModelOutputFormat, CustomModelMetadata } from '../types/models.js';
+import type { CustomModelMetadata, ModelCatalogEntry, ModelFormat, ModelOutputFormat } from '../types/models.js';
 /**
  * Configuration UI Schema -- declarative form definition for any element.
  *
@@ -111,6 +111,24 @@ export interface ConfigFieldBase {
      * `updateAddonSettings`.
      */
     readonly requiresRestart?: boolean;
+    /**
+     * Per-node store scoping. `perNode: true` ⇒ the field's persisted store
+     * key is physically `<key>@<nodeId>` — one value per cluster node — while
+     * the SCHEMA field key stays bare (the UI form never sees the scoped key).
+     * `BaseAddon.getGlobalSettings` / `updateGlobalSettings` / `resolveConfig`
+     * scope reads and writes through `addon/per-node-store.ts`; a node with no
+     * scoped key resolves to the field's schema `default` — NEVER another
+     * node's value (deliberately NO bare-key fallback).
+     *
+     * Absent/false (default) ⇒ node-agnostic shared blob — a single value for
+     * the whole cluster, today's behavior for the vast majority of fields.
+     *
+     * This is SCHEMA metadata (like `immediate` / `requiresRestart`), NOT
+     * capability metadata: it lives on the field only — never in a `*.cap.ts`
+     * definition or an addon manifest — so it is invisible to
+     * `check-capability-metadata-drift.ts`.
+     */
+    readonly perNode?: boolean;
     /**
      * Override the default placement of this field.
      * Moves it to a different tab and/or section than its parent section.

package/dist/interfaces/pipeline-executor-capability.d.ts

@@ -2,6 +2,7 @@ import type { PipelineEngineChoice, PipelineConfig } from '../types/pipeline.js'
 import type { PipelineSchema, PipelineDefaultStep, PipelineTemplateStep, PipelineTemplate } from '../types/pipeline-schema.js';
 import type { ModelFormat } from '../types/models.js';
 import type { FrameInput } from '../types/io.js';
+import type { FrameHandle } from './frame-handle.js';
 import type { FrameResult, DetectorOutput } from '../types/detection.js';
 import type { ConfigUISchema } from './config-ui.js';
 import type { InferenceCapabilities } from './inference-capabilities.js';
@@ -24,6 +25,9 @@ export interface PipelineStepInput {
 /**
  * Input for pipeline execution. Exactly one image source must be provided:
  *  - `frame`: runtime dispatch (pipeline-runner — decoded broker frame)
+ *  - `frameHandle` (CB5): a zero-pixel shm `FrameHandle` for the same
+ *    decoded frame — the hub-local executor maps the segment and reads the
+ *    pixels back zero-copy instead of paying the ~1.2MB UDS re-serialise.
  *  - `imageBase64`: one-shot benchmark (ImageTab "Run")
  *  - `referenceImage`: named file from the reference-image store
  *
@@ -36,6 +40,12 @@ export interface PipelineRunInput {
     readonly steps: readonly PipelineStepInput[];
     readonly engine?: PipelineEngineChoice;
     readonly frame?: FrameInput;
+    /**
+     * CB5 shm passthrough — names the ring slot the decoded pixels live in.
+     * A null read (recycled slot / foreign handle) degrades to an empty
+     * result; the runner ships `frame` as the fallback (queue-depth gated).
+     */
+    readonly frameHandle?: FrameHandle;
     readonly referenceImage?: string;
     readonly imageBase64?: string;
     /**

package/dist/{sleep-BabrCASa.js → sleep-B8cp-HUn.js}

@@ -907,6 +907,102 @@ function createDurableState(deps) {
 	};
 }
 //#endregion
+//#region src/addon/per-node-store.ts
+/**
+* Per-node scoping for the shared addon-settings blob.
+*
+* An addon's settings store is hub-central (the `addon-settings` cap is
+* hub-routed — the hub instance answers for every node), so fields whose
+* value is a NODE fact (decoder backend, engine pick, probed hardware
+* capabilities) persist under the node-scoped key `<key>@<nodeId>` inside
+* the single shared blob. The SCHEMA field key stays bare: the write path
+* ({@link scopePatch}) maps the bare field onto the target node's scoped
+* key; the read/hydrate path ({@link projectStore}) maps THIS node's value
+* back, so UI forms and `resolveConfig` only ever see the bare key.
+*
+* Fields opt in via the `perNode: true` schema marker on `ConfigFieldBase`
+* (`interfaces/config-ui.ts`); `BaseAddon` derives the key set from the
+* schema and routes reads/writes through these helpers.
+*
+* ## No bare-key fallback — deliberate
+*
+* {@link readNodeValue} reads the node-scoped key ONLY. A node with no
+* scoped key resolves to `undefined` so the field's schema `default` wins —
+* NEVER `store[base]` and never another node's value. A bare legacy key in
+* the store is invisible to every node, hub included, so one node's
+* selection can never leak onto another. (This generalizes the
+* `decoder-backend-keys.ts` semantics — the no-fallback variant — over an
+* arbitrary set of per-node field keys.)
+*
+* Pure functions only — no I/O, no imports beyond the language. This is a
+* LEAF module: import it via its deep path, never from the root barrel.
+*/
+/**
+* Normalize a raw kernel node id to the bare node id used for scoping.
+* `localNodeId` can carry a `<node>/<addon>` suffix on forked child
+* processes; per-node settings are per-NODE, so strip the addon segment.
+* `undefined` / `null` / empty falls back to `'hub'`.
+*/
+function normalizeNodeId(raw) {
+	if (raw === void 0 || raw === null || raw === "") return "hub";
+	const slashIdx = raw.indexOf("/");
+	if (slashIdx < 0) return raw;
+	const bare = raw.slice(0, slashIdx);
+	return bare === "" ? "hub" : bare;
+}
+/** The node-scoped store key for a per-node field: `<base>@<nodeId>`. */
+function nodeScopedKey(base, nodeId) {
+	return `${base}@${normalizeNodeId(nodeId)}`;
+}
+/**
+* Read a node's value for a per-node field from the raw shared store:
+* the node-scoped key when present, otherwise `undefined`.
+* Deliberately NO bare-key fallback (see module doc) — the caller lets the
+* schema `default` win on `undefined`.
+*/
+function readNodeValue(store, base, nodeId) {
+	return store[nodeScopedKey(base, nodeId)];
+}
+/**
+* Re-map a UI/settings patch so every bare perNode field persists under the
+* TARGET node's scoped key; all other keys pass through unchanged. Used on
+* the write path so a save for one node never clobbers another node's value
+* (and the bare key is never written). Returns a new object — the input
+* patch is not mutated.
+*/
+function scopePatch(patch, perNodeKeys, nodeId) {
+	const out = {};
+	for (const [key, value] of Object.entries(patch)) out[perNodeKeys.has(key) ? nodeScopedKey(key, nodeId) : key] = value;
+	return out;
+}
+/**
+* Project the raw shared store onto the bare schema keys for ONE node so a
+* UI schema (whose field keys are bare) hydrates from that node's own
+* values:
+*
+* - EVERY `@`-scoped key (any node's) is dropped from the pass-through.
+* - Every bare perNode key is dropped from the pass-through (a stray bare
+*   legacy key must never hydrate any node — no bare fallback).
+* - THIS node's effective value ({@link readNodeValue}) is then laid onto
+*   each bare perNode key; when the node has no scoped key the bare key is
+*   left ABSENT so the field's schema `default` wins.
+*
+* Returns a new object — the input store is not mutated.
+*/
+function projectStore(store, perNodeKeys, nodeId) {
+	const out = {};
+	for (const [key, value] of Object.entries(store)) {
+		if (key.includes("@")) continue;
+		if (perNodeKeys.has(key)) continue;
+		out[key] = value;
+	}
+	for (const base of perNodeKeys) {
+		const value = readNodeValue(store, base, nodeId);
+		if (value !== void 0) out[base] = value;
+	}
+	return out;
+}
+//#endregion
 //#region src/addon/base-addon.ts
 /**
 * Base class for CamStack addons. Eliminates settings boilerplate:
@@ -1076,23 +1172,63 @@ var BaseAddon = class {
 	deviceSettingsSchema() {
 		return null;
 	}
-	async getGlobalSettings(overlay, cap, _nodeId) {
+	async getGlobalSettings(overlay, cap, nodeId) {
 		const schema = this.globalSettingsSchema(cap);
 		if (!schema) return { sections: [] };
-		const raw = await this._ctx?.settings?.readAddonStore() ?? {};
+		const projected = await this.resolveGlobalStore(nodeId, cap);
 		return hydrateSchema(schema, overlay ? {
-			...raw,
+			...projected,
 			...overlay
-		} : raw);
+		} : projected);
 	}
-	async updateGlobalSettings(patch, _nodeId) {
-		await this._ctx?.settings?.writeAddonStore(patch);
+	/**
+	* The raw addon store PROJECTED onto the target node's bare per-node keys:
+	* every `perNode: true` field carries THAT node's scoped value on its bare
+	* key (absent scoped key ⇒ key absent, so the schema `default` wins — no
+	* bare fallback), all `@`-scoped and stray bare per-node keys are dropped.
+	* A no-op passthrough when the schema declares no `perNode` field.
+	*
+	* This is the sanctioned way for a `getGlobalSettings` OVERRIDE that needs
+	* the store for custom option logic (option narrowing, value snapping) to
+	* read it per-node — never `ctx.settings.readAddonStore()` directly.
+	* `nodeId` omitted ⇒ the local node (node-blind injection from ctx).
+	*/
+	async resolveGlobalStore(nodeId, cap) {
+		const raw = await this._ctx?.settings?.readAddonStore() ?? {};
+		const keys = this.perNodeKeys(cap);
+		const node = normalizeNodeId(nodeId ?? this._ctx?.kernel?.localNodeId);
+		return keys.size > 0 ? projectStore(raw, keys, node) : raw;
+	}
+	async updateGlobalSettings(patch, nodeId) {
+		const keys = this.perNodeKeys();
+		const localNode = normalizeNodeId(this._ctx?.kernel?.localNodeId);
+		const target = normalizeNodeId(nodeId ?? this._ctx?.kernel?.localNodeId);
+		const barePatch = patch;
+		const scoped = keys.size > 0 ? scopePatch(barePatch, keys, target) : barePatch;
+		await this._ctx?.settings?.writeAddonStore(scoped);
+		if (target !== localNode) return;
 		await this.resolveConfig();
 		await this.onConfigChanged();
 		this.emitLifecycle(EventCategory.AddonUpdated, { level: "global" });
 		this.maybeAutoRestart(patch, this.globalSettingsSchema());
 	}
 	/**
+	* The set of field keys the global settings schema declares `perNode: true`
+	* — derived once per `cap` argument and memoized (schemas are static
+	* declarations). Empty set ⇒ every per-node code path is bypassed and the
+	* settings API behaves exactly like the legacy node-agnostic one.
+	*/
+	_perNodeKeysCache = /* @__PURE__ */ new Map();
+	perNodeKeys(cap) {
+		const cacheKey = cap ?? "";
+		const cached = this._perNodeKeysCache.get(cacheKey);
+		if (cached) return cached;
+		const schema = this.globalSettingsSchema(cap);
+		const keys = new Set(schema ? schema.sections.flatMap((section) => collectPerNodeFieldKeys(section.fields)) : []);
+		this._perNodeKeysCache.set(cacheKey, keys);
+		return keys;
+	}
+	/**
 	* If any field in `patch` is marked `requiresRestart` in `schema`,
 	* schedule an addon restart for the next tick. Deferred via
 	* `setImmediate` so the tRPC mutation that triggered the write has
@@ -1245,12 +1381,19 @@ var BaseAddon = class {
 	* The merge is shallow: each key in `defaults` is checked against the store.
 	* Only keys present in defaults are read — the store can contain extra keys
 	* (e.g. from older versions) without polluting the typed config.
+	*
+	* Keys the global settings schema declares `perNode: true` resolve from
+	* THIS node's scoped key (`<key>@<localNode>`) via `readNodeValue` — never
+	* from the bare key — so a per-node field resolves to this node's own
+	* selection at boot (absent scoped key ⇒ the constructor default wins).
 	*/
 	async resolveConfig() {
 		const stored = await this.readAddonStoreWithRetry();
+		const perNode = this.perNodeKeys();
+		const localNode = normalizeNodeId(this._ctx?.kernel?.localNodeId);
 		const resolved = { ...this.defaults };
 		for (const key of Object.keys(this.defaults)) {
-			const storedValue = stored[key];
+			const storedValue = perNode.has(key) ? readNodeValue(stored, key, localNode) : stored[key];
 			if (storedValue !== void 0 && storedValue !== null) {
 				const defaultType = typeof this.defaults[key];
 				if (typeof storedValue === defaultType) resolved[key] = storedValue;
@@ -1334,6 +1477,27 @@ var BaseAddon = class {
 	}
 };
 /**
+* Collect the keys of every field marked `perNode: true`, recursing into
+* layout containers (`group` fields and `sub-tabs` tabs) the same way
+* `hydrateSchema` does. Valueless structural fields (separator/info/…)
+* don't declare `perNode` and are excluded by the `in` narrowing.
+*/
+function collectPerNodeFieldKeys(fields) {
+	const collected = [];
+	for (const field of fields) {
+		if (field.type === "group") {
+			collected.push(...collectPerNodeFieldKeys(field.fields));
+			continue;
+		}
+		if (field.type === "sub-tabs") {
+			for (const tab of field.tabs) collected.push(...collectPerNodeFieldKeys(tab.fields));
+			continue;
+		}
+		if ("perNode" in field && field.perNode === true) collected.push(field.key);
+	}
+	return collected;
+}
+/**
 * Normalize an `ICamstackAddon.initialize()` return value into the
 * `AddonInitResult` envelope. Arrays are wrapped into `{ providers }`;
 * envelopes pass through; void stays void.
@@ -2239,6 +2403,13 @@ var DeviceType = /* @__PURE__ */ function(DeviceType) {
 	/** Single still-image entity (HA `image.*`). Read-only display of an
 	*  `entity_picture` signed URL the browser loads directly. `image` cap. */
 	DeviceType["Image"] = "image";
+	/** Smart pet feeder — cloud-connected food dispenser with a bowl food
+	*  level, battery, desiccant life, feeding state and manual-feed /
+	*  call-pet / maintenance actions. Installed with the `pet-feeder` cap;
+	*  dual-hopper models (D4S/D4SH) expose per-hopper portions. Sources:
+	*  native PetKit (`nodepetkit` `FeederDevice`), reusable by other feeder
+	*  integrations sharing the same food/desiccant/hopper surface. */
+	DeviceType["PetFeeder"] = "pet-feeder";
 	return DeviceType;
 }({});
 var DeviceFeature = /* @__PURE__ */ function(DeviceFeature) {
@@ -2898,6 +3069,7 @@ function createDeviceProxy(api, binding, opts) {
 			nativeObjectDetection: createSliceHandle(stateSource, binding.deviceId, "native-object-detection"),
 			notifier: createSliceHandle(stateSource, binding.deviceId, "notifier"),
 			numericSensor: createSliceHandle(stateSource, binding.deviceId, "numeric-sensor"),
+			petFeeder: createSliceHandle(stateSource, binding.deviceId, "pet-feeder"),
 			powerMeter: createSliceHandle(stateSource, binding.deviceId, "power-meter"),
 			presence: createSliceHandle(stateSource, binding.deviceId, "presence"),
 			pressureSensor: createSliceHandle(stateSource, binding.deviceId, "pressure-sensor"),
@@ -3121,6 +3293,19 @@ function createDeviceProxy(api, binding, opts) {
 			setOverlay: (input) => dispatch("osd", "osd", "setOverlay", "mutation", input),
 			getStatus: (input) => dispatch("osd", "osd", "getStatus", "query", input)
 		},
+		petFeeder: {
+			feed: (input) => dispatch("pet-feeder", "petFeeder", "feed", "mutation", input),
+			cancelFeed: (input) => dispatch("pet-feeder", "petFeeder", "cancelFeed", "mutation", input),
+			resetDesiccant: (input) => dispatch("pet-feeder", "petFeeder", "resetDesiccant", "mutation", input),
+			markFoodReplenished: (input) => dispatch("pet-feeder", "petFeeder", "markFoodReplenished", "mutation", input),
+			callPet: (input) => dispatch("pet-feeder", "petFeeder", "callPet", "mutation", input),
+			playSound: (input) => dispatch("pet-feeder", "petFeeder", "playSound", "mutation", input),
+			setChildLock: (input) => dispatch("pet-feeder", "petFeeder", "setChildLock", "mutation", input),
+			setIndicatorLight: (input) => dispatch("pet-feeder", "petFeeder", "setIndicatorLight", "mutation", input),
+			setFeedSound: (input) => dispatch("pet-feeder", "petFeeder", "setFeedSound", "mutation", input),
+			setVolume: (input) => dispatch("pet-feeder", "petFeeder", "setVolume", "mutation", input),
+			getStatus: (input) => dispatch("pet-feeder", "petFeeder", "getStatus", "query", input)
+		},
 		pipelineAnalytics: {
 			getActiveTracks: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getActiveTracks", "query", input),
 			getTrack: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getTrack", "query", input),
@@ -3280,6 +3465,7 @@ function createDeviceProxy(api, binding, opts) {
 			setPrimaryChildEntityId: (input) => dispatchSystem("deviceManager", "setPrimaryChildEntityId", "mutation", input),
 			setChildLayout: (input) => dispatchSystem("deviceManager", "setChildLayout", "mutation", input),
 			setDeviceLinks: (input) => dispatchSystem("deviceManager", "setDeviceLinks", "mutation", input),
+			setDisplay: (input) => dispatchSystem("deviceManager", "setDisplay", "mutation", input),
 			getWireableFields: (input) => dispatchSystem("deviceManager", "getWireableFields", "query", input),
 			setRole: (input) => dispatchSystem("deviceManager", "setRole", "mutation", input),
 			applyInitialMeta: (input) => dispatchSystem("deviceManager", "applyInitialMeta", "mutation", input),

package/dist/{sleep-MHm--th-.mjs → sleep-BiDFW0E7.mjs}

@@ -907,6 +907,102 @@ function createDurableState(deps) {
 	};
 }
 //#endregion
+//#region src/addon/per-node-store.ts
+/**
+* Per-node scoping for the shared addon-settings blob.
+*
+* An addon's settings store is hub-central (the `addon-settings` cap is
+* hub-routed — the hub instance answers for every node), so fields whose
+* value is a NODE fact (decoder backend, engine pick, probed hardware
+* capabilities) persist under the node-scoped key `<key>@<nodeId>` inside
+* the single shared blob. The SCHEMA field key stays bare: the write path
+* ({@link scopePatch}) maps the bare field onto the target node's scoped
+* key; the read/hydrate path ({@link projectStore}) maps THIS node's value
+* back, so UI forms and `resolveConfig` only ever see the bare key.
+*
+* Fields opt in via the `perNode: true` schema marker on `ConfigFieldBase`
+* (`interfaces/config-ui.ts`); `BaseAddon` derives the key set from the
+* schema and routes reads/writes through these helpers.
+*
+* ## No bare-key fallback — deliberate
+*
+* {@link readNodeValue} reads the node-scoped key ONLY. A node with no
+* scoped key resolves to `undefined` so the field's schema `default` wins —
+* NEVER `store[base]` and never another node's value. A bare legacy key in
+* the store is invisible to every node, hub included, so one node's
+* selection can never leak onto another. (This generalizes the
+* `decoder-backend-keys.ts` semantics — the no-fallback variant — over an
+* arbitrary set of per-node field keys.)
+*
+* Pure functions only — no I/O, no imports beyond the language. This is a
+* LEAF module: import it via its deep path, never from the root barrel.
+*/
+/**
+* Normalize a raw kernel node id to the bare node id used for scoping.
+* `localNodeId` can carry a `<node>/<addon>` suffix on forked child
+* processes; per-node settings are per-NODE, so strip the addon segment.
+* `undefined` / `null` / empty falls back to `'hub'`.
+*/
+function normalizeNodeId(raw) {
+	if (raw === void 0 || raw === null || raw === "") return "hub";
+	const slashIdx = raw.indexOf("/");
+	if (slashIdx < 0) return raw;
+	const bare = raw.slice(0, slashIdx);
+	return bare === "" ? "hub" : bare;
+}
+/** The node-scoped store key for a per-node field: `<base>@<nodeId>`. */
+function nodeScopedKey(base, nodeId) {
+	return `${base}@${normalizeNodeId(nodeId)}`;
+}
+/**
+* Read a node's value for a per-node field from the raw shared store:
+* the node-scoped key when present, otherwise `undefined`.
+* Deliberately NO bare-key fallback (see module doc) — the caller lets the
+* schema `default` win on `undefined`.
+*/
+function readNodeValue(store, base, nodeId) {
+	return store[nodeScopedKey(base, nodeId)];
+}
+/**
+* Re-map a UI/settings patch so every bare perNode field persists under the
+* TARGET node's scoped key; all other keys pass through unchanged. Used on
+* the write path so a save for one node never clobbers another node's value
+* (and the bare key is never written). Returns a new object — the input
+* patch is not mutated.
+*/
+function scopePatch(patch, perNodeKeys, nodeId) {
+	const out = {};
+	for (const [key, value] of Object.entries(patch)) out[perNodeKeys.has(key) ? nodeScopedKey(key, nodeId) : key] = value;
+	return out;
+}
+/**
+* Project the raw shared store onto the bare schema keys for ONE node so a
+* UI schema (whose field keys are bare) hydrates from that node's own
+* values:
+*
+* - EVERY `@`-scoped key (any node's) is dropped from the pass-through.
+* - Every bare perNode key is dropped from the pass-through (a stray bare
+*   legacy key must never hydrate any node — no bare fallback).
+* - THIS node's effective value ({@link readNodeValue}) is then laid onto
+*   each bare perNode key; when the node has no scoped key the bare key is
+*   left ABSENT so the field's schema `default` wins.
+*
+* Returns a new object — the input store is not mutated.
+*/
+function projectStore(store, perNodeKeys, nodeId) {
+	const out = {};
+	for (const [key, value] of Object.entries(store)) {
+		if (key.includes("@")) continue;
+		if (perNodeKeys.has(key)) continue;
+		out[key] = value;
+	}
+	for (const base of perNodeKeys) {
+		const value = readNodeValue(store, base, nodeId);
+		if (value !== void 0) out[base] = value;
+	}
+	return out;
+}
+//#endregion
 //#region src/addon/base-addon.ts
 /**
 * Base class for CamStack addons. Eliminates settings boilerplate:
@@ -1076,23 +1172,63 @@ var BaseAddon = class {
 	deviceSettingsSchema() {
 		return null;
 	}
-	async getGlobalSettings(overlay, cap, _nodeId) {
+	async getGlobalSettings(overlay, cap, nodeId) {
 		const schema = this.globalSettingsSchema(cap);
 		if (!schema) return { sections: [] };
-		const raw = await this._ctx?.settings?.readAddonStore() ?? {};
+		const projected = await this.resolveGlobalStore(nodeId, cap);
 		return hydrateSchema(schema, overlay ? {
-			...raw,
+			...projected,
 			...overlay
-		} : raw);
+		} : projected);
 	}
-	async updateGlobalSettings(patch, _nodeId) {
-		await this._ctx?.settings?.writeAddonStore(patch);
+	/**
+	* The raw addon store PROJECTED onto the target node's bare per-node keys:
+	* every `perNode: true` field carries THAT node's scoped value on its bare
+	* key (absent scoped key ⇒ key absent, so the schema `default` wins — no
+	* bare fallback), all `@`-scoped and stray bare per-node keys are dropped.
+	* A no-op passthrough when the schema declares no `perNode` field.
+	*
+	* This is the sanctioned way for a `getGlobalSettings` OVERRIDE that needs
+	* the store for custom option logic (option narrowing, value snapping) to
+	* read it per-node — never `ctx.settings.readAddonStore()` directly.
+	* `nodeId` omitted ⇒ the local node (node-blind injection from ctx).
+	*/
+	async resolveGlobalStore(nodeId, cap) {
+		const raw = await this._ctx?.settings?.readAddonStore() ?? {};
+		const keys = this.perNodeKeys(cap);
+		const node = normalizeNodeId(nodeId ?? this._ctx?.kernel?.localNodeId);
+		return keys.size > 0 ? projectStore(raw, keys, node) : raw;
+	}
+	async updateGlobalSettings(patch, nodeId) {
+		const keys = this.perNodeKeys();
+		const localNode = normalizeNodeId(this._ctx?.kernel?.localNodeId);
+		const target = normalizeNodeId(nodeId ?? this._ctx?.kernel?.localNodeId);
+		const barePatch = patch;
+		const scoped = keys.size > 0 ? scopePatch(barePatch, keys, target) : barePatch;
+		await this._ctx?.settings?.writeAddonStore(scoped);
+		if (target !== localNode) return;
 		await this.resolveConfig();
 		await this.onConfigChanged();
 		this.emitLifecycle(EventCategory.AddonUpdated, { level: "global" });
 		this.maybeAutoRestart(patch, this.globalSettingsSchema());
 	}
 	/**
+	* The set of field keys the global settings schema declares `perNode: true`
+	* — derived once per `cap` argument and memoized (schemas are static
+	* declarations). Empty set ⇒ every per-node code path is bypassed and the
+	* settings API behaves exactly like the legacy node-agnostic one.
+	*/
+	_perNodeKeysCache = /* @__PURE__ */ new Map();
+	perNodeKeys(cap) {
+		const cacheKey = cap ?? "";
+		const cached = this._perNodeKeysCache.get(cacheKey);
+		if (cached) return cached;
+		const schema = this.globalSettingsSchema(cap);
+		const keys = new Set(schema ? schema.sections.flatMap((section) => collectPerNodeFieldKeys(section.fields)) : []);
+		this._perNodeKeysCache.set(cacheKey, keys);
+		return keys;
+	}
+	/**
 	* If any field in `patch` is marked `requiresRestart` in `schema`,
 	* schedule an addon restart for the next tick. Deferred via
 	* `setImmediate` so the tRPC mutation that triggered the write has
@@ -1245,12 +1381,19 @@ var BaseAddon = class {
 	* The merge is shallow: each key in `defaults` is checked against the store.
 	* Only keys present in defaults are read — the store can contain extra keys
 	* (e.g. from older versions) without polluting the typed config.
+	*
+	* Keys the global settings schema declares `perNode: true` resolve from
+	* THIS node's scoped key (`<key>@<localNode>`) via `readNodeValue` — never
+	* from the bare key — so a per-node field resolves to this node's own
+	* selection at boot (absent scoped key ⇒ the constructor default wins).
 	*/
 	async resolveConfig() {
 		const stored = await this.readAddonStoreWithRetry();
+		const perNode = this.perNodeKeys();
+		const localNode = normalizeNodeId(this._ctx?.kernel?.localNodeId);
 		const resolved = { ...this.defaults };
 		for (const key of Object.keys(this.defaults)) {
-			const storedValue = stored[key];
+			const storedValue = perNode.has(key) ? readNodeValue(stored, key, localNode) : stored[key];
 			if (storedValue !== void 0 && storedValue !== null) {
 				const defaultType = typeof this.defaults[key];
 				if (typeof storedValue === defaultType) resolved[key] = storedValue;
@@ -1334,6 +1477,27 @@ var BaseAddon = class {
 	}
 };
 /**
+* Collect the keys of every field marked `perNode: true`, recursing into
+* layout containers (`group` fields and `sub-tabs` tabs) the same way
+* `hydrateSchema` does. Valueless structural fields (separator/info/…)
+* don't declare `perNode` and are excluded by the `in` narrowing.
+*/
+function collectPerNodeFieldKeys(fields) {
+	const collected = [];
+	for (const field of fields) {
+		if (field.type === "group") {
+			collected.push(...collectPerNodeFieldKeys(field.fields));
+			continue;
+		}
+		if (field.type === "sub-tabs") {
+			for (const tab of field.tabs) collected.push(...collectPerNodeFieldKeys(tab.fields));
+			continue;
+		}
+		if ("perNode" in field && field.perNode === true) collected.push(field.key);
+	}
+	return collected;
+}
+/**
 * Normalize an `ICamstackAddon.initialize()` return value into the
 * `AddonInitResult` envelope. Arrays are wrapped into `{ providers }`;
 * envelopes pass through; void stays void.
@@ -2239,6 +2403,13 @@ var DeviceType = /* @__PURE__ */ function(DeviceType) {
 	/** Single still-image entity (HA `image.*`). Read-only display of an
 	*  `entity_picture` signed URL the browser loads directly. `image` cap. */
 	DeviceType["Image"] = "image";
+	/** Smart pet feeder — cloud-connected food dispenser with a bowl food
+	*  level, battery, desiccant life, feeding state and manual-feed /
+	*  call-pet / maintenance actions. Installed with the `pet-feeder` cap;
+	*  dual-hopper models (D4S/D4SH) expose per-hopper portions. Sources:
+	*  native PetKit (`nodepetkit` `FeederDevice`), reusable by other feeder
+	*  integrations sharing the same food/desiccant/hopper surface. */
+	DeviceType["PetFeeder"] = "pet-feeder";
 	return DeviceType;
 }({});
 var DeviceFeature = /* @__PURE__ */ function(DeviceFeature) {
@@ -2898,6 +3069,7 @@ function createDeviceProxy(api, binding, opts) {
 			nativeObjectDetection: createSliceHandle(stateSource, binding.deviceId, "native-object-detection"),
 			notifier: createSliceHandle(stateSource, binding.deviceId, "notifier"),
 			numericSensor: createSliceHandle(stateSource, binding.deviceId, "numeric-sensor"),
+			petFeeder: createSliceHandle(stateSource, binding.deviceId, "pet-feeder"),
 			powerMeter: createSliceHandle(stateSource, binding.deviceId, "power-meter"),
 			presence: createSliceHandle(stateSource, binding.deviceId, "presence"),
 			pressureSensor: createSliceHandle(stateSource, binding.deviceId, "pressure-sensor"),
@@ -3121,6 +3293,19 @@ function createDeviceProxy(api, binding, opts) {
 			setOverlay: (input) => dispatch("osd", "osd", "setOverlay", "mutation", input),
 			getStatus: (input) => dispatch("osd", "osd", "getStatus", "query", input)
 		},
+		petFeeder: {
+			feed: (input) => dispatch("pet-feeder", "petFeeder", "feed", "mutation", input),
+			cancelFeed: (input) => dispatch("pet-feeder", "petFeeder", "cancelFeed", "mutation", input),
+			resetDesiccant: (input) => dispatch("pet-feeder", "petFeeder", "resetDesiccant", "mutation", input),
+			markFoodReplenished: (input) => dispatch("pet-feeder", "petFeeder", "markFoodReplenished", "mutation", input),
+			callPet: (input) => dispatch("pet-feeder", "petFeeder", "callPet", "mutation", input),
+			playSound: (input) => dispatch("pet-feeder", "petFeeder", "playSound", "mutation", input),
+			setChildLock: (input) => dispatch("pet-feeder", "petFeeder", "setChildLock", "mutation", input),
+			setIndicatorLight: (input) => dispatch("pet-feeder", "petFeeder", "setIndicatorLight", "mutation", input),
+			setFeedSound: (input) => dispatch("pet-feeder", "petFeeder", "setFeedSound", "mutation", input),
+			setVolume: (input) => dispatch("pet-feeder", "petFeeder", "setVolume", "mutation", input),
+			getStatus: (input) => dispatch("pet-feeder", "petFeeder", "getStatus", "query", input)
+		},
 		pipelineAnalytics: {
 			getActiveTracks: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getActiveTracks", "query", input),
 			getTrack: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getTrack", "query", input),
@@ -3280,6 +3465,7 @@ function createDeviceProxy(api, binding, opts) {
 			setPrimaryChildEntityId: (input) => dispatchSystem("deviceManager", "setPrimaryChildEntityId", "mutation", input),
 			setChildLayout: (input) => dispatchSystem("deviceManager", "setChildLayout", "mutation", input),
 			setDeviceLinks: (input) => dispatchSystem("deviceManager", "setDeviceLinks", "mutation", input),
+			setDisplay: (input) => dispatchSystem("deviceManager", "setDisplay", "mutation", input),
 			getWireableFields: (input) => dispatchSystem("deviceManager", "getWireableFields", "query", input),
 			setRole: (input) => dispatchSystem("deviceManager", "setRole", "mutation", input),
 			applyInitialMeta: (input) => dispatchSystem("deviceManager", "applyInitialMeta", "mutation", input),