@camstack/types 1.2.440 → 1.2.441

package/dist/interfaces/device-call-redirect.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The device-call redirect (D963) — the ONE question every resolution of a
+ * device-scoped cap call asks before it routes the call to the owning
+ * provider: does something take this call over?
+ *
+ * Today the remote extension is the one that does. A media-player command on a
+ * device whose remote binds the command's role runs the binding (an infrared
+ * code, a smart-TV call); an unbound role falls through to the native cap. A
+ * `getStatus` on a media player no running source answers is served from the
+ * remote's own bookkeeping, marked `assumed`. It is a dispatch concern, not a
+ * UI one, so it holds for every caller: the admin UI, an automation, an
+ * exporter, a forked addon.
+ *
+ * Declared here, like the claimed-status overlay, because `ICapabilityRegistry`
+ * carries the setter and the question; the kernel registry and the transport
+ * entries both import from it and neither imports the other.
+ */
+/** A device-scoped cap call as an entry sees it. */
+export interface DeviceCall {
+    readonly capName: string;
+    readonly method: string;
+    readonly deviceId: number;
+    readonly args: unknown;
+}
+/**
+ * - `not-redirected`: nothing took the call over — route it as before.
+ * - `redirected`: `result` IS the call's answer; the provider is not called.
+ *   A redirect that FAILS throws instead, so the caller sees the failure and
+ *   the native cap never silently runs in its place.
+ */
+export type DeviceCallAnswer = {
+    readonly kind: 'not-redirected';
+} | {
+    readonly kind: 'redirected';
+    readonly result: unknown;
+};
+/** Installed by the owner of the redirecting authority (core-blocks, for the remote). */
+export interface DeviceCallRedirect {
+    /** Synchronous and cheap: could this `(cap, method)` ever be redirected? */
+    covers(capName: string, method: string): boolean;
+    attempt(call: DeviceCall): Promise<DeviceCallAnswer>;
+}

package/dist/interfaces/kernel-abstractions.d.ts

@@ -10,6 +10,7 @@ import type { FrameInput } from '../types/io.js';
 import type { CropInput } from '../types/detection.js';
 import type { InferenceOutput } from './pipeline-runner.js';
 import type { CapabilityProviderMap } from './capability.js';
+import type { DeviceCall, DeviceCallAnswer, DeviceCallRedirect } from './device-call-redirect.js';
 import type { StatusOverlay, StatusOverlayAnswer } from './status-overlay.js';
 /**
  * Capability registry interface exposing what core/addon consumers need.
@@ -53,6 +54,17 @@ export interface ICapabilityRegistry {
      * native (D315, D49).
      */
     resolveClaimedStatus(capName: string, deviceId: number): Promise<StatusOverlayAnswer>;
+    /**
+     * Install (or remove, with `null`) the device-call redirect (D963). While
+     * installed, a covered device-scoped call resolved through the registry —
+     * and, through `redirectDeviceCall`, through the transport entries — may be
+     * taken over before it reaches the provider.
+     */
+    setDeviceCallRedirect(redirect: DeviceCallRedirect | null): void;
+    /** Cheap and synchronous: could a redirect take this `(cap, method)` over? Asked before args are decoded. */
+    coversDeviceCall(capName: string, method: string): boolean;
+    /** The one question every name-resolving entry asks before routing. */
+    redirectDeviceCall(call: DeviceCall): Promise<DeviceCallAnswer>;
     /** Get the addonId that registered a native provider for (cap, device). */
     getNativeAddonId(capName: string, deviceId: number): string | null;
     /** List all capability names with a native registration for a device. */

package/dist/remote/remote-config.d.ts

@@ -0,0 +1,116 @@
+/**
+ * The per-device configuration of the `remote` Customize extension (D963) and
+ * the layout payload of the `remote` template kind. Pure data: no runtime, no
+ * node dependency, so the admin UI imports the same schemas the server checks.
+ *
+ * A binding is the SAME shape an Action step has (`AutomationCapStepSchema`: a
+ * cap method called on a device with arguments), narrowed to ONE device: an IR
+ * code is `ir-transmitter.send` on the transmitter, a smart TV is a `switch` or a
+ * vendor cap — the remote does not know which. How many times a command is sent
+ * is the CALLER's (`sendCommand({ repeat })`), never stored here.
+ */
+import { z } from 'zod';
+export declare const RemoteBindingActionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"cap">;
+    cap: z.ZodString;
+    method: z.ZodString;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    deviceId: z.ZodNumber;
+}, z.core.$strip>;
+export type RemoteBindingAction = z.infer<typeof RemoteBindingActionSchema>;
+export declare const RemoteBindingSchema: z.ZodObject<{
+    action: z.ZodObject<{
+        kind: z.ZodLiteral<"cap">;
+        cap: z.ZodString;
+        method: z.ZodString;
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        deviceId: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type RemoteBinding = z.infer<typeof RemoteBindingSchema>;
+export declare const RemoteCustomButtonSchema: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+export type RemoteCustomButton = z.infer<typeof RemoteCustomButtonSchema>;
+export declare const REMOTE_POWER_MODES: readonly ['toggle', 'discrete'];
+export declare const RemotePowerModeSchema: z.ZodEnum<{
+    discrete: "discrete";
+    toggle: "toggle";
+}>;
+export type RemotePowerMode = z.infer<typeof RemotePowerModeSchema>;
+export declare const MAX_REMOTE_BINDINGS = 200;
+export declare const MAX_REMOTE_CUSTOM_BUTTONS = 100;
+export declare const RemoteConfigSchema: z.ZodObject<{
+    layoutTemplateId: z.ZodNullable<z.ZodString>;
+    defaultTransmitterId: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    bindings: z.ZodRecord<z.ZodString, z.ZodObject<{
+        action: z.ZodObject<{
+            kind: z.ZodLiteral<"cap">;
+            cap: z.ZodString;
+            method: z.ZodString;
+            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    customButtons: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    power: z.ZodObject<{
+        mode: z.ZodEnum<{
+            discrete: "discrete";
+            toggle: "toggle";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type RemoteConfig = z.infer<typeof RemoteConfigSchema>;
+export declare const EMPTY_REMOTE_CONFIG: RemoteConfig;
+/**
+ * What the remote last SENT and therefore guesses about a device that does not
+ * report it (infrared has no feedback). Persisted next to the config so a hub
+ * restart does not forget it, and never recorded in history: it is a guess, not
+ * a reading. A reading from a running source always outranks it.
+ */
+export declare const RemoteAssumedStateSchema: z.ZodObject<{
+    power: z.ZodNullable<z.ZodObject<{
+        state: z.ZodEnum<{
+            off: "off";
+            on: "on";
+        }>;
+        at: z.ZodNumber;
+    }, z.core.$strip>>;
+    muted: z.ZodNullable<z.ZodObject<{
+        value: z.ZodBoolean;
+        at: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RemoteAssumedState = z.infer<typeof RemoteAssumedStateSchema>;
+export declare const EMPTY_REMOTE_ASSUMED_STATE: RemoteAssumedState;
+export declare const MAX_LAYOUT_SPAN = 24;
+export declare const RemoteLayoutButtonSchema: z.ZodObject<{
+    id: z.ZodString;
+    row: z.ZodNumber;
+    col: z.ZodNumber;
+    rowSpan: z.ZodNumber;
+    colSpan: z.ZodNumber;
+    icon: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    role: z.ZodString;
+}, z.core.$strip>;
+export type RemoteLayoutButton = z.infer<typeof RemoteLayoutButtonSchema>;
+export declare const RemoteLayoutPayloadSchema: z.ZodObject<{
+    columns: z.ZodNumber;
+    rows: z.ZodNumber;
+    buttons: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        row: z.ZodNumber;
+        col: z.ZodNumber;
+        rowSpan: z.ZodNumber;
+        colSpan: z.ZodNumber;
+        icon: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        role: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RemoteLayoutPayload = z.infer<typeof RemoteLayoutPayloadSchema>;

package/dist/remote/remote-roles.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The role vocabulary of a remote (D963): what a button MEANS, independent of
+ * how it is wired. A layout template places buttons by role; a device binds a
+ * role to an action; an exporter asks for a role by name. Roles are shared so
+ * one layout fits every appliance and one voice command fits every binding.
+ *
+ * A role outside this list is `custom:<key>` — the operator's own button (a
+ * SmartIR source, a channel preset). The key is a lowercase slug.
+ */
+import { z } from 'zod';
+export declare const REMOTE_KNOWN_ROLES: readonly ['power', 'power_on', 'power_off', 'volume_up', 'volume_down', 'mute', 'channel_up', 'channel_down', 'up', 'down', 'left', 'right', 'ok', 'back', 'home', 'menu', 'info', 'guide', 'exit', 'input', 'play', 'pause', 'play_pause', 'stop', 'next', 'previous', 'fast_forward', 'rewind', 'digit_0', 'digit_1', 'digit_2', 'digit_3', 'digit_4', 'digit_5', 'digit_6', 'digit_7', 'digit_8', 'digit_9'];
+export type RemoteKnownRole = (typeof REMOTE_KNOWN_ROLES)[number];
+export declare const REMOTE_CUSTOM_ROLE_PREFIX = "custom:";
+export declare function isRemoteKnownRole(value: string): value is RemoteKnownRole;
+export declare function isRemoteCustomKey(key: string): boolean;
+export declare function customRole(key: string): string;
+/** The key of a `custom:<key>` role, or null for any other string. */
+export declare function customKeyOfRole(role: string): string | null;
+export declare function isRemoteRole(value: string): boolean;
+export declare const RemoteRoleSchema: z.ZodString;
+export type RemoteRole = z.infer<typeof RemoteRoleSchema>;

package/dist/remote/smartir-draft.d.ts

@@ -0,0 +1,25 @@
+import type { RemoteCommandTable } from '../ir/smartir.js';
+import type { RemoteBinding, RemoteCustomButton, RemotePowerMode } from './remote-config.js';
+/** The transmitter that sends a draft's codes unless a command names its own. */
+export interface SmartIrTarget {
+    readonly transmitterDeviceId: number;
+}
+export interface SmartIrSkipped {
+    readonly name: string;
+    readonly reason: string;
+}
+export interface SmartIrDraft {
+    readonly bindings: Record<string, RemoteBinding>;
+    readonly customButtons: RemoteCustomButton[];
+    readonly power: {
+        readonly mode: RemotePowerMode;
+    };
+    readonly skipped: SmartIrSkipped[];
+}
+/**
+ * `on` and `off` carrying the SAME pulse train are one power TOGGLE (bound to
+ * `power`); different trains are a discrete pair (`power_on` / `power_off`). A
+ * command SmartIR knows fills its role; a source, or any command it does not
+ * know, becomes a custom button named as the file spells it.
+ */
+export declare function smartIrDraft(table: RemoteCommandTable, target: SmartIrTarget): SmartIrDraft;

package/dist/{sleep-g6ZjBHBL.js → sleep-BpwNJ1Su.js}

@@ -6785,6 +6785,7 @@ var CAP_NAMES = Object.freeze([
 	"recording-onboard",
 	"recording-signal",
 	"records",
+	"remote",
 	"running-state",
 	"scene-monitor",
 	"script-runner",
@@ -6808,6 +6809,7 @@ var CAP_NAMES = Object.freeze([
 	"system",
 	"tamper",
 	"temperature-sensor",
+	"template",
 	"terminal-session",
 	"toast",
 	"training",
@@ -7749,6 +7751,11 @@ var CAP_STATE_LEAVES = Object.freeze({
 				"standby"
 			]
 		},
+		{
+			"path": "stateSource",
+			"valueType": "enum",
+			"enumValues": ["reported", "assumed"]
+		},
 		{
 			"path": "volumeLevel",
 			"valueType": "number"
@@ -8024,6 +8031,18 @@ var CAP_STATE_LEAVES = Object.freeze({
 		{
 			"path": "volume",
 			"valueType": "number"
+		},
+		{
+			"path": "lastFeedGrams",
+			"valueType": "number"
+		},
+		{
+			"path": "lastFeedHopper1",
+			"valueType": "number"
+		},
+		{
+			"path": "lastFeedHopper2",
+			"valueType": "number"
 		}
 	],
 	"power-meter": [

package/dist/{sleep-BAvUCi_2.mjs → sleep-DJws6ho7.mjs}

@@ -6785,6 +6785,7 @@ var CAP_NAMES = Object.freeze([
 	"recording-onboard",
 	"recording-signal",
 	"records",
+	"remote",
 	"running-state",
 	"scene-monitor",
 	"script-runner",
@@ -6808,6 +6809,7 @@ var CAP_NAMES = Object.freeze([
 	"system",
 	"tamper",
 	"temperature-sensor",
+	"template",
 	"terminal-session",
 	"toast",
 	"training",
@@ -7749,6 +7751,11 @@ var CAP_STATE_LEAVES = Object.freeze({
 				"standby"
 			]
 		},
+		{
+			"path": "stateSource",
+			"valueType": "enum",
+			"enumValues": ["reported", "assumed"]
+		},
 		{
 			"path": "volumeLevel",
 			"valueType": "number"
@@ -8024,6 +8031,18 @@ var CAP_STATE_LEAVES = Object.freeze({
 		{
 			"path": "volume",
 			"valueType": "number"
+		},
+		{
+			"path": "lastFeedGrams",
+			"valueType": "number"
+		},
+		{
+			"path": "lastFeedHopper1",
+			"valueType": "number"
+		},
+		{
+			"path": "lastFeedHopper2",
+			"valueType": "number"
 		}
 	],
 	"power-meter": [

package/dist/template/template-kinds.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Template kinds (D963). A template is a named, reusable piece of operator
+ * data that more than one device points at — today the button grid of a
+ * remote. The store is generic: it keeps `{ id, kind, name, payload }` and
+ * knows nothing of a remote. Only the SYSTEM declares kinds, here: each kind
+ * names the schema its payload must satisfy. Adding a kind is adding a member
+ * to `TEMPLATE_KINDS` and a payload schema; the compiler refuses one without
+ * the other.
+ */
+import { z } from 'zod';
+export declare const TEMPLATE_KINDS: readonly ['remote'];
+export declare const TemplateKindSchema: z.ZodEnum<{
+    remote: "remote";
+}>;
+export type TemplateKind = z.infer<typeof TemplateKindSchema>;
+export declare const TEMPLATE_PAYLOAD_SCHEMAS: Readonly<Record<TemplateKind, z.ZodType>>;
+export declare function isTemplateKind(value: string): value is TemplateKind;
+export type TemplatePayloadCheck = {
+    readonly ok: true;
+    readonly payload: unknown;
+} | {
+    readonly ok: false;
+    readonly detail: string;
+};
+/** The payload as the kind's schema reads it, or why it is not one. */
+export declare function checkTemplatePayload(kind: TemplateKind, payload: unknown): TemplatePayloadCheck;

package/package.json

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