@honua/app-platform 0.0.20-alpha.0

package/core/surfaces.js

@@ -0,0 +1,1964 @@
+import { HonuaJobPollTimeoutError, isJobTerminal } from "../contract/jobs.js";
+import { FEATURE_SERVER_H3_SPATIAL_AGGREGATION_INDEX_MODEL_ID, SPATIAL_AGGREGATION_METADATA_SCHEMA_VERSION, SPATIAL_AGGREGATION_SCHEMA_VERSION, assertFeatureServerH3SpatialAggregationRequest, spatialAggregationWidgets, } from "../contract/spatial-aggregation.js";
+import { encodeServiceIdPath } from "./path-utils.js";
+import { responseExceededTransferLimit } from "./wire-shared.js";
+export class HonuaService {
+    client;
+    serviceId;
+    constructor(options) {
+        this.client = options.client;
+        this.serviceId = options.serviceId;
+    }
+    featureLayer(layerId) {
+        return new HonuaFeatureLayer({
+            client: this.client,
+            serviceId: this.serviceId,
+            layerId,
+        });
+    }
+    layer(layerId) {
+        return this.featureLayer(layerId);
+    }
+    async featureServiceMetadata(options = {}) {
+        return this.client.getFeatureServiceMetadata(this.serviceId, options);
+    }
+    async mapServiceMetadata(options = {}) {
+        return this.client.getMapServiceMetadata(this.serviceId, options);
+    }
+    async featureLayerIds() {
+        const metadata = await this.featureServiceMetadata();
+        return extractLayerIds(metadata);
+    }
+    async featureLayers() {
+        const ids = await this.featureLayerIds();
+        return ids.map((layerId) => new HonuaFeatureLayer({
+            client: this.client,
+            serviceId: this.serviceId,
+            layerId,
+        }));
+    }
+    async mapLayerIds() {
+        const metadata = await this.mapServiceMetadata();
+        return extractLayerIds(metadata);
+    }
+    async mapLayers() {
+        const ids = await this.mapLayerIds();
+        return ids.map((layerId) => new HonuaMapLayer({
+            client: this.client,
+            serviceId: this.serviceId,
+            layerId,
+        }));
+    }
+    async request(request) {
+        return this.client.request({
+            ...request,
+            path: `/rest/services/${encodeServiceIdPath(this.serviceId)}/${normalizeServicePath(request.path)}`,
+        });
+    }
+    mapService() {
+        return new HonuaMapService({
+            client: this.client,
+            serviceId: this.serviceId,
+        });
+    }
+    mapLayer(layerId) {
+        return new HonuaMapLayer({
+            client: this.client,
+            serviceId: this.serviceId,
+            layerId,
+        });
+    }
+}
+export class HonuaFeatureLayer {
+    client;
+    serviceId;
+    layerId;
+    constructor(options) {
+        this.client = options.client;
+        this.serviceId = options.serviceId;
+        this.layerId = options.layerId;
+    }
+    async metadata(options = {}) {
+        return this.client.getLayerMetadata(this.serviceId, this.layerId, options);
+    }
+    createQuery() {
+        return {
+            where: "1=1",
+            outFields: ["*"],
+            returnGeometry: true,
+        };
+    }
+    async queryFeatures(request = {}) {
+        return this.client.queryFeatures({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            ...request,
+        });
+    }
+    async queryFeaturesAll(request = {}) {
+        const pageSize = typeof request.pageSize === "number" && Number.isFinite(request.pageSize)
+            ? Math.max(1, Math.trunc(request.pageSize))
+            : 2000;
+        const maxPages = typeof request.maxPages === "number" && Number.isFinite(request.maxPages)
+            ? Math.max(1, Math.trunc(request.maxPages))
+            : 100;
+        const startingOffset = normalizeOffset(request.resultOffset);
+        const features = [];
+        let offset = startingOffset;
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.queryFeatures({
+                ...request,
+                extraParams: {
+                    ...(request.extraParams ?? {}),
+                    resultOffset: offset,
+                    resultRecordCount: pageSize,
+                },
+            });
+            const pageFeatures = response.features ?? [];
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            features.push(...pageFeatures);
+            offset += pageFeatures.length;
+            if (!responseExceededTransferLimit(response) && pageFeatures.length < pageSize) {
+                break;
+            }
+        }
+        return features;
+    }
+    async *queryFeaturesStream(request = {}) {
+        const pageSize = typeof request.pageSize === "number" && Number.isFinite(request.pageSize)
+            ? Math.max(1, Math.trunc(request.pageSize))
+            : 2000;
+        const maxPages = typeof request.maxPages === "number" && Number.isFinite(request.maxPages)
+            ? Math.max(1, Math.trunc(request.maxPages))
+            : 100;
+        const startingOffset = normalizeOffset(request.resultOffset);
+        // Use server streaming RPC when gRPC-Web transport is active
+        if (this.client.isGrpcWeb) {
+            const { pageSize: _pageSize, maxPages: _maxPages, ...queryRequest } = request;
+            let pageCount = 0;
+            const stream = this.client.queryFeaturesStream({
+                serviceId: this.serviceId,
+                layerId: this.layerId,
+                ...queryRequest,
+                resultRecordCount: queryRequest.resultRecordCount ?? pageSize,
+            });
+            for await (const page of stream) {
+                yield page;
+                pageCount += 1;
+                if (pageCount >= maxPages) {
+                    break;
+                }
+            }
+            return;
+        }
+        let offset = startingOffset;
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.queryFeatures({
+                ...request,
+                extraParams: {
+                    ...(request.extraParams ?? {}),
+                    resultOffset: offset,
+                    resultRecordCount: pageSize,
+                },
+            });
+            const pageFeatures = response.features ?? [];
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            yield pageFeatures;
+            offset += pageFeatures.length;
+            if (!responseExceededTransferLimit(response) && pageFeatures.length < pageSize) {
+                break;
+            }
+        }
+    }
+    async queryFeatureCount(request = {}) {
+        const response = await this.client.queryFeatures({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            where: request.where ?? "1=1",
+            returnGeometry: false,
+            outFields: "OBJECTID",
+            method: request.method,
+            extraParams: {
+                returnCountOnly: true,
+                ...request.extraParams,
+            },
+        });
+        if (isObject(response) && typeof response.count === "number" && Number.isFinite(response.count)) {
+            return response.count;
+        }
+        if (isObject(response) && Array.isArray(response.features)) {
+            return response.features.length;
+        }
+        return 0;
+    }
+    async queryObjectIds(request = {}) {
+        const response = await this.client.queryFeatures({
+            ...request,
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            where: request.where ?? "1=1",
+            returnGeometry: false,
+            outFields: request.outFields ?? "OBJECTID",
+            extraParams: {
+                returnIdsOnly: true,
+                ...request.extraParams,
+            },
+        });
+        if (isObject(response) && Array.isArray(response.objectIds)) {
+            return response.objectIds
+                .map((value) => Number(value))
+                .filter((value) => Number.isFinite(value));
+        }
+        return [];
+    }
+    async queryExtent(request = {}) {
+        const response = await this.client.queryFeatures({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            where: request.where ?? "1=1",
+            returnGeometry: false,
+            method: request.method,
+            extraParams: {
+                returnExtentOnly: true,
+                ...request.extraParams,
+            },
+        });
+        return extractExtentFromResponse(response);
+    }
+    async querySpatialAggregation(request) {
+        const sourceId = request.sourceId ?? defaultFeatureLayerSourceId(this.serviceId, this.layerId);
+        const normalizedRequest = {
+            ...request,
+            sourceId,
+        };
+        assertFeatureServerH3SpatialAggregationRequest(normalizedRequest);
+        const plan = createFeatureServerH3AggregationPlan(normalizedRequest, request.kRingDistance);
+        const path = `/rest/services/${encodeServiceIdPath(this.serviceId)}/FeatureServer/${this.layerId}/queryH3`;
+        const method = request.method ?? "POST";
+        const response = method === "GET"
+            ? await this.client.request({
+                method,
+                path,
+                responseFormat: request.responseFormat ?? "json",
+                query: plan.params,
+                signal: request.signal,
+            })
+            : await this.client.request({
+                method,
+                path,
+                responseFormat: request.responseFormat ?? "json",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+                body: toFormBody(plan.params),
+                signal: request.signal,
+            });
+        return featureServerH3AggregationResultFromResponse(response, normalizedRequest, plan);
+    }
+    async queryRelatedRecords(request) {
+        return this.client.queryRelatedRecords({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            ...request,
+        });
+    }
+    async queryRelatedFeatures(request) {
+        return this.queryRelatedRecords(request);
+    }
+    async applyEdits(request) {
+        return this.client.applyEdits({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            ...request,
+        });
+    }
+    async queryAttachments(request = {}) {
+        const method = request.method ?? "GET";
+        const path = `/rest/services/${encodeServiceIdPath(this.serviceId)}` + `/FeatureServer/${this.layerId}/queryAttachments`;
+        const query = {
+            ...(request.objectIds === undefined
+                ? {}
+                : {
+                    objectIds: normalizeObjectIds(request.objectIds),
+                }),
+            ...(request.where === undefined ? {} : { where: request.where }),
+            ...(request.extraParams ?? {}),
+        };
+        if (method === "GET") {
+            return this.client.request({
+                method: "GET",
+                path,
+                responseFormat: request.responseFormat ?? "json",
+                query,
+                signal: request.signal,
+            });
+        }
+        const body = toFormBody({
+            f: request.responseFormat ?? "json",
+            ...query,
+        });
+        return this.client.request({
+            method: "POST",
+            path,
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+            body,
+            signal: request.signal,
+        });
+    }
+    async listAttachments(request) {
+        return this.client.request({
+            method: "GET",
+            path: `/rest/services/${encodeServiceIdPath(this.serviceId)}` +
+                `/FeatureServer/${this.layerId}/${request.objectId}/attachments`,
+            responseFormat: request.responseFormat ?? "json",
+            query: request.extraParams,
+            signal: request.signal,
+        });
+    }
+    async deleteAttachments(request) {
+        const body = toFormBody({
+            f: request.responseFormat ?? "json",
+            attachmentIds: normalizeObjectIds(request.attachmentIds),
+            ...(request.extraParams ?? {}),
+        });
+        return this.client.request({
+            method: "POST",
+            path: `/rest/services/${encodeServiceIdPath(this.serviceId)}` +
+                `/FeatureServer/${this.layerId}/${request.objectId}/deleteAttachments`,
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+            body,
+            signal: request.signal,
+        });
+    }
+    async addAttachment(request) {
+        const form = buildAttachmentFormData(request);
+        return this.client.request({
+            method: "POST",
+            path: `/rest/services/${encodeServiceIdPath(this.serviceId)}` +
+                `/FeatureServer/${this.layerId}/${request.objectId}/addAttachment`,
+            responseFormat: request.responseFormat ?? "json",
+            query: request.extraParams,
+            body: form,
+            signal: request.signal,
+        });
+    }
+    async updateAttachment(request) {
+        const form = buildAttachmentFormData(request);
+        form.set("attachmentId", String(request.attachmentId));
+        return this.client.request({
+            method: "POST",
+            path: `/rest/services/${encodeServiceIdPath(this.serviceId)}` +
+                `/FeatureServer/${this.layerId}/${request.objectId}/updateAttachment`,
+            responseFormat: request.responseFormat ?? "json",
+            query: request.extraParams,
+            body: form,
+            signal: request.signal,
+        });
+    }
+    async request(request) {
+        return this.client.request({
+            ...request,
+            path: `/rest/services/${encodeServiceIdPath(this.serviceId)}` +
+                `/FeatureServer/${this.layerId}/${normalizeLayerPath(request.path)}`,
+        });
+    }
+}
+export class HonuaMapService {
+    client;
+    serviceId;
+    constructor(options) {
+        this.client = options.client;
+        this.serviceId = options.serviceId;
+    }
+    async metadata(options = {}) {
+        return this.client.getMapServiceMetadata(this.serviceId, options);
+    }
+    layer(layerId) {
+        return new HonuaMapLayer({
+            client: this.client,
+            serviceId: this.serviceId,
+            layerId,
+        });
+    }
+    async layerIds() {
+        const metadata = await this.metadata();
+        return extractLayerIds(metadata);
+    }
+    async layers() {
+        const ids = await this.layerIds();
+        return ids.map((layerId) => new HonuaMapLayer({
+            client: this.client,
+            serviceId: this.serviceId,
+            layerId,
+        }));
+    }
+    async exportMap(request) {
+        return this.client.exportMap({
+            serviceId: this.serviceId,
+            ...request,
+        });
+    }
+    async legend(request = {}) {
+        return this.client.getMapLegend({
+            serviceId: this.serviceId,
+            ...request,
+        });
+    }
+    async getLegend(request = {}) {
+        return this.legend(request);
+    }
+    async identify(request) {
+        return this.client.identifyMap({
+            serviceId: this.serviceId,
+            ...request,
+        });
+    }
+    async find(request) {
+        return this.client.findMap({
+            serviceId: this.serviceId,
+            ...request,
+        });
+    }
+    async queryLayer(request) {
+        return this.client.queryMapLayer({
+            serviceId: this.serviceId,
+            ...request,
+        });
+    }
+    async queryLayerRelatedRecords(request) {
+        return this.client.queryMapRelatedRecords({
+            serviceId: this.serviceId,
+            ...request,
+        });
+    }
+    async queryLayerRelatedFeatures(request) {
+        return this.queryLayerRelatedRecords(request);
+    }
+    async queryLayerFeaturesAll(request) {
+        const pageSize = typeof request.pageSize === "number" && Number.isFinite(request.pageSize)
+            ? Math.max(1, Math.trunc(request.pageSize))
+            : 2000;
+        const maxPages = typeof request.maxPages === "number" && Number.isFinite(request.maxPages)
+            ? Math.max(1, Math.trunc(request.maxPages))
+            : 100;
+        const features = [];
+        let offset = 0;
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.queryLayer({
+                ...request,
+                extraParams: {
+                    ...(request.extraParams ?? {}),
+                    resultOffset: offset,
+                    resultRecordCount: pageSize,
+                },
+            });
+            const pageFeatures = extractFeaturesFromResponse(response);
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            features.push(...pageFeatures);
+            offset += pageFeatures.length;
+            if (!responseExceededTransferLimit(response) && pageFeatures.length < pageSize) {
+                break;
+            }
+        }
+        return features;
+    }
+    async *queryLayerFeaturesStream(request) {
+        const pageSize = typeof request.pageSize === "number" && Number.isFinite(request.pageSize)
+            ? Math.max(1, Math.trunc(request.pageSize))
+            : 2000;
+        const maxPages = typeof request.maxPages === "number" && Number.isFinite(request.maxPages)
+            ? Math.max(1, Math.trunc(request.maxPages))
+            : 100;
+        let offset = 0;
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.queryLayer({
+                ...request,
+                extraParams: {
+                    ...(request.extraParams ?? {}),
+                    resultOffset: offset,
+                    resultRecordCount: pageSize,
+                },
+            });
+            const pageFeatures = extractFeaturesFromResponse(response);
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            yield pageFeatures;
+            offset += pageFeatures.length;
+            if (!responseExceededTransferLimit(response) && pageFeatures.length < pageSize) {
+                break;
+            }
+        }
+    }
+    async queryLayerFeatureCount(request) {
+        const response = await this.queryLayer({
+            layerId: request.layerId,
+            where: request.where ?? "1=1",
+            returnGeometry: false,
+            outFields: "OBJECTID",
+            method: request.method,
+            extraParams: {
+                returnCountOnly: true,
+                ...request.extraParams,
+            },
+        });
+        return extractFeatureCountFromResponse(response);
+    }
+    async queryLayerObjectIds(request) {
+        const response = await this.queryLayer({
+            layerId: request.layerId,
+            where: request.where ?? "1=1",
+            returnGeometry: false,
+            outFields: "OBJECTID",
+            method: request.method,
+            extraParams: {
+                returnIdsOnly: true,
+                ...request.extraParams,
+            },
+        });
+        return extractObjectIdsFromResponse(response);
+    }
+    async queryLayerExtent(request) {
+        const response = await this.queryLayer({
+            layerId: request.layerId,
+            where: request.where ?? "1=1",
+            returnGeometry: false,
+            method: request.method,
+            extraParams: {
+                returnExtentOnly: true,
+                ...request.extraParams,
+            },
+        });
+        return extractExtentFromResponse(response);
+    }
+    async exportImage(request) {
+        return this.exportMap(request);
+    }
+    async request(request) {
+        return this.client.request({
+            ...request,
+            path: `/rest/services/${encodeServiceIdPath(this.serviceId)}` + `/MapServer/${normalizeServicePath(request.path)}`,
+        });
+    }
+}
+export class HonuaMapLayer {
+    client;
+    serviceId;
+    layerId;
+    constructor(options) {
+        this.client = options.client;
+        this.serviceId = options.serviceId;
+        this.layerId = options.layerId;
+    }
+    async metadata(options = {}) {
+        return this.client.getMapLayerMetadata(this.serviceId, this.layerId, options);
+    }
+    createQuery() {
+        return {
+            where: "1=1",
+            outFields: ["*"],
+            returnGeometry: true,
+        };
+    }
+    async queryFeatures(request = {}) {
+        return this.client.queryMapLayer({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            ...request,
+        });
+    }
+    async queryRelatedRecords(request) {
+        return this.client.queryMapRelatedRecords({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            ...request,
+        });
+    }
+    async queryRelatedFeatures(request) {
+        return this.queryRelatedRecords(request);
+    }
+    async queryFeaturesAll(request = {}) {
+        const pageSize = typeof request.pageSize === "number" && Number.isFinite(request.pageSize)
+            ? Math.max(1, Math.trunc(request.pageSize))
+            : 2000;
+        const maxPages = typeof request.maxPages === "number" && Number.isFinite(request.maxPages)
+            ? Math.max(1, Math.trunc(request.maxPages))
+            : 100;
+        const startingOffset = normalizeOffset(request.resultOffset);
+        const features = [];
+        let offset = startingOffset;
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.queryFeatures({
+                ...request,
+                extraParams: {
+                    ...(request.extraParams ?? {}),
+                    resultOffset: offset,
+                    resultRecordCount: pageSize,
+                },
+            });
+            const pageFeatures = extractFeaturesFromResponse(response);
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            features.push(...pageFeatures);
+            offset += pageFeatures.length;
+            if (!responseExceededTransferLimit(response) && pageFeatures.length < pageSize) {
+                break;
+            }
+        }
+        return features;
+    }
+    async *queryFeaturesStream(request = {}) {
+        const pageSize = typeof request.pageSize === "number" && Number.isFinite(request.pageSize)
+            ? Math.max(1, Math.trunc(request.pageSize))
+            : 2000;
+        const maxPages = typeof request.maxPages === "number" && Number.isFinite(request.maxPages)
+            ? Math.max(1, Math.trunc(request.maxPages))
+            : 100;
+        const startingOffset = normalizeOffset(request.resultOffset);
+        let offset = startingOffset;
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.queryFeatures({
+                ...request,
+                extraParams: {
+                    ...(request.extraParams ?? {}),
+                    resultOffset: offset,
+                    resultRecordCount: pageSize,
+                },
+            });
+            const pageFeatures = extractFeaturesFromResponse(response);
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            yield pageFeatures;
+            offset += pageFeatures.length;
+            if (!responseExceededTransferLimit(response) && pageFeatures.length < pageSize) {
+                break;
+            }
+        }
+    }
+    async queryFeatureCount(request = {}) {
+        const response = await this.queryFeatures({
+            where: request.where ?? "1=1",
+            returnGeometry: false,
+            outFields: "OBJECTID",
+            method: request.method,
+            extraParams: {
+                returnCountOnly: true,
+                ...request.extraParams,
+            },
+        });
+        return extractFeatureCountFromResponse(response);
+    }
+    async queryObjectIds(request = {}) {
+        const response = await this.queryFeatures({
+            ...request,
+            where: request.where ?? "1=1",
+            returnGeometry: false,
+            outFields: request.outFields ?? "OBJECTID",
+            extraParams: {
+                returnIdsOnly: true,
+                ...request.extraParams,
+            },
+        });
+        return extractObjectIdsFromResponse(response);
+    }
+    async queryExtent(request = {}) {
+        const response = await this.queryFeatures({
+            where: request.where ?? "1=1",
+            returnGeometry: false,
+            method: request.method,
+            extraParams: {
+                returnExtentOnly: true,
+                ...request.extraParams,
+            },
+        });
+        return extractExtentFromResponse(response);
+    }
+    async request(request) {
+        return this.client.request({
+            ...request,
+            path: `/rest/services/${encodeServiceIdPath(this.serviceId)}` +
+                `/MapServer/${this.layerId}/${normalizeLayerPath(request.path)}`,
+        });
+    }
+}
+/**
+ * Resolve the layout to inject onto a request. Returns `undefined` for the
+ * facade fast path so the wire layer keeps its zero-round-trip default.
+ */
+async function resolveInjectedLayout(client, mode) {
+    if (mode === undefined || mode === "honua-facade")
+        return undefined;
+    return client.resolveOgcFeaturesLayout(mode);
+}
+export class HonuaOgcFeatures {
+    client;
+    layoutMode;
+    constructor(options) {
+        this.client = options.client;
+        this.layoutMode = options.layout;
+    }
+    layout() {
+        return resolveInjectedLayout(this.client, this.layoutMode);
+    }
+    collection(collectionId) {
+        return new HonuaOgcFeatureCollection({
+            client: this.client,
+            collectionId,
+            ...(this.layoutMode ? { layout: this.layoutMode } : {}),
+        });
+    }
+    async landing(request = {}) {
+        const layout = await this.layout();
+        return this.client.getOgcFeaturesLanding({ ...request, ...(layout ? { layout } : {}) });
+    }
+    async conformance(request = {}) {
+        const layout = await this.layout();
+        return this.client.getOgcFeaturesConformance({ ...request, ...(layout ? { layout } : {}) });
+    }
+    async collections(request = {}) {
+        const layout = await this.layout();
+        return this.client.listOgcCollections({ ...request, ...(layout ? { layout } : {}) });
+    }
+    async getCollection(request) {
+        const layout = await this.layout();
+        return this.client.getOgcCollection({ ...request, ...(layout ? { layout } : {}) });
+    }
+    async queryables(request) {
+        const layout = await this.layout();
+        return this.client.getOgcQueryables({ ...request, ...(layout ? { layout } : {}) });
+    }
+    async items(request) {
+        const layout = await this.layout();
+        return this.client.listOgcItems({ ...request, ...(layout ? { layout } : {}) });
+    }
+    async itemsAll(request) {
+        const pageSize = normalizePageSize(request.pageSize, request.limit);
+        const maxPages = normalizeMaxPages(request.maxPages);
+        const offset = normalizeOffset(request.offset);
+        const totalLimit = normalizeTotalLimit(request.limit);
+        const features = [];
+        for (let page = 0; page < maxPages; page += 1) {
+            if (totalLimit !== undefined && features.length >= totalLimit) {
+                break;
+            }
+            const remainingLimit = totalLimit === undefined ? pageSize : Math.max(0, totalLimit - features.length);
+            if (remainingLimit < 1) {
+                break;
+            }
+            const limit = Math.min(pageSize, remainingLimit);
+            const response = await this.items({
+                ...request,
+                limit,
+                offset: offset + page * pageSize,
+            });
+            const pageFeatures = extractOgcFeatures(response);
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            features.push(...pageFeatures);
+            if (pageFeatures.length < limit) {
+                break;
+            }
+        }
+        if (totalLimit !== undefined && features.length > totalLimit) {
+            return features.slice(0, totalLimit);
+        }
+        return features;
+    }
+    async item(request) {
+        const layout = await this.layout();
+        return this.client.getOgcItem({ ...request, ...(layout ? { layout } : {}) });
+    }
+    async createItem(request) {
+        const layout = await this.layout();
+        return this.client.createOgcItem({ ...request, ...(layout ? { layout } : {}) });
+    }
+    async replaceItem(request) {
+        const layout = await this.layout();
+        return this.client.replaceOgcItem({ ...request, ...(layout ? { layout } : {}) });
+    }
+    async patchItem(request) {
+        const layout = await this.layout();
+        return this.client.patchOgcItem({ ...request, ...(layout ? { layout } : {}) });
+    }
+    async deleteItem(request) {
+        const layout = await this.layout();
+        return this.client.deleteOgcItem({ ...request, ...(layout ? { layout } : {}) });
+    }
+}
+export class HonuaOgcFeatureCollection {
+    client;
+    collectionId;
+    layoutMode;
+    constructor(options) {
+        this.client = options.client;
+        this.collectionId = options.collectionId;
+        this.layoutMode = options.layout;
+    }
+    layout() {
+        return resolveInjectedLayout(this.client, this.layoutMode);
+    }
+    async metadata(request = {}) {
+        const layout = await this.layout();
+        return this.client.getOgcCollection({
+            ...request,
+            collectionId: this.collectionId,
+            ...(layout ? { layout } : {}),
+        });
+    }
+    async queryables(request = {}) {
+        const layout = await this.layout();
+        return this.client.getOgcQueryables({
+            ...request,
+            collectionId: this.collectionId,
+            ...(layout ? { layout } : {}),
+        });
+    }
+    async items(request = {}) {
+        const layout = await this.layout();
+        return this.client.listOgcItems({
+            ...request,
+            collectionId: this.collectionId,
+            ...(layout ? { layout } : {}),
+        });
+    }
+    async itemsAll(request = {}) {
+        const pageSize = normalizePageSize(request.pageSize, request.limit);
+        const maxPages = normalizeMaxPages(request.maxPages);
+        const offset = normalizeOffset(request.offset);
+        const totalLimit = normalizeTotalLimit(request.limit);
+        const features = [];
+        for (let page = 0; page < maxPages; page += 1) {
+            if (totalLimit !== undefined && features.length >= totalLimit) {
+                break;
+            }
+            const remainingLimit = totalLimit === undefined ? pageSize : Math.max(0, totalLimit - features.length);
+            if (remainingLimit < 1) {
+                break;
+            }
+            const limit = Math.min(pageSize, remainingLimit);
+            const response = await this.items({
+                ...request,
+                limit,
+                offset: offset + page * pageSize,
+            });
+            const pageFeatures = extractOgcFeatures(response);
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            features.push(...pageFeatures);
+            if (pageFeatures.length < limit) {
+                break;
+            }
+        }
+        if (totalLimit !== undefined && features.length > totalLimit) {
+            return features.slice(0, totalLimit);
+        }
+        return features;
+    }
+    async *itemsStream(request = {}) {
+        const pageSize = normalizePageSize(request.pageSize, request.limit);
+        const maxPages = normalizeMaxPages(request.maxPages);
+        const offset = normalizeOffset(request.offset);
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.items({
+                ...request,
+                limit: pageSize,
+                offset: offset + page * pageSize,
+            });
+            const pageFeatures = extractOgcFeatures(response);
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            yield pageFeatures;
+            if (pageFeatures.length < pageSize) {
+                break;
+            }
+        }
+    }
+    async item(request) {
+        const layout = await this.layout();
+        return this.client.getOgcItem({
+            ...request,
+            collectionId: this.collectionId,
+            ...(layout ? { layout } : {}),
+        });
+    }
+    async createItem(request) {
+        const layout = await this.layout();
+        return this.client.createOgcItem({
+            ...request,
+            collectionId: this.collectionId,
+            ...(layout ? { layout } : {}),
+        });
+    }
+    async replaceItem(request) {
+        const layout = await this.layout();
+        return this.client.replaceOgcItem({
+            ...request,
+            collectionId: this.collectionId,
+            ...(layout ? { layout } : {}),
+        });
+    }
+    async patchItem(request) {
+        const layout = await this.layout();
+        return this.client.patchOgcItem({
+            ...request,
+            collectionId: this.collectionId,
+            ...(layout ? { layout } : {}),
+        });
+    }
+    async deleteItem(request) {
+        const layout = await this.layout();
+        return this.client.deleteOgcItem({
+            ...request,
+            collectionId: this.collectionId,
+            ...(layout ? { layout } : {}),
+        });
+    }
+}
+export function createHonuaService(client, serviceId) {
+    return new HonuaService({
+        client,
+        serviceId,
+    });
+}
+export function createHonuaOgcFeatures(client) {
+    return new HonuaOgcFeatures({
+        client,
+    });
+}
+/**
+ * Wrapper over a Honua ImageServer endpoint. Each operation maps to the
+ * server route published in
+ * `honua-server/docs/gis/image-server-matrix.md`. The wrapper does not
+ * downgrade to a generic raw call: it carries a typed request shape so
+ * the contract layer can negotiate capabilities and the server can
+ * branch on a stable method name.
+ */
+export class HonuaImageService {
+    client;
+    serviceId;
+    constructor(options) {
+        this.client = options.client;
+        this.serviceId = options.serviceId;
+    }
+    async metadata() {
+        return this.client.request({
+            method: "GET",
+            path: `/rest/services/${encodeServiceIdPath(this.serviceId)}/ImageServer`,
+            responseFormat: "json",
+        });
+    }
+    async queryRasterCatalog(request = {}) {
+        return this.dispatch("query", request, imageQueryParams(request));
+    }
+    async queryRasterCatalogObjectIds(request = {}) {
+        const response = await this.dispatch("query", request, {
+            ...imageQueryParams(request),
+            where: request.where ?? "1=1",
+            returnIdsOnly: true,
+        });
+        if (!Array.isArray(response.objectIds))
+            return [];
+        return response.objectIds.map((v) => Number(v)).filter((v) => Number.isFinite(v));
+    }
+    async exportImage(request) {
+        return this.dispatch("exportImage", request, imageExportParams(request));
+    }
+    async identify(request) {
+        return this.dispatch("identify", request, imageIdentifyParams(request));
+    }
+    /**
+     * Dispatch an ImageServer operation. POST mode sends params as a
+     * form-encoded body so the server's `TryReadRequestValuesAsync` parser
+     * finds them (returns "Request body is required" otherwise); GET mode
+     * keeps params in the query string. Both encodings are accepted by
+     * Honua Server per its ImageServer endpoint registration.
+     */
+    async dispatch(op, request, params) {
+        const method = request.method ?? "GET";
+        const path = `/rest/services/${encodeServiceIdPath(this.serviceId)}/ImageServer/${op}`;
+        const responseFormat = request.responseFormat ?? "json";
+        if (method === "GET") {
+            return this.client.request({ method: "GET", path, responseFormat, query: params, signal: request.signal });
+        }
+        return this.client.request({
+            method: "POST",
+            path,
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: toFormBody({ f: responseFormat, ...params }),
+            signal: request.signal,
+        });
+    }
+    tileUrl(level, row, col, format = "png") {
+        const path = `/rest/services/${encodeServiceIdPath(this.serviceId)}/ImageServer/tile/${level}/${row}/${col}`;
+        return `${this.client.serverBaseUrl}${path}?f=${format}`;
+    }
+    async legend() {
+        return this.client.request({
+            method: "GET",
+            path: `/rest/services/${encodeServiceIdPath(this.serviceId)}/ImageServer/legend`,
+            responseFormat: "json",
+        });
+    }
+}
+function imageQueryParams(request) {
+    const params = {};
+    if (request.where !== undefined)
+        params.where = request.where;
+    if (request.outFields !== undefined) {
+        params.outFields = Array.isArray(request.outFields) ? request.outFields.join(",") : String(request.outFields);
+    }
+    if (request.objectIds !== undefined) {
+        params.objectIds = Array.isArray(request.objectIds) ? request.objectIds.join(",") : String(request.objectIds);
+    }
+    if (request.returnGeometry !== undefined)
+        params.returnGeometry = request.returnGeometry;
+    if (request.outSr !== undefined)
+        params.outSR = String(request.outSr);
+    if (request.resultOffset !== undefined)
+        params.resultOffset = request.resultOffset;
+    if (request.resultRecordCount !== undefined)
+        params.resultRecordCount = request.resultRecordCount;
+    if (request.geometry !== undefined)
+        params.geometry = JSON.stringify(request.geometry);
+    if (request.geometryType !== undefined)
+        params.geometryType = String(request.geometryType);
+    if (request.spatialRel !== undefined)
+        params.spatialRel = String(request.spatialRel);
+    Object.assign(params, request.extraParams ?? {});
+    return params;
+}
+function imageExportParams(request) {
+    const params = {};
+    if (request.bbox !== undefined) {
+        params.bbox = Array.isArray(request.bbox) ? request.bbox.join(",") : request.bbox;
+    }
+    if (request.size !== undefined) {
+        params.size = Array.isArray(request.size) ? request.size.join(",") : request.size;
+    }
+    if (request.format !== undefined)
+        params.format = request.format;
+    if (request.pixelType !== undefined)
+        params.pixelType = request.pixelType;
+    if (request.noData !== undefined)
+        params.noData = request.noData;
+    if (request.interpolation !== undefined)
+        params.interpolation = request.interpolation;
+    if (request.compressionQuality !== undefined)
+        params.compressionQuality = request.compressionQuality;
+    if (request.bandIds !== undefined) {
+        params.bandIds = Array.isArray(request.bandIds) ? request.bandIds.join(",") : String(request.bandIds);
+    }
+    if (request.mosaicRule !== undefined) {
+        params.mosaicRule =
+            typeof request.mosaicRule === "string" ? request.mosaicRule : JSON.stringify(request.mosaicRule);
+    }
+    if (request.renderingRule !== undefined) {
+        params.renderingRule =
+            typeof request.renderingRule === "string" ? request.renderingRule : JSON.stringify(request.renderingRule);
+    }
+    if (request.imageSr !== undefined)
+        params.imageSR = String(request.imageSr);
+    if (request.bboxSr !== undefined)
+        params.bboxSR = String(request.bboxSr);
+    Object.assign(params, request.extraParams ?? {});
+    return params;
+}
+function imageIdentifyParams(request) {
+    const params = {};
+    params.geometry = typeof request.geometry === "string" ? request.geometry : JSON.stringify(request.geometry);
+    if (request.geometryType !== undefined)
+        params.geometryType = request.geometryType;
+    if (request.sr !== undefined)
+        params.sr = String(request.sr);
+    if (request.mosaicRule !== undefined) {
+        params.mosaicRule =
+            typeof request.mosaicRule === "string" ? request.mosaicRule : JSON.stringify(request.mosaicRule);
+    }
+    if (request.renderingRule !== undefined) {
+        params.renderingRule =
+            typeof request.renderingRule === "string" ? request.renderingRule : JSON.stringify(request.renderingRule);
+    }
+    if (request.pixelSize !== undefined) {
+        params.pixelSize = Array.isArray(request.pixelSize) ? request.pixelSize.join(",") : request.pixelSize;
+    }
+    Object.assign(params, request.extraParams ?? {});
+    return params;
+}
+/**
+ * Wrapper over a Honua Geometry Service endpoint. Routes match the
+ * canonical paths published by Honua Server's `EndpointRegistry`
+ * (`/rest/services/Utilities/Geometry/GeometryServer/<op>`; see
+ * `honua-server/docs/gis/geometry-service-matrix.md`). Wraps the
+ * server-supported operations: `project`, `buffer`, `simplify`,
+ * `intersect`, `union`, `clip`, `difference`. Operations not
+ * implemented in Honua Server (autoComplete, convexHull, cut,
+ * areasAndLengths/lengths measurement helpers, etc.) intentionally have
+ * no wrapper — callers that need them go through the raw `request()`
+ * escape hatch and handle 404s themselves.
+ *
+ * POST mode submits form-encoded bodies so the server's
+ * `TryReadRequestValuesAsync` parser finds the parameters. GET mode keeps
+ * params in the query string (the server accepts both).
+ */
+const GEOMETRY_SERVICE_ROOT = "/rest/services/Utilities/Geometry/GeometryServer";
+export class HonuaGeometryService {
+    client;
+    constructor(options) {
+        this.client = options.client;
+    }
+    async project(request) {
+        return this.dispatch("project", request, geometryProjectParams(request));
+    }
+    async buffer(request) {
+        return this.dispatch("buffer", request, geometryBufferParams(request));
+    }
+    async simplify(request) {
+        return this.dispatch("simplify", request, geometrySimplifyParams(request));
+    }
+    async intersect(request) {
+        return this.dispatch("intersect", request, geometryBinaryParams(request));
+    }
+    async union(request) {
+        return this.dispatch("union", request, geometryUnionParams(request));
+    }
+    async clip(request) {
+        return this.dispatch("clip", request, geometryBinaryParams(request));
+    }
+    async difference(request) {
+        return this.dispatch("difference", request, geometryBinaryParams(request));
+    }
+    async dispatch(op, request, params) {
+        const method = request.method ?? "POST";
+        const path = `${GEOMETRY_SERVICE_ROOT}/${op}`;
+        const responseFormat = request.responseFormat ?? "json";
+        if (method === "GET") {
+            return this.client.request({ method: "GET", path, responseFormat, query: params, signal: request.signal });
+        }
+        return this.client.request({
+            method: "POST",
+            path,
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: toFormBody({ f: responseFormat, ...params }),
+            signal: request.signal,
+        });
+    }
+}
+function geometryProjectParams(request) {
+    const params = {
+        geometries: typeof request.geometries === "string" ? request.geometries : JSON.stringify(request.geometries),
+        inSR: typeof request.inSr === "string" || typeof request.inSr === "number"
+            ? String(request.inSr)
+            : JSON.stringify(request.inSr),
+        outSR: typeof request.outSr === "string" || typeof request.outSr === "number"
+            ? String(request.outSr)
+            : JSON.stringify(request.outSr),
+    };
+    Object.assign(params, request.extraParams ?? {});
+    return params;
+}
+function geometryBufferParams(request) {
+    const params = {
+        geometries: typeof request.geometries === "string" ? request.geometries : JSON.stringify(request.geometries),
+        distances: Array.isArray(request.distances) ? request.distances.join(",") : String(request.distances),
+    };
+    if (request.unit !== undefined)
+        params.unit = request.unit;
+    if (request.inSr !== undefined)
+        params.inSR = typeof request.inSr === "object" ? JSON.stringify(request.inSr) : String(request.inSr);
+    if (request.outSr !== undefined)
+        params.outSR = typeof request.outSr === "object" ? JSON.stringify(request.outSr) : String(request.outSr);
+    if (request.bufferSr !== undefined)
+        params.bufferSR =
+            typeof request.bufferSr === "object" ? JSON.stringify(request.bufferSr) : String(request.bufferSr);
+    if (request.unionResults !== undefined)
+        params.unionResults = request.unionResults;
+    if (request.geodesic !== undefined)
+        params.geodesic = request.geodesic;
+    Object.assign(params, request.extraParams ?? {});
+    return params;
+}
+function geometrySimplifyParams(request) {
+    const params = {
+        geometries: typeof request.geometries === "string" ? request.geometries : JSON.stringify(request.geometries),
+    };
+    if (request.sr !== undefined)
+        params.sr = typeof request.sr === "object" ? JSON.stringify(request.sr) : String(request.sr);
+    Object.assign(params, request.extraParams ?? {});
+    return params;
+}
+function geometryBinaryParams(request) {
+    const params = {
+        geometries: typeof request.geometries === "string" ? request.geometries : JSON.stringify(request.geometries),
+        geometry: typeof request.geometry === "string" ? request.geometry : JSON.stringify(request.geometry),
+        sr: typeof request.sr === "object" ? JSON.stringify(request.sr) : String(request.sr),
+    };
+    Object.assign(params, request.extraParams ?? {});
+    return params;
+}
+function geometryUnionParams(request) {
+    const params = {
+        geometries: typeof request.geometries === "string" ? request.geometries : JSON.stringify(request.geometries),
+        sr: typeof request.sr === "object" ? JSON.stringify(request.sr) : String(request.sr),
+    };
+    Object.assign(params, request.extraParams ?? {});
+    return params;
+}
+/**
+ * Wrapper over a Honua GP Service task. Mirrors the routes published in
+ * `honua-server/docs/gis/geoprocess-framework-analysis.md`: `submitJob`,
+ * `jobs/{jobId}` (status), `jobs/{jobId}/cancel`, and per-result lookup
+ * (currently registered route, output delivery still depends on the
+ * execution engine — see the parity matrix).
+ */
+export class HonuaGeoprocessingService {
+    client;
+    serviceId;
+    taskName;
+    constructor(options) {
+        this.client = options.client;
+        this.serviceId = options.serviceId;
+        this.taskName = options.taskName;
+    }
+    async submitJob(request) {
+        return this.client.request({
+            method: request.method ?? "POST",
+            path: this.taskPath("submitJob"),
+            responseFormat: request.responseFormat ?? "json",
+            query: gpSubmitParams(request),
+            signal: request.signal,
+        });
+    }
+    /**
+     * Submit a GeoServices GP job and expose it through the canonical
+     * async-operation surface. This keeps GPServer tasks interoperable with
+     * OGC Processes jobs, app-workspace job state, and any future job-aware
+     * UI components.
+     */
+    async submit(request, options = {}) {
+        const accepted = await this.submitJob(request);
+        return new HonuaGeoprocessingJobRun({
+            client: this.client,
+            serviceId: this.serviceId,
+            taskName: this.taskName,
+            jobId: accepted.jobId,
+            initialJob: accepted,
+            resultNames: options.resultNames,
+            pollIntervalMs: options.pollIntervalMs,
+        });
+    }
+    /** Adopt an existing GP job by id after navigation or reconnect. */
+    job(jobId, options = {}) {
+        return new HonuaGeoprocessingJobRun({
+            client: this.client,
+            serviceId: this.serviceId,
+            taskName: this.taskName,
+            jobId,
+            resultNames: options.resultNames,
+            pollIntervalMs: options.pollIntervalMs,
+        });
+    }
+    async jobStatus(jobId, options = {}) {
+        return this.client.request({
+            method: "GET",
+            path: `${this.taskPath("jobs")}/${encodeURIComponent(jobId)}`,
+            responseFormat: "json",
+            signal: options.signal,
+        });
+    }
+    async cancelJob(jobId, options = {}) {
+        return this.client.request({
+            method: "POST",
+            path: `${this.taskPath("jobs")}/${encodeURIComponent(jobId)}/cancel`,
+            responseFormat: "json",
+            signal: options.signal,
+        });
+    }
+    async jobResult(jobId, resultName, options = {}) {
+        return this.client.request({
+            method: "GET",
+            path: `${this.taskPath("jobs")}/${encodeURIComponent(jobId)}/results/${encodeURIComponent(resultName)}`,
+            responseFormat: "json",
+            signal: options.signal,
+        });
+    }
+    taskPath(suffix) {
+        const taskSegment = this.taskName ? `/${encodeURIComponent(this.taskName)}` : "";
+        return `/rest/services/${encodeServiceIdPath(this.serviceId)}/GPServer${taskSegment}/${suffix}`;
+    }
+}
+const DEFAULT_GP_POLL_INTERVAL_MS = 1_000;
+export class HonuaGeoprocessingJobRun {
+    id;
+    type;
+    client;
+    serviceId;
+    taskName;
+    resultNames;
+    pollIntervalMs;
+    pollFn;
+    resultFn;
+    cancelFn;
+    currentStatus;
+    currentProgress;
+    terminalSnapshot;
+    terminalPromise;
+    listeners = new Set();
+    constructor(options) {
+        this.client = options.client;
+        this.serviceId = options.serviceId;
+        this.taskName = options.taskName;
+        this.id = options.jobId;
+        this.type = options.taskName ? `${options.serviceId}/${options.taskName}` : options.serviceId;
+        this.resultNames = options.resultNames ?? [];
+        this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_GP_POLL_INTERVAL_MS;
+        this.pollFn =
+            options.pollFn ??
+                ((jobId, signal) => new HonuaGeoprocessingService({
+                    client: this.client,
+                    serviceId: this.serviceId,
+                    taskName: this.taskName,
+                }).jobStatus(jobId, { signal }));
+        this.resultFn =
+            options.resultFn ??
+                ((jobId, resultName, signal) => new HonuaGeoprocessingService({
+                    client: this.client,
+                    serviceId: this.serviceId,
+                    taskName: this.taskName,
+                }).jobResult(jobId, resultName, { signal }));
+        this.cancelFn =
+            options.cancelFn ??
+                ((jobId, signal) => new HonuaGeoprocessingService({
+                    client: this.client,
+                    serviceId: this.serviceId,
+                    taskName: this.taskName,
+                }).cancelJob(jobId, { signal }));
+        this.currentStatus = geoprocessingStatusToJobStatus(options.initialJob?.jobStatus);
+        this.currentProgress = progressFromGeoprocessingJob(options.initialJob);
+    }
+    get status() {
+        return this.currentStatus;
+    }
+    get progress() {
+        return this.currentProgress;
+    }
+    async poll() {
+        if (this.terminalSnapshot)
+            return this.terminalSnapshot;
+        const job = await this.pollFn(this.id);
+        return this.handleGeoprocessingJob(job);
+    }
+    watch(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async results(options = {}) {
+        if (!this.terminalPromise) {
+            // Reset the cached promise if the poll loop rejects (abort / deadline /
+            // attempt cap / transient poll error) so a later results() call can retry
+            // rather than being permanently poisoned while the job may still be
+            // running and pollable.
+            this.terminalPromise = this.runUntilTerminal(options).catch((error) => {
+                this.terminalPromise = undefined;
+                throw error;
+            });
+        }
+        return this.terminalPromise;
+    }
+    async cancel() {
+        if (this.terminalSnapshot)
+            return this.currentStatus;
+        const cancelled = await this.cancelFn(this.id);
+        const snapshot = await this.handleGeoprocessingJob(cancelled);
+        return snapshot.status;
+    }
+    async runUntilTerminal(options = {}) {
+        const { signal } = options;
+        const baseIntervalMs = options.pollIntervalMs ?? this.pollIntervalMs;
+        const maxIntervalMs = options.maxPollIntervalMs ?? Math.max(baseIntervalMs, 30_000);
+        const startedAt = Date.now();
+        let attempts = 0;
+        while (!this.terminalSnapshot) {
+            if (signal?.aborted) {
+                throw new HonuaJobPollTimeoutError(`Job ${this.id} poll aborted`, "aborted", this.id, this.currentStatus);
+            }
+            if (options.maxAttempts !== undefined && attempts >= options.maxAttempts) {
+                throw new HonuaJobPollTimeoutError(`Job ${this.id} did not reach a terminal state within ${options.maxAttempts} poll attempt(s)`, "max-attempts", this.id, this.currentStatus);
+            }
+            let job;
+            try {
+                job = await this.pollFn(this.id, signal);
+            }
+            catch (error) {
+                if (signal?.aborted) {
+                    throw new HonuaJobPollTimeoutError(`Job ${this.id} poll aborted`, "aborted", this.id, this.currentStatus);
+                }
+                throw error;
+            }
+            attempts += 1;
+            await this.handleGeoprocessingJob(job);
+            if (this.terminalSnapshot)
+                break;
+            if (options.deadlineMs !== undefined && Date.now() - startedAt >= options.deadlineMs) {
+                throw new HonuaJobPollTimeoutError(`Job ${this.id} did not reach a terminal state within ${options.deadlineMs}ms`, "deadline", this.id, this.currentStatus);
+            }
+            // Capped exponential backoff instead of a fixed interval, matching the
+            // OGC Processes and geospatial-grpc job pollers.
+            const intervalMs = Math.min(maxIntervalMs, baseIntervalMs * 2 ** (attempts - 1));
+            if (intervalMs > 0)
+                await gpDelay(intervalMs, signal);
+        }
+        if (this.terminalSnapshot.status === "successful" && this.terminalSnapshot.result) {
+            return this.terminalSnapshot.result;
+        }
+        const error = this.terminalSnapshot.error;
+        throw new Error(error?.message ?? `GeoServices GP job ended in ${this.terminalSnapshot.status}`);
+    }
+    async handleGeoprocessingJob(job) {
+        const status = geoprocessingStatusToJobStatus(job?.jobStatus);
+        const progress = progressFromGeoprocessingJob(job);
+        this.currentStatus = status;
+        this.currentProgress = progress;
+        if (status === "successful") {
+            const outputs = await this.resolveOutputs(job);
+            const snapshot = {
+                status,
+                progress,
+                result: { outputs },
+            };
+            this.terminalSnapshot = snapshot;
+            this.notify(snapshot);
+            return snapshot;
+        }
+        if (status === "failed" || status === "dismissed") {
+            const error = geoprocessingJobError(status, job);
+            const snapshot = {
+                status,
+                progress,
+                ...(error ? { error } : {}),
+            };
+            this.terminalSnapshot = snapshot;
+            this.notify(snapshot);
+            return snapshot;
+        }
+        const snapshot = { status, progress };
+        this.notify(snapshot);
+        return snapshot;
+    }
+    async resolveOutputs(job) {
+        if (this.resultNames.length === 0) {
+            return (job?.results ?? {});
+        }
+        const outputs = {};
+        for (const resultName of this.resultNames) {
+            outputs[resultName] = (await this.resultFn(this.id, resultName));
+        }
+        return outputs;
+    }
+    notify(snapshot) {
+        for (const listener of this.listeners) {
+            listener(snapshot);
+        }
+    }
+}
+function gpSubmitParams(request) {
+    const params = {};
+    for (const [key, value] of Object.entries(request.parameters)) {
+        params[key] =
+            typeof value === "string" || typeof value === "number" || typeof value === "boolean"
+                ? value
+                : JSON.stringify(value);
+    }
+    Object.assign(params, request.extraParams ?? {});
+    return params;
+}
+function geoprocessingStatusToJobStatus(value) {
+    const normalized = (value ?? "esriJobSubmitted").toLowerCase();
+    if (normalized.includes("succeeded") || normalized === "successful")
+        return "successful";
+    if (normalized.includes("cancelled") || normalized.includes("canceled") || normalized.includes("dismissed")) {
+        return "dismissed";
+    }
+    if (normalized.includes("failed") || normalized.includes("timedout") || normalized.includes("timed out")) {
+        return "failed";
+    }
+    if (normalized.includes("submitted") || normalized.includes("waiting") || normalized.includes("accepted")) {
+        return "accepted";
+    }
+    if (isJobTerminal(normalized))
+        return normalized;
+    return "running";
+}
+function progressFromGeoprocessingJob(job) {
+    if (!job)
+        return undefined;
+    const message = job.messages?.at(-1)?.description;
+    const status = geoprocessingStatusToJobStatus(job.jobStatus);
+    const percent = status === "successful" ? 100 : status === "accepted" ? 5 : status === "running" ? 50 : undefined;
+    if (percent === undefined && message === undefined)
+        return undefined;
+    return { ...(percent !== undefined ? { percent } : {}), ...(message !== undefined ? { message } : {}) };
+}
+function geoprocessingJobError(status, job) {
+    const message = job?.messages?.find((entry) => /error|failed|cancel/i.test(entry.type))?.description ??
+        job?.messages?.at(-1)?.description;
+    if (!message) {
+        return status === "dismissed"
+            ? { code: "GeoServicesJobDismissed", message: "GeoServices GP job was dismissed." }
+            : { code: "GeoServicesJobFailed", message: "GeoServices GP job failed." };
+    }
+    return {
+        code: status === "dismissed" ? "GeoServicesJobDismissed" : "GeoServicesJobFailed",
+        message,
+    };
+}
+function gpDelay(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve();
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function defaultFeatureLayerSourceId(serviceId, layerId) {
+    return `geoservices-feature-service:${serviceId}/${layerId}`;
+}
+function createFeatureServerH3AggregationPlan(request, kRingDistance) {
+    const resolution = request.resolution?.indexResolution;
+    if (resolution === undefined) {
+        throw new Error("FeatureServer queryH3 requires resolution.indexResolution");
+    }
+    const params = {
+        resolution,
+    };
+    if (request.where !== undefined) {
+        params.where = request.where;
+    }
+    const normalizedKRingDistance = normalizeH3KRingDistance(kRingDistance);
+    if (normalizedKRingDistance !== undefined) {
+        params.kRingDistance = normalizedKRingDistance;
+    }
+    const firstSummary = request.summaries[0];
+    const usesServerDefaultCount = request.summaries.length === 1 && firstSummary?.kind === "count" && firstSummary.field === undefined;
+    if (usesServerDefaultCount) {
+        return {
+            params,
+            resolution,
+            summaryBindings: [{ summary: firstSummary, responseField: "count" }],
+        };
+    }
+    const outStatistics = [];
+    const summaryBindings = request.summaries.map((summary, index) => {
+        const responseField = outStatisticFieldName(summary, index);
+        const onStatisticField = statisticInputField(summary);
+        outStatistics.push({
+            statisticType: summary.kind,
+            onStatisticField,
+            outStatisticFieldName: responseField,
+        });
+        return { summary, responseField };
+    });
+    params.outStatistics = JSON.stringify(outStatistics);
+    return {
+        params,
+        resolution,
+        summaryBindings,
+    };
+}
+function featureServerH3AggregationResultFromResponse(response, request, plan) {
+    const cells = extractFeaturesFromResponse(response).map((feature) => featureServerH3CellFromFeature(feature, request, plan));
+    const extent = mergeExtents(cells.map((cell) => cell.extent).filter((value) => value !== undefined));
+    const indexModel = {
+        id: request.index?.modelId ?? FEATURE_SERVER_H3_SPATIAL_AGGREGATION_INDEX_MODEL_ID,
+        title: "FeatureServer indexed cells",
+        family: FEATURE_SERVER_H3_SPATIAL_AGGREGATION_INDEX_MODEL_ID,
+        cellIdEncoding: "string",
+        minResolution: 0,
+        maxResolution: 15,
+        supportedGeometry: ["none", "extent", "boundary"],
+        hierarchy: "parent-child",
+        spatialReference: response.spatialReference ?? extent?.spatialReference ?? { wkid: 4326 },
+    };
+    const summaries = request.summaries.map(spatialAggregationSummaryMetadataFromSpec);
+    const progressive = {
+        status: response.exceededTransferLimit === true ? "partial" : "complete",
+        refinement: response.exceededTransferLimit === true ? "append" : undefined,
+        loadedCellCount: cells.length,
+    };
+    const metadata = {
+        schemaVersion: SPATIAL_AGGREGATION_METADATA_SCHEMA_VERSION,
+        sourceId: request.sourceId,
+        indexModels: [indexModel],
+        summaries,
+        progressive,
+        cache: {
+            metadataCacheable: true,
+            resultCacheable: false,
+            cacheKeyParts: [
+                "geoservices-feature-service",
+                request.sourceId,
+                "queryH3",
+                `resolution=${plan.resolution}`,
+                `where=${request.where ?? ""}`,
+            ],
+        },
+    };
+    return {
+        schemaVersion: SPATIAL_AGGREGATION_SCHEMA_VERSION,
+        requestId: request.requestId,
+        sourceId: request.sourceId,
+        index: {
+            model: indexModel,
+            resolution: plan.resolution,
+            requestedResolution: request.resolution,
+            cellCount: cells.length,
+            extent,
+        },
+        metadata: {
+            ...metadata,
+            widgets: spatialAggregationWidgets(metadata),
+        },
+        cells,
+        page: response.exceededTransferLimit === true
+            ? {
+                loadedCellCount: cells.length,
+            }
+            : undefined,
+        degraded: response.exceededTransferLimit === true
+            ? [
+                {
+                    capability: "spatialAggregate",
+                    protocol: "geoservices-feature-service",
+                    sourceId: request.sourceId,
+                    reason: "FeatureServer queryH3 response exceeded the server transfer limit; returned cells may be partial.",
+                },
+            ]
+            : undefined,
+    };
+}
+function featureServerH3CellFromFeature(feature, request, plan) {
+    const attributes = feature.attributes ?? {};
+    const id = cellIdFromAttributes(attributes);
+    const extent = extentFromGeometry(feature.geometry);
+    const geometryMode = request.index?.geometry ?? "boundary";
+    const cell = {
+        id,
+        resolution: plan.resolution,
+        extent,
+        summaries: spatialAggregationSummariesFromAttributes(attributes, plan),
+    };
+    if (geometryMode === "boundary" && isObject(feature.geometry)) {
+        return {
+            ...cell,
+            geometry: feature.geometry,
+        };
+    }
+    return cell;
+}
+function spatialAggregationSummariesFromAttributes(attributes, plan) {
+    const summaries = {};
+    for (const binding of plan.summaryBindings) {
+        summaries[binding.summary.id] = spatialAggregationSummaryValueFromAttribute(binding.summary, attributes[binding.responseField]);
+    }
+    return summaries;
+}
+function spatialAggregationSummaryValueFromAttribute(summary, value) {
+    if (summary.kind === "count") {
+        return {
+            kind: "count",
+            value: Math.max(0, finiteNumberOr(value, 0)),
+        };
+    }
+    if (summary.kind === "sum" || summary.kind === "avg" || summary.kind === "min" || summary.kind === "max") {
+        return {
+            kind: summary.kind,
+            value: finiteNumberOrNull(value),
+            unit: summary.unit,
+        };
+    }
+    throw new Error(`FeatureServer queryH3 does not support ${summary.kind} summaries.`);
+}
+function spatialAggregationSummaryMetadataFromSpec(summary) {
+    return {
+        id: summary.id,
+        kind: summary.kind,
+        title: summary.title,
+        field: summary.field,
+        valueType: summary.valueType ?? (summary.kind === "count" ? "number" : undefined),
+        unit: summary.unit,
+    };
+}
+function statisticInputField(summary) {
+    if (summary.kind === "count") {
+        if (summary.field === undefined) {
+            throw new Error("count summaries require a field when queryH3 uses outStatistics.");
+        }
+        return summary.field;
+    }
+    if (summary.kind === "sum" || summary.kind === "avg" || summary.kind === "min" || summary.kind === "max") {
+        return summary.field;
+    }
+    throw new Error(`FeatureServer queryH3 does not support ${summary.kind} summaries.`);
+}
+function outStatisticFieldName(summary, index) {
+    const safeId = summary.id.replace(/[^A-Za-z0-9_]/g, "_").replace(/^([^A-Za-z_])/, "_$1");
+    return `honua_${index + 1}_${safeId || "summary"}`.slice(0, 63);
+}
+function normalizeH3KRingDistance(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Number.isInteger(value) || value < 0 || value > 20) {
+        throw new Error("FeatureServer queryH3 kRingDistance must be an integer between 0 and 20.");
+    }
+    return value;
+}
+function cellIdFromAttributes(attributes) {
+    for (const key of ["cellIndex", "cell_index", "h3Index", "h3_index"]) {
+        const value = attributes[key];
+        if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") {
+            return String(value);
+        }
+    }
+    throw new Error("FeatureServer queryH3 response is missing a cellIndex attribute.");
+}
+function extentFromGeometry(geometry) {
+    if (!isObject(geometry)) {
+        return undefined;
+    }
+    if (isFiniteNumber(geometry.xmin) &&
+        isFiniteNumber(geometry.ymin) &&
+        isFiniteNumber(geometry.xmax) &&
+        isFiniteNumber(geometry.ymax)) {
+        return {
+            xmin: geometry.xmin,
+            ymin: geometry.ymin,
+            xmax: geometry.xmax,
+            ymax: geometry.ymax,
+            spatialReference: isObject(geometry.spatialReference)
+                ? geometry.spatialReference
+                : undefined,
+        };
+    }
+    const coordinates = [];
+    collectCoordinatePairs(geometry.rings, coordinates);
+    collectCoordinatePairs(geometry.paths, coordinates);
+    collectCoordinatePairs(geometry.points, coordinates);
+    if (isFiniteNumber(geometry.x) && isFiniteNumber(geometry.y)) {
+        coordinates.push([geometry.x, geometry.y]);
+    }
+    if (coordinates.length === 0) {
+        return undefined;
+    }
+    let xmin = Number.POSITIVE_INFINITY;
+    let ymin = Number.POSITIVE_INFINITY;
+    let xmax = Number.NEGATIVE_INFINITY;
+    let ymax = Number.NEGATIVE_INFINITY;
+    for (const [x, y] of coordinates) {
+        xmin = Math.min(xmin, x);
+        ymin = Math.min(ymin, y);
+        xmax = Math.max(xmax, x);
+        ymax = Math.max(ymax, y);
+    }
+    return {
+        xmin,
+        ymin,
+        xmax,
+        ymax,
+        spatialReference: isObject(geometry.spatialReference)
+            ? geometry.spatialReference
+            : undefined,
+    };
+}
+function collectCoordinatePairs(value, coordinates) {
+    if (!Array.isArray(value)) {
+        return;
+    }
+    if (isFiniteNumber(value[0]) && isFiniteNumber(value[1])) {
+        coordinates.push([value[0], value[1]]);
+        return;
+    }
+    for (const child of value) {
+        collectCoordinatePairs(child, coordinates);
+    }
+}
+function mergeExtents(extents) {
+    if (extents.length === 0) {
+        return undefined;
+    }
+    const [first, ...rest] = extents;
+    return rest.reduce((merged, extent) => ({
+        xmin: Math.min(merged.xmin, extent.xmin),
+        ymin: Math.min(merged.ymin, extent.ymin),
+        xmax: Math.max(merged.xmax, extent.xmax),
+        ymax: Math.max(merged.ymax, extent.ymax),
+        spatialReference: merged.spatialReference ?? extent.spatialReference,
+    }), first);
+}
+function finiteNumberOr(value, fallback) {
+    const numeric = finiteNumberOrNull(value);
+    return numeric ?? fallback;
+}
+function finiteNumberOrNull(value) {
+    if (isFiniteNumber(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function extractFeatureCountFromResponse(response) {
+    if (isObject(response) && typeof response.count === "number" && Number.isFinite(response.count)) {
+        return response.count;
+    }
+    if (isObject(response) && Array.isArray(response.features)) {
+        return response.features.length;
+    }
+    return 0;
+}
+function extractFeaturesFromResponse(response) {
+    if (!isObject(response) || !Array.isArray(response.features)) {
+        return [];
+    }
+    return response.features;
+}
+function extractObjectIdsFromResponse(response) {
+    if (!isObject(response) || !Array.isArray(response.objectIds)) {
+        return [];
+    }
+    return response.objectIds.map((value) => Number(value)).filter((value) => Number.isFinite(value));
+}
+function extractExtentFromResponse(response) {
+    if (!isObject(response)) {
+        return { extent: null };
+    }
+    const count = isFiniteNumber(response.count) ? response.count : undefined;
+    const extent = isObject(response.extent) ? response.extent : null;
+    return { extent, count };
+}
+function normalizeObjectIds(ids) {
+    return Array.isArray(ids) ? ids.join(",") : String(ids);
+}
+function toFormBody(values) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(values)) {
+        params.set(key, String(value));
+    }
+    return params.toString();
+}
+function normalizeLayerPath(path) {
+    return path.startsWith("/") ? path.slice(1) : path;
+}
+function normalizeServicePath(path) {
+    return path.startsWith("/") ? path.slice(1) : path;
+}
+function normalizePageSize(pageSize, limit) {
+    if (isFinitePositiveInteger(pageSize)) {
+        return pageSize;
+    }
+    if (isFinitePositiveInteger(limit)) {
+        return limit;
+    }
+    return 100;
+}
+function normalizeMaxPages(maxPages) {
+    if (isFinitePositiveInteger(maxPages)) {
+        return maxPages;
+    }
+    return 100;
+}
+function normalizeOffset(offset) {
+    if (typeof offset !== "number" || !Number.isFinite(offset)) {
+        return 0;
+    }
+    return Math.max(0, Math.trunc(offset));
+}
+function normalizeTotalLimit(limit) {
+    if (!isFinitePositiveInteger(limit)) {
+        return undefined;
+    }
+    return limit;
+}
+function isFinitePositiveInteger(value) {
+    return typeof value === "number" && Number.isFinite(value) && Math.trunc(value) > 0;
+}
+function buildAttachmentFormData(request) {
+    const form = new FormData();
+    if (request.attachment instanceof Blob) {
+        const blob = ensureBlobType(request.attachment, request.contentType);
+        const fileName = request.name ?? resolveBlobName(request.attachment);
+        form.set("attachment", blob, fileName);
+        return form;
+    }
+    const blob = new Blob([request.attachment], {
+        type: request.contentType ?? "application/octet-stream",
+    });
+    form.set("attachment", blob, request.name ?? "attachment.txt");
+    return form;
+}
+function resolveBlobName(blob) {
+    if ("name" in blob && typeof blob.name === "string" && blob.name.length > 0) {
+        return blob.name;
+    }
+    return "attachment.bin";
+}
+function ensureBlobType(blob, contentType) {
+    if (!contentType || blob.type === contentType) {
+        return blob;
+    }
+    return new Blob([blob], { type: contentType });
+}
+function extractLayerIds(metadata) {
+    if (!isObject(metadata) || !Array.isArray(metadata.layers)) {
+        return [];
+    }
+    const ids = [];
+    for (const layer of metadata.layers) {
+        if (!isObject(layer)) {
+            continue;
+        }
+        const parsed = Number(layer.id);
+        if (!Number.isFinite(parsed)) {
+            continue;
+        }
+        ids.push(Math.trunc(parsed));
+    }
+    return ids;
+}
+function extractOgcFeatures(response) {
+    if (!isObject(response) || !Array.isArray(response.features)) {
+        return [];
+    }
+    return response.features;
+}