@qaecy/cue-cli 0.0.45 → 0.0.47

package/main.js

@@ -372,7 +372,7 @@ var init_md5_builder_node = __esm({
 });
 
 // apps/desktop/cue-cli/src/main.ts
-var import_commander = require("commander");
+var import_commander2 = require("commander");
 var import_fs8 = require("fs");
 var import_path4 = require("path");
 
@@ -4721,6 +4721,53 @@ var prefixCC = {
   rex: "http://purl.obolibrary.org/obo/REX_"
 };
 
+// libs/js/prefixes/src/lib/compact-expand.ts
+var CompactExpand = class _CompactExpand {
+  static _instance;
+  // Opposite map is built once
+  _nsMap;
+  static getInstance() {
+    if (this._instance) {
+      return this._instance;
+    }
+    this._instance = new _CompactExpand();
+    return this._instance;
+  }
+  compactIRI(iri) {
+    let nsMap = this._nsMap;
+    if (nsMap === void 0)
+      nsMap = this._buildNSMap();
+    let ns = iri;
+    if (iri.includes("#"))
+      ns = `${iri.split("#")[0]}#`;
+    else {
+      const parts = iri.split("/");
+      parts.pop();
+      ns = parts.join("/") + "/";
+    }
+    if (ns === void 0)
+      return iri;
+    const pfx = nsMap[ns];
+    if (pfx === void 0)
+      return iri;
+    return iri.replace(ns, `${pfx}:`);
+  }
+  expandIRI(iri) {
+    const prefix = iri.split(":")[0];
+    const ns = prefixCC[prefix] ?? qaecyPrefixes[prefix];
+    return iri.replace(`${prefix}:`, ns);
+  }
+  _buildNSMap() {
+    const map = {};
+    Object.keys(prefixCC).forEach((key) => map[prefixCC[key]] = key);
+    Object.keys(qaecyPrefixes).forEach(
+      (key) => map[qaecyPrefixes[key]] = key
+    );
+    this._nsMap = map;
+    return map;
+  }
+};
+
 // libs/js/sync-tools/src/lib/list-remote-files.ts
 async function listRemoteFiles(spaceId, providerId, queryHandler2, verbose = false) {
   const firebase = CueFirebase.getInstance();
@@ -5090,13 +5137,17 @@ var BUCKET_PERSISTENCE2 = "db_persistence_eu_west6";
 var ENDPOINT_CONSUMPTION = "/data-views/admin/consumption";
 var ENDPOINT_PROFILE_ORGANIZATIONS = "/data-views/admin/profile/organizations";
 var ENDPOINT_PROFILE_API_KEYS = "/data-views/admin/profile/api-keys";
+var ENDPOINT_COMMANDS_PROFILE_API_KEYS = "/commands/admin/profile/api-keys";
+var ENDPOINT_COMMANDS_PROFILE_TERMS = "/commands/admin/profile/terms";
 var ENDPOINT_ORG_MEMBERS = (orgId) => `/data-views/admin/organizations/${orgId}/members`;
 var ENDPOINT_CREATE_PROJECT = "/commands/admin/project";
 var ENDPOINT_SEARCH = "/assistant/search";
 var ENDPOINT_FUSEKI_QUERY = "/triplestore/query";
 var ENDPOINT_FUSEKI_UPDATE = "/triplestore/update";
+var ENDPOINT_FUSEKI_SHACL = "/triplestore/shacl";
 var ENDPOINT_QLEVER_QUERY = "/qlever-server/qlever/query";
 var ENDPOINT_QLEVER_UPDATE = "/qlever-server/qlever/update";
+var ENDPOINT_QLEVER_SHACL = "/qlever-server/qlever/shacl";
 var ENDPOINT_FSS_BATCH = "/commands/file-system-structure/batch";
 var MICROSOFT_PROVIDER_ID = "microsoft.com";
 var SUPERADMIN_ROLE = "superadmin";
@@ -5221,6 +5272,28 @@ var CueAuth = class {
   async signOut() {
     await (0, import_auth3.signOut)(this._auth);
   }
+  /**
+   * Register a new user by name and email.
+   * The backend validates that the email domain belongs to an existing organisation,
+   * creates the Firebase Auth account, assigns org membership, and dispatches a
+   * "set your password" email to the address provided.
+   * Returns the new user's UID and the organisation name on success.
+   */
+  async signUp(name, email) {
+    const response = await fetch(
+      `${this._endpoints.gatewayUrl}/commands/admin/user/signup`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name, email })
+      }
+    );
+    if (!response.ok) {
+      const body = await response.json().catch(() => ({}));
+      throw new Error(body?.message ?? `Sign-up failed (${response.status})`);
+    }
+    return response.json();
+  }
   /** Currently signed-in user, or null if not authenticated */
   get currentUser() {
     return this._auth.currentUser;
@@ -5266,6 +5339,49 @@ var CueAuth = class {
   }
 };
 
+// libs/js/cue-sdk/src/lib/tables.ts
+var ENDPOINT_DATA_VIEWS_TABLES = "/data-views/tables";
+var ENDPOINT_COMMANDS_TABLES = "/commands/tables";
+var CueTables = class {
+  constructor(_auth, _gatewayUrl) {
+    this._auth = _auth;
+    this._gatewayUrl = _gatewayUrl;
+  }
+  async listTables(projectId) {
+    const response = await this._auth.authenticatedFetch(
+      `${this._gatewayUrl}${ENDPOINT_DATA_VIEWS_TABLES}`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          "x-project-id": projectId,
+          "cue-project-id": projectId
+        }
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to list tables: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async saveTables(tables, projectId) {
+    const response = await this._auth.authenticatedFetch(
+      `${this._gatewayUrl}${ENDPOINT_COMMANDS_TABLES}`,
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+          "x-project-id": projectId,
+          "cue-project-id": projectId
+        },
+        body: JSON.stringify(tables)
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to save tables: ${response.status} ${response.statusText}`);
+    }
+  }
+};
+
 // libs/js/cue-sdk/src/lib/api.ts
 var CueApi = class {
   constructor(_auth, _gatewayUrl, projects, sync) {
@@ -5273,6 +5389,14 @@ var CueApi = class {
     this._gatewayUrl = _gatewayUrl;
     this.projects = projects;
     this.sync = sync;
+    this.tables = new CueTables(_auth, _gatewayUrl);
+  }
+  tables;
+  /** Active language used for language-sensitive SPARQL queries across all project classes. */
+  language = "en";
+  /** Updates the active language. All project classes (`CueProjectSchema`, `CueProjectDocuments`, `CueProjectEntities`) read this at query time. */
+  setLanguage(lang) {
+    this.language = lang;
   }
   /**
    * Returns standard authentication headers for the current user.
@@ -5316,9 +5440,12 @@ var CueApi = class {
    * The user must be authenticated before calling this.
    */
   async sparql(query3, projectId, graphType) {
-    console.log(graphType);
-    const endpoint = graphType === "qlever" ? ENDPOINT_QLEVER_QUERY : ENDPOINT_FUSEKI_QUERY;
-    console.log(`Executing SPARQL query against ${endpoint} for project ${projectId} with graph type ${graphType ?? "fuseki"}`);
+    if (!graphType) {
+      const project = await this.projects.getProject(projectId);
+      graphType = project?.projectSettings?.graph?.type ?? "qlever";
+    }
+    const endpoint = graphType === "fuseki" ? ENDPOINT_FUSEKI_QUERY : ENDPOINT_QLEVER_QUERY;
+    console.log(`Executing SPARQL query against ${endpoint} for project ${projectId} with graph type ${graphType}`);
     const urlencoded = new URLSearchParams();
     urlencoded.append("query", query3);
     const response = await this._auth.authenticatedFetch(
@@ -5341,6 +5468,57 @@ var CueApi = class {
     }
     return response.json();
   }
+  /**
+   * Validate a SHACL shape against the project's triplestore.
+   *
+   * @param shape     - SHACL shapes graph in Turtle syntax.
+   * @param projectId - Project to validate against.
+   * @param options   - `format`: `'json-ld'` (default, structured result) or `'turtle'` (raw string).
+   *                    `verbose`: include server-side timing logs.
+   *
+   * Returns a {@link ShaclValidationReport} for JSON-LD, or a Turtle string.
+   */
+  async shacl(shape, projectId, options) {
+    const fmt = options?.format ?? "json-ld";
+    const accept = fmt === "turtle" ? "text/turtle" : "application/ld+json";
+    if (options?.graphType === "fuseki") {
+      const response2 = await this._auth.authenticatedFetch(
+        `${this._gatewayUrl}${ENDPOINT_FUSEKI_SHACL}`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "text/turtle",
+            "Accept": accept,
+            "x-project-id": projectId,
+            "cue-project-id": projectId
+          },
+          body: shape
+        }
+      );
+      if (!response2.ok) {
+        const msg = await response2.text().catch(() => "");
+        throw new Error(`SHACL validation failed: ${response2.status} ${response2.statusText}${msg ? " \u2014 " + msg.slice(0, 200) : ""}`);
+      }
+      return fmt === "turtle" ? response2.text() : response2.json();
+    }
+    const url = `${this._gatewayUrl}${ENDPOINT_QLEVER_SHACL}${options?.verbose ? "?verbose=true" : ""}`;
+    const body = new URLSearchParams({ shape });
+    const response = await this._auth.authenticatedFetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "Accept": accept,
+        "x-project-id": projectId,
+        "cue-project-id": projectId
+      },
+      body
+    });
+    if (!response.ok) {
+      const msg = await response.text().catch(() => "");
+      throw new Error(`SHACL validation failed: ${response.status} ${response.statusText}${msg ? " \u2014 " + msg.slice(0, 200) : ""}`);
+    }
+    return fmt === "turtle" ? response.text() : response.json();
+  }
   async getConsumption(projectId) {
     const response = await this._auth.authenticatedFetch(
       `${this._gatewayUrl}${ENDPOINT_CONSUMPTION}`,
@@ -5361,6 +5539,1730 @@ var CueApi = class {
   }
 };
 
+// libs/js/cue-gis/src/lib/models.ts
+var FEATURE_CATEGORIES = [
+  "building",
+  "cadastre",
+  "zone",
+  "address",
+  "poi",
+  "greenspace",
+  "paved",
+  "railway",
+  "natural",
+  "manmade"
+];
+var NOMINATIM_FEATURE_CATEGORIES = [
+  "address",
+  "poi",
+  "railway",
+  "natural",
+  "manmade"
+];
+var FEATURE_CATEGORY_DESCRIPTORS = {
+  address: {
+    category: "address",
+    label: "Address",
+    description: "Official addresses, streets, and addressable access points.",
+    preferredColor: "#1d4ed8"
+  },
+  poi: {
+    category: "poi",
+    label: "Points of interest",
+    description: "Places and amenities relevant to everyday operations and access.",
+    preferredColor: "#059669"
+  },
+  railway: {
+    category: "railway",
+    label: "Railway",
+    description: "Rail infrastructure, stations, and rail-adjacent transport context.",
+    preferredColor: "#dc2626"
+  },
+  natural: {
+    category: "natural",
+    label: "Natural features",
+    description: "Natural and hydrological features such as watercourses, forests, and land cover.",
+    preferredColor: "#0ea5e9"
+  },
+  manmade: {
+    category: "manmade",
+    label: "Built features",
+    description: "Structures and man-made elements not covered by more specific categories.",
+    preferredColor: "#ca8a04"
+  },
+  cadastre: {
+    category: "cadastre",
+    label: "Cadastre",
+    description: "Land parcels, legal boundaries, official surveying, and public-law land restrictions.",
+    preferredColor: "#7c3aed"
+  },
+  building: {
+    category: "building",
+    label: "Buildings",
+    description: "Building footprints and structures from official registry or cadastral data.",
+    preferredColor: "#f97316"
+  },
+  greenspace: {
+    category: "greenspace",
+    label: "Green spaces",
+    description: "Parks, gardens, playgrounds, sports facilities, and other vegetated open areas.",
+    preferredColor: "#16a34a"
+  },
+  paved: {
+    category: "paved",
+    label: "Paved surfaces",
+    description: "Courtyards, sidewalks, parking areas, and other sealed ground surfaces.",
+    preferredColor: "#78716c"
+  },
+  zone: {
+    category: "zone",
+    label: "Planning zones",
+    description: "Land-use zones, local plans, and public-law planning constraints (Nutzungsplanung / Lokalplan).",
+    preferredColor: "#db2777"
+  }
+};
+function featureCategoryDescriptor(category) {
+  return FEATURE_CATEGORY_DESCRIPTORS[category];
+}
+var ZONE_PLAN_TYPE_COLORS = {
+  "land-use-plan": "#f59e0b",
+  // amber        – primary zoning
+  "local-plan": "#ec4899",
+  // pink         – Danish lokalplan
+  "design-plan": "#3b82f6",
+  // blue         – Gestaltungsplan
+  "development-plan": "#0891b2",
+  // cyan         – Bebauungsplan
+  "special-use-plan": "#f97316",
+  // orange       – Sondernutzungsplan
+  "open-space-zone": "#22c55e",
+  // green        – Freihaltezone
+  "overlay-regulation": "#a855f7",
+  // purple       – overlaying regulations
+  "unzoned": "#94a3b8",
+  // slate-400    – nicht zonierte Fläche
+  "municipal-plan-framework": "#6366f1",
+  // indigo       – Kommuneplanramme
+  "neighbourhood-conservation-plan": "#14b8a6",
+  // teal         – Quartiererhaltungszonenplan
+  "noise-sensitivity-plan": "#eab308",
+  // yellow       – Lärmempfindlichkeitsstufenplan
+  "water-protection-plan": "#06b6d4",
+  // sky          – Gewässerschutzzonenplan
+  "nature-landscape-plan": "#16a34a"
+  // dark-green   – Natur- und Landschaftsschutz
+};
+function bboxIntersects(a5, b) {
+  return a5[0] < b[2] && a5[2] > b[0] && a5[1] < b[3] && a5[3] > b[1];
+}
+
+// libs/js/cue-gis/src/lib/nominatim-adapter.ts
+var NOMINATIM_BASE_URL = "https://nominatim.openstreetmap.org";
+var DEFAULT_USER_AGENT = "cue-gis/0.0.1";
+var LAYER_PROBE_QUERY = {
+  address: "street",
+  poi: "shop",
+  railway: "station",
+  natural: "park",
+  manmade: "building",
+  cadastre: "parcel",
+  building: "building",
+  greenspace: "park",
+  paved: "road",
+  zone: "boundary"
+};
+var NOMINATIM_SOURCE_ID = "nominatim";
+function toLayerId(category) {
+  return `${NOMINATIM_SOURCE_ID}:${category}`;
+}
+function toLayerDescriptor(category) {
+  const descriptor = featureCategoryDescriptor(category);
+  return {
+    id: toLayerId(category),
+    sourceId: NOMINATIM_SOURCE_ID,
+    sourceLayerId: category,
+    category,
+    preferredColor: descriptor.preferredColor,
+    tier: "raw",
+    label: descriptor.label,
+    description: `Nominatim ${category} layer`,
+    labelKey: `gis.layer.${NOMINATIM_SOURCE_ID}.${category}.label`,
+    descriptionKey: `gis.layer.${NOMINATIM_SOURCE_ID}.${category}.description`
+  };
+}
+var NominatimAdapter = class {
+  baseUrl;
+  userAgent;
+  email;
+  limit;
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl ?? NOMINATIM_BASE_URL;
+    this.userAgent = options.userAgent ?? DEFAULT_USER_AGENT;
+    this.email = options.email;
+    this.limit = Math.min(options.limit ?? 40, 40);
+  }
+  async listFeatureCategoryDescriptors(bbox) {
+    const checks = await Promise.allSettled(
+      NOMINATIM_FEATURE_CATEGORIES.map(async (category) => {
+        const results = await this.search(bbox, category);
+        return { category, hasResults: results.length > 0 };
+      })
+    );
+    return checks.filter(
+      (r) => r.status === "fulfilled" && r.value.hasResults
+    ).map((r) => featureCategoryDescriptor(r.value.category));
+  }
+  async listAvailableLayers(bbox) {
+    const categories = await this.listFeatureCategoryDescriptors(bbox);
+    return categories.map((category) => toLayerDescriptor(category.category));
+  }
+  async getFeaturesForLayer(bbox, layerId) {
+    const category = FEATURE_CATEGORIES.find((candidate) => toLayerId(candidate) === layerId);
+    if (!category) {
+      return [];
+    }
+    return this.search(bbox, category);
+  }
+  async listFeatureCategories(bbox) {
+    const descriptors = await this.listFeatureCategoryDescriptors(bbox);
+    return descriptors.map((descriptor) => descriptor.category);
+  }
+  async getFeaturesOfCategory(bbox, category) {
+    return this.getFeaturesForLayer(bbox, toLayerId(category));
+  }
+  /**
+   * Low-level search against the Nominatim API. Uses a per-layer probe query
+   * so bounded viewbox searches return meaningful results.
+   */
+  async search(bbox, layer) {
+    const [west, south, east, north] = bbox;
+    const q = layer ? LAYER_PROBE_QUERY[layer] : "place";
+    const params = new URLSearchParams({
+      q,
+      format: "jsonv2",
+      viewbox: `${west},${north},${east},${south}`,
+      bounded: "1",
+      limit: String(this.limit),
+      addressdetails: "1",
+      extratags: "1",
+      dedupe: "1"
+    });
+    if (layer) {
+      params.set("layer", layer);
+    }
+    if (this.email) {
+      params.set("email", this.email);
+    }
+    const url = `${this.baseUrl}/search?${params.toString()}`;
+    const response = await fetch(url, {
+      headers: {
+        "User-Agent": this.userAgent,
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Nominatim request failed: ${response.status} ${response.statusText}`
+      );
+    }
+    const results = await response.json();
+    return results.map((r) => this.toGisFeature(r, layer));
+  }
+  toGisFeature(r, category) {
+    const [s, n, w, e] = r.boundingbox;
+    const resolvedCategory = category ?? r.category;
+    const descriptor = featureCategoryDescriptor(resolvedCategory);
+    return {
+      id: `${r.osm_type}/${r.osm_id}`,
+      sourceId: NOMINATIM_SOURCE_ID,
+      sourceFeatureId: `${r.osm_type}/${r.osm_id}`,
+      layerId: toLayerId(resolvedCategory),
+      name: r.name ?? r.display_name.split(",")[0].trim(),
+      category: resolvedCategory,
+      preferredColor: descriptor.preferredColor,
+      type: r.type,
+      lat: parseFloat(r.lat),
+      lon: parseFloat(r.lon),
+      displayName: r.display_name,
+      bbox: [parseFloat(w), parseFloat(s), parseFloat(e), parseFloat(n)],
+      tier: "raw",
+      originalData: r
+    };
+  }
+};
+
+// libs/js/cue-gis/src/lib/use-classifier.ts
+var DK_BBR_BUILDING = {
+  // 100s – Residential
+  "110": "residential",
+  "120": "residential",
+  "121": "residential",
+  "122": "residential",
+  "130": "residential",
+  "131": "residential",
+  "132": "residential",
+  "140": "residential",
+  "150": "residential",
+  "160": "residential",
+  "190": "residential",
+  // 200s – Recreational / holiday
+  "210": "recreational",
+  "212": "recreational",
+  "220": "recreational",
+  "221": "recreational",
+  "230": "recreational",
+  "290": "residential",
+  // 300s – Agricultural
+  "310": "agricultural",
+  "311": "agricultural",
+  "312": "agricultural",
+  "320": "agricultural",
+  "321": "agricultural",
+  "322": "agricultural",
+  "330": "agricultural",
+  "390": "agricultural",
+  // 400s – Commercial
+  "410": "commercial",
+  "411": "commercial",
+  "420": "commercial",
+  "421": "commercial",
+  "422": "commercial",
+  "430": "commercial",
+  "431": "commercial",
+  "432": "commercial",
+  "440": "commercial",
+  "490": "commercial",
+  // 500s – Industrial / infrastructure
+  "510": "industrial",
+  "511": "industrial",
+  "519": "industrial",
+  "520": "infrastructure",
+  "521": "infrastructure",
+  "522": "infrastructure",
+  "529": "infrastructure",
+  "530": "infrastructure",
+  "531": "infrastructure",
+  "532": "infrastructure",
+  "533": "infrastructure",
+  "534": "infrastructure",
+  "535": "infrastructure",
+  "540": "infrastructure",
+  "585": "infrastructure",
+  "590": "industrial",
+  // 600s – Public / institutional
+  "610": "public",
+  "620": "public",
+  "621": "public",
+  "622": "public",
+  "630": "public",
+  "640": "public",
+  "650": "recreational",
+  "660": "public",
+  "670": "public",
+  "680": "public",
+  "690": "public",
+  // 900s – Accessory / utility
+  "910": "other",
+  "920": "other",
+  "930": "other",
+  "940": "other",
+  "950": "infrastructure",
+  // Teknikbygning (utility / technical building)
+  "960": "agricultural",
+  "970": "agricultural",
+  "990": "other"
+};
+var CH_GWR_BUILDING = {
+  "1010": "residential",
+  "1020": "mixed",
+  "1030": "residential",
+  "1040": "other",
+  "1060": "recreational",
+  "1080": "residential",
+  "1110": "commercial",
+  "1120": "commercial",
+  "1130": "commercial",
+  "1140": "industrial",
+  "1150": "infrastructure",
+  "1160": "infrastructure",
+  "1210": "public",
+  "1220": "public",
+  "1230": "public",
+  "1240": "recreational",
+  "1241": "public",
+  "1242": "recreational",
+  "1251": "public",
+  "1261": "agricultural",
+  "1262": "agricultural",
+  "1263": "agricultural",
+  "1275": "other",
+  "1276": "other",
+  "1277": "infrastructure",
+  "1278": "infrastructure",
+  "1281": "infrastructure",
+  "1282": "infrastructure",
+  "9999": "other"
+};
+var CH_GWR_GKLAS = {
+  // Residential
+  "1110": "residential",
+  // Einfamilienhaus
+  "1121": "recreational",
+  // Ferienhaus / Sommerwohnsitz
+  "1122": "residential",
+  // Mehrfamilienhaus
+  "1130": "mixed",
+  // Wohn- und Geschäftshaus
+  "1140": "mixed",
+  // Wohn- und Landwirtschaftsgebäude
+  // Hospitality
+  "1211": "commercial",
+  // Hotel, Motel
+  "1212": "commercial",
+  // Gaststätten, Restaurant
+  "1213": "mixed",
+  // Pension, Heim (care home / pension)
+  // Office / commercial
+  "1220": "commercial",
+  // Büro- und Verwaltungsgebäude
+  "1230": "commercial",
+  // Handelsbau (retail)
+  "1231": "commercial",
+  // Grosshandel / Grossmarkt
+  // Infrastructure / transport
+  "1241": "infrastructure",
+  // Bahnhof, Flughafen
+  // Leisure
+  "1242": "recreational",
+  // Freizeitgebäude
+  "1264": "recreational",
+  // Sportgebäude
+  // Industrial
+  "1251": "industrial",
+  // Fabrik, Werkstatt
+  "1252": "industrial",
+  // Lagerhalle, Silo
+  // Public / institutional
+  "1261": "public",
+  // Schulen, Bildungsstätten
+  "1262": "public",
+  // Spitäler, Kliniken
+  "1263": "public",
+  // Universität, Forschungsstätte
+  "1265": "public",
+  // Polizei, Militär, Gefängnis
+  "1272": "public",
+  // Religiöse Gebäude und Kultbauten
+  "1273": "public",
+  // Öffentliche Verwaltungsgebäude
+  // Agricultural
+  "1271": "agricultural",
+  // Landwirtschaftsgebäude
+  // Other
+  "1274": "other",
+  // Anderes Gebäude
+  "1281": "infrastructure",
+  // Empfangsgebäude Bahn/Bus
+  "1282": "infrastructure"
+  // Parkhaus, Garage
+};
+var KEYWORD_RULES = [
+  // "Gebäude" is the Swiss AV BoFlaeche land-cover label for a building footprint.
+  // It does not encode the actual use type, so map it to 'other' as a safe fallback.
+  [/^geb[äa]ude$/i, "other"],
+  [/wohn|resident|housing|bolig|enfamil|etagebolig|rækkehus|lejlighed/i, "residential"],
+  [/büro|office|handel|commercial|butik|forretning|kontor|supermarked|lager|hotel|restaurant/i, "commercial"],
+  [/industri|fabrik|industrial|gewerbe|produktion|fabrik|fremstill/i, "industrial"],
+  [/landwirtschaft|agrar|agricultural|landbrug|skov|dyrk|stald|lade|drivhus/i, "agricultural"],
+  [/schule|school|hospital|gesundheit|sundhed|kirche|church|offentlig|uddannelse|kultur|social|plejehjem/i, "public"],
+  [/freizeit|recreation|sport|sommerhus|ferienhaus|fritid|kolonihave/i, "recreational"],
+  [/infrastruktur|verkehr|transport|energy|energie|forsyning|teknik|teknisk/i, "infrastructure"],
+  [/gemischt|mixed|blandet/i, "mixed"]
+];
+function classifyByText(text) {
+  for (const [pattern, use] of KEYWORD_RULES) {
+    if (pattern.test(text))
+      return use;
+  }
+  return void 0;
+}
+function classifyBuildingUse(code, sourceId) {
+  if (code == null)
+    return void 0;
+  const key = String(code).trim();
+  if (sourceId === "swiss-gwr") {
+    return CH_GWR_GKLAS[key] ?? classifyByText(key);
+  }
+  if (sourceId === "danish-matrikel") {
+    return DK_BBR_BUILDING[key] ?? classifyByText(key);
+  }
+  if (sourceId === "zurich-wfs" || sourceId === "swiss-av-wfs") {
+    return CH_GWR_BUILDING[key] ?? classifyByText(key);
+  }
+  return CH_GWR_BUILDING[key] ?? DK_BBR_BUILDING[key] ?? classifyByText(key);
+}
+function classifyPlotUse(use, _sourceId) {
+  if (use == null)
+    return void 0;
+  return classifyByText(String(use).trim());
+}
+function normKey(raw) {
+  return raw.trim().toLowerCase().replace(/[\s_\-]/g, "");
+}
+var ZONE_LEGAL_STATUS_MAP = {
+  // Swiss ÖREB rechtsstatus
+  "inkraft": "in-force",
+  "laufendeanderung": "amendment-pending",
+  "laufende\xE4nderung": "amendment-pending",
+  "aenderungohnevorvirkung": "amendment-pending",
+  // guard against common typo
+  "aenderungohnevorwirkung": "amendment-pending",
+  "\xE4nderungohnevorwirkung": "amendment-pending",
+  "aenderungmitvorwirkung": "amendment-in-effect",
+  "\xE4nderungmitvorwirkung": "amendment-in-effect",
+  "\xF6ffentlicheauflage": "proposed",
+  "offentlicheauflage": "proposed",
+  "aufgehoben": "repealed",
+  // Danish plandata.dk status
+  "vedtaget": "in-force",
+  "forslag": "proposed",
+  "aflyst": "repealed"
+};
+function classifyZoneLegalStatus(raw) {
+  if (!raw)
+    return void 0;
+  return ZONE_LEGAL_STATUS_MAP[normKey(raw)];
+}
+var ZONE_PLAN_TYPE_EXACT = {
+  // Swiss Nutzungsplanung (typ_gde_bezeichnung and common variants)
+  "grundnutzungszonenplan": "land-use-plan",
+  "nutzungszonenplan": "land-use-plan",
+  "zonenplan": "land-use-plan",
+  "gestaltungsplan": "design-plan",
+  "bebauungsplan": "development-plan",
+  "sondernutzungsplan": "special-use-plan",
+  "quartiererhaltungszonenplan": "neighbourhood-conservation-plan",
+  "l\xE4rmempfindlichkeitsstufenplan": "noise-sensitivity-plan",
+  "laermempfindlichkeitsstufenplan": "noise-sensitivity-plan",
+  "gew\xE4sserschutzzonenplan": "water-protection-plan",
+  "gewasserschutzzonenplan": "water-protection-plan",
+  "grundwasserschutzzonenplan": "water-protection-plan",
+  "gew\xE4sserschutzplan": "water-protection-plan",
+  "naturundlandschaftsschutzzonenplan": "nature-landscape-plan",
+  "natur-undlandschaftsschutzzonenplan": "nature-landscape-plan",
+  "landschaftsschutzzonenplan": "nature-landscape-plan",
+  // Freihaltezone — open space / clearance zone within the Grundnutzungszonenplan
+  "freihaltezone": "open-space-zone",
+  // Simple Grundnutzung zone type designations (municipality labels from ogd-0156)
+  "kernzone": "land-use-plan",
+  "wald": "land-use-plan",
+  "gew\xE4sser": "land-use-plan",
+  "gewasser": "land-use-plan",
+  "reservezone": "land-use-plan",
+  "bahnareal": "land-use-plan",
+  "erholungszone": "land-use-plan",
+  // Road / transport area designations
+  "strassen(weitere)": "land-use-plan",
+  "strassen": "land-use-plan",
+  // Unzoned areas
+  "nichtzoniertfl\xE4che": "unzoned",
+  "nichtzoniertefl\xE4che": "unzoned",
+  "nichtzoniertflache": "unzoned",
+  "nichtzonierteflache": "unzoned",
+  "nichtzoniertgem\xE4ssbzo2016": "unzoned",
+  "nichtzoniertgemassbzo2016": "unzoned",
+  // Overlay building/development regulations (Überlagernde Festlegungen)
+  "hochh\xE4user": "overlay-regulation",
+  "hochhauser": "overlay-regulation",
+  "areal\xFCberbauungenzul\xE4ssig": "overlay-regulation",
+  "arealuberbauungenzulassig": "overlay-regulation",
+  "erh\xF6hteausnutzung": "overlay-regulation",
+  "erhohteausnutzung": "overlay-regulation",
+  "erdgeschossnutzung": "overlay-regulation",
+  "freifl\xE4chenzifferverlegungsgebiet": "overlay-regulation",
+  "freiflachenzifferverlegungsgebiet": "overlay-regulation",
+  "baumschutz": "overlay-regulation",
+  // Special building regulations (Sonderbauvorschriften)
+  "sonderbauvorschriften": "overlay-regulation",
+  // Danish plandata.dk
+  "lokalplan": "local-plan",
+  "kommuneplanramme": "municipal-plan-framework"
+};
+var ZONE_PLAN_TYPE_KEYWORDS = [
+  [/quartiererhalt/i, "neighbourhood-conservation-plan"],
+  [/lärmempfindlich|laermempfindlich/i, "noise-sensitivity-plan"],
+  [/gewässerschutz|grundwasserschutz/i, "water-protection-plan"],
+  [/natur.*landschaft|landschaft.*schutz/i, "nature-landscape-plan"],
+  [/gestaltungsplan/i, "design-plan"],
+  [/bebauungsplan/i, "development-plan"],
+  [/sondernutzung/i, "special-use-plan"],
+  // Freihaltezone / open-space clearance zones (before general zonenplan catch-all)
+  [/freihalt/i, "open-space-zone"],
+  // Zone für öffentliche Bauten — public-facilities land-use zone
+  [/öffentliche.*bauten|zone.*öffentlich/i, "land-use-plan"],
+  // Overlaying building/development regulations
+  [/hochhaus/i, "overlay-regulation"],
+  [/arealüberbauung|arealuberbauung/i, "overlay-regulation"],
+  [/erhöhte.*ausnutzung|ausnutzung/i, "overlay-regulation"],
+  [/erdgeschossnutzung/i, "overlay-regulation"],
+  [/freiflächenzifferverlegung|freiflachenzifferverlegung/i, "overlay-regulation"],
+  [/erhaltenswert/i, "overlay-regulation"],
+  [/m[\u00e4a]ssig.*st[\u00f6o]rend|st[\u00f6o]rendes.*gewerbe/i, "overlay-regulation"],
+  // Grundnutzung zone type designations (municipality labels, ogd-0156)
+  [/wohnzone/i, "land-use-plan"],
+  [/kernzone|zentrumszone/i, "land-use-plan"],
+  [/erholungszone|erholungs/i, "land-use-plan"],
+  [/stra[sß]en/i, "land-use-plan"],
+  [/landwirtschaft/i, "land-use-plan"],
+  [/\bwald\b/i, "land-use-plan"],
+  [/\bgew[\u00e4a]sser\b/i, "land-use-plan"],
+  // Unzoned areas
+  [/nicht\s*zoniert/i, "unzoned"],
+  // Tree / vegetation protection overlay
+  [/baumschutz/i, "overlay-regulation"],
+  // Special building regulations not under standard building ordinance
+  [/sonderbauvorschrift/i, "overlay-regulation"],
+  [/kommuneplan/i, "municipal-plan-framework"],
+  [/lokalplan/i, "local-plan"],
+  [/zonenplan|nutzungsplan|nutzungszone/i, "land-use-plan"],
+  // Catch-all: any remaining Xzone / Xareal designation from the Grundnutzungszonenplan
+  [/zone$|areal$/i, "land-use-plan"]
+];
+function classifyZonePlanType(raw) {
+  if (!raw)
+    return void 0;
+  const key = normKey(raw);
+  if (key in ZONE_PLAN_TYPE_EXACT)
+    return ZONE_PLAN_TYPE_EXACT[key];
+  for (const [pattern, planType] of ZONE_PLAN_TYPE_KEYWORDS) {
+    if (pattern.test(raw))
+      return planType;
+  }
+  console.warn(
+    `[cue-gis] Unknown zone plan type \u2014 add "${raw}" to classifyZonePlanType: no ZonePlanType mapping found.`
+  );
+  return void 0;
+}
+
+// libs/js/cue-gis/src/lib/zurich-maps-adapter.ts
+var WFS_BASE_URL = "https://maps.zh.ch/wfs/OGDZHWFS";
+var ZURICH_SOURCE_ID = "zurich-wfs";
+var ZURICH_CANTON_BBOX = [8.35, 47.15, 8.95, 47.7];
+var SWITZERLAND_BBOX = [5.9, 45.7, 10.55, 47.85];
+function entryTypeName(entry) {
+  return typeof entry === "string" ? entry : entry.typeName;
+}
+function entryCqlFilter(entry) {
+  return typeof entry === "string" ? void 0 : entry.cqlFilter;
+}
+function firstCoordinate(geometry) {
+  if (!geometry)
+    return [0, 0];
+  const coords = geometry.coordinates;
+  switch (geometry.type) {
+    case "Point":
+      return coords;
+    case "MultiPoint":
+    case "LineString":
+      return coords[0];
+    case "MultiLineString":
+    case "Polygon":
+      return coords[0][0];
+    case "MultiPolygon":
+      return coords[0][0][0];
+    default:
+      return [0, 0];
+  }
+}
+function pickName(props, fallback) {
+  if (!props)
+    return fallback;
+  for (const key of ["plannavn", "bezeichnung", "name", "strassenname", "objektname", "title", "label"]) {
+    if (typeof props[key] === "string" && props[key])
+      return props[key];
+  }
+  return fallback;
+}
+function toLayerId2(sourceId, typeName, cqlFilter) {
+  if (!cqlFilter)
+    return `${sourceId}:${typeName}`;
+  return `${sourceId}:${typeName}[${cqlFilter}]`;
+}
+var PRIORITY_CATEGORIES = /* @__PURE__ */ new Set(["building", "cadastre", "greenspace", "paved", "zone"]);
+function toLayerDescriptor2(sourceId, category, typeName, cqlFilter) {
+  const shortName = typeName.replace(/^ms:/, "");
+  const descriptor = featureCategoryDescriptor(category);
+  const tier = PRIORITY_CATEGORIES.has(category) ? "priority" : "raw";
+  return {
+    id: toLayerId2(sourceId, typeName, cqlFilter),
+    sourceId,
+    sourceLayerId: typeName,
+    category,
+    preferredColor: descriptor.preferredColor,
+    tier,
+    label: shortName,
+    description: `Z\xFCrich WFS layer ${shortName}`,
+    labelKey: `gis.layer.${sourceId}.${shortName}.label`,
+    descriptionKey: `gis.layer.${sourceId}.${shortName}.description`
+  };
+}
+function toNormalisedBuildingProperties(props, sourceId) {
+  if (!props)
+    return { featureType: "building" };
+  const rawArea = props["grundflaeche"] ?? props["gbf"] ?? props["gebaeudegrundrissflaeche"] ?? props["flaeche"] ?? void 0;
+  const rawFloors = props["vollgeschosse"] ?? props["geschossanzahl"] ?? props["anzahl_geschosse"] ?? void 0;
+  const buildingUse = props["gebaeudefunktion"] ?? props["gfkode"] ?? props["art"] ?? props["objektart"] ?? void 0;
+  const rawYear = props["baujahr"] ?? props["bauperiode"] ?? void 0;
+  const registryId = String(props["egid"] ?? props["gwr_egid"] ?? props["egris_egid"] ?? "").trim() || void 0;
+  return {
+    featureType: "building",
+    areaM2: typeof rawArea === "number" ? rawArea : void 0,
+    buildingUse: buildingUse ? String(buildingUse) : void 0,
+    buildingUseGeneric: classifyBuildingUse(buildingUse, sourceId),
+    floors: typeof rawFloors === "number" ? rawFloors : void 0,
+    yearBuilt: typeof rawYear === "number" ? rawYear : void 0,
+    registryId
+  };
+}
+function toNormalisedPlotProperties(props, sourceId) {
+  if (!props)
+    return { featureType: "plot" };
+  const registryId = props["egris_egrid"] ?? props["egrid"] ?? void 0;
+  const nummer = props["nummer"] ?? void 0;
+  const nbident = props["nbident"] ?? void 0;
+  const plotId = nummer && nbident ? `${nummer}, ${nbident}` : nummer ?? void 0;
+  const rawArea = props["flaechenmass"] ?? props["flaeche"] ?? void 0;
+  const plotUse = props["art"] ?? props["nutzungsart"] ?? void 0;
+  return {
+    featureType: "plot",
+    areaM2: typeof rawArea === "number" ? rawArea : void 0,
+    plotUse: plotUse ? String(plotUse) : void 0,
+    plotUseGeneric: classifyPlotUse(plotUse, sourceId),
+    plotId,
+    registryId
+  };
+}
+function toNormalisedGreenspaceProperties(props) {
+  if (!props)
+    return { featureType: "greenspace" };
+  const rawArea = props["flaeche"] ?? void 0;
+  const surfaceType = props["art"] ?? void 0;
+  return {
+    featureType: "greenspace",
+    areaM2: typeof rawArea === "number" ? rawArea : void 0,
+    surfaceType: surfaceType ? String(surfaceType) : void 0
+  };
+}
+function toNormalisedPavedProperties(props) {
+  if (!props)
+    return { featureType: "paved" };
+  const rawArea = props["flaeche"] ?? void 0;
+  const surfaceType = props["art"] ?? void 0;
+  return {
+    featureType: "paved",
+    areaM2: typeof rawArea === "number" ? rawArea : void 0,
+    surfaceType: surfaceType ? String(surfaceType) : void 0
+  };
+}
+function toNormalisedZoneProperties(props) {
+  if (!props)
+    return { featureType: "zone" };
+  const zoneType = props["plannavn"] ?? props["bezeichnung"] ?? props["typ_bezeichnung"] ?? props["art"] ?? void 0;
+  const planId = props["planid"] ?? props["plannummer"] ?? void 0;
+  const zoneCode = props["artcode"] ?? props["typ_code"] ?? props["abkuerzung"] ?? planId ?? void 0;
+  const rawLegalStatus = props["rechtsstatus"] ?? props["status"] ?? void 0;
+  const legalStatus = classifyZoneLegalStatus(rawLegalStatus);
+  const rawPlanType = props["typ_gde_bezeichnung"] ?? void 0;
+  const planType = classifyZonePlanType(rawPlanType);
+  const planDocumentLink = props["dagsordenpunkt_url"] ?? props["dokument_url"] ?? props["link"] ?? void 0;
+  const publicationDate = props["auflagedatum"] ?? void 0;
+  const fixingDate = props["festsetzungsdatum"] ?? void 0;
+  const approvalDate = props["genehmigungsdatum"] ?? void 0;
+  const effectiveFrom = props["inkraftsetzungsdatum"] ?? void 0;
+  const rawArea = props["flaeche"] ?? props["flaeche_m2"] ?? void 0;
+  return {
+    featureType: "zone",
+    zoneType: zoneType ? String(zoneType) : void 0,
+    zoneCode: zoneCode ? String(zoneCode) : void 0,
+    legalStatus,
+    planType,
+    planId: planId ? String(planId) : void 0,
+    planDocumentLink: planDocumentLink ? String(planDocumentLink) : void 0,
+    publicationDate: publicationDate ?? void 0,
+    fixingDate: fixingDate ?? void 0,
+    approvalDate: approvalDate ?? void 0,
+    effectiveFrom: effectiveFrom ?? void 0,
+    areaM2: typeof rawArea === "number" ? rawArea : void 0
+  };
+}
+function _makeCqlPostFilter(cqlFilter) {
+  const eqMatch = cqlFilter.match(/^(\w+)\s*=\s*'([^']+)'$/);
+  if (eqMatch) {
+    const [, field, value] = eqMatch;
+    return (props) => String(props?.[field] ?? "") === value;
+  }
+  const inMatch = cqlFilter.match(/^(\w+)\s+IN\s*\(([^)]+)\)$/i);
+  if (inMatch) {
+    const [, field, valuesStr] = inMatch;
+    const allowed = new Set(
+      valuesStr.split(",").map((v) => v.trim().replace(/^'|'$/g, ""))
+    );
+    return (props) => allowed.has(String(props?.[field] ?? ""));
+  }
+  return () => true;
+}
+var ZurichMapsAdapter = class {
+  categoryMap;
+  baseUrl;
+  sourceId;
+  outputFormat;
+  constructor(options) {
+    this.categoryMap = options.categoryMap;
+    this.baseUrl = options.baseUrl ?? WFS_BASE_URL;
+    this.sourceId = options.sourceId ?? ZURICH_SOURCE_ID;
+    this.outputFormat = options.outputFormat ?? "application/json; subtype=geojson";
+  }
+  async listFeatureCategoryDescriptors(bbox) {
+    const layers = await this.listAvailableLayers(bbox);
+    return [...new Map(layers.map((layer) => [layer.category, featureCategoryDescriptor(layer.category)])).values()];
+  }
+  async listAvailableLayers(bbox) {
+    const entries = Object.entries(this.categoryMap);
+    const results = await Promise.allSettled(
+      entries.flatMap(
+        ([category, layerEntries]) => layerEntries.map(async (entry) => {
+          const typeName = entryTypeName(entry);
+          const cqlFilter = entryCqlFilter(entry);
+          const fc = await this._fetchFeatures(bbox, typeName, 1, cqlFilter);
+          return { category, typeName, cqlFilter, hasResults: fc.features.length > 0 };
+        })
+      )
+    );
+    return results.filter(
+      (r) => r.status === "fulfilled" && r.value.hasResults
+    ).map((r) => toLayerDescriptor2(this.sourceId, r.value.category, r.value.typeName, r.value.cqlFilter));
+  }
+  async getFeaturesForLayer(bbox, layerId) {
+    const found = this._findLayerById(layerId);
+    if (!found)
+      return [];
+    return this._fetchAndConvert(bbox, found.descriptor, found.cqlFilter);
+  }
+  async _fetchAndConvert(bbox, layer, cqlFilter) {
+    const fc = await this._fetchFeatures(bbox, layer.sourceLayerId, void 0, cqlFilter);
+    const postFilter = cqlFilter ? _makeCqlPostFilter(cqlFilter) : void 0;
+    const features = postFilter ? fc.features.filter((f) => postFilter(f.properties)) : fc.features;
+    return features.map((feature, index) => this.toGisFeature(feature, layer, index));
+  }
+  /**
+   * Returns the categories that have at least one configured typename AND at
+   * least one feature in the given bbox (light `count=1` probe per typename).
+   */
+  async listFeatureCategories(bbox) {
+    const layers = await this.listAvailableLayers(bbox);
+    return [...new Set(layers.map((layer) => layer.category))];
+  }
+  async getFeaturesOfCategory(bbox, category) {
+    const entries = this.categoryMap[category] ?? [];
+    const batches = await Promise.all(
+      entries.map((entry) => {
+        const typeName = entryTypeName(entry);
+        const cqlFilter = entryCqlFilter(entry);
+        const layer = toLayerDescriptor2(this.sourceId, category, typeName);
+        return this._fetchAndConvert(bbox, layer, cqlFilter);
+      })
+    );
+    return batches.flat();
+  }
+  // ─── Private helpers ────────────────────────────────────────────────────────
+  _findLayerById(layerId) {
+    const entries = Object.entries(this.categoryMap);
+    for (const [category, layerEntries] of entries) {
+      for (const entry of layerEntries) {
+        const typeName = entryTypeName(entry);
+        const cqlFilter = entryCqlFilter(entry);
+        const layer = toLayerDescriptor2(this.sourceId, category, typeName, cqlFilter);
+        if (layer.id === layerId) {
+          return { descriptor: layer, cqlFilter };
+        }
+      }
+    }
+    return void 0;
+  }
+  async _fetchFeatures(bbox, typeName, count, cqlFilter) {
+    const [west, south, east, north] = bbox;
+    const bboxParam = `${south},${west},${north},${east},urn:ogc:def:crs:EPSG::4326`;
+    const params = new URLSearchParams({
+      service: "WFS",
+      version: "2.0.0",
+      request: "GetFeature",
+      typename: typeName,
+      bbox: bboxParam,
+      srsName: "EPSG:4326",
+      outputFormat: this.outputFormat
+    });
+    if (count !== void 0) {
+      params.set("count", String(count));
+    }
+    if (cqlFilter !== void 0) {
+      params.set("CQL_FILTER", cqlFilter);
+    }
+    params.set("outputFormat", this.outputFormat);
+    const url = `${this.baseUrl}?${params.toString()}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(
+        `WFS request failed for ${typeName} (${this.sourceId}): ${response.status} ${response.statusText}`
+      );
+    }
+    return response.json();
+  }
+  toGisFeature(feature, layer, index) {
+    const [lon, lat] = firstCoordinate(feature.geometry);
+    const name = pickName(feature.properties, `${layer.sourceLayerId}[${index}]`);
+    const featureBBox = feature.bbox ? [feature.bbox[0], feature.bbox[1], feature.bbox[2], feature.bbox[3]] : void 0;
+    const tier = layer.tier;
+    const properties = tier === "priority" ? this._extractNormalisedProperties(feature, layer) : void 0;
+    return {
+      id: feature.id ?? `${layer.sourceLayerId}/${index}`,
+      preferredColor: layer.preferredColor,
+      sourceId: this.sourceId,
+      sourceFeatureId: feature.id ?? `${layer.sourceLayerId}/${index}`,
+      layerId: layer.id,
+      name,
+      category: layer.category,
+      type: layer.sourceLayerId.replace(/^ms:/, ""),
+      lat,
+      lon,
+      displayName: name,
+      bbox: featureBBox,
+      geometry: feature.geometry ?? void 0,
+      tier,
+      properties,
+      originalData: feature.properties ?? {}
+    };
+  }
+  _extractNormalisedProperties(feature, layer) {
+    if (layer.category === "building") {
+      return toNormalisedBuildingProperties(feature.properties, this.sourceId);
+    }
+    if (layer.category === "greenspace") {
+      return toNormalisedGreenspaceProperties(feature.properties);
+    }
+    if (layer.category === "paved") {
+      return toNormalisedPavedProperties(feature.properties);
+    }
+    if (layer.category === "zone") {
+      return toNormalisedZoneProperties(feature.properties);
+    }
+    return toNormalisedPlotProperties(feature.properties, this.sourceId);
+  }
+};
+
+// libs/js/cue-gis/src/lib/danish-cadastre-adapter.ts
+var DENMARK_BBOX = [8, 54.5, 15.2, 57.8];
+
+// libs/js/cue-gis/src/lib/cue-sdk-gis-adapter.ts
+var DEFAULT_DANISH_SDK_CATEGORY_MAP = {
+  building: [
+    { source: "danish-matrikel", typename: "bbr_v001:bygning_current" }
+  ],
+  cadastre: [
+    { source: "danish-matrikel", typename: "mat_v001:lodflade_current" },
+    { source: "danish-matrikel", typename: "mat_v001:samletfastejendom_current" }
+  ]
+};
+function firstCoordinate2(geometry) {
+  if (!geometry)
+    return [0, 0];
+  const coords = geometry.coordinates;
+  switch (geometry.type) {
+    case "Point":
+      return coords;
+    case "MultiPoint":
+    case "LineString":
+      return coords[0];
+    case "MultiLineString":
+    case "Polygon":
+      return coords[0][0];
+    case "MultiPolygon":
+      return coords[0][0][0];
+    default:
+      return [0, 0];
+  }
+}
+function pickName2(props, fallback) {
+  if (!props)
+    return fallback;
+  for (const key of [
+    "mat:matrikelnummer",
+    "matrikelnummer",
+    "mat:ejerlavsnavn",
+    "ejerlavsnavn",
+    "name",
+    "bezeichnung",
+    "stednavntekst",
+    "title",
+    "label"
+  ]) {
+    if (typeof props[key] === "string" && props[key])
+      return props[key];
+  }
+  return fallback;
+}
+function toLayerId3(sourceId, source, typename) {
+  return `${sourceId}:${source}:${typename}`;
+}
+var PRIORITY_CATEGORIES2 = /* @__PURE__ */ new Set(["building", "cadastre", "zone"]);
+function toLayerDescriptor3(sourceId, category, entry) {
+  const shortName = entry.typename.replace(/^[^:]+:/, "");
+  const descriptor = featureCategoryDescriptor(category);
+  const tier = PRIORITY_CATEGORIES2.has(category) ? "priority" : "raw";
+  return {
+    id: toLayerId3(sourceId, entry.source, entry.typename),
+    sourceId,
+    sourceLayerId: entry.typename,
+    category,
+    preferredColor: descriptor.preferredColor,
+    tier,
+    label: entry.label ?? shortName,
+    description: `${entry.source} / ${entry.typename}`,
+    labelKey: `gis.layer.${sourceId}.${entry.source}.${shortName}.label`,
+    descriptionKey: `gis.layer.${sourceId}.${entry.source}.${shortName}.description`
+  };
+}
+function _extractNormalizedProperties(props, category) {
+  if (category === "building") {
+    const rawArea2 = props?.["byg041BebyggetAreal"] ?? props?.["byg038SamletBygningsareal"];
+    const buildingUse = props?.["byg021BygningensAnvendelse"];
+    const registryId = props?.["id_lokalId"];
+    const rawYear = props?.["byg026Opf\xF8relses\xE5r"];
+    return {
+      featureType: "building",
+      areaM2: typeof rawArea2 === "number" ? rawArea2 : void 0,
+      buildingUse: buildingUse ?? void 0,
+      yearBuilt: typeof rawYear === "number" ? rawYear : void 0,
+      registryId: registryId ?? void 0
+    };
+  }
+  if (category === "zone") {
+    const zoneType = props?.["plannavn"] ?? props?.["bezeichnung"] ?? props?.["typ_bezeichnung"] ?? void 0;
+    const planId = props?.["planid"] ?? props?.["plannummer"] ?? void 0;
+    const zoneCode = props?.["artcode"] ?? props?.["typ_code"] ?? planId ?? void 0;
+    const rawLegalStatus = props?.["rechtsstatus"] ?? props?.["status"] ?? void 0;
+    const planDocumentLink = props?.["dagsordenpunkt_url"] ?? props?.["dokument_url"] ?? void 0;
+    const rawArea2 = props?.["flaeche"] ?? props?.["flaeche_m2"] ?? void 0;
+    return {
+      featureType: "zone",
+      zoneType: zoneType ?? void 0,
+      zoneCode: zoneCode ?? void 0,
+      legalStatus: classifyZoneLegalStatus(rawLegalStatus),
+      planType: classifyZonePlanType(props?.["typ_gde_bezeichnung"]),
+      planId: planId ?? void 0,
+      planDocumentLink: planDocumentLink ?? void 0,
+      publicationDate: props?.["auflagedatum"] ?? void 0,
+      fixingDate: props?.["festsetzungsdatum"] ?? void 0,
+      approvalDate: props?.["genehmigungsdatum"] ?? void 0,
+      effectiveFrom: props?.["inkraftsetzungsdatum"] ?? void 0,
+      areaM2: typeof rawArea2 === "number" ? rawArea2 : void 0
+    };
+  }
+  const parcelNr = props?.["mat:matrikelnummer"] ?? props?.["matrikelnummer"];
+  const districtName = props?.["mat:ejerlavsnavn"] ?? props?.["ejerlavsnavn"];
+  const rawArea = props?.["mat:registreretareal"] ?? props?.["registreretareal"];
+  const bfeNr = props?.["mat:bfenummer"] ?? props?.["bfenummer"];
+  return {
+    featureType: "plot",
+    areaM2: typeof rawArea === "number" ? rawArea : void 0,
+    plotId: parcelNr && districtName ? `${parcelNr}, ${districtName}` : parcelNr ?? void 0,
+    registryId: bfeNr ?? void 0
+  };
+}
+var CueSdkGisAdapter = class {
+  categoryMap;
+  dataViewsBaseUrl;
+  getHeaders;
+  sourceId;
+  constructor(options) {
+    this.dataViewsBaseUrl = options.dataViewsBaseUrl.replace(/\/$/, "");
+    this.getHeaders = options.getHeaders;
+    this.categoryMap = options.categoryMap ?? DEFAULT_DANISH_SDK_CATEGORY_MAP;
+    this.sourceId = options.sourceId ?? "cue-sdk-gis";
+  }
+  async listFeatureCategoryDescriptors(bbox) {
+    const layers = await this.listAvailableLayers(bbox);
+    return [
+      ...new Map(
+        layers.map((l) => [l.category, featureCategoryDescriptor(l.category)])
+      ).values()
+    ];
+  }
+  async listAvailableLayers(bbox) {
+    const entries = Object.entries(this.categoryMap);
+    const results = await Promise.allSettled(
+      entries.flatMap(
+        ([category, layerEntries]) => layerEntries.map(async (entry) => {
+          const fc = await this._fetchFeatures(bbox, entry, 1);
+          return { category, entry, hasResults: fc.features.length > 0 };
+        })
+      )
+    );
+    return results.filter(
+      (r) => r.status === "fulfilled" && r.value.hasResults
+    ).map((r) => toLayerDescriptor3(this.sourceId, r.value.category, r.value.entry));
+  }
+  async getFeaturesForLayer(bbox, layerId) {
+    const result = this._findLayerById(layerId);
+    if (!result)
+      return [];
+    const fc = await this._fetchFeatures(bbox, result.entry);
+    return fc.features.map((f, i) => this._toGisFeature(f, result.descriptor, i));
+  }
+  async listFeatureCategories(bbox) {
+    const layers = await this.listAvailableLayers(bbox);
+    return [...new Set(layers.map((l) => l.category))];
+  }
+  async getFeaturesOfCategory(bbox, category) {
+    const layerEntries = this.categoryMap[category] ?? [];
+    const batches = await Promise.all(
+      layerEntries.map((entry) => {
+        const descriptor = toLayerDescriptor3(this.sourceId, category, entry);
+        return this.getFeaturesForLayer(bbox, descriptor.id);
+      })
+    );
+    return batches.flat();
+  }
+  // ─── Private helpers ────────────────────────────────────────────────────────
+  _findLayerById(layerId) {
+    for (const [category, entries] of Object.entries(this.categoryMap)) {
+      for (const entry of entries) {
+        const descriptor = toLayerDescriptor3(this.sourceId, category, entry);
+        if (descriptor.id === layerId)
+          return { entry, descriptor };
+      }
+    }
+    return void 0;
+  }
+  async _fetchFeatures(bbox, entry, count) {
+    const [west, south, east, north] = bbox;
+    const headers = await this.getHeaders();
+    const params = new URLSearchParams({
+      source: entry.source,
+      typename: entry.typename,
+      bbox: `${west},${south},${east},${north}`
+    });
+    if (count !== void 0) {
+      params.set("count", String(count));
+    }
+    const url = `${this.dataViewsBaseUrl}/gis/features?${params.toString()}`;
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+      throw new Error(
+        `CueSdkGisAdapter: request failed for ${entry.source}/${entry.typename}: ${response.status} ${response.statusText}`
+      );
+    }
+    return response.json();
+  }
+  _toGisFeature(feature, layer, index) {
+    const [lon, lat] = firstCoordinate2(feature.geometry);
+    const featureId = feature.id ?? `${layer.sourceLayerId}/${index}`;
+    const name = pickName2(feature.properties, featureId);
+    const featureBBox = feature.bbox ? [feature.bbox[0], feature.bbox[1], feature.bbox[2], feature.bbox[3]] : void 0;
+    const tier = layer.tier;
+    const properties = tier === "priority" ? _extractNormalizedProperties(feature.properties, layer.category) : void 0;
+    return {
+      id: featureId,
+      sourceId: this.sourceId,
+      sourceFeatureId: featureId,
+      layerId: layer.id,
+      name,
+      category: layer.category,
+      preferredColor: layer.preferredColor,
+      type: layer.sourceLayerId.replace(/^[^:]+:/, ""),
+      lat,
+      lon,
+      displayName: name,
+      bbox: featureBBox,
+      geometry: feature.geometry ?? void 0,
+      tier,
+      properties,
+      originalData: feature.properties ?? {}
+    };
+  }
+};
+
+// libs/js/cue-gis/src/lib/global-config.ts
+var DEFAULT_ZURICH_CATEGORY_MAP = {
+  address: [
+    "ms:ogd-0406_arv_basis_avzh_hausnummer_pos_p",
+    "ms:ogd-0571_afv_gv_strat_strassennetz_l"
+  ],
+  poi: [
+    "ms:ogd-0053_giszhpub_ogd_veloparkieranlagen_p",
+    "ms:ogd-0406_arv_basis_avzh_gebaeudeeingang_p"
+  ],
+  railway: [
+    "ms:ogd-0529_afv_gv_seilbahn_skilift_l",
+    "ms:ogd-0529_afv_gv_seilbahn_skilift_p"
+  ],
+  natural: [
+    "ms:ogd-0045_giszhpub_wb_fliessgewaesser_l",
+    "ms:ogd-0045_giszhpub_wb_stehgewaesser_f",
+    "ms:ogd-0111_giszhpub_wald_waldareal_f"
+  ],
+  manmade: [
+    "ms:ogd-0248_giszhpub_en_gebaeude_volumen_ha_f",
+    // Transport / infrastructure surface types from the cantonal land-cover layer.
+    { typeName: "ms:ogd-0401_arv_basis_avzh_bodenbedeckung_f", cqlFilter: "art IN ('Bahngebiet', 'Strasse_Weg', 'Flugplatz', 'Bruecke')" }
+  ],
+  building: [
+    // Individual building footprint polygons from the official cantonal survey (AV ZH).
+    // BoFlaeche covers all land-cover types; the CQL filter restricts to buildings.
+    { typeName: "ms:ogd-0401_arv_basis_avzh_bodenbedeckung_f", cqlFilter: "art = 'Geb\xE4ude'" }
+  ],
+  greenspace: [
+    // Parks, gardens, playgrounds, sports facilities and other vegetated open areas.
+    { typeName: "ms:ogd-0401_arv_basis_avzh_bodenbedeckung_f", cqlFilter: "art IN ('Gartenanlage', 'Parkanlage', 'Spielplatz', 'Sportanlage', 'Friedhof', 'Gehoelz', 'Feuchtgebiet')" }
+  ],
+  paved: [
+    // Sealed / paved ground surfaces (courtyards, sidewalks, parking, etc.).
+    { typeName: "ms:ogd-0401_arv_basis_avzh_bodenbedeckung_f", cqlFilter: "art IN ('befBoden', 'befestigte Fl\xE4che', 'Hof', 'Trottoir', 'Parkplatz')" }
+  ],
+  cadastre: [
+    // Land parcels (Liegenschaften) from the official cantonal survey (AV ZH)
+    "ms:ogd-0404_arv_basis_avzh_liegenschaften_f",
+    // Independent and permanent rights (SelbstRecht / SDR)
+    "ms:ogd-0404_arv_basis_avzh_selbstrecht_f"
+  ],
+  zone: [
+    // ÖREB Nutzungsplanung (Grundnutzung) – primary land-use zoning polygons
+    "ms:ogd-0156_arv_basis_np_gn_zonenflaeche_f",
+    // ÖREB Überlagernde Festlegungen (Flächen) – overlaying planning constraints
+    "ms:ogd-0155_arv_basis_np_ul_flaeche_f"
+  ]
+};
+var DEFAULT_LOCAL_SERVICE_REGIONS = [
+  {
+    name: "Canton of Z\xFCrich",
+    coverageBBox: ZURICH_CANTON_BBOX,
+    supportedCategories: ["address", "poi", "railway", "natural", "manmade", "building", "cadastre", "greenspace", "paved", "zone"],
+    priority: 10,
+    adapter: new ZurichMapsAdapter({
+      categoryMap: DEFAULT_ZURICH_CATEGORY_MAP
+    })
+  },
+  {
+    name: "Switzerland (national AV cadastre)",
+    coverageBBox: SWITZERLAND_BBOX,
+    supportedCategories: ["cadastre"],
+    priority: 5,
+    // Lower priority than canton-specific adapters. For ZH, the canton adapter (priority 10) wins.
+    adapter: new ZurichMapsAdapter({
+      sourceId: "swiss-av-wfs",
+      baseUrl: "https://wfs.geodienste.ch/av_0/deu",
+      categoryMap: {
+        cadastre: [
+          "ms:RESF",
+          // Rechtsgültige Liegenschaften (valid parcels, all cantons)
+          "ms:DPRSF"
+          // Selbständige und dauernde Rechte / SDR (all cantons)
+        ]
+      }
+    })
+  },
+  {
+    /**
+     * Denmark planning zones (lokalplan + kommuneplanrammer) from plandata.dk.
+     *
+     * This is a fully open WFS service (no API key required) provided by
+     * Plandata, the Danish national planning data register.
+     *
+     * - `pdk:lokalplan_vedtaget` – adopted local plans (lokalplaner)
+     * - `pdk:kommuneplanramme_vedtaget` – adopted municipal plan frameworks
+     */
+    name: "Denmark (Plandata.dk \u2013 planning zones)",
+    coverageBBox: DENMARK_BBOX,
+    supportedCategories: ["zone"],
+    priority: 10,
+    adapter: new ZurichMapsAdapter({
+      sourceId: "danish-plandata",
+      baseUrl: "https://wfs.plandata.dk/geoserver/pdk/wfs",
+      outputFormat: "application/json",
+      categoryMap: {
+        zone: [
+          "pdk:lokalplan_vedtaget",
+          // Adopted local plans
+          "pdk:kommuneplanramme_vedtaget"
+          // Adopted municipal plan frameworks
+        ]
+      }
+    })
+  }
+];
+
+// libs/js/cue-gis/src/lib/gis-gateway.ts
+function sortByCanonicalOrder(descriptors) {
+  return [...descriptors].sort(
+    (a5, b) => FEATURE_CATEGORIES.indexOf(a5.category) - FEATURE_CATEGORIES.indexOf(b.category)
+  );
+}
+var GisGateway = class {
+  nominatim;
+  regions;
+  /**
+   * Effective zone plan type colour map — {@link ZONE_PLAN_TYPE_COLORS} merged
+   * with any overrides supplied via {@link GisGatewayOptions.zonePlanTypeColors}.
+   */
+  zonePlanTypeColors;
+  constructor(options = {}) {
+    const {
+      regions,
+      useDefaultRegions = true,
+      zonePlanTypeColors,
+      ...nominatimOptions
+    } = options;
+    this.nominatim = new NominatimAdapter(nominatimOptions);
+    const defaultRegions = useDefaultRegions ? DEFAULT_LOCAL_SERVICE_REGIONS : [];
+    this.regions = regions ?? defaultRegions;
+    this.zonePlanTypeColors = { ...ZONE_PLAN_TYPE_COLORS, ...zonePlanTypeColors };
+  }
+  /**
+   * Return the available feature categories together with UI metadata such as
+   * preferred color.
+   *
+   * When the matching regions declare their {@link LocalServiceRegion.supportedCategories}
+   * the result is built from those declarations without network probing.
+   * Otherwise the winning adapter's own probing is used.
+   *
+   * @param bbox [west, south, east, north] in WGS-84 decimal degrees
+   */
+  async listFeatureCategoryDescriptors(bbox) {
+    const declaredRegions = this.regions.filter((r) => bboxIntersects(r.coverageBBox, bbox) && r.supportedCategories).sort((a5, b) => (b.priority ?? 0) - (a5.priority ?? 0));
+    if (declaredRegions.length > 0) {
+      const seen = /* @__PURE__ */ new Set();
+      const descriptors = [];
+      for (const region of declaredRegions) {
+        for (const cat of region.supportedCategories ?? []) {
+          if (!seen.has(cat)) {
+            seen.add(cat);
+            descriptors.push(featureCategoryDescriptor(cat));
+          }
+        }
+      }
+      for (const cat of NOMINATIM_FEATURE_CATEGORIES) {
+        if (!seen.has(cat)) {
+          descriptors.push(featureCategoryDescriptor(cat));
+        }
+      }
+      return sortByCanonicalOrder(descriptors);
+    }
+    const probed = await this._adapterFor(bbox).listFeatureCategoryDescriptors(bbox);
+    return sortByCanonicalOrder(probed);
+  }
+  /**
+   * Return the feature categories that have at least one result within the
+   * given bounding box.
+   *
+   * @param bbox [west, south, east, north] in WGS-84 decimal degrees
+   */
+  async listFeatureCategories(bbox) {
+    const descriptors = await this.listFeatureCategoryDescriptors(bbox);
+    return descriptors.map((d) => d.category);
+  }
+  /**
+   * Return all available layers for the given bbox using a provider-independent
+   * layer descriptor shape.
+   */
+  async listAvailableLayers(bbox) {
+    return this._adapterFor(bbox).listAvailableLayers(bbox);
+  }
+  /**
+   * Stream GIS features of the given category from **all** services whose
+   * coverage intersects the query bbox (plus the Nominatim global fallback).
+   *
+   * Processing steps:
+   * 1. Log all configured services and their coverage bboxes.
+   * 2. Identify services whose `coverageBBox` intersects `bbox`.
+   * 3. Log the matched services.
+   * 4. Fan out requests to all matched services in parallel; yield features as
+   *    each source resolves (streaming).
+   * 5. All features are already normalised to {@link GisFeature} by each adapter.
+   * 6. Quality-based deduplication: when two sources return a feature for the
+   *    same real-world object, only the higher-quality geometry is emitted.
+   *    A polygon/multipolygon beats a linestring, which beats a point.  If a
+   *    better feature arrives after a lower-quality one was already yielded,
+   *    the better feature is yielded again (same {@link GisFeature.id}) so the
+   *    consumer can replace its copy.
+   *
+   * @param bbox     [west, south, east, north] in WGS-84 decimal degrees
+   * @param category One of the categories returned by {@link listFeatureCategories}
+   */
+  async *streamFeaturesOfCategory(bbox, category) {
+    console.log("[GisGateway] Available services:");
+    for (const region of this.regions) {
+      const [w, s, e, n] = region.coverageBBox;
+      console.log(
+        `  \u2022 ${region.name}  bbox=[${w}, ${s}, ${e}, ${n}]  priority=${region.priority ?? 0}`
+      );
+    }
+    console.log("  \u2022 Nominatim (OSM)  bbox=[global]  priority=-1");
+    const matchedRegions = this.regions.filter(
+      (r) => bboxIntersects(r.coverageBBox, bbox) && (!r.supportedCategories || r.supportedCategories.includes(category))
+    );
+    const sources = [
+      ...matchedRegions.map((r) => ({
+        name: r.name,
+        adapter: r.adapter,
+        priority: r.priority ?? 0
+      })),
+      { name: "Nominatim (OSM)", adapter: this.nominatim, priority: -1 }
+    ];
+    sources.sort((a5, b) => b.priority - a5.priority);
+    console.log(`[GisGateway] Matched services for category "${category}":`);
+    for (const s of sources) {
+      console.log(`  \u2022 ${s.name}  (priority=${s.priority})`);
+    }
+    const qualityMap = /* @__PURE__ */ new Map();
+    const remaining = new Map(
+      sources.map(
+        (s, i) => [
+          i,
+          s.adapter.getFeaturesOfCategory(bbox, category).then((features) => ({ features, idx: i })).catch((err) => {
+            console.warn(`[GisGateway] Source "${s.name}" failed:`, err);
+            return { features: [], idx: i };
+          })
+        ]
+      )
+    );
+    while (remaining.size > 0) {
+      const { features, idx } = await Promise.race(remaining.values());
+      remaining.delete(idx);
+      for (const feature of features) {
+        const key = _dedupKey(feature);
+        const score = _geometryQuality(feature);
+        const best = qualityMap.get(key);
+        if (best === void 0 || score > best) {
+          qualityMap.set(key, score);
+          yield feature;
+        }
+      }
+    }
+  }
+  /**
+   * Return all GIS features of the given category within the bounding box.
+   *
+   * Fans out to all matching services in parallel, then applies:
+   * 1. Spatial merging – Nominatim point features that fall within ~100 m of a
+   *    local-service polygon are merged into that polygon (enriching its
+   *    `originalData`) rather than returned as a separate feature.
+   * 2. Quality-based deduplication – when two unmerged features represent the
+   *    same object, the one with richer geometry is kept.
+   *
+   * @param bbox     [west, south, east, north] in WGS-84 decimal degrees
+   * @param category One of the categories returned by {@link listFeatureCategories}
+   */
+  async getFeaturesOfCategory(bbox, category) {
+    const matchedRegions = this.regions.filter(
+      (r) => bboxIntersects(r.coverageBBox, bbox) && (!r.supportedCategories || r.supportedCategories.includes(category))
+    );
+    const sources = [
+      ...matchedRegions.map((r) => ({ name: r.name, adapter: r.adapter, isNominatim: false })),
+      { name: "Nominatim (OSM)", adapter: this.nominatim, isNominatim: true }
+    ];
+    const batches = await Promise.allSettled(
+      sources.map(
+        (s) => s.adapter.getFeaturesOfCategory(bbox, category).then((features) => ({
+          features,
+          isNominatim: s.isNominatim
+        })).catch((err) => {
+          console.warn(`[GisGateway] Source "${s.name}" failed:`, err);
+          return { features: [], isNominatim: s.isNominatim };
+        })
+      )
+    );
+    const localFeatures = [];
+    const nominatimFeatures = [];
+    for (const result of batches) {
+      if (result.status !== "fulfilled")
+        continue;
+      if (result.value.isNominatim) {
+        nominatimFeatures.push(...result.value.features);
+      } else {
+        localFeatures.push(...result.value.features);
+      }
+    }
+    const merged = _mergeNominatimIntoPolygons(localFeatures, nominatimFeatures);
+    const qualityMap = /* @__PURE__ */ new Map();
+    const deduplicated = [];
+    for (const feature of merged) {
+      const key = _dedupKey(feature);
+      const score = _geometryQuality(feature);
+      const best = qualityMap.get(key);
+      if (best === void 0 || score > best) {
+        qualityMap.set(key, score);
+        deduplicated.push(feature);
+      }
+    }
+    return deduplicated;
+  }
+  /** Fetch features for a specific layer descriptor id. */
+  async getFeaturesForLayer(bbox, layerId) {
+    return this._adapterFor(bbox).getFeaturesForLayer(bbox, layerId);
+  }
+  /** Resolve the best adapter for a query bbox (legacy single-adapter routing). */
+  _adapterFor(bbox) {
+    const region = this.regions.filter((r) => bboxIntersects(r.coverageBBox, bbox)).sort((a5, b) => (b.priority ?? 0) - (a5.priority ?? 0))[0];
+    return region?.adapter ?? this.nominatim;
+  }
+};
+function _geometryQuality(feature) {
+  const gt = feature.geometry?.type;
+  if (gt === "Polygon" || gt === "MultiPolygon")
+    return 3;
+  if (gt === "LineString" || gt === "MultiLineString")
+    return 2;
+  return 1;
+}
+function _dedupKey(feature) {
+  const lat = Math.round(feature.lat * 1e3) / 1e3;
+  const lon = Math.round(feature.lon * 1e3) / 1e3;
+  const name = (feature.name ?? feature.id ?? "").toLowerCase().trim();
+  return `${name}|${lat}|${lon}`;
+}
+var MERGE_THRESHOLD = 1e-3;
+function _latLonDist(a5, b) {
+  const dlat = a5.lat - b.lat;
+  const dlon = a5.lon - b.lon;
+  return Math.sqrt(dlat * dlat + dlon * dlon);
+}
+function _mergeNominatimIntoPolygons(localFeatures, nominatimFeatures) {
+  if (nominatimFeatures.length === 0)
+    return localFeatures;
+  const polygons = localFeatures.filter((f) => _geometryQuality(f) === 3);
+  const nonPolygons = localFeatures.filter((f) => _geometryQuality(f) !== 3);
+  const enriched = polygons.map((f) => ({ feature: { ...f, originalData: { ...f.originalData } }, matched: false }));
+  const unmatched = [];
+  for (const nom of nominatimFeatures) {
+    let bestIdx = -1;
+    let bestDist = MERGE_THRESHOLD;
+    for (let i = 0; i < enriched.length; i++) {
+      const dist = _latLonDist(nom, enriched[i].feature);
+      if (dist < bestDist) {
+        bestDist = dist;
+        bestIdx = i;
+      }
+    }
+    if (bestIdx >= 0) {
+      enriched[bestIdx].feature.originalData = {
+        ...nom.originalData,
+        ...enriched[bestIdx].feature.originalData
+      };
+      enriched[bestIdx].matched = true;
+    } else {
+      unmatched.push(nom);
+    }
+  }
+  return [
+    ...enriched.map((e) => e.feature),
+    ...nonPolygons,
+    ...unmatched
+  ];
+}
+
+// libs/js/cue-sdk/src/lib/gis.ts
+var DATA_VIEWS_PATH = "/data-views";
+var DEBOUNCE_MS = 1500;
+var CueGis = class {
+  // undefined = not yet built
+  /** @internal — construct via `cue.gis`, not directly. */
+  constructor(_getAuthHeaders, _gatewayUrl) {
+    this._getAuthHeaders = _getAuthHeaders;
+    this._gatewayUrl = _gatewayUrl;
+  }
+  _bbox = null;
+  _projectId = null;
+  _selectedCategories = /* @__PURE__ */ new Set();
+  _queryToken = 0;
+  _categoryTokens = /* @__PURE__ */ new Map();
+  _debounceTimer = null;
+  _availableCategories = [];
+  _features = /* @__PURE__ */ new Map();
+  _catListeners = /* @__PURE__ */ new Set();
+  _featListeners = /* @__PURE__ */ new Set();
+  _loadListeners = /* @__PURE__ */ new Set();
+  _gatewayCache = null;
+  _gatewayProjectId = void 0;
+  // ── Setters ───────────────────────────────────────────────────────────────
+  /**
+   * Update the current map viewport.
+   * Triggers a debounced query for available categories and reloads selected ones.
+   */
+  setBbox(bbox) {
+    this._bbox = bbox;
+    this._scheduleDebouncedQuery();
+  }
+  /**
+   * Set or clear the active project.
+   * Rebuilds the authenticated adapter so subsequent requests carry the new project header.
+   */
+  setProjectId(projectId) {
+    if (projectId === this._projectId)
+      return;
+    this._projectId = projectId;
+    this._gatewayCache = null;
+    this._scheduleDebouncedQuery();
+  }
+  /**
+   * Replace the full set of selected categories.
+   * Newly added categories begin loading immediately; removed categories are cleared.
+   */
+  setSelectedCategories(categories) {
+    const prev = this._selectedCategories;
+    this._selectedCategories = new Set(categories);
+    let featuresChanged = false;
+    for (const cat of prev) {
+      if (!categories.has(cat)) {
+        this._features.delete(cat);
+        featuresChanged = true;
+      }
+    }
+    if (featuresChanged)
+      this._emitFeatures();
+    const bbox = this._bbox;
+    if (bbox) {
+      for (const cat of categories) {
+        if (!prev.has(cat))
+          this._loadCategory(cat, bbox, this._queryToken);
+      }
+    }
+  }
+  // ── Subscriptions ─────────────────────────────────────────────────────────
+  /**
+   * Subscribe to available-category updates.
+   * Replays the current value immediately, then fires on every bbox change.
+   * @returns An unsubscribe function.
+   */
+  onAvailableCategories(cb) {
+    cb([...this._availableCategories]);
+    this._catListeners.add(cb);
+    return () => this._catListeners.delete(cb);
+  }
+  /**
+   * Subscribe to the feature map (category → GisFeature[]).
+   * Replays the current value immediately, then fires whenever features change.
+   * @returns An unsubscribe function.
+   */
+  onFeaturesChange(cb) {
+    cb(new Map(this._features));
+    this._featListeners.add(cb);
+    return () => this._featListeners.delete(cb);
+  }
+  /**
+   * Subscribe to the global loading state.
+   * Fires `true` while the category list is being queried, `false` when done.
+   * @returns An unsubscribe function.
+   */
+  onLoadingChange(cb) {
+    this._loadListeners.add(cb);
+    return () => this._loadListeners.delete(cb);
+  }
+  /** Cancel all pending requests and clear all listeners. */
+  destroy() {
+    if (this._debounceTimer !== null)
+      clearTimeout(this._debounceTimer);
+    this._queryToken++;
+    this._catListeners.clear();
+    this._featListeners.clear();
+    this._loadListeners.clear();
+  }
+  // ── Private ───────────────────────────────────────────────────────────────
+  _scheduleDebouncedQuery() {
+    if (this._debounceTimer !== null)
+      clearTimeout(this._debounceTimer);
+    this._debounceTimer = setTimeout(() => this._queryLayers(), DEBOUNCE_MS);
+  }
+  _getGateway() {
+    if (this._gatewayCache !== null && this._gatewayProjectId === this._projectId) {
+      return this._gatewayCache;
+    }
+    const projectId = this._projectId;
+    const regions = [...DEFAULT_LOCAL_SERVICE_REGIONS];
+    if (projectId) {
+      regions.unshift({
+        name: "Cue SDK (authenticated)",
+        coverageBBox: DENMARK_BBOX,
+        supportedCategories: Object.keys(DEFAULT_DANISH_SDK_CATEGORY_MAP),
+        priority: 10,
+        adapter: new CueSdkGisAdapter({
+          dataViewsBaseUrl: `${this._gatewayUrl}${DATA_VIEWS_PATH}`,
+          getHeaders: async () => ({
+            ...await this._getAuthHeaders(),
+            "x-project-id": projectId
+          })
+        })
+      });
+    }
+    this._gatewayCache = new GisGateway({ regions });
+    this._gatewayProjectId = projectId;
+    return this._gatewayCache;
+  }
+  async _queryLayers() {
+    const bbox = this._bbox;
+    if (!bbox)
+      return;
+    this._queryToken++;
+    const token = this._queryToken;
+    this._emitLoading(true);
+    try {
+      const descriptors = await this._getGateway().listFeatureCategoryDescriptors(bbox);
+      if (token !== this._queryToken)
+        return;
+      this._availableCategories = descriptors;
+      this._catListeners.forEach((cb) => cb([...descriptors]));
+      const available = new Set(descriptors.map((d) => d.category));
+      let changed = false;
+      for (const cat of [...this._selectedCategories]) {
+        if (!available.has(cat)) {
+          this._selectedCategories.delete(cat);
+          this._features.delete(cat);
+          changed = true;
+        }
+      }
+      if (changed)
+        this._emitFeatures();
+      for (const cat of this._selectedCategories) {
+        this._loadCategory(cat, bbox, token);
+      }
+    } catch (err) {
+      console.error("[CueGis] Failed to list categories:", err);
+    } finally {
+      if (token === this._queryToken)
+        this._emitLoading(false);
+    }
+  }
+  async _loadCategory(category, bbox, ownerToken) {
+    const catToken = (this._categoryTokens.get(category) ?? 0) + 1;
+    this._categoryTokens.set(category, catToken);
+    try {
+      const features = await this._getGateway().getFeaturesOfCategory(bbox, category);
+      const stale = this._categoryTokens.get(category) !== catToken || ownerToken !== this._queryToken || !this._selectedCategories.has(category);
+      if (stale)
+        return;
+      this._features.set(category, features);
+      this._emitFeatures();
+    } catch (err) {
+      console.error(`[CueGis] Failed to load "${category}":`, err);
+    }
+  }
+  _emitFeatures() {
+    const snapshot = new Map(this._features);
+    this._featListeners.forEach((cb) => cb(snapshot));
+  }
+  _emitLoading(v) {
+    this._loadListeners.forEach((cb) => cb(v));
+  }
+};
+
 // libs/js/cue-sdk/src/lib/project.ts
 var import_firestore3 = require("firebase/firestore");
 var import_functions2 = require("firebase/functions");
@@ -5549,7 +7451,7 @@ var CueProfile = class {
   }
   /** Creates a new API key for the current user. */
   async createAPIKey(expiration) {
-    return this._fetch(ENDPOINT_PROFILE_API_KEYS, {
+    return this._fetch(ENDPOINT_COMMANDS_PROFILE_API_KEYS, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ expiration })
@@ -5558,7 +7460,7 @@ var CueProfile = class {
   /** Revokes the current user's API key. */
   async revokeAPIKey() {
     const response = await this._auth.authenticatedFetch(
-      this._url(ENDPOINT_PROFILE_API_KEYS),
+      this._url(ENDPOINT_COMMANDS_PROFILE_API_KEYS),
       { method: "DELETE" }
     );
     if (!response.ok) {
@@ -5595,10 +7497,26 @@ var CueProfile = class {
     const res = await fn({ uids });
     return res.data;
   }
-  /** Record that the current user has accepted the terms of service. */
-  async acceptTerms() {
-    const fn = (0, import_functions3.httpsCallable)(this._functions, "acceptTerms");
-    await fn({});
+  /** Record that the current user has accepted the terms of service. Sets a `terms` custom claim on the token. */
+  async acceptTerms(version) {
+    await this._fetch(ENDPOINT_COMMANDS_PROFILE_TERMS, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ version })
+    });
+  }
+  /**
+   * Returns the terms version the current user has accepted (e.g. `"v1"`),
+   * or `null` if they have not accepted any version yet.
+   * Reads from the cached ID token — call after `acceptTerms()` with a
+   * force-refreshed token to see the updated value.
+   */
+  async latestTermsAccepted() {
+    const user = this._auth.currentUser;
+    if (!user)
+      return null;
+    const result = await (0, import_auth4.getIdTokenResult)(user);
+    return result.claims["terms"] ?? null;
   }
 };
 
@@ -5785,19 +7703,20 @@ var CueProjectSchema = class {
     this._projectId = _projectId;
     this._queryCache = _queryCache;
     this._graphType = _graphType;
-    this._language = new CueSignal(language);
+    this._currentLang = language;
+    this._api.setLanguage(language);
     this._contentCategories = new CueSignal([]);
     this._entityCategories = new CueSignal([]);
     this._relationships = new CueSignal([]);
     this.availableContentCategories = this._contentCategories.asReadonly();
     this.availableEntityCategories = this._entityCategories.asReadonly();
     this.availableEntityRelationships = this._relationships.asReadonly();
-    this._load(language).catch(
+    this.ready = this._load(language).catch(
       (err) => console.error("[CueProjectSchema] Initial load failed:", err)
     );
   }
   _cache = /* @__PURE__ */ new Map();
-  _language;
+  _currentLang;
   _contentCategories;
   _entityCategories;
   _relationships;
@@ -5807,9 +7726,14 @@ var CueProjectSchema = class {
   availableEntityCategories;
   /** Currently active entity relationship types for the selected language. */
   availableEntityRelationships;
+  /**
+   * Resolves when the initial schema load for the constructor language has
+   * completed (or failed). Await this before reading signal values imperatively.
+   */
+  ready;
   /** Returns the currently active language. */
   get language() {
-    return this._language.get();
+    return this._api.language;
   }
   /**
    * Switch the active language. If the data for this language has already been
@@ -5817,9 +7741,10 @@ var CueProjectSchema = class {
    * is triggered.
    */
   setLanguage(lang) {
-    if (this._language.get() === lang)
+    if (this._currentLang === lang)
       return;
-    this._language.set(lang);
+    this._currentLang = lang;
+    this._api.setLanguage(lang);
     this._load(lang).catch(
       (err) => console.error("[CueProjectSchema] Language switch failed:", err)
     );
@@ -5829,7 +7754,7 @@ var CueProjectSchema = class {
    * Useful when the triplestore data has changed.
    */
   async refresh() {
-    const lang = this._language.get();
+    const lang = this._api.language;
     this._cache.delete(lang);
     await this._load(lang);
   }
@@ -5855,7 +7780,7 @@ var CueProjectSchema = class {
       },
       (snapshot) => {
         this._cache.set(lang, snapshot);
-        if (this._language.get() === lang)
+        if (this._currentLang === lang)
           this._apply(snapshot);
       },
       this._queryCache
@@ -5944,7 +7869,9 @@ var CueProjectEntities = class {
   baseURL;
   // ── Internal writable slices ───────────────────────────────────────────────
   _entityDetails = new CueSignal({});
-  _entityDocuments = new CueSignal({});
+  _entityDocuments = new CueSignal(
+    {}
+  );
   _entityRelationships = new CueSignal({});
   _entityOSMMap = new CueSignal({});
   _osmWKTMap = new CueSignal({});
@@ -5986,7 +7913,10 @@ var CueProjectEntities = class {
     this._entityGraph.set(void 0);
     this._fetchingOSMIds.clear();
     this._fetchEntityGraph().catch(
-      (err) => console.error("[CueProjectEntities] Entity graph fetch failed after reset:", err)
+      (err) => console.error(
+        "[CueProjectEntities] Entity graph fetch failed after reset:",
+        err
+      )
     );
   }
   // ── Public imperative API ──────────────────────────────────────────────────
@@ -5997,7 +7927,9 @@ var CueProjectEntities = class {
    * Data is merged into `entityInfoMap` once the SPARQL response arrives.
    */
   requestEntityData(uuids, includeMentionCount = false) {
-    const newUUIDs = uuids.filter((id) => this._entityDetails.get()[id] === void 0);
+    const newUUIDs = uuids.filter(
+      (id) => this._entityDetails.get()[id] === void 0
+    );
     if (newUUIDs.length === 0)
       return;
     const values = newUUIDs.map((id) => `r:${id}`).join(" ");
@@ -6015,7 +7947,9 @@ WHERE {
 GROUP BY ?id ?mentionCount`;
     this._api.sparql(q, this._projectId, this._graphType).then((data) => {
       const result = data;
-      const updates = { ...this._entityDetails.get() };
+      const updates = {
+        ...this._entityDetails.get()
+      };
       result.results.bindings.forEach((b) => {
         if (!b["id"])
           return;
@@ -6039,7 +7973,9 @@ GROUP BY ?id ?mentionCount`;
    * query and merged into `entityInfoMap` reactively once it arrives.
    */
   async requestEntityLocations(uuids) {
-    const newUUIDs = uuids.filter((id) => this._entityOSMMap.get()[id] === void 0);
+    const newUUIDs = uuids.filter(
+      (id) => this._entityOSMMap.get()[id] === void 0
+    );
     if (newUUIDs.length === 0)
       return;
     const osmInit = { ...this._entityOSMMap.get() };
@@ -6075,7 +8011,11 @@ WHERE {
   }
   BIND(REPLACE(STR(?iri), "^.*/([^/]*)$", "$1") AS ?id)
 }`;
-    const data = await this._api.sparql(q, this._projectId, this._graphType);
+    const data = await this._api.sparql(
+      q,
+      this._projectId,
+      this._graphType
+    );
     const update = { ...this._entityOSMMap.get() };
     data.results.bindings.forEach((b) => {
       if (!b["id"] || !b["osm"])
@@ -6114,7 +8054,10 @@ WHERE {
       this._fetchIncomingRelationships(iri)
     ]);
     const result = { outgoing, incoming };
-    this._entityRelationships.set({ ...this._entityRelationships.get(), [uuid]: result });
+    this._entityRelationships.set({
+      ...this._entityRelationships.get(),
+      [uuid]: result
+    });
     return result;
   }
   /**
@@ -6138,11 +8081,111 @@ WHERE {
          qcy:about ?iri .
     BIND(REPLACE(STR(?doc), "^.*/([^/]*)$", "$1") AS ?id)
 }`;
-    const data = await this._api.sparql(q, this._projectId, this._graphType);
+    const data = await this._api.sparql(
+      q,
+      this._projectId,
+      this._graphType
+    );
     const ids = data.results.bindings.filter((b) => b["id"] !== void 0).map((b) => b["id"].value);
     this._entityDocuments.set({ ...this._entityDocuments.get(), [uuid]: ids });
     return ids;
   }
+  /**
+   * Fetches all `qcy:EntityCategory` IRIs and their preferred labels for this
+   * project. Uses `api.language` (default `'en'`);
+   * falls back to an untagged label when no match is found.
+   */
+  async contentCategoriesInProject(orderByOccurences = true) {
+    const language = this._api.language;
+    const q = `PREFIX qcy: <${qaecyPrefixes["qcy"]}>
+PREFIX skos: <${prefixCC["skos"]}>
+SELECT ?iri (SAMPLE(?l) AS ?label) ?count
+WHERE {
+    ?iri a qcy:EntityCategory .
+    OPTIONAL { ?iri skos:prefLabel ?lang_label FILTER(LANG(?lang_label) = "${language}") }
+    OPTIONAL { ?iri skos:prefLabel ?no_lang_label }
+    BIND(COALESCE(?lang_label, ?no_lang_label) AS ?l)
+    ${orderByOccurences ? "{ SELECT (COUNT(?x) AS ?count) ?iri where { ?x a qcy:CanonicalEntity ; qcy:hasEntityCategory ?iri } GROUP BY ?iri }" : ""}
+}
+GROUP BY ?iri ?count
+ORDER BY ${orderByOccurences ? "DESC(?count)" : "ASC(?label)"}`;
+    const data = await this._api.sparql(
+      q,
+      this._projectId,
+      this._graphType
+    );
+    return data.results.bindings.filter((b) => b["iri"] !== void 0).map((b) => {
+      const count = b["count"] ? parseInt(b["count"].value, 10) : 0;
+      const label = b["label"]?.value ?? b["iri"].value.split("#").at(-1);
+      const labelWithCount = count > 0 ? `${label} (${count})` : label ?? "";
+      return {
+        iri: b["iri"].value,
+        label: labelWithCount
+      };
+    });
+  }
+  async buildSummaryGraph(format) {
+    const q = `PREFIX qcy: <${qaecyPrefixes["qcy"]}>
+SELECT
+  ?sourceCat
+  ?predicate
+  ?targetCat
+  (COUNT(*) AS ?weight)
+WHERE {
+  ?s a qcy:CanonicalEntity ;
+       qcy:hasEntityCategory ?sourceCat .
+  ?o a qcy:CanonicalEntity ;
+       qcy:hasEntityCategory ?targetCat .
+  ?s ?predicate ?o .
+  FILTER(isIRI(?s) && isIRI(?o))
+  FILTER(?predicate != qcy:relatedEntity)
+}
+GROUP BY ?sourceCat ?predicate ?targetCat
+ORDER BY DESC(?weight)`;
+    const data = await this._api.sparql(
+      q,
+      this._projectId,
+      this._graphType
+    );
+    const bindings = data.results.bindings.filter(
+      (b) => b["sourceCat"] && b["predicate"] && b["targetCat"]
+    );
+    if (format === "graph") {
+      const irisSet = /* @__PURE__ */ new Set();
+      const relations = [];
+      for (const b of bindings) {
+        const sourceID = b["sourceCat"].value;
+        const predicate = b["predicate"].value;
+        const targetID = b["targetCat"].value;
+        const weight = parseInt(b["weight"].value, 10);
+        irisSet.add(sourceID);
+        irisSet.add(targetID);
+        relations.push({ sourceID, predicate, targetID, weight });
+      }
+      return {
+        entities: Array.from(irisSet).map((iri) => ({ iri })),
+        relations
+      };
+    }
+    if (format === "md") {
+      const ce = CompactExpand.getInstance();
+      const rows = bindings.map((b) => ({
+        src: ce.compactIRI(b["sourceCat"].value),
+        pred: ce.compactIRI(b["predicate"].value),
+        tgt: ce.compactIRI(b["targetCat"].value),
+        weight: parseInt(b["weight"].value, 10)
+      }));
+      if (rows.length === 0)
+        return "(no results)";
+      const maxSrc = Math.max(...rows.map((r) => r.src.length));
+      const maxPred = Math.max(...rows.map((r) => r.pred.length));
+      const maxTgt = Math.max(...rows.map((r) => r.tgt.length));
+      return rows.map(
+        (r) => `${r.src.padEnd(maxSrc)} -> ${r.pred.padEnd(maxPred)} -> ${r.tgt.padEnd(maxTgt)}  (${r.weight})`
+      ).join("\n");
+    }
+    return data;
+  }
   // ── Private helpers ────────────────────────────────────────────────────────
   _computeEntityInfoMap() {
     const details = this._entityDetails.get();
@@ -6216,7 +8259,11 @@ WHERE {
     FILTER(?rel != qcy:relatedEntity)
 }
 GROUP BY ?rel ?related`;
-    const data = await this._api.sparql(q, this._projectId, this._graphType);
+    const data = await this._api.sparql(
+      q,
+      this._projectId,
+      this._graphType
+    );
     const result = [];
     const detailsUpdate = { ...this._entityDetails.get() };
     data.results.bindings.forEach((b) => {
@@ -6250,7 +8297,11 @@ WHERE {
     FILTER(?rel != qcy:relatedEntity)
 }
 GROUP BY ?rel ?relating`;
-    const data = await this._api.sparql(q, this._projectId, this._graphType);
+    const data = await this._api.sparql(
+      q,
+      this._projectId,
+      this._graphType
+    );
     const result = [];
     const detailsUpdate = { ...this._entityDetails.get() };
     data.results.bindings.forEach((b) => {
@@ -6285,7 +8336,11 @@ GROUP BY ?e1Cat ?e2Cat`;
     await staleWhileRevalidate(
       q,
       async () => {
-        const data = await this._api.sparql(q, this._projectId, this._graphType);
+        const data = await this._api.sparql(
+          q,
+          this._projectId,
+          this._graphType
+        );
         const entities = [];
         const relations = [];
         data.results.bindings.forEach((b) => {
@@ -6342,7 +8397,11 @@ SELECT * WHERE {
         ?s geo:hasGeometry/geo:asWKT ?wkt
     }
 }`;
-    const data = await this._api.sparql(q, this._projectId, this._graphType);
+    const data = await this._api.sparql(
+      q,
+      this._projectId,
+      this._graphType
+    );
     const update = { ...this._osmWKTMap.get() };
     data.results.bindings.forEach((b) => {
       if (!b["s"] || !b["wkt"])
@@ -6362,13 +8421,14 @@ var CueProjectDocuments = class {
     this._queryCache = _queryCache;
     this._graphType = _graphType;
     this.baseURL = `${rdfBase}${_projectId}/`;
-    this._language = language;
+    this._currentLang = language ?? this._api.language;
     this.documentInfoMap = this._documentInfoMap.asReadonly();
     this.projectDocumentsData = this._projectDocumentsData.asReadonly();
   }
   /** Full RDF base URL for this project, e.g. `https://cue.qaecy.com/r/{pid}/` */
   baseURL;
-  _language;
+  /** Tracks the language for which `_documentInfoMap` is currently populated. */
+  _currentLang;
   _documentInfoMap = new CueSignal({});
   _projectDocumentsData = new CueSignal({
     duplicateCount: 0,
@@ -6398,9 +8458,10 @@ var CueProjectDocuments = class {
    * `requestDocumentData()` call.
    */
   setLanguage(lang) {
-    if (this._language === lang)
+    if (this._currentLang === lang)
       return;
-    this._language = lang;
+    this._currentLang = lang;
+    this._api.setLanguage(lang);
     this._documentInfoMap.set({});
   }
   // ── Public API ─────────────────────────────────────────────────────────────
@@ -6442,7 +8503,7 @@ var CueProjectDocuments = class {
     if (newUUIDs.length === 0)
       return;
     const values = newUUIDs.map((id) => `r:${id}`).join(" ");
-    const lang = this._language;
+    const lang = this._api.language;
     const q = `PREFIX qcy: <${qaecyPrefixes["qcy"]}>
 PREFIX r: <${this.baseURL}>
 SELECT ?id ?contentIRI ?suffix ?size ?subject ?summary
@@ -6495,6 +8556,21 @@ GROUP BY ?id ?contentIRI ?suffix ?size ?subject ?summary`;
       (err) => console.error("[CueProjectDocuments] requestDocumentData failed:", err)
     );
   }
+  /**
+   * Returns a single arbitrary file path from the project's triplestore.
+   * Useful for pre-filling path-based query inputs with a realistic example.
+   */
+  async randomFilePath() {
+    const q = `PREFIX qcy: <${qaecyPrefixes["qcy"]}>
+SELECT ?path
+WHERE {
+    ?fl a qcy:FileLocation ;
+        qcy:filePath ?path .
+}
+LIMIT 1`;
+    const data = await this._api.sparql(q, this._projectId, this._graphType);
+    return data.results.bindings[0]?.["path"]?.value ?? null;
+  }
   // ── Private helpers ────────────────────────────────────────────────────────
   async _fetchDocumentsBySuffix() {
     return this._runDocumentsBySuffixQuery(this._buildDocumentsBySuffixQuery());
@@ -6597,6 +8673,7 @@ var CueProjectView = class {
     this.availableContentCategories = this.schema.availableContentCategories;
     this.availableEntityCategories = this.schema.availableEntityCategories;
     this.availableEntityRelationships = this.schema.availableEntityRelationships;
+    this.schemaReady = this.schema.ready;
     this.entityInfoMap = this.entities.entityInfoMap;
     this.entityGraph = this.entities.entityGraph;
     this.documentInfoMap = this.documents.documentInfoMap;
@@ -6617,6 +8694,11 @@ var CueProjectView = class {
   availableEntityCategories;
   /** Available entity relationship types. Auto-fetched on init. */
   availableEntityRelationships;
+  /**
+   * Resolves when the initial schema load has completed. Await before reading
+   * schema signal values imperatively.
+   */
+  schemaReady;
   /** Merged per-entity detail map. Populated lazily via `requestEntityData()` etc. */
   entityInfoMap;
   /** Project-level entity co-occurrence graph. Fetched once on init. */
@@ -7724,7 +9806,10 @@ function uploadedFileMetadata(originalName, projectId, userId, md5, providerId,
 
 // libs/js/cue-sdk/src/lib/sync.ts
 async function _fs2() {
-  return import("fs/promises");
+  return import(
+    /* webpackIgnore: true */
+    "fs/promises"
+  );
 }
 async function _readNodeFile(fullPath) {
   if (typeof window !== "undefined") {
@@ -7759,11 +9844,17 @@ async function _initWasm() {
     _scanFn = mod.scan;
   } else {
     const { readFile } = await _fs2();
-    const { join: join4 } = await import("path");
-    const { pathToFileURL } = await import("url");
+    const { join: join4 } = await import(
+      /* webpackIgnore: true */
+      "path"
+    );
+    const { pathToFileURL } = await import(
+      /* webpackIgnore: true */
+      "url"
+    );
     const wasmDir = join4(__dirname, "assets", "wasm");
     const wasmBinary = await readFile(join4(wasmDir, "dir_scanner_wasm_bg.wasm"));
-    const glueUrl = pathToFileURL(join4(wasmDir, "dir_scanner_wasm.mjs")).href;
+    const glueUrl = pathToFileURL(join4(wasmDir, "dir_scanner_wasm.js")).href;
     const mod = await import(
       /* @vite-ignore */
       glueUrl
@@ -7772,12 +9863,18 @@ async function _initWasm() {
     _scanFn = mod.scan;
   }
 }
-var DEFAULT_GRAPH_TYPE = "fuseki";
+var DEFAULT_GRAPH_TYPE = "qlever";
 var FSS_BATCH_CHUNK_SIZE = 1e3;
 var PENDING_LS_PREFIX = "cue:pending:";
 async function _pendingFilePath(spaceId) {
-  const { tmpdir } = await import("os");
-  const { join: join4 } = await import("path");
+  const { tmpdir } = await import(
+    /* webpackIgnore: true */
+    "os"
+  );
+  const { join: join4 } = await import(
+    /* webpackIgnore: true */
+    "path"
+  );
   return join4(tmpdir(), `cue-sync-pending-${spaceId}.json`);
 }
 async function _loadPending(spaceId) {
@@ -8412,6 +10509,27 @@ var Cue = class _Cue {
   _app;
   _endpoints;
   _isEmulator;
+  _gis = null;
+  /**
+   * Reactive GIS service. Lazily constructed on first access.
+   *
+   * @example
+   * ```ts
+   * cue.gis.setProjectId('my-project');
+   * cue.gis.onAvailableCategories(cats => ...);
+   * cue.gis.setBbox([west, south, east, north]);
+   * cue.gis.setSelectedCategories(new Set(['cadastre', 'building']));
+   * ```
+   */
+  get gis() {
+    if (!this._gis) {
+      this._gis = new CueGis(
+        () => this.api.getAuthHeaders(),
+        this._endpoints.gatewayUrl
+      );
+    }
+    return this._gis;
+  }
   constructor(config = {}) {
     const usingDefaults = !config.apiKey && !config.appId && !config.measurementId;
     if (usingDefaults) {
@@ -9398,10 +11516,17 @@ async function syncHandler(options) {
     process.exit(0);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
+    const cause = err instanceof Error ? err.cause : void 0;
+    const causeCode = cause instanceof Error ? cause.code : void 0;
+    const causeMsg = cause instanceof Error ? cause.message : void 0;
+    const isTimeout = causeCode === "UND_ERR_HEADERS_TIMEOUT" || causeCode === "UND_ERR_BODY_TIMEOUT" || causeCode === "UND_ERR_CONNECT_TIMEOUT" || causeMsg?.includes("Timeout") || msg.includes("fetch failed");
     if (msg.includes("GRAPH_UNAVAILABLE")) {
       console.error("The knowledge graph for this project has no database configured. Contact your administrator or check the project setup.");
-    } else if (msg.includes("GRAPH_TIMEOUT")) {
-      console.error("Could not reach the knowledge graph. Make sure all required services are running.");
+    } else if (msg.includes("GRAPH_TIMEOUT") || isTimeout) {
+      console.error("Could not reach the QAECY API \u2014 the request timed out or the server could not be reached.");
+      console.error("Check your internet connection and try again. If the problem persists, the service may be temporarily unavailable.");
+      if (verbose && causeCode)
+        console.error(`  Cause: ${causeMsg ?? causeCode}`);
     } else if (msg.includes("METADATA_SYNC_FAILED")) {
       console.error("Metadata sync failed. Try again.");
     } else if (msg.includes("LEDGER_WRITE_FAILED") || msg.includes("File structure batch POST failed")) {
@@ -9409,7 +11534,13 @@ async function syncHandler(options) {
         "Failed communication with the knowledge graph. The files are up to date but metadata is not. Run the tool again to sync metadata. This is a swift job."
       );
     } else {
-      console.error("[syncHandler] Unexpected error:", err);
+      console.error("An unexpected error occurred during sync.");
+      if (verbose) {
+        console.error("Details:", err);
+      } else {
+        console.error(`  ${msg}`);
+        console.error("Re-run with --verbose for more details.");
+      }
     }
     process.exit(1);
   }
@@ -9872,6 +12003,97 @@ Project created \u2705`);
   }
 }
 
+// apps/desktop/cue-cli/src/cue-cli-app-builder-tools.ts
+var import_commander = require("commander");
+async function buildCueClient(options) {
+  const key = options.key ?? process.env["CUE_API_KEY"];
+  if (!key) {
+    console.error("API key is required. Provide it via --key or CUE_API_KEY env variable.");
+    process.exit(1);
+  }
+  const cue = new CueNode({
+    apiKey: FIREBASE_CONFIG().apiKey,
+    appId: FIREBASE_CONFIG().appId,
+    measurementId: FIREBASE_CONFIG().measurementId,
+    environment: options.emulators ? "emulator" : "production",
+    ...options.emulators ? { endpoints: getEmulatorEndpoints() } : {}
+  });
+  await cue.auth.signInWithApiKey(key);
+  return cue;
+}
+async function listProjectsHandler(options) {
+  try {
+    const cue = await buildCueClient(options);
+    if (options.verbose)
+      console.error("Fetching projects...");
+    const projects = await cue.api.projects.listProjects();
+    const output = projects.map((p) => ({
+      id: p.id,
+      name: p.name,
+      organizationID: p.organizationID,
+      isPublic: p.isPublic,
+      graphType: p.projectSettings?.graph?.type ?? "qlever",
+      lastSync: p.lastSync
+    }));
+    console.log(JSON.stringify(output, null, 2));
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+async function entitySummaryGraphHandler(options) {
+  try {
+    const cue = await buildCueClient(options);
+    if (options.verbose)
+      console.error(`Fetching entity summary graph for project ${options.space}...`);
+    const entities = new CueProjectEntities(cue.api, options.space);
+    if (options.format === "graph") {
+      const graph = await entities.buildSummaryGraph("graph");
+      console.log(JSON.stringify(graph, null, 2));
+    } else if (options.format === "md") {
+      const md = await entities.buildSummaryGraph("md");
+      console.log(md);
+    } else {
+      const raw = await entities.buildSummaryGraph();
+      console.log(JSON.stringify(raw, null, 2));
+    }
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+async function sparqlHandler(options) {
+  try {
+    let sparqlQuery = options.query;
+    if (!sparqlQuery) {
+      if (process.stdin.isTTY) {
+        console.error("Provide a SPARQL query via --query or pipe it via stdin.");
+        process.exit(1);
+      }
+      const chunks = [];
+      for await (const chunk of process.stdin)
+        chunks.push(chunk);
+      sparqlQuery = Buffer.concat(chunks).toString("utf8").trim();
+    }
+    if (!sparqlQuery) {
+      console.error("SPARQL query is empty.");
+      process.exit(1);
+    }
+    const cue = await buildCueClient(options);
+    if (options.verbose)
+      console.error(`Executing SPARQL query against project ${options.space}...`);
+    const result = await cue.api.sparql(sparqlQuery, options.space);
+    console.log(JSON.stringify(result, null, 2));
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+var appBuilderToolsCommand = new import_commander.Command("app-builder-tools").description("Tools for agent-assisted Cue app development. Outputs JSON for machine consumption.");
+appBuilderToolsCommand.command("list-projects").description("List all projects accessible to the authenticated user").option("-k, --key <api-key>", "Specify the API key (or set CUE_API_KEY env variable)").option("-e, --emulators", "Use emulators", false).option("-v, --verbose", "Enable verbose output", false).action(listProjectsHandler);
+appBuilderToolsCommand.command("entity-summary-graph").description("Fetch the entity category relationship summary graph for a project").requiredOption("-s, --space <id>", "Project ID (required)").option("-k, --key <api-key>", "Specify the API key (or set CUE_API_KEY env variable)").option("-e, --emulators", "Use emulators", false).option("-f, --format <format>", "Output format: md (aligned text), graph (JSON nodes+edges), json (raw SPARQL)", "md").option("-v, --verbose", "Enable verbose output", false).action(entitySummaryGraphHandler);
+appBuilderToolsCommand.command("sparql").description("Execute a SPARQL SELECT query against a project triplestore. Query via --query or stdin.").requiredOption("-s, --space <id>", "Project ID (required)").option("-q, --query <sparql>", "SPARQL query string (or pipe query via stdin)").option("-k, --key <api-key>", "Specify the API key (or set CUE_API_KEY env variable)").option("-e, --emulators", "Use emulators", false).option("-v, --verbose", "Enable verbose output", false).action(sparqlHandler);
+
 // apps/desktop/cue-cli/src/main.ts
 var packageJson;
 try {
@@ -9884,7 +12106,7 @@ try {
     console.warn("Could not find package.json, using fallback version");
   }
 }
-var program = new import_commander.Command();
+var program = new import_commander2.Command();
 program.name("cue-cli").description("Cue Command Line Interface").version(packageJson.version);
 program.command("sync").description("Sync files to Cue").option("-s, --space <id>", "Specify the space ID (omit to pick interactively)").requiredOption("-p, --path <id>", "Specify the folder path (required)").option("-k, --key <api-key>", "Specify the API key (or set CUE_API_KEY env variable)").option("--provider <provider ID>", "Specify the provider ID (eg. sharepoint, drive, dropbox) or leave empty for default provider", "").option("-v, --verbose", "Enable verbose output", false).option("-e, --emulators", "Uses emulators for sync", false).option("-z, --zip", 'Include zipped content (will be unzipped to path "<zip_path>_unzipped". Max uncompressed size: 500 MB, max recursion depth: 3)', false).option("--legacy", "Write RDF as BLOBs to the processed bucket instead of patching the graph directly", false).option("--metadata-only", "Push filesystem-structure metadata for all local files without checking credits or remote state", false).action(syncHandler);
 program.command("dump").description("Dump Cue Knowledge Graph data to file\n				Examples:\n				$ cue-cli dump -s <space_id> -l -v\n				$ cue-cli dump -s <space_id> -j -v").requiredOption("-s, --space <id>", "Specify the space ID (required)").option("-k, --key <api-key>", "Specify the API key (or set CUE_API_KEY env variable)").option("-v, --verbose", "Enable verbose output", false).option("-e, --emulators", "Uses emulators for sync", false).option("-q, --query", "Uses a construct query to get the dump rather than using the /data endpoint", false).option("-j, --jelly", "Downloads a Jelly file rather than the standard Gzipped NQuads format", false).option("-l, --load", "Loads the dumped file into a local triplestore (requires emulators)", false).action(dumpHandler);
@@ -9894,4 +12116,5 @@ program.command("repair-ttl").description("Repair TTL files in the specified spa
 program.command("util-rdf-compare").description("Compare two Turtle (.ttl) files and report semantic differences").requiredOption("--file1 <path>", "Path to the first TTL file").requiredOption("--file2 <path>", "Path to the second TTL file").option("-v, --verbose", "Enable verbose output", false).action(utilRdfCompareHandler);
 program.command("util-remove-rdf-star").description("Remove RDF-star (quoted) triples from an NQuads file. Supports .nq and .nq.gz input/output.").requiredOption("-i, --input <path>", "Input file path (.nq or .nq.gz)").requiredOption("-o, --output <path>", "Output file path (.nq or .nq.gz)").option("-v, --verbose", "Enable verbose output", false).action(utilRemoveRdfStarHandler);
 program.command("create-project").description("Interactively create a new project under an organisation").option("-k, --key <api-key>", "Specify the API key (or set CUE_API_KEY env variable)").option("-e, --emulators", "Uses emulators", false).option("-v, --verbose", "Enable verbose output", false).action(createProjectHandler);
+program.addCommand(appBuilderToolsCommand);
 program.parse(process.argv);