Fixes types

packages/core/src/renderer/components/canvas.tsx

 import { ErrorBoundary } from 'react-error-boundary'
 import { useZoomEvents, useSafariFocusOutFix, useCanvasEvents, useCameraCss } from '../hooks'
 import { ErrorFallback } from './error-fallback'
-import type { TLPage, TLPageState, TLShape } from '../../types'
+import type { TLBinding, TLPage, TLPageState, TLShape } from '../../types'
 
 import { Brush } from './brush'
 import { Defs } from './defs'
 }
 
 interface CanvasProps<T extends TLShape> {
-  page: TLPage<T>
+  page: TLPage<T, TLBinding>
   pageState: TLPageState
   hideBounds?: boolean
   hideHandles?: boolean

packages/core/src/renderer/components/page.tsx

 import * as React from 'react'
 import { useShapeTree } from '../hooks/useShapeTree'
-import type { IShapeTreeNode, TLPage, TLPageState, TLShape } from '../../types'
+import type { IShapeTreeNode, TLBinding, TLPage, TLPageState, TLShape } from '../../types'
 import { Shape as ShapeComponent } from './shape'
 import { useHandles, useRenderOnResize, useTLContext } from '../hooks'
 import { Bounds } from './bounds'
 import { Handles } from './handles'
 
 interface PageProps<T extends TLShape> {
-  page: TLPage<T>
+  page: TLPage<T, TLBinding>
   pageState: TLPageState
   hideBounds: boolean
   hideHandles: boolean

packages/core/src/renderer/hooks/useHandles.ts

-import type { TLPage, TLPageState, TLShape } from '../../types'
+import type { TLBinding, TLPage, TLPageState, TLShape } from '../../types'
 
-export function useHandles<T extends TLShape>(
-  page: TLPage<T>,
-  pageState: TLPageState
-) {
+export function useHandles<T extends TLShape>(page: TLPage<T, TLBinding>, pageState: TLPageState) {
   const { selectedIds } = pageState
 
   let shapeWithHandles: TLShape | undefined = undefined

packages/core/src/renderer/hooks/useSelection.tsx

-import type {
-  TLPage,
-  TLPageState,
-  TLShape,
-  TLBounds,
-  TLShapeUtils,
-} from '../../types'
+import type { TLPage, TLPageState, TLShape, TLBounds, TLShapeUtils, TLBinding } from '../../types'
 import Utils from '../../utils'
 import { useTLContext } from '../hooks/useTLContext'
 
-function canvasToScreen(
-  point: number[],
-  camera: TLPageState['camera']
-): number[] {
-  return [
-    (point[0] + camera.point[0]) * camera.zoom,
-    (point[1] + camera.point[1]) * camera.zoom,
-  ]
+function canvasToScreen(point: number[], camera: TLPageState['camera']): number[] {
+  return [(point[0] + camera.point[0]) * camera.zoom, (point[1] + camera.point[1]) * camera.zoom]
 }
 
 export function useSelection<T extends TLShape>(
-  page: TLPage<T>,
+  page: TLPage<T, TLBinding>,
   pageState: TLPageState,
   shapeUtils: TLShapeUtils<T>
 ) {
   }
 
   if (bounds) {
-    const [minX, minY] = canvasToScreen(
-      [bounds.minX, bounds.minY],
-      pageState.camera
-    )
-    const [maxX, maxY] = canvasToScreen(
-      [bounds.maxX, bounds.maxY],
-      pageState.camera
-    )
+    const [minX, minY] = canvasToScreen([bounds.minX, bounds.minY], pageState.camera)
+    const [maxX, maxY] = canvasToScreen([bounds.maxX, bounds.maxY], pageState.camera)
 
     rScreenBounds.current = {
       minX,

packages/core/src/renderer/hooks/useShapeTree.tsx

   TLShape,
   TLShapeUtils,
   TLCallbacks,
+  TLBinding,
 } from '../../types'
 import Utils, { Vec } from '../../utils'
 
 function addToShapeTree<T extends TLShape>(
   shape: TLShape,
   branch: IShapeTreeNode[],
-  shapes: TLPage<T>['shapes'],
+  shapes: TLPage<T, TLBinding>['shapes'],
   selectedIds: string[],
   info: {
     bindingId?: string
 }
 
 export function useShapeTree<T extends TLShape>(
-  page: TLPage<T>,
+  page: TLPage<T, TLBinding>,
   pageState: TLPageState,
   shapeUtils: TLShapeUtils<T>,
   onChange?: TLCallbacks['onChange']
 
     return (
       // TODO: Some shapes should always render (lines, rays)
-      Utils.boundsContain(viewport, shapeBounds) ||
-      Utils.boundsCollide(viewport, shapeBounds)
+      Utils.boundsContain(viewport, shapeBounds) || Utils.boundsCollide(viewport, shapeBounds)
     )
   })
 
 
   shapesToRender
     .sort((a, b) => a.childIndex - b.childIndex)
-    .forEach((shape) =>
-      addToShapeTree(shape, tree, page.shapes, selectedIds, pageState)
-    )
+    .forEach((shape) => addToShapeTree(shape, tree, page.shapes, selectedIds, pageState))
 
   return tree
 }

packages/core/src/renderer/renderer.tsx

   TLShapeUtils,
   TLTheme,
   TLBounds,
+  TLBinding,
 } from '../types'
 import { Canvas } from './components/canvas'
 import { useTLTheme } from './hooks/useStyle'
   extends Partial<TLSettings>,
     Partial<TLCallbacks> {
   shapeUtils: TLShapeUtils<T>
-  page: TLPage<T>
+  page: TLPage<T, TLBinding>
   pageState: TLPageState
   theme?: Partial<TLTheme>
   hideBounds?: boolean

packages/core/src/types.tsx

 /* --------------------- Primary -------------------- */
 
-export interface TLPage<T extends TLShape> {
+export interface TLPage<T extends TLShape, B extends TLBinding> {
   id: string
   name?: string
   childIndex?: number
   shapes: Record<string, T>
-  bindings: Record<string, TLBinding>
+  bindings: Record<string, B>
   backgroundColor?: string
 }
 

packages/tldraw/tsconfig.json

     "jsx": "preserve",
     "lib": ["dom", "esnext"],
     "module": "esnext",
-    "outDir": "./dist/types"
+    "outDir": "./dist/types",
+    "paths": {
+      "@tldraw/core": ["packages/core/dist"]
+    }
   }
 }