@threlte/theatre 3.0.0-next.6 → 3.0.0-next.8

package/dist/project/Project.svelte.d.ts

@@ -1,24 +1,12 @@
-import { SvelteComponent } from "svelte";
 import { type Snippet } from 'svelte';
 import type { IProject, IProjectConfig } from '@theatre/core';
-declare const __propDef: {
-    props: {
-        name: string;
-        config?: IProjectConfig | undefined;
-        project?: IProject | undefined;
-        isReady?: boolean | undefined;
-        children?: Snippet<[{
-            project: IProject;
-        }]> | undefined;
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type ProjectProps = typeof __propDef.props;
-export type ProjectEvents = typeof __propDef.events;
-export type ProjectSlots = typeof __propDef.slots;
-export default class Project extends SvelteComponent<ProjectProps, ProjectEvents, ProjectSlots> {
-}
-export {};
+declare const Project: import("svelte").Component<{
+    name: string;
+    config?: IProjectConfig | undefined;
+    project?: IProject | undefined;
+    isReady?: boolean | undefined;
+    children?: Snippet<[{
+        project: IProject;
+    }]> | undefined;
+}, {}, "project" | "isReady">;
+export default Project;

package/dist/sequence/Sequence.svelte.d.ts

@@ -1,76 +1,82 @@
-import { SvelteComponent } from "svelte";
-import type { IRafDriver } from '@theatre/core';
+/// <reference types="svelte" />
+import type { IRafDriver, ISequence } from '@theatre/core';
 import type { Autoreset, IterationCount, PlaybackDirection, PlaybackRange, SequenceAudioOptions } from './types';
-declare const __propDef: {
-    props: {
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+type $$__sveltets_2_PropsWithChildren<Props, Slots> = Props & (Slots extends {
+    default: any;
+} ? Props extends Record<string, never> ? any : {
+    children?: any;
+} : {});
+declare const Sequence: $$__sveltets_2_IsomorphicComponent<$$__sveltets_2_PropsWithChildren<{
+    rate?: number | undefined;
+    range?: PlaybackRange;
+    iterationCount?: IterationCount;
+    direction?: PlaybackDirection;
+    rafDriver?: IRafDriver | undefined;
+    audio?: SequenceAudioOptions | undefined;
+    autoplay?: boolean | undefined;
+    autoreset?: Autoreset;
+    autopause?: boolean | undefined;
+    delay?: number | undefined;
+    sequence?: import("./SequenceController").SequenceController | undefined;
+    position?: number | undefined;
+    playing?: boolean | undefined;
+    length?: number | undefined;
+    play?: ((conf?: {
+        iterationCount?: number | undefined;
+        range?: [from: number, to: number] | undefined;
         rate?: number | undefined;
-        range?: PlaybackRange;
-        iterationCount?: IterationCount;
-        direction?: PlaybackDirection;
+        direction?: ("reverse" | "alternate" | "normal" | "alternateReverse") | undefined;
         rafDriver?: IRafDriver | undefined;
-        audio?: SequenceAudioOptions | undefined;
-        autoplay?: boolean | undefined;
-        autoreset?: Autoreset;
-        autopause?: boolean | undefined;
-        delay?: number | undefined;
-        sequence?: import("./SequenceController").SequenceController | undefined;
-        position?: number | undefined;
-        playing?: boolean | undefined;
-        length?: number | undefined;
-        play?: ((conf?: {
+    } | undefined) => Promise<boolean>) | undefined;
+    pause?: (() => void) | undefined;
+}, {
+    default: {
+        sequence: import("./SequenceController").SequenceController;
+        position: number;
+        playing: boolean;
+        play: (conf?: {
             iterationCount?: number | undefined;
             range?: [from: number, to: number] | undefined;
             rate?: number | undefined;
             direction?: ("reverse" | "alternate" | "normal" | "alternateReverse") | undefined;
             rafDriver?: IRafDriver | undefined;
-        } | undefined) => Promise<boolean>) | undefined;
-        pause?: (() => void) | undefined;
-        children?: import("svelte").Snippet<[{
-            sequence: import("./SequenceController").SequenceController;
-            position: number;
-            playing: boolean;
-            play: (conf?: {
-                iterationCount?: number | undefined;
-                range?: [from: number, to: number] | undefined;
-                rate?: number | undefined;
-                direction?: ("reverse" | "alternate" | "normal" | "alternateReverse") | undefined;
-                rafDriver?: IRafDriver | undefined;
-            } | undefined) => Promise<boolean>;
-            pause: () => void;
-        }]> | undefined;
+        } | undefined) => Promise<boolean>;
+        pause: () => void;
     };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {
-        default: {
-            sequence: import("./SequenceController").SequenceController;
-            position: number;
-            playing: boolean;
-            play: (conf?: {
-                iterationCount?: number | undefined;
-                range?: [from: number, to: number] | undefined;
-                rate?: number | undefined;
-                direction?: ("reverse" | "alternate" | "normal" | "alternateReverse") | undefined;
-                rafDriver?: IRafDriver | undefined;
-            } | undefined) => Promise<boolean>;
-            pause: () => void;
-        };
+}>, {
+    [evt: string]: CustomEvent<any>;
+}, {
+    default: {
+        sequence: import("./SequenceController").SequenceController;
+        position: number;
+        playing: boolean;
+        play: (conf?: {
+            iterationCount?: number | undefined;
+            range?: [from: number, to: number] | undefined;
+            rate?: number | undefined;
+            direction?: ("reverse" | "alternate" | "normal" | "alternateReverse") | undefined;
+            rafDriver?: IRafDriver | undefined;
+        } | undefined) => Promise<boolean>;
+        pause: () => void;
     };
-};
-export type SequenceProps = typeof __propDef.props;
-export type SequenceEvents = typeof __propDef.events;
-export type SequenceSlots = typeof __propDef.slots;
-export default class Sequence extends SvelteComponent<SequenceProps, SequenceEvents, SequenceSlots> {
-    get sequence(): import("./SequenceController").SequenceController;
-    get length(): number;
-    get play(): (conf?: {
-        iterationCount?: number | undefined;
-        range?: [from: number, to: number] | undefined;
-        rate?: number | undefined;
-        direction?: ("reverse" | "alternate" | "normal" | "alternateReverse") | undefined;
-        rafDriver?: IRafDriver | undefined;
-    } | undefined) => Promise<boolean>;
-    get pause(): () => void;
-}
-export {};
+}, {
+    sequence: import("./SequenceController").SequenceController;
+    length: number;
+    play: ISequence['play'];
+    pause: ISequence['pause'];
+}, string>;
+type Sequence = InstanceType<typeof Sequence>;
+export default Sequence;

package/dist/sheet/Sheet.svelte.d.ts

@@ -1,32 +1,44 @@
-import { SvelteComponent } from "svelte";
+/// <reference types="svelte" />
 import type { IProject } from '@theatre/core';
 import { SequenceController } from '../sequence/SequenceController';
-declare const __propDef: {
-    props: {
-        project?: IProject | undefined;
-        name?: string | undefined;
-        instance?: string | undefined;
-        sheet?: import("@theatre/core").ISheet | undefined;
-        sequence?: SequenceController | undefined;
-        children?: import("svelte").Snippet<[{
-            sheet: import("@theatre/core").ISheet;
-        }]> | undefined;
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
     };
-    events: {
-        [evt: string]: CustomEvent<any>;
+    z_$$bindings?: Bindings;
+}
+type $$__sveltets_2_PropsWithChildren<Props, Slots> = Props & (Slots extends {
+    default: any;
+} ? Props extends Record<string, never> ? any : {
+    children?: any;
+} : {});
+declare const Sheet: $$__sveltets_2_IsomorphicComponent<$$__sveltets_2_PropsWithChildren<{
+    project?: IProject | undefined;
+    name?: string | undefined;
+    instance?: string | undefined;
+    sheet?: import("@theatre/core").ISheet | undefined;
+    sequence?: SequenceController | undefined;
+}, {
+    default: {
+        sheet: import("@theatre/core").ISheet;
     };
-    slots: {
-        default: {
-            sheet: import("@theatre/core").ISheet;
-        };
+}>, {
+    [evt: string]: CustomEvent<any>;
+}, {
+    default: {
+        sheet: import("@theatre/core").ISheet;
     };
-};
-export type SheetProps = typeof __propDef.props;
-export type SheetEvents = typeof __propDef.events;
-export type SheetSlots = typeof __propDef.slots;
-export default class Sheet extends SvelteComponent<SheetProps, SheetEvents, SheetSlots> {
-    get project(): IProject;
-    get sheet(): import("@theatre/core").ISheet;
-    get sequence(): SequenceController;
-}
-export {};
+}, {
+    project: IProject;
+    sheet: import("@theatre/core").ISheet;
+    sequence: SequenceController;
+}, string>;
+type Sheet = InstanceType<typeof Sheet>;
+export default Sheet;

package/dist/sheetObject/SheetObject.svelte

@@ -3,9 +3,12 @@
 	- Creating namespaces
 	- Potentially Providing a sheet object
 -->
-<script lang="ts">import { useStudio } from '../studio/useStudio';
-import { currentWritable, watch, useThrelte } from '@threlte/core';
-import { getContext, onDestroy, onMount, setContext } from 'svelte';
+<script
+  lang="ts"
+  generics="Props extends UnknownShorthandCompoundProps"
+>import { useStudio } from '../studio/useStudio';
+import { currentWritable, useThrelte, watch } from '@threlte/core';
+import { getContext, onDestroy, onMount } from 'svelte';
 import Declare from './declare/Declare.svelte';
 import Sync from './sync/Sync.svelte';
 import Transform from './transform/Transform.svelte';

package/dist/sheetObject/SheetObject.svelte.d.ts

@@ -1,32 +1,20 @@
-import type { ISheetObject, UnknownShorthandCompoundProps } from '@theatre/core'
-import { SvelteComponent, type Snippet } from 'svelte'
-import type Declare from './declare/Declare.svelte'
-import type Sync from './sync/Sync.svelte'
-import type Transform from './transform/Transform.svelte'
-
-export type SheetObjectProps<T> = {
-  key: string
-  detach?: boolean
-  selected?: boolean
-  props?: T
-
-  children?: Snippet<
-    [
-      {
-        values: ISheetObject['value']
-        selected: boolean
-        select: () => void
-        deselect: () => void
-        sheetObject: ISheetObject
-        Sync: typeof Sync
-        Transform: typeof Transform
-        Declare: typeof Declare
-      }
-    ]
-  >
-
-  onchange?: (sheet: ISheetObject['value']) => void
+/// <reference types="svelte" />
+import type { UnknownShorthandCompoundProps } from '@theatre/core';
+import type { SheetObjectProps } from './types';
+declare class __sveltets_Render<Props extends UnknownShorthandCompoundProps> {
+    props(): SheetObjectProps<Props>;
+    events(): {};
+    slots(): {};
+    bindings(): "selected";
+    exports(): {};
 }
-export default class SheetObject<T extends UnknownShorthandCompoundProps> extends SvelteComponent<
-  SheetObjectProps<T>
-> {}
+interface $$IsomorphicComponent {
+    new <Props extends UnknownShorthandCompoundProps>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Props>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Props>['props']>, ReturnType<__sveltets_Render<Props>['events']>, ReturnType<__sveltets_Render<Props>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<Props>['bindings']>;
+    } & ReturnType<__sveltets_Render<Props>['exports']>;
+    <Props extends UnknownShorthandCompoundProps>(internal: unknown, props: ReturnType<__sveltets_Render<Props>['props']> & {}): ReturnType<__sveltets_Render<Props>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const SheetObject: $$IsomorphicComponent;
+type SheetObject<Props extends UnknownShorthandCompoundProps> = InstanceType<typeof SheetObject<Props>>;
+export default SheetObject;

package/dist/sheetObject/declare/Declare.svelte

@@ -1,4 +1,7 @@
-<script lang="ts">import { watch } from '@threlte/core';
+<script
+  lang="ts"
+  generics="P extends UnknownShorthandCompoundProps"
+>import { watch } from '@threlte/core';
 import { onDestroy } from 'svelte';
 import { useSheet } from '../useSheet';
 let { props, children } = $props();

package/dist/sheetObject/declare/Declare.svelte.d.ts

@@ -1,12 +1,20 @@
-import type { ISheetObject, UnknownShorthandCompoundProps } from '@theatre/core'
-import type { Snippet, SvelteComponent } from 'svelte'
-
-export type DeclareProps<T extends UnknownShorthandCompoundProps> = {
-  props: T
-
-  children?: Snippet<[{ values: ISheetObject<T>['value'] }]>
+/// <reference types="svelte" />
+import type { UnknownShorthandCompoundProps } from '@theatre/core';
+import type { DeclareProps } from './types';
+declare class __sveltets_Render<P extends UnknownShorthandCompoundProps> {
+    props(): DeclareProps<P>;
+    events(): {};
+    slots(): {};
+    bindings(): "";
+    exports(): {};
 }
-
-export default class Declare<T extends UnknownShorthandCompoundProps> extends SvelteComponent<
-  DeclareProps<T>
-> {}
+interface $$IsomorphicComponent {
+    new <P extends UnknownShorthandCompoundProps>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<P>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<P>['props']>, ReturnType<__sveltets_Render<P>['events']>, ReturnType<__sveltets_Render<P>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<P>['bindings']>;
+    } & ReturnType<__sveltets_Render<P>['exports']>;
+    <P extends UnknownShorthandCompoundProps>(internal: unknown, props: ReturnType<__sveltets_Render<P>['props']> & {}): ReturnType<__sveltets_Render<P>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Declare: $$IsomorphicComponent;
+type Declare<P extends UnknownShorthandCompoundProps> = InstanceType<typeof Declare<P>>;
+export default Declare;

package/dist/sheetObject/declare/types.d.ts

@@ -0,0 +1,9 @@
+import type { ISheetObject, UnknownShorthandCompoundProps } from '@theatre/core';
+import type { Snippet } from 'svelte';
+export type DeclareProps<T extends UnknownShorthandCompoundProps> = {
+    props: T;
+    children?: Snippet<[{
+        values: ISheetObject<T>['value'];
+    }]>;
+};
+export type Values<T> = T extends UnknownShorthandCompoundProps ? ISheetObject<T>['value'] : never;

package/dist/sheetObject/declare/types.js

@@ -0,0 +1 @@
+export {};

package/dist/sheetObject/sync/Sync.svelte

@@ -1,12 +1,15 @@
-<script lang="ts">import { resolvePropertyPath, useParent, watch } from '@threlte/core';
+<script
+  lang="ts"
+  generics="Type"
+>import { resolvePropertyPath, useParent, watch } from '@threlte/core';
 import { onDestroy } from 'svelte';
+import { useStudio } from '../../studio/useStudio';
+import { useSheet } from '../useSheet';
 import { getInitialValue } from './utils/getInitialValue';
 import { isComplexProp } from './utils/isComplexProp';
+import { isStringProp } from './utils/isStringProp';
 import { makeAlphanumeric } from './utils/makeAlphanumeric';
 import { parsePropLabel } from './utils/parsePropLabel';
-import { isStringProp } from './utils/isStringProp';
-import { useStudio } from '../../studio/useStudio';
-import { useSheet } from '../useSheet';
 let { type, children, ...rest } = $props();
 const { sheetObject, addProps, removeProps } = useSheet();
 const parent = useParent();
@@ -73,6 +76,9 @@ watch([parent, sheetObject], ([parent, sheetObject]) => {
 });
 initProps();
 const studio = useStudio();
+/**
+ * Capture the current values of the props
+ */
 export const capture = () => {
     if (!$studio)
         return;

package/dist/sheetObject/sync/Sync.svelte.d.ts

@@ -1,65 +1,23 @@
-import type { Snippet, SvelteComponent } from 'svelte'
-import type { Transformer } from '../transfomers/types'
-import type { ConditionalKeys, Primitive } from 'type-fest'
-
-/* COPIED FROM @threlte/core START */
-type OmittedPropKeys =
-  | 'type'
-  | 'args'
-  | 'attach'
-  | 'manual'
-  | 'makeDefault'
-  | 'id'
-  | 'children'
-  | `is${string}` // isMesh, isObject3D, etc
-  | 'parent'
-  | 'uuid'
-  | 'name'
-type AnyClass = new (...args: any) => any
-type AnyFn = (...args: any) => any
-type MaybeInstance<Type extends any> = Type extends AnyClass ? InstanceType<Type> : Type
-type InstanceProps<Type extends any> = Partial<
-  Omit<
-    MaybeInstance<Type> extends Primitive
-      ? Record<string, unknown>
-      : {
-          [K in keyof MaybeInstance<Type>]?: MaybeInstance<Type>[K] extends {
-            set: (...args: any[]) => any
-          }
-            ?
-                | Parameters<MaybeInstance<Type>[K]['set']>
-                | Parameters<MaybeInstance<Type>[K]['set']>[0]
-            : MaybeInstance<Type>[K] extends AnyFn
-              ? never
-              : MaybeInstance<Type>[K]
-        },
-    ConditionalKeys<MaybeInstance<Type>, AnyFn> | OmittedPropKeys
-  >
->
-/* COPIED FROM @threlte/core END */
-
-type ObjectProp<T> = {
-  type?: T
+/// <reference types="svelte" />
+import type { SyncProps } from './types';
+declare class __sveltets_Render<Type> {
+    props(): SyncProps<Type>;
+    events(): {};
+    slots(): {};
+    bindings(): "";
+    exports(): {
+        /**
+           * Capture the current values of the props
+           */ capture: () => void;
+    };
 }
-
-export type ComplexProp = {
-  transformer?: Transformer
-  label?: string
-  key?: string
+interface $$IsomorphicComponent {
+    new <Type>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Type>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Type>['props']>, ReturnType<__sveltets_Render<Type>['events']>, ReturnType<__sveltets_Render<Type>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<Type>['bindings']>;
+    } & ReturnType<__sveltets_Render<Type>['exports']>;
+    <Type>(internal: unknown, props: ReturnType<__sveltets_Render<Type>['props']> & {}): ReturnType<__sveltets_Render<Type>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
-
-export type AnyProp = string | boolean | ComplexProp
-
-type AnyProps<T> = {
-  [P in keyof InstanceProps<T>]?: AnyProp
-}
-
-export type SyncProps<T> = AnyProps<T> &
-  ObjectProp<T> &
-  Record<string, AnyProp | T> & {
-    capture?: () => void
-  } & {
-    children?: Snippet<[{ capture: () => void }]>
-  }
-
-export default class Sync<T> extends SvelteComponent<SyncProps<T>> {}
+declare const Sync: $$IsomorphicComponent;
+type Sync<Type> = InstanceType<typeof Sync<Type>>;
+export default Sync;

package/dist/sheetObject/sync/types.d.ts

@@ -0,0 +1,30 @@
+import type { Snippet } from 'svelte';
+import type { ConditionalKeys, Primitive } from 'type-fest';
+import type { Transformer } from '../transfomers/types';
+type OmittedPropKeys = 'type' | 'args' | 'attach' | 'manual' | 'makeDefault' | 'id' | 'children' | `is${string}` | 'parent' | 'uuid' | 'name';
+type AnyClass = new (...args: any) => any;
+type AnyFn = (...args: any) => any;
+type MaybeInstance<Type extends any> = Type extends AnyClass ? InstanceType<Type> : Type;
+type InstanceProps<Type extends any> = Partial<Omit<MaybeInstance<Type> extends Primitive ? Record<string, unknown> : {
+    [K in keyof MaybeInstance<Type>]?: MaybeInstance<Type>[K] extends {
+        set: (...args: any[]) => any;
+    } ? Parameters<MaybeInstance<Type>[K]['set']> | Parameters<MaybeInstance<Type>[K]['set']>[0] : MaybeInstance<Type>[K] extends AnyFn ? never : MaybeInstance<Type>[K];
+}, ConditionalKeys<MaybeInstance<Type>, AnyFn> | OmittedPropKeys>>;
+type ObjectProp<T> = {
+    type?: T;
+};
+export type ComplexProp = {
+    transformer?: Transformer;
+    label?: string;
+    key?: string;
+};
+export type AnyProp = string | boolean | ComplexProp;
+type AnyProps<T> = {
+    [P in keyof InstanceProps<T>]?: AnyProp;
+};
+export type SyncProps<T> = AnyProps<T> & ObjectProp<T> & Record<string, AnyProp | T> & {
+    children?: Snippet<[{
+        capture: () => void;
+    }]>;
+};
+export {};

package/dist/sheetObject/sync/types.js

@@ -0,0 +1 @@
+export {};

package/dist/sheetObject/sync/utils/isComplexProp.d.ts

@@ -1,2 +1,2 @@
-import type { AnyProp, ComplexProp } from '../Sync.svelte';
+import type { AnyProp, ComplexProp } from '../types';
 export declare const isComplexProp: (prop: AnyProp) => prop is ComplexProp;

package/dist/sheetObject/sync/utils/isStringProp.d.ts

@@ -1,2 +1,2 @@
-import type { AnyProp } from '../Sync.svelte';
+import type { AnyProp } from '../types';
 export declare const isStringProp: (prop: AnyProp) => prop is string;

package/dist/sheetObject/sync/utils/parsePropLabel.d.ts

@@ -1,2 +1,2 @@
-import type { AnyProp } from '../Sync.svelte';
+import type { AnyProp } from '../types';
 export declare const parsePropLabel: (alphaNumericKey: string, propValue: AnyProp) => string;

package/dist/sheetObject/transform/Transform.svelte

@@ -1,10 +1,13 @@
-<script lang="ts">import { types } from '../../theatre';
-import { T, watch } from '@threlte/core';
+<script
+  lang="ts"
+  generics="Label extends string | undefined"
+>import { T, watch } from '@threlte/core';
 import { TransformControls } from '@threlte/extras';
 import { onMount } from 'svelte';
 import { Group } from 'three';
 import { RAD2DEG } from 'three/src/math/MathUtils.js';
 import { useStudio } from '../../studio/useStudio';
+import { types } from '../../theatre';
 import { getDefaultTransformer } from '../transfomers/getDefaultTransformer';
 import { useSheet } from '../useSheet';
 let { label, key, mode = 'translate', space, translationSnap, rotationSnap, scaleSnap, children } = $props();

package/dist/sheetObject/transform/Transform.svelte.d.ts

@@ -1,22 +1,19 @@
-import type { Snippet, SvelteComponent } from 'svelte'
-
-export type TransformProps<T extends string | undefined> = {
-  label?: T
-  mode?: 'translate' | 'rotate' | 'scale'
-  translationSnap?: number
-  rotationSnap?: number
-  scaleSnap?: number
-  space?: 'world' | 'local'
-
-  children?: Snippet
-} & (T extends string
-  ? {
-      key: string
-    }
-  : {
-      key?: string
-    })
-
-export default class Transform<Label extends string | undefined> extends SvelteComponent<
-  TransformProps<Label>
-> {}
+/// <reference types="svelte" />
+import type { TransformProps } from './types';
+declare class __sveltets_Render<Label extends string | undefined> {
+    props(): TransformProps<Label>;
+    events(): {};
+    slots(): {};
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Label extends string | undefined>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Label>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Label>['props']>, ReturnType<__sveltets_Render<Label>['events']>, ReturnType<__sveltets_Render<Label>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<Label>['bindings']>;
+    } & ReturnType<__sveltets_Render<Label>['exports']>;
+    <Label extends string | undefined>(internal: unknown, props: ReturnType<__sveltets_Render<Label>['props']> & {}): ReturnType<__sveltets_Render<Label>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Transform: $$IsomorphicComponent;
+type Transform<Label extends string | undefined> = InstanceType<typeof Transform<Label>>;
+export default Transform;

package/dist/sheetObject/transform/types.d.ts

@@ -0,0 +1,14 @@
+import type { Snippet } from 'svelte';
+export type TransformProps<T extends string | undefined> = {
+    label?: T;
+    mode?: 'translate' | 'rotate' | 'scale';
+    translationSnap?: number;
+    rotationSnap?: number;
+    scaleSnap?: number;
+    space?: 'world' | 'local';
+    children?: Snippet;
+} & (T extends string ? {
+    key: string;
+} : {
+    key?: string;
+});

package/dist/sheetObject/transform/types.js

@@ -0,0 +1 @@
+export {};

package/dist/sheetObject/types.d.ts

@@ -0,0 +1,24 @@
+import type { ISheetObject, UnknownShorthandCompoundProps } from '@theatre/core';
+import { type Snippet } from 'svelte';
+import type Declare from './declare/Declare.svelte';
+import type Sync from './sync/Sync.svelte';
+import type Transform from './transform/Transform.svelte';
+export type SheetObjectProps<T extends UnknownShorthandCompoundProps> = {
+    key: string;
+    detach?: boolean;
+    selected?: boolean;
+    props?: T;
+    children?: Snippet<[
+        {
+            values: ISheetObject['value'];
+            selected: boolean;
+            select: () => void;
+            deselect: () => void;
+            sheetObject: ISheetObject<T>;
+            Sync: typeof Sync;
+            Transform: typeof Transform;
+            Declare: typeof Declare;
+        }
+    ]>;
+    onchange?: (sheet: ISheetObject<T>['value']) => void;
+};

package/dist/sheetObject/types.js

@@ -0,0 +1 @@
+export {};

package/dist/sheetObject/useSheet.d.ts

@@ -1,10 +1,10 @@
 import type { ISheetObject, UnknownShorthandCompoundProps } from '@theatre/core';
 import type { CurrentWritable } from '@threlte/core';
-interface Context {
-    sheetObject: CurrentWritable<ISheetObject<any>>;
+type Context<T extends UnknownShorthandCompoundProps = {}> = {
+    sheetObject: CurrentWritable<ISheetObject<T>>;
     addProps: (props: UnknownShorthandCompoundProps) => void;
     removeProps: (names: string[]) => void;
-}
+};
 export declare const createSheetContext: (context: Context) => void;
-export declare const useSheet: () => Context;
+export declare const useSheet: <T extends UnknownShorthandCompoundProps = {}>() => Context<T>;
 export {};

package/dist/studio/InnerStudio.svelte.d.ts

@@ -1,19 +1,30 @@
-import { SvelteComponent } from "svelte";
-declare const __propDef: {
-    props: {
-        hide: boolean;
-        children?: import("svelte").Snippet<[]> | undefined;
+/// <reference types="svelte" />
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
     };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {
-        default: {};
-    };
-};
-export type InnerStudioProps = typeof __propDef.props;
-export type InnerStudioEvents = typeof __propDef.events;
-export type InnerStudioSlots = typeof __propDef.slots;
-export default class InnerStudio extends SvelteComponent<InnerStudioProps, InnerStudioEvents, InnerStudioSlots> {
+    z_$$bindings?: Bindings;
 }
-export {};
+type $$__sveltets_2_PropsWithChildren<Props, Slots> = Props & (Slots extends {
+    default: any;
+} ? Props extends Record<string, never> ? any : {
+    children?: any;
+} : {});
+declare const InnerStudio: $$__sveltets_2_IsomorphicComponent<$$__sveltets_2_PropsWithChildren<{
+    hide: boolean;
+}, {
+    default: {};
+}>, {
+    [evt: string]: CustomEvent<any>;
+}, {
+    default: {};
+}, {}, string>;
+type InnerStudio = InstanceType<typeof InnerStudio>;
+export default InnerStudio;

package/dist/studio/Studio.svelte.d.ts

@@ -1,20 +1,31 @@
-import { SvelteComponent } from "svelte";
-declare const __propDef: {
-    props: {
-        enabled?: boolean | undefined;
-        hide?: boolean | undefined;
-        children?: import("svelte").Snippet<[]> | undefined;
+/// <reference types="svelte" />
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
     };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {
-        default: {};
-    };
-};
-export type StudioProps = typeof __propDef.props;
-export type StudioEvents = typeof __propDef.events;
-export type StudioSlots = typeof __propDef.slots;
-export default class Studio extends SvelteComponent<StudioProps, StudioEvents, StudioSlots> {
+    z_$$bindings?: Bindings;
 }
-export {};
+type $$__sveltets_2_PropsWithChildren<Props, Slots> = Props & (Slots extends {
+    default: any;
+} ? Props extends Record<string, never> ? any : {
+    children?: any;
+} : {});
+declare const Studio: $$__sveltets_2_IsomorphicComponent<$$__sveltets_2_PropsWithChildren<{
+    enabled?: boolean | undefined;
+    hide?: boolean | undefined;
+}, {
+    default: {};
+}>, {
+    [evt: string]: CustomEvent<any>;
+}, {
+    default: {};
+}, {}, string>;
+type Studio = InstanceType<typeof Studio>;
+export default Studio;

package/dist/theatre/Theatre.svelte.d.ts

@@ -1,24 +1,35 @@
-import { SvelteComponent } from "svelte";
+/// <reference types="svelte" />
 import type { IProjectConfig } from '@theatre/core';
-declare const __propDef: {
-    props: {
-        studio?: {
-            enabled?: boolean | undefined;
-            hide?: boolean | undefined;
-        } | undefined;
-        config?: IProjectConfig | undefined;
-        children?: import("svelte").Snippet<[]> | undefined;
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
     };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {
-        default: {};
-    };
-};
-export type TheatreProps = typeof __propDef.props;
-export type TheatreEvents = typeof __propDef.events;
-export type TheatreSlots = typeof __propDef.slots;
-export default class Theatre extends SvelteComponent<TheatreProps, TheatreEvents, TheatreSlots> {
+    z_$$bindings?: Bindings;
 }
-export {};
+type $$__sveltets_2_PropsWithChildren<Props, Slots> = Props & (Slots extends {
+    default: any;
+} ? Props extends Record<string, never> ? any : {
+    children?: any;
+} : {});
+declare const Theatre: $$__sveltets_2_IsomorphicComponent<$$__sveltets_2_PropsWithChildren<{
+    studio?: {
+        enabled?: boolean | undefined;
+        hide?: boolean | undefined;
+    } | undefined;
+    config?: IProjectConfig | undefined;
+}, {
+    default: {};
+}>, {
+    [evt: string]: CustomEvent<any>;
+}, {
+    default: {};
+}, {}, string>;
+type Theatre = InstanceType<typeof Theatre>;
+export default Theatre;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@threlte/theatre",
-  "version": "3.0.0-next.6",
+  "version": "3.0.0-next.8",
   "author": "Grischa Erbe <hello@legrisch.com> (https://legrisch.com)",
   "license": "MIT",
   "description": "Threlte Components for Theatre, an animation library with a professional motion design toolset",
   "devDependencies": {
     "@sveltejs/adapter-auto": "^3.2.0",
     "@sveltejs/kit": "^2.7.2",
-    "@sveltejs/package": "^2.3.1",
+    "@sveltejs/package": "^2.3.7",
     "@sveltejs/vite-plugin-svelte": "^3.1.0",
     "@types/node": "^20.12.7",
     "@types/three": "^0.169.0",
@@ -21,17 +21,17 @@
     "prettier-plugin-svelte": "^3.2.2",
     "publint": "^0.2.7",
     "rimraf": "^5.0.5",
-    "svelte": "^5.0.5",
+    "svelte": "^5.1.6",
     "svelte-check": "^3.6.9",
     "svelte-preprocess": "^5.1.3",
     "svelte2tsx": "^0.7.6",
-    "three": "^0.169.0",
+    "three": "^0.170.0",
     "tslib": "^2.6.2",
     "type-fest": "^4.15.0",
     "typescript": "^5.4.5",
     "vite": "^5.2.8",
-    "@threlte/core": "8.0.0-next.21",
-    "@threlte/extras": "9.0.0-next.28"
+    "@threlte/core": "8.0.0-next.24",
+    "@threlte/extras": "9.0.0-next.35"
   },
   "peerDependencies": {
     "svelte": ">=4",