@woven-canvas/core 1.0.4 → 1.0.6

package/build/_tsup-dts-rollup.d.ts

@@ -75,10 +75,37 @@ declare const AabbSchema: {
 
 export { addComponent }
 
+declare const AddFrameHighlight: CommandDef<    {
+frameId: EntityId;
+}>;
+export { AddFrameHighlight }
+export { AddFrameHighlight as AddFrameHighlight_alias_1 }
+export { AddFrameHighlight as AddFrameHighlight_alias_2 }
+
+declare const AddHeld: CommandDef<    {
+entityId: EntityId;
+}>;
+export { AddHeld }
+export { AddHeld as AddHeld_alias_1 }
+export { AddHeld as AddHeld_alias_2 }
+
 declare function addPointerSample(pointer: ReturnType<typeof Pointer.write>, position: Vec2, time: number): void;
 export { addPointerSample }
 export { addPointerSample as addPointerSample_alias_1 }
 
+declare const AddSelectionBox: CommandDef<void>;
+export { AddSelectionBox }
+export { AddSelectionBox as AddSelectionBox_alias_1 }
+export { AddSelectionBox as AddSelectionBox_alias_2 }
+
+declare const AddTransformBox: CommandDef<    {
+transformBoxId: EntityId;
+skipHandles?: boolean;
+}>;
+export { AddTransformBox }
+export { AddTransformBox as AddTransformBox_alias_1 }
+export { AddTransformBox as AddTransformBox_alias_2 }
+
 export { AnyCanvasComponentDef }
 
 export { AnyCanvasSingletonDef }
@@ -91,6 +118,16 @@ export { Asset }
 export { Asset as Asset_alias_1 }
 export { Asset as Asset_alias_2 }
 
+declare const AssignFrameChildren: CommandDef<    {
+assignments: Array<{
+entityId: EntityId;
+frameId: EntityId | null;
+}>;
+}>;
+export { AssignFrameChildren }
+export { AssignFrameChildren as AssignFrameChildren_alias_1 }
+export { AssignFrameChildren as AssignFrameChildren_alias_2 }
+
 declare function attachKeyboardListeners(domElement: HTMLElement): void;
 export { attachKeyboardListeners }
 export { attachKeyboardListeners as attachKeyboardListeners_alias_1 }
@@ -133,6 +170,7 @@ declare const BlockDef: z.ZodObject<{
     canRotate: z.ZodDefault<z.ZodBoolean>;
     canScale: z.ZodDefault<z.ZodBoolean>;
     interactable: z.ZodDefault<z.ZodBoolean>;
+    excludeFromRankBounds: z.ZodDefault<z.ZodBoolean>;
     connectors: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         terminals: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
@@ -145,6 +183,8 @@ export { BlockDef as BlockDef_alias_1 }
 
 declare class BlockDef_2 extends CanvasComponentDef<typeof BlockSchema> {
     constructor();
+    getWorldPosition(ctx: Context, entityId: EntityId, out?: Vec2): Vec2;
+    setWorldPosition(ctx: Context, entityId: EntityId, worldPos: Vec2): void;
     getCenter(ctx: Context, entityId: EntityId, out?: Vec2): Vec2;
     setCenter(ctx: Context, entityId: EntityId, center: Vec2): void;
     getCorners(ctx: Context, entityId: EntityId, out?: [Vec2, Vec2, Vec2, Vec2]): [Vec2, Vec2, Vec2, Vec2];
@@ -174,8 +214,18 @@ declare const BlockSchema: {
     flip: TupleFieldBuilder<BooleanFieldBuilder, 2>;
     rank: StringFieldBuilder;
     resizeMode: EnumFieldBuilder<"default" | "scale" | "text" | "free" | "groupOnly">;
+    parentId: RefFieldBuilder;
 };
 
+declare const blockSystem: EditorSystem;
+export { blockSystem }
+export { blockSystem as blockSystem_alias_1 }
+
+declare const BringForwardSelected: CommandDef<void>;
+export { BringForwardSelected }
+export { BringForwardSelected as BringForwardSelected_alias_1 }
+export { BringForwardSelected as BringForwardSelected_alias_2 }
+
 declare const Camera: CameraDef;
 export { Camera }
 export { Camera as Camera_alias_1 }
@@ -229,6 +279,15 @@ export { CanvasComponentDef }
 
 export { CanvasSingletonDef }
 
+declare const captureFrameContainmentSystem: EditorSystem;
+export { captureFrameContainmentSystem }
+export { captureFrameContainmentSystem as captureFrameContainmentSystem_alias_1 }
+
+declare function cascadeDelete(ctx: Context, entityId: EntityId): void;
+export { cascadeDelete }
+export { cascadeDelete as cascadeDelete_alias_1 }
+export { cascadeDelete as cascadeDelete_alias_2 }
+
 export declare function cleanupCommands(ctx: Context): void;
 
 declare function clearBits(buffer: {
@@ -243,6 +302,15 @@ export { clearPointerTrackingState }
 export { clearPointerTrackingState as clearPointerTrackingState_alias_1 }
 export { clearPointerTrackingState as clearPointerTrackingState_alias_2 }
 
+declare const CloneEntities: CommandDef<    {
+entityIds: EntityId[];
+offset: Vec2;
+seed: string;
+}>;
+export { CloneEntities }
+export { CloneEntities as CloneEntities_alias_1 }
+export { CloneEntities as CloneEntities_alias_2 }
+
 declare const codeToIndex: Record<string, number>;
 export { codeToIndex }
 export { codeToIndex as codeToIndex_alias_1 }
@@ -283,10 +351,21 @@ name: StringFieldBuilder;
 export { CommandMarker }
 export { CommandMarker as CommandMarker_alias_1 }
 
+declare function compareBlockOrder(getBlock: (id: unknown) => SortableBlock | null, a: SortableBlock, b: SortableBlock): number;
+export { compareBlockOrder }
+export { compareBlockOrder as compareBlockOrder_alias_1 }
+export { compareBlockOrder as compareBlockOrder_alias_2 }
+
 export { ComponentDef }
 
 export { ComponentSchema }
 
+declare type ComponentSchema_2 = Record<string, {
+    def?: {
+        type?: string;
+    };
+}>;
+
 declare function computeAabb(ctx: Context, entityId: EntityId, out: Aabb_2): void;
 export { computeAabb }
 export { computeAabb as computeAabb_alias_1 }
@@ -304,7 +383,6 @@ export { Connector as Connector_alias_1 }
 export { Connector as Connector_alias_2 }
 
 export { Context }
-export { Context as Context_alias_1 }
 
 declare const Controls: ControlsDef;
 export { Controls }
@@ -340,13 +418,38 @@ declare const ControlsSchema: {
     wheelTool: StringFieldBuilder;
     modWheelTool: StringFieldBuilder;
     heldSnapshot: StringFieldBuilder;
+    activeToolName: StringFieldBuilder;
 };
 
+declare function convertRefsToUuids(ctx: Context, schema: ComponentSchema_2, data: Record<string, unknown>): Record<string, unknown>;
+export { convertRefsToUuids }
+export { convertRefsToUuids as convertRefsToUuids_alias_1 }
+export { convertRefsToUuids as convertRefsToUuids_alias_2 }
+
 export declare const CORE_PLUGIN_NAME = "core";
 
-declare const CorePlugin: EditorPlugin;
-export { CorePlugin }
-export { CorePlugin as CorePlugin_alias_1 }
+declare type CorePluginOptions = z.output<typeof CorePluginOptionsSchema>;
+export { CorePluginOptions }
+export { CorePluginOptions as CorePluginOptions_alias_1 }
+
+declare type CorePluginOptionsInput = z.input<typeof CorePluginOptionsSchema>;
+export { CorePluginOptionsInput }
+export { CorePluginOptionsInput as CorePluginOptionsInput_alias_1 }
+
+declare const CorePluginOptionsSchema: z.ZodObject<{
+    edgeScrolling: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        edgeSizePx: z.ZodDefault<z.ZodNumber>;
+        edgeScrollSpeedPxPerFrame: z.ZodDefault<z.ZodNumber>;
+        edgeScrollDelayMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export { CorePluginOptionsSchema }
+export { CorePluginOptionsSchema as CorePluginOptionsSchema_alias_1 }
+
+declare function createCorePlugin(options?: CorePluginOptionsInput): EditorPlugin<CorePluginOptions>;
+export { createCorePlugin }
+export { createCorePlugin as createCorePlugin_alias_1 }
 
 export { createEntity }
 
@@ -380,6 +483,24 @@ declare type CursorDefMap = Partial<Record<string, CursorDef>>;
 export { CursorDefMap }
 export { CursorDefMap as CursorDefMap_alias_1 }
 
+declare enum CursorKind {
+    Drag = "drag",
+    NESW = "nesw",
+    NWSE = "nwse",
+    NS = "ns",
+    EW = "ew",
+    RotateNW = "rotateNW",
+    RotateNE = "rotateNE",
+    RotateSW = "rotateSW",
+    RotateSE = "rotateSE"
+}
+export { CursorKind }
+export { CursorKind as CursorKind_alias_1 }
+
+declare const CURSORS: Record<string, CursorDef>;
+export { CURSORS }
+export { CURSORS as CURSORS_alias_1 }
+
 declare const CursorSchema: {
     cursorKind: StringFieldBuilder;
     rotation: NumberFieldBuilder<"float64">;
@@ -413,6 +534,28 @@ export { defineQuery }
 
 export { defineSystem }
 
+declare const DeselectAll: CommandDef<void>;
+export { DeselectAll }
+export { DeselectAll as DeselectAll_alias_1 }
+export { DeselectAll as DeselectAll_alias_2 }
+
+declare function deselectAll(ctx: Context): void;
+export { deselectAll }
+export { deselectAll as deselectAll_alias_1 }
+export { deselectAll as deselectAll_alias_2 }
+
+declare const DeselectBlock: CommandDef<    {
+entityId: EntityId;
+}>;
+export { DeselectBlock }
+export { DeselectBlock as DeselectBlock_alias_1 }
+export { DeselectBlock as DeselectBlock_alias_2 }
+
+declare function deselectBlock(ctx: Context, entityId: EntityId): void;
+export { deselectBlock }
+export { deselectBlock as deselectBlock_alias_1 }
+export { deselectBlock as deselectBlock_alias_2 }
+
 declare function detachKeyboardListeners(domElement: HTMLElement): void;
 export { detachKeyboardListeners }
 export { detachKeyboardListeners as detachKeyboardListeners_alias_1 }
@@ -434,6 +577,39 @@ export { detectEmbedProvider }
 export { detectEmbedProvider as detectEmbedProvider_alias_1 }
 export { detectEmbedProvider as detectEmbedProvider_alias_2 }
 
+declare const DragBlock: CommandDef<    {
+entityId: EntityId;
+position: Vec2;
+}>;
+export { DragBlock }
+export { DragBlock as DragBlock_alias_1 }
+export { DragBlock as DragBlock_alias_2 }
+
+declare const dragHandlerSystem: EditorSystem;
+export { dragHandlerSystem }
+export { dragHandlerSystem as dragHandlerSystem_alias_1 }
+
+declare const DragStart: CanvasComponentDef<    {
+position: TupleFieldBuilder<NumberFieldBuilder<"float64">, 2>;
+size: TupleFieldBuilder<NumberFieldBuilder<"float64">, 2>;
+rotateZ: NumberFieldBuilder<"float64">;
+flip: TupleFieldBuilder<BooleanFieldBuilder, 2>;
+fontSize: NumberFieldBuilder<"float64">;
+}, "dragStart">;
+export { DragStart }
+export { DragStart as DragStart_alias_1 }
+export { DragStart as DragStart_alias_2 }
+
+declare const DuplicateSelected: CommandDef<void>;
+export { DuplicateSelected }
+export { DuplicateSelected as DuplicateSelected_alias_1 }
+export { DuplicateSelected as DuplicateSelected_alias_2 }
+
+declare const EditAfterPlacing: CanvasComponentDef<    {}, "editAfterPlacing">;
+export { EditAfterPlacing }
+export { EditAfterPlacing as EditAfterPlacing_alias_1 }
+export { EditAfterPlacing as EditAfterPlacing_alias_2 }
+
 declare const Edited: CanvasComponentDef<    {}, "edited">;
 export { Edited }
 export { Edited as Edited_alias_1 }
@@ -459,6 +635,7 @@ declare class Editor {
     tick(): Promise<void>;
     nextTick(callback: (ctx: Context) => void): () => void;
     command<T>(def: CommandDef<T>, ...args: T extends void ? [] : [T]): void;
+    get readonly(): boolean;
     subscribe(query: QueryDef, callback: QueryCallback): () => void;
     _getContext(): Context;
     attachDom(domElement: HTMLElement): void;
@@ -476,6 +653,21 @@ export { EditorOptionsInput as EditorOptionsInput_alias_1 }
 
 export declare const EditorOptionsSchema: z.ZodObject<{
     plugins: z.ZodDefault<z.ZodArray<z.ZodCustom<EditorPluginInput, EditorPluginInput>>>;
+    corePlugin: z.ZodDefault<z.ZodCustom<{
+        edgeScrolling?: {
+            enabled?: boolean | undefined;
+            edgeSizePx?: number | undefined;
+            edgeScrollSpeedPxPerFrame?: number | undefined;
+            edgeScrollDelayMs?: number | undefined;
+        } | undefined;
+    }, {
+        edgeScrolling?: {
+            enabled?: boolean | undefined;
+            edgeSizePx?: number | undefined;
+            edgeScrollSpeedPxPerFrame?: number | undefined;
+            edgeScrollDelayMs?: number | undefined;
+        } | undefined;
+    }>>;
     maxEntities: z.ZodDefault<z.ZodNumber>;
     user: z.ZodDefault<z.ZodCustom<{
         userId?: string | undefined;
@@ -517,6 +709,7 @@ export declare const EditorOptionsSchema: z.ZodObject<{
         canRotate?: boolean | undefined;
         canScale?: boolean | undefined;
         interactable?: boolean | undefined;
+        excludeFromRankBounds?: boolean | undefined;
         connectors?: {
             enabled?: boolean | undefined;
             terminals?: [number, number][] | undefined;
@@ -533,6 +726,7 @@ export declare const EditorOptionsSchema: z.ZodObject<{
         canRotate?: boolean | undefined;
         canScale?: boolean | undefined;
         interactable?: boolean | undefined;
+        excludeFromRankBounds?: boolean | undefined;
         connectors?: {
             enabled?: boolean | undefined;
             terminals?: [number, number][] | undefined;
@@ -594,6 +788,7 @@ export declare const EditorOptionsSchema: z.ZodObject<{
         wheelTool?: string | undefined;
         modWheelTool?: string | undefined;
     }>>;
+    readonly: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 
 declare interface EditorPlugin<TResources = unknown> {
@@ -631,6 +826,7 @@ declare interface EditorResources {
     singletonsByName: Map<string, AnyCanvasSingletonDef>;
     componentsById: Map<number, AnyCanvasComponentDef>;
     singletonsById: Map<number, AnyCanvasSingletonDef>;
+    readonly: boolean;
 }
 export { EditorResources }
 export { EditorResources as EditorResources_alias_1 }
@@ -694,6 +890,11 @@ export { EmbedProvider }
 export { EmbedProvider as EmbedProvider_alias_1 }
 export { EmbedProvider as EmbedProvider_alias_2 }
 
+declare const EndTransformBoxEdit: CommandDef<void>;
+export { EndTransformBoxEdit }
+export { EndTransformBoxEdit as EndTransformBoxEdit_alias_1 }
+export { EndTransformBoxEdit as EndTransformBoxEdit_alias_2 }
+
 export { EntityId }
 export { EntityId as EntityId_alias_1 }
 
@@ -701,6 +902,11 @@ export { EventType }
 
 export { field }
 
+declare function findFrameAtPoint(ctx: Context, point: [number, number], exclude?: EntityId | null): EntityId | null;
+export { findFrameAtPoint }
+export { findFrameAtPoint as findFrameAtPoint_alias_1 }
+export { findFrameAtPoint as findFrameAtPoint_alias_2 }
+
 declare const FontFamily: z.ZodObject<{
     name: z.ZodString;
     displayName: z.ZodString;
@@ -732,16 +938,39 @@ declare class FontLoader {
 export { FontLoader }
 export { FontLoader as FontLoader_alias_1 }
 
-declare const Frame: CanvasSingletonDef<    {
-number: NumberFieldBuilder<"uint32">;
-delta: NumberFieldBuilder<"float64">;
-time: NumberFieldBuilder<"float64">;
-lastTime: NumberFieldBuilder<"float64">;
+declare const Frame: CanvasComponentDef<    {
+label: StringFieldBuilder;
 }, "frame">;
 export { Frame }
 export { Frame as Frame_alias_1 }
 export { Frame as Frame_alias_2 }
 
+export declare const FRAME_EDGE_THICKNESS = 12;
+
+declare const FrameContainmentState: EditorStateDef<    {
+state: StringFieldBuilder;
+highlightedFrame: RefFieldBuilder;
+}>;
+export { FrameContainmentState }
+export { FrameContainmentState as FrameContainmentState_alias_1 }
+export { FrameContainmentState as FrameContainmentState_alias_2 }
+
+declare const FrameContainmentStateEnum: {
+    readonly Idle: "idle";
+    readonly Tracking: "tracking";
+};
+export { FrameContainmentStateEnum }
+export { FrameContainmentStateEnum as FrameContainmentStateEnum_alias_1 }
+
+declare type FrameContainmentStateValue = (typeof FrameContainmentStateEnum)[keyof typeof FrameContainmentStateEnum];
+export { FrameContainmentStateValue }
+export { FrameContainmentStateValue as FrameContainmentStateValue_alias_1 }
+
+declare const FrameDropTarget: CanvasComponentDef<    {}, "frameDropTarget">;
+export { FrameDropTarget }
+export { FrameDropTarget as FrameDropTarget_alias_1 }
+export { FrameDropTarget as FrameDropTarget_alias_2 }
+
 declare interface FrameInput {
     type: 'frame';
     ctx: Context;
@@ -753,9 +982,10 @@ export { FrameInput }
 export { FrameInput as FrameInput_alias_1 }
 export { FrameInput as FrameInput_alias_2 }
 
-declare const frameSystem: EditorSystem;
-export { frameSystem }
-export { frameSystem as frameSystem_alias_1 }
+declare function generateUuidBySeed(originalUuid: string, generatorSeed: string | number): string;
+export { generateUuidBySeed }
+export { generateUuidBySeed as generateUuidBySeed_alias_1 }
+export { generateUuidBySeed as generateUuidBySeed_alias_2 }
 
 export { getBackrefs }
 
@@ -773,8 +1003,23 @@ export { getBlockResizeMode }
 export { getBlockResizeMode as getBlockResizeMode_alias_1 }
 export { getBlockResizeMode as getBlockResizeMode_alias_2 }
 
+declare function getChildren(ctx: Context, parentId: EntityId): EntityId[];
+export { getChildren }
+export { getChildren as getChildren_alias_1 }
+export { getChildren as getChildren_alias_2 }
+
 export declare function getCursorSvg(cursors: Record<string, CursorDef>, kind: string, rotateZ: number): string;
 
+declare function getDescendants(ctx: Context, parentId: EntityId): EntityId[];
+export { getDescendants }
+export { getDescendants as getDescendants_alias_1 }
+export { getDescendants as getDescendants_alias_2 }
+
+declare function getEntityUuid(ctx: Context, entityId: EntityId | null | undefined): string | null;
+export { getEntityUuid }
+export { getEntityUuid as getEntityUuid_alias_1 }
+export { getEntityUuid as getEntityUuid_alias_2 }
+
 declare function getFrameInput(ctx: Context): FrameInput;
 export { getFrameInput }
 export { getFrameInput as getFrameInput_alias_1 }
@@ -803,6 +1048,11 @@ export { getPointerInput }
 export { getPointerInput as getPointerInput_alias_1 }
 export { getPointerInput as getPointerInput_alias_2 }
 
+declare function getRefFieldNames(schema: ComponentSchema_2): string[];
+export { getRefFieldNames }
+export { getRefFieldNames as getRefFieldNames_alias_1 }
+export { getRefFieldNames as getRefFieldNames_alias_2 }
+
 export { getResources }
 
 declare function getTopmostBlockAtPoint(ctx: Context, point: Vec2): EntityId | undefined;
@@ -810,6 +1060,11 @@ export { getTopmostBlockAtPoint }
 export { getTopmostBlockAtPoint as getTopmostBlockAtPoint_alias_1 }
 export { getTopmostBlockAtPoint as getTopmostBlockAtPoint_alias_2 }
 
+declare function getWorldPosition(ctx: Context, entityId: EntityId, out?: Vec2): Vec2;
+export { getWorldPosition }
+export { getWorldPosition as getWorldPosition_alias_1 }
+export { getWorldPosition as getWorldPosition_alias_2 }
+
 declare const Grid: GridDef;
 export { Grid }
 export { Grid as Grid_alias_1 }
@@ -858,6 +1113,13 @@ export { Held }
 export { Held as Held_alias_1 }
 export { Held as Held_alias_2 }
 
+declare const HideTransformBox: CommandDef<    {
+transformBoxId: EntityId;
+}>;
+export { HideTransformBox }
+export { HideTransformBox as HideTransformBox_alias_1 }
+export { HideTransformBox as HideTransformBox_alias_2 }
+
 declare const HitGeometry: HitGeometryDef;
 export { HitGeometry }
 export { HitGeometry as HitGeometry_alias_1 }
@@ -888,6 +1150,10 @@ declare const HitGeometrySchema: {
     arcCount: NumberFieldBuilder<"uint16">;
 };
 
+declare const hoverCursorSystem: EditorSystem;
+export { hoverCursorSystem }
+export { hoverCursorSystem as hoverCursorSystem_alias_1 }
+
 declare const Hovered: CanvasComponentDef<    {}, "hovered">;
 export { Hovered }
 export { Hovered as Hovered_alias_1 }
@@ -952,11 +1218,20 @@ export { intersectSystem as intersectSystem_alias_1 }
 
 export { isAlive }
 
+declare function isAncestor(ctx: Context, entityId: EntityId, candidateAncestor: EntityId): boolean;
+export { isAncestor }
+export { isAncestor as isAncestor_alias_1 }
+export { isAncestor as isAncestor_alias_2 }
+
 declare function isHeldByRemote(ctx: Context, entityId: EntityId): boolean;
 export { isHeldByRemote }
 export { isHeldByRemote as isHeldByRemote_alias_1 }
 export { isHeldByRemote as isHeldByRemote_alias_2 }
 
+declare function isReadonly(ctx: Context): boolean;
+export { isReadonly }
+export { isReadonly as isReadonly_alias_1 }
+
 declare const Key: {
     readonly A: number;
     readonly B: number;
@@ -1272,7 +1547,7 @@ declare const PointerSchema: {
     position: TupleFieldBuilder<NumberFieldBuilder<"float32">, 2>;
     downPosition: TupleFieldBuilder<NumberFieldBuilder<"float32">, 2>;
     downFrame: NumberFieldBuilder<"uint32">;
-    button: EnumFieldBuilder<"left" | "none" | "middle" | "right" | "back" | "forward">;
+    button: EnumFieldBuilder<"left" | "right" | "none" | "middle" | "back" | "forward">;
     pointerType: EnumFieldBuilder<"mouse" | "pen" | "touch">;
     pressure: NumberFieldBuilder<"float32">;
     obscured: BooleanFieldBuilder;
@@ -1337,10 +1612,48 @@ declare const Redo: CommandDef<void>;
 export { Redo }
 export { Redo as Redo_alias_1 }
 
+declare const RemoveBlock: CommandDef<    {
+entityId: EntityId;
+}>;
+export { RemoveBlock }
+export { RemoveBlock as RemoveBlock_alias_1 }
+export { RemoveBlock as RemoveBlock_alias_2 }
+
 export { removeComponent }
 
 export { removeEntity }
 
+declare const RemoveFrameHighlight: CommandDef<    {
+frameId: EntityId;
+}>;
+export { RemoveFrameHighlight }
+export { RemoveFrameHighlight as RemoveFrameHighlight_alias_1 }
+export { RemoveFrameHighlight as RemoveFrameHighlight_alias_2 }
+
+declare const RemoveHeld: CommandDef<    {
+entityId: EntityId;
+}>;
+export { RemoveHeld }
+export { RemoveHeld as RemoveHeld_alias_1 }
+export { RemoveHeld as RemoveHeld_alias_2 }
+
+declare const RemoveSelected: CommandDef<void>;
+export { RemoveSelected }
+export { RemoveSelected as RemoveSelected_alias_1 }
+export { RemoveSelected as RemoveSelected_alias_2 }
+
+declare const RemoveSelectionBox: CommandDef<void>;
+export { RemoveSelectionBox }
+export { RemoveSelectionBox as RemoveSelectionBox_alias_1 }
+export { RemoveSelectionBox as RemoveSelectionBox_alias_2 }
+
+declare const RemoveTransformBox: CommandDef<    {
+transformBoxId: EntityId;
+}>;
+export { RemoveTransformBox }
+export { RemoveTransformBox as RemoveTransformBox_alias_1 }
+export { RemoveTransformBox as RemoveTransformBox_alias_2 }
+
 declare const ResetKeyboard: CommandDef<void>;
 export { ResetKeyboard }
 export { ResetKeyboard as ResetKeyboard_alias_1 }
@@ -1362,6 +1675,14 @@ export { resolveEmbedUrl }
 export { resolveEmbedUrl as resolveEmbedUrl_alias_1 }
 export { resolveEmbedUrl as resolveEmbedUrl_alias_2 }
 
+declare function resolveRefFields(ctx: Context, entityId: EntityId, componentDef: {
+    schema: ComponentSchema_2;
+    write: (ctx: Context, entityId: EntityId) => Record<string, unknown>;
+}, componentData: Record<string, unknown>, uuidToEntityId: Map<string, EntityId>): void;
+export { resolveRefFields }
+export { resolveRefFields as resolveRefFields_alias_1 }
+export { resolveRefFields as resolveRefFields_alias_2 }
+
 declare function runMachine<TState extends string, TContext extends object>(machine: AnyStateMachine, currentState: TState, context: TContext, events: Array<{
     type: string;
     [key: string]: unknown;
@@ -1413,6 +1734,100 @@ declare const screenSystem: EditorSystem;
 export { screenSystem }
 export { screenSystem as screenSystem_alias_1 }
 
+declare const ScrollEdgesState: {
+    readonly Idle: "idle";
+    readonly Waiting: "waiting";
+    readonly Scrolling: "scrolling";
+};
+
+declare type ScrollEdgesState = (typeof ScrollEdgesState)[keyof typeof ScrollEdgesState];
+export { ScrollEdgesState }
+export { ScrollEdgesState as ScrollEdgesState_alias_1 }
+
+declare const ScrollEdgesStateSingleton: EditorStateDef<    {
+state: EnumFieldBuilder<"idle" | "waiting" | "scrolling">;
+edgeEnterStartTime: NumberFieldBuilder<"float64">;
+}>;
+export { ScrollEdgesStateSingleton }
+export { ScrollEdgesStateSingleton as ScrollEdgesStateSingleton_alias_1 }
+export { ScrollEdgesStateSingleton as ScrollEdgesStateSingleton_alias_2 }
+
+declare const scrollEdgesSystem: EditorSystem;
+export { scrollEdgesSystem }
+export { scrollEdgesSystem as scrollEdgesSystem_alias_1 }
+
+declare const SelectAll: CommandDef<void>;
+export { SelectAll }
+export { SelectAll as SelectAll_alias_1 }
+export { SelectAll as SelectAll_alias_2 }
+
+declare function selectAll(ctx: Context): void;
+export { selectAll }
+export { selectAll as selectAll_alias_1 }
+export { selectAll as selectAll_alias_2 }
+
+declare const SelectBlock: CommandDef<    {
+entityId: EntityId;
+deselectOthers?: boolean;
+}>;
+export { SelectBlock }
+export { SelectBlock as SelectBlock_alias_1 }
+export { SelectBlock as SelectBlock_alias_2 }
+
+declare function selectBlock(ctx: Context, entityId: EntityId): void;
+export { selectBlock }
+export { selectBlock as selectBlock_alias_1 }
+export { selectBlock as selectBlock_alias_2 }
+
+declare const Selected: CanvasComponentDef<    {}, "selected">;
+export { Selected }
+export { Selected as Selected_alias_1 }
+export { Selected as Selected_alias_2 }
+
+declare const SelectionBox: CanvasComponentDef<    {}, "selectionBox">;
+export { SelectionBox }
+export { SelectionBox as SelectionBox_alias_1 }
+export { SelectionBox as SelectionBox_alias_2 }
+
+declare const SelectionState: {
+    readonly Idle: "idle";
+    readonly Pointing: "pointing";
+    readonly Dragging: "dragging";
+    readonly SelectionBoxPointing: "selectionBoxPointing";
+    readonly SelectionBoxDragging: "selectionBoxDragging";
+};
+
+declare type SelectionState = (typeof SelectionState)[keyof typeof SelectionState];
+export { SelectionState }
+export { SelectionState as SelectionState_alias_1 }
+
+declare const SelectionStateSingleton: EditorStateDef<    {
+state: EnumFieldBuilder<"idle" | "pointing" | "dragging" | "selectionBoxPointing" | "selectionBoxDragging">;
+dragStart: TupleFieldBuilder<NumberFieldBuilder<"float64">, 2>;
+pointingStartClient: TupleFieldBuilder<NumberFieldBuilder<"float64">, 2>;
+pointingStartWorld: TupleFieldBuilder<NumberFieldBuilder<"float64">, 2>;
+draggedEntityStart: TupleFieldBuilder<NumberFieldBuilder<"float64">, 2>;
+draggedEntity: RefFieldBuilder;
+cloneGeneratorSeed: StringFieldBuilder;
+isCloning: BooleanFieldBuilder;
+}>;
+export { SelectionStateSingleton }
+export { SelectionStateSingleton as SelectionStateSingleton_alias_1 }
+export { SelectionStateSingleton as SelectionStateSingleton_alias_2 }
+
+declare const selectSystem: EditorSystem;
+export { selectSystem }
+export { selectSystem as selectSystem_alias_1 }
+
+declare const selectSystem_2: EditorSystem;
+export { selectSystem_2 as selectSystem_alias_2 }
+export { selectSystem_2 as selectSystem_alias_3 }
+
+declare const SendBackwardSelected: CommandDef<void>;
+export { SendBackwardSelected }
+export { SendBackwardSelected as SendBackwardSelected_alias_1 }
+export { SendBackwardSelected as SendBackwardSelected_alias_2 }
+
 declare function setBit(buffer: {
     [index: number]: number;
     length: number;
@@ -1420,6 +1835,16 @@ declare function setBit(buffer: {
 export { setBit }
 export { setBit as setBit_alias_1 }
 
+declare const SetCursor: CommandDef<    {
+cursorKind?: string;
+rotation?: number;
+contextCursorKind?: string;
+contextRotation?: number;
+}>;
+export { SetCursor }
+export { SetCursor as SetCursor_alias_1 }
+export { SetCursor as SetCursor_alias_2 }
+
 declare const Shape: CanvasComponentDef<    {
 kind: StringFieldBuilder;
 strokeKind: EnumFieldBuilder<"none" | "solid" | "dashed">;
@@ -1437,12 +1862,35 @@ export { Shape }
 export { Shape as Shape_alias_1 }
 export { Shape as Shape_alias_2 }
 
+declare const ShowTransformBox: CommandDef<    {
+transformBoxId: EntityId;
+}>;
+export { ShowTransformBox }
+export { ShowTransformBox as ShowTransformBox_alias_1 }
+export { ShowTransformBox as ShowTransformBox_alias_2 }
+
 export { SINGLETON_ENTITY_ID }
 
 export { SingletonSyncBehavior }
 
+declare interface SortableBlock {
+    rank: string;
+    stratum: Stratum;
+    parentId: unknown;
+}
+export { SortableBlock }
+export { SortableBlock as SortableBlock_alias_1 }
+export { SortableBlock as SortableBlock_alias_2 }
+
 export declare function sortPluginsByDependencies(plugins: EditorPlugin[]): EditorPlugin[];
 
+declare const StartTransformBoxEdit: CommandDef<    {
+transformBoxId: EntityId;
+}>;
+export { StartTransformBoxEdit }
+export { StartTransformBoxEdit as StartTransformBoxEdit_alias_1 }
+export { StartTransformBoxEdit as StartTransformBoxEdit_alias_2 }
+
 declare interface StateSchema extends ComponentSchema {
     state: {
         def: StringFieldDef | EnumFieldDef<any>;
@@ -1512,10 +1960,115 @@ declare type TextAlignment = (typeof TextAlignment)[keyof typeof TextAlignment];
 export { TextAlignment }
 export { TextAlignment as TextAlignment_alias_1 }
 
+declare const Tick: CanvasSingletonDef<    {
+number: NumberFieldBuilder<"uint32">;
+delta: NumberFieldBuilder<"float64">;
+time: NumberFieldBuilder<"float64">;
+lastTime: NumberFieldBuilder<"float64">;
+}, "tick">;
+export { Tick }
+export { Tick as Tick_alias_1 }
+export { Tick as Tick_alias_2 }
+
+declare const tickSystem: EditorSystem;
+export { tickSystem }
+export { tickSystem as tickSystem_alias_1 }
+
+declare const ToggleSelect: CommandDef<    {
+entityId: EntityId;
+}>;
+export { ToggleSelect }
+export { ToggleSelect as ToggleSelect_alias_1 }
+export { ToggleSelect as ToggleSelect_alias_2 }
+
+declare const TransformBox: CanvasComponentDef<    {}, "transformBox">;
+export { TransformBox }
+export { TransformBox as TransformBox_alias_1 }
+export { TransformBox as TransformBox_alias_2 }
+
+declare const TransformBoxState: {
+    readonly None: "none";
+    readonly Idle: "idle";
+    readonly Editing: "editing";
+};
+
+declare type TransformBoxState = (typeof TransformBoxState)[keyof typeof TransformBoxState];
+export { TransformBoxState }
+export { TransformBoxState as TransformBoxState_alias_1 }
+
+declare const TransformBoxStateSingleton: EditorStateDef<    {
+state: StringFieldBuilder;
+transformBoxId: RefFieldBuilder;
+}>;
+export { TransformBoxStateSingleton }
+export { TransformBoxStateSingleton as TransformBoxStateSingleton_alias_1 }
+export { TransformBoxStateSingleton as TransformBoxStateSingleton_alias_2 }
+
+declare const transformBoxSystem: EditorSystem;
+export { transformBoxSystem }
+export { transformBoxSystem as transformBoxSystem_alias_1 }
+
+declare const transformBoxSystem_2: EditorSystem;
+export { transformBoxSystem_2 as transformBoxSystem_alias_2 }
+export { transformBoxSystem_2 as transformBoxSystem_alias_3 }
+
+declare const TransformHandle: CanvasComponentDef<    {
+kind: StringFieldBuilder;
+vectorX: NumberFieldBuilder<"int8">;
+vectorY: NumberFieldBuilder<"int8">;
+transformBox: RefFieldBuilder;
+cursorKind: StringFieldBuilder;
+}, "transformHandle">;
+export { TransformHandle }
+export { TransformHandle as TransformHandle_alias_1 }
+export { TransformHandle as TransformHandle_alias_2 }
+
+declare const TransformHandleKind: {
+    readonly Scale: "scale";
+    readonly Stretch: "stretch";
+    readonly Rotate: "rotate";
+    readonly RotateScale: "rotateScale";
+};
+
+declare type TransformHandleKind = (typeof TransformHandleKind)[keyof typeof TransformHandleKind];
+export { TransformHandleKind }
+export { TransformHandleKind as TransformHandleKind_alias_1 }
+
+declare const UncloneEntities: CommandDef<    {
+entityIds: EntityId[];
+seed: string;
+}>;
+export { UncloneEntities }
+export { UncloneEntities as UncloneEntities_alias_1 }
+export { UncloneEntities as UncloneEntities_alias_2 }
+
 declare const Undo: CommandDef<void>;
 export { Undo }
 export { Undo as Undo_alias_1 }
 
+declare const updateFrameContainmentSystem: EditorSystem;
+export { updateFrameContainmentSystem }
+export { updateFrameContainmentSystem as updateFrameContainmentSystem_alias_1 }
+
+declare const updateFrameSetupSystem: EditorSystem;
+export { updateFrameSetupSystem }
+export { updateFrameSetupSystem as updateFrameSetupSystem_alias_1 }
+
+declare const UpdateSelectionBox: CommandDef<    {
+bounds: Aabb_2;
+deselectOthers?: boolean;
+}>;
+export { UpdateSelectionBox }
+export { UpdateSelectionBox as UpdateSelectionBox_alias_1 }
+export { UpdateSelectionBox as UpdateSelectionBox_alias_2 }
+
+declare const UpdateTransformBox: CommandDef<    {
+transformBoxId: EntityId;
+}>;
+export { UpdateTransformBox }
+export { UpdateTransformBox as UpdateTransformBox_alias_1 }
+export { UpdateTransformBox as UpdateTransformBox_alias_2 }
+
 declare const UploadState: {
     readonly Pending: "pending";
     readonly Uploading: "uploading";
@@ -1576,4 +2129,9 @@ declare const VerticalAlignment: {
 export { VerticalAlignment }
 export { VerticalAlignment as VerticalAlignment_alias_1 }
 
+declare function worldToLocal(ctx: Context, entityId: EntityId, worldPos: Vec2, out?: Vec2): Vec2;
+export { worldToLocal }
+export { worldToLocal as worldToLocal_alias_1 }
+export { worldToLocal as worldToLocal_alias_2 }
+
 export { }