@honua/react 0.0.20-alpha.0 → 0.1.1-beta.0

package/core/client.js

@@ -3,6 +3,7 @@ import { HONUA_MINIMUM_SUPPORTED_SERVER_VERSION, MINIMUM_SUPPORTED_SERVER_RELEAS
 import { HonuaHttpError, HonuaNetworkError, HonuaTimeoutError } from "./errors.js";
 import { applyEdits, exportMap, findMap, getFeatureServiceMetadata, getLayerMetadata, getMapLayerMetadata, getMapLegend, getMapServiceMetadata, identifyMap, listServices, queryFeaturesRest, queryMapLayer, queryMapRelatedRecords, queryRelatedRecords, } from "./geoservices.js";
 import { HonuaOdataEntitySet } from "./odata.js";
+import { honuaFacadeFeaturesLayout, resolveOgcEndpointLayout } from "./ogc-endpoint-layout.js";
 import { createOgcItem, deleteOgcItem, getOgcCollection, getOgcFeaturesConformance, getOgcFeaturesLanding, getOgcItem, getOgcQueryables, listOgcCollections, listOgcItems, patchOgcItem, replaceOgcItem, } from "./ogc-features.js";
 import { HonuaOgcMaps, getOgcMapImage, getOgcMapsConformance, getOgcMapsLanding } from "./ogc-maps.js";
 import { HonuaOgcProcesses, cancelOgcProcessJob, executeOgcProcess, getOgcProcess, getOgcProcessJob, getOgcProcessJobResults, getOgcProcessesConformance, getOgcProcessesLanding, listOgcProcesses, } from "./ogc-processes.js";
@@ -170,7 +171,10 @@ export class HonuaClient {
     authCredentialsCache;
     authRefreshPromise;
     connectClient;
+    connectClientPromise;
     metadataCache = new Map();
+    ogcLayoutCache = new Map();
+    wfsRootCache = new Map();
     /**
      * Create a new `HonuaClient`.
      *
@@ -224,9 +228,6 @@ export class HonuaClient {
             pipelineFetch: (method, path, init, callerSignal, pipelineOptions) => this.pipelineFetch(method, path, init, callerSignal, pipelineOptions),
             requestBinaryWithJsonFallback: (method, path, params, signal) => this.requestBinaryWithJsonFallback(method, path, params, signal),
         };
-        if (this.transport === "grpc-web") {
-            this.initConnectClient();
-        }
     }
     /**
      * Connect interceptor that injects the same credentials the REST pipeline
@@ -298,26 +299,36 @@ export class HonuaClient {
             ...(this.timeoutMs !== undefined ? { defaultTimeoutMs: this.timeoutMs } : {}),
         };
     }
-    initConnectClient() {
-        // Dynamic imports are used to avoid bundling Connect dependencies
-        // when only the REST transport is used. The imports are resolved
-        // at module level since they are static ESM imports.
-        import("@connectrpc/connect").then(({ createClient }) => import("@connectrpc/connect-web").then(({ createGrpcWebTransport }) => import("../gen/honua/v1/feature_service_pb.js").then(({ FeatureService }) => {
-            const transport = createGrpcWebTransport(this.connectTransportOptions());
-            this.connectClient = createClient(FeatureService, transport);
-        })));
-    }
     async ensureConnectClient() {
         if (this.connectClient) {
             return this.connectClient;
         }
-        // If initConnectClient hasn't resolved yet, wait for it
-        const { createClient } = await import("@connectrpc/connect");
-        const { createGrpcWebTransport } = await import("@connectrpc/connect-web");
-        const { FeatureService } = await import("../gen/honua/v1/feature_service_pb.js");
-        const transport = createGrpcWebTransport(this.connectTransportOptions());
-        this.connectClient = createClient(FeatureService, transport);
-        return this.connectClient;
+        // Keep optional Connect peers out of the module graph until the first
+        // gRPC operation is actually awaited. Caching the in-flight promise also
+        // prevents concurrent first calls from constructing competing clients.
+        let initPromise = this.connectClientPromise;
+        if (!initPromise) {
+            initPromise = Promise.all([
+                import("@connectrpc/connect"),
+                import("@connectrpc/connect-web"),
+                import("../gen/honua/v1/feature_service_pb.js"),
+            ]).then(([{ createClient }, { createGrpcWebTransport }, { FeatureService }]) => {
+                const transport = createGrpcWebTransport(this.connectTransportOptions());
+                this.connectClient = createClient(FeatureService, transport);
+                return this.connectClient;
+            });
+            this.connectClientPromise = initPromise;
+        }
+        try {
+            return await initPromise;
+        }
+        catch (error) {
+            // A transient module-loader failure must not poison every later call.
+            if (this.connectClientPromise === initPromise) {
+                this.connectClientPromise = undefined;
+            }
+            throw error;
+        }
     }
     /**
      * Perform a fetch that never auto-follows a cross-origin redirect.
@@ -330,11 +341,24 @@ export class HonuaClient {
      * base origin (re-running the {@link resolveRequestUrl} origin guard).
      * Cross-origin redirects throw before the credentialed request is replayed.
      */
-    async fetchWithSafeRedirects(url, init) {
+    async fetchWithSafeRedirects(url, init, redirectPolicy = "safe-follow") {
         let currentUrl = url;
         let currentInit = init;
         for (let redirects = 0;; redirects += 1) {
-            const response = await this.fetchFn(currentUrl, { ...currentInit, redirect: "manual" });
+            const response = await this.fetchFn(currentUrl, {
+                ...currentInit,
+                redirect: redirectPolicy === "error" ? "error" : "manual",
+            });
+            if (redirectPolicy === "error") {
+                if (response.type === "opaqueredirect" ||
+                    response.redirected ||
+                    REDIRECT_STATUSES.has(response.status) ||
+                    (response.url !== "" && response.url !== currentUrl)) {
+                    await response.body?.cancel().catch(() => undefined);
+                    throw new HonuaNetworkError("Redirects are not allowed for this bounded request.", undefined);
+                }
+                return response;
+            }
             // `redirect: "manual"` surfaces redirects as status 3xx with a usable
             // `Location` header (and, in fetch, an "opaqueredirect" type with status 0
             // in some runtimes — treated as a same-origin-unverifiable redirect we
@@ -342,9 +366,13 @@ export class HonuaClient {
             if (response.type === "opaqueredirect") {
                 throw new HonuaNetworkError("Refusing to follow an opaque cross-origin redirect; the request's API key would be leaked to the redirect target.", undefined);
             }
-            if (!REDIRECT_STATUSES.has(response.status)) {
+            if (!REDIRECT_STATUSES.has(response.status))
+                return response;
+            // Some bounded metadata callers need the untouched 3xx response so
+            // their protocol facade can preserve its typed redirect diagnostic.
+            // Credentials are still never replayed because fetch remains manual.
+            if (redirectPolicy === "manual")
                 return response;
-            }
             if (redirects >= MAX_SAFE_REDIRECTS) {
                 throw new HonuaNetworkError(`Exceeded the maximum of ${MAX_SAFE_REDIRECTS} redirects.`, undefined);
             }
@@ -391,6 +419,33 @@ export class HonuaClient {
         });
         return cached?.credentials;
     }
+    /**
+     * Resolve the auth headers the client would attach to an outgoing request
+     * right now, refreshing provider credentials first if they are expiring.
+     *
+     * Transports that build their own connection outside the REST/gRPC pipeline —
+     * notably realtime SSE streams, which must re-authenticate on every
+     * (re)connect so a refreshed token is picked up after a drop — call this per
+     * connect to obtain fresh credentials. Returns an empty object when no
+     * credentials are configured.
+     */
+    async getAuthHeaders() {
+        return this.composeHeaders();
+    }
+    /**
+     * Resolve just the current bearer/authorization token value (without the
+     * `Bearer ` scheme prefix when a plain bearer token is configured), or
+     * `undefined` if none. Convenience for realtime transports that must carry the
+     * token as a query parameter (native `EventSource` cannot set headers).
+     */
+    async getAuthToken() {
+        const headers = await this.composeHeaders();
+        const authorization = headers.Authorization ?? headers.authorization;
+        if (authorization) {
+            return authorization.startsWith("Bearer ") ? authorization.slice("Bearer ".length) : authorization;
+        }
+        return headers["X-API-Key"] ?? headers["x-api-key"];
+    }
     /** Drop cached provider credentials without calling a revocation endpoint. */
     clearAuthCredentials() {
         this.authCredentialsCache = undefined;
@@ -530,7 +585,14 @@ export class HonuaClient {
         return createHonuaProcessRunner(createGeospatialGrpcProcessAdapter(processClient));
     }
     wfs(endpointUrl = "/wfs", options = {}) {
-        return new HonuaWfs({ client: this, endpointUrl, version: options.version });
+        const version = options.version ?? "2.0.0";
+        const key = `${endpointUrl}\u0000${version}`;
+        const cached = this.wfsRootCache.get(key);
+        if (cached)
+            return cached;
+        const root = new HonuaWfs({ client: this, endpointUrl, version });
+        this.wfsRootCache.set(key, root);
+        return root;
     }
     odata(entitySet, options = {}) {
         return new HonuaOdataEntitySet({ client: this, entitySet, basePath: options.basePath });
@@ -748,6 +810,15 @@ export class HonuaClient {
         return this.executeRequest(request, {
             callerSignal,
             ...(options.okStatuses ? { okStatuses: options.okStatuses } : {}),
+            ...(options.redirect ? { redirect: options.redirect } : {}),
+            ...(options.discardErrorBody
+                ? {
+                    errorBody: (response) => {
+                        void response.body?.cancel().catch(() => undefined);
+                        return Promise.resolve({});
+                    },
+                }
+                : {}),
             finalize: async (response, _durationMs, _request, runAfter) => {
                 await runAfter();
                 return response;
@@ -756,7 +827,11 @@ export class HonuaClient {
     }
     async requestCachedMetadataJson(cacheKey, path, options = {}) {
         const metadataOptions = normalizeHonuaMetadataRequestOptions(options);
-        const keyFingerprint = `metadata:${cacheKey}`;
+        // A byte-bounded trust boundary must never reuse an entry populated by an
+        // unbounded or more-permissive request. Partitioning preserves normal cache
+        // reuse for callers that share the same ceiling without retaining bodies
+        // that were admitted under different limits.
+        const keyFingerprint = `metadata:${cacheKey}${metadataOptions.maxResponseBytes === undefined ? "" : `:max-response-bytes:${metadataOptions.maxResponseBytes}`}`;
         const cached = this.metadataCache.get(keyFingerprint);
         const bypass = metadataOptions.cache === "bypass";
         const now = Date.now();
@@ -810,7 +885,7 @@ export class HonuaClient {
                 };
             },
             finalize: async (response, durationMs, currentRequest, runAfter) => {
-                const body = await parseResponseBody(this.hasAfterInterceptors() ? response.clone() : response);
+                const body = await parseResponseBody(this.hasAfterInterceptors() ? response.clone() : response, metadataOptions.maxResponseBytes);
                 // GeoServices reports metadata failures (layer not found, invalid token
                 // => code 499, …) as HTTP 200 with a top-level `{error}` envelope.
                 // Detect it before caching so a transient auth/permission error is never
@@ -882,6 +957,29 @@ export class HonuaClient {
     async getFeatureServiceMetadata(serviceId, options = {}) {
         return getFeatureServiceMetadata(this.protocolTransport, serviceId, options);
     }
+    /**
+     * Resolve (and memoize) the OGC API Features endpoint layout for the
+     * given discovery `mode`. `honua-facade` (default) returns the fixed
+     * `/ogc/features/...` fast path with no network access; `ogc-api` and
+     * `auto` discover the layout from the server's landing page per OGC API
+     * - Common so the same typed surface works against pygeoapi / ldproxy /
+     * GeoServer. Discovery is cached per mode for the life of the client
+     * (the layout is a function of the fixed `baseUrl`).
+     */
+    resolveOgcFeaturesLayout(mode = "honua-facade") {
+        if (mode === "honua-facade")
+            return Promise.resolve(honuaFacadeFeaturesLayout());
+        let cached = this.ogcLayoutCache.get(mode);
+        if (!cached) {
+            cached = resolveOgcEndpointLayout(this.protocolTransport, mode).catch((err) => {
+                // Allow a later retry after a transient discovery failure.
+                this.ogcLayoutCache.delete(mode);
+                throw err;
+            });
+            this.ogcLayoutCache.set(mode, cached);
+        }
+        return cached;
+    }
     async getOgcFeaturesLanding(request = {}) {
         return getOgcFeaturesLanding(this.protocolTransport, request);
     }
@@ -1333,7 +1431,7 @@ export class HonuaClient {
                     ...request.init,
                     method: request.method,
                     signal: timeout.signal,
-                });
+                }, options.redirect);
             }
             catch (error) {
                 const durationMs = performance.now() - startTime;
@@ -1492,8 +1590,10 @@ function geoServicesEnvelopeError(httpStatus, body) {
     const message = hasMessage ? error.message : "Request failed";
     return new HonuaHttpError(statusCode, message, body);
 }
-async function parseResponseBody(response) {
-    const text = await response.text();
+async function parseResponseBody(response, maxResponseBytes) {
+    const text = maxResponseBytes === undefined
+        ? await response.text()
+        : new TextDecoder().decode(await readBoundedResponseBytes(response, maxResponseBytes));
     if (!text) {
         return {};
     }
@@ -1504,6 +1604,44 @@ async function parseResponseBody(response) {
         return { raw: text };
     }
 }
+async function readBoundedResponseBytes(response, maximum) {
+    const advertised = response.headers.get("content-length");
+    if (advertised !== null) {
+        const length = Number(advertised);
+        if (Number.isFinite(length) && length > maximum) {
+            await response.body?.cancel().catch(() => undefined);
+            throw new HonuaNetworkError(`Metadata response exceeds the configured ${maximum}-byte limit.`, undefined);
+        }
+    }
+    if (!response.body)
+        return new Uint8Array();
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > maximum) {
+                await reader.cancel().catch(() => undefined);
+                throw new HonuaNetworkError(`Metadata response exceeds the configured ${maximum}-byte limit.`, undefined);
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+}
 function isObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/core/error-classifications.d.ts

@@ -0,0 +1,153 @@
+import type { HonuaErrorCategory, HonuaErrorDomain } from "./error-code-registry.js";
+/**
+ * The classification state required by the error base at runtime.
+ *
+ * Human-readable summaries intentionally live only in
+ * `error-code-registry.ts`. Keep this table private to SDK internals and use
+ * `check:error-codes` to prove exact parity with the canonical registry.
+ *
+ * @internal
+ */
+export type HonuaErrorRuntimeClassification = readonly [
+    domain: HonuaErrorDomain,
+    category: HonuaErrorCategory,
+    retryable: boolean
+];
+/** @internal */
+export declare const HONUA_ERROR_RUNTIME_CLASSIFICATIONS: Readonly<{
+    readonly "core.http.transient": HonuaErrorRuntimeClassification;
+    readonly "core.http.rejected": HonuaErrorRuntimeClassification;
+    readonly "core.timeout": HonuaErrorRuntimeClassification;
+    readonly "core.network": HonuaErrorRuntimeClassification;
+    readonly "core.cancelled": HonuaErrorRuntimeClassification;
+    readonly "core.grpc.transient": HonuaErrorRuntimeClassification;
+    readonly "core.grpc.rejected": HonuaErrorRuntimeClassification;
+    readonly "core.geometry.unknown-geometry": HonuaErrorRuntimeClassification;
+    readonly "core.geometry.malformed-geometry": HonuaErrorRuntimeClassification;
+    readonly "core.auth.interaction-required": HonuaErrorRuntimeClassification;
+    readonly "core.auth.refresh-failed": HonuaErrorRuntimeClassification;
+    readonly "core.auth.invalid-grant": HonuaErrorRuntimeClassification;
+    readonly "core.capability-not-supported": HonuaErrorRuntimeClassification;
+    readonly "core.exploration-context": HonuaErrorRuntimeClassification;
+    readonly "core.wfs-exception": HonuaErrorRuntimeClassification;
+    readonly "core.job-failed": HonuaErrorRuntimeClassification;
+    readonly "core.wms-capabilities-parse": HonuaErrorRuntimeClassification;
+    readonly "core.wmts-capabilities-parse": HonuaErrorRuntimeClassification;
+    readonly "discovery.ambiguous-protocol": HonuaErrorRuntimeClassification;
+    readonly "discovery.ambiguous-source": HonuaErrorRuntimeClassification;
+    readonly "discovery.invalid-endpoint": HonuaErrorRuntimeClassification;
+    readonly "discovery.invalid-cache-identity": HonuaErrorRuntimeClassification;
+    readonly "discovery.invalid-discovery-cache": HonuaErrorRuntimeClassification;
+    readonly "discovery.invalid-capability": HonuaErrorRuntimeClassification;
+    readonly "discovery.unsupported-protocol": HonuaErrorRuntimeClassification;
+    readonly "discovery.protocol-mismatch": HonuaErrorRuntimeClassification;
+    readonly "query.planning.invalid-query": HonuaErrorRuntimeClassification;
+    readonly "query.planning.unsupported-compiler": HonuaErrorRuntimeClassification;
+    readonly "query.planning.unsupported-query": HonuaErrorRuntimeClassification;
+    readonly "query.planning.capability-not-supported": HonuaErrorRuntimeClassification;
+    readonly "query.planning.fallback-disabled": HonuaErrorRuntimeClassification;
+    readonly "query.planning.unsafe-materialization": HonuaErrorRuntimeClassification;
+    readonly "query.execution.invalid-plan": HonuaErrorRuntimeClassification;
+    readonly "query.execution.plan-context-mismatch": HonuaErrorRuntimeClassification;
+    readonly "query.execution.unsafe-materialization": HonuaErrorRuntimeClassification;
+    readonly "query.execution.invalid-resource-handle": HonuaErrorRuntimeClassification;
+    readonly "query.execution.resource-unavailable": HonuaErrorRuntimeClassification;
+    readonly "query.execution.resource-expired": HonuaErrorRuntimeClassification;
+    readonly "query.execution.resource-resolution-failed": HonuaErrorRuntimeClassification;
+    readonly "query.execution.resource-execution-failed": HonuaErrorRuntimeClassification;
+    readonly "map.source-adapter.disposed": HonuaErrorRuntimeClassification;
+    readonly "map.source-adapter.source-conflict": HonuaErrorRuntimeClassification;
+    readonly "map.source-adapter.layer-conflict": HonuaErrorRuntimeClassification;
+    readonly "map.source-adapter.unsupported-plan": HonuaErrorRuntimeClassification;
+    readonly "map.source-adapter.invalid-option": HonuaErrorRuntimeClassification;
+    readonly "map.source-adapter.map-mutation-failed": HonuaErrorRuntimeClassification;
+    readonly "map.data-bridge.invalid-option": HonuaErrorRuntimeClassification;
+    readonly "map.data-bridge.disposed": HonuaErrorRuntimeClassification;
+    readonly "map.data-bridge.source-conflict": HonuaErrorRuntimeClassification;
+    readonly "map.data-bridge.layer-conflict": HonuaErrorRuntimeClassification;
+    readonly "map.data-bridge.map-mutation-failed": HonuaErrorRuntimeClassification;
+    readonly "map.data-bridge.interaction-unsupported": HonuaErrorRuntimeClassification;
+    readonly "map.data-bridge.filter-unsupported": HonuaErrorRuntimeClassification;
+    readonly "map.automatic-strategy.no-eligible-strategy": HonuaErrorRuntimeClassification;
+    readonly "map.automatic-strategy.stale-plan": HonuaErrorRuntimeClassification;
+    readonly "map.automatic-strategy.source-conflict": HonuaErrorRuntimeClassification;
+    readonly "map.automatic-strategy.layer-conflict": HonuaErrorRuntimeClassification;
+    readonly "map.automatic-strategy.map-mutation-failed": HonuaErrorRuntimeClassification;
+    readonly "map.automatic-strategy.cancelled": HonuaErrorRuntimeClassification;
+    readonly "map.automatic-strategy.disposed": HonuaErrorRuntimeClassification;
+    readonly "map.raster-strategy.unsupported-strategy": HonuaErrorRuntimeClassification;
+    readonly "map.raster-strategy.capability-mismatch": HonuaErrorRuntimeClassification;
+    readonly "map.raster-strategy.missing-metadata": HonuaErrorRuntimeClassification;
+    readonly "map.raster-strategy.invalid-option": HonuaErrorRuntimeClassification;
+    readonly "map.raster-strategy.source-conflict": HonuaErrorRuntimeClassification;
+    readonly "map.raster-strategy.layer-conflict": HonuaErrorRuntimeClassification;
+    readonly "map.raster-strategy.map-mutation-failed": HonuaErrorRuntimeClassification;
+    readonly "map.automatic-integration.disposed": HonuaErrorRuntimeClassification;
+    readonly "map.automatic-integration.invalid-target": HonuaErrorRuntimeClassification;
+    readonly "map.temporal-playback.invalid-option": HonuaErrorRuntimeClassification;
+    readonly "runtime.map-package.fetch": HonuaErrorRuntimeClassification;
+    readonly "runtime.map-package.load": HonuaErrorRuntimeClassification;
+    readonly "runtime.map-package.validate": HonuaErrorRuntimeClassification;
+    readonly "runtime.map-package.update": HonuaErrorRuntimeClassification;
+    readonly "runtime.map-package.style-compose": HonuaErrorRuntimeClassification;
+    readonly "runtime.map-package.source-bind": HonuaErrorRuntimeClassification;
+    readonly "runtime.map-package.view": HonuaErrorRuntimeClassification;
+    readonly "runtime.map-package.popup": HonuaErrorRuntimeClassification;
+    readonly "runtime.map-package.dispose": HonuaErrorRuntimeClassification;
+    readonly "runtime.diagnostic": HonuaErrorRuntimeClassification;
+    readonly "runtime.query-tiles.transient": HonuaErrorRuntimeClassification;
+    readonly "runtime.query-tiles.rejected": HonuaErrorRuntimeClassification;
+    readonly "realtime.cancelled": HonuaErrorRuntimeClassification;
+    readonly "realtime.transport.reconnectable": HonuaErrorRuntimeClassification;
+    readonly "realtime.checkpoint.invalid": HonuaErrorRuntimeClassification;
+    readonly "realtime.sequence.gap": HonuaErrorRuntimeClassification;
+    readonly "realtime.protocol.terminal": HonuaErrorRuntimeClassification;
+    readonly "offline.region.validation": HonuaErrorRuntimeClassification;
+    readonly "offline.region.quota": HonuaErrorRuntimeClassification;
+    readonly "offline.region.integrity": HonuaErrorRuntimeClassification;
+    readonly "offline.cancelled": HonuaErrorRuntimeClassification;
+    readonly "offline.transport.failure": HonuaErrorRuntimeClassification;
+    readonly "offline.transport.transient": HonuaErrorRuntimeClassification;
+    readonly "offline.storage.concurrent": HonuaErrorRuntimeClassification;
+    readonly "offline.storage.failure": HonuaErrorRuntimeClassification;
+    readonly "offline.replica-sync.capability": HonuaErrorRuntimeClassification;
+    readonly "offline.replica-sync.validation": HonuaErrorRuntimeClassification;
+    readonly "offline.replica-sync.permission-denied": HonuaErrorRuntimeClassification;
+    readonly "plugin.registry.validation": HonuaErrorRuntimeClassification;
+    readonly "plugin.compatibility": HonuaErrorRuntimeClassification;
+    readonly "plugin.execution.policy-denied": HonuaErrorRuntimeClassification;
+    readonly "plugin.capability-unavailable": HonuaErrorRuntimeClassification;
+    readonly "plugin.lifecycle.activation": HonuaErrorRuntimeClassification;
+    readonly "plugin.execution.validation": HonuaErrorRuntimeClassification;
+    readonly "plugin.lifecycle.cleanup": HonuaErrorRuntimeClassification;
+    readonly "plugin.cancelled": HonuaErrorRuntimeClassification;
+    readonly "plugin.internal": HonuaErrorRuntimeClassification;
+    readonly "agent.tool.unknown-tool": HonuaErrorRuntimeClassification;
+    readonly "agent.tool.missing-runtime": HonuaErrorRuntimeClassification;
+    readonly "agent.tool.unqualified-selection": HonuaErrorRuntimeClassification;
+    readonly "agent.tool.missing-runtime-method": HonuaErrorRuntimeClassification;
+    readonly "agent.tool.internal": HonuaErrorRuntimeClassification;
+    readonly "agent.safety.aborted": HonuaErrorRuntimeClassification;
+    readonly "agent.safety.invalid-input": HonuaErrorRuntimeClassification;
+    readonly "agent.safety.policy-denied": HonuaErrorRuntimeClassification;
+    readonly "agent.safety.integrity-failed": HonuaErrorRuntimeClassification;
+    readonly "agent.safety.approval-expired": HonuaErrorRuntimeClassification;
+    readonly "agent.safety.context-mismatch": HonuaErrorRuntimeClassification;
+    readonly "agent.safety.signature-invalid": HonuaErrorRuntimeClassification;
+    readonly "agent.safety.execution-failed": HonuaErrorRuntimeClassification;
+    readonly "agent.safety.audit-failed": HonuaErrorRuntimeClassification;
+    readonly "agent.safety.receipt-failed": HonuaErrorRuntimeClassification;
+    readonly "app.unsupported-profile": HonuaErrorRuntimeClassification;
+    readonly "app.unsupported-widget": HonuaErrorRuntimeClassification;
+    readonly "app.missing-manifest": HonuaErrorRuntimeClassification;
+    readonly "app.missing-manifest-artifact": HonuaErrorRuntimeClassification;
+    readonly "app.missing-map-package": HonuaErrorRuntimeClassification;
+    readonly "app.map-package-mismatch": HonuaErrorRuntimeClassification;
+    readonly "app.missing-widget": HonuaErrorRuntimeClassification;
+    readonly "app.missing-binding": HonuaErrorRuntimeClassification;
+    readonly "app.map-load-failed": HonuaErrorRuntimeClassification;
+    readonly "app.data-load-failed": HonuaErrorRuntimeClassification;
+    readonly "app.render-failed": HonuaErrorRuntimeClassification;
+    readonly "app.disposed": HonuaErrorRuntimeClassification;
+}>;
+//# sourceMappingURL=error-classifications.d.ts.map

package/core/error-classifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-classifications.d.ts","sourceRoot":"","sources":["../../../src/core/error-classifications.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAkB,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAErG;;;;;;;;GAQG;AACH,MAAM,MAAM,+BAA+B,GAAG,SAAS;IACrD,MAAM,EAAE,gBAAgB;IACxB,QAAQ,EAAE,kBAAkB;IAC5B,SAAS,EAAE,OAAO;CACnB,CAAC;AAEF,gBAAgB;AAChB,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuI6B,CAAC"}

package/core/error-classifications.js

@@ -0,0 +1,140 @@
+/** @internal */
+export const HONUA_ERROR_RUNTIME_CLASSIFICATIONS = Object.freeze({
+    "core.http.transient": runtimeClassification("core", "protocol", true),
+    "core.http.rejected": runtimeClassification("core", "protocol", false),
+    "core.timeout": runtimeClassification("core", "timeout", true),
+    "core.network": runtimeClassification("core", "network", true),
+    "core.cancelled": runtimeClassification("core", "cancellation", false),
+    "core.grpc.transient": runtimeClassification("core", "protocol", true),
+    "core.grpc.rejected": runtimeClassification("core", "protocol", false),
+    "core.geometry.unknown-geometry": runtimeClassification("core", "validation", false),
+    "core.geometry.malformed-geometry": runtimeClassification("core", "validation", false),
+    "core.auth.interaction-required": runtimeClassification("core", "authentication", false),
+    "core.auth.refresh-failed": runtimeClassification("core", "authentication", true),
+    "core.auth.invalid-grant": runtimeClassification("core", "authentication", false),
+    "core.capability-not-supported": runtimeClassification("core", "capability", false),
+    "core.exploration-context": runtimeClassification("core", "validation", false),
+    "core.wfs-exception": runtimeClassification("core", "protocol", false),
+    "core.job-failed": runtimeClassification("core", "protocol", false),
+    "core.wms-capabilities-parse": runtimeClassification("core", "protocol", false),
+    "core.wmts-capabilities-parse": runtimeClassification("core", "protocol", false),
+    "discovery.ambiguous-protocol": runtimeClassification("discovery", "validation", false),
+    "discovery.ambiguous-source": runtimeClassification("discovery", "validation", false),
+    "discovery.invalid-endpoint": runtimeClassification("discovery", "validation", false),
+    "discovery.invalid-cache-identity": runtimeClassification("discovery", "validation", false),
+    "discovery.invalid-discovery-cache": runtimeClassification("discovery", "validation", false),
+    "discovery.invalid-capability": runtimeClassification("discovery", "validation", false),
+    "discovery.unsupported-protocol": runtimeClassification("discovery", "capability", false),
+    "discovery.protocol-mismatch": runtimeClassification("discovery", "validation", false),
+    "query.planning.invalid-query": runtimeClassification("query", "validation", false),
+    "query.planning.unsupported-compiler": runtimeClassification("query", "capability", false),
+    "query.planning.unsupported-query": runtimeClassification("query", "capability", false),
+    "query.planning.capability-not-supported": runtimeClassification("query", "capability", false),
+    "query.planning.fallback-disabled": runtimeClassification("query", "capability", false),
+    "query.planning.unsafe-materialization": runtimeClassification("query", "validation", false),
+    "query.execution.invalid-plan": runtimeClassification("query", "validation", false),
+    "query.execution.plan-context-mismatch": runtimeClassification("query", "validation", false),
+    "query.execution.unsafe-materialization": runtimeClassification("query", "validation", false),
+    "query.execution.invalid-resource-handle": runtimeClassification("query", "validation", false),
+    "query.execution.resource-unavailable": runtimeClassification("query", "authentication", false),
+    "query.execution.resource-expired": runtimeClassification("query", "authentication", false),
+    "query.execution.resource-resolution-failed": runtimeClassification("query", "internal", false),
+    "query.execution.resource-execution-failed": runtimeClassification("query", "internal", false),
+    "map.source-adapter.disposed": runtimeClassification("map", "validation", false),
+    "map.source-adapter.source-conflict": runtimeClassification("map", "validation", false),
+    "map.source-adapter.layer-conflict": runtimeClassification("map", "validation", false),
+    "map.source-adapter.unsupported-plan": runtimeClassification("map", "capability", false),
+    "map.source-adapter.invalid-option": runtimeClassification("map", "validation", false),
+    "map.source-adapter.map-mutation-failed": runtimeClassification("map", "internal", false),
+    "map.data-bridge.invalid-option": runtimeClassification("map", "validation", false),
+    "map.data-bridge.disposed": runtimeClassification("map", "validation", false),
+    "map.data-bridge.source-conflict": runtimeClassification("map", "validation", false),
+    "map.data-bridge.layer-conflict": runtimeClassification("map", "validation", false),
+    "map.data-bridge.map-mutation-failed": runtimeClassification("map", "internal", false),
+    "map.data-bridge.interaction-unsupported": runtimeClassification("map", "capability", false),
+    "map.data-bridge.filter-unsupported": runtimeClassification("map", "capability", false),
+    "map.automatic-strategy.no-eligible-strategy": runtimeClassification("map", "capability", false),
+    "map.automatic-strategy.stale-plan": runtimeClassification("map", "validation", false),
+    "map.automatic-strategy.source-conflict": runtimeClassification("map", "validation", false),
+    "map.automatic-strategy.layer-conflict": runtimeClassification("map", "validation", false),
+    "map.automatic-strategy.map-mutation-failed": runtimeClassification("map", "internal", false),
+    "map.automatic-strategy.cancelled": runtimeClassification("map", "cancellation", false),
+    "map.automatic-strategy.disposed": runtimeClassification("map", "validation", false),
+    "map.raster-strategy.unsupported-strategy": runtimeClassification("map", "capability", false),
+    "map.raster-strategy.capability-mismatch": runtimeClassification("map", "capability", false),
+    "map.raster-strategy.missing-metadata": runtimeClassification("map", "validation", false),
+    "map.raster-strategy.invalid-option": runtimeClassification("map", "validation", false),
+    "map.raster-strategy.source-conflict": runtimeClassification("map", "validation", false),
+    "map.raster-strategy.layer-conflict": runtimeClassification("map", "validation", false),
+    "map.raster-strategy.map-mutation-failed": runtimeClassification("map", "internal", false),
+    "map.automatic-integration.disposed": runtimeClassification("map", "validation", false),
+    "map.automatic-integration.invalid-target": runtimeClassification("map", "validation", false),
+    "map.temporal-playback.invalid-option": runtimeClassification("map", "validation", false),
+    "runtime.map-package.fetch": runtimeClassification("runtime", "network", true),
+    "runtime.map-package.load": runtimeClassification("runtime", "internal", false),
+    "runtime.map-package.validate": runtimeClassification("runtime", "validation", false),
+    "runtime.map-package.update": runtimeClassification("runtime", "internal", false),
+    "runtime.map-package.style-compose": runtimeClassification("runtime", "validation", false),
+    "runtime.map-package.source-bind": runtimeClassification("runtime", "internal", false),
+    "runtime.map-package.view": runtimeClassification("runtime", "internal", false),
+    "runtime.map-package.popup": runtimeClassification("runtime", "validation", false),
+    "runtime.map-package.dispose": runtimeClassification("runtime", "internal", true),
+    "runtime.diagnostic": runtimeClassification("runtime", "validation", false),
+    "runtime.query-tiles.transient": runtimeClassification("runtime", "protocol", true),
+    "runtime.query-tiles.rejected": runtimeClassification("runtime", "protocol", false),
+    "realtime.cancelled": runtimeClassification("realtime", "cancellation", false),
+    "realtime.transport.reconnectable": runtimeClassification("realtime", "network", true),
+    "realtime.checkpoint.invalid": runtimeClassification("realtime", "validation", false),
+    "realtime.sequence.gap": runtimeClassification("realtime", "protocol", true),
+    "realtime.protocol.terminal": runtimeClassification("realtime", "protocol", false),
+    "offline.region.validation": runtimeClassification("offline", "validation", false),
+    "offline.region.quota": runtimeClassification("offline", "validation", false),
+    "offline.region.integrity": runtimeClassification("offline", "protocol", false),
+    "offline.cancelled": runtimeClassification("offline", "cancellation", false),
+    "offline.transport.failure": runtimeClassification("offline", "network", false),
+    "offline.transport.transient": runtimeClassification("offline", "network", true),
+    "offline.storage.concurrent": runtimeClassification("offline", "internal", true),
+    "offline.storage.failure": runtimeClassification("offline", "internal", false),
+    "offline.replica-sync.capability": runtimeClassification("offline", "capability", false),
+    "offline.replica-sync.validation": runtimeClassification("offline", "validation", false),
+    "offline.replica-sync.permission-denied": runtimeClassification("offline", "authentication", false),
+    "plugin.registry.validation": runtimeClassification("plugin", "validation", false),
+    "plugin.compatibility": runtimeClassification("plugin", "capability", false),
+    "plugin.execution.policy-denied": runtimeClassification("plugin", "capability", false),
+    "plugin.capability-unavailable": runtimeClassification("plugin", "capability", false),
+    "plugin.lifecycle.activation": runtimeClassification("plugin", "internal", false),
+    "plugin.execution.validation": runtimeClassification("plugin", "validation", false),
+    "plugin.lifecycle.cleanup": runtimeClassification("plugin", "internal", false),
+    "plugin.cancelled": runtimeClassification("plugin", "cancellation", false),
+    "plugin.internal": runtimeClassification("plugin", "internal", false),
+    "agent.tool.unknown-tool": runtimeClassification("agent", "validation", false),
+    "agent.tool.missing-runtime": runtimeClassification("agent", "validation", false),
+    "agent.tool.unqualified-selection": runtimeClassification("agent", "validation", false),
+    "agent.tool.missing-runtime-method": runtimeClassification("agent", "capability", false),
+    "agent.tool.internal": runtimeClassification("agent", "internal", false),
+    "agent.safety.aborted": runtimeClassification("agent", "cancellation", false),
+    "agent.safety.invalid-input": runtimeClassification("agent", "validation", false),
+    "agent.safety.policy-denied": runtimeClassification("agent", "capability", false),
+    "agent.safety.integrity-failed": runtimeClassification("agent", "protocol", false),
+    "agent.safety.approval-expired": runtimeClassification("agent", "authentication", false),
+    "agent.safety.context-mismatch": runtimeClassification("agent", "validation", false),
+    "agent.safety.signature-invalid": runtimeClassification("agent", "validation", false),
+    "agent.safety.execution-failed": runtimeClassification("agent", "internal", false),
+    "agent.safety.audit-failed": runtimeClassification("agent", "internal", false),
+    "agent.safety.receipt-failed": runtimeClassification("agent", "internal", false),
+    "app.unsupported-profile": runtimeClassification("app", "capability", false),
+    "app.unsupported-widget": runtimeClassification("app", "capability", false),
+    "app.missing-manifest": runtimeClassification("app", "validation", false),
+    "app.missing-manifest-artifact": runtimeClassification("app", "validation", false),
+    "app.missing-map-package": runtimeClassification("app", "validation", false),
+    "app.map-package-mismatch": runtimeClassification("app", "validation", false),
+    "app.missing-widget": runtimeClassification("app", "validation", false),
+    "app.missing-binding": runtimeClassification("app", "validation", false),
+    "app.map-load-failed": runtimeClassification("app", "internal", false),
+    "app.data-load-failed": runtimeClassification("app", "internal", false),
+    "app.render-failed": runtimeClassification("app", "internal", false),
+    "app.disposed": runtimeClassification("app", "validation", false),
+});
+function runtimeClassification(domain, category, retryable) {
+    return Object.freeze([domain, category, retryable]);
+}