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:158

Properties

`Private`chunkIndex

chunkIndex: LinesDualChunkIndex | null = null

`Private`zarrLocation

zarrLocation: Location<Readable>

`Private`node

node: SceneNode

`Private` `Readonly`_lifetime

_lifetime: LoaderLifetime = ...

Disposed latch, lifetime signal, one-shot initialization and the per-call demand-load context (lifetime.calls) the wrapped arrays' getChunk reads through the () => this._lifetime.calls.signal / .probe thunks below (see LoaderLifetime, ActiveLoadContext).

`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`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:209

ensureInitialized

ensureInitialized(priority?: FetchPriority): Promise<void>
Initialize metadata once without loading any attribute payload chunks, under the disposed latch (LoaderLifetime.ensureInitialized): a disposed loader refuses to re-initialize, and an initialization still in flight when dispose runs is discarded instead of repopulating the loader.

priority classes the chunk_bounds read of an initialization THIS call starts (B6: a progressive loader warms rung k+1's index at 'refinement' while rung k loads; the speculative entry points pass 'speculative'). A later call without one raises an in-flight warm to demand.
Parameters
- Optionalpriority: FetchPriority
Returns Promise<void>
- Defined in src/data/lines/lines-spatial-index-loader.ts:225

initialize

initialize(signal?: AbortSignal): Promise<void>
Initialize the loader by loading spatial index and opening arrays
Parameters
- Optionalsignal: AbortSignal
Returns Promise<void>
- Defined in src/data/lines/lines-spatial-index-loader.ts:237

`Private`createAccumulator

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

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:449

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:462

`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:471

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:850

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 ActiveLoadContext.runWithProbe).
Parameters
- viewState: ViewState
- Optionalsession: UpdateSession
- Optionalsignal: AbortSignal
Returns Promise<{ data: LoadedLinesData; allResident: boolean }>
- Defined in src/data/lines/lines-spatial-index-loader.ts:869

prefetchChunks

prefetchChunks(viewState: ViewState, signal?: AbortSignal): 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. Each distinct chunk those ranges touch is fetched and decoded into L0 via the proxy's warmChunk — no zarr get(), so no output selection is assembled, and the demand load's abort signal / residency probe are not consulted (see prefetchRangesIntoCache).
Parameters
- viewState: ViewState
- Optionalsignal: AbortSignal
Returns Promise<void>
- Defined in src/data/lines/lines-spatial-index-loader.ts:891

prefetchChunkBoundary

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

`Private`prefetchVertexArrays

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

`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:977

`Private`loadDualChunkBounds

loadDualChunkBounds(
attrs: LinesMetadata,
signal?: AbortSignal,
): 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
- Optionalsignal: AbortSignal
Returns Promise<LinesDualChunkIndex | null>
- Defined in src/data/lines/lines-spatial-index-loader.ts:992

`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:999

`Private`queryVisibleVertexRanges

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

`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:1029

`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:1074

`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:1098

`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:1141

`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:1166

getAccumulatorStats

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

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

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:1183

dispose

dispose(): void
Clean up resources

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

Class LinesSpatialIndexLoader

Implements

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns LinesSpatialIndexLoader

Properties

PrivatechunkIndex

PrivatezarrLocation

Privatenode

Private Readonly_lifetime

PrivaterangeLoader

PrivatezarrStore

Private_accumulator

Private_accumulatorConfig

Private_accumulatorReleased

Privatel0Cache

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

ensureInitialized

Parameters

Returns Promise<void>

initialize

Parameters

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

`Private`chunkIndex

`Private`zarrLocation

`Private`node

`Private` `Readonly`_lifetime

`Private`rangeLoader

`Private`zarrStore

`Private`_accumulator

`Private`_accumulatorConfig

`Private`_accumulatorReleased

`Private`l0Cache

`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