@m2c2kit/core 0.3.15 → 0.3.17

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Image, CanvasKit, Canvas, Surface, FontMgr, Typeface, EmbindObject, Font, Paint, ParagraphBuilder, Paragraph, Path, PaintStyle } from 'canvaskit-wasm';
+import { Canvas, Typeface, TypefaceFontProvider, Image, CanvasKit, Surface, Font, Paint, ParagraphBuilder, Paragraph, FontMgr, Path, PaintStyle } from 'canvaskit-wasm';
 
 declare class GlobalVariables {
     now: number;
@@ -14,8 +14,413 @@ declare global {
 }
 //# sourceMappingURL=Globals.d.ts.map
 
+/**
+ * Base interface for all m2c2kit events.
+ *
+ * @remarks I would have named it Event, but that would collide with
+ * the existing DOM Event
+ */
+interface M2Event<T> {
+    /** Type of event. */
+    type: M2EventType | string;
+    /** The object on which the event occurred. */
+    target: T;
+    /** Has the event been taken care of by the listener and not be dispatched to other targets? */
+    handled?: boolean;
+}
+/**
+ * The different events that are dispatched by m2c2kit core.
+ */
+declare const M2EventType: {
+    readonly ActivityStart: "ActivityStart";
+    readonly ActivityEnd: "ActivityEnd";
+    readonly ActivityCancel: "ActivityCancel";
+    readonly ActivityData: "ActivityData";
+    readonly GameWarmupStart: "GameWarmupStart";
+    readonly GameWarmupEnd: "GameWarmupEnd";
+    readonly TapDown: "TapDown";
+    readonly TapUp: "TapUp";
+    readonly TapUpAny: "TapUpAny";
+    readonly TapLeave: "TapLeave";
+    readonly PointerDown: "PointerDown";
+    readonly PointerUp: "PointerUp";
+    readonly PointerMove: "PointerMove";
+    readonly PointerLeave: "PointerLeave";
+    readonly Drag: "Drag";
+    readonly DragStart: "DragStart";
+    readonly DragEnd: "DragEnd";
+    readonly CompositeCustom: "CompositeCustom";
+    readonly FrameDidSimulatePhysics: "FrameDidSimulatePhysics";
+    readonly SceneSetup: "SceneSetup";
+    readonly SceneAppear: "SceneAppear";
+};
+type M2EventType = (typeof M2EventType)[keyof typeof M2EventType];
+
+/**
+ * Base interface for all m2c2kit event listeners.
+ */
+interface M2EventListener<T> {
+    /** Type of event to listen for. */
+    type: M2EventType | string;
+    /** Callback function to be called when the event is dispatched. */
+    callback: (event: T) => void;
+    /** Optional key (string identifier) used to identify the event listener. */
+    key?: string;
+}
+
+interface M2NodeEventListener<M2NodeEvent> extends M2EventListener<M2NodeEvent> {
+    /** For composites that raise events, type of the composite custom event. */
+    compositeType?: string;
+    /** UUID of the node that the event listener is listening for. */
+    nodeUuid: string;
+}
+
+/** Base interface for all M2Node events. */
+interface M2NodeEvent extends M2Event<M2Node> {
+    /** The M2Node on which the event occurred. */
+    target: M2Node;
+    /** For composites that raise events, type of the composite custom event. */
+    compositeType?: string;
+}
+
+/**
+ * Position in two-dimensional space.
+ */
+interface Point {
+    /** Horizontal coordinate */
+    x: number;
+    /** Vertical coordinate */
+    y: number;
+}
+
+/**
+ * Describes an interaction between the pointer (mouse, touches) and a node.
+ *
+ * @remarks I would have named it PointerEvent, but that would collide with
+ * the existing DOM PointerEvent.
+ */
+interface M2PointerEvent extends M2NodeEvent {
+    /** Point that was tapped on node, relative to the node coordinate system */
+    point: Point;
+    /** Buttons being pressed when event was fired. Taken from DOM MouseEvent.buttons */
+    buttons: number;
+}
+
+/**
+ * Describes an interaction of a pointer (mouse, touches) pressing a node.
+ *
+ * @remarks Unlike M2PointerEvent, TapEvent considers how the pointer, while
+ * in the down state, moves in relation to the bounds of the node.
+ */
+interface TapEvent extends M2NodeEvent {
+    /** Point that was tapped on node, relative to the node coordinate system */
+    point: Point;
+    /** Buttons being pressed when event was fired. Taken from DOM MouseEvent.buttons */
+    buttons: number;
+}
+
+interface DrawableOptions {
+    /** Point within the node that determines its position. Default is &#123; x: 0.5, y: 0.5 &#125;, which centers the node on its position */
+    anchorPoint?: Point;
+    /** Value along the z-axis to determine drawing and tap order. Larger values are on top. */
+    zPosition?: number;
+}
+
+/**
+ * Constraints for defining relative layouts.
+ *
+ * @remarks FOR INTERNAL USE ONLY
+ */
+interface Constraints {
+    /** Constrain the top (vertical axis) of this node to the top of the specified node. The tops of both will appear at the same vertical location */
+    topToTopOf?: M2Node | string;
+    /** Constrain the top (vertical axis) of this node to the bottom of the specified node. This node will appear immediately below the specified node */
+    topToBottomOf?: M2Node | string;
+    /** Constrain the bottom (vertical axis) of this node to the top of the specified node. This node will appear immediately above of the specified node */
+    bottomToTopOf?: M2Node | string;
+    /** Constrain the bottom (vertical axis) of this node to the bottom of the specified node. The bottoms of both will appear at the same vertical location */
+    bottomToBottomOf?: M2Node | string;
+    /** Constrain the start (horizontal axis) of this node to the start of the specified node. The start of both will appear at the same horizontal location */
+    startToStartOf?: M2Node | string;
+    /** Constrain the start (horizontal axis) of this node to the end of the specified node. This node will appear immediately to the right of the specified node */
+    startToEndOf?: M2Node | string;
+    /** Constrain the end (horizontal axis) of this node to the end of the specified node. The end of both will appear at the same horizontal location */
+    endToEndOf?: M2Node | string;
+    /** Constrain the end (horizontal axis) of this node to the start of the specified node. This node will appear immediately to the left of the specified node */
+    endToStartOf?: M2Node | string;
+    /** When opposing horizontal constraints are applied, the default is to center the node within the constraints (horizontalBias = .5). Setting horizontalBias less than .5 will pull the node towards the start (to the left). Setting horizontalBias greater than .5 will pull the node towards the end (to the right)  */
+    horizontalBias?: number;
+    /** When opposing vertical constraints are applied, the default is to center the node within the constraints (verticalBias = .5). Setting verticalBias less than .5 will pull the node towards the top. Setting verticalBias greater than .5 will pull the node towards the bottom */
+    verticalBias?: number;
+    [key: string]: M2Node | string | number | undefined;
+}
+
+/**
+ * The Layout allows relative positioning via constraints.
+ * This is not fully implemented yet: DO NOT USE!
+ * We use it internally for instructions.
+ */
+interface Layout {
+    height?: number;
+    width?: number;
+    marginStart?: number;
+    marginEnd?: number;
+    marginTop?: number;
+    marginBottom?: number;
+    constraints?: Constraints;
+}
+
+/**
+ * Color in red (0-255), green (0-255), blue (0-255), alpha (0-1) format. Must be numeric array of length 4.
+ */
+type RgbaColor = [number, number, number, number];
+
+interface TextOptions {
+    /** Text to be displayed */
+    text?: string;
+    /** Name of font to use for text. Must have been previously loaded */
+    fontName?: string;
+    /** Color of text. Default is Constants.DEFAULT_FONT_COLOR (WebColors.Black) */
+    fontColor?: RgbaColor;
+    /** Size of text. Default is Constants.DEFAULT_FONT_SIZE (16) */
+    fontSize?: number;
+}
+
+/**
+ * Width and height on two-dimensional space
+ */
+interface Size {
+    /** Horizontal width, x-axis */
+    width: number;
+    /** Vertical height, y-axis */
+    height: number;
+}
+
+interface M2NodeOptions {
+    /** Name of the node. Only needed if the node will be referred to by name in a later function */
+    name?: string;
+    /** Position of the node within its parent coordinate system. Default is (0, 0) */
+    position?: Point;
+    /** Scale of the node. Default is 1.0 */
+    scale?: number;
+    /** Opacity of the node. 0 is fully transparent, 1 is fully opaque. Default is 1.0. Alpha has multiplicative inheritance. For example, if the node's parent is alpha .5 and this node's is alpha .4, then the node will appear with alpha .2. */
+    alpha?: number;
+    /** Rotation of the node around the Z axis. Unit is radians. Default is 0 (no rotation). zRotation has inheritance. In addition to this node's zRotation, all ancestors' zRotations will be applied. */
+    zRotation?: number;
+    /** Does the node respond to user events, such as taps? Default is false */
+    isUserInteractionEnabled?: boolean;
+    /** Can the node be dragged? */
+    draggable?: boolean;
+    /** Is the node, and its children, hidden? (not displayed). Default is false */
+    hidden?: boolean;
+    /** FOR INTERNAL USE ONLY */
+    layout?: Layout;
+}
+
+declare enum M2NodeType {
+    Node = "Node",
+    Scene = "Scene",
+    Sprite = "Sprite",
+    Label = "Label",
+    TextLine = "TextLine",
+    Shape = "Shape",
+    Composite = "Composite"
+}
+
+type EasingFunction = (
+/** elapsed time since start of action */
+t: number, 
+/** start value of value to be eased */
+b: number, 
+/** total change of value to be eased */
+c: number, 
+/** total duration of action */
+d: number) => number;
+/**
+ * The Easings class has static methods for creating easings to be used in actions.
+ */
+declare class Easings {
+    static none: EasingFunction;
+    static linear: EasingFunction;
+    static quadraticIn: EasingFunction;
+    static quadraticOut: EasingFunction;
+    static quadraticInOut: EasingFunction;
+    static cubicIn: EasingFunction;
+    static cubicOut: EasingFunction;
+    static cubicInOut: EasingFunction;
+    static quarticIn: EasingFunction;
+    static quarticOut: EasingFunction;
+    static quarticInOut: EasingFunction;
+    static quinticIn: EasingFunction;
+    static quinticOut: EasingFunction;
+    static quinticInOut: EasingFunction;
+    static sinusoidalIn: EasingFunction;
+    static sinusoidalOut: EasingFunction;
+    static sinusoidalInOut: EasingFunction;
+    static exponentialIn: EasingFunction;
+    static exponentialOut: EasingFunction;
+    static exponentialInOut: EasingFunction;
+    static circularIn: EasingFunction;
+    static circularOut: EasingFunction;
+    static circularInOut: EasingFunction;
+}
+
+interface IDrawable {
+    draw(canvas: Canvas): void;
+    warmup(canvas: Canvas): void;
+    /**
+     * Frees up resources allocated by the Drawable M2Node.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @remarks This will be done automatically by the m2c2kit library; the
+     * end-user must not call this.
+     */
+    dispose(): void;
+    anchorPoint: Point;
+    zPosition: number;
+}
+
+interface SceneOptions extends M2NodeOptions, DrawableOptions {
+    /** Background color of the scene. Default is Constants.DEFAULT_SCENE_BACKGROUND_COLOR (WebColors.White) */
+    backgroundColor?: RgbaColor;
+}
+
+interface CallbackOptions {
+    /** Should the provided callback replace any existing callbacks of the same event type for this target? Default is false */
+    replaceExisting?: boolean;
+    /** String identifier used to identify the callback. Only needed if the callback will be removed later */
+    key?: string;
+}
+
+declare class Scene extends M2Node implements IDrawable, SceneOptions {
+    readonly type = M2NodeType.Scene;
+    isDrawable: boolean;
+    anchorPoint: {
+        x: number;
+        y: number;
+    };
+    zPosition: number;
+    private _backgroundColor;
+    _active: boolean;
+    _transitioning: boolean;
+    private backgroundPaint?;
+    /**
+     * Top-level node that holds all other nodes, such as sprites, rectangles, or labels, that will be displayed on the screen
+     *
+     * @remarks The scene is the game screen or stage, and fills the entire available screen. There are usually multiple screens to contain multiple stages of the game, such as various instruction pages or phases of a game.
+     *
+     * @param options - {@link SceneOptions}
+     */
+    constructor(options?: SceneOptions);
+    initialize(): void;
+    dispose(): void;
+    set game(game: Game);
+    /**
+     * The game which this scene is a part of.
+     *
+     * @remarks Throws error if scene is not part of the game object.
+     */
+    get game(): Game;
+    get backgroundColor(): RgbaColor;
+    set backgroundColor(backgroundColor: RgbaColor);
+    /**
+     * Duplicates a node using deep copy.
+     *
+     * @remarks This is a deep recursive clone (node and children).
+     * The uuid property of all duplicated nodes will be newly created,
+     * because uuid must be unique.
+     *
+     * @param newName - optional name of the new, duplicated node. If not
+     * provided, name will be the new uuid
+     */
+    duplicate(newName?: string): Scene;
+    /**
+     * Code that will be called every time the scene is presented.
+     *
+     * @remarks Use this callback to set nodes to their initial state, if
+     * that state might be changed later. For example, if a scene allows
+     * players to place dots on a grid, the setup() method should ensure the
+     * grid is clear of any prior dots from previous times this scene may
+     * have been displayed. In addition, if nodes should vary in each
+     * iteration, that should be done here.
+     *
+     * @param callback - function to execute
+     * @param options - {@link CallbackOptions}
+     */
+    onSetup(callback: (nodeEvent: M2NodeEvent) => void, options?: CallbackOptions): void;
+    /**
+     *
+     * Code that will be called after the scene has finished any transitions
+     * and has fully appeared on the screen.
+     *
+     * @param callback - function to execute
+     * @param options - {@link CallbackOptions}
+     */
+    onAppear(callback: (nodeEvent: M2NodeEvent) => void, options?: CallbackOptions): void;
+    update(): void;
+    draw(canvas: Canvas): void;
+    warmup(canvas: Canvas): void;
+}
+
+interface SlideTransitionOptions {
+    /** Direction in which the slide action goes */
+    direction: TransitionDirection;
+    /** Duration, in milliseconds, of the transition */
+    duration: number;
+    /** Easing function for movement; default is linear */
+    easing?: EasingFunction;
+}
+/**
+ * The Transition class has static methods for creating animations that run as one scene transitions to another.
+ */
+declare abstract class Transition {
+    abstract type: TransitionType;
+    abstract easing: EasingFunction;
+    abstract duration: number;
+    /**
+     * Creates a scene transition in which the outgoing scene slides out and the incoming scene slides in, as if the incoming scene pushes it.
+     *
+     * @param options - {@link SlideTransitionOptions}
+     * @returns
+     */
+    static slide(options: SlideTransitionOptions): SlideTransition;
+    /**
+     * Creates a scene transition with no animation or duration. The next scene is immediately drawn.
+     */
+    static none(): NoneTransition;
+}
+declare class NoneTransition extends Transition {
+    type: TransitionType;
+    easing: EasingFunction;
+    duration: number;
+    constructor();
+}
+declare class SlideTransition extends Transition {
+    type: TransitionType;
+    easing: EasingFunction;
+    duration: number;
+    direction: TransitionDirection;
+    constructor(direction: TransitionDirection, duration: number, easing: EasingFunction);
+}
+declare enum TransitionType {
+    Slide = "Slide",
+    None = "None"
+}
+declare enum TransitionDirection {
+    Up = "Up",
+    Down = "Down",
+    Right = "Right",
+    Left = "Left"
+}
+declare class SceneTransition {
+    scene: Scene;
+    transition: Transition;
+    constructor(scene: Scene, transition: Transition);
+}
+
 /** Base interface for all Activity events. */
-interface ActivityEvent extends EventBase {
+interface ActivityEvent extends M2Event<Activity> {
     target: Activity;
 }
 
@@ -159,420 +564,104 @@ interface IDataStore {
     itemExists(key: string): Promise<boolean>;
 }
 
-declare class LoadedImage {
-    name: string;
-    image: Image;
-    width: number;
-    height: number;
-    constructor(name: string, image: Image, width: number, height: number);
-}
-
-/**
- * Image that can be rendered by a browser from a URL or from a
- * HTML svg tag in string form. Provide either url or svgString, not both.
- */
-interface BrowserImage {
-    /** Name that will be used to refer to the image. Must be unique among all
-     * images within a game */
-    imageName: string;
-    /** Width to scale image to */
-    width: number;
-    /** Height to scale image to */
-    height: number;
-    /** The HTML SVG tag, in string form, that will be rendered and loaded.
-     * Must begin with &#60;svg> and end with &#60;/svg> */
-    svgString?: string;
-    /** URL of image asset (svg, png, jpg) to render and load */
-    url?: string;
-}
-
-interface GameImages {
-    uuid: string;
-    images: Array<BrowserImage>;
-}
-
-declare class LoadedImages {
-    [gameUuid: string]: {
-        [name: string]: LoadedImage;
-    };
-}
-declare class ImageManager {
-    canvasKit?: CanvasKit;
-    private renderedImages;
-    loadedImages: LoadedImages;
-    private _scratchCanvas?;
-    private ctx?;
-    private scale?;
-    private session;
-    constructor(session: Session);
-    /**
-     * Returns a CanvasKit Image that was previously rendered by the ImageManager.
-     *
-     * @remarks Typically, this won't be called directly because a programmer
-     * will use a higher-level abstraction (m2c2kit Sprite).
-     *
-     * @param gameUuid - The game that the image resource is part of
-     * @param imageName - The name given to the rendered image
-     * @returns A CanvasKit Image
-     */
-    getLoadedImage(gameUuid: string, imageName: string): LoadedImage;
-    /**
-     * Adds a CanvasKit Image to the images available to a given game.
-     *
-     * @remarks Typically, a programmer won't call this because images will be
-     * automatically rendered and loaded in the Activity async init.
-     * The only time this function is called in-game is when our internal
-     * methods add screenshot images needed for transitions.
-     *
-     * @param loadedImage - An image that has been converted to a CanvasKit Image
-     * @param gameUuid - The game that the Image is part of
-     */
-    addLoadedImage(loadedImage: LoadedImage, gameUuid: string): void;
-    /**
-     * Renders game images from their original format (png, jpg, svg) to
-     * CanvasKit Image.
-     *
-     * @remarks Typically, a programmer won't call this because the Session
-     * object will manage this. Rendering is an async activity, and thus
-     * this method returns a promise. Rendering of all images is done in
-     * parallel.
-     *
-     * @param allGamesImages - An array of GameImages data structures that
-     * specify the image's desired size, it's name, and where the image to be
-     * rendered is located (e.g., embedded svgString or url)
-     * @returns A promise that completes when all game images have rendered
-     */
-    renderImages(allGamesImages: Array<GameImages>): Promise<void[]>;
-    /**
-     * Adds all rendered CanvasKit Images to the images available to m2c2kit.
-     *
-     * @remarks Typically, a programmer won't call this because the Session
-     * object will manage this.
-     */
-    loadAllGamesRenderedImages(): void;
-    /**
-     * Our private method rendering an image to a CanvasKit Image
-     *
-     * @remarks This is complex because there is a separate flow to render
-     * svg images versus other (e.g., jpg, png). Svg images may be provided
-     * in a url or inline. In addition, there is a Firefox svg rendering issue,
-     * see below, that must be handled.
-     * Additional complexity comes from the potentially multiple async steps and
-     * the multiple errors that can happen throughout.
-     *
-     * @param gameUuid
-     * @param browserImage
-     * @returns A promise of type void
-     */
-    private renderBrowserImage;
-    private arrayBufferToBase64String;
-    private inferImageSubtypeFromUrl;
-    private convertRenderedDataUrlImageToCanvasKitImage;
-    /**
-     * Returns the scratchCanvas, which is an extra, non-visible canvas in the
-     * DOM we use so the native browser can render images like svg, png, jpg,
-     * that we later will convert to CanvasKit Image.
-     */
-    private get scratchCanvas();
-    private dataURLtoArrayBuffer;
-    removeScratchCanvas(): void;
-}
-
-interface FontData {
-    gameUuid: string;
-    fontUrl: string;
-    fontName: string;
-    fontFamilyName: string;
-    fontArrayBuffer: ArrayBuffer;
-    isDefault: boolean;
-}
-
-type EasingFunction = (
-/** elapsed time since start of action */
-t: number, 
-/** start value of value to be eased */
-b: number, 
-/** total change of value to be eased */
-c: number, 
-/** total duration of action */
-d: number) => number;
-/**
- * The Easings class has static methods for creating easings to be used in actions.
- */
-declare class Easings {
-    static none: EasingFunction;
-    static linear: EasingFunction;
-    static quadraticIn: EasingFunction;
-    static quadraticOut: EasingFunction;
-    static quadraticInOut: EasingFunction;
-    static cubicIn: EasingFunction;
-    static cubicOut: EasingFunction;
-    static cubicInOut: EasingFunction;
-    static quarticIn: EasingFunction;
-    static quarticOut: EasingFunction;
-    static quarticInOut: EasingFunction;
-    static quinticIn: EasingFunction;
-    static quinticOut: EasingFunction;
-    static quinticInOut: EasingFunction;
-    static sinusoidalIn: EasingFunction;
-    static sinusoidalOut: EasingFunction;
-    static sinusoidalInOut: EasingFunction;
-    static exponentialIn: EasingFunction;
-    static exponentialOut: EasingFunction;
-    static exponentialInOut: EasingFunction;
-    static circularIn: EasingFunction;
-    static circularOut: EasingFunction;
-    static circularInOut: EasingFunction;
-}
-
-/**
- * Position in two-dimensional space.
- */
-interface Point {
-    /** Horizontal coordinate */
-    x: number;
-    /** Vertical coordinate */
-    y: number;
-}
-
-interface IDrawable {
-    draw(canvas: Canvas): void;
-    warmup(canvas: Canvas): void;
-    /**
-     * Frees up resources that were allocated for this drawable entity.
-     *
-     * @remarks This will be done automatically by the m2c2kit library;
-     * the end-user must not call this.
-     */
-    dispose(): void;
-    anchorPoint: Point;
-    zPosition: number;
-}
-
-declare enum EntityType {
-    Entity = "Entity",
-    Scene = "Scene",
-    Sprite = "Sprite",
-    Label = "Label",
-    TextLine = "TextLine",
-    Shape = "Shape",
-    Composite = "Composite"
-}
-
-/**
- * Color in red (0-255), green (0-255), blue (0-255), alpha (0-1) format. Must be numeric array of length 4.
- */
-type RgbaColor = [number, number, number, number];
-
-interface DrawableOptions {
-    /** Point within the entity that determines its position. Default is &#123; x: 0.5, y: 0.5 &#125;, which centers the entity on its position */
-    anchorPoint?: Point;
-    /** Value along the z-axis to determine drawing and tap order. Larger values are on top. */
-    zPosition?: number;
-}
-
-/**
- * Constraints for defining relative layouts.
- *
- * @remarks FOR INTERNAL USE ONLY
- */
-interface Constraints {
-    /** Constrain the top (vertical axis) of this entity to the top of the specified entity. The tops of both will appear at the same vertical location */
-    topToTopOf?: Entity | string;
-    /** Constrain the top (vertical axis) of this entity to the bottom of the specified entity. This entity will appear immediately below the specified entity */
-    topToBottomOf?: Entity | string;
-    /** Constrain the bottom (vertical axis) of this entity to the top of the specified entity. This entity will appear immediately above of the specified entity */
-    bottomToTopOf?: Entity | string;
-    /** Constrain the bottom (vertical axis) of this entity to the bottom of the specified entity. The bottoms of both will appear at the same vertical location */
-    bottomToBottomOf?: Entity | string;
-    /** Constrain the start (horizontal axis) of this entity to the start of the specified entity. The start of both will appear at the same horizontal location */
-    startToStartOf?: Entity | string;
-    /** Constrain the start (horizontal axis) of this entity to the end of the specified entity. This entity will appear immediately to the right of the specified entity */
-    startToEndOf?: Entity | string;
-    /** Constrain the end (horizontal axis) of this entity to the end of the specified entity. The end of both will appear at the same horizontal location */
-    endToEndOf?: Entity | string;
-    /** Constrain the end (horizontal axis) of this entity to the start of the specified entity. This entity will appear immediately to the left of the specified entity */
-    endToStartOf?: Entity | string;
-    /** When opposing horizontal constraints are applied, the default is to center the entity within the constraints (horizontalBias = .5). Setting horizontalBias less than .5 will pull the entity towards the start (to the left). Setting horizontalBias greater than .5 will pull the entity towards the end (to the right)  */
-    horizontalBias?: number;
-    /** When opposing vertical constraints are applied, the default is to center the entity within the constraints (verticalBias = .5). Setting verticalBias less than .5 will pull the entity towards the top. Setting verticalBias greater than .5 will pull the entity towards the bottom */
-    verticalBias?: number;
-    [key: string]: Entity | string | number | undefined;
-}
-
-/**
- * The Layout allows relative positioning via constraints.
- * This is not fully implemented yet: DO NOT USE!
- * We use it internally for instructions.
- */
-interface Layout {
-    height?: number;
-    width?: number;
-    marginStart?: number;
-    marginEnd?: number;
-    marginTop?: number;
-    marginBottom?: number;
-    constraints?: Constraints;
-}
-
-interface EntityOptions {
-    /** Name of the entity. Only needed if the entity will be referred to by name in a later function */
-    name?: string;
-    /** Position of the entity within its parent coordinate system. Default is (0, 0) */
-    position?: Point;
-    /** Scale of the entity. Default is 1.0 */
-    scale?: number;
-    /** Opacity of the entity. 0 is fully transparent, 1 is fully opaque. Default is 1.0. Alpha has multiplicative inheritance. For example, if the entity's parent is alpha .5 and this entity's is alpha .4, then the entity will appear with alpha .2. */
-    alpha?: number;
-    /** Rotation of the entity around the Z axis. Unit is radians. Default is 0 (no rotation). zRotation has inheritance. In addition to this entity's zRotation, all ancestors' zRotations will be applied. */
-    zRotation?: number;
-    /** Does the entity respond to user events, such as taps? Default is false */
-    isUserInteractionEnabled?: boolean;
-    /** Can the entity be dragged? */
-    draggable?: boolean;
-    /** Is the entity, and its children, hidden? (not displayed). Default is false */
-    hidden?: boolean;
-    /** FOR INTERNAL USE ONLY */
-    layout?: Layout;
-}
-
-interface SceneOptions extends EntityOptions, DrawableOptions {
-    /** Background color of the scene. Default is Constants.DEFAULT_SCENE_BACKGROUND_COLOR (WebColors.White) */
-    backgroundColor?: RgbaColor;
-}
-
-declare class Scene extends Entity implements IDrawable, SceneOptions {
-    readonly type = EntityType.Scene;
-    isDrawable: boolean;
-    anchorPoint: {
-        x: number;
-        y: number;
-    };
-    zPosition: number;
-    private _backgroundColor;
-    _active: boolean;
-    _transitioning: boolean;
-    _setupCallback?: (scene: Scene) => void;
-    _appearCallback?: (scene: Scene) => void;
-    private backgroundPaint?;
-    /**
-     * Top-level entity that holds all other entities, such as sprites, rectangles, or labels, that will be displayed on the screen
-     *
-     * @remarks The scene is the game screen or stage, and fills the entire available screen. There are usually multiple screens to contain multiple stages of the game, such as various instruction pages or phases of a game.
-     *
-     * @param options - {@link SceneOptions}
-     */
-    constructor(options?: SceneOptions);
-    initialize(): void;
-    dispose(): void;
-    set game(game: Game);
+interface Activity {
+    /** The type of activity: Game or Survey */
+    type: ActivityType;
     /**
-     * The game which this scene is a part of.
+     * Initializes the activity.
      *
-     * @remarks Throws error if scene is not part of the game object.
+     * @remarks All code to create the activity's appearance and behavior must
+     * be placed in this method. This method is asynchronous, and must be
+     * awaited. When writing a new game by extending the `Game` class, this
+     * method will be overridden, but the base method must still be called with
+     * `await super.initialize()`.
      */
-    get game(): Game;
-    get backgroundColor(): RgbaColor;
-    set backgroundColor(backgroundColor: RgbaColor);
+    initialize(): Promise<void>;
     /**
-     * Duplicates an entity using deep copy.
+     * Initializes the activity.
      *
-     * @remarks This is a deep recursive clone (entity and children).
-     * The uuid property of all duplicated entities will be newly created,
-     * because uuid must be unique.
+     * @remarks All code to create the activity's appearance and behavior must
+     * be placed in this method. This method is asynchronous, and must be
+     * awaited. When writing a new game by extending the `Game` class, this
+     * method will be overridden, but the base method must still be called with
+     * `await super.init()`.
      *
-     * @param newName - optional name of the new, duplicated entity. If not
-     * provided, name will be the new uuid
+     * @deprecated use Game.initialize() instead.
      */
-    duplicate(newName?: string): Scene;
-    /**
-     * Code that will be called every time the scene is presented.
-     *
-     * @remarks Use this callback to set entities to their initial state, if
-     * that state might be changed later. For example, if a scene allows
-     * players to place dots on a grid, the setup() method should ensure the
-     * grid is clear of any prior dots from previous times this scene may
-     * have been displayed. In addition, if entities should vary in each
-     * iteration, that should be done here.
+    init(): Promise<void>;
+    /** Starts the activity */
+    start(): Promise<void>;
+    /** Stops the activity */
+    stop(): void;
+    /**
+     * Executes a callback when the activity starts.
      *
-     * @param callback
+     * @param callback - function to execute.
+     * @param options - options for the callback.
      */
-    onSetup(callback: (scene: Scene) => void): void;
+    onStart(callback: (activityLifecycleEvent: ActivityLifecycleEvent) => void, options?: CallbackOptions): void;
     /**
+     * Executes a callback when the activity is canceled.
      *
-     * Code that will be called after the scene has finished any transitions
-     * and has fully appeared on the screen.
-     *
-     * @param callback
+     * @param callback - function to execute.
+     * @param options - options for the callback.
      */
-    onAppear(callback: (scene: Scene) => void): void;
-    update(): void;
-    draw(canvas: Canvas): void;
-    warmup(canvas: Canvas): void;
-}
-
-interface SlideTransitionOptions {
-    /** Direction in which the slide action goes */
-    direction: TransitionDirection;
-    /** Duration, in milliseconds, of the transition */
-    duration: number;
-    /** Easing function for movement; default is linear */
-    easing?: EasingFunction;
-}
-/**
- * The Transition class has static methods for creating animations that run as one scene transitions to another.
- */
-declare abstract class Transition {
-    abstract type: TransitionType;
-    abstract easing: EasingFunction;
-    abstract duration: number;
+    onCancel(callback: (activityLifecycleEvent: ActivityLifecycleEvent) => void, options?: CallbackOptions): void;
     /**
-     * Creates a scene transition in which the outgoing scene slides out and the incoming scene slides in, as if the incoming scene pushes it.
+     * Executes a callback when the activity ends.
      *
-     * @param options - {@link SlideTransitionOptions}
-     * @returns
+     * @param callback - function to execute.
+     * @param options - options for the callback.
      */
-    static slide(options: SlideTransitionOptions): SlideTransition;
+    onEnd(callback: (activityLifecycleEvent: ActivityLifecycleEvent) => void, options?: CallbackOptions): void;
     /**
-     * Creates a scene transition with no animation or duration. The next scene is immediately drawn.
+     * Executes a callback when the activity generates data.
+     *
+     * @param callback - function to execute.
+     * @param options - options for the callback.
      */
-    static none(): NoneTransition;
-}
-declare class NoneTransition extends Transition {
-    type: TransitionType;
-    easing: EasingFunction;
-    duration: number;
-    constructor();
-}
-declare class SlideTransition extends Transition {
-    type: TransitionType;
-    easing: EasingFunction;
-    duration: number;
-    direction: TransitionDirection;
-    constructor(direction: TransitionDirection, duration: number, easing: EasingFunction);
-}
-declare enum TransitionType {
-    Slide = "Slide",
-    None = "None"
-}
-declare enum TransitionDirection {
-    Up = "Up",
-    Down = "Down",
-    Right = "Right",
-    Left = "Left"
-}
-declare class SceneTransition {
-    scene: Scene;
-    transition: Transition;
-    constructor(scene: Scene, transition: Transition);
+    onData(callback: (activityResultsEvent: ActivityResultsEvent) => void, options?: CallbackOptions): void;
+    /** The activity's parent session unique identifier. */
+    sessionUuid: string;
+    /** The activity's unique identifier. NOTE: This is newly generated each session. The uuid for an activity will vary across sessions. */
+    uuid: string;
+    /** Human-friendly name of this activity */
+    name: string;
+    /** Short identifier of this activity */
+    id: string;
+    /** The value of performance.now() immediately before the activity begins */
+    beginTimestamp: number;
+    /** The value of new Date().toISOString() immediately before the activity begins */
+    beginIso8601Timestamp: string;
+    /** Sets additional activity parameters if defaults are not sufficient. */
+    setParameters(additionalParameters: unknown): void;
+    /** Additional activity parameters that were set. */
+    readonly additionalParameters?: unknown;
+    /** Optional stores to use for saving data. The implementation of the store is not provided by the \@m2c2kit/core library. */
+    dataStores?: IDataStore[];
 }
 
-/** Base interface for all Entity events. */
-interface EntityEvent extends EventBase {
-    /** The Entity on which the event occurred. */
-    target: Entity;
-    /** For composites that raise events, type of the composite custom event. */
-    compositeType?: string;
+/**
+ * Image that can be rendered by a browser from a URL or from a
+ * HTML svg tag in string form. Provide either url or svgString, not both.
+ */
+interface BrowserImage {
+    /** Name that will be used to refer to the image. Must be unique among all
+     * images within a game */
+    imageName: string;
+    /** Width to scale image to */
+    width: number;
+    /** Height to scale image to */
+    height: number;
+    /** The HTML SVG tag, in string form, that will be rendered and loaded.
+     * Must begin with &#60;svg> and end with &#60;/svg> */
+    svgString?: string;
+    /** URL of image asset (svg, png, jpg) to render and load */
+    url?: string;
+    /** If true, the image will not be fully loaded until it is needed. Default
+     * is false. Lazy loading is useful for localized images or large "banks"
+     * of images. These should be lazy loaded because they may not be needed. */
+    lazy?: boolean;
 }
 
 /**
@@ -621,6 +710,19 @@ interface Translations {
     };
 }
 
+/**
+ * Font url and raw data that has been shared with other games in the session.
+ *
+ * @remarks Font sharing will happen only if the font filename is the same AND
+ * a game's `shareAssets` property is not false.
+ */
+interface SharedFont {
+    /** url that the shared font was loaded from */
+    url: string;
+    /** raw data of the shared font */
+    data: ArrayBuffer;
+}
+
 /**
  * Font asset to use in the game.
  */
@@ -629,6 +731,27 @@ interface FontAsset {
     fontName: string;
     /** URL of font (TrueType font) to load */
     url: string;
+    /** If true, the font will not be fully loaded until it is needed. Default
+     * is false. Lazy loading is useful for fonts involved in localization.
+     * These should be lazy loaded because they may not be needed.
+     */
+    lazy?: boolean;
+    /** Font url and raw data that has been shared with other games in the session. Undefined if this font was not shared. @internal For m2c2kit library use only */
+    sharedFont?: SharedFont;
+}
+
+/**
+ * Game's module name, version, and dependencies.
+ */
+interface ModuleMetadata {
+    /** name property from package.json */
+    name: string;
+    /** version property from package.json */
+    version: string;
+    /** dependency property from package.json */
+    dependencies: {
+        [key: string]: string;
+    };
 }
 
 /**
@@ -671,16 +794,16 @@ interface GameOptions {
     maximumRecordedActivityMetrics?: number;
     /** The FPS will be logged in game metrics if the FPS is lower than this value. Default is 59, as defined in Constants.FPS_METRIC_REPORT_THRESHOLD */
     fpsMetricReportThreshold?: number;
-    /** Adapt execution for unit testing? Default is false */
-    _unitTesting?: boolean;
     /** Advance through time step-by-step, for development and debugging */
     timeStepping?: boolean;
     /** Translations for localization. */
     translations?: Translations;
     /** Show logs for WebGl activity? */
     logWebGl?: boolean;
-    /** URL of game assets folder, if not the default location of "assets/id of game from GameOptions" */
-    assetsUrl?: string;
+    /** Should games within a session share wasm and font assets that have identical filenames, in order to reduce bandwidth? Default is true. */
+    shareAssets?: boolean;
+    /** Game's module name, version, and dependencies. @internal For m2c2kit library use only */
+    moduleMetadata?: ModuleMetadata;
 }
 
 interface GameData extends ActivityKeyValueData {
@@ -718,20 +841,286 @@ declare class I18n {
     private mergeAdditionalTranslations;
 }
 
-interface CallbackOptions {
-    /** Should the provided callback replace any existing callbacks of the same event type for this target? Default is false */
-    replaceExisting?: boolean;
-    /** String identifier used to identify the callback. Only needed if the callback will be removed later */
-    key?: string;
+/**
+ * A Plugin is code that can be registered to run at certain points in the game loop.
+ */
+interface Plugin {
+    /** Short identifier of the plugin. */
+    id: string;
+    /** What kind of m2c2kit object does the plugin work with? */
+    type: "Game" | "Session" | "Survey";
+    /** Initialization code run when the plugin is registered with the game. */
+    initialize?: (game: Game) => Promise<void>;
+    /** Is the plugin disabled and not to be run? Default is false. @remarks Disabled plugins will still be initialized. */
+    disabled?: boolean;
+    /** Plugin code run before the frame update, but before the frame draw. */
+    beforeUpdate?: (game: Game, deltaTime: number) => void;
+    /** Plugin code run after the frame update, but before the frame draw. */
+    afterUpdate?: (game: Game, deltaTime: number) => void;
+}
+
+interface M2Font {
+    fontName: string;
+    typeface: Typeface | undefined;
+    data: ArrayBuffer | undefined;
+    url: string;
+    status: M2FontStatus;
+    default: boolean;
+}
+declare const M2FontStatus: {
+    /** Font was set for lazy loading, and loading has not yet been requested. */
+    readonly Deferred: "Deferred";
+    /** Font is in the process of loading. */
+    readonly Loading: "Loading";
+    /** Font has fully finished loading and is ready to use. */
+    readonly Ready: "Ready";
+    /** Error occurred in loading. */
+    readonly Error: "Error";
+};
+type M2FontStatus = (typeof M2FontStatus)[keyof typeof M2FontStatus];
+
+/**
+ * Base URLs for game resources.
+ */
+interface GameBaseUrls {
+    /** Base URL for fonts and images. */
+    assets: string;
+    /** Base URL for CanvasKit wasm binary. */
+    canvasKitWasm: string;
+}
+
+/**
+ * Fetches, loads, and provides fonts to the game.
+ *
+ * @internal For m2c2kit library use only
+ */
+declare class FontManager {
+    fonts: Record<string, M2Font>;
+    provider: TypefaceFontProvider;
+    private canvasKit;
+    private game;
+    private baseUrls;
+    constructor(game: Game, baseUrls: GameBaseUrls);
+    /**
+     * Loads font assets and makes them ready to use during the game initialization.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @remarks Typically, a user won't call this because the m2c2kit
+     * framework will call this automatically.
+     *
+     * @param fonts - array of FontAsset objects (name and url)
+     */
+    initializeFonts(fonts: Array<FontAsset> | undefined): Promise<void>;
+    /**
+     * Loads an array of fonts and makes them ready for the game.
+     *
+     * @param fonts - an array of {@link FontAsset}
+     * @returns A promise that completes when all fonts have loaded
+     */
+    loadFonts(fonts: Array<FontAsset>): Promise<void>;
+    private prepareFont;
+    /**
+     * Makes ready to the game a m2c2kit font ({@link M2Font}) that was
+     * previously loaded, but whose processing was deferred.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @param font - M2Font to make ready
+     * @returns A promise that completes when the font is ready
+     */
+    prepareDeferredFont(font: M2Font): Promise<void>;
+    private fetchFontAsArrayBuffer;
+    private registerFont;
+    /**
+     * Returns a m2c2kit font ({@link M2Font}) that has been loaded by the
+     * FontManager.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @remarks Typically, a user won't need to call this because font
+     * initialization and processing is handled by the framework.
+     *
+     * @param fontName - font's name as defined in the game's font assets
+     * @returns a m2c2kit font
+     */
+    getFont(fontName: string): M2Font;
+    /**
+     * Returns the m2c2kit default font ({@link M2Font}) that has been loaded
+     * by the FontManager.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @remarks Typically, a user won't need to call this because font
+     * initialization and processing is handled by the framework.
+     *
+     * @returns a m2c2kit font
+     */
+    getDefaultFont(): M2Font;
+    /**
+     * Frees up resources allocated by the FontManager.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @remarks This will be done automatically by the m2c2kit library; the
+     * end-user must not call this.
+     */
+    dispose(): void;
+    /**
+     * Gets a CanvasKit Typeface that has been loaded.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @remarks Typically, a user won't need to call this because font
+     * initialization and processing is handled by the framework.
+     *
+     * @param fontName - name as defined in the game's font assets
+     * @returns the requested Typeface
+     */
+    getTypeface(fontName: string): Typeface;
+    /**
+     * Gets names of fonts loaded.
+     *
+     * @returns array of font names loaded from the game's font assets and
+     * converted into M2Font objects. The names are the names as defined
+     * in the game's font assets.
+     */
+    getFontNames(): Array<string>;
+}
+
+/**
+ * An image that has been loaded into the game.
+ *
+ * @remarks An M2Image is a wrapper around a CanvasKit Image, with some
+ * additional properties.
+ */
+interface M2Image {
+    imageName: string;
+    canvaskitImage: Image | undefined;
+    width: number;
+    height: number;
+    status: M2ImageStatus;
+    url?: string;
+    svgString?: string;
 }
+declare const M2ImageStatus: {
+    /** Image was set for lazy loading, and loading has not yet been requested. */
+    readonly Deferred: "Deferred";
+    /** Image is in the process of loading (fetching, rendering, and conversion to CanvasKit Image). */
+    readonly Loading: "Loading";
+    /** Image has fully finished loading and is ready to use. */
+    readonly Ready: "Ready";
+    /** Error occurred in loading. */
+    readonly Error: "Error";
+};
+type M2ImageStatus = (typeof M2ImageStatus)[keyof typeof M2ImageStatus];
 
 /**
- * Notifies when events in the Frame cycle occur on a Game.
+ * Fetches, loads, and provides images to the game.
  */
-interface FrameCycleEvent extends EventBase {
+declare class ImageManager {
+    images: Record<string, M2Image>;
+    private canvasKit;
+    private _scratchCanvas?;
+    private ctx?;
+    private scale?;
+    private game;
+    private baseUrls;
+    constructor(game: Game, baseUrls: GameBaseUrls);
+    /**
+     * Loads image assets and makes them ready to use during the game initialization.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @remarks Typically, a user won't call this because the m2c2kit
+     * framework will call this automatically.
+     *
+     * @param browserImages - array of BrowserImage objects
+     * @returns A promise that completes when all images have loaded
+     */
+    initializeImages(browserImages: Array<BrowserImage> | undefined): Promise<void>;
+    /**
+     * Loads an array of images and makes them ready for the game.
+     *
+     * @remarks Using the browser's image rendering, this method converts the
+     * images (png, jpg, svg, or svg string) into m2c2kit images ({@link M2Image}).
+     * Rendering is an async activity, and thus this method returns a promise.
+     * Rendering of all images is done in parallel.
+     *
+     * @param browserImages - an array of {@link BrowserImage}
+     * @returns A promise that completes when all images have loaded
+     */
+    loadImages(browserImages: Array<BrowserImage>): Promise<void>;
+    private checkImageNamesForDuplicates;
+    /**
+     * Makes ready to the game a m2c2kit image ({@link M2Image}) that was
+     * previously loaded, but whose browser rendering was deferred.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @param image - M2Image to render and make ready
+     * @returns A promise that completes when the image is ready
+     */
+    prepareDeferredImage(image: M2Image): Promise<void>;
+    /**
+     * Uses the browser to render an image to a CanvasKit Image and make it
+     * ready to the game as an M2Image.
+     *
+     * @remarks This is complex because we rely on the browser's rendering
+     * and HTML image element processing. This involves a number of steps,
+     * including events, callbacks, and error handling. In addition, there
+     * are two types of images to be rendered: 1) url to an image (e.g., jpg,
+     * png, svg), and 2) svg string.
+     *
+     * @param image - The M2Image to render
+     * @returns A promise of type void that resolves when the image has been
+     * rendered
+     */
+    private renderM2Image;
+    private arrayBufferToBase64Async;
+    private inferImageSubtypeFromUrl;
+    /**
+     * Returns a m2c2kit image ({@link M2Image}) that has been loaded by the ImageManager.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @remarks Typically, a user won't call this because they use a higher-level
+     * abstraction (m2c2kit Sprite).
+     *
+     * @param imageName - The name given to the previously rendered image
+     * @returns A m2c2kit image
+     */
+    getImage(imageName: string): M2Image;
+    /**
+     * Adds a m2c2kit image ({@link M2Image}) to the images ready for the game.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @remarks Typically, a programmer won't call this because images will be
+     * automatically rendered and loaded in initializeImages().
+     * One reason this function is called in-game is when the game takes
+     * a screenshot and adds it as an outgoing image for transitions.
+     *
+     * @param image - A m2c2kit image
+     */
+    addImage(image: M2Image): void;
+    /**
+     * Returns the scratchCanvas, which is an extra, non-visible canvas in the
+     * DOM we use so the native browser can render images like svg, png, jpg,
+     * that we later will convert to CanvasKit Image.
+     */
+    private get scratchCanvas();
+    private removeScratchCanvas;
+}
+
+/** Key value pairs of file URLs and hashed file URLs */
+type Manifest = {
+    [originalUrl: string]: string;
+};
+
+/** Base interface for all Game events. */
+interface GameEvent extends M2Event<Activity> {
     target: Game;
-    /** difference in milliseconds since the last Frame lifecycle began */
-    deltaTime: number;
 }
 
 interface TrialData {
@@ -740,10 +1129,12 @@ interface TrialData {
 declare class Game implements Activity {
     readonly type = ActivityType.Game;
     _canvasKit?: CanvasKit;
-    _session?: Session;
+    sessionUuid: string;
     uuid: string;
     name: string;
     id: string;
+    moduleMetadata: ModuleMetadata;
+    readonly canvasKitWasmVersion = "__CANVASKITWASM_VERSION__";
     options: GameOptions;
     beginTimestamp: number;
     beginIso8601Timestamp: string;
@@ -755,21 +1146,65 @@ declare class Game implements Activity {
     private steppingNow;
     i18n?: I18n;
     private warmupFunctionQueue;
-    private loaderElementsRemoved;
+    private warmupFinished;
     private _dataStores?;
+    private plugins;
     additionalParameters?: unknown;
     staticTrialSchema: {
         [key: string]: JsonSchemaDataTypeScriptTypes;
     };
+    private _fontManager?;
+    private _imageManager?;
+    manifest?: Manifest;
     /**
      * The base class for all games. New games should extend this class.
      *
      * @param options - {@link GameOptions}
      */
     constructor(options: GameOptions);
+    private getImportedModuleBaseUrl;
     private addLocalizationParametersToGameParameters;
     init(): Promise<void>;
+    /**
+     * Loads the canvaskit wasm binary.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @remarks The CanvasKit object is initialized with this method, rather
+     * than calling `CanvasKitInit()` directly, so that this method can be
+     * easily mocked in tests.
+     *
+     * @param canvasKitWasmUrl - URL to the canvaskit wasm binary
+     * @returns a promise that resolves to a CanvasKit object
+     */
+    loadCanvasKit(canvasKitWasmUrl: string): Promise<CanvasKit>;
+    /**
+     * Resolves base URL locations for game assets and CanvasKit wasm binary.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @param game - game to resolve base URLs for
+     * @returns base URLs for game assets and CanvasKit wasm binary
+     */
+    resolveGameBaseUrls(game: Game): Promise<GameBaseUrls>;
     initialize(): Promise<void>;
+    /**
+     * Returns the manifest, if manifest.json was created during the build.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @remarks This should be called without any parameters. The
+     * `manifestJsonUrl` parameter's default value will be modified during the
+     * build step, if the build was configured to include the manifest.json
+     *
+     * @param manifestJsonUrl - Do not use this parameter. Allow the default.
+     * @returns a promise that resolves to the manifest object, or an empty object if there is no manifest
+     */
+    loadManifest(manifestJsonUrl?: string): Promise<Manifest>;
+    get fontManager(): FontManager;
+    set fontManager(fontManager: FontManager);
+    get imageManager(): ImageManager;
+    set imageManager(imageManager: ImageManager);
     /**
      * Saves an item to the activity's key-value store.
      *
@@ -878,8 +1313,6 @@ declare class Game implements Activity {
     setParameters(additionalParameters: unknown): void;
     get canvasKit(): CanvasKit;
     set canvasKit(canvasKit: CanvasKit);
-    get session(): Session;
-    set session(session: Session);
     /** The scene, or its name as a string, to be presented when the game is started. If this is undefined, the game will start with the first scene that has been added */
     entryScene?: Scene | string;
     data: GameData;
@@ -899,54 +1332,69 @@ declare class Game implements Activity {
     private fpsRate;
     private animationFramesRequested;
     private limitFps;
-    private unitTesting;
     private gameStopRequested;
     private webGlRendererInfo;
     canvasCssWidth: number;
     canvasCssHeight: number;
     scenes: Scene[];
-    private freeEntitiesScene;
+    private freeNodesScene;
     private incomingSceneTransitions;
     private currentSceneSnapshot?;
     private pendingScreenshot?;
     /**
-     * Adds an entity as a free entity (an entity that is not part of a scene)
+     * Adds a node as a free node (a node that is not part of a scene)
      * to the game.
      *
-     * @remarks Once added to the game, a free entity will always be drawn,
+     * @remarks Once added to the game, a free node will always be drawn,
      * and it will not be part of any scene transitions. This is useful if
-     * an entity must persistently be drawn and not move with scene
-     * transitions. The appearance of the free entity must be managed
-     * by the programmer. Note: internally, the free entities are part of a
-     * special scene (named "__freeEntitiesScene"), but this scene is handled
-     * apart from regular scenes in order to achieve the free entity behavior.
+     * a node must persistently be drawn and not move with scene
+     * transitions. The appearance of the free node must be managed
+     * by the programmer. Note: internally, the free nodes are part of a
+     * special scene (named "__freeNodesScene"), but this scene is handled
+     * apart from regular scenes in order to achieve the free node behavior.
      *
-     * @param entity - entity to add as a free entity
+     * @param node - node to add as a free node
+     */
+    addFreeNode(node: M2Node): void;
+    /**
+     * @deprecated Use addFreeNode() instead
      */
-    addFreeEntity(entity: Entity): void;
+    addFreeEntity(node: M2Node): void;
     /**
-     * Removes a free entity from the game.
+     * Removes a free node from the game.
      *
-     * @remarks Throws exception if the entity to remove is not currently added
-     * to the game as a free entity
+     * @remarks Throws exception if the node to remove is not currently added
+     * to the game as a free node
      *
-     * @param entity - the free entity to remove or its name as a string
+     * @param node - the free node to remove or its name as a string
+     */
+    removeFreeNode(node: M2Node | string): void;
+    /**
+     * @deprecated Use removeFreeNode() instead
+     */
+    removeFreeEntity(node: M2Node | string): void;
+    /**
+     * Removes all free nodes from the game.
      */
-    removeFreeEntity(entity: Entity | string): void;
+    removeAllFreeNodes(): void;
     /**
-     * Removes all free entities from the game.
+     * @deprecated Use removeAllFreeNodes() instead
      */
     removeAllFreeEntities(): void;
     /**
-     * Returns array of free entities that have been added to the game.
+     * Returns array of free nodes that have been added to the game.
      *
-     * @returns array of free entities
+     * @returns array of free nodes
+     */
+    get freeNodes(): Array<M2Node>;
+    /**
+     * @deprecated Use Game.freeEntities instead
      */
-    get freeEntities(): Array<Entity>;
+    get freeEntities(): Array<M2Node>;
     /**
      * Adds a scene to the game.
      *
-     * @remarks A scene, and its children entities, cannot be presented unless it has been added to the game object.
+     * @remarks A scene, and its children nodes, cannot be presented unless it has been added to the game object.
      *
      * @param scene
      */
@@ -983,7 +1431,7 @@ declare class Game implements Activity {
      * is not found, then return fallback value
      *
      * @param parameterName - the name of the game parameter whose value is requested
-     * @param fallback - the value to return if parameterName is not found
+     * @param fallbackValue - the value to return if parameterName is not found
      * @returns
      */
     getParameterOrFallback<T, U>(parameterName: string, fallbackValue: U): T | U;
@@ -1035,12 +1483,12 @@ declare class Game implements Activity {
     private warmupShadersWithPrimitives;
     /**
      * Warms up the Skia-based shaders underlying canvaskit by drawing
-     * m2c2kit entities.
+     * m2c2kit nodes.
      *
      * @remarks While warmupShadersWithPrimitives draws a predefined set of
      * primitives, this function initializes and draws all canvaskit objects
-     * that have been defined as m2c2kit entities. This not only is another
-     * opportunity for shader warmup, it also does the entity initialization.
+     * that have been defined as m2c2kit nodes. This not only is another
+     * opportunity for shader warmup, it also does the node initialization.
      *
      * @param canvas - the canvaskit-canvas to draw on
      */
@@ -1049,8 +1497,8 @@ declare class Game implements Activity {
     /**
      * Frees up resources that were allocated to run the game.
      *
-     * @remarks This will be done automatically by the m2c2kit library;
-     * the end-user must not call this.
+     * @remarks This will be done automatically by the m2c2kit library; the
+     * end-user must not call this. FOR INTERNAL USE ONLY.
      */
     dispose(): void;
     private initData;
@@ -1095,683 +1543,226 @@ declare class Game implements Activity {
      *       type: "string",
      *       description: "ID of the participant",
      *     &#125;
-     *   &#125;);
-     *   game.addStaticTrialData("participant_id", "12345");
-     *
-     *  When Game.trialComplete() is called, the participant_id variable will
-     *  be saved for the trial with the value "12345".
-     *
-     * @param variableName - variable to be set
-     * @param value - value of the variable to set
-     */
-    addStaticTrialData(variableName: string, value: JsonSchemaDataTypeScriptTypes): void;
-    /**
-     * Should be called when the current trial has completed. It will
-     * also increment the trial index.
-     *
-     * @remarks Calling will trigger the onActivityResults callback function,
-     * if one was provided in SessionOptions. This is how the game communicates
-     * trial data to the parent session, which can then save or process the data.
-     * It is the responsibility of the the game programmer to call this at
-     * the appropriate time. It is not triggered automatically.
-     */
-    trialComplete(): void;
-    /**
-     * The m2c2kit engine will automatically include these schema and their
-     * values in the trial data.
-     */
-    private readonly automaticTrialSchema;
-    private makeNewGameDataSchema;
-    private makeGameDataSchema;
-    /**
-     * GameParameters combines default parameters values and
-     * JSON Schema to describe what the parameters are.
-     * The next two functions extract GameParameters's two parts
-     * (the default values and the schema) so they can be returned
-     * separately in the activityData event
-     */
-    private makeGameActivityConfiguration;
-    private makeGameActivityConfigurationSchema;
-    /**
-     * Should be called when current game has ended successfully.
-     *
-     * @remarks This will send an ActivityEnd event to any listeners, such as
-     * a function provided to Game.onEnd() or a callback defined in
-     * SessionOptions.activityCallbacks.onActivityLifecycle. This is how the
-     * game can communicate changes in activity state to the parent session.
-     * It is the responsibility of the the game programmer to call this at the
-     * appropriate time. It is not triggered automatically.
-     */
-    end(): void;
-    /**
-     * Should be called when current game has been canceled by a user action.
-     *
-     * @remarks This will send an ActivityCancel event to any listeners, such as
-     * a function provided to Game.onCancel() or a callback defined in
-     * SessionOptions.activityCallbacks.onActivityLifecycle. This is how the
-     * game can communicate changes in activity state to the parent session.
-     * It is the responsibility of the the game programmer to call this at the
-     * appropriate time. It is not triggered automatically.
-     */
-    cancel(): void;
-    private setupHtmlCanvases;
-    private setupCanvasKitSurface;
-    private interceptWebGlCalls;
-    private setupFpsFont;
-    private setupCanvasDomEventHandlers;
-    private loop;
-    snapshots: Image[];
-    private updateGameTime;
-    private handleIncomingSceneTransitions;
-    /**
-     * Creates a scene that has a screen shot of the current scene.
-     *
-     * @param outgoingSceneImage - an image of the current scene
-     * @returns - the scene with the screen shot
-     */
-    private createOutgoingScene;
-    /**
-     * Executes a callback when the frame has finished simulating physics.
-     *
-     * @param callback - function to execute.
-     * @param options - options for the callback.
-     */
-    onFrameDidSimulatePhysics(callback: (frameCycleEvent: FrameCycleEvent) => void, options?: CallbackOptions): void;
-    private update;
-    private draw;
-    private calculateFps;
-    private takeCurrentSceneSnapshot;
-    private handlePendingScreenshot;
-    /**
-     * Takes screenshot of canvas
-     *
-     * @remarks Coordinates should be provided unscaled; that is, the method
-     * will handle any scaling that happened due to device pixel ratios
-     * not equal to 1. This returns a promise because the screenshot request
-     * must be queued and completed once a draw cycle has completed. See
-     * the loop() method.
-     *
-     * @param sx - Upper left coordinate of screenshot
-     * @param sy - Upper right coordinate of screenshot
-     * @param sw - width of area to screenshot
-     * @param sh - height of area to screenshot
-     * @returns Promise of Uint8Array of image data
-     */
-    takeScreenshot(sx?: number, sy?: number, sw?: number, sh?: number): Promise<Uint8Array | null>;
-    private animateSceneTransition;
-    private drawFps;
-    /**
-     * Creates an event listener for an entity based on the entity name
-     *
-     * @remarks Typically, event listeners will be created using a method specific to the event, such as onTapDown(). This alternative allows creation with entity name.
-     *
-     * @param type - the type of event to listen for, e.g., "tapDown"
-     * @param entityName - the entity name for which an event will be listened
-     * @param callback - the callback to be invoked when the event occurs
-     * @param callbackOptions
-     */
-    createEventListener(type: EventType, entityName: string, callback: (event: EntityEvent) => void, callbackOptions?: CallbackOptions): void;
-    /**
-     * Returns array of all entities that have been added to the game object.
-     */
-    get entities(): Array<Entity>;
-    /**
-     * Receives callback from DOM PointerDown event
-     *
-     * @param domPointerEvent - PointerEvent from the DOM
-     * @returns
-     */
-    private htmlCanvasPointerDownHandler;
-    private htmlCanvasPointerUpHandler;
-    private htmlCanvasPointerMoveHandler;
-    /**
-     * Adjusts dragging behavior when the pointer leaves the canvas
-     *
-     * @remarks This is necessary because the pointerup event is not fired when
-     * the pointer leaves the canvas. On desktop, this means that the user might
-     * lift the pointer outside the canvas, but the entity will still be dragged
-     * when the pointer is moved back into the canvas.
-     *
-     * @param domPointerEvent
-     * @returns
-     */
-    private htmlCanvasPointerLeaveHandler;
-    /**
-     * Determines if/how m2c2kit entities respond to the DOM PointerDown event
-     *
-     * @param entity - entity that might be affected by the DOM PointerDown event
-     * @param m2Event
-     * @param domPointerEvent
-     */
-    private processDomPointerDown;
-    private processDomPointerUp;
-    private processDomPointerMove;
-    private raiseM2PointerDownEvent;
-    private raiseTapDownEvent;
-    private raiseTapLeaveEvent;
-    private raiseM2PointerUpEvent;
-    private raiseTapUpEvent;
-    private raiseTapUpAny;
-    private raiseM2PointerMoveEvent;
-    private raiseM2PointerLeaveEvent;
-    private raiseM2DragStartEvent;
-    private raiseM2DragEvent;
-    private raiseM2DragEndEvent;
-    private calculatePointWithinEntityFromDomPointerEvent;
-    /**
-     * Executes a callback when the game starts.
-     *
-     * @param callback - function to execute.
-     * @param options - options for the callback.
-     */
-    onStart(callback: (activityLifecycleEvent: ActivityLifecycleEvent) => void, options?: CallbackOptions): void;
-    /**
-     * Executes a callback when the game is canceled.
-     *
-     * @param callback - function to execute.
-     * @param options - options for the callback.
-     */
-    onCancel(callback: (activityLifecycleEvent: ActivityLifecycleEvent) => void, options?: CallbackOptions): void;
-    /**
-     * Executes a callback when the game ends.
-     *
-     * @param callback - function to execute.
-     * @param options - options for the callback.
-     */
-    onEnd(callback: (activityLifecycleEvent: ActivityLifecycleEvent) => void, options?: CallbackOptions): void;
-    /**
-     * Executes a callback when the game generates data.
-     *
-     * @param callback - function to execute.
-     * @param options - options for the callback.
-     */
-    onData(callback: (activityResultsEvent: ActivityResultsEvent) => void, options?: CallbackOptions): void;
-    private addEventListener;
-    private raiseActivityEventOnListeners;
-    private raiseEventOnListeningEntities;
-    private sceneCanReceiveUserInteraction;
-    /**
-     *
-     * Checks if the given canvas point is within the entity's bounds.
-     *
-     * @param entity - entity to check bounds for
-     * @param x - x coordinate of the canvas point
-     * @param y - y coordinate of the canvas point
-     * @returns true if x, y point is within the entity's bounds
-     */
-    private IsCanvasPointWithinEntityBounds;
-    prependAssetsGameIdUrl(url: string): string;
-}
-
-/**
- * This class contains all the fonts for all the games in the activity.
- * Fonts have been converted to canvaskit Typeface.
- *
- * @remarks fontName is how the user will refer to the font in the game.
- * fontFamily is the name of the font as it was specified within the TTF file.
- * We must retain the fontFamily name because we must provide fontFamily (not
- * fontName!) to canvaskit when rendering paragraphs.
- */
-declare class GameTypefaces {
-    [gameUuid: string]: {
-        [fontName: string]: {
-            fontFamily: string;
-            typeface: Typeface;
-            isDefault: boolean;
-        };
-    };
-}
-/**
- * Class for loading, preparing, and providing fonts to games.
- *
- * @remarks FOR INTERNAL USE ONLY
- */
-declare class FontManager {
-    canvasKit?: CanvasKit;
-    fontMgr?: FontMgr;
-    gameTypefaces: GameTypefaces;
-    fontData: Array<FontData>;
-    session: Session;
-    games?: Array<Game>;
-    constructor(session: Session);
-    /**
-     * Gets a typeface that was previously loaded for the specified game.
-     *
-     * @param gameUuid
-     * @param fontName
-     * @returns the requested Typeface
-     */
-    getTypeface(gameUuid: string, fontName: string): Typeface;
-    /**
-     * Gets names of fonts loaded for the specified game.
-     *
-     * @param gameUuid
-     * @returns array of font names
-     */
-    getFontNames(gameUuid: string): Array<string>;
-    /**
-     * Fetches all fonts games.
-     *
-     * @param games - array of games
-     * @returns
-     */
-    fetchFonts(games: Array<Game>): Promise<void[]>;
-    /**
-     * Takes the fonts, which have been previously fetched and converted into
-     * Array Buffers using FontManager.fetchFonts(), and makes them available
-     * to our engine by creating canvaskit Typefaces.
-     */
-    loadAllGamesFontData(): void;
-}
-
-interface ActivityCallbacks {
-    /** Callback executed when the activity lifecycle changes, such as when it ends. */
-    onActivityLifecycle?: (event: ActivityLifecycleEvent) => void;
-    /** Callback executed when an activity creates some data. */
-    onActivityResults?: (event: ActivityResultsEvent) => void;
-}
-
-/** Base interface for all Session events. */
-interface SessionEvent extends EventBase {
-    target: Session;
-}
-
-/**
- * Notifies when a session starts, ends, or initializes.
- */
-interface SessionLifecycleEvent extends SessionEvent {
-}
-
-interface SessionCallbacks {
-    /** Callback executed when the session lifecycle changes, such as when it is initialized. */
-    onSessionLifecycle?: (event: SessionLifecycleEvent) => void;
-}
-
-interface SessionOptions {
-    /** The activities that compose this session */
-    activities: Array<Activity>;
-    /** Callbacks executed when activity events occurs, such as when activity creates data or ends */
-    activityCallbacks?: ActivityCallbacks;
-    /** Callbacks executed when session events occur */
-    sessionCallbacks?: SessionCallbacks;
-    /** Url of the canvaskit.wasm binary. Always set to the default value of "canvaskit.wasm" */
-    canvasKitWasmUrl: "canvaskit.wasm";
-    /** Use a specified session UUID, rather than create a new one */
-    sessionUuid?: string;
-    /** URL of session assets folder (which contains wasm binary), if not the default location of "assets" */
-    assetsUrl?: string;
-    /** Array of one or more optional databases that implement the IDataStore interface for persisting data. For store item operations, the first data store will be used. */
-    dataStores?: IDataStore[];
-    /** After the session initializes, should the session automatically start? Default is true */
-    autoStartAfterInit?: boolean;
-    /** When an activity ends or is canceled, should the session automatically go to the next activity? Default is true */
-    autoGoToNextActivity?: boolean;
-    /** After the last activity ends or is canceled, should the session automatically end? Default is true */
-    autoEndAfterLastActivity?: boolean;
-    /** NOT IMPLEMENTED YET: Orientation the screen should be locked to for this session. Value will be passed into the ScreenOrientation.lock() Web API. */
-    orientation?: "natural" | "landscape" | "portrait" | "portrait-primary" | "portrait-secondary" | "landscape-primary" | "landscape-secondary";
-}
-
-declare class Session {
-    options: SessionOptions;
-    fontManager: FontManager;
-    imageManager: ImageManager;
-    currentActivity?: Activity;
-    uuid: string;
-    dataStores?: IDataStore[];
-    private eventListeners;
-    private sessionDictionary;
-    private canvasKit?;
-    private initialized;
-    private version;
-    /**
-     * A Session contains one or more activities. The session manages the start
-     * and stop of activities, and advancement to next activity
-     *
-     * @param options
-     */
-    constructor(options: SessionOptions);
-    /**
-     * Executes a callback when the session initializes.
-     *
-     * @param callback - function to execute.
-     * @param options - options for the callback.
-     */
-    onInitialize(callback: (sessionLifecycleEvent: SessionLifecycleEvent) => void, options?: CallbackOptions): void;
-    /**
-     * Executes a callback when the session starts.
-     *
-     * @param callback - function to execute.
-     * @param options - options for the callback.
-     */
-    onStart(callback: (sessionLifecycleEvent: SessionLifecycleEvent) => void, options?: CallbackOptions): void;
-    /**
-     * Executes a callback when the session ends.
-     *
-     * @param callback - function to execute.
-     * @param options - options for the callback.
-     */
-    onEnd(callback: (sessionLifecycleEvent: SessionLifecycleEvent) => void, options?: CallbackOptions): void;
-    /**
-     * Executes a callback when any activity in the session generates data.
-     *
-     * @param callback - function to execute.
-     * @param options - options for the callback.
-     */
-    onActivityData(callback: (activityResultsEvent: ActivityResultsEvent) => void, options?: CallbackOptions): void;
-    private addEventListener;
-    private raiseEventOnListeners;
-    private sessionActivityStartHandler;
-    private sessionActivityCancelHandler;
-    private sessionActivityEndHandler;
-    private sessionActivityLifecycleHandler;
-    private activityResultsEventHandler;
-    /**
-     * Asynchronously initializes the m2c2kit engine and loads assets
-     *
-     * @deprecated Use Session.initialize() instead.
-     */
-    init(): Promise<void>;
-    /**
-     * Check if the Activity uses the deprecated init() method.
+     *   &#125;);
+     *   game.addStaticTrialData("participant_id", "12345");
      *
-     * @remarks Activity.init() is deprecated and should be replaced with
-     * Activity.initialize().
+     *  When Game.trialComplete() is called, the participant_id variable will
+     *  be saved for the trial with the value "12345".
      *
-     * @param activity
-     * @returns true if the activity defines its own init() method, false otherwise.
-     */
-    private activityUsesDeprecatedInit;
-    /**
-     * Asynchronously initializes the m2c2kit engine and loads assets
+     * @param variableName - variable to be set
+     * @param value - value of the variable to set
      */
-    initialize(): Promise<void>;
+    addStaticTrialData(variableName: string, value: JsonSchemaDataTypeScriptTypes): void;
     /**
-     * Waits for the session to be initialized.
+     * Should be called when the current trial has completed. It will
+     * also increment the trial index.
      *
-     * @remarks Session.initialize() is asynchronous, and it should be awaited
-     * so that the session is fully initialized before calling Session.start().
-     * If it is not awaited (or it cannot be awaited because the target
-     * environment does not support top-level await), this function ensures that
-     * the session has been initialized.
+     * @remarks Calling will trigger the onActivityResults callback function,
+     * if one was provided in SessionOptions. This is how the game communicates
+     * trial data to the parent session, which can then save or process the data.
+     * It is the responsibility of the the game programmer to call this at
+     * the appropriate time. It is not triggered automatically.
      */
-    private waitForSessionInitialization;
+    trialComplete(): void;
     /**
-     * Starts the session and starts the first activity.
+     * The m2c2kit engine will automatically include these schema and their
+     * values in the trial data.
      */
-    start(): Promise<void>;
+    private readonly automaticTrialSchema;
+    private makeNewGameDataSchema;
+    private makeGameDataSchema;
     /**
-     * Declares the session ended and sends callback.
+     * GameParameters combines default parameters values and
+     * JSON Schema to describe what the parameters are.
+     * The next two functions extract GameParameters's two parts
+     * (the default values and the schema) so they can be returned
+     * separately in the activityData event
      */
-    end(): void;
-    private stop;
+    private makeGameActivityConfiguration;
+    private makeGameActivityConfigurationSchema;
     /**
-     * Frees up resources that were allocated to run the session.
+     * Should be called when current game has ended successfully.
      *
-     * @remarks This will be done automatically by the m2c2kit library;
-     * the end-user must not call this.
+     * @remarks This will send an ActivityEnd event to any listeners, such as
+     * a function provided to Game.onEnd() or a callback defined in
+     * SessionOptions.activityCallbacks.onActivityLifecycle. This is how the
+     * game can communicate changes in activity state to the parent session.
+     * It is the responsibility of the the game programmer to call this at the
+     * appropriate time. It is not triggered automatically.
      */
-    private dispose;
+    end(): void;
     /**
-     * Stops the current activity and goes to the activity with the provided id.
+     * Should be called when current game has been canceled by a user action.
      *
-     * @param options
-     */
-    goToActivity(options: GoToActivityOptions): Promise<void>;
-    /**
-     * Stops the current activity and advances to next activity in the session.
-     * If there is no activity after the current activity, throws error.
+     * @remarks This will send an ActivityCancel event to any listeners, such as
+     * a function provided to Game.onCancel() or a callback defined in
+     * SessionOptions.activityCallbacks.onActivityLifecycle. This is how the
+     * game can communicate changes in activity state to the parent session.
+     * It is the responsibility of the the game programmer to call this at the
+     * appropriate time. It is not triggered automatically.
      */
-    goToNextActivity(): Promise<void>;
+    cancel(): void;
+    private setupHtmlCanvases;
+    private setupCanvasKitSurface;
+    private interceptWebGlCalls;
+    private setupFpsFont;
+    private setupCanvasDomEventHandlers;
+    private loop;
+    snapshots: Image[];
+    private updateGameTime;
+    private handleIncomingSceneTransitions;
     /**
-     * Stops the current activity and advances to next activity in the session.
-     * If there is no activity after the current activity, throws error.
+     * Creates a scene that has a screen shot of the current scene.
      *
-     * @deprecated Use goToNextActivity() instead.
-     */
-    advanceToNextActivity(): Promise<void>;
-    /**
-     * Gets the next activity after the current one, or undefined if
-     * this is the last activity.
+     * @param outgoingSceneImage - an image of the current scene
+     * @returns - the scene with the screen shot
      */
-    get nextActivity(): Activity | undefined;
+    private createOutgoingScene;
     /**
-     * Saves an item to the session's key-value dictionary.
+     * Registers a plugin with the game.
      *
-     * @remarks The session dictionary is not persisted. It is available only
-     * during the actively running session. It is useful for storing temporary
-     * data to coordinate between activities.
+     * @remarks Upon registration, the plugin's optional asynchronous
+     * `initialize()` method will be called.
      *
-     * @param key - item key
-     * @param value - item value
+     * @param plugin - Plugin to register
      */
-    dictionarySetItem(key: string, value: SessionDictionaryValues): void;
+    registerPlugin(plugin: Plugin): Promise<void>;
+    private update;
+    private draw;
+    private calculateFps;
+    private takeCurrentSceneSnapshot;
+    private handlePendingScreenshot;
     /**
-     * Gets an item value from the session's key-value dictionary.
+     * Takes screenshot of canvas
      *
-     * @remarks The session dictionary is not persisted. It is available only
-     * during the actively running session. It is useful for storing temporary
-     * data to coordinate between activities.
+     * @remarks Coordinates should be provided unscaled; that is, the method
+     * will handle any scaling that happened due to device pixel ratios
+     * not equal to 1. This returns a promise because the screenshot request
+     * must be queued and completed once a draw cycle has completed. See
+     * the loop() method.
      *
-     * @param key - item key
-     * @returns value of the item
+     * @param sx - Upper left coordinate of screenshot
+     * @param sy - Upper right coordinate of screenshot
+     * @param sw - width of area to screenshot
+     * @param sh - height of area to screenshot
+     * @returns Promise of Uint8Array of image data
      */
-    dictionaryGetItem<T extends SessionDictionaryValues>(key: string): T;
+    takeScreenshot(sx?: number, sy?: number, sw?: number, sh?: number): Promise<Uint8Array | null>;
+    private animateSceneTransition;
+    private drawFps;
     /**
-     * Deletes an item value from the session's key-value dictionary.
+     * Creates an event listener for a node based on the node name
      *
-     * @remarks The session dictionary is not persisted. It is available only
-     * during the actively running session. It is useful for storing temporary
-     * data to coordinate between activities.
+     * @remarks Typically, event listeners will be created using a method specific to the event, such as onTapDown(). This alternative allows creation with node name.
      *
-     * @param key - item key
-     * @returns true if the item was deleted, false if it did not exist
+     * @param type - the type of event to listen for, e.g., "tapDown"
+     * @param nodeName - the node name for which an event will be listened
+     * @param callback - the callback to be invoked when the event occurs
+     * @param callbackOptions
      */
-    dictionaryDeleteItem(key: string): boolean;
+    createEventListener(type: M2EventType, nodeName: string, callback: (event: M2NodeEvent) => void, callbackOptions?: CallbackOptions): void;
     /**
-     * Determines if a key exists in the activity's key-value dictionary.
-     *
-     * @remarks The session dictionary is not persisted. It is available only
-     * during the actively running session. It is useful for storing temporary
-     * data to coordinate between activities.
-     *
-     * @param key - item key
-     * @returns true if the key exists, false otherwise
+     * Returns array of all nodes that have been added to the game object.
      */
-    dictionaryItemExists(key: string): boolean;
+    get nodes(): Array<M2Node>;
     /**
-     * Gets asynchronous assets, including initialization of canvaskit wasm,
-     * fetching of fonts from specified urls, and rendering and fetching
-     * of images
-     * @returns
+     * @deprecated use Game.nodes instead
      */
-    private getAsynchronousAssets;
-    private loadCanvasKit;
-    private loadAssets;
-    private assignCanvasKit;
-    private getImagesConfigurationFromGames;
-    prependAssetsUrl(url: string): string;
-}
-interface GoToActivityOptions {
-    /** ActivityId of the activity to go to. */
-    id: string;
-}
-/**
- * Types of values that can be stored in the session dictionary.
- */
-type SessionDictionaryValues = string | number | boolean | object | null | undefined;
-
-interface Activity {
-    /** The type of activity: Game or Survey */
-    type: ActivityType;
+    get entities(): Array<M2Node>;
     /**
-     * Initializes the activity.
+     * Receives callback from DOM PointerDown event
      *
-     * @remarks All code to create the activity's appearance and behavior must
-     * be placed in this method. This method is asynchronous, and must be
-     * awaited. When writing a new game by extending the `Game` class, this
-     * method will be overridden, but the base method must still be called with
-     * `await super.initialize()`.
+     * @param domPointerEvent - PointerEvent from the DOM
+     * @returns
      */
-    initialize(): Promise<void>;
+    private htmlCanvasPointerDownHandler;
+    private htmlCanvasPointerUpHandler;
+    private htmlCanvasPointerMoveHandler;
+    private htmlCanvasPointerLeaveHandler;
     /**
-     * Initializes the activity.
-     *
-     * @remarks All code to create the activity's appearance and behavior must
-     * be placed in this method. This method is asynchronous, and must be
-     * awaited. When writing a new game by extending the `Game` class, this
-     * method will be overridden, but the base method must still be called with
-     * `await super.init()`.
+     * Determines if/how m2c2kit nodes respond to the DOM PointerDown event
      *
-     * @deprecated use Game.initialize() instead.
+     * @param node - node that might be affected by the DOM PointerDown event
+     * @param nodeEvent
+     * @param domPointerEvent
      */
-    init(): Promise<void>;
-    /** Starts the activity */
-    start(): Promise<void>;
-    /** Stops the activity */
-    stop(): void;
+    private processDomPointerDown;
+    private processDomPointerUp;
+    private processDomPointerMove;
+    private processDomPointerLeave;
+    private raiseM2PointerDownEvent;
+    private raiseTapDownEvent;
+    private raiseTapLeaveEvent;
+    private raiseM2PointerUpEvent;
+    private raiseTapUpEvent;
+    private raiseTapUpAny;
+    private raiseM2PointerMoveEvent;
+    private raiseM2PointerLeaveEvent;
+    private raiseM2DragStartEvent;
+    private raiseM2DragEvent;
+    private raiseM2DragEndEvent;
+    private raiseSceneEvent;
+    private calculatePointWithinNodeFromDomPointerEvent;
     /**
-     * Executes a callback when the activity starts.
+     * Executes a callback when the game starts.
      *
      * @param callback - function to execute.
      * @param options - options for the callback.
      */
     onStart(callback: (activityLifecycleEvent: ActivityLifecycleEvent) => void, options?: CallbackOptions): void;
     /**
-     * Executes a callback when the activity is canceled.
+     * Executes a callback when the game is canceled.
      *
      * @param callback - function to execute.
      * @param options - options for the callback.
      */
     onCancel(callback: (activityLifecycleEvent: ActivityLifecycleEvent) => void, options?: CallbackOptions): void;
     /**
-     * Executes a callback when the activity ends.
-     *
-     * @param callback - function to execute.
-     * @param options - options for the callback.
-     */
-    onEnd(callback: (activityLifecycleEvent: ActivityLifecycleEvent) => void, options?: CallbackOptions): void;
-    /**
-     * Executes a callback when the activity generates data.
+     * Executes a callback when the game ends.
      *
      * @param callback - function to execute.
      * @param options - options for the callback.
      */
-    onData(callback: (activityResultsEvent: ActivityResultsEvent) => void, options?: CallbackOptions): void;
-    /** The activity's parent session */
-    session: Session;
-    /** The activity's unique identifier. NOTE: This is newly generated each session. The uuid for an activity will vary across sessions. */
-    uuid: string;
-    /** Human-friendly name of this activity */
-    name: string;
-    /** Short identifier of this activity */
-    id: string;
-    /** The value of performance.now() immediately before the activity begins */
-    beginTimestamp: number;
-    /** The value of new Date().toISOString() immediately before the activity begins */
-    beginIso8601Timestamp: string;
-    /** Sets additional activity parameters if defaults are not sufficient. */
-    setParameters(additionalParameters: unknown): void;
-    /** Additional activity parameters that were set. */
-    readonly additionalParameters?: unknown;
-    /** Optional stores to use for saving data. The implementation of the store is not provided by the \@m2c2kit/core library. */
-    dataStores?: IDataStore[];
-}
-
-/**
- * Base interface for all m2c2kit events.
- *
- * @remarks I would have named it Event, but that would collide with
- * the existing DOM Event
- */
-interface EventBase {
-    /** Type of event. */
-    type: EventType | string;
-    /** The object on which the event occurred. */
-    target: Entity | Session | Activity;
-    /** Has the event been taken care of by the listener and not be dispatched to other targets? */
-    handled?: boolean;
-}
-/**
- * The different events that are dispatched by m2c2kit core.
- */
-declare const EventType: {
-    readonly SessionInitialize: "SessionInitialize";
-    readonly SessionStart: "SessionStart";
-    readonly SessionEnd: "SessionEnd";
-    readonly ActivityStart: "ActivityStart";
-    readonly ActivityEnd: "ActivityEnd";
-    readonly ActivityCancel: "ActivityCancel";
-    readonly ActivityData: "ActivityData";
-    readonly TapDown: "TapDown";
-    readonly TapUp: "TapUp";
-    readonly TapUpAny: "TapUpAny";
-    readonly TapLeave: "TapLeave";
-    readonly PointerDown: "PointerDown";
-    readonly PointerUp: "PointerUp";
-    readonly PointerMove: "PointerMove";
-    readonly PointerLeave: "PointerLeave";
-    readonly Drag: "Drag";
-    readonly DragStart: "DragStart";
-    readonly DragEnd: "DragEnd";
-    readonly CompositeCustom: "CompositeCustom";
-    readonly FrameDidSimulatePhysics: "FrameDidSimulatePhysics";
-};
-type EventType = (typeof EventType)[keyof typeof EventType];
-
-interface EntityEventListener {
-    type: EventType | string;
-    /** For composites that raise events, type of the composite custom event. */
-    compositeType?: string;
-    entityUuid: string;
-    callback: (event: EntityEvent) => void;
-}
-
-/**
- * Describes an interaction between the pointer (mouse, touches) and an entity.
- *
- * @remarks I would have named it PointerEvent, but that would collide with
- * the existing DOM PointerEvent.
- */
-interface M2PointerEvent extends EntityEvent {
-    /** Point that was tapped on entity, relative to the entity coordinate system */
-    point: Point;
-    /** Buttons being pressed when event was fired. Taken from DOM MouseEvent.buttons */
-    buttons: number;
-}
-
-/**
- * Describes an interaction of a pointer (mouse, touches) pressing an entity.
- *
- * @remarks Unlike M2PointerEvent, TapEvent considers how the pointer, while
- * in the down state, moves in relation to the bounds of the entity.
- */
-interface TapEvent extends EntityEvent {
-    /** Point that was tapped on entity, relative to the entity coordinate system */
-    point: Point;
-    /** Buttons being pressed when event was fired. Taken from DOM MouseEvent.buttons */
-    buttons: number;
-}
-
-interface TextOptions {
-    /** Text to be displayed */
-    text?: string;
-    /** Name of font to use for text. Must have been previously loaded */
-    fontName?: string;
-    /** Color of text. Default is Constants.DEFAULT_FONT_COLOR (WebColors.Black) */
-    fontColor?: RgbaColor;
-    /** Size of text. Default is Constants.DEFAULT_FONT_SIZE (16) */
-    fontSize?: number;
-}
-
-/**
- * Width and height on two-dimensional space
- */
-interface Size {
-    /** Horizontal width, x-axis */
-    width: number;
-    /** Vertical height, y-axis */
-    height: number;
+    onEnd(callback: (activityLifecycleEvent: ActivityLifecycleEvent) => void, options?: CallbackOptions): void;
+    /**
+     * Executes a callback when the game generates data.
+     *
+     * @param callback - function to execute.
+     * @param options - options for the callback.
+     */
+    onData(callback: (activityResultsEvent: ActivityResultsEvent) => void, options?: CallbackOptions): void;
+    /**
+     * Executes a callback when the game begins its warmup.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @param callback - function to execute.
+     * @param options - options for the callback.
+     */
+    onWarmupStart(callback: (gameEvent: GameEvent) => void, options?: CallbackOptions): void;
+    /**
+     * Executes a callback when the game ends its warmup.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @param callback - function to execute.
+     * @param options - options for the callback.
+     */
+    onWarmupEnd(callback: (activityEvent: ActivityEvent) => void, options?: CallbackOptions): void;
+    private addEventListener;
+    private raiseActivityEventOnListeners;
+    private raiseEventOnListeningNodes;
+    private sceneCanReceiveUserInteraction;
+    /**
+     *
+     * Checks if the given canvas point is within the node's bounds.
+     *
+     * @param node - node to check bounds for
+     * @param x - x coordinate of the canvas point
+     * @param y - y coordinate of the canvas point
+     * @returns true if x, y point is within the node's bounds
+     */
+    private IsCanvasPointWithinNodeBounds;
 }
 
 /**
@@ -1780,31 +1771,31 @@ interface Size {
  * @remarks I would have named it DragEvent, but that would collide with
  * the existing DOM DragEvent.
  */
-interface M2DragEvent extends EntityEvent {
-    /** Position of the entity at the time of the M2DragEvent, relative to the parent entity coordinate system. */
+interface M2DragEvent extends M2NodeEvent {
+    /** Position of the node at the time of the M2DragEvent, relative to the parent node coordinate system. */
     position: Point;
     /** Buttons being pressed when event was fired. Taken from DOM MouseEvent.buttons. */
     buttons: number;
 }
 
-declare function handleInterfaceOptions(entity: Entity, options: EntityOptions): void;
-declare abstract class Entity implements EntityOptions {
-    type: EntityType;
+declare function handleInterfaceOptions(node: M2Node, options: M2NodeOptions): void;
+declare abstract class M2Node implements M2NodeOptions {
+    type: M2NodeType;
     isDrawable: boolean;
     isShape: boolean;
     isText: boolean;
     name: string;
-    position: Point;
-    scale: number;
+    _position: Point;
+    _scale: number;
     alpha: number;
-    zRotation: number;
+    _zRotation: number;
     isUserInteractionEnabled: boolean;
     draggable: boolean;
     hidden: boolean;
     layout: Layout;
     _game?: Game;
-    parent?: Entity;
-    children: Entity[];
+    parent?: M2Node;
+    children: M2Node[];
     absolutePosition: Point;
     size: Size;
     absoluteScale: number;
@@ -1813,100 +1804,100 @@ declare abstract class Entity implements EntityOptions {
     actions: Action[];
     queuedAction?: Action;
     originalActions: Action[];
-    eventListeners: EntityEventListener[];
+    eventListeners: M2NodeEventListener<M2NodeEvent>[];
     readonly uuid: string;
     needsInitialization: boolean;
     userData: any;
     loopMessages: Set<string>;
-    /** Is the entity in a pressed state? E.g., did the user put the pointer
-     * down on the entity and not yet release it? */
+    /** Is the node in a pressed state? E.g., did the user put the pointer
+     * down on the node and not yet release it? */
     pressed: boolean;
     withinHitArea: boolean;
-    /** Is the entity in a pressed state AND is the pointer within the entity's
-     * hit area? For example, a user may put the pointer down on the entity, but
-     * then move the pointer, while still down, beyond the entity's hit area. In
+    /** Is the node in a pressed state AND is the pointer within the node's
+     * hit area? For example, a user may put the pointer down on the node, but
+     * then move the pointer, while still down, beyond the node's hit area. In
      * this case, pressed = true, but pressedAndWithinHitArea = false. */
     pressedAndWithinHitArea: boolean;
-    /** When the entity initially enters the pressed state, what is the pointer
+    /** When the node initially enters the pressed state, what is the pointer
      * offset? (offset from the canvas's origin to the pointer position). We
      * save this because it will be needed if this press then led to a drag. */
     pressedInitialPointerOffset: Point;
-    /** What was the previous pointer offset when the entity was in a dragging
+    /** What was the previous pointer offset when the node was in a dragging
      * state? */
     draggingLastPointerOffset: Point;
-    /** Is the entity in a dragging state? */
+    /** Is the node in a dragging state? */
     dragging: boolean;
-    constructor(options?: EntityOptions);
+    constructor(options?: M2NodeOptions);
     initialize(): void;
     /**
-     * The game which this entity is a part of.
+     * The game which this node is a part of.
      *
-     * @remarks Throws error if entity is not part of the game object.
+     * @remarks Throws error if node is not part of the game object.
      */
     get game(): Game;
     /**
-     * Determines if the entity has been added to the game object.
+     * Determines if the node has been added to the game object.
      *
-     * @returns true if entity has been added
+     * @returns true if node has been added
      */
     private isPartOfGame;
     /**
-     * Overrides toString() and returns a human-friendly description of the entity.
+     * Overrides toString() and returns a human-friendly description of the node.
      *
      * @remarks Inspiration from https://stackoverflow.com/a/35361695
      */
     toString: () => string;
     /**
-     * Adds a child to this parent entity. Throws exception if the child's name
+     * Adds a child to this parent node. Throws exception if the child's name
      * is not unique with respect to other children of this parent, or if the
      * child has already been added to another parent.
      *
-     * @param child - The child entity to add
+     * @param child - The child node to add
      */
-    addChild(child: Entity): void;
+    addChild(child: M2Node): void;
     /**
-     * Removes all children from the entity.
+     * Removes all children from the node.
      */
     removeAllChildren(): void;
     /**
-     * Removes the specific child from this parent entity. Throws exception if
+     * Removes the specific child from this parent node. Throws exception if
      * this parent does not contain the child.
      *
      * @param child
      */
-    removeChild(child: Entity): void;
+    removeChild(child: M2Node): void;
     /**
      * Removes the children from the parent. Throws error if the parent does not
      * contain all of the children.
      *
-     * @param children - An array of children to remove from the parent entity
+     * @param children - An array of children to remove from the parent node
      */
-    removeChildren(children: Array<Entity>): void;
+    removeChildren(children: Array<M2Node>): void;
     /**
-     * Searches all descendants by name and returns first matching entity.
+     * Searches all descendants by name and returns first matching node.
      *
      * @remarks Descendants are children and children of children, recursively.
      * Throws exception if no descendant with the given name is found.
      *
-     * @param name - Name of the descendant entity to return
+     * @param name - Name of the descendant node to return
      * @returns
      */
-    descendant<T extends Entity>(name: string): T;
+    descendant<T extends M2Node>(name: string): T;
     /**
-     * Returns all descendant entities.
+     * Returns all descendant nodes.
      *
      * @remarks Descendants are children and children of children, recursively.
      */
-    get descendants(): Array<Entity>;
+    get descendants(): Array<M2Node>;
     /**
-     * Returns all ancestor entities, not including the entity itself.
+     * Returns all ancestor nodes, not including the node itself.
      */
-    get ancestors(): Array<Entity>;
+    get ancestors(): Array<M2Node>;
     /**
-     * Determines if this entity or ancestor is part of an active action that
+     * Determines if this node or ancestor is part of an active action that
      * affects it appearance.
      *
-     * @remarks This is used to determine if the entity should be rendered with
+     * @remarks This is used to determine if the node should be rendered with
      * anti-aliasing or not. Anti-aliasing on some devices causes a new shader
      * to be compiled during the action, which causes jank.
      *
@@ -1914,17 +1905,17 @@ declare abstract class Entity implements EntityOptions {
      */
     involvedInActionAffectingAppearance(): boolean;
     /**
-     * Determines if the entity is a transitioning Scene or a descendant of a
+     * Determines if the node is a transitioning Scene or a descendant of a
      * transitioning Scene.
      *
      * @returns true if transitioning
      */
     involvedInSceneTransition(): boolean;
     /**
-     * Executes a callback when the user presses down on the entity.
+     * Executes a callback when the user presses down on the node.
      *
      * @remarks TapDown is a pointer down (mouse click or touches begin) within
-     * the bounds of the entity.
+     * the bounds of the node.
      *
      * @param callback - function to execute
      * @param options - {@link CallbackOptions}
@@ -1932,23 +1923,23 @@ declare abstract class Entity implements EntityOptions {
     onTapDown(callback: (tapEvent: TapEvent) => void, options?: CallbackOptions): void;
     /**
      * Executes a callback when the user releases a press, that has been fully
-     * within the entity, from the entity.
+     * within the node, from the node.
      *
      * @remarks TapUp is a pointer up (mouse click release or touches end) within
-     * the bounds of the entity and the pointer, while down, has never moved
-     * beyond the bounds of the entity.
+     * the bounds of the node and the pointer, while down, has never moved
+     * beyond the bounds of the node.
      *
      * @param callback - function to execute
      * @param options - {@link CallbackOptions}ue.
      */
     onTapUp(callback: (tapEvent: TapEvent) => void, options?: CallbackOptions): void;
     /**
-     * Executes a callback when the user releases a press from the entity within
-     * the bounds of the entity.
+     * Executes a callback when the user releases a press from the node within
+     * the bounds of the node.
      *
      * @remarks TapUpAny is a pointer up (mouse click release or touches end)
-     * within the bounds of the entity and the pointer, while down, is allowed to
-     * have been beyond the bounds of the entity during the press before the
+     * within the bounds of the node and the pointer, while down, is allowed to
+     * have been beyond the bounds of the node during the press before the
      * release.
      *
      * @param callback - function to execute
@@ -1957,10 +1948,10 @@ declare abstract class Entity implements EntityOptions {
     onTapUpAny(callback: (tapEvent: TapEvent) => void, options?: CallbackOptions): void;
     /**
      * Executes a callback when the user moves the pointer (mouse, touches) beyond
-     * the bounds of the entity while the pointer is down.
+     * the bounds of the node while the pointer is down.
      *
      * @remarks TapLeave occurs when the pointer (mouse, touches) that has
-     * previously pressed the entity moves beyond the bounds of the entity
+     * previously pressed the node moves beyond the bounds of the node
      * before the press release.
      *
      * @param callback - function to execute
@@ -1968,22 +1959,22 @@ declare abstract class Entity implements EntityOptions {
      */
     onTapLeave(callback: (tapEvent: TapEvent) => void, options?: CallbackOptions): void;
     /**
-     * Executes a callback when the pointer first is down on the entity.
+     * Executes a callback when the pointer first is down on the node.
      *
      * @remarks PointerDown is a pointer down (mouse click or touches begin) within
-     * the bounds of the entity. It occurs under the same conditions as TapDown.
+     * the bounds of the node. It occurs under the same conditions as TapDown.
      *
      * @param callback - function to execute
      * @param options - {@link CallbackOptions}
      */
     onPointerDown(callback: (m2PointerEvent: M2PointerEvent) => void, options?: CallbackOptions): void;
     /**
-     * Executes a callback when the user releases a press from the entity within
-     * the bounds of the entity.
+     * Executes a callback when the user releases a press from the node within
+     * the bounds of the node.
      *
      * @remarks PointerUp is a pointer up (mouse click release or touches end)
-     * within the bounds of the entity. It does not require that there was a
-     * previous PointerDown on the entity.
+     * within the bounds of the node. It does not require that there was a
+     * previous PointerDown on the node.
      *
      * @param callback - function to execute
      * @param options - {@link CallbackOptions}
@@ -1991,7 +1982,7 @@ declare abstract class Entity implements EntityOptions {
     onPointerUp(callback: (m2PointerEvent: M2PointerEvent) => void, options?: CallbackOptions): void;
     /**
      * Executes a callback when the user moves the pointer (mouse or touches)
-     * within the bounds of the entity.
+     * within the bounds of the node.
      *
      * @param callback - function to execute
      * @param options - {@link CallbackOptions}
@@ -1999,62 +1990,62 @@ declare abstract class Entity implements EntityOptions {
     onPointerMove(callback: (m2PointerEvent: M2PointerEvent) => void, options?: CallbackOptions): void;
     /**
      * Executes a callback when the user moves the pointer (mouse or touches)
-     * outside the bounds of the entity.
+     * outside the bounds of the node.
      *
      * @param callback - function to execute
      * @param options - {@link CallbackOptions}
      */
     onPointerLeave(callback: (m2PointerEvent: M2PointerEvent) => void, options?: CallbackOptions): void;
     /**
-     * Executes a callback when the user begins dragging an entity.
+     * Executes a callback when the user begins dragging a node.
      *
      * @param callback - function to execute
      * @param options - {@link CallbackOptions}
      */
     onDragStart(callback: (m2DragEvent: M2DragEvent) => void, options?: CallbackOptions): void;
     /**
-     * Executes a callback when the user continues dragging an entity.
+     * Executes a callback when the user continues dragging a node.
      *
      * @param callback - function to execute
      * @param options - {@link CallbackOptions}
      */
     onDrag(callback: (m2DragEvent: M2DragEvent) => void, options?: CallbackOptions): void;
     /**
-     * Executes a callback when the user stop dragging an entity.
+     * Executes a callback when the user stop dragging a node.
      *
      * @param callback - function to execute
      * @param options - {@link CallbackOptions}
      */
     onDragEnd(callback: (m2DragEvent: M2DragEvent) => void, options?: CallbackOptions): void;
-    addEventListener(type: EventType | string, callback: (ev: EntityEvent) => void, callbackOptions?: CallbackOptions): void;
+    addEventListener<T extends M2NodeEvent>(type: M2EventType | string, callback: (ev: T) => void, callbackOptions?: CallbackOptions): void;
     private parseLayoutConstraints;
     private calculateYFromConstraint;
     private calculateXFromConstraint;
     /**
-     * Calculates the absolute alpha of the entity, taking into account the
-     * alpha of all ancestor parent entities.
+     * Calculates the absolute alpha of the node, taking into account the
+     * alpha of all ancestor parent nodes.
      *
      * @remarks Alpha has multiplicative inheritance from all ancestors.
      *
-     * @param alpha - Opacity of the entity
-     * @param ancestors - Array of ancestor parent entities
+     * @param alpha - Opacity of the node
+     * @param ancestors - Array of ancestor parent nodes
      * @returns
      */
     private calculateAbsoluteAlpha;
     update(): void;
     /**
-     * Draws each child entity that is Drawable and is not hidden, by zPosition
+     * Draws each child node that is Drawable and is not hidden, by zPosition
      * order (highest zPosition on top).
      *
      * @param canvas - CanvasKit canvas
      */
     drawChildren(canvas: Canvas): void;
     /**
-     * Runs an action on this entity.
+     * Runs an action on this node.
      *
-     * @remarks If the entity is part of an active scene, the action runs
-     * immediately. Otherwise, the action will run when the entity's scene
-     * becomes active. Calling run() multiple times on an entity will add
+     * @remarks If the node is part of an active scene, the action runs
+     * immediately. Otherwise, the action will run when the node's scene
+     * becomes active. Calling run() multiple times on a node will add
      * to existing actions, not replace them.
      *
      * @param action - The action to run
@@ -2063,38 +2054,44 @@ declare abstract class Entity implements EntityOptions {
      */
     run(action: Action, key?: string): void;
     /**
-     * Remove an action from this entity. If the action is running, it will be
+     * Remove an action from this node. If the action is running, it will be
      * stopped.
      *
      * @param key - key (string identifier) of the action to remove
      */
     removeAction(key: string): void;
     /**
-     * Remove all actions from this entity. If actions are running, they will be
+     * Remove all actions from this node. If actions are running, they will be
      * stopped.
      */
     removeAllActions(): void;
     /**
-     * Duplicates an entity using deep copy.
+     * Duplicates a node using deep copy.
      *
-     * @remarks This is a deep recursive clone (entity and children).
-     * The uuid property of all duplicated entities will be newly created,
+     * @remarks This is a deep recursive clone (node and children).
+     * The uuid property of all duplicated nodes will be newly created,
      * because uuid must be unique.
      *
-     * @param newName - optional name of the new, duplicated entity. If not
+     * @param newName - optional name of the new, duplicated node. If not
      * provided, name will be the new uuid
      */
-    abstract duplicate(newName?: string): Entity;
-    protected getEntityOptions(): EntityOptions;
+    abstract duplicate(newName?: string): M2Node;
+    protected getNodeOptions(): M2NodeOptions;
     protected getDrawableOptions(): DrawableOptions;
     protected getTextOptions(): TextOptions;
     /**
-     * Gets the scene that contains this entity by searching up the ancestor tree recursively. Throws exception if entity is not part of a scene.
+     * Gets the scene that contains this node by searching up the ancestor tree recursively. Throws exception if node is not part of a scene.
      *
-     * @returns Scene that contains this entity
+     * @returns Scene that contains this node
      */
     get canvasKit(): CanvasKit;
-    get parentSceneAsEntity(): Entity;
+    get parentSceneAsNode(): M2Node;
+    get position(): Point;
+    set position(position: Point);
+    get zRotation(): number;
+    set zRotation(zRotation: number);
+    get scale(): number;
+    set scale(scale: number);
     /**
      * For a given directed acyclic graph, topological ordering of the vertices will be identified using BFS
      * @param adjList Adjacency List that represent a graph with vertices and edges
@@ -2103,7 +2100,7 @@ declare abstract class Entity implements EntityOptions {
 }
 
 interface MoveActionOptions {
-    /** Destination point. The point is relative to the entity's parent coordinate system */
+    /** Destination point. The point is relative to the node's parent coordinate system */
     point: Point;
     /** Duration of move, in milliseconds */
     duration: number;
@@ -2137,7 +2134,7 @@ interface ScaleActionOptions {
 }
 
 interface FadeAlphaActionOptions {
-    /** Opacity of the entity. 0 is fully transparent, 1 is fully opaque. */
+    /** Opacity of the node. 0 is fully transparent, 1 is fully opaque. */
     alpha: number;
     /** Duration of scale, in milliseconds */
     duration: number;
@@ -2146,9 +2143,9 @@ interface FadeAlphaActionOptions {
 }
 
 interface RotateActionOptions {
-    /** Relative amount to rotate the entity, in counter-clockwise radians */
+    /** Relative amount to rotate the node, in counter-clockwise radians */
     byAngle?: number;
-    /** Absolute angle to which rotate the entity, in counter-clockwise radians */
+    /** Absolute angle to which rotate the node, in counter-clockwise radians */
     toAngle?: number;
     /** If `toAngle` is provided, should the rotation be performed in the direction that leads to the smallest rotation? Default is true */
     shortestUnitArc?: boolean;
@@ -2176,7 +2173,7 @@ declare enum ActionType {
 
 /**
  * The Action class has static methods for creating actions to be executed by
- * an Entity.
+ * an M2Node.
  */
 declare abstract class Action {
     abstract type: ActionType;
@@ -2194,7 +2191,7 @@ declare abstract class Action {
     key?: string;
     constructor(runDuringTransition?: boolean);
     /**
-     * Creates an action that will move an entity to a point on the screen.
+     * Creates an action that will move a node to a point on the screen.
      *
      * @param options - {@link MoveActionOptions}
      * @returns The move action
@@ -2215,27 +2212,27 @@ declare abstract class Action {
      */
     static custom(options: CustomActionOptions): Action;
     /**
-     * Creates an action that will scale the entity's size.
+     * Creates an action that will scale the node's size.
      *
-     * @remarks Scaling is relative to any inherited scaling, which is multiplicative. For example, if the entity's parent is scaled to 2.0 and this entity's action scales to 3.0, then the entity will appear 6 times as large as original.
+     * @remarks Scaling is relative to any inherited scaling, which is multiplicative. For example, if the node's parent is scaled to 2.0 and this node's action scales to 3.0, then the node will appear 6 times as large as original.
      *
      * @param options - {@link ScaleActionOptions}
      * @returns The scale action
      */
     static scale(options: ScaleActionOptions): Action;
     /**
-     * Creates an action that will change the entity's alpha (opacity).
+     * Creates an action that will change the node's alpha (opacity).
      *
-     * @remarks Alpha has multiplicative inheritance. For example, if the entity's parent is alpha .5 and this entity's action fades alpha to .4, then the entity will appear with alpha .2.
+     * @remarks Alpha has multiplicative inheritance. For example, if the node's parent is alpha .5 and this node's action fades alpha to .4, then the node will appear with alpha .2.
      *
      * @param options - {@link FadeAlphaActionOptions}
      * @returns The fadeAlpha action
      */
     static fadeAlpha(options: FadeAlphaActionOptions): Action;
     /**
-     * Creates an action that will rotate the entity.
+     * Creates an action that will rotate the node.
      *
-     * @remarks Rotate actions are applied to their children. In addition to this entity's rotate action, all ancestors' rotate actions will also be applied.
+     * @remarks Rotate actions are applied to their children. In addition to this node's rotate action, all ancestors' rotate actions will also be applied.
      *
      * @param options - {@link RotateActionOptions}
      * @returns The rotate action
@@ -2259,9 +2256,9 @@ declare abstract class Action {
      * @returns
      */
     static group(actions: Array<Action>): Action;
-    initialize(entity: Entity, key?: string): Array<Action>;
+    initialize(node: M2Node, key?: string): Array<Action>;
     static cloneAction(action: Action, key?: string): Action;
-    static evaluateAction(action: Action, entity: Entity, now: number, dt: number): void;
+    static evaluateAction(action: Action, node: M2Node, now: number, dt: number): void;
     /**
      * Calculates the duration of an action, including any children actions
      * the action may contain.
@@ -2357,6 +2354,18 @@ declare class RotateAction extends Action {
     constructor(byAngle: number | undefined, toAngle: number | undefined, shortestUnitArc: boolean | undefined, duration: number, runDuringTransition?: boolean);
 }
 
+interface ActivityCallbacks {
+    /** Callback executed when the activity lifecycle changes, such as when it ends. */
+    onActivityLifecycle?: (event: ActivityLifecycleEvent) => void;
+    /** Callback executed when an activity creates some data. */
+    onActivityResults?: (event: ActivityResultsEvent) => void;
+}
+
+interface ActivityEventListener<ActivityEvent> extends M2EventListener<ActivityEvent> {
+    /** UUID of the activity that the event listener is listening for. */
+    activityUuid: string;
+}
+
 declare class CanvasKitHelpers {
     /**
      * Frees up resources that were allocated by CanvasKit.
@@ -2365,7 +2374,7 @@ declare class CanvasKitHelpers {
      * canvaskit-wasm. JavaScript garbage collection won't
      * free these wasm objects.
      */
-    static Dispose(objects: Array<undefined | null | EmbindObject<Font | Paint | ParagraphBuilder | Paragraph | Image | Typeface | FontMgr | Path>>): void;
+    static Dispose(objects: Array<undefined | null | Font | Paint | ParagraphBuilder | Paragraph | Image | Typeface | TypefaceFontProvider | FontMgr | Path>): void;
     static makePaint(canvasKit: CanvasKit, color: RgbaColor, style: PaintStyle, isAntialiased: boolean): Paint;
 }
 
@@ -2464,17 +2473,17 @@ declare class ColorfulMutablePath extends MutablePath {
     duplicate(): ColorfulMutablePath;
 }
 
-interface CompositeOptions extends EntityOptions, DrawableOptions {
+interface CompositeOptions extends M2NodeOptions, DrawableOptions {
 }
 
-declare abstract class Composite extends Entity implements IDrawable {
-    readonly type = EntityType.Composite;
+declare abstract class Composite extends M2Node implements IDrawable {
+    readonly type = M2NodeType.Composite;
     compositeType: string;
     isDrawable: boolean;
     anchorPoint: Point;
     zPosition: number;
     /**
-     * Base Drawable object for creating custom entities ("composites") composed of primitive entities.
+     * Base Drawable object for creating custom nodes ("composites") composed of primitive nodes.
      *
      * @param options
      */
@@ -2513,11 +2522,14 @@ declare class Constants {
     /** Font size in Label and TextLine, if none is specified. */
     static readonly DEFAULT_FONT_SIZE = 16;
     static readonly LIMITED_FPS_RATE = 5;
-    static readonly FREE_ENTITIES_SCENE_NAME = "__freeEntitiesScene";
+    static readonly FREE_NODES_SCENE_NAME = "__freeNodesScene";
     static readonly OUTGOING_SCENE_NAME = "__outgoingScene";
     static readonly OUTGOING_SCENE_SPRITE_NAME = "__outgoingSceneSprite";
     static readonly OUTGOING_SCENE_IMAGE_NAME = "__outgoingSceneSnapshot";
     static readonly SESSION_INITIALIZATION_POLLING_INTERVAL_MS = 50;
+    /** Placeholder that will be populated during the build process. */
+    static readonly MODULE_METADATA_PLACEHOLDER: ModuleMetadata;
+    static readonly DEFAULT_ROOT_ELEMENT_ID = "m2c2kit";
 }
 
 /**
@@ -2560,10 +2572,187 @@ declare class Equals {
     static rgbaColor(color1?: RgbaColor, color2?: RgbaColor): boolean;
 }
 
-interface EventListenerBase {
-    type: EventType;
-    callback: (event: EventBase) => void;
-    key?: string;
+/**
+ * Bounding box of a node.
+ *
+ * @remarks In the m2c2kit coordinate system, the origin (0, 0) is at the top
+ * left corner.
+ */
+interface BoundingBox {
+    /** The minimum x value of the bounding box */
+    xMin: number;
+    /** The maximum x value of the bounding box */
+    xMax: number;
+    /** The minimum y value of the bounding box */
+    yMin: number;
+    /** The maximum y value of the bounding box */
+    yMax: number;
+}
+
+interface RotationTransform {
+    /** Counterclockwise radians of the rotation */
+    radians: number;
+    /** Point around which to rotate */
+    center: Point;
+}
+declare class M2c2KitHelpers {
+    /**
+     * Returns the URL as it appears in the game's manifest.json file.
+     *
+     * @remarks This is used to return the hashed URL.
+     *
+     * @param game - game object
+     * @param url - the URL
+     * @returns the hashed URL from the manifest, or the original URL if there is no manifest or the URL is not in the manifest.
+     */
+    static getUrlFromManifest(game: Game, url: string): string;
+    /**
+     * Does the URL have a scheme?
+     *
+     * @param url - the URL to test
+     * @returns true if the url begins with a scheme (e.g., "http://",
+     * "https://", "file://", etc.)
+     */
+    static urlHasScheme(url: string): boolean;
+    /**
+     * Calculates the four points of the bounding box of the node, taking
+     * into account the node's rotation (as well as the rotation of its
+     * ancestors).
+     *
+     * @remarks This method is used to calculate the rotated bounding box of an
+     * node when in order to determine if a point is inside the node in
+     * response to DOM pointer events. This method is NOT used to prepare the
+     * CanvasKit canvas for drawing the node.
+     *
+     * @param drawableNode
+     * @returns array of points representing the rotated node
+     */
+    static calculateRotatedPoints(drawableNode: IDrawable & M2Node): Point[];
+    /**
+     * Rotates the canvas so the node appears rotated when drawn.
+     *
+     * @remarks Nodes inherit rotations from their ancestors. Each ancestor,
+     * however, rotates around its own anchor point. Thus, we must rotate the
+     * canvas around the anchor point of each ancestor as well as the node's
+     * anchor point.
+     *
+     * @param canvas - CanvasKit canvas to rotate
+     * @param drawableNode - Node to rotate the canvas for
+     */
+    static rotateCanvasForDrawableNode(canvas: Canvas, drawableNode: IDrawable & M2Node): void;
+    /**
+     * Calculates the absolute bounding box of the node before any rotation
+     * is applied.
+     *
+     * @remarks The absolute bounding box is the bounding box of the node
+     * relative to the scene's origin (0, 0).
+     *
+     * @param node
+     * @returns the bounding box of the node
+     */
+    static calculateNodeAbsoluteBoundingBox(node: M2Node): BoundingBox;
+    /**
+     * Converts an angle from radians to degrees.
+     *
+     * @remarks In m2c2kit, radians are counter clockwise from the positive
+     * x-axis, but the rotate method in CanvasKit uses degrees clockwise. Thus
+     * we negate after conversion from radians to degrees.
+     *
+     * @param radians - The angle in radians
+     * @returns The angle in degrees
+     */
+    static radiansToDegrees(radians: number): number;
+    /**
+     * Normalizes an angle in radians to the range [0, 2*Math.PI)
+     *
+     * @param radians - angle in radians
+     * @returns normalized angle in radians
+     */
+    static normalizeAngleRadians(radians: number): number;
+    /**
+     * Checks if two points are on the same side of a line.
+     *
+     * @remarks The line is defined by two points, a and b. The function uses
+     * the cross product to determine the relative position of the points.
+     *
+     * @param p1 - point to check
+     * @param p2 - point to check
+     * @param a - point that defines one end of the line
+     * @param b - point that defines the other end of the line
+     * @returns true if p1 and p2 are on the same side of the line, or false
+     * otherwise
+     */
+    static arePointsOnSameSideOfLine(p1: Point, p2: Point, a: Point, b: Point): boolean;
+    /**
+     * Checks if a point is inside a rectangle.
+     *
+     * @remarks The rectangle may have been rotated (sides might not be parallel
+     * to the axes).
+     *
+     * @param point - The Point to check
+     * @param rect - An array of four Points representing the vertices of the
+     * rectangle in clockwise order
+     * @returns true if the Point is inside the rectangle
+     */
+    static isPointInsideRectangle(point: Point, rect: Point[]): boolean;
+    /**
+     * Checks if the node or any of its ancestors have been rotated.
+     *
+     * @param node - node to check
+     * @returns true if the node or any of its ancestors have been rotated
+     */
+    static nodeOrAncestorHasBeenRotated(node: M2Node): boolean;
+    /**
+     * Converts a bounding box to an array of four points representing the
+     * vertices of the rectangle.
+     *
+     * @remarks In m2c2kit, the y-axis is inverted: origin is in the upper-left.
+     * Vertices are returned in clockwise order starting from the upper-left.
+     *
+     * @param boundingBox
+     * @returns An array of four points
+     */
+    static boundingBoxToPoints(boundingBox: BoundingBox): Point[];
+    /**
+     * Finds the centroid of a rectangle.
+     *
+     * @param points - An array of four points representing the vertices of the
+     * rectangle.
+     * @returns array of points representing the centroid of the rectangle.
+     */
+    static findCentroid(points: Point[]): Point;
+    /**
+     * Rotates a point, counterclockwise, around another point by an angle in
+     * radians.
+     *
+     * @param point - Point to rotate
+     * @param radians - angle in radians
+     * @param center - Point to rotate around
+     * @returns rotated point
+     */
+    static rotatePoint(point: Point, radians: number, center: Point): Point;
+    /**
+     * Calculates the rotation transforms to apply to node, respecting any
+     * ancestor rotations.
+     *
+     * @param drawableNode - node to calculate rotation transforms for
+     * @returns array of rotation transforms to apply
+     */
+    static calculateRotationTransforms(drawableNode: IDrawable & M2Node): RotationTransform[];
+}
+
+/**
+ * FontData holds metadata about the font (names, url) and the raw bytes of
+ * the font TTF in an ArrayBuffer. This ArrayBuffer font data cannot be used
+ * by canvaskit directly. These data are later used to create a canvaskit
+ * TypeFace in FontManager.loadFonts().
+ */
+interface FontData {
+    fontUrl: string;
+    fontName: string;
+    fontFamilyName: string;
+    fontArrayBuffer: ArrayBuffer;
+    isDefault: boolean;
 }
 
 interface IText {
@@ -2579,7 +2768,7 @@ declare enum LabelHorizontalAlignmentMode {
     Right = 2
 }
 
-interface LabelOptions extends EntityOptions, DrawableOptions, TextOptions {
+interface LabelOptions extends M2NodeOptions, DrawableOptions, TextOptions {
     /** Horizontal alignment of label text. see {@link LabelHorizontalAlignmentMode}. Default is LabelHorizontalAlignmentMode.center  */
     horizontalAlignmentMode?: LabelHorizontalAlignmentMode;
     /** Maximum width of label text before wrapping occurs. Default is the canvas width */
@@ -2590,8 +2779,8 @@ interface LabelOptions extends EntityOptions, DrawableOptions, TextOptions {
     fontNames?: Array<string>;
 }
 
-declare class Label extends Entity implements IDrawable, IText, LabelOptions {
-    readonly type = EntityType.Label;
+declare class Label extends M2Node implements IDrawable, IText, LabelOptions {
+    readonly type = M2NodeType.Label;
     isDrawable: boolean;
     isText: boolean;
     anchorPoint: {
@@ -2622,6 +2811,17 @@ declare class Label extends Entity implements IDrawable, IText, LabelOptions {
      */
     constructor(options?: LabelOptions);
     initialize(): void;
+    /**
+     * Determines the M2Font objects that need to be ready in order to draw
+     * the Label.
+     *
+     * @remarks It needs a FontManager because it may need to look up the
+     * default font.
+     *
+     * @param fontManager - {@link FontManager}
+     * @returns an array of M2Font objects that are required for the Label
+     */
+    private getRequiredLabelFonts;
     dispose(): void;
     get text(): string;
     set text(text: string);
@@ -2645,13 +2845,13 @@ declare class Label extends Entity implements IDrawable, IText, LabelOptions {
     private get fontPaint();
     private set fontPaint(value);
     /**
-     * Duplicates an entity using deep copy.
+     * Duplicates a node using deep copy.
      *
-     * @remarks This is a deep recursive clone (entity and children).
-     * The uuid property of all duplicated entities will be newly created,
+     * @remarks This is a deep recursive clone (node and children).
+     * The uuid property of all duplicated nodes will be newly created,
      * because uuid must be unique.
      *
-     * @param newName - optional name of the new, duplicated entity. If not
+     * @param newName - optional name of the new, duplicated node. If not
      * provided, name will be the new uuid
      */
     duplicate(newName?: string): Label;
@@ -2664,23 +2864,143 @@ declare class Label extends Entity implements IDrawable, IText, LabelOptions {
  * This class is used internally for processing layout constraints that
  * have been defined according to the Constraints interface.
  *
- * Imagine we have two entities, A and B. B's position is set
+ * Imagine we have two nodes, A and B. B's position is set
  * using its position property. A's position is set using the layout
- * constraint "bottomToTopOf B." A is the focal entity in this example.
+ * constraint "bottomToTopOf B." A is the focal node in this example.
  * What this means is that A's y coordinate will be computed such that
  * the bottom of A is the top of B. If A and B are squares, then A sits
  * on top of B with no gap.
  */
 declare class LayoutConstraint {
     type: ConstraintType;
-    alterEntity: Entity;
+    alterNode: M2Node;
     verticalConstraint: boolean;
-    focalEntityMinimum: boolean;
-    alterEntityMinimum: boolean;
+    focalNodeMinimum: boolean;
+    alterNodeMinimum: boolean;
     verticalTypes: ConstraintType[];
-    focalEntityMinimumTypes: ConstraintType[];
-    alterEntityMinimumTypes: ConstraintType[];
-    constructor(type: ConstraintType, alterEntity: Entity);
+    focalNodeMinimumTypes: ConstraintType[];
+    alterNodeMinimumTypes: ConstraintType[];
+    constructor(type: ConstraintType, alterNode: M2Node);
+}
+
+/**
+ * A class to create, start, and stop named timers that measure elapsed time in milliseconds.
+ *
+ * @deprecated Use Timer class instead. To migrate to the Timer class, use Timer.startNew() to create and start a new timer instead
+ * of LegacyTimer.start().
+ */
+declare class LegacyTimer {
+    private startTime;
+    private stopTime;
+    private stopped;
+    /**
+     * cumulativeElapsed is a cumulative total of elapsed time while the timer
+     * was in previous started (running) states, NOT INCLUDING the possibly
+     * active run's duration
+     */
+    private cumulativeElapsed;
+    private name;
+    private static _timers;
+    constructor(name: string);
+    /**
+     * Aliases performance.now()
+     *
+     * @remarks The m2c2kit Timer class is designed to measure elapsed durations
+     * after a designated start point for a uniquely named timer. However, if a
+     * timestamp based on the
+     * [time origin](https://developer.mozilla.org/en-US/docs/Web/API/DOMHighResTimeStamp#the_time_origin)
+     * is needed, this method can be used.
+     *
+     * @deprecated Use Timer class.
+     *
+     * @returns a [DOMHighResTimeStamp](https://developer.mozilla.org/en-US/docs/Web/API/DOMHighResTimeStamp)
+     */
+    static now(): number;
+    /**
+     * Starts a millisecond-resolution timer based on
+     * [performance.now()](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now).
+     *
+     * @remarks The method throws an error if a timer with the given
+     * name is already in a started state.
+     *
+     * @deprecated Use Timer class. Use Timer.startNew() to create and start a new timer or Timer.new() to create a new timer without starting it.
+     *
+     * @param name - The name of the timer to be started
+     */
+    static start(name: string): void;
+    /**
+     * Stops a timer.
+     *
+     * @remarks The method throws an error if a timer with the given
+     * name is already in a stopped state, or if a timer with the
+     * given name has not been started.
+     *
+     * @deprecated Use Timer class.
+     *
+     * @param name - The name of the timer to be stopped
+     */
+    static stop(name: string): void;
+    /**
+     * Restarts a timer.
+     *
+     * @remarks The timer elapsed duration is set to 0 and it starts anew.
+     * The method throws an error if a timer with the given
+     * name does not exist (if there is not a started or stopped timer
+     * with the given name).
+     *
+     * @deprecated Use Timer class. Use Timer.startNew() to create and start a new timer with the same name.
+     *
+     * @param name - The name of the timer to be restarted
+     */
+    static restart(name: string): void;
+    /**
+     * Returns the total time elapsed, in milliseconds, of the timer.
+     *
+     * @remarks The total time elapsed will include all durations from multiple
+     * starts and stops of the timer, if applicable. A timer's elapsed duration
+     * can be read while it is in started or stopped state. The method throws
+     * an error if a timer with the given name does not exist.
+     *
+     * @deprecated Use Timer class.
+     *
+     * @param name - The name of the timer whose elapsed duration is requested
+     */
+    static elapsed(name: string): number;
+    /**
+     * Removes a timer.
+     *
+     * @remarks After removal, no additional methods can be used with a timer
+     * of the given name, other than to start a new timer with the given name,
+     * whose duration will begin at 0 again. The method throws an error if
+     * a timer with the given name does not exist.
+     *
+     * @deprecated Use Timer class.
+     *
+     * @param name - The name of the timer to be removed
+     */
+    static remove(name: string): void;
+    /**
+     * Remove all timers.
+     *
+     * @remarks This method will {@link remove} any timers in a started or
+     * stopped state. This method is idempotent; method is safe to call even
+     * if there are no timers to remove; no errors are thrown if there are
+     * not any timers that can be removed.
+     *
+     * @deprecated Use Timer class.
+     */
+    static removeAll(): void;
+    /**
+     * Checks if a timer of the given name exists.
+     *
+     * @remarks The method checks if there is a timer with the given name.
+     *
+     * @deprecated Use Timer class.
+     *
+     * @param name - The name of the timer to check for existence
+     * @returns boolean
+     */
+    static exists(name: string): boolean;
 }
 
 /**
@@ -2694,6 +3014,11 @@ interface M2ColorfulPath extends M2Path {
     linePresentations: Array<LinePresentation>;
 }
 
+/** Base interface for all Plugin events. */
+interface PluginEvent extends M2Event<Plugin> {
+    target: Plugin;
+}
+
 declare class RandomDraws {
     /**
      * Draws a single random integer from a uniform distribution of integers in
@@ -2772,7 +3097,7 @@ interface SvgStringPath {
     width?: number;
 }
 
-interface ShapeOptions extends EntityOptions, DrawableOptions {
+interface ShapeOptions extends M2NodeOptions, DrawableOptions {
     shapeType?: ShapeType;
     /** If provided, shape will be a circle with given radius */
     circleOfRadius?: number;
@@ -2794,8 +3119,8 @@ interface ShapeOptions extends EntityOptions, DrawableOptions {
     isAntialiased?: boolean;
 }
 
-declare class Shape extends Entity implements IDrawable, ShapeOptions {
-    readonly type = EntityType.Shape;
+declare class Shape extends M2Node implements IDrawable, ShapeOptions {
+    readonly type = M2NodeType.Shape;
     isDrawable: boolean;
     isShape: boolean;
     anchorPoint: {
@@ -2837,13 +3162,13 @@ declare class Shape extends Entity implements IDrawable, ShapeOptions {
     initialize(): void;
     dispose(): void;
     /**
-     * Duplicates an entity using deep copy.
+     * Duplicates a node using deep copy.
      *
-     * @remarks This is a deep recursive clone (entity and children).
-     * The uuid property of all duplicated entities will be newly created,
+     * @remarks This is a deep recursive clone (node and children).
+     * The uuid property of all duplicated nodes will be newly created,
      * because uuid must be unique.
      *
-     * @param newName - optional name of the new, duplicated entity. If not
+     * @param newName - optional name of the new, duplicated node. If not
      * provided, name will be the new uuid
      */
     duplicate(newName?: string): Shape;
@@ -2888,13 +3213,13 @@ declare class Shape extends Entity implements IDrawable, ShapeOptions {
     set strokeColorPaintNotAntialiased(value: Paint);
 }
 
-interface SpriteOptions extends EntityOptions, DrawableOptions {
+interface SpriteOptions extends M2NodeOptions, DrawableOptions {
     /** Name of image to use for sprite. Must have been previously loaded */
     imageName?: string;
 }
 
-declare class Sprite extends Entity implements IDrawable, SpriteOptions {
-    readonly type = EntityType.Sprite;
+declare class Sprite extends M2Node implements IDrawable, SpriteOptions {
+    readonly type = M2NodeType.Sprite;
     isDrawable: boolean;
     anchorPoint: {
         x: number;
@@ -2902,7 +3227,7 @@ declare class Sprite extends Entity implements IDrawable, SpriteOptions {
     };
     zPosition: number;
     private _imageName;
-    private loadedImage?;
+    private m2Image?;
     private _paint?;
     /**
      * Visual image displayed on the screen.
@@ -2919,13 +3244,13 @@ declare class Sprite extends Entity implements IDrawable, SpriteOptions {
     private set paint(value);
     private get paint();
     /**
-     * Duplicates an entity using deep copy.
+     * Duplicates a node using deep copy.
      *
-     * @remarks This is a deep recursive clone (entity and children).
-     * The uuid property of all duplicated entities will be newly created,
+     * @remarks This is a deep recursive clone (node and children).
+     * The uuid property of all duplicated nodes will be newly created,
      * because uuid must be unique.
      *
-     * @param newName - optional name of the new, duplicated entity. If not
+     * @param newName - optional name of the new, duplicated node. If not
      * provided, name will be the new uuid
      */
     duplicate(newName?: string): Sprite;
@@ -2939,15 +3264,15 @@ interface StoryOptions {
 }
 
 declare abstract class Story {
-    static Create(options: StoryOptions): Array<Scene>;
+    static create(options?: StoryOptions): Array<Scene>;
 }
 
-interface TextLineOptions extends EntityOptions, DrawableOptions, TextOptions {
+interface TextLineOptions extends M2NodeOptions, DrawableOptions, TextOptions {
     width?: number;
 }
 
-declare class TextLine extends Entity implements IDrawable, IText, TextLineOptions {
-    readonly type = EntityType.TextLine;
+declare class TextLine extends M2Node implements IDrawable, IText, TextLineOptions {
+    readonly type = M2NodeType.TextLine;
     isDrawable: boolean;
     isText: boolean;
     zPosition: number;
@@ -2983,15 +3308,26 @@ declare class TextLine extends Entity implements IDrawable, IText, TextLineOptio
     set fontSize(fontSize: number);
     update(): void;
     initialize(): void;
+    /**
+     * Determines the M2Font object that needs to be ready in order to draw
+     * the TextLine.
+     *
+     * @remarks It needs a FontManager because it may need to look up the
+     * default font.
+     *
+     * @param fontManager - {@link FontManager}
+     * @returns a M2Font object that is required for the TextLine
+     */
+    private getRequiredTextLineFont;
     dispose(): void;
     /**
-     * Duplicates an entity using deep copy.
+     * Duplicates a node using deep copy.
      *
-     * @remarks This is a deep recursive clone (entity and children).
-     * The uuid property of all duplicated entities will be newly created,
+     * @remarks This is a deep recursive clone (node and children).
+     * The uuid property of all duplicated nodes will be newly created,
      * because uuid must be unique.
      *
-     * @param newName - optional name of the new, duplicated entity. If not
+     * @param newName - optional name of the new, duplicated node. If not
      * provided, name will be the new uuid
      */
     duplicate(newName?: string): TextLine;
@@ -2999,6 +3335,9 @@ declare class TextLine extends Entity implements IDrawable, IText, TextLineOptio
     warmup(canvas: Canvas): void;
 }
 
+/**
+ * A class to create, start, and stop named timers that measure elapsed time in milliseconds.
+ */
 declare class Timer {
     private startTime;
     private stopTime;
@@ -3011,7 +3350,7 @@ declare class Timer {
     private cumulativeElapsed;
     private name;
     private static _timers;
-    constructor(name: string);
+    private constructor();
     /**
      * Aliases performance.now()
      *
@@ -3025,11 +3364,31 @@ declare class Timer {
      */
     static now(): number;
     /**
-     * Starts a millisecond-resolution timer based on
+     * Creates, but does not start, a new millisecond-resolution timer based on
      * [performance.now()](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now).
      *
-     * @remarks The method throws an error if a timer with the given
-     * name is already in a started state.
+     * @remarks If a timer with the given name already exists, it will be created
+     * and set back to zero, but not started.
+     *
+     * @param name - The name of the timer to be started
+     */
+    static new(name: string): void;
+    /**
+     * Creates and starts a new millisecond-resolution timer based on
+     * [performance.now()](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now).
+     *
+     * @remarks If a timer with the given name already exists, it will be created,
+     * set back to zero, and started.
+     *
+     * @param name - The name of the timer to be started
+     */
+    static startNew(name: string): void;
+    /**
+     * Starts a stopped millisecond-resolution timer based on
+     * [performance.now()](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now).
+     *
+     * @remarks The method throws an error if a timer with the given name does
+     * not exist or is not in a stopped state.
      *
      * @param name - The name of the timer to be started
      */
@@ -3044,17 +3403,6 @@ declare class Timer {
      * @param name - The name of the timer to be stopped
      */
     static stop(name: string): void;
-    /**
-     * Restarts a timer.
-     *
-     * @remarks The timer elapsed duration is set to 0 and it starts anew.
-     * The method throws an error if a timer with the given
-     * name does not exist (if there is not a started or stopped timer
-     * with the given name).
-     *
-     * @param name - The name of the timer to be restarted
-     */
-    static restart(name: string): void;
     /**
      * Returns the total time elapsed, in milliseconds, of the timer.
      *
@@ -3070,8 +3418,8 @@ declare class Timer {
      * Removes a timer.
      *
      * @remarks After removal, no additional methods can be used with a timer
-     * of the given name, other than to start a new timer with the given name,
-     * whose duration will begin at 0 again. The method throws an error if
+     * of the given name, other than to create a new timer with the given name,
+     * whose duration will be set at 0 again. The method throws an error if
      * a timer with the given name does not exist.
      *
      * @param name - The name of the timer to be removed
@@ -3263,4 +3611,4 @@ declare class WebGlInfo {
     static dispose(): void;
 }
 
-export { Action, type Activity, type ActivityKeyValueData, type ActivityLifecycleEvent, type ActivityResultsEvent, ActivityType, type BrowserImage, type CallbackOptions, CanvasKitHelpers, ColorfulMutablePath, Composite, type CompositeOptions, Constants, ConstraintType, type Constraints, CustomAction, type CustomActionOptions, type DefaultParameter, Dimensions, type DrawableOptions, type EasingFunction, Easings, Entity, type EntityEvent, type EntityEventListener, type EntityOptions, EntityType, Equals, type EventBase, type EventListenerBase, EventType, FadeAlphaAction, type FadeAlphaActionOptions, type FontData, FontManager, Game, type GameData, type GameOptions, type GameParameters, GlobalVariables, type GoToActivityOptions, GroupAction, I18n, type IDataStore, type IDrawable, type IText, ImageManager, Label, LabelHorizontalAlignmentMode, type LabelOptions, type Layout, LayoutConstraint, LoadedImage, type M2ColorfulPath, type M2DragEvent, type M2Path, type M2PointerEvent, MoveAction, type MoveActionOptions, MutablePath, NoneTransition, type Point, RandomDraws, type RectOptions, type RgbaColor, RotateAction, ScaleAction, type ScaleActionOptions, Scene, type SceneOptions, SceneTransition, SequenceAction, Session, type SessionDictionaryValues, type SessionLifecycleEvent, type SessionOptions, Shape, type ShapeOptions, ShapeType, type Size, SlideTransition, type SlideTransitionOptions, Sprite, type SpriteOptions, Story, type StoryOptions, type TapEvent, TextLine, type TextLineOptions, type TextOptions, Timer, Transition, TransitionDirection, TransitionType, type Translations, type TrialData, type TrialSchema, Uuid, WaitAction, type WaitActionOptions, WebColors, WebGlInfo, handleInterfaceOptions };
+export { Action, type Activity, type ActivityCallbacks, type ActivityEvent, type ActivityEventListener, type ActivityKeyValueData, type ActivityLifecycleEvent, type ActivityResultsEvent, ActivityType, type BrowserImage, type CallbackOptions, CanvasKitHelpers, ColorfulMutablePath, Composite, type CompositeOptions, Constants, ConstraintType, type Constraints, CustomAction, type CustomActionOptions, type DefaultParameter, Dimensions, type DrawableOptions, type EasingFunction, Easings, Equals, FadeAlphaAction, type FadeAlphaActionOptions, type FontAsset, type FontData, FontManager, Game, type GameData, type GameEvent, type GameOptions, type GameParameters, GlobalVariables, GroupAction, I18n, type IDataStore, type IDrawable, type IText, ImageManager, Label, LabelHorizontalAlignmentMode, type LabelOptions, type Layout, LayoutConstraint, LegacyTimer, type M2ColorfulPath, type M2DragEvent, type M2Event, type M2EventListener, M2EventType, type M2Image, M2ImageStatus, M2Node, type M2NodeEvent, type M2NodeEventListener, type M2NodeOptions, M2NodeType, type M2Path, type M2PointerEvent, M2c2KitHelpers, MoveAction, type MoveActionOptions, MutablePath, NoneTransition, type Plugin, type PluginEvent, type Point, RandomDraws, type RectOptions, type RgbaColor, RotateAction, ScaleAction, type ScaleActionOptions, Scene, type SceneOptions, SceneTransition, SequenceAction, Shape, type ShapeOptions, ShapeType, type Size, SlideTransition, type SlideTransitionOptions, Sprite, type SpriteOptions, Story, type StoryOptions, type TapEvent, TextLine, type TextLineOptions, type TextOptions, Timer, Transition, TransitionDirection, TransitionType, type Translations, type TrialData, type TrialSchema, Uuid, WaitAction, type WaitActionOptions, WebColors, WebGlInfo, handleInterfaceOptions };