@camstack/types 1.2.46 → 1.2.47

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

@@ -95,82 +95,6 @@ export interface ChildLayoutEntry {
     readonly collapsed?: boolean;
 }
 export type ChildLayout = readonly ChildLayoutEntry[];
-/** Field source: copy one field of a sibling accessory's cap status.
- *  Addressed by the source's re-sync-stable accessory `stableIdSuffix`
- *  (`sourceKey`) — NOT a raw numeric id — so the link survives a re-sync. The
- *  source must be a sibling accessory under the SAME parent container as the
- *  target device; resolution is `${parentStableId}-${sourceKey}`. For a source
- *  anywhere else in the cluster use `DeviceLinkGlobalSource`. */
-export interface DeviceLinkFieldSource {
-    readonly kind?: 'field';
-    readonly sourceKey: string;
-    readonly cap: string;
-    readonly fieldPath: string;
-}
-/** Literal source: a per-device constant (e.g. `battery.binary = true`,
- *  a consumable item's `label`/`resettable`). No sibling is read. */
-export interface DeviceLinkLiteralSource {
-    readonly kind: 'literal';
-    readonly value: string | number | boolean | null;
-}
-/** Global source (P2e): copy one field of ANY device's cap status, regardless
- *  of parent container. Addressed by the source device's FULL `stableId` —
- *  chosen over the numeric id because a re-sync (`resetToSource`) REALLOCATES
- *  numeric ids while stableIds are deterministic from the provider (the same
- *  property the sibling `sourceKey` mechanism relies on). stableId uniqueness
- *  is formally per-addon; the resolver matches the first meta row with that
- *  stableId (effective global uniqueness — an `addonId` disambiguator can be
- *  added later without a wire break). */
-export interface DeviceLinkGlobalSource {
-    readonly kind: 'global';
-    readonly sourceStableId: string;
-    readonly cap: string;
-    readonly fieldPath: string;
-}
-/** The source kinds a single expression BINDING may use — a sibling FIELD, a
- *  per-device LITERAL, or a GLOBAL device field. Never another expression:
- *  bindings do not nest, so an expression cannot reference another expression. */
-export type DeviceLinkExpressionBinding = DeviceLinkFieldSource | DeviceLinkLiteralSource | DeviceLinkGlobalSource;
-/** Expression source (Stage X): compute the target field from N named source
- *  bindings via a safe, non-Turing-complete infix expression (see
- *  `packages/types/src/expression/`). Each binding resolves to an
- *  `ExpressionValue` and is exposed to the expression under its record key.
- *  `now` (epoch ms) is auto-injected and is a reserved binding name. The
- *  evaluated result flows through `transform` exactly like a scalar source. */
-export interface DeviceLinkExpressionSource {
-    readonly kind: 'expression';
-    readonly expr: string;
-    readonly bindings: Readonly<Record<string, DeviceLinkExpressionBinding>>;
-}
-export type DeviceLinkSource = DeviceLinkFieldSource | DeviceLinkLiteralSource | DeviceLinkGlobalSource | DeviceLinkExpressionSource;
-/** The target field a link writes: a dot-path into the target cap's status. */
-export interface DeviceLinkTarget {
-    readonly cap: string;
-    readonly fieldPath: string;
-    /** Optional grouping key for array-of-items target caps (consumables); P2. */
-    readonly itemKey?: string;
-}
-/** Optional value transform applied to the resolved source value. */
-export type DeviceLinkTransform = {
-    readonly kind: 'identity';
-} | {
-    readonly kind: 'enum-map';
-    readonly mapping: Record<string, string | number | boolean>;
-    readonly fallback?: string | number | boolean;
-} | {
-    readonly kind: 'linear';
-    readonly scale: number;
-    readonly offset: number;
-    readonly clamp?: readonly [number, number];
-};
-/** One operator-authored cross-device field wiring, persisted on the TARGET. */
-export interface DeviceLink {
-    readonly id: string;
-    readonly source: DeviceLinkSource;
-    readonly target: DeviceLinkTarget;
-    readonly transform?: DeviceLinkTransform;
-}
-export type DeviceLinks = readonly DeviceLink[];
 /** Per-cap display refinement inside a `DeviceDisplayOverride` — unit/precision
  *  only (icon/label/hidden are device-level). Keyed by cap name for devices
  *  carrying several numeric caps (e.g. power-meter). */
@@ -254,12 +178,8 @@ export interface DeviceMeta {
      *  same lifecycle as `primaryChildEntityId`. Absent ⇒ no layout declared (all
      *  children render in the plain Overview list). */
     readonly childLayout?: ChildLayout;
-    /** Operator-authored cross-device field wirings (source field → this device's
-     *  cap field). Same create/persist/project/restore lifecycle as `childLayout`.
-     *  Absent ⇒ no links. Overlaid onto the target cap's `getStatus` at read time. */
-    readonly deviceLinks?: DeviceLinks;
     /** Operator-authored per-device display override (icon/label/unit/precision/
-     *  hidden). Same create/persist/project/restore lifecycle as `deviceLinks`.
+     *  hidden). Same create/persist/project/restore lifecycle as `childLayout`.
      *  Absent ⇒ no override; the renderer falls back to role default → live slice
      *  → canonical unit. Applied at RENDER time only — storage stays in source
      *  units. */
@@ -292,8 +212,6 @@ export interface InitialDeviceMeta {
      *  across re-register/restore. Optional: only set for CONTAINER devices that
      *  declare a layout. */
     readonly childLayout?: ChildLayout;
-    /** Cross-device field wirings set at create. Mirrors `DeviceMeta.deviceLinks`. */
-    readonly deviceLinks?: DeviceLinks;
     /** Per-device display override set at create. Mirrors `DeviceMeta.display`. */
     readonly display?: DeviceDisplayOverride;
 }

package/dist/device/index.d.ts

@@ -1,25 +1,26 @@
-export { DeviceType, DeviceFeature, ChargingStatus, DeviceRole } from './device-type.js';
-export { AccessoryKind, ACCESSORY_LABEL, accessoryStableId, type AccessoryKindValue, } from './accessory.js';
-export type { IBatteryOperated, IRebootable, INativeSnapshot, IDoorbellButton, ITwoWayAudio, IPanTiltZoom, } from './features.js';
-export { DeviceConfig } from './device-config.js';
-export type { DeviceContext, DeviceManagerApi, DeviceConstructor, IDeviceRegistryReader, IDeviceRegistry, } from './device-context.js';
-export { BaseDevice } from './base-device.js';
+export { ACCESSORY_LABEL, AccessoryKind, type AccessoryKindValue, accessoryStableId, } from './accessory.js';
 export type { AccessoryChildSpec } from './base-device.js';
+export { BaseDevice } from './base-device.js';
+export type { DeviceSummary, DiscoveryCandidate, FieldProbeResult, ProviderStatus, } from './base-device-provider.js';
 export { BaseDeviceProvider, toDeviceSummary } from './base-device-provider.js';
-export type { DiscoveryCandidate, DeviceSummary, ProviderStatus, FieldProbeResult, } from './base-device-provider.js';
-export type { IDevice } from './device.js';
-export { DEVICE_PROFILES, BATTERY_DEVICE_PROFILE, deviceMatchesProfile, resolveDeviceProfile, } from './device-profile.js';
-export type { DeviceProfile, DeviceProfileMatch, DeviceProfileDefaults, PipelinePhaseMode, } from './device-profile.js';
 export type { ICameraDevice, StreamSourceEntry } from './camera-device.js';
-export type { DeviceManualCreation, DeviceDiscovery, DiscoveredDevice, SavedDevice, DeviceMeta, InitialDeviceMeta, CreateDeviceSpec, ChildLayout, ChildLayoutEntry, DeviceLinkFieldSource, DeviceLinkLiteralSource, DeviceLinkGlobalSource, DeviceLinkExpressionBinding, DeviceLinkExpressionSource, DeviceLinkSource, DeviceLinkTarget, DeviceLinkTransform, DeviceLink, DeviceLinks, } from './device-management.js';
-export { zodEntriesToConfigUI } from './zod-to-config-ui.js';
-export type { DeviceConfigEntry } from './zod-to-config-ui.js';
-export { createRuntimeStateBridge } from './runtime-state-helpers.js';
-export type { RuntimeStateBridge } from './runtime-state-helpers.js';
+export type { DeclarationPlacement, DeclaredDeviceOutcome, DeclaredDevicePorts, DeclaredDeviceRow, DeclaredDevicesResult, DeclaredDevicesSpec, DeclaredIntegrationRow, DeviceDeclaration, } from './declared-device.js';
+export { DECLARED_DEVICE_SWEEP_LIMIT, DECLARED_INTEGRATION_FIXED_KEY, DeclaredDevices, declarationOwnerNodeId, } from './declared-device.js';
+export type { IDevice } from './device.js';
+export { DeviceConfig } from './device-config.js';
+export type { DeviceConstructor, DeviceContext, DeviceManagerApi, IDeviceRegistry, IDeviceRegistryReader, } from './device-context.js';
+export type { ChildLayout, ChildLayoutEntry, CreateDeviceSpec, DeviceDiscovery, DeviceManualCreation, DeviceMeta, DiscoveredDevice, InitialDeviceMeta, SavedDevice, } from './device-management.js';
+export type { DeviceProfile, DeviceProfileDefaults, DeviceProfileMatch, PipelinePhaseMode, } from './device-profile.js';
+export { BATTERY_DEVICE_PROFILE, DEVICE_PROFILES, deviceMatchesProfile, resolveDeviceProfile, } from './device-profile.js';
 export type { IDeviceRuntimeState, Snapshot as RuntimeStateSnapshot, } from './device-runtime-state.js';
+export { ChargingStatus, DeviceFeature, DeviceRole, DeviceType } from './device-type.js';
+export type { IBatteryOperated, IDoorbellButton, INativeSnapshot, IPanTiltZoom, IRebootable, ITwoWayAudio, } from './features.js';
 export { getByPath, setByPath } from './path-util.js';
-export { applyTransform } from './device-link-transform.js';
-export { enumerateItemArrayFields, enumerateSchemaFields } from './schema-fields.js';
+export type { ReachabilityPollHandle, ReachabilityPollLogger, ReachabilityPollOptions, } from './reachability-poll.js';
+export { REACHABILITY_FAILURES_TO_OFFLINE, REACHABILITY_POLL_INTERVAL_MS, REACHABILITY_PROBE_TIMEOUT_MS, startReachabilityPoll, } from './reachability-poll.js';
+export type { RuntimeStateBridge } from './runtime-state-helpers.js';
+export { createRuntimeStateBridge } from './runtime-state-helpers.js';
 export type { WireableField } from './schema-fields.js';
-export { startReachabilityPoll, REACHABILITY_POLL_INTERVAL_MS, REACHABILITY_FAILURES_TO_OFFLINE, REACHABILITY_PROBE_TIMEOUT_MS, } from './reachability-poll.js';
-export type { ReachabilityPollOptions, ReachabilityPollHandle, ReachabilityPollLogger, } from './reachability-poll.js';
+export { enumerateItemArrayFields, enumerateSchemaFields } from './schema-fields.js';
+export type { DeviceConfigEntry } from './zod-to-config-ui.js';
+export { zodEntriesToConfigUI } from './zod-to-config-ui.js';

package/dist/expression/binding-source.d.ts

@@ -0,0 +1,85 @@
+/**
+ * What an expression's named bindings READ from.
+ *
+ * Salvaged verbatim from the deleted device-link mechanism. Wiring's source
+ * kinds were the one part of it worth keeping: addressing a device field by
+ * re-sync-stable `stableId`, a per-device constant, and a sibling-accessory
+ * read are the vocabulary any cross-device derivation needs, and they were
+ * already correct. What wiring got wrong was the DESTINATION — a field on
+ * somebody else's device, with no identity — not the source.
+ *
+ * These shapes are therefore kept, re-homed next to the engine that consumes
+ * them, and are the binding type of a composition recipe (the source picker
+ * stays `deviceManager.getWireableFields`). They deliberately do NOT nest: a
+ * binding is a read, never another expression.
+ *
+ * Schemas are authoritative; every type is `z.infer` of one, so a wire shape and
+ * a TypeScript shape cannot drift apart (`scripts/check-schema-type-twins.ts`).
+ */
+import { z } from 'zod';
+/** Read a sibling accessory's status field, addressed by the sibling's key.
+ *  `kind` is optional for wire compatibility — absent means `'field'`. */
+export declare const ExpressionFieldBindingSchema: z.ZodObject<{
+    kind: z.ZodOptional<z.ZodLiteral<"field">>;
+    sourceKey: z.ZodString;
+    cap: z.ZodString;
+    fieldPath: z.ZodString;
+}, z.core.$strip>;
+/** A constant. No device is read. */
+export declare const ExpressionLiteralBindingSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"literal">;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strip>;
+/** Read ANY device's status field, addressed by its re-sync-stable `stableId` —
+ *  never by numeric id, which a re-adoption reissues. */
+export declare const ExpressionGlobalBindingSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"global">;
+    sourceStableId: z.ZodString;
+    cap: z.ZodString;
+    fieldPath: z.ZodString;
+}, z.core.$strip>;
+export declare const ExpressionBindingSourceSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodOptional<z.ZodLiteral<"field">>;
+    sourceKey: z.ZodString;
+    cap: z.ZodString;
+    fieldPath: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"literal">;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"global">;
+    sourceStableId: z.ZodString;
+    cap: z.ZodString;
+    fieldPath: z.ZodString;
+}, z.core.$strip>]>;
+/**
+ * An expression plus the bindings its free identifiers resolve against.
+ *
+ * The `superRefine` runs the SAME author-time validation as
+ * `validateExpressionSource` — compiles the expression, checks binding names,
+ * checks identifier coverage — so every boundary that parses one
+ * validates-at-write rather than discovering the problem at read time.
+ * Compiles are LRU-cached, so repeated validation of the same string is a hit.
+ */
+export declare const ExpressionSourceSchema: z.ZodObject<{
+    expr: z.ZodString;
+    bindings: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodOptional<z.ZodLiteral<"field">>;
+        sourceKey: z.ZodString;
+        cap: z.ZodString;
+        fieldPath: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"literal">;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"global">;
+        sourceStableId: z.ZodString;
+        cap: z.ZodString;
+        fieldPath: z.ZodString;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>;
+export type ExpressionFieldBinding = z.infer<typeof ExpressionFieldBindingSchema>;
+export type ExpressionLiteralBinding = z.infer<typeof ExpressionLiteralBindingSchema>;
+export type ExpressionGlobalBinding = z.infer<typeof ExpressionGlobalBindingSchema>;
+export type ExpressionBindingSource = z.infer<typeof ExpressionBindingSourceSchema>;
+export type ExpressionSource = z.infer<typeof ExpressionSourceSchema>;

package/dist/expression/{link-expression.d.ts → expression-source.d.ts}

@@ -1,5 +1,15 @@
-import { type ExpressionEvalOptions } from './evaluator.js';
+/**
+ * Expression-source helpers — the single seam every consumer of the engine
+ * shares, so author-time validation and read-time evaluation cannot drift.
+ *
+ * These were written for the `expression` device-link source and outlived it:
+ * wiring was deleted on 2026-08-08 with zero live users, and the engine was
+ * kept on purpose. It is the derivation language of a composed device and the
+ * escape-hatch leaf of an automation's condition tree — one language, three
+ * positions (derive a value, gate a trigger, compute an argument).
+ */
 import type { ExpressionValue } from './ast.js';
+import { type ExpressionEvalOptions } from './evaluator.js';
 /** The `now` epoch-ms binding is auto-injected into every evaluation and is a
  *  reserved binding name (authors may not rebind it). */
 export declare const EXPRESSION_INJECTED_NOW = "now";
@@ -10,8 +20,8 @@ export declare const EXPRESSION_INJECTED_NOW = "now";
  * its binding-miss policy (→ `null`). `null` itself is a valid value.
  */
 export declare function toExpressionValue(raw: unknown): ExpressionValue | undefined;
-/** Shape the author-time validator accepts (structural subset of a
- *  `DeviceLinkExpressionSource`). */
+/** Shape the author-time validator accepts (structural subset of an
+ *  {@link ExpressionSource}). */
 export interface ExpressionSourceInput {
     readonly expr: string;
     readonly bindings: Readonly<Record<string, unknown>>;
@@ -24,10 +34,9 @@ export interface ExpressionSourceInput {
  * FREE identifier of the AST is covered by a binding or the injected `now`.
  */
 export declare function validateExpressionSource(src: ExpressionSourceInput): string | null;
-/** Result of a link-expression evaluation — `ok` carries the value, the error
- *  branch carries a reason the async channel can log while the sync channel
- *  silently skips. */
-export type EvaluateLinkExpressionResult = {
+/** Result of an expression evaluation — `ok` carries the value, the error
+ *  branch carries a reason the caller can log while it skips the derivation. */
+export type EvaluateExpressionSourceResult = {
     readonly ok: true;
     readonly value: ExpressionValue;
 } | {
@@ -35,10 +44,10 @@ export type EvaluateLinkExpressionResult = {
     readonly error: string;
 };
 /**
- * Shared read-path evaluation for BOTH resolver channels. Builds a null-proto
- * scope from `bindingValues` plus the injected `now` (supplied by the caller
- * for determinism/testability), compiles via the LRU, and evaluates. Any
- * failure (parse or eval) returns `{ ok: false }` — the caller treats that as
- * "skip this link".
+ * Shared read-path evaluation. Builds a null-proto scope from `bindingValues`
+ * plus the injected `now` (supplied by the caller for determinism and
+ * testability), compiles via the LRU, and evaluates. Any failure (parse or
+ * eval) returns `{ ok: false }` — the caller treats that as "skip this
+ * derivation", never as a throw that takes the pass down.
  */
-export declare function evaluateLinkExpression(expr: string, bindingValues: Readonly<Record<string, ExpressionValue>>, now: number, opts?: ExpressionEvalOptions): EvaluateLinkExpressionResult;
+export declare function evaluateExpressionSource(expr: string, bindingValues: Readonly<Record<string, ExpressionValue>>, now: number, opts?: ExpressionEvalOptions): EvaluateExpressionSourceResult;

package/dist/expression/index.d.ts

@@ -2,24 +2,27 @@
  * Safe expression engine — public surface. A non-Turing-complete infix
  * mini-language (tokenizer → Pratt parser → whitelisted-AST interpreter) with
  * NO eval / new Function / node:vm, NO member access, NO loops/lambdas, and
- * hard resource bounds. Powers the `expression` DeviceLinkSource kind.
+ * hard resource bounds. It is the derivation language of a composed device and
+ * the escape-hatch leaf of an automation's condition tree.
  *
  * This is the module barrel; leaf files inside @camstack/types MUST import from
  * the deep modules (e.g. `../expression/compile.js`), never through this file
  * OR the root barrel (see biome-plugins/no-types-barrel-leaf-import.grit).
  */
-export type { ExpressionValue, ExpressionNode, ExpressionLiteralNode, ExpressionIdentifierNode, ExpressionUnaryNode, ExpressionBinaryNode, ExpressionLogicalNode, ExpressionConditionalNode, ExpressionCallNode, ExpressionBinaryOperator, ExpressionLogicalOperator, ExpressionUnaryOperator, } from './ast.js';
-export { ExpressionParseError, ExpressionEvalError } from './errors.js';
-export { MAX_EXPRESSION_SOURCE_LENGTH, MAX_EXPRESSION_AST_NODES, MAX_EXPRESSION_EVAL_STEPS, MAX_EXPRESSION_BINDINGS, MAX_EXPRESSION_CALL_ARGS, EXPRESSION_COMPILE_CACHE_CAPACITY, EXPRESSION_IDENTIFIER_RE, RESERVED_BINDING_NAMES, } from './limits.js';
-export { tokenize } from './tokenizer.js';
-export type { Token, Punctuator, Keyword } from './tokenizer.js';
-export { parseExpression } from './parser.js';
-export type { ParsedExpression } from './parser.js';
-export { EXPRESSION_BUILTINS, EXPRESSION_BUILTIN_NAMES, } from './builtins.js';
+export type { ExpressionBinaryNode, ExpressionBinaryOperator, ExpressionCallNode, ExpressionConditionalNode, ExpressionIdentifierNode, ExpressionLiteralNode, ExpressionLogicalNode, ExpressionLogicalOperator, ExpressionNode, ExpressionUnaryNode, ExpressionUnaryOperator, ExpressionValue, } from './ast.js';
+export type { ExpressionBindingSource, ExpressionFieldBinding, ExpressionGlobalBinding, ExpressionLiteralBinding, ExpressionSource, } from './binding-source.js';
+export { ExpressionBindingSourceSchema, ExpressionFieldBindingSchema, ExpressionGlobalBindingSchema, ExpressionLiteralBindingSchema, ExpressionSourceSchema, } from './binding-source.js';
 export type { ExpressionBuiltin, ExpressionEvalHooks } from './builtins.js';
-export { createExpressionScope, evaluateAst } from './evaluator.js';
-export type { ExpressionEvalOptions } from './evaluator.js';
-export { compileExpression, compileExpressionSafe } from './compile.js';
+export { EXPRESSION_BUILTIN_NAMES, EXPRESSION_BUILTINS, } from './builtins.js';
 export type { CompileResult } from './compile.js';
-export { EXPRESSION_INJECTED_NOW, toExpressionValue, validateExpressionSource, evaluateLinkExpression, } from './link-expression.js';
-export type { ExpressionSourceInput, EvaluateLinkExpressionResult, } from './link-expression.js';
+export { compileExpression, compileExpressionSafe } from './compile.js';
+export { ExpressionEvalError, ExpressionParseError } from './errors.js';
+export type { ExpressionEvalOptions } from './evaluator.js';
+export { createExpressionScope, evaluateAst } from './evaluator.js';
+export type { EvaluateExpressionSourceResult, ExpressionSourceInput, } from './expression-source.js';
+export { EXPRESSION_INJECTED_NOW, evaluateExpressionSource, toExpressionValue, validateExpressionSource, } from './expression-source.js';
+export { EXPRESSION_COMPILE_CACHE_CAPACITY, EXPRESSION_IDENTIFIER_RE, MAX_EXPRESSION_AST_NODES, MAX_EXPRESSION_BINDINGS, MAX_EXPRESSION_CALL_ARGS, MAX_EXPRESSION_EVAL_STEPS, MAX_EXPRESSION_SOURCE_LENGTH, RESERVED_BINDING_NAMES, } from './limits.js';
+export type { ParsedExpression } from './parser.js';
+export { parseExpression } from './parser.js';
+export type { Keyword, Punctuator, Token } from './tokenizer.js';
+export { tokenize } from './tokenizer.js';

package/dist/expression/limits.d.ts

@@ -17,7 +17,7 @@ export declare const MAX_EXPRESSION_AST_NODES = 256;
  *  evaluation. The grammar guarantees O(nodeCount) walks, so this can only trip
  *  on a crafted maximum-size AST. */
 export declare const MAX_EXPRESSION_EVAL_STEPS = 4096;
-/** Max named bindings on one `DeviceLinkExpressionSource`. */
+/** Max named bindings on one {@link ExpressionSource}. */
 export declare const MAX_EXPRESSION_BINDINGS = 32;
 /** Max positional arguments to any builtin call. */
 export declare const MAX_EXPRESSION_CALL_ARGS = 16;

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

@@ -1441,6 +1441,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof coreBlocksCapability.methods.setEnabled.output>;
             meta: object;
         }>;
+        restart: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof coreBlocksCapability.methods.restart.input>;
+            output: z.infer<typeof coreBlocksCapability.methods.restart.output>;
+            meta: object;
+        }>;
         compile: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
@@ -2076,13 +2083,6 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof deviceManagerCapability.methods.setChildLayout.output>;
             meta: object;
         }>;
-        setDeviceLinks: TRPCMutationProcedure<{
-            input: {
-                [x: string]: unknown;
-            } & z.input<typeof deviceManagerCapability.methods.setDeviceLinks.input>;
-            output: z.infer<typeof deviceManagerCapability.methods.setDeviceLinks.output>;
-            meta: object;
-        }>;
         setDisplay: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;

package/dist/generated/device-proxy.d.ts

@@ -269,7 +269,7 @@ export interface DeviceProxy {
     readonly cameraPipelineConfig: Pick<InferDeviceProxyCap<typeof cameraPipelineConfigCapability>, 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
     readonly deviceAdoption: Pick<InferDeviceProxyCap<typeof deviceAdoptionCapability>, 'getStatus'>;
     readonly deviceExport: Pick<InferDeviceProxyCap<typeof deviceExportCapability>, 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
-    readonly deviceManager: Pick<InferDeviceProxyCap<typeof deviceManagerCapability>, 'loadConfig' | 'loadRuntimeState' | 'loadMeta' | 'setName' | 'setLocation' | 'setType' | 'setIntegrationId' | 'setLinkDeviceId' | 'setPrimaryChildEntityId' | 'setChildLayout' | 'setDeviceLinks' | 'setDisplay' | 'getWireableFields' | 'setRole' | 'applyInitialMeta' | 'setMetadata' | 'setDisabled' | 'getDevice' | 'getLinkedDevices' | 'getStreamSources' | 'getConfigSchema' | 'getSettingsSchema' | 'updateConfig' | 'enable' | 'disable' | 'remove' | 'getStreamProfileMap' | 'setStreamProfileMap' | 'probeStreams' | 'getBindings' | 'getAllBindings' | 'setWrapperActive' | 'getDeviceSettingsAggregate' | 'getDeviceLiveInfoAggregate' | 'getDeviceAggregate' | 'runDeviceAction' | 'updateDeviceField' | 'updateDeviceFieldsBatch' | 'testField' | 'getDeviceStatusAggregate' | 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
+    readonly deviceManager: Pick<InferDeviceProxyCap<typeof deviceManagerCapability>, 'loadConfig' | 'loadRuntimeState' | 'loadMeta' | 'setName' | 'setLocation' | 'setType' | 'setIntegrationId' | 'setLinkDeviceId' | 'setPrimaryChildEntityId' | 'setChildLayout' | 'setDisplay' | 'getWireableFields' | 'setRole' | 'applyInitialMeta' | 'setMetadata' | 'setDisabled' | 'getDevice' | 'getLinkedDevices' | 'getStreamSources' | 'getConfigSchema' | 'getSettingsSchema' | 'updateConfig' | 'enable' | 'disable' | 'remove' | 'getStreamProfileMap' | 'setStreamProfileMap' | 'probeStreams' | 'getBindings' | 'getAllBindings' | 'setWrapperActive' | 'getDeviceSettingsAggregate' | 'getDeviceLiveInfoAggregate' | 'getDeviceAggregate' | 'runDeviceAction' | 'updateDeviceField' | 'updateDeviceFieldsBatch' | 'testField' | 'getDeviceStatusAggregate' | 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
     readonly deviceState: Pick<InferDeviceProxyCap<typeof deviceStateCapability>, 'getSnapshot' | 'getCapSlice' | 'setCapSlice'>;
     readonly faceGallery: Pick<InferDeviceProxyCap<typeof faceGalleryCapability>, 'getFaceByTrack'>;
     readonly networkQuality: Pick<InferDeviceProxyCap<typeof networkQualityCapability>, 'getDeviceStats' | 'reportClientStats'>;

package/dist/generated/system-proxy.d.ts

@@ -61,7 +61,7 @@ export interface SystemProxy {
     readonly audioCodec: Pick<InferProvider<typeof audioCodecCapability>, 'listSupportedCodecs' | 'canHandle' | 'createDecodeSession' | 'createEncodeSession' | 'closeSession' | 'pushEncodedFrame' | 'pullPcm' | 'pushPcm' | 'pullEncoded' | 'flushEncode' | 'listActiveSessions'>;
     readonly backup: Pick<InferProvider<typeof backupCapability>, 'listDestinations' | 'trigger' | 'list' | 'listLocations' | 'getEntries' | 'restore' | 'delete' | 'listArchives' | 'upsertDestinationPolicy' | 'previewSchedule' | 'listSchedules' | 'upsertSchedule' | 'deleteSchedule'>;
     readonly broker: Pick<InferProvider<typeof brokerCapability>, 'list' | 'get' | 'listProviders' | 'add' | 'remove' | 'testConnection' | 'getSettings' | 'setSettings' | 'getBrokerConfig' | 'getSettingsSchema' | 'testSettings' | 'publish' | 'subscribe' | 'unsubscribe' | 'getState' | 'getStatus'>;
-    readonly coreBlocks: Pick<InferProvider<typeof coreBlocksCapability>, 'list' | 'get' | 'create' | 'update' | 'delete' | 'setEnabled' | 'compile' | 'getTypeDefs'>;
+    readonly coreBlocks: Pick<InferProvider<typeof coreBlocksCapability>, 'list' | 'get' | 'create' | 'update' | 'delete' | 'setEnabled' | 'restart' | 'compile' | 'getTypeDefs'>;
     readonly decoder: Pick<InferProvider<typeof decoderCapability>, 'supportsCodec' | 'getInfo' | 'createSession' | 'destroySession' | 'pushPacket' | 'openStream' | 'pullFrames' | 'pullHandles' | 'getFrame' | 'getShmStats' | 'updateConfig' | 'getStats' | 'listActiveSessions' | 'reprobeHwaccel'>;
     readonly deviceAdoption: Pick<InferProvider<typeof deviceAdoptionCapability>, 'listCandidateFilters' | 'listCandidates' | 'getCandidate' | 'refresh' | 'adopt' | 'release' | 'resync'>;
     readonly deviceExport: Pick<InferProvider<typeof deviceExportCapability>, 'getStatus' | 'listSupportedDeviceKinds' | 'listExposedDevices' | 'exposeDevice' | 'unexposeDevice'>;

package/dist/index.d.ts

@@ -8,11 +8,11 @@ export type { IAuthProvider } from './capabilities/auth-provider.cap.js';
 export type { DisposerChainOptions, DisposerFn } from './disposer-chain.js';
 export { DisposerChain } from './disposer-chain.js';
 export * from './encode-profile.js';
-export * from './ffmpeg/invocation.js';
 export * from './ffmpeg/encode-defaults.js';
+export * from './ffmpeg/fmp4-box-splitter.js';
 export * from './ffmpeg/hwaccel.js';
+export * from './ffmpeg/invocation.js';
 export * from './ffmpeg/sharing-key.js';
-export * from './ffmpeg/fmp4-box-splitter.js';
 export * from './health/wiring-health.js';
 export type * from './interfaces/addon.js';
 export { DEFAULT_ADDON_PLACEMENT, isAgentOnlyPlacement, isDeployableToAgent, resolveAddonExecution, resolveAddonGroup, resolveAddonPlacement, resolveRunnerId, } from './interfaces/addon.js';
@@ -127,14 +127,15 @@ export { BaseDevice } from './device/base-device.js';
 export type { DeviceSummary, DiscoveryCandidate, FieldProbeResult, } from './device/base-device-provider.js';
 export { BaseDeviceProvider, toDeviceSummary } from './device/base-device-provider.js';
 export type { ICameraDevice, StreamSourceEntry } from './device/camera-device.js';
+export type { DeclarationPlacement, DeclaredDeviceOutcome, DeclaredDevicePorts, DeclaredDeviceRow, DeclaredDevicesResult, DeclaredDevicesSpec, DeclaredIntegrationRow, DeviceDeclaration, } from './device/declared-device.js';
+export { DECLARED_DEVICE_SWEEP_LIMIT, DECLARED_INTEGRATION_FIXED_KEY, DeclaredDevices, declarationOwnerNodeId, } from './device/declared-device.js';
 export type { IDevice } from './device/device.js';
 export type { DeviceBinding, DeviceBindingEntry } from './device/device-binding.js';
 export { DeviceConfig } from './device/device-config.js';
 export type { DeviceConstructor, DeviceContext, DeviceManagerApi, IDeviceRegistry, IDeviceRegistryReader, } from './device/device-context.js';
 export type { AccessoryControlInput, AccessoryControlKind, AccessoryControlPick, DeviceControlKind, SensorMapping, } from './device/device-control-resolution.js';
 export { DEVICE_TYPE_CONTROL_KIND, hasMotionTrigger, isNode, MOTION_TRIGGER_FEATURE, pickAccessoryControl, resolveDeviceControlKind, resolveMutate, SENSOR_FEATURES, SENSOR_MAP, } from './device/device-control-resolution.js';
-export { applyTransform } from './device/device-link-transform.js';
-export type { ChildLayout, ChildLayoutEntry, CreateDeviceSpec, DeviceCapDisplayOverride, DeviceDiscovery, DeviceDisplayOverride, DeviceLink, DeviceLinkExpressionBinding, DeviceLinkExpressionSource, DeviceLinkFieldSource, DeviceLinkLiteralSource, DeviceLinkSource, DeviceLinks, DeviceLinkTarget, DeviceLinkTransform, DeviceManualCreation, DeviceMeta, DiscoveredDevice, InitialDeviceMeta, RoleDisplayDefault, SavedDevice, } from './device/device-management.js';
+export type { ChildLayout, ChildLayoutEntry, CreateDeviceSpec, DeviceCapDisplayOverride, DeviceDiscovery, DeviceDisplayOverride, DeviceManualCreation, DeviceMeta, DiscoveredDevice, InitialDeviceMeta, RoleDisplayDefault, SavedDevice, } from './device/device-management.js';
 export type { DeviceProfile, DeviceProfileDefaults, DeviceProfileMatch, PipelinePhaseMode, } from './device/device-profile.js';
 export { BATTERY_DEVICE_PROFILE, DEVICE_PROFILES, deviceMatchesProfile, resolveDeviceProfile, } from './device/device-profile.js';
 export type { IDeviceRuntimeState } from './device/device-runtime-state.js';
@@ -158,8 +159,8 @@ export type { DeviceConfigEntry } from './device/zod-to-config-ui.js';
 export { zodEntriesToConfigUI } from './device/zod-to-config-ui.js';
 export { EventCategory } from './enums/event-category.js';
 export * from './enums/index.js';
-export type { CompileResult, EvaluateLinkExpressionResult, ExpressionBinaryOperator, ExpressionBuiltin, ExpressionEvalHooks, ExpressionEvalOptions, ExpressionLogicalOperator, ExpressionNode, ExpressionSourceInput, ExpressionUnaryOperator, ExpressionValue, Keyword, ParsedExpression, Punctuator, Token, } from './expression/index.js';
-export { compileExpression, compileExpressionSafe, createExpressionScope, EXPRESSION_BUILTIN_NAMES, EXPRESSION_BUILTINS, EXPRESSION_COMPILE_CACHE_CAPACITY, EXPRESSION_IDENTIFIER_RE, EXPRESSION_INJECTED_NOW, ExpressionEvalError, ExpressionParseError, evaluateAst, evaluateLinkExpression, MAX_EXPRESSION_AST_NODES, MAX_EXPRESSION_BINDINGS, MAX_EXPRESSION_CALL_ARGS, MAX_EXPRESSION_EVAL_STEPS, MAX_EXPRESSION_SOURCE_LENGTH, parseExpression, RESERVED_BINDING_NAMES, toExpressionValue, tokenize, validateExpressionSource, } from './expression/index.js';
+export type { CompileResult, EvaluateExpressionSourceResult, ExpressionBinaryOperator, ExpressionBindingSource, ExpressionBuiltin, ExpressionEvalHooks, ExpressionEvalOptions, ExpressionFieldBinding, ExpressionGlobalBinding, ExpressionLiteralBinding, ExpressionLogicalOperator, ExpressionNode, ExpressionSource, ExpressionSourceInput, ExpressionUnaryOperator, ExpressionValue, Keyword, ParsedExpression, Punctuator, Token, } from './expression/index.js';
+export { compileExpression, compileExpressionSafe, createExpressionScope, EXPRESSION_BUILTIN_NAMES, EXPRESSION_BUILTINS, EXPRESSION_COMPILE_CACHE_CAPACITY, EXPRESSION_IDENTIFIER_RE, EXPRESSION_INJECTED_NOW, ExpressionBindingSourceSchema, ExpressionEvalError, ExpressionFieldBindingSchema, ExpressionGlobalBindingSchema, ExpressionLiteralBindingSchema, ExpressionParseError, ExpressionSourceSchema, evaluateAst, evaluateExpressionSource, MAX_EXPRESSION_AST_NODES, MAX_EXPRESSION_BINDINGS, MAX_EXPRESSION_CALL_ARGS, MAX_EXPRESSION_EVAL_STEPS, MAX_EXPRESSION_SOURCE_LENGTH, parseExpression, RESERVED_BINDING_NAMES, toExpressionValue, tokenize, validateExpressionSource, } from './expression/index.js';
 export type { AddonApi, AppRouter } from './generated/addon-api.js';
 export type { CapNameWithStatus, CapStatusTypeMap } from './generated/cap-status-types.js';
 export { CAP_NAMES_WITH_STATUS } from './generated/cap-status-types.js';
@@ -185,6 +186,8 @@ export { htmlToText, markdownToHtmlLite, markdownToText, type NotificationFormat
 export { isScheduleActive } from './notification/schedule.js';
 export type { TimelapseRule, TimelapseRuleInput, TimelapseRulePatch, TimelapseTemplate, } from './notification/timelapse-rule.js';
 export { TimelapseRuleInputSchema, TimelapseRulePatchSchema, TimelapseRuleSchema, TimelapseTemplateSchema, } from './notification/timelapse-rule.js';
+export { DEFAULT_DETAIL_CROP_CONVENTION, DETAIL_CROP_PADDING_FIELD, DETAIL_CROP_PADDING_KEY, DETAIL_CROP_SECTION_ID, DETAIL_CROP_SQUARE_KEY, type DetailCropConvention, DetailCropConventionSchema, type DetailCropRect, deriveDetailCropRect, type HydratedSettingsSection, type HydratedSettingsView, pickDetailCropConvention, readDetailCropConvention, } from './pipeline/detail-crop.js';
+export { DEFAULT_NATIVE_LEASE_SETTINGS, NATIVE_LEASE_ACTIVITY_FIELD, NATIVE_LEASE_ACTIVITY_KEY, NATIVE_LEASE_ADMISSION_FIELD, NATIVE_LEASE_ADMISSION_KEY, NATIVE_LEASE_BUDGET_FIELD, NATIVE_LEASE_BUDGET_KEY, NATIVE_LEASE_SECTION_ID, NATIVE_LEASE_TTL_FIELD, NATIVE_LEASE_TTL_KEY, type NativeLeaseAdmission, NativeLeaseAdmissionSchema, type NativeLeaseKnob, type NativeLeaseNumberKnob, type NativeLeaseSettings, type NativeLeaseSettingsOverride, NativeLeaseSettingsSchema, pickNativeLeaseOverride, readNativeLeaseOverride, } from './pipeline/native-lease.js';
 export { type ApiKeyRecord, ApiKeyRecordSchema, type CapScope, CapScopeSchema, type MethodAccess, MethodAccessSchema, type ScopedToken, ScopedTokenSchema, type TokenScope, TokenScopeSchema, type UserRecord, UserRecordSchema, } from './schemas/auth-records.js';
 export type { CameraDetectionCapabilities, CameraMotionConfig, CameraNativeDetectionConfig, } from './types/camera-detection.js';
 export { DEVICE_TYPE_INFO, type DeviceTypeInfo } from './types/device-type.js';
@@ -206,8 +209,6 @@ export { BACKEND_TO_FORMAT, DEVICE_BACKEND_TO_FORMAT, deviceBackendToFormat, for
 export { sleep, sleepCancellable } from './utils/sleep.js';
 export { decodeVectorBase64, encodeVectorBase64, vectorDimFromBase64, } from './utils/vector-codec.js';
 export { evaluateZoneRules, type ZoneRuleEvalResult } from './utils/zone-rule-eval.js';
-export { DEFAULT_DETAIL_CROP_CONVENTION, DETAIL_CROP_PADDING_FIELD, DETAIL_CROP_PADDING_KEY, DETAIL_CROP_SECTION_ID, DETAIL_CROP_SQUARE_KEY, type DetailCropConvention, DetailCropConventionSchema, type DetailCropRect, deriveDetailCropRect, type HydratedSettingsSection, type HydratedSettingsView, pickDetailCropConvention, readDetailCropConvention, } from './pipeline/detail-crop.js';
-export { DEFAULT_NATIVE_LEASE_SETTINGS, NATIVE_LEASE_ACTIVITY_FIELD, NATIVE_LEASE_ACTIVITY_KEY, NATIVE_LEASE_ADMISSION_FIELD, NATIVE_LEASE_ADMISSION_KEY, NATIVE_LEASE_BUDGET_FIELD, NATIVE_LEASE_BUDGET_KEY, NATIVE_LEASE_SECTION_ID, NATIVE_LEASE_TTL_FIELD, NATIVE_LEASE_TTL_KEY, type NativeLeaseAdmission, NativeLeaseAdmissionSchema, type NativeLeaseKnob, type NativeLeaseNumberKnob, type NativeLeaseSettings, NativeLeaseSettingsSchema, type NativeLeaseSettingsOverride, pickNativeLeaseOverride, readNativeLeaseOverride, } from './pipeline/native-lease.js';
 export { bindAddonActions } from './helpers/bind-addon-actions.js';
 export type { DeviceOption, InferenceDeviceDescriptor, RuntimeId, } from './inference/runtime-capabilities.js';
 export { defaultDeviceFor, enumerateInferenceDevices, modelFormatForRuntime, runtimeDevices, scoreRuntimes, supportedRuntimes, } from './inference/runtime-capabilities.js';