@honua/app-platform 0.0.20-alpha.0

package/core/ogc-conformance.d.ts

@@ -0,0 +1,35 @@
+/**
+ * OGC API conformance-class → canonical capability mapping. The
+ * conformance class identifiers are intentionally kept *internal* to
+ * this module — `negotiateOgcCapabilities` is the only public surface
+ * that maps from the server-advertised list onto canonical capability
+ * names. Top-level SDK types must not expose conformance-class names
+ * (acceptance criterion).
+ *
+ * @module
+ */
+import type { Capabilities, Protocol } from "../contract/types.js";
+import type { HonuaOgcConformanceResponse } from "./types.js";
+/** Subset of `Protocol` for which OGC-style conformance applies. */
+export type OgcConformanceProtocol = Extract<Protocol, "ogc-features" | "ogc-tiles" | "ogc-maps" | "ogc-records" | "stac"> | "ogc-processes";
+/**
+ * Translate the server-advertised `conformsTo[]` list into a canonical
+ * `Capabilities` set for the given protocol. Conformance class
+ * identifiers are matched against substring keys so version drift
+ * (`features-1` → `features-3`) does not silently drop capabilities.
+ *
+ * Callers can intersect the result with their own narrower set when
+ * they want to gate optional features even if the server claims them.
+ */
+export declare function negotiateOgcCapabilities(protocol: OgcConformanceProtocol, conformance: HonuaOgcConformanceResponse | {
+    conformsTo?: readonly string[];
+} | undefined): Capabilities;
+/**
+ * `true` when the conformance response advertises a class containing
+ * the given substring. Lets callers gate features on a specific
+ * extension without exposing the URI as a primary SDK type.
+ */
+export declare function hasOgcConformanceClass(conformance: HonuaOgcConformanceResponse | {
+    conformsTo?: readonly string[];
+} | undefined, classSubstring: string): boolean;
+//# sourceMappingURL=ogc-conformance.d.ts.map

package/core/ogc-conformance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ogc-conformance.d.ts","sourceRoot":"","sources":["../../../src/core/ogc-conformance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAc,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAE/E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AA8F9D,oEAAoE;AACpE,MAAM,MAAM,sBAAsB,GAC9B,OAAO,CAAC,QAAQ,EAAE,cAAc,GAAG,WAAW,GAAG,UAAU,GAAG,aAAa,GAAG,MAAM,CAAC,GACrF,eAAe,CAAC;AAEpB;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,sBAAsB,EAChC,WAAW,EAAE,2BAA2B,GAAG;IAAE,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAAG,SAAS,GACxF,YAAY,CAad;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,2BAA2B,GAAG;IAAE,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAAG,SAAS,EACzF,cAAc,EAAE,MAAM,GACrB,OAAO,CAMT"}

package/core/ogc-conformance.js

@@ -0,0 +1,134 @@
+/**
+ * OGC API conformance-class → canonical capability mapping. The
+ * conformance class identifiers are intentionally kept *internal* to
+ * this module — `negotiateOgcCapabilities` is the only public surface
+ * that maps from the server-advertised list onto canonical capability
+ * names. Top-level SDK types must not expose conformance-class names
+ * (acceptance criterion).
+ *
+ * @module
+ */
+import { capabilities } from "../contract/types.js";
+/**
+ * Mapping from OGC conformance-class URI segments to one or more
+ * canonical capabilities. Stored as substring keys because the server
+ * may version the path differently (`features-1`, `features-2`,
+ * `features-3`, `features-4` — and OGC has been re-issuing the URIs
+ * over time). A substring match against `conformsTo[]` covers both
+ * versions.
+ */
+const FEATURE_CONFORMANCE_MAP = [
+    ["features-1/1.0/conf/core", ["query", "queryObjectIds"]],
+    ["features-1/1.0/conf/oas3", []],
+    ["features-1/1.0/conf/oas30", []],
+    ["features-1/1.0/conf/geojson", []],
+    ["features-1/1.0/conf/html", []],
+    ["features-1/1.0/conf/crs", []],
+    ["features-3/1.0/conf/filter", ["queryAggregate"]],
+    ["features-3/1.0/conf/features-filter", ["queryAggregate"]],
+    ["features-3/1.0/conf/queryables", []],
+    ["features-3/1.0/conf/cql2-text", []],
+    ["features-3/1.0/conf/cql2-json", []],
+    ["features-4/1.0/conf/create-replace-delete", ["applyEdits"]],
+    ["features-4/1.0/conf/transactions", ["applyEdits"]],
+    ["features-2/1.0/conf/sql", ["sql"]],
+];
+const TILE_CONFORMANCE_MAP = [
+    ["tiles-1/1.0/conf/core", ["tiles"]],
+    ["tiles-1/1.0/conf/tileset", ["tiles"]],
+    ["tiles-1/1.0/conf/tilesets-list", ["tiles"]],
+    ["tiles-1/1.0/conf/dataset-tilesets", ["tiles"]],
+    ["tiles-1/1.0/conf/geodata-tilesets", ["tiles"]],
+    ["tiles-1/1.0/conf/geodata-selection", ["tiles"]],
+    ["tiles-1/1.0/conf/multi-tile", ["tiles"]],
+    ["tiles-1/1.0/conf/oas30", []],
+    ["tiles-1/1.0/conf/mvt", ["tiles", "render"]],
+    ["tiles-1/1.0/conf/png", ["tiles", "render"]],
+    ["tiles-1/1.0/conf/jpeg", ["tiles", "render"]],
+];
+const MAP_CONFORMANCE_MAP = [
+    ["maps-1/1.0/conf/core", ["render"]],
+    ["maps-1/1.0/conf/dataset-map", ["render"]],
+    ["maps-1/1.0/conf/collection-map", ["render"]],
+    ["maps-1/1.0/conf/scaling", ["render"]],
+    ["maps-1/1.0/conf/spatial-subsetting", ["render"]],
+    ["maps-1/1.0/conf/png", ["render"]],
+    ["maps-1/1.0/conf/jpeg", ["render"]],
+    ["styles-1/1.0/conf/core", ["render"]],
+];
+const PROCESS_CONFORMANCE_MAP = [
+    ["processes-1/1.0/conf/core", ["processes"]],
+    ["processes-1/1.0/conf/ogc-process-description", ["processes"]],
+    ["processes-1/1.0/conf/job-list", ["processes"]],
+    ["processes-1/1.0/conf/dismiss", ["processes"]],
+    ["processes-1/1.0/conf/callback", ["processes"]],
+];
+const RECORDS_CONFORMANCE_MAP = [
+    ["ogcapi-records-1/1.0/conf/records-api", ["query", "queryObjectIds"]],
+    ["ogcapi-records-1/1.0/conf/searchable-catalog", ["query", "queryObjectIds"]],
+    ["ogcapi-records-1/1.0/conf/record-core-query-parameters", ["query"]],
+    ["ogcapi-records-1/1.0/conf/cql-filter", ["query"]],
+    ["ogcapi-records-1/1.0/conf/searchable-catalog-filtering", ["query"]],
+    ["ogcapi-records-1/1.0/conf/sorting", ["query"]],
+    ["ogcapi-records-1/1.0/conf/searchable-catalog/sorting", ["query"]],
+    ["ogcapi-records-1/1.0/conf/json", []],
+    ["ogcapi-records-1/1.0/conf/html", []],
+    ["ogcapi-records-1/1.0/conf/oas30", []],
+];
+const STAC_CONFORMANCE_MAP = [
+    ["stac-spec.org", ["query", "queryObjectIds"]],
+    ["api.stacspec.org/v1.0.0/core", ["query"]],
+    ["api.stacspec.org/v1.0.0/item-search", ["query", "queryObjectIds"]],
+    ["api.stacspec.org/v1.0.0/ogcapi-features", ["query", "queryObjectIds"]],
+    ["api.stacspec.org/v1.0.0/collections", []],
+    // STAC's `filter` extension is CQL2 query-side filtering, not server-side
+    // aggregation. The STAC source adapter has no aggregation implementation,
+    // so this conformance class must not advertise `queryAggregate`.
+    ["api.stacspec.org/v1.0.0/filter", []],
+];
+const CONFORMANCE_TABLES = {
+    "ogc-features": FEATURE_CONFORMANCE_MAP,
+    "ogc-tiles": TILE_CONFORMANCE_MAP,
+    "ogc-maps": MAP_CONFORMANCE_MAP,
+    "ogc-processes": PROCESS_CONFORMANCE_MAP,
+    "ogc-records": RECORDS_CONFORMANCE_MAP,
+    stac: STAC_CONFORMANCE_MAP,
+};
+/**
+ * Translate the server-advertised `conformsTo[]` list into a canonical
+ * `Capabilities` set for the given protocol. Conformance class
+ * identifiers are matched against substring keys so version drift
+ * (`features-1` → `features-3`) does not silently drop capabilities.
+ *
+ * Callers can intersect the result with their own narrower set when
+ * they want to gate optional features even if the server claims them.
+ */
+export function negotiateOgcCapabilities(protocol, conformance) {
+    const table = CONFORMANCE_TABLES[protocol];
+    const advertised = conformance?.conformsTo ?? [];
+    const out = new Set();
+    for (const uri of advertised) {
+        if (typeof uri !== "string")
+            continue;
+        for (const [needle, caps] of table) {
+            if (uri.includes(needle)) {
+                for (const cap of caps)
+                    out.add(cap);
+            }
+        }
+    }
+    return capabilities(Array.from(out));
+}
+/**
+ * `true` when the conformance response advertises a class containing
+ * the given substring. Lets callers gate features on a specific
+ * extension without exposing the URI as a primary SDK type.
+ */
+export function hasOgcConformanceClass(conformance, classSubstring) {
+    const advertised = conformance?.conformsTo ?? [];
+    for (const uri of advertised) {
+        if (typeof uri === "string" && uri.includes(classSubstring))
+            return true;
+    }
+    return false;
+}

package/core/ogc-endpoint-layout.d.ts

@@ -0,0 +1,70 @@
+/**
+ * OGC API endpoint-layout resolution.
+ *
+ * The SDK's headline claim is one typed contract against ANY standards
+ * server. For OGC API Features / Records that means the client must not
+ * assume a fixed path prefix: a Honua Server mounts the facade at
+ * `/ogc/features/...`, but pygeoapi, ldproxy, and GeoServer's OGC API each
+ * serve the landing page at their own root and advertise their collections
+ * and conformance URLs through the landing page's `links` array
+ * (OGC API - Common Requirement 5).
+ *
+ * This module produces an {@link OgcEndpointLayout} — the concrete set of
+ * resource paths a Features client addresses:
+ *
+ *  - {@link honuaFacadeFeaturesLayout} is the fixed facade layout and the
+ *    default. It performs no network round-trips, so existing callers see
+ *    zero behaviour change.
+ *  - {@link resolveOgcEndpointLayout} discovers the layout from the landing
+ *    page (`ogc-api` mode) or auto-detects the facade first and falls back
+ *    to discovery (`auto` mode).
+ *
+ * Per OGC API - Features Requirement 17 the items resource is always at
+ * `{collections}/{collectionId}/items`, so a single landing-page fetch is
+ * enough to derive every per-collection path from the discovered
+ * collections URL.
+ *
+ * @module
+ */
+import type { HonuaProtocolTransport } from "./protocol-transport.js";
+import type { OgcEndpointLayout } from "./types.js";
+/** Discovery mode carried on a source locator. */
+export type OgcApiLayoutMode = "honua-facade" | "ogc-api" | "auto";
+/**
+ * The Honua Server facade layout (`/ogc/features/...`). No network access;
+ * this is the default fast path and preserves the pre-existing behaviour of
+ * every OGC Features caller that points at a Honua Server.
+ */
+export declare function honuaFacadeFeaturesLayout(base?: string): OgcEndpointLayout;
+/**
+ * A raw OGC API layout built from a discovered (or configured) landing +
+ * collections + conformance URL triple. Per-collection paths are templated
+ * off the collections URL per OGC API - Features Requirement 17.
+ */
+export declare function ogcApiFeaturesLayout(options: {
+    landingUrl: string;
+    collectionsUrl: string;
+    conformanceUrl: string;
+}): OgcEndpointLayout;
+/**
+ * Find the first link whose `rel` matches one of `rels` (exact or as the
+ * final path segment of a full OGC relation URI, e.g.
+ * `http://www.opengis.net/def/rel/ogc/1.0/data`).
+ */
+export declare function findOgcLink(links: ReadonlyArray<{
+    href?: string;
+    rel?: string;
+}> | undefined, ...rels: string[]): string | undefined;
+/**
+ * Resolve the endpoint layout for the requested `mode`:
+ *
+ *  - `honua-facade` (default) — the fixed facade layout, no round-trips.
+ *  - `ogc-api` — discover from the landing page at the client baseUrl.
+ *  - `auto` — probe the facade landing; use it when valid, otherwise
+ *    discover from the root.
+ *
+ * Discovery failures surface as {@link HonuaCapabilityNotSupportedError}
+ * (per the SDK convention of throwing rather than returning empty data).
+ */
+export declare function resolveOgcEndpointLayout(transport: HonuaProtocolTransport, mode?: OgcApiLayoutMode): Promise<OgcEndpointLayout>;
+//# sourceMappingURL=ogc-endpoint-layout.d.ts.map

package/core/ogc-endpoint-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ogc-endpoint-layout.d.ts","sourceRoot":"","sources":["../../../src/core/ogc-endpoint-layout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAA2B,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE7E,kDAAkD;AAClD,MAAM,MAAM,gBAAgB,GAAG,cAAc,GAAG,SAAS,GAAG,MAAM,CAAC;AAcnE;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,GAAE,MAA4B,GAAG,iBAAiB,CAY/F;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE;IAC5C,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB,GAAG,iBAAiB,CAiBpB;AAgBD;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,aAAa,CAAC;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,SAAS,EACjE,GAAG,IAAI,EAAE,MAAM,EAAE,GAChB,MAAM,GAAG,SAAS,CAWpB;AAyCD;;;;;;;;;;GAUG;AACH,wBAAsB,wBAAwB,CAC5C,SAAS,EAAE,sBAAsB,EACjC,IAAI,GAAE,gBAAiC,GACtC,OAAO,CAAC,iBAAiB,CAAC,CAe5B"}

package/core/ogc-endpoint-layout.js

@@ -0,0 +1,173 @@
+/**
+ * OGC API endpoint-layout resolution.
+ *
+ * The SDK's headline claim is one typed contract against ANY standards
+ * server. For OGC API Features / Records that means the client must not
+ * assume a fixed path prefix: a Honua Server mounts the facade at
+ * `/ogc/features/...`, but pygeoapi, ldproxy, and GeoServer's OGC API each
+ * serve the landing page at their own root and advertise their collections
+ * and conformance URLs through the landing page's `links` array
+ * (OGC API - Common Requirement 5).
+ *
+ * This module produces an {@link OgcEndpointLayout} — the concrete set of
+ * resource paths a Features client addresses:
+ *
+ *  - {@link honuaFacadeFeaturesLayout} is the fixed facade layout and the
+ *    default. It performs no network round-trips, so existing callers see
+ *    zero behaviour change.
+ *  - {@link resolveOgcEndpointLayout} discovers the layout from the landing
+ *    page (`ogc-api` mode) or auto-detects the facade first and falls back
+ *    to discovery (`auto` mode).
+ *
+ * Per OGC API - Features Requirement 17 the items resource is always at
+ * `{collections}/{collectionId}/items`, so a single landing-page fetch is
+ * enough to derive every per-collection path from the discovered
+ * collections URL.
+ *
+ * @module
+ */
+import { HonuaCapabilityNotSupportedError } from "./errors.js";
+const DEFAULT_FACADE_BASE = "/ogc/features";
+function enc(id) {
+    return encodeURIComponent(String(id));
+}
+function trimTrailingSlash(url) {
+    let end = url.length;
+    while (end > 0 && url.charCodeAt(end - 1) === 0x2f)
+        end--;
+    return url.slice(0, end);
+}
+/**
+ * The Honua Server facade layout (`/ogc/features/...`). No network access;
+ * this is the default fast path and preserves the pre-existing behaviour of
+ * every OGC Features caller that points at a Honua Server.
+ */
+export function honuaFacadeFeaturesLayout(base = DEFAULT_FACADE_BASE) {
+    const root = trimTrailingSlash(base) || DEFAULT_FACADE_BASE;
+    return {
+        mode: "honua-facade",
+        landing: () => root,
+        conformance: () => `${root}/conformance`,
+        collections: () => `${root}/collections`,
+        collection: (id) => `${root}/collections/${enc(id)}`,
+        queryables: (id) => `${root}/collections/${enc(id)}/queryables`,
+        items: (id) => `${root}/collections/${enc(id)}/items`,
+        item: (id, featureId) => `${root}/collections/${enc(id)}/items/${enc(featureId)}`,
+    };
+}
+/**
+ * A raw OGC API layout built from a discovered (or configured) landing +
+ * collections + conformance URL triple. Per-collection paths are templated
+ * off the collections URL per OGC API - Features Requirement 17.
+ */
+export function ogcApiFeaturesLayout(options) {
+    const landing = trimTrailingSlash(options.landingUrl);
+    const collections = trimTrailingSlash(options.collectionsUrl);
+    const conformance = trimTrailingSlash(options.conformanceUrl);
+    return {
+        mode: "ogc-api",
+        // A bare landing path can be empty (the client baseUrl is the landing
+        // root); the wire layer still appends the `f=` param, producing
+        // `${baseUrl}?f=json`.
+        landing: () => landing,
+        conformance: () => conformance,
+        collections: () => collections,
+        collection: (id) => `${collections}/${enc(id)}`,
+        queryables: (id) => `${collections}/${enc(id)}/queryables`,
+        items: (id) => `${collections}/${enc(id)}/items`,
+        item: (id, featureId) => `${collections}/${enc(id)}/items/${enc(featureId)}`,
+    };
+}
+/**
+ * Resolve a link href to an absolute URL against a base. Absolute hrefs are
+ * returned unchanged; relative hrefs resolve against `${baseUrl}/`.
+ */
+function absolutize(href, baseUrl) {
+    if (/^https?:\/\//i.test(href))
+        return href;
+    const root = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    try {
+        return new URL(href, root).toString();
+    }
+    catch {
+        return href;
+    }
+}
+/**
+ * Find the first link whose `rel` matches one of `rels` (exact or as the
+ * final path segment of a full OGC relation URI, e.g.
+ * `http://www.opengis.net/def/rel/ogc/1.0/data`).
+ */
+export function findOgcLink(links, ...rels) {
+    if (!links)
+        return undefined;
+    const wanted = new Set(rels.map((r) => r.toLowerCase()));
+    for (const link of links) {
+        if (typeof link.href !== "string" || link.href.length === 0)
+            continue;
+        const rel = (link.rel ?? "").toLowerCase();
+        if (wanted.has(rel))
+            return link.href;
+        const tail = rel.slice(rel.lastIndexOf("/") + 1);
+        if (tail && wanted.has(tail))
+            return link.href;
+    }
+    return undefined;
+}
+/**
+ * Discover an OGC API layout from the landing page. The client `baseUrl`
+ * IS the landing page root; the collections and conformance URLs are read
+ * from the landing `links` (falling back to the mandated relative
+ * `collections` / `conformance` sub-paths when a server omits them).
+ */
+async function discoverOgcApiLayout(transport) {
+    const landing = await transport.requestCachedMetadataJson("ogc-features:layout:landing", "?f=json", {});
+    const baseUrl = trimTrailingSlash(transport.baseUrl);
+    const links = landing?.links;
+    const dataHref = findOgcLink(links, "data");
+    const conformanceHref = findOgcLink(links, "conformance");
+    const collectionsUrl = dataHref ? absolutize(dataHref, baseUrl) : `${baseUrl}/collections`;
+    const conformanceUrl = conformanceHref ? absolutize(conformanceHref, baseUrl) : `${baseUrl}/conformance`;
+    return ogcApiFeaturesLayout({ landingUrl: baseUrl, collectionsUrl, conformanceUrl });
+}
+/**
+ * Probe whether the Honua facade landing (`/ogc/features`) exists. Used by
+ * `auto` mode: a valid OGC landing document there confirms the facade
+ * fast path; anything else falls through to landing-page discovery.
+ */
+async function facadeLandingLooksValid(transport) {
+    try {
+        const landing = await transport.requestCachedMetadataJson("ogc-features:layout:facade-probe", `${DEFAULT_FACADE_BASE}?f=json`, {});
+        return Array.isArray(landing?.links);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve the endpoint layout for the requested `mode`:
+ *
+ *  - `honua-facade` (default) — the fixed facade layout, no round-trips.
+ *  - `ogc-api` — discover from the landing page at the client baseUrl.
+ *  - `auto` — probe the facade landing; use it when valid, otherwise
+ *    discover from the root.
+ *
+ * Discovery failures surface as {@link HonuaCapabilityNotSupportedError}
+ * (per the SDK convention of throwing rather than returning empty data).
+ */
+export async function resolveOgcEndpointLayout(transport, mode = "honua-facade") {
+    if (mode === "honua-facade")
+        return honuaFacadeFeaturesLayout();
+    if (mode === "auto") {
+        if (await facadeLandingLooksValid(transport))
+            return honuaFacadeFeaturesLayout();
+    }
+    try {
+        return await discoverOgcApiLayout(transport);
+    }
+    catch (err) {
+        if (err instanceof HonuaCapabilityNotSupportedError)
+            throw err;
+        throw new HonuaCapabilityNotSupportedError("query", "ogc-features", `ogc-api layout discovery failed for ${transport.baseUrl}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/core/ogc-features.d.ts

@@ -0,0 +1,23 @@
+/**
+ * OGC API Features wire methods. Concrete URL-building, param
+ * serialization, and request shaping for the OGC API Features endpoints,
+ * invoked against an injected {@link HonuaProtocolTransport}. The typed
+ * `HonuaOgcFeatures` surface (in `surfaces.ts`) and the `HonuaClient`
+ * facade both delegate here.
+ *
+ * @module
+ */
+import type { HonuaProtocolTransport } from "./protocol-transport.js";
+import type { HonuaOgcCollectionMetadata, HonuaOgcCollectionsResponse, HonuaOgcConformanceResponse, HonuaOgcFeatureCollectionResponse, HonuaOgcFeatureResponse, HonuaOgcLandingResponse, HonuaOgcQueryablesResponse, OgcCollectionRequest, OgcCreateItemRequest, OgcDeleteItemRequest, OgcItemRequest, OgcItemsRequest, OgcMetadataRequest, OgcPatchItemRequest, OgcReplaceItemRequest } from "./types.js";
+export declare function getOgcFeaturesLanding(transport: HonuaProtocolTransport, request?: OgcMetadataRequest): Promise<HonuaOgcLandingResponse>;
+export declare function getOgcFeaturesConformance(transport: HonuaProtocolTransport, request?: OgcMetadataRequest): Promise<HonuaOgcConformanceResponse>;
+export declare function listOgcCollections(transport: HonuaProtocolTransport, request?: OgcMetadataRequest): Promise<HonuaOgcCollectionsResponse>;
+export declare function getOgcCollection(transport: HonuaProtocolTransport, request: OgcCollectionRequest): Promise<HonuaOgcCollectionMetadata>;
+export declare function getOgcQueryables(transport: HonuaProtocolTransport, request: OgcCollectionRequest): Promise<HonuaOgcQueryablesResponse>;
+export declare function listOgcItems(transport: HonuaProtocolTransport, request: OgcItemsRequest): Promise<HonuaOgcFeatureCollectionResponse>;
+export declare function getOgcItem(transport: HonuaProtocolTransport, request: OgcItemRequest): Promise<HonuaOgcFeatureResponse>;
+export declare function createOgcItem(transport: HonuaProtocolTransport, request: OgcCreateItemRequest): Promise<HonuaOgcFeatureResponse>;
+export declare function replaceOgcItem(transport: HonuaProtocolTransport, request: OgcReplaceItemRequest): Promise<HonuaOgcFeatureResponse>;
+export declare function patchOgcItem(transport: HonuaProtocolTransport, request: OgcPatchItemRequest): Promise<HonuaOgcFeatureResponse>;
+export declare function deleteOgcItem(transport: HonuaProtocolTransport, request: OgcDeleteItemRequest): Promise<void>;
+//# sourceMappingURL=ogc-features.d.ts.map

package/core/ogc-features.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ogc-features.d.ts","sourceRoot":"","sources":["../../../src/core/ogc-features.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EACV,0BAA0B,EAC1B,2BAA2B,EAC3B,2BAA2B,EAC3B,iCAAiC,EACjC,uBAAuB,EACvB,uBAAuB,EACvB,0BAA0B,EAC1B,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,EAEpB,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAoBpB,wBAAsB,qBAAqB,CACzC,SAAS,EAAE,sBAAsB,EACjC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,uBAAuB,CAAC,CAQlC;AAED,wBAAsB,yBAAyB,CAC7C,SAAS,EAAE,sBAAsB,EACjC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,2BAA2B,CAAC,CAQtC;AAED,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,sBAAsB,EACjC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,2BAA2B,CAAC,CAQtC;AAED,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,0BAA0B,CAAC,CAQrC;AAED,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,0BAA0B,CAAC,CAQrC;AAED,wBAAsB,YAAY,CAChC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,iCAAiC,CAAC,CAoC5C;AAED,wBAAsB,UAAU,CAC9B,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,uBAAuB,CAAC,CAYlC;AAED,wBAAsB,aAAa,CACjC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,uBAAuB,CAAC,CAYlC;AAED,wBAAsB,cAAc,CAClC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,uBAAuB,CAAC,CAelC;AAED,wBAAsB,YAAY,CAChC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,uBAAuB,CAAC,CAelC;AAED,wBAAsB,aAAa,CAAC,SAAS,EAAE,sBAAsB,EAAE,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAOnH"}

package/core/ogc-features.js

@@ -0,0 +1,129 @@
+/**
+ * OGC API Features wire methods. Concrete URL-building, param
+ * serialization, and request shaping for the OGC API Features endpoints,
+ * invoked against an injected {@link HonuaProtocolTransport}. The typed
+ * `HonuaOgcFeatures` surface (in `surfaces.ts`) and the `HonuaClient`
+ * facade both delegate here.
+ *
+ * @module
+ */
+import { honuaFacadeFeaturesLayout } from "./ogc-endpoint-layout.js";
+import { createOgcMetadataParams, mergeHeaders, normalizeCsv } from "./wire-shared.js";
+/**
+ * The endpoint layout to build paths against. Defaults to the Honua facade
+ * fast path (`/ogc/features/...`); backend-agnostic callers thread a
+ * spec-discovered layout onto `request.layout`.
+ */
+function layoutOf(request) {
+    return request.layout ?? honuaFacadeFeaturesLayout();
+}
+/**
+ * A layout key fragment for cache keys so the facade and a discovered raw
+ * layout never collide in the metadata cache.
+ */
+function layoutKey(layout) {
+    return layout.mode === "honua-facade" ? "facade" : layout.collections();
+}
+export async function getOgcFeaturesLanding(transport, request = {}) {
+    const params = createOgcMetadataParams(request);
+    const layout = layoutOf(request);
+    return transport.requestCachedMetadataJson(`ogc-features:landing:${layoutKey(layout)}:${params.toString()}`, `${layout.landing()}?${params.toString()}`, request);
+}
+export async function getOgcFeaturesConformance(transport, request = {}) {
+    const params = createOgcMetadataParams(request);
+    const layout = layoutOf(request);
+    return transport.requestCachedMetadataJson(`ogc-features:conformance:${layoutKey(layout)}:${params.toString()}`, `${layout.conformance()}?${params.toString()}`, request);
+}
+export async function listOgcCollections(transport, request = {}) {
+    const params = createOgcMetadataParams(request);
+    const layout = layoutOf(request);
+    return transport.requestCachedMetadataJson(`ogc-features:collections:${layoutKey(layout)}:${params.toString()}`, `${layout.collections()}?${params.toString()}`, request);
+}
+export async function getOgcCollection(transport, request) {
+    const params = createOgcMetadataParams(request);
+    const layout = layoutOf(request);
+    return transport.requestCachedMetadataJson(`ogc-features:collection:${layoutKey(layout)}:${request.collectionId}:${params.toString()}`, `${layout.collection(request.collectionId)}?${params.toString()}`, request);
+}
+export async function getOgcQueryables(transport, request) {
+    const params = createOgcMetadataParams(request);
+    const layout = layoutOf(request);
+    return transport.requestCachedMetadataJson(`ogc-features:queryables:${layoutKey(layout)}:${request.collectionId}:${params.toString()}`, `${layout.queryables(request.collectionId)}?${params.toString()}`, request);
+}
+export async function listOgcItems(transport, request) {
+    const params = createOgcMetadataParams(request);
+    if (request.limit !== undefined) {
+        params.set("limit", String(request.limit));
+    }
+    if (request.offset !== undefined) {
+        params.set("offset", String(request.offset));
+    }
+    if (request.bbox !== undefined) {
+        params.set("bbox", request.bbox);
+    }
+    if (request.datetime !== undefined) {
+        params.set("datetime", request.datetime);
+    }
+    if (request.filter !== undefined) {
+        params.set("filter", request.filter);
+    }
+    if (request.ids !== undefined) {
+        params.set("ids", normalizeCsv(request.ids));
+    }
+    if (request.properties !== undefined) {
+        params.set("properties", normalizeCsv(request.properties));
+    }
+    if (request.sortby !== undefined) {
+        params.set("sortby", request.sortby);
+    }
+    if (request.crs !== undefined) {
+        params.set("crs", request.crs);
+    }
+    const path = layoutOf(request).items(request.collectionId);
+    return transport.requestJson("GET", `${path}?${params.toString()}`, undefined, request.signal);
+}
+export async function getOgcItem(transport, request) {
+    const params = createOgcMetadataParams(request);
+    if (request.crs !== undefined) {
+        params.set("crs", request.crs);
+    }
+    const path = layoutOf(request).item(request.collectionId, request.featureId);
+    return transport.requestJson("GET", `${path}?${params.toString()}`, undefined, request.signal);
+}
+export async function createOgcItem(transport, request) {
+    const params = createOgcMetadataParams(request);
+    const path = layoutOf(request).items(request.collectionId);
+    return transport.requestJson("POST", `${path}?${params.toString()}`, {
+        headers: mergeHeaders({ "Content-Type": "application/geo+json" }, request.headers),
+        body: JSON.stringify(request.feature),
+    }, request.signal);
+}
+export async function replaceOgcItem(transport, request) {
+    const params = createOgcMetadataParams(request);
+    if (request.crs !== undefined) {
+        params.set("crs", request.crs);
+    }
+    const path = layoutOf(request).item(request.collectionId, request.featureId);
+    return transport.requestJson("PUT", `${path}?${params.toString()}`, {
+        headers: mergeHeaders({ "Content-Type": "application/geo+json" }, request.headers),
+        body: JSON.stringify(request.feature),
+    }, request.signal);
+}
+export async function patchOgcItem(transport, request) {
+    const params = createOgcMetadataParams(request);
+    if (request.crs !== undefined) {
+        params.set("crs", request.crs);
+    }
+    const path = layoutOf(request).item(request.collectionId, request.featureId);
+    return transport.requestJson("PATCH", `${path}?${params.toString()}`, {
+        headers: mergeHeaders({ "Content-Type": "application/merge-patch+json" }, request.headers),
+        body: JSON.stringify(request.patch),
+    }, request.signal);
+}
+export async function deleteOgcItem(transport, request) {
+    const params = createOgcMetadataParams(request);
+    if (request.crs !== undefined) {
+        params.set("crs", request.crs);
+    }
+    const path = layoutOf(request).item(request.collectionId, request.featureId);
+    await transport.requestJson("DELETE", `${path}?${params.toString()}`, undefined, request.signal);
+}

package/core/ogc-maps.d.ts

@@ -0,0 +1,49 @@
+/**
+ * OGC API Maps surface. Server-rendered map images at the dataset or
+ * collection level, with optional styled-output access. The runtime
+ * deliberately exposes a thin envelope (`width`, `height`, `bbox`,
+ * `crs`, `format`, optional `filter` / `collections`) — extension
+ * parameters live on `extraParams`.
+ *
+ * @module
+ */
+import type { HonuaClient } from "./client.js";
+import type { HonuaProtocolTransport } from "./protocol-transport.js";
+import type { HonuaOgcConformanceResponse, HonuaOgcLandingResponse, HonuaOgcMapImageResponse, OgcMapImageRequest, OgcMetadataRequest } from "./types.js";
+export interface HonuaOgcMapsOptions {
+    client: HonuaClient;
+}
+export interface HonuaOgcCollectionMapOptions {
+    client: HonuaClient;
+    collectionId: string | number;
+    styleId?: string;
+}
+export type HonuaOgcCollectionMapImageRequest = Omit<OgcMapImageRequest, "collectionId" | "styleId"> & {
+    styleId?: string;
+};
+/** Top-level OGC API Maps handle. */
+export declare class HonuaOgcMaps {
+    readonly client: HonuaClient;
+    constructor(options: HonuaOgcMapsOptions);
+    collection(collectionId: string | number, styleId?: string): HonuaOgcCollectionMap;
+    landing(request?: OgcMetadataRequest): Promise<HonuaOgcLandingResponse>;
+    conformance(request?: OgcMetadataRequest): Promise<HonuaOgcConformanceResponse>;
+    /** Render a dataset-level map (across one or more collections). */
+    map(request?: OgcMapImageRequest): Promise<HonuaOgcMapImageResponse>;
+}
+/**
+ * Bound handle for a collection-level (and optionally styled) map. Drops
+ * the routing-discriminator fields from per-call requests.
+ */
+export declare class HonuaOgcCollectionMap {
+    readonly client: HonuaClient;
+    readonly collectionId: string | number;
+    readonly styleId: string | undefined;
+    constructor(options: HonuaOgcCollectionMapOptions);
+    map(request?: HonuaOgcCollectionMapImageRequest): Promise<HonuaOgcMapImageResponse>;
+}
+export declare function createHonuaOgcMaps(client: HonuaClient): HonuaOgcMaps;
+export declare function getOgcMapsLanding(transport: HonuaProtocolTransport, request?: OgcMetadataRequest): Promise<HonuaOgcLandingResponse>;
+export declare function getOgcMapsConformance(transport: HonuaProtocolTransport, request?: OgcMetadataRequest): Promise<HonuaOgcConformanceResponse>;
+export declare function getOgcMapImage(transport: HonuaProtocolTransport, request: OgcMapImageRequest): Promise<HonuaOgcMapImageResponse>;
+//# sourceMappingURL=ogc-maps.d.ts.map

package/core/ogc-maps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ogc-maps.d.ts","sourceRoot":"","sources":["../../../src/core/ogc-maps.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EACV,2BAA2B,EAC3B,uBAAuB,EACvB,wBAAwB,EACxB,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAGpB,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,WAAW,4BAA4B;IAC3C,MAAM,EAAE,WAAW,CAAC;IACpB,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,iCAAiC,GAAG,IAAI,CAAC,kBAAkB,EAAE,cAAc,GAAG,SAAS,CAAC,GAAG;IACrG,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,qCAAqC;AACrC,qBAAa,YAAY;IACvB,SAAgB,MAAM,EAAE,WAAW,CAAC;gBAEjB,OAAO,EAAE,mBAAmB;IAIxC,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,qBAAqB;IAI5E,OAAO,CAAC,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAI3E,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,2BAA2B,CAAC;IAIhG,mEAAmE;IACtD,GAAG,CAAC,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,wBAAwB,CAAC;CAGtF;AAED;;;GAGG;AACH,qBAAa,qBAAqB;IAChC,SAAgB,MAAM,EAAE,WAAW,CAAC;IACpC,SAAgB,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9C,SAAgB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;gBAEzB,OAAO,EAAE,4BAA4B;IAM3C,GAAG,CAAC,OAAO,GAAE,iCAAsC,GAAG,OAAO,CAAC,wBAAwB,CAAC;CAOrG;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,YAAY,CAEpE;AAID,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,sBAAsB,EACjC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,uBAAuB,CAAC,CAOlC;AAED,wBAAsB,qBAAqB,CACzC,SAAS,EAAE,sBAAsB,EACjC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,2BAA2B,CAAC,CAOtC;AAED,wBAAsB,cAAc,CAClC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,wBAAwB,CAAC,CASnC"}