@nebula-spatial/cad-loader 0.1.0

package/dist/loader/internal/geo-prepare.d.ts

@@ -0,0 +1,38 @@
+import type { ViewportRect } from '../../shared/types';
+import { type GeoChunk, type GeoGeometryChunk } from '../../core';
+export type GeometryKind = Extract<GeoChunk['kind'], 'line' | 'fill' | 'dot'>;
+export interface PreparedColorRun {
+    readonly startVertex: number;
+    readonly vertexCount: number;
+    readonly color: readonly [number, number, number];
+}
+export interface PreparedLayerChunk {
+    layerIndex: number;
+    lineweightPx?: number;
+    pos: Float32Array;
+    positionItemSize: 2 | 3;
+    col: Uint8Array;
+    count: number;
+    bbox: ViewportRect | null;
+    colorRuns?: readonly PreparedColorRun[];
+    linePositionKind?: 'xy-zero-z';
+}
+export type PrepareGeometryChunkOptions = {
+    markLinePositionXy?: boolean;
+    splitLineweight?: boolean;
+};
+export declare class PreparedGeometryAccumulatorByLayer {
+    #private;
+    get size(): number;
+    append(layers: readonly PreparedLayerChunk[]): number;
+    drain(): PreparedLayerChunk[];
+}
+export type PreparedGeometryAccumulators = Record<GeometryKind, PreparedGeometryAccumulatorByLayer>;
+export declare function createPreparedGeometryAccumulatorByLayer(): PreparedGeometryAccumulatorByLayer;
+export declare function createPreparedGeometryAccumulators(): PreparedGeometryAccumulators;
+export declare function mergePreparedBounds(current: ViewportRect | null, next: ViewportRect | null): ViewportRect | null;
+export declare function prepareGeometryChunkByLayer(payload: GeoGeometryChunk, options?: PrepareGeometryChunkOptions): PreparedLayerChunk[];
+export declare function appendPreparedLayers(accumulator: PreparedGeometryAccumulatorByLayer, layers: readonly PreparedLayerChunk[]): number;
+export declare function drainPreparedLayers(accumulator: PreparedGeometryAccumulatorByLayer): PreparedLayerChunk[];
+export declare function estimatePreparedLayerBytes(layers: readonly PreparedLayerChunk[]): number;
+export declare function collectPreparedLayerTransfers(layers: readonly PreparedLayerChunk[]): Transferable[];

package/dist/loader/internal/geo-prepare.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/loader/internal/insert-model-builder.d.ts

@@ -0,0 +1,10 @@
+import type { TransferableInsertInstanceBatch, TransferableVariantGeometry } from './geo-prepare-worker-types';
+import type { ParsedHeader } from '../../core';
+export interface InsertModel {
+    variants: TransferableVariantGeometry[];
+    instances: TransferableInsertInstanceBatch;
+    bytes: number;
+    cost: number;
+}
+export declare function buildInsertModel(header: ParsedHeader): InsertModel | null;
+export declare function collectInsertModelTransfers(model: InsertModel): Transferable[];

package/dist/loader/internal/insert-runtime-geometry.d.ts

@@ -0,0 +1,15 @@
+import type { ViewportRect } from '../../shared/types';
+import type { GeoGeometryChunk, GroupLayerEncoding, InsertRuntimeVariant } from '../../core';
+export type InsertRuntimeGeometryKind = 'line' | 'fill' | 'dot';
+export type RuntimeVariantLayerChunk = {
+    readonly layerIndex: number;
+    readonly lineweightPx?: number;
+    readonly pos: Float32Array;
+    readonly col: Uint8Array;
+    readonly count: number;
+    readonly bbox: ViewportRect | null;
+};
+export type RuntimeVariantChunkMaps = Record<InsertRuntimeGeometryKind, ReadonlyMap<string, RuntimeVariantLayerChunk>>;
+export declare function decodeRuntimeGeometryChunk(raw: Uint8Array, count: number, groupLayerEncoding?: GroupLayerEncoding): GeoGeometryChunk;
+export declare function buildRuntimeVariantChunkMaps(variant: InsertRuntimeVariant): RuntimeVariantChunkMaps;
+export declare function mergeRuntimeLayerChunkBBoxes(chunks: RuntimeVariantChunkMaps, textsBBox: ViewportRect | null): ViewportRect | null;

package/dist/loader/internal/line-canonical.d.ts

@@ -0,0 +1,37 @@
+export type LineVariant = 'thin' | 'fat';
+export type LineCanonicalPosition = {
+    kind: 'xy';
+    xy: Float32Array;
+} | {
+    kind: 'xyz';
+    xyz: Float32Array;
+};
+export type LineCanonicalMemoryStats = {
+    recordCount: number;
+    vertexCount: number;
+    xyRecordCount: number;
+    xyzRecordCount: number;
+    xyVertexCount: number;
+    xyzVertexCount: number;
+    positionBytes: number;
+    colorBytes: number;
+    totalBytes: number;
+};
+export type LineVariantStats = {
+    activeThinCount: number;
+    activeFatCount: number;
+    cachedThinCount: number;
+    cachedFatCount: number;
+};
+export type LineMemoryStatsSnapshot = {
+    canonical: LineCanonicalMemoryStats;
+    variants: LineVariantStats;
+};
+export declare function packLineCanonicalPosition(pos3d: Float32Array, vertexCount: number): LineCanonicalPosition;
+export declare function packLineCanonicalPositionKnownXy(pos: Float32Array, vertexCount: number, itemSize?: 2 | 3): LineCanonicalPosition;
+export declare function copyLineCanonicalPositionTo3d(position: LineCanonicalPosition, vertexCount: number, target: Float32Array, targetVertexOffset: number): void;
+export declare function copyLineCanonicalPositionToItemSize(position: LineCanonicalPosition, vertexCount: number, target: Float32Array, targetVertexOffset: number, targetItemSize: 2 | 3): void;
+export declare function estimateLineCanonicalMemory(position: LineCanonicalPosition, color: Uint8Array, vertexCount: number): LineCanonicalMemoryStats;
+export declare function emptyLineCanonicalMemoryStats(): LineCanonicalMemoryStats;
+export declare function addLineCanonicalMemoryStats(total: LineCanonicalMemoryStats, delta: LineCanonicalMemoryStats): LineCanonicalMemoryStats;
+export declare function subtractLineCanonicalMemoryStats(total: LineCanonicalMemoryStats, delta: LineCanonicalMemoryStats): LineCanonicalMemoryStats;

package/dist/loader/internal/line-quality.d.ts

@@ -0,0 +1,9 @@
+import type { LineRenderMode } from '../../shared/types';
+export type RenderQualityMode = 'auto' | Exclude<LineRenderMode, 'width'>;
+export type EffectiveRenderQuality = Exclude<LineRenderMode, 'width'>;
+export interface AutoQualityContext {
+    visibleVertexCount: number;
+    zoom: number;
+}
+export declare function resolveAutoLineQuality(current: EffectiveRenderQuality, context: AutoQualityContext): EffectiveRenderQuality;
+export declare function resolveLineQuality(requested: RenderQualityMode, current: EffectiveRenderQuality, context: AutoQualityContext): EffectiveRenderQuality;

package/dist/loader/internal/prepare-credit-gate.d.ts

@@ -0,0 +1,20 @@
+export type CreditKind = 'geometry' | 'text';
+export interface WorkerCreditGrant {
+    geometryCredits: number;
+    textCredits: number;
+}
+export declare class PrepareCreditGate {
+    private geometryCredits;
+    private textCredits;
+    private cancelled;
+    private readonly geometryWaiters;
+    private readonly textWaiters;
+    grant(grant: WorkerCreditGrant): void;
+    cancel(): void;
+    take(kind: CreditKind): Promise<boolean>;
+    private flushWaiters;
+    private flushKind;
+    private getCredits;
+    private setCredits;
+    private getWaiters;
+}

package/dist/loader/internal/transport.d.ts

@@ -0,0 +1,2 @@
+import type { GeoLoadSource } from '../../shared/types';
+export declare function loadBuffer(source: GeoLoadSource): Promise<ArrayBuffer>;

package/dist/scene/geo-cad-line-geometry.d.ts

@@ -0,0 +1,28 @@
+import { Box3, BufferGeometry, InstancedBufferGeometry, LineSegments, Mesh, Sphere, Vector2 } from 'three';
+import { GeoCadLineMaterial } from './geo-cad-line-material';
+export type CadLineBBox = {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+};
+export type CadLineCreateArgs = {
+    position: Float32Array;
+    positionItemSize: 2 | 3;
+    color: Uint8Array;
+    vertexCount: number;
+    bbox: CadLineBBox;
+};
+export type FatCadLineCreateArgs = CadLineCreateArgs & {
+    linewidthPx: number;
+    resolution: Vector2;
+};
+export type ThinCadLine = LineSegments<BufferGeometry, GeoCadLineMaterial>;
+export type FatCadLine = Mesh<InstancedBufferGeometry, GeoCadLineMaterial>;
+export declare function createLineBoundsFromBbox(bbox: CadLineBBox): {
+    box: Box3;
+    sphere: Sphere;
+};
+export declare function createThinCadLine(args: CadLineCreateArgs): ThinCadLine;
+export declare function createFatCadLine(args: FatCadLineCreateArgs): FatCadLine;
+export declare function markCadLineColorBufferNeedsUpdate(geometry: BufferGeometry): void;

package/dist/scene/geo-cad-line-material.d.ts

@@ -0,0 +1,18 @@
+import { Color, RawShaderMaterial, Vector2 } from 'three';
+export type CadLineVariant = 'thin' | 'fat';
+export declare class GeoCadLineMaterial extends RawShaderMaterial {
+    readonly color: Color;
+    readonly resolution: Vector2;
+    constructor(args: {
+        variant: CadLineVariant;
+        linewidthPx?: number;
+        resolution?: Vector2;
+    });
+    get vertexColors(): boolean;
+    set vertexColors(value: boolean);
+    get opacity(): number;
+    set opacity(value: number);
+    get linewidthPx(): number;
+    set linewidthPx(value: number);
+    updateResolution(width: number, height: number): void;
+}

package/dist/scene/instancing/block-geometry-registry.d.ts

@@ -0,0 +1,35 @@
+import { BufferGeometry } from 'three';
+import type { ViewportRect } from '../../shared/types';
+export type BlockGeometryKind = 'line' | 'fill' | 'dot';
+export interface BlockGeometryChunkInput {
+    readonly pos: Float32Array;
+    readonly col: Uint8Array;
+    readonly count: number;
+    readonly layerIndex?: number;
+    readonly lineweightPx?: number;
+    readonly bbox?: ViewportRect | null;
+}
+export interface VariantGeometryInput {
+    readonly variantId: number;
+    readonly line: readonly BlockGeometryChunkInput[];
+    readonly fill: readonly BlockGeometryChunkInput[];
+    readonly dot: readonly BlockGeometryChunkInput[];
+}
+export interface KindGeometry {
+    readonly geometry: BufferGeometry;
+    readonly vertexCount: number;
+    readonly layerIndex: number;
+    readonly lineweightPx?: number;
+    readonly bbox: ViewportRect | null;
+}
+export interface VariantGeometry {
+    readonly variantId: number;
+    readonly byKind: Map<BlockGeometryKind, readonly KindGeometry[]>;
+}
+export interface BlockGeometryRegistry {
+    getVariant(variantId: number): VariantGeometry | undefined;
+    variantIds(): Iterable<number>;
+    appendVariants(inputs: readonly VariantGeometryInput[]): VariantGeometry[];
+    dispose(): void;
+}
+export declare function buildBlockGeometryRegistry(inputs: readonly VariantGeometryInput[]): BlockGeometryRegistry;

package/dist/scene/instancing/insert-instance-table.d.ts

@@ -0,0 +1,23 @@
+import type { ViewportRect } from '../../shared/types';
+export interface InsertInstanceRecord {
+    readonly recordKey?: string;
+    readonly instanceId: number;
+    readonly variantId: number;
+    readonly layerIdx: number;
+    readonly matA: number;
+    readonly matB: number;
+    readonly matC: number;
+    readonly matD: number;
+    readonly tx: number;
+    readonly ty: number;
+    readonly bbox: ViewportRect;
+}
+export interface InsertInstanceTable {
+    readonly records: readonly InsertInstanceRecord[];
+    appendRecords(records: readonly InsertInstanceRecord[]): void;
+    replaceRecord(record: InsertInstanceRecord): boolean;
+    queryInRect(rect: ViewportRect): InsertInstanceRecord[];
+    size(): number;
+    variantHistogram(): Map<number, number>;
+}
+export declare function buildInsertInstanceTable(records: readonly InsertInstanceRecord[]): InsertInstanceTable;

package/dist/scene/instancing/viewport-instance-presenter.d.ts

@@ -0,0 +1,66 @@
+import { InstancedBufferGeometry, LineSegments, Mesh, Object3D, Points, type Material } from 'three';
+import type { ViewportRect } from '../../shared/types';
+import type { BlockGeometryKind, BlockGeometryRegistry, VariantGeometry } from './block-geometry-registry';
+import type { InsertInstanceTable } from './insert-instance-table';
+export interface LayerVisibility {
+    readonly version: number;
+    isVisible(layerIdx: number): boolean;
+}
+export interface MaterialFactory {
+    (kind: BlockGeometryKind): Material;
+}
+export interface ViewportInstancePresenterOptions {
+    readonly registry: BlockGeometryRegistry;
+    readonly table: InsertInstanceTable;
+    readonly materialFactory: MaterialFactory;
+    readonly initialCapacity: number;
+    readonly marginRatio: number;
+}
+export interface ViewportInstancePresenterDebugSlot {
+    readonly variantId: number;
+    readonly kind: BlockGeometryKind;
+    readonly geometryLayerIndex: number;
+    readonly perVertexCount: number;
+    readonly localBBox: ViewportRect | null;
+    readonly mesh: PresenterRenderable;
+    readonly capacity: number;
+}
+type PresenterRenderable = (LineSegments | Mesh | Points) & {
+    geometry: InstancedBufferGeometry;
+    material: Material | Material[];
+    count: number;
+};
+export declare class ViewportInstancePresenter {
+    private readonly slots;
+    private readonly group;
+    private readonly marginRatio;
+    private readonly table;
+    private readonly materialFactory;
+    private readonly initialCapacity;
+    private attachedParent;
+    private lastQueryAll;
+    private lastQueryRect;
+    private lastQueryHits;
+    private lastFilteredQueryRect;
+    private lastFilteredQueryAll;
+    private lastLayerVersion;
+    private lastUserHiddenCacheKey;
+    private cacheValid;
+    private visibleVertexCount;
+    constructor(opts: ViewportInstancePresenterOptions);
+    appendVariant(variant: VariantGeometry): void;
+    attach(parent: Object3D): void;
+    detach(): void;
+    invalidateQueryCache(): void;
+    refresh(viewport: ViewportRect | null, layers: LayerVisibility, userHidden: ReadonlySet<number>, userHiddenRevision?: number): void;
+    currentVisibleVertexCount(): number;
+    private resolveQueryHits;
+    private removeVariantSlots;
+    private invalidateFilteredQueryCache;
+    dispose(): void;
+    _debugSlots(): readonly ViewportInstancePresenterDebugSlot[];
+    private ensureCapacity;
+    private writeMatRows;
+    private slotVisibleForRecord;
+}
+export {};

package/dist/selection/cad-insert-selection.d.ts

@@ -0,0 +1,35 @@
+import type { GeoNode } from '../loader/internal/geo-node';
+import type { BlockInstanceBBox } from '../shared/types';
+export interface CadPoint2D {
+    readonly x: number;
+    readonly y: number;
+}
+export interface CadInsertSelectionId {
+    readonly kind: 'insert';
+    readonly layerIndex: number;
+    readonly variantId: number;
+    readonly instanceId: number;
+}
+export interface CadInsertDetails {
+    readonly id: CadInsertSelectionId;
+    readonly label: string;
+    readonly blockName: string;
+    readonly layerName: string;
+    readonly layerIndex: number;
+    readonly tx: number;
+    readonly ty: number;
+    readonly rotation: number | null;
+    readonly scaleX: number | null;
+    readonly scaleY: number | null;
+    readonly bbox: Readonly<BlockInstanceBBox>;
+}
+export interface CadInsertPickOptions {
+    readonly padding?: number;
+    readonly isInstanceVisible?: (instanceId: number) => boolean;
+    readonly viewport?: Readonly<BlockInstanceBBox> | null;
+}
+export declare function cadInsertSelectionEquals(a: CadInsertSelectionId, b: CadInsertSelectionId): boolean;
+/** Resolve a world-space point to the top-most selectable CAD INSERT instance. */
+export declare function pickCadInsertAtPoint(node: GeoNode, point: CadPoint2D, options?: CadInsertPickOptions): CadInsertSelectionId | null;
+/** Resolve stable, read-only CAD properties for an INSERT selection. */
+export declare function resolveCadInsertDetails(node: GeoNode, id: CadInsertSelectionId): CadInsertDetails | null;

package/dist/session/load-session.d.ts

@@ -0,0 +1,90 @@
+import type { CadDisplayChunk, CadInsertInstance, CadPackDocument, CadPackHeader, CadTextChunk, ViewportRect } from '../core';
+import { type CadLoadSource } from '../shared/cad-load-source';
+import type { ExternalBlockVariantManifestEntry } from '../shared/types';
+export type { CadLoadSource } from '../shared/cad-load-source';
+export interface CadLoadFlowControlOptions {
+    highWatermarkBytes: number;
+    lowWatermarkBytes: number;
+    initialGeometryCredits: number;
+    initialTextCredits: number;
+}
+export interface CadExternalVariantFetchSource {
+    readonly baseUrl: string;
+    readonly entries: readonly ExternalBlockVariantManifestEntry[];
+}
+export interface CadLoadSessionOptions {
+    signal?: AbortSignal;
+    hiddenInstanceIds?: readonly number[];
+    keepTextsForHiddenInstances?: boolean;
+    loadBlocks?: boolean;
+    maxExpandedInstanceVertices?: number;
+    preferWorker?: boolean;
+    workerUrl?: string | URL;
+    workerFactory?: () => Worker;
+    externalVariantFetchSource?: CadExternalVariantFetchSource;
+    externalVariantBuffers?: ReadonlyMap<number, ArrayBuffer>;
+    requiredExternalVariantIds?: readonly number[];
+    externalVariantGeometryFetchIds?: readonly number[];
+    flowControl?: Partial<CadLoadFlowControlOptions>;
+    /** Cooperative decode budget before yielding to the next browser frame. */
+    frameBudgetMs?: number;
+    /** Time reserved for the renderer/UI within `frameBudgetMs`. */
+    frameReserveMs?: number;
+}
+export interface CadLoadMetaEvent {
+    readonly type: 'meta';
+    readonly meta: CadPackHeader;
+    /** Alias kept explicit for consumers that distinguish metadata from the parsed header. */
+    readonly header: CadPackHeader;
+}
+export interface CadLoadGeometryEvent {
+    readonly type: 'geometry';
+    readonly kind: 'line' | 'fill' | 'dot';
+    readonly chunk: CadDisplayChunk;
+    readonly layerIndex: number;
+    readonly lineweightPx?: number;
+    readonly bounds: ViewportRect | null;
+}
+export interface CadLoadTextEvent {
+    readonly type: 'text';
+    readonly chunk: CadTextChunk;
+}
+export interface CadLoadVariantGeometryChunk {
+    readonly pos: Float32Array;
+    readonly col: Uint8Array;
+    readonly count: number;
+    readonly layerIndex?: number;
+    readonly lineweightPx?: number;
+    readonly bounds?: ViewportRect | null;
+}
+export interface CadLoadVariantGeometry {
+    readonly variantId: number;
+    readonly line: readonly CadLoadVariantGeometryChunk[];
+    readonly fill: readonly CadLoadVariantGeometryChunk[];
+    readonly dot: readonly CadLoadVariantGeometryChunk[];
+}
+export interface CadLoadInsertEvent {
+    readonly type: 'insert';
+    readonly instances: readonly CadInsertInstance[];
+    readonly variants: readonly CadLoadVariantGeometry[];
+}
+export interface CadLoadVariantRequestEvent {
+    readonly type: 'variant-request';
+    readonly variantId: number;
+}
+export interface CadLoadReadyEvent {
+    readonly type: 'ready';
+    readonly document: CadPackDocument;
+}
+export interface CadLoadErrorEvent {
+    readonly type: 'error';
+    readonly error: Error;
+}
+export type CadLoadEvent = CadLoadMetaEvent | CadLoadGeometryEvent | CadLoadTextEvent | CadLoadInsertEvent | CadLoadVariantRequestEvent | CadLoadReadyEvent | CadLoadErrorEvent;
+export interface CadLoadSession {
+    readonly events: AsyncIterable<CadLoadEvent>;
+    readonly ready: Promise<CadPackDocument>;
+    abort(reason?: unknown): void;
+    dispose(): void;
+}
+export declare function createLoadSession(source: CadLoadSource, options?: CadLoadSessionOptions): CadLoadSession;

package/dist/shared/abort.d.ts

@@ -0,0 +1,3 @@
+export declare function toAbortError(reason: unknown, fallbackMessage?: string): Error;
+export declare function forwardAbortSignal(signal: AbortSignal | undefined, controller: AbortController): () => void;
+export declare function raceWithAbort<T>(promise: Promise<T>, signal: AbortSignal, fallbackMessage?: string): Promise<T>;

package/dist/shared/cad-display-color.d.ts

@@ -0,0 +1,55 @@
+import type { ViewerThemeName } from './viewer-theme';
+export type CadRgb = [number, number, number];
+export type CadRawColor = {
+    kind: 'aci';
+    index: number;
+} | {
+    kind: 'truecolor';
+    rgb: CadRgb;
+} | {
+    kind: 'bylayer';
+} | {
+    kind: 'byblock';
+} | {
+    kind: 'none';
+};
+export type CadDisplayElementKind = 'line' | 'fill' | 'dot' | 'text' | 'hatch' | 'overlay';
+export type CadDisplayState = 'normal' | 'hover' | 'selected' | 'hidden' | 'locked' | 'xrefFaded';
+export interface CadDisplayColorContext {
+    theme: ViewerThemeName;
+    layerColor?: CadRawColor | null;
+    byBlockColor?: CadRawColor | null;
+    parentByBlockColor?: CadRawColor | null;
+    fallbackColor?: CadRawColor | null;
+    elementKind?: CadDisplayElementKind;
+    state?: CadDisplayState;
+    enhanceContrast?: boolean;
+}
+export interface CadDisplayColor {
+    rgb: CadRgb;
+    opacity: number;
+    raw: CadRawColor;
+    resolvedRaw: CadRawColor;
+    adapted: boolean;
+}
+type ThemeDisplayPalette = {
+    background: CadRgb;
+    foreground: CadRgb;
+    defaultLine: CadRgb;
+    defaultText: CadRgb;
+    hover: CadRgb;
+    selected: CadRgb;
+    lockedOpacity: number;
+    xrefOpacity: number;
+    hatchOpacity: number;
+};
+export declare function getCadThemeDisplayPalette(theme: ViewerThemeName): ThemeDisplayPalette;
+export declare function resolveCadDisplayColor(raw: CadRawColor, context: CadDisplayColorContext): CadDisplayColor;
+export declare function adaptCadDisplayRgb(rgb: readonly [number, number, number], context: Pick<CadDisplayColorContext, 'theme' | 'elementKind' | 'enhanceContrast'>): CadRgb;
+export declare function resolveCadRawColor(raw: CadRawColor, context: CadDisplayColorContext, depth?: number): CadRawColor;
+export declare function isLikelyLegacyForegroundRgb(rgb: readonly [number, number, number]): boolean;
+export declare function isLegacyDefaultForegroundRgb(rgb: readonly [number, number, number]): boolean;
+export declare function rawColorFromLegacyRgb(rgb: readonly [number, number, number], options?: {
+    treatLegacyForegroundAsAci7?: boolean;
+}): CadRawColor;
+export {};

package/dist/shared/cad-load-source.d.ts

@@ -0,0 +1,8 @@
+import type { GeoLoadSource } from './types';
+export type CadLoadSource = GeoLoadSource | ArrayBuffer | string | URL | Pick<File, 'arrayBuffer'>;
+export interface NormalizedCadLoadSource {
+    readonly source: GeoLoadSource;
+    readonly sourceSignal?: AbortSignal;
+}
+export declare function normalizeCadLoadSource(source: CadLoadSource, signal: AbortSignal): NormalizedCadLoadSource;
+export declare function assertGeoLoadSource(source: unknown): asserts source is GeoLoadSource;

package/dist/shared/color-buffer.d.ts

@@ -0,0 +1,6 @@
+import { BufferAttribute } from 'three';
+export type RgbColorArray = Uint8Array | Float32Array;
+export declare function toRgbBytes(source: RgbColorArray): Uint8Array;
+export declare function colorBytesToNormalizedFloat32(source: Uint8Array): Float32Array;
+export declare function setNormalizedRgbColorAttribute(source: Uint8Array): BufferAttribute;
+export declare function readColorAttributeAsBytes(attribute: BufferAttribute): Uint8Array;

package/dist/shared/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const GEO_LOADER_FRAME_BUDGET_MS = 16.7;
+export declare const GEO_LOADER_RENDER_RESERVE_MS = 6;
+export declare const GEO_LOADER_HIGH_WATERMARK_BYTES: number;
+export declare const GEO_LOADER_LOW_WATERMARK_BYTES: number;
+export declare const GEO_LOADER_INITIAL_GEOMETRY_CREDITS = 2;
+export declare const GEO_LOADER_INITIAL_TEXT_CREDITS = 1;
+export declare const LINE_STRESS_ENTER_VERTS = 300000;
+export declare const LINE_STRESS_EXIT_VERTS = 220000;
+export declare const LINE_THICK_LW_PX = 2;
+export declare const PROMOTED_INSERT_FAST_VISIBILITY_ENABLED = true;
+export declare const PROMOTED_INSERT_MIN_REFCOUNT = 1;

package/dist/shared/display-color-buffer.d.ts

@@ -0,0 +1,27 @@
+export type DisplayRgbResolver = (rgb: readonly [number, number, number]) => readonly [number, number, number];
+export interface DisplayColorBuildStats {
+    readonly vertexCount: number;
+    readonly runCount: number;
+    readonly uniqueColorCount: number;
+    readonly cacheHitCount: number;
+    readonly repeatedRunVertexCount: number;
+}
+export interface DisplayColorBuildResult {
+    readonly color: Uint8Array;
+    readonly stats: DisplayColorBuildStats;
+}
+export interface DisplayColorFloatBuildResult {
+    readonly color: Float32Array;
+    readonly stats: DisplayColorBuildStats;
+}
+export interface SourceColorRun {
+    readonly startVertex: number;
+    readonly vertexCount: number;
+    readonly color: readonly [number, number, number];
+}
+export declare function hasCompleteSourceColorRuns(vertexCount: number, runs: readonly SourceColorRun[]): boolean;
+export declare function buildDisplayColorBytesFromRuns(sourceColor: Uint8Array, resolveRgb: DisplayRgbResolver): DisplayColorBuildResult;
+export declare function buildDisplayColorBytesFromSourceRuns(vertexCount: number, runs: readonly SourceColorRun[], resolveRgb: DisplayRgbResolver): DisplayColorBuildResult;
+export declare function buildDisplayColorFloatsFromSourceRuns(vertexCount: number, runs: readonly SourceColorRun[], resolveRgb: DisplayRgbResolver): DisplayColorFloatBuildResult;
+export declare function writeDisplayColorBytesFromSourceRuns(target: Uint8Array, vertexCount: number, runs: readonly SourceColorRun[], resolveRgb: DisplayRgbResolver): DisplayColorBuildStats;
+export declare function writeDisplayColorFloatsFromSourceRuns(target: Float32Array, vertexCount: number, runs: readonly SourceColorRun[], resolveRgb: DisplayRgbResolver): DisplayColorBuildStats;

package/dist/shared/errors.d.ts

@@ -0,0 +1,2 @@
+export { GeoLoaderError } from '../core';
+export type { GeoLoaderErrorCode } from '../core';

package/dist/shared/text-font.d.ts

@@ -0,0 +1,12 @@
+export interface ResolvedTextFont {
+    readonly text: string;
+    readonly fontUrl?: string;
+    readonly kind?: string;
+    readonly replacedUnsupported: boolean;
+}
+export type ResolveTextFont = (text: string) => ResolvedTextFont;
+export declare function normalizeCadTextForRendering(text: string): {
+    text: string;
+    replacedUnsupported: boolean;
+};
+export declare function defaultResolveTextFont(text: string): ResolvedTextFont;

package/dist/shared/types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Compatibility facade while the renderer-neutral contracts live in
+ * `@nebula-spatial/cad-loader/core`.
+ */
+export type * from '../core';
+import type { ViewportRect } from '../core';
+/** Browser source contract owned by the loader runtime, not its core parser. */
+export type GeoLoadSource = {
+    kind: 'buffer';
+    buffer: ArrayBuffer;
+} | {
+    kind: 'packFile';
+    file: File;
+} | {
+    kind: 'url';
+    url: string;
+    signal?: AbortSignal;
+};
+/** Three viewer compatibility types retained in cad-loader during the package transition. */
+export interface LayerVertexChunk {
+    posArray: Float32Array;
+    start: number;
+    count: number;
+    bbox: ViewportRect;
+}
+export interface LayerVertexStat {
+    chunks: LayerVertexChunk[];
+}
+export type LineRenderMode = 'width' | 'full' | 'stress';
+export interface SplitBlockLayerDetail {
+    variantId: number;
+    blockName: string;
+    layerCount: number;
+    instanceCount: number;
+    layers: string[];
+}
+export interface RenderDebugBreakdownEntry {
+    kind: 'line' | 'fill' | 'dot' | 'text' | 'insertPresenter' | 'other';
+    label: string;
+    renderables: number;
+    submittedVertexRefs: number;
+}
+export interface SceneStats {
+    fpsCurrent: number;
+    drawCalls: number;
+    renderableCount?: number;
+    viewportVertexCount: number;
+    submittedVertexRefs: number;
+    lineRenderMode: LineRenderMode;
+    visibleLayerCount: number;
+    totalLayerCount: number;
+    renderDebugBreakdown?: RenderDebugBreakdownEntry[];
+    blockVariantCount?: number;
+    blockInstanceCount?: number;
+    splitBlockLayerGroupCount?: number;
+    splitBlockLayerDetails?: SplitBlockLayerDetail[];
+}

package/dist/shared/utils/insert-bbox.d.ts

@@ -0,0 +1 @@
+export * from '../../core';

package/dist/shared/utils/timing.d.ts

@@ -0,0 +1,2 @@
+export declare function nowMs(): number;
+export declare function scheduleMicrotaskCompat(callback: () => void): void;

package/dist/shared/utils/viewport-rect.d.ts

@@ -0,0 +1 @@
+export * from '../../core';

package/dist/shared/viewer-theme.d.ts

@@ -0,0 +1,2 @@
+export type ViewerThemeName = 'dark' | 'light';
+export declare const DEFAULT_VIEWER_THEME: ViewerThemeName;