@tangram.gl/tangram-renderer 0.0.0-stage → 0.0.0

package/src/gpu/tangram_gpu_backend.ts

@@ -0,0 +1,195 @@
+// tangram-layers
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {
+  Buffer,
+  BufferLayout,
+  Bindings,
+  Device,
+  ExternalImage,
+  RenderPass,
+  RenderPipelineParameters,
+  PrimitiveTopology,
+  Shader,
+  Texture,
+  UniformValue
+} from '@luma.gl/core';
+
+/** Shader languages supported by Tangram's portable GPU backend. */
+export type TangramShaderLanguage = 'glsl' | 'wgsl';
+
+/** Options used to allocate a Tangram uniform buffer. */
+export type TangramUniformBufferOptions = {
+  id: string;
+  usage: 'uniform';
+  byteLength: number;
+};
+
+/** Options used to allocate a Tangram vertex or index buffer. */
+export type TangramMeshBufferOptions = {
+  id: string;
+  usage: 'vertex' | 'index';
+  data: ArrayBuffer | ArrayBufferView;
+  indexType?: 'uint16' | 'uint32';
+};
+
+/** Options used to compile one stage of a Tangram shader program. */
+export type TangramShaderOptions = {
+  id: string;
+  language?: TangramShaderLanguage;
+  stage: 'vertex' | 'fragment';
+  source: string;
+  entryPoint?: string;
+};
+
+/** Options used to validate a linked Tangram shader pair. */
+export type TangramShaderProgramOptions = {
+  id: string;
+  vertexShader: Shader;
+  fragmentShader: Shader;
+};
+
+/** Options used to allocate and initialize a Tangram texture. */
+export type TangramTextureOptions = {
+  id: string;
+  width: number;
+  height: number;
+  data?: ArrayBuffer | ArrayBufferView | ExternalImage;
+  filtering?: 'nearest' | 'linear' | 'mipmap';
+  repeat?: boolean;
+  flipY?: boolean;
+  premultipliedAlpha?: boolean;
+};
+
+/** Portable mesh submission passed from Tangram scene traversal to a GPU backend. */
+export type TangramMeshDrawOptions = {
+  mesh: TangramDrawableMesh;
+  program: TangramDrawableProgram;
+  renderPass: RenderPass;
+  renderState?: RenderPipelineParameters;
+  visibleTime: number;
+};
+
+/** GPU resources and layout needed to submit one portable mesh. */
+export type TangramMeshDrawDescriptor = {
+  topology: PrimitiveTopology;
+  vertexCount: number;
+  indexCount: number;
+  vertexBuffer: Buffer | null;
+  indexBuffer: Buffer | null;
+  bufferLayout: BufferLayout & {attributes: NonNullable<BufferLayout['attributes']>};
+  staticAttributes: {attribute: string; value: readonly number[]}[];
+};
+
+/** Scene-owned mesh state consumed by the device backend. */
+export type TangramDrawableMesh = {
+  id: string | number;
+  vertex_layout: object;
+  uniforms?: Record<string, unknown>;
+  getDrawDescriptor(): TangramMeshDrawDescriptor;
+};
+
+/** Mutable uniform block whose contents can be snapshotted per encoded draw. */
+export type TangramDrawableUniformBlock = {
+  snapshot_per_mesh: boolean;
+  data: ArrayBuffer | null;
+  byteLength: number;
+};
+
+/** Shader and uniform operations required by the device submission path. */
+export type TangramDrawableProgram = {
+  id: string | number;
+  name?: string;
+  vertex_shader_resource: Shader | null | undefined;
+  fragment_shader_resource: Shader | null | undefined;
+  uniform_blocks?: Record<string, TangramDrawableUniformBlock>;
+  saveUniforms(uniforms: Record<string, unknown>): void;
+  setUniforms(uniforms: Record<string, unknown>, resetTextureUnit: boolean): void;
+  restoreUniforms(uniforms: Record<string, unknown>): void;
+  uniform(method: string, name: string, value: number): void;
+  getBindings(): Record<string, object>;
+  getUniformValues(): Record<string, UniformValue>;
+};
+
+/** Tangram blend modes accepted by the portable renderer. */
+export type TangramBlendMode =
+  | false
+  | 'opaque'
+  | 'overlay'
+  | 'inlay'
+  | 'translucent'
+  | 'add'
+  | 'multiply';
+
+/** Normalized Tangram state used to create a luma.gl render pipeline. */
+export type TangramRenderStateOptions = {
+  depthTest: boolean;
+  depthWrite: boolean;
+  cullFace: boolean;
+  blend: TangramBlendMode;
+};
+
+/**
+ * Scene integration hooks supplied by a portable Tangram GPU backend.
+ *
+ * This compatibility shape keeps the current Scene and Style internals isolated
+ * while their individual resource wrappers are migrated to the backend contract.
+ */
+export type TangramGPUSceneOptions = {
+  enableUniformBuffers: true;
+  deviceShaderCompilation: true;
+  shaderLanguage: TangramShaderLanguage;
+  uniformBufferFactory: (options: TangramUniformBufferOptions) => Buffer;
+  shaderFactory: (options: TangramShaderOptions) => Shader;
+  shaderProgramValidator: (options: TangramShaderProgramOptions) => void;
+  meshBufferFactory: (options: TangramMeshBufferOptions) => Buffer;
+  textureFactory: (options: TangramTextureOptions) => Texture;
+  maxTextureSize?: number;
+  meshRenderer: TangramGPUBackend;
+};
+
+/**
+ * Renderer-independent boundary for Tangram GPU resource ownership and drawing.
+ *
+ * `LumaDeviceRenderer` is the current and only implementation. It owns the
+ * resources it creates but does not own the host device or render pass. The
+ * interface intentionally contains no deck.gl types.
+ */
+export interface TangramGPUBackend {
+  /** Host-owned luma.gl device used by this backend. */
+  readonly device: Device;
+
+  /** Shader language compiled by this backend. */
+  readonly shaderLanguage: TangramShaderLanguage;
+
+  /** Maximum supported two-dimensional texture dimension, when known. */
+  readonly maxTextureSize?: number;
+
+  /** Returns the compatibility hooks consumed by current Scene internals. */
+  getSceneOptions(): TangramGPUSceneOptions;
+
+  /** Allocates a uniform buffer. */
+  createUniformBuffer(options: TangramUniformBufferOptions): Buffer;
+
+  /** Allocates a vertex or index buffer. */
+  createMeshBuffer(options: TangramMeshBufferOptions): Buffer;
+
+  /** Compiles a shader stage. */
+  createShader(options: TangramShaderOptions): Shader;
+
+  /** Validates a linked shader pair. */
+  validateShaderProgram(options: TangramShaderProgramOptions): void;
+
+  /** Allocates and initializes a texture. */
+  createTexture(options: TangramTextureOptions): Texture;
+
+  /** Submits one mesh to a host-owned render pass. */
+  drawMesh(options: TangramMeshDrawOptions): boolean;
+
+  /** Translates Tangram state into luma.gl render-pipeline parameters. */
+  getRenderPipelineParameters(options: TangramRenderStateOptions): RenderPipelineParameters;
+
+  /** Releases resources owned by this backend. */
+  destroy(): void;
+}

package/src/index.d.ts

@@ -0,0 +1,155 @@
+// tangram-layers
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {
+  HostFrameOptions,
+  HostRenderView,
+  LegacyHostFrame,
+  RendererOptions,
+  RenderOptions,
+  SceneDataSource,
+  SceneDefinition,
+  SceneListeners,
+  SceneLoadOptions,
+  SceneQueryOptions,
+  SceneScreenshot,
+  SceneFeature,
+  SceneUpdateOptions,
+  Viewport
+} from './types.js';
+export type {FeatureSelectionResult, FeatureSelectionOptions} from './types.js';
+export {DrapedTerrainSurfaceSnapshot} from './selection/draped-terrain-surface';
+export {TerrainMeshSurface, TerrainSurfaceCollection, sampleTerrainElevation, resolveTerrainClearance, pickTerrainAt} from './selection/terrain_surface';
+export type {TerrainSurface, TerrainSurfaceBounds, TerrainRay, TerrainSurfaceHit, TerrainMeshOptions, TerrainMeshStatistics, TerrainSurfaceEntry, TerrainCollectionHit, TerrainElevationProbe} from './selection/terrain_surface';
+export type {
+  TangramGPUBackend,
+  TangramGPUSceneOptions,
+  TangramMeshBufferOptions,
+  TangramMeshDrawOptions,
+  TangramMeshDrawDescriptor,
+  TangramDrawableMesh,
+  TangramDrawableProgram,
+  TangramDrawableUniformBlock,
+  TangramRenderStateOptions,
+  TangramShaderLanguage,
+  TangramShaderOptions,
+  TangramShaderProgramOptions,
+  TangramTextureOptions,
+  TangramUniformBufferOptions
+} from './gpu/tangram_gpu_backend.js';
+
+export type {Matrix4, Vector3, SceneDefinition, Viewport, GeographicAnchor, HostProjection, HostCamera, HostRenderView, HostTileLODOptions, HostTileResourceOptions, TileResourceStatistics, TileSourceStatistics, HostFrameOptions, LegacyHostFrame, RendererOptions, SceneLoadOptions, SceneUpdateOptions, SceneDataSource, SceneFeature, SceneQueryOptions, SceneScreenshot, RenderOptions, SceneConfigEvent, SceneErrorEvent, SceneEventMap, SceneListener, SceneListeners, WorkerRequest, WorkerResponse, WorkerBrokerMessage} from './types.js';
+export {
+  WebMercatorGlobeVisibilityAdapter,
+  WebMercatorVisibilityAdapter
+} from './scene/visibility_adapter.js';
+export type {
+  CalculatedViewBounds,
+  GlobeVisibilityLODAdapter,
+  GlobeVisibilityViewState,
+  VisibilityLODAdapter,
+  VisibilityViewState
+} from './scene/visibility_adapter.js';
+
+import HostFrame from './scene/host_frame';
+import LumaDeviceRenderer from './gpu/luma_device_renderer.js';
+export {HostFrame};
+export {LumaDeviceRenderer};
+export {calculatePlanarGroundBounds, calculatePlanarVolumeBounds} from './scene/ground_footprint';
+export {convertLumaLight, mapTangramLight} from './lights/light-definitions';
+export type {ResolvedTangramLight, TangramLightMapping, TangramLight, TangramAmbientLight,
+    TangramDirectionalLight, TangramPointLight, TangramSpotLight, TangramLightExtensions,
+    TangramPositionalLightExtensions, TangramLightColor, NormalizedTangramLight} from './lights/light-definitions';
+export type {Light as LumaLight} from '@luma.gl/shadertools';
+export type {TangramTileSourceMetadata} from './sources/tile_source_metadata';
+export type {MeshProjectionStatistics} from './procedures/mesh-projector';
+export type {ProjectionExecutionOptions, ProjectionExecutionStatistics} from './procedures/projection-batch-executor.js';
+
+export declare class Scene {
+  /** Normalized animation policy read by host-driven layer integrations. */
+  config: {scene?: {animated?: boolean}} | null;
+  /** Run a synchronous operation inside the renderer's existing shared WebGL state scope. */
+  withWebGLContext<Value>(operation: () => Value): Value;
+  static create(config: SceneDefinition, options?: RendererOptions): Scene;
+  subscribe(listeners: SceneListeners): void;
+  unsubscribe(listeners: SceneListeners): void;
+  load(config?: SceneDefinition | null, options?: SceneLoadOptions): Promise<unknown>;
+  updateConfig(options?: SceneUpdateOptions): Promise<void>;
+  /** Deduplicated source/TileJSON credits; HTML must be sanitized by the displaying host. */
+  getAttributions(): Promise<string[]>;
+  /** Normalized TileJSON/archive capabilities, preserving authored source overrides. */
+  getSourceMetadata(): Promise<Record<string, import('./sources/tile_source_metadata').TangramTileSourceMetadata>>;
+  /** Detached decoded acquisition diagnostics from each current worker. */
+  getTileSourceStatistics(): Promise<import('./types').TileSourceStatistics[]>;
+  /** Detached cooperative host execution counters; absent for worker-local kernels. */
+  getProjectionEngineStatistics(): import('./procedures/projection-batch-executor.js').ProjectionExecutionStatistics | undefined;
+  /** Current-eye luma.gl definitions with exact Tangram-only shading extensions. */
+  getLumaLightDefinitions(): import('./lights/light-definitions').TangramLightMapping[];
+  setDataSource(name: string, config: SceneDataSource): Promise<unknown> | undefined;
+  queryFeatures(
+    options?: SceneQueryOptions
+  ): Promise<SceneFeature[] | Record<string, SceneFeature[]>>;
+  screenshot(options?: {background?: string}): Promise<SceneScreenshot>;
+  destroy(): unknown;
+}
+
+export declare class ClassicWebGLRenderer {
+  /** Synchronous nearest hit on an explicit host-owned terrain mesh, in the selected eye. */
+  getTerrainAt(pixel: {x: number; y: number}, surface?: import('./selection/terrain_surface').TerrainSurface,
+    options?: import('./types').FeatureSelectionOptions): import('./selection/terrain_surface').TerrainSurfaceHit | null;
+  /** Async interactive-draw selection in active-view CSS pixels; host rendering must continue. */
+  getFeatureAt(pixel: {x: number; y: number}, options?: import('./types').FeatureSelectionOptions): Promise<import('./types').FeatureSelectionResult | undefined>;
+  /** Reproject loaded meshes without replacing workers; rejects failed builds and permits subsequent recovery. */
+  setProjectedBasemapProjection(projection: import('./procedures/mesh-projector').ProjectedBasemapOptions): Promise<void>;
+  /** Rebuild worker terrain geometry while preserving vector source caches. */
+  setTerrain(options: import('./procedures/terrain-draping').TerrainDrapingOptions): Promise<void>;
+  /** Adjust visual relief without resampling or rebuilding worker geometry. */
+  setTerrainExaggeration(value: number): void;
+  /** Exact admitted ground draw topology, temporal blend and physical query channels. */
+  getDrapedTerrainSurface(): import('./selection/draped-terrain-surface').DrapedTerrainSurfaceSnapshot | null;
+    /** Resident worker preparation cost, excluding GPU and transient copies. */
+    getTerrainDrapingStatistics(): import('./procedures/terrain-draping').TerrainDrapingStatistics;
+  constructor(config: SceneDefinition, options?: RendererOptions);
+  static create(config: SceneDefinition, options?: RendererOptions): ClassicWebGLRenderer;
+  readonly scene: Scene;
+  readonly gpuBackend: LumaDeviceRenderer | null;
+  setFrame(
+    frame: HostFrame | HostFrameOptions | LegacyHostFrame,
+    options?: {renderViewId?: string}
+  ): HostFrame;
+  render(options?: RenderOptions): boolean;
+  load(config?: SceneDefinition | null, options?: SceneLoadOptions): Promise<unknown>;
+  /** Current source/TileJSON credits for the host's attribution UI. */
+  getAttributions(): Promise<string[]>;
+  /** Current source capabilities without exposing worker/archive ownership. */
+  getSourceMetadata(): Promise<Record<string, import('./sources/tile_source_metadata').TangramTileSourceMetadata>>;
+  /** Per-worker built-in source-procedure slots; separate from renderer mesh-build accounting. */
+  getTileSourceStatistics(): Promise<import('./types').TileSourceStatistics[]>;
+  /** Detached cooperative host execution counters; absent for worker-local kernels. */
+  getProjectionEngineStatistics(): import('./procedures/projection-batch-executor.js').ProjectionExecutionStatistics | undefined;
+  /** Current-eye luma.gl definitions with exact Tangram-only shading extensions. */
+  getLumaLightDefinitions(): import('./lights/light-definitions').TangramLightMapping[];
+  subscribe(listeners: SceneListeners): void;
+  /** Shared worker queue and completed-cache mesh bytes; excludes texture/CPU/driver memory. */
+  getTileResourceStatistics(): import('./types.js').TileResourceStatistics;
+  destroy(): unknown;
+}
+
+export declare const Renderer: typeof ClassicWebGLRenderer;
+export declare const debug: Record<string, unknown>;
+export declare const version: string;
+
+declare const Tangram: {
+  Scene: typeof Scene;
+  ClassicWebGLRenderer: typeof ClassicWebGLRenderer;
+  Renderer: typeof ClassicWebGLRenderer;
+  HostFrame: typeof HostFrame;
+  LumaDeviceRenderer: typeof LumaDeviceRenderer;
+  debug: typeof debug;
+  version: string;
+};
+
+export default Tangram;
+export type {TerrainDrapingOptions, TerrainDrapingStatistics} from './procedures/terrain-draping';
+export type {ProjectionEngine, ProjectionEngineOptions, ProjectionEngineTransform} from './types.js';

package/src/index.ts

@@ -0,0 +1,105 @@
+// Tangram
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2013-2016 Brett Camper and Mapzen
+// Copyright (c) 2026 vis.gl contributors
+
+/*jshint worker: true*/
+
+import Scene from './scene/classic_scene';
+import ClassicWebGLRenderer from './scene/renderer';
+import HostFrame from './scene/host_frame';
+export {TerrainMeshSurface, TerrainSurfaceCollection, sampleTerrainElevation, resolveTerrainClearance, pickTerrainAt} from './selection/terrain_surface';
+export type {TerrainSurface, TerrainSurfaceBounds, TerrainRay, TerrainSurfaceHit, TerrainMeshOptions, TerrainMeshStatistics, TerrainSurfaceEntry, TerrainCollectionHit, TerrainElevationProbe} from './selection/terrain_surface';
+import LumaDeviceRenderer from './gpu/luma_device_renderer';
+export type {HostTileResourceOptions, TileResourceStatistics, TileSourceStatistics} from './types';
+export type {MeshProjectionStatistics} from './procedures/mesh-projector';
+
+// Additional modules are exposed for debugging
+import version from './utils/version';
+import log from './utils/log';
+import Utils from './utils/utils';
+import Geo from './utils/geo';
+import Vector from './utils/vector';
+import DataSource from './sources/data_source';
+import GLSL from './gl/glsl';
+import ShaderProgram from './gl/shader_program';
+import UniformBuffer from './gl/uniform_buffer';
+import VertexData from './gl/vertex_data';
+import Texture from './gl/texture';
+import Material from './lights/material';
+import Light from './lights/light';
+import WorkerBroker from './utils/worker_broker';
+import Task from './utils/task';
+import {StyleManager} from './styles/style_manager';
+import StyleParser from './styles/style_parser';
+import {TileID} from './tile/tile_id';
+import Collision from './labels/collision';
+import FeatureSelection from './selection/selection';
+import TextCanvas from './styles/text/text_canvas';
+import debugSettings from './utils/debug_settings';
+import {
+    WebMercatorGlobeVisibilityAdapter,
+    WebMercatorVisibilityAdapter
+} from './scene/visibility_adapter';
+
+import yaml from 'js-yaml';
+
+// Make some modules accessible for debugging
+const debug = {
+    log,
+    yaml,
+    Utils,
+    Geo,
+    Vector,
+    DataSource,
+    GLSL,
+    ShaderProgram,
+    UniformBuffer,
+    VertexData,
+    Texture,
+    Material,
+    Light,
+    Scene,
+    ClassicWebGLRenderer,
+    HostFrame,
+    LumaDeviceRenderer,
+    WorkerBroker,
+    Task,
+    StyleManager,
+    StyleParser,
+    TileID,
+    Collision,
+    FeatureSelection,
+    TextCanvas,
+    debugSettings
+};
+
+const Tangram = {
+    Scene,
+    ClassicWebGLRenderer,
+    Renderer: ClassicWebGLRenderer,
+    HostFrame,
+    LumaDeviceRenderer,
+    debug,
+    version
+};
+
+export {WebMercatorGlobeVisibilityAdapter, WebMercatorVisibilityAdapter};
+export {calculatePlanarGroundBounds, calculatePlanarVolumeBounds} from './scene/ground_footprint';
+export {convertLumaLight, mapTangramLight} from './lights/light-definitions';
+export type {ResolvedTangramLight, TangramLightMapping, TangramLight, TangramAmbientLight,
+    TangramDirectionalLight, TangramPointLight, TangramSpotLight, TangramLightExtensions,
+    TangramPositionalLightExtensions, TangramLightColor, NormalizedTangramLight} from './lights/light-definitions';
+export type {Light as LumaLight} from '@luma.gl/shadertools';
+export type {TangramTileSourceMetadata} from './sources/tile_source_metadata';
+export type {
+    CalculatedViewBounds,
+    GlobeVisibilityLODAdapter,
+    GlobeVisibilityViewState,
+    VisibilityLODAdapter,
+    VisibilityViewState
+} from './scene/visibility_adapter';
+
+export default Tangram;
+export type {TerrainDrapingOptions, TerrainDrapingStatistics} from './procedures/terrain-draping';
+export {DrapedTerrainSurfaceSnapshot} from './selection/draped-terrain-surface';

package/src/labels/collision-types.ts

@@ -0,0 +1,94 @@
+// tangram-layers
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type OBB from '../utils/obb';
+
+/** Parallel broad/narrow-phase bounds for labels already placed in a tile or grid cell. */
+export interface CollisionBounds {
+    /** Axis-aligned boxes in placement order. */
+    aabb: number[][];
+    /** Oriented boxes corresponding to the axis-aligned boxes. */
+    obb: OBB[];
+}
+
+/** Layout controls consumed by collision and repeat culling, independent of rendering styles. */
+export interface CollisionLayout {
+    /** Lower numeric values are considered first. */
+    priority: number;
+    /** Whether placed-label intersections can reject this label. */
+    collide?: boolean;
+    /** Minimum separation within a repeat group. */
+    repeat_distance?: number;
+    /** Optional repeat group identifier. */
+    repeat_group?: string;
+    /** Worker/main-pass distance scale, provided by layout normalization. */
+    repeat_scale: number;
+}
+
+/** Minimal mutable label contract shared by worker and main-pass collision. */
+export interface CollisionLabel {
+    /** Collision and repeat rules. */
+    layout: CollisionLayout;
+    /** Position used by repeat culling. */
+    position: [number, number];
+    /** Single-box broad-phase extent, or null before bounds are built. */
+    aabb?: number[] | null;
+    /** Multi-box broad-phase extents. */
+    aabbs?: number[][];
+    /** Single-box narrow-phase bounds. */
+    obb?: OBB | null;
+    /** Multi-box narrow-phase bounds. */
+    obbs?: OBB[];
+    /** Placement outcome; null/undefined means not processed yet. */
+    placed?: boolean | null;
+    /** Grid cells containing this candidate. */
+    cells?: CollisionBounds[];
+    /** Whether this label crosses a tile boundary. */
+    breach?: boolean;
+    /** Whether main-pass repeat culling is still required. */
+    may_repeat_across_tiles?: boolean;
+    /** Test placed bounds while ignoring an explicitly linked label. */
+    discard(bounds: CollisionBounds, exclude: CollisionLabel | null | 0 | ''): boolean;
+}
+
+/** Placement container; callers can retain additional renderer-specific payload. */
+export interface PendingCollisionObject {
+    /** Attached text acquires its label before the cross-style completion barrier is released. */
+    label?: CollisionLabel;
+    /** Optional linked queue entry, also prepared before placement begins. */
+    linked?: PendingCollisionObject | null | 0 | '';
+    /** Placement visibility after the shared barrier has completed. */
+    show?: boolean | null;
+}
+
+export interface CollisionObject extends PendingCollisionObject {
+    /** Mutable candidate label. */
+    label: CollisionLabel;
+    /** Optional placement dependency, considered as a pair; legacy falsy IDs are ignored. */
+    linked?: PendingCollisionObject | null | 0 | '';
+    /** Visibility assigned by the collision pass. */
+    show?: boolean | null;
+}
+
+/** Per-tile batching and resolution state. */
+export interface CollisionTileState {
+    /** Accumulated placed bounds when no grid is used. */
+    bboxes: CollisionBounds;
+    /** Submitted objects grouped first by numeric priority, then by style. */
+    objects: Record<string, Record<string, CollisionObject[]>>;
+    /** Resolved visible/hidden objects grouped by style. */
+    labels: Record<string, CollisionObject[]>;
+    /** Styles that have not yet submitted their objects. */
+    styles: Record<string, boolean>;
+    /** Whether repeat culling is enabled for this tile. */
+    repeat: boolean;
+    /** Whether rejected objects are returned as hidden. */
+    return_hidden: boolean;
+    /** Completion barrier initialized by startTile before any submissions. */
+    complete?: Promise<void | CollisionObject[]>;
+    /** Complete normally or abort with an empty result. */
+    resolve?: ((result?: CollisionObject[]) => void) | null;
+    /** Rejection hook retained for compatibility with the existing state. */
+    reject?: (reason?: unknown) => void;
+}