@tileflow/react-native 0.0.0-bootstrap.0 → 0.1.0-alpha.1

package/dist/internal/interactions.js

@@ -0,0 +1,794 @@
+// src/native-interaction-input.ts
+import {
+  tileflowInteractionJsonValueSchema,
+  tileflowInteractionLimits,
+  validateTileflowAnnotations,
+  validateTileflowInteractionBindings
+} from "@tileflow/interactions";
+var messages = {
+  DUPLICATE_ANNOTATION_ID: "Annotation IDs must be unique.",
+  INVALID_FIELD: "An interaction field is invalid.",
+  INVALID_ANNOTATION: "An annotation is invalid.",
+  INVALID_DOCUMENT: "The interaction document is invalid.",
+  LIMIT_EXCEEDED: "The portable interaction limit was exceeded.",
+  MISSING_VIEW: "The interaction view is unavailable.",
+  OVERLAY_FAILURE: "The interaction operation failed.",
+  SEMANTIC_MANIFEST_MISMATCH: "The current style cannot provide verified semantic POI queries.",
+  STALE_TARGET: "The interaction target is no longer available.",
+  UNSTABLE_FEATURE_IDENTITY: "A stable feature ID is unavailable.",
+  UNSUPPORTED_MODE: "This interaction input modality is unavailable.",
+  UNSUPPORTED_TARGET: "This interaction target is unavailable."
+};
+function nativeInteractionDiagnostic(code) {
+  return Object.freeze({
+    code,
+    level: code === "STALE_TARGET" || code === "UNSUPPORTED_TARGET" ? "warning" : "error",
+    message: messages[code]
+  });
+}
+function nativeInteractionField(value, key) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error();
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype) throw new Error();
+  const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  if (!descriptor) return void 0;
+  if (!("value" in descriptor) || !descriptor.enumerable) throw new Error();
+  return descriptor.value;
+}
+function snapshotNativeInteractionJson(input) {
+  if (!tileflowInteractionJsonValueSchema.safeParse(input).success) throw new Error();
+  let nodes = 0;
+  let properties2 = 0;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const copy = (value, depth) => {
+    if (++nodes > tileflowInteractionLimits.maxDocumentNodes || depth > tileflowInteractionLimits.maxDocumentDepth)
+      throw new Error();
+    if (value === null || typeof value === "boolean") return value;
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    if (typeof value === "string" && value.length <= tileflowInteractionLimits.maxDocumentBytes)
+      return value;
+    if (!value || typeof value !== "object" || seen.has(value)) throw new Error();
+    seen.add(value);
+    const array2 = Array.isArray(value);
+    const prototype = Object.getPrototypeOf(value);
+    if (array2 ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null)
+      throw new Error();
+    if (array2) {
+      const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+      if (!lengthDescriptor || !("value" in lengthDescriptor)) throw new Error();
+      const length = lengthDescriptor.value;
+      if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 0 || length > tileflowInteractionLimits.maxDocumentProperties - properties2)
+        throw new Error();
+      if (length > 0 && depth >= tileflowInteractionLimits.maxDocumentDepth) throw new Error();
+      properties2 += length;
+      const keys2 = Reflect.ownKeys(value);
+      if (keys2.length > length + 1) throw new Error();
+      const result2 = new Array(length);
+      let sawLength = false;
+      for (const key of keys2) {
+        if (typeof key !== "string") throw new Error();
+        if (key === "length") {
+          sawLength = true;
+          continue;
+        }
+        const index = Number(key);
+        if (!Number.isSafeInteger(index) || index < 0 || index >= length || String(index) !== key)
+          throw new Error();
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) throw new Error();
+        Object.defineProperty(result2, key, {
+          value: copy(descriptor.value, depth + 1),
+          enumerable: true,
+          configurable: true,
+          writable: true
+        });
+      }
+      if (!sawLength) throw new Error();
+      return Object.freeze(result2);
+    }
+    const keys = Reflect.ownKeys(value);
+    if (keys.length > tileflowInteractionLimits.maxDocumentProperties - properties2)
+      throw new Error();
+    properties2 += keys.length;
+    const result = {};
+    for (const key of keys) {
+      if (typeof key !== "string" || key === "__proto__" || key === "prototype" || key === "constructor")
+        throw new Error();
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) throw new Error();
+      result[key] = copy(descriptor.value, depth + 1);
+    }
+    return Object.freeze(result);
+  };
+  const snapshot = copy(input, 0);
+  if (!tileflowInteractionJsonValueSchema.safeParse(snapshot).success) throw new Error();
+  return snapshot;
+}
+function freezeNativeInteractionValue(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    for (const child of Object.values(value)) freezeNativeInteractionValue(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+function nativeInteractionValuesEqual(left, right) {
+  if (left === right) return true;
+  if (!left || !right || typeof left !== "object" || typeof right !== "object") return false;
+  const array2 = Array.isArray(left);
+  if (array2 !== Array.isArray(right)) return false;
+  if (array2 && Object.getOwnPropertyDescriptor(left, "length")?.value !== Object.getOwnPropertyDescriptor(right, "length")?.value)
+    return false;
+  const a = Object.keys(left).sort();
+  const b = Object.keys(right).sort();
+  return a.length === b.length && a.every(
+    (key, index) => key === b[index] && nativeInteractionValuesEqual(
+      Object.getOwnPropertyDescriptor(left, key)?.value,
+      Object.getOwnPropertyDescriptor(right, key)?.value
+    )
+  );
+}
+function prepareNativeInteractionInputs(input, previous) {
+  let annotations = previous?.annotations ?? Object.freeze([]);
+  let bindings = previous?.bindings ?? Object.freeze([]);
+  const diagnostics = [];
+  const report = (code) => {
+    if (!diagnostics.some((value) => value.code === code))
+      diagnostics.push(nativeInteractionDiagnostic(code));
+  };
+  try {
+    const raw = nativeInteractionField(input, "annotations");
+    let result = validateTileflowAnnotations(raw === void 0 ? [] : raw);
+    if (result.ok)
+      result = validateTileflowAnnotations(snapshotNativeInteractionJson(result.annotations));
+    if (result.ok) {
+      if (!nativeInteractionValuesEqual(annotations, result.annotations))
+        annotations = freezeNativeInteractionValue(result.annotations);
+    } else for (const diagnostic of result.diagnostics) report(diagnostic.code);
+  } catch {
+    report("INVALID_DOCUMENT");
+  }
+  try {
+    const raw = nativeInteractionField(input, "interactions");
+    let result = validateTileflowInteractionBindings(raw === void 0 ? [] : raw);
+    if (result.ok)
+      result = validateTileflowInteractionBindings(snapshotNativeInteractionJson(result.bindings));
+    if (result.ok) {
+      if (!nativeInteractionValuesEqual(bindings, result.bindings))
+        bindings = freezeNativeInteractionValue(result.bindings);
+    } else for (const diagnostic of result.diagnostics) report(diagnostic.code);
+  } catch {
+    report("INVALID_DOCUMENT");
+  }
+  return Object.freeze({
+    annotations,
+    bindings,
+    diagnostics: Object.freeze(diagnostics)
+  });
+}
+function planNativeAnnotations(previous, next) {
+  const before = new Map(previous.map((annotation) => [annotation.id, annotation]));
+  const after = new Set(next.map((annotation) => annotation.id));
+  const create = [];
+  const update = [];
+  const retain = [];
+  for (const annotation of next) {
+    const old = before.get(annotation.id);
+    if (!old) create.push(annotation);
+    else if (nativeInteractionValuesEqual(old, annotation)) retain.push(annotation.id);
+    else update.push(Object.freeze({ id: annotation.id, previous: old, annotation }));
+  }
+  return Object.freeze({
+    create: Object.freeze(create),
+    update: Object.freeze(update),
+    retain: Object.freeze(retain),
+    remove: Object.freeze(
+      previous.filter((annotation) => !after.has(annotation.id)).map((annotation) => annotation.id)
+    ),
+    order: Object.freeze(next.map((annotation) => annotation.id))
+  });
+}
+
+// src/native-interaction-poi.ts
+import {
+  tileflowInteractionLimits as tileflowInteractionLimits2,
+  tileflowPoiCategories
+} from "@tileflow/interactions";
+var nativePoiQueryLimit = 512;
+var emptyDiagnostics = Object.freeze([]);
+var stale = Object.freeze({ status: "stale", diagnostics: emptyDiagnostics });
+var miss = Object.freeze({ status: "miss", diagnostics: emptyDiagnostics });
+var failure = (code = "SEMANTIC_MANIFEST_MISMATCH") => Object.freeze({ status: "error", diagnostics: Object.freeze([nativeInteractionDiagnostic(code)]) });
+function array(value, maximum) {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) throw new Error();
+  const length = Object.getOwnPropertyDescriptor(value, "length")?.value;
+  if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 0 || length > maximum)
+    throw new Error();
+  const result = [];
+  for (let index = 0; index < length; index++) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) throw new Error();
+    result.push(descriptor.value);
+  }
+  return result;
+}
+function name(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 256 && value !== "__proto__" && value !== "constructor" && value !== "prototype" && !Array.from(value).some(
+    (character) => character.charCodeAt(0) <= 31 || character.charCodeAt(0) === 127
+  );
+}
+function category(value) {
+  return typeof value === "string" && tileflowPoiCategories.some((candidate) => candidate === value);
+}
+function representation(value) {
+  return value === "combined" || value === "icon" || value === "label" || value === "marker";
+}
+function parseManifest(style) {
+  if (nativeInteractionField(style, "version") !== 8) throw new Error();
+  const metadata = nativeInteractionField(style, "metadata");
+  const artifact = snapshotNativeInteractionJson(nativeInteractionField(metadata, "tileflow:interaction-manifest"));
+  if (nativeInteractionField(artifact, "version") !== 2) throw new Error();
+  const poi = nativeInteractionField(nativeInteractionField(artifact, "domains"), "poi");
+  if (nativeInteractionField(poi, "identity") !== "maplibre-feature-id-if-present") throw new Error();
+  const hitTesting = nativeInteractionField(poi, "hitTesting");
+  if (nativeInteractionField(hitTesting, "order") !== "rendered-topmost" || nativeInteractionField(hitTesting, "frequency") !== "animation-frame")
+    throw new Error();
+  const deduplication = nativeInteractionField(poi, "deduplication");
+  const identity = array(nativeInteractionField(deduplication, "identity"), 3);
+  if (identity.length !== 3 || identity[0] !== "source" || identity[1] !== "source-layer" || identity[2] !== "feature-id")
+    throw new Error();
+  const priorityInput = array(nativeInteractionField(deduplication, "representationPriority"), 4);
+  if (priorityInput.length !== 4 || !priorityInput.every(representation) || new Set(priorityInput).size !== 4)
+    throw new Error();
+  const fieldsInput = nativeInteractionField(poi, "fields");
+  const readField = (key) => {
+    const value = nativeInteractionField(fieldsInput, key);
+    if (!name(value)) throw new Error();
+    return value;
+  };
+  const fields = Object.freeze({
+    category: readField("category"),
+    filterRank: readField("filterRank"),
+    icon: readField("icon"),
+    name: readField("name"),
+    sizeRank: readField("sizeRank"),
+    type: readField("type")
+  });
+  const physical = /* @__PURE__ */ new Map();
+  for (const layer of array(nativeInteractionField(style, "layers"), 4096)) {
+    const id = nativeInteractionField(layer, "id");
+    if (!name(id) || physical.has(id)) throw new Error();
+    physical.set(id, layer);
+  }
+  const sources = nativeInteractionField(style, "sources");
+  const inputs = array(nativeInteractionField(poi, "layers"), 256);
+  if (!inputs.length) throw new Error();
+  const layers = [];
+  const ids = /* @__PURE__ */ new Set();
+  let namespace;
+  for (const input of inputs) {
+    const layerId = nativeInteractionField(input, "layerId");
+    const source = nativeInteractionField(input, "source");
+    const sourceLayer = nativeInteractionField(input, "sourceLayer");
+    const layerCategory = nativeInteractionField(input, "category");
+    const kind = nativeInteractionField(input, "representation");
+    const priority = nativeInteractionField(input, "priority");
+    if (!name(layerId) || !name(source) || sourceLayer !== void 0 && !name(sourceLayer) || !category(layerCategory) || !representation(kind) || typeof priority !== "number" || !Number.isSafeInteger(priority) || priority < 0 || priority > 1e5 || ids.has(layerId) || nativeInteractionField(input, "anchor") !== "pointer-coordinate")
+      throw new Error();
+    const actual = physical.get(layerId);
+    if (!actual || nativeInteractionField(actual, "source") !== source || nativeInteractionField(actual, "source-layer") !== sourceLayer)
+      throw new Error();
+    const sourceDefinition = nativeInteractionField(sources, source);
+    if (!sourceDefinition || typeof sourceDefinition !== "object" || Array.isArray(sourceDefinition))
+      throw new Error();
+    if (namespace && (namespace.source !== source || namespace.sourceLayer !== sourceLayer))
+      throw new Error();
+    const layer = Object.freeze({
+      layerId,
+      source,
+      ...sourceLayer === void 0 ? {} : { sourceLayer },
+      category: layerCategory,
+      representation: kind,
+      priority
+    });
+    namespace = layer;
+    ids.add(layerId);
+    layers.push(layer);
+  }
+  return Object.freeze({
+    layers: Object.freeze(layers.sort((left, right) => right.priority - left.priority)),
+    fields,
+    representationPriority: Object.freeze(priorityInput)
+  });
+}
+function featureId(value) {
+  if (typeof value === "number") return Number.isSafeInteger(value) ? value : void 0;
+  return typeof value === "string" && value.length > 0 && value.length <= tileflowInteractionLimits2.maxFeatureIdLength ? value : void 0;
+}
+function properties(input, fields) {
+  const read = (key) => {
+    try {
+      return nativeInteractionField(input, fields[key]);
+    } catch {
+      return void 0;
+    }
+  };
+  const result = {};
+  const c = read("category");
+  if (category(c)) result.category = c;
+  for (const [key, output, max] of [
+    ["filterRank", "filter_rank", 5],
+    ["sizeRank", "size_rank", 16]
+  ]) {
+    const value = read(key);
+    if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= max)
+      result[output] = value;
+  }
+  for (const key of ["name", "type", "icon"]) {
+    const value = read(key);
+    if (typeof value === "string" && value.length <= tileflowInteractionLimits2.maxContentTextLength && (key === "name" || /^[a-z0-9]+(?:_[a-z0-9]+)*$/u.test(value)))
+      result[key] = value;
+  }
+  return Object.freeze(result);
+}
+function choose(features, manifest, bindings, coordinate, queried) {
+  const candidates = [];
+  const byIdentity = /* @__PURE__ */ new Map();
+  const allowed = new Set(queried);
+  for (const [renderedIndex, feature] of features.entries()) {
+    const id = nativeInteractionField(nativeInteractionField(feature, "layer"), "id");
+    const layer = manifest.layers.find((value) => value.layerId === id);
+    if (!layer || !allowed.has(layer.layerId)) continue;
+    if (nativeInteractionField(feature, "source") !== layer.source || nativeInteractionField(feature, "sourceLayer") !== layer.sourceLayer)
+      throw new Error();
+    const binding = bindings.find(
+      (value) => value.target.kind === "semantic-feature" && value.target.domain === "poi" && (!value.target.categories || value.target.categories.includes(layer.category))
+    );
+    if (!binding) continue;
+    const stable = featureId(nativeInteractionField(feature, "id"));
+    const target = freezeNativeInteractionValue({
+      kind: "semantic-feature",
+      domain: "poi",
+      coordinate,
+      bindingId: binding.id,
+      feature: {
+        category: layer.category,
+        ...stable === void 0 ? {} : { id: stable },
+        properties: properties(nativeInteractionField(feature, "properties"), manifest.fields)
+      }
+    });
+    const candidate = { layer, renderedIndex, match: Object.freeze({ binding, target }) };
+    const identity = stable === void 0 ? void 0 : `${typeof stable}:${String(stable)}`;
+    const existingIndex = identity === void 0 ? void 0 : byIdentity.get(identity);
+    if (existingIndex === void 0) {
+      if (identity !== void 0) byIdentity.set(identity, candidates.length);
+      candidates.push(candidate);
+    } else {
+      const existing = candidates[existingIndex];
+      const nextPriority = manifest.representationPriority.indexOf(layer.representation);
+      const oldPriority = manifest.representationPriority.indexOf(existing.layer.representation);
+      if (nextPriority < oldPriority || nextPriority === oldPriority && layer.priority > existing.layer.priority)
+        candidates[existingIndex] = {
+          ...candidate,
+          renderedIndex: Math.min(existing.renderedIndex, renderedIndex)
+        };
+    }
+  }
+  return candidates.sort(
+    (a, b) => a.renderedIndex - b.renderedIndex || b.layer.priority - a.layer.priority
+  )[0]?.match;
+}
+function createNativePoiAdapter() {
+  let disposed = false;
+  let generation = 0;
+  let intent = 0;
+  let lease;
+  let manifest;
+  let pending;
+  const inspect = (candidate, expected) => {
+    const live = () => !disposed && generation === expected && lease === candidate;
+    if (!live()) return "stale";
+    try {
+      const owned = candidate?.isCurrent() === true;
+      return live() && owned ? "current" : "stale";
+    } catch {
+      return live() ? "error" : "stale";
+    }
+  };
+  const stopPending = () => {
+    const job = pending;
+    pending = void 0;
+    if (!job) return;
+    job.live = false;
+    job.resolve(stale);
+    try {
+      job.cancel?.();
+    } catch {
+    }
+  };
+  const cancelQueries = () => {
+    ++intent;
+    stopPending();
+  };
+  return Object.freeze({
+    get available() {
+      const parsed = manifest;
+      return !!parsed && inspect(lease, generation) === "current" && manifest === parsed;
+    },
+    supports(target) {
+      const parsed = manifest;
+      return !!parsed && inspect(lease, generation) === "current" && manifest === parsed && parsed.layers.some((layer) => layer.category === target.feature.category);
+    },
+    replaceStyle(next) {
+      if (disposed) return emptyDiagnostics;
+      const expected = ++generation;
+      manifest = void 0;
+      lease = next;
+      cancelQueries();
+      if (!next || inspect(next, expected) !== "current")
+        return next && generation === expected ? failure().diagnostics : emptyDiagnostics;
+      try {
+        const parsed = parseManifest(next.style);
+        if (inspect(next, expected) === "current") {
+          manifest = parsed;
+          return emptyDiagnostics;
+        }
+      } catch {
+      }
+      return generation === expected ? failure().diagnostics : emptyDiagnostics;
+    },
+    cancelQueries,
+    queryTouch(input, bindingsInput) {
+      const ticket = ++intent;
+      const expected = generation;
+      const invocationIsLive = () => !disposed && intent === ticket && generation === expected;
+      const answer = (value) => Promise.resolve(invocationIsLive() ? value : stale);
+      stopPending();
+      if (!invocationIsLive()) return Promise.resolve(stale);
+      const owner = lease;
+      const selected = manifest;
+      let point;
+      let coordinate;
+      try {
+        if (nativeInteractionField(input, "inputModality") !== "touch") return answer(failure("UNSUPPORTED_MODE"));
+        const p = array(nativeInteractionField(input, "point"), 2);
+        const c = array(nativeInteractionField(input, "coordinate"), 2);
+        if (p.length !== 2 || c.length !== 2 || !p.every(
+          (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1e7
+        ) || !c.every((value) => typeof value === "number" && Number.isFinite(value)) || typeof p[0] !== "number" || typeof p[1] !== "number" || typeof c[0] !== "number" || typeof c[1] !== "number" || c[0] < -180 || c[0] > 180 || c[1] < -90 || c[1] > 90)
+          throw new Error();
+        point = Object.freeze([p[0], p[1]]);
+        coordinate = Object.freeze([c[0], c[1]]);
+      } catch {
+        return answer(failure("INVALID_DOCUMENT"));
+      }
+      const prepared = prepareNativeInteractionInputs({ interactions: bindingsInput });
+      if (prepared.diagnostics.length)
+        return answer(Object.freeze({ status: "error", diagnostics: prepared.diagnostics }));
+      const bindings = prepared.bindings.filter(
+        (binding) => binding.target.kind === "semantic-feature" && binding.target.domain === "poi"
+      );
+      if (!bindings.length)
+        return answer(prepared.bindings.length ? failure("UNSUPPORTED_TARGET") : miss);
+      if (!owner || !selected) return answer(failure());
+      const ownership = inspect(owner, expected);
+      if (ownership !== "current") return answer(ownership === "error" ? failure() : stale);
+      const layers = selected.layers.filter(
+        (layer) => bindings.some(
+          (binding) => binding.target.kind === "semantic-feature" && (!binding.target.categories || binding.target.categories.includes(layer.category))
+        )
+      ).map((layer) => layer.layerId);
+      if (!layers.length) return answer(miss);
+      if (!invocationIsLive()) return Promise.resolve(stale);
+      const request = Object.freeze({
+        point,
+        layers: Object.freeze(layers),
+        limit: nativePoiQueryLimit
+      });
+      let resolve;
+      const result = new Promise((yes) => {
+        resolve = yes;
+      });
+      const job = { live: true, resolve };
+      pending = job;
+      const finish = (value) => {
+        if (!job.live || pending !== job) return;
+        const ownership2 = inspect(owner, expected);
+        if (!job.live || pending !== job) return;
+        pending = void 0;
+        job.live = false;
+        resolve(
+          ownership2 === "error" ? failure() : ownership2 === "current" && invocationIsLive() ? value : stale
+        );
+      };
+      try {
+        const operation = owner.query(request);
+        const cancel = operation.cancel;
+        if (typeof cancel !== "function") throw new Error();
+        let cancelled = false;
+        job.cancel = () => {
+          if (!cancelled) {
+            cancelled = true;
+            cancel.call(operation);
+          }
+        };
+        void Promise.resolve(operation.result).then(
+          (value) => {
+            if (!job.live || pending !== job) return;
+            try {
+              const ownership2 = inspect(owner, expected);
+              if (ownership2 !== "current") {
+                finish(ownership2 === "error" ? failure() : stale);
+                return;
+              }
+              if (nativeInteractionField(value, "request") !== request) throw new Error();
+              const raw = nativeInteractionField(value, "features");
+              const length = Array.isArray(raw) ? Object.getOwnPropertyDescriptor(raw, "length")?.value : void 0;
+              if (typeof length === "number" && length > nativePoiQueryLimit) {
+                finish(failure("LIMIT_EXCEEDED"));
+                return;
+              }
+              const match = choose(
+                array(raw, nativePoiQueryLimit),
+                selected,
+                bindings,
+                coordinate,
+                layers
+              );
+              finish(
+                match ? Object.freeze({ status: "match", match, diagnostics: emptyDiagnostics }) : miss
+              );
+            } catch {
+              finish(failure());
+            }
+          },
+          () => finish(failure())
+        );
+        if (!job.live || pending !== job || inspect(owner, expected) !== "current") {
+          if (pending === job) cancelQueries();
+          else {
+            try {
+              job.cancel();
+            } catch {
+            }
+          }
+        }
+      } catch {
+        finish(failure());
+        try {
+          job.cancel?.();
+        } catch {
+        }
+      }
+      return result;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      ++generation;
+      lease = void 0;
+      manifest = void 0;
+      cancelQueries();
+    }
+  });
+}
+
+// src/native-interaction-owner.ts
+var ignoreFailure = (work) => {
+  try {
+    void Promise.resolve(work()).catch(() => void 0);
+  } catch {
+  }
+};
+function createNativeInteractionOwner(initial = {}, initialCallbacks = {}) {
+  let disposed = false;
+  let transaction = 0;
+  let queryGeneration = 0;
+  let revision = 0;
+  let callbacks = initialCallbacks;
+  let prepared;
+  let styleLease;
+  let styleDiagnostics = [];
+  let runtimeDiagnostics = [];
+  const subscribers = /* @__PURE__ */ new Set();
+  const semantic = createNativePoiAdapter();
+  const empty = prepareNativeInteractionInputs({});
+  let snapshot = Object.freeze({
+    ...empty,
+    revision,
+    plan: planNativeAnnotations([], []),
+    disposed
+  });
+  const live = (version) => !disposed && transaction === version;
+  const activate = (target) => {
+    const value = freezeNativeInteractionValue({
+      type: "target:activate",
+      target,
+      coordinate: target.coordinate,
+      inputModality: "touch",
+      ...target.bindingId === void 0 ? {} : { bindingId: target.bindingId }
+    });
+    ignoreFailure(() => callbacks.onInteractionEvent?.(value));
+  };
+  const commit = (data, plan, version) => {
+    if (!live(version)) return;
+    const previous = snapshot;
+    const diagnostics = [];
+    const semanticBindings = data.bindings.some(
+      (binding) => binding.target.kind === "semantic-feature" && binding.target.domain === "poi"
+    );
+    const unsupported = data.bindings.some(
+      (binding) => binding.target.kind !== "annotation" && (binding.target.kind !== "semantic-feature" || binding.target.domain !== "poi")
+    );
+    for (const diagnostic of [
+      ...data.diagnostics,
+      ...semanticBindings ? styleDiagnostics : [],
+      ...runtimeDiagnostics,
+      ...unsupported ? [nativeInteractionDiagnostic("UNSUPPORTED_TARGET")] : []
+    ])
+      if (!diagnostics.some((value) => value.code === diagnostic.code))
+        diagnostics.push(diagnostic);
+    prepared = data;
+    if (previous.annotations === data.annotations && previous.bindings === data.bindings && nativeInteractionValuesEqual(previous.diagnostics, diagnostics))
+      return;
+    snapshot = Object.freeze({
+      ...data,
+      diagnostics: Object.freeze(diagnostics),
+      revision: ++revision,
+      plan,
+      disposed: false
+    });
+    for (const listener of [...subscribers]) {
+      if (!live(version)) return;
+      if (subscribers.has(listener)) ignoreFailure(listener);
+    }
+    for (const diagnostic of diagnostics) {
+      if (!live(version)) return;
+      if (!previous.diagnostics.some((value) => value.code === diagnostic.code))
+        ignoreFailure(() => callbacks.onDiagnostic?.(diagnostic));
+    }
+  };
+  const report = (code) => {
+    if (disposed || !prepared) return;
+    const version = ++transaction;
+    runtimeDiagnostics = [nativeInteractionDiagnostic(code)];
+    commit(prepared, planNativeAnnotations(prepared.annotations, prepared.annotations), version);
+  };
+  const update = (input) => {
+    if (disposed) return;
+    const inspected = transaction;
+    const next = prepareNativeInteractionInputs(input, prepared);
+    if (!live(inspected)) return;
+    const changed = !prepared || next.annotations !== prepared.annotations || next.bindings !== prepared.bindings;
+    const same = !changed && !runtimeDiagnostics.length && nativeInteractionValuesEqual(next.diagnostics, prepared?.diagnostics);
+    if (same) return;
+    const version = ++transaction;
+    if (changed) {
+      ++queryGeneration;
+      semantic.cancelQueries();
+      if (!live(version)) return;
+    }
+    runtimeDiagnostics = [];
+    commit(next, planNativeAnnotations(prepared?.annotations ?? [], next.annotations), version);
+  };
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    ++transaction;
+    ++queryGeneration;
+    styleLease = void 0;
+    semantic.dispose();
+    subscribers.clear();
+    callbacks = {};
+    snapshot = Object.freeze({
+      ...empty,
+      revision: ++revision,
+      plan: planNativeAnnotations(snapshot.annotations, []),
+      disposed: true
+    });
+    prepared = void 0;
+    styleDiagnostics = [];
+    runtimeDiagnostics = [];
+  };
+  update(initial);
+  return Object.freeze({
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      if (disposed) return () => void 0;
+      if (subscribers.size >= 64) {
+        report("LIMIT_EXCEEDED");
+        return () => void 0;
+      }
+      subscribers.add(listener);
+      return () => {
+        subscribers.delete(listener);
+      };
+    },
+    setCallbacks(next) {
+      if (!disposed) callbacks = next;
+    },
+    update,
+    replaceStyle(next) {
+      if (disposed || !prepared) return;
+      const version = ++transaction;
+      ++queryGeneration;
+      styleLease = next;
+      styleDiagnostics = semantic.replaceStyle(next);
+      if (!live(version)) return;
+      runtimeDiagnostics = [];
+      commit(prepared, planNativeAnnotations(prepared.annotations, prepared.annotations), version);
+    },
+    /** Rotate touch authority only while both leases prove the same still-owned style. */
+    renewTouchLease(next) {
+      if (disposed || !prepared) return false;
+      const inspected = transaction;
+      const previous = styleLease;
+      try {
+        if (!previous || previous.style !== next.style || !previous.isCurrent() || !next.isCurrent())
+          return false;
+      } catch {
+        return false;
+      }
+      if (!live(inspected) || styleLease !== previous) return false;
+      const version = ++transaction;
+      ++queryGeneration;
+      styleLease = next;
+      styleDiagnostics = semantic.replaceStyle(next);
+      if (!live(version)) return false;
+      commit(prepared, planNativeAnnotations(prepared.annotations, prepared.annotations), version);
+      return live(version) && styleLease === next;
+    },
+    activateAnnotation(id, inputModality) {
+      if (disposed || !prepared) return;
+      if (inputModality !== "touch") {
+        report("UNSUPPORTED_MODE");
+        return;
+      }
+      const version = ++transaction;
+      ++queryGeneration;
+      semantic.cancelQueries();
+      if (!live(version)) return;
+      const annotation = prepared.annotations.find((value) => value.id === id);
+      if (!annotation) {
+        report("STALE_TARGET");
+        return;
+      }
+      const binding = prepared.bindings.find(
+        (value) => value.target.kind === "annotation" && value.target.id === id
+      );
+      const target = freezeNativeInteractionValue({
+        kind: "annotation",
+        annotation,
+        coordinate: annotation.coordinate,
+        ...binding ? { bindingId: binding.id } : {}
+      });
+      activate(target);
+    },
+    async activateTouch(input) {
+      if (disposed || !prepared) return;
+      const version = ++transaction;
+      const query = ++queryGeneration;
+      const result = await semantic.queryTouch(
+        input,
+        prepared.bindings.filter((binding) => binding.target.kind === "semantic-feature")
+      );
+      if (!live(version) || query !== queryGeneration || result.status === "stale") return;
+      if (result.status === "error") {
+        if (result.diagnostics[0]) report(result.diagnostics[0].code);
+        return;
+      }
+      if (result.status === "match") activate(result.match.target);
+    },
+    /** Retires only touch intent; application selection remains untouched. */
+    cancelTouch() {
+      if (disposed) return;
+      ++transaction;
+      ++queryGeneration;
+      semantic.cancelQueries();
+    },
+    retireSource: dispose,
+    dispose
+  });
+}
+export {
+  createNativeInteractionOwner
+};