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

package/core/wfs-capabilities.js

@@ -19,6 +19,15 @@
  * @module
  */
 import { HonuaWfsExceptionError } from "./errors.js";
+/** Fixed allocation ceilings for every WFS metadata XML document. */
+export const WFS_XML_LIMITS = Object.freeze({
+    maxBytes: 2 * 1024 * 1024,
+    maxElements: 12_000,
+    maxDepth: 32,
+    maxAttributesPerElement: 64,
+    maxAttributeBytesPerElement: 64 * 1024,
+    maxTextBytes: 512 * 1024,
+});
 /**
  * Parse a WFS `GetCapabilities` document. Throws when the document declares
  * a DOCTYPE / ENTITY (XXE defense) or when the root element is not
@@ -73,7 +82,7 @@ export function parseWfsCapabilities(xml) {
                 for (const value of findChildren(allowed, "Value")) {
                     const text = value.text.trim();
                     if (text)
-                        outputFormats.push(text.toLowerCase());
+                        outputFormats.push(text);
                 }
             }
             // Older WFS servers advertise output formats as direct <Value> children
@@ -81,17 +90,19 @@ export function parseWfsCapabilities(xml) {
             for (const value of findChildren(param, "Value")) {
                 const text = value.text.trim();
                 if (text)
-                    outputFormats.push(text.toLowerCase());
+                    outputFormats.push(text);
             }
         }
-        operations.set(name, {
+        const immutableMethods = Object.freeze([...new Set(methods)]);
+        const immutableOutputFormats = Object.freeze([...outputFormats]);
+        operations.set(name, Object.freeze({
             name,
-            methods: [...new Set(methods)],
-            outputFormats,
+            methods: immutableMethods,
+            outputFormats: immutableOutputFormats,
             ...(getUrl !== undefined ? { getUrl } : {}),
             ...(postUrl !== undefined ? { postUrl } : {}),
-        });
-        outputFormatsByOp.set(name, outputFormats);
+        }));
+        outputFormatsByOp.set(name, immutableOutputFormats);
     }
     const featureTypeList = findChild(root, "FeatureTypeList");
     const featureTypes = [];
@@ -100,11 +111,18 @@ export function parseWfsCapabilities(xml) {
             const nameNode = findChild(ft, "Name");
             const titleNode = findChild(ft, "Title");
             const defaultCrsNode = findChild(ft, "DefaultCRS") ?? findChild(ft, "DefaultSRS");
+            const otherCrs = [
+                ...findChildren(ft, "OtherCRS").map((node) => node.text.trim()),
+                ...findChildren(ft, "OtherSRS").map((node) => node.text.trim()),
+            ].filter((value) => value.length > 0);
             const bboxNode = findChild(ft, "WGS84BoundingBox");
             const lowerCorner = bboxNode ? findChild(bboxNode, "LowerCorner") : undefined;
             const upperCorner = bboxNode ? findChild(bboxNode, "UpperCorner") : undefined;
+            const namespace = nameNode ? namespaceBindingForQName(nameNode, nameNode.text.trim()) : undefined;
             const entry = {
                 name: nameNode?.text.trim() ?? "",
+                otherCrs: Object.freeze([...otherCrs]),
+                ...(namespace ? { namespace } : {}),
             };
             if (titleNode?.text)
                 entry.title = titleNode.text.trim();
@@ -114,11 +132,11 @@ export function parseWfsCapabilities(xml) {
                 const [xmin, ymin] = lowerCorner.text.trim().split(/\s+/).map(Number);
                 const [xmax, ymax] = upperCorner.text.trim().split(/\s+/).map(Number);
                 if (Number.isFinite(xmin) && Number.isFinite(ymin) && Number.isFinite(xmax) && Number.isFinite(ymax)) {
-                    entry.wgs84BoundingBox = { xmin, ymin, xmax, ymax };
+                    entry.wgs84BoundingBox = Object.freeze({ xmin, ymin, xmax, ymax });
                 }
             }
             if (entry.name)
-                featureTypes.push(entry);
+                featureTypes.push(Object.freeze(entry));
         }
     }
     const filterCapabilities = parseFilterCapabilities(findChild(root, "Filter_Capabilities"));
@@ -128,17 +146,61 @@ export function parseWfsCapabilities(xml) {
         if (name.startsWith("xmlns:") && value)
             namespaces.set(name.slice("xmlns:".length), value);
     }
-    const snapshot = {
-        operations,
-        outputFormatsByOp,
-        featureTypes,
-        namespaces,
-        filterCapabilities,
-        storedQueryNames,
+    return Object.freeze({
+        ...(version ? { version } : {}),
+        operations: immutableMap(operations),
+        outputFormatsByOp: immutableMap(outputFormatsByOp),
+        featureTypes: Object.freeze([...featureTypes]),
+        namespaces: immutableMap(namespaces),
+        filterCapabilities: immutableFilterCapabilities(filterCapabilities),
+        storedQueryNames: Object.freeze([...storedQueryNames]),
+    });
+}
+function namespaceBindingForQName(node, qname) {
+    const separator = qname.indexOf(":");
+    if (separator <= 0 || separator === qname.length - 1 || qname.indexOf(":", separator + 1) !== -1) {
+        return undefined;
+    }
+    const prefix = qname.slice(0, separator);
+    return Object.freeze({ prefix, uri: node.namespaces[prefix] ?? "" });
+}
+function immutableMap(source) {
+    const owned = new Map(source);
+    const view = {
+        get size() {
+            return owned.size;
+        },
+        get(key) {
+            return owned.get(key);
+        },
+        has(key) {
+            return owned.has(key);
+        },
+        forEach(callbackfn, thisArg) {
+            for (const [key, value] of owned)
+                callbackfn.call(thisArg, value, key, view);
+        },
+        entries() {
+            return owned.entries();
+        },
+        keys() {
+            return owned.keys();
+        },
+        values() {
+            return owned.values();
+        },
+        [Symbol.iterator]() {
+            return owned[Symbol.iterator]();
+        },
     };
-    if (version)
-        snapshot.version = version;
-    return snapshot;
+    return Object.freeze(view);
+}
+function immutableFilterCapabilities(value) {
+    return Object.freeze({
+        spatial: Object.freeze([...value.spatial]),
+        scalar: Object.freeze([...value.scalar]),
+        temporal: Object.freeze([...value.temporal]),
+    });
 }
 /**
  * Parse an `ows:ExceptionReport` document into structured fields. Used when
@@ -235,6 +297,106 @@ export function parseListStoredQueriesResponse(xml) {
     }
     return ids;
 }
+/**
+ * GML property types that carry a geometry value. A `DescribeFeatureType`
+ * XSD names the feature type's geometry property through one of these, so the
+ * set is what lets the adapter resolve the real property name per server
+ * (`the_geom` on PostGIS-via-GeoServer, `msGeometry` on MapServer, arbitrary
+ * per-schema names elsewhere) instead of assuming one vendor default.
+ */
+const GML_GEOMETRY_PROPERTY_TYPES = new Set([
+    "GeometryPropertyType",
+    "GeometryAssociationType",
+    "GeometryArrayPropertyType",
+    "MultiGeometryPropertyType",
+    "AbstractGeometryType",
+    "PointPropertyType",
+    "MultiPointPropertyType",
+    "LineStringPropertyType",
+    "MultiLineStringPropertyType",
+    "CurvePropertyType",
+    "MultiCurvePropertyType",
+    "PolygonPropertyType",
+    "MultiPolygonPropertyType",
+    "SurfacePropertyType",
+    "MultiSurfacePropertyType",
+    "SolidPropertyType",
+    "MultiSolidPropertyType",
+]);
+/** GML namespace prefixes bind to a URI under this root in every GML version. */
+const GML_NAMESPACE_ROOT = "http://www.opengis.net/gml";
+/**
+ * Parse a `DescribeFeatureType` XSD and return the geometry property names
+ * declared for `typeName`, in schema declaration order. Empty when the schema
+ * declares no GML geometry property (schema-less / non-spatial types) — the
+ * caller fails closed rather than guessing a vendor default.
+ *
+ * Only the requested feature type's own complex type is walked, so a schema
+ * carrying several types cannot leak another type's geometry property.
+ */
+export function parseWfsDescribeFeatureTypeGeometry(xml, typeName) {
+    const root = parseXml(xml);
+    if (root.local !== "schema") {
+        if (root.local === "ExceptionReport") {
+            const report = parseExceptionFromRoot(root);
+            throw new HonuaWfsExceptionError(report.exceptionCode, report.message, report.locator);
+        }
+        throw new Error(`WFS DescribeFeatureType: expected <schema>, got <${root.qname}>`);
+    }
+    const declaration = findFeatureTypeDeclaration(root, stripPrefix(typeName));
+    if (!declaration)
+        return Object.freeze([]);
+    const names = [];
+    collectGeometryPropertyNames(declaration, names);
+    return Object.freeze(names);
+}
+/**
+ * Locate the complex type that declares one feature type's properties. Servers
+ * spell this three ways: a global `<element name="lot" type="ns:lotType"/>`
+ * pointing at a named `<complexType>`, an inline anonymous `<complexType>` on
+ * that element, or (single-type responses) just the one complex type in the
+ * document.
+ */
+function findFeatureTypeDeclaration(root, localTypeName) {
+    const complexTypes = findChildren(root, "complexType");
+    const element = findChildren(root, "element").find((node) => node.attributes.name === localTypeName);
+    if (element) {
+        const typeRef = element.attributes.type;
+        const named = typeRef
+            ? complexTypes.find((node) => node.attributes.name === stripPrefix(typeRef))
+            : findChild(element, "complexType");
+        if (named)
+            return named;
+    }
+    const conventional = complexTypes.find((node) => node.attributes.name === `${localTypeName}Type`);
+    if (conventional)
+        return conventional;
+    return complexTypes.length === 1 ? complexTypes[0] : undefined;
+}
+function collectGeometryPropertyNames(node, out) {
+    for (const child of node.children) {
+        if (child.local === "element") {
+            const name = child.attributes.name;
+            const type = child.attributes.type;
+            if (name && type && isGmlGeometryPropertyType(child, type)) {
+                out.push(name);
+                continue;
+            }
+        }
+        collectGeometryPropertyNames(child, out);
+    }
+}
+function isGmlGeometryPropertyType(node, type) {
+    const colon = type.indexOf(":");
+    const prefix = colon > 0 ? type.slice(0, colon) : undefined;
+    if (!GML_GEOMETRY_PROPERTY_TYPES.has(stripPrefix(type)))
+        return false;
+    // A prefix that resolves to a non-GML namespace is a same-named schema type
+    // from another vocabulary, not a geometry property. An unresolvable prefix
+    // is accepted: servers routinely omit the binding from the fragment we read.
+    const uri = prefix === undefined ? undefined : node.namespaces[prefix];
+    return uri === undefined || uri.startsWith(GML_NAMESPACE_ROOT);
+}
 export function parseWfsTransactionResponse(xml) {
     const root = parseXml(xml);
     if (root.local !== "TransactionResponse") {
@@ -291,6 +453,9 @@ export function parseXml(xml) {
     if (typeof xml !== "string" || xml.length === 0) {
         throw new Error("WFS XML parser: empty document");
     }
+    if (utf8Length(xml) > WFS_XML_LIMITS.maxBytes) {
+        throw new Error(`WFS XML parser: document exceeds the ${WFS_XML_LIMITS.maxBytes}-byte limit`);
+    }
     // XXE / external-entity defense: refuse documents that declare a DOCTYPE
     // (which is the only way to introduce ENTITY declarations in XML 1.0).
     // This is intentionally strict — Honua's WFS surfaces never emit a
@@ -305,6 +470,7 @@ export function parseXml(xml) {
     let i = 0;
     const stack = [];
     let root;
+    const budget = { elements: 0, textBytes: 0 };
     while (i < len) {
         if (stripped[i] === "<") {
             if (stripped.startsWith("<?", i)) {
@@ -328,7 +494,7 @@ export function parseXml(xml) {
                 const text = stripped.slice(i + 9, end);
                 const top = stack[stack.length - 1];
                 if (top)
-                    top.text += text;
+                    appendXmlText(top, text, budget);
                 i = end + 3;
                 continue;
             }
@@ -356,17 +522,32 @@ export function parseXml(xml) {
             const selfClosing = inner.endsWith("/");
             const tagBody = selfClosing ? inner.slice(0, -1).trim() : inner.trim();
             const { name, attributes } = parseTagBody(tagBody);
+            budget.elements += 1;
+            if (budget.elements > WFS_XML_LIMITS.maxElements) {
+                throw new Error(`WFS XML parser: document exceeds the ${WFS_XML_LIMITS.maxElements}-element limit`);
+            }
+            if (stack.length + 1 > WFS_XML_LIMITS.maxDepth) {
+                throw new Error(`WFS XML parser: document exceeds the ${WFS_XML_LIMITS.maxDepth}-level depth limit`);
+            }
             const local = stripPrefix(name);
+            const parent = stack[stack.length - 1];
+            const namespaces = Object.assign(Object.create(null), parent?.namespaces);
+            for (const [attributeName, value] of Object.entries(attributes)) {
+                if (attributeName === "xmlns")
+                    namespaces[""] = value;
+                else if (attributeName.startsWith("xmlns:"))
+                    namespaces[attributeName.slice("xmlns:".length)] = value;
+            }
             const node = {
                 local,
                 qname: name,
                 attributes,
+                namespaces,
                 children: [],
                 text: "",
             };
-            const top = stack[stack.length - 1];
-            if (top)
-                top.children.push(node);
+            if (parent)
+                parent.children.push(node);
             else if (root) {
                 throw new Error("WFS XML parser: multiple root elements");
             }
@@ -383,7 +564,7 @@ export function parseXml(xml) {
         const text = stripped.slice(i, next === -1 ? len : next);
         const top = stack[stack.length - 1];
         if (top)
-            top.text += decodeXmlEntities(text);
+            appendXmlText(top, decodeXmlEntities(text), budget);
         i = next === -1 ? len : next;
     }
     if (stack.length > 0) {
@@ -433,7 +614,9 @@ function parseTagBody(body) {
     const name = trimmed.slice(0, i);
     if (!name)
         throw new Error("WFS XML parser: missing tag name");
-    const attributes = {};
+    const attributes = Object.create(null);
+    let attributeCount = 0;
+    let attributeBytes = 0;
     let j = i;
     while (j < trimmed.length) {
         while (j < trimmed.length && /\s/.test(trimmed[j]))
@@ -442,8 +625,15 @@ function parseTagBody(body) {
             break;
         const eq = trimmed.indexOf("=", j);
         if (eq === -1)
-            break;
+            throw new Error("WFS XML parser: attribute lacks '='");
         const attrName = trimmed.slice(j, eq).trim();
+        if (attrName.length === 0 || /\s/.test(attrName)) {
+            throw new Error("WFS XML parser: invalid attribute name");
+        }
+        attributeCount += 1;
+        if (attributeCount > WFS_XML_LIMITS.maxAttributesPerElement) {
+            throw new Error("WFS XML parser: element exceeds the bounded attribute count");
+        }
         let k = eq + 1;
         while (k < trimmed.length && /\s/.test(trimmed[k]))
             k += 1;
@@ -456,11 +646,31 @@ function parseTagBody(body) {
             throw new Error(`WFS XML parser: unterminated attribute value for "${attrName}"`);
         const rawValue = trimmed.slice(k + 1, close);
         const normalizedName = attrName.startsWith("xmlns:") ? attrName : stripPrefix(attrName);
-        attributes[normalizedName] = decodeXmlEntities(rawValue);
+        const value = decodeXmlEntities(rawValue);
+        attributeBytes += utf8Length(attrName) + utf8Length(value);
+        if (attributeBytes > WFS_XML_LIMITS.maxAttributeBytesPerElement) {
+            throw new Error("WFS XML parser: element exceeds the bounded attribute-byte limit");
+        }
+        if (Object.hasOwn(attributes, normalizedName)) {
+            throw new Error(`WFS XML parser: repeated attribute "${normalizedName}"`);
+        }
+        attributes[normalizedName] = value;
         j = close + 1;
     }
     return { name, attributes };
 }
+function appendXmlText(node, value, budget) {
+    if (value.length === 0)
+        return;
+    budget.textBytes += utf8Length(value);
+    if (budget.textBytes > WFS_XML_LIMITS.maxTextBytes) {
+        throw new Error(`WFS XML parser: document exceeds the ${WFS_XML_LIMITS.maxTextBytes}-byte text limit`);
+    }
+    node.text += value;
+}
+function utf8Length(value) {
+    return new TextEncoder().encode(value).byteLength;
+}
 function stripPrefix(name) {
     const idx = name.indexOf(":");
     return idx === -1 ? name : name.slice(idx + 1);

package/core/wfs-filter.d.ts

@@ -63,6 +63,11 @@ export type FesNode = {
     op: FesSpatialOp;
     property: string;
     gml: string;
+} | {
+    kind: "temporal";
+    op: FesTemporalOp;
+    property: string;
+    time: FesTimeOperand;
 } | {
     kind: "bbox";
     property: string;
@@ -74,6 +79,19 @@ export type FesNode = {
         srsName?: string;
     };
 };
+/**
+ * FES 2.0 temporal operators the canonical filter compiles to. `AnyInteracts`
+ * is the FES spelling of "the value and the requested period overlap"; the
+ * remaining three map one-to-one onto the canonical predicates.
+ */
+export type FesTemporalOp = "Before" | "After" | "During" | "AnyInteracts";
+/** GML time primitive operand: an instant, or a (closed) period. */
+export type FesTimeOperand = {
+    readonly instant: string;
+} | {
+    readonly start: string;
+    readonly end: string;
+};
 export type FesCompareOp = "=" | "<>" | "<" | "<=" | ">" | ">=";
 export type FesSpatialOp = "Intersects" | "Within" | "Contains" | "Crosses" | "Disjoint" | "Touches" | "Overlaps" | "Equals";
 export type FesLiteral = {
@@ -91,14 +109,19 @@ export type FesLiteral = {
 export declare function compileWhere(input: string | undefined): FesCompileResult;
 /**
  * Compile the canonical `SpatialFilter` (Esri-flavored) into the FES spatial
- * leaf the adapter splices into the request. Default geometry property
- * name is `the_geom`; callers may override (some servers use `geometry`,
- * `shape`, etc.).
+ * leaf the adapter splices into the request. `geometryProperty` is required
+ * and caller-resolved: it is per feature type (`the_geom`, `msGeometry`,
+ * `shape`, …), and a wrong name silently matches nothing.
  */
 export declare function compileSpatialFilter(filter: SpatialFilter, options: {
     geometryProperty: string;
     srsName?: string;
 }): FesCompileResult;
+/**
+ * Serialize a WFS 2.0 BBOX KVP in the authority axis order of its input CRS.
+ * Canonical geometries remain x/y; only the wire tuple is swapped.
+ */
+export declare function formatWfsBboxKvp(xmin: number, ymin: number, xmax: number, ymax: number, srsName?: string): string;
 /**
  * Serialize a list of FES nodes into a single `<fes:Filter>` element. Used
  * for both the POST GetFeature body and (URL-encoded) the KVP `filter=`

package/core/wfs-filter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wfs-filter.d.ts","sourceRoot":"","sources":["../../../src/core/wfs-filter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"wfs-filter.d.ts","sourceRoot":"","sources":["../../../src/core/wfs-filter.ts"],"names":[],"mappings":"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"}

package/core/wfs-filter.js

@@ -20,6 +20,7 @@
  *
  * @module
  */
+import { requireWfsAxisOrder } from "./wfs-axis-order.js";
 /**
  * Sentinel used by the `where` compiler when the input contains a construct
  * the FES emitter does not know how to translate. Callers should treat this
@@ -53,9 +54,9 @@ export function compileWhere(input) {
 }
 /**
  * Compile the canonical `SpatialFilter` (Esri-flavored) into the FES spatial
- * leaf the adapter splices into the request. Default geometry property
- * name is `the_geom`; callers may override (some servers use `geometry`,
- * `shape`, etc.).
+ * leaf the adapter splices into the request. `geometryProperty` is required
+ * and caller-resolved: it is per feature type (`the_geom`, `msGeometry`,
+ * `shape`, …), and a wrong name silently matches nothing.
  */
 export function compileSpatialFilter(filter, options) {
     const property = options.geometryProperty;
@@ -98,49 +99,22 @@ export function compileSpatialFilter(filter, options) {
 }
 function envelopeToPolygonGml(xmin, ymin, xmax, ymax, srsName) {
     const srsAttr = srsName ? ` srsName=${attr(srsName)}` : "";
-    const latLon = srsAxisIsLatLon(srsName);
-    const c = (x, y) => formatCoord(x, y, latLon);
+    const axisOrder = requireWfsAxisOrder(srsName);
+    const c = (x, y) => formatCoord(x, y, axisOrder);
     const ring = `${c(xmin, ymin)} ${c(xmax, ymin)} ${c(xmax, ymax)} ${c(xmin, ymax)} ${c(xmin, ymin)}`;
     return `<gml:Polygon${srsAttr}><gml:exterior><gml:LinearRing><gml:posList>${ring}</gml:posList></gml:LinearRing></gml:exterior></gml:Polygon>`;
 }
 /**
- * Well-known geographic (latitude/longitude) EPSG codes. In URN
- * (`urn:ogc:def:crs:EPSG::4326`) or OGC-HTTP
- * (`http://www.opengis.net/def/crs/EPSG/0/4326`) form, WFS 2.0 / GML 3.2 require
- * authority axis order — latitude,longitude — for these CRSes, whereas the
- * legacy short `EPSG:4326` form and `CRS84` stay longitude,latitude. Projected
- * CRSes (easting,northing) already match the canonical x,y order, so they are
- * intentionally excluded.
+ * Serialize a WFS 2.0 BBOX KVP in the authority axis order of its input CRS.
+ * Canonical geometries remain x/y; only the wire tuple is swapped.
  */
-const LATLON_GEOGRAPHIC_EPSG = new Set([
-    4326, 4979, 4258, 4269, 4267, 4203, 4283, 4759, 4490, 4674, 4617, 4612, 4619, 4668, 4555,
-]);
-/**
- * Decide whether a `srsName` implies latitude,longitude axis order. Defaults to
- * longitude,latitude (the canonical x,y order) for the legacy short EPSG form,
- * CRS84, unknown codes, and an absent srsName — preserving existing behavior and
- * avoiding regressions for callers that already supply lon,lat-oriented CRSes.
- */
-function srsAxisIsLatLon(srsName) {
-    if (!srsName)
-        return false;
-    const value = srsName.trim();
-    // CRS84 / CRS:84 are explicitly longitude,latitude regardless of form.
-    if (/(?:^|[:/])CRS:?84$/i.test(value) || /CRS84/i.test(value))
-        return false;
-    // URN form: urn:ogc:def:crs:EPSG::4326 (the version segment may be empty).
-    const urn = value.match(/^urn:[\w-]+:def:crs:EPSG:[^:]*:(\d+)$/i);
-    // OGC HTTP form: http://www.opengis.net/def/crs/EPSG/0/4326
-    const http = value.match(/def\/crs\/EPSG\/[^/]+\/(\d+)$/i);
-    const code = urn?.[1] ?? http?.[1];
-    // The legacy short "EPSG:4326" form keeps GIS-conventional lon,lat order.
-    if (!code)
-        return false;
-    return LATLON_GEOGRAPHIC_EPSG.has(Number(code));
+export function formatWfsBboxKvp(xmin, ymin, xmax, ymax, srsName) {
+    const coordinates = requireWfsAxisOrder(srsName) === "yx" ? [ymin, xmin, ymax, xmax] : [xmin, ymin, xmax, ymax];
+    return `${coordinates.join(",")}${srsName ? `,${srsName}` : ""}`;
 }
 /** Serialize a coordinate pair honoring the resolved CRS axis order. */
-function formatCoord(x, y, latLon) {
-    return latLon ? `${y} ${x}` : `${x} ${y}`;
+function formatCoord(x, y, axisOrder) {
+    return axisOrder === "yx" ? `${y} ${x}` : `${x} ${y}`;
 }
 function mapSpatialRel(rel) {
     switch (rel) {
@@ -211,6 +185,8 @@ function serializeNode(node) {
             return `<fes:PropertyIsNull><fes:ValueReference>${escapeXml(node.property)}</fes:ValueReference></fes:PropertyIsNull>`;
         case "spatial":
             return `<fes:${node.op}><fes:ValueReference>${escapeXml(node.property)}</fes:ValueReference>${node.gml}</fes:${node.op}>`;
+        case "temporal":
+            return `<fes:${node.op}><fes:ValueReference>${escapeXml(node.property)}</fes:ValueReference>${timeGml(node.time)}</fes:${node.op}>`;
         case "bbox":
             return `<fes:BBOX><fes:ValueReference>${escapeXml(node.property)}</fes:ValueReference>${envelopeGml(node.envelope)}</fes:BBOX>`;
     }
@@ -245,10 +221,31 @@ function escapeXml(input) {
 function attr(value) {
     return `"${value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;")}"`;
 }
+/**
+ * GML 3.2 time primitive for a FES temporal predicate. FES temporal operators
+ * take a `gml:TimeInstant` or `gml:TimePeriod` as their second operand; the
+ * `gml:id` is required by the GML schema and is derived from the position so
+ * the same filter always serializes to the same bytes.
+ */
+function timeGml(time) {
+    if ("instant" in time) {
+        return `<gml:TimeInstant gml:id=${attr(timeGmlId(time.instant))}><gml:timePosition>${escapeXml(time.instant)}</gml:timePosition></gml:TimeInstant>`;
+    }
+    return `<gml:TimePeriod gml:id=${attr(timeGmlId(`${time.start}_${time.end}`))}><gml:beginPosition>${escapeXml(time.start)}</gml:beginPosition><gml:endPosition>${escapeXml(time.end)}</gml:endPosition></gml:TimePeriod>`;
+}
+/** Deterministic NCName for a GML time primitive. */
+function timeGmlId(seed) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < seed.length; index += 1) {
+        hash ^= seed.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return `honua-t${hash.toString(16)}`;
+}
 function envelopeGml(env) {
     const srsAttr = env.srsName ? ` srsName=${attr(env.srsName)}` : "";
-    const latLon = srsAxisIsLatLon(env.srsName);
-    return `<gml:Envelope${srsAttr}><gml:lowerCorner>${formatCoord(env.xmin, env.ymin, latLon)}</gml:lowerCorner><gml:upperCorner>${formatCoord(env.xmax, env.ymax, latLon)}</gml:upperCorner></gml:Envelope>`;
+    const axisOrder = requireWfsAxisOrder(env.srsName);
+    return `<gml:Envelope${srsAttr}><gml:lowerCorner>${formatCoord(env.xmin, env.ymin, axisOrder)}</gml:lowerCorner><gml:upperCorner>${formatCoord(env.xmax, env.ymax, axisOrder)}</gml:upperCorner></gml:Envelope>`;
 }
 /**
  * Translate a GeoJSON-style geometry into a tiny GML 3.2 fragment. Only the
@@ -258,14 +255,14 @@ function envelopeGml(env) {
  */
 function geometryToGml(geometry, geometryType, srsName) {
     const srsAttr = srsName ? ` srsName=${attr(srsName)}` : "";
-    const latLon = srsAxisIsLatLon(srsName);
+    const axisOrder = requireWfsAxisOrder(srsName);
     switch (geometryType) {
         case "esriGeometryPoint": {
             const x = geometry.x;
             const y = geometry.y;
             if (typeof x !== "number" || typeof y !== "number")
                 return undefined;
-            return `<gml:Point${srsAttr}><gml:pos>${formatCoord(x, y, latLon)}</gml:pos></gml:Point>`;
+            return `<gml:Point${srsAttr}><gml:pos>${formatCoord(x, y, axisOrder)}</gml:pos></gml:Point>`;
         }
         case "esriGeometryPolyline": {
             const paths = geometry.paths;
@@ -276,7 +273,7 @@ function geometryToGml(geometry, geometryType, srsName) {
             if (!Array.isArray(path))
                 return undefined;
             const coords = path
-                .map((p) => (Array.isArray(p) ? formatCoord(p[0], p[1], latLon) : ""))
+                .map((p) => (Array.isArray(p) ? formatCoord(p[0], p[1], axisOrder) : ""))
                 .filter(Boolean)
                 .join(" ");
             if (!coords)
@@ -287,12 +284,12 @@ function geometryToGml(geometry, geometryType, srsName) {
             const rings = geometry.rings;
             if (!Array.isArray(rings) || rings.length === 0)
                 return undefined;
-            const exterior = ringToPosList(rings[0], latLon);
+            const exterior = ringToPosList(rings[0], axisOrder);
             if (!exterior)
                 return undefined;
             const interiors = [];
             for (let i = 1; i < rings.length; i += 1) {
-                const inner = ringToPosList(rings[i], latLon);
+                const inner = ringToPosList(rings[i], axisOrder);
                 if (!inner)
                     return undefined;
                 interiors.push(`<gml:interior><gml:LinearRing><gml:posList>${inner}</gml:posList></gml:LinearRing></gml:interior>`);
@@ -303,11 +300,11 @@ function geometryToGml(geometry, geometryType, srsName) {
             return undefined;
     }
 }
-function ringToPosList(ring, latLon) {
+function ringToPosList(ring, axisOrder) {
     if (!Array.isArray(ring) || ring.length < 3)
         return undefined;
     return ring
-        .map((p) => (Array.isArray(p) ? formatCoord(p[0], p[1], latLon) : ""))
+        .map((p) => (Array.isArray(p) ? formatCoord(p[0], p[1], axisOrder) : ""))
         .filter(Boolean)
         .join(" ");
 }
@@ -320,11 +317,9 @@ export function geoJsonGeometryToGml(geometry, srsName) {
         return undefined;
     const geom = geometry;
     const srsAttr = srsName ? ` srsName=${attr(srsName)}` : "";
-    // Honor GML 3.2 axis order for the resolved CRS, mirroring the query-path
-    // emitters: authority (URN/HTTP) forms of geographic CRSes are lat,lon while
-    // the legacy short `EPSG:4326` form and CRS84 stay lon,lat.
-    const latLon = srsAxisIsLatLon(srsName);
-    const c = (p) => formatCoord(p[0], p[1], latLon);
+    // Honor the authority definition for every supported CRS spelling.
+    const axisOrder = requireWfsAxisOrder(srsName);
+    const c = (p) => formatCoord(p[0], p[1], axisOrder);
     switch (geom.type) {
         case "Point": {
             const coord = geom.coordinates;

package/core/wfs-protocol-error.d.ts

@@ -0,0 +1,12 @@
+import { HonuaSdkError } from "./error-envelope.js";
+export type WfsProtocolErrorReason = "invalid-capabilities" | "invalid-feature-response" | "paging-stalled" | "unknown-axis-order"
+/** `DescribeFeatureType` did not yield the feature type's geometry property. */
+ | "unresolved-geometry-property";
+/** Typed, credential-safe fail-closed WFS protocol error. */
+export declare class HonuaWfsProtocolError extends HonuaSdkError {
+    readonly reason: WfsProtocolErrorReason;
+    constructor(reason: WfsProtocolErrorReason, message: string, options?: {
+        readonly cause?: unknown;
+    });
+}
+//# sourceMappingURL=wfs-protocol-error.d.ts.map

package/core/wfs-protocol-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wfs-protocol-error.d.ts","sourceRoot":"","sources":["../../../src/core/wfs-protocol-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,MAAM,MAAM,sBAAsB,GAC9B,sBAAsB,GACtB,0BAA0B,GAC1B,gBAAgB,GAChB,oBAAoB;AACtB,gFAAgF;GAC9E,8BAA8B,CAAC;AAEnC,6DAA6D;AAC7D,qBAAa,qBAAsB,SAAQ,aAAa;aAEpC,MAAM,EAAE,sBAAsB;gBAA9B,MAAM,EAAE,sBAAsB,EAC9C,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;QAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAO;CAQ7C"}