@nebula-spatial/cad-loader 0.1.0

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

@@ -0,0 +1,56 @@
+import type { ExternalBlockVariantManifestEntry, ParsedGeoPayload, TextEntity } from '../shared/types';
+import { type CadLoadSource } from '../shared/cad-load-source';
+import { GeoNode } from './internal/geo-node';
+import type { ResolveTextFont } from '../shared/text-font';
+import { type DecodedAnnotationSidecar, type ExternalVariantDependencyOptions, type ExternalVariantDependencyPlan, type ParsedHeader, type CadExternalVariantDelta as GeoNodeExternalVariantDelta } from '../core';
+export type { ExternalVariantDependencyOptions, ExternalVariantDependencyPlan } from '../core';
+export interface ExternalVariantFetchSource {
+    readonly baseUrl: string;
+    readonly entries: readonly ExternalBlockVariantManifestEntry[];
+}
+export interface LoadGeoOptions {
+    signal?: AbortSignal;
+    beforeTextAppend?: (texts: readonly TextEntity[]) => void | Promise<void>;
+    resolveTextFont?: ResolveTextFont;
+    hiddenInstanceIds?: readonly number[];
+    loadBlocks?: boolean;
+    loadAnnotations?: boolean;
+    maxExpandedInstanceVertices?: number;
+    preferWorker?: boolean;
+    workerUrl?: string | URL;
+    workerFactory?: () => Worker;
+    externalVariantFetchSource?: ExternalVariantFetchSource;
+    externalVariantBuffers?: ReadonlyMap<number, ArrayBuffer>;
+    requiredExternalVariantIds?: readonly number[];
+    externalVariantGeometryFetchIds?: readonly number[];
+}
+export interface LoadExternalVariantDeltaOptions {
+    beforeTextAppend?: (texts: readonly TextEntity[]) => void | Promise<void>;
+    hiddenInstanceIds?: readonly number[];
+    externalVariantFetchSource?: ExternalVariantFetchSource;
+    externalVariantBuffers: ReadonlyMap<number, ArrayBuffer>;
+    requiredExternalVariantIds: readonly number[];
+    externalVariantGeometryFetchIds?: readonly number[];
+}
+export type LoadExternalVariantDeltaFetchSourceOptions = Omit<LoadExternalVariantDeltaOptions, 'externalVariantFetchSource' | 'externalVariantBuffers'> & {
+    externalVariantFetchSource: ExternalVariantFetchSource;
+    externalVariantBuffers?: ReadonlyMap<number, ArrayBuffer>;
+};
+export declare function appendExternalVariantDeltaToGeoNode(node: GeoNode, buf: ArrayBuffer, options: LoadExternalVariantDeltaFetchSourceOptions): Promise<void>;
+export declare function appendExternalVariantDeltaToGeoNode(node: GeoNode, buf: ArrayBuffer, options: LoadExternalVariantDeltaOptions): Promise<void>;
+export declare function parseBuffer(buf: ArrayBuffer): ParsedGeoPayload;
+export declare function parseBufferHeader(buf: ArrayBuffer): ParsedHeader;
+export declare function parseBufferBounds(buf: ArrayBuffer): ParsedHeader['bounds'];
+export declare function readBufferExternalVariantManifest(buf: ArrayBuffer): readonly ExternalBlockVariantManifestEntry[];
+export declare function readBufferExternalVariantDependencyPlan(buf: ArrayBuffer, options?: ExternalVariantDependencyOptions): ExternalVariantDependencyPlan;
+export declare function readBufferExternalAnnotationManifest(buf: ArrayBuffer): import("..").ExternalAnnotationsManifest | null;
+export declare function readBufferExternalBlockAnnotations(buf: ArrayBuffer, options?: {
+    externalVariantBuffers?: ReadonlyMap<number, ArrayBuffer>;
+    hiddenInstanceIds?: ReadonlySet<number>;
+}): DecodedAnnotationSidecar | null;
+export declare function loadExternalVariantDeltaFromBuffer(buf: ArrayBuffer, options: LoadExternalVariantDeltaFetchSourceOptions): GeoNodeExternalVariantDelta;
+export declare function loadExternalVariantDeltaFromBuffer(buf: ArrayBuffer, options: LoadExternalVariantDeltaOptions): GeoNodeExternalVariantDelta;
+export declare function assertValidSourceOrThrow(source: unknown): asserts source is import('../shared/types').GeoLoadSource;
+declare function normalizeGeoError(err: unknown): Error;
+export declare function loadGeo(source: CadLoadSource, options?: LoadGeoOptions): GeoNode;
+export { normalizeGeoError };

package/dist/loader/internal/external-variant-sidecar-fetch.d.ts

@@ -0,0 +1,13 @@
+import type { ExternalBlockVariantManifestEntry } from '../../shared/types';
+export type FetchExternalVariantSidecarsOptions = {
+    readonly baseUrl: string;
+    readonly entries: readonly ExternalBlockVariantManifestEntry[];
+    readonly requiredVariantIds: readonly number[];
+    readonly fetchImpl?: typeof fetch;
+    readonly signal?: AbortSignal;
+    readonly concurrency?: number;
+};
+export declare function fetchExternalVariantSidecars(options: FetchExternalVariantSidecarsOptions): Promise<{
+    readonly buffers: ReadonlyMap<number, ArrayBuffer>;
+    readonly fetchMs: number;
+}>;

package/dist/loader/internal/flow-control.d.ts

@@ -0,0 +1,29 @@
+export type QueueKind = 'geometry' | 'text';
+export interface LoaderFlowControlOptions {
+    highWatermarkBytes: number;
+    lowWatermarkBytes: number;
+    initialGeometryCredits: number;
+    initialTextCredits: number;
+}
+export interface CreditGrant {
+    geometryCredits: number;
+    textCredits: number;
+}
+export interface ConsumeResult extends CreditGrant {
+    paused: boolean;
+}
+export declare class LoaderFlowControl {
+    private readonly highWatermarkBytes;
+    private readonly lowWatermarkBytes;
+    private readonly initialGeometryCredits;
+    private readonly initialTextCredits;
+    private queuedBytes;
+    private paused;
+    private initialGranted;
+    constructor(options: LoaderFlowControlOptions);
+    takeInitialGrant(): CreditGrant;
+    onQueued(_kind: QueueKind, bytes: number): void;
+    onConsumed(kind: QueueKind, bytes: number): ConsumeResult;
+    getQueuedBytes(): number;
+    private shouldStayPaused;
+}

package/dist/loader/internal/frame-budget-scheduler.d.ts

@@ -0,0 +1,21 @@
+export type BudgetTask = () => void | Promise<void>;
+export interface FrameBudgetSchedulerOptions {
+    frameBudgetMs: number;
+    reserveMs: number;
+    now?: () => number;
+}
+export interface FrameRunResult {
+    executed: number;
+    remaining: number;
+    exhausted: boolean;
+}
+export declare class FrameBudgetScheduler {
+    private readonly queue;
+    private readonly budgetMs;
+    private readonly now;
+    constructor(options: FrameBudgetSchedulerOptions);
+    enqueue(task: BudgetTask): void;
+    hasPending(): boolean;
+    size(): number;
+    runFrame(): Promise<FrameRunResult>;
+}

package/dist/loader/internal/geo-compact-executor.d.ts

@@ -0,0 +1,19 @@
+export interface GeoCompactOperation {
+    label: string;
+    run: () => boolean;
+}
+export interface GeoCompactRunStats {
+    visited: number;
+    compacted: number;
+    yielded: number;
+    elapsedMs: number;
+}
+export interface GeoCompactExecutorOptions {
+    opsPerPass?: number;
+    frameBudgetMs?: number;
+    now?: () => number;
+    onYield?: () => void | Promise<void>;
+}
+export declare const DEFAULT_COMPACT_OPS_PER_PASS = 64;
+export declare const DEFAULT_COMPACT_FRAME_BUDGET_MS = 8;
+export declare function runGeoCompactOperations(operations: readonly GeoCompactOperation[], options?: GeoCompactExecutorOptions): Promise<GeoCompactRunStats>;

package/dist/loader/internal/geo-loader-local-adapter.d.ts

@@ -0,0 +1,2 @@
+import type { GeoLoaderPipelineAdapter } from './geo-loader-pipeline';
+export declare function createLocalGeoLoaderAdapter(): GeoLoaderPipelineAdapter;

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

@@ -0,0 +1,81 @@
+import type { TextEntity } from '../../shared/types';
+import { type CreditGrant, type LoaderFlowControlOptions } from './flow-control';
+import { type FrameBudgetSchedulerOptions } from './frame-budget-scheduler';
+import type { GeometryKind, PreparedLayerChunk } from './geo-prepare';
+import { GeoNode } from './geo-node';
+import type { TransferableInsertInstanceBatch, TransferableVariantGeometry } from './geo-prepare-worker-types';
+import type { ParsedHeader } from '../../core';
+import type { ExternalVariantFetchSource } from '../geo-loader';
+type YieldCallback = () => void | Promise<void>;
+export type BeforeTextAppend = (texts: readonly TextEntity[]) => void | Promise<void>;
+export type GeoLoaderPipelineEvent = {
+    type: 'header';
+    header: ParsedHeader;
+} | {
+    type: 'geometry';
+    kind: GeometryKind;
+    layers: readonly PreparedLayerChunk[];
+    cost: number;
+    bytes: number;
+} | {
+    type: 'text';
+    texts: readonly TextEntity[];
+    cost: number;
+    bytes: number;
+} | {
+    type: 'insertModel';
+    variants: readonly TransferableVariantGeometry[];
+    instances: TransferableInsertInstanceBatch;
+    bytes: number;
+    planMs?: number;
+} | {
+    type: 'done';
+};
+export type GeoLoaderPipelineEmit = (event: GeoLoaderPipelineEvent) => void | Promise<void>;
+export interface GeoLoaderPipelineAdapterInput {
+    buffer: ArrayBuffer;
+    hiddenInstanceIds?: ReadonlySet<number>;
+    keepTextsForHiddenInstances?: boolean;
+    loadBlocks?: boolean;
+    suppressExpandedInsertGeometry?: boolean;
+    maxExpandedInstanceVertices?: number;
+    externalVariantFetchSource?: ExternalVariantFetchSource;
+    externalVariantBuffers?: ReadonlyMap<number, ArrayBuffer>;
+    requiredExternalVariantIds?: ReadonlySet<number>;
+    externalVariantGeometryFetchIds?: ReadonlySet<number>;
+    externalVariantDeltaOnly?: boolean;
+}
+export interface GeoLoaderPipelineSession {
+    completion: Promise<void>;
+    backgroundCompletion?: Promise<void>;
+    grant?: (grant: CreditGrant) => void;
+    cancel?: () => void;
+    dispose: () => void;
+}
+export interface GeoLoaderPipelineAdapter {
+    start(input: GeoLoaderPipelineAdapterInput, emit: GeoLoaderPipelineEmit): GeoLoaderPipelineSession;
+}
+export interface RunGeoLoaderPipelineOptions {
+    node: GeoNode;
+    buffer: ArrayBuffer;
+    adapter: GeoLoaderPipelineAdapter;
+    signal?: AbortSignal;
+    beforeTextAppend?: BeforeTextAppend;
+    beforeFinalize?: () => void | Promise<void>;
+    hiddenInstanceIds?: ReadonlySet<number>;
+    keepTextsForHiddenInstances?: boolean;
+    loadBlocks?: boolean;
+    suppressExpandedInsertGeometry?: boolean;
+    maxExpandedInstanceVertices?: number;
+    externalVariantFetchSource?: ExternalVariantFetchSource;
+    externalVariantBuffers?: ReadonlyMap<number, ArrayBuffer>;
+    requiredExternalVariantIds?: ReadonlySet<number>;
+    externalVariantGeometryFetchIds?: ReadonlySet<number>;
+    externalVariantDeltaOnly?: boolean;
+    appendExternalVariantDelta?: boolean;
+    onYield?: YieldCallback;
+    scheduler?: Partial<FrameBudgetSchedulerOptions>;
+    flowControl?: Partial<LoaderFlowControlOptions>;
+}
+export declare function runGeoLoaderPipeline(options: RunGeoLoaderPipelineOptions): Promise<void>;
+export {};

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

@@ -0,0 +1,7 @@
+import type { GeoLoaderPipelineAdapter } from './geo-loader-pipeline';
+export interface WorkerGeoLoaderAdapterOptions {
+    workerUrl?: string | URL;
+    workerFactory?: () => Worker;
+}
+export declare function canUsePrepareWorker(workerFactory?: () => Worker): boolean;
+export declare function createWorkerGeoLoaderAdapter(options?: WorkerGeoLoaderAdapterOptions): GeoLoaderPipelineAdapter;

package/dist/loader/internal/geo-node-builder.d.ts

@@ -0,0 +1,29 @@
+import type { FrameBudgetSchedulerOptions } from './frame-budget-scheduler';
+import type { LoaderFlowControlOptions } from './flow-control';
+import { GeoNode } from './geo-node';
+import type { TextEntity } from '../../shared/types';
+import type { ExternalVariantFetchSource } from '../geo-loader';
+type YieldCallback = () => void | Promise<void>;
+type BeforeTextAppend = (texts: readonly TextEntity[]) => void | Promise<void>;
+export interface BuildGeoNodeOptions {
+    scheduler?: Partial<FrameBudgetSchedulerOptions>;
+    flowControl?: Partial<LoaderFlowControlOptions>;
+    beforeTextAppend?: BeforeTextAppend;
+    beforeFinalize?: () => void | Promise<void>;
+    signal?: AbortSignal;
+    hiddenInstanceIds?: ReadonlySet<number>;
+    preferWorker?: boolean;
+    workerUrl?: string | URL;
+    workerFactory?: () => Worker;
+    keepTextsForHiddenInstances?: boolean;
+    loadBlocks?: boolean;
+    maxExpandedInstanceVertices?: number;
+    externalVariantFetchSource?: ExternalVariantFetchSource;
+    externalVariantBuffers?: ReadonlyMap<number, ArrayBuffer>;
+    requiredExternalVariantIds?: ReadonlySet<number> | readonly number[];
+    externalVariantGeometryFetchIds?: ReadonlySet<number> | readonly number[];
+    externalVariantDeltaOnly?: boolean;
+}
+export declare function buildGeoNodeFromBuffer(node: GeoNode, buf: ArrayBuffer, onYield?: YieldCallback, options?: BuildGeoNodeOptions): Promise<void>;
+export declare function appendExternalVariantDeltaToGeoNode(node: GeoNode, buf: ArrayBuffer, onYield?: YieldCallback, options?: BuildGeoNodeOptions): Promise<void>;
+export {};

package/dist/loader/internal/geo-node-load-sink.d.ts

@@ -0,0 +1,28 @@
+import type { TextEntity } from '../../shared/types';
+import { GeoNode } from './geo-node';
+import type { GeometryKind, PreparedLayerChunk } from './geo-prepare';
+import type { TransferableInsertInstanceBatch, TransferableVariantGeometry } from './geo-prepare-worker-types';
+import { type ParsedHeader } from '../../core';
+type YieldCallback = () => void | Promise<void>;
+export declare class GeoNodeLoadSink {
+    private readonly node;
+    private headerSeen;
+    private headerTexts;
+    constructor(node: GeoNode);
+    initFromHeader(header: ParsedHeader): void;
+    appendGeometry(kind: GeometryKind, layers: readonly PreparedLayerChunk[]): void;
+    appendText(texts: readonly TextEntity[]): void;
+    installInsertModel(payload: {
+        variants: readonly TransferableVariantGeometry[];
+        instances: TransferableInsertInstanceBatch;
+        planMs?: number;
+    }): void;
+    appendInsertModel(payload: {
+        variants: readonly TransferableVariantGeometry[];
+        instances: TransferableInsertInstanceBatch;
+        planMs?: number;
+    }): void;
+    finalize(onYield?: YieldCallback): Promise<void>;
+    fail(err: Error): void;
+}
+export {};

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

@@ -0,0 +1,284 @@
+import { Group } from 'three';
+import { type ResolveTextFont } from '../../shared/text-font';
+import type { GeoMetaSnapshot, LayerBlockUsage, LayerSnapshot, LineRenderMode, TextEntity, ViewportRect } from '../../shared/types';
+import { type ViewerThemeName } from '../../shared/viewer-theme';
+import { type VariantGeometry } from '../../scene/instancing/block-geometry-registry';
+import { type InsertInstanceRecord } from '../../scene/instancing/insert-instance-table';
+import { type LayerVisibility } from '../../scene/instancing/viewport-instance-presenter';
+import { type GeometryKind, type PreparedLayerChunk } from './geo-prepare';
+import type { TransferableInsertInstanceBatch, TransferableVariantGeometry } from './geo-prepare-worker-types';
+import type { CadExternalVariantDelta as GeoNodeExternalVariantDelta, GeoChunk, GeoGeometryChunk, ParsedHeader } from '../../core';
+import { type AutoQualityContext, type EffectiveRenderQuality, type RenderQualityMode } from './line-quality';
+import { type LineMemoryStatsSnapshot } from './line-canonical';
+export type ColorPipelineStatsSnapshot = {
+    geometryCount: number;
+    sourceRgbBytes: number;
+    displayRgbBytes: number;
+    displayRgbFloat32Bytes: number;
+    displayRefreshVertexTotal: number;
+    displayRefreshRunTotal: number;
+    displayRefreshUniqueColorTotal: number;
+    displayRefreshCacheHitTotal: number;
+    displayRefreshRepeatedRunVertexTotal: number;
+};
+type BBox = ViewportRect;
+type YieldCallback = () => void | Promise<void>;
+export type GeoNodeInternalChangeKind = 'structure' | 'visual';
+export type GeoNodeInternalChange = {
+    readonly kind: GeoNodeInternalChangeKind;
+};
+export declare const GEO_NODE_STRUCTURE_CHANGE: GeoNodeInternalChange;
+export declare const GEO_NODE_VISUAL_CHANGE: GeoNodeInternalChange;
+type FinalizeIncrementallyOptions = Record<string, never>;
+export interface InsertInstanceMatrix2D {
+    readonly matA: number;
+    readonly matB: number;
+    readonly matC: number;
+    readonly matD: number;
+    readonly tx: number;
+    readonly ty: number;
+}
+export declare function setGeoNodeLoadAbortHook(node: GeoNode, hook: (() => void) | null): void;
+export declare class GeoNode extends Group {
+    private meta;
+    private layerOrder;
+    private readonly layerStatesByIndex;
+    private bounds;
+    private readonly originalLayerColorsByIndex;
+    private readonly colorOverridesByIndex;
+    private displayThemeName;
+    private displayContrastEnhancement;
+    private readonly displayHexMemo;
+    private layerStateRevision;
+    private metaRevision;
+    private renderDebugRevision;
+    private layersSnapshotCache;
+    private metaSnapshotCache;
+    private boundsSnapshotCache;
+    private readonly layerGroupsByIndex;
+    private readonly textUserDataByAppendOrder;
+    private readonly textBatchByLayerIndex;
+    private readonly textRenderablesByLayerIndex;
+    private readonly textRenderablesByAppendOrder;
+    private readonly annotationOverlayGroupsByLayerIndex;
+    private readonly annotationTextBatchByLayerIndex;
+    private readonly annotationTextRenderablesByLayerIndex;
+    private readonly annotationTextRecordsByOwnerKey;
+    private readonly annotationTextRecordsByLayerIndex;
+    private readonly pendingTextBatchSync;
+    private textBatchSyncScheduled;
+    private insertRuntime;
+    private readonly insertRuntimeInstancesById;
+    private blockGeometryRegistry;
+    private readonly insertPresenterVariantInputs;
+    private readonly insertPresenterRecordsByKey;
+    private readonly insertPresenterRecordKeysByInstanceId;
+    private insertInstanceTable;
+    private viewportInstancePresenter;
+    private insertPresenterExternallyManaged;
+    private renderQualityMode;
+    private effectiveRenderQuality;
+    private interactionRenderQualityOverride;
+    private lineModeSwitchingEnabled;
+    private autoQualityContext;
+    private readonly lineChunkRecords;
+    private lineCanonicalMemoryStats;
+    private readonly nonLineChunkStats;
+    private readonly worldSizedPointUniforms;
+    private lineResolution;
+    private internalChangeHook;
+    private disposed;
+    private readySettled;
+    private layerBlockUsages;
+    private colorRefreshStats;
+    private contentGeneration;
+    private annotationOverlayVisible;
+    private readyPromise;
+    private resolveReady;
+    private rejectReady;
+    private readonly resolveTextFont;
+    constructor(options?: {
+        resolveTextFont?: ResolveTextFont;
+    });
+    get ready(): Promise<void>;
+    setLayerVisible(layerIndex: number, visible: boolean): void;
+    setAnnotationOverlayVisible(visible: boolean): void;
+    setDisplayTheme(themeName: ViewerThemeName, options?: {
+        enhanceContrast?: boolean;
+    }): void;
+    setLayerColor(layerIndex: number, color: number | null): void;
+    setRenderQuality(mode: RenderQualityMode): void;
+    setLineModeSwitchingEnabled(enabled: boolean): void;
+    updateAutoQualityContext(context: AutoQualityContext): void;
+    setInteractionRenderQualityOverride(mode: EffectiveRenderQuality | null): void;
+    getMeta(): Readonly<GeoMetaSnapshot>;
+    getLayers(): readonly Readonly<LayerSnapshot>[];
+    getLayerVisibility(): LayerVisibility;
+    refreshInsertPresenter(viewport: ViewportRect | null, layers: LayerVisibility, userHiddenInstanceIds: ReadonlySet<number>, userHiddenInstanceIdsRevision?: number): void;
+    getInsertPresenterVisibleVertexCount(): number;
+    invalidateInsertPresenterQueryCache(): void;
+    getLayerBlockUsages(layerIndex: number): readonly LayerBlockUsage[];
+    getBlockLayerStatsRevision(): number;
+    getRenderDebugRevision(): number;
+    getBounds(): Readonly<[number, number, number, number]>;
+    getGeometryChunkStats(): ReadonlyArray<{
+        layerIndex: number;
+        vertexCount: number;
+        bbox: BBox | null;
+    }>;
+    _collectTextUserDataForDebug(): readonly TextEntity[];
+    getTextEntries(): readonly TextEntity[];
+    getInsertInstanceBaseTransform(instanceId: number, variantId?: number): {
+        tx: number;
+        ty: number;
+        rotation: number;
+        scaleX: number;
+        scaleY: number;
+    } | null;
+    getInsertVariantGeometry(variantId: number): VariantGeometry | null;
+    getInsertInstanceMatrix(instanceId: number, variantId?: number): InsertInstanceMatrix2D | null;
+    getInsertPreviewRecordsForInstance(instanceId: number): readonly InsertInstanceRecord[];
+    getEffectiveLayerColorHex(layerIndex: number): number | null;
+    private resolveInsertRuntimeInstance;
+    updateTextEntry(textId: number, patch: Partial<{
+        content: string;
+        x: number;
+        y: number;
+        rotation: number;
+    }>): boolean;
+    updateInsertInstanceTransform(instanceId: number, transform: {
+        tx: number;
+        ty: number;
+        rotation: number;
+        scaleX: number;
+        scaleY: number;
+    }): boolean;
+    getEffectiveRenderQuality(): EffectiveRenderQuality;
+    getLineRenderMode(): LineRenderMode;
+    getLineModeSwitchingEnabled(): boolean;
+    getRenderQualityModeForDebug(): RenderQualityMode;
+    getLineMemoryStats(): Readonly<LineMemoryStatsSnapshot>;
+    getColorPipelineStats(): Readonly<ColorPipelineStatsSnapshot>;
+    getInsertRuntime(): ParsedHeader['insertRuntime'] | null;
+    getTextRenderablesByAppendOrder(): Array<{
+        visible: boolean;
+    } | null | undefined>;
+    getSupplementalTextRenderablesByInstanceId(): ReadonlyMap<number, ReadonlyArray<{
+        visible: boolean;
+    }>>;
+    private rebuildInsertRuntimeInstanceIndex;
+    dispose(): void;
+    _initFromHeader(header: ParsedHeader): void;
+    _appendChunk(chunk: GeoChunk): void;
+    _appendPreparedGeometryChunk(kind: GeometryKind, layers: readonly PreparedLayerChunk[]): void;
+    _appendTextChunks(texts: readonly TextEntity[]): void;
+    _installInsertModel(payload: {
+        variants: readonly TransferableVariantGeometry[];
+        instances: TransferableInsertInstanceBatch;
+        planMs?: number;
+    }): void;
+    _appendInsertModel(payload: {
+        variants: readonly TransferableVariantGeometry[];
+        instances: TransferableInsertInstanceBatch;
+        planMs?: number;
+    }): void;
+    private mergeInsertModelPayload;
+    private createVariantGeometryInput;
+    private rebuildViewportInsertPresenterFromAccumulatedModel;
+    private rebuildViewportInsertPresenter;
+    private computeInsertPresenterWorldBBox;
+    _debugHasInsertPresenter(): boolean;
+    _debugInsertInstanceTableSize(): number;
+    appendAnnotationOverlay(input: {
+        line: GeoGeometryChunk;
+        fill: GeoGeometryChunk;
+        dot: GeoGeometryChunk;
+        texts: readonly TextEntity[];
+    }): void;
+    appendExternalVariantDelta(delta: GeoNodeExternalVariantDelta): void;
+    appendExternalVariantDeltaHeader(header: ParsedHeader): void;
+    _finalize(): void;
+    _finalizeIncrementally(onYield?: YieldCallback, maxCompactOpsPerPass?: number, _options?: FinalizeIncrementallyOptions): Promise<void>;
+    _fail(err: Error): void;
+    _setInternalChangeHook(callback: ((change: GeoNodeInternalChange) => void) | null): void;
+    _setViewportSize(width: number, height: number): void;
+    private createPointMaterial;
+    private resolvePointWorldSize;
+    private appendTextChunk;
+    private appendAnnotationTextChunks;
+    private appendAnnotationTextChunk;
+    private getOrCreateTextBatch;
+    private getOrCreateAnnotationTextBatch;
+    private configureTextBatchForStaticBounds;
+    private markTextBatchBoundsDirty;
+    private markTextBatchBoundsClean;
+    private scheduleTextBatchSync;
+    private createRenderableChunk;
+    private createRenderableLineChunk;
+    private makeLineChunkRecord;
+    private registerLineChunkRecord;
+    private addLineCanonicalStats;
+    private subtractLineCanonicalStats;
+    private rebuildLineVariantStats;
+    private resolveLineChunkVariant;
+    private resolveInitialLineChunkVariant;
+    private resolveLineweightPx;
+    private shouldUseThinLineVariant;
+    private buildLineRenderableViews;
+    private finalizeCadLineRenderable;
+    private installSharedLineColorTargetMarkers;
+    private applyInitialLineDisplayColors;
+    private createRenderableTextChunk;
+    private commitTroikaTextTransform;
+    private getOrCreateKindGroup;
+    private appendAnnotationPreparedGeometryChunk;
+    private getOrCreateAnnotationKindGroup;
+    private getOrCreateAnnotationOverlayGroup;
+    private applyAnnotationOverlayVisibility;
+    private createInsertVisibilityHandleForAnnotationText;
+    private applyAnnotationTextRenderableVisibility;
+    private refreshAnnotationTextVisibilityForLayer;
+    private isLayerVisible;
+    private ensureLayerGroup;
+    private compactGeometryByLayer;
+    private compactGeometryByLayerIncrementally;
+    private compactLineChunksPerLayer;
+    private compactLineChunksForSingleLayer;
+    private buildLineCompactionGroups;
+    private compactNonLineChunksPerLayer;
+    private compactNonLineChunksForSingleLayer;
+    private rebuildNonLineChunkStats;
+    private findKindGroup;
+    private disposeLineChunkRecord;
+    private applyLayerColorState;
+    private refreshDisplayColors;
+    private registerGeometryDisplayColors;
+    private installGeometryDisplayColorMetadata;
+    private applyDisplayColorsToGeometry;
+    private buildDisplayColorBytes;
+    private recordDisplayColorBuildStats;
+    private resolveDisplayHexForRgb;
+    private resolveDisplayRgbForLegacyRgb;
+    private displayElementKindForObject;
+    private createInsertInstanceRecords;
+    private createInsertPresenterMaterial;
+    private clearViewportInsertPresenter;
+    private refreshDefaultInsertPresenterIfUnmanaged;
+    private resetContent;
+    private rebuildLineChunks;
+    private applyCachedLineChunkColors;
+    private applyColorToRenderable;
+    private applyLayerTextColors;
+    private invalidateTextBatchDisplayState;
+    private applyColorToTextRenderable;
+    private applyEffectiveRenderQuality;
+    private resolveCurrentEffectiveRenderQuality;
+    private notifyInternalChange;
+    private static getTextOwnerKey;
+    private static resolveTextAnchorX;
+    private static resolveTextAnchorY;
+    private startReadyCycle;
+    private resolveReadyOnce;
+    private rejectReadyOnce;
+}
+export {};

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

@@ -0,0 +1,87 @@
+import type { TextEntity, ViewportRect } from '../../shared/types';
+import type { GeometryKind, PreparedLayerChunk } from './geo-prepare';
+import type { ParsedHeader } from '../../core';
+import type { ExternalVariantFetchSource } from '../geo-loader';
+export type { GeometryKind, PreparedLayerChunk } from './geo-prepare';
+export interface GeoPrepareParseRequest {
+    type: 'parse';
+    buffer: ArrayBuffer;
+    hiddenInstanceIds?: number[];
+    keepTextsForHiddenInstances?: boolean;
+    loadBlocks?: boolean;
+    suppressExpandedInsertGeometry?: boolean;
+    maxExpandedInstanceVertices?: number;
+    externalVariantFetchSource?: ExternalVariantFetchSource;
+    deferExternalVariantGeometry?: boolean;
+    externalVariantBuffers?: Array<{
+        variantId: number;
+        buffer: ArrayBuffer;
+    }>;
+    requiredExternalVariantIds?: number[];
+    externalVariantGeometryFetchIds?: number[];
+    externalVariantDeltaOnly?: boolean;
+}
+export interface GeoPrepareGrantMessage {
+    type: 'grant';
+    geometryCredits: number;
+    textCredits: number;
+}
+export interface GeoPrepareCancelMessage {
+    type: 'cancel';
+}
+export type GeoPrepareWorkerInputMessage = GeoPrepareParseRequest | GeoPrepareGrantMessage | GeoPrepareCancelMessage;
+export interface GeoPrepareHeaderMessage {
+    type: 'header';
+    header: ParsedHeader;
+}
+export interface GeoPrepareGeometryMessage {
+    type: 'geometry';
+    kind: GeometryKind;
+    layers: PreparedLayerChunk[];
+    cost: number;
+}
+export interface GeoPrepareTextMessage {
+    type: 'text';
+    texts: TextEntity[];
+    cost: number;
+}
+export interface TransferableVariantGeometryKindChunk {
+    readonly pos: Float32Array;
+    readonly col: Uint8Array;
+    readonly count: number;
+    readonly layerIndex?: number;
+    readonly lineweightPx?: number;
+    readonly bbox?: ViewportRect | null;
+}
+export interface TransferableVariantGeometry {
+    readonly variantId: number;
+    readonly line: readonly TransferableVariantGeometryKindChunk[];
+    readonly fill: readonly TransferableVariantGeometryKindChunk[];
+    readonly dot: readonly TransferableVariantGeometryKindChunk[];
+}
+export interface TransferableInsertInstanceBatch {
+    readonly meta: Uint32Array;
+    readonly mats: Float32Array;
+    readonly bboxes: Float32Array;
+    readonly count: number;
+}
+export interface GeoPrepareInsertModelMessage {
+    type: 'insertModel';
+    variants: readonly TransferableVariantGeometry[];
+    instances: TransferableInsertInstanceBatch;
+    cost: number;
+    bytes: number;
+    planMs: number;
+}
+export interface GeoPrepareDoneMessage {
+    type: 'done';
+}
+export interface GeoPrepareCompleteMessage {
+    type: 'complete';
+}
+export interface GeoPrepareErrorMessage {
+    type: 'error';
+    message: string;
+    code?: string;
+}
+export type GeoPrepareWorkerOutputMessage = GeoPrepareHeaderMessage | GeoPrepareGeometryMessage | GeoPrepareTextMessage | GeoPrepareInsertModelMessage | GeoPrepareDoneMessage | GeoPrepareCompleteMessage | GeoPrepareErrorMessage;