@tileflow/interactions 0.0.0-bootstrap.0

package/dist/maplibre-entry.js

@@ -0,0 +1,2892 @@
+// src/maplibre.ts
+function createTileflowAnnotationRegistry(adapter) {
+  let currentEntries = [];
+  let currentEntriesByKey = /* @__PURE__ */ new Map();
+  const retiredEntries = /* @__PURE__ */ new Set();
+  let disposed = false;
+  let mutating = false;
+  const publicEntries = () => snapshotEntries(currentEntries);
+  const reconcile = (definitions) => {
+    assertRegistryCanMutate(disposed, mutating);
+    mutating = true;
+    try {
+      const requested = collectRequestedDefinitions(definitions, adapter.getKey);
+      const previousEntries = currentEntries;
+      const nextEntries = [];
+      const nextEntriesByKey = /* @__PURE__ */ new Map();
+      const createdEntries = [];
+      const completedUpdates = [];
+      let failureAlreadyRolledBack = false;
+      try {
+        for (const { definition, key } of requested) {
+          const previous = currentEntriesByKey.get(key);
+          if (previous) {
+            const next2 = { definition, instance: previous.instance, key };
+            nextEntries.push(next2);
+            nextEntriesByKey.set(key, next2);
+            continue;
+          }
+          const instance = adapter.create(adapter.context, definition, key);
+          const next = { definition, instance, key };
+          createdEntries.push(next);
+          nextEntries.push(next);
+          nextEntriesByKey.set(key, next);
+        }
+        for (const entry of nextEntries) {
+          const previous = currentEntriesByKey.get(entry.key);
+          if (!previous || !shouldUpdateDefinition(adapter, previous.definition, entry.definition, entry.key)) {
+            continue;
+          }
+          const completed = {
+            entry: previous,
+            next: entry.definition
+          };
+          completedUpdates.push(completed);
+          completed.rollback = adapter.update(
+            previous.instance,
+            adapter.context,
+            entry.definition,
+            previous.definition,
+            entry.key
+          ) ?? void 0;
+        }
+        if (adapter.reorder && !haveSameKeyOrder(previousEntries, nextEntries)) {
+          const nextSnapshot = snapshotEntries(nextEntries);
+          const previousSnapshot = snapshotEntries(previousEntries);
+          try {
+            adapter.reorder(adapter.context, nextSnapshot, previousSnapshot);
+          } catch (error) {
+            const rollbackErrors = safelyRun(
+              () => adapter.reorder?.(adapter.context, previousSnapshot, nextSnapshot)
+            );
+            rollbackErrors.push(...rollbackCompletedUpdates(adapter, completedUpdates));
+            rollbackErrors.push(...retireAndClean(adapter, retiredEntries, createdEntries));
+            failureAlreadyRolledBack = true;
+            throwRollbackFailure(error, rollbackErrors);
+          }
+        }
+      } catch (error) {
+        if (failureAlreadyRolledBack) throw error;
+        const rollbackErrors = rollbackCompletedUpdates(adapter, completedUpdates);
+        rollbackErrors.push(...retireAndClean(adapter, retiredEntries, createdEntries));
+        throwRollbackFailure(error, rollbackErrors);
+      }
+      currentEntries = nextEntries;
+      currentEntriesByKey = nextEntriesByKey;
+      for (const entry of previousEntries) {
+        if (!nextEntriesByKey.has(entry.key)) retiredEntries.add(entry);
+      }
+      throwCleanupFailures(cleanRetiredEntries(adapter, retiredEntries));
+    } finally {
+      mutating = false;
+    }
+  };
+  const dispose = () => {
+    if (mutating) {
+      throw new Error("Tileflow annotation registry mutation is already in progress.");
+    }
+    if (disposed && retiredEntries.size === 0) return;
+    mutating = true;
+    try {
+      if (!disposed) {
+        disposed = true;
+        for (const entry of currentEntries) retiredEntries.add(entry);
+        currentEntries = [];
+        currentEntriesByKey = /* @__PURE__ */ new Map();
+      }
+      throwCleanupFailures(cleanRetiredEntries(adapter, retiredEntries));
+    } finally {
+      mutating = false;
+    }
+  };
+  return {
+    get size() {
+      return currentEntries.length;
+    },
+    clear() {
+      if (disposed) return;
+      reconcile([]);
+    },
+    dispose,
+    entries: publicEntries,
+    get(key) {
+      const entry = currentEntriesByKey.get(key);
+      return entry ? freezeEntry(entry) : void 0;
+    },
+    reconcile
+  };
+}
+function collectRequestedDefinitions(definitions, getKey) {
+  const keys = /* @__PURE__ */ new Set();
+  const requested = [];
+  for (const definition of definitions) {
+    const key = getKey(definition);
+    if (keys.has(key)) {
+      throw new TypeError("Duplicate Tileflow annotation key.");
+    }
+    keys.add(key);
+    requested.push({ definition, key });
+  }
+  return requested;
+}
+function shouldUpdateDefinition(adapter, previous, next, key) {
+  return adapter.shouldUpdate?.(previous, next, key) ?? !Object.is(previous, next);
+}
+function rollbackCompletedUpdates(adapter, updates) {
+  const errors = [];
+  for (const update of [...updates].reverse()) {
+    errors.push(
+      ...safelyRun(() => {
+        if (update.rollback) {
+          update.rollback();
+          return;
+        }
+        adapter.update(
+          update.entry.instance,
+          adapter.context,
+          update.entry.definition,
+          update.next,
+          update.entry.key
+        );
+      })
+    );
+  }
+  return errors;
+}
+function retireAndClean(adapter, retiredEntries, entries) {
+  for (const entry of entries) retiredEntries.add(entry);
+  return cleanRetiredEntries(adapter, retiredEntries);
+}
+function cleanRetiredEntries(adapter, retiredEntries) {
+  const errors = [];
+  for (const entry of retiredEntries) {
+    try {
+      adapter.remove(entry.instance, adapter.context, entry.definition, entry.key);
+      retiredEntries.delete(entry);
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  return errors;
+}
+function haveSameKeyOrder(previous, next) {
+  return previous.length === next.length && previous.every((entry, index) => sameValueZero(entry.key, next[index]?.key));
+}
+function sameValueZero(left, right) {
+  return left === right || left !== left && right !== right;
+}
+function snapshotEntries(entries) {
+  return Object.freeze(entries.map(freezeEntry));
+}
+function freezeEntry(entry) {
+  return Object.freeze({
+    definition: entry.definition,
+    instance: entry.instance,
+    key: entry.key
+  });
+}
+function assertRegistryCanMutate(disposed, mutating) {
+  if (disposed) throw new Error("Tileflow annotation registry is disposed.");
+  if (mutating) throw new Error("Tileflow annotation registry mutation is already in progress.");
+}
+function throwRollbackFailure(error, rollbackErrors) {
+  if (rollbackErrors.length === 0) throw error;
+  throw new AggregateError(
+    [error, ...rollbackErrors],
+    "Tileflow annotation reconciliation failed and rollback reported additional errors.",
+    { cause: error }
+  );
+}
+function throwCleanupFailures(errors) {
+  if (errors.length === 0) return;
+  throw new AggregateError(errors, "Unable to remove one or more Tileflow annotation instances.");
+}
+function safelyRun(operation) {
+  try {
+    operation();
+    return [];
+  } catch (error) {
+    return [error];
+  }
+}
+function createTileflowOverlayStateController(options = {}) {
+  const areTargetsEqual = options.areTargetsEqual ?? Object.is;
+  const listeners = /* @__PURE__ */ new Set();
+  if (options.onChange) listeners.add(options.onChange);
+  const initialPopup = options.initialPopup === void 0 ? null : options.initialPopup;
+  let initialTooltip = options.initialTooltip === void 0 ? null : options.initialTooltip;
+  if (initialPopup !== null && initialTooltip !== null && areTargetsEqual(initialPopup, initialTooltip)) {
+    initialTooltip = null;
+  }
+  let state = overlayState(initialPopup, initialTooltip);
+  let disposed = false;
+  const commit = (popup, tooltip, reason) => {
+    if (disposed || sameTarget(state.popup, popup, areTargetsEqual) && sameTarget(state.tooltip, tooltip, areTargetsEqual)) {
+      return false;
+    }
+    const previous = state;
+    state = overlayState(popup, tooltip);
+    notifyOverlayListeners(listeners, state, previous, reason);
+    return true;
+  };
+  return {
+    clearTarget(target) {
+      const popup = targetMatches(state.popup, target, areTargetsEqual) ? null : state.popup;
+      const tooltip = targetMatches(state.tooltip, target, areTargetsEqual) ? null : state.tooltip;
+      return commit(popup, tooltip, "target:remove");
+    },
+    dispose() {
+      if (disposed) return;
+      const previous = state;
+      disposed = true;
+      state = overlayState(null, null);
+      try {
+        if (previous.popup !== null || previous.tooltip !== null) {
+          notifyOverlayListeners(listeners, state, previous, "dispose");
+        }
+      } finally {
+        listeners.clear();
+      }
+    },
+    getState() {
+      return state;
+    },
+    reconcileTargets(isAvailable) {
+      if (disposed) return false;
+      const popup = state.popup !== null && !isAvailable(state.popup) ? null : state.popup;
+      const tooltip = state.tooltip !== null && !isAvailable(state.tooltip) ? null : state.tooltip;
+      return commit(popup, tooltip, "targets:reconcile");
+    },
+    setPopup(target) {
+      const tooltip = target !== null && targetMatches(state.tooltip, target, areTargetsEqual) ? null : state.tooltip;
+      return commit(target, tooltip, target === null ? "popup:close" : "popup:open");
+    },
+    setTooltip(target) {
+      if (target !== null && targetMatches(state.popup, target, areTargetsEqual)) return false;
+      return commit(state.popup, target, target === null ? "tooltip:close" : "tooltip:open");
+    },
+    subscribe(listener) {
+      if (disposed) return () => {
+      };
+      listeners.add(listener);
+      let subscribed = true;
+      return () => {
+        if (!subscribed) return;
+        subscribed = false;
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+function overlayState(popup, tooltip) {
+  return Object.freeze({ popup, tooltip });
+}
+function targetMatches(current, target, areTargetsEqual) {
+  return current !== null && areTargetsEqual(current, target);
+}
+function sameTarget(left, right, areTargetsEqual) {
+  if (left === null || right === null) return left === right;
+  return areTargetsEqual(left, right);
+}
+function notifyOverlayListeners(listeners, state, previous, reason) {
+  const errors = [];
+  for (const listener of [...listeners]) {
+    try {
+      listener(state, previous, reason);
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  if (errors.length === 1) throw errors[0];
+  if (errors.length > 1) {
+    throw new AggregateError(errors, "Tileflow overlay state listeners failed.");
+  }
+}
+
+// src/maplibre-dom.ts
+function normalizeTileflowLegacyMarkers(markers) {
+  const titles = /* @__PURE__ */ new Map();
+  const annotations = markers.map((marker) => {
+    const title = marker.label ?? marker.id;
+    titles.set(marker.id, title);
+    return {
+      ariaLabel: title.trim().length > 0 ? title : marker.id,
+      coordinate: marker.coordinates,
+      id: marker.id,
+      kind: "marker",
+      ...marker.color === void 0 ? {} : { marker: { color: marker.color } }
+    };
+  });
+  return Object.freeze({ annotations: Object.freeze(annotations), titles });
+}
+var runtimeSequence = 0;
+function createTileflowMapLibreDomRuntime(options) {
+  const document = options.document;
+  const idPrefix = options.idPrefix ?? `tileflow-interactions-${++runtimeSequence}`;
+  assertIdPrefix(idPrefix);
+  const controlled = options.interactionState !== void 0;
+  let customRenderers = Object.freeze({
+    marker: options.customMarker ?? false,
+    popup: options.customPopup ?? false,
+    tooltip: options.customTooltip ?? false
+  });
+  let interactionState = options.interactionState ?? options.defaultInteractionState ?? createInteractionState(null);
+  let pendingStateRequest = null;
+  let missingControlledPopupNotified = null;
+  const eventListeners = /* @__PURE__ */ new Set();
+  const diagnosticListeners = /* @__PURE__ */ new Set();
+  const renderTargetListeners = /* @__PURE__ */ new Set();
+  const activeDiagnostics = /* @__PURE__ */ new Map();
+  let diagnosticSnapshot = Object.freeze([]);
+  let renderTargets = Object.freeze([]);
+  let activeTooltip = null;
+  let activePopup = null;
+  let reconciling = false;
+  let disposeStarted = false;
+  let disposeComplete = false;
+  let overlaySequence = 0;
+  const emit = (type, annotation, inputModality2) => {
+    const event = Object.freeze({
+      coordinate: annotation.coordinate,
+      ...inputModality2 === void 0 ? {} : { inputModality: inputModality2 },
+      target: Object.freeze({
+        annotation,
+        coordinate: annotation.coordinate,
+        kind: "annotation"
+      }),
+      type
+    });
+    notifyListeners(eventListeners, event, "Tileflow interaction event listeners failed.");
+  };
+  const publishRenderTargets = () => {
+    if (reconciling || disposeComplete) return;
+    renderTargets = buildRenderTargets();
+    notifyListeners(
+      renderTargetListeners,
+      renderTargets,
+      "Tileflow render target listeners failed."
+    );
+  };
+  const publishDiagnostics = () => {
+    if (reconciling || disposeComplete) return;
+    diagnosticSnapshot = Object.freeze([...activeDiagnostics.values()]);
+    notifyListeners(
+      diagnosticListeners,
+      diagnosticSnapshot,
+      "Tileflow diagnostic listeners failed."
+    );
+  };
+  const closeTooltipVisual = (annotationId) => {
+    const current = activeTooltip;
+    if (!current || annotationId !== void 0 && current.annotation.id !== annotationId) {
+      return false;
+    }
+    activeTooltip = null;
+    clearSurfaceDiagnostics(current.annotation.id, "tooltip");
+    const marker = registry.get(current.annotation.id)?.instance;
+    marker?.element.removeAttribute("aria-describedby");
+    const errors = safelyRunAll([() => current.overlay.remove(), () => current.shell.remove()]);
+    publishRenderTargets();
+    throwCollectedErrors(errors, "Unable to close the Tileflow tooltip.");
+    return true;
+  };
+  const closePopupVisual = (returnFocus, inputModality2, annotationId) => {
+    const current = activePopup;
+    if (!current || annotationId !== void 0 && current.annotation.id !== annotationId) {
+      return false;
+    }
+    activePopup = null;
+    clearSurfaceDiagnostics(current.annotation.id, "popup");
+    const marker = registry.get(current.annotation.id)?.instance;
+    if (current.keydownListener) {
+      current.shell.removeEventListener("keydown", current.keydownListener);
+    }
+    marker?.element.setAttribute("aria-expanded", "false");
+    marker?.element.removeAttribute("aria-controls");
+    const errors = safelyRunAll([() => current.overlay.remove(), () => current.shell.remove()]);
+    publishRenderTargets();
+    emit("popup:close", current.annotation, inputModality2);
+    if (returnFocus && marker && !marker.removed) {
+      errors.push(...safelyRunAll([() => marker.element.focus({ preventScroll: true })]));
+    }
+    throwCollectedErrors(errors, "Unable to close the Tileflow popup.");
+    return true;
+  };
+  const updateActiveOverlay = (current, annotation) => {
+    const previousAnnotation = current.annotation;
+    current.annotation = annotation;
+    current.overlay.setLngLat(copyCoordinate(annotation.coordinate));
+    options.updateOverlay?.(current.overlay, {
+      annotation,
+      container: current.shell,
+      kind: current.kind,
+      previousAnnotation
+    });
+    configureOverlayContent(current, annotation);
+  };
+  const openTooltipVisual = (annotationId) => {
+    const entry = registry.get(annotationId);
+    if (!entry?.definition.tooltip || activePopup?.annotation.id === annotationId) return false;
+    if (activeTooltip?.annotation.id === annotationId) {
+      if (!Object.is(activeTooltip.annotation, entry.definition)) {
+        try {
+          updateActiveOverlay(activeTooltip, entry.definition);
+          clearOverlayFailure(entry.definition.id, "tooltip");
+        } catch {
+          reportOverlayFailure(entry.definition, "tooltip");
+        }
+      }
+      return false;
+    }
+    closeTooltipVisual();
+    const shell = document.createElement("div");
+    const container = document.createElement("div");
+    shell.className = "tileflow-interaction-tooltip";
+    container.className = "tileflow-interaction-tooltip-content";
+    shell.id = domId(idPrefix, "tooltip", ++overlaySequence);
+    shell.setAttribute("data-tileflow-interaction", "tooltip");
+    shell.setAttribute("data-tileflow-target-kind", "annotation");
+    shell.setAttribute("role", "tooltip");
+    shell.style.pointerEvents = "none";
+    configureSurfaceStyles(shell);
+    shell.append(container);
+    let overlay;
+    try {
+      overlay = options.createOverlay({
+        annotation: entry.definition,
+        container: shell,
+        kind: "tooltip"
+      });
+      overlay.setLngLat(copyCoordinate(entry.definition.coordinate));
+      overlay.addTo(options.map);
+    } catch {
+      safelyRunAll([() => overlay?.remove(), () => shell.remove()]);
+      reportOverlayFailure(entry.definition, "tooltip");
+      return false;
+    }
+    activeTooltip = {
+      annotation: entry.definition,
+      container,
+      kind: "tooltip",
+      overlay,
+      shell
+    };
+    configureOverlayContent(activeTooltip, entry.definition);
+    clearOverlayFailure(entry.definition.id, "tooltip");
+    entry.instance.element.setAttribute("aria-describedby", shell.id);
+    publishRenderTargets();
+    return true;
+  };
+  const openPopupVisual = (annotationId, inputModality2) => {
+    const entry = registry.get(annotationId);
+    if (!entry?.definition.popup) return false;
+    if (activePopup?.annotation.id === annotationId) {
+      if (!Object.is(activePopup.annotation, entry.definition)) {
+        try {
+          updateActiveOverlay(activePopup, entry.definition);
+          clearOverlayFailure(entry.definition.id, "popup");
+        } catch {
+          reportOverlayFailure(entry.definition, "popup");
+        }
+      }
+      return false;
+    }
+    closePopupVisual(false, inputModality2);
+    closeTooltipVisual(annotationId);
+    const shell = document.createElement("div");
+    const container = document.createElement("div");
+    const closeButton = document.createElement("button");
+    shell.className = "tileflow-interaction-popup";
+    container.className = "tileflow-interaction-popup-content";
+    closeButton.className = "tileflow-interaction-popup-close";
+    closeButton.type = "button";
+    closeButton.textContent = "Close";
+    shell.id = domId(idPrefix, "popup", ++overlaySequence);
+    shell.setAttribute("data-tileflow-interaction", "popup");
+    shell.setAttribute("data-tileflow-target-kind", "annotation");
+    shell.setAttribute("aria-label", entry.definition.ariaLabel);
+    shell.setAttribute("aria-modal", "false");
+    shell.setAttribute("role", "dialog");
+    closeButton.setAttribute("aria-label", `Close ${entry.definition.ariaLabel}`);
+    configureSurfaceStyles(shell);
+    closeButton.style.background = "transparent";
+    closeButton.style.border = "0";
+    closeButton.style.color = "inherit";
+    closeButton.style.cursor = "pointer";
+    shell.append(container, closeButton);
+    const closeListener = () => requestPopupState(null, "pointer");
+    const keydownListener = (event) => {
+      if (event.key !== "Escape") return;
+      event.preventDefault();
+      event.stopPropagation();
+      requestPopupState(null, "keyboard");
+    };
+    closeButton.addEventListener("click", closeListener);
+    shell.addEventListener("keydown", keydownListener);
+    let overlay;
+    try {
+      overlay = options.createOverlay({
+        annotation: entry.definition,
+        container: shell,
+        kind: "popup"
+      });
+      overlay.setLngLat(copyCoordinate(entry.definition.coordinate));
+      overlay.addTo(options.map);
+    } catch {
+      closeButton.removeEventListener("click", closeListener);
+      shell.removeEventListener("keydown", keydownListener);
+      safelyRunAll([() => overlay?.remove(), () => shell.remove()]);
+      reportOverlayFailure(entry.definition, "popup");
+      return false;
+    }
+    activePopup = {
+      annotation: entry.definition,
+      closeButton,
+      container,
+      keydownListener,
+      kind: "popup",
+      overlay,
+      shell
+    };
+    configureOverlayContent(activePopup, entry.definition);
+    clearOverlayFailure(entry.definition.id, "popup");
+    entry.instance.element.setAttribute("aria-controls", shell.id);
+    entry.instance.element.setAttribute("aria-expanded", "true");
+    publishRenderTargets();
+    emit("popup:open", entry.definition, inputModality2);
+    closeButton.focus({ preventScroll: true });
+    return true;
+  };
+  const syncPopupFromInteractionState = (inputModality2, returnFocusWhenClosing) => {
+    const popupId = getAnnotationPopupId(interactionState);
+    if (popupId === null) {
+      closePopupVisual(returnFocusWhenClosing, inputModality2);
+      return;
+    }
+    const entry = registry.get(popupId);
+    if (!entry?.definition.popup) {
+      closePopupVisual(false, inputModality2);
+      return;
+    }
+    openPopupVisual(popupId, inputModality2);
+  };
+  const notifyStateRequest = (next, previous, reason) => {
+    options.onInteractionStateChange?.(next, previous, reason);
+  };
+  function requestPopupState(popupId, inputModality2) {
+    const currentPopupId = getAnnotationPopupId(interactionState);
+    if (popupId === null ? interactionState.popup === null && activePopup === null : currentPopupId === popupId && activePopup?.annotation.id === popupId) {
+      return false;
+    }
+    if (popupId !== null && !registry.get(popupId)?.definition.popup) return false;
+    const previous = interactionState;
+    const next = createInteractionState(
+      popupId === null ? null : Object.freeze({ id: popupId, kind: "annotation" })
+    );
+    missingControlledPopupNotified = null;
+    if (controlled) {
+      pendingStateRequest = { inputModality: inputModality2, popupId };
+      notifyStateRequest(next, previous, popupId === null ? "popup:close" : "popup:open");
+      return true;
+    }
+    interactionState = next;
+    syncPopupFromInteractionState(inputModality2, popupId === null);
+    notifyStateRequest(next, previous, popupId === null ? "popup:close" : "popup:open");
+    return true;
+  }
+  const reconcileOverlayAvailability = () => {
+    if (activeTooltip) {
+      const tooltipEntry = registry.get(activeTooltip.annotation.id);
+      if (!tooltipEntry?.definition.tooltip) closeTooltipVisual();
+      else if (!Object.is(activeTooltip.annotation, tooltipEntry.definition)) {
+        updateActiveOverlay(activeTooltip, tooltipEntry.definition);
+      }
+    }
+    const popupId = getAnnotationPopupId(interactionState);
+    if (popupId === null) {
+      closePopupVisual(false, "programmatic");
+      missingControlledPopupNotified = null;
+      return;
+    }
+    const popupEntry = registry.get(popupId);
+    if (popupEntry?.definition.popup) {
+      missingControlledPopupNotified = null;
+      syncPopupFromInteractionState("programmatic", false);
+      return;
+    }
+    closePopupVisual(false, "programmatic");
+    if (controlled) {
+      if (missingControlledPopupNotified === popupId) return;
+      missingControlledPopupNotified = popupId;
+      notifyStateRequest(createInteractionState(null), interactionState, "target:remove");
+      return;
+    }
+    const previous = interactionState;
+    interactionState = createInteractionState(null);
+    notifyStateRequest(interactionState, previous, "target:remove");
+  };
+  const closeAnnotationOverlays = (annotationId, inputModality2) => {
+    closeTooltipVisual(annotationId);
+    if (getAnnotationPopupId(interactionState) === annotationId) {
+      requestPopupState(null, inputModality2);
+      return;
+    }
+    closePopupVisual(true, inputModality2, annotationId);
+  };
+  const clearContentDiagnostic = (annotationId, surface, code) => {
+    if (!activeDiagnostics.delete(diagnosticKey(annotationId, surface, code))) return;
+    publishDiagnostics();
+  };
+  const reportContentDiagnostic = (annotation, surface, code) => {
+    const key = diagnosticKey(annotation.id, surface, code);
+    if (activeDiagnostics.has(key)) return;
+    const diagnostic2 = Object.freeze({
+      code,
+      level: "error",
+      message: code === "INVALID_FIELD" ? "Annotation field content did not resolve to a scalar value." : "Annotation view content has no custom renderer for its active surface.",
+      target: Object.freeze({ id: annotation.id, kind: "annotation" })
+    });
+    activeDiagnostics.set(key, diagnostic2);
+    options.onDiagnostic?.(diagnostic2);
+    publishDiagnostics();
+  };
+  const clearOverlayFailure = (annotationId, surface) => {
+    if (!activeDiagnostics.delete(overlayDiagnosticKey(annotationId, surface))) return;
+    publishDiagnostics();
+  };
+  const reportOverlayFailure = (annotation, surface) => {
+    const key = overlayDiagnosticKey(annotation.id, surface);
+    if (activeDiagnostics.has(key)) return;
+    const diagnostic2 = Object.freeze({
+      code: "OVERLAY_FAILURE",
+      level: "error",
+      message: `Tileflow could not mount or update the annotation ${surface} overlay.`,
+      target: Object.freeze({ id: annotation.id, kind: "annotation" })
+    });
+    activeDiagnostics.set(key, diagnostic2);
+    options.onDiagnostic?.(diagnostic2);
+    publishDiagnostics();
+  };
+  const resolveAnnotationContent = (annotation, content, surface) => {
+    if (content.kind === "view") {
+      clearContentDiagnostic(annotation.id, surface, "INVALID_FIELD");
+      if (customRenderers[surface]) {
+        clearContentDiagnostic(annotation.id, surface, "MISSING_VIEW");
+      } else {
+        reportContentDiagnostic(annotation, surface, "MISSING_VIEW");
+      }
+      return "";
+    }
+    clearContentDiagnostic(annotation.id, surface, "MISSING_VIEW");
+    const resolution = resolveContent(content, annotation.data);
+    if (resolution.invalidField) {
+      reportContentDiagnostic(annotation, surface, "INVALID_FIELD");
+    } else {
+      clearContentDiagnostic(annotation.id, surface, "INVALID_FIELD");
+    }
+    return resolution.text;
+  };
+  const clearAnnotationDiagnostics = (annotationId) => {
+    const prefix = `${annotationId}\0`;
+    let changed = false;
+    for (const key of activeDiagnostics.keys()) {
+      if (!key.startsWith(prefix)) continue;
+      activeDiagnostics.delete(key);
+      changed = true;
+    }
+    if (changed) publishDiagnostics();
+  };
+  function clearSurfaceDiagnostics(annotationId, surface) {
+    const removedInvalidField = activeDiagnostics.delete(
+      diagnosticKey(annotationId, surface, "INVALID_FIELD")
+    );
+    const removedMissingView = activeDiagnostics.delete(
+      diagnosticKey(annotationId, surface, "MISSING_VIEW")
+    );
+    if (removedInvalidField || removedMissingView) publishDiagnostics();
+  }
+  const configureAnnotationElement = (instance, annotation) => {
+    instance.annotation = annotation;
+    instance.element.setAttribute("aria-label", annotation.ariaLabel);
+    instance.element.setAttribute("data-tileflow-interaction", "marker");
+    instance.element.setAttribute("data-tileflow-target-kind", "annotation");
+    instance.element.title = annotation.ariaLabel;
+    instance.element.style.cursor = annotation.popup ? "pointer" : "default";
+    if (annotation.popup) {
+      instance.element.setAttribute("aria-haspopup", "dialog");
+      instance.element.setAttribute("role", "button");
+      instance.element.tabIndex = 0;
+      if (activePopup?.annotation.id !== annotation.id) {
+        instance.element.setAttribute("aria-expanded", "false");
+      }
+    } else {
+      instance.element.removeAttribute("aria-controls");
+      instance.element.removeAttribute("aria-expanded");
+      instance.element.removeAttribute("aria-haspopup");
+      instance.element.setAttribute("role", "img");
+      instance.element.tabIndex = annotation.tooltip ? 0 : -1;
+    }
+    if (annotation.marker?.color) {
+      instance.element.style.setProperty(
+        "--tileflow-interaction-marker-color",
+        annotation.marker.color
+      );
+    } else {
+      instance.element.style.removeProperty("--tileflow-interaction-marker-color");
+    }
+    const markerText = annotation.marker?.content ? resolveAnnotationContent(annotation, annotation.marker.content, "marker") : "\u2022";
+    if (!annotation.marker?.content) {
+      clearContentDiagnostic(annotation.id, "marker", "INVALID_FIELD");
+      clearContentDiagnostic(annotation.id, "marker", "MISSING_VIEW");
+    }
+    if (!customRenderers.marker) {
+      instance.container.textContent = markerText;
+      configureDefaultMarkerStyles(instance.container);
+    } else {
+      clearDefaultMarkerStyles(instance.container);
+    }
+    configureViewAttribute(instance.container, annotation.marker?.content);
+  };
+  const applyAnnotation = (instance, annotation, previousAnnotation) => {
+    configureAnnotationElement(instance, annotation);
+    instance.marker.setLngLat(copyCoordinate(annotation.coordinate));
+    options.updateMarker?.(instance.marker, {
+      annotation,
+      element: instance.element,
+      previousAnnotation
+    });
+    if (activeTooltip?.annotation.id === annotation.id && annotation.tooltip) {
+      try {
+        updateActiveOverlay(activeTooltip, annotation);
+        clearOverlayFailure(annotation.id, "tooltip");
+      } catch (error) {
+        reportOverlayFailure(annotation, "tooltip");
+        throw error;
+      }
+    }
+    if (activePopup?.annotation.id === annotation.id && annotation.popup) {
+      try {
+        updateActiveOverlay(activePopup, annotation);
+        clearOverlayFailure(annotation.id, "popup");
+      } catch (error) {
+        reportOverlayFailure(annotation, "popup");
+        throw error;
+      }
+    }
+  };
+  const createAnnotationInstance = (annotation) => {
+    const element = document.createElement("div");
+    const container = document.createElement("div");
+    element.className = "tileflow-interaction-marker";
+    container.className = "tileflow-interaction-marker-content";
+    element.append(container);
+    configureAnnotationElement({ annotation, container, element }, annotation);
+    const marker = options.createMarker({ annotation, element });
+    const instance = {
+      annotation,
+      container,
+      element,
+      focused: false,
+      hovered: false,
+      marker,
+      removed: false,
+      removeListeners: []
+    };
+    const removeListeners = [];
+    const listen = (type, listener) => {
+      element.addEventListener(type, listener);
+      removeListeners.push(() => element.removeEventListener(type, listener));
+    };
+    listen("pointerenter", () => {
+      instance.hovered = true;
+      emit("target:enter", instance.annotation, "pointer");
+      openTooltipVisual(instance.annotation.id);
+    });
+    listen("pointerleave", () => {
+      instance.hovered = false;
+      emit("target:leave", instance.annotation, "pointer");
+      if (!instance.focused) closeTooltipVisual(instance.annotation.id);
+    });
+    listen("focus", () => {
+      instance.focused = true;
+      emit("target:focus", instance.annotation, "keyboard");
+      openTooltipVisual(instance.annotation.id);
+    });
+    listen("blur", () => {
+      instance.focused = false;
+      emit("target:blur", instance.annotation, "keyboard");
+      if (!instance.hovered) closeTooltipVisual(instance.annotation.id);
+    });
+    listen("click", () => {
+      if (!instance.annotation.popup) return;
+      emit("target:activate", instance.annotation, "pointer");
+      requestPopupState(instance.annotation.id, "pointer");
+    });
+    listen("keydown", (event) => {
+      if (event.key === "Escape") {
+        const didCloseTooltip = closeTooltipVisual(instance.annotation.id);
+        const didRequestPopupClose = activePopup?.annotation.id === instance.annotation.id ? requestPopupState(null, "keyboard") : false;
+        if (didCloseTooltip || didRequestPopupClose) {
+          event.preventDefault();
+          event.stopPropagation();
+        }
+        return;
+      }
+      if (!instance.annotation.popup || event.key !== "Enter" && event.key !== " " && event.code !== "Space") {
+        return;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      emit("target:activate", instance.annotation, "keyboard");
+      requestPopupState(instance.annotation.id, "keyboard");
+    });
+    instance.removeListeners = removeListeners;
+    try {
+      marker.setLngLat(copyCoordinate(annotation.coordinate));
+      marker.addTo(options.map);
+    } catch (error) {
+      for (const removeListener of removeListeners) removeListener();
+      safelyRunAll([() => marker.remove(), () => element.remove()]);
+      throw error;
+    }
+    return instance;
+  };
+  const removeAnnotationInstance = (instance) => {
+    if (instance.removed) return;
+    closeTooltipVisual(instance.annotation.id);
+    closePopupVisual(false, "programmatic", instance.annotation.id);
+    const errors = safelyRunAll([
+      ...instance.removeListeners,
+      () => instance.marker.remove(),
+      () => instance.element.remove()
+    ]);
+    if (errors.length === 0) instance.removed = true;
+    clearAnnotationDiagnostics(instance.annotation.id);
+    throwCollectedErrors(
+      errors,
+      `Unable to remove Tileflow annotation "${instance.annotation.id}".`
+    );
+  };
+  const registry = createTileflowAnnotationRegistry({
+    context: void 0,
+    create: (_context, annotation) => createAnnotationInstance(annotation),
+    getKey: (annotation) => annotation.id,
+    remove: (instance) => removeAnnotationInstance(instance),
+    reorder: options.reorderMarkers ? (_context, entries, previousEntries) => {
+      options.reorderMarkers?.(
+        entries.map((entry) => entry.instance.marker),
+        entries.map((entry) => entry.definition),
+        previousEntries.map((entry) => entry.instance.marker),
+        previousEntries.map((entry) => entry.definition)
+      );
+    } : void 0,
+    update: (instance, _context, annotation, previousAnnotation) => {
+      applyAnnotation(instance, annotation, previousAnnotation);
+      return () => applyAnnotation(instance, previousAnnotation, annotation);
+    }
+  });
+  function configureOverlayContent(overlay, annotation) {
+    if (overlay.kind === "tooltip") {
+      configureViewAttribute(overlay.container, annotation.tooltip?.content);
+      if (annotation.tooltip) {
+        const text = resolveAnnotationContent(annotation, annotation.tooltip.content, "tooltip");
+        if (!customRenderers.tooltip) overlay.container.textContent = text;
+      }
+      return;
+    }
+    overlay.shell.setAttribute("aria-label", annotation.ariaLabel);
+    overlay.closeButton?.setAttribute("aria-label", `Close ${annotation.ariaLabel}`);
+    configureViewAttribute(overlay.container, annotation.popup?.content);
+    if (annotation.popup) {
+      const text = resolveAnnotationContent(annotation, annotation.popup.content, "popup");
+      if (!customRenderers.popup) overlay.container.textContent = text;
+    }
+  }
+  function buildRenderTargets() {
+    const targets = [];
+    if (customRenderers.marker) {
+      for (const entry of registry.entries()) {
+        const annotationId = entry.definition.id;
+        targets.push(
+          Object.freeze({
+            annotation: entry.definition,
+            close: () => closeAnnotationOverlays(annotationId, "programmatic"),
+            container: entry.instance.container,
+            key: renderTargetKey("marker", annotationId),
+            kind: "marker"
+          })
+        );
+      }
+    }
+    if (customRenderers.tooltip && activeTooltip) {
+      const annotationId = activeTooltip.annotation.id;
+      targets.push(
+        Object.freeze({
+          annotation: activeTooltip.annotation,
+          close: () => closeTooltipVisual(annotationId),
+          container: activeTooltip.container,
+          key: renderTargetKey("tooltip", annotationId),
+          kind: "tooltip"
+        })
+      );
+    }
+    if (customRenderers.popup && activePopup) {
+      const annotationId = activePopup.annotation.id;
+      targets.push(
+        Object.freeze({
+          annotation: activePopup.annotation,
+          close: () => requestPopupState(null, "programmatic"),
+          container: activePopup.container,
+          key: renderTargetKey("popup", annotationId),
+          kind: "popup"
+        })
+      );
+    }
+    return Object.freeze(targets);
+  }
+  return {
+    closePopup() {
+      assertRuntimeActive(disposeStarted);
+      return requestPopupState(null, "programmatic");
+    },
+    dispose() {
+      if (disposeComplete) return;
+      if (!disposeStarted) {
+        disposeStarted = true;
+        reconciling = true;
+        const errors = safelyRunAll([
+          () => closeTooltipVisual(),
+          () => closePopupVisual(false, "programmatic")
+        ]);
+        reconciling = false;
+        renderTargets = Object.freeze([]);
+        activeDiagnostics.clear();
+        diagnosticSnapshot = Object.freeze([]);
+        notifyListeners(
+          diagnosticListeners,
+          diagnosticSnapshot,
+          "Tileflow diagnostic listeners failed.",
+          errors
+        );
+        notifyListeners(
+          renderTargetListeners,
+          renderTargets,
+          "Tileflow render target listeners failed.",
+          errors
+        );
+        renderTargetListeners.clear();
+        diagnosticListeners.clear();
+        eventListeners.clear();
+        throwCollectedErrors(errors, "Unable to begin Tileflow interaction runtime disposal.");
+      }
+      registry.dispose();
+      disposeComplete = true;
+    },
+    getInteractionState() {
+      return interactionState;
+    },
+    getDiagnostics() {
+      return diagnosticSnapshot;
+    },
+    getRenderTargets() {
+      return renderTargets;
+    },
+    openPopup(annotationId) {
+      assertRuntimeActive(disposeStarted);
+      return requestPopupState(annotationId, "programmatic");
+    },
+    reconcile(annotations) {
+      assertRuntimeActive(disposeStarted);
+      reconciling = true;
+      try {
+        registry.reconcile(annotations);
+      } finally {
+        reconciling = false;
+        reconcileOverlayAvailability();
+        publishDiagnostics();
+        publishRenderTargets();
+      }
+    },
+    setCustomRenderers(renderers) {
+      assertRuntimeActive(disposeStarted);
+      if (renderers.marker === customRenderers.marker && renderers.tooltip === customRenderers.tooltip && renderers.popup === customRenderers.popup) {
+        return;
+      }
+      reconciling = true;
+      try {
+        const previous = customRenderers;
+        customRenderers = Object.freeze({ ...renderers });
+        if (!previous.marker && customRenderers.marker) {
+          for (const entry of registry.entries()) entry.instance.container.textContent = "";
+        }
+        if (!previous.tooltip && customRenderers.tooltip && activeTooltip) {
+          activeTooltip.container.textContent = "";
+        }
+        if (!previous.popup && customRenderers.popup && activePopup) {
+          activePopup.container.textContent = "";
+        }
+        for (const entry of registry.entries()) {
+          configureAnnotationElement(entry.instance, entry.definition);
+        }
+        if (activeTooltip) configureOverlayContent(activeTooltip, activeTooltip.annotation);
+        if (activePopup) configureOverlayContent(activePopup, activePopup.annotation);
+      } finally {
+        reconciling = false;
+        publishDiagnostics();
+        publishRenderTargets();
+      }
+    },
+    setInteractionState(state) {
+      assertRuntimeActive(disposeStarted);
+      const popupId = getAnnotationPopupId(state);
+      const inputModality2 = pendingStateRequest?.popupId === popupId ? pendingStateRequest.inputModality : "programmatic";
+      pendingStateRequest = null;
+      interactionState = state;
+      missingControlledPopupNotified = null;
+      syncPopupFromInteractionState(inputModality2, popupId === null);
+    },
+    subscribeEvents(listener) {
+      assertRuntimeActive(disposeStarted);
+      eventListeners.add(listener);
+      return createUnsubscribe(eventListeners, listener);
+    },
+    subscribeDiagnostics(listener) {
+      assertRuntimeActive(disposeStarted);
+      diagnosticListeners.add(listener);
+      return createUnsubscribe(diagnosticListeners, listener);
+    },
+    subscribeRenderTargets(listener) {
+      assertRuntimeActive(disposeStarted);
+      renderTargetListeners.add(listener);
+      return createUnsubscribe(renderTargetListeners, listener);
+    }
+  };
+}
+function createInteractionState(popup) {
+  return Object.freeze({ popup });
+}
+function getAnnotationPopupId(state) {
+  return state.popup?.kind === "annotation" ? state.popup.id : null;
+}
+function copyCoordinate(coordinate) {
+  return [coordinate[0], coordinate[1]];
+}
+function renderTargetKey(kind, annotationId) {
+  return `${kind}:${annotationId}`;
+}
+function domId(prefix, kind, sequence) {
+  return `${prefix}-${kind}-${sequence}`;
+}
+function assertIdPrefix(idPrefix) {
+  if (!/^[A-Za-z][A-Za-z0-9_-]{0,127}$/u.test(idPrefix)) {
+    throw new TypeError("Tileflow DOM idPrefix must be a portable identifier.");
+  }
+}
+function assertRuntimeActive(disposed) {
+  if (disposed) throw new Error("Tileflow MapLibre DOM runtime is disposed.");
+}
+function configureViewAttribute(element, content) {
+  if (content?.kind === "view") {
+    element.setAttribute("data-tileflow-view", content.name);
+  } else {
+    element.removeAttribute("data-tileflow-view");
+  }
+}
+function configureSurfaceStyles(element) {
+  element.style.background = "var(--tileflow-interaction-surface, #ffffff)";
+  element.style.borderColor = "var(--tileflow-interaction-border-color, #d1d5db)";
+  element.style.borderRadius = "var(--tileflow-interaction-border-radius, 0.375rem)";
+  element.style.borderStyle = "solid";
+  element.style.borderWidth = "1px";
+  element.style.boxShadow = "var(--tileflow-interaction-shadow, 0 2px 8px rgb(0 0 0 / 0.18))";
+  element.style.color = "var(--tileflow-interaction-foreground, #111827)";
+  element.style.maxWidth = "var(--tileflow-interaction-max-width, 20rem)";
+  element.style.padding = "0.5rem";
+}
+function configureDefaultMarkerStyles(element) {
+  element.style.alignItems = "center";
+  element.style.background = "var(--tileflow-interaction-marker-color, #2563eb)";
+  element.style.borderColor = "var(--tileflow-interaction-border-color, #ffffff)";
+  element.style.borderRadius = "var(--tileflow-interaction-border-radius, 9999px)";
+  element.style.borderStyle = "solid";
+  element.style.borderWidth = "1px";
+  element.style.boxShadow = "var(--tileflow-interaction-shadow, 0 1px 4px rgb(0 0 0 / 0.25))";
+  element.style.color = "var(--tileflow-interaction-foreground, #ffffff)";
+  element.style.display = "inline-flex";
+  element.style.justifyContent = "center";
+  element.style.minHeight = "1.5rem";
+  element.style.minWidth = "1.5rem";
+  element.style.padding = "0.25rem";
+}
+function clearDefaultMarkerStyles(element) {
+  element.style.alignItems = "";
+  element.style.background = "";
+  element.style.borderColor = "";
+  element.style.borderRadius = "";
+  element.style.borderStyle = "";
+  element.style.borderWidth = "";
+  element.style.boxShadow = "";
+  element.style.color = "";
+  element.style.display = "";
+  element.style.justifyContent = "";
+  element.style.minHeight = "";
+  element.style.minWidth = "";
+  element.style.padding = "";
+}
+function resolveContent(content, data) {
+  if (content.kind === "text") return { invalidField: false, text: content.text };
+  if (content.kind === "view") return { invalidField: false, text: "" };
+  const fallback = content.fallback ?? "";
+  const invalid = () => ({ invalidField: content.fallback === void 0, text: fallback });
+  let current = data;
+  try {
+    for (const segment of content.field.split(".")) {
+      if (current === null || typeof current !== "object" || isUnsafeFieldSegment(segment) || !Object.prototype.hasOwnProperty.call(current, segment)) {
+        return invalid();
+      }
+      current = current[segment];
+    }
+  } catch {
+    return invalid();
+  }
+  return current === null || typeof current === "boolean" || typeof current === "number" || typeof current === "string" ? { invalidField: false, text: String(current) } : invalid();
+}
+function diagnosticKey(annotationId, surface, code) {
+  return `${annotationId}\0${surface}\0${code}`;
+}
+function overlayDiagnosticKey(annotationId, surface) {
+  return `${annotationId}\0${surface}\0OVERLAY_FAILURE`;
+}
+function isUnsafeFieldSegment(segment) {
+  return segment === "__proto__" || segment === "constructor" || segment === "prototype";
+}
+function createUnsubscribe(values, value) {
+  let subscribed = true;
+  return () => {
+    if (!subscribed) return;
+    subscribed = false;
+    values.delete(value);
+  };
+}
+function notifyListeners(listeners, value, message, errors = []) {
+  for (const listener of [...listeners]) {
+    try {
+      listener(value);
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  throwCollectedErrors(errors, message);
+}
+function safelyRunAll(operations) {
+  const errors = [];
+  for (const operation of operations) {
+    try {
+      operation();
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  return errors;
+}
+function throwCollectedErrors(errors, message) {
+  if (errors.length === 0) return;
+  if (errors.length === 1) throw errors[0];
+  throw new AggregateError(errors, message);
+}
+
+// src/reducer.ts
+var initialTileflowInteractionState = Object.freeze({
+  popup: null
+});
+function tileflowInteractionTargetRefsEqual(left, right) {
+  if (left === right) return true;
+  if (left === null || right === null || left.kind !== right.kind) return false;
+  switch (left.kind) {
+    case "annotation":
+      return left.id === right.id;
+    case "semantic-feature": {
+      const candidate = right;
+      return left.domain === candidate.domain && left.featureId === candidate.featureId;
+    }
+    case "style-feature": {
+      const candidate = right;
+      return left.layerId === candidate.layerId && left.featureId === candidate.featureId;
+    }
+    case "map": {
+      const candidate = right;
+      return left.coordinate[0] === candidate.coordinate[0] && left.coordinate[1] === candidate.coordinate[1];
+    }
+  }
+}
+
+// src/maplibre-coordinator.ts
+function createTileflowMapLibreInteractionCoordinator(options = {}) {
+  const controlled = options.interactionState !== void 0;
+  let state = options.interactionState ?? options.defaultInteractionState ?? Object.freeze({ popup: null });
+  let disposed = false;
+  let committing = false;
+  const participants = /* @__PURE__ */ new Map();
+  const commit = (next) => {
+    if (committing) throw new Error("Tileflow interaction state commit is reentrant.");
+    const previous = state;
+    const attempted = [];
+    committing = true;
+    try {
+      for (const kind of participantCommitOrder(next)) {
+        const participant = participants.get(kind);
+        if (!participant) continue;
+        attempted.push(participant);
+        participant.setInteractionState(next);
+      }
+      state = next;
+    } catch (error) {
+      const rollbackErrors = [];
+      for (const participant of attempted.reverse()) {
+        try {
+          participant.setInteractionState(previous);
+        } catch (rollbackError) {
+          rollbackErrors.push(rollbackError);
+        }
+      }
+      if (rollbackErrors.length > 0) {
+        throw new AggregateError(
+          [error, ...rollbackErrors],
+          "Tileflow interaction state commit and rollback failed."
+        );
+      }
+      throw error;
+    } finally {
+      committing = false;
+    }
+  };
+  return {
+    attach(kind, participant) {
+      assertActive(disposed);
+      if (participants.has(kind)) {
+        throw new Error(`Tileflow interaction participant "${kind}" is already attached.`);
+      }
+      participants.set(kind, participant);
+      try {
+        participant.setInteractionState(state);
+      } catch (error) {
+        participants.delete(kind);
+        throw error;
+      }
+      let attached = true;
+      return () => {
+        if (!attached) return;
+        attached = false;
+        if (participants.get(kind) === participant) participants.delete(kind);
+      };
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      participants.clear();
+    },
+    getInteractionState: () => state,
+    requestInteractionState(next, _participantPrevious, reason) {
+      assertActive(disposed);
+      if (interactionStatesEqual(state, next)) return;
+      const previous = state;
+      if (!controlled) commit(next);
+      options.onInteractionStateChange?.(next, previous, reason);
+    },
+    setInteractionState(next) {
+      assertActive(disposed);
+      if (interactionStatesEqual(state, next)) return;
+      commit(next);
+    }
+  };
+}
+function participantCommitOrder(state) {
+  return state.popup?.kind === "annotation" ? ["semantic", "annotation"] : ["annotation", "semantic"];
+}
+function interactionStatesEqual(left, right) {
+  return tileflowInteractionTargetRefsEqual(left.popup, right.popup);
+}
+function assertActive(disposed) {
+  if (disposed) throw new Error("Tileflow interaction coordinator is disposed.");
+}
+
+// src/contracts.ts
+import { z } from "zod/mini";
+var tileflowPoiCategories = [
+  "arts-entertainment",
+  "education",
+  "food-drink",
+  "landmark",
+  "lodging",
+  "medical",
+  "park-nature",
+  "public-services",
+  "religion",
+  "retail",
+  "sport-leisure",
+  "transport",
+  "visitor-amenity"
+];
+var tileflowInteractionLimits = {
+  maxAnnotations: 1e3,
+  maxAriaLabelLength: 256,
+  maxBindings: 100,
+  maxCategories: 32,
+  maxColorLength: 64,
+  maxContentTextLength: 4096,
+  maxDocumentBytes: 256e3,
+  maxDocumentDepth: 64,
+  maxDocumentNodes: 2e4,
+  maxDocumentProperties: 5e4,
+  maxFeatureIdLength: 128,
+  maxFieldSelectorLength: 128,
+  maxIdLength: 64,
+  maxTargetNameLength: 128,
+  maxViewNameLength: 64
+};
+function auditTileflowInteractionJsonDocument(input) {
+  try {
+    const stack = [{ depth: 0, value: input }];
+    const seen = /* @__PURE__ */ new WeakSet();
+    if (isObject(input)) seen.add(input);
+    let bytes = 0;
+    let nodes = 1;
+    let properties = 0;
+    const consumeBytes = (addition) => {
+      if (!Number.isSafeInteger(addition) || addition < 0 || addition > tileflowInteractionLimits.maxDocumentBytes - bytes) {
+        return false;
+      }
+      bytes += addition;
+      return true;
+    };
+    const enqueue = (value, depth) => {
+      if (depth > tileflowInteractionLimits.maxDocumentDepth) return "depth";
+      if (isObject(value)) {
+        if (seen.has(value)) return "invalid";
+        seen.add(value);
+      }
+      stack.push({ depth, value });
+      return void 0;
+    };
+    while (stack.length > 0) {
+      const entry = stack.pop();
+      if (!entry) return { ok: false, reason: "invalid" };
+      const { depth, value } = entry;
+      if (value === null) {
+        if (!consumeBytes(4)) return { ok: false, reason: "bytes" };
+        continue;
+      }
+      if (typeof value === "boolean") {
+        if (!consumeBytes(value ? 4 : 5)) return { ok: false, reason: "bytes" };
+        continue;
+      }
+      if (typeof value === "number") {
+        if (!Number.isFinite(value)) return { ok: false, reason: "invalid" };
+        const length = value === 0 ? 1 : String(value).length;
+        if (!consumeBytes(length)) return { ok: false, reason: "bytes" };
+        continue;
+      }
+      if (typeof value === "string") {
+        const length = jsonStringByteLength(
+          value,
+          tileflowInteractionLimits.maxDocumentBytes - bytes
+        );
+        if (length === void 0) return { ok: false, reason: "bytes" };
+        bytes += length;
+        continue;
+      }
+      if (!isObject(value)) return { ok: false, reason: "invalid" };
+      const array = Array.isArray(value);
+      const prototype = Object.getPrototypeOf(value);
+      if (array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null) {
+        return { ok: false, reason: "invalid" };
+      }
+      if (array) {
+        const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+        if (!lengthDescriptor || !("value" in lengthDescriptor) || typeof lengthDescriptor.value !== "number" || !Number.isSafeInteger(lengthDescriptor.value) || lengthDescriptor.value < 0) {
+          return { ok: false, reason: "invalid" };
+        }
+        const length = lengthDescriptor.value;
+        if (length > tileflowInteractionLimits.maxDocumentProperties - properties) {
+          return { ok: false, reason: "properties" };
+        }
+        properties += length;
+        if (length > 0 && depth >= tileflowInteractionLimits.maxDocumentDepth) {
+          return { ok: false, reason: "depth" };
+        }
+        const syntaxBytes = length === 0 ? 2 : length + 1;
+        if (!consumeBytes(syntaxBytes)) return { ok: false, reason: "bytes" };
+        const keys2 = Reflect.ownKeys(value);
+        const children2 = [];
+        let sawLength = false;
+        for (const key of keys2) {
+          if (typeof key !== "string") return { ok: false, reason: "invalid" };
+          if (key === "length") {
+            sawLength = true;
+            continue;
+          }
+          if (!isCanonicalArrayIndex(key, length)) return { ok: false, reason: "invalid" };
+          const descriptor = Object.getOwnPropertyDescriptor(value, key);
+          if (!isEnumerableDataDescriptor(descriptor)) return { ok: false, reason: "invalid" };
+          children2.push(descriptor.value);
+        }
+        if (!sawLength || children2.length > length) return { ok: false, reason: "invalid" };
+        if (children2.length > tileflowInteractionLimits.maxDocumentNodes - nodes) {
+          return { ok: false, reason: "nodes" };
+        }
+        nodes += children2.length;
+        const holes = length - children2.length;
+        if (!consumeBytes(holes * 4)) return { ok: false, reason: "bytes" };
+        for (const child of children2) {
+          const failure = enqueue(child, depth + 1);
+          if (failure) return { ok: false, reason: failure };
+        }
+        continue;
+      }
+      const keys = Reflect.ownKeys(value);
+      if (keys.length > tileflowInteractionLimits.maxDocumentProperties - properties) {
+        return { ok: false, reason: "properties" };
+      }
+      if (keys.length > tileflowInteractionLimits.maxDocumentNodes - nodes) {
+        return { ok: false, reason: "nodes" };
+      }
+      if (keys.length > 0 && depth >= tileflowInteractionLimits.maxDocumentDepth) {
+        return { ok: false, reason: "depth" };
+      }
+      properties += keys.length;
+      nodes += keys.length;
+      if (!consumeBytes(keys.length === 0 ? 2 : keys.length * 2 + 1)) {
+        return { ok: false, reason: "bytes" };
+      }
+      const children = [];
+      for (const key of keys) {
+        if (typeof key !== "string" || key === "__proto__" || key === "constructor" || key === "prototype") {
+          return { ok: false, reason: "invalid" };
+        }
+        const keyBytes = jsonStringByteLength(
+          key,
+          tileflowInteractionLimits.maxDocumentBytes - bytes
+        );
+        if (keyBytes === void 0) return { ok: false, reason: "bytes" };
+        bytes += keyBytes;
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!isEnumerableDataDescriptor(descriptor)) return { ok: false, reason: "invalid" };
+        children.push(descriptor.value);
+      }
+      for (const child of children) {
+        const failure = enqueue(child, depth + 1);
+        if (failure) return { ok: false, reason: failure };
+      }
+    }
+    return { bytes, ok: true };
+  } catch {
+    return { ok: false, reason: "invalid" };
+  }
+}
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function isEnumerableDataDescriptor(descriptor) {
+  return Boolean(descriptor?.enumerable && "value" in descriptor);
+}
+function isCanonicalArrayIndex(key, length) {
+  if (!/^(?:0|[1-9]\d*)$/u.test(key)) return false;
+  const index = Number(key);
+  return Number.isSafeInteger(index) && index >= 0 && index < length && String(index) === key;
+}
+function jsonStringByteLength(value, maximum) {
+  let bytes = 2;
+  if (bytes > maximum) return void 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    let addition;
+    if (code === 34 || code === 92) addition = 2;
+    else if (code <= 31) {
+      addition = code === 8 || code === 9 || code === 10 || code === 12 || code === 13 ? 2 : 6;
+    } else if (code <= 127) addition = 1;
+    else if (code <= 2047) addition = 2;
+    else if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (next >= 56320 && next <= 57343) {
+        addition = 4;
+        index += 1;
+      } else addition = 6;
+    } else if (code >= 56320 && code <= 57343) addition = 6;
+    else addition = 3;
+    if (addition > maximum - bytes) return void 0;
+    bytes += addition;
+  }
+  return bytes;
+}
+var portableIdPattern = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/u;
+var semanticDomainPattern = /^[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*$/u;
+var fieldSelectorPattern = /^[A-Za-z_][A-Za-z0-9_-]*(?:\.[A-Za-z_][A-Za-z0-9_-]*)*$/u;
+var unsafeFieldSegments = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var safeCssColorPattern = /^(?:#(?:[\da-f]{3}|[\da-f]{4}|[\da-f]{6}|[\da-f]{8})|[a-z]+|(?:color|hsla?|hwb|lab|lch|oklab|oklch|rgba?)\([A-Za-z0-9.,%+\- /]+\))$/iu;
+var portableIdSchema = z.string().check(
+  z.minLength(1),
+  z.maxLength(tileflowInteractionLimits.maxIdLength),
+  z.regex(portableIdPattern, "Expected a portable identifier")
+);
+var targetNameSchema = z.string().check(
+  z.trim(),
+  z.minLength(1),
+  z.maxLength(tileflowInteractionLimits.maxTargetNameLength),
+  z.refine((value) => !hasControlCharacters(value), {
+    message: "Target names may not contain control characters"
+  })
+);
+function hasControlCharacters(value) {
+  return [...value].some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code === 127;
+  });
+}
+var coordinateSchema = z.tuple([z.number(), z.number()]).check(
+  z.refine(([lng, lat]) => lng >= -180 && lng <= 180 && lat >= -90 && lat <= 90, {
+    message: "Expected [longitude, latitude] within world bounds"
+  })
+);
+var featureIdSchema = z.union([
+  z.int(),
+  z.string().check(z.minLength(1), z.maxLength(tileflowInteractionLimits.maxFeatureIdLength))
+]);
+var tileflowInteractionJsonValueSchema = z.custom(
+  (value) => auditTileflowInteractionJsonDocument(value).ok,
+  "Expected a bounded, finite JSON value"
+);
+var textContentSchema = z.strictObject({
+  kind: z.literal("text"),
+  text: z.string().check(z.maxLength(tileflowInteractionLimits.maxContentTextLength))
+});
+var fieldContentSchema = z.strictObject({
+  fallback: z.optional(
+    z.string().check(z.maxLength(tileflowInteractionLimits.maxContentTextLength))
+  ),
+  field: z.string().check(
+    z.minLength(1),
+    z.maxLength(tileflowInteractionLimits.maxFieldSelectorLength),
+    z.regex(fieldSelectorPattern, "Expected a dotted declarative field selector"),
+    z.refine((field) => field.split(".").every((segment) => !unsafeFieldSegments.has(segment)), {
+      message: "Field selectors may not contain unsafe object keys"
+    })
+  ),
+  kind: z.literal("field")
+});
+var viewContentSchema = z.strictObject({
+  kind: z.literal("view"),
+  name: z.string().check(
+    z.minLength(1),
+    z.maxLength(tileflowInteractionLimits.maxViewNameLength),
+    z.regex(portableIdPattern, "Expected a portable view name")
+  )
+});
+var tileflowInteractionContentSchema = z.discriminatedUnion("kind", [
+  textContentSchema,
+  fieldContentSchema,
+  viewContentSchema
+]);
+var annotationMarkerSchema = z.strictObject({
+  color: z.optional(
+    z.string().check(
+      z.trim(),
+      z.minLength(1),
+      z.maxLength(tileflowInteractionLimits.maxColorLength),
+      z.regex(safeCssColorPattern, "Expected a bounded CSS color without URL or variable input")
+    )
+  ),
+  content: z.optional(tileflowInteractionContentSchema)
+});
+var annotationSurfaceSchema = z.strictObject({ content: tileflowInteractionContentSchema });
+var tileflowAnnotationSchema = z.strictObject({
+  ariaLabel: z.string().check(z.trim(), z.minLength(1), z.maxLength(tileflowInteractionLimits.maxAriaLabelLength)),
+  coordinate: coordinateSchema,
+  data: z.optional(tileflowInteractionJsonValueSchema),
+  id: portableIdSchema,
+  kind: z.literal("marker"),
+  marker: z.optional(annotationMarkerSchema),
+  popup: z.optional(annotationSurfaceSchema),
+  tooltip: z.optional(annotationSurfaceSchema)
+});
+var tileflowAnnotationsSchema = z.array(tileflowAnnotationSchema).check(z.maxLength(tileflowInteractionLimits.maxAnnotations));
+var annotationTargetSelectorSchema = z.strictObject({
+  id: portableIdSchema,
+  kind: z.literal("annotation")
+});
+var semanticFeatureTargetSelectorSchema = z.strictObject({
+  categories: z.optional(
+    z.array(z.enum(tileflowPoiCategories)).check(z.minLength(1), z.maxLength(tileflowInteractionLimits.maxCategories))
+  ),
+  domain: z.string().check(
+    z.minLength(1),
+    z.maxLength(tileflowInteractionLimits.maxTargetNameLength),
+    z.regex(semanticDomainPattern, "Expected a dotted semantic domain")
+  ),
+  kind: z.literal("semantic-feature")
+});
+var styleLayerTargetSelectorSchema = z.strictObject({
+  kind: z.literal("style-layer"),
+  layerId: targetNameSchema
+});
+var mapTargetSelectorSchema = z.strictObject({ kind: z.literal("map") });
+var tileflowInteractionTargetSchema = z.discriminatedUnion("kind", [
+  annotationTargetSelectorSchema,
+  semanticFeatureTargetSelectorSchema,
+  styleLayerTargetSelectorSchema,
+  mapTargetSelectorSchema
+]);
+var tileflowInteractionBindingSchema = z.strictObject({
+  id: portableIdSchema,
+  popup: z.optional(annotationSurfaceSchema),
+  target: tileflowInteractionTargetSchema,
+  tooltip: z.optional(annotationSurfaceSchema)
+});
+var tileflowInteractionBindingsSchema = z.array(tileflowInteractionBindingSchema).check(z.maxLength(tileflowInteractionLimits.maxBindings));
+var annotationTargetSchema = z.strictObject({
+  id: portableIdSchema,
+  kind: z.literal("annotation")
+});
+var semanticFeatureTargetSchema = z.strictObject({
+  domain: z.string().check(
+    z.minLength(1),
+    z.maxLength(tileflowInteractionLimits.maxTargetNameLength),
+    z.regex(semanticDomainPattern, "Expected a dotted semantic domain")
+  ),
+  featureId: featureIdSchema,
+  kind: z.literal("semantic-feature")
+});
+var styleFeatureTargetSchema = z.strictObject({
+  featureId: featureIdSchema,
+  kind: z.literal("style-feature"),
+  layerId: targetNameSchema
+});
+var mapTargetSchema = z.strictObject({ coordinate: coordinateSchema, kind: z.literal("map") });
+var tileflowInteractionTargetRefSchema = z.discriminatedUnion("kind", [
+  annotationTargetSchema,
+  semanticFeatureTargetSchema,
+  styleFeatureTargetSchema,
+  mapTargetSchema
+]);
+var tileflowInteractionStateSchema = z.strictObject({
+  popup: z.nullable(tileflowInteractionTargetRefSchema)
+});
+var tileflowInteractionActionSchema = z.discriminatedUnion("type", [
+  z.strictObject({ target: tileflowInteractionTargetRefSchema, type: z.literal("open-popup") }),
+  z.strictObject({ type: z.literal("close-popup") })
+]);
+
+// src/maplibre-poi.ts
+var interactionManifestMetadataKey = "tileflow:interaction-manifest";
+var interactionManifestVersion = 2;
+var missingSourceLayerNamespace = "
tileflow-no-source-layer";
+function createTileflowMapLibrePoiController(options) {
+  let bindings = semanticPoiBindings(options.bindings ?? [], options.onDiagnostic);
+  let manifest = null;
+  let hovered = null;
+  let pendingMove = null;
+  let pendingFrame = null;
+  let disposed = false;
+  let disposeComplete = false;
+  let framePendingCancellation = null;
+  let hoverClearPending = false;
+  const subscriptionDisposers = [];
+  const emit = (type, match, modality) => {
+    options.onInteractionEvent?.({
+      bindingId: match.binding.id,
+      coordinate: match.target.coordinate,
+      inputModality: modality,
+      target: match.target,
+      type
+    });
+  };
+  const setHovered = (next, modality) => {
+    if (matchesEqual(hovered, next)) {
+      if (next && !Object.is(hovered, next)) {
+        hovered = next;
+        options.onHoverChange?.(hovered);
+      }
+      return;
+    }
+    if (hovered) emit("target:leave", hovered, modality);
+    hovered = next;
+    if (hovered) emit("target:enter", hovered, modality);
+    options.onHoverChange?.(hovered);
+  };
+  const hitTest = (event) => {
+    if (!manifest || bindings.length === 0) return null;
+    const layerIds = relevantLayerIds(manifest, bindings);
+    if (layerIds.length === 0) return null;
+    let features;
+    try {
+      features = options.map.queryRenderedFeatures(event.point, { layers: layerIds });
+    } catch {
+      diagnostic(
+        options.onDiagnostic,
+        "SEMANTIC_MANIFEST_MISMATCH",
+        "Tileflow could not query the semantic POI layers declared by this style."
+      );
+      return null;
+    }
+    const candidates = [];
+    let manifestMismatch = false;
+    for (const [renderedIndex, feature] of features.entries()) {
+      const layer = manifest.layers.find((candidate) => candidate.layerId === feature.layer.id);
+      if (!layer) continue;
+      if (feature.source !== void 0 && feature.source !== layer.source || sourceLayerNamespace(feature.sourceLayer) !== sourceLayerNamespace(layer.sourceLayer)) {
+        manifestMismatch = true;
+        diagnostic(
+          options.onDiagnostic,
+          "SEMANTIC_MANIFEST_MISMATCH",
+          "A rendered POI feature does not match its semantic interaction metadata."
+        );
+        continue;
+      }
+      const binding = bindings.find((candidate) => {
+        const target = candidate.target;
+        return target.kind === "semantic-feature" && target.domain === "poi" && (!target.categories || target.categories.includes(layer.category));
+      });
+      if (!binding) continue;
+      const featureId = normalizeFeatureId(feature.id);
+      candidates.push({
+        layer,
+        renderedIndex,
+        match: {
+          binding,
+          target: {
+            bindingId: binding.id,
+            coordinate: [event.lngLat.lng, event.lngLat.lat],
+            domain: "poi",
+            feature: {
+              category: layer.category,
+              ...featureId === void 0 ? {} : { id: featureId },
+              properties: normalizePoiProperties(feature.properties, manifest.fields)
+            },
+            kind: "semantic-feature"
+          }
+        }
+      });
+    }
+    if (!manifestMismatch) {
+      options.onDiagnosticResolved?.("SEMANTIC_MANIFEST_MISMATCH");
+    }
+    return choosePoiCandidate(candidates, manifest)?.match ?? null;
+  };
+  const handleMove = (value) => {
+    const event = parsePointerEvent(value);
+    if (!event || disposed) return;
+    pendingMove = event;
+    if (pendingFrame !== null) return;
+    pendingFrame = options.requestFrame(() => {
+      pendingFrame = null;
+      const current = pendingMove;
+      pendingMove = null;
+      if (current && !disposed) setHovered(hitTest(current), inputModality(current));
+    });
+  };
+  const handleLeave = () => {
+    pendingMove = null;
+    if (pendingFrame !== null) {
+      options.cancelFrame(pendingFrame);
+      pendingFrame = null;
+    }
+    setHovered(null, "pointer");
+  };
+  const handleClick = (value) => {
+    const event = parsePointerEvent(value);
+    if (!event || disposed) return;
+    const modality = inputModality(event);
+    const match = hitTest(event);
+    if (!match) return;
+    emit("target:activate", match, modality);
+    if (match.binding.popup && match.target.feature.id === void 0) {
+      diagnostic(
+        options.onDiagnostic,
+        "UNSTABLE_FEATURE_IDENTITY",
+        "This semantic POI has no stable feature ID, so Tileflow cannot open durable popup state."
+      );
+      return;
+    }
+    options.onActivate?.(match, modality);
+  };
+  const refreshManifest = () => {
+    if (disposed) return;
+    setHovered(null, "programmatic");
+    if (bindings.length === 0) {
+      manifest = null;
+      options.onManifestChange?.(true);
+      return;
+    }
+    const style = options.map.getStyle();
+    if (style === void 0) {
+      manifest = null;
+      options.onManifestChange?.(false);
+      return;
+    }
+    manifest = parsePoiManifest(style, options.onDiagnostic);
+    options.onManifestChange?.(manifest !== null);
+  };
+  let manifestRefreshScheduled = false;
+  const scheduleManifestRefresh = () => {
+    if (disposed || manifestRefreshScheduled) return;
+    manifestRefreshScheduled = true;
+    queueMicrotask(() => {
+      if (!manifestRefreshScheduled) return;
+      manifestRefreshScheduled = false;
+      refreshManifest();
+    });
+  };
+  const handleStyleLoad = () => {
+    manifestRefreshScheduled = false;
+    refreshManifest();
+  };
+  try {
+    for (const [event, listener] of [
+      ["mousemove", handleMove],
+      ["mouseout", handleLeave],
+      ["click", handleClick],
+      ["styledata", scheduleManifestRefresh],
+      ["style.load", handleStyleLoad]
+    ]) {
+      subscriptionDisposers.push({
+        active: true,
+        dispose: subscribe(options.map, event, listener)
+      });
+    }
+    refreshManifest();
+  } catch (error) {
+    disposed = true;
+    const rollbackErrors = disposeSubscriptions(subscriptionDisposers);
+    throwWithCleanupErrors(
+      error,
+      rollbackErrors,
+      "Tileflow semantic POI controller construction failed during cleanup."
+    );
+  }
+  return {
+    dispose() {
+      if (disposeComplete) return;
+      disposed = true;
+      if (framePendingCancellation === null) framePendingCancellation = pendingFrame;
+      pendingFrame = null;
+      pendingMove = null;
+      const errors = [];
+      if (framePendingCancellation !== null) {
+        try {
+          options.cancelFrame(framePendingCancellation);
+          framePendingCancellation = null;
+        } catch (error) {
+          errors.push(error);
+        }
+      }
+      errors.push(...disposeSubscriptions(subscriptionDisposers));
+      if (hovered) {
+        hovered = null;
+        hoverClearPending = true;
+      }
+      if (hoverClearPending) {
+        try {
+          options.onHoverChange?.(null);
+          hoverClearPending = false;
+        } catch (error) {
+          errors.push(error);
+        }
+      }
+      if (errors.length > 0) {
+        throwCollectedErrors2(errors, "Unable to dispose the Tileflow semantic POI controller.");
+      }
+      disposeComplete = true;
+    },
+    getHovered: () => hovered,
+    reconcile(nextBindings) {
+      if (disposed) throw new Error("Tileflow semantic POI controller is disposed.");
+      const previouslyRequiredManifest = bindings.length > 0;
+      bindings = semanticPoiBindings(nextBindings, options.onDiagnostic);
+      if (bindings.length === 0 || !previouslyRequiredManifest || manifest === null) {
+        refreshManifest();
+      }
+      if (hovered) {
+        const replacement = bindings.find(
+          (binding) => binding.id === hovered?.binding.id && bindingMatchesTarget(binding, hovered.target)
+        );
+        if (!replacement) setHovered(null, "programmatic");
+        else if (!Object.is(replacement, hovered.binding)) {
+          hovered = {
+            binding: replacement,
+            target: { ...hovered.target, bindingId: replacement.id }
+          };
+          options.onHoverChange?.(hovered);
+        }
+      }
+    },
+    refreshManifest
+  };
+}
+function semanticPoiBindings(bindings, onDiagnostic) {
+  const result = [];
+  let hasUnsupportedTarget = false;
+  for (const binding of bindings) {
+    if (binding.target.kind === "semantic-feature" && binding.target.domain === "poi") {
+      result.push(binding);
+      continue;
+    }
+    hasUnsupportedTarget = true;
+  }
+  if (hasUnsupportedTarget) {
+    diagnostic(
+      onDiagnostic,
+      "UNSUPPORTED_TARGET",
+      "One or more Tileflow interaction targets are not available in the current semantic runtime."
+    );
+  }
+  return result;
+}
+function parsePoiManifest(styleInput, onDiagnostic) {
+  const style = asRecord(styleInput);
+  const metadata = asRecord(style?.metadata);
+  const artifact = asRecord(metadata?.[interactionManifestMetadataKey]);
+  const domains = asRecord(artifact?.domains);
+  const poi = asRecord(domains?.poi);
+  if (!artifact || !poi) {
+    diagnostic(
+      onDiagnostic,
+      "SEMANTIC_MANIFEST_MISMATCH",
+      "This style does not include Tileflow semantic POI interaction metadata.",
+      "warning"
+    );
+    return null;
+  }
+  if (artifact.version !== interactionManifestVersion) {
+    diagnostic(
+      onDiagnostic,
+      "SEMANTIC_MANIFEST_MISMATCH",
+      "This style uses an unsupported Tileflow interaction metadata version."
+    );
+    return null;
+  }
+  const fields = asRecord(poi.fields);
+  const deduplication = asRecord(poi.deduplication);
+  const hitTesting = asRecord(poi.hitTesting);
+  const identityFields = Array.isArray(deduplication?.identity) ? deduplication.identity : [];
+  const representationPriority = Array.isArray(deduplication?.representationPriority) ? deduplication.representationPriority : [];
+  const layerInputs = Array.isArray(poi.layers) ? poi.layers : [];
+  const styleLayers = Array.isArray(style?.layers) ? style.layers : [];
+  const styleLayersById = new Map(
+    styleLayers.flatMap((layer) => {
+      const record = asRecord(layer);
+      const id = record?.id;
+      return typeof id === "string" && record ? [[id, record]] : [];
+    })
+  );
+  if (!fields || !["category", "filterRank", "icon", "name", "sizeRank", "type"].every(
+    (field) => isSafeManifestName(fields[field])
+  ) || poi.identity !== "maplibre-feature-id-if-present" || identityFields.length !== 3 || identityFields[0] !== "source" || identityFields[1] !== "source-layer" || identityFields[2] !== "feature-id" || !isRepresentationPriority(representationPriority) || hitTesting?.frequency !== "animation-frame" || hitTesting.order !== "rendered-topmost" || layerInputs.length === 0 || layerInputs.length > 256) {
+    diagnostic(onDiagnostic, "SEMANTIC_MANIFEST_MISMATCH", "Invalid semantic POI metadata.");
+    return null;
+  }
+  const layers = [];
+  const ids = /* @__PURE__ */ new Set();
+  let identityNamespace;
+  for (const input of layerInputs) {
+    const layer = asRecord(input);
+    const sourceLayer = layer?.sourceLayer;
+    if (!layer || !isTileflowPoiCategory(layer.category) || !isSafeManifestName(layer.layerId) || !isSafeManifestName(layer.source) || sourceLayer !== void 0 && !isSafeManifestName(sourceLayer) || layer.anchor !== "pointer-coordinate" || !isPoiRepresentation(layer.representation) || !Number.isSafeInteger(layer.priority) || layer.priority < 0 || layer.priority > 1e5 || ids.has(layer.layerId)) {
+      diagnostic(onDiagnostic, "SEMANTIC_MANIFEST_MISMATCH", "Invalid semantic POI layer lookup.");
+      return null;
+    }
+    const styleLayer = styleLayersById.get(layer.layerId);
+    if (!styleLayer || styleLayer.source !== layer.source || styleLayer["source-layer"] !== sourceLayer) {
+      diagnostic(
+        onDiagnostic,
+        "SEMANTIC_MANIFEST_MISMATCH",
+        "Semantic POI metadata does not match the finalized style layer."
+      );
+      return null;
+    }
+    const namespace = [
+      layer.source,
+      sourceLayerNamespace(sourceLayer)
+    ];
+    if (identityNamespace && (identityNamespace[0] !== namespace[0] || identityNamespace[1] !== namespace[1])) {
+      diagnostic(
+        onDiagnostic,
+        "SEMANTIC_MANIFEST_MISMATCH",
+        "Semantic POI metadata spans multiple feature-ID namespaces."
+      );
+      return null;
+    }
+    identityNamespace = namespace;
+    ids.add(layer.layerId);
+    layers.push({
+      category: layer.category,
+      layerId: layer.layerId,
+      priority: layer.priority,
+      representation: layer.representation,
+      source: layer.source,
+      ...sourceLayer === void 0 ? {} : { sourceLayer }
+    });
+  }
+  return {
+    deduplication: {
+      representationPriority
+    },
+    fields: {
+      category: fields.category,
+      filterRank: fields.filterRank,
+      icon: fields.icon,
+      name: fields.name,
+      sizeRank: fields.sizeRank,
+      type: fields.type
+    },
+    layers: layers.sort((left, right) => right.priority - left.priority)
+  };
+}
+function choosePoiCandidate(candidates, manifest) {
+  const deduplicated = [];
+  const indexByIdentity = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const id = candidate.match.target.feature.id;
+    if (id === void 0) {
+      deduplicated.push(candidate);
+      continue;
+    }
+    const identity = `${candidate.layer.source}\0${sourceLayerNamespace(candidate.layer.sourceLayer)}\0${typeof id}\0${String(id)}`;
+    const existingIndex = indexByIdentity.get(identity);
+    if (existingIndex === void 0) {
+      indexByIdentity.set(identity, deduplicated.length);
+      deduplicated.push(candidate);
+      continue;
+    }
+    const existing = deduplicated[existingIndex];
+    if (preferPoiRepresentation(candidate, existing, manifest)) {
+      deduplicated[existingIndex] = {
+        ...candidate,
+        renderedIndex: Math.min(existing.renderedIndex, candidate.renderedIndex)
+      };
+    }
+  }
+  return deduplicated.sort(
+    (left, right) => left.renderedIndex - right.renderedIndex || right.layer.priority - left.layer.priority
+  )[0];
+}
+function preferPoiRepresentation(candidate, existing, manifest) {
+  const priority = manifest.deduplication.representationPriority;
+  const candidateIndex = priority.indexOf(candidate.layer.representation);
+  const existingIndex = priority.indexOf(existing.layer.representation);
+  return candidateIndex < existingIndex || candidateIndex === existingIndex && candidate.layer.priority > existing.layer.priority;
+}
+function isRepresentationPriority(input) {
+  return input.length === 4 && input.every(isPoiRepresentation) && new Set(input).size === input.length;
+}
+function isPoiRepresentation(value) {
+  return value === "combined" || value === "icon" || value === "label" || value === "marker";
+}
+function isTileflowPoiCategory(value) {
+  return typeof value === "string" && tileflowPoiCategories.includes(value);
+}
+function sourceLayerNamespace(sourceLayer) {
+  return sourceLayer ?? missingSourceLayerNamespace;
+}
+function relevantLayerIds(manifest, bindings) {
+  return manifest.layers.filter(
+    (layer) => bindings.some(
+      (binding) => binding.target.kind === "semantic-feature" && (!binding.target.categories || binding.target.categories.includes(layer.category))
+    )
+  ).map((layer) => layer.layerId);
+}
+function normalizePoiProperties(properties, fields) {
+  const source = properties ?? {};
+  const normalized = {};
+  const read = (field) => {
+    try {
+      return source[fields[field]];
+    } catch {
+      return void 0;
+    }
+  };
+  const category = read("category");
+  const filterRank = read("filterRank");
+  const icon = read("icon");
+  const name = read("name");
+  const sizeRank = read("sizeRank");
+  const type = read("type");
+  if (isTileflowPoiCategory(category)) normalized.category = category;
+  if (isIntegerInRange(filterRank, 0, 5)) {
+    normalized.filter_rank = filterRank;
+  }
+  if (isSnakeCaseValue(icon)) normalized.icon = icon;
+  if (isBoundedText(name)) normalized.name = name;
+  if (isIntegerInRange(sizeRank, 0, 16)) {
+    normalized.size_rank = sizeRank;
+  }
+  if (isSnakeCaseValue(type)) normalized.type = type;
+  return Object.freeze(normalized);
+}
+function isIntegerInRange(value, minimum, maximum) {
+  return Number.isSafeInteger(value) && value >= minimum && value <= maximum;
+}
+function isBoundedText(value) {
+  return typeof value === "string" && value.length <= tileflowInteractionLimits.maxContentTextLength;
+}
+function isSnakeCaseValue(value) {
+  return isBoundedText(value) && /^[a-z0-9]+(?:_[a-z0-9]+)*$/u.test(value);
+}
+function normalizeFeatureId(value) {
+  if (typeof value === "number") return Number.isSafeInteger(value) ? value : void 0;
+  if (typeof value === "string" && value.length > 0 && value.length <= tileflowInteractionLimits.maxFeatureIdLength) {
+    return value;
+  }
+  return void 0;
+}
+function matchesEqual(left, right) {
+  if (left === right) return true;
+  if (!left || !right || left.binding.id !== right.binding.id) return false;
+  const leftFeature = left.target.feature;
+  const rightFeature = right.target.feature;
+  if (leftFeature.id !== void 0 || rightFeature.id !== void 0) {
+    return leftFeature.id === rightFeature.id && left.target.domain === right.target.domain;
+  }
+  return leftFeature.category === rightFeature.category && JSON.stringify(leftFeature.properties) === JSON.stringify(rightFeature.properties);
+}
+function bindingMatchesTarget(binding, target) {
+  const selector = binding.target;
+  if (selector.kind !== "semantic-feature" || selector.domain !== target.domain || selector.domain !== "poi") {
+    return false;
+  }
+  return !selector.categories || target.feature.category !== void 0 && selector.categories.includes(target.feature.category);
+}
+function parsePointerEvent(value) {
+  const event = asRecord(value);
+  const lngLat = asRecord(event?.lngLat);
+  if (!event || !lngLat || event.point === void 0 || typeof lngLat.lng !== "number" || !Number.isFinite(lngLat.lng) || typeof lngLat.lat !== "number" || !Number.isFinite(lngLat.lat)) {
+    return null;
+  }
+  return value;
+}
+function inputModality(event) {
+  return event.originalEvent?.pointerType === "touch" || event.originalEvent?.touches !== void 0 ? "touch" : "pointer";
+}
+function subscribe(map, event, listener) {
+  const subscription = map.on(event, listener);
+  if (typeof subscription?.unsubscribe === "function") return () => subscription.unsubscribe?.();
+  return () => map.off?.(event, listener);
+}
+function disposeSubscriptions(subscriptions) {
+  const errors = [];
+  for (const subscription of [...subscriptions].reverse()) {
+    if (!subscription.active) continue;
+    try {
+      subscription.dispose();
+      subscription.active = false;
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  return errors;
+}
+function throwWithCleanupErrors(error, cleanupErrors, message) {
+  if (cleanupErrors.length === 0) throw error;
+  throw new AggregateError([error, ...cleanupErrors], message, { cause: error });
+}
+function throwCollectedErrors2(errors, message) {
+  if (errors.length === 0) return;
+  if (errors.length === 1) throw errors[0];
+  throw new AggregateError(errors, message);
+}
+function diagnostic(listener, code, message, level = "error") {
+  listener?.({ code, level, message });
+}
+function isSafeManifestName(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 256 && ![...value].some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code === 127;
+  });
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+
+// src/maplibre-semantic-dom.ts
+var semanticRuntimeSequence = 0;
+function createTileflowMapLibreSemanticDomRuntime(options) {
+  const controlled = options.interactionState !== void 0;
+  const idPrefix = options.idPrefix ?? `tileflow-semantic-${++semanticRuntimeSequence}`;
+  assertIdPrefix2(idPrefix);
+  let bindings = Object.freeze([]);
+  let interactionState = options.interactionState ?? options.defaultInteractionState ?? Object.freeze({ popup: null });
+  let customRenderers = Object.freeze({
+    popup: options.customPopup ?? false,
+    tooltip: options.customTooltip ?? false
+  });
+  let pendingStateRequest = null;
+  let hoveredMatch = null;
+  let activeTooltip = null;
+  let activePopup = null;
+  let renderTargets = Object.freeze([]);
+  let disposed = false;
+  let disposeComplete = false;
+  let overlaySequence = 0;
+  const pendingCleanupTasks = /* @__PURE__ */ new Set();
+  const eventListeners = /* @__PURE__ */ new Set();
+  const renderTargetListeners = /* @__PURE__ */ new Set();
+  const diagnosticListeners = /* @__PURE__ */ new Set();
+  const diagnosticsByKey = /* @__PURE__ */ new Map();
+  let diagnostics = Object.freeze([]);
+  const publishRenderTargets = () => {
+    if (disposed) return;
+    renderTargets = buildRenderTargets();
+    notify(renderTargetListeners, renderTargets);
+  };
+  const publishDiagnostics = () => {
+    if (disposed) return;
+    diagnostics = Object.freeze([...diagnosticsByKey.values()]);
+    notify(diagnosticListeners, diagnostics);
+  };
+  const reportDiagnostic = (key, diagnostic2) => {
+    if (diagnosticsByKey.has(key)) return;
+    const frozen = Object.freeze(diagnostic2);
+    diagnosticsByKey.set(key, frozen);
+    publishDiagnostics();
+    options.onDiagnostic?.(frozen);
+  };
+  const clearDiagnostic = (key) => {
+    if (!diagnosticsByKey.delete(key)) return;
+    publishDiagnostics();
+  };
+  const retireResources = (operations) => {
+    const task = {
+      operations: operations.map((run) => ({ complete: false, run }))
+    };
+    pendingCleanupTasks.add(task);
+    const errors = runCleanupTask(task);
+    if (cleanupTaskComplete(task)) pendingCleanupTasks.delete(task);
+    return errors;
+  };
+  const flushPendingCleanupTasks = () => {
+    const errors = [];
+    for (const task of pendingCleanupTasks) {
+      errors.push(...runCleanupTask(task));
+      if (cleanupTaskComplete(task)) pendingCleanupTasks.delete(task);
+    }
+    return errors;
+  };
+  const emit = (event) => notify(eventListeners, event);
+  const emitPopupEvent = (type, match, inputModality2) => {
+    emit(
+      Object.freeze({
+        bindingId: match.binding.id,
+        coordinate: match.target.coordinate,
+        inputModality: inputModality2,
+        target: match.target,
+        type
+      })
+    );
+  };
+  const closeTooltipVisual = () => {
+    const current = activeTooltip;
+    if (!current) return false;
+    activeTooltip = null;
+    const errors = retireResources([() => current.overlay.remove(), () => current.shell.remove()]);
+    errors.push(
+      ...safelyRunAll2([
+        () => clearSurfaceDiagnostics(current.match, "tooltip"),
+        () => publishRenderTargets()
+      ])
+    );
+    throwCollectedErrors3(errors, "Unable to close the Tileflow semantic tooltip.");
+    return true;
+  };
+  const closePopupVisual = (inputModality2) => {
+    const current = activePopup;
+    if (!current) return false;
+    activePopup = null;
+    const errors = retireResources([
+      ...current.closeButton && current.closeListener ? [() => current.closeButton?.removeEventListener("click", current.closeListener)] : [],
+      ...current.keydownListener ? [() => current.shell.removeEventListener("keydown", current.keydownListener)] : [],
+      () => current.overlay.remove(),
+      () => current.shell.remove()
+    ]);
+    errors.push(
+      ...safelyRunAll2([
+        () => clearSurfaceDiagnostics(current.match, "popup"),
+        () => publishRenderTargets(),
+        () => emitPopupEvent("popup:close", current.match, inputModality2)
+      ])
+    );
+    throwCollectedErrors3(errors, "Unable to close the Tileflow semantic popup.");
+    return true;
+  };
+  const configureOverlayContent = (current) => {
+    const surface = current.match.binding[current.kind];
+    if (!surface) return;
+    configureViewAttribute2(current.container, surface.content);
+    const text = resolveSemanticContent(current.match, current.kind, surface.content);
+    if (!customRenderers[current.kind]) current.container.textContent = text;
+  };
+  const resolveSemanticContent = (match, kind, content) => {
+    const missingViewKey = surfaceDiagnosticKey(match, kind, "MISSING_VIEW");
+    const invalidFieldKey = surfaceDiagnosticKey(match, kind, "INVALID_FIELD");
+    if (content.kind === "view") {
+      clearDiagnostic(invalidFieldKey);
+      if (customRenderers[kind]) clearDiagnostic(missingViewKey);
+      else {
+        const target = semanticTargetReference(match.target);
+        reportDiagnostic(missingViewKey, {
+          code: "MISSING_VIEW",
+          level: "error",
+          message: "Semantic view content has no custom renderer for its active surface.",
+          ...target ? { target } : {}
+        });
+      }
+      return "";
+    }
+    clearDiagnostic(missingViewKey);
+    const resolution = resolveContent2(content, match.target.feature.properties);
+    if (resolution.invalidField) {
+      const target = semanticTargetReference(match.target);
+      reportDiagnostic(invalidFieldKey, {
+        code: "INVALID_FIELD",
+        level: "error",
+        message: "Semantic feature field content did not resolve to a scalar value.",
+        ...target ? { target } : {}
+      });
+    } else clearDiagnostic(invalidFieldKey);
+    return resolution.text;
+  };
+  function clearSurfaceDiagnostics(match, kind) {
+    clearDiagnostic(surfaceDiagnosticKey(match, kind, "MISSING_VIEW"));
+    clearDiagnostic(surfaceDiagnosticKey(match, kind, "INVALID_FIELD"));
+  }
+  const openTooltipVisual = (match) => {
+    if (!match.binding.tooltip || sameMatch(activePopup?.match, match)) {
+      return false;
+    }
+    if (activeTooltip && sameMatch(activeTooltip.match, match)) {
+      try {
+        updateOverlayVisual(activeTooltip, match);
+        clearDiagnostic(overlayDiagnosticKey2("tooltip"));
+      } catch {
+        reportOverlayFailure("tooltip", match.target);
+      }
+      return false;
+    }
+    closeTooltipVisual();
+    const shell = options.document.createElement("div");
+    const container = options.document.createElement("div");
+    shell.className = "tileflow-interaction-tooltip";
+    container.className = "tileflow-interaction-tooltip-content";
+    shell.id = `${idPrefix}-tooltip-${++overlaySequence}`;
+    shell.setAttribute("data-tileflow-interaction", "tooltip");
+    shell.setAttribute("data-tileflow-target-kind", "semantic-feature");
+    shell.setAttribute("role", "tooltip");
+    shell.style.pointerEvents = "none";
+    configureSurfaceStyles2(shell);
+    shell.append(container);
+    let overlay;
+    try {
+      overlay = options.createOverlay({
+        binding: match.binding,
+        container: shell,
+        kind: "tooltip",
+        target: match.target
+      });
+      overlay.setLngLat(copyCoordinate2(match.target.coordinate));
+      overlay.addTo(options.map);
+    } catch {
+      retireResources([() => overlay?.remove(), () => shell.remove()]);
+      reportOverlayFailure("tooltip", match.target);
+      return false;
+    }
+    activeTooltip = { container, kind: "tooltip", match, overlay, shell };
+    configureOverlayContent(activeTooltip);
+    clearDiagnostic(overlayDiagnosticKey2("tooltip"));
+    publishRenderTargets();
+    return true;
+  };
+  const openPopupVisual = (match, inputModality2) => {
+    if (!match.binding.popup) return false;
+    if (activePopup && sameMatch(activePopup.match, match)) {
+      try {
+        updateOverlayVisual(activePopup, match);
+        clearDiagnostic(overlayDiagnosticKey2("popup"));
+      } catch {
+        reportOverlayFailure("popup", match.target);
+      }
+      return false;
+    }
+    closePopupVisual(inputModality2);
+    closeTooltipVisual();
+    const shell = options.document.createElement("div");
+    const container = options.document.createElement("div");
+    const closeButton = options.document.createElement("button");
+    const label = semanticAccessibleLabel(match.target);
+    shell.className = "tileflow-interaction-popup";
+    container.className = "tileflow-interaction-popup-content";
+    closeButton.className = "tileflow-interaction-popup-close";
+    closeButton.type = "button";
+    closeButton.textContent = "Close";
+    shell.id = `${idPrefix}-popup-${++overlaySequence}`;
+    shell.setAttribute("data-tileflow-interaction", "popup");
+    shell.setAttribute("data-tileflow-target-kind", "semantic-feature");
+    shell.setAttribute("aria-label", label);
+    shell.setAttribute("aria-modal", "false");
+    shell.setAttribute("role", "dialog");
+    closeButton.setAttribute("aria-label", `Close ${label}`);
+    configureSurfaceStyles2(shell);
+    closeButton.style.background = "transparent";
+    closeButton.style.border = "0";
+    closeButton.style.color = "inherit";
+    closeButton.style.cursor = "pointer";
+    shell.append(container, closeButton);
+    const closeListener = () => requestPopupState(null, "pointer");
+    const keydownListener = (event) => {
+      if (event.key !== "Escape") return;
+      event.preventDefault();
+      event.stopPropagation();
+      requestPopupState(null, "keyboard");
+    };
+    closeButton.addEventListener("click", closeListener);
+    shell.addEventListener("keydown", keydownListener);
+    let overlay;
+    try {
+      overlay = options.createOverlay({
+        binding: match.binding,
+        container: shell,
+        kind: "popup",
+        target: match.target
+      });
+      overlay.setLngLat(copyCoordinate2(match.target.coordinate));
+      overlay.addTo(options.map);
+    } catch {
+      retireResources([
+        () => closeButton.removeEventListener("click", closeListener),
+        () => shell.removeEventListener("keydown", keydownListener),
+        () => overlay?.remove(),
+        () => shell.remove()
+      ]);
+      reportOverlayFailure("popup", match.target);
+      return false;
+    }
+    activePopup = {
+      closeListener,
+      closeButton,
+      container,
+      keydownListener,
+      kind: "popup",
+      match,
+      overlay,
+      shell
+    };
+    configureOverlayContent(activePopup);
+    clearDiagnostic(overlayDiagnosticKey2("popup"));
+    publishRenderTargets();
+    emitPopupEvent("popup:open", match, inputModality2);
+    closeButton.focus({ preventScroll: true });
+    return true;
+  };
+  const updateOverlayVisual = (current, match) => {
+    current.match = match;
+    current.overlay.setLngLat(copyCoordinate2(match.target.coordinate));
+    if (current.kind === "popup") {
+      const label = semanticAccessibleLabel(match.target);
+      current.shell.setAttribute("aria-label", label);
+      current.closeButton?.setAttribute("aria-label", `Close ${label}`);
+    }
+    configureOverlayContent(current);
+    publishRenderTargets();
+  };
+  const reportOverlayFailure = (kind, target) => {
+    const reference = semanticTargetReference(target);
+    reportDiagnostic(overlayDiagnosticKey2(kind), {
+      code: "OVERLAY_FAILURE",
+      level: "error",
+      message: `Tileflow could not mount or update the semantic ${kind} overlay.`,
+      ...reference ? { target: reference } : {}
+    });
+  };
+  const resolveAvailableMatch = (reference) => {
+    for (const match of [pendingStateRequest?.match, hoveredMatch, activePopup?.match]) {
+      if (!match) continue;
+      if (!tileflowInteractionTargetRefsEqual(semanticTargetReference(match.target), reference)) {
+        continue;
+      }
+      const rebound = rebindSemanticMatch(match, bindings, "popup");
+      if (rebound) return rebound;
+    }
+    return null;
+  };
+  const invalidateResolvedMatches = () => {
+    pendingStateRequest = null;
+    hoveredMatch = null;
+    const errors = safelyRunAll2([
+      () => closeTooltipVisual(),
+      () => closePopupVisual("programmatic")
+    ]);
+    throwCollectedErrors3(errors, "Unable to invalidate stale Tileflow semantic targets.");
+  };
+  const syncPopupFromInteractionState = (inputModality2) => {
+    const popup = interactionState.popup;
+    if (popup?.kind !== "semantic-feature" || popup.domain !== "poi") {
+      closePopupVisual(inputModality2);
+      clearDiagnostic("state:stale");
+      return;
+    }
+    const match = resolveAvailableMatch(popup);
+    if (!match?.binding.popup) {
+      closePopupVisual(inputModality2);
+      reportDiagnostic("state:stale", {
+        code: "STALE_TARGET",
+        level: "warning",
+        message: "The semantic popup target is not available in the current rendered map.",
+        target: popup
+      });
+      return;
+    }
+    clearDiagnostic("state:stale");
+    openPopupVisual(match, inputModality2);
+  };
+  function requestPopupState(match, inputModality2) {
+    const target = match?.target ?? null;
+    const targetRef = target ? semanticTargetReference(target) : null;
+    if (target && !targetRef) return false;
+    const next = Object.freeze({ popup: targetRef });
+    if (tileflowInteractionTargetRefsEqual(interactionState.popup, next.popup)) {
+      if (target && !sameSemanticTarget(activePopup?.match.target, target)) {
+        syncPopupFromInteractionState(inputModality2);
+        return activePopup !== null;
+      }
+      return false;
+    }
+    const previous = interactionState;
+    pendingStateRequest = { inputModality: inputModality2, match };
+    if (!controlled) {
+      interactionState = next;
+      syncPopupFromInteractionState(inputModality2);
+      pendingStateRequest = null;
+    }
+    options.onInteractionStateChange?.(
+      next,
+      previous,
+      next.popup === null ? "popup:close" : "popup:open"
+    );
+    return true;
+  }
+  function buildRenderTargets() {
+    const targets = [];
+    for (const current of [activeTooltip, activePopup]) {
+      if (!current || !customRenderers[current.kind]) continue;
+      const surface = current.match.binding[current.kind];
+      if (!surface) continue;
+      const reference = semanticReferenceKey(current.match.target) ?? "unstable";
+      targets.push(
+        Object.freeze({
+          binding: current.match.binding,
+          close: () => current.kind === "popup" ? requestPopupState(null, "programmatic") : closeTooltipVisual(),
+          container: current.container,
+          content: surface.content,
+          key: `${current.kind}:${current.match.binding.id}:${reference}`,
+          kind: current.kind,
+          target: current.match.target,
+          ...surface.content.kind === "view" ? { viewName: surface.content.name } : {}
+        })
+      );
+    }
+    return Object.freeze(targets);
+  }
+  const poiController = createTileflowMapLibrePoiController({
+    bindings,
+    cancelFrame: options.cancelFrame,
+    map: options.poiMap,
+    onActivate(match, inputModality2) {
+      clearDiagnostic("poi:UNSTABLE_FEATURE_IDENTITY");
+      if (match.binding.popup) requestPopupState(match, inputModality2);
+    },
+    onDiagnostic(diagnostic2) {
+      reportDiagnostic(`poi:${diagnostic2.code}`, diagnostic2);
+    },
+    onDiagnosticResolved(code) {
+      clearDiagnostic(`poi:${code}`);
+    },
+    onHoverChange(match) {
+      hoveredMatch = match;
+      if (!match) {
+        closeTooltipVisual();
+        return;
+      }
+      if (tileflowInteractionTargetRefsEqual(
+        interactionState.popup,
+        semanticTargetReference(match.target)
+      )) {
+        syncPopupFromInteractionState("programmatic");
+      }
+      if (match.binding.tooltip) openTooltipVisual(match);
+      else closeTooltipVisual();
+    },
+    onInteractionEvent: emit,
+    onManifestChange(available) {
+      if (available) clearDiagnostic("poi:SEMANTIC_MANIFEST_MISMATCH");
+      invalidateResolvedMatches();
+      syncPopupFromInteractionState("programmatic");
+    },
+    requestFrame: options.requestFrame
+  });
+  return {
+    closePopup() {
+      assertActive2(disposed);
+      return requestPopupState(null, "programmatic");
+    },
+    dispose() {
+      if (disposeComplete) return;
+      const errors = [];
+      if (!disposed) {
+        disposed = true;
+        errors.push(
+          ...safelyRunAll2([() => closeTooltipVisual(), () => closePopupVisual("programmatic")])
+        );
+        renderTargets = Object.freeze([]);
+        diagnostics = Object.freeze([]);
+        eventListeners.clear();
+        renderTargetListeners.clear();
+        diagnosticListeners.clear();
+        diagnosticsByKey.clear();
+        pendingStateRequest = null;
+        hoveredMatch = null;
+      }
+      errors.push(...flushPendingCleanupTasks());
+      errors.push(...safelyRunAll2([() => poiController.dispose()]));
+      if (errors.length > 0) {
+        throwCollectedErrors3(errors, "Unable to dispose the Tileflow semantic DOM runtime.");
+      }
+      disposeComplete = true;
+    },
+    getDiagnostics: () => diagnostics,
+    getInteractionState: () => interactionState,
+    getRenderTargets: () => renderTargets,
+    reconcile(nextBindings) {
+      assertActive2(disposed);
+      bindings = Object.freeze([...nextBindings]);
+      if (bindings.every(
+        (binding) => binding.target.kind === "semantic-feature" && binding.target.domain === "poi"
+      )) {
+        clearDiagnostic("poi:UNSUPPORTED_TARGET");
+      }
+      if (!bindings.some(
+        (binding) => binding.target.kind === "semantic-feature" && binding.target.domain === "poi"
+      )) {
+        clearDiagnostic("poi:SEMANTIC_MANIFEST_MISMATCH");
+      }
+      clearDiagnostic("poi:UNSTABLE_FEATURE_IDENTITY");
+      poiController.reconcile(bindings);
+      if (pendingStateRequest?.match) {
+        const replacement = rebindSemanticMatch(pendingStateRequest.match, bindings);
+        pendingStateRequest = replacement ? { ...pendingStateRequest, match: replacement } : null;
+      }
+      if (hoveredMatch) {
+        hoveredMatch = rebindSemanticMatch(hoveredMatch, bindings);
+      }
+      if (activeTooltip) {
+        const replacement = rebindSemanticMatch(activeTooltip.match, bindings, "tooltip");
+        if (!replacement) closeTooltipVisual();
+        else if (!Object.is(replacement.binding, activeTooltip.match.binding)) {
+          updateOverlayVisual(activeTooltip, replacement);
+        }
+      }
+      if (activePopup) {
+        const replacement = rebindSemanticMatch(activePopup.match, bindings, "popup");
+        if (!replacement) {
+          if (controlled) closePopupVisual("programmatic");
+          requestPopupState(null, "programmatic");
+        } else if (!Object.is(replacement.binding, activePopup.match.binding)) {
+          updateOverlayVisual(activePopup, replacement);
+        }
+      }
+      syncPopupFromInteractionState("programmatic");
+    },
+    setCustomRenderers(renderers) {
+      assertActive2(disposed);
+      if (renderers.popup === customRenderers.popup && renderers.tooltip === customRenderers.tooltip) {
+        return;
+      }
+      customRenderers = Object.freeze({ ...renderers });
+      if (activeTooltip) {
+        if (customRenderers.tooltip) activeTooltip.container.textContent = "";
+        configureOverlayContent(activeTooltip);
+      }
+      if (activePopup) {
+        if (customRenderers.popup) activePopup.container.textContent = "";
+        configureOverlayContent(activePopup);
+      }
+      publishRenderTargets();
+    },
+    setInteractionState(state) {
+      assertActive2(disposed);
+      const requestedRef = pendingStateRequest?.match ? semanticTargetReference(pendingStateRequest.match.target) : null;
+      const inputModality2 = tileflowInteractionTargetRefsEqual(requestedRef, state.popup) ? pendingStateRequest?.inputModality ?? "programmatic" : "programmatic";
+      interactionState = state;
+      syncPopupFromInteractionState(inputModality2);
+      pendingStateRequest = null;
+    },
+    subscribeDiagnostics(listener) {
+      assertActive2(disposed);
+      diagnosticListeners.add(listener);
+      return unsubscribe(diagnosticListeners, listener);
+    },
+    subscribeEvents(listener) {
+      assertActive2(disposed);
+      eventListeners.add(listener);
+      return unsubscribe(eventListeners, listener);
+    },
+    subscribeRenderTargets(listener) {
+      assertActive2(disposed);
+      renderTargetListeners.add(listener);
+      return unsubscribe(renderTargetListeners, listener);
+    }
+  };
+}
+function semanticTargetReference(target) {
+  return target.feature.id === void 0 ? null : Object.freeze({
+    domain: target.domain,
+    featureId: target.feature.id,
+    kind: "semantic-feature"
+  });
+}
+function semanticReferenceKey(target) {
+  return target.feature.id === void 0 ? null : targetReferenceKey(target.domain, target.feature.id);
+}
+function targetReferenceKey(domain, featureId) {
+  return `${domain}\0${typeof featureId}\0${String(featureId)}`;
+}
+function surfaceDiagnosticKey(match, kind, code) {
+  return `${match.binding.id}\0${semanticReferenceKey(match.target) ?? "unstable"}\0${kind}\0${code}`;
+}
+function overlayDiagnosticKey2(kind) {
+  return `overlay\0${kind}`;
+}
+function sameMatch(left, right) {
+  if (!left || left.binding.id !== right.binding.id) return false;
+  const leftKey = semanticReferenceKey(left.target);
+  const rightKey = semanticReferenceKey(right.target);
+  return leftKey !== null && leftKey === rightKey;
+}
+function sameSemanticTarget(left, right) {
+  if (!left) return false;
+  const leftKey = semanticReferenceKey(left);
+  return leftKey !== null && leftKey === semanticReferenceKey(right);
+}
+function rebindSemanticMatch(match, bindings, surface) {
+  const replacement = bindings.find((binding) => {
+    const target = binding.target;
+    return binding.id === match.binding.id && target.kind === "semantic-feature" && target.domain === match.target.domain && target.domain === "poi" && (!target.categories || match.target.feature.category !== void 0 && target.categories.includes(match.target.feature.category)) && (surface === void 0 || binding[surface] !== void 0);
+  });
+  if (!replacement) return null;
+  if (Object.is(replacement, match.binding)) return match;
+  return {
+    binding: replacement,
+    target: { ...match.target, bindingId: replacement.id }
+  };
+}
+function semanticAccessibleLabel(target) {
+  const name = target.feature.properties.name;
+  if (typeof name === "string" && name.trim()) return name.slice(0, 256);
+  return target.feature.category ? `Point of interest: ${target.feature.category}` : "Point of interest";
+}
+function configureViewAttribute2(element, content) {
+  if (content.kind === "view") element.setAttribute("data-tileflow-view", content.name);
+  else element.removeAttribute("data-tileflow-view");
+}
+function configureSurfaceStyles2(element) {
+  element.style.background = "var(--tileflow-interaction-surface, #ffffff)";
+  element.style.borderColor = "var(--tileflow-interaction-border-color, #d1d5db)";
+  element.style.borderRadius = "var(--tileflow-interaction-border-radius, 0.375rem)";
+  element.style.borderStyle = "solid";
+  element.style.borderWidth = "1px";
+  element.style.boxShadow = "var(--tileflow-interaction-shadow, 0 2px 8px rgb(0 0 0 / 0.18))";
+  element.style.color = "var(--tileflow-interaction-foreground, #111827)";
+  element.style.maxWidth = "var(--tileflow-interaction-max-width, 20rem)";
+  element.style.padding = "0.5rem";
+}
+function resolveContent2(content, data) {
+  if (content.kind === "text") return { invalidField: false, text: content.text };
+  if (content.kind === "view") return { invalidField: false, text: "" };
+  const fallback = content.fallback ?? "";
+  const invalid = () => ({ invalidField: content.fallback === void 0, text: fallback });
+  let current = data;
+  for (const segment of content.field.split(".")) {
+    if (current === null || typeof current !== "object" || segment === "__proto__" || segment === "constructor" || segment === "prototype" || !Object.prototype.hasOwnProperty.call(current, segment)) {
+      return invalid();
+    }
+    current = current[segment];
+  }
+  return current === null || typeof current === "boolean" || typeof current === "number" || typeof current === "string" ? { invalidField: false, text: String(current) } : invalid();
+}
+function copyCoordinate2(coordinate) {
+  return [coordinate[0], coordinate[1]];
+}
+function assertIdPrefix2(idPrefix) {
+  if (!/^[A-Za-z][A-Za-z0-9_-]{0,127}$/u.test(idPrefix)) {
+    throw new TypeError("Tileflow semantic DOM idPrefix must be a portable identifier.");
+  }
+}
+function assertActive2(disposed) {
+  if (disposed) throw new Error("Tileflow semantic DOM runtime is disposed.");
+}
+function runCleanupTask(task) {
+  const errors = [];
+  for (const operation of task.operations) {
+    if (operation.complete) continue;
+    try {
+      operation.run();
+      operation.complete = true;
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  return errors;
+}
+function cleanupTaskComplete(task) {
+  return task.operations.every(({ complete }) => complete);
+}
+function safelyRunAll2(operations) {
+  const errors = [];
+  for (const operation of operations) {
+    try {
+      operation();
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  return errors;
+}
+function throwCollectedErrors3(errors, message) {
+  if (errors.length === 0) return;
+  if (errors.length === 1) throw errors[0];
+  throw new AggregateError(errors, message);
+}
+function notify(listeners, value) {
+  const errors = [];
+  for (const listener of [...listeners]) {
+    try {
+      listener(value);
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  if (errors.length === 1) throw errors[0];
+  if (errors.length > 1) throw new AggregateError(errors, "Tileflow semantic listeners failed.");
+}
+function unsubscribe(values, value) {
+  let active = true;
+  return () => {
+    if (!active) return;
+    active = false;
+    values.delete(value);
+  };
+}
+export {
+  createTileflowAnnotationRegistry,
+  createTileflowMapLibreDomRuntime,
+  createTileflowMapLibreInteractionCoordinator,
+  createTileflowMapLibrePoiController,
+  createTileflowMapLibreSemanticDomRuntime,
+  createTileflowOverlayStateController,
+  normalizeTileflowLegacyMarkers
+};