@qaecy/cue-cli 0.0.45 → 0.0.46

package/main.js

@@ -5090,6 +5090,8 @@ 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";
@@ -5221,6 +5223,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;
@@ -5316,9 +5340,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(
@@ -5361,6 +5388,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 +7300,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 +7309,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 +7346,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;
   }
 };
 
@@ -7724,7 +9491,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 +9529,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 +9548,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 +10194,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) {