@cimplify/sdk 0.108.0 → 0.110.2

package/dist/interactives-studio.d.ts

@@ -0,0 +1,806 @@
+import { J as JsonSchema } from './schema-BrWxzKp6.js';
+import { D as DespawnListener, E as Entity, T as Transforms } from './world-PvILHDR1.js';
+import { b as Graphics } from './fluid-ARr0qUIL.js';
+import { a9 as PickHit, v as TextureId, b as AssetSource, x as ModelId, w as TextureUpgrade, y as ModelUpgrade, D as DeviceTier } from './backend-gUCzs5Kg.js';
+export { aK as createPickHit } from './backend-gUCzs5Kg.js';
+import { q as Thing, K as WorldPlacement, P as PhoneCost, I as WorldLayer, H as WorldDoc } from './types-D_f6UUxM.js';
+import { S as SceneCatalogue } from './catalogue-DzrTXP3v.js';
+import { f as ThingBreak, i as TierVerdict, H as HeavyWithoutPeople, W as WorldWeight } from './weight-CPGjsgjV.js';
+export { H as HotModule, a as HotReloader, b as HotReport, c as HotScenes } from './hot-Crn9XpHJ.js';
+import './library-DXYaMFhi.js';
+import './network-ZXLD7l1b.js';
+
+type SettingUnit = "none" | "fraction" | "times" | "count" | "m" | "m2" | "m/s" | "m/s2" | "kg" | "N" | "s" | "ms" | "Hz" | "1/s" | "deg" | "deg/s" | "rad" | "rad/s" | "px" | "dB" | "K" | "atm" | "bytes" | "cells";
+declare const SETTING_UNIT_LABELS: {
+    readonly [U in SettingUnit]: string;
+};
+type AssetKind = "model" | "texture" | "material" | "geometry" | "sound" | "font" | "vector" | "pack" | "animation" | "rig" | "data";
+type ThingRole = "any" | "camera" | "character" | "vehicle" | "light" | "body" | "joint";
+type SettingValue = null | boolean | number | string | readonly SettingValue[] | {
+    readonly [key: string]: SettingValue;
+};
+type Rgb = readonly [number, number, number];
+interface ChoiceOption {
+    readonly value: string | number;
+    readonly label: string;
+}
+interface SettingBase {
+    readonly description: string;
+    readonly group: string | null;
+    readonly label: string | null;
+    readonly heavy: boolean;
+    readonly advanced: boolean;
+}
+interface NumberSetting extends SettingBase {
+    readonly kind: "number";
+    readonly min: number;
+    readonly max: number;
+    readonly step: number | null;
+    readonly unit: SettingUnit;
+    readonly scale: "linear" | "log";
+    readonly default: number;
+}
+interface IntegerSetting extends SettingBase {
+    readonly kind: "integer";
+    readonly min: number;
+    readonly max: number;
+    readonly unit: SettingUnit;
+    readonly default: number;
+}
+interface BooleanSetting extends SettingBase {
+    readonly kind: "boolean";
+    readonly default: boolean;
+}
+interface ChoiceSetting extends SettingBase {
+    readonly kind: "choice";
+    readonly options: readonly ChoiceOption[];
+    readonly default: string | number;
+}
+interface ColorSetting extends SettingBase {
+    readonly kind: "color";
+    readonly format: "hex" | "rgb";
+    readonly default: number | Rgb;
+}
+interface VectorSetting extends SettingBase {
+    readonly kind: "vector";
+    readonly axes: readonly string[];
+    readonly min: number;
+    readonly max: number;
+    readonly unit: SettingUnit;
+    readonly default: readonly number[];
+}
+interface TextSetting extends SettingBase {
+    readonly kind: "text";
+    readonly maxLength: number;
+    readonly default: string;
+}
+interface AssetSetting extends SettingBase {
+    readonly kind: "asset";
+    readonly asset: AssetKind;
+    readonly default: null;
+}
+interface ThingSetting extends SettingBase {
+    readonly kind: "thing";
+    readonly role: ThingRole;
+    readonly default: null;
+}
+interface NestedSetting extends SettingBase {
+    readonly kind: "settings";
+    readonly settings: string;
+    readonly default: null;
+}
+interface ListSetting extends SettingBase {
+    readonly kind: "list";
+    readonly item: Setting;
+    readonly maxItems: number;
+    readonly default: readonly SettingValue[];
+}
+interface WiringSetting extends SettingBase {
+    readonly kind: "wiring";
+    readonly default: null;
+}
+type Setting = NumberSetting | IntegerSetting | BooleanSetting | ChoiceSetting | ColorSetting | VectorSetting | TextSetting | AssetSetting | ThingSetting | NestedSetting | ListSetting | WiringSetting;
+type SettingKind = Setting["kind"];
+type SettingFields = {
+    readonly [field: string]: Setting;
+};
+interface SettingsSchema {
+    readonly name: string;
+    readonly title: string;
+    readonly description: string;
+    readonly group: string;
+    readonly extends: readonly string[];
+    readonly omit: readonly string[];
+    readonly fields: SettingFields;
+}
+interface Common {
+    readonly group?: string;
+    readonly label?: string;
+    readonly heavy?: boolean;
+    readonly advanced?: boolean;
+}
+interface NumberOptions extends Common {
+    readonly default: number;
+    readonly min: number;
+    readonly max: number;
+    readonly unit: SettingUnit;
+    readonly step?: number;
+    readonly scale?: "linear" | "log";
+}
+interface IntegerOptions extends Common {
+    readonly default: number;
+    readonly min: number;
+    readonly max: number;
+    readonly unit?: SettingUnit;
+}
+interface VectorOptions extends Common {
+    readonly default: readonly number[];
+    readonly min: number;
+    readonly max: number;
+    readonly unit: SettingUnit;
+    readonly axes?: readonly string[];
+}
+interface ListOptions extends Common {
+    readonly maxItems: number;
+    readonly default?: readonly SettingValue[];
+}
+declare function sentence(name: string): string;
+declare const s: {
+    number(description: string, options: NumberOptions): NumberSetting;
+    integer(description: string, options: IntegerOptions): IntegerSetting;
+    boolean(description: string, value: boolean, common?: Common): BooleanSetting;
+    choice<const V extends string | number>(description: string, values: readonly V[], value: NoInfer<V>, common?: Common & {
+        readonly labels?: { readonly [K in V]?: string; };
+    }): ChoiceSetting;
+    color(description: string, value: number, common?: Common): ColorSetting;
+    rgb(description: string, value: Rgb, common?: Common): ColorSetting;
+    vector(description: string, options: VectorOptions): VectorSetting;
+    text(description: string, value?: string, maxLength?: number, common?: Common): TextSetting;
+    asset(description: string, asset: AssetKind, common?: Common): AssetSetting;
+    thing(description: string, role?: ThingRole, common?: Common): ThingSetting;
+    settings(description: string, settings: string, common?: Common): NestedSetting;
+    list(description: string, item: Setting, options: ListOptions): ListSetting;
+    wiring(description: string, common?: Common): WiringSetting;
+};
+interface SettingsDefinition {
+    readonly title: string;
+    readonly description: string;
+    readonly group?: string;
+    readonly extends?: readonly string[];
+    readonly omit?: readonly string[];
+    readonly fields: SettingFields;
+}
+declare function defineSettings(name: string, definition: SettingsDefinition): SettingsSchema;
+declare const MAX_DESCRIPTION_CHARS = 140;
+interface SchemaGap {
+    readonly field: string;
+    readonly reason: string;
+}
+declare function settingGaps(setting: Setting, field: string): SchemaGap[];
+declare function schemaGaps(schema: SettingsSchema): SchemaGap[];
+interface ValueIssue {
+    readonly path: string;
+    readonly reason: string;
+}
+type Normalized = {
+    readonly ok: true;
+    readonly value: SettingValue;
+} | {
+    readonly ok: false;
+    readonly issue: ValueIssue;
+};
+declare function normalizeSetting(setting: Setting, value: unknown, path?: string): Normalized;
+declare function settingDefault(setting: Setting): SettingValue;
+
+interface ResolvedField {
+    readonly name: string;
+    readonly setting: Setting;
+    readonly group: string;
+    readonly owner: string;
+}
+interface ResolvedSettings {
+    readonly schema: SettingsSchema;
+    readonly fields: readonly ResolvedField[];
+    readonly byName: ReadonlyMap<string, ResolvedField>;
+}
+interface RegistryGap extends SchemaGap {
+    readonly schema: string;
+}
+declare class SettingsRegistryError extends Error {
+    constructor(message: string);
+}
+declare class SettingsRegistry {
+    private readonly schemas;
+    private readonly resolved;
+    constructor(schemas: readonly SettingsSchema[]);
+    names(): readonly string[];
+    has(name: string): boolean;
+    schema(name: string): SettingsSchema;
+    resolve(name: string): ResolvedSettings;
+    private build;
+    fields(name: string): SettingFields;
+    field(name: string, path: readonly string[]): ResolvedField | null;
+    gaps(): RegistryGap[];
+    normalize(name: string, path: readonly string[], value: unknown): Normalized;
+    private normalizeField;
+    private normalizeGroup;
+    defaults(name: string): {
+        readonly [field: string]: SettingValue;
+    };
+}
+
+declare const PLACEMENT_SETTINGS = "Placement";
+declare const PLACEMENT_POSITION = "position";
+declare const PLACEMENT_ROTATION = "rotation";
+declare const PLACEMENT_SCALE = "scale";
+
+declare const THING_PART_SETTINGS = "ThingPart";
+declare const THING_EFFECT_SETTINGS = "ThingEffect";
+
+declare const WORLD_SKY_SETTINGS = "WorldSky";
+declare const SCATTER_BRUSH_SETTINGS = "ScatterBrush";
+declare const GROUND_BRUSH_SETTINGS = "GroundBrush";
+
+declare const UI_MOTION_SETTINGS = "UiMotion";
+declare const MUSIC_BED_SETTINGS = "MusicBed";
+declare const CROWD_VOTE_SETTINGS = "CrowdVote";
+declare const CROWD_CHEER_SETTINGS = "CrowdCheer";
+
+declare const STUDIO_SETTINGS: SettingsRegistry;
+
+declare const STEPPER_MAX_SPAN = 16;
+declare const SEGMENTED_MAX_OPTIONS = 4;
+declare const HEAVY_NOTE = "Heavy on cheaper phones";
+type InspectorValues = {
+    readonly [field: string]: SettingValue | undefined;
+};
+interface ControlBase {
+    readonly key: string;
+    readonly path: readonly string[];
+    readonly label: string;
+    readonly description: string;
+    readonly note: string | null;
+    readonly advanced: boolean;
+    readonly changed: boolean;
+}
+interface SliderControl extends ControlBase {
+    readonly control: "slider";
+    readonly min: number;
+    readonly max: number;
+    readonly step: number | null;
+    readonly whole: boolean;
+    readonly log: boolean;
+    readonly unit: string;
+    readonly value: number;
+    readonly default: number;
+}
+interface StepperControl extends ControlBase {
+    readonly control: "stepper";
+    readonly min: number;
+    readonly max: number;
+    readonly unit: string;
+    readonly value: number;
+    readonly default: number;
+}
+interface ToggleControl extends ControlBase {
+    readonly control: "toggle";
+    readonly value: boolean;
+    readonly default: boolean;
+}
+interface PickControl extends ControlBase {
+    readonly control: "segmented" | "select";
+    readonly options: readonly ChoiceOption[];
+    readonly value: string | number;
+    readonly default: string | number;
+}
+interface ColorControl extends ControlBase {
+    readonly control: "color";
+    readonly hex: string;
+    readonly format: "hex" | "rgb";
+    readonly value: SettingValue;
+    readonly default: SettingValue;
+}
+interface VectorControl extends ControlBase {
+    readonly control: "vector";
+    readonly axes: readonly string[];
+    readonly min: number;
+    readonly max: number;
+    readonly unit: string;
+    readonly value: readonly number[];
+    readonly default: readonly number[];
+}
+interface TextControl extends ControlBase {
+    readonly control: "text";
+    readonly maxLength: number;
+    readonly value: string;
+    readonly default: string;
+}
+interface AssetControl extends ControlBase {
+    readonly control: "asset";
+    readonly asset: AssetKind;
+    readonly value: string | null;
+}
+interface ThingControl extends ControlBase {
+    readonly control: "thing";
+    readonly role: ThingRole;
+    readonly value: string | null;
+}
+type ListItemEditor = {
+    readonly kind: "choice";
+    readonly options: readonly ChoiceOption[];
+    readonly default: string | number;
+} | {
+    readonly kind: "text";
+    readonly maxLength: number;
+    readonly default: string;
+} | {
+    readonly kind: "other";
+};
+interface ListControl extends ControlBase {
+    readonly control: "list";
+    readonly maxItems: number;
+    readonly count: number;
+    readonly value: readonly SettingValue[];
+    readonly item: ListItemEditor;
+}
+interface GroupControl extends ControlBase {
+    readonly control: "group";
+    readonly panel: InspectorPanel;
+}
+type InspectorControl = SliderControl | StepperControl | ToggleControl | PickControl | ColorControl | VectorControl | TextControl | AssetControl | ThingControl | ListControl | GroupControl;
+interface InspectorSection {
+    readonly title: string;
+    readonly controls: readonly InspectorControl[];
+}
+interface InspectorPanel {
+    readonly name: string;
+    readonly title: string;
+    readonly description: string;
+    readonly sections: readonly InspectorSection[];
+    readonly changed: number;
+}
+interface InspectorOptions {
+    readonly path?: readonly string[];
+    readonly advanced?: boolean;
+}
+declare function inspectorPanel(registry: SettingsRegistry, name: string, values?: InspectorValues, options?: InspectorOptions): InspectorPanel;
+declare function inspectorControls(panel: InspectorPanel): InspectorControl[];
+
+type OpAuthor = "person" | "reesa" | "plugin" | "remix";
+interface SetOp {
+    readonly kind: "set";
+    readonly target: string;
+    readonly settings: string;
+    readonly path: readonly string[];
+    readonly value: SettingValue;
+    readonly previous: SettingValue | undefined;
+}
+type SourceOp = SetOp;
+interface EditTransaction {
+    readonly label: string;
+    readonly author: OpAuthor;
+    readonly ops: readonly SourceOp[];
+}
+interface OpSink {
+    commit(transaction: EditTransaction): number;
+}
+declare const DEFAULT_HISTORY = 512;
+declare function invertOp(op: SourceOp): SourceOp;
+declare function invertTransaction(transaction: EditTransaction): EditTransaction;
+declare class MemoryOpLog implements OpSink {
+    readonly limit: number;
+    private readonly done;
+    private readonly undone;
+    private counter;
+    constructor(limit?: number);
+    get revision(): number;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    commit(transaction: EditTransaction): number;
+    undo(): EditTransaction | null;
+    redo(): EditTransaction | null;
+    history(): readonly EditTransaction[];
+}
+
+interface StudioToolDefinition {
+    readonly name: string;
+    readonly description: string;
+    readonly input_schema: JsonSchema;
+}
+declare const SETTINGS_TOOL_PREFIX = "set_";
+declare function settingsToolName(name: string): string;
+declare function settingsTool(registry: SettingsRegistry, name: string): StudioToolDefinition;
+declare function settingsTools(registry: SettingsRegistry, names?: readonly string[]): StudioToolDefinition[];
+interface SettingsToolResult {
+    readonly ops: readonly SetOp[];
+    readonly issues: readonly ValueIssue[];
+}
+type ReadSetting = (target: string, settings: string, path: readonly string[]) => SettingValue | undefined;
+declare function settingsToolOps(registry: SettingsRegistry, tool: string, input: unknown, read: ReadSetting): SettingsToolResult;
+declare function settingsToolTransaction(result: SettingsToolResult, label: string, author?: OpAuthor): EditTransaction;
+
+declare function settingDefaultText(setting: Setting): string;
+declare function settingRangeText(setting: Setting): string;
+declare function settingsDoc(registry: SettingsRegistry, name: string): string;
+declare function settingsDocs(registry: SettingsRegistry, names?: readonly string[]): string;
+
+declare class SourceIdError extends Error {
+    constructor(message: string);
+}
+declare class SourceIdMap implements DespawnListener {
+    readonly capacity: number;
+    private readonly handleOfIndex;
+    private readonly entityOfHandle;
+    private readonly ids;
+    private readonly handleOfId;
+    private readonly free;
+    private bound;
+    constructor(capacity: number);
+    get size(): number;
+    bind(entity: Entity, id: string): void;
+    unbind(entity: Entity): boolean;
+    onDespawn(entity: Entity): void;
+    sourceOf(entity: Entity): string | null;
+    entityOf(id: string): Entity;
+    has(id: string): boolean;
+    private claim;
+    private release;
+}
+
+type SelectMode = "replace" | "add" | "toggle";
+type SelectionListener = (selection: Selection) => void;
+declare class Selection {
+    private readonly chosen;
+    private readonly listeners;
+    private counter;
+    get version(): number;
+    get primary(): string | null;
+    get ids(): readonly string[];
+    get size(): number;
+    has(id: string): boolean;
+    select(id: string | null, mode?: SelectMode): void;
+    remove(id: string): void;
+    clear(): void;
+    subscribe(listener: SelectionListener): () => void;
+    private changed;
+}
+interface PickScene {
+    raycast(origin: ArrayLike<number>, direction: ArrayLike<number>, out: PickHit, far?: number, layers?: number): boolean;
+    entityOfNode(node: PickHit["node"]): Entity;
+    parentOf(entity: Entity): Entity;
+}
+declare const MAX_PICK_DEPTH = 64;
+interface PickableGame {
+    readonly graphics: Pick<Graphics, "raycast" | "entityOfNode">;
+    readonly transforms: Pick<Transforms, "parentOf" | "store">;
+}
+declare function gamePickScene(game: PickableGame): PickScene;
+declare function sourceAt(scene: PickScene, ids: SourceIdMap, entity: Entity): string | null;
+declare function pickSource(scene: PickScene, ids: SourceIdMap, origin: ArrayLike<number>, direction: ArrayLike<number>, hit: PickHit, far?: number, layers?: number): string | null;
+
+declare const PICK_SEGMENTS = 12;
+interface ThingPicker {
+    readonly scene: PickScene;
+    readonly ids: SourceIdMap;
+}
+declare function thingPicker(thing: Thing, segments?: number): ThingPicker;
+
+type Writable = {
+    [index: number]: number;
+};
+declare function eulerDegreesToQuat(x: number, y: number, z: number, out: Writable): void;
+declare function quatToEulerDegrees(x: number, y: number, z: number, w: number, out: Writable): void;
+
+type GizmoMode = "move" | "rotate" | "scale";
+type GizmoSpace = "world" | "local";
+declare const GizmoHandle: {
+    readonly None: 0;
+    readonly X: 1;
+    readonly Y: 2;
+    readonly Z: 3;
+    readonly YZ: 4;
+    readonly XZ: 5;
+    readonly XY: 6;
+    readonly View: 7;
+};
+type GizmoHandleId = (typeof GizmoHandle)[keyof typeof GizmoHandle];
+interface GizmoSnap {
+    readonly move: number;
+    readonly rotateDegrees: number;
+    readonly scale: number;
+}
+interface GizmoOptions {
+    readonly mode?: GizmoMode;
+    readonly space?: GizmoSpace;
+    readonly sizePixels?: number;
+    readonly hitPixels?: number;
+    readonly snap?: Partial<GizmoSnap>;
+}
+interface GizmoLines {
+    line(ax: number, ay: number, az: number, bx: number, by: number, bz: number, color?: number): unknown;
+    circle(x: number, y: number, z: number, radius: number, nx: number, ny: number, nz: number, color?: number, segments?: number): unknown;
+}
+declare const GIZMO_SIZE_PIXELS = 96;
+declare const GIZMO_HIT_PIXELS = 12;
+declare const GIZMO_COLORS: {
+    readonly x: 16729402;
+    readonly y: 3331915;
+    readonly z: 689407;
+    readonly view: 15921911;
+    readonly active: 16766474;
+};
+declare const NO_SNAP: GizmoSnap;
+declare class TransformGizmo {
+    mode: GizmoMode;
+    space: GizmoSpace;
+    snap: GizmoSnap;
+    readonly sizePixels: number;
+    readonly hitPixels: number;
+    readonly position: Float64Array<ArrayBuffer>;
+    readonly rotation: Float64Array<ArrayBuffer>;
+    readonly scale: Float64Array<ArrayBuffer>;
+    hovered: GizmoHandleId;
+    active: GizmoHandleId;
+    private readonly axes;
+    private readonly local;
+    private readonly eye;
+    private readonly viewNormal;
+    private readonly startPosition;
+    private readonly startRotation;
+    private readonly startScale;
+    private readonly startHit;
+    private readonly hit;
+    private readonly turn;
+    private length;
+    private startT;
+    constructor(options?: GizmoOptions);
+    get dragging(): boolean;
+    get handleLength(): number;
+    setTarget(position: ArrayLike<number>, rotation: ArrayLike<number>, scale: ArrayLike<number>): void;
+    setView(eye: ArrayLike<number>, pixelsPerUnit: number): void;
+    axis(index: number, out: Float64Array | Float32Array, offset?: number): void;
+    pick(origin: ArrayLike<number>, direction: ArrayLike<number>): GizmoHandleId;
+    begin(handle: GizmoHandleId, origin: ArrayLike<number>, direction: ArrayLike<number>): boolean;
+    drag(origin: ArrayLike<number>, direction: ArrayLike<number>): boolean;
+    end(): boolean;
+    cancel(): void;
+    eulerDegrees(out: Writable): void;
+    draw(lines: GizmoLines): void;
+    private drawPlane;
+    private corner;
+    private colorOf;
+    private isAxis;
+    private dragMove;
+    private dragRotate;
+    private dragScale;
+    private dominantLocalAxis;
+    private updateAxes;
+    private updateViewNormal;
+    private grab;
+    private intersectPlane;
+    private axisParameter;
+    private rayToAxisSegment;
+    private rayToPivot;
+    private rayToPoint;
+    private along;
+    private distanceFromPivot;
+    private distanceFrom;
+}
+
+interface LiveTarget {
+    read(path: readonly string[]): SettingValue | undefined;
+    apply(path: readonly string[], value: SettingValue): void;
+}
+type LiveTargets = (target: string, settings: string) => LiveTarget | null;
+declare class LiveTweak {
+    private readonly registry;
+    private readonly sink;
+    private readonly author;
+    private open;
+    constructor(registry: SettingsRegistry, sink: OpSink, author?: OpAuthor);
+    get active(): boolean;
+    get activeKey(): string | null;
+    reset(target: string, settings: string, path: readonly string[], live: LiveTarget, label?: string): number | null;
+    begin(target: string, settings: string, path: readonly string[], live: LiveTarget): boolean;
+    update(value: unknown): Normalized;
+    commit(label?: string): number | null;
+    cancel(): void;
+    set(target: string, settings: string, path: readonly string[], value: unknown, live: LiveTarget, label?: string): Normalized;
+}
+declare function applyOps(ops: readonly SourceOp[], targets: LiveTargets): number;
+declare function applyTransaction(transaction: EditTransaction | null, targets: LiveTargets): number;
+type PlacementTransforms = Pick<Transforms, "position" | "rotation" | "setPosition" | "setRotation" | "setScale" | "store">;
+declare class PlacementTarget implements LiveTarget {
+    private readonly transforms;
+    readonly entity: Entity;
+    private readonly vec;
+    private readonly quat;
+    private readonly q;
+    constructor(transforms: PlacementTransforms, entity: Entity);
+    read(path: readonly string[]): SettingValue | undefined;
+    readQuat(out: Float64Array): void;
+    apply(path: readonly string[], value: SettingValue): void;
+}
+declare class PlacementDrag {
+    private readonly sink;
+    private readonly transforms;
+    private readonly author;
+    private target;
+    private live;
+    private readonly before;
+    private readonly euler;
+    private readonly q;
+    constructor(sink: OpSink, transforms: PlacementTransforms, author?: OpAuthor);
+    get active(): boolean;
+    begin(target: string, entity: Entity, gizmo: TransformGizmo): void;
+    frame(gizmo: TransformGizmo): void;
+    commit(gizmo: TransformGizmo, label?: string): number | null;
+    cancel(gizmo: TransformGizmo): void;
+}
+
+interface AssetUpgrades {
+    upgradeTexture(texture: TextureId, source: AssetSource): Promise<TextureUpgrade>;
+    upgradeModel(model: ModelId, source: AssetSource): Promise<ModelUpgrade>;
+}
+type AssetChange = {
+    readonly kind: "texture";
+    readonly id: TextureId;
+    readonly source: AssetSource;
+} | {
+    readonly kind: "model";
+    readonly id: ModelId;
+    readonly source: AssetSource;
+};
+interface AssetSwap {
+    readonly kind: "texture" | "model";
+    readonly from: number;
+    readonly to: number;
+    readonly inPlace: boolean;
+}
+declare function reloadAsset(graphics: AssetUpgrades, change: AssetChange): Promise<AssetSwap>;
+
+type StudioPlaceableLayer = "prop" | "person";
+interface StudioPlaceable {
+    readonly kind: string;
+    readonly label: string;
+    readonly layer: StudioPlaceableLayer;
+    readonly footprint: readonly [number, number];
+}
+interface StudioCatalogue {
+    readonly placeables: readonly StudioPlaceable[];
+    readonly people: readonly StudioPlaceable[];
+}
+declare const MARKER_KINDS: readonly string[];
+declare const STUDIO_PEOPLE: readonly {
+    readonly kind: string;
+    readonly label: string;
+}[];
+declare function kindLabel(kind: string): string;
+declare function studioCatalogue(catalogue?: SceneCatalogue): StudioCatalogue;
+
+declare const STUDIO_KERNEL_GLOBAL = "CimplifyStudioKernel";
+interface KernelSchema {
+    readonly name: string;
+    readonly title: string;
+    readonly description: string;
+    readonly order: readonly string[];
+    readonly fields: {
+        readonly [field: string]: Setting & {
+            readonly group: string;
+        };
+    };
+}
+interface KernelMaterial {
+    readonly id: string;
+    readonly label: string;
+    readonly color: number;
+    readonly breaks: ThingBreak;
+}
+interface KernelThingLevel {
+    readonly name: "close" | "middle" | "far";
+    readonly triangles: number;
+    readonly dropped: readonly string[];
+}
+interface KernelThingMesh {
+    readonly positions: readonly number[];
+    readonly normals: readonly number[];
+    readonly indices: readonly number[];
+    readonly groups: readonly {
+        readonly material: string;
+        readonly start: number;
+        readonly count: number;
+    }[];
+}
+type KernelThing = {
+    readonly ok: true;
+    readonly reason: null;
+    readonly cost: PhoneCost;
+    readonly mass_kg: number;
+    readonly breaks: ThingBreak;
+    readonly levels: readonly KernelThingLevel[];
+    readonly mesh: KernelThingMesh;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+interface KernelPlace {
+    readonly grid: {
+        readonly columns: number;
+        readonly rows: number;
+        readonly cell: number;
+        readonly cells: readonly number[];
+    };
+    readonly placements: readonly WorldPlacement[];
+    readonly people: readonly WorldPlacement[];
+    readonly weight: {
+        readonly total: number;
+        readonly layers: readonly {
+            readonly layer: string;
+            readonly count: number;
+            readonly cost: number;
+            readonly share: number;
+        }[];
+        readonly tiers: {
+            readonly [T in DeviceTier]: TierVerdict;
+        };
+        readonly tier_totals: {
+            readonly [T in DeviceTier]: number;
+        };
+        readonly tier_people: {
+            readonly [T in DeviceTier]: number;
+        };
+    };
+    readonly checks: readonly {
+        readonly id: string;
+        readonly ok: boolean;
+        readonly summary: string;
+    }[];
+    readonly fewer_people: KernelFewerPeople | null;
+}
+interface KernelFewerPeople {
+    readonly crowd_caps: {
+        readonly [T in DeviceTier]?: number | null;
+    };
+    readonly fixes: readonly {
+        readonly tier: DeviceTier;
+        readonly from: number;
+        readonly to: number;
+    }[];
+    readonly still_heavy: readonly {
+        readonly tier: DeviceTier;
+        readonly without_people: number;
+        readonly budget: number;
+        readonly layers: readonly {
+            readonly layer: string;
+            readonly cost: number;
+            readonly share: number;
+        }[];
+        readonly summary: string;
+    }[];
+}
+declare const TIER_WORDS: {
+    readonly [T in DeviceTier]: string;
+};
+declare const LAYER_WORDS: {
+    readonly [L in WorldLayer]: string;
+};
+interface StudioKernel {
+    schemas(names: string): string;
+    materials(): string;
+    catalogue(): string;
+    compileThing(thing: string): string;
+    buildPlace(world: string): string;
+    simplifyRoad(points: string, tolerance: string): string;
+    outcome(parts: string, live: string): string;
+}
+declare function kernelSchemas(names: readonly string[]): {
+    readonly [name: string]: KernelSchema;
+};
+declare function kernelMaterials(): readonly KernelMaterial[];
+declare function kernelThing(thing: Thing): KernelThing;
+declare function heavySummary(heavy: HeavyWithoutPeople): string;
+declare function kernelFewerPeople(doc: WorldDoc, weight: WorldWeight): KernelFewerPeople | null;
+declare function kernelPlace(doc: WorldDoc): KernelPlace;
+declare function studioKernel(): StudioKernel;
+
+export { type AssetChange, type AssetControl, type AssetKind, type AssetSetting, type AssetSwap, type AssetUpgrades, type BooleanSetting, CROWD_CHEER_SETTINGS, CROWD_VOTE_SETTINGS, type ChoiceOption, type ChoiceSetting, type ColorControl, type ColorSetting, DEFAULT_HISTORY, type EditTransaction, GIZMO_COLORS, GIZMO_HIT_PIXELS, GIZMO_SIZE_PIXELS, GROUND_BRUSH_SETTINGS, GizmoHandle, type GizmoHandleId, type GizmoLines, type GizmoMode, type GizmoOptions, type GizmoSnap, type GizmoSpace, type GroupControl, HEAVY_NOTE, type InspectorControl, type InspectorOptions, type InspectorPanel, type InspectorSection, type InspectorValues, type IntegerSetting, type KernelFewerPeople, type KernelMaterial, type KernelPlace, type KernelSchema, type KernelThing, LAYER_WORDS, type ListControl, type ListItemEditor, type ListSetting, type LiveTarget, type LiveTargets, LiveTweak, MARKER_KINDS, MAX_DESCRIPTION_CHARS, MAX_PICK_DEPTH, MUSIC_BED_SETTINGS, MemoryOpLog, NO_SNAP, type NestedSetting, type Normalized, type NumberSetting, type OpAuthor, type OpSink, PICK_SEGMENTS, PLACEMENT_POSITION, PLACEMENT_ROTATION, PLACEMENT_SCALE, PLACEMENT_SETTINGS, type PickControl, PickHit, type PickScene, type PickableGame, PlacementDrag, PlacementTarget, type PlacementTransforms, type ReadSetting, type RegistryGap, type ResolvedField, type ResolvedSettings, type Rgb, SCATTER_BRUSH_SETTINGS, SEGMENTED_MAX_OPTIONS, SETTINGS_TOOL_PREFIX, SETTING_UNIT_LABELS, STEPPER_MAX_SPAN, STUDIO_KERNEL_GLOBAL, STUDIO_PEOPLE, STUDIO_SETTINGS, type SchemaGap, type SelectMode, Selection, type SelectionListener, type SetOp, type Setting, type SettingFields, type SettingKind, type SettingUnit, type SettingValue, type SettingsDefinition, SettingsRegistry, SettingsRegistryError, type SettingsSchema, type SettingsToolResult, type SliderControl, SourceIdError, SourceIdMap, type SourceOp, type StepperControl, type StudioCatalogue, type StudioKernel, type StudioPlaceable, type StudioPlaceableLayer, type StudioToolDefinition, THING_EFFECT_SETTINGS, THING_PART_SETTINGS, TIER_WORDS, type TextControl, type TextSetting, type ThingControl, type ThingPicker, type ThingRole, type ThingSetting, type ToggleControl, TransformGizmo, UI_MOTION_SETTINGS, type ValueIssue, type VectorControl, type VectorSetting, WORLD_SKY_SETTINGS, type WiringSetting, applyOps, applyTransaction, defineSettings, eulerDegreesToQuat, gamePickScene, heavySummary, inspectorControls, inspectorPanel, invertOp, invertTransaction, kernelFewerPeople, kernelMaterials, kernelPlace, kernelSchemas, kernelThing, kindLabel, normalizeSetting, pickSource, quatToEulerDegrees, reloadAsset, s, schemaGaps, sentence, settingDefault, settingDefaultText, settingGaps, settingRangeText, settingsDoc, settingsDocs, settingsTool, settingsToolName, settingsToolOps, settingsToolTransaction, settingsTools, sourceAt, studioCatalogue, studioKernel, thingPicker };