@laplace.live/persona-sdk 1.4.0 → 1.5.0

package/dist/values/scene-transition.d.ts

@@ -0,0 +1,14 @@
+import type { AssetRef, SceneTransition } from '../wire/types.ts';
+export declare const SCENE_TRANSITION_TYPES: readonly ["cut", "fade", "wipe", "circle", "image", "video"];
+export declare const SCENE_TRANSITION_DURATION_MIN_MS = 100;
+export declare const SCENE_TRANSITION_DURATION_MAX_MS = 10000;
+export declare const SCENE_TRANSITION_SWITCH_POINT_MIN = 0.05;
+export declare const SCENE_TRANSITION_SWITCH_POINT_MAX = 0.95;
+/** The destination scene's entrance effect; existing scenes keep an immediate cut. */
+export declare function defaultSceneTransition(): SceneTransition;
+/** The media kind a transition type plays, or null for the built-in effects. */
+export declare function sceneTransitionMedia(type: SceneTransition['type']): 'image' | 'video' | null;
+/** Whether `asset` can back the transition: an available image or video, matching the type when it plays media. */
+export declare function sceneTransitionAssetUsable(transition: SceneTransition, asset: Pick<AssetRef, 'kind' | 'exists'> | null | undefined): boolean;
+/** Heal saved transition settings independently, retaining media while another effect is selected. */
+export declare function healSceneTransition(raw: unknown): SceneTransition;

package/dist/values/scene-transition.js

@@ -0,0 +1,36 @@
+import { finiteOr, isOneOf, isRecord, nonEmptyString } from "./guards.js";
+import { clamp, hexColorOr } from "./limits.js";
+export const SCENE_TRANSITION_TYPES = ['cut', 'fade', 'wipe', 'circle', 'image', 'video'];
+export const SCENE_TRANSITION_DURATION_MIN_MS = 100;
+export const SCENE_TRANSITION_DURATION_MAX_MS = 10_000;
+export const SCENE_TRANSITION_SWITCH_POINT_MIN = 0.05;
+export const SCENE_TRANSITION_SWITCH_POINT_MAX = 0.95;
+/** The destination scene's entrance effect; existing scenes keep an immediate cut. */
+export function defaultSceneTransition() {
+    return { type: 'cut', durationMs: 1000, color: '#000000', assetId: null, switchPoint: 0.5, autoFade: false };
+}
+/** The media kind a transition type plays, or null for the built-in effects. */
+export function sceneTransitionMedia(type) {
+    return type === 'image' || type === 'video' ? type : null;
+}
+/** Whether `asset` can back the transition: an available image or video, matching the type when it plays media. */
+export function sceneTransitionAssetUsable(transition, asset) {
+    if (!asset?.exists || (asset.kind !== 'image' && asset.kind !== 'video'))
+        return false;
+    const media = sceneTransitionMedia(transition.type);
+    return media === null || asset.kind === media;
+}
+/** Heal saved transition settings independently, retaining media while another effect is selected. */
+export function healSceneTransition(raw) {
+    const d = defaultSceneTransition();
+    if (!isRecord(raw))
+        return d;
+    return {
+        type: isOneOf(raw.type, SCENE_TRANSITION_TYPES) ? raw.type : d.type,
+        durationMs: clamp(finiteOr(raw.durationMs, d.durationMs), SCENE_TRANSITION_DURATION_MIN_MS, SCENE_TRANSITION_DURATION_MAX_MS),
+        color: hexColorOr(raw.color, d.color),
+        assetId: nonEmptyString(raw.assetId),
+        switchPoint: clamp(finiteOr(raw.switchPoint, d.switchPoint), SCENE_TRANSITION_SWITCH_POINT_MIN, SCENE_TRANSITION_SWITCH_POINT_MAX),
+        autoFade: typeof raw.autoFade === 'boolean' ? raw.autoFade : d.autoFade,
+    };
+}

package/dist/wire/errors.js

@@ -1,10 +1,11 @@
+import { isOneOf } from "../values/guards.js";
 /** Every error the server can return, as string discriminants (never numeric bands). */
 export const API_ERROR_CODES = [
     'parse-error',
     'invalid-request',
     'unknown-method',
     'invalid-params',
-    /** A referenced id (scene, instance, model, asset, hotkey, shortcut, expression) resolves to nothing. */
+    /** A referenced id (scene, instance, model, asset, hotkey, automation, expression) resolves to nothing. */
     'not-found',
     /** The instance's model format cannot perform this method (e.g. MToon on Live2D). */
     'unsupported-for-format',
@@ -19,7 +20,7 @@ export const API_ERROR_CODES = [
     'internal',
 ];
 export function isApiErrorCode(v) {
-    return typeof v === 'string' && API_ERROR_CODES.includes(v);
+    return isOneOf(v, API_ERROR_CODES);
 }
 /** Thrown by {@link PersonaClient.call} when the server answers with an error envelope. */
 export class PersonaApiError extends Error {

package/dist/wire/events.d.ts

@@ -1,4 +1,4 @@
-import type { ExpressionPersistence, HotkeyState, ModelFormat, PoseStatus, SceneState, Settings, ShortcutInfo, TrackingStatus } from './types.ts';
+import type { AutomationInfo, ExpressionPersistence, HotkeyState, ModelFormat, PoseStatus, SceneState, Settings, TrackingStatus } from './types.ts';
 /** Every push event a session can subscribe to, with its payload. */
 export interface EventMap {
     /** Any scene mutation: create/delete/rename/activate/shortcut and persisted scene edits. */
@@ -10,9 +10,9 @@ export interface EventMap {
         modelId: string | null;
         config: HotkeyState;
     };
-    /** The app-shortcut list, its names, or its OS registrations changed. */
-    'shortcut.state': {
-        shortcuts: ShortcutInfo[];
+    /** The automation list, its names, or its OS registrations changed. */
+    'automation.state': {
+        automations: AutomationInfo[];
     };
     /** Network channel aggregates; `sources` includes webcam status and is optional for older servers. */
     'tracking.status': {

package/dist/wire/events.js

@@ -1,10 +1,11 @@
+import { isOneOf } from "../values/guards.js";
 // Built from a `Record<EventName, …>` so a new EventMap key that is missing
 // here fails the build instead of silently failing `isEventName`.
 export const EVENT_NAMES = Object.keys({
     'scene.changed': true,
     'settings.changed': true,
     'hotkey.state': true,
-    'shortcut.state': true,
+    'automation.state': true,
     'tracking.status': true,
     'instance.loaded': true,
     'expression.changed': true,
@@ -18,5 +19,5 @@ export const EVENT_NAMES = Object.keys({
     'expression.persistence': true,
 });
 export function isEventName(v) {
-    return typeof v === 'string' && EVENT_NAMES.includes(v);
+    return isOneOf(v, EVENT_NAMES);
 }

package/dist/wire/methods.d.ts

@@ -3,7 +3,7 @@ import type { ControllerMovementConfig, ControllerState } from '../values/contro
 import type { LipSyncCalibrationCommand, LipSyncConfig, LipSyncMode, LipSyncState } from '../values/lipsync.ts';
 import type { SceneInspection } from '../values/stage-info.ts';
 import type { EventName } from './events.ts';
-import type { AnchorOption, AppCapability, AssetKind, AssetRef, Attach, AttachHeadAngle, BindingInput, Expression, ExpressionPersistence, HandTrackingMode, HotkeyConfig, HotkeyState, InjectEntry, InjectTarget, InstanceRuntime, JsonValue, LayerEffectKey, LayerEffects, LayerEffectsPatch, MediaPipeConfig, ModelInfo, ModelRef, MotionGroup, MToonTuning, ObjectContent, ObjectLightOverride, ObjectSpace, Place2D, Place3D, PlayingMotion, PoseSourceId, PoseStatus, Scene, SceneItem, ScenePatch, SceneState, ScreenPlacement, Settings, SettingsPatch, ShortcutInfo, TrackingSourceConfig, TrackingSourceId, TrackingSourceKind, TrackingStatus, VrmPlacement } from './types.ts';
+import type { AnchorOption, AppCapability, AssetKind, AssetRef, Attach, AttachHeadAngle, AutomationInfo, BindingInput, Expression, ExpressionPersistence, HandTrackingMode, HotkeyConfig, HotkeyState, InjectEntry, InjectTarget, InstanceRuntime, JsonValue, LayerEffectKey, LayerEffects, LayerEffectsPatch, MediaPipeConfig, ModelInfo, ModelRef, MotionGroup, MToonTuning, ObjectContent, ObjectLightOverride, ObjectSpace, Place2D, Place3D, PlayingMotion, PoseSourceId, PoseStatus, Scene, SceneItem, ScenePatch, SceneState, ScreenPlacement, Settings, SettingsPatch, TrackingSourceConfig, TrackingSourceId, TrackingSourceKind, TrackingStatus, VrmPlacement } from './types.ts';
 /** Marker for methods that take no parameters; the client lets you omit the argument. */
 export type EmptyRequest = Record<never, never>;
 /** Marker for methods whose success response carries no data. */
@@ -295,14 +295,14 @@ export interface HotkeyTriggerRequest {
     hotkeyId: string;
 }
 export type HotkeyTriggerResponse = EmptyResponse;
-export type ShortcutListRequest = EmptyRequest;
-export interface ShortcutListResponse {
-    shortcuts: ShortcutInfo[];
+export type AutomationListRequest = EmptyRequest;
+export interface AutomationListResponse {
+    automations: AutomationInfo[];
 }
-export interface ShortcutTriggerRequest {
-    shortcutId: string;
+export interface AutomationRunRequest {
+    automationId: string;
 }
-export type ShortcutTriggerResponse = EmptyResponse;
+export type AutomationRunResponse = EmptyResponse;
 export type ModelListRequest = EmptyRequest;
 export interface ModelListResponse {
     models: ModelRef[];
@@ -842,13 +842,13 @@ export interface MethodMap {
         request: HotkeyTriggerRequest;
         response: HotkeyTriggerResponse;
     };
-    'shortcut.list': {
-        request: ShortcutListRequest;
-        response: ShortcutListResponse;
+    'automation.list': {
+        request: AutomationListRequest;
+        response: AutomationListResponse;
     };
-    'shortcut.trigger': {
-        request: ShortcutTriggerRequest;
-        response: ShortcutTriggerResponse;
+    'automation.run': {
+        request: AutomationRunRequest;
+        response: AutomationRunResponse;
     };
     'model.list': {
         request: ModelListRequest;

package/dist/wire/protocol.d.ts

@@ -1,10 +1,12 @@
 import type { InjectTarget } from './types.ts';
 /** Bumped on breaking wire changes; the server reports it in `hello` and clients warn on mismatch. */
-export declare const PROTOCOL_VERSION = 3;
+export declare const PROTOCOL_VERSION = 4;
 /** Default port the Persona API server listens on (user-configurable in the app). */
 export declare const DEFAULT_API_PORT = 25034;
 /** Default host clients dial: the server binds loopback unless LAN is opted in. */
 export declare const DEFAULT_API_HOST = "127.0.0.1";
+/** Scene activation waits for asset preparation before committing the new scene. */
+export declare const SCENE_ACTIVATION_TIMEOUT_MS = 120000;
 /** Server close code: the session's API key was revoked. Terminal — the client must not redial. */
 export declare const CLOSE_KEY_REVOKED = 4001;
 /** Server close code: the user disconnected this session from Persona's settings. Terminal — the client must not redial. */

package/dist/wire/protocol.js

@@ -1,9 +1,11 @@
 /** Bumped on breaking wire changes; the server reports it in `hello` and clients warn on mismatch. */
-export const PROTOCOL_VERSION = 3;
+export const PROTOCOL_VERSION = 4;
 /** Default port the Persona API server listens on (user-configurable in the app). */
 export const DEFAULT_API_PORT = 25034;
 /** Default host clients dial: the server binds loopback unless LAN is opted in. */
 export const DEFAULT_API_HOST = '127.0.0.1';
+/** Scene activation waits for asset preparation before committing the new scene. */
+export const SCENE_ACTIVATION_TIMEOUT_MS = 120_000;
 /** Server close code: the session's API key was revoked. Terminal — the client must not redial. */
 export const CLOSE_KEY_REVOKED = 4001;
 /** Server close code: the user disconnected this session from Persona's settings. Terminal — the client must not redial. */

package/dist/wire/schemas.d.ts

@@ -1,6 +1,22 @@
 import * as z from 'zod';
 import type { MethodName } from './methods.ts';
 import type { HotkeyConfig, ObjectContent } from './types.ts';
+/** A complete transition replacement; scene.patch remains stage-owned for its other slices. */
+export declare const SceneTransitionSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        circle: "circle";
+        image: "image";
+        video: "video";
+        cut: "cut";
+        fade: "fade";
+        wipe: "wipe";
+    }>;
+    durationMs: z.ZodNumber;
+    color: z.ZodString;
+    assetId: z.ZodNullable<z.ZodString>;
+    switchPoint: z.ZodNumber;
+    autoFade: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
 export declare const InjectTargetSchema: z.ZodObject<{
     type: z.ZodEnum<{
         input: "input";
@@ -164,8 +180,8 @@ export declare const requestSchemas: {
     'hotkey.trigger': z.ZodObject<{
         hotkeyId: z.ZodString;
     }, z.core.$strip>;
-    'shortcut.trigger': z.ZodObject<{
-        shortcutId: z.ZodString;
+    'automation.run': z.ZodObject<{
+        automationId: z.ZodString;
     }, z.core.$strip>;
     'tracking.addSource': z.ZodObject<{
         kind: z.ZodEnum<{

package/dist/wire/schemas.js

@@ -1,15 +1,25 @@
 import * as z from 'zod';
 import { CONTROLLER_DEAD_ZONE_MAX } from "../values/controller.js";
 import { isRecord } from "../values/guards.js";
-import { SPEECH_URL_MAX_LENGTH, STORAGE_KEY_MAX_LENGTH, STORAGE_VALUE_MAX_LENGTH } from "../values/limits.js";
+import { SCENE_COLOR_RE, SPEECH_URL_MAX_LENGTH, STORAGE_KEY_MAX_LENGTH, STORAGE_VALUE_MAX_LENGTH, } from "../values/limits.js";
 import { LIP_SYNC_CALIBRATION_ACTIONS, LIP_SYNC_GAIN_MAX, LIP_SYNC_MODES, LIP_SYNC_NOISE_GATE_MIN, LIP_SYNC_PHONEMES, LIP_SYNC_SMOOTHING_MAX, } from "../values/lipsync.js";
-import { ASSET_KINDS, POSE_SOURCE_IDS, TRACKING_SOURCE_IDS, TRACKING_SOURCE_KINDS } from "./types.js";
+import { SCENE_TRANSITION_DURATION_MAX_MS, SCENE_TRANSITION_DURATION_MIN_MS, SCENE_TRANSITION_SWITCH_POINT_MAX, SCENE_TRANSITION_SWITCH_POINT_MIN, SCENE_TRANSITION_TYPES, } from "../values/scene-transition.js";
+import { ASSET_KINDS, EFFECTS_QUALITY_LEVELS, INJECT_TARGET_TYPES, LIVE2D_ENGINES, MEDIAPIPE_DELEGATES, POSE_SOURCE_IDS, TRACKING_SOURCE_IDS, TRACKING_SOURCE_KINDS, } from "./types.js";
 // Runtime validation for the request side of the wire. Schemas exist for the
 // methods whose params the app's main process consumes directly; methods without
 // one are stage-owned — the renderer validates and heals them (same rules as the
 // panel). Fields marked z.custom are deliberately gated shallowly here because
 // the app heals them into shape server-side.
 const nonEmpty = z.string().min(1);
+/** A complete transition replacement; scene.patch remains stage-owned for its other slices. */
+export const SceneTransitionSchema = z.object({
+    type: z.enum(SCENE_TRANSITION_TYPES),
+    durationMs: z.number().min(SCENE_TRANSITION_DURATION_MIN_MS).max(SCENE_TRANSITION_DURATION_MAX_MS),
+    color: z.string().regex(SCENE_COLOR_RE),
+    assetId: nonEmpty.refine(v => v.trim() !== '', 'assetId must not be blank').nullable(),
+    switchPoint: z.number().min(SCENE_TRANSITION_SWITCH_POINT_MIN).max(SCENE_TRANSITION_SWITCH_POINT_MAX),
+    autoFade: z.boolean().default(false),
+});
 const port = z.number().int().min(1).max(65535);
 const lipSyncCalibration = z.discriminatedUnion('action', [
     z.object({ action: z.enum(LIP_SYNC_CALIBRATION_ACTIONS) }),
@@ -28,10 +38,10 @@ const mediapipePatch = z.object({
     face: z.boolean().optional(),
     hands: z.boolean().optional(),
     body: z.boolean().optional(),
-    delegate: z.enum(['CPU', 'GPU']).optional(),
+    delegate: z.enum(MEDIAPIPE_DELEGATES).optional(),
 });
 export const InjectTargetSchema = z.object({
-    type: z.enum(['input', 'live2d-param', 'vrm-expression']),
+    type: z.enum(INJECT_TARGET_TYPES),
     id: nonEmpty,
     instanceId: nonEmpty.optional(),
 });
@@ -49,9 +59,9 @@ export const SettingsPatchSchema = z.object({
         showFps: z.boolean().optional(),
         fpsLimit: z.number().optional(),
         selectionOutline: z.boolean().optional(),
-        effectsQuality: z.enum(['high', 'medium', 'low']).optional(),
+        effectsQuality: z.enum(EFFECTS_QUALITY_LEVELS).optional(),
         renderScale: z.number().optional(),
-        live2dEngine: z.enum(['pixi', 'three']).optional(),
+        live2dEngine: z.enum(LIVE2D_ENGINES).optional(),
     })
         .optional(),
 });
@@ -114,7 +124,7 @@ export const requestSchemas = {
         config: z.custom(isRecord, 'config must be a hotkey config'),
     }),
     'hotkey.trigger': z.object({ hotkeyId: nonEmpty }),
-    'shortcut.trigger': z.object({ shortcutId: nonEmpty }),
+    'automation.run': z.object({ automationId: nonEmpty }),
     'tracking.addSource': z.object({
         // Straight off the kind registry, for the same reason as ASSET_KINDS below: a schema
         // narrower than the constant answers invalid-params for a kind the app itself accepts.

package/dist/wire/types.d.ts

@@ -1,5 +1,6 @@
 import type { ControllerConfig } from '../values/controller.ts';
-import type { EFFECT_SCOPES } from '../values/effect-schema.ts';
+import type { EFFECT_BLEND_MODES, EFFECT_SCOPES } from '../values/effect-schema.ts';
+import type { SCENE_TRANSITION_TYPES } from '../values/scene-transition.ts';
 import { type ArkitInputName } from '../values/arkit.ts';
 import { type BaseControllerInputName, type ControllerInputName, type ControllerMovementConfig } from '../values/controller.ts';
 import { type HandInputName } from '../values/hands.ts';
@@ -175,7 +176,8 @@ export interface SceneModelItem {
     /** MToon material fine-tuning, VRM only. */
     mtoon: MToonTuning;
 }
-export type ObjectSpace = '2d' | '3d';
+export declare const OBJECT_SPACES: readonly ["2d", "3d"];
+export type ObjectSpace = (typeof OBJECT_SPACES)[number];
 /** Where a webpage overlay renders relative to the stage. */
 export type WebLayer = 'behind' | 'front';
 export type CaptureKind = 'display' | 'window';
@@ -608,7 +610,7 @@ export interface SceneDroplets {
     glints: number;
 }
 /** Blend modes shared by Shoost's rim light and gradient. */
-export type EffectBlendMode = 'normal' | 'darken' | 'multiply' | 'colorBurn' | 'linearBurn' | 'add' | 'lighten' | 'screen' | 'colorDodge' | 'overlay' | 'softLight' | 'hardLight' | 'vividLight' | 'linearLight' | 'pinLight' | 'hardMix' | 'difference' | 'exclusion' | 'subtract' | 'divide' | 'hue' | 'saturation' | 'color' | 'luminosity';
+export type EffectBlendMode = (typeof EFFECT_BLEND_MODES)[number];
 /** Solid, linear, or radial color overlay in scene or source coordinates. */
 export interface EffectGradient {
     enabled: boolean;
@@ -840,6 +842,19 @@ export interface SceneEnvironment {
      */
     effectLayers: ToggleEffectKey[];
 }
+/** An effect played when this destination scene becomes active. */
+export interface SceneTransition {
+    type: (typeof SCENE_TRANSITION_TYPES)[number];
+    /** Total animation time in milliseconds, 100–10,000; cuts are immediate. */
+    durationMs: number;
+    color: string;
+    /** A registered image/video id; filesystem paths never cross the wire. */
+    assetId: string | null;
+    /** Fraction of the animation where the scene changes, 0.05–0.95. */
+    switchPoint: number;
+    /** Fade a video's opacity at its start and end; false preserves the clip's authored alpha. */
+    autoFade: boolean;
+}
 export interface Scene {
     id: string;
     name: string;
@@ -852,6 +867,8 @@ export interface Scene {
     /** Array order is display order only; live lights are keyed by id. */
     lights: SceneLight[];
     environment: SceneEnvironment;
+    /** Absent on older hosts; gate editing on the `scene-transitions` capability. */
+    transition?: SceneTransition;
     /** Electron accelerator that applies this scene, or null. */
     shortcut: string | null;
 }
@@ -871,12 +888,13 @@ export interface ScenePatch {
     vrmCamera?: SceneCamera;
     lights?: SceneLight[];
     environment?: SceneEnvironment;
+    transition?: SceneTransition;
 }
 /**
  * App-level features a client gates on (never version-sniff): `hello` and
  * `app.info` report them — the per-app mirror of {@link InstanceRuntime.capabilities}.
  */
-export declare const APP_CAPABILITIES: readonly ["storage", "speech", "shortcuts", "controllers", "model-editing", "asset-inspection", "layer-effects"];
+export declare const APP_CAPABILITIES: readonly ["storage", "speech", "automations", "controllers", "model-editing", "asset-inspection", "layer-effects", "scene-transitions"];
 export type AppCapability = (typeof APP_CAPABILITIES)[number];
 export declare function isAppCapability(v: unknown): v is AppCapability;
 /** What a loaded model instance can do; absent capabilities answer `unsupported-for-format`. */
@@ -948,23 +966,27 @@ export interface HotkeyState extends HotkeyConfig {
     /** Hotkey ids currently registered with the OS (active model only). */
     registered: string[];
 }
-/** Action kinds an app shortcut can carry today; servers may send kinds newer than this list. */
-export declare const SHORTCUT_ACTION_KINDS: readonly ["effect-toggle", "effect-params", "camera-pose", "reset-camera", "layer-visibility", "stream-mode"];
-export type ShortcutActionKind = (typeof SHORTCUT_ACTION_KINDS)[number];
+/** Action kinds an app automation can carry today; servers may send kinds newer than this list. */
+export declare const AUTOMATION_ACTION_KINDS: readonly ["effect-toggle", "effect-params", "camera-pose", "reset-camera", "layer-visibility", "stream-mode", "delay"];
+export type AutomationActionKind = (typeof AUTOMATION_ACTION_KINDS)[number];
 /**
- * One app-level global shortcut (a multi-action macro) as clients see it. Action
- * payloads stay app-side — `actionKinds` is what drives derived labels.
+ * One app automation as clients see it. Action payloads stay app-side — `actionKinds`
+ * drives derived labels.
  */
-export interface ShortcutInfo {
+export interface AutomationInfo {
     id: string;
-    /** User-given name, or null — derive a label from `actionKinds` (see `shortcutLabel`). */
+    /** User-given name, or null — derive a label from `actionKinds` (see `automationLabel`). */
     title: string | null;
-    /** Bound key combo, or null for a trigger-only shortcut (`shortcut.trigger` still fires it). */
+    /** Bound key combo, or null when the automation has no keyboard/controller trigger. */
     accelerator: string | null;
     /** May include kinds newer than this SDK; label those generically. */
     actionKinds: string[];
     /** Whether the combo is currently registered with the OS. */
     registered: boolean;
+    /** Whether this automation can run. */
+    enabled: boolean;
+    /** Additional event trigger kinds. Trigger settings stay desktop-side. */
+    triggerKinds: string[];
 }
 export interface ExpressionPersistence {
     supported: boolean;
@@ -975,6 +997,8 @@ export interface ExpressionPersistence {
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue;
 };
+export declare const LIVE2D_ENGINES: readonly ["pixi", "three"];
+export type Live2DEngine = (typeof LIVE2D_ENGINES)[number];
 export declare const TRACKING_SOURCE_IDS: readonly ["persona-ios", "ifacialmocap", "vts-ios"];
 export type TrackingSourceId = (typeof TRACKING_SOURCE_IDS)[number];
 /** Body-pose protocols. Every one so far is UDP with a configurable port. */
@@ -985,17 +1009,18 @@ export type PoseStatus = 'off' | 'waiting' | 'tracking';
 /** Every protocol a tracking source instance can speak; face and body kinds. */
 export declare const TRACKING_SOURCE_KINDS: readonly ["persona-ios", "ifacialmocap", "vts-ios", "vmc", "mocopi", "mediapipe"];
 export type TrackingSourceKind = (typeof TRACKING_SOURCE_KINDS)[number];
-export declare const TRACKING_CHANNELS: readonly ["face", "pose", "hands"];
-export type TrackingChannel = (typeof TRACKING_CHANNELS)[number];
+export type TrackingChannel = keyof typeof TRACKING_CHANNEL_FIELDS;
 /** The scene-item binding each channel reads and writes. */
 export declare const TRACKING_CHANNEL_FIELDS: {
     readonly face: "faceSourceId";
     readonly pose: "poseSourceId";
     readonly hands: "handSourceId";
 };
+export declare const TRACKING_CHANNELS: readonly TrackingChannel[];
 export declare const HAND_TRACKING_MODES: readonly ["arms", "fingers"];
 export type HandTrackingMode = (typeof HAND_TRACKING_MODES)[number];
 export declare function isHandTrackingMode(v: unknown): v is HandTrackingMode;
+export declare const MEDIAPIPE_DELEGATES: readonly ["CPU", "GPU"];
 /** The shared webcam source's enabled inference tasks and camera configuration. */
 export interface MediaPipeConfig {
     deviceId: string;
@@ -1003,7 +1028,7 @@ export interface MediaPipeConfig {
     face: boolean;
     hands: boolean;
     body: boolean;
-    delegate: 'CPU' | 'GPU';
+    delegate: (typeof MEDIAPIPE_DELEGATES)[number];
 }
 export declare const DEFAULT_MEDIAPIPE_CONFIG: Readonly<MediaPipeConfig>;
 /** Whether a source kind uses a network face receiver. */
@@ -1088,7 +1113,7 @@ export interface Settings {
         effectsQuality: EffectsQuality;
         /** Absent on older hosts. */
         renderScale?: number;
-        live2dEngine?: 'pixi' | 'three';
+        live2dEngine?: Live2DEngine;
     };
     /** `enabled` gates network face sources; `source` mirrors the first one's kind for old clients. */
     tracking: {
@@ -1118,12 +1143,43 @@ export interface SettingsPatch {
         selectionOutline?: boolean;
         effectsQuality?: EffectsQuality;
         renderScale?: number;
-        live2dEngine?: 'pixi' | 'three';
+        live2dEngine?: Live2DEngine;
     };
 }
-/** VTS's input vocabulary, plus `JawOpen` — the derived half of {@link INPUT_NAMES}. */
-declare const VTS_INPUT_NAMES: readonly ["FaceAngleX", "FaceAngleY", "FaceAngleZ", "FacePositionX", "FacePositionY", "FacePositionZ", "EyeOpenLeft", "EyeOpenRight", "EyeLeftX", "EyeLeftY", "EyeRightX", "EyeRightY", "Brows", "BrowLeftY", "BrowRightY", "MouthSmile", "MouthOpen", "MouthX", "CheekPuff", "JawOpen", "TongueOut"];
-type VtsInputName = (typeof VTS_INPUT_NAMES)[number];
+/**
+ * From VTS's own registry (`FaceTrackingParamInfo.paramNameDictionary`), which is both the
+ * range its editor seeds a new parameter with and what every `.vtube.json` was authored
+ * against. Two families differ deliberately:
+ *
+ * - **the brow inputs** are signed here. VTS lists them `0..1`; we derive them as
+ *   `brow-up − brow-down`, so a frown needs the lower half.
+ * - **`JawOpen`** is absent from VTS's registry — it exists there only as a plugin-created
+ *   parameter, which VTS then special-cases — so its span is the ARKit channel's.
+ */
+declare const VTS_INPUT_RANGES: {
+    readonly FaceAngleX: readonly [-30, 30];
+    readonly FaceAngleY: readonly [-30, 30];
+    readonly FaceAngleZ: readonly [-90, 90];
+    readonly FacePositionX: readonly [-15, 15];
+    readonly FacePositionY: readonly [-15, 15];
+    readonly FacePositionZ: readonly [-10, 10];
+    readonly EyeOpenLeft: readonly [0, 1];
+    readonly EyeOpenRight: readonly [0, 1];
+    readonly EyeLeftX: readonly [-1, 1];
+    readonly EyeLeftY: readonly [-1, 1];
+    readonly EyeRightX: readonly [-1, 1];
+    readonly EyeRightY: readonly [-1, 1];
+    readonly Brows: readonly [-1, 1];
+    readonly BrowLeftY: readonly [-1, 1];
+    readonly BrowRightY: readonly [-1, 1];
+    readonly MouthSmile: readonly [0, 1];
+    readonly MouthOpen: readonly [0, 1];
+    readonly MouthX: readonly [-1, 1];
+    readonly CheekPuff: readonly [0, 1];
+    readonly JawOpen: readonly [0, 1];
+    readonly TongueOut: readonly [0, 1];
+};
+type VtsInputName = keyof typeof VTS_INPUT_RANGES;
 /**
  * Default input vocabulary: face and hand inputs, raw ARKit channels and controller profile 1.
  * Additional controller profile ids are accepted by isInputName without appearing in this list.
@@ -1168,7 +1224,8 @@ export declare function getInputRange(name: InputName): readonly [number, number
  * - `vrm-expression` — reserved, not implemented yet; the server answers
  *   `unsupported-for-format`.
  */
-export type InjectTargetType = 'input' | 'live2d-param' | 'vrm-expression';
+export declare const INJECT_TARGET_TYPES: readonly ["input", "live2d-param", "vrm-expression"];
+export type InjectTargetType = (typeof INJECT_TARGET_TYPES)[number];
 export interface InjectTarget {
     type: InjectTargetType;
     id: string;