@ngis/plugin-sdk 0.4.0

package/dist/src/domain/models/symbol.d.ts

@@ -0,0 +1,424 @@
+export type SymbolGeometry = "point" | "line" | "polygon";
+export type SymbolTier = 0 | 1 | 2 | 3;
+export interface SymbolTier0LayerSpec {
+    tier: 0;
+    renderer: `builtin:${string}`;
+    params?: SymbolParamBindings;
+}
+export interface SymbolTier1LayerSpec {
+    tier: 1;
+    renderer: "sprite";
+    asset: string;
+    sdf?: boolean;
+    anchor?: [number, number];
+    params?: SymbolParamBindings;
+}
+export interface SymbolTier2LayerSpec {
+    tier: 2;
+    renderer: "shader";
+    asset: string;
+    params?: SymbolParamBindings;
+}
+export interface SymbolTier3LayerSpec {
+    tier: 3;
+    renderer: `plugin:${string}@${string}/${string}`;
+    params?: SymbolParamBindings;
+}
+export type SymbolLayerSpec = SymbolTier0LayerSpec | SymbolTier1LayerSpec | SymbolTier2LayerSpec | SymbolTier3LayerSpec;
+export interface SymbolAnimationSpec {
+    period?: number;
+    footprint?: number;
+    reducedMotion?: "freeze" | "slow";
+}
+export interface SymbolExtendsRef {
+    symbolId: string;
+    version: string;
+    params: SymbolParamValues;
+}
+export interface SymbolManifest {
+    schema: 1;
+    id: string;
+    version: string;
+    name: string;
+    description?: string;
+    tags?: string[];
+    category?: string;
+    geometry: SymbolGeometry;
+    /** 1..8, bottom → top. Absent on a T0 preset, which carries `extends` instead. */
+    layers?: SymbolLayerSpec[];
+    params?: Record<string, SymbolParamDef>;
+    slots?: Partial<Record<SymbolSlot, SymbolSlotDef>>;
+    animation?: SymbolAnimationSpec;
+    /** REQUIRED iff any layer.tier is 2 or 3; tiers 0/1 only. */
+    fallback?: SymbolLayerSpec[];
+    extends?: SymbolExtendsRef;
+}
+export type SymbolParamType = "number" | "color" | "boolean" | "enum" | "angle" | "percent";
+export type SymbolParamValue = number | string | boolean;
+export type SymbolParamValues = Record<string, SymbolParamValue>;
+export interface SymbolParamDef {
+    type: SymbolParamType;
+    label?: string;
+    default: SymbolParamValue;
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: string;
+    values?: string[];
+}
+/** A stack layer's view of the symbol's params: alias → param name or literal.
+ *
+ *  Three forms, resolved by `resolveSymbolLayerParams` (symbol-params.ts):
+ *  `{ param: "speed" }` is always a reference; a bare string that names a
+ *  declared param is a reference (the spelling every seed manifest uses); any
+ *  other value is a literal. The explicit form exists so a symbol whose param
+ *  name collides with an intended string literal can still say which it meant. */
+export type SymbolParamBindings = Record<string, SymbolParamValue | {
+    param: string;
+}>;
+export declare const SYMBOL_SLOTS: readonly ["size", "color", "angle", "startTime", "phase", "data0", "data1", "data2", "data3"];
+export type SymbolSlot = (typeof SYMBOL_SLOTS)[number];
+export interface SymbolSlotDef {
+    label?: string;
+    /** A declared param whose resolved value is this slot's default. The seed
+     *  manifests (sym01/sym02) spell it this way; `default` is the literal form
+     *  and the two are mutually exclusive, `from` winning when both appear. */
+    from?: string;
+    default?: SymbolParamValue;
+}
+/** A scene layer's binding of one slot: a constant, a feature field, or a host-stamped value. */
+export type SymbolSlotBinding = {
+    const: SymbolParamValue;
+} | {
+    field: string;
+    mapping?: Record<string, unknown>;
+} | {
+    host: string;
+};
+/** The fixed uniform block a manifest may not exceed (F24.5). */
+export declare const SYMBOL_PARAM_FLOAT_SLOTS = 16;
+export declare const SYMBOL_PARAM_COLOR_SLOTS = 8;
+export type SymbolVisibility = "PRIVATE" | "PUBLIC";
+export type SymbolVersionStatus = "DRAFT" | "IN_REVIEW" | "PUBLISHED" | "REJECTED" | "YANKED";
+export type SymbolVersionPolicy = "PINNED" | "LATEST";
+export type SymbolCatalogScope = "builtin" | "mine" | "shared" | "public";
+export type SymbolCostHint = "light" | "moderate" | "heavy";
+export declare const SYMBOL_ID_PATTERN: RegExp;
+export declare const SYMBOL_BUILTIN_PREFIX = "builtin.";
+export declare const SYMBOL_MAX_LAYERS = 8;
+/** F24.10 caps. */
+export declare const SYMBOL_SOURCE_MAX_BYTES: number;
+/** F24.6.3 caps. */
+export declare const SYMBOL_SHADER_MAX_BYTES: number;
+export type SymbolRef = {
+    symbolId: string;
+    version: string;
+} | {
+    symbolId: string;
+    policy: "LATEST";
+} | {
+    inline: SymbolManifest;
+};
+export declare const SYMBOL_STYLE_VERSION = 1;
+export interface SymbolStyleJson {
+    version: typeof SYMBOL_STYLE_VERSION;
+    type: "symbol";
+    symbol: SymbolRef;
+    params?: SymbolParamValues;
+    bindings?: Partial<Record<SymbolSlot, SymbolSlotBinding>>;
+}
+export declare const SYMBOL_FALLBACK_REASONS: readonly ["missing", "forbidden", "yanked", "incompatible", "extension-unavailable"];
+export type SymbolFallbackReason = (typeof SYMBOL_FALLBACK_REASONS)[number];
+/**
+ * The SCREAMING words the **server** actually emits on
+ * `SymbolResolveEntryDto.reason` — `SymbolResolveService`s four constants.
+ *
+ * This is **not** `Uppercase<SymbolFallbackReason>`, which is what it was
+ * declared as until 2026-09-02. Two of the five members do not survive that
+ * transform: the server says `NOT_FOUND` where the domain says `missing`, and
+ * `Uppercase<"extension-unavailable">` keeps the hyphen the wire spells with an
+ * underscore. There is no `INCOMPATIBLE` on the wire at all — `incompatible` is
+ * a decision the client reaches on its own.
+ *
+ * `toSymbolFallbackReason` in `src/api/symbols.ts` is the one place the two
+ * vocabularies meet, and it is the only thing that should ever translate them.
+ */
+export declare const SYMBOL_RESOLVE_WIRE_REASONS: readonly ["NOT_FOUND", "FORBIDDEN", "YANKED", "EXTENSION_UNAVAILABLE"];
+export type SymbolResolveWireReason = (typeof SYMBOL_RESOLVE_WIRE_REASONS)[number];
+export type SymbolRenderEngine = "maplibre" | "deck";
+export interface SymbolRenderPlanLayer {
+    index: number;
+    tier: SymbolTier;
+    engine: SymbolRenderEngine;
+    spriteId?: string;
+    /** Whether the registered T1 image is an SDF and can use `icon-color`. */
+    spriteSdf?: boolean;
+    /** Constant slots MapLibre can apply to a T1 image. */
+    spriteColor?: string;
+    spriteSizePx?: number;
+    shaderAsset?: string;
+    pluginRef?: string;
+    animated: boolean;
+}
+export interface SymbolRenderPlanHint {
+    code: "deck-z-order-group" | "heavy-feature-count" | "reduced-motion";
+    detail: string;
+}
+/** A runtime resource/renderer condition that did not alter the saved style. */
+export interface SymbolRenderRuntimeNote {
+    code: string;
+    detail: string;
+}
+export interface SymbolRenderPlan {
+    engine: SymbolRenderEngine;
+    geometry: SymbolGeometry;
+    layers: SymbolRenderPlanLayer[];
+    animated: boolean;
+    hints: SymbolRenderPlanHint[];
+    fallbackSource: "none" | "author" | "host";
+    fallbackReason?: SymbolFallbackReason;
+    runtimeNotes?: SymbolRenderRuntimeNote[];
+}
+export interface SymbolCapabilities {
+    webgl2: boolean;
+    maplibreSdf: boolean;
+    reducedMotion: boolean;
+    featureCount?: number;
+}
+/** Measured on one GPU (F24.8.2) — an input to the default, not a constant to freeze. */
+export declare const SYMBOL_HEAVY_MAX_FEATURES = 10000;
+export type SymbolClockKind = "wall" | "data" | "event";
+export interface SymbolClockState {
+    time: number;
+    dataTime: number;
+    ticks: number;
+    running: boolean;
+}
+export declare const SYMBOL_CLOCK_TEST_HOOK = "__ngisSymbolClock";
+export declare const SYMBOL_LINT_RULE_IDS: readonly ["NO_PREPROCESSOR", "NO_STORAGE_QUALIFIER", "NO_GL_IDENTIFIER", "NO_TEXTURE_SAMPLING", "NO_UNBOUNDED_LOOP", "LOOP_BOUND_TOO_LARGE", "LOOP_NESTING_TOO_DEEP", "TOO_MANY_HELPERS", "SOURCE_TOO_LARGE", "RESERVED_IDENTIFIER_PREFIX", "ENTRY_POINT_MISSING", "ENTRY_POINT_DUPLICATED"];
+export type SymbolLintRuleId = (typeof SYMBOL_LINT_RULE_IDS)[number];
+export interface SymbolLintDiagnostic {
+    rule: SymbolLintRuleId;
+    /** 1-based, in the AUTHOR's coordinates. */
+    line: number;
+    detail: string;
+}
+export interface SymbolLintResult {
+    ok: boolean;
+    diagnostics: SymbolLintDiagnostic[];
+}
+export declare const SYMBOL_ENTRY_FUNCTION = "ngisSymbol";
+/** GLSL shares one namespace between a block instance and a function, so the block may not be
+ *  spelled `ngisSymbol` (S24-01 finding 11). */
+export declare const SYMBOL_UNIFORM_BLOCK_INSTANCE = "ngisU";
+export declare const SYMBOL_RESERVED_IDENTIFIER_PREFIXES: readonly ["ngis", "P_", "DECKGL_", "project_"];
+export interface SymbolSummaryDto {
+    symbolId: string;
+    geometry: SymbolGeometry;
+    displayName: string;
+    summary: string;
+    category: string;
+    tags: string[];
+    visibility: SymbolVisibility;
+    ownerId: string;
+    tierMax: SymbolTier;
+    animated: boolean;
+    costHint: SymbolCostHint;
+    latestPublishedVersion: string | null;
+    thumbnailUrl: string | null;
+    /**
+     * Absent when the version carries no 2× thumbnail — never a URL derived by
+     * appending `@2x`, which is the 404 the existence check exists to prevent
+     * (`S24-V208`). Amends F24.14's frozen `SymbolSummaryDto` (orchestrator
+     * ruling, 2026-09-02): the 2× became storable with `S24-V252` and would
+     * otherwise have been unaddressable from the catalog.
+     */
+    thumbnail2xUrl?: string | null;
+    thumbnailStripUrl?: string | null;
+}
+export interface SymbolAssetDescriptorDto {
+    url: string;
+    sha256: string;
+    size: number;
+    contentType: string;
+}
+/** F24.11.2: no naga block and no `portable` flag this stage. Reintroducing `portable` is a later
+ *  ruling, never a session's call. */
+export interface SymbolValidationDto {
+    lint: {
+        tool: string;
+        version: string;
+        ok: boolean;
+        diagnostics: SymbolLintDiagnostic[];
+    };
+    glslang?: {
+        tool: string;
+        version: string;
+        variant: "es300";
+        lineOffset: number;
+        ok: boolean;
+        ms: number;
+    };
+    costHint: SymbolCostHint;
+    animated: boolean;
+}
+export interface SymbolVersionDto {
+    symbolId: string;
+    version: string;
+    status: SymbolVersionStatus;
+    manifest: SymbolManifest;
+    assets: Record<string, SymbolAssetDescriptorDto>;
+    validation: SymbolValidationDto | null;
+    submittedBy: string;
+    reviewedBy: string | null;
+    reviewNote: string | null;
+    publishedAt: string | null;
+    createdAt: string;
+}
+export interface SymbolResolveEntryDto {
+    ref: string;
+    available: boolean;
+    /** SCREAMING on the wire; the domain spelling is lower-kebab. The two
+     *  vocabularies are **not** related by `Uppercase<>` — see
+     *  `SYMBOL_RESOLVE_WIRE_REASONS`, which is what the server emits.
+     *  `toSymbolFallbackReason` in src/api/symbols.ts is the one place they meet. */
+    reason?: SymbolResolveWireReason;
+    version?: string;
+    manifest?: SymbolManifest;
+    assets?: Record<string, SymbolAssetDescriptorDto>;
+}
+export interface SymbolResolveResponseDto {
+    entries: SymbolResolveEntryDto[];
+}
+export interface SymbolShareGrantDto {
+    symbolId: string;
+    userId: string;
+    grantedBy: string;
+    grantedAt: string;
+}
+export interface SymbolCatalogPageDto {
+    content: SymbolSummaryDto[];
+    page: number;
+    size: number;
+    totalElements: number;
+    totalPages: number;
+}
+/**
+ * One row of the ADMIN review queue's symbols tab
+ * (`GET /api/symbols/review-queue`, `SymbolReviewQueueEntryDto`).
+ *
+ * It carries the symbol's identity beside the version's so a queue of N rows is
+ * one request rather than N+1 — the server already paid that cost once and the
+ * DTO exists so the client does not pay it again. The manifest, the `assets` map
+ * and the `validation` blob are deliberately **absent**: a reviewer opening a row
+ * fetches `GET /api/symbols/{symbolId}/versions/{version}`, which carries all
+ * three.
+ *
+ * The server serializes with `NON_NULL`, so `reviewedBy`, `reviewNote` and
+ * `thumbnailUrl` are **missing keys, not nulls**, on a row that has none —
+ * `sym19-review-queue-page.json` pins both spellings, one row each.
+ */
+export interface SymbolReviewQueueEntryDto {
+    symbolId: string;
+    displayName: string;
+    geometry: SymbolGeometry;
+    visibility: SymbolVisibility;
+    ownerId: string;
+    version: string;
+    status: SymbolVersionStatus;
+    tierMax: SymbolTier;
+    animated: boolean;
+    costHint: SymbolCostHint;
+    submittedBy: string;
+    reviewedBy?: string;
+    reviewNote?: string;
+    createdAt: string;
+    thumbnailUrl?: string;
+}
+/** The same five members as `SymbolCatalogPageDto` — the symbol domain has one
+ *  page envelope, not two. Unlike the extension queue there is no unpaged array
+ *  form: `/api/symbols/review-queue` answers an envelope for every request. */
+export interface SymbolReviewQueuePageDto {
+    content: SymbolReviewQueueEntryDto[];
+    page: number;
+    size: number;
+    totalElements: number;
+    totalPages: number;
+}
+/** `reviewNote` is optional on approve and **required, non-blank** on reject. */
+export interface SymbolApproveRequestDto {
+    reviewNote?: string;
+}
+export interface SymbolRejectRequestDto {
+    reviewNote: string;
+}
+export interface SymbolCreateRequestDto {
+    symbolId: string;
+    geometry: SymbolGeometry;
+    displayName: string;
+    summary?: string;
+    category?: string;
+    tags?: string[];
+    visibility?: SymbolVisibility;
+}
+export interface SymbolVersionCreateRequestDto {
+    version: string;
+    manifest: SymbolManifest;
+}
+/**
+ * `PATCH /api/symbols/{symbolId}` — mirrors the backend's `UpdateSymbolRequest`.
+ * Every member is optional; an omitted one is left unchanged.
+ *
+ * **Not on the F24.18 name list.** Added by the W2 kickoff and recorded rather
+ * than invented silently, per F24.18's own rule: the studio (S24-21) edits
+ * identity and visibility and there was no request DTO for the leg.
+ */
+export interface SymbolUpdateRequestDto {
+    displayName?: string;
+    summary?: string;
+    description?: string;
+    category?: string;
+    tags?: string[];
+    visibility?: SymbolVisibility;
+}
+/** F24.10.2 — no `column`: StAX reports the tag's end column, which reads as wrong. */
+export interface SymbolSanitizeErrorDto {
+    code: "SVG_ELEMENT_FORBIDDEN" | "SVG_ATTRIBUTE_FORBIDDEN" | "SVG_DTD_FORBIDDEN" | "SVG_EXTERNAL_REF" | "SVG_TOO_LARGE" | "SVG_INFLATE_LIMIT" | "SVG_PARSE_ERROR";
+    element: string;
+    /** The offending element's line — except for SVG_DTD_FORBIDDEN, where it is where parsing was
+     *  refused (the end of the internal subset). */
+    line: number;
+    detail: string;
+}
+export interface SymbolShaderErrorDto {
+    stage: "lint" | "glslang";
+    /** The symbol layer whose function was refused, or absent when the refusal is
+     *  not attributable to one. F24.14 amendment 2026-09-02 (`S24-V406`): the
+     *  server already parses it — shaders arrive as `<layerIndex>.glsl` multipart
+     *  parts — and after ruling A3 a symbol may carry eight tier-2 layers authored
+     *  in eight composer rows, so without it the studio cannot mark the row that
+     *  failed and must render the refusal as prose. */
+    layerIndex?: number;
+    rule: SymbolLintRuleId | null;
+    /** Always in the AUTHOR's coordinates; a glslang line is mapped back through the single +40
+     *  offset and the assembled line is kept in `detail`. */
+    line: number;
+    column: number | null;
+    variant: "es300" | null;
+    detail: string;
+}
+/** Storage keys relative to `sym/{symbolId}/{version}/` (F24.14). No `.wgsl` key — F24.11.2. */
+export declare const SYMBOL_ASSET_KEYS: {
+    readonly manifest: "manifest.json";
+    readonly source: (name: string) => string;
+    readonly sprite: "sprite.png";
+    readonly spriteJson: "sprite.json";
+    readonly sprite2x: "sprite@2x.png";
+    readonly sprite2xJson: "sprite@2x.json";
+    readonly sprite3x: "sprite@3x.png";
+    readonly sprite3xJson: "sprite@3x.json";
+    readonly shader: (layer: number) => string;
+    readonly thumbnail: "thumbnail.png";
+    readonly thumbnail2x: "thumbnail@2x.png";
+    readonly thumbnailStrip: "thumbnail-strip.png";
+};

package/dist/src/lib/api.d.ts

@@ -0,0 +1,82 @@
+export declare const GATEWAY_ORIGIN: string;
+export declare const SERVER_GATEWAY_ORIGIN: string;
+export declare const API_BASE_URL: string;
+export declare const WS_BASE_URL: string;
+export interface CommonResult<T = unknown> {
+    code: number;
+    message: string;
+    data: T;
+    traceId?: string | null;
+    details?: unknown;
+}
+export type ApiResponse<T> = CommonResult<T>;
+export interface ApiRequestOptions {
+    signal?: AbortSignal;
+    headers?: HeadersInit;
+}
+export declare class ApiError extends Error {
+    code: number;
+    traceId?: string | null;
+    /**
+     * The parsed error payload, **verbatim**, or `null` when the body was absent
+     * or not JSON.
+     *
+     * Deliberately **not** named `detail` (Stage 12 W2.2): FastAPI's error body
+     * *contains* a `detail` key, while the Java services put a `CommonResult`
+     * envelope in exactly the same position. One field carries both, and callers
+     * narrow it themselves — see `asSkillPackageValidationError` in
+     * `src/api/skills.ts` for the structured-422 case this exists for.
+     *
+     * `unknown` on purpose: nothing may read a property off it without a guard.
+     */
+    body?: unknown;
+    constructor(message: string, code: number, traceId?: string | null, body?: unknown);
+}
+export declare function getErrorMessage(err: unknown, t: (key: string) => string): string;
+/** Called after login/refresh with the new `{accessToken, csrfToken}` pair. */
+export declare function setSession(accessToken: string, csrfToken: string): void;
+/** Drops the in-memory session (logout / session-expired). Does not touch the server-side cookie. */
+export declare function clearSession(): void;
+/**
+ * Silent-refresh bootstrap (SG2): call once on app startup (see `AuthProvider`) to re-derive an
+ * in-memory access token from the HttpOnly refresh cookie, since memory doesn't survive a page
+ * reload. Returns whether a session was recovered; failure (no cookie / expired) just means
+ * "not logged in" and is never surfaced as an error.
+ */
+export declare function bootstrapSession(): Promise<boolean>;
+export declare function getAccessToken(): string | null;
+export declare function getAccessTokenSubject(): string | null;
+export declare function getAuthHeaders(token?: string): HeadersInit;
+export declare function fetchWithAuth(input: string, init?: RequestInit, token?: string): Promise<Response>;
+/**
+ * Mints a short-lived, single-use WebSocket handshake ticket (SG2) via the authenticated
+ * `POST /api/auth/ws-ticket`. Call this immediately before opening the socket — the ticket
+ * expires quickly (`expiresInSec`, ~30s) and is consumed on first use, so don't cache the result.
+ */
+export declare function getWsTicket(): Promise<string | null>;
+/**
+ * Builds an authenticated WS URL (SG2). Replaces the previous `?token=<JWT>` pattern — which
+ * leaked the access token into server logs/browser history/referrers and, on the backend side,
+ * was never even validated — with a single-use `?ticket=` minted right before connecting. Async:
+ * returns `null` if minting the ticket fails (e.g. not authenticated), in which case the caller
+ * should not attempt to open the socket.
+ */
+export declare function buildAuthorizedWsUrl(path: string, params?: Record<string, string | undefined | null>): Promise<string | null>;
+export declare function buildAuthorizedApiUrl(input: string, params?: Record<string, string | undefined | null>): string;
+/**
+ * CSRF-aware POST for the `/api/auth/**` endpoints that require the double-submit header
+ * (SG2: `refresh`/`logout`) — kept out of the generic `api` client below since no other
+ * endpoint needs it. Auth/token state stays owned by this file per the architecture rule.
+ */
+export declare function postAuthCsrf<T>(endpoint: string, body?: unknown, options?: {
+    readonly keepalive?: boolean;
+}): Promise<T>;
+export declare const api: {
+    get<T>(endpoint: string, params?: Record<string, unknown>, token?: string, signalOrOptions?: AbortSignal | ApiRequestOptions): Promise<T>;
+    post<T>(endpoint: string, body?: unknown, token?: string, signalOrOptions?: AbortSignal | ApiRequestOptions): Promise<T>;
+    postForm<T>(endpoint: string, formData: FormData, token?: string, signal?: AbortSignal): Promise<T>;
+    put<T>(endpoint: string, body: unknown, token?: string, signalOrOptions?: AbortSignal | ApiRequestOptions): Promise<T>;
+    patch<T>(endpoint: string, body: unknown, token?: string, signalOrOptions?: AbortSignal | ApiRequestOptions): Promise<T>;
+    delete<T>(endpoint: string, token?: string, signalOrOptions?: AbortSignal | ApiRequestOptions): Promise<T>;
+    deleteWithBody<T>(endpoint: string, body: unknown, token?: string, signal?: AbortSignal): Promise<T>;
+};

package/dist/src/lib/auth-session.d.ts

@@ -0,0 +1,22 @@
+export declare const SESSION_EXPIRED_EVENT = "glmw:session-expired";
+export declare const SESSION_EXPIRED_REDIRECT_PATH = "/login";
+/** The minimal user profile we persist alongside the session. Not sensitive — no tokens here. */
+export interface StoredUser {
+    id?: string;
+    email?: string;
+    username?: string;
+    avatar?: string;
+    role?: string;
+}
+export declare function getStoredDeviceId(): string;
+/**
+ * SG2: only the display profile is cached here now — no tokens. `src/lib/api.ts` owns the
+ * actual session (in-memory access token + CSRF token, backed by the HttpOnly refresh cookie).
+ */
+export declare function storeUser(user: StoredUser | null): void;
+export declare function getStoredUser(): StoredUser | null;
+/** Bumps the cross-tab auth-epoch marker — call on login/logout so other tabs re-hydrate. */
+export declare function bumpAuthEpoch(): void;
+/** True if a `storage` event's key is the auth-epoch marker (vs. some unrelated key). */
+export declare function isAuthEpochKey(key: string | null): boolean;
+export declare function notifySessionExpired(): void;

package/dist/src/lib/raster-color-layer/RasterColorLayer.d.ts

@@ -0,0 +1,48 @@
+import type { CustomLayerInterface, CustomRenderMethodInput, Map as MapLibreMap } from "maplibre-gl";
+import { type TileBounds, type TileRequestInitFactory } from "./TileGrid";
+import { type ColorStop, type RasterColorMode } from "./colorRamp";
+import { type ZoomStop } from "./zoomInterpolate";
+export type RasterColorLayerOptions = {
+    urlTemplate: string;
+    maxZoom: number;
+    mix: [number, number, number, number];
+    range: [number, number];
+    ramp: ColorStop[];
+    colorMode?: RasterColorMode;
+    classBreaks?: number[];
+    valueRange?: [number, number];
+    opacity: number | ZoomStop[];
+    visibleZoomRange?: [number, number];
+    bounds?: TileBounds;
+    getRequestInit?: TileRequestInitFactory;
+};
+export declare function getRasterProjectionMatrix(options: Pick<CustomRenderMethodInput, "defaultProjectionData">): import("maplibre-gl").ProjectionMatrix;
+export declare class RasterColorLayer implements CustomLayerInterface {
+    id: string;
+    type: "custom";
+    renderingMode: "2d";
+    private opts;
+    private map;
+    private gl;
+    private program;
+    private quadBuffer;
+    private tileGrid;
+    private rampTexture;
+    private rampDirty;
+    private uniforms;
+    private attribs;
+    constructor(id: string, options: RasterColorLayerOptions);
+    onAdd(map: MapLibreMap, gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    setColorStyle(options: {
+        ramp: ColorStop[];
+        colorMode?: RasterColorMode;
+        classBreaks?: number[];
+        valueRange?: [number, number];
+    }): void;
+    setRange(range: [number, number]): void;
+    setOpacity(opacity: number | ZoomStop[]): void;
+    setVisibleZoomRange(range: [number, number]): void;
+    render(gl: WebGLRenderingContext | WebGL2RenderingContext, options: CustomRenderMethodInput): void;
+    onRemove(): void;
+    private ensureRampTexture;
+}

package/dist/src/lib/raster-color-layer/TileGrid.d.ts

@@ -0,0 +1,31 @@
+export type TileId = {
+    z: number;
+    x: number;
+    y: number;
+};
+export type TileBounds = [number, number, number, number];
+export type TileRequestInitFactory = () => RequestInit | undefined;
+export declare class TileGrid {
+    private gl;
+    private urlTemplate;
+    private maxZoom;
+    private onTileLoaded;
+    private getRequestInit?;
+    private bounds?;
+    private cache;
+    private queue;
+    private activeRequests;
+    private destroyed;
+    private frame;
+    private readonly maxCacheSize;
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, urlTemplate: string, maxZoom: number, onTileLoaded: () => void, getRequestInit?: TileRequestInitFactory | undefined, bounds?: TileBounds | undefined);
+    coveringTiles(west: number, south: number, east: number, north: number, zoom: number): TileId[];
+    ensure(tiles: TileId[]): void;
+    getTexture(tile: TileId): WebGLTexture | null;
+    private fetchTile;
+    private pumpQueue;
+    private scheduleRetry;
+    private evictIfNeeded;
+    private disposeEntry;
+    destroy(): void;
+}

package/dist/src/lib/raster-color-layer/colorRamp.d.ts

@@ -0,0 +1,18 @@
+export type ColorStop = {
+    stop: number;
+    color: [number, number, number, number];
+};
+export type RasterColorMode = "continuous" | "classified";
+export type RasterClassificationMethod = "equal-interval" | "manual";
+export declare function buildColorRampData(stops: ColorStop[], resolution?: number): Uint8Array<ArrayBuffer>;
+export declare function isValidClassBreaks(value: unknown, range?: [number, number], colorCount?: number): value is number[];
+export declare function buildEqualIntervalBreaks(min: number, max: number, classCount: number): number[] | null;
+export declare function normalizeClassBreaks(classBreaks: unknown, range: [number, number], colorCount?: number): number[] | null;
+export declare function buildClassifiedColorRampData(stops: ColorStop[], classBreaks: unknown, range: [number, number], resolution?: number): Uint8Array<ArrayBuffer> | null;
+export declare function buildRasterColorRampData(stops: ColorStop[], options?: {
+    colorMode?: RasterColorMode;
+    classBreaks?: unknown;
+    valueRange?: [number, number];
+}, resolution?: number): Uint8Array<ArrayBuffer>;
+export declare function computeRasterColorMix(colorRampRes: number, mix: [number, number, number, number], range: [number, number]): [number, number, number, number];
+export declare function computeRasterColorOffset(colorRampRes: number, offset: number, range: [number, number]): number;

package/dist/src/lib/raster-color-layer/shaders/raster-color.frag.d.ts

@@ -0,0 +1,2 @@
+declare const fragSrc = "\nprecision mediump float;\n\nuniform sampler2D u_tile;\nuniform sampler2D u_color_ramp;\nuniform vec3 u_colorization_mix;\nuniform float u_colorization_offset;\nuniform float u_opacity;\n\nvarying vec2 v_uv;\n\nvoid main() {\n  vec4 c = texture2D(u_tile, v_uv);\n\n  float value = u_colorization_offset + dot(c.rgb, u_colorization_mix);\n  vec4 ramped = texture2D(u_color_ramp, vec2(value, 0.5));\n\n  if (ramped.a > 0.0) ramped.rgb /= ramped.a;\n\n  float alpha = ramped.a * u_opacity * c.a;\n  gl_FragColor = vec4(ramped.rgb * alpha, alpha);\n}\n";
+export default fragSrc;

package/dist/src/lib/raster-color-layer/shaders/raster-color.vert.d.ts

@@ -0,0 +1,2 @@
+declare const vertSrc = "\nattribute vec2 a_pos;\n\nuniform mat4 u_matrix;\nuniform vec2 u_tile_tl;\nuniform vec2 u_tile_scale;\n\nvarying vec2 v_uv;\n\nvoid main() {\n  v_uv = a_pos;\n  vec2 mercator = u_tile_tl + a_pos * u_tile_scale;\n  gl_Position = u_matrix * vec4(mercator, 0.0, 1.0);\n}\n";
+export default vertSrc;

package/dist/src/lib/raster-color-layer/zoomInterpolate.d.ts

@@ -0,0 +1,2 @@
+export type ZoomStop = [zoom: number, value: number];
+export declare function resolveZoomStops(value: number | ZoomStop[], zoom: number): number;