@honua/react 0.1.0-beta.0 → 0.1.1-beta.0

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]);
+}

package/core/error-code-registry.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Canonical descriptive registry for public Honua SDK error codes.
+ *
+ * The error base consumes a compact classification table so focused SDK
+ * entrypoints do not retain these human-readable summaries. The registry
+ * remains the public documentation source of truth; `check:error-codes`
+ * verifies the compact table against every descriptor.
+ */
+export type HonuaErrorDomain = "core" | "discovery" | "query" | "map" | "runtime" | "realtime" | "offline" | "plugin" | "agent" | "app";
+export type HonuaErrorCategory = "authentication" | "cancellation" | "capability" | "internal" | "network" | "protocol" | "timeout" | "validation";
+export interface HonuaErrorCodeDescriptor {
+    readonly domain: HonuaErrorDomain;
+    readonly category: HonuaErrorCategory;
+    readonly retryable: boolean;
+    readonly summary: string;
+}
+/**
+ * Canonical public code registry. Object keys make duplicate codes a compile
+ * error; the base constructor rejects codes absent from this registry.
+ */
+export declare const HONUA_ERROR_CODE_REGISTRY: Readonly<{
+    readonly "core.http.transient": HonuaErrorCodeDescriptor;
+    readonly "core.http.rejected": HonuaErrorCodeDescriptor;
+    readonly "core.timeout": HonuaErrorCodeDescriptor;
+    readonly "core.network": HonuaErrorCodeDescriptor;
+    readonly "core.cancelled": HonuaErrorCodeDescriptor;
+    readonly "core.grpc.transient": HonuaErrorCodeDescriptor;
+    readonly "core.grpc.rejected": HonuaErrorCodeDescriptor;
+    readonly "core.geometry.unknown-geometry": HonuaErrorCodeDescriptor;
+    readonly "core.geometry.malformed-geometry": HonuaErrorCodeDescriptor;
+    readonly "core.auth.interaction-required": HonuaErrorCodeDescriptor;
+    readonly "core.auth.refresh-failed": HonuaErrorCodeDescriptor;
+    readonly "core.auth.invalid-grant": HonuaErrorCodeDescriptor;
+    readonly "core.capability-not-supported": HonuaErrorCodeDescriptor;
+    readonly "core.exploration-context": HonuaErrorCodeDescriptor;
+    readonly "core.wfs-exception": HonuaErrorCodeDescriptor;
+    readonly "core.job-failed": HonuaErrorCodeDescriptor;
+    readonly "core.wms-capabilities-parse": HonuaErrorCodeDescriptor;
+    readonly "core.wmts-capabilities-parse": HonuaErrorCodeDescriptor;
+    readonly "discovery.ambiguous-protocol": HonuaErrorCodeDescriptor;
+    readonly "discovery.ambiguous-source": HonuaErrorCodeDescriptor;
+    readonly "discovery.invalid-endpoint": HonuaErrorCodeDescriptor;
+    readonly "discovery.invalid-cache-identity": HonuaErrorCodeDescriptor;
+    readonly "discovery.invalid-discovery-cache": HonuaErrorCodeDescriptor;
+    readonly "discovery.invalid-capability": HonuaErrorCodeDescriptor;
+    readonly "discovery.unsupported-protocol": HonuaErrorCodeDescriptor;
+    readonly "discovery.protocol-mismatch": HonuaErrorCodeDescriptor;
+    readonly "query.planning.invalid-query": HonuaErrorCodeDescriptor;
+    readonly "query.planning.unsupported-compiler": HonuaErrorCodeDescriptor;
+    readonly "query.planning.unsupported-query": HonuaErrorCodeDescriptor;
+    readonly "query.planning.capability-not-supported": HonuaErrorCodeDescriptor;
+    readonly "query.planning.fallback-disabled": HonuaErrorCodeDescriptor;
+    readonly "query.planning.unsafe-materialization": HonuaErrorCodeDescriptor;
+    readonly "query.execution.invalid-plan": HonuaErrorCodeDescriptor;
+    readonly "query.execution.plan-context-mismatch": HonuaErrorCodeDescriptor;
+    readonly "query.execution.unsafe-materialization": HonuaErrorCodeDescriptor;
+    readonly "query.execution.invalid-resource-handle": HonuaErrorCodeDescriptor;
+    readonly "query.execution.resource-unavailable": HonuaErrorCodeDescriptor;
+    readonly "query.execution.resource-expired": HonuaErrorCodeDescriptor;
+    readonly "query.execution.resource-resolution-failed": HonuaErrorCodeDescriptor;
+    readonly "query.execution.resource-execution-failed": HonuaErrorCodeDescriptor;
+    readonly "map.source-adapter.disposed": HonuaErrorCodeDescriptor;
+    readonly "map.source-adapter.source-conflict": HonuaErrorCodeDescriptor;
+    readonly "map.source-adapter.layer-conflict": HonuaErrorCodeDescriptor;
+    readonly "map.source-adapter.unsupported-plan": HonuaErrorCodeDescriptor;
+    readonly "map.source-adapter.invalid-option": HonuaErrorCodeDescriptor;
+    readonly "map.source-adapter.map-mutation-failed": HonuaErrorCodeDescriptor;
+    readonly "map.data-bridge.invalid-option": HonuaErrorCodeDescriptor;
+    readonly "map.data-bridge.disposed": HonuaErrorCodeDescriptor;
+    readonly "map.data-bridge.source-conflict": HonuaErrorCodeDescriptor;
+    readonly "map.data-bridge.layer-conflict": HonuaErrorCodeDescriptor;
+    readonly "map.data-bridge.map-mutation-failed": HonuaErrorCodeDescriptor;
+    readonly "map.data-bridge.interaction-unsupported": HonuaErrorCodeDescriptor;
+    readonly "map.data-bridge.filter-unsupported": HonuaErrorCodeDescriptor;
+    readonly "map.automatic-strategy.no-eligible-strategy": HonuaErrorCodeDescriptor;
+    readonly "map.automatic-strategy.stale-plan": HonuaErrorCodeDescriptor;
+    readonly "map.automatic-strategy.source-conflict": HonuaErrorCodeDescriptor;
+    readonly "map.automatic-strategy.layer-conflict": HonuaErrorCodeDescriptor;
+    readonly "map.automatic-strategy.map-mutation-failed": HonuaErrorCodeDescriptor;
+    readonly "map.automatic-strategy.cancelled": HonuaErrorCodeDescriptor;
+    readonly "map.automatic-strategy.disposed": HonuaErrorCodeDescriptor;
+    readonly "map.raster-strategy.unsupported-strategy": HonuaErrorCodeDescriptor;
+    readonly "map.raster-strategy.capability-mismatch": HonuaErrorCodeDescriptor;
+    readonly "map.raster-strategy.missing-metadata": HonuaErrorCodeDescriptor;
+    readonly "map.raster-strategy.invalid-option": HonuaErrorCodeDescriptor;
+    readonly "map.raster-strategy.source-conflict": HonuaErrorCodeDescriptor;
+    readonly "map.raster-strategy.layer-conflict": HonuaErrorCodeDescriptor;
+    readonly "map.raster-strategy.map-mutation-failed": HonuaErrorCodeDescriptor;
+    readonly "map.automatic-integration.disposed": HonuaErrorCodeDescriptor;
+    readonly "map.automatic-integration.invalid-target": HonuaErrorCodeDescriptor;
+    readonly "map.temporal-playback.invalid-option": HonuaErrorCodeDescriptor;
+    readonly "runtime.map-package.fetch": HonuaErrorCodeDescriptor;
+    readonly "runtime.map-package.load": HonuaErrorCodeDescriptor;
+    readonly "runtime.map-package.validate": HonuaErrorCodeDescriptor;
+    readonly "runtime.map-package.update": HonuaErrorCodeDescriptor;
+    readonly "runtime.map-package.style-compose": HonuaErrorCodeDescriptor;
+    readonly "runtime.map-package.source-bind": HonuaErrorCodeDescriptor;
+    readonly "runtime.map-package.view": HonuaErrorCodeDescriptor;
+    readonly "runtime.map-package.popup": HonuaErrorCodeDescriptor;
+    readonly "runtime.map-package.dispose": HonuaErrorCodeDescriptor;
+    readonly "runtime.diagnostic": HonuaErrorCodeDescriptor;
+    readonly "runtime.query-tiles.transient": HonuaErrorCodeDescriptor;
+    readonly "runtime.query-tiles.rejected": HonuaErrorCodeDescriptor;
+    readonly "realtime.cancelled": HonuaErrorCodeDescriptor;
+    readonly "realtime.transport.reconnectable": HonuaErrorCodeDescriptor;
+    readonly "realtime.checkpoint.invalid": HonuaErrorCodeDescriptor;
+    readonly "realtime.sequence.gap": HonuaErrorCodeDescriptor;
+    readonly "realtime.protocol.terminal": HonuaErrorCodeDescriptor;
+    readonly "offline.region.validation": HonuaErrorCodeDescriptor;
+    readonly "offline.region.quota": HonuaErrorCodeDescriptor;
+    readonly "offline.region.integrity": HonuaErrorCodeDescriptor;
+    readonly "offline.cancelled": HonuaErrorCodeDescriptor;
+    readonly "offline.transport.failure": HonuaErrorCodeDescriptor;
+    readonly "offline.transport.transient": HonuaErrorCodeDescriptor;
+    readonly "offline.storage.concurrent": HonuaErrorCodeDescriptor;
+    readonly "offline.storage.failure": HonuaErrorCodeDescriptor;
+    readonly "offline.replica-sync.capability": HonuaErrorCodeDescriptor;
+    readonly "offline.replica-sync.validation": HonuaErrorCodeDescriptor;
+    readonly "offline.replica-sync.permission-denied": HonuaErrorCodeDescriptor;
+    readonly "plugin.registry.validation": HonuaErrorCodeDescriptor;
+    readonly "plugin.compatibility": HonuaErrorCodeDescriptor;
+    readonly "plugin.execution.policy-denied": HonuaErrorCodeDescriptor;
+    readonly "plugin.capability-unavailable": HonuaErrorCodeDescriptor;
+    readonly "plugin.lifecycle.activation": HonuaErrorCodeDescriptor;
+    readonly "plugin.execution.validation": HonuaErrorCodeDescriptor;
+    readonly "plugin.lifecycle.cleanup": HonuaErrorCodeDescriptor;
+    readonly "plugin.cancelled": HonuaErrorCodeDescriptor;
+    readonly "plugin.internal": HonuaErrorCodeDescriptor;
+    readonly "agent.tool.unknown-tool": HonuaErrorCodeDescriptor;
+    readonly "agent.tool.missing-runtime": HonuaErrorCodeDescriptor;
+    readonly "agent.tool.unqualified-selection": HonuaErrorCodeDescriptor;
+    readonly "agent.tool.missing-runtime-method": HonuaErrorCodeDescriptor;
+    readonly "agent.tool.internal": HonuaErrorCodeDescriptor;
+    readonly "agent.safety.aborted": HonuaErrorCodeDescriptor;
+    readonly "agent.safety.invalid-input": HonuaErrorCodeDescriptor;
+    readonly "agent.safety.policy-denied": HonuaErrorCodeDescriptor;
+    readonly "agent.safety.integrity-failed": HonuaErrorCodeDescriptor;
+    readonly "agent.safety.approval-expired": HonuaErrorCodeDescriptor;
+    readonly "agent.safety.context-mismatch": HonuaErrorCodeDescriptor;
+    readonly "agent.safety.signature-invalid": HonuaErrorCodeDescriptor;
+    readonly "agent.safety.execution-failed": HonuaErrorCodeDescriptor;
+    readonly "agent.safety.audit-failed": HonuaErrorCodeDescriptor;
+    readonly "agent.safety.receipt-failed": HonuaErrorCodeDescriptor;
+    readonly "app.unsupported-profile": HonuaErrorCodeDescriptor;
+    readonly "app.unsupported-widget": HonuaErrorCodeDescriptor;
+    readonly "app.missing-manifest": HonuaErrorCodeDescriptor;
+    readonly "app.missing-manifest-artifact": HonuaErrorCodeDescriptor;
+    readonly "app.missing-map-package": HonuaErrorCodeDescriptor;
+    readonly "app.map-package-mismatch": HonuaErrorCodeDescriptor;
+    readonly "app.missing-widget": HonuaErrorCodeDescriptor;
+    readonly "app.missing-binding": HonuaErrorCodeDescriptor;
+    readonly "app.map-load-failed": HonuaErrorCodeDescriptor;
+    readonly "app.data-load-failed": HonuaErrorCodeDescriptor;
+    readonly "app.render-failed": HonuaErrorCodeDescriptor;
+    readonly "app.disposed": HonuaErrorCodeDescriptor;
+}>;
+export type HonuaErrorCode = keyof typeof HONUA_ERROR_CODE_REGISTRY;
+//# sourceMappingURL=error-code-registry.d.ts.map

package/core/error-code-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-code-registry.d.ts","sourceRoot":"","sources":["../../../src/core/error-code-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GACxB,MAAM,GACN,WAAW,GACX,OAAO,GACP,KAAK,GACL,SAAS,GACT,UAAU,GACV,SAAS,GACT,QAAQ,GACR,OAAO,GACP,KAAK,CAAC;AAEV,MAAM,MAAM,kBAAkB,GAC1B,gBAAgB,GAChB,cAAc,GACd,YAAY,GACZ,UAAU,GACV,SAAS,GACT,UAAU,GACV,SAAS,GACT,YAAY,CAAC;AAEjB,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IACtC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsiBwB,CAAC;AAE/D,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,yBAAyB,CAAC"}