@tldraw/editor 3.13.0-canary.77b2db3d8725 → 3.13.0-canary.87a0019c391d

package/dist-cjs/index.d.ts

@@ -1,12 +1,16 @@
 /// <reference types="react" />
 
 import { Atom } from '@tldraw/state';
+import { atom } from '@tldraw/state';
 import { BoxModel } from '@tldraw/tlschema';
 import { ComponentType } from 'react';
 import { Computed } from '@tldraw/state';
+import { computed } from '@tldraw/state';
 import { Dispatch } from 'react';
 import { Editor as Editor_2 } from '@tiptap/core';
 import { EditorProviderProps } from '@tiptap/react';
+import { EffectScheduler } from '@tldraw/state';
+import { EMPTY_ARRAY } from '@tldraw/state';
 import EventEmitter from 'eventemitter3';
 import { ExoticComponent } from 'react';
 import { HistoryEntry } from '@tldraw/store';
@@ -19,6 +23,7 @@ import { NamedExoticComponent } from 'react';
 import { Node as Node_2 } from '@tiptap/pm/model';
 import { PerformanceTracker } from '@tldraw/utils';
 import { PointerEventHandler } from 'react';
+import { react } from '@tldraw/state';
 import { default as React_2 } from 'react';
 import * as React_3 from 'react';
 import { ReactElement } from 'react';
@@ -77,8 +82,18 @@ import { TLStoreSnapshot } from '@tldraw/tlschema';
 import { TLUnknownBinding } from '@tldraw/tlschema';
 import { TLUnknownShape } from '@tldraw/tlschema';
 import { TLVideoAsset } from '@tldraw/tlschema';
+import { track } from '@tldraw/state-react';
+import { transact } from '@tldraw/state';
+import { transaction } from '@tldraw/state';
 import { UnknownRecord } from '@tldraw/store';
+import { useAtom } from '@tldraw/state-react';
+import { useComputed } from '@tldraw/state-react';
+import { useQuickReactor } from '@tldraw/state-react';
+import { useReactor } from '@tldraw/state-react';
+import { useStateTracking } from '@tldraw/state-react';
+import { useValue } from '@tldraw/state-react';
 import { VecModel } from '@tldraw/tlschema';
+import { whyAmIRunning } from '@tldraw/state';
 
 /* Excluded from this release type: activeElementShouldCaptureKeys */
 
@@ -121,8 +136,8 @@ export declare class Arc2d extends Geometry2d {
         start: Vec;
         sweepFlag: number;
     });
-    nearestPoint(point: VecLike): Vec;
-    hitTestLineSegment(A: VecLike, B: VecLike): boolean;
+    nearestPoint(point: Vec): Vec;
+    hitTestLineSegment(A: Vec, B: Vec): boolean;
     getVertices(): Vec[];
     getSvgPathData(first?: boolean): string;
     getLength(): number;
@@ -138,6 +153,10 @@ export declare class Arc2d extends Geometry2d {
  */
 export declare function areAnglesCompatible(a: number, b: number): boolean;
 
+export { Atom }
+
+export { atom }
+
 /** @public */
 export declare function average(A: VecLike, B: VecLike): string;
 
@@ -458,16 +477,12 @@ export declare class Box {
     set point(val: Vec);
     get minX(): number;
     set minX(n: number);
-    get left(): number;
     get midX(): number;
     get maxX(): number;
-    get right(): number;
     get minY(): number;
     set minY(n: number);
-    get top(): number;
     get midY(): number;
     get maxY(): number;
-    get bottom(): number;
     get width(): number;
     set width(n: number);
     get height(): number;
@@ -563,8 +578,8 @@ export declare class Circle2d extends Geometry2d {
     });
     getBounds(): Box;
     getVertices(): Vec[];
-    nearestPoint(point: VecLike): Vec;
-    hitTestLineSegment(A: VecLike, B: VecLike, distance?: number): boolean;
+    nearestPoint(point: Vec): Vec;
+    hitTestLineSegment(A: Vec, B: Vec, distance?: number): boolean;
     getSvgPathData(): string;
 }
 
@@ -641,6 +656,8 @@ export declare class ClickManager {
  */
 export declare function clockwiseAngleDist(a0: number, a1: number): number;
 
+export { computed }
+
 /**
  * @public
  * @react
@@ -728,10 +745,10 @@ export declare class CubicBezier2d extends Polyline2d {
     });
     getVertices(): Vec[];
     midPoint(): Vec;
-    nearestPoint(A: VecLike): Vec;
+    nearestPoint(A: Vec): Vec;
     getSvgPathData(first?: boolean): string;
     static GetAtT(segment: CubicBezier2d, t: number): Vec;
-    getLength(filters?: Geometry2dFilters, precision?: number): number;
+    getLength(precision?: number): number;
 }
 
 /** @public */
@@ -744,8 +761,8 @@ export declare class CubicSpline2d extends Geometry2d {
     get segments(): CubicBezier2d[];
     getLength(): number;
     getVertices(): Vec[];
-    nearestPoint(A: VecLike): Vec;
-    hitTestLineSegment(A: VecLike, B: VecLike): boolean;
+    nearestPoint(A: Vec): Vec;
+    hitTestLineSegment(A: Vec, B: Vec): boolean;
     getSvgPathData(): string;
 }
 
@@ -939,8 +956,8 @@ export declare class Edge2d extends Geometry2d {
     getLength(): number;
     midPoint(): Vec;
     getVertices(): Vec[];
-    nearestPoint(point: VecLike): Vec;
-    hitTestLineSegment(A: VecLike, B: VecLike, distance?: number): boolean;
+    nearestPoint(point: Vec): Vec;
+    hitTestLineSegment(A: Vec, B: Vec, distance?: number): boolean;
     getSvgPathData(first?: boolean): string;
 }
 
@@ -3977,6 +3994,8 @@ export declare class Editor extends EventEmitter<TLEventMap> {
 /** @public */
 export declare const EditorContext: React_2.Context<Editor | null>;
 
+export { EffectScheduler }
+
 /** @public */
 export declare class Ellipse2d extends Geometry2d {
     config: Omit<Geometry2dOptions, 'isClosed'> & {
@@ -3992,13 +4011,15 @@ export declare class Ellipse2d extends Geometry2d {
     _edges?: Edge2d[];
     get edges(): Edge2d[];
     getVertices(): any[];
-    nearestPoint(A: VecLike): Vec;
-    hitTestLineSegment(A: VecLike, B: VecLike): boolean;
+    nearestPoint(A: Vec): Vec;
+    hitTestLineSegment(A: Vec, B: Vec): boolean;
     getBounds(): Box;
     getLength(): number;
     getSvgPathData(first?: boolean): string;
 }
 
+export { EMPTY_ARRAY }
+
 /** @public */
 export declare class ErrorBoundary extends React_3.Component<React_3.PropsWithRef<React_3.PropsWithChildren<TLErrorBoundaryProps>>, {
     error: Error | null;
@@ -4066,27 +4087,18 @@ export declare abstract class Geometry2d {
     constructor(opts: Geometry2dOptions);
     isExcludedByFilter(filters?: Geometry2dFilters): boolean;
     abstract getVertices(filters: Geometry2dFilters): Vec[];
-    abstract nearestPoint(point: VecLike, _filters?: Geometry2dFilters): Vec;
-    hitTestPoint(point: VecLike, margin?: number, hitInside?: boolean, _filters?: Geometry2dFilters): boolean;
-    distanceToPoint(point: VecLike, hitInside?: boolean, filters?: Geometry2dFilters): number;
-    distanceToLineSegment(A: VecLike, B: VecLike, filters?: Geometry2dFilters): number;
-    hitTestLineSegment(A: VecLike, B: VecLike, distance?: number, filters?: Geometry2dFilters): boolean;
+    abstract nearestPoint(point: Vec, _filters?: Geometry2dFilters): Vec;
+    hitTestPoint(point: Vec, margin?: number, hitInside?: boolean, _filters?: Geometry2dFilters): boolean;
+    distanceToPoint(point: Vec, hitInside?: boolean, filters?: Geometry2dFilters): number;
+    distanceToLineSegment(A: Vec, B: Vec, filters?: Geometry2dFilters): number;
+    hitTestLineSegment(A: Vec, B: Vec, distance?: number, filters?: Geometry2dFilters): boolean;
     intersectLineSegment(A: VecLike, B: VecLike, _filters?: Geometry2dFilters): VecLike[];
     intersectCircle(center: VecLike, radius: number, _filters?: Geometry2dFilters): VecLike[];
     intersectPolygon(polygon: VecLike[], _filters?: Geometry2dFilters): VecLike[];
     intersectPolyline(polyline: VecLike[], _filters?: Geometry2dFilters): VecLike[];
-    /**
-     * Find a point along the edge of the geometry that is a fraction `t` along the entire way round.
-     */
-    interpolateAlongEdge(t: number, _filters?: Geometry2dFilters): Vec;
-    /**
-     * Take `point`, find the closest point to it on the edge of the geometry, and return how far
-     * along the edge it is as a fraction of the total length.
-     */
-    uninterpolateAlongEdge(point: VecLike, _filters?: Geometry2dFilters): number;
     /** @deprecated Iterate the vertices instead. */
-    nearestPointOnLineSegment(A: VecLike, B: VecLike): Vec;
-    isPointInBounds(point: VecLike, margin?: number): boolean;
+    nearestPointOnLineSegment(A: Vec, B: Vec): Vec;
+    isPointInBounds(point: Vec, margin?: number): boolean;
     transform(transform: MatModel, opts?: TransformedGeometry2dOptions): Geometry2d;
     private _vertices;
     get vertices(): Vec[];
@@ -4100,7 +4112,7 @@ export declare abstract class Geometry2d {
     toSimpleSvgPath(): string;
     private _length?;
     get length(): number;
-    getLength(_filters?: Geometry2dFilters): number;
+    getLength(): number;
     abstract getSvgPathData(first: boolean): string;
 }
 
@@ -4168,15 +4180,15 @@ export declare function getFreshUserPreferences(): TLUserPreferences;
 export declare function getIncrementedName(name: string, others: string[]): string;
 
 /** @public */
-export declare function getPerfectDashProps(totalLength: number, strokeWidth: number, opts?: {
-    closed?: boolean;
-    end?: 'none' | 'outset' | 'skip';
-    forceSolid?: boolean;
-    lengthRatio?: number;
-    snap?: number;
-    start?: 'none' | 'outset' | 'skip';
-    style?: TLDefaultDashStyle;
-}): {
+export declare function getPerfectDashProps(totalLength: number, strokeWidth: number, opts?: Partial<{
+    closed: boolean;
+    end: 'none' | 'outset' | 'skip';
+    forceSolid: boolean;
+    lengthRatio: number;
+    snap: number;
+    start: 'none' | 'outset' | 'skip';
+    style: TLDefaultDashStyle;
+}>): {
     strokeDasharray: string;
     strokeDashoffset: string;
 };
@@ -4263,20 +4275,18 @@ export declare class Group2d extends Geometry2d {
         children: Geometry2d[];
     });
     getVertices(filters: Geometry2dFilters): Vec[];
-    nearestPoint(point: VecLike, filters?: Geometry2dFilters): Vec;
-    distanceToPoint(point: VecLike, hitInside?: boolean, filters?: Geometry2dFilters): number;
-    hitTestPoint(point: VecLike, margin: number, hitInside: boolean, filters?: Geometry2dFilters): boolean;
-    hitTestLineSegment(A: VecLike, B: VecLike, zoom: number, filters?: Geometry2dFilters): boolean;
+    nearestPoint(point: Vec, filters?: Geometry2dFilters): Vec;
+    distanceToPoint(point: Vec, hitInside?: boolean, filters?: Geometry2dFilters): number;
+    hitTestPoint(point: Vec, margin: number, hitInside: boolean, filters?: Geometry2dFilters): boolean;
+    hitTestLineSegment(A: Vec, B: Vec, zoom: number, filters?: Geometry2dFilters): boolean;
     intersectLineSegment(A: VecLike, B: VecLike, filters?: Geometry2dFilters): VecLike[];
     intersectCircle(center: VecLike, radius: number, filters?: Geometry2dFilters): VecLike[];
     intersectPolygon(polygon: VecLike[], filters?: Geometry2dFilters): VecLike[];
     intersectPolyline(polyline: VecLike[], filters?: Geometry2dFilters): VecLike[];
-    interpolateAlongEdge(t: number, filters?: Geometry2dFilters): Vec;
-    uninterpolateAlongEdge(point: VecLike, filters?: Geometry2dFilters): number;
     transform(transform: Mat): Geometry2d;
     getArea(): number;
     toSimpleSvgPath(): string;
-    getLength(filters?: Geometry2dFilters): number;
+    getLength(): number;
     getSvgPathData(): string;
 }
 
@@ -4581,8 +4591,8 @@ export declare class Mat {
     static Identity(): Mat;
     static Translate(x: number, y: number): Mat;
     static Rotate(r: number, cx?: number, cy?: number): Mat;
-    static Scale(x: number, y: number): Mat;
-    static Scale(x: number, y: number, cx: number, cy: number): Mat;
+    static Scale(x: number, y: number): MatModel;
+    static Scale(x: number, y: number, cx: number, cy: number): MatModel;
     static Multiply(m1: MatModel, m2: MatModel): MatModel;
     static Inverse(m: MatModel): MatModel;
     static Absolute(m: MatLike): MatModel;
@@ -4677,7 +4687,7 @@ export declare class Point2d extends Geometry2d {
     });
     getVertices(): Vec[];
     nearestPoint(): Vec;
-    hitTestLineSegment(A: VecLike, B: VecLike, margin: number): boolean;
+    hitTestLineSegment(A: Vec, B: Vec, margin: number): boolean;
     getSvgPathData(): string;
 }
 
@@ -4722,8 +4732,8 @@ export declare class Polyline2d extends Geometry2d {
     get segments(): Edge2d[];
     getLength(): number;
     getVertices(): Vec[];
-    nearestPoint(A: VecLike): Vec;
-    hitTestLineSegment(A: VecLike, B: VecLike, distance?: number): boolean;
+    nearestPoint(A: Vec): Vec;
+    hitTestLineSegment(A: Vec, B: Vec, distance?: number): boolean;
     getSvgPathData(): string;
 }
 
@@ -4764,6 +4774,8 @@ export declare function radiansToDegrees(r: number): number;
  */
 export declare function rangeIntersection(a0: number, a1: number, b0: number, b1: number): [number, number] | null;
 
+export { react }
+
 /**
  * A map of {@link @tldraw/tlschema#StyleProp | StyleProps} to their {@link SharedStyle} values. See
  * {@link Editor.getSharedStyles}.
@@ -5438,14 +5450,7 @@ export declare abstract class ShapeUtil<Shape extends TLUnknownShape = TLUnknown
      */
     onClick?(shape: Shape): TLShapePartial<Shape> | void;
     /**
-     * A callback called when a shape starts being edited.
-     *
-     * @param shape - The shape.
-     * @public
-     */
-    onEditStart?(shape: Shape): void;
-    /**
-     * A callback called when a shape finishes being edited.
+     * A callback called when a shape finishes being editing.
      *
      * @param shape - The shape.
      * @public
@@ -5484,6 +5489,8 @@ export declare function shortAngleDist(a0: number, a1: number): number;
 /** @public */
 export declare const SIDES: readonly ["top", "right", "bottom", "left"];
 
+export { Signal }
+
 /** @public */
 export declare const SIN: (x: number) => number;
 
@@ -5535,8 +5542,8 @@ export declare class Stadium2d extends Geometry2d {
         height: number;
         width: number;
     });
-    nearestPoint(A: VecLike): Vec;
-    hitTestLineSegment(A: VecLike, B: VecLike): boolean;
+    nearestPoint(A: Vec): Vec;
+    hitTestLineSegment(A: Vec, B: Vec): boolean;
     getVertices(): Vec[];
     getBounds(): Box;
     getLength(): number;
@@ -5740,7 +5747,6 @@ export declare class TextManager {
         fontWeight: string;
         lineHeight: number;
         minWidth?: null | number;
-        otherStyles?: Record<string, string>;
         padding: string;
     }): BoxModel & {
         scrollWidth: number;
@@ -6779,7 +6785,6 @@ export declare interface TLMeasureTextSpanOpts {
     fontStyle: string;
     lineHeight: number;
     textAlign: TLDefaultHorizontalAlignStyle;
-    otherStyles?: Record<string, string>;
 }
 
 /** @public */
@@ -7417,6 +7422,12 @@ export declare function toFixed(v: number): number;
  */
 export declare function toPrecision(n: number, precision?: number): number;
 
+export { track }
+
+export { transact }
+
+export { transaction }
+
 /** @public */
 export declare class TransformedGeometry2d extends Geometry2d {
     private readonly geometry;
@@ -7425,13 +7436,13 @@ export declare class TransformedGeometry2d extends Geometry2d {
     private readonly decomposed;
     constructor(geometry: Geometry2d, matrix: MatModel, opts?: TransformedGeometry2dOptions);
     getVertices(filters: Geometry2dFilters): Vec[];
-    nearestPoint(point: VecLike, filters?: Geometry2dFilters): Vec;
-    hitTestPoint(point: VecLike, margin?: number, hitInside?: boolean, filters?: Geometry2dFilters): boolean;
-    distanceToPoint(point: VecLike, hitInside?: boolean, filters?: Geometry2dFilters): number;
-    distanceToLineSegment(A: VecLike, B: VecLike, filters?: Geometry2dFilters): number;
-    hitTestLineSegment(A: VecLike, B: VecLike, distance?: number, filters?: Geometry2dFilters): boolean;
-    intersectLineSegment(A: VecLike, B: VecLike, filters?: Geometry2dFilters): Vec[];
-    intersectCircle(center: VecLike, radius: number, filters?: Geometry2dFilters): Vec[];
+    nearestPoint(point: Vec, filters?: Geometry2dFilters): Vec;
+    hitTestPoint(point: Vec, margin?: number, hitInside?: boolean, filters?: Geometry2dFilters): boolean;
+    distanceToPoint(point: Vec, hitInside?: boolean, filters?: Geometry2dFilters): number;
+    distanceToLineSegment(A: Vec, B: Vec, filters?: Geometry2dFilters): number;
+    hitTestLineSegment(A: Vec, B: Vec, distance?: number, filters?: Geometry2dFilters): boolean;
+    intersectLineSegment(A: VecLike, B: VecLike, filters?: Geometry2dFilters): VecLike[];
+    intersectCircle(center: VecLike, radius: number, filters?: Geometry2dFilters): VecLike[];
     intersectPolygon(polygon: VecLike[], filters?: Geometry2dFilters): VecLike[];
     intersectPolyline(polyline: VecLike[], filters?: Geometry2dFilters): VecLike[];
     transform(transform: MatModel, opts?: TransformedGeometry2dOptions): Geometry2d;
@@ -7458,6 +7469,10 @@ export declare function uniq<T>(array: {
     readonly length: number;
 } | null | undefined): T[];
 
+export { useAtom }
+
+export { useComputed }
+
 /** @public */
 export declare function useContainer(): HTMLElement;
 
@@ -7527,9 +7542,12 @@ export declare function usePeerIds(): string[];
  */
 export declare function usePresence(userId: string): null | TLInstancePresence;
 
+export { useQuickReactor }
+
 /* Excluded from this release type: USER_COLORS */
 
 /* Excluded from this release type: useReactiveEvent */
+export { useReactor }
 
 /* Excluded from this release type: useRefState */
 
@@ -7592,6 +7610,8 @@ export declare function useSelectionEvents(handle: TLSelectionHandle): {
  */
 export declare function useSharedSafeId(id: string): SafeId;
 
+export { useStateTracking }
+
 /**
  * Returns the current SVG export context. Returns null if the component isn't being rendered for an
  * SVG export.
@@ -7625,6 +7645,8 @@ export declare function useTransform(ref: React.RefObject<HTMLElement | SVGEleme
  */
 export declare function useUniqueSafeId(suffix?: string): SafeId;
 
+export { useValue }
+
 /** @public */
 export declare function useViewportHeight(): number;
 
@@ -7696,7 +7718,6 @@ export declare class Vec {
     static Per(A: VecLike): Vec;
     static Abs(A: VecLike): Vec;
     static Dist(A: VecLike, B: VecLike): number;
-    static ManhattanDist(A: VecLike, B: VecLike): number;
     static DistMin(A: VecLike, B: VecLike, n: number): boolean;
     static Dist2(A: VecLike, B: VecLike): number;
     /**
@@ -7744,15 +7765,7 @@ export declare class Vec {
     static Cast(A: VecLike): Vec;
     static Slope(A: VecLike, B: VecLike): number;
     static IsNaN(A: VecLike): boolean;
-    /**
-     * Get the angle from position A to position B.
-     */
     static Angle(A: VecLike, B: VecLike): number;
-    /**
-     * Get the angle between vector A and vector B. This will return the smallest angle between the
-     * two vectors, between -π and π. The sign indicates direction of angle.
-     */
-    static AngleBetween(A: VecLike, B: VecLike): number;
     /**
      * Linearly interpolate between two points.
      * @param A - The first point.
@@ -7796,9 +7809,9 @@ export declare class Vec {
 /** @public */
 export declare type VecLike = Vec | VecModel;
 
+export { whyAmIRunning }
+
 
-export * from "@tldraw/state";
-export * from "@tldraw/state-react";
 export * from "@tldraw/store";
 export * from "@tldraw/tlschema";
 export * from "@tldraw/utils";

package/dist-cjs/index.js

@@ -50,11 +50,13 @@ __export(index_exports, {
   DefaultSpinner: () => import_DefaultSpinner.DefaultSpinner,
   DefaultSvgDefs: () => import_DefaultSvgDefs.DefaultSvgDefs,
   EASINGS: () => import_easings.EASINGS,
+  EMPTY_ARRAY: () => import_state.EMPTY_ARRAY,
   EVENT_NAME_MAP: () => import_event_types.EVENT_NAME_MAP,
   Edge2d: () => import_Edge2d.Edge2d,
   EdgeScrollManager: () => import_EdgeScrollManager.EdgeScrollManager,
   Editor: () => import_Editor.Editor,
   EditorContext: () => import_useEditor.EditorContext,
+  EffectScheduler: () => import_state.EffectScheduler,
   Ellipse2d: () => import_Ellipse2d.Ellipse2d,
   ErrorBoundary: () => import_ErrorBoundary.ErrorBoundary,
   ErrorScreen: () => import_TldrawEditor.ErrorScreen,
@@ -103,6 +105,7 @@ __export(index_exports, {
   applyRotationToSnapshotShapes: () => import_rotation.applyRotationToSnapshotShapes,
   approximately: () => import_utils2.approximately,
   areAnglesCompatible: () => import_utils2.areAnglesCompatible,
+  atom: () => import_state.atom,
   average: () => import_utils2.average,
   canonicalizeRotation: () => import_utils2.canonicalizeRotation,
   centerOfCircleFromThreePoints: () => import_utils2.centerOfCircleFromThreePoints,
@@ -110,6 +113,7 @@ __export(index_exports, {
   clampRadians: () => import_utils2.clampRadians,
   clampToBrowserMaxCanvasSize: () => import_browserCanvasMaxSize.clampToBrowserMaxCanvasSize,
   clockwiseAngleDist: () => import_utils2.clockwiseAngleDist,
+  computed: () => import_state.computed,
   coreShapes: () => import_defaultShapes.coreShapes,
   counterClockwiseAngleDist: () => import_utils2.counterClockwiseAngleDist,
   createDeepLinkString: () => import_deepLinks.createDeepLinkString,
@@ -172,6 +176,7 @@ __export(index_exports, {
   preventDefault: () => import_dom.preventDefault,
   radiansToDegrees: () => import_utils2.radiansToDegrees,
   rangeIntersection: () => import_utils2.rangeIntersection,
+  react: () => import_state.react,
   refreshPage: () => import_refreshPage.refreshPage,
   releasePointerCapture: () => import_dom.releasePointerCapture,
   resizeBox: () => import_resizeBox.resizeBox,
@@ -192,7 +197,12 @@ __export(index_exports, {
   toDomPrecision: () => import_utils2.toDomPrecision,
   toFixed: () => import_utils2.toFixed,
   toPrecision: () => import_utils2.toPrecision,
+  track: () => import_state_react.track,
+  transact: () => import_state.transact,
+  transaction: () => import_state.transaction,
   uniq: () => import_uniq.uniq,
+  useAtom: () => import_state_react.useAtom,
+  useComputed: () => import_state_react.useComputed,
   useContainer: () => import_useContainer.useContainer,
   useContainerIfExists: () => import_useContainer.useContainerIfExists,
   useDelaySvgExport: () => import_SvgExportContext.useDelaySvgExport,
@@ -210,20 +220,25 @@ __export(index_exports, {
   usePassThroughWheelEvents: () => import_usePassThroughWheelEvents.usePassThroughWheelEvents,
   usePeerIds: () => import_usePeerIds.usePeerIds,
   usePresence: () => import_usePresence.usePresence,
+  useQuickReactor: () => import_state_react.useQuickReactor,
   useReactiveEvent: () => import_useEvent.useReactiveEvent,
+  useReactor: () => import_state_react.useReactor,
   useRefState: () => import_useRefState.useRefState,
   useSelectionEvents: () => import_useSelectionEvents.useSelectionEvents,
   useShallowArrayIdentity: () => import_useIdentity.useShallowArrayIdentity,
   useShallowObjectIdentity: () => import_useIdentity.useShallowObjectIdentity,
   useSharedSafeId: () => import_useSafeId.useSharedSafeId,
+  useStateTracking: () => import_state_react.useStateTracking,
   useSvgExportContext: () => import_SvgExportContext.useSvgExportContext,
   useTLSchemaFromUtils: () => import_useTLStore.useTLSchemaFromUtils,
   useTLStore: () => import_useTLStore.useTLStore,
   useTldrawUser: () => import_createTLUser.useTldrawUser,
   useTransform: () => import_useTransform.useTransform,
   useUniqueSafeId: () => import_useSafeId.useUniqueSafeId,
+  useValue: () => import_state_react.useValue,
   useViewportHeight: () => import_useViewportHeight.useViewportHeight,
-  userTypeValidator: () => import_TLUserPreferences.userTypeValidator
+  userTypeValidator: () => import_TLUserPreferences.userTypeValidator,
+  whyAmIRunning: () => import_state.whyAmIRunning
 });
 module.exports = __toCommonJS(index_exports);
 var import_utils = require("@tldraw/utils");
@@ -232,8 +247,11 @@ var import_flat_map = require("core-js/stable/array/flat-map.js");
 var import_flat = require("core-js/stable/array/flat.js");
 var import_at2 = require("core-js/stable/string/at.js");
 var import_replace_all = require("core-js/stable/string/replace-all.js");
-__reExport(index_exports, require("@tldraw/state"), module.exports);
-__reExport(index_exports, require("@tldraw/state-react"), module.exports);
+var import_state = require("@tldraw/state");
+var import_state_react = require("@tldraw/state-react");
+var import_resizeScaled = require("./lib/editor/shapes/shared/resizeScaled");
+var import_richText = require("./lib/utils/richText");
+var import_LocalIndexedDb = require("./lib/utils/sync/LocalIndexedDb");
 __reExport(index_exports, require("@tldraw/store"), module.exports);
 __reExport(index_exports, require("@tldraw/tlschema"), module.exports);
 __reExport(index_exports, require("@tldraw/utils"), module.exports);
@@ -284,7 +302,6 @@ var import_ShapeUtil = require("./lib/editor/shapes/ShapeUtil");
 var import_GroupShapeUtil = require("./lib/editor/shapes/group/GroupShapeUtil");
 var import_getPerfectDashProps = require("./lib/editor/shapes/shared/getPerfectDashProps");
 var import_resizeBox = require("./lib/editor/shapes/shared/resizeBox");
-var import_resizeScaled = require("./lib/editor/shapes/shared/resizeScaled");
 var import_BaseBoxShapeTool = require("./lib/editor/tools/BaseBoxShapeTool/BaseBoxShapeTool");
 var import_Pointing = require("./lib/editor/tools/BaseBoxShapeTool/children/Pointing");
 var import_StateNode = require("./lib/editor/tools/StateNode");
@@ -349,10 +366,8 @@ var import_hardResetEditor = require("./lib/utils/hardResetEditor");
 var import_keyboard = require("./lib/utils/keyboard");
 var import_normalizeWheel = require("./lib/utils/normalizeWheel");
 var import_refreshPage = require("./lib/utils/refreshPage");
-var import_richText = require("./lib/utils/richText");
 var import_rotation = require("./lib/utils/rotation");
 var import_runtime = require("./lib/utils/runtime");
-var import_LocalIndexedDb = require("./lib/utils/sync/LocalIndexedDb");
 var import_hardReset = require("./lib/utils/sync/hardReset");
 var import_uniq = require("./lib/utils/uniq");
 var import_window_open = require("./lib/utils/window-open");
@@ -361,7 +376,7 @@ function debugEnableLicensing() {
 }
 (0, import_utils.registerTldrawLibraryVersion)(
   "@tldraw/editor",
-  "3.13.0-canary.77b2db3d8725",
+  "3.13.0-canary.87a0019c391d",
   "cjs"
 );
 //# sourceMappingURL=index.js.map