@honua/app-platform 0.0.20-alpha.0

package/runtime/load-package.js

@@ -0,0 +1,272 @@
+/**
+ * `loadMapPackage` — the first-class entry point that turns a server
+ * `MapPackage` into a running MapLibre GL JS map. The caller owns the
+ * `MaplibreMap` instance (peer dependency); the runtime composes the
+ * style, resolves bindings through the shared contract, and hands the
+ * composed style to `map.setStyle`.
+ *
+ * @module
+ */
+import { createDataset } from "../contract/index.js";
+import { HonuaMap } from "../map/honua-map.js";
+import { HonuaMapPackageError } from "./errors.js";
+import { HONUA_MAP_PACKAGE_FORMAT_V1 } from "./map-package.js";
+import { createOgcStyleRefResolver } from "./ogc-styles.js";
+import { ensurePmtilesProtocol, styleUsesPmtiles } from "./pmtiles-protocol.js";
+import { HonuaMapRuntime, } from "./runtime.js";
+import { projectSourceBindings, toHonuaSourceSpec } from "./source-bridge.js";
+import { composeStyle } from "./style-compose.js";
+import { throwRuntimeDiagnostics } from "./style-interactions.js";
+import { prepareRuntimeStyleSpecValidation } from "./style-spec-validation.js";
+/**
+ * Load a `MapPackage` onto a caller-provided `MaplibreMap`. Returns a
+ * runtime handle that exposes the operational API. Throws
+ * `HonuaMapPackageError` on binding failure. Query-time adapter errors
+ * (`HonuaHttpError`, `HonuaCapabilityNotSupportedError`, ...) continue
+ * to flow through the returned `Source` promises on `runtime.dataset`
+ * and through the shared `HonuaClient` interceptor chain.
+ *
+ * Per-source binding tolerance is governed by
+ * {@link LoadMapPackageOptions.sourceErrorPolicy} — the default
+ * `"tolerant"` policy lets a heterogeneous (mixed-protocol) composition
+ * keep rendering when one source fails by skipping the failing source
+ * (and any layers that reference it) and emitting a `source-error`
+ * runtime event plus a `source-bind` telemetry error span. Pass
+ * `"fail-fast"` to restore the historical reject-on-any-binding-failure
+ * behaviour.
+ */
+export async function loadMapPackage(pkg, map, options) {
+    assertPackageFormat(pkg);
+    const startedAt = Date.now();
+    options.telemetry?.before?.({
+        kind: "load",
+        packageId: pkg.mapPackageId,
+        startedAt,
+    });
+    const sourceErrorPolicy = options.sourceErrorPolicy ?? "tolerant";
+    const styleSpecValidationMode = options.styleSpecValidationMode ?? "strict";
+    // Default StyleRef resolution to the server's OGC API – Styles surface so
+    // `styleRefs.styleId` aligns with the server's canonical styleId. A
+    // caller-supplied callback overrides this for back-compat.
+    const styleRefResolver = options.resolveStyleRef ??
+        (options.disableDefaultStyleRefResolver ? undefined : createOgcStyleRefResolver({ client: options.client }));
+    throwRuntimeDiagnostics(await prepareRuntimeStyleSpecValidation(styleSpecValidationMode), "Cannot initialize MapLibre style-spec validation.");
+    const compose = async (target) => {
+        const projection = projectSourceBindings(target.mapPackageId, target.sourceBindings);
+        const dataset = createDataset({
+            id: target.mapPackageId,
+            client: options.client,
+            sources: projection.descriptors,
+            resolveSource: options.resolveSource,
+            skipCompatibilityCheck: options.skipCompatibilityCheck,
+        });
+        const honuaMap = new HonuaMap({ client: options.client });
+        const styleSources = { ...target.mapSpec.sources };
+        const failedSources = [];
+        const failedSourceIds = new Set();
+        const recordSourceFailure = (descriptor, cause) => {
+            if (sourceErrorPolicy === "fail-fast") {
+                if (cause instanceof HonuaMapPackageError)
+                    throw cause;
+                throw new HonuaMapPackageError(`binding source "${descriptor.id}" failed`, {
+                    packageId: target.mapPackageId,
+                    stage: "source-bind",
+                    detail: { sourceId: descriptor.id, protocol: descriptor.protocol },
+                    cause,
+                });
+            }
+            failedSourceIds.add(descriptor.id);
+            failedSources.push({ sourceId: descriptor.id, error: cause });
+            // The tolerant contract is "failed sources are dropped from
+            // composedStyle.sources". Inline `mapSpec.sources` entries that
+            // collide with a failing binding id must go too — otherwise the
+            // composed style still advertises the failed source through the
+            // predeclared spec, which contradicts the documented behaviour.
+            delete styleSources[descriptor.id];
+        };
+        for (const descriptor of projection.descriptors) {
+            try {
+                const filter = projection.filtersBySourceId.get(descriptor.id);
+                const honuaSpec = toHonuaSourceSpec(descriptor, filter);
+                // Eagerly materialize so a `resolveSource` rejection (or missing
+                // built-in resolver) surfaces at bind time rather than the first
+                // query-time call. The built-in adapter constructors are
+                // side-effect free (no HTTP), so eager resolution is cheap.
+                dataset.source(descriptor.id);
+                // Commit to honuaMap before exposing the spec on styleSources so
+                // a thrown addSource cannot leave the failed source in
+                // composedStyle.sources after the catch records the failure.
+                honuaMap.addSource(descriptor.id, honuaSpec);
+                styleSources[descriptor.id] = honuaSpec;
+            }
+            catch (cause) {
+                recordSourceFailure(descriptor, cause);
+            }
+        }
+        for (const native of projection.nativeSources) {
+            styleSources[native.sourceId] = native.spec;
+            honuaMap.addSource(native.sourceId, native.spec);
+        }
+        for (const [sourceId, source] of Object.entries(styleSources)) {
+            if (!honuaMap.hasSource(sourceId))
+                honuaMap.addSource(sourceId, source);
+        }
+        const layers = filterLayersByAvailableSource(target.mapSpec.layers, failedSourceIds);
+        const preComposed = {
+            ...target.mapSpec,
+            sources: styleSources,
+            layers,
+        };
+        for (const layer of preComposed.layers) {
+            if (!honuaMap.hasLayer(layer.id))
+                honuaMap.addLayer(layer);
+        }
+        const composed = await composeStyle(target, preComposed, {
+            resolveStyleRef: styleRefResolver,
+            resolveTheme: options.resolveTheme,
+        });
+        // Auto-register the MapLibre `pmtiles://` protocol before the caller (or
+        // `runtime.reload`) hands this style to `map.setStyle`, so PMTiles-backed
+        // sources render with no manual `addProtocol` wiring. Idempotent across
+        // maps and no-ops (zero import cost) when no source uses PMTiles.
+        if (styleUsesPmtiles(composed)) {
+            await ensurePmtilesProtocol();
+        }
+        return { composed, dataset, honuaMap, failedSources };
+    };
+    try {
+        const { composed, dataset, honuaMap, failedSources } = await compose(pkg);
+        map.setStyle(composed);
+        const packageRef = { current: pkg };
+        const runtime = new HonuaMapRuntime({
+            map,
+            honuaMap,
+            dataset,
+            composedStyle: composed,
+            packageRef,
+            telemetry: options.telemetry,
+            popupFactory: options.popupFactory,
+            popupRenderer: options.popupRenderer,
+            styleSpecValidationMode,
+            reload: async (next) => {
+                const result = await compose(next);
+                for (const failed of result.failedSources) {
+                    emitSourceBindFailure(options.telemetry, next.mapPackageId, failed);
+                }
+                return {
+                    composed: result.composed,
+                    dataset: result.dataset,
+                    honuaMap: result.honuaMap,
+                    failedSources: result.failedSources,
+                };
+            },
+        });
+        // Register the caller's listener before emitting initial lifecycle
+        // events so callers can observe source-ready / package-loaded once
+        // per load instead of losing them to a race before runtime.on(...).
+        if (options.onEvent) {
+            runtime.on(options.onEvent);
+        }
+        if (options.applyInitialView !== false && pkg.initialView) {
+            try {
+                runtime.setViewState({
+                    ...(pkg.initialView.bbox ? { bbox: pkg.initialView.bbox } : {}),
+                    ...(pkg.initialView.center ? { center: pkg.initialView.center } : {}),
+                    ...(pkg.initialView.zoom !== undefined ? { zoom: pkg.initialView.zoom } : {}),
+                    ...(pkg.initialView.pitch !== undefined ? { pitch: pkg.initialView.pitch } : {}),
+                    ...(pkg.initialView.bearing !== undefined ? { bearing: pkg.initialView.bearing } : {}),
+                });
+            }
+            catch (cause) {
+                throw new HonuaMapPackageError("applying initialView failed", {
+                    packageId: pkg.mapPackageId,
+                    stage: "view",
+                    cause,
+                });
+            }
+        }
+        const failedIds = new Set(failedSources.map((entry) => entry.sourceId));
+        for (const sourceId of dataset.sourceIds()) {
+            if (failedIds.has(sourceId))
+                continue;
+            runtime._emit({ type: "source-ready", sourceId });
+        }
+        for (const failed of failedSources) {
+            emitSourceBindFailure(options.telemetry, pkg.mapPackageId, failed);
+            runtime._emit({ type: "source-error", sourceId: failed.sourceId, error: failed.error });
+        }
+        runtime._emit({ type: "package-loaded", packageId: pkg.mapPackageId });
+        const finishedAt = Date.now();
+        options.telemetry?.after?.({
+            kind: "load",
+            packageId: pkg.mapPackageId,
+            startedAt,
+            finishedAt,
+            durationMs: finishedAt - startedAt,
+        });
+        return runtime;
+    }
+    catch (error) {
+        const finishedAt = Date.now();
+        options.telemetry?.error?.({
+            kind: "load",
+            packageId: pkg.mapPackageId,
+            startedAt,
+            finishedAt,
+            durationMs: finishedAt - startedAt,
+            error,
+        });
+        if (error instanceof HonuaMapPackageError)
+            throw error;
+        throw new HonuaMapPackageError("loadMapPackage failed", {
+            packageId: pkg.mapPackageId,
+            stage: "load",
+            cause: error,
+        });
+    }
+}
+function filterLayersByAvailableSource(layers, failedSourceIds) {
+    if (failedSourceIds.size === 0)
+        return [...layers];
+    return layers.filter((layer) => {
+        const sourceId = typeof layer.source === "string" ? layer.source : undefined;
+        if (sourceId === undefined)
+            return true;
+        return !failedSourceIds.has(sourceId);
+    });
+}
+function emitSourceBindFailure(telemetry, packageId, failed) {
+    if (!telemetry?.error)
+        return;
+    const startedAt = Date.now();
+    telemetry.error({
+        kind: "source-bind",
+        packageId,
+        startedAt,
+        finishedAt: startedAt,
+        durationMs: 0,
+        detail: { sourceId: failed.sourceId },
+        error: failed.error,
+    });
+}
+function assertPackageFormat(pkg) {
+    if (pkg.format !== HONUA_MAP_PACKAGE_FORMAT_V1) {
+        throw new HonuaMapPackageError(`unsupported MapPackage format "${String(pkg.format)}"; runtime supports "${HONUA_MAP_PACKAGE_FORMAT_V1}"`, {
+            packageId: pkg.mapPackageId,
+            stage: "load",
+            detail: { received: pkg.format, expected: HONUA_MAP_PACKAGE_FORMAT_V1 },
+        });
+    }
+    if (!Array.isArray(pkg.sourceBindings)) {
+        throw new HonuaMapPackageError("MapPackage.sourceBindings must be an array", {
+            packageId: pkg.mapPackageId,
+            stage: "load",
+        });
+    }
+    if (!pkg.mapSpec || typeof pkg.mapSpec !== "object") {
+        throw new HonuaMapPackageError("MapPackage.mapSpec is required", {
+            packageId: pkg.mapPackageId,
+            stage: "load",
+        });
+    }
+}

package/runtime/map-package-fetch.d.ts

@@ -0,0 +1,107 @@
+import type { HonuaCacheValidator } from "../core/cache-state.js";
+import type { HonuaClient } from "../core/client.js";
+import { type LoadMapPackageOptions } from "./load-package.js";
+import { type HonuaMapPackageDiagnostic } from "./map-package-validation.js";
+import type { HonuaMapPackage } from "./map-package.js";
+import type { HonuaMapRuntime, MaplibreMap } from "./runtime.js";
+import type { StyleRefResolver } from "./style-compose.js";
+export declare const DEFAULT_MAP_PACKAGE_PATH_PREFIX = "/api/v1/map-packages";
+export type MapPackageLocator = string | {
+    readonly id?: string;
+    readonly packageId?: string;
+    readonly path?: string;
+    readonly url?: string;
+    readonly href?: string;
+};
+export type MapPackagePathResolver = (packageId: string) => string;
+export interface FetchMapPackageOptions {
+    readonly client: HonuaClient;
+    readonly signal?: AbortSignal;
+    readonly headers?: HeadersInit;
+    /**
+     * Override id-to-path resolution. The default is
+     * `/api/v1/map-packages/{encodeURIComponent(id)}`.
+     */
+    readonly resolvePath?: MapPackagePathResolver;
+    /** In-memory response cache. Omit for a per-client default; pass `false` to bypass SDK validators. */
+    readonly cache?: MapPackageFetchCache | false;
+    /**
+     * Resolve out-of-band style refs and inline successful bodies into the
+     * returned package. When omitted, defaults to resolving `styleRefs.styleId`
+     * against the server's OGC API – Styles surface (`GET /ogc/styles/{styleId}`)
+     * via {@link createOgcStyleRefResolver}. Pass a callback to override that
+     * path (back-compat), or set {@link disableDefaultStyleRefResolver} to skip it.
+     */
+    readonly resolveStyleRef?: StyleRefResolver;
+    /** Disable the default `/ogc/styles` StyleRef resolver when no callback is supplied. */
+    readonly disableDefaultStyleRefResolver?: boolean;
+    /** Treat unresolved style refs as validation errors instead of warnings. */
+    readonly requireStyleRefResolution?: boolean;
+    /** Emit a stale-package warning when the package timestamp is older than this many ms. */
+    readonly maxAgeMs?: number;
+    readonly now?: number | Date;
+    /** Return invalid packages with diagnostics instead of throwing `HonuaMapPackageError`. */
+    readonly allowInvalid?: boolean;
+}
+export interface MapPackageFetchCacheEntry {
+    readonly mapPackage: HonuaMapPackage;
+    readonly validator?: HonuaCacheValidator;
+    readonly cachedAtMs: number;
+    readonly sourceUpdatedAt?: string;
+    readonly fingerprint: string;
+}
+export type MapPackageFetchCache = Map<string, MapPackageFetchCacheEntry>;
+/**
+ * Default entry cap for the per-client map-package fetch cache, mirroring the
+ * metadata cache's 256-entry bound.
+ */
+export declare const DEFAULT_MAP_PACKAGE_CACHE_LIMIT = 256;
+/**
+ * A {@link MapPackageFetchCache} that evicts least-recently-used entries once it
+ * exceeds {@link DEFAULT_MAP_PACKAGE_CACHE_LIMIT}. The previous default cache
+ * was an unbounded `Map`, so a client that fetched many distinct packages grew
+ * it without bound (unlike the size-capped metadata cache). Callers that pass
+ * their own `cache` keep full control of eviction.
+ */
+export declare class BoundedMapPackageFetchCache extends Map<string, MapPackageFetchCacheEntry> {
+    private readonly limit;
+    constructor(limit?: number);
+    get(key: string): MapPackageFetchCacheEntry | undefined;
+    set(key: string, value: MapPackageFetchCacheEntry): this;
+}
+export type MapPackageFetchCacheStatus = "miss" | "refreshed" | "not-modified" | "bypass";
+export interface MapPackageFetchCacheState {
+    readonly status: MapPackageFetchCacheStatus;
+    readonly key: string;
+    readonly validator?: HonuaCacheValidator;
+    readonly sourceUpdatedAt?: string;
+    readonly fetchedAt: string;
+    readonly revalidatedAt?: string;
+}
+export interface FetchMapPackageResult {
+    readonly mapPackage: HonuaMapPackage;
+    readonly diagnostics: readonly HonuaMapPackageDiagnostic[];
+    readonly cache: MapPackageFetchCacheState;
+}
+export interface LoadMapPackageFromIdOptions extends LoadMapPackageOptions {
+    readonly signal?: AbortSignal;
+    readonly headers?: HeadersInit;
+    readonly resolvePath?: MapPackagePathResolver;
+    readonly cache?: MapPackageFetchCache | false;
+    readonly requireStyleRefResolution?: boolean;
+    readonly maxAgeMs?: number;
+    readonly now?: number | Date;
+    readonly allowInvalid?: boolean;
+}
+export interface LoadMapPackageFromIdResult {
+    readonly runtime: HonuaMapRuntime;
+    readonly mapPackage: HonuaMapPackage;
+    readonly diagnostics: readonly HonuaMapPackageDiagnostic[];
+    readonly cache: MapPackageFetchCacheState;
+}
+export declare function fetchMapPackage(locator: MapPackageLocator, options: FetchMapPackageOptions): Promise<FetchMapPackageResult>;
+export declare function loadMapPackageFromId(locator: MapPackageLocator, map: MaplibreMap, options: LoadMapPackageFromIdOptions): Promise<LoadMapPackageFromIdResult>;
+export declare function resolveMapPackagePath(locator: MapPackageLocator, resolvePath?: MapPackagePathResolver): string;
+export declare function defaultMapPackagePath(packageId: string): string;
+export declare function mapPackageFingerprint(pkg: HonuaMapPackage): string;
+//# sourceMappingURL=map-package-fetch.d.ts.map

package/runtime/map-package-fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-package-fetch.d.ts","sourceRoot":"","sources":["../../../src/runtime/map-package-fetch.ts"],"names":[],"mappings":"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"}