@honua/react 0.1.2-beta.0 → 0.1.4-beta.0

package/contract/source.js

@@ -13,19 +13,25 @@
  * @module
  */
 import { HonuaCapabilityNotSupportedError, HonuaHttpError } from "../core/errors.js";
-import { HonuaOdataEntitySet, buildOdataSpatialFilter, odataFieldSchema, rewriteWhereToOdataFilter, } from "../core/odata.js";
+import { esriGeometryToGeoJSON } from "../core/esri-geojson.js";
+import { buildOdataSpatialFilter, geometryToWkt, odataFieldSchema, rewriteWhereToOdataFilter, } from "../core/odata.js";
 import { HonuaOgcCollectionMap, HonuaOgcMaps } from "../core/ogc-maps.js";
 import { HonuaOgcRecordCollection } from "../core/ogc-records.js";
 import { HonuaOgcTiles, HonuaOgcTileset } from "../core/ogc-tiles.js";
-import { trimTrailingSlashes } from "../core/path-utils.js";
 import { HonuaStacStaticCatalog } from "../core/stac-static.js";
 import { HonuaStacSearch } from "../core/stac.js";
 import { HonuaFeatureLayer, HonuaGeometryService, HonuaGeoprocessingService, HonuaImageService, HonuaMapLayer, HonuaMapService, HonuaOgcFeatureCollection, HonuaOgcFeatures, } from "../core/surfaces.js";
-import { UNSUPPORTED_FES, compileSpatialFilter, compileWhere, geoJsonGeometryToGml, serializeFes, } from "../core/wfs-filter.js";
-import { HonuaWfsFeatureType } from "../core/wfs.js";
+import { geoJsonGeometryToGml } from "../core/wfs-filter.js";
+import { executeWmsFeatureInfo, resolveWmsQueryCrs } from "../core/wms-feature-info.js";
 import { HonuaWms, HonuaWmsLayer, parseWmsLayerNames } from "../core/wms.js";
 import { HonuaWmts, HonuaWmtsLayer, HonuaWmtsTileset } from "../core/wmts.js";
+import { createQueryIr } from "../query-planner/ir.js";
+import { createOdataProtocolCompiledQuery, odataProtocolModule, odataProtocolResultFromPage, } from "../query-planner/odata-protocol-module.js";
+import { HonuaQueryPlanningError, } from "../query-planner/types.js";
+import { HonuaWfsProtocolError, assertWfsPageProgress, buildWfsPostGetFeatureBody, checkedWfsPageEnd, wfsProtocolModule, } from "../query-planner/wfs-protocol-module.js";
+import { wfsSpatialFilterNeedsGeometryProperty, wfsSrsNameFromOutSr } from "../query-planner/wfs-v1.js";
 import { pmtilesProtocolModule } from "./pmtiles.js";
+import { andQueryFilters, compileQueryFilterToCql2Text, compileQueryFilterToOData, compileQueryFilterToSql92, compileTemporalFilterToGeoServicesTime, compileTemporalFilterToOgcDatetime, queryFilterConstraints, queryFilterHasSpatial, temporalFilterToExpression, } from "./query-filter.js";
 import { addCapabilitySupport, normalizeCapabilityDescriptor } from "./source-capability-support.js";
 import { CAPABILITIES, PROTOCOL_DEFAULT_CAPABILITIES, } from "./types.js";
 /**
@@ -43,7 +49,7 @@ import { CAPABILITIES, PROTOCOL_DEFAULT_CAPABILITIES, } from "./types.js";
  *
  * Operations the canonical surface does not cover stay reachable through the typed
  * `source.protocol(...)` escape hatch (e.g. ImageServer `exportImage`, GeometryServer
- * `project`, GPServer `submitJob`, WFS `LockFeature`).
+ * `project`, GPServer `submitJob`, WFS `GetPropertyValue`).
  *
  * @param options - The dataset id, the `HonuaClient` to talk to, the list of
  *   `SourceDescriptor`s, and (optionally) `capabilityPolicy` and a custom
@@ -71,7 +77,6 @@ import { CAPABILITIES, PROTOCOL_DEFAULT_CAPABILITIES, } from "./types.js";
  *
  * const parcels = dataset.source("parcels-fs")!;
  * const result = await parcels.queryAll({
- *   where: "STATUS = 'ACTIVE'",
  *   outFields: ["OBJECTID", "NAME"],
  *   returnGeometry: true,
  *   pagination: { limit: 500 },
@@ -81,6 +86,10 @@ import { CAPABILITIES, PROTOCOL_DEFAULT_CAPABILITIES, } from "./types.js";
  * ```
  */
 export function createDataset(options) {
+    return createDatasetWithAdapterSeeds(options);
+}
+/** @internal Reuse metadata already reviewed by top-level connect() adapters. */
+export function createDatasetWithAdapterSeeds(options, seeds = {}) {
     const { id, client, sources, resolveSource } = options;
     const policy = options.capabilityPolicy ?? "strict";
     const descriptors = new Map();
@@ -97,7 +106,7 @@ export function createDataset(options) {
         const cached = handles.get(descriptor.id);
         if (cached)
             return cached;
-        const builtIn = buildBuiltInSource(descriptor, client, policy);
+        const builtIn = buildBuiltInSource(descriptor, client, policy, seeds);
         const built = builtIn ?? resolveSource?.(descriptor, { client, capabilityPolicy: policy });
         if (!built) {
             throw new HonuaCapabilityNotSupportedError("query", descriptor.protocol, descriptor.id);
@@ -136,7 +145,7 @@ export function createDataset(options) {
     };
 }
 // ── Built-in resolver ─────────────────────────────────────────
-function buildBuiltInSource(descriptor, client, policy) {
+function buildBuiltInSource(descriptor, client, policy, seeds) {
     switch (descriptor.protocol) {
         case "grpc":
             // Honua gRPC is a transport-selectable fast path over the same
@@ -176,7 +185,11 @@ function buildBuiltInSource(descriptor, client, policy) {
         case "odata":
             return odataSource(descriptor, client, policy);
         case "pmtiles":
-            return pmtilesSource(descriptor, client, policy);
+            return pmtilesSource(descriptor, client, policy, {
+                ...(seeds.pmtilesDescriptions?.get(descriptor.id)
+                    ? { preloadedDescription: seeds.pmtilesDescriptions.get(descriptor.id) }
+                    : {}),
+            });
         default:
             return undefined;
     }
@@ -202,8 +215,8 @@ function buildBuiltInSource(descriptor, client, policy) {
  *   }],
  * });
  * const result = await dataset.source("parcels-fs")!.queryAll({
- *   where: "STATUS = 'ACTIVE'",
  *   outFields: ["OBJECTID", "NAME"],
+ *   pagination: { limit: 500 },
  * });
  * ```
  */
@@ -224,7 +237,7 @@ export function geoServicesFeatureSource(descriptor, client, policy) {
     return makeSource(descriptor, caps, policy, adapterRegistry, {
         async query(request) {
             ensureCapability(descriptor, caps, "query");
-            const requestParams = toFeatureLayerRequest(request);
+            const requestParams = toFeatureLayerRequest(request, descriptor);
             if (request?.aggregation) {
                 ensureCapability(descriptor, caps, "queryAggregate");
                 const { aggregateAlias, ...aggFields } = buildAggregationFields(request.aggregation);
@@ -235,7 +248,7 @@ export function geoServicesFeatureSource(descriptor, client, policy) {
         },
         async queryAll(request) {
             ensureCapability(descriptor, caps, "query");
-            const params = withPagingBounds(toFeatureLayerRequest(request), request?.pagination?.limit);
+            const params = withPagingBounds(toFeatureLayerRequest(request, descriptor), request?.pagination?.limit);
             const features = await layer.queryFeaturesAll(params);
             const { features: limited, exceededTransferLimit } = applyQueryAllLimit(features, request?.pagination?.limit);
             return {
@@ -246,19 +259,19 @@ export function geoServicesFeatureSource(descriptor, client, policy) {
         },
         async queryAggregate(request) {
             ensureCapability(descriptor, caps, "queryAggregate");
-            const requestParams = toFeatureLayerRequest(request);
+            const requestParams = toFeatureLayerRequest(request, descriptor);
             const { aggregateAlias, ...aggFields } = buildAggregationFields(request.aggregation);
             const response = await layer.queryFeatures({ ...requestParams, ...aggFields });
             return aggregateResultFromFeatureLayer(response, aggregateAlias);
         },
         async queryExtent(request) {
             ensureCapability(descriptor, caps, "queryExtent");
-            const response = await layer.queryFeatures(toExtentOnlyRequest(toFeatureLayerRequest(request)));
+            const response = await layer.queryFeatures(toExtentOnlyRequest(toFeatureLayerRequest(request, descriptor)));
             return extractExtentEnvelope(response);
         },
         async *stream(request) {
             ensureCapability(descriptor, caps, "stream");
-            const stream = layer.queryFeaturesStream(withStreamPageSize(toFeatureLayerRequest(request), request?.pagination?.limit));
+            const stream = layer.queryFeaturesStream(withStreamPageSize(toFeatureLayerRequest(request, descriptor), request?.pagination?.limit));
             for await (const page of stream) {
                 yield {
                     features: page,
@@ -268,7 +281,7 @@ export function geoServicesFeatureSource(descriptor, client, policy) {
         },
         async queryObjectIds(request) {
             ensureCapability(descriptor, caps, "queryObjectIds");
-            return layer.queryObjectIds(toFeatureLayerRequest(request));
+            return layer.queryObjectIds(toFeatureLayerRequest(request, descriptor));
         },
         async applyEdits(envelope) {
             ensureCapability(descriptor, caps, "applyEdits");
@@ -318,7 +331,7 @@ export function geoServicesMapServiceSource(descriptor, client, policy) {
     return makeSource(descriptor, caps, policy, adapterRegistry, {
         async query(request) {
             ensureCapability(descriptor, caps, "query");
-            const params = toFeatureLayerRequest(request);
+            const params = toFeatureLayerRequest(request, descriptor);
             if (request?.aggregation) {
                 ensureCapability(descriptor, caps, "queryAggregate");
                 const { aggregateAlias, ...aggFields } = buildAggregationFields(request.aggregation);
@@ -329,7 +342,7 @@ export function geoServicesMapServiceSource(descriptor, client, policy) {
         },
         async queryAll(request) {
             ensureCapability(descriptor, caps, "query");
-            const params = withPagingBounds(toFeatureLayerRequest(request), request?.pagination?.limit);
+            const params = withPagingBounds(toFeatureLayerRequest(request, descriptor), request?.pagination?.limit);
             const features = await layer.queryFeaturesAll(params);
             const typed = features.map((toTypedFeature));
             const { features: limited, exceededTransferLimit } = applyQueryAllLimit(typed, request?.pagination?.limit);
@@ -341,19 +354,19 @@ export function geoServicesMapServiceSource(descriptor, client, policy) {
         },
         async queryAggregate(request) {
             ensureCapability(descriptor, caps, "queryAggregate");
-            const params = toFeatureLayerRequest(request);
+            const params = toFeatureLayerRequest(request, descriptor);
             const { aggregateAlias, ...aggFields } = buildAggregationFields(request.aggregation);
             const response = await layer.queryFeatures({ ...params, ...aggFields });
             return aggregateResultFromUntyped(response, aggregateAlias);
         },
         async queryExtent(request) {
             ensureCapability(descriptor, caps, "queryExtent");
-            const response = await layer.queryFeatures(toExtentOnlyRequest(toFeatureLayerRequest(request)));
+            const response = await layer.queryFeatures(toExtentOnlyRequest(toFeatureLayerRequest(request, descriptor)));
             return extractExtentEnvelope(response);
         },
         async *stream(request) {
             ensureCapability(descriptor, caps, "stream");
-            const stream = layer.queryFeaturesStream(withStreamPageSize(toFeatureLayerRequest(request), request?.pagination?.limit));
+            const stream = layer.queryFeaturesStream(withStreamPageSize(toFeatureLayerRequest(request, descriptor), request?.pagination?.limit));
             for await (const page of stream) {
                 yield {
                     features: page.map((toTypedFeature)),
@@ -363,7 +376,7 @@ export function geoServicesMapServiceSource(descriptor, client, policy) {
         },
         async queryObjectIds(request) {
             ensureCapability(descriptor, caps, "queryObjectIds");
-            return layer.queryObjectIds(toFeatureLayerRequest(request));
+            return layer.queryObjectIds(toFeatureLayerRequest(request, descriptor));
         },
         async applyEdits() {
             // MapServer is read-only; applyEdits exists only on the FeatureServer
@@ -395,7 +408,6 @@ export function geoServicesMapServiceSource(descriptor, client, policy) {
  *   }],
  * });
  * const result = await dataset.source("addresses-ogc")!.queryAll({
- *   where: "city = 'Honolulu'",
  *   pagination: { limit: 200 },
  * });
  * ```
@@ -424,7 +436,7 @@ export function ogcFeaturesSource(descriptor, client, policy) {
                 // degradable capability here.
                 ensureCapabilityOrFallback(descriptor, caps, "queryAggregate", policy);
             }
-            const response = await collection.items(toOgcRequest(request));
+            const response = await collection.items(toOgcRequest(request, descriptor));
             const features = response.features.map((toTypedFeatureFromOgc));
             const totalCount = response.numberMatched;
             const degraded = [];
@@ -460,7 +472,7 @@ export function ogcFeaturesSource(descriptor, client, policy) {
             // exist. Mirrors the GeoServices `withPagingBounds` + `applyQueryAllLimit`
             // pattern so `queryAll({ pagination: { limit } })` has the same
             // contract across protocols.
-            const ogcRequest = toOgcRequest(request);
+            const ogcRequest = toOgcRequest(request, descriptor);
             if (typeof limit === "number" && Number.isFinite(limit) && limit >= 0) {
                 ogcRequest.limit = limit + 1;
             }
@@ -478,7 +490,7 @@ export function ogcFeaturesSource(descriptor, client, policy) {
             // the descriptor must advertise `queryAggregate`; under `degraded` the
             // fallback runs unconditionally.
             ensureCapabilityOrFallback(descriptor, caps, "queryAggregate", policy);
-            const all = await collection.itemsAll(withUnboundedMaxPages(toOgcMaterializedRequest(request)));
+            const all = await collection.itemsAll(withUnboundedMaxPages(toOgcMaterializedRequest(request, descriptor)));
             const features = all.map((toTypedFeatureFromOgc));
             return {
                 features,
@@ -512,12 +524,12 @@ export function ogcFeaturesSource(descriptor, client, policy) {
                 const [xmin, ymin, xmax, ymax] = bbox;
                 return { extent: { xmin, ymin, xmax, ymax } };
             }
-            const all = await collection.itemsAll(withUnboundedMaxPages(toOgcMaterializedRequest(request)));
+            const all = await collection.itemsAll(withUnboundedMaxPages(toOgcMaterializedRequest(request, descriptor)));
             return computeExtentFromOgcFeatures(all);
         },
         async *stream(request) {
             ensureCapability(descriptor, caps, "stream");
-            const stream = collection.itemsStream(withUnboundedMaxPages(toOgcRequest(request)));
+            const stream = collection.itemsStream(withUnboundedMaxPages(toOgcRequest(request, descriptor)));
             for await (const page of stream) {
                 yield {
                     features: page.map((toTypedFeatureFromOgc)),
@@ -530,7 +542,7 @@ export function ogcFeaturesSource(descriptor, client, policy) {
             // OGC `/items` does not expose a server-side ids-only mode; drain the
             // matching set and project the GeoJSON `id`. Callers that need a
             // bounded scan should pass `pagination.limit`.
-            const all = await collection.itemsAll(withUnboundedMaxPages(toOgcRequest(request)));
+            const all = await collection.itemsAll(withUnboundedMaxPages(toOgcRequest(request, descriptor)));
             const ids = [];
             for (const feature of all) {
                 if (feature.id !== undefined && feature.id !== null) {
@@ -635,13 +647,13 @@ export function geoServicesImageSource(descriptor, client, policy) {
             // ImageServer query returns the raster catalog. The GeoServices
             // request shape is identical to FeatureServer query so we reuse
             // `toFeatureLayerRequest` and dispatch through the service.
-            const response = await service.queryRasterCatalog(toFeatureLayerRequest(request));
+            const response = await service.queryRasterCatalog(toFeatureLayerRequest(request, descriptor));
             return featureLayerResultFromUntyped(response);
         },
         async queryAll(request) {
             ensureCapability(descriptor, caps, "query");
             requireImageServerCompatibleQuery(request);
-            const baseParams = toFeatureLayerRequest(request);
+            const baseParams = toFeatureLayerRequest(request, descriptor);
             const limit = request?.pagination?.limit;
             // ImageServer's catalog endpoint supports `resultOffset`/`resultRecordCount`
             // but the wrapper does not expose a `queryAllRasterCatalog` helper, so
@@ -691,7 +703,7 @@ export function geoServicesImageSource(descriptor, client, policy) {
         async queryExtent(request) {
             ensureCapability(descriptor, caps, "queryExtent");
             requireImageServerCompatibleQuery(request);
-            const response = await service.queryRasterCatalog(toExtentOnlyRequest(toFeatureLayerRequest(request)));
+            const response = await service.queryRasterCatalog(toExtentOnlyRequest(toFeatureLayerRequest(request, descriptor)));
             return extractExtentEnvelope(response);
         },
         // biome-ignore lint/correctness/useYield: ImageServer has no streaming raster-catalog mode; this generator refuses iteration rather than silently emit a single page
@@ -701,7 +713,7 @@ export function geoServicesImageSource(descriptor, client, policy) {
         async queryObjectIds(request) {
             ensureCapability(descriptor, caps, "queryObjectIds");
             requireImageServerCompatibleQuery(request);
-            return service.queryRasterCatalogObjectIds(toFeatureLayerRequest(request));
+            return service.queryRasterCatalogObjectIds(toFeatureLayerRequest(request, descriptor));
         },
         async applyEdits() {
             throw new HonuaCapabilityNotSupportedError("applyEdits", descriptor.protocol, descriptor.id);
@@ -828,9 +840,9 @@ export function ogcTilesSource(descriptor, client, policy) {
  * console.log(info.bounds, info.vectorLayers.map((layer) => layer.id));
  * ```
  */
-export function pmtilesSource(descriptor, _client, policy) {
+export function pmtilesSource(descriptor, _client, policy, deps = {}) {
     descriptor = normalizeCapabilityDescriptor(descriptor);
-    const discovered = pmtilesProtocolModule().discover(descriptor);
+    const discovered = pmtilesProtocolModule(deps).discover(descriptor);
     if (discovered instanceof Promise) {
         // PMTiles discovery is always synchronous (the reader opens lazily on the
         // handle's own first `describe()` call); a module that started returning
@@ -886,7 +898,7 @@ export function ogcMapsSource(descriptor, client, policy) {
  * @example
  * ```ts
  * const records = dataset.source("catalog")!;
- * const result = await records.query({ where: "type = 'dataset' AND q = 'parcels'" });
+ * const result = await records.query({ pagination: { limit: 100 } });
  * ```
  */
 export function ogcRecordsSource(descriptor, client, policy) {
@@ -908,7 +920,7 @@ export function ogcRecordsSource(descriptor, client, policy) {
             if (request?.aggregation) {
                 throw new HonuaCapabilityNotSupportedError("queryAggregate", descriptor.protocol, descriptor.id);
             }
-            const response = await collection.search(toOgcRecordsRequest(request));
+            const response = await collection.search(toOgcRecordsRequest(request, descriptor));
             const features = (response.features ?? []).map((toTypedFeatureFromOgcRecord));
             const totalCount = response.numberMatched;
             return {
@@ -921,7 +933,7 @@ export function ogcRecordsSource(descriptor, client, policy) {
             ensureCapability(descriptor, caps, "query");
             const limit = request?.pagination?.limit;
             const records = await collection.searchAll({
-                ...toOgcRecordsRequest(request),
+                ...toOgcRecordsRequest(request, descriptor),
                 ...withPagingBounds({}, limit),
             });
             const typed = records.map((toTypedFeatureFromOgcRecord));
@@ -942,7 +954,7 @@ export function ogcRecordsSource(descriptor, client, policy) {
             ensureCapability(descriptor, caps, "stream");
             const limit = request?.pagination?.limit;
             const stream = collection.searchStream({
-                ...toOgcRecordsRequest(request),
+                ...toOgcRecordsRequest(request, descriptor),
                 pageSize: limit !== undefined ? Math.max(1, limit) : undefined,
                 maxPages: Number.MAX_SAFE_INTEGER,
             });
@@ -957,7 +969,7 @@ export function ogcRecordsSource(descriptor, client, policy) {
             ensureCapability(descriptor, caps, "queryObjectIds");
             const limit = request?.pagination?.limit;
             const records = await collection.searchAll({
-                ...toOgcRecordsRequest(request),
+                ...toOgcRecordsRequest(request, descriptor),
                 ...withPagingBounds({}, limit),
             });
             const ids = [];
@@ -1012,14 +1024,21 @@ export function wmsSource(descriptor, client, policy) {
     descriptor = normalizeCapabilityDescriptor(descriptor);
     const advertisedCaps = descriptor.capabilities ?? PROTOCOL_DEFAULT_CAPABILITIES.wms;
     if (typeof descriptor.locator.serviceId !== "string" || descriptor.locator.serviceId.length === 0) {
-        if (descriptor.locator.raster?.kind !== "wms-kvp")
+        const featureInfoBinding = descriptor.locator.featureInfo;
+        if (descriptor.locator.raster?.kind !== "wms-kvp" && featureInfoBinding?.kind !== "wms-kvp") {
             requireWmsLocator(descriptor);
+        }
         // Raw third-party discovery is renderable through the existing descriptor
-        // → MapLibre raster projection. The existing canonical FeatureInfo adapter
-        // is Honua-service-id based, so keep that surface fail-closed here.
-        const caps = new Set([...advertisedCaps].filter((capability) => capability !== "query"));
-        descriptor = { ...descriptor, capabilities: caps };
-        return makeSource(descriptor, caps, policy, {}, unsupportedFeatureSurface(descriptor));
+        // → MapLibre raster projection, and queryable whenever discovery reviewed a
+        // GetFeatureInfo operation (queryable layer + projectable INFO_FORMAT +
+        // provable CRS axis order). Without that binding the query surface stays
+        // fail-closed.
+        if (featureInfoBinding?.kind !== "wms-kvp" || !advertisedCaps.has("query")) {
+            const caps = new Set([...advertisedCaps].filter((capability) => capability !== "query"));
+            descriptor = { ...descriptor, capabilities: caps };
+            return makeSource(descriptor, caps, policy, {}, unsupportedFeatureSurface(descriptor));
+        }
+        return standaloneWmsSource({ ...descriptor, capabilities: advertisedCaps }, featureInfoBinding, client, policy, advertisedCaps);
     }
     const { serviceId } = requireWmsLocator(descriptor);
     const layerName = descriptor.locator.typeName;
@@ -1049,24 +1068,11 @@ export function wmsSource(descriptor, client, policy) {
             ensureCapability(descriptor, caps, "query");
             requireWmsCompatibleQuery(descriptor, request);
             const layers = wmsRequireLayers(descriptor, layerName);
-            const { x: px, y: py, crs } = wmsExtractPointFromQuery(request, descriptor);
-            const bboxRadius = 0.0001; // tiny envelope around the point keeps the request a 1×1 image.
-            const widthHeight = 1;
-            const featureCount = request?.pagination?.limit;
+            const point = wmsExtractPointFromQuery(request, descriptor);
             const response = await client.getWmsFeatureInfo({
                 serviceId,
-                layers,
-                ...(styleId !== undefined ? { styles: [styleId] } : {}),
-                queryLayers: layers,
-                crs,
-                bbox: [px - bboxRadius, py - bboxRadius, px + bboxRadius, py + bboxRadius],
-                width: widthHeight,
-                height: widthHeight,
-                i: 0,
-                j: 0,
+                ...wmsPointFeatureInfoRequest({ layers, styleId, crs: point.crs, x: point.x, y: point.y, request }),
                 infoFormat: "application/json",
-                ...(featureCount !== undefined ? { featureCount } : {}),
-                ...(request?.signal ? { signal: request.signal } : {}),
             });
             return {
                 features: response.features ?? [],
@@ -1102,6 +1108,97 @@ export function wmsSource(descriptor, client, policy) {
         attachments: unsupportedAttachmentApi(descriptor),
     });
 }
+/**
+ * Radius of the envelope drawn around the queried point. WMS has no point
+ * request: `GetFeatureInfo` addresses a pixel inside a rendered image, so the
+ * canonical point query renders a 1×1 image whose BBOX is this tiny envelope
+ * and reads pixel (0, 0).
+ */
+const WMS_FEATURE_INFO_POINT_RADIUS = 0.0001;
+/**
+ * Build the shared `GetFeatureInfo` envelope for a canonical point query. Both
+ * the Honua service-id path and the capabilities-driven third-party path use
+ * it, so LAYERS / QUERY_LAYERS / STYLES / BBOX / WIDTH / HEIGHT / I / J /
+ * FEATURE_COUNT are derived once.
+ */
+function wmsPointFeatureInfoRequest(options) {
+    const radius = WMS_FEATURE_INFO_POINT_RADIUS;
+    const featureCount = options.request?.pagination?.limit;
+    const signal = options.request?.signal;
+    return {
+        layers: [...options.layers],
+        ...(options.styleId !== undefined ? { styles: [options.styleId] } : {}),
+        queryLayers: [...options.layers],
+        crs: options.crs,
+        bbox: [options.x - radius, options.y - radius, options.x + radius, options.y + radius],
+        width: 1,
+        height: 1,
+        i: 0,
+        j: 0,
+        ...(featureCount !== undefined ? { featureCount } : {}),
+        ...(signal ? { signal } : {}),
+    };
+}
+/**
+ * `Source` adapter for a third-party WMS 1.3.0 endpoint that `connect()`
+ * reviewed a `GetFeatureInfo` binding for. Canonical `Source.query()` issues
+ * the point request against the capabilities-advertised operation URL under the
+ * same same-origin, credential-free policy discovery applied to `GetMap`.
+ *
+ * The raw `Source.protocol("wms")` handles stay unavailable here: they are
+ * Honua-service-id bound. Render/tiles continue to flow through the descriptor
+ * → MapLibre raster projection.
+ */
+function standaloneWmsSource(descriptor, binding, client, policy, caps) {
+    const layerName = descriptor.locator.typeName;
+    const styleId = descriptor.locator.styleId;
+    const runQuery = async (request) => {
+        ensureCapability(descriptor, caps, "query");
+        requireWmsCompatibleQuery(descriptor, request);
+        const layers = wmsRequireLayers(descriptor, layerName);
+        const point = wmsExtractPointFromQuery(request, descriptor);
+        const crs = resolveWmsQueryCrs(binding.crs, point.crs);
+        if (crs === undefined) {
+            throw new HonuaCapabilityNotSupportedError("query", descriptor.protocol, `${descriptor.id} (GetFeatureInfo CRS "${point.crs}" is not one of the layer's reviewed CRS identifiers: ${binding.crs.join(", ")})`);
+        }
+        const features = await executeWmsFeatureInfo(client, {
+            binding: { url: binding.url, format: binding.format },
+            request: wmsPointFeatureInfoRequest({ layers, styleId, crs, x: point.x, y: point.y, request }),
+            sourceId: descriptor.id,
+        });
+        return { features, exceededTransferLimit: false };
+    };
+    return makeSource(descriptor, caps, policy, {}, {
+        async query(request) {
+            return runQuery(request);
+        },
+        async queryAll(request) {
+            // GetFeatureInfo returns a single response set; queryAll degenerates to
+            // query() because there is no paging on the wire.
+            return runQuery(request);
+        },
+        async queryAggregate() {
+            throw new HonuaCapabilityNotSupportedError("queryAggregate", descriptor.protocol, descriptor.id);
+        },
+        async queryExtent() {
+            throw new HonuaCapabilityNotSupportedError("queryExtent", descriptor.protocol, descriptor.id);
+        },
+        // biome-ignore lint/correctness/useYield: WMS exposes only single-shot GetFeatureInfo, which is delivered through query()
+        async *stream() {
+            throw new HonuaCapabilityNotSupportedError("stream", descriptor.protocol, descriptor.id);
+        },
+        async queryObjectIds() {
+            throw new HonuaCapabilityNotSupportedError("queryObjectIds", descriptor.protocol, descriptor.id);
+        },
+        async applyEdits() {
+            throw new HonuaCapabilityNotSupportedError("applyEdits", descriptor.protocol, descriptor.id);
+        },
+        async queryRelated() {
+            throw new HonuaCapabilityNotSupportedError("queryRelated", descriptor.protocol, descriptor.id);
+        },
+        attachments: unsupportedAttachmentApi(descriptor),
+    });
+}
 // ── WMTS 1.0 ──────────────────────────────────────────────────
 /**
  * Render-only `Source` adapter for first-party WMTS 1.0.0 services.
@@ -1159,10 +1256,14 @@ export function wmtsSource(descriptor, client, policy) {
 /**
  * Adapter factory for a STAC API search endpoint.
  *
- * The canonical `Source.query()` runs a `POST /search` against the STAC root,
- * with `Query.spatialFilter` (e.g. an `envelope(...)` bounding box) and
- * `Query.where` translated into STAC's `bbox` / `datetime` / `filter`
- * parameters.
+ * The canonical `Source.query()` runs a search against the STAC root, using
+ * `POST /search` when the landing page advertises a `rel="search"` link with
+ * `method: "POST"` (long CQL2 filters and `intersects` geometries overflow GET
+ * URL limits) and falling back to the universally supported `GET /search`
+ * otherwise. `Query.spatialFilter` translates to STAC's `bbox` for an
+ * `envelope(...)` and to `intersects` for any other GeoJSON-convertible
+ * geometry. The deprecated source-native `Query.where` migration member maps
+ * to STAC `datetime` / `filter` parameters.
  *
  * @example
  * ```ts
@@ -1179,8 +1280,8 @@ export function wmtsSource(descriptor, client, policy) {
  *   }],
  * });
  * const result = await dataset.source("stac-search")!.query({
- *   where: "collections IN ('landsat-c2-l2')",
  *   spatialFilter: envelope(-158.5, 21.2, -157.6, 21.7),
+ *   pagination: { limit: 100 },
  * });
  * ```
  */
@@ -1201,13 +1302,24 @@ export function stacSearchSource(descriptor, client, policy) {
     const adapterRegistry = {
         stac,
     };
+    /**
+     * Build the wire search request, negotiating the HTTP method once per
+     * source: `POST /search` when the API advertises it, `GET /search`
+     * otherwise. A static catalog has no search endpoint, so it never probes.
+     */
+    const toNegotiatedStacRequest = async (request) => {
+        const stacRequest = toStacRequest(request, collectionScope, descriptor);
+        if (!staticCatalog && (await stac.supportsPostSearch()))
+            stacRequest.usePost = true;
+        return stacRequest;
+    };
     return makeSource(descriptor, caps, policy, adapterRegistry, {
         async query(request) {
             ensureCapability(descriptor, caps, "query");
             if (request?.aggregation) {
                 throw new HonuaCapabilityNotSupportedError("queryAggregate", descriptor.protocol, descriptor.id);
             }
-            const stacRequest = toStacRequest(request, collectionScope);
+            const stacRequest = await toNegotiatedStacRequest(request);
             const response = staticCatalog
                 ? await staticCatalog.search(toStacStaticParams(stacRequest))
                 : await stac.search(stacRequest);
@@ -1224,13 +1336,13 @@ export function stacSearchSource(descriptor, client, policy) {
             ensureCapability(descriptor, caps, "query");
             const limit = request?.pagination?.limit;
             if (staticCatalog) {
-                const response = await staticCatalog.search(toStacStaticParams(toStacRequest(request, collectionScope)));
+                const response = await staticCatalog.search(toStacStaticParams(toStacRequest(request, collectionScope, descriptor)));
                 const typed = (response.features ?? []).map((toTypedFeatureFromStac));
                 const { features, exceededTransferLimit } = applyQueryAllLimit(typed, limit);
                 return { features, exceededTransferLimit, totalCount: features.length };
             }
             const items = await stac.searchAll({
-                ...toStacRequest(request, collectionScope),
+                ...(await toNegotiatedStacRequest(request)),
                 ...withPagingBounds({}, limit),
             });
             const typed = items.map((toTypedFeatureFromStac));
@@ -1253,7 +1365,7 @@ export function stacSearchSource(descriptor, client, policy) {
             if (staticCatalog) {
                 // A static catalog has no server-side paging; yield the whole
                 // filtered set as one page.
-                const response = await staticCatalog.search(toStacStaticParams(toStacRequest(request, collectionScope)));
+                const response = await staticCatalog.search(toStacStaticParams(toStacRequest(request, collectionScope, descriptor)));
                 yield {
                     features: (response.features ?? []).map((toTypedFeatureFromStac)),
                     exceededTransferLimit: false,
@@ -1261,7 +1373,7 @@ export function stacSearchSource(descriptor, client, policy) {
                 return;
             }
             const stream = stac.searchStream({
-                ...toStacRequest(request, collectionScope),
+                ...(await toNegotiatedStacRequest(request)),
                 pageSize: limit !== undefined ? Math.max(1, limit) : undefined,
                 maxPages: Number.MAX_SAFE_INTEGER,
             });
@@ -1280,9 +1392,10 @@ export function stacSearchSource(descriptor, client, policy) {
             // fetches at most `limit + 1` rows, never a full-catalog scan.
             const limit = request?.pagination?.limit;
             const items = staticCatalog
-                ? ((await staticCatalog.search(toStacStaticParams(toStacRequest(request, collectionScope)))).features ?? [])
+                ? ((await staticCatalog.search(toStacStaticParams(toStacRequest(request, collectionScope, descriptor))))
+                    .features ?? [])
                 : await stac.searchAll({
-                    ...toStacRequest(request, collectionScope),
+                    ...(await toNegotiatedStacRequest(request)),
                     ...withPagingBounds({}, limit),
                 });
             const ids = [];
@@ -1306,22 +1419,28 @@ export function stacSearchSource(descriptor, client, policy) {
     });
 }
 // ── WFS 2.0 ───────────────────────────────────────────────────
-/**
- * Threshold above which the WFS adapter switches to POST GetFeature with a
- * `<fes:Filter>` body. URL budget under 7000 chars stays GET-friendly; longer
- * filters are routed through POST so we do not stress middleboxes that
- * trim long query strings. The threshold is intentionally a single
- * constant we can revise after telemetry lands.
- */
-const WFS_GET_FILTER_BUDGET = 7000;
-const DEFAULT_WFS_GEOMETRY_PROPERTY = "the_geom";
 /**
  * Adapter factory for a WFS 2.0 endpoint.
  *
- * `Query.where` and `Query.spatialFilter` compile to FES 2.0; GeoJSON is
- * preferred over GML via `OperationsMetadata` negotiation. `applyEdits()`
- * builds `<wfs:Transaction>` bodies. Reach `Source.protocol("wfs")` for raw
- * GML / `LockFeature` / stored-query access.
+ * `Query.spatialFilter` and the deprecated source-native `Query.where`
+ * migration member compile to FES 2.0; GeoJSON is preferred over GML via
+ * `OperationsMetadata` negotiation. `applyEdits()` builds
+ * `<wfs:Transaction>` bodies. Reach `Source.protocol("wfs")` for raw GML,
+ * custom FES filters, `GetPropertyValue`, raw `<wfs:Transaction>` bodies, and
+ * stored queries.
+ *
+ * Locking (`LockFeature` / `GetFeatureWithLock`) has no typed helper anywhere in
+ * the SDK. Callers that need locks must send their own request XML through
+ * `Source.protocol("wfs")!.root.requestText(...)` and parse the response
+ * themselves; no lock id is extracted and no lock state is tracked.
+ *
+ * FES spatial predicates and transaction geometry name the feature type's
+ * geometry property, which is server-specific (`the_geom` on
+ * PostGIS-via-GeoServer, `msGeometry` on MapServer, arbitrary per-schema names
+ * elsewhere). The adapter resolves it from `DescribeFeatureType` on first use
+ * and caches it; `locator.geometryName` pins it explicitly. Resolution failure
+ * fails closed rather than guessing a default that would silently match
+ * nothing.
  *
  * @example
  * ```ts
@@ -1336,17 +1455,21 @@ const DEFAULT_WFS_GEOMETRY_PROPERTY = "the_geom";
  *   }],
  * });
  * const result = await dataset.source("parcels")!.queryAll({
- *   where: "STATUS = 'ACTIVE'",
  *   pagination: { limit: 500 },
  * });
  * ```
  */
 export function wfsSource(descriptor, client, policy) {
     descriptor = normalizeCapabilityDescriptor(descriptor);
-    const { url, typeName, featureNamespace, srsName: wfsSrsName } = requireWfsLocator(descriptor);
-    const root = client.wfs(url);
-    const featureType = new HonuaWfsFeatureType({ root, typeName });
-    const caps = descriptor.capabilities ?? PROTOCOL_DEFAULT_CAPABILITIES.wfs;
+    const { typeName, featureNamespace, srsName: wfsSrsName, geometryName } = requireWfsLocator(descriptor);
+    const module = wfsProtocolModule(client);
+    const discovered = module.discover(descriptor);
+    if (discovered instanceof Promise) {
+        throw new Error("wfs: built-in source construction requires synchronous protocol-module discovery");
+    }
+    const featureType = discovered.adapter;
+    const root = featureType.root;
+    const caps = discovered.capabilities;
     void policy;
     const adapterRegistry = {
         wfs: featureType,
@@ -1371,6 +1494,65 @@ export function wfsSource(descriptor, client, policy) {
         cachedFormat = choice;
         return choice;
     }
+    /**
+     * Geometry property of this feature type, from `locator.geometryName` or —
+     * once, lazily — from `DescribeFeatureType`. Throws
+     * `HonuaWfsProtocolError("unresolved-geometry-property")` when neither
+     * names it, so a spatial filter or transaction never targets a guessed
+     * property that silently matches nothing.
+     */
+    async function resolveGeometryProperty(signal) {
+        if (geometryName !== undefined)
+            return geometryName;
+        return featureType.geometryPropertyName(signal ? { signal } : undefined);
+    }
+    /**
+     * Descriptor whose locator carries the resolved geometry property, so the
+     * compiler emits it on every reference in the request it plans.
+     */
+    let geometryResolvedDescriptor;
+    async function geometryBoundDescriptor(signal) {
+        if (geometryName !== undefined)
+            return descriptor;
+        if (!geometryResolvedDescriptor) {
+            const resolved = await resolveGeometryProperty(signal);
+            geometryResolvedDescriptor = { ...descriptor, locator: { ...descriptor.locator, geometryName: resolved } };
+        }
+        return geometryResolvedDescriptor;
+    }
+    async function compileSourceQuery(request, operation) {
+        try {
+            const normalizedRequest = normalizeWfsModuleQuery(request);
+            const buildIr = (source) => normalizedRequest === undefined
+                ? createQueryIr({ descriptor: source })
+                : createQueryIr({ descriptor: source, query: normalizedRequest });
+            // The legacy WFS Source accepted an explicitly empty `where`. Preserve
+            // its wire distinction from an omitted `where`: with a spatial filter,
+            // the former takes the FES path while the latter may use the bbox KVP.
+            const canonicalQuery = (ir) => request?.where === ""
+                ? Object.freeze({
+                    ...ir.query,
+                    where: Object.freeze({ kind: "source-native", expression: "" }),
+                })
+                : ir.query;
+            let ir = buildIr(descriptor);
+            let query = canonicalQuery(ir);
+            // Only an FES spatial predicate names the geometry property on the wire;
+            // the `bbox=` shortcut addresses the default geometry positionally. Pay
+            // for schema resolution exactly when the request depends on the name.
+            if (ir.source.geometryProperty === undefined && wfsSpatialFilterNeedsGeometryProperty(query)) {
+                ir = buildIr(await geometryBoundDescriptor(request?.signal));
+                query = canonicalQuery(ir);
+            }
+            return module.compile({ source: ir.source, query, operation });
+        }
+        catch (error) {
+            if (error instanceof HonuaQueryPlanningError && error.code === "unsupported-query") {
+                throw new HonuaCapabilityNotSupportedError("query", descriptor.protocol, `${descriptor.id} (${error.message})`);
+            }
+            throw error;
+        }
+    }
     return makeSource(descriptor, caps, policy, adapterRegistry, {
         async query(request) {
             ensureCapability(descriptor, caps, "query");
@@ -1379,48 +1561,25 @@ export function wfsSource(descriptor, client, policy) {
                 // silent partial result.
                 throw new HonuaCapabilityNotSupportedError("queryAggregate", descriptor.protocol, descriptor.id);
             }
-            // `pagination.limit === 0` is an explicit zero cap, not "unbounded";
-            // short-circuit before the wire call so we do not silently widen to the
-            // server's default page size.
-            if (request?.pagination?.limit === 0) {
-                return { features: [], exceededTransferLimit: false };
-            }
-            const choice = await negotiateJsonOrThrow();
-            const json = await runGetFeatureJson(featureType, typeName, choice, request, request?.pagination?.limit);
-            return resultFromGeoJson(json);
+            return module.execute(discovered, {
+                compiled: await compileSourceQuery(request, "query"),
+                operation: "query",
+                query: {},
+                ...(request?.signal ? { signal: request.signal } : {}),
+            });
         },
         async queryAll(request) {
             ensureCapability(descriptor, caps, "query");
-            const choice = await negotiateJsonOrThrow();
-            const limit = request?.pagination?.limit;
-            const target = typeof limit === "number" && limit >= 0 ? limit + 1 : Number.POSITIVE_INFINITY;
-            const collected = [];
-            let totalCount;
-            let offset = request?.pagination?.offset ?? 0;
-            // Mirror `withPagingBounds`: a finite limit (including 0) sets the
-            // lookahead page size to `limit + 1` so we can stamp
-            // `exceededTransferLimit` without overfetching a full default page.
-            const pageSize = typeof limit === "number" && limit >= 0 ? Math.max(1, Math.min(limit + 1, 2000)) : 2000;
-            while (collected.length < target) {
-                const pageRequest = {
-                    ...(request ?? {}),
-                    pagination: { offset, limit: pageSize },
-                };
-                const json = await runGetFeatureJson(featureType, typeName, choice, pageRequest, pageSize);
-                const result = resultFromGeoJson(json);
-                if (result.totalCount !== undefined)
-                    totalCount = result.totalCount;
-                collected.push(...result.features);
-                if (result.features.length < pageSize)
-                    break;
-                offset += result.features.length;
-            }
-            const { features, exceededTransferLimit } = applyQueryAllLimit(collected, limit);
-            return {
-                features,
-                exceededTransferLimit,
-                totalCount: totalCount ?? features.length,
-            };
+            const requestedLimit = request?.pagination?.limit;
+            const limit = typeof requestedLimit === "number" && requestedLimit >= 0 ? requestedLimit : undefined;
+            return module.execute(discovered, {
+                compiled: await compileSourceQuery(request, "queryAll"),
+                operation: "queryAll",
+                query: {
+                    ...(limit !== undefined ? { logicalLimit: limit } : {}),
+                },
+                ...(request?.signal ? { signal: request.signal } : {}),
+            });
         },
         async queryAggregate() {
             throw new HonuaCapabilityNotSupportedError("queryAggregate", descriptor.protocol, descriptor.id);
@@ -1455,7 +1614,7 @@ export function wfsSource(descriptor, client, policy) {
                     ...extentRequest,
                     pagination: { offset, limit: drainPageSize },
                 };
-                const json = await runGetFeatureJson(featureType, typeName, choice, pageRequest, drainPageSize);
+                const json = await runGetFeatureJson(featureType, choice, featureNamespace, await compileSourceQuery(pageRequest, "query"));
                 const page = computeExtentFromFeatureCollection(json);
                 count += page.count;
                 if (page.extent) {
@@ -1484,25 +1643,46 @@ export function wfsSource(descriptor, client, policy) {
             // rather than silently fall back to the default 2000-row page size.
             if (limit === 0)
                 return;
-            const choice = await negotiateJsonOrThrow();
             const pageSize = typeof limit === "number" && limit > 0 ? Math.max(1, limit) : 2000;
             let offset = request?.pagination?.offset ?? 0;
+            let totalCount;
+            const seenPages = new Set();
             while (true) {
                 const pageRequest = {
                     ...(request ?? {}),
                     pagination: { offset, limit: pageSize },
                 };
-                const json = await runGetFeatureJson(featureType, typeName, choice, pageRequest, pageSize);
-                const result = resultFromGeoJson(json);
-                if (result.features.length === 0)
+                const result = await module.execute(discovered, {
+                    compiled: await compileSourceQuery(pageRequest, "query"),
+                    operation: "query",
+                    query: {},
+                    ...(request?.signal ? { signal: request.signal } : {}),
+                });
+                if (result.totalCount !== undefined) {
+                    if (totalCount !== undefined && totalCount !== result.totalCount) {
+                        throw new HonuaWfsProtocolError("invalid-feature-response", "WFS GetFeature numberMatched changed while streaming one query");
+                    }
+                    totalCount = result.totalCount;
+                }
+                const pageEnd = checkedWfsPageEnd(offset, result.features.length);
+                if (totalCount !== undefined && pageEnd > totalCount) {
+                    throw new HonuaWfsProtocolError("invalid-feature-response", "WFS GetFeature returned more rows than numberMatched permits");
+                }
+                if (result.features.length === 0) {
+                    if (totalCount !== undefined && offset < totalCount) {
+                        throw new HonuaWfsProtocolError("paging-stalled", `WFS GetFeature returned no rows at startIndex ${offset} while numberMatched=${totalCount}`);
+                    }
                     break;
+                }
+                assertWfsPageProgress(result, seenPages, offset);
                 yield {
                     features: result.features,
-                    exceededTransferLimit: false,
+                    exceededTransferLimit: totalCount !== undefined ? pageEnd < totalCount : result.exceededTransferLimit,
+                    ...(totalCount !== undefined ? { totalCount } : {}),
                 };
-                if (result.features.length < pageSize)
+                offset = pageEnd;
+                if (totalCount !== undefined && offset >= totalCount)
                     break;
-                offset += result.features.length;
             }
         },
         async queryObjectIds(request) {
@@ -1532,7 +1712,7 @@ export function wfsSource(descriptor, client, policy) {
                     ...idsRequest,
                     pagination: { offset, limit: pageSize },
                 };
-                const json = await runGetFeatureJson(featureType, typeName, choice, pageRequest, pageSize);
+                const json = await runGetFeatureJson(featureType, choice, featureNamespace, await compileSourceQuery(pageRequest, "query"));
                 const collection = json;
                 const features = collection.features ?? [];
                 for (const feature of features) {
@@ -1582,7 +1762,13 @@ export function wfsSource(descriptor, client, policy) {
                 // same root, so the capabilities promise is already settled there.
                 await root.capabilities(envelope.signal ? { signal: envelope.signal } : undefined);
                 const filtered = { ...envelope, updates: validUpdates };
-                const body = buildTransactionBody(typeName, filtered, featureNamespace, wfsSrsName);
+                // Attribute-only edits and deletes never name the geometry property,
+                // so only a geometry-bearing transaction pays for (and fails closed
+                // on) schema resolution.
+                const writesGeometry = adds.some((add) => add.geometry !== undefined && add.geometry !== null) ||
+                    validUpdates.some((update) => update.geometry !== undefined && update.geometry !== null);
+                const geometryProperty = writesGeometry ? await resolveGeometryProperty(envelope.signal) : undefined;
+                const body = buildTransactionBody(typeName, filtered, featureNamespace, wfsSrsName, geometryProperty);
                 const transactionOptions = { body };
                 if (envelope.signal)
                     transactionOptions.signal = envelope.signal;
@@ -1596,8 +1782,32 @@ export function wfsSource(descriptor, client, policy) {
         attachments: unsupportedAttachmentApi(descriptor),
     });
 }
+function normalizeWfsModuleQuery(request) {
+    if (request === undefined)
+        return undefined;
+    const omitWhere = request.where === "";
+    const pagination = request.pagination;
+    const omitLimit = pagination?.limit !== undefined && pagination.limit < 0;
+    const omitOffset = pagination?.offset !== undefined && pagination.offset < 0;
+    if (!omitWhere && !omitLimit && !omitOffset)
+        return request;
+    const { where: _where, pagination: _pagination, ...rest } = request;
+    void _where;
+    void _pagination;
+    const normalizedPagination = pagination === undefined
+        ? undefined
+        : {
+            ...(!omitOffset && pagination.offset !== undefined ? { offset: pagination.offset } : {}),
+            ...(!omitLimit && pagination.limit !== undefined ? { limit: pagination.limit } : {}),
+        };
+    return {
+        ...rest,
+        ...(!omitWhere && request.where !== undefined ? { where: request.where } : {}),
+        ...(normalizedPagination !== undefined ? { pagination: normalizedPagination } : {}),
+    };
+}
 function requireWfsLocator(descriptor) {
-    const { url, typeName, featureNamespace, srsName } = descriptor.locator;
+    const { url, typeName, featureNamespace, srsName, geometryName } = descriptor.locator;
     if (typeof url !== "string" || url.length === 0) {
         throw new Error(`createDataset: source "${descriptor.id}" (wfs) requires locator.url`);
     }
@@ -1607,13 +1817,23 @@ function requireWfsLocator(descriptor) {
     if (featureNamespace !== undefined && (typeof featureNamespace !== "string" || featureNamespace.length === 0)) {
         throw new Error(`createDataset: source "${descriptor.id}" (wfs) locator.featureNamespace must be a non-empty string`);
     }
+    // The geometry property is spliced into FES `<fes:ValueReference>` and
+    // transaction element names, so an override must be a plain XML name.
+    if (geometryName !== undefined && (typeof geometryName !== "string" || !isWfsPropertyName(geometryName))) {
+        throw new Error(`createDataset: source "${descriptor.id}" (wfs) locator.geometryName must be a valid geometry property name`);
+    }
     return {
         url,
         typeName,
         featureNamespace: typeof featureNamespace === "string" ? featureNamespace : undefined,
         srsName: wfsSrsNameFromOutSr(srsName),
+        geometryName: typeof geometryName === "string" ? geometryName : undefined,
     };
 }
+/** Optionally prefixed XML name, the only shape a WFS property reference takes. */
+function isWfsPropertyName(value) {
+    return /^[A-Za-z_][A-Za-z0-9_.-]*(?::[A-Za-z_][A-Za-z0-9_.-]*)?$/.test(value);
+}
 function toWfsExtentDrainRequest(request) {
     // The drain computes a bbox over geometries, so a caller-supplied
     // `returnGeometry: false` would suppress geometry on every page and
@@ -1644,211 +1864,51 @@ function toWfsObjectIdsDrainRequest(request) {
     return idsRequest;
 }
 /**
- * Compile `Query.where` and `Query.spatialFilter` into a (possibly empty)
- * FES filter and route the request through GET or POST GetFeature based on
- * the URL budget. Returns the decoded GeoJSON FeatureCollection.
+ * Execute a compiler-approved WFS GetFeature request and return its decoded
+ * GeoJSON FeatureCollection. The protocol compiler owns filter, projection,
+ * paging, CRS, and transport selection so legacy drains do not duplicate it.
  */
-async function runGetFeatureJson(featureType, typeName, choice, request, pageSize) {
-    const filterNodes = [];
-    let needsPostBody = false;
-    let bbox;
-    if (request?.where !== undefined && request.where !== "") {
-        const compiled = compileWhere(request.where);
-        if (compiled === UNSUPPORTED_FES) {
-            throw new HonuaCapabilityNotSupportedError("query", "wfs", `where clause is not expressible in FES; route the request through Source.protocol("wfs") to emit a custom filter`);
-        }
-        if (compiled.kind !== "and" || compiled.operands.length > 0) {
-            filterNodes.push(compiled);
-        }
-    }
-    if (request?.spatialFilter) {
-        const spatialRel = request.spatialFilter.spatialRel;
-        // The `bbox=` KVP and `<fes:BBOX>` both encode envelope-intersects
-        // semantics (OGC 09-026r2). Only take the bbox shortcut when the caller
-        // wants intersects (default), envelope-intersects, or did not specify.
-        // Anything else (Contains, Within, Crosses, Overlaps, Touches) needs an
-        // FES predicate that preserves the requested relation, which means
-        // routing the envelope through compileSpatialFilter so the geometry is
-        // serialized as a polygon under the correct spatial op.
-        const isEnvelopeIntersects = spatialRel === undefined ||
-            spatialRel === "esriSpatialRelIntersects" ||
-            spatialRel === "esriSpatialRelEnvelopeIntersects";
-        if (request.spatialFilter.geometryType === "esriGeometryEnvelope" &&
-            isEnvelopeIntersects &&
-            filterNodes.length === 0 &&
-            request.where === undefined) {
-            // BBox-only requests are short and travel safely as a `bbox=` KVP, no
-            // FES emission required. Saves a round-trip through XML serialization
-            // and keeps the URL human-debuggable.
-            const env = request.spatialFilter.geometry;
-            if (typeof env.xmin === "number" &&
-                typeof env.ymin === "number" &&
-                typeof env.xmax === "number" &&
-                typeof env.ymax === "number") {
-                bbox = `${env.xmin},${env.ymin},${env.xmax},${env.ymax}`;
-            }
-        }
-        else {
-            const filterSrsName = wfsSrsNameFromOutSr(request.outSr);
-            const compiled = compileSpatialFilter(request.spatialFilter, {
-                geometryProperty: DEFAULT_WFS_GEOMETRY_PROPERTY,
-                ...(filterSrsName !== undefined ? { srsName: filterSrsName } : {}),
-            });
-            if (compiled === UNSUPPORTED_FES) {
-                throw new HonuaCapabilityNotSupportedError("query", "wfs", `spatial filter (geometryType=${request.spatialFilter.geometryType}, spatialRel=${request.spatialFilter.spatialRel ?? "default"}) is not expressible in FES; reach the wire through Source.protocol("wfs")`);
-            }
-            filterNodes.push(compiled);
-        }
-    }
-    const filterXml = filterNodes.length > 0 ? serializeFes(filterNodes, { typeName }) : undefined;
-    if (filterXml !== undefined) {
-        const encoded = encodeURIComponent(filterXml);
-        if (encoded.length > WFS_GET_FILTER_BUDGET)
-            needsPostBody = true;
-    }
-    const params = {};
-    if (bbox !== undefined)
-        params.bbox = bbox;
-    if (filterXml !== undefined && !needsPostBody)
-        params.filter = filterXml;
-    // WFS `propertyName=` drops every property the caller does not list,
-    // including the geometry column. Honor the canonical contract: when
-    // `outFields` is set and `returnGeometry !== false`, append the
-    // geometry property so geometry is preserved; when
-    // `returnGeometry === false`, omit the geometry property; when
-    // `returnGeometry === false` is asked without an `outFields` list,
-    // refuse the request because WFS cannot suppress geometry without
-    // enumerating every non-geometry property — silently widening to
-    // "geometry included" would break the canonical contract.
-    const callerOutFields = request?.outFields && request.outFields.length > 0 ? request.outFields : undefined;
-    const wantsGeometry = request?.returnGeometry !== false;
-    let propertyNames;
-    if (callerOutFields !== undefined) {
-        if (wantsGeometry) {
-            const merged = [...callerOutFields];
-            if (!merged.includes(DEFAULT_WFS_GEOMETRY_PROPERTY))
-                merged.push(DEFAULT_WFS_GEOMETRY_PROPERTY);
-            propertyNames = merged;
-        }
-        else {
-            propertyNames = [...callerOutFields];
-        }
-    }
-    else if (request?.returnGeometry === false) {
-        throw new HonuaCapabilityNotSupportedError("query", "wfs", `returnGeometry=false requires an explicit outFields list (WFS propertyName cannot suppress geometry without enumerating non-geometry properties); set Query.outFields or reach the wire through Source.protocol("wfs")`);
-    }
-    if (propertyNames)
-        params.propertyName = [...propertyNames];
-    const sortBy = request?.orderBy && request.orderBy.length > 0
-        ? request.orderBy.map((s) => `${s.field}${s.direction === "desc" ? " D" : " A"}`).join(",")
+async function runGetFeatureJson(featureType, choice, featureNamespace, compiled) {
+    const typePrefix = compiled.typeName.includes(":")
+        ? compiled.typeName.slice(0, compiled.typeName.indexOf(":"))
         : undefined;
-    if (sortBy !== undefined)
-        params.sortBy = sortBy;
-    if (typeof pageSize === "number" && pageSize > 0) {
-        params.count = pageSize;
-    }
-    else if (typeof request?.pagination?.limit === "number" && request.pagination.limit > 0) {
-        params.count = request.pagination.limit;
-    }
-    if (typeof request?.pagination?.offset === "number" && request.pagination.offset > 0) {
-        params.startIndex = request.pagination.offset;
-    }
-    const srsName = wfsSrsNameFromOutSr(request?.outSr);
-    if (srsName !== undefined)
-        params.srsName = srsName;
-    params.outputFormat = choice.format;
-    if (request?.signal)
-        params.signal = request.signal;
-    if (needsPostBody && filterXml !== undefined) {
-        params.method = "POST";
-        const postOptions = {
-            typeName,
-            filter: filterXml,
-            count: params.count,
-            startIndex: params.startIndex,
+    const namespace = typePrefix !== undefined && featureNamespace !== undefined
+        ? { prefix: typePrefix, uri: featureNamespace }
+        : undefined;
+    const params = {
+        method: compiled.method,
+        outputFormat: choice.format,
+        ...(namespace !== undefined ? { namespace } : {}),
+        ...(compiled.method === "GET" && compiled.filter !== undefined ? { filter: compiled.filter } : {}),
+        ...(compiled.bbox !== undefined ? { bbox: compiled.bbox } : {}),
+        ...(compiled.propertyName !== undefined ? { propertyName: [...compiled.propertyName] } : {}),
+        ...(compiled.sortBy !== undefined ? { sortBy: compiled.sortBy } : {}),
+        ...(compiled.count !== undefined ? { count: compiled.count } : {}),
+        ...(compiled.startIndex !== undefined && compiled.startIndex > 0 ? { startIndex: compiled.startIndex } : {}),
+        ...(compiled.srsName !== undefined ? { srsName: compiled.srsName } : {}),
+    };
+    if (compiled.method === "POST" && compiled.filter !== undefined) {
+        params.body = buildWfsPostGetFeatureBody({
+            typeName: compiled.typeName,
+            filter: compiled.filter,
+            count: compiled.count,
+            startIndex: compiled.startIndex !== undefined && compiled.startIndex > 0 ? compiled.startIndex : undefined,
             outputFormat: choice.format,
-        };
-        if (propertyNames)
-            postOptions.propertyNames = propertyNames;
-        if (sortBy !== undefined)
-            postOptions.sortBy = sortBy;
-        if (srsName !== undefined)
-            postOptions.srsName = srsName;
-        params.body = buildPostGetFeatureBody(postOptions);
+            ...(namespace !== undefined ? { namespace } : {}),
+            ...(compiled.propertyName !== undefined ? { propertyNames: compiled.propertyName } : {}),
+            ...(compiled.sortBy !== undefined ? { sortBy: compiled.sortBy } : {}),
+            ...(compiled.srsName !== undefined ? { srsName: compiled.srsName } : {}),
+        });
     }
     const response = await featureType.getFeature(params);
     if (response.kind !== "json") {
-        throw new HonuaCapabilityNotSupportedError("query", "wfs", `WFS GetFeature returned ${response.contentType}; canonical surface only carries JSON. Reach raw output through Source.protocol("wfs")`);
+        throw new HonuaCapabilityNotSupportedError("query", "wfs", `WFS GetFeature returned ${response.contentType}; canonical surface only carries JSON. Reach the wire through Source.protocol("wfs")`);
     }
     return response.data;
 }
-function buildPostGetFeatureBody(options) {
-    const countAttr = typeof options.count === "number" ? ` count="${options.count}"` : "";
-    const startAttr = typeof options.startIndex === "number" ? ` startIndex="${options.startIndex}"` : "";
-    const outputAttr = ` outputFormat="${escapeXmlAttr(options.outputFormat)}"`;
-    const queryAttrs = options.srsName !== undefined ? ` srsName="${escapeXmlAttr(options.srsName)}"` : "";
-    const propertyXml = options.propertyNames && options.propertyNames.length > 0
-        ? options.propertyNames.map((name) => `<wfs:PropertyName>${escapeXmlText(name)}</wfs:PropertyName>`).join("")
-        : "";
-    const sortByXml = options.sortBy !== undefined ? buildSortByXml(options.sortBy) : "";
-    return `<wfs:GetFeature xmlns:wfs="http://www.opengis.net/wfs/2.0" xmlns:fes="http://www.opengis.net/fes/2.0" service="WFS" version="2.0.0"${outputAttr}${countAttr}${startAttr}><wfs:Query typeNames="${escapeXmlAttr(options.typeName)}"${queryAttrs}>${propertyXml}${options.filter}${sortByXml}</wfs:Query></wfs:GetFeature>`;
-}
-/**
- * Build a `<fes:SortBy>` block from the same comma-separated `sortBy` string
- * the GET path emits (`FIELD A,OTHER D`). Empty entries are skipped.
- */
-function buildSortByXml(sortBy) {
-    const entries = sortBy
-        .split(",")
-        .map((entry) => entry.trim())
-        .filter((entry) => entry.length > 0);
-    if (entries.length === 0)
-        return "";
-    const properties = entries.map((entry) => {
-        const parts = entry.split(/\s+/);
-        const field = parts[0];
-        const direction = parts[1]?.toUpperCase() === "D" ? "DESC" : "ASC";
-        return `<fes:SortProperty><fes:ValueReference>${escapeXmlText(field)}</fes:ValueReference><fes:SortOrder>${direction}</fes:SortOrder></fes:SortProperty>`;
-    });
-    return `<fes:SortBy>${properties.join("")}</fes:SortBy>`;
-}
-/**
- * Translate a canonical `Query.outSr` (string CRS URI / EPSG token, or numeric
- * WKID) into the WFS `srsName` form. Numeric WKIDs become the OGC URN form
- * `urn:ogc:def:crs:EPSG::<wkid>` so cross-server interop matches the format
- * advertised in `OperationsMetadata` / `Filter_Capabilities`.
- */
-function wfsSrsNameFromOutSr(outSr) {
-    if (typeof outSr === "string")
-        return outSr.length > 0 ? outSr : undefined;
-    if (typeof outSr === "number" && Number.isFinite(outSr))
-        return `urn:ogc:def:crs:EPSG::${outSr}`;
-    return undefined;
-}
 function escapeXmlAttr(value) {
     return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
-function resultFromGeoJson(data) {
-    if (typeof data !== "object" || data === null) {
-        return { features: [], exceededTransferLimit: false };
-    }
-    const collection = data;
-    const features = (collection.features ?? []).map((f) => ({
-        attributes: (f.properties ?? {}),
-        geometry: f.geometry,
-    }));
-    const totalCount = typeof collection.numberMatched === "number" && Number.isFinite(collection.numberMatched)
-        ? collection.numberMatched
-        : undefined;
-    const exceededTransferLimit = totalCount !== undefined && features.length < totalCount;
-    const out = {
-        features,
-        exceededTransferLimit,
-    };
-    if (totalCount !== undefined)
-        out.totalCount = totalCount;
-    return out;
-}
 function computeExtentFromFeatureCollection(data) {
     if (typeof data !== "object" || data === null)
         return { extent: null, count: 0 };
@@ -1877,7 +1937,7 @@ function computeExtentFromFeatureCollection(data) {
         return { extent: null, count };
     return { extent: { xmin, ymin, xmax, ymax }, count };
 }
-function buildTransactionBody(typeName, envelope, featureNamespace, srsName) {
+function buildTransactionBody(typeName, envelope, featureNamespace, srsName, geometryProperty) {
     const releaseAction = envelope.rollbackOnFailure ? "ALL" : "SOME";
     const { prefix } = splitTypeName(typeName);
     // Bind the feature-namespace prefix on the Transaction root so prefixed
@@ -1897,12 +1957,12 @@ function buildTransactionBody(typeName, envelope, featureNamespace, srsName) {
     // result-mapping side cannot drift.
     const adds = envelope.adds ?? [];
     for (let i = 0; i < adds.length; i += 1) {
-        blocks.push(buildInsertBlock(typeName, adds[i], wfsInsertHandle(i), srsName));
+        blocks.push(buildInsertBlock(typeName, adds[i], wfsInsertHandle(i), srsName, geometryProperty));
     }
     let handleCounter = adds.length;
     for (const update of envelope.updates ?? []) {
         handleCounter += 1;
-        blocks.push(buildUpdateBlock(typeName, update, `upd-${handleCounter}`, srsName));
+        blocks.push(buildUpdateBlock(typeName, update, `upd-${handleCounter}`, srsName, geometryProperty));
     }
     for (const id of envelope.deletes ?? []) {
         handleCounter += 1;
@@ -1931,30 +1991,41 @@ function splitTypeName(typeName) {
 function syntheticFeatureNamespace(prefix) {
     return `urn:honua:wfs:feature-namespace:${prefix}`;
 }
-function buildInsertBlock(typeName, feature, handle, srsName) {
+function buildInsertBlock(typeName, feature, handle, srsName, geometryProperty) {
     const attributes = feature.attributes;
     const propertyXml = Object.entries(attributes)
         .filter(([, value]) => value !== undefined)
         .map(([key, value]) => `<${escapeXmlElement(key)}>${escapeXmlText(formatLiteral(value))}</${escapeXmlElement(key)}>`)
         .join("");
     const geometryXml = feature.geometry ? (geoJsonGeometryToGml(feature.geometry, srsName) ?? "") : "";
-    const geometryProperty = escapeXmlElement(DEFAULT_WFS_GEOMETRY_PROPERTY);
-    const featureXml = `<${escapeXmlElement(typeName)}>${propertyXml}${geometryXml ? `<${geometryProperty}>${geometryXml}</${geometryProperty}>` : ""}</${escapeXmlElement(typeName)}>`;
+    const property = geometryXml ? escapeXmlElement(requireTransactionGeometryProperty(geometryProperty)) : "";
+    const featureXml = `<${escapeXmlElement(typeName)}>${propertyXml}${geometryXml ? `<${property}>${geometryXml}</${property}>` : ""}</${escapeXmlElement(typeName)}>`;
     return `<wfs:Insert handle="${handle}">${featureXml}</wfs:Insert>`;
 }
-function buildUpdateBlock(typeName, feature, handle, srsName) {
+function buildUpdateBlock(typeName, feature, handle, srsName, geometryProperty) {
     const attributes = feature.attributes;
     const properties = Object.entries(attributes)
         .filter(([, value]) => value !== undefined)
         .map(([key, value]) => `<wfs:Property><wfs:ValueReference>${escapeXmlText(key)}</wfs:ValueReference><wfs:Value>${escapeXmlText(formatLiteral(value))}</wfs:Value></wfs:Property>`)
         .join("");
-    const geometryProperty = feature.geometry
-        ? `<wfs:Property><wfs:ValueReference>${escapeXmlText(DEFAULT_WFS_GEOMETRY_PROPERTY)}</wfs:ValueReference><wfs:Value>${geoJsonGeometryToGml(feature.geometry, srsName) ?? ""}</wfs:Value></wfs:Property>`
+    const geometryXml = feature.geometry
+        ? `<wfs:Property><wfs:ValueReference>${escapeXmlText(requireTransactionGeometryProperty(geometryProperty))}</wfs:ValueReference><wfs:Value>${geoJsonGeometryToGml(feature.geometry, srsName) ?? ""}</wfs:Value></wfs:Property>`
         : "";
     const filter = feature.id !== undefined
         ? `<fes:Filter><fes:ResourceId rid="${escapeXmlAttr(String(feature.id))}"/></fes:Filter>`
         : "";
-    return `<wfs:Update handle="${handle}" typeName="${escapeXmlAttr(typeName)}">${properties}${geometryProperty}${filter}</wfs:Update>`;
+    return `<wfs:Update handle="${handle}" typeName="${escapeXmlAttr(typeName)}">${properties}${geometryXml}${filter}</wfs:Update>`;
+}
+/**
+ * Fail closed rather than write geometry into a guessed property: a
+ * transaction that targets the wrong element name is accepted by some servers
+ * and silently drops the geometry.
+ */
+function requireTransactionGeometryProperty(geometryProperty) {
+    if (geometryProperty === undefined) {
+        throw new HonuaWfsProtocolError("unresolved-geometry-property", "WFS transaction geometry requires the feature type's geometry property; set locator.geometryName or make DescribeFeatureType reachable");
+    }
+    return geometryProperty;
 }
 function buildDeleteBlock(typeName, id, handle) {
     return `<wfs:Delete handle="${handle}" typeName="${escapeXmlAttr(typeName)}"><fes:Filter><fes:ResourceId rid="${escapeXmlAttr(String(id))}"/></fes:Filter></wfs:Delete>`;
@@ -2046,10 +2117,11 @@ function loadOdataWriteCodec() {
 /**
  * Adapter factory for an OData v4 entity set.
  *
- * `Query.where` compiles to OData `$filter`, `Query.outFields` becomes
- * `$select`, `Query.orderBy` becomes `$orderby`, and `Query.pagination`
- * becomes `$top`/`$skip`. Geospatial filters translate to OData's
- * `geo.intersects` / `geo.distance` family.
+ * The deprecated source-native `Query.where` migration member compiles to
+ * OData `$filter`, `Query.outFields` becomes `$select`, `Query.orderBy`
+ * becomes `$orderby`, and `Query.pagination` becomes `$top`/`$skip`.
+ * Geospatial filters translate to OData's `geo.intersects` /
+ * `geo.distance` family.
  *
  * @example
  * ```ts
@@ -2064,7 +2136,6 @@ function loadOdataWriteCodec() {
  *   }],
  * });
  * const result = await dataset.source("incidents")!.queryAll({
- *   where: "Severity ge 3",
  *   orderBy: [{ field: "ReportedAt", direction: "desc" }],
  *   pagination: { limit: 100 },
  * });
@@ -2072,9 +2143,16 @@ function loadOdataWriteCodec() {
  */
 export function odataSource(descriptor, client, policy, options = {}) {
     descriptor = normalizeCapabilityDescriptor(descriptor);
-    const { entitySet, basePath } = requireOdataLocator(descriptor);
-    const entity = new HonuaOdataEntitySet({ client, entitySet, basePath });
-    const declaredCaps = descriptor.capabilities ?? PROTOCOL_DEFAULT_CAPABILITIES.odata;
+    const module = odataProtocolModule(client);
+    const discovered = module.discover(descriptor);
+    if (discovered instanceof Promise) {
+        // OData discovery only binds an explicitly injected client to an entity
+        // set. `$metadata` remains lazy, so built-in Source construction is
+        // intentionally synchronous.
+        throw new Error("odata: built-in source construction requires synchronous protocol-module discovery");
+    }
+    const entity = discovered.adapter;
+    const declaredCaps = discovered.capabilities;
     const negotiation = new OdataCapabilityNegotiator(entity, declaredCaps);
     const writeEncoding = options.writeEncoding ?? "legacy";
     if (writeEncoding !== "legacy" && writeEncoding !== "lossless-json") {
@@ -2089,8 +2167,17 @@ export function odataSource(descriptor, client, policy, options = {}) {
             await negotiation.ensureAdvertised(descriptor, "query");
             const geomColumn = await resolveOdataGeometryColumn(entity, descriptor);
             const params = await buildOdataParams(entity, descriptor, request, { count: true, geomColumn });
-            const page = await entity.query(params);
-            return odataResultFromPage(descriptor, page, await negotiation.fieldsFor(descriptor.id), request?.returnGeometry, geomColumn);
+            return module.execute(discovered, {
+                compiled: createOdataProtocolCompiledQuery(entity.entitySet, "query", params),
+                operation: "query",
+                query: {
+                    count: true,
+                    fields: await negotiation.fieldsFor(descriptor.id),
+                    ...(request?.returnGeometry !== undefined ? { returnGeometry: request.returnGeometry } : {}),
+                    ...(geomColumn ? { geometryColumn: geomColumn } : {}),
+                },
+                ...(request?.signal ? { signal: request.signal } : {}),
+            });
         },
         async queryAll(request) {
             ensureCapability(descriptor, declaredCaps, "query");
@@ -2098,30 +2185,20 @@ export function odataSource(descriptor, client, policy, options = {}) {
             const geomColumn = await resolveOdataGeometryColumn(entity, descriptor);
             const params = await buildOdataParams(entity, descriptor, request, { count: true, geomColumn });
             const limit = request?.pagination?.limit;
-            // Lookahead row: ask the server for `limit + 1` so we can prove
-            // truncation by collecting more than `limit` rows even when the
-            // response carries no `@odata.nextLink`. Mirrors the GeoServices
-            // and OGC `queryAll` truncation pattern.
-            if (typeof limit === "number" && limit >= 0) {
-                params.top = limit + 1;
-            }
-            const drained = await entity.queryAll(params);
-            const allFeatures = drained.rows.map((row) => odataRowToFeature(row, descriptor, request?.returnGeometry, geomColumn));
-            const { features: limited, exceededTransferLimit: collectedExceeded } = applyQueryAllLimit(allFeatures, limit);
-            // Belt-and-braces: if the server respected `$top` exactly but
-            // reports `@odata.count > limited.length`, that also proves
-            // truncation. Either signal sets the flag.
-            const countExceeded = typeof drained.totalCount === "number" && typeof limit === "number" && drained.totalCount > limited.length;
-            const exceededTransferLimit = collectedExceeded || countExceeded;
-            const fields = await negotiation.fieldsFor(descriptor.id);
-            return {
-                features: limited,
-                exceededTransferLimit,
-                ...(typeof drained.totalCount === "number"
-                    ? { totalCount: drained.totalCount }
-                    : { totalCount: limited.length }),
-                ...(fields.length > 0 ? { fields } : {}),
-            };
+            return module.execute(discovered, {
+                // The operation-bound compiler adds the one-row queryAll lookahead;
+                // the runtime query context retains the caller-visible logical limit.
+                compiled: createOdataProtocolCompiledQuery(entity.entitySet, "queryAll", params),
+                operation: "queryAll",
+                query: {
+                    count: true,
+                    fields: await negotiation.fieldsFor(descriptor.id),
+                    ...(request?.returnGeometry !== undefined ? { returnGeometry: request.returnGeometry } : {}),
+                    ...(geomColumn ? { geometryColumn: geomColumn } : {}),
+                    ...(limit !== undefined ? { limit } : {}),
+                },
+                ...(request?.signal ? { signal: request.signal } : {}),
+            });
         },
         async queryAggregate() {
             // OData aggregation is dialect-specific (`$apply` pipeline). The
@@ -2144,7 +2221,7 @@ export function odataSource(descriptor, client, policy, options = {}) {
             const fields = await negotiation.fieldsFor(descriptor.id);
             const stream = entity.queryStream(params);
             for await (const page of stream) {
-                yield odataResultFromPage(descriptor, page, fields, request?.returnGeometry, geomColumn);
+                yield odataProtocolResultFromPage(descriptor, page, fields, request?.returnGeometry, geomColumn);
             }
         },
         async queryObjectIds(request) {
@@ -2565,42 +2642,6 @@ function describeBatchError(body, status) {
 function stripLeadingSlashLocal(url) {
     return url.startsWith("/") ? url.slice(1) : url;
 }
-function requireOdataLocator(descriptor) {
-    const { entitySet, url, layerId } = descriptor.locator;
-    // Resolve the entity-set token. Honua Server's `SourceLocator` only
-    // carries `url`, `serviceId`, and `layerId`, so server-produced OData
-    // bindings arrive without `entitySet`. The canonical server route is
-    // layer-scoped — `/odata/Layers(<layerId>)/Features` — so derive that
-    // path when only `layerId` is provided. SDK callers that already pass
-    // `entitySet` (the historical path) continue to win.
-    let resolvedEntitySet;
-    if (typeof entitySet === "string" && entitySet !== "") {
-        resolvedEntitySet = entitySet;
-    }
-    else if (typeof layerId === "number" && Number.isFinite(layerId)) {
-        resolvedEntitySet = `Layers(${layerId})/Features`;
-    }
-    if (resolvedEntitySet === undefined) {
-        throw new Error(`createDataset: source "${descriptor.id}" (odata) requires locator.entitySet or locator.layerId`);
-    }
-    // `locator.url` is informational on the canonical surface; the request
-    // path is built from `basePath/<entitySet>`. When `locator.url` carries
-    // a path, treat its trailing path component as the basePath so a
-    // descriptor pointing at `https://srv/odata/v4` still resolves correctly.
-    const basePath = url ? extractOdataBasePath(url) : "/odata";
-    return { entitySet: resolvedEntitySet, basePath };
-}
-function extractOdataBasePath(url) {
-    try {
-        const parsed = new URL(url);
-        const pathname = trimTrailingSlashes(parsed.pathname);
-        return pathname === "" ? "/odata" : pathname;
-    }
-    catch {
-        // Relative URL: take it as the basePath verbatim.
-        return url.startsWith("/") ? trimTrailingSlashes(url) || "/odata" : `/${trimTrailingSlashes(url)}`;
-    }
-}
 /**
  * Resolve the OData geometry column for a descriptor. Prefers
  * `descriptor.schema.fields` (where a field of type
@@ -2712,6 +2753,9 @@ async function buildOdataParams(entity, descriptor, request, options) {
         if (rewritten !== "")
             filterParts.push(rewritten);
     }
+    const typedFilter = await compileOdataQueryFilter(entity, descriptor, request, options.geomColumn);
+    if (typedFilter !== undefined)
+        filterParts.push(typedFilter);
     if (request.spatialFilter) {
         // `$metadata` is advisory here — it only refines the geometry column
         // and SRID context. When it is missing or failing, fall back to the
@@ -2781,52 +2825,49 @@ async function buildOdataParams(entity, descriptor, request, options) {
     }
     if (request.signal)
         out.signal = request.signal;
-    void descriptor;
     return out;
 }
-function odataResultFromPage(descriptor, page, fields, returnGeometry, geomColumn) {
-    const features = page.rows.map((row) => odataRowToFeature(row, descriptor, returnGeometry, geomColumn));
-    const exceededTransferLimit = typeof page.totalCount === "number" ? features.length < page.totalCount : Boolean(page.nextLink);
-    return {
-        features,
-        exceededTransferLimit,
-        ...(typeof page.totalCount === "number" ? { totalCount: page.totalCount } : {}),
-        ...(fields.length > 0 ? { fields } : {}),
-    };
-}
 /**
- * Convert one OData JSON row into a canonical `HonuaTypedFeature`. The
- * geometry column (when the row carries one as GeoJSON via Honua Server's
- * spatial encoding) is split out from the attributes envelope. When
- * `returnGeometry === false`, the geometry column is dropped from both
- * the attributes envelope and the `geometry` field — defensive against
- * servers that ignore the `$select` exclusion (or callers that bypassed
- * metadata-derived selects). The geometry column is sourced from the
- * caller-resolved `geomColumn` (descriptor schema → metadata
- * `isSpatial`) and falls back to the canonical name guesses on the
- * row keys when neither declares one.
+ * Compile `Query.filter` / `Query.temporalFilter` into an OData `$filter`
+ * fragment. OData has no protocol-level time parameter, so a temporal filter
+ * must name its field; without one the adapter refuses rather than dropping the
+ * constraint. Spatial nodes reuse the `$metadata`-aware `geo.*` emitter.
  */
-function odataRowToFeature(row, descriptor, returnGeometry, geomColumn) {
-    const geometryKey = geomColumn ??
-        descriptor.schema?.fields?.find((f) => f.type === "esriFieldTypeGeometry")?.name ??
-        findGeometryKey(row);
-    if (geometryKey && row[geometryKey] !== undefined) {
-        const { [geometryKey]: geometry, ...rest } = row;
-        return {
-            attributes: rest,
-            geometry: returnGeometry === false ? null : (geometry ?? null),
-        };
-    }
-    return { attributes: row, geometry: null };
-}
-function findGeometryKey(row) {
-    for (const key of Object.keys(row)) {
-        const lower = key.toLowerCase();
-        if (lower === "geometry" || lower === "geography" || lower === "shape")
-            return key;
+async function compileOdataQueryFilter(entity, descriptor, request, geomColumn) {
+    const ctx = queryFilterContext(descriptor, geomColumn);
+    const temporalExpression = request.temporalFilter
+        ? temporalFilterToExpression(request.temporalFilter, ctx)
+        : undefined;
+    if (request.temporalFilter && temporalExpression === undefined) {
+        throw new HonuaCapabilityNotSupportedError("temporalFilter.field", descriptor.protocol, descriptor.id);
     }
-    return undefined;
+    const expression = andQueryFilters(request.filter, temporalExpression);
+    if (!expression)
+        return undefined;
+    const meta = await entity.metadata().catch(() => undefined);
+    const typeName = meta ? meta.entitySets[entity.entitySetName] : undefined;
+    const spatialFields = (typeName && meta ? meta.fields[typeName] : undefined) ?? [];
+    const spatialContext = {
+        ...(geomColumn ? { geometryColumn: geomColumn } : {}),
+        ...(spatialFields.length > 0 ? { geometryFields: spatialFields } : {}),
+    };
+    return compileQueryFilterToOData(expression, ctx, (node) => {
+        const spatialRel = ODATA_SPATIAL_REL[node.operator];
+        if (!spatialRel) {
+            throw new HonuaCapabilityNotSupportedError(`filter.spatial.${node.operator}`, descriptor.protocol, descriptor.id);
+        }
+        return buildOdataSpatialFilter({ geometry: node.geometry.geometry, geometryType: node.geometry.geometryType, spatialRel }, spatialContext);
+    });
 }
+/**
+ * OData v4 standard geo functions express only `geo.intersects` (and the
+ * distance family). Every other topological predicate is refused by name so a
+ * `within` never silently returns intersecting rows.
+ */
+const ODATA_SPATIAL_REL = {
+    intersects: "esriSpatialRelIntersects",
+    "bbox-intersects": "esriSpatialRelEnvelopeIntersects",
+};
 function featureToOdataBody(feature) {
     const body = { ...feature.attributes };
     if (feature.geometry !== undefined && feature.geometry !== null) {
@@ -3212,8 +3253,11 @@ function requireImageServiceLocator(descriptor) {
 function requireImageServerCompatibleQuery(request) {
     if (!request)
         return;
+    if (request.filter !== undefined && queryFilterHasSpatial(request.filter)) {
+        throw new Error("geoservices-image-service: a spatial filter node is not supported on the raster catalog; the ImageServer catalog endpoint does not accept geometry / geometryType / spatialRel filters. Attribute and temporal predicates are supported; for geometry, call protocol().identify() / exportImage() on the typed escape hatch.");
+    }
     if (request.spatialFilter) {
-        throw new Error("geoservices-image-service: Query.spatialFilter is not supported on the raster catalog; the ImageServer catalog endpoint does not accept geometry / geometryType / spatialRel filters. Use Query.where to constrain the catalog or call protocol().identify() / exportImage() on the typed escape hatch.");
+        throw new Error("geoservices-image-service: Query.spatialFilter is not supported on the raster catalog; the ImageServer catalog endpoint does not accept geometry / geometryType / spatialRel filters. During migration, the deprecated source-native Query.where member can constrain the catalog; otherwise call protocol().identify() / exportImage() on the typed escape hatch.");
     }
     if (request.orderBy && request.orderBy.length > 0) {
         throw new Error("geoservices-image-service: Query.orderBy is not supported on the raster catalog; the ImageServer catalog endpoint does not honor orderByFields. Drop orderBy or sort client-side.");
@@ -3285,6 +3329,14 @@ function requireWmsCompatibleQuery(descriptor, request) {
     if (typeof request.where === "string" && request.where.length > 0) {
         throw new Error(`wms: Query.where is not supported on GetFeatureInfo for source "${descriptor.id}"; WMS has no SQL/CQL filter on the wire. Pre-filter via Query.spatialFilter (point) or use a tabular protocol.`);
     }
+    if (request.filter !== undefined) {
+        throw new HonuaCapabilityNotSupportedError("filter", descriptor.protocol, descriptor.id);
+    }
+    if (request.temporalFilter !== undefined) {
+        // WMS carries time as a dimension on the typed `WmsMapRequest` envelope,
+        // not as a GetFeatureInfo attribute predicate.
+        throw new HonuaCapabilityNotSupportedError("temporalFilter", descriptor.protocol, descriptor.id);
+    }
     if (request.outFields && request.outFields.length > 0) {
         throw new Error(`wms: Query.outFields is not supported on GetFeatureInfo for source "${descriptor.id}"; the server returns the layer's full attribute schema. Project client-side after the result lands.`);
     }
@@ -3357,12 +3409,24 @@ function wmsCrsFromGeometrySpatialReference(spatialReference) {
     }
     return "CRS:84";
 }
-function toStacRequest(request, collectionScope) {
+function toStacRequest(request, collectionScope, descriptor) {
     const out = {};
-    if (request?.where !== undefined) {
+    const cql2 = request ? compileCql2QueryFilter(request, descriptor) : {};
+    const filterParts = [];
+    if (request?.where !== undefined && request.where !== "")
+        filterParts.push(request.where);
+    if (cql2.filter !== undefined)
+        filterParts.push(cql2.filter);
+    if (filterParts.length > 0) {
+        out.filter = filterParts.length === 1 ? filterParts[0] : filterParts.map((part) => `(${part})`).join(" AND ");
+        out.filterLang = "cql2-text";
+    }
+    else if (request?.where !== undefined) {
         out.filter = request.where;
         out.filterLang = "cql2-text";
     }
+    if (cql2.datetime !== undefined)
+        out.datetime = cql2.datetime;
     if (request?.outFields && request.outFields.length > 0) {
         out.fields = { include: [...request.outFields] };
     }
@@ -3374,15 +3438,30 @@ function toStacRequest(request, collectionScope) {
         out.sortby = request.orderBy.map((s) => `${s.direction === "desc" ? "-" : ""}${s.field}`).join(",");
     }
     if (request?.spatialFilter) {
-        if (request.spatialFilter.geometryType !== "esriGeometryEnvelope") {
-            throw new Error(`stac: spatialFilter.geometryType "${request.spatialFilter.geometryType}" is not supported; only "esriGeometryEnvelope" translates to STAC bbox.`);
+        if (request.spatialFilter.geometryType === "esriGeometryEnvelope") {
+            const env = request.spatialFilter.geometry;
+            if (typeof env.xmin === "number" &&
+                typeof env.ymin === "number" &&
+                typeof env.xmax === "number" &&
+                typeof env.ymax === "number") {
+                out.bbox = [env.xmin, env.ymin, env.xmax, env.ymax];
+            }
         }
-        const env = request.spatialFilter.geometry;
-        if (typeof env.xmin === "number" &&
-            typeof env.ymin === "number" &&
-            typeof env.xmax === "number" &&
-            typeof env.ymax === "number") {
-            out.bbox = [env.xmin, env.ymin, env.xmax, env.ymax];
+        else {
+            // STAC Item Search takes an arbitrary GeoJSON geometry on `intersects`
+            // (OGC 21-047 §7.2), so a polygon AOI does not have to be degraded to
+            // its envelope. `intersects` is the only predicate the parameter
+            // expresses; refuse other spatial relationships instead of silently
+            // widening them.
+            const rel = request.spatialFilter.spatialRel;
+            if (rel !== undefined && rel !== "esriSpatialRelIntersects" && rel !== "esriSpatialRelEnvelopeIntersects") {
+                throw new Error(`stac: spatialFilter.spatialRel "${rel}" is not supported; STAC search only expresses an intersects predicate.`);
+            }
+            const geometry = toStacIntersectsGeometry(request.spatialFilter.geometry);
+            if (geometry === null) {
+                throw new Error(`stac: spatialFilter.geometryType "${request.spatialFilter.geometryType}" could not be converted to a GeoJSON geometry for STAC intersects.`);
+            }
+            out.intersects = geometry;
         }
     }
     if (collectionScope !== undefined && collectionScope !== "") {
@@ -3392,11 +3471,35 @@ function toStacRequest(request, collectionScope) {
         out.signal = request.signal;
     return out;
 }
+/**
+ * Normalize a canonical `spatialFilter.geometry` into the GeoJSON geometry
+ * STAC `intersects` expects. Esri-shaped geometries (the shape the
+ * `polygon()` / `spatialIntersects()` builders emit) are converted; a
+ * geometry that is already GeoJSON passes through untouched.
+ */
+function toStacIntersectsGeometry(geometry) {
+    if (typeof geometry.type === "string" && (geometry.coordinates !== undefined || geometry.geometries !== undefined)) {
+        return geometry;
+    }
+    const converted = esriGeometryToGeoJSON(geometry);
+    return converted === null ? null : converted;
+}
 /**
  * Project a STAC API search request onto the client-side filter params a
  * static catalog traversal applies (it has no server-side query grammar).
  */
 function toStacStaticParams(request) {
+    if (request.intersects !== undefined) {
+        // A static catalog has no search endpoint; traversal only applies the
+        // bbox / datetime / collection filters below. Silently dropping the
+        // geometry would return an unfiltered superset.
+        throw new Error("stac-static: an `intersects` geometry filter is not supported by static catalog traversal; use an envelope spatial filter.");
+    }
+    if (request.filter !== undefined) {
+        // Static traversal has no CQL2 evaluator. Dropping the predicate would
+        // return every item in the catalog, so refuse instead.
+        throw new Error("stac-static: a CQL2 attribute filter (Query.filter or Query.where) is not supported by static catalog traversal; use a STAC API endpoint or filter client-side after the result lands.");
+    }
     const out = {};
     if (request.collections && request.collections.length > 0)
         out.collections = request.collections;
@@ -3416,14 +3519,26 @@ function toTypedFeatureFromStac(feature) {
         geometry: feature.geometry,
     };
 }
-function toOgcRecordsRequest(request) {
+function toOgcRecordsRequest(request, descriptor) {
     if (!request)
         return {};
     const out = {};
-    if (request.where !== undefined) {
+    const cql2 = compileCql2QueryFilter(request, descriptor);
+    const filterParts = [];
+    if (request.where !== undefined && request.where !== "")
+        filterParts.push(request.where);
+    if (cql2.filter !== undefined)
+        filterParts.push(cql2.filter);
+    if (filterParts.length > 0) {
+        out.filter = filterParts.length === 1 ? filterParts[0] : filterParts.map((part) => `(${part})`).join(" AND ");
+        out.filterLang = "cql2-text";
+    }
+    else if (request.where !== undefined) {
         out.filter = request.where;
         out.filterLang = "cql2-text";
     }
+    if (cql2.datetime !== undefined)
+        out.datetime = cql2.datetime;
     if (request.outFields && request.outFields.length > 0)
         out.properties = [...request.outFields];
     if (request.pagination) {
@@ -3518,12 +3633,27 @@ function applyQueryAllLimit(features, limit) {
     }
     return { features: features.slice(0, limit), exceededTransferLimit: true };
 }
-function toFeatureLayerRequest(request) {
+function toFeatureLayerRequest(request, descriptor) {
     if (!request)
         return {};
     const out = {};
-    if (request.where !== undefined)
+    const ctx = queryFilterContext(descriptor);
+    // The typed filter, the deprecated source-native `where`, and a field-bound
+    // temporal predicate are conjunctive: each contributes a SQL-92 fragment and
+    // the adapter ANDs them. A spatial node inside the typed filter leaves the
+    // SQL and becomes the request's geometry parameters.
+    const compiled = compileGeoServicesQueryFilter(request, ctx);
+    const whereParts = [];
+    if (request.where !== undefined && request.where !== "")
+        whereParts.push(request.where);
+    if (compiled.where !== undefined)
+        whereParts.push(compiled.where);
+    if (whereParts.length > 0) {
+        out.where = whereParts.length === 1 ? whereParts[0] : whereParts.map((part) => `(${part})`).join(" AND ");
+    }
+    else if (request.where !== undefined) {
         out.where = request.where;
+    }
     if (request.outFields && request.outFields.length > 0)
         out.outFields = [...request.outFields];
     if (request.returnGeometry !== undefined)
@@ -3533,11 +3663,23 @@ function toFeatureLayerRequest(request) {
     if (request.orderBy && request.orderBy.length > 0) {
         out.orderByFields = request.orderBy.map((s) => `${s.field}${s.direction === "desc" ? " DESC" : ""}`).join(",");
     }
-    if (request.spatialFilter) {
-        out.geometry = request.spatialFilter.geometry;
-        out.geometryType = request.spatialFilter.geometryType;
-        if (request.spatialFilter.spatialRel)
-            out.spatialRel = request.spatialFilter.spatialRel;
+    const spatialFilter = request.spatialFilter ?? compiled.spatialFilter;
+    if (request.spatialFilter && compiled.spatialFilter) {
+        // One `query` request carries one geometry. Refuse rather than drop either
+        // constraint or silently intersect them client-side.
+        throw new HonuaCapabilityNotSupportedError("filter.spatial.multiple", descriptor.protocol, descriptor.id);
+    }
+    if (spatialFilter) {
+        out.geometry = spatialFilter.geometry;
+        out.geometryType = spatialFilter.geometryType;
+        if (spatialFilter.spatialRel)
+            out.spatialRel = spatialFilter.spatialRel;
+    }
+    if (compiled.time !== undefined) {
+        out.extraParams = {
+            ...(out.extraParams ?? {}),
+            time: compiled.time,
+        };
     }
     if (request.pagination) {
         if (request.pagination.offset !== undefined)
@@ -3549,6 +3691,58 @@ function toFeatureLayerRequest(request) {
         out.signal = request.signal;
     return out;
 }
+/** Filter-compilation identity used when refusing a construct. */
+function queryFilterContext(descriptor, geometryProperty) {
+    return {
+        protocol: descriptor.protocol,
+        sourceId: descriptor.id,
+        ...(geometryProperty !== undefined ? { geometryProperty } : {}),
+        ...descriptorQueryFilterConstraints(descriptor),
+    };
+}
+/**
+ * Bind this source's evaluated capability profile into the filter gate.
+ *
+ * A profile is per-source evidence, so it narrows — never widens — what the
+ * protocol's grammar allows: a GeoServices layer whose evidence advertises only
+ * `esriSpatialRelIntersects`, or an OGC collection whose queryables list omits
+ * `LIKE`, refuses those constructs by name even though the protocol could carry
+ * them. Sources without a profile keep the protocol-level behaviour, because
+ * absent evidence is not evidence of absence.
+ */
+function descriptorQueryFilterConstraints(descriptor) {
+    const constraints = descriptor.capabilityProfile?.entries.find((entry) => entry.id === "query")?.constraints;
+    if (!constraints)
+        return {};
+    const bound = queryFilterConstraints(constraints);
+    if (bound.supportedFilterOperators === undefined &&
+        bound.supportedSpatialPredicates === undefined &&
+        bound.supportedTemporalPredicates === undefined) {
+        return {};
+    }
+    return { ...bound, constraintSource: "capability-profile" };
+}
+/**
+ * Lower `Query.filter` + `Query.temporalFilter` onto the GeoServices request
+ * vocabulary: a SQL-92 `where` fragment, at most one geometry parameter set,
+ * and the `time=` parameter when the temporal filter targets the layer's own
+ * time dimension.
+ */
+function compileGeoServicesQueryFilter(request, ctx) {
+    const temporalExpression = request.temporalFilter
+        ? temporalFilterToExpression(request.temporalFilter, ctx)
+        : undefined;
+    const expression = andQueryFilters(request.filter, temporalExpression);
+    const compiled = expression ? compileQueryFilterToSql92(expression, ctx) : {};
+    const time = request.temporalFilter && temporalExpression === undefined
+        ? compileTemporalFilterToGeoServicesTime(request.temporalFilter, ctx)
+        : undefined;
+    return {
+        ...(compiled.where !== undefined ? { where: compiled.where } : {}),
+        ...(compiled.spatialFilter ? { spatialFilter: compiled.spatialFilter } : {}),
+        ...(time !== undefined ? { time } : {}),
+    };
+}
 /**
  * Convert a translated GeoServices request into an extent-only variant. The
  * caller's spatial filter / outSr / signal / orderByFields must survive; only
@@ -3585,6 +3779,10 @@ function hasExtentFilter(request) {
         return true;
     if (request.spatialFilter)
         return true;
+    if (request.filter !== undefined)
+        return true;
+    if (request.temporalFilter !== undefined)
+        return true;
     return false;
 }
 function computeExtentFromOgcFeatures(features) {
@@ -3641,14 +3839,26 @@ function extractExtentEnvelope(response) {
     const count = typeof obj.count === "number" && Number.isFinite(obj.count) ? obj.count : undefined;
     return { extent, count };
 }
-function toOgcRequest(request) {
+function toOgcRequest(request, descriptor) {
     if (!request)
         return {};
     const out = {};
-    if (request.where !== undefined) {
+    const cql2 = compileCql2QueryFilter(request, descriptor);
+    const filterParts = [];
+    if (request.where !== undefined && request.where !== "")
+        filterParts.push(request.where);
+    if (cql2.filter !== undefined)
+        filterParts.push(cql2.filter);
+    if (filterParts.length > 0) {
+        out.filter = filterParts.length === 1 ? filterParts[0] : filterParts.map((part) => `(${part})`).join(" AND ");
+        out.filterLang = "cql2-text";
+    }
+    else if (request.where !== undefined) {
         out.filter = request.where;
         out.filterLang = "cql2-text";
     }
+    if (cql2.datetime !== undefined)
+        out.datetime = cql2.datetime;
     if (request.outFields && request.outFields.length > 0)
         out.properties = [...request.outFields];
     if (request.outSr !== undefined)
@@ -3698,12 +3908,42 @@ function toOgcRequest(request) {
  * `offset` would silently materialize only a window of the match set and break
  * the whole-result contract those methods promise.
  */
-function toOgcMaterializedRequest(request) {
-    const { limit: _limit, offset: _offset, ...out } = toOgcRequest(request);
+function toOgcMaterializedRequest(request, descriptor) {
+    const { limit: _limit, offset: _offset, ...out } = toOgcRequest(request, descriptor);
     void _limit;
     void _offset;
     return out;
 }
+/**
+ * Compile `Query.filter` / `Query.temporalFilter` for the CQL2 protocols (OGC
+ * API Features, OGC API Records, STAC). A temporal filter without a field is
+ * the protocol's own `datetime=` parameter; with a field it becomes a CQL2
+ * temporal predicate so the constraint stays exact.
+ */
+function compileCql2QueryFilter(request, descriptor) {
+    const ctx = queryFilterContext(descriptor, ogcGeometryProperty(descriptor));
+    const temporalExpression = request.temporalFilter
+        ? temporalFilterToExpression(request.temporalFilter, ctx)
+        : undefined;
+    const expression = andQueryFilters(request.filter, temporalExpression);
+    const filter = expression ? compileQueryFilterToCql2Text(expression, ctx, geometryToWkt) : undefined;
+    const datetime = request.temporalFilter && temporalExpression === undefined
+        ? compileTemporalFilterToOgcDatetime(request.temporalFilter, ctx)
+        : undefined;
+    return {
+        ...(filter !== undefined ? { filter } : {}),
+        ...(datetime !== undefined ? { datetime } : {}),
+    };
+}
+/**
+ * Geometry property a CQL2 spatial predicate references. OGC collections
+ * default to the GeoJSON `geometry` member; `locator.geometryName` pins a
+ * server that publishes a differently named queryable.
+ */
+function ogcGeometryProperty(descriptor) {
+    const declared = descriptor.locator.geometryName;
+    return typeof declared === "string" && declared.length > 0 ? declared : "geometry";
+}
 function featureLayerResultFromTyped(response) {
     return {
         features: response.features ?? [],