@laplace.live/persona-sdk 1.7.0 → 1.8.0

package/dist/index.d.ts

@@ -25,5 +25,6 @@ export * from './wire/errors.ts';
 export * from './wire/events.ts';
 export * from './wire/methods.ts';
 export * from './wire/protocol.ts';
-export * from './wire/schemas.ts';
+export * from './wire/schemas/requests.ts';
+export * from './wire/schemas/settings.ts';
 export * from './wire/types.ts';

package/dist/index.js

@@ -27,5 +27,6 @@ export * from "./wire/errors.js";
 export * from "./wire/events.js";
 export * from "./wire/methods.js";
 export * from "./wire/protocol.js";
-export * from "./wire/schemas.js";
+export * from "./wire/schemas/requests.js";
+export * from "./wire/schemas/settings.js";
 export * from "./wire/types.js";

package/dist/values/controller.d.ts

@@ -35,6 +35,8 @@ export declare function controllerInputName(base: BaseControllerInputName, slot:
 export declare function baseControllerInputName(full: ControllerInputName): BaseControllerInputName;
 /** Whether an input names a supported controller parameter. */
 export declare function isControllerInputName(v: string): v is ControllerInputName;
+/** JSON Schema pattern for the numbered (slot 2+) spellings of these base inputs; slot 1 keeps the bare names. */
+export declare function numberedControllerInputPattern(bases: readonly BaseControllerInputName[]): string;
 /** Natural parameter range, shared by every controller profile. */
 export declare function controllerInputRange(name: ControllerInputName): readonly [number, number];
 /** VTS shortcut names differ from parameter names, especially shoulders, clicks and D-pad. */

package/dist/values/controller.js

@@ -58,6 +58,10 @@ export function isControllerInputName(v) {
     const parts = controllerParts(v);
     return parts !== null && CONTROLLER_INPUT_SET.has(parts.base);
 }
+/** JSON Schema pattern for the numbered (slot 2+) spellings of these base inputs; slot 1 keeps the bare names. */
+export function numberedControllerInputPattern(bases) {
+    return `^Controller(?:[2-9]|[1-9][0-9]+)(?:${bases.map(base => base.slice('Controller'.length)).join('|')})$`;
+}
 /** Natural parameter range, shared by every controller profile. */
 export function controllerInputRange(name) {
     return BASE_CONTROLLER_INPUT_RANGES[baseControllerInputName(name)];

package/dist/values/edit-history.d.ts

@@ -12,6 +12,8 @@ export interface EditHistory<T> {
     undo(): T | null;
     /** Step forward; mirror of {@link EditHistory.undo}. */
     redo(): T | null;
+    canUndo(): boolean;
+    canRedo(): boolean;
     /**
      * Rewrite the run of entries around the cursor that share its `runKey`, outward until the key
      * changes on either side — a fold, never a step, so undo and redo across the run all carry it.

package/dist/values/edit-history.js

@@ -36,6 +36,8 @@ export function createEditHistory(limit = EDIT_HISTORY_LIMIT) {
             cursor++;
             return structuredClone(stack[cursor].value);
         },
+        canUndo: () => cursor > 0,
+        canRedo: () => cursor < stack.length - 1,
         amend(runKey, rewrite) {
             const cur = stack[cursor];
             if (!cur)

package/dist/values/labels.d.ts

@@ -9,12 +9,9 @@ export declare function fileBasename(path: string): string;
 export declare function motionLabel(file: string): string;
 /** English label for one automation action kind; kinds newer than this SDK read `Action`. */
 export declare function automationActionLabel(kind: string): string;
-/** True for an action that ends a batch and waits before continuing. */
+/** True for an action that prepares the scene before playback. */
 export declare function isAutomationBoundary(kind: string | undefined): kind is AutomationBoundaryKind;
-/**
- * Join one automation's action labels: a batch boundary reads as an arrow, while actions
- * inside a batch read as ` + `. `kinds` must match `labels` in length and position.
- */
+/** Join action labels without implying timing that the client summary does not carry. */
 export declare function joinAutomationActionLabels(labels: readonly string[], kinds: readonly string[]): string;
 /** Display label for an app automation: its title, else its joined action-kind labels. */
 export declare function automationLabel(automation: Pick<AutomationInfo, 'title' | 'actionKinds'>): string;

package/dist/values/labels.js

@@ -17,6 +17,7 @@ export function motionLabel(file) {
 const AUTOMATION_ACTION_KIND_LABELS = {
     'effect-toggle': 'Toggle Effect',
     'effect-params': 'Effect Settings',
+    'effect-clip': 'Effect Clip',
     'camera-pose': 'Camera Position',
     'reset-camera': 'Reset Camera',
     'layer-visibility': 'Layer Visibility',
@@ -24,29 +25,27 @@ const AUTOMATION_ACTION_KIND_LABELS = {
     'switch-scene': 'Switch Scene',
     'toggle-expression': 'Toggle Expression',
     'play-motion': 'Play Motion',
+    'play-audio': 'Play Audio',
+    'audio-control': 'Control Audio',
+    'play-camera-motion': 'Play Camera Motion',
+    'stop-camera-motion': 'Stop Camera Motion',
     'remove-all-expressions': 'Clear All Expressions',
     'load-model': 'Swap Model',
     'model-position': 'Model Position',
-    delay: 'Wait',
 };
 /** English label for one automation action kind; kinds newer than this SDK read `Action`. */
 export function automationActionLabel(kind) {
     return AUTOMATION_ACTION_KIND_LABELS[kind] ?? 'Action';
 }
-/** True for an action that ends a batch and waits before continuing. */
+/** True for an action that prepares the scene before playback. */
 export function isAutomationBoundary(kind) {
     return isOneOf(kind, AUTOMATION_BOUNDARY_KINDS);
 }
-/**
- * Join one automation's action labels: a batch boundary reads as an arrow, while actions
- * inside a batch read as ` + `. `kinds` must match `labels` in length and position.
- */
+/** Join action labels without implying timing that the client summary does not carry. */
 export function joinAutomationActionLabels(labels, kinds) {
     if (labels.length !== kinds.length)
         throw new RangeError('automation action labels and kinds must have the same length');
-    return labels.reduce((out, label, i) => out +
-        (i === 0 ? '' : isAutomationBoundary(kinds[i]) || isAutomationBoundary(kinds[i - 1]) ? ' → ' : ' + ') +
-        label, '');
+    return labels.join(' · ');
 }
 /** Display label for an app automation: its title, else its joined action-kind labels. */
 export function automationLabel(automation) {

package/dist/values/limits.d.ts

@@ -39,9 +39,17 @@ export declare function sceneLightShadowRadiusMax(type: SceneLightType): number;
 export declare const SCENE_FOG_DENSITY_MAX = 0.5;
 /** ×4 is +2 stops — enough to rescue an AgX-dimmed avatar without turning the slider to mush. */
 export declare const SCENE_EXPOSURE_MAX = 4;
-/** Vertical field of view in degrees; the band either side of a portrait lens, before the framing distorts. */
+/** Manual editor field-of-view range in degrees. Authored cameras use CAMERA_FOV_MIN/MAX. */
 export declare const SCENE_FOV_MIN = 10;
 export declare const SCENE_FOV_MAX = 90;
+/** Nonsingular authored field of view in degrees, including every valid whole-degree VMD key. */
+export declare const CAMERA_FOV_MIN = 1;
+export declare const CAMERA_FOV_MAX = 179;
+/** Manual navigation stops short of ±90°; authored camera elevations remain unrestricted. */
+export declare const ELEVATION_LIMIT: number;
+/** Manual navigation distance bounds; authored cameras retain signed, unrestricted distances. */
+export declare const DISTANCE_MIN = 0.35;
+export declare const DISTANCE_MAX = 20;
 /** ×2 doubles Cubism's own breath amplitude — past that the head sway reads as a nod, not a breath. */
 export declare const BREATH_DEPTH_MAX = 2;
 export declare const MTOON_NORMAL_SCALE_MAX = 2;

package/dist/values/limits.js

@@ -62,9 +62,17 @@ export function sceneLightShadowRadiusMax(type) {
 export const SCENE_FOG_DENSITY_MAX = 0.5;
 /** ×4 is +2 stops — enough to rescue an AgX-dimmed avatar without turning the slider to mush. */
 export const SCENE_EXPOSURE_MAX = 4;
-/** Vertical field of view in degrees; the band either side of a portrait lens, before the framing distorts. */
+/** Manual editor field-of-view range in degrees. Authored cameras use CAMERA_FOV_MIN/MAX. */
 export const SCENE_FOV_MIN = 10;
 export const SCENE_FOV_MAX = 90;
+/** Nonsingular authored field of view in degrees, including every valid whole-degree VMD key. */
+export const CAMERA_FOV_MIN = 1;
+export const CAMERA_FOV_MAX = 179;
+/** Manual navigation stops short of ±90°; authored camera elevations remain unrestricted. */
+export const ELEVATION_LIMIT = (80 * Math.PI) / 180;
+/** Manual navigation distance bounds; authored cameras retain signed, unrestricted distances. */
+export const DISTANCE_MIN = 0.35;
+export const DISTANCE_MAX = 20;
 /** ×2 doubles Cubism's own breath amplitude — past that the head sway reads as a nod, not a breath. */
 export const BREATH_DEPTH_MAX = 2;
 export const MTOON_NORMAL_SCALE_MAX = 2;

package/dist/values/lipsync.d.ts

@@ -8,6 +8,10 @@ export type LipSyncMode = (typeof LIP_SYNC_MODES)[number];
 export declare const LIP_SYNC_GAIN_MAX = 30;
 export declare const LIP_SYNC_NOISE_GATE_MIN = -60;
 export declare const LIP_SYNC_SMOOTHING_MAX = 0.3;
+/** Persisted calibration dimensions, shared by the analyzer, healer, and settings schema. */
+export declare const LIP_SYNC_MFCC_COEFFICIENTS = 12;
+export declare const LIP_SYNC_MIN_SAMPLES = 12;
+export declare const LIP_SYNC_MAX_SAMPLES = 40;
 /** Local microphone calibration; each sample is a 12-coefficient MFCC vector. */
 export interface LipSyncProfile {
     deviceId: string;

package/dist/values/lipsync.js

@@ -7,6 +7,10 @@ export const LIP_SYNC_MODES = ['off', 'always', 'when-untracked'];
 export const LIP_SYNC_GAIN_MAX = 30;
 export const LIP_SYNC_NOISE_GATE_MIN = -60;
 export const LIP_SYNC_SMOOTHING_MAX = 0.3;
+/** Persisted calibration dimensions, shared by the analyzer, healer, and settings schema. */
+export const LIP_SYNC_MFCC_COEFFICIENTS = 12;
+export const LIP_SYNC_MIN_SAMPLES = 12;
+export const LIP_SYNC_MAX_SAMPLES = 40;
 /** Calibration steps that carry no phoneme; `record` is the sixth action and takes one. */
 export const LIP_SYNC_CALIBRATION_ACTIONS = ['start', 'cancel', 'preview', 'save', 'reset'];
 export const DEFAULT_LIP_SYNC_CONFIG = {
@@ -31,10 +35,10 @@ export function healLipSyncProfile(raw) {
     const samples = { A: [], I: [], U: [], E: [], O: [], S: [] };
     for (const phoneme of LIP_SYNC_PHONEMES) {
         const vectors = raw.samples[phoneme];
-        if (!Array.isArray(vectors) || vectors.length < 12 || vectors.length > 40)
+        if (!Array.isArray(vectors) || vectors.length < LIP_SYNC_MIN_SAMPLES || vectors.length > LIP_SYNC_MAX_SAMPLES)
             return null;
         for (const vector of vectors) {
-            if (!Array.isArray(vector) || vector.length !== 12 || !vector.every(isFiniteNumber))
+            if (!Array.isArray(vector) || vector.length !== LIP_SYNC_MFCC_COEFFICIENTS || !vector.every(isFiniteNumber))
                 return null;
             samples[phoneme].push([...vector]);
         }

package/dist/wire/{schemas.d.ts → schemas/requests.d.ts}

@@ -1,12 +1,12 @@
 import * as z from 'zod';
-import type { MethodName } from './methods.ts';
-import type { HotkeyConfig, ObjectContent } from './types.ts';
+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";
+        circle: "circle";
         cut: "cut";
         fade: "fade";
         wipe: "wipe";
@@ -39,38 +39,6 @@ export declare const InjectEntrySchema: z.ZodObject<{
     value: z.ZodNumber;
     weight: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-export declare const SettingsPatchSchema: z.ZodObject<{
-    lipSync: z.ZodOptional<z.ZodObject<{
-        enabled: z.ZodOptional<z.ZodBoolean>;
-        deviceId: z.ZodOptional<z.ZodString>;
-        gain: z.ZodOptional<z.ZodNumber>;
-        noiseGate: z.ZodOptional<z.ZodNumber>;
-        smoothing: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    controller: z.ZodOptional<z.ZodObject<{
-        enabled: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    window: z.ZodOptional<z.ZodObject<{
-        alwaysOnTop: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    ui: z.ZodOptional<z.ZodObject<{
-        trayVisible: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    performance: z.ZodOptional<z.ZodObject<{
-        showFps: z.ZodOptional<z.ZodBoolean>;
-        fpsLimit: z.ZodOptional<z.ZodNumber>;
-        effectsQuality: z.ZodOptional<z.ZodEnum<{
-            low: "low";
-            medium: "medium";
-            high: "high";
-        }>>;
-        renderScale: z.ZodOptional<z.ZodNumber>;
-        live2dEngine: z.ZodOptional<z.ZodEnum<{
-            pixi: "pixi";
-            three: "three";
-        }>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
 export declare const requestSchemas: {
     'lipSync.state': z.ZodObject<{}, z.core.$strip>;
     'lipSync.configure': z.ZodObject<{
@@ -233,6 +201,7 @@ export declare const requestSchemas: {
         want: z.ZodOptional<z.ZodEnum<{
             image: "image";
             video: "video";
+            audio: "audio";
             prop: "prop";
             ibl: "ibl";
             lut: "lut";
@@ -262,9 +231,9 @@ export declare const requestSchemas: {
                 showFps: z.ZodOptional<z.ZodBoolean>;
                 fpsLimit: z.ZodOptional<z.ZodNumber>;
                 effectsQuality: z.ZodOptional<z.ZodEnum<{
+                    high: "high";
                     low: "low";
                     medium: "medium";
-                    high: "high";
                 }>>;
                 renderScale: z.ZodOptional<z.ZodNumber>;
                 live2dEngine: z.ZodOptional<z.ZodEnum<{
@@ -320,10 +289,10 @@ export declare const requestSchemas: {
         instanceId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     'events.subscribe': z.ZodObject<{
-        events: z.ZodArray<z.ZodCustom<keyof import("./events.ts").EventMap, keyof import("./events.ts").EventMap>>;
+        events: z.ZodArray<z.ZodCustom<keyof import("../events.ts").EventMap, keyof import("../events.ts").EventMap>>;
     }, z.core.$strip>;
     'events.unsubscribe': z.ZodObject<{
-        events: z.ZodOptional<z.ZodArray<z.ZodCustom<keyof import("./events.ts").EventMap, keyof import("./events.ts").EventMap>>>;
+        events: z.ZodOptional<z.ZodArray<z.ZodCustom<keyof import("../events.ts").EventMap, keyof import("../events.ts").EventMap>>>;
     }, z.core.$strip>;
     'param.inject': z.ZodObject<{
         entries: z.ZodArray<z.ZodObject<{

package/dist/wire/{schemas.js → schemas/requests.js}

@@ -1,10 +1,11 @@
 import * as z from 'zod';
-import { CONTROLLER_DEAD_ZONE_MAX } from "../values/controller.js";
-import { isRecord } from "../values/guards.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 { SCENE_TRANSITION_DURATION_MAX_MS, SCENE_TRANSITION_DURATION_MIN_MS, SCENE_TRANSITION_FADE_DEFAULT_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";
+import { CONTROLLER_DEAD_ZONE_MAX } from "../../values/controller.js";
+import { isRecord } from "../../values/guards.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_MODES, LIP_SYNC_PHONEMES, } from "../../values/lipsync.js";
+import { SCENE_TRANSITION_DURATION_MAX_MS, SCENE_TRANSITION_DURATION_MIN_MS, SCENE_TRANSITION_FADE_DEFAULT_MS, SCENE_TRANSITION_SWITCH_POINT_MAX, SCENE_TRANSITION_SWITCH_POINT_MIN, SCENE_TRANSITION_TYPES, } from "../../values/scene-transition.js";
+import { ASSET_KINDS, INJECT_TARGET_TYPES, POSE_SOURCE_IDS, TRACKING_SOURCE_IDS, TRACKING_SOURCE_KINDS, } from "../types.js";
+import { LipSyncConfigSchema, MediaPipeConfigSchema, PortSchema, SettingsPatchSchema } from "./settings.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
@@ -22,26 +23,12 @@ export const SceneTransitionSchema = z.object({
     fadeInMs: z.number().min(0).max(SCENE_TRANSITION_DURATION_MAX_MS).default(SCENE_TRANSITION_FADE_DEFAULT_MS),
     fadeOutMs: z.number().min(0).max(SCENE_TRANSITION_DURATION_MAX_MS).default(SCENE_TRANSITION_FADE_DEFAULT_MS),
 });
-const port = z.number().int().min(1).max(65535);
 const lipSyncCalibration = z.discriminatedUnion('action', [
     z.object({ action: z.enum(LIP_SYNC_CALIBRATION_ACTIONS) }),
     z.object({ action: z.literal('record'), phoneme: z.enum(LIP_SYNC_PHONEMES) }),
 ]);
-const lipSyncPatch = z.object({
-    enabled: z.boolean().optional(),
-    deviceId: z.string().optional(),
-    gain: z.number().min(0).max(LIP_SYNC_GAIN_MAX).optional(),
-    noiseGate: z.number().min(LIP_SYNC_NOISE_GATE_MIN).max(0).optional(),
-    smoothing: z.number().min(0).max(LIP_SYNC_SMOOTHING_MAX).optional(),
-});
-const mediapipePatch = z.object({
-    deviceId: z.string().optional(),
-    mirror: z.boolean().optional(),
-    face: z.boolean().optional(),
-    hands: z.boolean().optional(),
-    body: z.boolean().optional(),
-    delegate: z.enum(MEDIAPIPE_DELEGATES).optional(),
-});
+const lipSyncPatch = LipSyncConfigSchema.partial();
+const mediapipePatch = MediaPipeConfigSchema.partial();
 export const InjectTargetSchema = z.object({
     type: z.enum(INJECT_TARGET_TYPES),
     id: nonEmpty,
@@ -51,21 +38,6 @@ export const InjectEntrySchema = InjectTargetSchema.extend({
     value: z.number(),
     weight: z.number().min(0).max(1).optional(),
 });
-export const SettingsPatchSchema = z.object({
-    lipSync: lipSyncPatch.optional(),
-    controller: z.object({ enabled: z.boolean().optional() }).optional(),
-    window: z.object({ alwaysOnTop: z.boolean().optional() }).optional(),
-    ui: z.object({ trayVisible: z.boolean().optional() }).optional(),
-    performance: z
-        .object({
-        showFps: z.boolean().optional(),
-        fpsLimit: z.number().optional(),
-        effectsQuality: z.enum(EFFECTS_QUALITY_LEVELS).optional(),
-        renderScale: z.number().optional(),
-        live2dEngine: z.enum(LIVE2D_ENGINES).optional(),
-    })
-        .optional(),
-});
 /** Tolerates unknown names for version skew; the server filters them and reports what took. */
 const lenientEventNameSchema = z.custom(v => typeof v === 'string', 'event names must be strings');
 const storageKey = z.string().min(1).max(STORAGE_KEY_MAX_LENGTH);
@@ -131,7 +103,7 @@ export const requestSchemas = {
         kind: z.enum(TRACKING_SOURCE_KINDS),
         name: z.string().optional(),
         phoneIp: nonEmpty.nullable().optional(),
-        port: port.optional(),
+        port: PortSchema.optional(),
         mediapipe: mediapipePatch.optional(),
     }),
     'tracking.updateSource': z.object({
@@ -139,7 +111,7 @@ export const requestSchemas = {
         name: z.string().optional(),
         enabled: z.boolean().optional(),
         phoneIp: nonEmpty.nullable().optional(),
-        port: port.optional(),
+        port: PortSchema.optional(),
         mediapipe: mediapipePatch.optional(),
     }),
     'tracking.removeSource': z.object({ id: nonEmpty }),
@@ -152,7 +124,7 @@ export const requestSchemas = {
     'tracking.setSource': z.object({ source: z.enum(TRACKING_SOURCE_IDS) }),
     'pose.setEnabled': z.object({ enabled: z.boolean() }),
     'pose.setSource': z.object({ source: z.enum(POSE_SOURCE_IDS) }),
-    'pose.setPort': z.object({ port }),
+    'pose.setPort': z.object({ port: PortSchema }),
     'session.identify': z.object({
         name: z.string().trim().min(1).max(64),
         version: z.string().max(32).optional(),

package/dist/wire/schemas/settings.d.ts

@@ -0,0 +1,284 @@
+import * as z from 'zod';
+/** Shared field definitions; parsing validates values without adding defaults or healing them. */
+export declare const PortSchema: z.ZodNumber;
+export declare const Live2DEngineSchema: z.ZodEnum<{
+    pixi: "pixi";
+    three: "three";
+}>;
+export declare const EffectsQualitySchema: z.ZodEnum<{
+    high: "high";
+    low: "low";
+    medium: "medium";
+}>;
+export declare const LanguageSettingSchema: z.ZodEnum<{
+    en: "en";
+    ja: "ja";
+    "zh-CN": "zh-CN";
+    "zh-TW": "zh-TW";
+    system: "system";
+}>;
+export declare const ThemeSettingSchema: z.ZodEnum<{
+    system: "system";
+    light: "light";
+    dark: "dark";
+}>;
+/** Microphone configuration shared by desktop persistence and the plugin API. */
+export declare const LipSyncConfigSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    deviceId: z.ZodString;
+    gain: z.ZodNumber;
+    noiseGate: z.ZodNumber;
+    smoothing: z.ZodNumber;
+}, z.core.$strip>;
+/** Saved local microphone calibration; raw samples never cross the settings API. */
+export declare const LipSyncProfileSchema: z.ZodObject<{
+    deviceId: z.ZodString;
+    deviceLabel: z.ZodString;
+    updatedAt: z.ZodNumber;
+    samples: z.ZodRecord<z.ZodEnum<{
+        A: "A";
+        I: "I";
+        U: "U";
+        E: "E";
+        O: "O";
+        S: "S";
+    }>, z.ZodArray<z.ZodArray<z.ZodNumber>>>;
+}, z.core.$strip>;
+/** Webcam camera selection and enabled inference tasks. */
+export declare const MediaPipeConfigSchema: z.ZodObject<{
+    deviceId: z.ZodString;
+    mirror: z.ZodBoolean;
+    face: z.ZodBoolean;
+    hands: z.ZodBoolean;
+    body: z.ZodBoolean;
+    delegate: z.ZodEnum<{
+        CPU: "CPU";
+        GPU: "GPU";
+    }>;
+}, z.core.$strip>;
+/** One configured tracking source; several may run concurrently. */
+export declare const TrackingSourceConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        "persona-ios": "persona-ios";
+        ifacialmocap: "ifacialmocap";
+        "vts-ios": "vts-ios";
+        vmc: "vmc";
+        mocopi: "mocopi";
+        mediapipe: "mediapipe";
+    }>;
+    name: z.ZodString;
+    enabled: z.ZodBoolean;
+    phoneIp: z.ZodNullable<z.ZodString>;
+    port: z.ZodNullable<z.ZodNumber>;
+    mediapipe: z.ZodOptional<z.ZodObject<{
+        deviceId: z.ZodString;
+        mirror: z.ZodBoolean;
+        face: z.ZodBoolean;
+        hands: z.ZodBoolean;
+        body: z.ZodBoolean;
+        delegate: z.ZodEnum<{
+            CPU: "CPU";
+            GPU: "GPU";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Public controller profile fields; desktop persistence adds local hardware metadata. */
+export declare const ControllerProfileInfoSchema: z.ZodObject<{
+    slot: z.ZodNumber;
+    deviceId: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    deadZone: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** Controller settings exposed to remote editors. */
+export declare const ControllerConfigSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    profiles: z.ZodArray<z.ZodObject<{
+        slot: z.ZodNumber;
+        deviceId: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        deadZone: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Shared performance fields; desktop healing snaps numeric presets after API patches. */
+export declare const PerformanceSettingsSchema: z.ZodObject<{
+    showFps: z.ZodBoolean;
+    fpsLimit: z.ZodNumber;
+    effectsQuality: z.ZodEnum<{
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>;
+    renderScale: z.ZodNumber;
+    live2dEngine: z.ZodEnum<{
+        pixi: "pixi";
+        three: "three";
+    }>;
+}, z.core.$strip>;
+/** Stage content dimensions in device-independent pixels. */
+export declare const StageSizeSchema: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>;
+/** Face master switch and sources, with the legacy source mirror for older clients. */
+export declare const TrackingSettingsSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    source: z.ZodEnum<{
+        "persona-ios": "persona-ios";
+        ifacialmocap: "ifacialmocap";
+        "vts-ios": "vts-ios";
+    }>;
+    sources: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            "persona-ios": "persona-ios";
+            ifacialmocap: "ifacialmocap";
+            "vts-ios": "vts-ios";
+            vmc: "vmc";
+            mocopi: "mocopi";
+            mediapipe: "mediapipe";
+        }>;
+        name: z.ZodString;
+        enabled: z.ZodBoolean;
+        phoneIp: z.ZodNullable<z.ZodString>;
+        port: z.ZodNullable<z.ZodNumber>;
+        mediapipe: z.ZodOptional<z.ZodObject<{
+            deviceId: z.ZodString;
+            mirror: z.ZodBoolean;
+            face: z.ZodBoolean;
+            hands: z.ZodBoolean;
+            body: z.ZodBoolean;
+            delegate: z.ZodEnum<{
+                CPU: "CPU";
+                GPU: "GPU";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Network body master switch, with source and port mirrors for older clients. */
+export declare const PoseSettingsSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    source: z.ZodEnum<{
+        vmc: "vmc";
+        mocopi: "mocopi";
+    }>;
+    port: z.ZodNumber;
+}, z.core.$strip>;
+/** The curated API response; absent capability fields stay absent on older hosts. */
+export declare const SettingsSchema: z.ZodObject<{
+    lipSync: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        deviceId: z.ZodString;
+        gain: z.ZodNumber;
+        noiseGate: z.ZodNumber;
+        smoothing: z.ZodNumber;
+    }, z.core.$strip>>;
+    controller: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        profiles: z.ZodArray<z.ZodObject<{
+            slot: z.ZodNumber;
+            deviceId: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            deadZone: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    window: z.ZodObject<{
+        alwaysOnTop: z.ZodBoolean;
+        stageSize: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    ui: z.ZodObject<{
+        trayVisible: z.ZodBoolean;
+    }, z.core.$strip>;
+    performance: z.ZodObject<{
+        showFps: z.ZodBoolean;
+        fpsLimit: z.ZodNumber;
+        effectsQuality: z.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+        }>;
+        renderScale: z.ZodOptional<z.ZodNumber>;
+        live2dEngine: z.ZodOptional<z.ZodEnum<{
+            pixi: "pixi";
+            three: "three";
+        }>>;
+    }, z.core.$strip>;
+    tracking: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        source: z.ZodEnum<{
+            "persona-ios": "persona-ios";
+            ifacialmocap: "ifacialmocap";
+            "vts-ios": "vts-ios";
+        }>;
+        sources: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                "persona-ios": "persona-ios";
+                ifacialmocap: "ifacialmocap";
+                "vts-ios": "vts-ios";
+                vmc: "vmc";
+                mocopi: "mocopi";
+                mediapipe: "mediapipe";
+            }>;
+            name: z.ZodString;
+            enabled: z.ZodBoolean;
+            phoneIp: z.ZodNullable<z.ZodString>;
+            port: z.ZodNullable<z.ZodNumber>;
+            mediapipe: z.ZodOptional<z.ZodObject<{
+                deviceId: z.ZodString;
+                mirror: z.ZodBoolean;
+                face: z.ZodBoolean;
+                hands: z.ZodBoolean;
+                body: z.ZodBoolean;
+                delegate: z.ZodEnum<{
+                    CPU: "CPU";
+                    GPU: "GPU";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    pose: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        source: z.ZodEnum<{
+            vmc: "vmc";
+            mocopi: "mocopi";
+        }>;
+        port: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** Allowed settings mutations; unknown and read-only keys are stripped at every level. */
+export declare const SettingsPatchSchema: z.ZodObject<{
+    lipSync: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        deviceId: z.ZodOptional<z.ZodString>;
+        gain: z.ZodOptional<z.ZodNumber>;
+        noiseGate: z.ZodOptional<z.ZodNumber>;
+        smoothing: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    controller: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    window: z.ZodOptional<z.ZodObject<{
+        alwaysOnTop: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    ui: z.ZodOptional<z.ZodObject<{
+        trayVisible: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    performance: z.ZodOptional<z.ZodObject<{
+        showFps: z.ZodOptional<z.ZodBoolean>;
+        fpsLimit: z.ZodOptional<z.ZodNumber>;
+        effectsQuality: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+        }>>;
+        renderScale: z.ZodOptional<z.ZodNumber>;
+        live2dEngine: z.ZodOptional<z.ZodEnum<{
+            pixi: "pixi";
+            three: "three";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/wire/schemas/settings.js

@@ -0,0 +1,125 @@
+import * as z from 'zod';
+import { CONTROLLER_DEAD_ZONE_MAX } from "../../values/controller.js";
+import { LIP_SYNC_GAIN_MAX, LIP_SYNC_MAX_SAMPLES, LIP_SYNC_MFCC_COEFFICIENTS, LIP_SYNC_MIN_SAMPLES, LIP_SYNC_NOISE_GATE_MIN, LIP_SYNC_PHONEMES, LIP_SYNC_SMOOTHING_MAX, } from "../../values/lipsync.js";
+import { LOCALES } from "../../values/locale.js";
+import { EFFECTS_QUALITY_LEVELS, LIVE2D_ENGINES, MEDIAPIPE_DELEGATES, POSE_SOURCE_IDS, TRACKING_SOURCE_IDS, TRACKING_SOURCE_KINDS, } from "../types.js";
+/** Shared field definitions; parsing validates values without adding defaults or healing them. */
+export const PortSchema = z.number().int().min(1).max(65535).describe('Network port, from 1 through 65535.');
+export const Live2DEngineSchema = z.enum(LIVE2D_ENGINES).describe('Engine used to render Live2D models.');
+export const EffectsQualitySchema = z.enum(EFFECTS_QUALITY_LEVELS).describe('Scene and layer effects quality tier.');
+export const LanguageSettingSchema = z
+    .enum(['system', ...LOCALES])
+    .describe('Interface language, or system to follow the operating system.');
+export const ThemeSettingSchema = z
+    .enum(['system', 'light', 'dark'])
+    .describe('Interface appearance, or system to follow the operating system.');
+/** Microphone configuration shared by desktop persistence and the plugin API. */
+export const LipSyncConfigSchema = z.object({
+    enabled: z.boolean().describe('Enable microphone lip sync.'),
+    deviceId: z.string().describe('Microphone device identifier; an empty string selects the system default.'),
+    gain: z.number().min(0).max(LIP_SYNC_GAIN_MAX).describe('Microphone input gain in dB.'),
+    noiseGate: z.number().min(LIP_SYNC_NOISE_GATE_MIN).max(0).describe('Silence threshold in dBFS.'),
+    smoothing: z.number().min(0).max(LIP_SYNC_SMOOTHING_MAX).describe('Volume and vowel smoothing in seconds.'),
+});
+/** Saved local microphone calibration; raw samples never cross the settings API. */
+export const LipSyncProfileSchema = z.object({
+    deviceId: z.string().min(1).describe('Identifier of the calibrated microphone.'),
+    deviceLabel: z.string().describe('Microphone label captured when calibrating.'),
+    updatedAt: z.number().min(0).describe('Calibration timestamp in milliseconds since the Unix epoch.'),
+    samples: z
+        .record(z.enum(LIP_SYNC_PHONEMES), z
+        .array(z.array(z.number().describe('Finite MFCC coefficient.')).length(LIP_SYNC_MFCC_COEFFICIENTS))
+        .min(LIP_SYNC_MIN_SAMPLES)
+        .max(LIP_SYNC_MAX_SAMPLES))
+        .describe('Twelve to forty MFCC samples per phoneme, each containing twelve finite coefficients.'),
+});
+/** Webcam camera selection and enabled inference tasks. */
+export const MediaPipeConfigSchema = z.object({
+    deviceId: z.string().describe('Camera device identifier; an empty string selects the system default.'),
+    mirror: z.boolean().describe('Mirror the webcam tracking input.'),
+    face: z.boolean().describe('Enable webcam face tracking.'),
+    hands: z.boolean().describe('Enable webcam hand tracking.'),
+    body: z.boolean().describe('Enable webcam body tracking.'),
+    delegate: z.enum(MEDIAPIPE_DELEGATES).describe('Processor used for webcam inference.'),
+});
+/** One configured tracking source; several may run concurrently. */
+export const TrackingSourceConfigSchema = z.object({
+    id: z.string().min(1).describe('Stable source identifier used by scene model bindings.'),
+    kind: z.enum(TRACKING_SOURCE_KINDS).describe('Tracking protocol or webcam source kind.'),
+    name: z.string().describe('User label; an empty string displays the source kind label.'),
+    enabled: z.boolean().describe('Enable this tracking source.'),
+    phoneIp: z.string().nullable().describe('Pinned face sender IP, or null to accept any unclaimed sender.'),
+    port: PortSchema.nullable().describe('UDP receive port, or null for protocols with a fixed port.'),
+    mediapipe: MediaPipeConfigSchema.optional().describe('Camera configuration, present only for a webcam source.'),
+});
+/** Public controller profile fields; desktop persistence adds local hardware metadata. */
+export const ControllerProfileInfoSchema = z.object({
+    slot: z.number().int().positive().describe('Positive safe-integer profile identifier, independent of browser index.'),
+    deviceId: z.string().describe('Controller device identifier.'),
+    name: z.string().optional().describe('User-assigned controller label.'),
+    deadZone: z
+        .number()
+        .min(0)
+        .max(CONTROLLER_DEAD_ZONE_MAX)
+        .optional()
+        .describe('Radial stick dead zone; absent until tuned.'),
+});
+/** Controller settings exposed to remote editors. */
+export const ControllerConfigSchema = z.object({
+    enabled: z.boolean().describe('Enable controller input.'),
+    profiles: z.array(ControllerProfileInfoSchema).describe('Saved controller profiles and per-device tuning.'),
+});
+/** Shared performance fields; desktop healing snaps numeric presets after API patches. */
+export const PerformanceSettingsSchema = z.object({
+    showFps: z.boolean().describe('Show the frame-rate overlay.'),
+    fpsLimit: z.number().describe('Frame-rate cap; zero is unlimited. The desktop snaps changes to supported presets.'),
+    effectsQuality: EffectsQualitySchema,
+    renderScale: z.number().describe('Render resolution multiplier. The desktop snaps changes to supported presets.'),
+    live2dEngine: Live2DEngineSchema,
+});
+/** Stage content dimensions in device-independent pixels. */
+export const StageSizeSchema = z.object({
+    width: z.number().describe('Stage content width in device-independent pixels.'),
+    height: z.number().describe('Stage content height in device-independent pixels.'),
+});
+/** Face master switch and sources, with the legacy source mirror for older clients. */
+export const TrackingSettingsSchema = z.object({
+    enabled: z.boolean().describe('Enable network face tracking; webcam tasks use their own switches.'),
+    source: z.enum(TRACKING_SOURCE_IDS).describe('Legacy mirror of the first network face source kind.'),
+    sources: z.array(TrackingSourceConfigSchema).describe('Configured face, body, and webcam sources.'),
+});
+/** Network body master switch, with source and port mirrors for older clients. */
+export const PoseSettingsSchema = z.object({
+    enabled: z.boolean().describe('Enable network body tracking; webcam tasks use their own switches.'),
+    source: z.enum(POSE_SOURCE_IDS).describe('Legacy mirror of the first network body source kind.'),
+    port: PortSchema.describe('Legacy mirror of the first network body source receive port.'),
+});
+/** The curated API response; absent capability fields stay absent on older hosts. */
+export const SettingsSchema = z.object({
+    lipSync: LipSyncConfigSchema.optional().describe('Microphone settings; absent on hosts without microphone lip sync.'),
+    controller: ControllerConfigSchema.optional().describe('Controller settings; absent on older hosts.'),
+    window: z
+        .object({
+        alwaysOnTop: z.boolean().describe('Keep the control-panel window above other windows.'),
+        stageSize: StageSizeSchema.optional().describe('Read-only stage content size; absent on older hosts.'),
+    })
+        .describe('Public window configuration and read-only stage dimensions.'),
+    ui: z
+        .object({ trayVisible: z.boolean().describe('Show the tray or menu bar icon.') })
+        .describe('Public interface preferences.'),
+    performance: PerformanceSettingsSchema.partial({ renderScale: true, live2dEngine: true }).describe('Renderer settings; renderScale and live2dEngine are absent on older hosts.'),
+    tracking: TrackingSettingsSchema.describe('Network face master switch and all configured tracking sources.'),
+    pose: PoseSettingsSchema.describe('Network body master switch and legacy source mirrors.'),
+});
+/** Allowed settings mutations; unknown and read-only keys are stripped at every level. */
+export const SettingsPatchSchema = z.object({
+    lipSync: LipSyncConfigSchema.partial().optional().describe('Microphone fields to update.'),
+    controller: ControllerConfigSchema.pick({ enabled: true }).partial().optional().describe('Controller master switch.'),
+    window: SettingsSchema.shape.window
+        .pick({ alwaysOnTop: true })
+        .partial()
+        .optional()
+        .describe('Control-panel window fields to update.'),
+    ui: SettingsSchema.shape.ui.partial().optional().describe('Public interface fields to update.'),
+    performance: PerformanceSettingsSchema.partial().optional().describe('Renderer fields to update.'),
+});

package/dist/wire/types.d.ts

@@ -1,10 +1,11 @@
-import type { ControllerConfig } from '../values/controller.ts';
+import type * as z from 'zod';
 import type { EFFECT_BLEND_MODES, EFFECT_SCOPES } from '../values/effect-schema.ts';
 import type { SCENE_TRANSITION_TYPES } from '../values/scene-transition.ts';
+import type { SettingsPatchSchema, SettingsSchema } from './schemas/settings.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';
-import { type LipSyncConfig, type LipSyncMode, type VoiceInputName } from '../values/lipsync.ts';
+import { type LipSyncMode, type VoiceInputName } from '../values/lipsync.ts';
 export type ModelFormat = 'live2d' | 'vrm';
 /** Where an item came from: shipped with the app, or added by the user. */
 export type ContentOrigin = 'bundled' | 'user';
@@ -13,7 +14,7 @@ export type ContentOrigin = 'bundled' | 'user';
  * ever an environment map, and a `.vmd` splits by content — `cameraMotion` for one that
  * frames a shot, `animation` for one that drives a rig.
  */
-export declare const ASSET_KINDS: readonly ["image", "video", "prop", "ibl", "lut", "animation", "cameraMotion"];
+export declare const ASSET_KINDS: readonly ["image", "video", "audio", "prop", "ibl", "lut", "animation", "cameraMotion"];
 export type AssetKind = (typeof ASSET_KINDS)[number];
 /** Narrow a kind string to the set the asset registry owns — models and effects have their own. */
 export declare function isAssetKind(v: unknown): v is AssetKind;
@@ -302,8 +303,9 @@ export interface SceneBackground {
 export interface OrbitTransform {
     azimuth: number;
     elevation: number;
+    /** Signed target-to-eye offset along camera-local +Z; negative values cross the target without reversing the view. */
     distance: number;
-    /** Pivot the camera orbits and looks at. Panning moves it along the camera's own axes, so it leaves the XY plane. */
+    /** Framing pivot. Panning moves it along the camera's own axes, so it leaves the XY plane. */
     targetX: number;
     targetY: number;
     targetZ: number;
@@ -311,13 +313,23 @@ export interface OrbitTransform {
 /** Scene-level VRM camera. `orbit: null` = never framed — the first VRM load frames it from model height. */
 export interface SceneCamera {
     orbit: OrbitTransform | null;
+    /** Vertical field of view in degrees, 1–179. */
     fov: number;
+    /** Rotation about camera-local +Z in radians; absent on older hosts, default 0. */
+    roll?: number;
+    /** Absent on older hosts; defaults to perspective. */
+    projection?: 'perspective' | 'orthographic';
     /**
      * A `cameraMotion` asset driving the camera, or null for the user's own orbit. While one
-     * is set it overrides `orbit` and `fov` every frame; neither field is written back.
+     * is set it overrides the framing every frame without writing it back.
      */
     clipAssetId: string | null;
 }
+/**
+ * The slice of {@link SceneCamera} a saved pose snapshots and applies — a framing, never
+ * the clip: applying a pose leaves whatever camera motion the scene has running.
+ */
+export type CameraPose = Pick<SceneCamera, 'orbit' | 'fov' | 'roll' | 'projection'>;
 export type SceneLightType = 'directional' | 'point' | 'ambient';
 /**
  * Per-light shadow tier. `off` is the old `castShadow: false`; the rest raise
@@ -969,10 +981,10 @@ export interface HotkeyState extends HotkeyConfig {
     registered: string[];
 }
 /** 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", "switch-scene", "toggle-expression", "play-motion", "remove-all-expressions", "load-model", "model-position", "delay"];
+export declare const AUTOMATION_ACTION_KINDS: readonly ["effect-toggle", "effect-params", "effect-clip", "camera-pose", "reset-camera", "play-camera-motion", "stop-camera-motion", "layer-visibility", "stream-mode", "switch-scene", "toggle-expression", "play-motion", "play-audio", "audio-control", "remove-all-expressions", "load-model", "model-position"];
 export type AutomationActionKind = (typeof AUTOMATION_ACTION_KINDS)[number];
-/** Kinds that end an action batch: the actions after one wait until it finishes. */
-export declare const AUTOMATION_BOUNDARY_KINDS: readonly ["switch-scene", "load-model", "delay"];
+/** Setup kinds that finish loading before the sequence clock starts. */
+export declare const AUTOMATION_BOUNDARY_KINDS: readonly ["switch-scene", "load-model"];
 export type AutomationBoundaryKind = (typeof AUTOMATION_BOUNDARY_KINDS)[number];
 /**
  * One app automation as clients see it. Action kinds and scene targets drive derived
@@ -1099,58 +1111,9 @@ export interface StageSize {
     height: number;
 }
 /** The curated settings surface the API exposes — never the raw store shape. */
-export interface Settings {
-    /** Absent on hosts without microphone lipsync. */
-    lipSync?: LipSyncConfig;
-    /** Absent on hosts without remote controller management. */
-    controller?: ControllerConfig;
-    /** `alwaysOnTop` floats the control-panel window, never the stage. */
-    window: {
-        alwaysOnTop: boolean;
-        /** Read-only; absent on older desktops. */
-        stageSize?: StageSize;
-    };
-    ui: {
-        trayVisible: boolean;
-    };
-    performance: {
-        showFps: boolean;
-        fpsLimit: number;
-        effectsQuality: EffectsQuality;
-        /** Absent on older hosts. */
-        renderScale?: number;
-        live2dEngine?: Live2DEngine;
-    };
-    /** `enabled` gates network face sources; `source` mirrors the first one's kind for old clients. */
-    tracking: {
-        enabled: boolean;
-        source: TrackingSourceId;
-        sources: TrackingSourceConfig[];
-    };
-    /** `enabled` gates network body sources; `source`/`port` mirror the first one's values for old clients. */
-    pose: {
-        enabled: boolean;
-        source: PoseSourceId;
-        port: number;
-    };
-}
-export interface SettingsPatch {
-    lipSync?: Partial<LipSyncConfig>;
-    controller?: Partial<Pick<ControllerConfig, 'enabled'>>;
-    window?: {
-        alwaysOnTop?: boolean;
-    };
-    ui?: {
-        trayVisible?: boolean;
-    };
-    performance?: {
-        showFps?: boolean;
-        fpsLimit?: number;
-        effectsQuality?: EffectsQuality;
-        renderScale?: number;
-        live2dEngine?: Live2DEngine;
-    };
-}
+export type Settings = z.infer<typeof SettingsSchema>;
+/** Allowed settings mutations; other fields have dedicated API methods or are desktop-private. */
+export type SettingsPatch = z.infer<typeof SettingsPatchSchema>;
 /**
  * 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

package/dist/wire/types.js

@@ -5,13 +5,13 @@ import { ARKIT_INPUT_NAMES } from "../values/arkit.js";
 import { BASE_CONTROLLER_INPUT_NAMES, BASE_CONTROLLER_INPUT_RANGES, controllerInputRange, isControllerInputName, } from "../values/controller.js";
 import { isOneOf, keysOf } from "../values/guards.js";
 import { HAND_INPUT_NAMES, HAND_INPUT_RANGES } from "../values/hands.js";
-import { VOICE_INPUT_NAMES, VOICE_INPUT_RANGES, } from "../values/lipsync.js";
+import { VOICE_INPUT_NAMES, VOICE_INPUT_RANGES } from "../values/lipsync.js";
 /**
  * How a registered file is labelled. Wider than an object's content kinds: `.hdr` is only
  * ever an environment map, and a `.vmd` splits by content — `cameraMotion` for one that
  * frames a shot, `animation` for one that drives a rig.
  */
-export const ASSET_KINDS = ['image', 'video', 'prop', 'ibl', 'lut', 'animation', 'cameraMotion'];
+export const ASSET_KINDS = ['image', 'video', 'audio', 'prop', 'ibl', 'lut', 'animation', 'cameraMotion'];
 /** Narrow a kind string to the set the asset registry owns — models and effects have their own. */
 export function isAssetKind(v) {
     return isOneOf(v, ASSET_KINDS);
@@ -47,23 +47,26 @@ export function isAppCapability(v) {
 export const AUTOMATION_ACTION_KINDS = [
     'effect-toggle',
     'effect-params',
+    'effect-clip',
     'camera-pose',
     'reset-camera',
+    'play-camera-motion',
+    'stop-camera-motion',
     'layer-visibility',
     'stream-mode',
     'switch-scene',
     'toggle-expression',
     'play-motion',
+    'play-audio',
+    'audio-control',
     'remove-all-expressions',
     'load-model',
     'model-position',
-    'delay',
 ];
-/** Kinds that end an action batch: the actions after one wait until it finishes. */
+/** Setup kinds that finish loading before the sequence clock starts. */
 export const AUTOMATION_BOUNDARY_KINDS = [
     'switch-scene',
     'load-model',
-    'delay',
 ];
 // ---- Settings ------------------------------------------------------------------
 export const LIVE2D_ENGINES = ['pixi', 'three'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@laplace.live/persona-sdk",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "TypeScript SDK and wire schema for the LAPLACE Persona plugin API",
   "license": "MIT",
   "type": "module",
@@ -34,7 +34,7 @@
     "node": ">=24"
   },
   "dependencies": {
-    "zod": "^4.6.1"
+    "zod": "^4.6.2"
   },
   "scripts": {
     "build": "rimraf dist && tsc -p tsconfig.build.json",