Class LinesSpatialIndexLoader

Lines data loader using spatial indices for efficient nD queries.

Key features:

Segment-first loading: segments → vertices
Index remapping from global to local indices
nD endpoint clipping for partial segment visibility
Per-vertex attribute interpolation for clipped segments

Implements

LinesDataLoader

Constructors

constructor

new LinesSpatialIndexLoader(
    zarrLocation: Location<Readable>,
    node: SceneNode,
    refRegistry?: ArrayRefRegistry,
    zarrStore?: Readable,
    l0Cache?: DecompressedChunkCache,
    prefetcher?: ChunkPrefetcher,
    sliceCache?: SliceCache,
): LinesSpatialIndexLoader
Parameters
- zarrLocation: Location<Readable>
- node: SceneNode
- OptionalrefRegistry: ArrayRefRegistry
- OptionalzarrStore: Readable
- Optionall0Cache: DecompressedChunkCache
- Optionalprefetcher: ChunkPrefetcher
- OptionalsliceCache: SliceCache
Returns LinesSpatialIndexLoader
- Defined in src/data/lines/lines-spatial-index-loader.ts:162

Properties

`Private`chunkIndex

chunkIndex: LinesDualChunkIndex | null = null

`Private`zarrLocation

zarrLocation: Location<Readable>

`Private`node

node: SceneNode

`Private`_onceInit

_onceInit: OnceInit = ...

`Private`rangeLoader

rangeLoader: RangeLoader

`Private`zarrStore

zarrStore: Readable | null = null

`Private`_accumulator

_accumulator: LinesDataAccumulator | null = null

`Private`_accumulatorConfig

_accumulatorConfig:
    | {
        initialVertexCapacity: number;
        initialSegmentCapacity: number;
        ndim: number;
    }
    | null = null

`Private`_accumulatorReleased

_accumulatorReleased: boolean = false

`Private`l0Cache

l0Cache: DecompressedChunkCache | null = null

`Private`_activeProbe

_activeProbe: ResidencyAccumulator | null = null

`Private`_activeSignal

_activeSignal: AbortSignal | null = null

`Private`prefetcher

prefetcher: ChunkPrefetcher | null = null

`Private`sliceCache

sliceCache: SliceCache | null = null

`Private`_initialLoadDone

_initialLoadDone: boolean = false

`Private`colorComponents

colorComponents: 3 | 4 = 3

`Private` `Readonly`events

events: LoaderEventEmitter = ...

`Private` `Readonly`metrics

metrics: LoaderMetrics

`Private` `Readonly`activeQueries

activeQueries: Map<string, QueryInfo> = ...

`Private`nextQueryId

nextQueryId: number = 0

`Private`totalQueryCells

totalQueryCells: number = 0

`Private` `Readonly`facadeCtx

facadeCtx: SpatialFacadeCtx

`Private`arrays

arrays: {
    vertices?: Array<DataType, Readable>;
    segments?: Array<DataType, Readable>;
    widths?: Array<DataType, Readable>;
    colors?: Array<DataType, Readable>;
    sharpness?: Array<DataType, Readable>;
    scalars?: Array<DataType, Readable>;
} = {}

Type Declaration

Optionalvertices?: Array<DataType, Readable>
Optionalsegments?: Array<DataType, Readable>
Optionalwidths?: Array<DataType, Readable>
Optionalcolors?: Array<DataType, Readable>
Optionalsharpness?: Array<DataType, Readable>
Optionalscalars?: Array<DataType, Readable>

optional per-vertex scalars for colormap lookup.

Methods

`Private`registerBounds

registerBounds(arrayName: string, array: Array<DataType, Readable>): void
Thin wrapper around the shared registerLinesArrayBounds helper so the call sites read more naturally than passing the prefetcher and node path on every call.
Parameters
- arrayName: string
- array: Array<DataType, Readable>
Returns void
- Defined in src/data/lines/lines-spatial-index-loader.ts:201

initialize

initialize(): Promise<void>
Initialize the loader by loading spatial index and opening arrays

Returns Promise<void>
- Defined in src/data/lines/lines-spatial-index-loader.ts:208

`Private`createAccumulator

createAccumulator(): void
Returns void
- Defined in src/data/lines/lines-spatial-index-loader.ts:398

releaseAccumulator

releaseAccumulator(): void
Release pooled decoded buffers after a progressive parent has copied them. Earlier payloads remain valid because dispose() replaces the accumulator buffers rather than clearing their old arrays. This deliberately gives up pooling across view changes: retaining the pool would keep the second copy that progressive Lines releases here.

Returns void
- Defined in src/data/lines/lines-spatial-index-loader.ts:431

loadLines

loadLines(
viewState: ViewState,
session?: UpdateSession,
): Promise<LoadedLinesData>
Load lines data for the given view state
Parameters
- viewState: ViewState
  Current view state
- Optionalsession: UpdateSession
  Optional profiler session for nested timing
Returns Promise<LoadedLinesData>
Implementation of LinesDataLoader.loadLines
- Defined in src/data/lines/lines-spatial-index-loader.ts:444

`Private`loadLinesInternal

loadLinesInternal(
    viewState: ViewState,
    session: UpdateSession | undefined,
    queryId: string,
    startTime: number,
): Promise<LoadedLinesData>
Parameters
- viewState: ViewState
- session: UpdateSession | undefined
- queryId: string
- startTime: number
Returns Promise<LoadedLinesData>
- Defined in src/data/lines/lines-spatial-index-loader.ts:453

updateView

updateView(
    viewState: ViewState,
    session?: UpdateSession,
    signal?: AbortSignal,
): Promise<LoadedLinesData>
Update view for new position. Note: extend_to_all optimization is handled at scene-loader level, which skips calling this method entirely for fully-extended nodes.
Parameters
- viewState: ViewState
  Current view state
- Optionalsession: UpdateSession
  Optional profiler session for nested timing
- Optionalsignal: AbortSignal
Returns Promise<LoadedLinesData>
Implementation of LinesDataLoader.updateView
- Defined in src/data/lines/lines-spatial-index-loader.ts:821

updateViewWithResidency

updateViewWithResidency(
    viewState: ViewState,
    session?: UpdateSession,
    signal?: AbortSignal,
): Promise<{ data: LoadedLinesData; allResident: boolean }>
Like updateView but also reports whether the load was served entirely from cache (see runWithResidencyProbe).
Parameters
- viewState: ViewState
- Optionalsession: UpdateSession
- Optionalsignal: AbortSignal
Returns Promise<{ data: LoadedLinesData; allResident: boolean }>
- Defined in src/data/lines/lines-spatial-index-loader.ts:844

prefetchChunks

prefetchChunks(viewState: ViewState): Promise<void>
Warm the cache for the given viewState without producing geometry.

Mirrors the gsplats / points prefetchChunks(viewState) so a dimension-animation hook can prefetch the next slice while the current frame renders. Segments are keyed by segment ranges; vertices, widths, colors, sharpness, and scalars are keyed by vertex ranges. Querying both published indexes keeps speculative reads in the same row currency as the demand path instead of treating segment offsets as vertex offsets.
Parameters
- viewState: ViewState
Returns Promise<void>
- Defined in src/data/lines/lines-spatial-index-loader.ts:865

prefetchChunkBoundary

prefetchChunkBoundary(current: ViewState, predicted: ViewState): Promise<void>
Parameters
- current: ViewState
- predicted: ViewState
Returns Promise<void>
- Defined in src/data/lines/lines-spatial-index-loader.ts:888

`Private`prefetchVertexArrays

prefetchVertexArrays(): Array<DataType, Readable>[]
Returns Array<DataType, Readable>[]
- Defined in src/data/lines/lines-spatial-index-loader.ts:935

`Private`sliceDistance

sliceDistance(left: ViewState, right: ViewState): number
Parameters
- left: ViewState
- right: ViewState
Returns number
- Defined in src/data/lines/lines-spatial-index-loader.ts:945

`Private`loadDualChunkBounds

loadDualChunkBounds(attrs: LinesMetadata): Promise<LinesDualChunkIndex | null>
Probe both vertex_chunk_bounds and segment_chunk_bounds from zarr.

Implementation lives in lines/chunk-index-loader.ts. The thin wrapper here exists for symmetry with the points facade, which follows the same pattern.
Parameters
- attrs: LinesMetadata
Returns Promise<LinesDualChunkIndex | null>
- Defined in src/data/lines/lines-spatial-index-loader.ts:960

`Private`vertexSpatialIndex

vertexSpatialIndex(
    attrs: LinesMetadata,
): {
    chunkBounds: Float32Array<ArrayBufferLike>;
    chunkCount: number;
    metadata: { ndim: number; chunk_size: number };
}
Parameters
- attrs: LinesMetadata
Returns {
    chunkBounds: Float32Array<ArrayBufferLike>;
    chunkCount: number;
    metadata: { ndim: number; chunk_size: number };
}
- Defined in src/data/lines/lines-spatial-index-loader.ts:964

`Private`queryVisibleVertexRanges

queryVisibleVertexRanges(viewState: ViewState): Promise<SegmentRange[]>
Parameters
- viewState: ViewState
Returns Promise<SegmentRange[]>
- Defined in src/data/lines/lines-spatial-index-loader.ts:972

`Private`queryVisibleSegmentRanges

queryVisibleSegmentRanges(viewState: ViewState): Promise<SegmentRange[]>
Query visible segment ranges based on view state.

Delegates the chunk-bounds AABB scan and range coalescing to the canonical SpatialQueryBuilder with geometryType: 'lines'. Returns a load-all range when no spatial index is available.
Parameters
- viewState: ViewState
Returns Promise<SegmentRange[]>
- Defined in src/data/lines/lines-spatial-index-loader.ts:994

`Private`loadSegmentRanges

loadSegmentRanges(ranges: SegmentRange[]): Promise<Uint32Array<ArrayBufferLike>>
Load segment index data for given ranges
Parameters
- ranges: SegmentRange[]
Returns Promise<Uint32Array<ArrayBufferLike>>
- Defined in src/data/lines/lines-spatial-index-loader.ts:1039

`Private`loadVertexRanges

loadVertexRanges(
    arrayName: string,
    ranges: SegmentRange[],
    elementsPerVertex: number,
    targetBuffer?: Float32Array<ArrayBufferLike>,
): Promise<Float32Array<ArrayBufferLike>>
Load vertex ranges with optional target buffer for zero-allocation operation.

Uses RangeLoader for unified encoding dispatch (broadcasted, quantized, lut, direct). Array references are handled specially (need zarrStore access to resolve target).
Parameters
- arrayName: string
- ranges: SegmentRange[]
- elementsPerVertex: number
- OptionaltargetBuffer: Float32Array<ArrayBufferLike>
Returns Promise<Float32Array<ArrayBufferLike>>
- Defined in src/data/lines/lines-spatial-index-loader.ts:1063

`Private`loadColorRanges

loadColorRanges(
    ranges: SegmentRange[],
    targetBuffer?:
        | Uint8Array<ArrayBufferLike>
        | Float32Array<ArrayBufferLike>
        | Uint16Array<ArrayBufferLike>,
): Promise<
    | Uint8Array<ArrayBufferLike>
    | Float32Array<ArrayBufferLike>
    | Uint16Array<ArrayBufferLike>,
>
Load color ranges with multi-type support (preserves original_dtype)

This method handles the full encoding/decoding pipeline for colors, including original_dtype restoration for encoded arrays.
Parameters
- ranges: SegmentRange[]
- OptionaltargetBuffer:
      | Uint8Array<ArrayBufferLike>
      | Float32Array<ArrayBufferLike>
      | Uint16Array<ArrayBufferLike>
Returns Promise<
    | Uint8Array<ArrayBufferLike>
    | Float32Array<ArrayBufferLike>
    | Uint16Array<ArrayBufferLike>,
>
- Defined in src/data/lines/lines-spatial-index-loader.ts:1106

`Private`createDefaultWidths

createDefaultWidths(count: number): Float32Array
Create default widths array (all 1.0)
Parameters
- count: number
Returns Float32Array
- Defined in src/data/lines/lines-spatial-index-loader.ts:1131

getAccumulatorStats

getAccumulatorStats(): AccumulatorStats | null
Get accumulator stats for memory monitoring

Returns AccumulatorStats | null
- Defined in src/data/lines/lines-spatial-index-loader.ts:1140

addEventListener

addEventListener(listener: MonitorEventListener): void
LoaderMonitor surface (optional, for the data-loading-monitor UI). Mirrors the surface that points-spatial-index-loader.ts exposes — implementations that don't track metrics may omit these methods.
Parameters
- listener: MonitorEventListener
Returns void
Implementation of LinesDataLoader.addEventListener
- Defined in src/data/lines/lines-spatial-index-loader.ts:1148

dispose

dispose(): void
Clean up resources

Returns void
Implementation of LinesDataLoader.dispose
- Defined in src/data/lines/lines-spatial-index-loader.ts:1183

Class LinesSpatialIndexLoader

Implements

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns LinesSpatialIndexLoader

Properties

PrivatechunkIndex

PrivatezarrLocation

Privatenode

Private_onceInit

PrivaterangeLoader

PrivatezarrStore

Private_accumulator

Private_accumulatorConfig

Private_accumulatorReleased

Privatel0Cache

Private_activeProbe

Private_activeSignal

Privateprefetcher

PrivatesliceCache

Private_initialLoadDone

PrivatecolorComponents

Private Readonlyevents

Private Readonlymetrics

Private ReadonlyactiveQueries

PrivatenextQueryId

PrivatetotalQueryCells

Private ReadonlyfacadeCtx

Privatearrays

Type Declaration

Optionalvertices?: Array<DataType, Readable>

Optionalsegments?: Array<DataType, Readable>

Optionalwidths?: Array<DataType, Readable>

Optionalcolors?: Array<DataType, Readable>

Optionalsharpness?: Array<DataType, Readable>

Optionalscalars?: Array<DataType, Readable>

Methods

PrivateregisterBounds

Parameters

Returns void

initialize

Returns Promise<void>

PrivatecreateAccumulator

Returns void

releaseAccumulator

Returns void

loadLines

Parameters

Returns Promise<LoadedLinesData>

PrivateloadLinesInternal

Parameters

Returns Promise<LoadedLinesData>

updateView

Parameters

Returns Promise<LoadedLinesData>

updateViewWithResidency

Parameters

Returns Promise<{ data: LoadedLinesData; allResident: boolean }>

prefetchChunks

Parameters

Returns Promise<void>

prefetchChunkBoundary

Parameters

Returns Promise<void>

PrivateprefetchVertexArrays

Returns Array<DataType, Readable>[]

PrivatesliceDistance

Parameters

Returns number

PrivateloadDualChunkBounds

Parameters

Returns Promise<LinesDualChunkIndex | null>

PrivatevertexSpatialIndex

Parameters

Returns { chunkBounds: Float32Array<ArrayBufferLike>; chunkCount: number; metadata: { ndim: number; chunk_size: number };}

`Private`chunkIndex

`Private`zarrLocation

`Private`node

`Private`_onceInit

`Private`rangeLoader

`Private`zarrStore

`Private`_accumulator

`Private`_accumulatorConfig

`Private`_accumulatorReleased

`Private`l0Cache

`Private`_activeProbe

`Private`_activeSignal

`Private`prefetcher

`Private`sliceCache

`Private`_initialLoadDone

`Private`colorComponents

`Private` `Readonly`events

`Private` `Readonly`metrics

`Private` `Readonly`activeQueries

`Private`nextQueryId

`Private`totalQueryCells

`Private` `Readonly`facadeCtx

`Private`arrays

`Optional`vertices?: Array<DataType, Readable>

`Optional`segments?: Array<DataType, Readable>

`Optional`widths?: Array<DataType, Readable>

`Optional`colors?: Array<DataType, Readable>

`Optional`sharpness?: Array<DataType, Readable>

`Optional`scalars?: Array<DataType, Readable>

`Private`registerBounds

`Private`createAccumulator

`Private`loadLinesInternal

`Private`prefetchVertexArrays

`Private`sliceDistance

`Private`loadDualChunkBounds

`Private`vertexSpatialIndex

Returns {
chunkBounds: Float32Array<ArrayBufferLike>;
chunkCount: number;
metadata: { ndim: number; chunk_size: number };
}

`Private`queryVisibleVertexRanges

`Private`queryVisibleSegmentRanges

`Private`loadSegmentRanges

`Private`loadVertexRanges

`Private`loadColorRanges

Returns Promise<
| Uint8Array<ArrayBufferLike>
| Float32Array<ArrayBufferLike>
| Uint16Array<ArrayBufferLike>,
>

`Private`createDefaultWidths

`Private`emitEvent