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

package/dist/types/scene/visibility_adapter.d.ts

@@ -0,0 +1,106 @@
+import { type Bounds, type Meters, type Tile } from "../utils/geo.js";
+import { type TileCoordinate } from "../tile/tile_id.js";
+import type { HostCamera } from "../types.js";
+/** State consumed by a renderer-owned visibility and LOD adapter. */
+export interface VisibilityViewState {
+    /** Optional host matrices for policies selecting a precise per-eye footprint. */
+    readonly camera?: HostCamera;
+    readonly center: {
+        readonly lng: number;
+        readonly lat: number;
+    };
+    /** Scene/style zoom used to calculate meter scale, independent of data detail. */
+    readonly zoom: number;
+    /** Requested data-tile level, before source normalization. */
+    readonly tile_zoom: number;
+    readonly size: {
+        readonly css: {
+            readonly width: number;
+            readonly height: number;
+        };
+    };
+    readonly bounds: Bounds | null;
+    readonly buffer: number;
+    readonly wrap: boolean;
+}
+/** Bounds and LOD state calculated for a Tangram view. */
+export interface CalculatedViewBounds {
+    /** Data-tile zoom selected for the current view. */
+    tileZoom: number;
+    metersPerPixel: number;
+    sizeMeters: Meters;
+    centerMeters: Meters;
+    centerTile: Tile;
+    bounds: Bounds;
+}
+/**
+ * Renderer-facing visibility and level-of-detail policy.
+ *
+ * Implementations consume Tangram geographic view state and return Tangram
+ * tile coordinates. They do not depend on deck.gl or a specific host camera.
+ */
+export interface VisibilityLODAdapter {
+    /** Calculates the current Web Mercator bounds and derived tile LOD state. */
+    calculateBounds(view: VisibilityViewState): CalculatedViewBounds;
+    /** Returns visible tiles for the current Web Mercator view. */
+    findVisibleTileCoordinates(view: VisibilityViewState): TileCoordinate[];
+    /** Conservative candidate visits before allocation; required only for automatic host LOD. */
+    countTileCoordinates?(view: VisibilityViewState): number;
+}
+/** Geographic state required to select tiles for a globe viewport. */
+export interface GlobeVisibilityViewState {
+    /** Tile zoom selected for the current host view. */
+    readonly tile_zoom: number;
+    /** Number of neighboring tiles included around the geographic bounds. */
+    readonly buffer: number;
+    /** Host-visible geographic bounds in west, south, east, north order. */
+    readonly visibleBounds: readonly [number, number, number, number];
+    /** Camera position in the globe's common-space coordinates, when available. */
+    readonly cameraPosition?: readonly [number, number, number];
+    /** Maximum rendered elevation in geographic meters; omitted means unknown, not zero. */
+    readonly maxElevation?: number;
+}
+/** Projection-specific tile visibility policy for globe views. */
+export interface GlobeVisibilityLODAdapter {
+    /** Returns visible tiles for the geographic bounds of a globe viewport. */
+    findVisibleTileCoordinates(view: GlobeVisibilityViewState): TileCoordinate[];
+    /** Candidate visits before deduplication/horizon rejection; required only for automatic host LOD. */
+    countTileCoordinates?(view: GlobeVisibilityViewState): number;
+}
+/**
+ * Default visibility policy preserving Tangram's rectangular Web Mercator
+ * viewport bounds and buffered tile-range behavior.
+ */
+export declare class WebMercatorVisibilityAdapter implements VisibilityLODAdapter {
+    /**
+     * Calculates meter-space viewport bounds and the center tile.
+     * @param view Tangram's current geographic view state.
+     * @returns Bounds, center, and LOD state used by View.
+     */
+    calculateBounds(view: VisibilityViewState): CalculatedViewBounds;
+    /**
+     * Selects the buffered tile rectangle intersecting the current view.
+     * @param view Tangram's current geographic view state.
+     * @returns Visible tile coordinates at the current tile zoom.
+     */
+    findVisibleTileCoordinates(view: VisibilityViewState): TileCoordinate[];
+    /** Counts the same buffered range as enumeration without creating tile objects. */
+    countTileCoordinates(view: VisibilityViewState): number;
+}
+/**
+ * Selects Web Mercator tiles intersecting geographic bounds on a globe.
+ * Antimeridian-crossing bounds are split into two ranges and duplicate tiles
+ * are removed while preserving traversal order. Horizon rejection requires both
+ * a host camera and an explicit conservative elevation bound. Geographic bounds
+ * must already enclose elevated content; this policy does not infer a frustum footprint.
+ */
+export declare class WebMercatorGlobeVisibilityAdapter implements GlobeVisibilityLODAdapter {
+    /**
+     * Returns buffered tiles intersecting host bounds and the visible globe hemisphere.
+     * @param view Tile zoom, buffer, geographic bounds, and optional camera position.
+     * @returns Visible tile coordinates.
+     */
+    findVisibleTileCoordinates(view: GlobeVisibilityViewState): TileCoordinate[];
+    /** Bounds raw traversal work, not just the smaller visible/deduplicated result. */
+    countTileCoordinates(view: GlobeVisibilityViewState): number;
+}

package/dist/types/selection/draped-terrain-surface.d.ts

@@ -0,0 +1,78 @@
+import { TerrainSurfaceCollection, type TerrainSurface } from "./terrain_surface.js";
+import { type DrapedTerrainBoundsSummary } from "../map-logic/draped-terrain-bounds.js";
+/** Measured CPU costs for one immutable terrain display, excluding other retained snapshots. */
+export interface DrapedTerrainQueryStatistics {
+    /** Unique retained physical input bytes. */
+    inputBytes: number;
+    /** Lazily projected geometry bytes. */
+    projectedBytes: number;
+    /** Completed acceleration hierarchy bytes. */
+    queryIndexBytes: number;
+    /** Aggregate permitted hierarchy bytes for this snapshot. */
+    reservedQueryIndexBytes: number;
+    /** Number of queried draw entries, including repeated clip leases. */
+    preparedMeshes: number;
+    /** Projected owners allocated by this snapshot. */
+    projectionBuilds: number;
+    /** Projection and cooperative hierarchy CPU time, excluding suspended time. */
+    preparationMs: number;
+    /** Ray-query CPU time. */
+    queryMs: number;
+    /** Owners whose acceleration failed; their exact linear queries remain available. */
+    preparationFailures: number;
+    /** Demanded entries using bounded-memory exact triangle projection rather than retained copies. */
+    streamingMeshes: number;
+}
+/** Worker-owned query channels extracted from the final ground draw topology. */
+export interface DrapedTerrainQueryMesh {
+    /** Absolute Mercator XYZ before terrain displacement; includes authored ground offsets. */
+    positions: Float64Array;
+    /** Current and previous physical height per vertex, interleaved in that order. */
+    heights: Float32Array;
+    /** Optional affine canonical globe channels: current base/relief, previous base/relief, three components each. */
+    globeBasis?: Float32Array;
+    /** Exact admitted draw triangles, excluding holes. */
+    indices: Uint16Array | Uint32Array;
+    /** Indexed XY footprint used to avoid allocating query geometry for unrelated vertical probes. */
+    bounds: readonly [number, number, number, number];
+    /** Worker-computed immutable extrema, avoiding vertex scans and projected allocations during the first host probe. */
+    boundsSummary?: DrapedTerrainBoundsSummary;
+}
+/** One admitted draw owner; callers never include pending worker generations. */
+export interface DrapedTerrainQueryEntry {
+    /** Stable tile/style/variant identity. */
+    id: string;
+    /** Final worker geometry retained independently of GPU buffers. */
+    mesh: DrapedTerrainQueryMesh;
+    /** Blend actually submitted for this draw generation. */
+    blend: number;
+    /** Optional absolute Mercator rectangles matching coarse globe fallback clipping. */
+    clips?: readonly (readonly [number, number, number, number])[];
+    /** Half-open interior ownership; terminal EPSG:3857 world edges stay closed for physical probes. Default false. */
+    halfOpenClips?: boolean;
+}
+/** Immutable frame-specific surface, matching ground draw topology and temporal displacement. */
+export declare class DrapedTerrainSurfaceSnapshot extends TerrainSurfaceCollection {
+    /** Lazy query owners and measured work for this snapshot, never global renderer/GPU ownership. */
+    private readonly queryOwners;
+    /** Scene mesh generation, not source-cache or provider revision. */
+    readonly generation: number;
+    /** Shared monotonic clock used for both eyes and the corresponding draw. */
+    readonly frameTime: number;
+    /** GPU relief multiplier captured with the snapshot. */
+    readonly exaggeration: number;
+    /** Retained physical query input arrays, including indices; excludes projected copies and GPU memory. */
+    readonly inputBytes: number;
+    /** Admitted membership, blend and exaggeration key for skipping repeated settled host probes. */
+    readonly displayKey: string;
+    /** Demand-admitted index bytes; unqueried display entries never reserve acceleration. */
+    get reservedQueryIndexBytes(): number;
+    /** Snapshot-local reservation state shared by repeated clip leases. */
+    private readonly indexBudget;
+    /** Capture displacement without copying/projecting every mesh until it is queried. */
+    constructor(projection: TerrainSurface['projection'], entries: readonly DrapedTerrainQueryEntry[], generation: number, frameTime: number, exaggeration: number, maxQueryIndexBytes?: number, maxProjectedQueryBytes?: number);
+    /** Fairly warm demanded settled owners; closing releases every partial hierarchy. */
+    prepareQueryIndexSteps(): Generator<void, void, void>;
+    /** Detached snapshot-local CPU query costs; excludes other retained host snapshots and GPU/transient storage. */
+    getStatistics(): DrapedTerrainQueryStatistics;
+}

package/dist/types/selection/terrain_surface.d.ts

@@ -0,0 +1,149 @@
+import type HostFrame from "../scene/host_frame.js";
+import type { FeatureSelectionOptions } from "../types.js";
+/** Detached conservative content-space bounds; null means the surface has no admitted triangles. */
+export interface TerrainSurfaceBounds {
+    /** Closed lower corner in the same units as query rays. */
+    minimum: [number, number, number];
+    /** Closed upper corner in the same units as query rays. */
+    maximum: [number, number, number];
+}
+/** A ray in the same absolute content coordinates as the supplied terrain. */
+export interface TerrainRay {
+    /** Absolute origin, before host view and room-placement transforms. */
+    origin: readonly [number, number, number];
+    /** Nonzero direction; the query normalizes its length. */
+    direction: readonly [number, number, number];
+}
+/** Nearest terrain triangle, not a worker feature ID or a GPU selection result. */
+export interface TerrainSurfaceHit {
+    /** Absolute EPSG:3857 meters or radius-256 globe common coordinates. */
+    position: [number, number, number];
+    /** Longitude/latitude degrees and physical altitude meters. */
+    coordinate: [number, number, number];
+    /** Distance from the ray origin in the surface's coordinate units. */
+    distance: number;
+    /** Normal in the supplied mesh's coordinate system, following triangle winding. */
+    normal: [number, number, number];
+    /** Triangle offset in the supplied index list. */
+    triangleIndex: number;
+    /** Vertex weights in index order. */
+    barycentric: [number, number, number];
+    /** Eye used for a screen query; absent for a content-space ray. */
+    renderViewId?: string;
+    /** Caller collection identity; absent on an individual surface query. */
+    surfaceId?: string;
+}
+/** Host-owned terrain query boundary; it does not load, render or displace a DEM. */
+export interface TerrainSurface {
+    /** Coordinate convention of both the mesh and rays. */
+    readonly projection: 'web-mercator' | 'globe';
+    /** Return the nearest two-sided hit within the finite camera segment, or null. */
+    intersectRay(ray: TerrainRay, maxDistance?: number): TerrainSurfaceHit | null;
+    /** Optional cheap bounds for near-first collection queries; must contain every accepted triangle. */
+    getBounds?(): TerrainSurfaceBounds | null;
+}
+/** One stable caller-owned surface identity; collections snapshot membership, not geometry. */
+export interface TerrainSurfaceEntry {
+    /** Unique nonempty identifier used to distinguish triangle offsets in different tiles. */
+    id: string;
+    /** Immutable terrain query owner, using the collection's projection. */
+    surface: TerrainSurface;
+}
+/** Nearest collection hit with the identity of its owning tile/surface. */
+export interface TerrainCollectionHit extends TerrainSurfaceHit {
+    /** Original caller identity, unaffected by nearest-hit clipping. */
+    surfaceId: string;
+}
+/** Explicit geographic probe bracket; altitude values describe displayed geometry, not source elevation. */
+export interface TerrainElevationProbe {
+    /** Lower geographic altitude in meters; must be strictly below maximumAltitude. */
+    minimumAltitude: number;
+    /** Upper geographic altitude in meters, above every surface that should be considered. */
+    maximumAltitude: number;
+    /** Optional Mercator longitude anchor for unwrapped tile coordinates. */
+    anchorLongitude?: number;
+}
+/** Snapshot tile membership and query nearest geometry without owning sources, views, buffers or resources. */
+export declare class TerrainSurfaceCollection implements TerrainSurface {
+    /** Shared absolute coordinate convention; mixed projections reject at construction. */
+    readonly projection: TerrainSurface['projection'];
+    /** Snapshotted membership and caller identities, retaining owners without copying their geometry. */
+    private readonly entries;
+    /** Retain immutable surface references with unique IDs; caller membership changes do not affect this collection. */
+    constructor(projection: TerrainSurface['projection'], entries: readonly TerrainSurfaceEntry[]);
+    /** Clip farther tiles after an accepted hit; equal-distance ties retain original membership order. */
+    intersectRay(ray: TerrainRay, maxDistance?: number): TerrainCollectionHit | null;
+    /** Query a finite content-space sightline; misses mean no loaded triangle hit, not certified world visibility. */
+    intersectSegment(start: readonly [number, number, number], end: readonly [number, number, number], options?: {
+        /** Trim origin self-intersections, in mesh coordinate units; defaults to zero. */
+        startInset?: number;
+        /** Trim target self-intersections, in mesh coordinate units; defaults to zero. */
+        endInset?: number;
+    }): TerrainCollectionHit | null;
+}
+/** Probe loaded top triangles along geographic up; returned coordinate altitude retains physical source meters. */
+export declare function sampleTerrainElevation(surface: TerrainSurface, coordinate: readonly [number, number], options: TerrainElevationProbe): TerrainSurfaceHit | null;
+/** Resolve a Mercator camera/anchor floor; this is a point probe, not swept-volume collision or locomotion. */
+export declare function resolveTerrainClearance(surface: TerrainSurface, coordinate: readonly [number, number, number], clearance: number, options: TerrainElevationProbe): {
+    /** Geographic position raised only when it lies below displayed terrain plus clearance. */
+    coordinate: [number, number, number];
+    /** Source elevation meters, independent of any caller-provided display displacement. */
+    physicalElevation: number;
+    /** True when the supplied altitude was raised. */
+    adjusted: boolean;
+} | null;
+/** Indexed content-space triangles; source buffers are copied at construction. */
+export interface TerrainMeshOptions {
+    /** Coordinate convention, matching the HostFrame or XR placement. */
+    projection: TerrainSurface['projection'];
+    /** Interleaved absolute XYZ coordinates, not tile-local positions. */
+    positions: ArrayLike<number>;
+    /** Three zero-based vertex indices per triangle. */
+    indices: ArrayLike<number>;
+    /** Optional source meters per vertex, preserving physical queries on exaggerated display meshes. */
+    physicalHeights?: ArrayLike<number>;
+    /** Match an outward backface-culled draw pass; default false preserves two-sided queries. */
+    cullBackfaces?: boolean;
+    /** Lazy hierarchy typed-array limit; exact linear picking is used when acceleration does not fit. */
+    maxQueryIndexBytes?: number;
+    /** Keep queries exact and linear until an explicit cooperative warming pass completes. */
+    deferQueryIndexBuild?: boolean;
+}
+/** Detached retained-storage diagnostics; no GPU or JavaScript heap estimate is included. */
+export interface TerrainMeshStatistics {
+    /** Owned immutable positions, topology and optional physical heights. */
+    geometryBytes: number;
+    /** Currently allocated packed hierarchy storage. */
+    queryIndexBytes: number;
+    /** Required acceleration bytes, even when linear picking is selected. */
+    requiredQueryIndexBytes: number;
+}
+/** Immutable physical terrain surface backed by the reusable CPU triangle hierarchy. */
+export declare class TerrainMeshSurface implements TerrainSurface {
+    /** Mercator XY/physical Z meters, or already projected globe common coordinates. */
+    readonly projection: TerrainSurface['projection'];
+    /** Optional detached physical elevations; only indexed vertices must be finite. */
+    private readonly physicalHeights?;
+    /** Optional render-pass face convention; unrelated to geographic height units. */
+    private readonly cullBackfaces;
+    /** Projection-independent immutable triangle query index. */
+    private readonly queryIndex;
+    /** Copy a finite indexed triangle mesh; mutation of caller buffers cannot change queries. */
+    constructor(options: TerrainMeshOptions);
+    /** Exact retained typed arrays; snapshots cannot mutate query ownership. */
+    getStatistics(): TerrainMeshStatistics;
+    /** Cooperatively warm picking acceleration; queries during preparation remain exact linear queries. */
+    prepareQueryIndexSteps(): Generator<void, void, void>;
+    /** Detached conservative mesh bounds; no mutable geometry or acceleration buffers escape. */
+    getBounds(): {
+        minimum: [number, number, number];
+        maximum: [number, number, number];
+    } | null;
+    /** Indexed queries; an optional display clip rejects candidates before nearest-hit selection. */
+    intersectRay(ray: TerrainRay, maxDistance?: number, acceptPosition?: (position: readonly [number, number, number], triangleIndex: number, barycentric: readonly [number, number, number]) => boolean): TerrainSurfaceHit | null;
+}
+/** Route top-origin CSS pixels through the actual HostFrame eye and its near/far segment. */
+export declare function pickTerrainAt(frame: HostFrame, pixel: {
+    x: number;
+    y: number;
+}, surface: TerrainSurface, options?: FeatureSelectionOptions, activeViewId?: string): TerrainSurfaceHit | null;

package/dist/types/shader-modules/globe-horizon.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Experimental binding-free sphere horizon occlusion adapted from Tangram label shaders.
+ * Position and eye are center-relative in the same orthonormal frame and linear units;
+ * radius must be positive. Missing/interior eyes have no exterior horizon (false).
+ * The finite eye-to-position segment, not an infinite ray, must enter the sphere by
+ * more than the squared-unit-radius 1e-6 tolerance. Elevated anchors are supported.
+ * getAnchor restores a nonzero direction's geographic radius using altitude and a
+ * positive earthRadius in identical units. Finite, f32-representable inputs required.
+ */
+export declare const globeHorizon: {
+    name: string;
+    vs: string;
+    fs: string;
+    source: string;
+};

package/dist/types/shader-modules/height-decode.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Experimental binding-free RGB elevation decoding for normalized linear samples.
+ * Terrarium and Terrain-RGB return meters. Custom coefficients apply to byte-valued
+ * channels (normalized RGB multiplied by 255); custom output units are host-defined.
+ * No rounding, clamping, alpha/no-data interpretation or sampling is performed.
+ * Finite inputs are required; f32 precision limits apply, especially at large heights.
+ */
+export declare const heightDecode: {
+    name: string;
+    vs: string;
+    fs: string;
+    source: string;
+};

package/dist/types/shader-modules/hillshade.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Experimental luma.gl ShaderModule with provider-independent hillshade functions.
+ * Hosts supply decoded, finite heights, positive finite neighbor spacing, and a
+ * local-frame light vector. Sampling, no-data handling, seam stitching, coordinate
+ * transforms, vertical exaggeration and color composition stay with the host.
+ * No uniforms, samplers, injection hooks, or runtime dependencies are introduced.
+ */
+export declare const hillshade: {
+    name: string;
+    vs: string;
+    fs: string;
+    source: string;
+};

package/dist/types/shader-modules/index.d.ts

@@ -0,0 +1,6 @@
+export { hillshade } from "./hillshade.js";
+export { triplanar } from "./triplanar.js";
+export { planar } from "./planar.js";
+export { sphereMap } from "./sphere-map.js";
+export { heightDecode } from "./height-decode.js";
+export { globeHorizon } from "./globe-horizon.js";

package/dist/types/shader-modules/planar.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Experimental binding-free planar mapping extracted from Tangram material GLSL.
+ * Frequency is repeats per position unit; finite inputs must retain f32 UV precision.
+ * Tangram's legacy vec2 scale uses only scale.x: pass that component here.
+ * The host owns textures, sampling, filtering and coordinate transforms.
+ */
+export declare const planar: {
+    name: string;
+    vs: string;
+    fs: string;
+    source: string;
+};

package/dist/types/shader-modules/sphere-map.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Experimental binding-free sphere-map reflection UVs for luma assemblers.
+ * Supply a nonzero camera-to-surface vector and unit surface normal in one frame.
+ * Inputs, their intermediate lengths and UVs must be finite. The back-facing
+ * reflection pole (0, 0, -1) and a zero post-skew eye are undefined, as in Tangram.
+ * This is environment mapping, not equirectangular mapping or GlobeView projection.
+ */
+export declare const sphereMap: {
+    name: string;
+    vs: string;
+    fs: string;
+    source: string;
+};

package/dist/types/shader-modules/triplanar.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Experimental Tangram-compatible triplanar UVs and RGBA blending for luma assemblers.
+ * Inputs must be finite and small enough for f32 normalization and UV precision.
+ * Normal components have a 1e-5 floor; a zero normal gives equal weights.
+ * Position and normal share a coordinate frame. Each scale component multiplies
+ * both UV coordinates of its projection plane, including negative frequencies.
+ * No sign-dependent UV mirroring or tangent-space normal reorientation is applied.
+ * Hosts own texture bindings, sampling, derivatives, color space and normal maps.
+ */
+export declare const triplanar: {
+    name: string;
+    vs: string;
+    fs: string;
+    source: string;
+};

package/dist/types/sources/decoded_tile_store.d.ts

@@ -0,0 +1,95 @@
+/** One consumer's interest in a decoded tile; releasing it cannot cancel another consumer. */
+export interface DecodedTileLease<ValueT> {
+    /** Independent completion, rejected promptly when this lease is released before completion. */
+    readonly promise: Promise<ValueT>;
+    /** Whether this consumer still owns a lease, including after synchronous source invalidation. */
+    isActive(): boolean;
+    /** Idempotently release this consumer's residency and request ownership. */
+    release(): void;
+}
+/** Source revision and unwrapped normalized data identity, never a mesh/style key. */
+export interface DecodedTileAcquisition<ValueT> {
+    /** Opaque source-instance revision, owned by the worker adapter. */
+    readonly source: object;
+    /** Normalized data coordinate key, preserving world-copy distinctions. */
+    readonly key: string;
+    /** Original acquisition/decode procedure; invoked once for compatible concurrent leases. */
+    load(signal: AbortSignal): Promise<ValueT>;
+}
+/** Detached diagnostics; missing allocation estimates never masquerade as zero decoded bytes. */
+export interface DecodedTileStatistics {
+    /** Pending unique acquisitions, including queued work. */
+    loadingTiles: number;
+    /** Unique acquisitions waiting for a source-procedure slot. */
+    queuedTiles: number;
+    /** Running source procedures, including cancelled procedures that have not settled. */
+    activeAcquisitions: number;
+    /** Configured source-procedure limit; undefined means unlimited. */
+    maxConcurrentLoads: number | undefined;
+    /** Ready records protected by live leases; there is no unreferenced warm cache. */
+    readyTiles: number;
+    /** Live consumer leases across pending and ready records. */
+    consumers: number;
+    /** Actual acquisition attempts since store creation. */
+    acquisitions: number;
+    /** Acquisitions served by an existing pending or ready record. */
+    sharedAcquisitions: number;
+    /** Requests cancelled when their final lease or source revision was released. */
+    cancelledAcquisitions: number;
+    /** Rejected acquisition attempts, excluding invalidated late completions. */
+    failedAcquisitions: number;
+    /** Ready payload bytes, undefined if any live ready record has unknown size. */
+    decodedBytes: number | undefined;
+}
+/** Request capacity is independent of styled mesh-build scheduling and residency. */
+export interface DecodedTileStoreOptions {
+    /** Positive safe integer; omission preserves unlimited acquisition. */
+    maxConcurrentLoads?: number;
+}
+/** Validate an optional load budget before creating resources or worker state. */
+export declare function validateConcurrentTileLoads(value: unknown): number | undefined;
+/** Portable cancellation error for leases, source invalidation, and stale publication. */
+export declare function createTileLeaseAbortError(): Error;
+/** Worker-local shared acquisition with source-instance revisions and zero warm retention. */
+export default class DecodedTileStore<ValueT> {
+    /** Source revisions stay retained only while they have live records. */
+    private readonly sources;
+    /** Optional decoded allocation estimator; encoded network bytes are not a substitute. */
+    private readonly getByteLength;
+    /** FIFO unique-content queue; duplicate leases never consume another slot. */
+    private readonly queued;
+    /** Fixed worker-local source-procedure limit, unrelated to GPU mesh ownership. */
+    private readonly maxConcurrentLoads;
+    /** Settling an aborted but non-cooperative procedure still releases exactly one slot. */
+    private activeAcquisitions;
+    /** Batch synchronous leases and cancellation before starting their providers. */
+    private scheduled;
+    /** Actual unique acquisition attempts. */
+    private acquisitions;
+    /** Reused pending/ready acquisitions. */
+    private sharedAcquisitions;
+    /** Underlying requests cancelled at final release or invalidation. */
+    private cancelledAcquisitions;
+    /** Underlying acquisition failures. */
+    private failedAcquisitions;
+    /** Create an empty store without fetch, decode, traversal, or GPU dependencies. */
+    constructor(getByteLength?: (value: ValueT) => number | undefined, options?: DecodedTileStoreOptions);
+    /** Acquire one consumer lease, sharing only the exact source revision and data key. */
+    acquireTile(request: DecodedTileAcquisition<ValueT>): DecodedTileLease<ValueT>;
+    /** Release one obsolete source revision without touching a successor source instance. */
+    invalidateSource(source: object): void;
+    /** Return unique content and consumer counts without retaining or exposing internal records. */
+    getStatistics(): DecodedTileStatistics;
+    /** Cancel all pending work and release content; subsequent use starts from an empty store. */
+    finalize(): void;
+    /** Drain only when a source procedure settles, not when its styled mesh finishes. */
+    private scheduleAcquisitions;
+    /** A slot follows the original procedure even if all consumer leases are released early. */
+    private startAcquisition;
+    /** A late completion cannot publish over a replacement attempt for the same coordinate. */
+    private isCurrent;
+    /** Forget only the matching attempt and release empty source maps immediately. */
+    private forgetRecord;
+    /** Ready content has no pending request; cancellation is issued at most once. */
+    private cancelRecord;
+}

package/dist/types/sources/tile_source_metadata.d.ts

@@ -0,0 +1,32 @@
+/** Source metadata subset structurally compatible with loaders.gl TileSourceMetadata. */
+export interface TangramTileSourceMetadata {
+    /** Source/container format, not a promise to select a different parser. */
+    format?: string;
+    /** Encoded tile MIME type, separate from archive format and decoder selection. */
+    tileMIMEType?: string;
+    /** Human-readable source name. */
+    name?: string;
+    /** Provider credits; consumers must sanitize before rendering HTML. */
+    attributions?: string[];
+    /** Minimum advertised data level. */
+    minZoom?: number;
+    /** Maximum advertised data level. */
+    maxZoom?: number;
+    /** Geographic bounds, retaining antimeridian-crossing west/east ordering. */
+    boundingBox?: [[number, number], [number, number]];
+}
+/** Configuration plus discovered metadata, without depending on the DataSource implementation. */
+export interface SourceMetadataInput {
+    /** Original scene source options. */
+    config: Record<string, unknown>;
+    /** Logical scene source name. */
+    name: string;
+    /** Effective legacy data levels. */
+    zooms: readonly number[];
+    /** Effective legacy data ceiling. */
+    max_zoom: number;
+    /** Authored and discovered provider credits. */
+    getAttributions(): string[];
+}
+/** Normalize metadata for new consumers without changing legacy source layout or URL resolution. */
+export declare function createTileSourceMetadata(source: SourceMetadataInput, discovered?: Record<string, unknown>): TangramTileSourceMetadata;

package/dist/types/styles/text/fontfaceobserver.d.ts

@@ -0,0 +1,10 @@
+// tangram-layers
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+declare module 'fontfaceobserver' {
+    export default class FontFaceObserver {
+        constructor (family: string, options?: Record<string, unknown>);
+        load (): Promise<void>;
+    }
+}

package/dist/types/tile/tile_id.d.ts

@@ -0,0 +1,37 @@
+export type TileCoordinates = {
+    x: number;
+    y: number;
+    z: number;
+};
+export type TileCoordinate = TileCoordinates & {
+    key: string;
+    center_dist?: number;
+};
+export type TileSource = {
+    id: string | number;
+    name: string;
+    zoom_bias?: number;
+    zooms: number[];
+};
+export type TileReference = {
+    coords: TileCoordinates;
+    source: TileSource;
+    style_z: number;
+    key?: string;
+};
+type TileChildrenCache = Record<string, Record<string, TileReference[]>>;
+type TileIdApi = {
+    coord(coordinates: TileCoordinates): TileCoordinate;
+    coordKey(coordinates: TileCoordinates): string;
+    key(coordinates: TileCoordinates, source: TileSource, styleZoom: number): string | undefined;
+    normalizedKey(coordinates: TileCoordinates, source: TileSource, styleZoom: number): string | undefined;
+    normalizedCoord(coordinates: TileCoordinates, source: TileSource): TileCoordinate;
+    coordAtZoom(coordinates: TileCoordinates, zoom: number): TileCoordinate;
+    coordForTileZooms(coordinates: TileCoordinates, zooms: number[]): TileCoordinate;
+    findZoomInRange(zoom: number, zooms: number[]): number;
+    isDescendant(parent: TileCoordinates, descendant: TileCoordinates): boolean;
+    parent(tile: TileReference): TileReference | null | undefined;
+    children(tile: TileReference, cache?: TileChildrenCache): TileReference[];
+};
+export declare const TileID: TileIdApi;
+export {};