@woven-canvas/core 0.1.0

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

@@ -0,0 +1,1509 @@
+import { Aabb as Aabb_2 } from '@woven-canvas/math';
+import { addComponent } from '@woven-ecs/core';
+import { AnyCanvasComponentDef } from '@woven-ecs/canvas-store';
+import { AnyCanvasSingletonDef } from '@woven-ecs/canvas-store';
+import { AnyStateMachine } from 'xstate';
+import { Arc } from '@woven-canvas/math';
+import { ArrayFieldBuilder } from '@woven-ecs/core';
+import { BooleanFieldBuilder } from '@woven-ecs/core';
+import { BufferFieldBuilder } from '@woven-ecs/core';
+import { CanvasComponentDef } from '@woven-ecs/canvas-store';
+import { CanvasSingletonDef } from '@woven-ecs/canvas-store';
+import { Capsule } from '@woven-canvas/math';
+import { ComponentDef } from '@woven-ecs/core';
+import { ComponentSchema } from '@woven-ecs/core';
+import { Context } from '@woven-ecs/core';
+import { createEntity } from '@woven-ecs/core';
+import { defineCanvasComponent } from '@woven-ecs/canvas-store';
+import { defineCanvasSingleton } from '@woven-ecs/canvas-store';
+import { defineQuery } from '@woven-ecs/core';
+import { defineSystem } from '@woven-ecs/core';
+import { EntityId } from '@woven-ecs/core';
+import { EnumFieldBuilder } from '@woven-ecs/core';
+import type { EnumFieldDef } from '@woven-ecs/core';
+import { EventType } from '@woven-ecs/core';
+import { field } from '@woven-ecs/core';
+import { getBackrefs } from '@woven-ecs/core';
+import { getResources } from '@woven-ecs/core';
+import { hasComponent } from '@woven-ecs/core';
+import { InferCanvasComponentType } from '@woven-ecs/canvas-store';
+import { isAlive } from '@woven-ecs/core';
+import { MainThreadSystem } from '@woven-ecs/core';
+import { Mat2 } from '@woven-canvas/math';
+import { NumberFieldBuilder } from '@woven-ecs/core';
+import { QueryDef } from '@woven-ecs/core';
+import { RefFieldBuilder } from '@woven-ecs/core';
+import { removeComponent } from '@woven-ecs/core';
+import { removeEntity } from '@woven-ecs/core';
+import { SINGLETON_ENTITY_ID } from '@woven-ecs/core';
+import { SingletonSyncBehavior } from '@woven-ecs/canvas-store';
+import { StringFieldBuilder } from '@woven-ecs/core';
+import type { StringFieldDef } from '@woven-ecs/core';
+import { SyncBehavior } from '@woven-ecs/canvas-store';
+import { Synced } from '@woven-ecs/canvas-store';
+import { System } from '@woven-ecs/core';
+import { TupleFieldBuilder } from '@woven-ecs/core';
+import { Vec2 } from '@woven-canvas/math';
+import { z } from 'zod';
+
+declare const Aabb: AabbDef;
+export { Aabb }
+export { Aabb as Aabb_alias_1 }
+export { Aabb as Aabb_alias_2 }
+
+declare class AabbDef extends CanvasComponentDef<typeof AabbSchema> {
+    constructor();
+    containsPoint(ctx: Context, entityId: EntityId, point: Vec2, inclusive?: boolean): boolean;
+    expandByPoint(ctx: Context, entityId: EntityId, point: Vec2): void;
+    expandByBlock(ctx: Context, entityId: EntityId, blockEntityId: EntityId): void;
+    expandByAabb(ctx: Context, entityId: EntityId, other: Aabb_2): void;
+    copyFrom(ctx: Context, entityId: EntityId, otherEntityId: EntityId): void;
+    setByPoints(ctx: Context, entityId: EntityId, points: Vec2[]): void;
+    getCenter(ctx: Context, entityId: EntityId): Vec2;
+    getWidth(ctx: Context, entityId: EntityId): number;
+    getHeight(ctx: Context, entityId: EntityId): number;
+    distanceToPoint(ctx: Context, entityId: EntityId, point: Vec2): number;
+    intersectsEntity(ctx: Context, entityIdA: EntityId, entityIdB: EntityId): boolean;
+    surroundsEntity(ctx: Context, entityIdA: EntityId, entityIdB: EntityId): boolean;
+    getCorners(ctx: Context, entityId: EntityId, out?: [Vec2, Vec2, Vec2, Vec2]): [Vec2, Vec2, Vec2, Vec2];
+    applyPadding(ctx: Context, entityId: EntityId, padding: number): void;
+}
+
+declare const AabbSchema: {
+    value: TupleFieldBuilder<NumberFieldBuilder<"float32">, 4>;
+};
+
+export { addComponent }
+
+declare function addPointerSample(pointer: ReturnType<typeof Pointer.write>, position: Vec2, time: number): void;
+export { addPointerSample }
+export { addPointerSample as addPointerSample_alias_1 }
+
+export { AnyCanvasComponentDef }
+
+export { AnyCanvasSingletonDef }
+
+declare const Asset: CanvasComponentDef<    {
+identifier: StringFieldBuilder;
+uploadState: EnumFieldBuilder<"pending" | "uploading" | "complete" | "failed">;
+}, "asset">;
+export { Asset }
+export { Asset as Asset_alias_1 }
+export { Asset as Asset_alias_2 }
+
+declare function attachKeyboardListeners(domElement: HTMLElement): void;
+export { attachKeyboardListeners }
+export { attachKeyboardListeners as attachKeyboardListeners_alias_1 }
+
+declare function attachMouseListeners(domElement: HTMLElement): void;
+export { attachMouseListeners }
+export { attachMouseListeners as attachMouseListeners_alias_1 }
+
+declare function attachPointerListeners(domElement: HTMLElement): void;
+export { attachPointerListeners }
+export { attachPointerListeners as attachPointerListeners_alias_1 }
+
+declare function attachScreenObserver(domElement: HTMLElement): void;
+export { attachScreenObserver }
+export { attachScreenObserver as attachScreenObserver_alias_1 }
+
+declare const Block: BlockDef_2;
+export { Block }
+export { Block as Block_alias_1 }
+export { Block as Block_alias_2 }
+
+declare const BlockDef: z.ZodObject<{
+    tag: z.ZodString;
+    stratum: z.ZodDefault<z.ZodEnum<{
+        background: "background";
+        content: "content";
+        overlay: "overlay";
+    }>>;
+    editOptions: z.ZodDefault<z.ZodObject<{
+        canEdit: z.ZodDefault<z.ZodBoolean>;
+        removeWhenTextEmpty: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    components: z.ZodDefault<z.ZodArray<z.ZodCustom<AnyCanvasComponentDef, AnyCanvasComponentDef>>>;
+    resizeMode: z.ZodDefault<z.ZodEnum<{
+        scale: "scale";
+        text: "text";
+        free: "free";
+        groupOnly: "groupOnly";
+    }>>;
+    canRotate: z.ZodDefault<z.ZodBoolean>;
+    canScale: 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>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+declare type BlockDef = z.infer<typeof BlockDef>;
+export { BlockDef }
+export { BlockDef as BlockDef_alias_1 }
+
+declare class BlockDef_2 extends CanvasComponentDef<typeof BlockSchema> {
+    constructor();
+    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];
+    containsPoint(ctx: Context, entityId: EntityId, point: Vec2): boolean;
+    translate(ctx: Context, entityId: EntityId, delta: Vec2): void;
+    setPosition(ctx: Context, entityId: EntityId, position: Vec2): void;
+    setSize(ctx: Context, entityId: EntityId, size: Vec2): void;
+    rotateBy(ctx: Context, entityId: EntityId, deltaAngle: number): void;
+    rotateAround(ctx: Context, entityId: EntityId, pivot: Vec2, angle: number): void;
+    scaleBy(ctx: Context, entityId: EntityId, scaleFactor: number): void;
+    scaleAround(ctx: Context, entityId: EntityId, pivot: Vec2, scaleFactor: number): void;
+    intersectsAabb(ctx: Context, entityId: EntityId, aabb: Aabb_2): boolean;
+    worldToUv(ctx: Context, entityId: EntityId, worldPos: Vec2): Vec2;
+    uvToWorld(ctx: Context, entityId: EntityId, uv: Vec2): Vec2;
+    getUvToWorldMatrix(ctx: Context, entityId: EntityId, out: Mat2): void;
+}
+
+declare type BlockDefInput = z.input<typeof BlockDef>;
+export { BlockDefInput }
+export { BlockDefInput as BlockDefInput_alias_1 }
+
+declare const BlockSchema: {
+    tag: StringFieldBuilder;
+    position: TupleFieldBuilder<NumberFieldBuilder<"float64">, 2>;
+    size: TupleFieldBuilder<NumberFieldBuilder<"float64">, 2>;
+    rotateZ: NumberFieldBuilder<"float64">;
+    flip: TupleFieldBuilder<BooleanFieldBuilder, 2>;
+    rank: StringFieldBuilder;
+};
+
+declare const Camera: CameraDef;
+export { Camera }
+export { Camera as Camera_alias_1 }
+export { Camera as Camera_alias_2 }
+
+declare class CameraDef extends CanvasSingletonDef<typeof CameraSchema> {
+    constructor();
+    toWorld(ctx: Context, screenPos: Vec2): Vec2;
+    toScreen(ctx: Context, worldPos: Vec2): Vec2;
+    getWorldCenter(ctx: Context): Vec2;
+    getWorldBounds(ctx: Context): {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    };
+    getAabb(ctx: Context, out?: Aabb_2): Aabb_2;
+}
+
+declare const CameraSchema: {
+    top: NumberFieldBuilder<"float64">;
+    left: NumberFieldBuilder<"float64">;
+    zoom: NumberFieldBuilder<"float64">;
+    canSeeBlocks: BooleanFieldBuilder;
+    lastSeenBlock: RefFieldBuilder;
+};
+
+declare function canBlockEdit(ctx: Context, tag: string): boolean;
+export { canBlockEdit }
+export { canBlockEdit as canBlockEdit_alias_1 }
+export { canBlockEdit as canBlockEdit_alias_2 }
+
+declare function canBlockRotate(ctx: Context, tag: string): boolean;
+export { canBlockRotate }
+export { canBlockRotate as canBlockRotate_alias_1 }
+
+declare function canBlockScale(ctx: Context, tag: string): boolean;
+export { canBlockScale }
+export { canBlockScale as canBlockScale_alias_1 }
+
+declare const canSeeBlocksSystem: EditorSystem;
+export { canSeeBlocksSystem }
+export { canSeeBlocksSystem as canSeeBlocksSystem_alias_1 }
+
+export { CanvasComponentDef }
+
+export { CanvasSingletonDef }
+
+export declare function cleanupCommands(ctx: Context): void;
+
+declare function clearBits(buffer: {
+    [index: number]: number;
+    length: number;
+}): void;
+export { clearBits }
+export { clearBits as clearBits_alias_1 }
+
+declare function clearPointerTrackingState(ctx: Context): void;
+export { clearPointerTrackingState }
+export { clearPointerTrackingState as clearPointerTrackingState_alias_1 }
+export { clearPointerTrackingState as clearPointerTrackingState_alias_2 }
+
+declare const codeToIndex: Record<string, number>;
+export { codeToIndex }
+export { codeToIndex as codeToIndex_alias_1 }
+
+declare const Color: ColorDef;
+export { Color }
+export { Color as Color_alias_1 }
+export { Color as Color_alias_2 }
+
+declare class ColorDef extends CanvasComponentDef<typeof ColorSchema> {
+    constructor();
+    toHex(ctx: Context, entityId: EntityId): string;
+    fromHex(ctx: Context, entityId: EntityId, hex: string): void;
+}
+
+declare const ColorSchema: {
+    red: NumberFieldBuilder<"uint8">;
+    green: NumberFieldBuilder<"uint8">;
+    blue: NumberFieldBuilder<"uint8">;
+    alpha: NumberFieldBuilder<"uint8">;
+};
+
+declare interface CommandDef<T> {
+    readonly name: string;
+    spawn(ctx: Context, payload: T): EntityId;
+    iter(ctx: Context): IterableIterator<{
+        eid: EntityId;
+        payload: T;
+    }>;
+    didSpawnLastFrame(ctx: Context): boolean;
+}
+export { CommandDef }
+export { CommandDef as CommandDef_alias_1 }
+
+declare const CommandMarker: ComponentDef<    {
+name: StringFieldBuilder;
+}>;
+export { CommandMarker }
+export { CommandMarker as CommandMarker_alias_1 }
+
+export { ComponentDef }
+
+export { ComponentSchema }
+
+declare function computeAabb(ctx: Context, entityId: EntityId, out: Aabb_2): void;
+export { computeAabb }
+export { computeAabb as computeAabb_alias_1 }
+
+declare const Connector: CanvasComponentDef<    {
+startBlock: RefFieldBuilder;
+startBlockUv: TupleFieldBuilder<NumberFieldBuilder<"float64">, 2>;
+startUv: TupleFieldBuilder<NumberFieldBuilder<"float64">, 2>;
+endBlock: RefFieldBuilder;
+endBlockUv: TupleFieldBuilder<NumberFieldBuilder<"float64">, 2>;
+endUv: TupleFieldBuilder<NumberFieldBuilder<"float64">, 2>;
+}, "connector">;
+export { Connector }
+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 }
+export { Controls as Controls_alias_1 }
+export { Controls as Controls_alias_2 }
+
+declare class ControlsDef extends CanvasSingletonDef<typeof ControlsSchema> {
+    constructor();
+    getButtons(ctx: Context, ...tools: string[]): PointerButton[];
+    wheelActive(ctx: Context, tool: string, modDown: boolean): boolean;
+}
+
+declare const ControlsOptions: z.ZodObject<{
+    leftMouseTool: z.ZodDefault<z.ZodString>;
+    middleMouseTool: z.ZodDefault<z.ZodString>;
+    rightMouseTool: z.ZodDefault<z.ZodString>;
+    wheelTool: z.ZodDefault<z.ZodString>;
+    modWheelTool: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+
+declare type ControlsOptions = z.infer<typeof ControlsOptions>;
+export { ControlsOptions }
+export { ControlsOptions as ControlsOptions_alias_1 }
+
+declare type ControlsOptionsInput = z.input<typeof ControlsOptions>;
+export { ControlsOptionsInput }
+export { ControlsOptionsInput as ControlsOptionsInput_alias_1 }
+
+declare const ControlsSchema: {
+    leftMouseTool: StringFieldBuilder;
+    middleMouseTool: StringFieldBuilder;
+    rightMouseTool: StringFieldBuilder;
+    wheelTool: StringFieldBuilder;
+    modWheelTool: StringFieldBuilder;
+    heldSnapshot: StringFieldBuilder;
+};
+
+declare const CorePlugin: EditorPlugin;
+export { CorePlugin }
+export { CorePlugin as CorePlugin_alias_1 }
+
+export { createEntity }
+
+declare const Cursor: CursorDef_2;
+export { Cursor }
+export { Cursor as Cursor_alias_1 }
+export { Cursor as Cursor_alias_2 }
+
+declare const CursorDef: z.ZodObject<{
+    makeSvg: z.ZodFunction<z.ZodTuple<[z.ZodNumber], null>, z.ZodString>;
+    hotspot: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    rotationOffset: z.ZodNumber;
+}, z.core.$strip>;
+
+declare type CursorDef = z.infer<typeof CursorDef>;
+export { CursorDef }
+export { CursorDef as CursorDef_alias_1 }
+
+declare class CursorDef_2 extends CanvasSingletonDef<typeof CursorSchema> {
+    constructor();
+    getEffective(ctx: Context): {
+        cursorKind: string;
+        rotation: number;
+    };
+    setCursor(ctx: Context, cursorKind: string, rotation?: number): void;
+    setContextCursor(ctx: Context, cursorKind: string, rotation?: number): void;
+    clearContextCursor(ctx: Context): void;
+}
+
+declare type CursorDefMap = Partial<Record<string, CursorDef>>;
+export { CursorDefMap }
+export { CursorDefMap as CursorDefMap_alias_1 }
+
+declare const CursorSchema: {
+    cursorKind: StringFieldBuilder;
+    rotation: NumberFieldBuilder<"float64">;
+    contextCursorKind: StringFieldBuilder;
+    contextRotation: NumberFieldBuilder<"float64">;
+};
+
+declare const cursorSystem: EditorSystem;
+export { cursorSystem }
+export { cursorSystem as cursorSystem_alias_1 }
+
+export declare const DEFAULT_PRIORITY = 0;
+
+export { defineCanvasComponent }
+
+export { defineCanvasSingleton }
+
+declare function defineCommand<T = void>(name: string): CommandDef<T>;
+export { defineCommand }
+export { defineCommand as defineCommand_alias_1 }
+
+declare function defineEditorState<T extends StateSchema>(name: string, schema: T): EditorStateDef<T>;
+export { defineEditorState }
+export { defineEditorState as defineEditorState_alias_1 }
+
+declare function defineEditorSystem(options: EditorSystemOptions, execute: EditorSystemFunction): EditorSystem;
+export { defineEditorSystem }
+export { defineEditorSystem as defineEditorSystem_alias_1 }
+
+export { defineQuery }
+
+export { defineSystem }
+
+declare function detachKeyboardListeners(domElement: HTMLElement): void;
+export { detachKeyboardListeners }
+export { detachKeyboardListeners as detachKeyboardListeners_alias_1 }
+
+declare function detachMouseListeners(domElement: HTMLElement): void;
+export { detachMouseListeners }
+export { detachMouseListeners as detachMouseListeners_alias_1 }
+
+declare function detachPointerListeners(domElement: HTMLElement): void;
+export { detachPointerListeners }
+export { detachPointerListeners as detachPointerListeners_alias_1 }
+
+declare function detachScreenObserver(domElement: HTMLElement): void;
+export { detachScreenObserver }
+export { detachScreenObserver as detachScreenObserver_alias_1 }
+
+declare const Edited: CanvasComponentDef<    {}, "edited">;
+export { Edited }
+export { Edited as Edited_alias_1 }
+export { Edited as Edited_alias_2 }
+
+declare class Editor {
+    cursors: Record<string, CursorDef>;
+    keybinds: Keybind[];
+    blockDefs: Record<string, BlockDef>;
+    fonts: FontFamily[];
+    components: AnyCanvasComponentDef[];
+    singletons: AnyCanvasSingletonDef[];
+    private world;
+    private systemBatches;
+    private plugins;
+    private fontLoader;
+    private userData;
+    private gridOptions;
+    private controlsOptions;
+    constructor(domElement: HTMLElement, optionsInput?: EditorOptionsInput);
+    private get ctx();
+    initialize(): Promise<void>;
+    tick(): Promise<void>;
+    nextTick(callback: (ctx: Context) => void): () => void;
+    command<T>(def: CommandDef<T>, ...args: T extends void ? [] : [T]): void;
+    subscribe(query: QueryDef, callback: QueryCallback): () => void;
+    _getContext(): Context;
+    dispose(): void;
+}
+export { Editor }
+export { Editor as Editor_alias_1 }
+
+export declare type EditorOptions = z.infer<typeof EditorOptionsSchema>;
+
+declare type EditorOptionsInput = z.input<typeof EditorOptionsSchema>;
+export { EditorOptionsInput }
+export { EditorOptionsInput as EditorOptionsInput_alias_1 }
+
+export declare const EditorOptionsSchema: z.ZodObject<{
+    plugins: z.ZodDefault<z.ZodArray<z.ZodCustom<EditorPluginInput, EditorPluginInput>>>;
+    maxEntities: z.ZodDefault<z.ZodNumber>;
+    user: z.ZodDefault<z.ZodCustom<{
+        userId?: string | undefined;
+        sessionId?: string | undefined;
+        color?: string | undefined;
+        name?: string | undefined;
+        avatar?: string | undefined;
+    }, {
+        userId?: string | undefined;
+        sessionId?: string | undefined;
+        color?: string | undefined;
+        name?: string | undefined;
+        avatar?: string | undefined;
+    }>>;
+    grid: z.ZodDefault<z.ZodCustom<{
+        enabled?: boolean | undefined;
+        strict?: boolean | undefined;
+        colWidth?: number | undefined;
+        rowHeight?: number | undefined;
+        snapAngleRad?: number | undefined;
+        shiftSnapAngleRad?: number | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        strict?: boolean | undefined;
+        colWidth?: number | undefined;
+        rowHeight?: number | undefined;
+        snapAngleRad?: number | undefined;
+        shiftSnapAngleRad?: number | undefined;
+    }>>;
+    blockDefs: z.ZodDefault<z.ZodArray<z.ZodCustom<{
+        tag: string;
+        stratum?: "background" | "content" | "overlay" | undefined;
+        editOptions?: {
+            canEdit?: boolean | undefined;
+            removeWhenTextEmpty?: boolean | undefined;
+        } | undefined;
+        components?: AnyCanvasComponentDef[] | undefined;
+        resizeMode?: "scale" | "text" | "free" | "groupOnly" | undefined;
+        canRotate?: boolean | undefined;
+        canScale?: boolean | undefined;
+        connectors?: {
+            enabled?: boolean | undefined;
+            terminals?: [number, number][] | undefined;
+        } | undefined;
+    }, {
+        tag: string;
+        stratum?: "background" | "content" | "overlay" | undefined;
+        editOptions?: {
+            canEdit?: boolean | undefined;
+            removeWhenTextEmpty?: boolean | undefined;
+        } | undefined;
+        components?: AnyCanvasComponentDef[] | undefined;
+        resizeMode?: "scale" | "text" | "free" | "groupOnly" | undefined;
+        canRotate?: boolean | undefined;
+        canScale?: boolean | undefined;
+        connectors?: {
+            enabled?: boolean | undefined;
+            terminals?: [number, number][] | undefined;
+        } | undefined;
+    }>>>;
+    keybinds: z.ZodDefault<z.ZodArray<z.ZodCustom<{
+        command: string;
+        key: number;
+        mod?: boolean | undefined;
+        shift?: boolean | undefined;
+    }, {
+        command: string;
+        key: number;
+        mod?: boolean | undefined;
+        shift?: boolean | undefined;
+    }>>>;
+    cursors: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodCustom<{
+        makeSvg: z.core.$InferOuterFunctionType<z.ZodTuple<[z.ZodNumber], null>, z.ZodString>;
+        hotspot: [number, number];
+        rotationOffset: number;
+    }, {
+        makeSvg: z.core.$InferOuterFunctionType<z.ZodTuple<[z.ZodNumber], null>, z.ZodString>;
+        hotspot: [number, number];
+        rotationOffset: number;
+    }>>>;
+    components: z.ZodDefault<z.ZodArray<z.ZodCustom<AnyCanvasComponentDef, AnyCanvasComponentDef>>>;
+    singletons: z.ZodDefault<z.ZodArray<z.ZodCustom<AnyCanvasSingletonDef, AnyCanvasSingletonDef>>>;
+    systems: z.ZodDefault<z.ZodArray<z.ZodCustom<EditorSystem, EditorSystem>>>;
+    fonts: z.ZodDefault<z.ZodArray<z.ZodCustom<{
+        name: string;
+        displayName: string;
+        url: string;
+        previewImage?: string | undefined;
+        selectable?: boolean | undefined;
+        weights?: number[] | undefined;
+        italics?: boolean | undefined;
+    }, {
+        name: string;
+        displayName: string;
+        url: string;
+        previewImage?: string | undefined;
+        selectable?: boolean | undefined;
+        weights?: number[] | undefined;
+        italics?: boolean | undefined;
+    }>>>;
+    omitPluginKeybinds: z.ZodDefault<z.ZodBoolean>;
+    omitPluginCursors: z.ZodDefault<z.ZodBoolean>;
+    omitPluginFonts: z.ZodDefault<z.ZodBoolean>;
+    controls: z.ZodOptional<z.ZodCustom<{
+        leftMouseTool?: string | undefined;
+        middleMouseTool?: string | undefined;
+        rightMouseTool?: string | undefined;
+        wheelTool?: string | undefined;
+        modWheelTool?: string | undefined;
+    }, {
+        leftMouseTool?: string | undefined;
+        middleMouseTool?: string | undefined;
+        rightMouseTool?: string | undefined;
+        wheelTool?: string | undefined;
+        modWheelTool?: string | undefined;
+    }>>;
+}, z.core.$strip>;
+
+declare interface EditorPlugin<TResources = unknown> {
+    name: string;
+    keybinds?: Keybind[];
+    blockDefs?: BlockDefInput[];
+    cursors?: Record<string, CursorDef>;
+    fonts?: FontFamilyInput[];
+    resources?: TResources;
+    dependencies?: string[];
+    components?: AnyCanvasComponentDef[];
+    singletons?: AnyCanvasSingletonDef[];
+    systems?: EditorSystem[];
+    setup?: (ctx: Context) => void | Promise<void>;
+    teardown?: (ctx: Context) => void;
+}
+export { EditorPlugin }
+export { EditorPlugin as EditorPlugin_alias_1 }
+
+declare type EditorPluginFactory<TOptions = unknown, TResources = unknown> = (options: TOptions) => EditorPlugin<TResources>;
+export { EditorPluginFactory }
+export { EditorPluginFactory as EditorPluginFactory_alias_1 }
+
+declare type EditorPluginInput = EditorPlugin | EditorPluginFactory<any, any>;
+export { EditorPluginInput }
+export { EditorPluginInput as EditorPluginInput_alias_1 }
+
+declare interface EditorResources {
+    domElement: HTMLElement;
+    editor: Editor;
+    userId: string;
+    sessionId: string;
+    pluginResources: Record<string, unknown>;
+    componentsByName: Map<string, AnyCanvasComponentDef>;
+    singletonsByName: Map<string, AnyCanvasSingletonDef>;
+    componentsById: Map<number, AnyCanvasComponentDef>;
+    singletonsById: Map<number, AnyCanvasSingletonDef>;
+}
+export { EditorResources }
+export { EditorResources as EditorResources_alias_1 }
+
+declare class EditorStateDef<T extends StateSchema> extends CanvasSingletonDef<T> {
+    constructor(name: string, schema: T);
+    getState(ctx: Context): string;
+    getContext<TContext extends object = InferMachineContext<T>>(ctx: Context): TContext;
+    run<TState extends string, TContext extends object = InferMachineContext<T>, TEvent extends {
+        type: string;
+    } = {
+        type: string;
+    }>(ctx: Context, machine: AnyStateMachine, events: TEvent[]): {
+        value: TState;
+        context: TContext;
+    };
+}
+export { EditorStateDef }
+export { EditorStateDef as EditorStateDef_alias_1 }
+
+declare interface EditorSystem {
+    readonly _system: MainThreadSystem;
+    readonly phase: SystemPhase;
+    readonly priority: number;
+}
+export { EditorSystem }
+export { EditorSystem as EditorSystem_alias_1 }
+
+declare type EditorSystemFunction = (ctx: Context) => void;
+export { EditorSystemFunction }
+export { EditorSystemFunction as EditorSystemFunction_alias_1 }
+
+declare interface EditorSystemOptions {
+    phase: SystemPhase;
+    priority?: number;
+}
+export { EditorSystemOptions }
+export { EditorSystemOptions as EditorSystemOptions_alias_1 }
+
+export { EntityId }
+export { EntityId as EntityId_alias_1 }
+
+export { EventType }
+
+export { field }
+
+declare const FontFamily: z.ZodObject<{
+    name: z.ZodString;
+    displayName: z.ZodString;
+    url: z.ZodString;
+    previewImage: z.ZodOptional<z.ZodString>;
+    selectable: z.ZodDefault<z.ZodBoolean>;
+    weights: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    italics: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+
+declare type FontFamily = z.infer<typeof FontFamily>;
+export { FontFamily }
+export { FontFamily as FontFamilyType }
+export { FontFamily as FontFamily_alias_1 }
+
+declare type FontFamilyInput = z.input<typeof FontFamily>;
+export { FontFamilyInput }
+export { FontFamilyInput as FontFamilyInput_alias_1 }
+
+declare class FontLoader {
+    private loadedFonts;
+    loadFonts(families: FontFamily[]): Promise<void>;
+    private buildGoogleFontsUrl;
+    private loadSingleFont;
+    private getFontLoadPromises;
+    isLoaded(fontName: string): boolean;
+    getLoadedFonts(): ReadonlySet<string>;
+}
+export { FontLoader }
+export { FontLoader as FontLoader_alias_1 }
+
+declare const Frame: CanvasSingletonDef<    {
+number: NumberFieldBuilder<"uint32">;
+delta: NumberFieldBuilder<"float64">;
+time: NumberFieldBuilder<"float64">;
+lastTime: NumberFieldBuilder<"float64">;
+}, "frame">;
+export { Frame }
+export { Frame as Frame_alias_1 }
+export { Frame as Frame_alias_2 }
+
+declare interface FrameInput {
+    type: 'frame';
+    ctx: Context;
+    delta: number;
+    frameNumber: number;
+    time: number;
+}
+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 }
+
+export { getBackrefs }
+
+declare function getBlockDef(ctx: Context, tag: string): BlockDef;
+export { getBlockDef }
+export { getBlockDef as getBlockDef_alias_1 }
+export { getBlockDef as getBlockDef_alias_2 }
+
+declare function getBlockDefs(ctx: Context): Record<string, BlockDef>;
+export { getBlockDefs }
+export { getBlockDefs as getBlockDefs_alias_1 }
+
+export declare function getCursorSvg(cursors: Record<string, CursorDef>, kind: string, rotateZ: number): string;
+
+declare function getFrameInput(ctx: Context): FrameInput;
+export { getFrameInput }
+export { getFrameInput as getFrameInput_alias_1 }
+export { getFrameInput as getFrameInput_alias_2 }
+
+declare function getKeyboardInput(ctx: Context, keys: number[]): KeyboardInput[];
+export { getKeyboardInput }
+export { getKeyboardInput as getKeyboardInput_alias_1 }
+export { getKeyboardInput as getKeyboardInput_alias_2 }
+
+declare function getMouseInput(ctx: Context): MouseInput[];
+export { getMouseInput }
+export { getMouseInput as getMouseInput_alias_1 }
+export { getMouseInput as getMouseInput_alias_2 }
+
+declare function getMyUserEntityId(ctx: Context): EntityId | null;
+export { getMyUserEntityId }
+export { getMyUserEntityId as getMyUserEntityId_alias_1 }
+
+declare function getPluginResources<T>(ctx: Context, pluginName: string): T;
+export { getPluginResources }
+export { getPluginResources as getPluginResources_alias_1 }
+
+declare function getPointerInput(ctx: Context, buttons: PointerButton[], options?: PointerInputOptions): PointerInput[];
+export { getPointerInput }
+export { getPointerInput as getPointerInput_alias_1 }
+export { getPointerInput as getPointerInput_alias_2 }
+
+export { getResources }
+
+declare function getTopmostBlockAtPoint(ctx: Context, point: Vec2): EntityId | undefined;
+export { getTopmostBlockAtPoint }
+export { getTopmostBlockAtPoint as getTopmostBlockAtPoint_alias_1 }
+export { getTopmostBlockAtPoint as getTopmostBlockAtPoint_alias_2 }
+
+declare const Grid: GridDef;
+export { Grid }
+export { Grid as Grid_alias_1 }
+export { Grid as Grid_alias_2 }
+
+declare class GridDef extends CanvasSingletonDef<typeof GridSchema> {
+    constructor();
+    snapPosition(ctx: Context, position: Vec2): void;
+    snapSize(ctx: Context, size: Vec2): void;
+    snapX(ctx: Context, value: number): number;
+    snapY(ctx: Context, value: number): number;
+}
+
+declare const GridOptions: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    strict: z.ZodDefault<z.ZodBoolean>;
+    colWidth: z.ZodDefault<z.ZodNumber>;
+    rowHeight: z.ZodDefault<z.ZodNumber>;
+    snapAngleRad: z.ZodDefault<z.ZodNumber>;
+    shiftSnapAngleRad: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+
+declare type GridOptions = z.infer<typeof GridOptions>;
+export { GridOptions }
+export { GridOptions as GridOptions_alias_1 }
+
+declare type GridOptionsInput = z.input<typeof GridOptions>;
+export { GridOptionsInput }
+export { GridOptionsInput as GridOptionsInput_alias_1 }
+
+declare const GridSchema: {
+    enabled: BooleanFieldBuilder;
+    strict: BooleanFieldBuilder;
+    colWidth: NumberFieldBuilder<"float64">;
+    rowHeight: NumberFieldBuilder<"float64">;
+    snapAngleRad: NumberFieldBuilder<"float64">;
+    shiftSnapAngleRad: NumberFieldBuilder<"float64">;
+};
+
+export { hasComponent }
+
+declare const Held: CanvasComponentDef<    {
+sessionId: StringFieldBuilder;
+}, "held">;
+export { Held }
+export { Held as Held_alias_1 }
+export { Held as Held_alias_2 }
+
+declare const HitGeometry: HitGeometryDef;
+export { HitGeometry }
+export { HitGeometry as HitGeometry_alias_1 }
+export { HitGeometry as HitGeometry_alias_2 }
+
+declare class HitGeometryDef extends CanvasComponentDef<typeof HitGeometrySchema> {
+    constructor();
+    getCapsuleAt(ctx: Context, entityId: EntityId, index: number): Capsule;
+    setCapsuleAt(ctx: Context, entityId: EntityId, index: number, capsule: Capsule): void;
+    getArcAt(ctx: Context, entityId: EntityId, index: number): Arc;
+    setArcAt(ctx: Context, entityId: EntityId, index: number, arc: Arc): void;
+    containsPointWorld(ctx: Context, entityId: EntityId, point: Vec2): boolean;
+    intersectsAabbWorld(ctx: Context, entityId: EntityId, aabb: Aabb_2): boolean;
+    getExtremaWorld(ctx: Context, entityId: EntityId): Vec2[];
+    addCapsule(ctx: Context, entityId: EntityId, capsule: Capsule): void;
+    addCapsuleUv(ctx: Context, entityId: EntityId, uvA: Vec2, uvB: Vec2, worldRadius: number): void;
+    addCapsuleWorld(ctx: Context, entityId: EntityId, worldA: Vec2, worldB: Vec2, worldRadius: number): void;
+    addArc(ctx: Context, entityId: EntityId, arc: Arc): void;
+    addArcUv(ctx: Context, entityId: EntityId, uvA: Vec2, uvB: Vec2, uvC: Vec2, worldThickness: number): void;
+    addArcWorld(ctx: Context, entityId: EntityId, worldA: Vec2, worldB: Vec2, worldC: Vec2, worldThickness: number): void;
+    clear(ctx: Context, entityId: EntityId): void;
+}
+
+declare const HitGeometrySchema: {
+    hitCapsules: BufferFieldBuilder<"float32">;
+    capsuleCount: NumberFieldBuilder<"uint16">;
+    hitArcs: BufferFieldBuilder<"float32">;
+    arcCount: NumberFieldBuilder<"uint16">;
+};
+
+declare const Hovered: CanvasComponentDef<    {}, "hovered">;
+export { Hovered }
+export { Hovered as Hovered_alias_1 }
+export { Hovered as Hovered_alias_2 }
+
+declare const Image_2: CanvasComponentDef<    {
+width: NumberFieldBuilder<"uint16">;
+height: NumberFieldBuilder<"uint16">;
+alt: StringFieldBuilder;
+}, "image">;
+export { Image_2 as Image }
+export { Image_2 as Image_alias_1 }
+export { Image_2 as Image_alias_2 }
+
+export { InferCanvasComponentType }
+
+declare type InferMachineContext<T extends StateSchema> = Omit<InferCanvasComponentType<T>, 'state'>;
+
+declare type InferStateContext<T> = T extends EditorStateDef<infer S> ? Omit<InferMachineContext<S>, '_exists' | '_version'> : never;
+export { InferStateContext }
+export { InferStateContext as InferStateContext_alias_1 }
+
+declare const Intersect: IntersectDef;
+export { Intersect }
+export { Intersect as Intersect_alias_1 }
+export { Intersect as Intersect_alias_2 }
+
+declare function intersectAabb(ctx: Context, bounds: Aabb_2, entityIds?: Iterable<EntityId>): EntityId[];
+export { intersectAabb }
+export { intersectAabb as intersectAabb_alias_1 }
+export { intersectAabb as intersectAabb_alias_2 }
+
+declare function intersectCapsule(ctx: Context, capsule: Capsule, entityIds: Iterable<EntityId>): EntityId[];
+export { intersectCapsule }
+export { intersectCapsule as intersectCapsule_alias_1 }
+export { intersectCapsule as intersectCapsule_alias_2 }
+
+declare class IntersectDef extends CanvasSingletonDef<typeof IntersectSchema> {
+    constructor();
+    getTop(ctx: Context): EntityId | null;
+    getAll(ctx: Context): EntityId[];
+    setAll(ctx: Context, entities: EntityId[]): void;
+    clear(ctx: Context): void;
+}
+
+declare function intersectPoint(ctx: Context, point: Vec2, entityIds?: Iterable<EntityId>): EntityId[];
+export { intersectPoint }
+export { intersectPoint as intersectPoint_alias_1 }
+export { intersectPoint as intersectPoint_alias_2 }
+
+declare const IntersectSchema: {
+    entity1: RefFieldBuilder;
+    entity2: RefFieldBuilder;
+    entity3: RefFieldBuilder;
+    entity4: RefFieldBuilder;
+    entity5: RefFieldBuilder;
+};
+
+declare const intersectSystem: EditorSystem;
+export { intersectSystem }
+export { intersectSystem as intersectSystem_alias_1 }
+
+export { isAlive }
+
+declare function isHeldByRemote(ctx: Context, entityId: EntityId): boolean;
+export { isHeldByRemote }
+export { isHeldByRemote as isHeldByRemote_alias_1 }
+export { isHeldByRemote as isHeldByRemote_alias_2 }
+
+declare const Key: {
+    readonly A: number;
+    readonly B: number;
+    readonly C: number;
+    readonly D: number;
+    readonly E: number;
+    readonly F: number;
+    readonly G: number;
+    readonly H: number;
+    readonly I: number;
+    readonly J: number;
+    readonly K: number;
+    readonly L: number;
+    readonly M: number;
+    readonly N: number;
+    readonly O: number;
+    readonly P: number;
+    readonly Q: number;
+    readonly R: number;
+    readonly S: number;
+    readonly T: number;
+    readonly U: number;
+    readonly V: number;
+    readonly W: number;
+    readonly X: number;
+    readonly Y: number;
+    readonly Z: number;
+    readonly Digit0: number;
+    readonly Digit1: number;
+    readonly Digit2: number;
+    readonly Digit3: number;
+    readonly Digit4: number;
+    readonly Digit5: number;
+    readonly Digit6: number;
+    readonly Digit7: number;
+    readonly Digit8: number;
+    readonly Digit9: number;
+    readonly F1: number;
+    readonly F2: number;
+    readonly F3: number;
+    readonly F4: number;
+    readonly F5: number;
+    readonly F6: number;
+    readonly F7: number;
+    readonly F8: number;
+    readonly F9: number;
+    readonly F10: number;
+    readonly F11: number;
+    readonly F12: number;
+    readonly ShiftLeft: number;
+    readonly ShiftRight: number;
+    readonly ControlLeft: number;
+    readonly ControlRight: number;
+    readonly AltLeft: number;
+    readonly AltRight: number;
+    readonly MetaLeft: number;
+    readonly MetaRight: number;
+    readonly Escape: number;
+    readonly Space: number;
+    readonly Enter: number;
+    readonly Tab: number;
+    readonly Backspace: number;
+    readonly Delete: number;
+    readonly ArrowLeft: number;
+    readonly ArrowUp: number;
+    readonly ArrowRight: number;
+    readonly ArrowDown: number;
+    readonly Home: number;
+    readonly End: number;
+    readonly PageUp: number;
+    readonly PageDown: number;
+    readonly Insert: number;
+    readonly Semicolon: number;
+    readonly Equal: number;
+    readonly Comma: number;
+    readonly Minus: number;
+    readonly Period: number;
+    readonly Slash: number;
+    readonly Backquote: number;
+    readonly BracketLeft: number;
+    readonly Backslash: number;
+    readonly BracketRight: number;
+    readonly Quote: number;
+    readonly Numpad0: number;
+    readonly Numpad1: number;
+    readonly Numpad2: number;
+    readonly Numpad3: number;
+    readonly Numpad4: number;
+    readonly Numpad5: number;
+    readonly Numpad6: number;
+    readonly Numpad7: number;
+    readonly Numpad8: number;
+    readonly Numpad9: number;
+    readonly NumpadAdd: number;
+    readonly NumpadSubtract: number;
+    readonly NumpadMultiply: number;
+    readonly NumpadDivide: number;
+    readonly NumpadDecimal: number;
+    readonly NumpadEnter: number;
+};
+
+declare type Key = (typeof Key)[keyof typeof Key];
+export { Key }
+export { Key as Key_alias_1 }
+export { Key as Key_alias_2 }
+
+declare const Keybind: z.ZodObject<{
+    command: z.ZodString;
+    key: z.ZodNumber;
+    mod: z.ZodOptional<z.ZodBoolean>;
+    shift: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+
+declare type Keybind = z.infer<typeof Keybind>;
+export { Keybind }
+export { Keybind as Keybind_alias_1 }
+
+declare type KeybindInput = z.input<typeof Keybind>;
+export { KeybindInput }
+export { KeybindInput as KeybindInput_alias_1 }
+
+declare const keybindSystem: EditorSystem;
+export { keybindSystem }
+export { keybindSystem as keybindSystem_alias_1 }
+
+declare const Keyboard: KeyboardDef;
+export { Keyboard }
+export { Keyboard as Keyboard_alias_1 }
+export { Keyboard as Keyboard_alias_2 }
+
+declare class KeyboardDef extends CanvasSingletonDef<typeof KeyboardSchema> {
+    constructor();
+    isKeyDown(ctx: Context, key: number): boolean;
+    isKeyDownTrigger(ctx: Context, key: number): boolean;
+    isKeyUpTrigger(ctx: Context, key: number): boolean;
+}
+
+declare interface KeyboardInput {
+    type: KeyboardInputType;
+    key: number;
+    ctx: Context;
+}
+export { KeyboardInput }
+export { KeyboardInput as KeyboardInput_alias_1 }
+export { KeyboardInput as KeyboardInput_alias_2 }
+
+declare type KeyboardInputType = 'keyDown' | 'keyUp';
+export { KeyboardInputType }
+export { KeyboardInputType as KeyboardInputType_alias_1 }
+export { KeyboardInputType as KeyboardInputType_alias_2 }
+
+declare const KeyboardSchema: {
+    keysDown: BufferFieldBuilder<"uint8">;
+    keysDownTrigger: BufferFieldBuilder<"uint8">;
+    keysUpTrigger: BufferFieldBuilder<"uint8">;
+    shiftDown: BooleanFieldBuilder;
+    altDown: BooleanFieldBuilder;
+    modDown: BooleanFieldBuilder;
+};
+
+declare const keyboardSystem: EditorSystem;
+export { keyboardSystem }
+export { keyboardSystem as keyboardSystem_alias_1 }
+
+declare interface MachineResult<TState, TContext> {
+    value: TState;
+    context: TContext;
+}
+export { MachineResult }
+export { MachineResult as MachineResult_alias_1 }
+
+export { MainThreadSystem }
+
+declare const MAX_HIT_ARCS = 2;
+export { MAX_HIT_ARCS }
+export { MAX_HIT_ARCS as MAX_HIT_ARCS_alias_1 }
+export { MAX_HIT_ARCS as MAX_HIT_ARCS_alias_2 }
+
+declare const MAX_HIT_CAPSULES = 64;
+export { MAX_HIT_CAPSULES }
+export { MAX_HIT_CAPSULES as MAX_HIT_CAPSULES_alias_1 }
+export { MAX_HIT_CAPSULES as MAX_HIT_CAPSULES_alias_2 }
+
+declare const Mouse: MouseDef;
+export { Mouse }
+export { Mouse as Mouse_alias_1 }
+export { Mouse as Mouse_alias_2 }
+
+declare class MouseDef extends CanvasSingletonDef<typeof MouseSchema> {
+    constructor();
+    didMove(ctx: Context): boolean;
+    didScroll(ctx: Context): boolean;
+    didEnter(ctx: Context): boolean;
+    didLeave(ctx: Context): boolean;
+    getPosition(ctx: Context): Vec2;
+    getWheelDelta(ctx: Context): Vec2;
+}
+
+declare interface MouseInput {
+    type: MouseInputType;
+    ctx: Context;
+    screenPosition: Vec2;
+    worldPosition: Vec2;
+    wheelDeltaX: number;
+    wheelDeltaY: number;
+}
+export { MouseInput }
+export { MouseInput as MouseInput_alias_1 }
+export { MouseInput as MouseInput_alias_2 }
+
+declare type MouseInputType = 'wheel' | 'mouseMove';
+export { MouseInputType }
+export { MouseInputType as MouseInputType_alias_1 }
+export { MouseInputType as MouseInputType_alias_2 }
+
+declare const MouseSchema: {
+    position: TupleFieldBuilder<NumberFieldBuilder<"float32">, 2>;
+    wheelDeltaX: NumberFieldBuilder<"float32">;
+    wheelDeltaY: NumberFieldBuilder<"float32">;
+    moveTrigger: BooleanFieldBuilder;
+    wheelTrigger: BooleanFieldBuilder;
+    enterTrigger: BooleanFieldBuilder;
+    leaveTrigger: BooleanFieldBuilder;
+};
+
+declare const mouseSystem: EditorSystem;
+export { mouseSystem }
+export { mouseSystem as mouseSystem_alias_1 }
+
+declare function on<T>(ctx: Context, def: CommandDef<T>, handler: (ctx: Context, payload: T) => void): void;
+export { on }
+export { on as on_alias_1 }
+
+declare const Opacity: CanvasComponentDef<    {
+value: NumberFieldBuilder<"uint8">;
+}, "opacity">;
+export { Opacity }
+export { Opacity as Opacity_alias_1 }
+export { Opacity as Opacity_alias_2 }
+
+declare function parsePlugin(input: EditorPluginInput): EditorPlugin;
+export { parsePlugin }
+export { parsePlugin as parsePlugin_alias_1 }
+
+export declare const PLUGIN_NAME = "core";
+
+declare const Pointer: PointerDef;
+export { Pointer }
+export { Pointer as Pointer_alias_1 }
+export { Pointer as Pointer_alias_2 }
+
+declare const PointerButton: {
+    readonly None: "none";
+    readonly Left: "left";
+    readonly Middle: "middle";
+    readonly Right: "right";
+    readonly Back: "back";
+    readonly Forward: "forward";
+};
+
+declare type PointerButton = (typeof PointerButton)[keyof typeof PointerButton];
+export { PointerButton }
+export { PointerButton as PointerButton_alias_1 }
+export { PointerButton as PointerButton_alias_2 }
+
+declare class PointerDef extends CanvasComponentDef<typeof PointerSchema> {
+    constructor();
+    getVelocity(ctx: Context, entityId: number): Vec2;
+    getButton(button: number): PointerButton;
+    getType(pointerType: string): PointerType;
+}
+
+declare interface PointerInput {
+    type: PointerInputType;
+    ctx: Context;
+    screenPosition: Vec2;
+    worldPosition: Vec2;
+    velocity: Vec2;
+    pressure: number;
+    button: PointerButton;
+    pointerType: PointerType;
+    obscured: boolean;
+    shiftDown: boolean;
+    altDown: boolean;
+    modDown: boolean;
+    cameraLeft: number;
+    cameraTop: number;
+    cameraZoom: number;
+    pointerId: number;
+    intersects: EntityId[];
+}
+export { PointerInput }
+export { PointerInput as PointerInput_alias_1 }
+export { PointerInput as PointerInput_alias_2 }
+
+declare interface PointerInputOptions {
+    includeFrameEvent?: boolean;
+    clickMoveThreshold?: number;
+    clickFrameThreshold?: number;
+}
+export { PointerInputOptions }
+export { PointerInputOptions as PointerInputOptions_alias_1 }
+export { PointerInputOptions as PointerInputOptions_alias_2 }
+
+declare type PointerInputType = 'pointerDown' | 'pointerMove' | 'pointerUp' | 'click' | 'cancel' | 'frame';
+export { PointerInputType }
+export { PointerInputType as PointerInputType_alias_1 }
+export { PointerInputType as PointerInputType_alias_2 }
+
+declare const PointerSchema: {
+    pointerId: NumberFieldBuilder<"uint16">;
+    position: TupleFieldBuilder<NumberFieldBuilder<"float32">, 2>;
+    downPosition: TupleFieldBuilder<NumberFieldBuilder<"float32">, 2>;
+    downFrame: NumberFieldBuilder<"uint32">;
+    button: EnumFieldBuilder<"none" | "left" | "middle" | "right" | "back" | "forward">;
+    pointerType: EnumFieldBuilder<"mouse" | "pen" | "touch">;
+    pressure: NumberFieldBuilder<"float32">;
+    obscured: BooleanFieldBuilder;
+    _prevPositions: ArrayFieldBuilder<NumberFieldBuilder<"float32">>;
+    _prevTimes: ArrayFieldBuilder<NumberFieldBuilder<"float32">>;
+    _sampleCount: NumberFieldBuilder<"int32">;
+    _velocity: TupleFieldBuilder<NumberFieldBuilder<"float32">, 2>;
+};
+
+declare const pointerSystem: EditorSystem;
+export { pointerSystem }
+export { pointerSystem as pointerSystem_alias_1 }
+
+declare const PointerType: {
+    readonly Mouse: "mouse";
+    readonly Pen: "pen";
+    readonly Touch: "touch";
+};
+
+declare type PointerType = (typeof PointerType)[keyof typeof PointerType];
+export { PointerType }
+export { PointerType as PointerType_alias_1 }
+export { PointerType as PointerType_alias_2 }
+
+declare const presenceSystem: EditorSystem;
+export { presenceSystem }
+export { presenceSystem as presenceSystem_alias_1 }
+
+declare type QueryCallback = (ctx: Context, result: {
+    added: number[];
+    changed: number[];
+    removed: number[];
+}) => void;
+export { QueryCallback }
+export { QueryCallback as QueryCallback_alias_1 }
+
+export { QueryDef }
+
+declare const RankBounds: RankBoundsDef;
+export { RankBounds }
+export { RankBounds as RankBounds_alias_1 }
+export { RankBounds as RankBounds_alias_2 }
+
+declare class RankBoundsDef extends CanvasSingletonDef<typeof RankBoundsSchema> {
+    constructor();
+    genNext(ctx: Context): string;
+    genPrev(ctx: Context): string;
+    genBetween(before: string | null, after: string | null): string;
+    add(ctx: Context, rank: string): void;
+}
+
+declare const RankBoundsSchema: {
+    minRank: StringFieldBuilder;
+    maxRank: StringFieldBuilder;
+};
+
+declare const rankBoundsSystem: EditorSystem;
+export { rankBoundsSystem }
+export { rankBoundsSystem as rankBoundsSystem_alias_1 }
+
+declare const Redo: CommandDef<void>;
+export { Redo }
+export { Redo as Redo_alias_1 }
+
+export { removeComponent }
+
+export { removeEntity }
+
+declare type ResizeMode = 'scale' | 'text' | 'free' | 'groupOnly';
+export { ResizeMode }
+export { ResizeMode as ResizeMode_alias_1 }
+
+declare function runMachine<TState extends string, TContext extends object>(machine: AnyStateMachine, currentState: TState, context: TContext, events: Array<{
+    type: string;
+    [key: string]: unknown;
+}>): MachineResult<TState, TContext>;
+export { runMachine }
+export { runMachine as runMachine_alias_1 }
+
+declare const ScaleWithZoom: CanvasComponentDef<    {
+anchor: TupleFieldBuilder<NumberFieldBuilder<"float64">, 2>;
+startPosition: TupleFieldBuilder<NumberFieldBuilder<"float64">, 2>;
+startSize: TupleFieldBuilder<NumberFieldBuilder<"float64">, 2>;
+scaleMultiplier: TupleFieldBuilder<NumberFieldBuilder<"float64">, 2>;
+}, "scaleWithZoom">;
+export { ScaleWithZoom }
+export { ScaleWithZoom as ScaleWithZoom_alias_1 }
+export { ScaleWithZoom as ScaleWithZoom_alias_2 }
+
+declare const ScaleWithZoomState: CanvasSingletonDef<    {
+lastZoom: NumberFieldBuilder<"float64">;
+}, "scaleWithZoomState">;
+export { ScaleWithZoomState }
+export { ScaleWithZoomState as ScaleWithZoomState_alias_1 }
+export { ScaleWithZoomState as ScaleWithZoomState_alias_2 }
+
+declare const scaleWithZoomSystem: EditorSystem;
+export { scaleWithZoomSystem }
+export { scaleWithZoomSystem as scaleWithZoomSystem_alias_1 }
+
+declare const Screen_2: ScreenDef;
+export { Screen_2 as Screen }
+export { Screen_2 as Screen_alias_1 }
+export { Screen_2 as Screen_alias_2 }
+
+declare class ScreenDef extends CanvasSingletonDef<typeof ScreenSchema> {
+    constructor();
+    getSize(ctx: Context): Vec2;
+    getPosition(ctx: Context): Vec2;
+    getCenter(ctx: Context): Vec2;
+}
+
+declare const ScreenSchema: {
+    width: NumberFieldBuilder<"float64">;
+    height: NumberFieldBuilder<"float64">;
+    left: NumberFieldBuilder<"float64">;
+    top: NumberFieldBuilder<"float64">;
+};
+
+declare const screenSystem: EditorSystem;
+export { screenSystem }
+export { screenSystem as screenSystem_alias_1 }
+
+declare function setBit(buffer: {
+    [index: number]: number;
+    length: number;
+}, bitIndex: number, value: boolean): void;
+export { setBit }
+export { setBit as setBit_alias_1 }
+
+declare const Shape: CanvasComponentDef<    {
+kind: StringFieldBuilder;
+strokeKind: EnumFieldBuilder<"none" | "solid" | "dashed">;
+strokeWidth: NumberFieldBuilder<"uint16">;
+strokeRed: NumberFieldBuilder<"uint8">;
+strokeGreen: NumberFieldBuilder<"uint8">;
+strokeBlue: NumberFieldBuilder<"uint8">;
+strokeAlpha: NumberFieldBuilder<"uint8">;
+fillRed: NumberFieldBuilder<"uint8">;
+fillGreen: NumberFieldBuilder<"uint8">;
+fillBlue: NumberFieldBuilder<"uint8">;
+fillAlpha: NumberFieldBuilder<"uint8">;
+}, "shape">;
+export { Shape }
+export { Shape as Shape_alias_1 }
+export { Shape as Shape_alias_2 }
+
+export { SINGLETON_ENTITY_ID }
+
+export { SingletonSyncBehavior }
+
+export declare function sortPluginsByDependencies(plugins: EditorPlugin[]): EditorPlugin[];
+
+declare interface StateSchema extends ComponentSchema {
+    state: {
+        def: StringFieldDef | EnumFieldDef<any>;
+    };
+}
+export { StateSchema }
+export { StateSchema as StateSchema_alias_1 }
+
+declare const Stratum: z.ZodEnum<{
+    background: "background";
+    content: "content";
+    overlay: "overlay";
+}>;
+
+declare type Stratum = z.infer<typeof Stratum>;
+export { Stratum }
+export { Stratum as Stratum_alias_1 }
+
+declare const STRATUM_ORDER: {
+    readonly background: 0;
+    readonly content: 1;
+    readonly overlay: 2;
+};
+export { STRATUM_ORDER }
+export { STRATUM_ORDER as STRATUM_ORDER_alias_1 }
+
+declare const StrokeKind: {
+    readonly Solid: "solid";
+    readonly Dashed: "dashed";
+    readonly None: "none";
+};
+
+declare type StrokeKind = (typeof StrokeKind)[keyof typeof StrokeKind];
+export { StrokeKind }
+export { StrokeKind as StrokeKind_alias_1 }
+export { StrokeKind as StrokeKind_alias_2 }
+
+export { SyncBehavior }
+
+export { Synced }
+
+export { System }
+
+export declare type SystemPhase = 'input' | 'capture' | 'update' | 'render';
+
+declare const Text_2: CanvasComponentDef<    {
+content: StringFieldBuilder;
+fontSizePx: NumberFieldBuilder<"float64">;
+fontFamily: StringFieldBuilder;
+lineHeight: NumberFieldBuilder<"float64">;
+letterSpacingEm: NumberFieldBuilder<"float64">;
+constrainWidth: BooleanFieldBuilder;
+defaultAlignment: EnumFieldBuilder<"center" | "left" | "right" | "justify">;
+}, "text">;
+export { Text_2 as Text }
+export { Text_2 as Text_alias_1 }
+export { Text_2 as Text_alias_2 }
+
+declare const TextAlignment: {
+    readonly Left: "left";
+    readonly Center: "center";
+    readonly Right: "right";
+    readonly Justify: "justify";
+};
+
+declare type TextAlignment = (typeof TextAlignment)[keyof typeof TextAlignment];
+export { TextAlignment }
+export { TextAlignment as TextAlignment_alias_1 }
+
+declare const Undo: CommandDef<void>;
+export { Undo }
+export { Undo as Undo_alias_1 }
+
+declare const UploadState: {
+    readonly Pending: "pending";
+    readonly Uploading: "uploading";
+    readonly Complete: "complete";
+    readonly Failed: "failed";
+};
+export { UploadState }
+export { UploadState as UploadState_alias_1 }
+export { UploadState as UploadState_alias_2 }
+
+declare const User: CanvasComponentDef<    {
+userId: StringFieldBuilder;
+sessionId: StringFieldBuilder;
+color: StringFieldBuilder;
+name: StringFieldBuilder;
+avatar: StringFieldBuilder;
+position: TupleFieldBuilder<NumberFieldBuilder<"float32">, 2>;
+}, "user">;
+export { User }
+export { User as User_alias_1 }
+export { User as User_alias_2 }
+
+declare const UserData: z.ZodObject<{
+    userId: z.ZodDefault<z.ZodString>;
+    sessionId: z.ZodDefault<z.ZodString>;
+    color: z.ZodDefault<z.ZodString>;
+    name: z.ZodDefault<z.ZodString>;
+    avatar: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+
+declare type UserData = z.infer<typeof UserData>;
+export { UserData }
+export { UserData as UserData_alias_1 }
+
+declare type UserDataInput = z.input<typeof UserData>;
+export { UserDataInput }
+export { UserDataInput as UserDataInput_alias_1 }
+
+export { Vec2 }
+
+declare const VerticalAlign: CanvasComponentDef<    {
+value: EnumFieldBuilder<"center" | "top" | "bottom">;
+}, "verticalAlign">;
+export { VerticalAlign }
+export { VerticalAlign as VerticalAlign_alias_1 }
+export { VerticalAlign as VerticalAlign_alias_2 }
+
+declare const VerticalAlignment: {
+    readonly Top: "top";
+    readonly Center: "center";
+    readonly Bottom: "bottom";
+};
+export { VerticalAlignment }
+export { VerticalAlignment as VerticalAlignment_alias_1 }
+
+export { }