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

package/dist/internal/camera.d.ts

@@ -0,0 +1,65 @@
+import { M as MapView, a as MapViewChangeEvent, b as MapInitialViewInputs, c as MapCameraProps } from '../contract-DWs-lDPo.js';
+import '@maplibre/maplibre-react-native';
+import 'react';
+import 'react-native';
+import '@tileflow/core/native';
+import '@tileflow/interactions';
+
+declare const messages: {
+    readonly CAMERA_INPUT_INVALID: "Expected valid camera ownership and a canonical view.";
+    readonly CAMERA_MODE_CHANGE: "Camera ownership cannot change on a mounted instance.";
+    readonly CAMERA_NOT_MOUNTED: "The camera instance has not been mounted.";
+    readonly CAMERA_DISPOSED: "The camera instance has been disposed.";
+    readonly CAMERA_COMMAND_FAILED: "The camera command could not be applied.";
+};
+/** Internal owner diagnostic, never a forwarded native exception or public renderer event. */
+declare class CameraControllerError extends Error {
+    readonly code: keyof typeof messages;
+    constructor(code: keyof typeof messages);
+}
+type CameraFallbacks = Pick<MapInitialViewInputs, 'mapOptionsView' | 'manifestView'>;
+type CameraPropsSnapshot = Readonly<{
+    mode: 'controlled' | 'initial';
+    view: MapView;
+    onViewChange?: (event: MapViewChangeEvent) => void;
+}>;
+
+/** Identity, not just sequence equality, binds callbacks to one controller instance. */
+type CameraToken = Readonly<{
+    sequence: number;
+}>;
+type CameraCommand = Readonly<{
+    token: CameraToken;
+    view: MapView;
+}>;
+type CameraOperation = {
+    /** Resolve only after this target has been applied. Retired completions are ignored. */
+    finished: Promise<void>;
+    cancel(): void | Promise<void>;
+};
+type CameraPort = {
+    /** The adapter must retire/cancel old commands and classify their observations by token. */
+    apply(command: CameraCommand): CameraOperation;
+};
+/** One pure owner per real native instance. No renderer, source, appearance or scheduling API. */
+declare function createMapCameraController(port: CameraPort, onError?: (error: CameraControllerError) => void): {
+    /** Last canonical observed/acknowledged view; not renderer readiness. */
+    readonly view: MapView | undefined;
+    readonly mode: CameraPropsSnapshot["mode"] | undefined;
+    mount: (input: MapCameraProps, fallbacks?: CameraFallbacks) => void;
+    update: (input: MapCameraProps) => void;
+    startGesture(): CameraToken | undefined;
+    changeGesture(identity: CameraToken, input: MapView): void;
+    endGesture(identity: CameraToken, input: MapView): void;
+    /** Confirm the post-gesture prop commit, after update() has delivered its current props. */
+    settleGesture(identity: CameraToken): void;
+    /** Retire renderer-bound camera epochs without guessing a completion or issuing a replacement. */
+    interrupt(): void;
+    /** Programmatic observations are never public changes, even when their values differ. */
+    observeCommand(identity: CameraToken, input: MapView): void;
+    /** Called explicitly by the renderer owner after replacing style/source on this instance. */
+    restoreAfterStyleChange(): void;
+    dispose(): void;
+};
+
+export { type CameraCommand, CameraControllerError, type CameraOperation, type CameraPort, type CameraToken, createMapCameraController };

package/dist/internal/camera.js

@@ -0,0 +1,325 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/initial-view.ts
+import { resolveTileflowNativeInitialView } from "@tileflow/core/native";
+function resolveMapInitialView(inputs) {
+  return resolveTileflowNativeInitialView(inputs);
+}
+
+// src/camera-input.ts
+var messages = {
+  CAMERA_INPUT_INVALID: "Expected valid camera ownership and a canonical view.",
+  CAMERA_MODE_CHANGE: "Camera ownership cannot change on a mounted instance.",
+  CAMERA_NOT_MOUNTED: "The camera instance has not been mounted.",
+  CAMERA_DISPOSED: "The camera instance has been disposed.",
+  CAMERA_COMMAND_FAILED: "The camera command could not be applied."
+};
+var CameraControllerError = class extends Error {
+  constructor(code) {
+    super(messages[code]);
+    __publicField(this, "code");
+    this.name = "CameraControllerError";
+    this.code = code;
+  }
+};
+var fail = () => {
+  throw new CameraControllerError("CAMERA_INPUT_INVALID");
+};
+function ownRecord(value, allowed) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return fail();
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype) return fail();
+  const keys = Reflect.ownKeys(value);
+  if (keys.length > allowed.length) return fail();
+  const copy = /* @__PURE__ */ Object.create(null);
+  for (const key of keys) {
+    if (typeof key !== "string" || !allowed.includes(key)) return fail();
+    const property = Object.getOwnPropertyDescriptor(value, key);
+    if (!property?.enumerable || !("value" in property)) return fail();
+    copy[key] = property.value;
+  }
+  return copy;
+}
+function requireCompleteView(value) {
+  if (!value || typeof value !== "object") return fail();
+  for (const key of ["center", "zoom", "bearing", "pitch"]) {
+    const property = Object.getOwnPropertyDescriptor(value, key);
+    if (!property || !("value" in property) || property.value === void 0) return fail();
+  }
+}
+function snapshotCameraProps(props, fallbacks = {}) {
+  try {
+    const input = ownRecord(props, ["view", "initialView", "onViewChange"]);
+    const fallback = ownRecord(fallbacks, ["mapOptionsView", "manifestView"]);
+    const controlled = input.view !== void 0;
+    if (controlled && input.initialView !== void 0) return fail();
+    if (input.onViewChange !== void 0 && typeof input.onViewChange !== "function") return fail();
+    if (controlled) {
+      if (typeof input.onViewChange !== "function") return fail();
+      requireCompleteView(input.view);
+    }
+    const view = resolveMapInitialView({
+      view: controlled ? input.view : input.initialView,
+      mapOptionsView: fallback.mapOptionsView,
+      manifestView: fallback.manifestView
+    });
+    return Object.freeze({
+      mode: controlled ? "controlled" : "initial",
+      view,
+      onViewChange: input.onViewChange
+    });
+  } catch {
+    return fail();
+  }
+}
+function snapshotCameraView(view) {
+  try {
+    requireCompleteView(view);
+    return resolveMapInitialView({ view });
+  } catch {
+    return fail();
+  }
+}
+function sameCameraView(left, right) {
+  return left.zoom === right.zoom && left.bearing === right.bearing && left.pitch === right.pitch && left.center[0] === right.center[0] && left.center[1] === right.center[1];
+}
+
+// src/camera-controller.ts
+function createMapCameraController(port, onError = () => void 0) {
+  let apply;
+  try {
+    if (!port || typeof port.apply !== "function" || typeof onError !== "function") {
+      throw new CameraControllerError("CAMERA_INPUT_INVALID");
+    }
+    apply = port.apply.bind(port);
+  } catch {
+    throw new CameraControllerError("CAMERA_INPUT_INVALID");
+  }
+  let report = onError;
+  let mounted = false;
+  let disposed = false;
+  let mode;
+  let props;
+  let live;
+  let gesture;
+  let settlement;
+  let pending;
+  let sequence = 0;
+  let revision = 0;
+  function advance() {
+    if (revision >= Number.MAX_SAFE_INTEGER)
+      throw new CameraControllerError("CAMERA_INPUT_INVALID");
+    return ++revision;
+  }
+  function token() {
+    if (sequence >= Number.MAX_SAFE_INTEGER)
+      throw new CameraControllerError("CAMERA_INPUT_INVALID");
+    return Object.freeze({ sequence: ++sequence });
+  }
+  function assertUsable() {
+    if (disposed) throw new CameraControllerError("CAMERA_DISPOSED");
+  }
+  function notify(event) {
+    const listener = props?.onViewChange;
+    try {
+      void Promise.resolve(listener?.(event)).catch(() => void 0);
+    } catch {
+    }
+  }
+  function retire(run) {
+    if (!run) return;
+    run.retired = true;
+    if (!run.operation || run.cancelled) return;
+    run.cancelled = true;
+    try {
+      void Promise.resolve(run.operation.cancel()).catch(() => void 0);
+    } catch {
+    }
+  }
+  function current(run) {
+    return mounted && !disposed && pending === run && !run.retired;
+  }
+  function failed(run) {
+    if (!current(run)) return;
+    const own = revision;
+    pending = void 0;
+    retire(run);
+    if (disposed || revision !== own) return;
+    try {
+      void Promise.resolve(report?.(new CameraControllerError("CAMERA_COMMAND_FAILED"))).catch(
+        () => void 0
+      );
+    } catch {
+    }
+  }
+  function issue(view, force = false) {
+    if (!mounted || disposed) return;
+    if (!force && pending && sameCameraView(pending.command.view, view)) return;
+    if (!force && !pending && live && sameCameraView(live, view)) return;
+    const run = {
+      command: Object.freeze({ token: token(), view }),
+      retired: false,
+      cancelled: false
+    };
+    const previous = pending;
+    pending = run;
+    retire(previous);
+    if (!current(run)) return;
+    try {
+      const operation = apply(run.command);
+      if (!operation || typeof operation.cancel !== "function") {
+        throw new CameraControllerError("CAMERA_COMMAND_FAILED");
+      }
+      run.operation = operation;
+      const finished = operation.finished;
+      if (!finished || typeof finished.then !== "function") {
+        throw new CameraControllerError("CAMERA_COMMAND_FAILED");
+      }
+      void Promise.resolve(finished).then(
+        () => {
+          if (!current(run)) return;
+          live = run.command.view;
+          pending = void 0;
+        },
+        () => failed(run)
+      );
+      if (!current(run)) retire(run);
+    } catch {
+      if (current(run)) failed(run);
+      else retire(run);
+    }
+  }
+  function reconcile() {
+    if (!disposed && !gesture && !settlement && props?.mode === "controlled") issue(props.view);
+  }
+  function update(input) {
+    assertUsable();
+    if (!mounted) throw new CameraControllerError("CAMERA_NOT_MOUNTED");
+    const own = advance();
+    const next = snapshotCameraProps(input);
+    if (disposed || revision !== own) return;
+    if (next.mode !== mode) throw new CameraControllerError("CAMERA_MODE_CHANGE");
+    props = next;
+    reconcile();
+  }
+  function mount(input, fallbacks = {}) {
+    assertUsable();
+    if (mounted) {
+      update(input);
+      return;
+    }
+    const own = advance();
+    const next = snapshotCameraProps(input, fallbacks);
+    if (disposed || revision !== own) return;
+    mode = next.mode;
+    props = next;
+    live = next.view;
+    mounted = true;
+    issue(next.view, true);
+  }
+  return {
+    /** Last canonical observed/acknowledged view; not renderer readiness. */
+    get view() {
+      return live;
+    },
+    get mode() {
+      return mode;
+    },
+    mount,
+    update,
+    startGesture() {
+      if (!mounted || disposed || !live) return void 0;
+      if (gesture) return gesture.token;
+      advance();
+      const next = { token: token(), lastEmitted: live };
+      gesture = next;
+      settlement = void 0;
+      const previous = pending;
+      pending = void 0;
+      retire(previous);
+      return gesture === next && !disposed ? next.token : void 0;
+    },
+    changeGesture(identity, input) {
+      const active = gesture;
+      if (disposed || !active || active.token !== identity) return;
+      const own = advance();
+      const view = snapshotCameraView(input);
+      if (disposed || gesture !== active || revision !== own) return;
+      live = view;
+      if (sameCameraView(active.lastEmitted, view)) return;
+      active.lastEmitted = view;
+      notify(Object.freeze({ type: "view-change", view }));
+    },
+    endGesture(identity, input) {
+      const active = gesture;
+      if (disposed || !active || active.token !== identity) return;
+      const own = advance();
+      const view = snapshotCameraView(input);
+      if (disposed || gesture !== active || revision !== own) return;
+      live = view;
+      gesture = void 0;
+      const waiting = { token: identity, notifying: true };
+      settlement = waiting;
+      try {
+        if (!sameCameraView(active.lastEmitted, view)) {
+          notify(Object.freeze({ type: "view-change", view }));
+        }
+      } finally {
+        waiting.notifying = false;
+      }
+    },
+    /** Confirm the post-gesture prop commit, after update() has delivered its current props. */
+    settleGesture(identity) {
+      const waiting = settlement;
+      if (disposed || !waiting || waiting.token !== identity || waiting.notifying) return;
+      advance();
+      settlement = void 0;
+      reconcile();
+    },
+    /** Retire renderer-bound camera epochs without guessing a completion or issuing a replacement. */
+    interrupt() {
+      if (!mounted || disposed) return;
+      advance();
+      gesture = void 0;
+      settlement = void 0;
+      const previous = pending;
+      pending = void 0;
+      retire(previous);
+    },
+    /** Programmatic observations are never public changes, even when their values differ. */
+    observeCommand(identity, input) {
+      const run = pending;
+      if (!run || !current(run) || run.command.token !== identity) return;
+      const own = advance();
+      const view = snapshotCameraView(input);
+      if (!current(run) || revision !== own) return;
+      live = view;
+    },
+    /** Called explicitly by the renderer owner after replacing style/source on this instance. */
+    restoreAfterStyleChange() {
+      if (!mounted || disposed || !live || !props) return;
+      advance();
+      const view = props.mode === "controlled" ? props.view : live;
+      gesture = void 0;
+      settlement = void 0;
+      issue(view, true);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      gesture = void 0;
+      settlement = void 0;
+      props = void 0;
+      report = void 0;
+      const previous = pending;
+      pending = void 0;
+      retire(previous);
+    }
+  };
+}
+export {
+  CameraControllerError,
+  createMapCameraController
+};

package/dist/internal/hosted-binding.d.ts

@@ -0,0 +1,18 @@
+import { TileflowNativeSourceState } from '@tileflow/core/native';
+import { HostedNativeSessionBinding } from './session.js';
+
+type MobileConfiguration = Readonly<{
+    apiOrigin: string;
+    credential: string;
+}>;
+
+/**
+ * Private source-to-session boundary, with no network or renderer capability.
+ * Its caller owns the separate session controller and retires it with the real Map.
+ */
+declare function createHostedNativeBindingResolver(readConfiguration: () => Promise<MobileConfiguration>): Readonly<{
+    replace(source: TileflowNativeSourceState): Promise<HostedNativeSessionBinding>;
+    dispose(): void;
+}>;
+
+export { createHostedNativeBindingResolver };

package/dist/internal/hosted-binding.js

@@ -0,0 +1,277 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/mobile-configuration.ts
+var messages = {
+  NATIVE_CONFIGURATION_INVALID: "Native application configuration is invalid.",
+  NATIVE_CONFIGURATION_UNAVAILABLE: "Native application configuration is unavailable.",
+  NATIVE_CONFIGURATION_SOURCE_INVALID: "Hosted source metadata is invalid.",
+  NATIVE_CONFIGURATION_ORIGIN_MISMATCH: "Hosted source origin is not approved by the application.",
+  NATIVE_CONFIGURATION_REPLACED: "Hosted binding resolution was replaced.",
+  NATIVE_CONFIGURATION_DISPOSED: "Hosted binding resolution is disposed."
+};
+var originPattern = /^([Hh][Tt][Tt][Pp][Ss]):\/\/([A-Za-z0-9.-]+)(?::([1-9][0-9]{0,4}))?\/?$/u;
+var NativeConfigurationError = class extends Error {
+  constructor(code) {
+    super(messages[code]);
+    __publicField(this, "code");
+    this.name = "NativeConfigurationError";
+    this.code = code;
+  }
+};
+function invalid() {
+  throw new NativeConfigurationError("NATIVE_CONFIGURATION_INVALID");
+}
+function canonicalMobileApiOrigin(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 2048) return invalid();
+  const match = originPattern.exec(value);
+  if (!match || match[0] !== value) return invalid();
+  const host = match[2].toLowerCase();
+  const labels = host.split(".");
+  if (host.length > 253 || labels.some((label) => !/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/u.test(label))) {
+    return invalid();
+  }
+  const last = labels[labels.length - 1];
+  if (!/^[a-z]/u.test(last)) {
+    if (labels.length !== 4 || labels.some((label) => !/^(?:0|[1-9][0-9]{0,2})$/u.test(label) || Number(label) > 255)) {
+      return invalid();
+    }
+  }
+  const port = match[3] === void 0 ? 443 : Number(match[3]);
+  if (port > 65535) return invalid();
+  return `https://${host}${port === 443 ? "" : `:${port}`}`;
+}
+function configurationRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return invalid();
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return invalid();
+  const keys = Reflect.ownKeys(value);
+  if (keys.length > 32) return invalid();
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const key of keys) {
+    if (typeof key !== "string") return invalid();
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !("value" in descriptor)) return invalid();
+    result[key] = descriptor.value;
+  }
+  return result;
+}
+function snapshotMobileConfiguration(value) {
+  try {
+    const data = configurationRecord(value);
+    if (Object.keys(data).length !== 2 || !Object.hasOwn(data, "apiOrigin") || !Object.hasOwn(data, "credential") || typeof data.credential !== "string" || data.credential.length !== 58 || !/^tf_public_[0-9a-f]{48}$/u.test(data.credential)) {
+      return invalid();
+    }
+    const apiOrigin = canonicalMobileApiOrigin(data.apiOrigin);
+    const snapshot = Object.defineProperties(
+      {},
+      {
+        apiOrigin: { value: apiOrigin },
+        credential: { value: data.credential }
+      }
+    );
+    return Object.freeze(snapshot);
+  } catch {
+    return invalid();
+  }
+}
+
+// src/hosted-manifest-identity.ts
+var mapPattern = /^map_[A-Za-z0-9_-]{16}$/u;
+var themePattern = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/u;
+var revisionPattern = /^[a-f0-9]{64}$/u;
+function record(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error();
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) throw new Error();
+  return value;
+}
+function field(value, name) {
+  const descriptor = Object.getOwnPropertyDescriptor(record(value), name);
+  if (!descriptor) return void 0;
+  if (!descriptor.enumerable || !("value" in descriptor)) throw new Error();
+  return descriptor.value;
+}
+function names(value, maximum) {
+  const keys = Reflect.ownKeys(record(value));
+  if (!keys.length || keys.length > maximum || keys.some((key) => typeof key !== "string"))
+    throw new Error();
+  return keys;
+}
+function reservedManifest(value) {
+  if (typeof value !== "string" || value.length > 2048) throw new Error();
+  return /^https:\/\/[^/?#]+\/maps\/[^/?#]+\/native\//iu.test(decodeURIComponent(value));
+}
+function exactApiOrigin(value) {
+  if (typeof value !== "string" || canonicalMobileApiOrigin(value) !== value) throw new Error();
+  return value;
+}
+function styleVersion(url, origin, mapId, theme) {
+  if (typeof url !== "string" || url.length > 2048) throw new Error();
+  const prefix = `${origin}/maps/${mapId}/native/v`;
+  const suffix = `/${theme}.json`;
+  if (!url.startsWith(prefix) || !url.endsWith(suffix)) throw new Error();
+  const raw = url.slice(prefix.length, -suffix.length);
+  if (!/^[1-9][0-9]{0,15}$/u.test(raw)) throw new Error();
+  const version = Number(raw);
+  if (!Number.isSafeInteger(version)) throw new Error();
+  return version;
+}
+function snapshotHostedNativeManifestIdentity(source) {
+  try {
+    if (field(source, "status") !== "ready") throw new Error();
+    const map = field(source, "map");
+    const mode = field(map, "usageMode");
+    const input = field(source, "source");
+    const sourceUrl = field(input, "manifestUrl");
+    const finalUrl = field(source, "manifestUrl");
+    if (mode === void 0) {
+      if (reservedManifest(sourceUrl) || reservedManifest(finalUrl)) throw new Error();
+      return null;
+    }
+    if (mode !== "session") throw new Error();
+    const mapId = field(map, "mapId");
+    const name = field(map, "name");
+    if (typeof mapId !== "string" || !mapPattern.test(mapId) || typeof name !== "string" || !themePattern.test(name) || name !== field(input, "map"))
+      throw new Error();
+    const apiOrigin = exactApiOrigin(field(map, "apiUrl"));
+    const expected = `${apiOrigin}/maps/${mapId}/native/manifest.json`;
+    if (sourceUrl !== expected || finalUrl !== expected) throw new Error();
+    const manifest = field(source, "manifest");
+    const maps = field(manifest, "maps");
+    if (field(manifest, "version") !== 1 || names(maps, 1)[0] !== name) throw new Error();
+    const declared = field(maps, name);
+    if (field(declared, "mapId") !== mapId || field(declared, "usageMode") !== "session")
+      throw new Error();
+    const rootApi = field(manifest, "apiUrl");
+    const declaredApi = field(declared, "apiUrl") ?? rootApi;
+    if (declaredApi !== apiOrigin || rootApi !== void 0 && rootApi !== apiOrigin)
+      throw new Error();
+    const themes = field(map, "themes");
+    const declaredThemes = field(declared, "themes");
+    const themeNames = names(themes, 64).sort();
+    if (themeNames.join("\0") !== names(declaredThemes, 64).sort().join("\0") || field(map, "defaultTheme") !== field(declared, "defaultTheme"))
+      throw new Error();
+    let deploymentVersion;
+    for (const themeName of themeNames) {
+      if (!themePattern.test(themeName)) throw new Error();
+      const theme2 = field(themes, themeName);
+      const original = field(declaredThemes, themeName);
+      const revision = field(theme2, "revision");
+      const styleUrl = field(theme2, "styleUrl");
+      if (typeof revision !== "string" || !revisionPattern.test(revision) || revision !== field(original, "revision") || styleUrl !== field(original, "styleUrl") || field(theme2, "colorScheme") !== field(original, "colorScheme"))
+        throw new Error();
+      const version = styleVersion(styleUrl, apiOrigin, mapId, themeName);
+      if (deploymentVersion !== void 0 && deploymentVersion !== version) throw new Error();
+      deploymentVersion = version;
+    }
+    const selected = field(source, "theme");
+    const selectedName = field(selected, "name");
+    if (typeof selectedName !== "string" || !themeNames.includes(selectedName)) throw new Error();
+    const theme = field(themes, selectedName);
+    if (field(selected, "styleUrl") !== field(theme, "styleUrl") || field(selected, "revision") !== field(theme, "revision"))
+      throw new Error();
+    return Object.freeze({ mapId, apiOrigin, deploymentVersion });
+  } catch {
+    throw new NativeConfigurationError("NATIVE_CONFIGURATION_SOURCE_INVALID");
+  }
+}
+
+// src/hosted-binding.ts
+function bind(metadata, configuration) {
+  const snapshot = snapshotMobileConfiguration(configuration);
+  if (snapshot.apiOrigin !== metadata.apiOrigin) {
+    throw new NativeConfigurationError("NATIVE_CONFIGURATION_ORIGIN_MISMATCH");
+  }
+  const binding = Object.defineProperties(
+    { kind: "hosted", mapId: metadata.mapId },
+    {
+      apiOrigin: { value: snapshot.apiOrigin },
+      credential: { value: snapshot.credential }
+    }
+  );
+  return Object.freeze(binding);
+}
+function createHostedNativeBindingResolver(readConfiguration) {
+  let disposed = false;
+  let generation = 0;
+  let active;
+  return Object.freeze({
+    replace(source) {
+      if (disposed) {
+        return Promise.reject(new NativeConfigurationError("NATIVE_CONFIGURATION_DISPOSED"));
+      }
+      if (generation >= Number.MAX_SAFE_INTEGER) {
+        return Promise.reject(new NativeConfigurationError("NATIVE_CONFIGURATION_SOURCE_INVALID"));
+      }
+      const sequence = ++generation;
+      let resolve;
+      let reject;
+      const result = new Promise((yes, no) => {
+        resolve = yes;
+        reject = no;
+      });
+      void result.catch(() => void 0);
+      const previous = active;
+      const own = { reject };
+      active = own;
+      const current = () => !disposed && generation === sequence && active === own;
+      previous?.reject(new NativeConfigurationError("NATIVE_CONFIGURATION_REPLACED"));
+      let metadata;
+      try {
+        metadata = snapshotHostedNativeManifestIdentity(source);
+      } catch {
+        if (current()) {
+          active = void 0;
+          reject(new NativeConfigurationError("NATIVE_CONFIGURATION_SOURCE_INVALID"));
+        }
+        return result;
+      }
+      if (!current()) return result;
+      if (!metadata) {
+        active = void 0;
+        resolve(Object.freeze({ kind: "direct" }));
+        return result;
+      }
+      const selected = metadata;
+      void Promise.resolve().then(() => {
+        if (!current()) return void 0;
+        return readConfiguration();
+      }).then((configuration) => {
+        if (!current()) return;
+        const binding = bind(selected, configuration);
+        if (!current()) return;
+        active = void 0;
+        resolve(binding);
+      }).catch((error) => {
+        if (!current()) return;
+        let code;
+        try {
+          if (error && typeof error === "object") {
+            code = Object.getOwnPropertyDescriptor(error, "code")?.value;
+          }
+        } catch {
+        }
+        if (!current()) return;
+        active = void 0;
+        reject(
+          new NativeConfigurationError(
+            code === "NATIVE_CONFIGURATION_INVALID" || code === "NATIVE_CONFIGURATION_ORIGIN_MISMATCH" ? code : "NATIVE_CONFIGURATION_UNAVAILABLE"
+          )
+        );
+      });
+      return result;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      const previous = active;
+      active = void 0;
+      previous?.reject(new NativeConfigurationError("NATIVE_CONFIGURATION_DISPOSED"));
+    }
+  });
+}
+export {
+  createHostedNativeBindingResolver
+};