@laplace.live/persona-sdk 1.24.0 → 1.25.1

package/dist/values/effect-schema.js

@@ -1,5 +1,5 @@
 // Scope and parameter metadata are plain data; labels and rendering stay with their consumers.
-import { finiteOr, isOneOf, isRecord } from "./guards.js";
+import { finiteOr, isOneOf, isRecord, keysOf } from "./guards.js";
 import { clamp, hexColorOr } from "./limits.js";
 /** Supported owners of each toggle effect; scene and layer membership are independent. */
 export const EFFECT_SCOPES = {
@@ -48,6 +48,57 @@ export const SCENE_EFFECT_KEYS = keysForScope('scene');
 /** Scene toggle keys; retained for existing SDK consumers. */
 export const TOGGLE_EFFECT_KEYS = SCENE_EFFECT_KEYS;
 export const LAYER_EFFECT_KEYS = keysForScope('layer');
+/** Levels' color channels, run before the master levels; each suffixes its own copy of the params (`inputBlackR`). */
+export const LEVEL_CHANNELS = ['R', 'G', 'B'];
+/** Color Shift's hue bands, around the wheel from red; each suffixes its own copy of the params (`hueRed`). */
+export const COLOR_SHIFT_BANDS = ['Red', 'Yellow', 'Green', 'Cyan', 'Blue', 'Magenta'];
+/** Select Colors' color slots, `color1` up. */
+export const SELECT_COLORS_SLOTS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+/** The color slots a layer's bloom can limit its glow to, `color1` up. */
+export const BLOOM_COLOR_SLOTS = [1, 2, 3, 4, 5];
+/** One channel's levels, shared by the master set and each of {@link LEVEL_CHANNELS}. */
+const LEVEL_SPECS = {
+    inputBlack: { default: 0, min: 0, max: 1, step: 0.01 },
+    inputWhite: { default: 1, min: 0, max: 1, step: 0.01 },
+    inputGamma: { default: 1, min: 0.1, max: 4, step: 0.01 },
+    outputBlack: { default: 0, min: 0, max: 1, step: 0.01 },
+    outputWhite: { default: 1, min: 0, max: 1, step: 0.01 },
+};
+/** One hue band's offsets, shared by each of {@link COLOR_SHIFT_BANDS}. */
+const COLOR_SHIFT_SPECS = {
+    hue: { default: 0, min: -180, max: 180, step: 1, unit: '°' },
+    saturation: { default: 0, min: -1, max: 1, step: 0.01 },
+    luminance: { default: 0, min: -1, max: 1, step: 0.01 },
+    luminanceSaturation: { default: 0, min: -1, max: 1, step: 0.01 },
+};
+const SELECT_COLORS_DEFAULTS = {
+    1: '#ff0000',
+    2: '#ffff00',
+    3: '#00ff00',
+    4: '#00ffff',
+    5: '#0000ff',
+    6: '#ff00ff',
+    7: '#ffffff',
+    8: '#808080',
+    9: '#000000',
+    10: '#ff8800',
+};
+/**
+ * `table` once per suffix, suffix by suffix, each key suffixed (`{ hue }` over `['Red', 'Blue']` is
+ * `{ hueRed, hueBlue }`): how a per-channel parameter set spells its specs, labels and descriptions.
+ */
+export function suffixKeys(table, suffixes) {
+    // Object.fromEntries widens its keys to string; the entries are exactly the keys named.
+    return Object.fromEntries(suffixes.flatMap(suffix => keysOf(table).map(key => [`${key}${suffix}`, table[key]])));
+}
+/** `spec(slot)` for each color slot, keyed `color${slot}${suffix}` in slot order. */
+function colorSlotSpecs(slots, suffix, spec) {
+    // Object.fromEntries widens its keys to string; the entries are exactly the keys named.
+    return Object.fromEntries(slots.map(slot => [`color${slot}${suffix}`, spec(slot)]));
+}
+// The first slot starts on: with every pick off the mask is zero, so switching selection on
+// would select nothing rather than narrow.
+const slotEnabled = (slot) => ({ default: slot === 1 });
 // Declared string-indexed so generic call sites (slider loop, healing walk) iterate
 // without erasure casts; `satisfies` still checks exact per-effect param parity here.
 export const EFFECT_SPECS = {
@@ -60,28 +111,7 @@ export const EFFECT_SPECS = {
         temperature: { default: 0, min: -100, max: 100, step: 1 },
         tint: { default: 0, min: -100, max: 100, step: 1 },
     },
-    levels: {
-        inputBlack: { default: 0, min: 0, max: 1, step: 0.01 },
-        inputWhite: { default: 1, min: 0, max: 1, step: 0.01 },
-        inputGamma: { default: 1, min: 0.1, max: 4, step: 0.01 },
-        outputBlack: { default: 0, min: 0, max: 1, step: 0.01 },
-        outputWhite: { default: 1, min: 0, max: 1, step: 0.01 },
-        inputBlackR: { default: 0, min: 0, max: 1, step: 0.01 },
-        inputWhiteR: { default: 1, min: 0, max: 1, step: 0.01 },
-        inputGammaR: { default: 1, min: 0.1, max: 4, step: 0.01 },
-        outputBlackR: { default: 0, min: 0, max: 1, step: 0.01 },
-        outputWhiteR: { default: 1, min: 0, max: 1, step: 0.01 },
-        inputBlackG: { default: 0, min: 0, max: 1, step: 0.01 },
-        inputWhiteG: { default: 1, min: 0, max: 1, step: 0.01 },
-        inputGammaG: { default: 1, min: 0.1, max: 4, step: 0.01 },
-        outputBlackG: { default: 0, min: 0, max: 1, step: 0.01 },
-        outputWhiteG: { default: 1, min: 0, max: 1, step: 0.01 },
-        inputBlackB: { default: 0, min: 0, max: 1, step: 0.01 },
-        inputWhiteB: { default: 1, min: 0, max: 1, step: 0.01 },
-        inputGammaB: { default: 1, min: 0.1, max: 4, step: 0.01 },
-        outputBlackB: { default: 0, min: 0, max: 1, step: 0.01 },
-        outputWhiteB: { default: 1, min: 0, max: 1, step: 0.01 },
-    },
+    levels: suffixKeys(LEVEL_SPECS, ['', ...LEVEL_CHANNELS]),
     colorWheels: {
         lift: { default: 0, min: -1, max: 1, step: 0.01 },
         gamma: { default: 0, min: -1, max: 1, step: 0.01 },
@@ -92,32 +122,7 @@ export const EFFECT_SPECS = {
         shadowLimit: { default: 0.3, min: 0, max: 1, step: 0.01 },
         highlightLimit: { default: 0.7, min: 0, max: 1, step: 0.01 },
     },
-    colorShift: {
-        hueRed: { default: 0, min: -180, max: 180, step: 1, unit: '°' },
-        saturationRed: { default: 0, min: -1, max: 1, step: 0.01 },
-        luminanceRed: { default: 0, min: -1, max: 1, step: 0.01 },
-        luminanceSaturationRed: { default: 0, min: -1, max: 1, step: 0.01 },
-        hueYellow: { default: 0, min: -180, max: 180, step: 1, unit: '°' },
-        saturationYellow: { default: 0, min: -1, max: 1, step: 0.01 },
-        luminanceYellow: { default: 0, min: -1, max: 1, step: 0.01 },
-        luminanceSaturationYellow: { default: 0, min: -1, max: 1, step: 0.01 },
-        hueGreen: { default: 0, min: -180, max: 180, step: 1, unit: '°' },
-        saturationGreen: { default: 0, min: -1, max: 1, step: 0.01 },
-        luminanceGreen: { default: 0, min: -1, max: 1, step: 0.01 },
-        luminanceSaturationGreen: { default: 0, min: -1, max: 1, step: 0.01 },
-        hueCyan: { default: 0, min: -180, max: 180, step: 1, unit: '°' },
-        saturationCyan: { default: 0, min: -1, max: 1, step: 0.01 },
-        luminanceCyan: { default: 0, min: -1, max: 1, step: 0.01 },
-        luminanceSaturationCyan: { default: 0, min: -1, max: 1, step: 0.01 },
-        hueBlue: { default: 0, min: -180, max: 180, step: 1, unit: '°' },
-        saturationBlue: { default: 0, min: -1, max: 1, step: 0.01 },
-        luminanceBlue: { default: 0, min: -1, max: 1, step: 0.01 },
-        luminanceSaturationBlue: { default: 0, min: -1, max: 1, step: 0.01 },
-        hueMagenta: { default: 0, min: -180, max: 180, step: 1, unit: '°' },
-        saturationMagenta: { default: 0, min: -1, max: 1, step: 0.01 },
-        luminanceMagenta: { default: 0, min: -1, max: 1, step: 0.01 },
-        luminanceSaturationMagenta: { default: 0, min: -1, max: 1, step: 0.01 },
-    },
+    colorShift: suffixKeys(COLOR_SHIFT_SPECS, COLOR_SHIFT_BANDS),
     selectColors: {
         hueRange: { default: 0.08, min: 0, max: 0.5, step: 0.01 },
         saturationRange: { default: 1, min: 0, max: 1, step: 0.01 },
@@ -289,25 +294,10 @@ export const EFFECT_COLOR_SPECS = {
         midtonesColor: { default: '#ffffff' },
         highlightsColor: { default: '#ffffff' },
     },
-    selectColors: {
-        color1: { default: '#ff0000' },
-        color2: { default: '#ffff00' },
-        color3: { default: '#00ff00' },
-        color4: { default: '#00ffff' },
-        color5: { default: '#0000ff' },
-        color6: { default: '#ff00ff' },
-        color7: { default: '#ffffff' },
-        color8: { default: '#808080' },
-        color9: { default: '#000000' },
-        color10: { default: '#ff8800' },
-    },
+    selectColors: colorSlotSpecs(SELECT_COLORS_SLOTS, '', slot => ({ default: SELECT_COLORS_DEFAULTS[slot] })),
     bloom: {
         tint: { default: '#ffffff' },
-        color1: { default: '#ffffff' },
-        color2: { default: '#ffffff' },
-        color3: { default: '#ffffff' },
-        color4: { default: '#ffffff' },
-        color5: { default: '#ffffff' },
+        ...colorSlotSpecs(BLOOM_COLOR_SLOTS, '', () => ({ default: '#ffffff' })),
     },
     rim: {
         color: { default: '#ffeb74' },
@@ -335,26 +325,11 @@ export const EFFECT_BOOLEAN_SPECS = {
     bloom: {
         selectColors: { default: false },
         invertColors: { default: false },
-        // Like Select Colors' first slot: with every pick off the mask is zero, so switching
-        // selection on would make the glow vanish rather than narrow.
-        color1Enabled: { default: true },
-        color2Enabled: { default: false },
-        color3Enabled: { default: false },
-        color4Enabled: { default: false },
-        color5Enabled: { default: false },
+        ...colorSlotSpecs(BLOOM_COLOR_SLOTS, 'Enabled', slotEnabled),
     },
     selectColors: {
         invert: { default: false },
-        color1Enabled: { default: true },
-        color2Enabled: { default: false },
-        color3Enabled: { default: false },
-        color4Enabled: { default: false },
-        color5Enabled: { default: false },
-        color6Enabled: { default: false },
-        color7Enabled: { default: false },
-        color8Enabled: { default: false },
-        color9Enabled: { default: false },
-        color10Enabled: { default: false },
+        ...colorSlotSpecs(SELECT_COLORS_SLOTS, 'Enabled', slotEnabled),
     },
 };
 /** Blend-mode order shared by effect editors and shader uniforms. */
@@ -384,21 +359,31 @@ export const EFFECT_BLEND_MODES = [
     'color',
     'luminosity',
 ];
+// The wire types derive from these, so every member a type admits also heals and publishes.
+export const FLARE_MODES = ['add', 'screen', 'colorDodge'];
+export const FLARE_RAYS_MODES = ['sun', 'shine', 'god'];
+export const GRADIENT_TYPES = ['solid', 'linear', 'circle', 'ellipse'];
+export const BLUR_MODES = ['gaussian', 'bokeh'];
+export const BLOOM_MODES = ['normal', 'streak', 'star'];
+export const RIM_MODES = ['single', 'double', 'sharpenSingle', 'sharpenDouble'];
+export const COLOR_WHEELS_MODES = ['liftGammaGain', 'shadowsMidtonesHighlights'];
+/** Effects quality tiers, lowest first. */
+export const EFFECTS_QUALITY_LEVELS = ['low', 'medium', 'high'];
 /** Enum defaults and allowed values. */
 export const EFFECT_ENUM_SPECS = {
     flare: {
-        mode: { default: 'add', values: ['add', 'screen', 'colorDodge'] },
-        raysMode: { default: 'sun', values: ['sun', 'shine', 'god'] },
+        mode: { default: 'add', values: FLARE_MODES },
+        raysMode: { default: 'sun', values: FLARE_RAYS_MODES },
     },
     gradient: {
-        type: { default: 'circle', values: ['solid', 'linear', 'circle', 'ellipse'] },
+        type: { default: 'circle', values: GRADIENT_TYPES },
         blendMode: { default: 'normal', values: EFFECT_BLEND_MODES },
     },
-    blur: { mode: { default: 'gaussian', values: ['gaussian', 'bokeh'] } },
-    bloom: { mode: { default: 'normal', values: ['normal', 'streak', 'star'] } },
-    rim: { mode: { default: 'single', values: ['single', 'double', 'sharpenSingle', 'sharpenDouble'] } },
-    outline: { quality: { default: 'medium', values: ['low', 'medium', 'high'] } },
-    colorWheels: { mode: { default: 'liftGammaGain', values: ['liftGammaGain', 'shadowsMidtonesHighlights'] } },
+    blur: { mode: { default: 'gaussian', values: BLUR_MODES } },
+    bloom: { mode: { default: 'normal', values: BLOOM_MODES } },
+    rim: { mode: { default: 'single', values: RIM_MODES } },
+    outline: { quality: { default: 'medium', values: EFFECTS_QUALITY_LEVELS } },
+    colorWheels: { mode: { default: 'liftGammaGain', values: COLOR_WHEELS_MODES } },
 };
 /** Select the layer effects from any value set containing them. */
 export function pickLayerEffects(effects) {

package/dist/values/hotkey-targets.d.ts

@@ -1,6 +1,6 @@
-import type { Hotkey, MotionGroup } from '../wire/types.ts';
+import type { Hotkey, ModelRef, MotionGroup } from '../wire/types.ts';
 /** A hotkey action Persona can run. */
-type HotkeyAction = NonNullable<Hotkey['action']>;
+export type HotkeyAction = NonNullable<Hotkey['action']>;
 /** What a model offers hotkeys: its expressions (a null `file` on formats with none) and its motion groups. */
 export interface HotkeyListing {
     expressions: readonly {
@@ -53,4 +53,11 @@ export declare function modelMatchesFile(file: string, model: {
     vtubeFile?: string | null;
     entryFile?: string;
 }): boolean;
-export {};
+/**
+ * Labels a model's hotkeys by what each points at — an expression's Name, a motion's label, a
+ * load-model's model name — or undefined for an action with no file, or once the target is gone.
+ * Walks the listing once, so a shortcut list builds one per model and asks it per row.
+ * @param models `model.list`'s refs; scene item refs carry no `vtubeFile` (see {@link modelMatchesFile}).
+ * @param groupLabel Display name for a motion group; VRM groups are clip refs, not names.
+ */
+export declare function hotkeyTargetLabels(listing: HotkeyListing, models: readonly Pick<ModelRef, 'name' | 'vtubeFile' | 'entryFile'>[], groupLabel?: (group: string) => string): (h: Pick<Hotkey, 'action' | 'file'>) => string | undefined;

package/dist/values/hotkey-targets.js

@@ -86,3 +86,23 @@ export function modelMatchesFile(file, model) {
         return true;
     return model.entryFile !== undefined && fileBasename(model.entryFile).toLowerCase() === base;
 }
+/**
+ * Labels a model's hotkeys by what each points at — an expression's Name, a motion's label, a
+ * load-model's model name — or undefined for an action with no file, or once the target is gone.
+ * Walks the listing once, so a shortcut list builds one per model and asks it per row.
+ * @param models `model.list`'s refs; scene item refs carry no `vtubeFile` (see {@link modelMatchesFile}).
+ * @param groupLabel Display name for a motion group; VRM groups are clip refs, not names.
+ */
+export function hotkeyTargetLabels(listing, models, groupLabel) {
+    const labelByFile = {
+        'expression-toggle': new Map(hotkeyTargets(listing, 'expression-toggle').map(x => [x.file, x.label])),
+        'motion-play': new Map(hotkeyTargets(listing, 'motion-play', groupLabel).map(x => [x.file, x.label])),
+    };
+    return h => {
+        if (h.action === 'model-load')
+            return models.find(m => modelMatchesFile(h.file, m))?.name;
+        if (h.action !== 'expression-toggle' && h.action !== 'motion-play')
+            return undefined;
+        return labelByFile[h.action].get(h.file);
+    };
+}

package/dist/values/hotkeys.d.ts

@@ -1,4 +1,4 @@
-import type { Hotkey } from '../wire/types.ts';
+import type { Hotkey, HotkeyState } from '../wire/types.ts';
 /** True when the combo carries a command modifier and so may be registered globally. */
 export declare function hasCommandModifier(accelerator: string | null): boolean;
 /**
@@ -9,6 +9,12 @@ export declare function hasCommandModifier(accelerator: string | null): boolean;
 export declare function canRunInBackground(accelerator: string | null): boolean;
 /** True when a model hotkey is meant to fire while Persona sits in the background — what main registers on, and what the globe shows. */
 export declare function hotkeyRunsInBackground(h: Hotkey): boolean;
+/**
+ * True when main should hold an OS registration for `h` but doesn't — another app owns its
+ * command-modifier combo. A non-command combo (a controller one included) never registers, so its
+ * absence is not contention; nor is anything under the model's master switch turned off.
+ */
+export declare function hotkeyContended(state: Pick<HotkeyState, 'keyboardEnabled' | 'registered'>, h: Hotkey): boolean;
 /**
  * Why a `hold` hotkey toggles instead of holding, or null when it can hold. A combo registered with
  * the OS reaches Persona as a press alone — Electron reports no key-up for it — and one registration
@@ -16,6 +22,8 @@ export declare function hotkeyRunsInBackground(h: Hotkey): boolean;
  * `'shared'` when only another one on its combo does, which `registered` (main's list) alone can tell.
  */
 export declare function holdBlockedBy(h: Pick<Hotkey, 'hold' | 'global' | 'accelerator'>, registered: boolean): 'own' | 'shared' | null;
+/** A hotkey's playback options, which every writer and healer treats as one group. */
+export type HotkeyOptions = Pick<Hotkey, 'hold' | 'fadeSeconds' | 'deactivateAfterSeconds' | 'stopsOnLastFrame'>;
 /** VTS's editor limits for a hotkey's fade and auto-off times, in seconds; healing clamps API input to them. */
 export declare const HOTKEY_FADE_SECONDS_MAX = 2;
 export declare const HOTKEY_DEACTIVATE_SECONDS_MIN = 0.1;

package/dist/values/hotkeys.js

@@ -25,6 +25,17 @@ export function canRunInBackground(accelerator) {
 export function hotkeyRunsInBackground(h) {
     return h.global && h.active && h.action !== null && canRunInBackground(h.accelerator);
 }
+/**
+ * True when main should hold an OS registration for `h` but doesn't — another app owns its
+ * command-modifier combo. A non-command combo (a controller one included) never registers, so its
+ * absence is not contention; nor is anything under the model's master switch turned off.
+ */
+export function hotkeyContended(state, h) {
+    return (state.keyboardEnabled &&
+        hotkeyRunsInBackground(h) &&
+        hasCommandModifier(h.accelerator) &&
+        !state.registered.includes(h.id));
+}
 /**
  * Why a `hold` hotkey toggles instead of holding, or null when it can hold. A combo registered with
  * the OS reaches Persona as a press alone — Electron reports no key-up for it — and one registration

package/dist/values/labels.js

@@ -26,6 +26,7 @@ export function motionSlots(files) {
     return files.flatMap((file, index) => (file === '' ? [] : [{ file, index }]));
 }
 // English fallbacks; localizing clients keep their own map and use these for unknown kinds.
+// The panel's `KIND_SPECS` labels must read the same — a desktop test holds them together.
 const AUTOMATION_ACTION_KIND_LABELS = {
     'effect-toggle': 'Toggle Effect',
     'effect-params': 'Apply Effect Settings',

package/dist/values/limits.d.ts

@@ -1,9 +1,11 @@
-import type { AssetRef, Attach, AttachDepth, CameraAnchor, CameraFollowDamping, CameraTrackTarget, ChromaKey, EnvironmentLook, KeyableContent, ModelFormat, MToonTuning, ObjectContent, ObjectSpace, SceneCameraAim, SceneCameraAimSettings, SceneCameraFocus, SceneCameraFocusSettings, SceneCameraFollow, SceneCameraFollowSettings, SceneCameraHandheld, SceneEnvironment, SceneLight, SceneLightCameraFollowOptions, SceneLightType, ScreenPlacement, VrmPlacement } from '../wire/types.ts';
+import type { AssetRef, Attach, AttachAnchor, AttachDepth, CameraAnchor, CameraFollowDamping, CameraTrackTarget, ChromaKey, EnvironmentLook, KeyableContent, ModelFormat, MToonTuning, ObjectContent, ObjectSpace, SceneCameraAim, SceneCameraAimSettings, SceneCameraFocus, SceneCameraFocusSettings, SceneCameraFollow, SceneCameraFollowSettings, SceneCameraHandheld, SceneEnvironment, SceneLight, SceneLightCameraFollowOptions, SceneLightType, ScreenPlacement, TextFont, VrmPlacement } from '../wire/types.ts';
 export declare function clamp(v: number, min: number, max: number): number;
 /** Clamp to the unit interval. */
 export declare function clamp01(v: number): number;
 /** Wrap an angle into (-π, π]. */
 export declare function wrapAngle(a: number): number;
+/** Wrap degrees into (-180°, 180°], {@link wrapAngle}'s range; whole turns keep in-range values exact. */
+export declare function wrapDegrees(v: number): number;
 export declare const DEFAULT_LIVE2D_PLACEMENT: ScreenPlacement;
 export declare const DEFAULT_VRM_PLACEMENT: VrmPlacement;
 /** Scene colors heal to 6-digit hex; both cases are spelled out because JSON Schema patterns carry no flags. */
@@ -27,6 +29,11 @@ export declare const SCENE_LIGHT_SPOT_ANGLE_MIN = 1;
 export declare const SCENE_LIGHT_SPOT_ANGLE_MAX = 89;
 export declare const DEFAULT_SPOT_ANGLE_DEG = 30;
 export declare const DEFAULT_SPOT_PENUMBRA = 0.3;
+/** Light azimuth and roll bounds in degrees, symmetric: a half turn either way. */
+export declare const SCENE_LIGHT_AZIMUTH_MAX = 180;
+export declare const SCENE_LIGHT_ROLL_MAX = 180;
+/** Light elevation bound in degrees, symmetric: straight up or straight down. */
+export declare const SCENE_LIGHT_ELEVATION_MAX = 90;
 /** Positional lights need falloff headroom; the slider and scene healing share this ceiling. */
 export declare function sceneLightIntensityMax(type: SceneLightType): number;
 /** Whether a light of `type` aims with azimuth/elevation. */
@@ -41,6 +48,7 @@ export declare const LIVE2D_SCALE_MIN = 0.1;
 export declare const LIVE2D_SCALE_MAX = 24;
 export declare const VRM_SCALE_MIN = 0.05;
 export declare const VRM_SCALE_MAX = 10;
+export declare const SCENE_LIGHT_RANGE_MIN = 0.1;
 export declare const SCENE_LIGHT_RANGE_MAX = 20;
 /** Past this the 5-tap kernel spreads thin enough that its dither reads as noise. */
 export declare const SCENE_LIGHT_SHADOW_RADIUS_MAX = 16;
@@ -48,6 +56,8 @@ export declare const SCENE_LIGHT_SHADOW_RADIUS_MAX = 16;
 export declare const SCENE_LIGHT_POINT_SHADOW_RADIUS_MAX = 32;
 export declare const SCENE_LIGHT_SHADOW_SOURCE_SIZE_MAX = 10;
 export declare const DEFAULT_LIGHT_SHADOW_SOURCE_SIZE = 0.1;
+/** A light override's key: the baked light's traversal index, in decimal digits. */
+export declare const LIGHT_OVERRIDE_KEY_RE: RegExp;
 /** Shadow softness (PCF disk radius, in shadow-map texels) ceiling for a light of `type`. */
 export declare function sceneLightShadowRadiusMax(type: SceneLightType): number;
 /**
@@ -68,6 +78,8 @@ export declare const CAMERA_DAMPING_MAX = 10;
 /** Ceiling for {@link SceneCameraAim}'s lookahead time, in seconds, and its smoothing. */
 export declare const CAMERA_AIM_LOOKAHEAD_MAX = 1;
 export declare const CAMERA_AIM_SMOOTHING_MAX = 30;
+/** {@link SceneCameraAim}'s bias bound on each axis, symmetric: a share of the slack between its zones. */
+export declare const CAMERA_AIM_BIAS_MAX = 0.5;
 /** Ceiling for {@link SceneCameraHandheld}'s speed. */
 export declare const CAMERA_HANDHELD_SPEED_MAX = 2;
 /** Warudo's Handheld Movement defaults, switched off. */
@@ -105,6 +117,30 @@ export declare function cameraTrackKind(item: {
     kind: 'object';
     space: ObjectSpace;
 }): 'model' | 'object' | null;
+/**
+ * The layer `target` tracks in `scene` — the primary model for a primary pick, else the first model — when it
+ * is one a camera can track.
+ */
+export declare function cameraTrackItem<T extends {
+    kind: 'model';
+    instanceId: string;
+    ref: {
+        kind: string;
+    };
+} | {
+    kind: 'object';
+    instanceId: string;
+    space: ObjectSpace;
+}>(scene: {
+    items: readonly T[];
+    primaryInstanceId: string | null;
+}, target: CameraTrackTarget): T | undefined;
+/** A layer the camera's follow, aim and focus pickers offer; `model` tells a model from an object. */
+export interface CameraTrackCandidate {
+    instanceId: string;
+    name: string;
+    model: boolean;
+}
 /** Rows for the camera's follow, aim and focus pickers, in layer order. One rule, or the console offers a layer the desktop drops. */
 export declare function cameraTrackCandidates(items: readonly ({
     kind: 'model';
@@ -118,11 +154,7 @@ export declare function cameraTrackCandidates(items: readonly ({
     instanceId: string;
     name: string;
     space: ObjectSpace;
-})[]): {
-    instanceId: string;
-    name: string;
-    model: boolean;
-}[];
+})[]): CameraTrackCandidate[];
 /** 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. */
@@ -153,6 +185,23 @@ export declare const MTOON_OUTLINE_WIDTH_MAX = 2;
 /** HDR headroom: past ×1 the point is pushing emissive parts over the bloom threshold. */
 export declare const MTOON_EMISSIVE_MAX = 4;
 export declare const MTOON_UV_ANIMATION_MAX = 4;
+/** Each {@link MToonTuning} field's `[min, max]`: offsets −1..1, `shade` 0..1, multipliers 0 to their ceiling. */
+export declare const MTOON_RANGES: {
+    readonly shade: readonly [0, 1];
+    readonly shadingShift: readonly [-1, 1];
+    readonly shadingToony: readonly [-1, 1];
+    readonly giEqualization: readonly [-1, 1];
+    readonly normalScale: readonly [0, 2];
+    readonly rim: readonly [0, 2];
+    readonly rimLift: readonly [-1, 1];
+    readonly rimFresnelPower: readonly [0, 4];
+    readonly rimLightingMix: readonly [-1, 1];
+    readonly matcap: readonly [0, 4];
+    readonly outlineWidth: readonly [0, 2];
+    readonly outlineLightingMix: readonly [-1, 1];
+    readonly emissive: readonly [0, 4];
+    readonly uvAnimation: readonly [0, 4];
+};
 export declare function defaultMToonTuning(): MToonTuning;
 export declare const DEFAULT_LIGHT_AZIMUTH_DEG = 45;
 export declare const DEFAULT_LIGHT_ELEVATION_DEG: number;
@@ -262,8 +311,26 @@ export declare const TEXT_BEVEL_RESOLUTION_MAX = 8;
 export declare const TEXT_EMISSION_MAX = 4;
 /** A PostScript name: printable ASCII, at most 63 chars, minus the quote and backslash that would escape `local("…")`. */
 export declare const TEXT_POSTSCRIPT_NAME_RE: RegExp;
+/** A text font's CSS `font-weight` bounds. */
+export declare const TEXT_FONT_WEIGHT_MIN = 1;
+export declare const TEXT_FONT_WEIGHT_MAX = 1000;
+/** A text font's CSS `font-stretch` bounds, in percent. */
+export declare const TEXT_FONT_STRETCH_MIN = 50;
+export declare const TEXT_FONT_STRETCH_MAX = 200;
+/** CSS's normal face: what a text font, or a font file, that leaves its weight, slope or width unsaid reads as. */
+export declare const DEFAULT_TEXT_FONT_FACE: Pick<TextFont, 'weight' | 'italic' | 'stretch'>;
 /** A prop is a mesh, so it only exists in the three.js scene; every other kind renders in both. */
 export declare function objectSupportsSpace(kind: ObjectContent['kind'], space: ObjectSpace): boolean;
+/** The {@link ObjectContent} kinds that stream from a registered asset; the rest carry their source inline. */
+declare const ASSET_CONTENT_KINDS: readonly ["image", "video", "prop"];
+/** The variants of {@link ObjectContent} that stream from a registered asset. */
+export type AssetContent = Extract<ObjectContent, {
+    kind: (typeof ASSET_CONTENT_KINDS)[number];
+}>;
+/** Whether `kind` — a content kind, or an Inventory row's — is one whose asset streams into a layer. */
+export declare function isAssetContentKind(kind: string): kind is AssetContent['kind'];
+/** Whether the content streams from a registered asset: image, video and prop; the rest carry their source inline. */
+export declare function isAssetContent(content: ObjectContent): content is AssetContent;
 /** The asset an object streams from, or null for kinds that carry their source inline (web, capture, text). */
 export declare function contentAssetId(content: ObjectContent): string | null;
 /**
@@ -281,6 +348,12 @@ export declare function pinRiders(items: readonly {
         parentInstanceId: string;
     } | null;
 }[], instanceId: string): Set<string>;
+/** A pin picker row; `ridesThis` flags a model that already rides the item. */
+interface PinnableParent {
+    instanceId: string;
+    name: string;
+    ridesThis: boolean;
+}
 /**
  * Rows for the pin picker: every other Live2D model, each flagged when it already rides
  * `instanceId` — picking one would put the two in a circle, so both apps offer it disabled
@@ -297,10 +370,20 @@ export declare function pinnableParents(models: readonly {
     attach?: {
         parentInstanceId: string;
     } | null;
-}[], instanceId: string): {
+}[], instanceId: string): PinnableParent[];
+/**
+ * {@link pinnableParents} for an object: every model of the one format its space can ride. Nothing
+ * rides an object, so no row is ever flagged.
+ */
+export declare function objectPinParents(models: readonly {
+    instanceId: string;
+    ref: {
+        kind: string;
+        name: string;
+    };
+}[], space: ObjectSpace): {
     instanceId: string;
     name: string;
-    ridesThis: boolean;
 }[];
 /**
  * Whether pinning puts an item inside its Live2D host's ArtMesh stack, where `attach.depth` places
@@ -323,6 +406,8 @@ export declare function pinEntersStack(item: {
 export declare function depthStops(meshes: readonly string[]): AttachDepth[];
 /** Which stop a depth sits at; an ArtMesh the host no longer has reads as the frontmost. */
 export declare function depthStopIndex(meshes: readonly string[], depth: AttachDepth): number;
+/** A stored anchor — a model's root, a VRM bone or a point on a Live2D ArtMesh — as a usable one, or null. */
+export declare function healAttachAnchor(raw: unknown): AttachAnchor | null;
 export declare const DEFAULT_HEAD_ANGLE: NonNullable<Attach['headAngle']>;
 /**
  * A fresh pin onto `parentInstanceId`: root anchor, in front of the model. A screen-space item (a
@@ -343,6 +428,8 @@ export declare const STORAGE_KEY_MAX_LENGTH = 128;
 export declare const STORAGE_VALUE_MAX_LENGTH: number;
 /** Keys one API key may hold; a `storage.set` that would exceed it answers `invalid-state`. */
 export declare const STORAGE_KEYS_MAX = 256;
+/** `session.identify` refuses a longer name, so a client composing one trims it to this. */
+export declare const SESSION_NAME_MAX_LENGTH = 64;
 /** `speech.play` URL ceiling — sized for a ~40 s WAV as a base64 `data:audio/*` payload. */
 export declare const SPEECH_URL_MAX_LENGTH = 8000000;
 /**
@@ -364,3 +451,4 @@ export declare const TWO_COLUMN_WIDTH = 672;
 export declare const SAVED_COLORS_MAX = 12;
 /** 3D-stage resolution multipliers offered by both performance pickers. */
 export declare const RENDER_SCALE_PRESETS: readonly [1, 0.85, 0.75, 0.66, 0.5];
+export {};