@honua/mcp-server 0.1.2-beta.0 → 0.1.8-beta.0

package/dist/src/certification/ogc-fixture-client.d.ts

@@ -0,0 +1,4 @@
+import type { HonuaClient } from "@honua/sdk-js";
+/** Build the offline platform-free OGC API Features fixture client. */
+export declare function createOgcFixtureClient(): HonuaClient;
+//# sourceMappingURL=ogc-fixture-client.d.ts.map

package/dist/src/certification/ogc-fixture-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ogc-fixture-client.d.ts","sourceRoot":"","sources":["../../../src/certification/ogc-fixture-client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AA2HjD,uEAAuE;AACvE,wBAAgB,sBAAsB,IAAI,WAAW,CAgGpD"}

package/dist/src/certification/ogc-fixture-client.js

@@ -0,0 +1,190 @@
+import { compileCql2 } from "./cql2.js";
+import { OGC_COLLECTIONS, OGC_COLLECTION_IDS, OGC_ENDPOINT } from "./ogc-data.js";
+/**
+ * Offline NON-GeoServices fixture `HonuaClient` (issue #1005).
+ *
+ * Where `census-fixture-client.ts` models a plain Esri FeatureServer, this one
+ * models a plain **OGC API Features** endpoint — no `/rest/services`, no
+ * FeatureServer query surface, no Honua surfaces — replaying the recorded
+ * pygeoapi demo collections (`ogc-data.ts`) through an in-process evaluator that
+ * honours the OGC API Features Part 1 query parameters (`limit`, `offset`,
+ * `bbox`, `datetime`, `properties`, `sortby`) plus the Part 3 `filter` +
+ * `filter-lang=cql2-text` the neutral tool contract compiles to.
+ *
+ * Its whole purpose is to prove the protocol-neutral tool contract on a
+ * protocol whose vocabulary shares nothing with GeoServices: the GeoServices
+ * entry points all reject, so a tool that still secretly depended on
+ * `serviceId`/`layerId` fails loudly here instead of passing by accident.
+ */
+const NO_GEOSERVICES = "This endpoint is OGC API Features only; it publishes no GeoServices/FeatureServer surface.";
+function requireCollection(collectionId) {
+    const collection = OGC_COLLECTIONS[String(collectionId)];
+    if (!collection) {
+        throw new Error(`OGC API Features fixture: unknown collection "${String(collectionId)}"`);
+    }
+    return collection;
+}
+function geometryBbox(geometry) {
+    if (!geometry)
+        return undefined;
+    const coordinates = geometry.coordinates;
+    const xs = [];
+    const ys = [];
+    const visit = (node) => {
+        if (!Array.isArray(node))
+            return;
+        if (typeof node[0] === "number" && typeof node[1] === "number") {
+            xs.push(node[0]);
+            ys.push(node[1]);
+            return;
+        }
+        for (const child of node)
+            visit(child);
+    };
+    visit(coordinates);
+    if (xs.length === 0)
+        return undefined;
+    return [Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys)];
+}
+function bboxIntersects(feature, bbox) {
+    const [minX, minY, maxX, maxY] = bbox.split(",").map(Number);
+    const box = geometryBbox(feature.geometry);
+    if (!box)
+        return false;
+    return !(box[2] < minX || box[0] > maxX || box[3] < minY || box[1] > maxY);
+}
+/** The collection's own time dimension, when it publishes one. */
+function timeField(collectionId) {
+    const properties = OGC_COLLECTIONS[collectionId]?.queryables ?? {};
+    return "datetime" in properties ? "datetime" : undefined;
+}
+function withinDatetime(feature, datetime, field) {
+    const raw = feature.properties?.[field];
+    if (typeof raw !== "string")
+        return false;
+    const value = Date.parse(raw);
+    if (Number.isNaN(value))
+        return false;
+    const [rawStart, rawEnd] = datetime.includes("/") ? datetime.split("/") : [datetime, datetime];
+    const start = rawStart === ".." || rawStart === "" ? Number.NEGATIVE_INFINITY : Date.parse(rawStart);
+    const end = rawEnd === ".." || rawEnd === "" ? Number.POSITIVE_INFINITY : Date.parse(rawEnd);
+    return value >= start && value <= end;
+}
+function sortFeatures(features, sortby) {
+    const specs = sortby
+        .split(",")
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map((part) => part.startsWith("-") ? { field: part.slice(1), descending: true } : { field: part, descending: false });
+    return [...features].sort((a, b) => {
+        for (const spec of specs) {
+            const av = a.properties?.[spec.field];
+            const bv = b.properties?.[spec.field];
+            if (av === bv)
+                continue;
+            const less = typeof av === "number" && typeof bv === "number" ? av < bv : String(av) < String(bv);
+            return (less ? -1 : 1) * (spec.descending ? -1 : 1);
+        }
+        return 0;
+    });
+}
+function projectProperties(feature, properties) {
+    if (properties === undefined)
+        return feature;
+    const requested = (Array.isArray(properties) ? properties : String(properties).split(","))
+        .map((name) => name.trim())
+        .filter(Boolean);
+    if (requested.length === 0 || requested.includes("*"))
+        return feature;
+    const projected = {};
+    for (const name of requested) {
+        if (feature.properties && name in feature.properties)
+            projected[name] = feature.properties[name];
+    }
+    return { ...feature, properties: projected };
+}
+/** Build the offline platform-free OGC API Features fixture client. */
+export function createOgcFixtureClient() {
+    const client = {
+        serverBaseUrl: OGC_ENDPOINT,
+        async listOgcCollections(_request = {}) {
+            return {
+                collections: OGC_COLLECTION_IDS.map((id) => OGC_COLLECTIONS[id].collection),
+            };
+        },
+        async getOgcCollection(request) {
+            return requireCollection(request.collectionId).collection;
+        },
+        async getOgcQueryables(request) {
+            const collection = requireCollection(request.collectionId);
+            if (!collection.queryables) {
+                throw new Error(`OGC API Features fixture: collection "${String(request.collectionId)}" publishes no queryables`);
+            }
+            return { type: "object", properties: collection.queryables };
+        },
+        async listOgcItems(request) {
+            const collectionId = String(request.collectionId);
+            const collection = requireCollection(collectionId);
+            let features = collection.features;
+            if (request.filter !== undefined && request.filter !== "") {
+                if (request.filterLang !== undefined && request.filterLang !== "cql2-text") {
+                    throw new Error(`OGC API Features fixture: unsupported filter-lang "${String(request.filterLang)}"`);
+                }
+                const predicate = compileCql2(request.filter);
+                features = features.filter((feature) => predicate(feature.properties ?? {}));
+            }
+            if (request.bbox !== undefined) {
+                features = features.filter((feature) => bboxIntersects(feature, request.bbox));
+            }
+            if (request.datetime !== undefined) {
+                const field = timeField(collectionId);
+                if (!field) {
+                    throw new Error(`OGC API Features fixture: collection "${collectionId}" has no time dimension`);
+                }
+                features = features.filter((feature) => withinDatetime(feature, request.datetime, field));
+            }
+            if (request.ids !== undefined) {
+                const ids = (Array.isArray(request.ids) ? request.ids : String(request.ids).split(",")).map(String);
+                features = features.filter((feature) => ids.includes(String(feature.id)));
+            }
+            const numberMatched = features.length;
+            if (request.sortby)
+                features = sortFeatures(features, request.sortby);
+            const offset = request.offset ?? 0;
+            // OGC API Features servers apply a default and a maximum page size
+            // (Part 1 §7.15.4). The default mirrors the pygeoapi demo's 10; the
+            // maximum is generous so a client that asks to drain a collection
+            // actually drains it, rather than silently aggregating one page.
+            const limit = Math.min(request.limit ?? 10, 1000);
+            const page = features
+                .slice(offset, offset + limit)
+                .map((feature) => projectProperties(feature, request.properties));
+            return {
+                type: "FeatureCollection",
+                features: page,
+                numberMatched,
+                numberReturned: page.length,
+            };
+        },
+        // ── Surfaces this endpoint does NOT publish ──────────────────
+        async listServices() {
+            throw new Error(NO_GEOSERVICES);
+        },
+        async getFeatureServiceMetadata() {
+            throw new Error(NO_GEOSERVICES);
+        },
+        async getLayerMetadata() {
+            throw new Error(NO_GEOSERVICES);
+        },
+        async queryFeatures() {
+            throw new Error(NO_GEOSERVICES);
+        },
+        async pipelineFetch(_method, _path) {
+            return new Response(JSON.stringify({ error: { code: 404, message: "not found" } }), {
+                status: 404,
+                headers: { "Content-Type": "application/json" },
+            });
+        },
+    };
+    return client;
+}

package/dist/src/certification/target.d.ts

@@ -20,8 +20,17 @@ import { type ProxyOptions } from "../proxy.js";
  *                     of a PLAIN public FeatureServer (recorded census layer, no
  *                     Honua surfaces). Proves the tools certify green against a
  *                     non-Honua endpoint, with Honua-only tools skip-with-reason.
+ *   - `standalone-ogc` : the same surface against a NON-GeoServices endpoint
+ *                     (issue #1005) — an in-process fixture of a plain OGC API
+ *                     Features server replaying recorded pygeoapi collections.
+ *                     Nothing Esri-shaped exists there (the GeoServices entry
+ *                     points all reject), so it proves the tool contract is
+ *                     genuinely protocol-neutral rather than GeoServices with
+ *                     extra fields.
  */
-export type CertTargetMode = "offline" | "remote" | "stdio-proxy" | "standalone";
+export type CertTargetMode = "offline" | "remote" | "stdio-proxy" | "standalone" | "standalone-ogc";
+/** Target modes that certify the platform-free `createServer` surface. */
+export declare function isStandaloneTargetMode(mode: CertTargetMode): boolean;
 export interface CertificationTarget {
     mode: CertTargetMode;
     backend: "mock-upstream" | "live";

package/dist/src/certification/target.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../../../src/certification/target.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAInE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,KAAK,YAAY,EAAmB,MAAM,aAAa,CAAC;AAIjE;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,QAAQ,GAAG,aAAa,GAAG,YAAY,CAAC;AAEjF,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,eAAe,GAAG,MAAM,CAAC;IAClC,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAC;IACpB,iFAAiF;IACjF,QAAQ,EAAE,QAAQ,CAAC;IACnB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,2BAA2B,EAAE,OAAO,CAAC;IACrC,gFAAgF;IAChF,sBAAsB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,cAAc,CAQtF;AAED,6EAA6E;AAC7E,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,YAAY,CAc9E;AAED,kFAAkF;AAClF,wBAAgB,iBAAiB,IAAI,MAAM,CAc1C;AAED,gDAAgD;AAChD,wBAAsB,uBAAuB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAYhH"}
+{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../../../src/certification/target.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAInE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,KAAK,YAAY,EAAwC,MAAM,aAAa,CAAC;AAMtF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,QAAQ,GAAG,aAAa,GAAG,YAAY,GAAG,gBAAgB,CAAC;AAEpG,0EAA0E;AAC1E,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAEpE;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,eAAe,GAAG,MAAM,CAAC;IAClC,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAC;IACpB,iFAAiF;IACjF,QAAQ,EAAE,QAAQ,CAAC;IACnB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,2BAA2B,EAAE,OAAO,CAAC;IACrC,gFAAgF;IAChF,sBAAsB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,cAAc,CActF;AAED,6EAA6E;AAC7E,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,YAAY,CAK9E;AAED,kFAAkF;AAClF,wBAAgB,iBAAiB,IAAI,MAAM,CAc1C;AAED,gDAAgD;AAChD,wBAAsB,uBAAuB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAehH"}

package/dist/src/certification/target.js

@@ -4,31 +4,32 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
 import { createClientFromEnv, createServer } from "../index.js";
-import { connectUpstream } from "../proxy.js";
+import { connectUpstream, resolveProxyOptions } from "../proxy.js";
 import { createStandaloneFixtureClient } from "./census-fixture-client.js";
 import { startMockUpstream } from "./mock-upstream.js";
+import { OGC_ENDPOINT } from "./ogc-data.js";
+import { createOgcFixtureClient } from "./ogc-fixture-client.js";
+/** Target modes that certify the platform-free `createServer` surface. */
+export function isStandaloneTargetMode(mode) {
+    return mode === "standalone" || mode === "standalone-ogc";
+}
 export function resolveTargetMode(env = process.env) {
     const raw = (env.HONUA_MCP_CERT_TARGET ?? "offline").trim().toLowerCase();
-    if (raw === "offline" || raw === "remote" || raw === "stdio-proxy" || raw === "standalone") {
+    if (raw === "offline" ||
+        raw === "remote" ||
+        raw === "stdio-proxy" ||
+        raw === "standalone" ||
+        raw === "standalone-ogc") {
         return raw;
     }
-    throw new Error(`HONUA_MCP_CERT_TARGET must be "offline", "remote", "stdio-proxy", or "standalone", received "${raw}"`);
+    throw new Error(`HONUA_MCP_CERT_TARGET must be "offline", "remote", "stdio-proxy", "standalone", or "standalone-ogc", received "${raw}"`);
 }
 /** Resolve the remote `/mcp` endpoint + credentials from the environment. */
 export function resolveRemoteProxyOptions(env) {
-    const remoteUrl = env.HONUA_MCP_REMOTE_URL ?? env.HONUA_MCP_URL;
-    if (!remoteUrl) {
+    if (!(env.HONUA_MCP_REMOTE_URL ?? env.HONUA_MCP_URL)) {
         throw new Error("HONUA_MCP_REMOTE_URL is required for remote / stdio-proxy certification against a live /mcp.");
     }
-    const parsed = new URL(remoteUrl);
-    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-        throw new Error(`HONUA_MCP_REMOTE_URL must use http or https: ${remoteUrl}`);
-    }
-    return {
-        remoteUrl: parsed.toString(),
-        authToken: env.HONUA_MCP_AUTH_TOKEN,
-        apiKey: env.HONUA_API_KEY,
-    };
+    return resolveProxyOptions(env);
 }
 /** Resolve the built `honua-mcp-proxy` entry usable from src (vitest) or dist. */
 export function resolveProxyEntry() {
@@ -56,8 +57,41 @@ export async function openCertificationTarget(env = process.env) {
     if (mode === "standalone") {
         return openStandaloneTarget(env);
     }
+    if (mode === "standalone-ogc") {
+        return openStandaloneOgcTarget(env);
+    }
     return openOfflineTarget(env);
 }
+/**
+ * Open the NON-GeoServices standalone target (#1005): the same platform-free
+ * `createServer` surface, wired to an in-process fixture of a plain OGC API
+ * Features endpoint (recorded pygeoapi collections). The GeoServices entry
+ * points on that fixture all reject, so any tool still requiring Esri
+ * addressing fails here rather than passing by accident.
+ */
+async function openStandaloneOgcTarget(env) {
+    const server = createServer(createOgcFixtureClient());
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    const client = new Client({ name: "honua-mcp-certifier", version: "1.0.0" });
+    await server.connect(serverTransport);
+    await client.connect(clientTransport);
+    return {
+        mode: "standalone-ogc",
+        backend: "mock-upstream",
+        serverLabel: `honua-mcp standalone → ${OGC_ENDPOINT} (recorded OGC API Features fixture, no GeoServices surface)`,
+        authMode: "anonymous",
+        honuaTransport: env.HONUA_TRANSPORT ?? null,
+        client,
+        supportsUnauthenticatedPass: false,
+        connectUnauthenticated() {
+            return Promise.reject(new Error("standalone-ogc target has no auth boundary"));
+        },
+        async close() {
+            await client.close().catch(() => { });
+            await server.close().catch(() => { });
+        },
+    };
+}
 /**
  * Open the platform-free standalone target: the direct-SDK `createServer` surface,
  * reached over an in-memory MCP transport. By default it is wired to an in-process
@@ -157,32 +191,33 @@ async function openStdioProxyTarget(env) {
     const clients = [];
     // Upstream: a live /mcp when configured, otherwise the in-process mock.
     let mock;
-    let upstreamUrl;
-    let upstreamToken;
+    let upstreamOptions;
     let backend;
     if (env.HONUA_MCP_REMOTE_URL ?? env.HONUA_MCP_URL) {
-        const options = resolveRemoteProxyOptions(env);
-        upstreamUrl = options.remoteUrl;
-        upstreamToken = options.authToken;
+        upstreamOptions = resolveRemoteProxyOptions(env);
         backend = "live";
     }
     else {
         mock = await startMockUpstream();
-        upstreamUrl = mock.url;
-        upstreamToken = mock.authToken;
+        upstreamOptions = { remoteUrl: mock.url, authToken: mock.authToken };
         backend = "mock-upstream";
     }
     const spawnProxyClient = async (withAuth) => {
         const childEnv = {
             ...process.env,
-            HONUA_MCP_REMOTE_URL: upstreamUrl,
+            HONUA_MCP_REMOTE_URL: upstreamOptions.remoteUrl,
         };
-        if (withAuth && upstreamToken) {
-            childEnv.HONUA_MCP_AUTH_TOKEN = upstreamToken;
+        delete childEnv.HONUA_MCP_AUTH_TOKEN;
+        delete childEnv.HONUA_ADMIN_KEY;
+        delete childEnv.HONUA_API_KEY;
+        if (withAuth && upstreamOptions.authToken) {
+            childEnv.HONUA_MCP_AUTH_TOKEN = upstreamOptions.authToken;
+        }
+        else if (withAuth && upstreamOptions.apiKey) {
+            childEnv.HONUA_API_KEY = upstreamOptions.apiKey;
         }
         else {
-            delete childEnv.HONUA_MCP_AUTH_TOKEN;
-            delete childEnv.HONUA_API_KEY;
+            // Keep the certification's anonymous negative control credential-free.
         }
         const transport = new StdioClientTransport({
             command: process.execPath,
@@ -199,8 +234,8 @@ async function openStdioProxyTarget(env) {
     return {
         mode: "stdio-proxy",
         backend,
-        serverLabel: `honua-mcp-proxy → ${backend === "live" ? upstreamUrl : "in-process mock /mcp"}`,
-        authMode: upstreamToken ? "bearer" : env.HONUA_API_KEY ? "api-key" : "anonymous",
+        serverLabel: `honua-mcp-proxy → ${backend === "live" ? upstreamOptions.remoteUrl : "in-process mock /mcp"}`,
+        authMode: upstreamOptions.authToken ? "bearer" : upstreamOptions.apiKey ? "api-key" : "anonymous",
         honuaTransport: env.HONUA_TRANSPORT ?? null,
         client,
         supportsUnauthenticatedPass: true,

package/dist/src/credential-endpoint.d.ts

@@ -0,0 +1,3 @@
+/** Validate an HTTP endpoint before any transport is created. */
+export declare function requireSecureCredentialEndpoint(value: string, label: string, credentialed?: boolean): URL;
+//# sourceMappingURL=credential-endpoint.d.ts.map

package/dist/src/credential-endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credential-endpoint.d.ts","sourceRoot":"","sources":["../../src/credential-endpoint.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,UAAO,GAAG,GAAG,CAiBtG"}

package/dist/src/credential-endpoint.js

@@ -0,0 +1,24 @@
+/** Validate an HTTP endpoint before any transport is created. */
+export function requireSecureCredentialEndpoint(value, label, credentialed = true) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error(`${label} must be a valid absolute URL`);
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new Error(`${label} must use http or https`);
+    }
+    if (url.username || url.password || url.search || url.hash) {
+        throw new Error(`${label} must not include embedded credentials, query parameters, or a fragment`);
+    }
+    if (credentialed && url.protocol === "http:" && !isLoopbackHost(url.hostname)) {
+        throw new Error(`${label} requires HTTPS except for exact loopback HTTP development endpoints`);
+    }
+    return url;
+}
+function isLoopbackHost(hostname) {
+    const normalized = hostname.toLowerCase();
+    return normalized === "localhost" || normalized === "127.0.0.1" || normalized === "::1" || normalized === "[::1]";
+}

package/dist/src/eval/cli.js

@@ -22,10 +22,12 @@ import { runEval } from "./runner.js";
  *                    explicit request yields an honest driverError, not a silent
  *                    skip. Without --driver, drivers are auto-resolved from env.
  *   --corpus <name>  Select the corpus explicitly: analyst | operator | northstar |
- *                    all. This overrides HONUA_EVAL_CORPUS and is how the `eval:live`
+ *                    standalone | ogc | all. This overrides HONUA_EVAL_CORPUS and is how the `eval:live`
  *                    script targets the operator surface without relying on shell env
  *                    (cross-platform). `northstar` targets the three P1-gate
- *                    workflows. Defaults to the env-driven selection.
+ *                    workflows; `standalone` and `ogc` target the two platform-free
+ *                    fixture surfaces (a plain Esri FeatureServer and a plain OGC API
+ *                    Features endpoint). Defaults to the env-driven selection.
  *
  * Corpus selection is env-driven (see `resolveCorpus`): default is the analyst
  * corpus (in-process SDK fixture surface, the CI control); `HONUA_EVAL_CORPUS=operator`
@@ -37,7 +39,7 @@ import { runEval } from "./runner.js";
  * chain), and live remote MCP runs when HONUA_MCP_REMOTE_URL is set. Keys are
  * never hardcoded — they come from the environment.
  */
-const CORPUS_NAMES = ["analyst", "operator", "northstar", "standalone", "all"];
+const CORPUS_NAMES = ["analyst", "operator", "northstar", "standalone", "ogc", "all"];
 function parseArgs(argv) {
     let artifactOnly = false;
     let offline = false;
@@ -93,6 +95,7 @@ async function main() {
         ...(drivers.length > 0 ? { drivers: selectDrivers(drivers) } : {}),
         ...(corpus ? { corpus: corpusForName(corpus) } : {}),
         ...(corpus === "standalone" ? { forceStandaloneSurface: true } : {}),
+        ...(corpus === "ogc" ? { forceOgcSurface: true } : {}),
     });
     mkdirSync(outDir, { recursive: true });
     const jsonPath = resolve(outDir, "mcp-eval-results.json");

package/dist/src/eval/corpus.d.ts

@@ -31,4 +31,11 @@ export declare function resolveCorpus(env?: NodeJS.ProcessEnv): Scenario[];
  * corpus resolves against real recorded non-Honua data.
  */
 export declare function isStandaloneCorpus(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Whether a corpus selection targets the NON-GeoServices surface (issue #1005) —
+ * a plain OGC API Features endpoint replayed from recorded pygeoapi collections.
+ * The offline runner uses this to pick the OGC fixture client, on which every
+ * GeoServices entry point rejects.
+ */
+export declare function isOgcCorpus(env?: NodeJS.ProcessEnv): boolean;
 //# sourceMappingURL=corpus.d.ts.map

package/dist/src/eval/corpus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"corpus.d.ts","sourceRoot":"","sources":["../../../src/eval/corpus.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM,EAAE,QAAQ,EAkG5B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,QAAQ,EAAE,CAiB9E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAEhF"}
+{"version":3,"file":"corpus.d.ts","sourceRoot":"","sources":["../../../src/eval/corpus.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM,EAAE,QAAQ,EAkG5B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,QAAQ,EAAE,CAmB9E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAEhF;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAEzE"}

package/dist/src/eval/corpus.js

@@ -1,4 +1,5 @@
 import { NORTHSTAR_CORPUS } from "./northstar-corpus.js";
+import { OGC_CORPUS } from "./ogc-corpus.js";
 import { OPERATOR_CORPUS } from "./operator-corpus.js";
 import { STANDALONE_CORPUS } from "./standalone-corpus.js";
 /**
@@ -129,6 +130,8 @@ export function resolveCorpus(env = process.env) {
             return NORTHSTAR_CORPUS;
         case "standalone":
             return STANDALONE_CORPUS;
+        case "ogc":
+            return OGC_CORPUS;
         case "all":
             // `all` spans the Honua-surface corpora only. The platform-free standalone
             // corpus targets a DIFFERENT surface (a plain FeatureServer fixture) and is
@@ -148,3 +151,12 @@ export function resolveCorpus(env = process.env) {
 export function isStandaloneCorpus(env = process.env) {
     return (env.HONUA_EVAL_CORPUS ?? "").trim().toLowerCase() === "standalone";
 }
+/**
+ * Whether a corpus selection targets the NON-GeoServices surface (issue #1005) —
+ * a plain OGC API Features endpoint replayed from recorded pygeoapi collections.
+ * The offline runner uses this to pick the OGC fixture client, on which every
+ * GeoServices entry point rejects.
+ */
+export function isOgcCorpus(env = process.env) {
+    return (env.HONUA_EVAL_CORPUS ?? "").trim().toLowerCase() === "ogc";
+}

package/dist/src/eval/ogc-corpus.d.ts

@@ -0,0 +1,3 @@
+import type { Scenario } from "./types.js";
+export declare const OGC_CORPUS: Scenario[];
+//# sourceMappingURL=ogc-corpus.d.ts.map

package/dist/src/eval/ogc-corpus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ogc-corpus.d.ts","sourceRoot":"","sources":["../../../src/eval/ogc-corpus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAqC3C,eAAO,MAAM,UAAU,EAAE,QAAQ,EAgahC,CAAC"}