@unmap/geocoding 0.12.0 → 0.14.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { DEFAULT_GATEWAY } from "@unmap/core";
+import { DEFAULT_GATEWAY as DEFAULT_GATEWAY2, UnmapError as UnmapError2, fetchWithRetry as fetchWithRetry2, parseRetryAfter as parseRetryAfter2 } from "@unmap/core";
 
 // src/legal-land.ts
 var SEP = String.raw`(?:\s*-\s*|\s+)`;
@@ -651,6 +651,317 @@ function parseFocus(raw) {
   return { focus: [lng, lat] };
 }
 
+// src/treaties.ts
+var INCLUDE_VALUES = ["treaties"];
+var COMMUNITY_INCLUDE_VALUES = ["territories", "acknowledgements"];
+function parseInclude(raw, options = {}) {
+  const out = { treaties: false, territories: false, acknowledgements: false };
+  const known = options.community ? [...INCLUDE_VALUES, ...COMMUNITY_INCLUDE_VALUES] : [...INCLUDE_VALUES];
+  for (const token of (raw ?? "").split(",")) {
+    const value = token.trim();
+    if (value === "") continue;
+    if (value === "treaties") {
+      out.treaties = true;
+      continue;
+    }
+    if (COMMUNITY_INCLUDE_VALUES.includes(value)) {
+      if (!options.community) {
+        return { error: `include "${value}" is not available: no community source has been admitted` };
+      }
+      out[value] = true;
+      continue;
+    }
+    return { error: `unknown include "${value}". known: ${known.join(", ")}` };
+  }
+  return out;
+}
+var VERSION_SHAPE = /^(\d{4})-(\d{2})-(\d{2})\.[0-9a-f]{12}$/;
+function isTreatiesVersion(value) {
+  const m = VERSION_SHAPE.exec(value);
+  if (!m) return false;
+  const [year, month, day] = [Number(m[1]), Number(m[2]), Number(m[3])];
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+function parseTreatiesVersion(raw, treatiesIncluded) {
+  if (raw === void 0) return { version: void 0 };
+  if (!treatiesIncluded) return { error: "treaties_version requires include=treaties" };
+  if (!isTreatiesVersion(raw)) {
+    return { error: "treaties_version must be YYYY-MM-DD. followed by 12 lowercase hex characters" };
+  }
+  return { version: raw };
+}
+function pickTreatyLabel(labels, lang) {
+  const preferred = lang.toLowerCase().split("-")[0] === "fr" ? "fr" : "en";
+  const other = preferred === "fr" ? "en" : "fr";
+  for (const l of [preferred, other]) {
+    const text = labels[l];
+    if (text !== void 0 && text.trim() !== "") return { text, lang: l };
+  }
+  return void 0;
+}
+function orderTreatyMatches(matches) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const m of matches) if (!byId.has(m.id)) byId.set(m.id, m);
+  const rank = (c) => c === "historic" ? 0 : 1;
+  return [...byId.values()].sort(
+    (a, b) => rank(a.category) - rank(b.category) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)
+  );
+}
+var CATEGORIES = /* @__PURE__ */ new Set(["historic", "modern"]);
+var BASES = /* @__PURE__ */ new Set(["result_point", "input_point"]);
+var KINDS = /* @__PURE__ */ new Set([
+  "treaty_area",
+  "overall_treaty_area",
+  "settlement_land",
+  "rights_area",
+  "other",
+  "unspecified"
+]);
+var REPRESENTATIONS = /* @__PURE__ */ new Set(["approximate", "illustrative", "unspecified"]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function fail(message) {
+  throw new TypeError(`invalid treaty context: ${message}`);
+}
+function isHttpUrl(value) {
+  if (typeof value !== "string") return false;
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" || url.protocol === "http:";
+  } catch {
+    return false;
+  }
+}
+function checkLabels(value, field) {
+  if (!isRecord(value)) fail(`${field} must be an object`);
+  for (const [k, v] of Object.entries(value)) {
+    if (k !== "en" && k !== "fr" || typeof v !== "string") fail(`${field} may only carry en/fr strings`);
+  }
+}
+function checkMatch(value, i) {
+  const at = `matches[${i}]`;
+  if (!isRecord(value)) fail(`${at} must be an object`);
+  for (const key of ["id", "source_id", "source_record_id", "name"]) {
+    if (typeof value[key] !== "string" || value[key] === "") fail(`${at}.${key} must be a non-empty string`);
+  }
+  if (!CATEGORIES.has(value.category)) fail(`${at}.category`);
+  if (value.name_lang !== "en" && value.name_lang !== "fr") fail(`${at}.name_lang`);
+  checkLabels(value.names, `${at}.names`);
+  if (value.subtype !== void 0 && typeof value.subtype !== "string") fail(`${at}.subtype`);
+  if (value.subtypes !== void 0) checkLabels(value.subtypes, `${at}.subtypes`);
+  if (!KINDS.has(value.geography_kind)) fail(`${at}.geography_kind`);
+  if (!REPRESENTATIONS.has(value.representation)) fail(`${at}.representation`);
+  if (!isHttpUrl(value.source_url)) fail(`${at}.source_url must be an http(s) URL`);
+}
+function parseTreatyContext(value) {
+  if (!isRecord(value)) fail("must be an object");
+  if (value.schema_version !== 1) fail("schema_version must be 1");
+  if (value.status !== "ok" && value.status !== "unavailable") fail("status");
+  const version = value.dataset_version;
+  if (version !== null && (typeof version !== "string" || !isTreatiesVersion(version))) {
+    fail("dataset_version must be a version or null");
+  }
+  if (value.status === "ok" && version === null) fail("an ok context needs a dataset_version");
+  const point2 = value.point;
+  if (!isRecord(point2)) fail("point must be an object");
+  if (typeof point2.lng !== "number" || !Number.isFinite(point2.lng) || point2.lng < -180 || point2.lng > 180) {
+    fail("point.lng");
+  }
+  if (typeof point2.lat !== "number" || !Number.isFinite(point2.lat) || point2.lat < -90 || point2.lat > 90) {
+    fail("point.lat");
+  }
+  if (!BASES.has(point2.basis)) fail("point.basis");
+  const coverage = value.coverage;
+  if (!isRecord(coverage) || coverage.scope !== "Canada" || coverage.completeness !== "partial") fail("coverage");
+  if (value.notice_code !== "source_limitations_apply") fail("notice_code");
+  if (!Array.isArray(value.matches)) fail("matches must be an array");
+  if (value.status === "unavailable" && value.matches.length > 0) fail("an unavailable context carries no matches");
+  value.matches.forEach(checkMatch);
+  return value;
+}
+function unavailableTreatyContext(point2) {
+  return {
+    schema_version: 1,
+    dataset_version: null,
+    status: "unavailable",
+    point: { lng: point2.lng, lat: point2.lat, basis: point2.basis },
+    coverage: { scope: "Canada", completeness: "partial" },
+    matches: [],
+    notice_code: "source_limitations_apply"
+  };
+}
+
+// src/community.ts
+function pickCommunityName(names, lang, defaultLang) {
+  const want = lang.toLowerCase().split("-")[0];
+  for (const [tag, text] of Object.entries(names)) {
+    if (tag.toLowerCase().split("-")[0] === want && text.trim() !== "") return { text, lang: tag };
+  }
+  const fallback = names[defaultLang];
+  return fallback !== void 0 && fallback.trim() !== "" ? { text: fallback, lang: defaultLang } : void 0;
+}
+function point(p) {
+  return { lng: p.lng, lat: p.lat, basis: p.basis };
+}
+function emptyTerritoryContext(p, status) {
+  return {
+    schema_version: 1,
+    dataset_version: null,
+    status,
+    point: point(p),
+    coverage: { scope: "source_defined", completeness: "partial" },
+    matches: [],
+    notice_code: "source_limitations_apply"
+  };
+}
+function emptyAcknowledgementContext(p, status) {
+  return {
+    schema_version: 1,
+    dataset_version: null,
+    status,
+    point: point(p),
+    resources: [],
+    notice_code: "source_limitations_apply"
+  };
+}
+function isRecord2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function fail2(message) {
+  throw new TypeError(`invalid community context: ${message}`);
+}
+function isHttpUrl2(v) {
+  if (typeof v !== "string") return false;
+  try {
+    const { protocol } = new URL(v);
+    return protocol === "https:" || protocol === "http:";
+  } catch {
+    return false;
+  }
+}
+function checkEnvelope(v, list) {
+  if (v.schema_version !== 1) fail2("schema_version must be 1");
+  if (v.status !== "ok" && v.status !== "not_enabled" && v.status !== "unavailable") fail2("status");
+  const version = v.dataset_version;
+  if (version !== null && (typeof version !== "string" || !isTreatiesVersion(version))) fail2("dataset_version");
+  if (v.status === "ok" && version === null) fail2("an ok context needs a dataset_version");
+  if (v.notice_code !== "source_limitations_apply") fail2("notice_code");
+  const p = v.point;
+  if (!isRecord2(p) || typeof p.lng !== "number" || typeof p.lat !== "number" || !Number.isFinite(p.lng) || !Number.isFinite(p.lat)) {
+    fail2("point");
+  }
+  const items = v[list];
+  if (!Array.isArray(items)) fail2(`${list} must be an array`);
+  if (v.status !== "ok" && items.length > 0) fail2(`a ${String(v.status)} context carries no ${list}`);
+  return items;
+}
+function parseTerritoryContext(value) {
+  if (!isRecord2(value)) fail2("must be an object");
+  const items = checkEnvelope(value, "matches");
+  items.forEach((m, i) => {
+    if (!isRecord2(m)) fail2(`matches[${i}]`);
+    for (const k of ["id", "source_id", "source_record_id", "name", "name_lang", "attribution"]) {
+      if (typeof m[k] !== "string" || m[k] === "") fail2(`matches[${i}].${k}`);
+    }
+    if (!Array.isArray(m.community_ids) || m.community_ids.some((c) => typeof c !== "string")) fail2(`matches[${i}].community_ids`);
+    if (!isHttpUrl2(m.source_url)) fail2(`matches[${i}].source_url must be an http(s) URL`);
+  });
+  return value;
+}
+function parseAcknowledgementContext(value) {
+  if (!isRecord2(value)) fail2("must be an object");
+  const items = checkEnvelope(value, "resources");
+  items.forEach((r, i) => {
+    if (!isRecord2(r)) fail2(`resources[${i}]`);
+    for (const k of ["id", "source_id", "title", "language", "attribution", "applicability", "reviewed_at", "content_version"]) {
+      if (typeof r[k] !== "string" || r[k] === "") fail2(`resources[${i}].${k}`);
+    }
+    if (!isHttpUrl2(r.url)) fail2(`resources[${i}].url must be an http(s) URL`);
+    if (!Array.isArray(r.applies_to) || r.applies_to.length === 0 || r.applies_to.some((t) => typeof t !== "string")) {
+      fail2(`resources[${i}].applies_to must name at least one territory`);
+    }
+    if (r.text !== void 0 && typeof r.text !== "string") fail2(`resources[${i}].text`);
+  });
+  return value;
+}
+
+// src/treaty-overlay.ts
+function treatyLayerIds(category) {
+  return [`overlay_treaties_fill_${category}`, `overlay_treaties_line_${category}`];
+}
+var CATEGORIES2 = ["historic", "modern"];
+function createTreatyOverlay(map, client, options = {}) {
+  const visibility = { historic: options.historic ?? true, modern: options.modern ?? true };
+  let lang = options.lang ?? "en";
+  let latest = 0;
+  let destroyed = false;
+  let drawnVersion;
+  const allLayers = () => CATEGORIES2.flatMap((c) => treatyLayerIds(c)).filter((id) => map.getLayer(id));
+  const apply = () => {
+    for (const category of CATEGORIES2) {
+      for (const id of treatyLayerIds(category)) {
+        if (map.getLayer(id)) map.setLayoutProperty(id, "visibility", visibility[category] ? "visible" : "none");
+      }
+    }
+  };
+  const hidden = () => CATEGORIES2.filter((c) => !visibility[c]);
+  async function select(point2, version, drawn) {
+    const id = ++latest;
+    try {
+      const results = await client.reverse(point2[0], point2[1], {
+        include: ["treaties"],
+        lang,
+        limit: 1,
+        ...version ? { treatiesVersion: version } : {}
+      });
+      const context = results[0]?.treaties;
+      if (!context) throw new Error("the geocoder returned no treaty context");
+      const selection = { context, drawn, hidden: hidden() };
+      if (id === latest && !destroyed) options.onSelect?.(selection);
+      return selection;
+    } catch (err) {
+      if (id === latest && !destroyed) {
+        options.onError?.(err instanceof Error ? err : new Error(String(err)));
+      }
+      return void 0;
+    }
+  }
+  const onClick = (e) => {
+    const layers = allLayers();
+    const features = layers.length > 0 ? map.queryRenderedFeatures(e.point, { layers }) : [];
+    const drawn = [...new Set(features.map((f) => f.properties?.id).filter((v) => typeof v === "string"))].sort();
+    const version = features.map((f) => f.properties?.dataset_version).find((v) => typeof v === "string");
+    if (version) drawnVersion = version;
+    void select([e.lngLat.lng, e.lngLat.lat], version ?? drawnVersion, drawn);
+  };
+  map.on("styledata", apply);
+  if (options.interactive !== false) map.on("click", onClick);
+  apply();
+  return {
+    get visibility() {
+      return { ...visibility };
+    },
+    setVisibility(value) {
+      if (value.historic !== void 0) visibility.historic = value.historic;
+      if (value.modern !== void 0) visibility.modern = value.modern;
+      apply();
+    },
+    setLanguage(next) {
+      lang = next;
+    },
+    lookupAt(point2, datasetVersion) {
+      return select(point2, datasetVersion ?? drawnVersion, []);
+    },
+    destroy() {
+      destroyed = true;
+      map.off("styledata", apply);
+      map.off("click", onClick);
+    }
+  };
+}
+
 // src/regions.ts
 var BASE = {
   ab: "AB",
@@ -822,7 +1133,7 @@ function parseQueryLimit(raw) {
 }
 
 // src/rural-route.ts
-var KINDS = [
+var KINDS2 = [
   { pattern: /\b(?:R\.?\s?R\.?|RURAL\s+ROUTE)\s*#?\s*(\d{1,3})\b/i, kind: "rural-route", numbered: true },
   { pattern: /\b(?:S\.?\s?S\.?|SUBURBAN\s+SERVICE)\s*#?\s*(\d{1,3})\b/i, kind: "suburban-service", numbered: true },
   { pattern: /\b(?:M\.?\s?R\.?|MOBILE\s+ROUTE)\s*#?\s*(\d{1,3})\b/i, kind: "mobile-route", numbered: true },
@@ -842,7 +1153,7 @@ function parseRuralRoute(q) {
   if (typeof q !== "string") return null;
   const raw = q.trim();
   if (raw === "") return null;
-  const matched = KINDS.map((k) => ({ ...k, match: k.pattern.exec(raw) })).find((k) => k.match !== null);
+  const matched = KINDS2.map((k) => ({ ...k, match: k.pattern.exec(raw) })).find((k) => k.match !== null);
   if (!matched?.match) return null;
   let rest = raw.replace(matched.pattern, " ");
   const parsed = { raw, kind: matched.kind, remainder: "" };
@@ -860,18 +1171,105 @@ function looksLikeRuralRoute(q) {
   return parseRuralRoute(q) != null;
 }
 
+// src/places.ts
+import { DEFAULT_GATEWAY, UnmapError, fetchWithRetry, parseRetryAfter } from "@unmap/core";
+var PlacesError = class extends UnmapError {
+  constructor(status, message, code, retryAfterSeconds) {
+    super(status, message, code, retryAfterSeconds);
+    this.name = "PlacesError";
+  }
+};
+async function errorFrom(res, path) {
+  const fallback = `places ${res.status} on ${path}`;
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    body = void 0;
+  }
+  const reason = typeof body?.error === "string" ? body.error : void 0;
+  const code = typeof body?.code === "string" ? body.code : void 0;
+  const retryAfter = parseRetryAfter(res.headers?.get("retry-after") ?? null) ?? void 0;
+  return new PlacesError(res.status, reason ? `${reason} (${fallback})` : fallback, code, retryAfter);
+}
+var Places = class {
+  key;
+  base;
+  fetchImpl;
+  retry;
+  constructor(opts) {
+    this.retry = opts.retry;
+    this.key = opts.key;
+    this.base = (opts.gateway ?? DEFAULT_GATEWAY).replace(/\/+$/, "");
+    this.fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  /**
+   * Search places by name.
+   *
+   * Unlike `Geocoder.search()`, which returns whatever best matches and for "Calgary" is the city
+   * itself, this returns places. A missing query is 400 `bad_request` (`q is required`). A bbox
+   * corner outside WGS84 is the same status and code. A box outside Canada stays a filter.
+   */
+  search(q, opts = {}) {
+    return this.request("/places/search", {
+      q,
+      limit: opts.limit != null ? String(opts.limit) : void 0,
+      lang: opts.lang,
+      bbox: opts.bbox?.join(",")
+    }, opts.signal);
+  }
+  /**
+   * Places of a category near a point.
+   *
+   * `category` takes a taxonomy id (`health.pharmacy`) or a word in English or French
+   * (`pharmacy`, `pharmacie`); the gateway resolves aliases, so `"boulangerie"` works. An anchor
+   * outside Canada rejects with status 422 and code `outside_coverage`. A longitude or latitude
+   * outside WGS84, including a bbox corner, rejects with status 400 and code `bad_request`.
+   */
+  nearby(category, opts = {}) {
+    return this.request("/places/nearby", {
+      category: Array.isArray(category) ? category.join(",") : String(category),
+      near: opts.near?.join(","),
+      bbox: opts.bbox?.join(","),
+      radius: opts.radius != null ? String(opts.radius) : void 0,
+      limit: opts.limit != null ? String(opts.limit) : void 0,
+      lang: opts.lang
+    }, opts.signal);
+  }
+  /**
+   * One place by its unmap id.
+   *
+   * Throws `PlacesError` with status 404 when it does not exist. A malformed id is also a 404,
+   * because from a caller's side "does not exist" and "is not a well-formed id" are the same
+   * answer; the gateway's message distinguishes them as far as it honestly can.
+   */
+  get(id, opts = {}) {
+    return this.request(`/places/${encodeURIComponent(id)}`, { lang: opts.lang }, opts.signal);
+  }
+  async request(path, params, signal) {
+    const q = new URLSearchParams({ key: this.key });
+    for (const [k, v] of Object.entries(params)) if (v != null && v !== "") q.set(k, v);
+    const res = await fetchWithRetry(
+      this.fetchImpl,
+      `${this.base}${path}?${q}`,
+      { signal, headers: { accept: "application/json" } },
+      this.retry
+    );
+    if (!res.ok) throw await errorFrom(res, path);
+    return await res.json();
+  }
+};
+
 // src/index.ts
-var GeocoderError = class extends Error {
-  constructor(status, message, code) {
-    super(message);
-    this.status = status;
-    this.code = code;
+import { UnmapError as UnmapError3, parseRetryAfter as parseRetryAfter3 } from "@unmap/core";
+var GEOCODE_BATCH_MAX = 100;
+var GeocoderError = class extends UnmapError2 {
+  constructor(status, message, code, retryAfterSeconds) {
+    super(status, message, code, retryAfterSeconds);
     this.name = "GeocoderError";
   }
-  status;
-  code;
 };
-async function errorFrom(res, path) {
+async function errorFrom2(res, path) {
   const fallback = `geocode ${res.status} on ${path}`;
   let body;
   try {
@@ -881,21 +1279,46 @@ async function errorFrom(res, path) {
   }
   const reason = typeof body?.error === "string" ? body.error : void 0;
   const code = typeof body?.code === "string" ? body.code : void 0;
-  return new GeocoderError(res.status, reason ? `${reason} (${fallback})` : fallback, code);
+  const retryAfter = parseRetryAfter2(res.headers?.get("retry-after") ?? null) ?? void 0;
+  return new GeocoderError(res.status, reason ? `${reason} (${fallback})` : fallback, code, retryAfter);
 }
 var Geocoder = class {
   key;
   base;
   fetchImpl;
+  retry;
   constructor(opts) {
     this.key = opts.key;
-    this.base = (opts.gateway ?? DEFAULT_GATEWAY).replace(/\/+$/, "");
+    this.retry = opts.retry;
+    this.base = (opts.gateway ?? DEFAULT_GATEWAY2).replace(/\/+$/, "");
     this.fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);
   }
   /** Full-text search. */
   search(q, opts = {}) {
     return this.query("/geocode/search", { q, ...toParams(opts) }, opts.signal);
   }
+  /**
+   * Many searches in one or more `POST /geocode/batch` calls, chunked at
+   * {@link GEOCODE_BATCH_MAX}. Results stay aligned to `queries`.
+   */
+  async batch(queries, opts = {}) {
+    if (queries.length === 0) return [];
+    const out = [];
+    for (let i = 0; i < queries.length; i += GEOCODE_BATCH_MAX) {
+      const chunk = queries.slice(i, i + GEOCODE_BATCH_MAX);
+      const body = await this.postJson(
+        "/geocode/batch",
+        {
+          queries: chunk,
+          ...toBatchBody(opts)
+        },
+        opts.signal
+      );
+      if (!Array.isArray(body)) return out.concat(chunk.map(() => []));
+      out.push(...body);
+    }
+    return out;
+  }
   /** Type-ahead suggestions for partial input. */
   autocomplete(q, opts = {}) {
     return this.query("/geocode/autocomplete", { q, ...toParams(opts) }, opts.signal);
@@ -930,7 +1353,9 @@ var Geocoder = class {
    * Category search: POIs of a kind near a point, sorted by distance (metres, in each
    * result's `distance`). `category` takes canonical taxonomy ids ("health.pharmacy") or
    * plain words in English or French ("pharmacy", "pharmacie") — the gateway resolves
-   * aliases, so this client passes the value through untouched.
+   * aliases, so this client passes the value through untouched. An anchor outside Canada rejects
+   * with status 422 and code `outside_coverage`; the corpus is not queried. A longitude or
+   * latitude outside WGS84, including a bbox corner, rejects with status 400 and code `bad_request`.
    */
   nearby(category, opts = {}) {
     return this.query(
@@ -946,11 +1371,21 @@ var Geocoder = class {
       opts.signal
     );
   }
-  /** Reverse geocode a coordinate. */
+  /**
+   * Reverse geocode a coordinate. A point outside Canada rejects with status 422 and code
+   * `outside_coverage`. A longitude or latitude outside WGS84 rejects with status 400 and code
+   * `bad_request`.
+   */
   reverse(lng, lat, opts = {}) {
     return this.query(
       "/geocode/reverse",
-      { lon: String(lng), lat: String(lat), lang: opts.lang },
+      {
+        lon: String(lng),
+        lat: String(lat),
+        lang: opts.lang,
+        limit: opts.limit != null ? String(opts.limit) : void 0,
+        ...treatyParams(opts)
+      },
       opts.signal
     );
   }
@@ -990,14 +1425,27 @@ var Geocoder = class {
       opts.signal
     );
   }
-  async requestJson(path, params, signal) {
+  async postJson(path, body, signal) {
     const q = new URLSearchParams({ key: this.key });
-    for (const [k, v] of Object.entries(params)) if (v != null && v !== "") q.set(k, v);
     const res = await this.fetchImpl(`${this.base}${path}?${q}`, {
+      method: "POST",
       signal,
-      headers: { accept: "application/json" }
+      headers: { accept: "application/json", "content-type": "application/json" },
+      body: JSON.stringify(body)
     });
-    if (!res.ok) throw await errorFrom(res, path);
+    if (!res.ok) throw await errorFrom2(res, path);
+    return res.json();
+  }
+  async requestJson(path, params, signal) {
+    const q = new URLSearchParams({ key: this.key });
+    for (const [k, v] of Object.entries(params)) if (v != null && v !== "") q.set(k, v);
+    const res = await fetchWithRetry2(
+      this.fetchImpl,
+      `${this.base}${path}?${q}`,
+      { signal, headers: { accept: "application/json" } },
+      this.retry
+    );
+    if (!res.ok) throw await errorFrom2(res, path);
     return res.json();
   }
   async query(path, params, signal) {
@@ -1005,6 +1453,20 @@ var Geocoder = class {
     return Array.isArray(body) ? body : body.results ?? [];
   }
 };
+function toBatchBody(o) {
+  return {
+    ...o.limit != null ? { limit: o.limit } : {},
+    ...o.lang ? { lang: o.lang } : {},
+    ...o.bbox ? { bbox: o.bbox.join(",") } : {},
+    ...o.focus ? { focus: o.focus.join(",") } : {},
+    ...o.region ? { region: o.region } : {},
+    ...o.layers ? { layers: o.layers } : {}
+  };
+}
+function treatyParams(o) {
+  const include = o.include && o.include.length > 0 ? [...new Set(o.include)].join(",") : void 0;
+  return { include, treaties_version: o.treatiesVersion };
+}
 function toParams(o) {
   return {
     limit: o.limit != null ? String(o.limit) : void 0,
@@ -1013,32 +1475,42 @@ function toParams(o) {
     focus: o.focus ? o.focus.join(",") : void 0,
     region: o.region,
     geometry: o.geometry ? "true" : void 0,
-    layers: o.layers
+    layers: o.layers,
+    ...treatyParams(o)
   };
 }
 export {
   AMBIGUOUS_SCORE_RATIO,
   CIVIC_SEARCH_LAYERS,
+  COMMUNITY_INCLUDE_VALUES,
   CsvParser,
   DEFAULT_IDENTIFY_LAYERS,
   DEFAULT_QUERY_LIMIT,
   ENERGY_IDENTIFY_LAYER_IDS,
   ENERGY_SEARCH_LAYERS,
+  GEOCODE_BATCH_MAX,
   Geocoder,
   GeocoderError,
   IDENTIFY_LAYER_IDS,
+  INCLUDE_VALUES,
   LAND_IDENTIFY_LAYER_IDS,
   MAX_QUERY_LIMIT,
   MINING_IDENTIFY_LAYER_IDS,
   OUTPUT_COLUMNS,
   OUTPUT_PREFIX,
+  Places,
+  PlacesError,
   QUERY_LAYER_IDS,
   REGIONS,
   REGION_CODES,
   REGION_KEYS,
   STRUCTURED_FIELDS,
+  UnmapError3 as UnmapError,
   alignRow,
   classify,
+  createTreatyOverlay,
+  emptyAcknowledgementContext,
+  emptyTerritoryContext,
   encodeField,
   encodeRow,
   energySearchRequested,
@@ -1047,6 +1519,7 @@ export {
   isEnergySearchSource,
   isIdentifyLayer,
   isLandIdentifyLayer,
+  isTreatiesVersion,
   knownIdentifyLayers,
   knownQueryLayers,
   knownSearchLayers,
@@ -1055,23 +1528,34 @@ export {
   looksLikeLegalLand,
   looksLikeParcel,
   looksLikeRuralRoute,
+  orderTreatyMatches,
   outputValues,
+  parseAcknowledgementContext,
   parseEnergyQuery,
   parseEnergySearchLayers,
   parseFocus,
   parseIdentifyAt,
   parseIdentifyLayers,
+  parseInclude,
   parseLegalLand,
   parseParcel,
   parseQueryBbox,
   parseQueryLayer,
   parseQueryLimit,
   parseRegion,
+  parseRetryAfter3 as parseRetryAfter,
   parseRuralRoute,
   parseSearchLayers,
   parseStructuredQuery,
+  parseTerritoryContext,
+  parseTreatiesVersion,
+  parseTreatyContext,
+  pickCommunityName,
+  pickTreatyLabel,
   regionForms,
   resolveOutputHeader,
-  toLegalLandDetails
+  toLegalLandDetails,
+  treatyLayerIds,
+  unavailableTreatyContext
 };
 //# sourceMappingURL=index.js.map