@laplace.live/persona-sdk 0.0.1

package/dist/schemas.d.ts

@@ -0,0 +1,189 @@
+import * as z from 'zod';
+import type { MethodName } from './methods.ts';
+import type { HotkeyConfig, ObjectContent } from './types.ts';
+export declare const InjectTargetSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        input: "input";
+        "live2d-param": "live2d-param";
+        "vrm-expression": "vrm-expression";
+    }>;
+    id: z.ZodString;
+    instanceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const InjectEntrySchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        input: "input";
+        "live2d-param": "live2d-param";
+        "vrm-expression": "vrm-expression";
+    }>;
+    id: z.ZodString;
+    instanceId: z.ZodOptional<z.ZodString>;
+    value: z.ZodNumber;
+    weight: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const SettingsPatchSchema: z.ZodObject<{
+    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<{
+        backgroundRendering: z.ZodOptional<z.ZodBoolean>;
+        showFps: z.ZodOptional<z.ZodBoolean>;
+        fpsLimit: z.ZodOptional<z.ZodNumber>;
+        selectionOutline: z.ZodOptional<z.ZodBoolean>;
+        effectsQuality: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const requestSchemas: {
+    'scene.get': z.ZodObject<{
+        sceneId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    'scene.activate': z.ZodObject<{
+        sceneId: z.ZodString;
+    }, z.core.$strip>;
+    'scene.duplicate': z.ZodObject<{
+        sceneId: z.ZodString;
+    }, z.core.$strip>;
+    'scene.rename': z.ZodObject<{
+        sceneId: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    'scene.delete': z.ZodObject<{
+        sceneId: z.ZodString;
+    }, z.core.$strip>;
+    'scene.setShortcut': z.ZodObject<{
+        sceneId: z.ZodString;
+        accelerator: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    'instance.add': z.ZodObject<{
+        modelId: z.ZodString;
+    }, z.core.$strip>;
+    'object.add': z.ZodObject<{
+        content: z.ZodCustom<ObjectContent, ObjectContent>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    'object.setContent': z.ZodObject<{
+        instanceId: z.ZodString;
+        content: z.ZodCustom<ObjectContent, ObjectContent>;
+    }, z.core.$strip>;
+    'expression.getPersistence': z.ZodObject<{
+        modelId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    'expression.setPersistence': z.ZodObject<{
+        modelId: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodBoolean;
+    }, z.core.$strip>;
+    'hotkey.list': z.ZodObject<{
+        modelId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    'hotkey.set': z.ZodObject<{
+        modelId: z.ZodOptional<z.ZodString>;
+        config: z.ZodCustom<HotkeyConfig, HotkeyConfig>;
+    }, z.core.$strip>;
+    'hotkey.trigger': z.ZodObject<{
+        hotkeyId: z.ZodString;
+    }, z.core.$strip>;
+    'model.register': z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strip>;
+    'asset.register': z.ZodObject<{
+        path: z.ZodString;
+        want: z.ZodOptional<z.ZodEnum<{
+            image: "image";
+            video: "video";
+            prop: "prop";
+            ibl: "ibl";
+            lut: "lut";
+        }>>;
+    }, z.core.$strip>;
+    'settings.patch': z.ZodObject<{
+        settings: z.ZodObject<{
+            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<{
+                backgroundRendering: z.ZodOptional<z.ZodBoolean>;
+                showFps: z.ZodOptional<z.ZodBoolean>;
+                fpsLimit: z.ZodOptional<z.ZodNumber>;
+                selectionOutline: z.ZodOptional<z.ZodBoolean>;
+                effectsQuality: z.ZodOptional<z.ZodEnum<{
+                    high: "high";
+                    medium: "medium";
+                    low: "low";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    'tracking.setEnabled': z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$strip>;
+    'tracking.setSource': z.ZodObject<{
+        source: z.ZodEnum<{
+            "vts-ios": "vts-ios";
+            "vts-ios-native": "vts-ios-native";
+            ifacialmocap: "ifacialmocap";
+        }>;
+    }, z.core.$strip>;
+    'pose.setEnabled': z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$strip>;
+    'pose.setSource': z.ZodObject<{
+        source: z.ZodEnum<{
+            vmc: "vmc";
+        }>;
+    }, z.core.$strip>;
+    'pose.setPort': z.ZodObject<{
+        port: z.ZodNumber;
+    }, z.core.$strip>;
+    'events.subscribe': z.ZodObject<{
+        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>>>;
+    }, z.core.$strip>;
+    'param.inject': z.ZodObject<{
+        entries: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                input: "input";
+                "live2d-param": "live2d-param";
+                "vrm-expression": "vrm-expression";
+            }>;
+            id: z.ZodString;
+            instanceId: z.ZodOptional<z.ZodString>;
+            value: z.ZodNumber;
+            weight: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    'param.release': z.ZodObject<{
+        targets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                input: "input";
+                "live2d-param": "live2d-param";
+                "vrm-expression": "vrm-expression";
+            }>;
+            id: z.ZodString;
+            instanceId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+};
+/**
+ * Validate one request's params against its method schema. Methods without a
+ * schema pass through verbatim (the stage validates them). On success `params`
+ * is the parsed value — unknown keys stripped, ready to hand to an executor.
+ */
+export declare function parseRequest(method: MethodName, params: unknown): {
+    ok: true;
+    params: unknown;
+} | {
+    ok: false;
+    message: string;
+};

package/dist/schemas.js

@@ -0,0 +1,92 @@
+import * as z from 'zod';
+import { isEventName } from "./events.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.
+function isRecord(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+const nonEmpty = z.string().min(1);
+export const InjectTargetSchema = z.object({
+    type: z.enum(['input', 'live2d-param', 'vrm-expression']),
+    id: nonEmpty,
+    instanceId: nonEmpty.optional(),
+});
+export const InjectEntrySchema = InjectTargetSchema.extend({
+    value: z.number(),
+    weight: z.number().min(0).max(1).optional(),
+});
+export const SettingsPatchSchema = z.object({
+    window: z.object({ alwaysOnTop: z.boolean().optional() }).optional(),
+    ui: z.object({ trayVisible: z.boolean().optional() }).optional(),
+    performance: z
+        .object({
+        backgroundRendering: z.boolean().optional(),
+        showFps: z.boolean().optional(),
+        fpsLimit: z.number().optional(),
+        selectionOutline: z.boolean().optional(),
+        effectsQuality: z.enum(['high', 'medium', 'low']).optional(),
+    })
+        .optional(),
+});
+const eventNameSchema = z.custom(isEventName, 'unknown event name');
+/** Tolerates unknown names (version skew); the server ignores what it cannot map. */
+const lenientEventNameSchema = z.custom(v => typeof v === 'string', 'event names must be strings');
+export const requestSchemas = {
+    'scene.get': z.object({ sceneId: nonEmpty.optional() }),
+    'scene.activate': z.object({ sceneId: nonEmpty }),
+    'scene.duplicate': z.object({ sceneId: nonEmpty }),
+    'scene.rename': z.object({ sceneId: nonEmpty, name: nonEmpty }),
+    'scene.delete': z.object({ sceneId: nonEmpty }),
+    'scene.setShortcut': z.object({ sceneId: nonEmpty, accelerator: nonEmpty.nullable() }),
+    'instance.add': z.object({ modelId: nonEmpty }),
+    'object.add': z.object({
+        content: z.custom(isRecord, 'content must be an object'),
+        name: nonEmpty.optional(),
+    }),
+    'object.setContent': z.object({
+        instanceId: nonEmpty,
+        content: z.custom(isRecord, 'content must be an object'),
+    }),
+    'expression.getPersistence': z.object({ modelId: nonEmpty.optional() }),
+    'expression.setPersistence': z.object({ modelId: nonEmpty.optional(), enabled: z.boolean() }),
+    'hotkey.list': z.object({ modelId: nonEmpty.optional() }),
+    'hotkey.set': z.object({
+        modelId: nonEmpty.optional(),
+        config: z.custom(isRecord, 'config must be a hotkey config'),
+    }),
+    'hotkey.trigger': z.object({ hotkeyId: nonEmpty }),
+    'model.register': z.object({ path: nonEmpty }),
+    'asset.register': z.object({ path: nonEmpty, want: z.enum(['image', 'video', 'prop', 'ibl', 'lut']).optional() }),
+    'settings.patch': z.object({ settings: SettingsPatchSchema }),
+    'tracking.setEnabled': z.object({ enabled: z.boolean() }),
+    'tracking.setSource': z.object({ source: z.enum(['vts-ios', 'vts-ios-native', 'ifacialmocap']) }),
+    'pose.setEnabled': z.object({ enabled: z.boolean() }),
+    'pose.setSource': z.object({ source: z.enum(['vmc']) }),
+    'pose.setPort': z.object({ port: z.number().int().min(1).max(65535) }),
+    'events.subscribe': z.object({ events: z.array(eventNameSchema).min(1) }),
+    'events.unsubscribe': z.object({ events: z.array(lenientEventNameSchema).optional() }),
+    'param.inject': z.object({ entries: z.array(InjectEntrySchema).min(1) }),
+    'param.release': z.object({ targets: z.array(InjectTargetSchema).optional() }),
+};
+/**
+ * Validate one request's params against its method schema. Methods without a
+ * schema pass through verbatim (the stage validates them). On success `params`
+ * is the parsed value — unknown keys stripped, ready to hand to an executor.
+ */
+export function parseRequest(method, params) {
+    if (!Object.hasOwn(requestSchemas, method))
+        return { ok: true, params };
+    const schema = requestSchemas[method];
+    if (schema === undefined)
+        return { ok: true, params };
+    const r = schema.safeParse(params);
+    if (r.success)
+        return { ok: true, params: r.data };
+    const issue = r.error.issues[0];
+    const path = issue === undefined ? '' : issue.path.map(String).join('.');
+    const message = issue?.message ?? 'params do not match the method schema';
+    return { ok: false, message: path === '' ? message : `${path}: ${message}` };
+}

package/dist/types.d.ts

@@ -0,0 +1,390 @@
+export type ModelFormat = 'live2d' | 'vrm';
+export type ModelKind = 'bundled' | 'user';
+/** A model as the registry lists it. Paths deliberately never cross the wire. */
+export interface ModelRef {
+    id: string;
+    name: string;
+    kind: ModelKind;
+    format: ModelFormat;
+}
+export type AssetKind = 'image' | 'video' | 'prop' | 'ibl' | 'lut';
+/** A registered object-source file. `exists` is false once the file is gone from disk. */
+export interface AssetRef {
+    id: string;
+    name: string;
+    kind: AssetKind;
+    exists: boolean;
+}
+/** Screen-space placement: pixels from the stage centre, rotation in radians. */
+export interface ScreenPlacement {
+    x: number;
+    y: number;
+    scale: number;
+    rotation: number;
+}
+/** World-space VRM placement. Rotations in radians. */
+export interface VrmPlacement {
+    x: number;
+    y: number;
+    z: number;
+    rotX: number;
+    rotY: number;
+    rotZ: number;
+    scale: number;
+}
+export interface Place2D extends ScreenPlacement {
+    opacity: number;
+}
+export interface Place3D extends VrmPlacement {
+    opacity: number;
+}
+/** Per-instance MToon fine-tuning, layered over each material's authored values. */
+export interface MToonTuning {
+    shade: number;
+    shadingShift: number;
+    shadingToony: number;
+    giEqualization: number;
+    rim: number;
+    outlineWidth: number;
+    emissive: number;
+}
+export interface SceneModelItem {
+    kind: 'model';
+    instanceId: string;
+    ref: ModelRef;
+    visible: boolean;
+    live2d: ScreenPlacement;
+    vrm: VrmPlacement;
+    idleAnimation: boolean;
+    idleClip: string;
+    mtoon: MToonTuning;
+}
+export type ObjectSpace = '2d' | '3d';
+export type WebLayer = 'behind' | 'front';
+export type CaptureKind = 'display' | 'window';
+export type ObjectContent = {
+    kind: 'image';
+    assetId: string;
+} | {
+    kind: 'video';
+    assetId: string;
+    loop: boolean;
+    muted: boolean;
+    volume: number;
+} | {
+    kind: 'prop';
+    assetId: string;
+} | {
+    kind: 'web';
+    url: string;
+    width: number;
+    height: number;
+    fps: number;
+    transparent: boolean;
+    css: string;
+    layer: WebLayer;
+} | {
+    kind: 'capture';
+    source: CaptureKind;
+    sourceId: string;
+    label: string;
+};
+/** Where on a parent model an object rides. */
+export type AttachAnchor = {
+    kind: 'root';
+} | {
+    kind: 'bone';
+    bone: string;
+} | {
+    kind: 'artMesh';
+    id: string;
+    verts: [number, number, number];
+    weights: [number, number, number];
+};
+export interface Attach {
+    parentInstanceId: string;
+    anchor: AttachAnchor;
+    followRotation: boolean;
+    headAngle: {
+        multiplier: number;
+        smoothing: number;
+    } | null;
+    elasticity: {
+        stiffness: number;
+        damping: number;
+        maxSpeed: number;
+    } | null;
+}
+export interface ObjectLightOverride {
+    enabled: boolean;
+    intensity: number | null;
+}
+export interface SceneObjectItem {
+    kind: 'object';
+    instanceId: string;
+    name: string;
+    visible: boolean;
+    space: ObjectSpace;
+    content: ObjectContent;
+    place2d: Place2D;
+    place3d: Place3D;
+    attach: Attach | null;
+    lightOverrides: Record<string, ObjectLightOverride>;
+}
+export type SceneItem = SceneModelItem | SceneObjectItem;
+export type BackgroundMode = 'transparent' | 'color' | 'image';
+/** `imagePath` is accepted but survives only when the app has allowlisted it via its own picker. */
+export interface SceneBackground {
+    mode: BackgroundMode;
+    color: string;
+    imagePath: string | null;
+}
+export interface SceneBehavior {
+    lookAtCursor: boolean;
+}
+export interface OrbitTransform {
+    azimuth: number;
+    elevation: number;
+    distance: number;
+    targetX: number;
+    targetY: number;
+}
+export interface SceneCamera {
+    orbit: OrbitTransform | null;
+    fov: number;
+}
+export type SceneLightType = 'directional' | 'point' | 'ambient';
+export interface SceneLight {
+    id: string;
+    type: SceneLightType;
+    color: string;
+    intensity: number;
+    azimuth: number;
+    elevation: number;
+    x: number;
+    y: number;
+    z: number;
+    range: number;
+    castShadow: boolean;
+    shadowRadius: number;
+}
+export interface SceneFog {
+    enabled: boolean;
+    color: string;
+    density: number;
+}
+export type SceneToneMapping = 'none' | 'neutral' | 'aces' | 'agx';
+export interface SceneEffects {
+    toneMapping: SceneToneMapping;
+    exposure: number;
+    bloom: {
+        enabled: boolean;
+        intensity: number;
+        threshold: number;
+        radius: number;
+    };
+    vignette: {
+        enabled: boolean;
+        darkness: number;
+        offset: number;
+    };
+    color: {
+        enabled: boolean;
+        hue: number;
+        saturation: number;
+        brightness: number;
+        contrast: number;
+    };
+    chromaticAberration: {
+        enabled: boolean;
+        strength: number;
+    };
+    grain: {
+        enabled: boolean;
+        strength: number;
+    };
+    lut: {
+        assetId: string | null;
+        intensity: number;
+    };
+    dof: {
+        enabled: boolean;
+        bokehScale: number;
+        focusRange: number;
+    };
+    stylize: {
+        pixelate: {
+            enabled: boolean;
+            granularity: number;
+        };
+        glitch: {
+            enabled: boolean;
+        };
+    };
+}
+export interface SceneEnvironment {
+    iblAssetId: string | null;
+    iblIntensity: number;
+    showSkybox: boolean;
+    fog: SceneFog;
+    effects: SceneEffects;
+}
+export interface Scene {
+    id: string;
+    name: string;
+    items: SceneItem[];
+    primaryInstanceId: string | null;
+    background: SceneBackground;
+    behavior: SceneBehavior;
+    vrmCamera: SceneCamera;
+    lights: SceneLight[];
+    environment: SceneEnvironment;
+    shortcut: string | null;
+}
+export interface SceneState {
+    scenes: Scene[];
+    activeSceneId: string;
+    /** Scene ids whose shortcut is currently registered with the OS. */
+    registeredSceneIds: string[];
+}
+/**
+ * Editable sections of the active scene. Items are deliberately absent — they
+ * are manipulated through `instance.*` / `object.*` methods so the app, not the
+ * client, constructs model refs and asset references.
+ */
+export interface ScenePatch {
+    background?: SceneBackground;
+    behavior?: SceneBehavior;
+    vrmCamera?: SceneCamera;
+    lights?: SceneLight[];
+    environment?: SceneEnvironment;
+}
+/** What a loaded model instance can do; absent capabilities answer `unsupported-for-format`. */
+export type InstanceCapability = 'motions' | 'expressions' | 'placement-2d' | 'placement-3d' | 'mtoon' | 'idle-clips' | 'pose' | 'live2d-params';
+export interface InstanceRuntime {
+    instanceId: string;
+    kind: 'model' | 'object';
+    /** Model format, or null for objects. */
+    format: ModelFormat | null;
+    loaded: boolean;
+    capabilities: InstanceCapability[];
+}
+export interface MotionGroup {
+    group: string;
+    files: string[];
+}
+export interface Expression {
+    name: string;
+    file: string | null;
+    active: boolean;
+}
+export interface PlayingMotion {
+    group: string;
+    index: number;
+}
+export interface AnchorOption {
+    anchor: AttachAnchor;
+    label: string;
+}
+/** Panel-style model info block. Format-specific fields mirror the app's `ModelInfo`. */
+export interface ModelInfo {
+    format: ModelFormat;
+    name: string;
+    kind: ModelKind;
+    file: string;
+    loadMs: number;
+    /** Format-specific details (canvas/params/textures for Live2D, spec/bones for VRM). */
+    [key: string]: unknown;
+}
+export interface Hotkey {
+    id: string;
+    name: string;
+    /** The VTS `Action` string verbatim; `action` is null when Persona cannot run it. */
+    vtsAction: string;
+    action: 'toggle-expression' | 'play-motion' | 'remove-all-expressions' | 'load-model' | null;
+    file: string;
+    accelerator: string | null;
+    global: boolean;
+    active: boolean;
+}
+export interface HotkeyConfig {
+    keyboardEnabled: boolean;
+    hotkeys: Hotkey[];
+}
+export interface HotkeyState extends HotkeyConfig {
+    /** Hotkey ids currently registered with the OS (active model only). */
+    registered: string[];
+}
+export interface ExpressionPersistence {
+    supported: boolean;
+    enabled: boolean;
+    saved: string[];
+}
+export type TrackingSourceId = 'vts-ios' | 'vts-ios-native' | 'ifacialmocap';
+export type PoseSourceId = 'vmc';
+export type EffectsQuality = 'high' | 'medium' | 'low';
+export type TrackingStatus = 'off' | 'waiting' | 'tracking' | 'no-face';
+export type PoseStatus = 'off' | 'waiting' | 'tracking';
+/** The curated settings surface the API exposes — never the raw store shape. */
+export interface Settings {
+    window: {
+        alwaysOnTop: boolean;
+    };
+    ui: {
+        trayVisible: boolean;
+    };
+    performance: {
+        backgroundRendering: boolean;
+        showFps: boolean;
+        fpsLimit: number;
+        selectionOutline: boolean;
+        effectsQuality: EffectsQuality;
+    };
+    tracking: {
+        enabled: boolean;
+        source: TrackingSourceId;
+    };
+    pose: {
+        enabled: boolean;
+        source: PoseSourceId;
+        port: number;
+    };
+}
+export interface SettingsPatch {
+    window?: {
+        alwaysOnTop?: boolean;
+    };
+    ui?: {
+        trayVisible?: boolean;
+    };
+    performance?: {
+        backgroundRendering?: boolean;
+        showFps?: boolean;
+        fpsLimit?: number;
+        selectionOutline?: boolean;
+        effectsQuality?: EffectsQuality;
+    };
+}
+/** VTS's input vocabulary — the valid `id`s for `input` inject targets (and the names a model's `.vtube.json` references). */
+export declare const INPUT_NAMES: readonly ["FaceAngleX", "FaceAngleY", "FaceAngleZ", "FacePositionX", "FacePositionY", "FacePositionZ", "EyeOpenLeft", "EyeOpenRight", "EyeLeftX", "EyeLeftY", "EyeRightX", "EyeRightY", "Brows", "BrowLeftY", "BrowRightY", "MouthSmile", "MouthOpen", "MouthX", "CheekPuff", "JawOpen", "TongueOut", "MouthPucker", "MouthFunnel", "MouthShrug", "MouthPress"];
+export type InputName = (typeof INPUT_NAMES)[number];
+/**
+ * What an injected value drives:
+ * - `input` — a VTS-vocabulary tracking input (`MouthOpen`, `FaceAngleX`, …), mapped
+ *   through the model's own tracking rules. Live2D only.
+ * - `live2d-param` — a Cubism parameter id, written directly.
+ * - `vrm-expression` — reserved, not implemented yet; the server answers
+ *   `unsupported-for-format`.
+ */
+export type InjectTargetType = 'input' | 'live2d-param' | 'vrm-expression';
+export interface InjectTarget {
+    type: InjectTargetType;
+    id: string;
+    /** Defaults to the scene's primary model instance. */
+    instanceId?: string;
+}
+export interface InjectEntry extends InjectTarget {
+    value: number;
+    /** 0..1 blend over whatever else drives the parameter; default 1. */
+    weight?: number;
+}

package/dist/types.js

@@ -0,0 +1,32 @@
+// The API's data model: the entity shapes that requests, responses, and events
+// carry. Structural mirrors of the app's scene/settings models, minus anything
+// filesystem-shaped — model refs are sanitized to ids, never directories.
+// ---- Injection -----------------------------------------------------------------
+/** VTS's input vocabulary — the valid `id`s for `input` inject targets (and the names a model's `.vtube.json` references). */
+export const INPUT_NAMES = [
+    'FaceAngleX',
+    'FaceAngleY',
+    'FaceAngleZ',
+    'FacePositionX',
+    'FacePositionY',
+    'FacePositionZ',
+    'EyeOpenLeft',
+    'EyeOpenRight',
+    'EyeLeftX',
+    'EyeLeftY',
+    'EyeRightX',
+    'EyeRightY',
+    'Brows',
+    'BrowLeftY',
+    'BrowRightY',
+    'MouthSmile',
+    'MouthOpen',
+    'MouthX',
+    'CheekPuff',
+    'JawOpen',
+    'TongueOut',
+    'MouthPucker',
+    'MouthFunnel',
+    'MouthShrug',
+    'MouthPress',
+];