diff --git a/src/foundry/client-esm/applications/api/application.d.mts b/src/foundry/client-esm/applications/api/application.d.mts
index a82571399..9873ef904 100644
--- a/src/foundry/client-esm/applications/api/application.d.mts
+++ b/src/foundry/client-esm/applications/api/application.d.mts
@@ -1,4 +1,11 @@
-import type { MustConform, AnyObject, DeepPartial, EmptyObject, InexactPartial, MaybePromise } from "../../../../utils/index.d.mts";
+import type {
+  MustConform,
+  AnyObject,
+  DeepPartial,
+  EmptyObject,
+  InexactPartial,
+  MaybePromise,
+} from "../../../../utils/index.d.mts";
 import type EventEmitterMixin from "../../../common/utils/event-emitter.d.mts";
 
 // TODO: Investigate use of DeepPartial vs Partial vs InexactPartial
diff --git a/src/foundry/client-esm/canvas/sources/base-effect-source.d.mts b/src/foundry/client-esm/canvas/sources/base-effect-source.d.mts
index 9328b0960..a449e2511 100644
--- a/src/foundry/client-esm/canvas/sources/base-effect-source.d.mts
+++ b/src/foundry/client-esm/canvas/sources/base-effect-source.d.mts
@@ -1,4 +1,4 @@
-import type { InexactPartial } from "../../../../utils/index.d.mts";
+import type { NullishProps, IntentionalPartial } from "../../../../utils/index.d.mts";
 
 /**
  * TODO - Re-document after ESM refactor.
@@ -14,15 +14,16 @@ import type { InexactPartial } from "../../../../utils/index.d.mts";
  * ```
  * @privateRemarks The TODO is foundry's
  */
-declare class BaseEffectSource<
-  SourceData extends BaseEffectSource.BaseEffectSourceData,
+declare abstract class BaseEffectSource<
+  SourceData extends BaseEffectSource.SourceData,
   SourceShape extends PIXI.Polygon,
 > {
   /**
    * An effect source is constructed by providing configuration options.
    * @param options - Options which modify the base effect source instance
+   * @remarks Passing a PlaceableObject is deprecated, and will be removed in v13
    */
-  constructor(options?: BaseEffectSource.BaseEffectSourceOptions);
+  constructor(options?: BaseEffectSource.SourceOptions | PlaceableObject);
 
   /**
    * The type of source represented by this data structure.
@@ -47,7 +48,7 @@ declare class BaseEffectSource<
    * }
    * ```
    */
-  static defaultData: BaseEffectSource.BaseEffectSourceData;
+  static defaultData: BaseEffectSource.SourceData;
 
   /**
    * Some other object which is responsible for this source.
@@ -56,8 +57,9 @@ declare class BaseEffectSource<
 
   /**
    * The source id linked to this effect source.
+   * @remarks Foundry types this as Readonly<string>, but does nothing to that effect at runtime
    */
-  readonly sourceId: string;
+  sourceId: string | undefined;
 
   /**
    * The data of this source.
@@ -66,8 +68,9 @@ declare class BaseEffectSource<
 
   /**
    * The geometric shape of the effect source which is generated later.
+   * @remarks This only isn't `undefined` in subclasses implementing `_createShapes()`, usually via {@link PointEffectSourceMixin}
    */
-  shape: SourceShape;
+  shape: SourceShape | undefined;
 
   /**
    * A collection of boolean flags which control rendering and refresh behavior for the source.
@@ -129,14 +132,14 @@ declare class BaseEffectSource<
    * @returns The initialized source
    */
   initialize(
-    data?: InexactPartial<SourceData>,
-    options?: InexactPartial<{
-      // The type def references a behaviors object that is not even passed into the function
+    data?: NullishProps<SourceData>,
+    /** @privateRemarks Foundry describes an `options.behaviors` key, but it is neither checked for nor used at runtime */
+    options?: NullishProps<{
       /**
        * Should source data be reset to default values before applying changes?
        * @defaultValue `false`
        */
-      reset?: boolean;
+      reset: boolean;
     }>,
   ): this;
 
@@ -144,7 +147,10 @@ declare class BaseEffectSource<
    * Subclass specific data initialization steps.
    * @param data - Provided data for configuration
    */
-  _initialize(data: Partial<SourceData>): void;
+  _initialize(
+    /** @remarks IntentionalPartial because `this.initialize` has filtered invalid keys and replaced any nullish values before calling this */
+    data: IntentionalPartial<SourceData>,
+  ): void;
 
   /**
    * Create the polygon shape (or shapes) for this source using configured data.
@@ -155,8 +161,9 @@ declare class BaseEffectSource<
    * Subclass specific configuration steps. Occurs after data initialization and shape computation.
    * Only called if the source is attached and not disabled.
    * @param changes - Changes to the source data which were applied
+   * @remarks This is actually passed *flattened* partial data
    */
-  protected _configure(changes: Partial<SourceData>): void;
+  protected _configure(changes: IntentionalPartial<SourceData>): void;
 
   /**
    * Refresh the state and uniforms of the source.
@@ -211,19 +218,25 @@ declare class BaseEffectSource<
 declare namespace BaseEffectSource {
   type AnyConstructor = typeof AnyBaseEffectSource;
 
-  interface BaseEffectSourceOptions {
+  /** @internal */
+  type _SourceOptions = NullishProps<{
     /**
      * An optional PlaceableObject which is responsible for this source
      */
-    object?: PlaceableObject | undefined;
+    object: PlaceableObject;
+  }>;
+
+  interface SourceOptions extends _SourceOptions {
     /**
      * A unique ID for this source. This will be set automatically if an
      * object is provided, otherwise is required.
+     * @remarks The above is misleading; sourceId will *not* be inferred if you pass in `{object: PlaceableObject}`,
+     * only if you pass a `PlaceableObject` *instead* of an options object to the constructor.
      */
-    sourceId?: string | undefined;
+    sourceId?: string;
   }
 
-  interface BaseEffectSourceData {
+  interface SourceData {
     /**
      * The x-coordinate of the source location
      */
diff --git a/src/foundry/client-esm/canvas/sources/base-light-source.d.mts b/src/foundry/client-esm/canvas/sources/base-light-source.d.mts
index 53ca1d2ec..76322100b 100644
--- a/src/foundry/client-esm/canvas/sources/base-light-source.d.mts
+++ b/src/foundry/client-esm/canvas/sources/base-light-source.d.mts
@@ -1,13 +1,13 @@
-import type { InexactPartial } from "../../../../utils/index.d.mts";
+import type { InexactPartial, IntentionalPartial } from "../../../../utils/index.d.mts";
 import type RenderedEffectSource from "./rendered-effect-source.d.mts";
 
 /**
  * A specialized subclass of BaseEffectSource which deals with the rendering of light or darkness.
  */
-declare class BaseLightSource<
-  SourceData extends BaseLightSource.LightSourceData = BaseLightSource.LightSourceData,
+declare abstract class BaseLightSource<
+  SourceData extends BaseLightSource.SourceData = BaseLightSource.SourceData,
   SourceShape extends PIXI.Polygon = PIXI.Polygon,
-  RenderingLayers extends Record<string, RenderedEffectSource.RenderedEffectSourceLayer> = RenderedEffectSource.Layers,
+  RenderingLayers extends Record<string, RenderedEffectSource.SourceLayer> = RenderedEffectSource.Layers,
 > extends RenderedEffectSource<SourceData, SourceShape, RenderingLayers> {
   /** @defaultValue `"light"` */
   static override sourceType: string;
@@ -20,18 +20,22 @@ declare class BaseLightSource<
 
   /**
    * The corresponding lighting levels for dim light.
+   * @defaultValue `foundry.CONST.LIGHTING_LEVELS.DIM`
    */
   protected static _dimLightingLevel: foundry.CONST.LIGHTING_LEVELS;
 
   /**
    * The corresponding lighting levels for bright light.
+   * @defaultValue `foundry.CONST.LIGHTING_LEVELS.BRIGHT`
    */
   protected static _brightLightingLevel: foundry.CONST.LIGHTING_LEVELS;
 
   /**
    * The corresponding animation config.
+   * @remarks More broad than it should be to accomodate {@link foundry.canvas.sources.PointDarknessSource}
+   * TODO: Reevaluate after CONFIG has been gone over
    */
-  protected static get ANIMATIONS(): CONFIG.Canvas.LightSourceAnimationConfig;
+  protected static get ANIMATIONS(): typeof CONFIG.Canvas.lightAnimations | typeof CONFIG.Canvas.darknessAnimations;
 
   /**
    * @defaultValue
@@ -52,14 +56,14 @@ declare class BaseLightSource<
    * }
    * ```
    */
-  static override defaultData: RenderedEffectSource.RenderedEffectSourceData;
+  static override defaultData: BaseLightSource.SourceData;
 
   /**
    * A ratio of dim:bright as part of the source radius
    */
   ratio: number;
 
-  override _initialize(data: Partial<SourceData>): void;
+  override _initialize(data: IntentionalPartial<SourceData>): void;
 
   override _updateColorationUniforms(): void;
 
@@ -69,12 +73,18 @@ declare class BaseLightSource<
 
   override _updateCommonUniforms(shader: AbstractBaseShader): void;
 
+  /** @remarks This property is undocumented, and only defined during `_updateCommonUniforms` */
+  cachededAttentuation?: number;
+
+  /** @remarks This property is undocumented, and only defined during `_updateCommonUniforms` */
+  computedAttentuation?: number;
+
   /**
    * An animation with flickering ratio and light intensity.
    * @param dt      - Delta time
    * @param options - Additional options which modify the torch animation
    */
-  animateTorch(dt: number, options?: InexactPartial<RenderedEffectSource.AnimationOptions>): void;
+  animateTorch(dt: number, options?: RenderedEffectSource.AnimationFunctionOptions): void;
 
   /**
    * An animation with flickering ratio and light intensity
@@ -83,72 +93,96 @@ declare class BaseLightSource<
    */
   animateFlickering(
     dt: number,
-    options?: InexactPartial<
-      RenderedEffectSource.AnimationOptions & {
+    options?: RenderedEffectSource.AnimationFunctionOptions &
+      InexactPartial<{
         /**
          * Noise amplification (\>1) or dampening (\<1)
          * @defaultValue `1`
          */
         amplification: number;
-      }
-    >,
+      }>,
   ): void;
 
+  /**
+   * @remarks This property will be generated on any class that is `animateFlickering`'s `this` when it is called.
+   * Foundry does not document it.
+   */
+  _noise?: SmoothNoise;
+
   /**
    * A basic "pulse" animation which expands and contracts.
    * @param dt      - Delta time
    * @param options - Additional options which modify the pulse animation
    */
-  animatePulse(dt: number, options?: InexactPartial<RenderedEffectSource.AnimationOptions>): void;
+  animatePulse(dt: number, options?: RenderedEffectSource.AnimationFunctionOptions): void;
 
   /**
-   * @deprecated since v12
+   * @deprecated since v12, until v14
+   * @remarks "BaseLightSource#isDarkness is now obsolete. Use DarknessSource instead."
    */
   get isDarkness(): boolean;
 }
 
 declare namespace BaseLightSource {
-  interface LightSourceData extends RenderedEffectSource.RenderedEffectSourceData {
+  type AnyConstructor = typeof AnyBaseLightSource;
+
+  type LightAnimationFunction = (
+    this: BaseLightSource,
+    dt: number,
+    options?: RenderedEffectSource.AnimationFunctionOptions,
+  ) => void;
+
+  interface SourceData extends RenderedEffectSource.SourceData {
     /**
      * An opacity for the emitted light, if any
      */
     alpha: number;
+
     /**
      * The allowed radius of bright vision or illumination
      */
     bright: number;
+
     /**
      * The coloration technique applied in the shader
      */
     coloration: number;
+
     /**
      * The amount of contrast this light applies to the background texture
      */
     contrast: number;
+
     /**
      * The allowed radius of dim vision or illumination
      */
     dim: number;
+
     /**
      * Strength of the attenuation between bright, dim, and dark
      */
     attenuation: number;
+
     /**
      * The luminosity applied in the shader
      */
     luminosity: number;
+
     /**
      * The amount of color saturation this light applies to the background texture
      */
     saturation: number;
+
     /**
      * The depth of shadows this light applies to the background texture
      */
     shadows: number;
+
     /**
      * Whether or not this source provides a source of vision
      */
     vision: boolean;
+
     /**
      * Strength of this source to beat or not negative/positive sources
      */
@@ -156,4 +190,8 @@ declare namespace BaseLightSource {
   }
 }
 
+declare abstract class AnyBaseLightSource extends BaseLightSource {
+  constructor(arg0: never, ...args: never[]);
+}
+
 export default BaseLightSource;
diff --git a/src/foundry/client-esm/canvas/sources/global-light-source.d.mts b/src/foundry/client-esm/canvas/sources/global-light-source.d.mts
index aef6f5e5e..53987b285 100644
--- a/src/foundry/client-esm/canvas/sources/global-light-source.d.mts
+++ b/src/foundry/client-esm/canvas/sources/global-light-source.d.mts
@@ -26,16 +26,18 @@ export default class GlobalLightSource extends BaseLightSource {
    * }
    * ```
    */
-  static override defaultData: BaseLightSource.LightSourceData;
+  static override defaultData: BaseLightSource.SourceData;
 
   /**
    * Name of this global light source.
-   * @defaultValue GlobalLightSource.sourceType
+   * @defaultValue `GlobalLightSource.sourceType`
    */
   name: string;
 
   /**
    * A custom polygon placeholder.
+   * @defaultValue `null`
+   * @remarks This is not set anywhere in Foundry code, so will always be null barring system/module/user action
    */
   customPolygon: PIXI.Polygon | number[] | null;
 
@@ -44,4 +46,6 @@ export default class GlobalLightSource extends BaseLightSource {
   override _initializeSoftEdges(): void;
 
   override _updateGeometry(): void;
+
+  override _updateCommonUniforms(shader: AbstractBaseShader): void;
 }
diff --git a/src/foundry/client-esm/canvas/sources/point-darkness-source.d.mts b/src/foundry/client-esm/canvas/sources/point-darkness-source.d.mts
index 3f436d081..e8a998584 100644
--- a/src/foundry/client-esm/canvas/sources/point-darkness-source.d.mts
+++ b/src/foundry/client-esm/canvas/sources/point-darkness-source.d.mts
@@ -1,45 +1,48 @@
+import type { IntentionalPartial } from "../../../../utils/index.d.mts";
 import type BaseLightSource from "./base-light-source.d.mts";
 import type PointEffectSourceMixin from "./point-effect-source.d.mts";
 import type RenderedEffectSource from "./rendered-effect-source.d.mts";
 
-type DarknessSourceData = BaseLightSource.LightSourceData & PointEffectSourceMixin.PointEffectSourceData;
-
-// Interface causes errors
-// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-type DarknessLayers = {
-  darkness: RenderedEffectSource.RenderedEffectSourceLayer;
-};
-
 /**
  * A specialized subclass of the BaseLightSource which renders a source of darkness as a point-based effect.
  */
-export default class PointDarknessSource<
-  SourceData extends DarknessSourceData = DarknessSourceData,
+declare class PointDarknessSource<
+  SourceData extends PointDarknessSource.SourceData = PointDarknessSource.SourceData,
   SourceShape extends PointSourcePolygon = PointSourcePolygon,
-> extends PointEffectSourceMixin(BaseLightSource)<SourceData, SourceShape, DarknessLayers> {
+> extends PointEffectSourceMixin(BaseLightSource)<SourceData, SourceShape, PointDarknessSource.Layers> {
   /** @defaultValue `"darknessSources"` */
   static override effectsCollection: string;
 
-  /** @defaultValue `LIGHTING_LEVELS.HALFDARK` */
+  /** @defaultValue `foundry.CONST.LIGHTING_LEVELS.HALFDARK` */
   static override _dimLightingLevel: foundry.CONST.LIGHTING_LEVELS;
 
-  /** @defaultValue `LIGHTING_LEVELS.DARKNESS` */
+  /** @defaultValue `foundry.CONST.LIGHTING_LEVELS.DARKNESS` */
   static override _brightLightingLevel: foundry.CONST.LIGHTING_LEVELS;
 
   /** @defaultValue `CONFIG.Canvas.darknessAnimations` */
-  static get ANIMATIONS(): CONFIG.Canvas.LightSourceAnimationConfig;
+  static get ANIMATIONS(): typeof CONFIG.Canvas.darknessAnimations;
+
+  static override get _layers(): Record<string, foundry.canvas.sources.RenderedEffectSource.LayerConfig>;
 
-  static override get _layers(): Record<string, foundry.canvas.sources.RenderedEffectSource.RenderedEffectLayerConfig>;
+  /** @privateRemarks This is not in Foundry's code, but accounts for the mixin class's static property's inability to be generic */
+  static override defaultData: PointDarknessSource.SourceData;
 
   /**
    * The optional geometric shape is solely utilized for visual representation regarding darkness sources.
    * Used only when an additional radius is added for visuals.
    */
-  protected _visualShape: SourceShape;
+  protected _visualShape: SourceShape | null;
+
+  /**
+   * @privateRemarks This is not in foundry's code, but since this class (and its parent) implements `_createShapes`,
+   * and we are counting what happens in `initialize` as 'the constructor', this gets to be declared never undefined.
+   */
+  override shape: SourceShape;
 
   /**
    * Padding applied on the darkness source shape for visual appearance only.
    * Note: for now, padding is increased radius. It might evolve in a future release.
+   * @defaultValue `(CONFIG.Canvas.darknessSourcePaddingMultiplier ?? 0) * canvas.grid.size`
    */
   protected _padding: number;
 
@@ -48,9 +51,16 @@ export default class PointDarknessSource<
    */
   edges: foundry.canvas.edges.Edge[];
 
+  /**
+   * A convenience accessor to the darkness layer mesh.
+   */
+  get darkness(): this["layers"]["darkness"]["mesh"];
+
+  override _initialize(data: IntentionalPartial<SourceData>): void;
+
   override _createShapes(): void;
 
-  override _configure(changes: Partial<SourceData>): void;
+  override _configure(changes: IntentionalPartial<SourceData>): void;
 
   override _getPolygonConfiguration(): PointSourcePolygonConfig;
 
@@ -66,9 +76,26 @@ export default class PointDarknessSource<
   override _destroy(): void;
 
   /**
-   * A convenience accessor to the darkness layer mesh.
    * @deprecated since v12, until v14
    * @remarks `"BaseLightSource#isDarkness is now obsolete. Use DarknessSource instead."`
    */
-  get darkness(): PointSourceMesh;
+  get isDarkness(): boolean;
 }
+
+declare namespace PointDarknessSource {
+  type AnyConstructor = typeof AnyPointDarknessSource;
+
+  type SourceData = BaseLightSource.SourceData & PointEffectSourceMixin.SourceData;
+
+  // Interface would require `RenderingLayers extends ... = InterfaceToObject<Layers>` in every subclass signature
+  // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+  type Layers = {
+    darkness: RenderedEffectSource.SourceLayer;
+  };
+}
+
+declare abstract class AnyPointDarknessSource extends PointDarknessSource {
+  constructor(arg0: never, ...args: never[]);
+}
+
+export default PointDarknessSource;
diff --git a/src/foundry/client-esm/canvas/sources/point-effect-source.d.mts b/src/foundry/client-esm/canvas/sources/point-effect-source.d.mts
index a129fa195..632f71210 100644
--- a/src/foundry/client-esm/canvas/sources/point-effect-source.d.mts
+++ b/src/foundry/client-esm/canvas/sources/point-effect-source.d.mts
@@ -1,4 +1,4 @@
-import type { Mixin } from "../../../../utils/index.d.mts";
+import type { Mixin, IntentionalPartial } from "../../../../utils/index.d.mts";
 import type BaseEffectSource from "./base-effect-source.d.mts";
 
 declare class PointEffectSource {
@@ -17,21 +17,27 @@ declare class PointEffectSource {
    * walls: true
    * }
    * ```
+   * @privateRemarks This will only be accurate for classes extending `PointEffectSourceMixin(BaseEffectSource)`.
+   * Other subclasses must override this.
    */
-  static defaultData: PointEffectSourceMixin.PointEffectSourceData;
+  static defaultData: PointEffectSourceMixin.MixedSourceData;
+
+  /** @privateRemarks This is not in Foundry's code, but the mixin class loses access to the type parameter that would otherwise be here */
+  shape: PointSourcePolygon;
 
   /**
    * A convenience reference to the radius of the source.
    */
   get radius(): number;
 
-  _initialize(data: Partial<PointEffectSourceMixin.PointEffectSourceData>): void;
+  _initialize(data: IntentionalPartial<PointEffectSourceMixin.MixedSourceData>): void;
 
   _initializeSoftEdges(): void;
 
   /**
    * Configure the parameters of the polygon that is generated for this source.
    */
+  //TODO: Make sure this is accurate as part of work on "pixi leftovers"
   protected _getPolygonConfiguration(): PointSourcePolygonConfig;
 
   _createShapes(): void;
@@ -66,7 +72,9 @@ declare function PointEffectSourceMixin<BaseClass extends BaseEffectSource.AnyCo
 declare namespace PointEffectSourceMixin {
   type AnyMixed = ReturnType<typeof PointEffectSourceMixin<BaseEffectSource.AnyConstructor>>;
 
-  interface PointEffectSourceData extends BaseEffectSource.BaseEffectSourceData {
+  type MixedSourceData = SourceData & BaseEffectSource.SourceData;
+
+  interface SourceData {
     /**
      * The radius of the source
      */
diff --git a/src/foundry/client-esm/canvas/sources/point-light-source.d.mts b/src/foundry/client-esm/canvas/sources/point-light-source.d.mts
index 83f22e259..6a88d127c 100644
--- a/src/foundry/client-esm/canvas/sources/point-light-source.d.mts
+++ b/src/foundry/client-esm/canvas/sources/point-light-source.d.mts
@@ -1,23 +1,28 @@
+import type { IntentionalPartial } from "../../../../utils/index.d.mts";
 import type BaseLightSource from "./base-light-source.d.mts";
 import type PointEffectSourceMixin from "./point-effect-source.d.mts";
 
-type LightSourceData = PointEffectSourceMixin.PointEffectSourceData & BaseLightSource.LightSourceData;
-
 /**
  * A specialized subclass of the BaseLightSource which renders a source of light as a point-based effect.
  */
-export default class PointLightSource<
-  SourceData extends LightSourceData = LightSourceData,
+declare class PointLightSource<
+  SourceData extends PointLightSource.SourceData = PointLightSource.SourceData,
   SourceShape extends PointSourcePolygon = PointSourcePolygon,
 > extends PointEffectSourceMixin(BaseLightSource)<SourceData, SourceShape> {
   /** @defaultValue `"lightSources"` */
   static override effectsCollection: string;
 
-  override _initialize(data: Partial<SourceData>): void;
+  /**
+   * @privateRemarks This is not in foundry's code, but since this class (and its parent) implements `_createShapes`,
+   * and we are counting what happens in `initialize` as 'the constructor', this gets to be declared never undefined.
+   */
+  override shape: SourceShape;
+
+  override _initialize(data: IntentionalPartial<SourceData>): void;
 
   override _createShapes(): void;
 
-  override _configure(changes: Partial<SourceData>): void;
+  override _configure(changes: IntentionalPartial<SourceData>): void;
 
   override _getPolygonConfiguration(): PointSourcePolygonConfig;
 
@@ -26,12 +31,7 @@ export default class PointLightSource<
    * @param config - The visibility test configuration
    * @returns Is the target object visible to this source?
    */
-  testVisibility(config: {
-    /** The sequence of tests to perform */
-    tests: CanvasVisibilityTest[];
-    /** The target object being tested */
-    object: PlaceableObject;
-  }): boolean;
+  testVisibility(config?: CanvasVisibilityTestConfig): boolean;
 
   /**
    * Can this LightSource theoretically detect a certain object based on its properties?
@@ -39,5 +39,17 @@ export default class PointLightSource<
    * @param target - The target object being tested
    * @returns Can the target object theoretically be detected by this vision source?
    */
-  _canDetectObject(target: PlaceableObject): boolean;
+  _canDetectObject(target?: PlaceableObject | null): boolean;
+}
+
+declare namespace PointLightSource {
+  type AnyConstructor = typeof AnyPointLightSource;
+
+  type SourceData = PointEffectSourceMixin.SourceData & BaseLightSource.SourceData;
 }
+
+declare abstract class AnyPointLightSource extends PointLightSource {
+  constructor(arg0: never, ...args: never[]);
+}
+
+export default PointLightSource;
diff --git a/src/foundry/client-esm/canvas/sources/point-movement-source.d.mts b/src/foundry/client-esm/canvas/sources/point-movement-source.d.mts
index 345cdb386..0bd9111b2 100644
--- a/src/foundry/client-esm/canvas/sources/point-movement-source.d.mts
+++ b/src/foundry/client-esm/canvas/sources/point-movement-source.d.mts
@@ -1,15 +1,31 @@
 import type BaseEffectSource from "./base-effect-source.d.mts";
 import type PointEffectSourceMixin from "./point-effect-source.d.mts";
 
-type MovementSourceData = PointEffectSourceMixin.PointEffectSourceData & BaseEffectSource.BaseEffectSourceData;
-
 /**
  * A specialized subclass of the BaseEffectSource which describes a movement-based source.
  */
-export default class PointMovementSource<
-  SourceData extends MovementSourceData = MovementSourceData,
+declare class PointMovementSource<
+  SourceData extends PointMovementSource.SourceData = PointMovementSource.SourceData,
   SourceShape extends PointSourcePolygon = PointSourcePolygon,
 > extends PointEffectSourceMixin(BaseEffectSource)<SourceData, SourceShape> {
   /** @defaultValue `"move"` */
   static override sourceType: string;
+
+  /**
+   * @privateRemarks This is not in foundry's code, but since this class (and its parent) implements `_createShapes`,
+   * and we are counting what happens in `initialize` as 'the constructor', this gets to be declared never undefined.
+   */
+  override shape: SourceShape;
+}
+
+declare namespace PointMovementSource {
+  type AnyConstructor = typeof AnyPointMovementSource;
+
+  type SourceData = PointEffectSourceMixin.MixedSourceData;
+}
+
+declare abstract class AnyPointMovementSource extends PointMovementSource {
+  constructor(arg0: never, ...args: never[]);
 }
+
+export default PointMovementSource;
diff --git a/src/foundry/client-esm/canvas/sources/point-sound-source.d.mts b/src/foundry/client-esm/canvas/sources/point-sound-source.d.mts
index dc92ef944..e39328ce9 100644
--- a/src/foundry/client-esm/canvas/sources/point-sound-source.d.mts
+++ b/src/foundry/client-esm/canvas/sources/point-sound-source.d.mts
@@ -1,18 +1,23 @@
+import type { NullishProps } from "../../../../utils/index.d.mts";
 import type BaseEffectSource from "./base-effect-source.d.mts";
 import type PointEffectSourceMixin from "./point-effect-source.d.mts";
 
-type SoundSourceData = PointEffectSourceMixin.PointEffectSourceData & BaseEffectSource.BaseEffectSourceData;
-
 /**
  * A specialized subclass of the BaseEffectSource which describes a point-based source of sound.
  */
-export default class PointSoundSource<
-  SourceData extends SoundSourceData = SoundSourceData,
+declare class PointSoundSource<
+  SourceData extends PointSoundSource.SourceData = PointSoundSource.SourceData,
   SourceShape extends PointSourcePolygon = PointSourcePolygon,
 > extends PointEffectSourceMixin(BaseEffectSource)<SourceData, SourceShape> {
   /** @defaultValue `"sound"` */
   static override sourceType: string;
 
+  /**
+   * @privateRemarks This is not in foundry's code, but since this class (and its parent) implements `_createShapes`,
+   * and we are counting what happens in `initialize` as 'the constructor', this gets to be declared never undefined.
+   */
+  override shape: SourceShape;
+
   override get effectsCollection(): Collection<this>;
 
   override _getPolygonConfiguration(): PointSourcePolygonConfig;
@@ -22,8 +27,21 @@ export default class PointSoundSource<
    */
   getVolumeMultiplier(
     listener: Canvas.Point,
-    options?: {
-      easing?: boolean | undefined;
-    },
+    options?: NullishProps<{
+      /** If no easing, return `1` */
+      easing: boolean;
+    }>,
   ): number;
 }
+
+declare namespace PointSoundSource {
+  type AnyConstructor = typeof AnyPointSoundSource;
+
+  type SourceData = PointEffectSourceMixin.MixedSourceData;
+}
+
+declare abstract class AnyPointSoundSource extends PointSoundSource {
+  constructor(arg0: never, ...args: never[]);
+}
+
+export default PointSoundSource;
diff --git a/src/foundry/client-esm/canvas/sources/point-vision-source.d.mts b/src/foundry/client-esm/canvas/sources/point-vision-source.d.mts
index 3ad52368c..15cbbc491 100644
--- a/src/foundry/client-esm/canvas/sources/point-vision-source.d.mts
+++ b/src/foundry/client-esm/canvas/sources/point-vision-source.d.mts
@@ -1,12 +1,15 @@
 import type RenderedEffectSource from "./rendered-effect-source.d.mts";
 import type PointEffectSourceMixin from "./point-effect-source.d.mts";
+import type { IntentionalPartial } from "../../../../utils/index.d.mts";
 
 /**
  * A specialized subclass of RenderedEffectSource which represents a source of point-based vision.
  */
 declare class PointVisionSource<
-  SourceData extends PointVisionSource.VisionSourceData = PointVisionSource.VisionSourceData,
-> extends PointEffectSourceMixin(RenderedEffectSource)<SourceData> {
+  SourceData extends PointVisionSource.SourceData = PointVisionSource.SourceData,
+  SourceShape extends PointSourcePolygon = PointSourcePolygon,
+  RenderingLayers extends RenderedEffectSource.Layers = RenderedEffectSource.Layers,
+> extends PointEffectSourceMixin(RenderedEffectSource)<SourceData, SourceShape, RenderingLayers> {
   /** @defaultValue `"sight"` */
   static override sourceType: string;
 
@@ -18,16 +21,18 @@ declare class PointVisionSource<
 
   /**
    * The corresponding lighting levels for dim light.
-   * @defaultValue `LIGHTING_LEVELS.DIM`
+   * @defaultValue `foundry.CONST.LIGHTING_LEVELS.DIM`
    */
   protected static _dimLightingLevel: foundry.CONST.LIGHTING_LEVELS;
 
   /**
    * The corresponding lighting levels for bright light.
-   * @defaultValue `LIGHTING_LEVELS.BRIGHT`
+   * @defaultValue `foundry.CONST.LIGHTING_LEVELS.BRIGHT`
    */
   protected static _brightLightingLevel: foundry.CONST.LIGHTING_LEVELS;
 
+  static override EDGE_OFFSET: number;
+
   /** @defaultValue `"visionSources"` */
   static override effectsCollection: string;
 
@@ -45,9 +50,10 @@ declare class PointVisionSource<
    * }
    * ```
    */
-  static override defaultData: PointVisionSourceData;
+  static override defaultData: PointVisionSource.SourceData;
 
-  static get _layers(): Record<string, RenderedEffectSource.RenderedEffectLayerConfig>;
+  /** @remarks Overrides `Adaptive*Shader` references with `*VisionShader` ones */
+  static get _layers(): Record<string, RenderedEffectSource.LayerConfig>;
 
   /**
    * The vision mode linked to this VisionSource
@@ -78,7 +84,7 @@ declare class PointVisionSource<
   /**
    * If this vision source background is rendered into the lighting container.
    */
-  get preferred(): boolean;
+  get preferred(): boolean | undefined;
 
   /**
    * Is the rendered source animated?
@@ -108,20 +114,18 @@ declare class PointVisionSource<
    */
   visionModeOverrides: object;
 
-  override _initialize(data: Partial<SourceData>): void;
+  override _initialize(data: IntentionalPartial<SourceData>): void;
 
   override _createShapes(): void;
 
-  override shape: PointSourcePolygon;
-
   /**
    * Responsible for assigning the Vision Mode and calling the activation and deactivation handlers.
    */
   protected _updateVisionMode(): void;
 
-  override _configure(changes: Partial<SourceData>): void;
+  override _configure(changes: IntentionalPartial<SourceData>): void;
 
-  override _configureLayer(layer: Record<string, unknown>, layerId: string): void;
+  override _configureLayer(layer: RenderedEffectSource.SourceLayer, layerId: string): void;
 
   override _getPolygonConfiguration(): PointSourcePolygonConfig;
 
@@ -141,11 +145,7 @@ declare class PointVisionSource<
    */
   protected _createRestrictedPolygon(): PointSourcePolygon;
 
-  override _configureShaders(): {
-    background: AdaptiveLightingShader;
-    coloration: AdaptiveLightingShader;
-    illumination: AdaptiveLightingShader;
-  };
+  override _configureShaders(): Record<keyof RenderingLayers, typeof AdaptiveVisionShader>;
 
   override _updateColorationUniforms(): void;
 
@@ -164,11 +164,11 @@ declare class PointVisionSource<
 }
 
 declare namespace PointVisionSource {
-  type Any = PointVisionSource<VisionSourceData>;
+  type Any = PointVisionSource<SourceData>;
 
-  interface VisionSourceData
-    extends RenderedEffectSource.RenderedEffectSourceData,
-      PointEffectSourceMixin.PointEffectSourceData {
+  type AnyConstructor = typeof AnyPointVisionSource;
+
+  interface SourceData extends RenderedEffectSource.SourceData, PointEffectSourceMixin.SourceData {
     /**
      * The amount of contrast
      */
@@ -197,7 +197,7 @@ declare namespace PointVisionSource {
     /**
      * The range of light perception.
      */
-    lightRadius: number;
+    lightRadius: number | null;
 
     /**
      * Is this vision source blinded?
@@ -206,7 +206,8 @@ declare namespace PointVisionSource {
   }
 }
 
-type PointVisionSourceData = PointEffectSourceMixin.PointEffectSourceData &
-  RenderedEffectSource.RenderedEffectSourceData;
+declare abstract class AnyPointVisionSource extends PointVisionSource {
+  constructor(arg0: never, ...args: never[]);
+}
 
 export default PointVisionSource;
diff --git a/src/foundry/client-esm/canvas/sources/rendered-effect-source.d.mts b/src/foundry/client-esm/canvas/sources/rendered-effect-source.d.mts
index 1afeb6468..696690f4a 100644
--- a/src/foundry/client-esm/canvas/sources/rendered-effect-source.d.mts
+++ b/src/foundry/client-esm/canvas/sources/rendered-effect-source.d.mts
@@ -1,17 +1,14 @@
-import type { AnyFunction, InexactPartial } from "../../../../utils/index.d.mts";
+import type { InexactPartial, IntentionalPartial } from "../../../../utils/index.d.mts";
 import type BaseEffectSource from "./base-effect-source.d.mts";
 
-// TODO: Remove after shaders are done
-type AdaptiveDarknessShader = unknown;
-
 /**
  * An abstract class which extends the base PointSource to provide common functionality for rendering.
  * This class is extended by both the LightSource and VisionSource subclasses.
  */
 declare class RenderedEffectSource<
-  SourceData extends RenderedEffectSource.RenderedEffectSourceData = RenderedEffectSource.RenderedEffectSourceData,
+  SourceData extends RenderedEffectSource.SourceData = RenderedEffectSource.SourceData,
   SourceShape extends PIXI.Polygon = PIXI.Polygon,
-  RenderingLayers extends Record<string, RenderedEffectSource.RenderedEffectSourceLayer> = RenderedEffectSource.Layers,
+  RenderingLayers extends Record<string, RenderedEffectSource.SourceLayer> = RenderedEffectSource.Layers,
 > extends BaseEffectSource<SourceData, SourceShape> {
   /**
    * Keys of the data object which require shaders to be re-initialized.
@@ -27,7 +24,7 @@ declare class RenderedEffectSource<
    * Layers handled by this rendered source.
    * @remarks Keys should match the keys of RenderingLayers
    */
-  protected static get _layers(): Record<string, RenderedEffectSource.RenderedEffectLayerConfig>;
+  protected static get _layers(): Record<string, RenderedEffectSource.LayerConfig>;
 
   /**
    * The offset in pixels applied to create soft edges.
@@ -47,13 +44,13 @@ declare class RenderedEffectSource<
    * }
    * ```
    */
-  static defaultData: RenderedEffectSource.RenderedEffectSourceData;
+  static defaultData: RenderedEffectSource.SourceData;
 
   /**
    * The animation configuration applied to this source
    * @defaultValue `{}`
    */
-  animation: RenderedEffectSource.RenderedEffectSourceAnimationConfig;
+  animation: RenderedEffectSource.AnimationConfig;
 
   /**
    * Track the status of rendering layers
@@ -100,29 +97,25 @@ declare class RenderedEffectSource<
    */
   get illumination(): PointSourceMesh;
 
-  _initialize(data: Partial<SourceData>): void;
+  override _initialize(data: IntentionalPartial<SourceData>): void;
 
   /**
    * Decide whether to render soft edges with a blur.
    */
   protected _initializeSoftEdges(): void;
 
-  override _configure(changes: Partial<SourceData>): void;
+  override _configure(changes: IntentionalPartial<SourceData>): void;
 
   /**
    * Configure which shaders are used for each rendered layer.
    * @privateRemarks Foundry marks this as private then overrides it in `PointVisionSource`
    */
-  protected _configureShaders(): {
-    background: AdaptiveLightingShader;
-    coloration: AdaptiveLightingShader;
-    illumination: AdaptiveLightingShader;
-  };
+  protected _configureShaders(): Record<keyof RenderingLayers, typeof AdaptiveLightingShader>;
 
   /**
    * Specific configuration for a layer.
    */
-  protected _configureLayer(layer: Record<string, unknown>, layerId: string): void;
+  protected _configureLayer(layer: RenderedEffectSource.SourceLayer, layerId: string): void;
 
   /**
    * Create the geometry for the source shape that is used in shaders and compute its bounds for culling purpose.
@@ -134,11 +127,8 @@ declare class RenderedEffectSource<
   /**
    * Render the containers used to represent this light source within the LightingLayer
    */
-  drawMeshes(): {
-    background: PIXI.Mesh;
-    coloration: PIXI.Mesh;
-    illumination: PIXI.Mesh;
-  };
+  drawMeshes(): Record<keyof RenderingLayers, PIXI.Mesh | null>;
+
   /**
    * Create a Mesh for a certain rendered layer of this source.
    * @param layerId - The layer key in layers to draw
@@ -166,9 +156,13 @@ declare class RenderedEffectSource<
    */
   protected _updateIlluminationUniforms(): void;
 
+  protected override _destroy(): void;
+
   /**
    * Animate the PointSource, if an animation is enabled and if it currently has rendered containers.
    * @param dt - Delta time.
+   * @privateRemarks In core this will return `void`, as the `this.animation.animation` function will  be a {@link BaseLightSource.LightAnimationFunction}
+   * and in fact most of the time will be `RenderedEffectSource#animateTime`, but it could technically be set to any function
    */
   animate(dt: number): this["animation"]["animation"] extends (...args: any) => infer Return ? Return : void;
 
@@ -177,7 +171,7 @@ declare class RenderedEffectSource<
    * @param dt      - Delta time.
    * @param options - Options which affect the time animation
    */
-  animateTime(dt: number, options?: InexactPartial<RenderedEffectSource.AnimationOptions>): void;
+  animateTime(dt: number, options?: RenderedEffectSource.AnimationFunctionOptions): void;
 
   /**
    * Get corrected level according to level and active vision mode data.
@@ -196,12 +190,14 @@ declare class RenderedEffectSource<
   ): Color;
 
   /**
-   * @deprecated since v11
+   * @deprecated since v11, until v13
+   * @remarks "The RenderedEffectSource#preview is deprecated. Use RenderedEffectSource#isPreview instead."
    */
   set preview(preview: boolean);
 
   /**
-   * @deprecated since v11
+   * @deprecated since v11, until v13
+   * @remarks "The RenderedEffectSource#preview is deprecated. Set RenderedEffectSource#preview as part of RenderedEffectSource#initialize instead."
    */
   get preview(): boolean;
 }
@@ -209,122 +205,163 @@ declare class RenderedEffectSource<
 declare namespace RenderedEffectSource {
   type Any = RenderedEffectSource<any, any, any>;
 
-  interface RenderedEffectSourceData extends BaseEffectSource.BaseEffectSourceData {
+  type AnyConstructor = typeof AnyRenderedEffectSource;
+
+  interface SourceData extends BaseEffectSource.SourceData {
     /**
      * An animation configuration for the source
      */
     animation: object;
+
     /**
      * A color applied to the rendered effect
      */
     color: number | null;
+
     /**
      * An integer seed to synchronize (or de-synchronize) animations
      */
     seed: number | null;
+
     /**
      * Is this source a temporary preview?
      */
     preview: boolean;
   }
 
-  interface AnimationOptions {
+  type AnimationFunction = (
+    this: RenderedEffectSource,
+    /** Delta time */
+    dt: number,
+    options?: AnimationFunctionOptions,
+  ) => void;
+
+  /** @internal */
+  type _AnimationFunctionOptions = InexactPartial<{
     /**
      * The animation speed, from 0 to 10
      * @defaultValue `5`
+     * @remarks Can't be null due to only having default via signature
      */
-    speed?: number;
+    speed: number;
 
     /**
      * The animation intensity, from 1 to 10
      * @defaultValue `5`
+     * @remarks Can't be null due to only having default via signature
      */
-    intensity?: number;
+    intensity: number;
 
     /**
      * Reverse the animation direction
      * @defaultValue `false`
      */
-    reverse?: boolean;
-  }
+    reverse: boolean | null;
+  }>;
+
+  /** Shared options for the {@link AnimationFunction}s provided by `_Source` classes */
+  interface AnimationFunctionOptions extends _AnimationFunctionOptions {}
 
-  interface RenderedEffectSourceAnimationConfig {
+  type AnimationConfig = InexactPartial<{
     /**
      * The human-readable (localized) label for the animation
      */
-    label?: string | undefined;
+    label: string;
+
     /**
      * The animation function that runs every frame
      * @privateRemarks TODO: Figure out if there's a better way to define the function
      */
-    animation?: AnyFunction | undefined;
+    animation: RenderedEffectSource.AnimationFunction;
+
     /**
      * A custom illumination shader used by this animation
      */
-    illuminationShader?: AdaptiveIlluminationShader | undefined;
+    illuminationShader: typeof AdaptiveIlluminationShader;
+
     /**
      * A custom coloration shader used by this animation
      */
-    colorationShader?: AdaptiveColorationShader | undefined;
+    colorationShader: typeof AdaptiveColorationShader;
+
     /**
      * A custom background shader used by this animation
      */
-    backgroundShader?: AdaptiveBackgroundShader | undefined;
+    backgroundShader: typeof AdaptiveBackgroundShader;
+
     /**
      * A custom darkness shader used by this animation
      */
-    darknessShader?: AdaptiveDarknessShader | undefined;
+    darknessShader: typeof AdaptiveDarknessShader;
+
     /**
      * The animation seed
      */
-    seed?: number | undefined;
+    seed: number;
+
     /**
      * The animation time
      */
-    time?: number | undefined;
-  }
+    time: number;
+  }>;
 
-  interface RenderedEffectSourceLayer {
+  /**
+   * @remarks The properties `mesh` and `shader` from `LayerConfig` are not documented as being part of the typedef. They are given values
+   * during initialization *if* the Source has a valid `Placeable` as its `object`. `vmUniforms` is only provided a value for `PointVisionSource` layers.
+   */
+  interface SourceLayer extends LayerConfig {
     /**
      * Is this layer actively rendered?
      */
     active: boolean;
+
     /**
      * Do uniforms need to be reset?
      */
     reset: boolean;
+
     /**
      * Is this layer temporarily suppressed?
      */
     suppressed: boolean;
+
     /**
      * The rendered mesh for this layer
      */
-    mesh: PointSourceMesh;
+    mesh: PointSourceMesh | undefined;
+
     /**
      * The shader instance used for the layer
      */
-    shader: AdaptiveLightingShader;
+    shader: AdaptiveLightingShader | undefined;
+
+    /** @remarks Foundry does not include this in the typedef but is in the initalization of `RenderedEffectSource#layers` */
+    vmUniforms: AbstractBaseShader.Uniforms | undefined;
   }
 
-  interface RenderedEffectLayerConfig {
+  interface LayerConfig {
     /**
      * The default shader used by this layer
      */
-    defaultShader: AdaptiveLightingShader;
+    defaultShader: typeof AdaptiveLightingShader;
+
     /**
      * The blend mode used by this layer
      */
-    blendMode: PIXI.BLEND_MODES;
+    blendMode: keyof typeof PIXI.BLEND_MODES;
   }
 
-  // Interface causes errors
+  // Interface would require `RenderingLayers extends ... = InterfaceToObject<Layers>` in every subclass signature
   // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
   type Layers = {
-    background: RenderedEffectSource.RenderedEffectSourceLayer;
-    coloration: RenderedEffectSource.RenderedEffectSourceLayer;
-    illumination: RenderedEffectSource.RenderedEffectSourceLayer;
+    background: RenderedEffectSource.SourceLayer;
+    coloration: RenderedEffectSource.SourceLayer;
+    illumination: RenderedEffectSource.SourceLayer;
   };
 }
 
+declare abstract class AnyRenderedEffectSource extends RenderedEffectSource<any, any, any> {
+  constructor(arg0: never, ...args: never[]);
+}
+
 export default RenderedEffectSource;
diff --git a/src/foundry/client-esm/dice/terms/dice.d.mts b/src/foundry/client-esm/dice/terms/dice.d.mts
index 16b8887ab..ceb46bc3c 100644
--- a/src/foundry/client-esm/dice/terms/dice.d.mts
+++ b/src/foundry/client-esm/dice/terms/dice.d.mts
@@ -315,7 +315,10 @@ declare abstract class DiceTerm extends RollTerm {
   /*  Serialization & Loading                     */
   /* -------------------------------------------- */
 
-  protected static _fromData<T extends RollTerm.AnyConstructor>(this: T, data: Record<string, unknown>): InstanceType<T>;
+  protected static _fromData<T extends RollTerm.AnyConstructor>(
+    this: T,
+    data: Record<string, unknown>,
+  ): InstanceType<T>;
 
   override toJSON(): Record<string, unknown>;
 }
diff --git a/src/foundry/client/config.d.mts b/src/foundry/client/config.d.mts
index d3060d76c..9e20d19cf 100644
--- a/src/foundry/client/config.d.mts
+++ b/src/foundry/client/config.d.mts
@@ -1,7 +1,7 @@
 import type * as CONST from "../common/constants.d.mts";
 import type { DataModel, Document } from "../common/abstract/module.d.mts";
-import type PointLightSource from "../client-esm/canvas/sources/point-light-source.d.mts";
 import type { GetKey, AnyObject, HandleEmptyObject, MaybePromise } from "../../utils/index.d.mts";
+import type BaseLightSource from "../client-esm/canvas/sources/base-light-source.d.mts";
 
 declare global {
   namespace CONFIG {
@@ -1027,13 +1027,13 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animateFlickering` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `FlameIlluminationShader` */
-          illuminationShader: typeof AbstractBaseShader;
+          illuminationShader: typeof AdaptiveIlluminationShader;
 
           /** @defaultValue `FlameColorationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
 
         torch: {
@@ -1041,13 +1041,13 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animateTorch` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `TorchIlluminationShader` */
-          illuminationShader: typeof AbstractBaseShader;
+          illuminationShader: typeof AdaptiveIlluminationShader;
 
           /** @defaultValue `TorchColorationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
 
         revolving: {
@@ -1055,10 +1055,10 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animateTime` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `RevolvingColorationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
 
         siren: {
@@ -1066,13 +1066,13 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animateTorch` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `SirenIlluminationShader` */
-          illuminationShader: typeof AbstractBaseShader;
+          illuminationShader: typeof AdaptiveIlluminationShader;
 
           /** @defaultValue `SirenIlluminationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
 
         pulse: {
@@ -1080,13 +1080,13 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animatePulse` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `PulseIlluminationShader` */
-          illuminationShader: typeof AbstractBaseShader;
+          illuminationShader: typeof AdaptiveIlluminationShader;
 
           /** @defaultValue `PulseColorationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
 
         chroma: {
@@ -1094,10 +1094,10 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animateTime` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `ChromaColorationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
 
         wave: {
@@ -1105,13 +1105,13 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animateTime` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `WaveIlluminationShader` */
-          illuminationShader: typeof AbstractBaseShader;
+          illuminationShader: typeof AdaptiveIlluminationShader;
 
           /** @defaultValue `WaveColorationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
 
         fog: {
@@ -1119,10 +1119,10 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animateTime` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `FogColorationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
 
         sunburst: {
@@ -1130,13 +1130,13 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animateTime` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `SunburstIlluminationShader` */
-          illuminationShader: typeof AbstractBaseShader;
+          illuminationShader: typeof AdaptiveIlluminationShader;
 
           /** @defaultValue `SunburstColorationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
 
         dome: {
@@ -1144,10 +1144,10 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animateTime` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `LightDomeColorationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
 
         emanation: {
@@ -1155,10 +1155,10 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animateTime` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `EmanationColorationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
 
         hexa: {
@@ -1166,10 +1166,10 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animateTime` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `HexaDomeColorationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
 
         ghost: {
@@ -1177,13 +1177,13 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animateTime` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `GhostLightIlluminationShader` */
-          illuminationShader: typeof AbstractBaseShader;
+          illuminationShader: typeof AdaptiveIlluminationShader;
 
           /** @defaultValue `GhostLightColorationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
 
         energy: {
@@ -1191,10 +1191,10 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animateTime` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `EnergyFieldColorationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
 
         vortex: {
@@ -1202,13 +1202,13 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animateTime` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `VortexIlluminationShader` */
-          illuminationShader: typeof AbstractBaseShader;
+          illuminationShader: typeof AdaptiveIlluminationShader;
 
           /** @defaultValue `VortexColorationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
 
         witchwave: {
@@ -1216,13 +1216,13 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animateTime` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `BewitchingWaveIlluminationShader` */
-          illuminationShader: typeof AbstractBaseShader;
+          illuminationShader: typeof AdaptiveIlluminationShader;
 
           /** @defaultValue `BewitchingWaveColorationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
 
         rainbowswirl: {
@@ -1230,10 +1230,10 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animateTime` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `SwirlingRainbowColorationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
 
         radialrainbow: {
@@ -1241,10 +1241,10 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animateTime` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `RadialRainbowColorationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
 
         fairy: {
@@ -1252,13 +1252,13 @@ declare global {
           label: string;
 
           /** @defaultValue `foundry.canvas.sources.LightSource.prototype.animateTime` */
-          animation: CONFIG.Canvas.LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
 
           /** @defaultValue `FairyLightIlluminationShader` */
-          illuminationShader: typeof AbstractBaseShader;
+          illuminationShader: typeof AdaptiveIlluminationShader;
 
           /** @defaultValue `FairyLightColorationShader` */
-          colorationShader: typeof AbstractBaseShader;
+          colorationShader: typeof AdaptiveColorationShader;
         };
       };
 
@@ -2990,10 +2990,10 @@ declare global {
         string,
         {
           label: string;
-          animation: LightAnimationFunction;
+          animation: BaseLightSource.LightAnimationFunction;
           backgroundShader?: typeof AdaptiveBackgroundShader;
-          illuminationShader?: typeof AbstractBaseShader;
-          colorationShader?: typeof AbstractBaseShader;
+          illuminationShader?: typeof AdaptiveIlluminationShader;
+          colorationShader?: typeof AdaptiveColorationShader;
         }
       >;
 
@@ -3002,18 +3002,13 @@ declare global {
        */
       type DarknessSourceAnimationConfig = Record<
         string,
-        { label: string; animation: LightAnimationFunction; darknessShader: typeof AdaptiveDarknessShader }
+        {
+          label: string;
+          animation: BaseLightSource.LightAnimationFunction;
+          darknessShader: typeof AdaptiveDarknessShader;
+        }
       >;
 
-      type LightAnimationFunction = (
-        // `this` is technically not a `PointLightSource`.
-        // Instead it is `foundry.canvas.sources.Pointfoundry.canvas.sources.LightSource.prototype`.
-        // However differentiating this would be a lot of work for little gain as nothing critical happens in the constructor.
-        this: PointLightSource,
-        dt: number,
-        properties?: { speed?: number; intensity?: number; reverse?: false },
-      ) => void;
-
       namespace Pings {
         interface Style {
           class: unknown;
diff --git a/src/foundry/client/data/abstract/client-document.d.mts b/src/foundry/client/data/abstract/client-document.d.mts
index e1da94775..4b65bd830 100644
--- a/src/foundry/client/data/abstract/client-document.d.mts
+++ b/src/foundry/client/data/abstract/client-document.d.mts
@@ -88,7 +88,10 @@ declare class ClientDocument<BaseDocument extends Document.Internal.Instance.Any
   /**
    * Obtain the FormApplication class constructor which should be used to configure this Document.
    */
-  protected _getSheetClass(): FormApplication.AnyConstructor | foundry.applications.api.ApplicationV2.AnyConstructor | null;
+  protected _getSheetClass():
+    | FormApplication.AnyConstructor
+    | foundry.applications.api.ApplicationV2.AnyConstructor
+    | null;
 
   /**
    * Safely prepare data for a Document, catching any errors.
diff --git a/src/foundry/client/pixi/board.d.mts b/src/foundry/client/pixi/board.d.mts
index 9fe51fce6..35c47cbc7 100644
--- a/src/foundry/client/pixi/board.d.mts
+++ b/src/foundry/client/pixi/board.d.mts
@@ -167,7 +167,7 @@ declare global {
     /**
      * The singleton FogManager instance.
      */
-    fog: FogManager;
+    fog: InstanceType<typeof CONFIG.Canvas.fogManager>;
 
     /**
      * A perception manager interface for batching lighting, sight, and sound updates
diff --git a/src/foundry/client/pixi/core/interaction/render-flags.d.mts b/src/foundry/client/pixi/core/interaction/render-flags.d.mts
index 660b22f91..c1c20421e 100644
--- a/src/foundry/client/pixi/core/interaction/render-flags.d.mts
+++ b/src/foundry/client/pixi/core/interaction/render-flags.d.mts
@@ -86,7 +86,7 @@ declare global {
          * Valid options are OBJECTS or PERCEPTION.
          * @defaultValue `PIXI.UPDATE_PRIORITY.OBJECTS`
          */
-        priority?: PIXI.UPDATE_PRIORITY.OBJECTS | PIXI.UPDATE_PRIORITY.PERCEPTION;
+        priority?: PIXI.UPDATE_PRIORITY;
       },
     );
 
diff --git a/src/foundry/client/pixi/layers/controls/layer.d.mts b/src/foundry/client/pixi/layers/controls/layer.d.mts
index 235a0a95d..66d675f3d 100644
--- a/src/foundry/client/pixi/layers/controls/layer.d.mts
+++ b/src/foundry/client/pixi/layers/controls/layer.d.mts
@@ -1,4 +1,9 @@
-import type { IntentionalPartial, InexactPartial, NullishProps, RemoveIndexSignatures } from "../../../../../utils/index.d.mts";
+import type {
+  IntentionalPartial,
+  InexactPartial,
+  NullishProps,
+  RemoveIndexSignatures,
+} from "../../../../../utils/index.d.mts";
 import type { LineIntersection } from "../../../../common/utils/geometry.d.mts";
 
 declare global {
diff --git a/src/foundry/client/pixi/layers/effects/visibility.d.mts b/src/foundry/client/pixi/layers/effects/visibility.d.mts
index be8fe4987..58f340c6f 100644
--- a/src/foundry/client/pixi/layers/effects/visibility.d.mts
+++ b/src/foundry/client/pixi/layers/effects/visibility.d.mts
@@ -211,11 +211,15 @@ declare global {
 
   interface CanvasVisibilityTest {
     point: PIXI.Point;
+    elevation: number;
     los: Map<foundry.canvas.sources.PointVisionSource.Any, boolean>;
   }
 
   interface CanvasVisibilityTestConfig {
+    /** The target object */
     object: PlaceableObject | null;
+
+    /** An array of visibility tests */
     tests: CanvasVisibilityTest[];
   }
 }
diff --git a/src/foundry/common/data/data.d.mts b/src/foundry/common/data/data.d.mts
index f4c0e7bfd..7300dc103 100644
--- a/src/foundry/common/data/data.d.mts
+++ b/src/foundry/common/data/data.d.mts
@@ -2,7 +2,7 @@ import type { DatabaseBackend } from "../abstract/module.d.mts";
 import type { DataModel } from "../abstract/data.d.mts";
 import type { fields } from "./module.d.mts";
 import type * as documents from "../documents/_module.d.mts";
-import type { AnyObject, EmptyObject, ToMethod, ValueOf } from "../../../utils/index.d.mts"
+import type { AnyObject, EmptyObject, ToMethod, ValueOf } from "../../../utils/index.d.mts";
 
 // TODO: Implement all of the necessary options
 
diff --git a/src/foundry/common/grid/_module.d.mts b/src/foundry/common/grid/_module.d.mts
index acfbdc7cd..eb793d528 100644
--- a/src/foundry/common/grid/_module.d.mts
+++ b/src/foundry/common/grid/_module.d.mts
@@ -7,4 +7,4 @@ export { default as BaseGrid } from "./base.mjs";
 export { default as GridHex } from "./grid-hex.mjs";
 export { default as GridlessGrid } from "./gridless.mjs";
 export { default as HexagonalGrid } from "./hexagonal.mjs";
-export { default as SquareHex } from "./square.mjs";
+export { default as SquareGrid } from "./square.mjs";
diff --git a/src/types/augments/particles.d.mts b/src/types/augments/particles.d.mts
new file mode 100644
index 000000000..9e904fdae
--- /dev/null
+++ b/src/types/augments/particles.d.mts
@@ -0,0 +1,11 @@
+/* eslint-disable import/export */
+
+import * as pixiParticles from "@pixi/particle-emitter";
+import type { Brand } from "src/utils/index.d.mts";
+
+export namespace behaviors {
+  type BehaviorOrder = Brand<number, "PIXI.particles.behaviors.BehaviorOrder">;
+  const BehaviorOrder: Record<keyof pixiParticles.behaviors.BehaviorOrder, BehaviorOrder>;
+}
+
+export * from "@pixi/particle-emitter";
diff --git a/src/types/augments/pixi.d.mts b/src/types/augments/pixi.d.mts
index 99566ab47..d162145c1 100644
--- a/src/types/augments/pixi.d.mts
+++ b/src/types/augments/pixi.d.mts
@@ -1,6 +1,14 @@
 import * as _PIXI from "pixi.js";
-import * as pixiParticles from "@pixi/particle-emitter";
-import * as graphicsSmooth from "@pixi/graphics-smooth";
+import type { Brand } from "src/utils/index.d.mts";
+
+// Note(LukeAbby): The `smooth.d.mts` and `smooth.d.mts` files exist to make it DRY to selectively tweak PIXI sub-namespaces.
+// Each of them write `export * from "..."` and then selectively shadow or augment the exports.
+
+// eslint-disable-next-line import/extensions
+import * as _smooth from "./smooth.mjs";
+
+// eslint-disable-next-line import/extensions
+import * as _particles from "./particles.mjs";
 
 export * from "pixi.js";
 
@@ -11,8 +19,93 @@ export as namespace PIXI;
 
 declare global {
   namespace PIXI {
-    export import smooth = graphicsSmooth;
-    export import particles = pixiParticles;
+    /*****************************
+     * Enum to Brand conversions *
+     *****************************/
+    type ALPHA_MODES = Brand<number, "PIXI.ALPHA_MODES">;
+    const ALPHA_MODES: Record<keyof typeof _PIXI.ALPHA_MODES, PIXI.ALPHA_MODES>;
+
+    /** @privateRemarks Merges Foundry's extra keys */
+    type BLEND_MODES = Brand<number, "PIXI.BLEND_MODES">;
+    const BLEND_MODES: Record<keyof typeof _PIXI.BLEND_MODES | "MAX_COLOR" | "MIN_COLOR" | "MIN_ALL", PIXI.BLEND_MODES>;
+
+    type BUFFER_BITS = Brand<number, "PIXI.BUFFER_BITS">;
+    const BUFFER_BITS: Record<keyof typeof _PIXI.BUFFER_BITS, PIXI.BUFFER_BITS>;
+
+    type BUFFER_TYPE = Brand<number, "PIXI.BUFFER_TYPE">;
+    const BUFFER_TYPE: Record<keyof typeof _PIXI.BUFFER_TYPE, PIXI.BUFFER_TYPE>;
+
+    type CLEAR_MODES = Brand<number, "PIXI.CLEAR_MODES">;
+    const CLEAR_MODES: Record<keyof typeof _PIXI.CLEAR_MODES, PIXI.CLEAR_MODES>;
+
+    type COLOR_MASK_BITS = Brand<number, "PIXI.COLOR_MASK_BITS">;
+    const COLOR_MASK_BITS: Record<keyof typeof _PIXI.COLOR_MASK_BITS, PIXI.COLOR_MASK_BITS>;
+
+    type DRAW_MODES = Brand<number, "PIXI.DRAW_MODES">;
+    const DRAW_MODES: Record<keyof typeof _PIXI.DRAW_MODES, PIXI.DRAW_MODES>;
+
+    type ENV = Brand<number, "PIXI.ENV">;
+    const ENV: Record<keyof typeof _PIXI.ENV, PIXI.ENV>;
+
+    type ExtensionType = Brand<string, "PIXI.ExtensionType">;
+    const ExtensionType: Record<keyof typeof _PIXI.ExtensionType, PIXI.ExtensionType>;
+
+    type FORMATS = Brand<number, "PIXI.FORMATS">;
+    const FORMATS: Record<keyof typeof _PIXI.FORMATS, PIXI.FORMATS>;
+
+    type GC_MODES = Brand<number, "PIXI.GC_MODES">;
+    const GC_MODES: Record<keyof typeof _PIXI.GC_MODES, PIXI.GC_MODES>;
+
+    type INTERNAL_FORMATS = Brand<number, "PIXI.INTERNAL_FORMATS">;
+    const INTERNAL_FORMATS: Record<keyof typeof _PIXI.INTERNAL_FORMATS, PIXI.INTERNAL_FORMATS>;
+
+    type LINE_CAP = Brand<string, "PIXI.LINE_CAP">;
+    const LINE_CAP: Record<keyof typeof _PIXI.LINE_CAP, PIXI.LINE_CAP>;
+
+    type LINE_JOIN = Brand<string, "PIXI.LINE_JOIN">;
+    const LINE_JOIN: Record<keyof typeof _PIXI.LINE_JOIN, PIXI.LINE_JOIN>;
+
+    type LoaderParserPriority = Brand<number, "PIXI.LoaderParserPriority">;
+    const LoaderParserPriority: Record<keyof typeof _PIXI.LoaderParserPriority, PIXI.LoaderParserPriority>;
+
+    type MASK_TYPES = Brand<number, "PIXI.MASK_TYPES">;
+    const MASK_TYPES: Record<keyof typeof _PIXI.MASK_TYPES, PIXI.MASK_TYPES>;
+
+    type MIPMAP_MODES = Brand<number, "PIXI.MIPMAP_MODES">;
+    const MIPMAP_MODES: Record<keyof typeof _PIXI.MIPMAP_MODES, PIXI.MIPMAP_MODES>;
+
+    type MSAA_QUALITY = Brand<number, "PIXI.MSAA_QUALITY">;
+    const MSAA_QUALITY: Record<keyof typeof _PIXI.MSAA_QUALITY, PIXI.MSAA_QUALITY>;
+
+    type PRECISION = Brand<string, "PIXI.PRECISION">;
+    const PRECISION: Record<keyof typeof _PIXI.PRECISION, PIXI.PRECISION>;
+
+    type RENDERER_TYPE = Brand<number, "PIXI.RENDERER_TYPE">;
+    const RENDERER_TYPE: Record<keyof typeof _PIXI.RENDERER_TYPE, PIXI.RENDERER_TYPE>;
+
+    type SAMPLER_TYPES = Brand<number, "PIXI.SAMPLER_TYPES">;
+    const SAMPLER_TYPES: Record<keyof typeof _PIXI.SAMPLER_TYPES, PIXI.SAMPLER_TYPES>;
+
+    type SCALE_MODES = Brand<number, "PIXI.SCALE_MODES">;
+    const SCALE_MODES: Record<keyof typeof _PIXI.SCALE_MODES, PIXI.SCALE_MODES>;
+
+    type SHAPES = Brand<number, "PIXI.SHAPES">;
+    const SHAPES: Record<keyof typeof _PIXI.SHAPES, PIXI.SHAPES>;
+
+    type TARGETS = Brand<number, "PIXI.TARGETS">;
+    const TARGET: Record<keyof typeof _PIXI.TARGETS, PIXI.TARGETS>;
+
+    type TEXT_GRADIENT = Brand<number, "PIXI.TEXT_GRADIENT">;
+    const TEXT_GRADIENT: Record<keyof typeof _PIXI.TEXT_GRADIENT, PIXI.TEXT_GRADIENT>;
+
+    type UPDATE_PRIORITY = Brand<number, "PIXI.UPDATE_PRIORITY">;
+    const UPDATE_PRIORITY: Record<keyof typeof _PIXI.UPDATE_PRIORITY, PIXI.UPDATE_PRIORITY>;
+
+    type WRAP_MODES = Brand<number, "PIXI.WRAP_MODES">;
+    const WRAP_MODES: Record<keyof typeof _PIXI.WRAP_MODES, PIXI.WRAP_MODES>;
+
+    export import smooth = _smooth;
+    export import particles = _particles;
 
     export class Graphics extends PIXI.smooth.SmoothGraphics {}
 
diff --git a/src/types/augments/smooth.d.mts b/src/types/augments/smooth.d.mts
new file mode 100644
index 000000000..7f0ba7ef0
--- /dev/null
+++ b/src/types/augments/smooth.d.mts
@@ -0,0 +1,13 @@
+import type { Brand } from "src/utils/index.d.mts";
+import * as graphicsSmooth from "@pixi/graphics-smooth";
+
+type JOINT_TYPE = Brand<number, "PIXI.smooth.JOINT_TYPE">;
+declare const JOINT_TYPE: Record<keyof typeof graphicsSmooth.JOINT_TYPE, PIXI.smooth.JOINT_TYPE>;
+
+type LINE_SCALE_MODE = Brand<number, "PIXI.smooth.LINE_SCALE_MODE">;
+declare const LINE_SCALE_MODE: Record<keyof typeof graphicsSmooth.LINE_SCALE_MODE, PIXI.smooth.LINE_SCALE_MODE>;
+
+// eslint-disable-next-line
+export * from "@pixi/graphics-smooth";
+// eslint-disable-next-line
+export { JOINT_TYPE, LINE_SCALE_MODE };
diff --git a/tests/foundry/client-esm/canvas/sources/base-effect-source.mjs.test-d.ts b/tests/foundry/client-esm/canvas/sources/base-effect-source.mjs.test-d.ts
index dfc93a283..c3b7c1554 100644
--- a/tests/foundry/client-esm/canvas/sources/base-effect-source.mjs.test-d.ts
+++ b/tests/foundry/client-esm/canvas/sources/base-effect-source.mjs.test-d.ts
@@ -1,5 +1,6 @@
 import { expectTypeOf } from "vitest";
+import type BaseEffectSource from "../../../../../src/foundry/client-esm/canvas/sources/base-effect-source.d.mts";
 
-const mySource = new foundry.canvas.sources.BaseEffectSource();
+declare const mySource: BaseEffectSource<BaseEffectSource.SourceData, PIXI.Polygon>;
 
 expectTypeOf(mySource.active).toEqualTypeOf<boolean>();
diff --git a/tests/foundry/client-esm/canvas/sources/base-light-source.mjs.test-d.ts b/tests/foundry/client-esm/canvas/sources/base-light-source.mjs.test-d.ts
index c9766a0d3..8f7060de0 100644
--- a/tests/foundry/client-esm/canvas/sources/base-light-source.mjs.test-d.ts
+++ b/tests/foundry/client-esm/canvas/sources/base-light-source.mjs.test-d.ts
@@ -1,7 +1,8 @@
 import { expectTypeOf } from "vitest";
+import type BaseLightSource from "../../../../../src/foundry/client-esm/canvas/sources/base-light-source.d.mts";
 
-const mySource = new foundry.canvas.sources.BaseLightSource();
+declare const mySource: BaseLightSource;
 
 expectTypeOf(mySource.active).toEqualTypeOf<boolean>();
-expectTypeOf(mySource.drawMeshes().background.visible).toEqualTypeOf<boolean>();
+expectTypeOf(mySource.drawMeshes().background?.visible).toEqualTypeOf<boolean | undefined>();
 expectTypeOf(mySource.animateTorch(5)).toEqualTypeOf<void>();
diff --git a/tests/foundry/client-esm/canvas/sources/point-darkness-sources.mjs.test-d.ts b/tests/foundry/client-esm/canvas/sources/point-darkness-sources.mjs.test-d.ts
index e277f89f3..df2386ba3 100644
--- a/tests/foundry/client-esm/canvas/sources/point-darkness-sources.mjs.test-d.ts
+++ b/tests/foundry/client-esm/canvas/sources/point-darkness-sources.mjs.test-d.ts
@@ -2,8 +2,10 @@ import { expectTypeOf } from "vitest";
 
 const mySource = new foundry.canvas.sources.PointDarknessSource();
 
+expectTypeOf(mySource.data).toEqualTypeOf<foundry.canvas.sources.PointDarknessSource.SourceData>();
 expectTypeOf(mySource.active).toEqualTypeOf<boolean>();
-expectTypeOf(mySource.drawMeshes().background.visible).toEqualTypeOf<boolean>();
+expectTypeOf(mySource.drawMeshes().darkness).toEqualTypeOf<PIXI.Mesh | null>();
+expectTypeOf(mySource.drawMeshes().darkness?.visible).toEqualTypeOf<boolean | undefined>();
 expectTypeOf(mySource.animateTorch(5)).toEqualTypeOf<void>();
 expectTypeOf(mySource.add()).toEqualTypeOf<void>();
 expectTypeOf(mySource.shape).toEqualTypeOf<PointSourcePolygon>();
diff --git a/tests/foundry/client-esm/canvas/sources/point-light-source.mjs.test-d.ts b/tests/foundry/client-esm/canvas/sources/point-light-source.mjs.test-d.ts
index 8b399678f..20b959643 100644
--- a/tests/foundry/client-esm/canvas/sources/point-light-source.mjs.test-d.ts
+++ b/tests/foundry/client-esm/canvas/sources/point-light-source.mjs.test-d.ts
@@ -3,7 +3,7 @@ import { expectTypeOf } from "vitest";
 const mySource = new foundry.canvas.sources.PointLightSource();
 
 expectTypeOf(mySource.active).toEqualTypeOf<boolean>();
-expectTypeOf(mySource.drawMeshes().background.visible).toEqualTypeOf<boolean>();
+expectTypeOf(mySource.drawMeshes().background?.visible).toEqualTypeOf<boolean | undefined>();
 expectTypeOf(mySource.animateTorch(5)).toEqualTypeOf<void>();
 expectTypeOf(mySource.add()).toEqualTypeOf<void>();
 expectTypeOf(mySource.shape).toEqualTypeOf<PointSourcePolygon>();
diff --git a/tests/foundry/client-esm/canvas/sources/point-movement-source.mjs.test-d.ts b/tests/foundry/client-esm/canvas/sources/point-movement-source.mjs.test-d.ts
index 3dc1d6755..1eec56be1 100644
--- a/tests/foundry/client-esm/canvas/sources/point-movement-source.mjs.test-d.ts
+++ b/tests/foundry/client-esm/canvas/sources/point-movement-source.mjs.test-d.ts
@@ -1,8 +1,9 @@
 import { expectTypeOf } from "vitest";
+import type PointMovementSource from "../../../../../src/foundry/client-esm/canvas/sources/point-movement-source.d.mts";
 
 const mySource = new foundry.canvas.sources.PointMovementSource();
 
 expectTypeOf(mySource.active).toEqualTypeOf<boolean>();
-expectTypeOf(
-  mySource.initialize({ x: 3, y: 5, elevation: 7 }),
-).toEqualTypeOf<foundry.canvas.sources.PointMovementSource>();
+expectTypeOf(mySource.initialize({ x: 3, y: 5, elevation: 7 })).toEqualTypeOf<PointMovementSource>();
+expectTypeOf(mySource.shape).toEqualTypeOf<PointSourcePolygon>();
+expectTypeOf(mySource.data).toEqualTypeOf<PointMovementSource.SourceData>();
diff --git a/tests/foundry/client-esm/canvas/sources/point-sound-source.mjs.test-d.ts b/tests/foundry/client-esm/canvas/sources/point-sound-source.mjs.test-d.ts
index 35037e40d..d4374b953 100644
--- a/tests/foundry/client-esm/canvas/sources/point-sound-source.mjs.test-d.ts
+++ b/tests/foundry/client-esm/canvas/sources/point-sound-source.mjs.test-d.ts
@@ -1,8 +1,9 @@
 import { expectTypeOf } from "vitest";
+import type PointSoundSource from "../../../../../src/foundry/client-esm/canvas/sources/point-sound-source.d.mts";
 
 const mySource = new foundry.canvas.sources.PointSoundSource();
 
 expectTypeOf(mySource.active).toEqualTypeOf<boolean>();
-expectTypeOf(
-  mySource.initialize({ radius: 5, walls: true, disabled: false }),
-).toEqualTypeOf<foundry.canvas.sources.PointSoundSource>();
+expectTypeOf(mySource.initialize({ radius: 5, walls: true, disabled: false })).toEqualTypeOf<PointSoundSource>();
+expectTypeOf(mySource.shape).toEqualTypeOf<PointSourcePolygon>();
+expectTypeOf(mySource.data).toEqualTypeOf<PointSoundSource.SourceData>();
diff --git a/tests/foundry/client-esm/canvas/sources/point-vision-source.mjs.test-d.ts b/tests/foundry/client-esm/canvas/sources/point-vision-source.mjs.test-d.ts
index bf690de43..510338d67 100644
--- a/tests/foundry/client-esm/canvas/sources/point-vision-source.mjs.test-d.ts
+++ b/tests/foundry/client-esm/canvas/sources/point-vision-source.mjs.test-d.ts
@@ -1,6 +1,10 @@
 import { expectTypeOf } from "vitest";
+import type PointVisionSource from "../../../../../src/foundry/client-esm/canvas/sources/point-vision-source.d.mts";
 
 const mySource = new foundry.canvas.sources.PointVisionSource();
 
 expectTypeOf(mySource.active).toEqualTypeOf<boolean>();
-expectTypeOf(mySource.drawMeshes().background.visible).toEqualTypeOf<boolean>();
+expectTypeOf(mySource.drawMeshes().background?.visible).toEqualTypeOf<boolean | undefined>();
+expectTypeOf(mySource.data).toEqualTypeOf<PointVisionSource.SourceData>();
+expectTypeOf(mySource.shape).toEqualTypeOf<PointSourcePolygon>();
+expectTypeOf(mySource._configureShaders().background).toEqualTypeOf<typeof AdaptiveVisionShader>();
diff --git a/tests/foundry/client-esm/canvas/sources/rendered-effect-source.mjs.test-d.ts b/tests/foundry/client-esm/canvas/sources/rendered-effect-source.mjs.test-d.ts
index 814c1a482..db8d2a527 100644
--- a/tests/foundry/client-esm/canvas/sources/rendered-effect-source.mjs.test-d.ts
+++ b/tests/foundry/client-esm/canvas/sources/rendered-effect-source.mjs.test-d.ts
@@ -1,6 +1,6 @@
 import { expectTypeOf } from "vitest";
 
 const mySource = new foundry.canvas.sources.RenderedEffectSource();
-
+const meshes = mySource.drawMeshes();
 expectTypeOf(mySource.active).toEqualTypeOf<boolean>();
-expectTypeOf(mySource.drawMeshes().background.visible).toEqualTypeOf<boolean>();
+expectTypeOf(meshes.background?.visible).toEqualTypeOf<boolean | undefined>();
diff --git a/tests/foundry/client/pixi/board.test-d.ts b/tests/foundry/client/pixi/board.test-d.ts
index 69dbfbdb6..12f76db69 100644
--- a/tests/foundry/client/pixi/board.test-d.ts
+++ b/tests/foundry/client/pixi/board.test-d.ts
@@ -14,19 +14,21 @@ expectTypeOf(myCanvas.getLayerByEmbeddedName("Token")).toEqualTypeOf<TokenLayer
 expectTypeOf(myCanvas.getLayerByEmbeddedName("Wall")).toEqualTypeOf<WallsLayer | null>();
 expectTypeOf(myCanvas.getLayerByEmbeddedName("any-string")).toEqualTypeOf<null>();
 
-expectTypeOf(myCanvas.animatePan()).toEqualTypeOf<Promise<boolean | void>>();
-expectTypeOf(myCanvas.animatePan({})).toEqualTypeOf<Promise<boolean | void>>();
-expectTypeOf(myCanvas.animatePan({ x: 100, y: 100, scale: 1, duration: 250, speed: 10 })).toEqualTypeOf<
-  Promise<boolean | void>
+expectTypeOf(myCanvas.animatePan({})).toEqualTypeOf<Promise<boolean>>();
+expectTypeOf(
+  myCanvas.animatePan({ x: 100, y: 100, scale: 1, duration: 250, easing: (pt: number) => pt }),
+).toEqualTypeOf<Promise<boolean>>();
+expectTypeOf(myCanvas.animatePan({ x: 500, y: 500, scale: 10, speed: 6, easing: "easeInCircle" })).toEqualTypeOf<
+  Promise<boolean>
 >();
 
-expectTypeOf(myCanvas.recenter()).toEqualTypeOf<Promise<boolean | void>>();
-expectTypeOf(myCanvas.recenter({})).toEqualTypeOf<Promise<boolean | void>>();
-expectTypeOf(myCanvas.recenter({ x: null, y: null, scale: null })).toEqualTypeOf<Promise<boolean | void>>();
-expectTypeOf(myCanvas.recenter({ x: 100, y: 100, scale: 1 })).toEqualTypeOf<Promise<boolean | void>>();
+expectTypeOf(myCanvas.recenter()).toEqualTypeOf<Promise<boolean>>();
+expectTypeOf(myCanvas.recenter({})).toEqualTypeOf<Promise<boolean>>();
+expectTypeOf(myCanvas.recenter({ x: null, y: null, scale: null })).toEqualTypeOf<Promise<boolean>>();
+expectTypeOf(myCanvas.recenter({ x: 100, y: 100, scale: 1 })).toEqualTypeOf<Promise<boolean>>();
 
 myCanvas.pendingRenderFlags.OBJECTS.add(myCanvas.perception);
 
 expectTypeOf(myCanvas.hidden).toEqualTypeOf<HiddenCanvasGroup | undefined>();
-expectTypeOf(myCanvas.rendered).toEqualTypeOf<RenderedCanvasGroup | undefined>();
-expectTypeOf(myCanvas.environment).toEqualTypeOf<EnvironmentCanvasGroup | undefined>();
+expectTypeOf(myCanvas.rendered).toEqualTypeOf<RenderedCanvasGroup>();
+expectTypeOf(myCanvas.environment).toEqualTypeOf<EnvironmentCanvasGroup>();
diff --git a/tests/foundry/client/pixi/layers/base/placeables-layer.test-d.ts b/tests/foundry/client/pixi/layers/base/placeables-layer.test-d.ts
index eaa619ae9..32b0cc244 100644
--- a/tests/foundry/client/pixi/layers/base/placeables-layer.test-d.ts
+++ b/tests/foundry/client/pixi/layers/base/placeables-layer.test-d.ts
@@ -64,11 +64,11 @@ expectTypeOf(layer.rotateMany({ angle: 10, delta: 20, snap: 20, ids: ["abc", "de
 >();
 expectTypeOf(layer.moveMany()).toEqualTypeOf<Promise<AmbientLight[]> | undefined>();
 expectTypeOf(layer.moveMany({})).toEqualTypeOf<Promise<AmbientLight[]> | undefined>();
-expectTypeOf(layer.moveMany({ dx: 100, dy: 100, rotate: true, ids: ["abc", "def"] })).toEqualTypeOf<
+expectTypeOf(layer.moveMany({ dx: 1, dy: -1, rotate: true, ids: ["abc", "def"] })).toEqualTypeOf<
   Promise<AmbientLight[]> | undefined
 >();
 expectTypeOf(layer.undoHistory()).toEqualTypeOf<Promise<AmbientLightDocument[]>>();
-expectTypeOf(layer.deleteAll()).toEqualTypeOf<Promise<AmbientLightDocument[] | false | null>>();
+expectTypeOf(layer.deleteAll()).toEqualTypeOf<Promise<undefined | false | null>>();
 expectTypeOf(layer.storeHistory("create", new AmbientLightDocument()["_source"])).toEqualTypeOf<void>();
 expectTypeOf(layer.storeHistory("update", new AmbientLightDocument()["_source"])).toEqualTypeOf<void>();
 expectTypeOf(layer.storeHistory("delete", new AmbientLightDocument()["_source"])).toEqualTypeOf<void>();
diff --git a/tests/foundry/client/pixi/layers/grid/grid.test-d.ts b/tests/foundry/client/pixi/layers/grid/grid.test-d.ts
deleted file mode 100644
index 4260a0052..000000000
--- a/tests/foundry/client/pixi/layers/grid/grid.test-d.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import { expectTypeOf } from "vitest";
-
-const myGrid = new foundry.grid.BaseGrid({
-  dimensions: {
-    width: 1,
-    height: 2,
-    sceneHeight: 3,
-    sceneRect: { x: 1, y: 2, width: 3, height: 4 },
-    sceneWidth: 5,
-    sceneX: 6,
-    sceneY: 7,
-    size: 8,
-    rect: { x: 1, y: 2, width: 3, height: 4 },
-    distance: 9,
-    maxR: 10,
-    ratio: 11,
-  },
-  color: "0x000000",
-  alpha: 3,
-});
-
-expectTypeOf(myGrid.draw()).toEqualTypeOf<foundry.grid.BaseGrid>();
diff --git a/tests/foundry/client/pixi/layers/grid/hex.test-d.ts b/tests/foundry/client/pixi/layers/grid/hex.test-d.ts
deleted file mode 100644
index 2b1c290fb..000000000
--- a/tests/foundry/client/pixi/layers/grid/hex.test-d.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import { expectTypeOf } from "vitest";
-
-HexagonalGrid.pixelsToOffset({ x: 3, y: 2 }, { columns: true, even: false, size: 4 }, "floor");
-
-const myGrid = new HexagonalGrid({ columns: true, even: false, size: 4 });
-
-expectTypeOf(myGrid.draw()).toEqualTypeOf<HexagonalGrid>();
diff --git a/tests/foundry/client/pixi/layers/grid/square.test-d.ts b/tests/foundry/client/pixi/layers/grid/square.test-d.ts
deleted file mode 100644
index 94697e4e4..000000000
--- a/tests/foundry/client/pixi/layers/grid/square.test-d.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import { expectTypeOf } from "vitest";
-
-const myGrid = new SquareGrid({
-  dimensions: {
-    width: 1,
-    height: 2,
-    sceneHeight: 3,
-    sceneRect: { x: 1, y: 2, width: 3, height: 4 },
-    sceneWidth: 5,
-    sceneX: 6,
-    sceneY: 7,
-    size: 8,
-    rect: { x: 1, y: 2, width: 3, height: 4 },
-    distance: 9,
-    maxR: 10,
-    ratio: 11,
-  },
-  color: "0x000000",
-  alpha: 3,
-});
-
-expectTypeOf(myGrid.draw()).toEqualTypeOf<SquareGrid>();
diff --git a/tests/foundry/common/grid/hex.test-d.ts b/tests/foundry/common/grid/hex.test-d.ts
new file mode 100644
index 000000000..f555d461b
--- /dev/null
+++ b/tests/foundry/common/grid/hex.test-d.ts
@@ -0,0 +1,10 @@
+import type HexagonalGrid from "src/foundry/common/grid/hexagonal.d.mts";
+import { expectTypeOf } from "vitest";
+
+const hexGrid = new foundry.grid.HexagonalGrid({
+  columns: false,
+  even: true,
+  size: 200,
+});
+
+expectTypeOf(hexGrid.getOffset({ q: 50, r: 200, s: 500 })).toEqualTypeOf<HexagonalGrid.Offset>();
diff --git a/tests/foundry/common/grid/square.test-d.ts b/tests/foundry/common/grid/square.test-d.ts
new file mode 100644
index 000000000..4d4ee4391
--- /dev/null
+++ b/tests/foundry/common/grid/square.test-d.ts
@@ -0,0 +1,16 @@
+import type SquareGrid from "src/foundry/common/grid/square.d.mts";
+import { expectTypeOf } from "vitest";
+
+const myGrid = new foundry.grid.SquareGrid({
+  diagonals: CONST.GRID_DIAGONALS.ALTERNATING_1,
+  size: 100,
+  color: "0x000000",
+  alpha: 3,
+});
+
+expectTypeOf(
+  myGrid.getDirectPath([
+    { i: 30, j: 200 },
+    { x: 2000, y: 2000 },
+  ]),
+).toEqualTypeOf<SquareGrid.Offset[]>();