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

package/dist/internal/native-appearance.d.ts

@@ -0,0 +1,21 @@
+import { y as MapThemeSelection, f as MapColorScheme } from '../contract-DWs-lDPo.js';
+import '@maplibre/maplibre-react-native';
+import 'react';
+import 'react-native';
+import '@tileflow/core/native';
+import '@tileflow/interactions';
+
+type AppearanceState = Readonly<{
+    status: 'available';
+    colorScheme: MapColorScheme;
+}> | Readonly<{
+    status: 'unavailable';
+}>;
+type AppearanceSelection = Readonly<{
+    theme?: MapThemeSelection;
+}>;
+
+/** Internal native boundary. Package import is inert; only a mounted system theme subscribes. */
+declare function observeNativeAppearance(selection: AppearanceSelection, listener: (state: AppearanceState) => void): () => void;
+
+export { observeNativeAppearance };

package/dist/internal/native-appearance.js

@@ -0,0 +1,110 @@
+// src/native-appearance.ts
+import { Appearance } from "react-native";
+
+// src/appearance.ts
+var light = Object.freeze({ status: "available", colorScheme: "light" });
+var dark = Object.freeze({ status: "available", colorScheme: "dark" });
+var unavailable = Object.freeze({ status: "unavailable" });
+function normalize(value) {
+  return value === "light" ? light : value === "dark" ? dark : unavailable;
+}
+function normalizeEvent(value) {
+  try {
+    if (!value || typeof value !== "object") return unavailable;
+    const property = Object.getOwnPropertyDescriptor(value, "colorScheme");
+    return property && "value" in property ? normalize(property.value) : unavailable;
+  } catch {
+    return unavailable;
+  }
+}
+function remove(subscription) {
+  try {
+    subscription?.remove();
+  } catch {
+  }
+}
+function createAppearanceObserver(port) {
+  const listeners = /* @__PURE__ */ new Set();
+  let connection;
+  const notify = (entry, state) => {
+    if (!listeners.has(entry) || entry.last === state) return;
+    entry.last = state;
+    try {
+      void Promise.resolve(entry.notify(state)).catch(() => void 0);
+    } catch {
+    }
+  };
+  const publish = (current, state) => {
+    if (connection !== current || current.closed || current.current === state) return;
+    current.current = state;
+    for (const entry of [...listeners]) {
+      if (connection !== current || current.closed || current.current !== state) break;
+      notify(entry, state);
+    }
+  };
+  const activate = () => {
+    const current = { closed: false, acceptEvents: true, revision: 0 };
+    connection = current;
+    let subscription;
+    try {
+      subscription = port.addChangeListener((event) => {
+        if (connection !== current || current.closed || !current.acceptEvents) return;
+        current.revision++;
+        publish(current, normalizeEvent(event));
+      });
+    } catch {
+      current.acceptEvents = false;
+      publish(current, unavailable);
+      return;
+    }
+    if (connection !== current || current.closed) {
+      remove(subscription);
+      return;
+    }
+    current.subscription = subscription;
+    let initial;
+    try {
+      initial = normalize(port.getColorScheme());
+    } catch {
+      initial = unavailable;
+    }
+    if (current.revision === 0) publish(current, initial);
+  };
+  return {
+    subscribe(selection, listener) {
+      if (selection.theme !== "system") return () => void 0;
+      if (typeof listener !== "function") throw new TypeError("Expected an appearance listener.");
+      const entry = { notify: listener };
+      listeners.add(entry);
+      if (!connection) activate();
+      if (connection?.current) notify(entry, connection.current);
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        listeners.delete(entry);
+        if (listeners.size !== 0) return;
+        const previous = connection;
+        connection = void 0;
+        if (!previous) return;
+        previous.closed = true;
+        previous.acceptEvents = false;
+        const subscription = previous.subscription;
+        previous.subscription = void 0;
+        remove(subscription);
+      };
+    }
+  };
+}
+
+// src/native-appearance.ts
+var observer = createAppearanceObserver({
+  getColorScheme: () => Appearance.getColorScheme(),
+  addChangeListener: (listener) => Appearance.addChangeListener(listener)
+});
+function observeNativeAppearance(selection, listener) {
+  return observer.subscribe(selection, listener);
+}
+export {
+  observeNativeAppearance
+};

package/dist/internal/native-configuration-bridge.d.ts

@@ -0,0 +1,9 @@
+import { HostedNativeSessionBinding } from './session.js';
+import * as _tileflow_core_native from '@tileflow/core/native';
+
+declare function createReactNativeHostedBindingResolver(): Readonly<{
+    replace(source: _tileflow_core_native.TileflowNativeSourceState): Promise<HostedNativeSessionBinding>;
+    dispose(): void;
+}>;
+
+export { createReactNativeHostedBindingResolver };

package/dist/internal/native-configuration-bridge.js

@@ -0,0 +1,343 @@
+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/native-configuration-bridge.ts
+import { NativeModules } from "react-native";
+
+// 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"));
+    }
+  });
+}
+
+// src/native-configuration-reader.ts
+function createNativeConfigurationReader(locate) {
+  let pending;
+  let owner;
+  let read;
+  let failure;
+  const checkOwner = () => {
+    try {
+      if (failure || !owner || locate() !== owner || owner.readConfiguration !== read) {
+        throw new Error();
+      }
+    } catch {
+      failure = "NATIVE_CONFIGURATION_UNAVAILABLE";
+      throw new NativeConfigurationError(failure);
+    }
+  };
+  return Object.freeze({
+    read() {
+      if (!pending) {
+        pending = Promise.resolve().then(() => {
+          const module = locate();
+          if (!module || typeof module !== "object") throw new Error();
+          const method = module.readConfiguration;
+          if (typeof method !== "function") throw new Error();
+          owner = module;
+          read = method;
+          return method.call(owner);
+        }).then((raw) => {
+          checkOwner();
+          return snapshotMobileConfiguration(raw);
+        }).catch((error) => {
+          let code;
+          try {
+            if (error && typeof error === "object") {
+              code = Object.getOwnPropertyDescriptor(error, "code")?.value;
+            }
+          } catch {
+          }
+          failure = code === "NATIVE_CONFIGURATION_INVALID" ? "NATIVE_CONFIGURATION_INVALID" : "NATIVE_CONFIGURATION_UNAVAILABLE";
+          throw new NativeConfigurationError(failure);
+        });
+      }
+      return pending.then(
+        (configuration) => {
+          checkOwner();
+          return configuration;
+        },
+        () => {
+          throw new NativeConfigurationError(failure ?? "NATIVE_CONFIGURATION_UNAVAILABLE");
+        }
+      );
+    }
+  });
+}
+
+// src/native-configuration-bridge.ts
+var applicationConfiguration = createNativeConfigurationReader(
+  () => NativeModules.TileflowNativeConfiguration
+);
+function createReactNativeHostedBindingResolver() {
+  return createHostedNativeBindingResolver(applicationConfiguration.read);
+}
+export {
+  createReactNativeHostedBindingResolver
+};

package/dist/internal/session.d.ts

@@ -0,0 +1,125 @@
+type NativeSessionResourceScope = 'style' | 'tilejson' | 'tile' | 'sprite' | 'glyph' | 'font';
+type HostedNativeSessionBinding = Readonly<{
+    kind: 'hosted';
+    apiOrigin: string;
+    credential: string;
+    mapId: string;
+    surfaceId?: string;
+}> | Readonly<{
+    kind: 'direct';
+}>;
+type HostedNativeSessionAbortSignal = Readonly<{
+    aborted: boolean;
+    addEventListener(type: 'abort', listener: () => void, options?: {
+        once?: boolean;
+    }): void;
+    removeEventListener(type: 'abort', listener: () => void): void;
+}>;
+type HostedNativeSessionFetchInit = Readonly<{
+    body: string;
+    credentials: 'omit';
+    headers: Readonly<Record<string, string>>;
+    method: 'POST';
+    signal: HostedNativeSessionAbortSignal;
+}>;
+type HostedNativeSessionBodyReader = Readonly<{
+    read(): Promise<{
+        done: true;
+        value?: undefined;
+    } | {
+        done: false;
+        value: Uint8Array;
+    }>;
+    cancel(): void | Promise<void>;
+}>;
+type HostedNativeSessionFetchResponse = Readonly<{
+    status: number;
+    headers: Readonly<{
+        get(name: string): string | null;
+    }>;
+    body: Readonly<{
+        getReader(): HostedNativeSessionBodyReader;
+    }> | null;
+}>;
+type HostedNativeSessionFetch = (url: string, init: HostedNativeSessionFetchInit) => Promise<HostedNativeSessionFetchResponse>;
+type HostedNativeSessionErrorCode = 'NATIVE_SESSION_INPUT_INVALID' | 'NATIVE_SESSION_RESPONSE_TOO_LARGE' | 'NATIVE_SESSION_RESPONSE_UTF8_INVALID' | 'NATIVE_SESSION_RESPONSE_JSON_INVALID' | 'NATIVE_SESSION_RESPONSE_INVALID' | 'NATIVE_SESSION_CREDENTIAL_REJECTED' | 'NATIVE_SESSION_MAP_MISMATCH' | 'NATIVE_SESSION_MAP_NOT_FOUND' | 'NATIVE_SESSION_QUOTA_EXCEEDED' | 'NATIVE_SESSION_REJECTED' | 'NATIVE_SESSION_UNAVAILABLE' | 'NATIVE_SESSION_REPLACED' | 'NATIVE_SESSION_DISPOSED';
+type HostedNativeSessionErrorKind = 'terminal' | 'recoverable' | 'cancelled';
+declare class HostedNativeSessionError extends Error {
+    readonly code: HostedNativeSessionErrorCode;
+    readonly kind: HostedNativeSessionErrorKind;
+    constructor(code: HostedNativeSessionErrorCode);
+}
+type HostedNativeSessionAuthority = Readonly<{
+    grant: string;
+    mapId: string;
+    sessionId: string;
+    surfaceId: string;
+    credentialId: string;
+    credentialRevision: number;
+    deliveryPolicyRevision: number;
+    issuedAt: string;
+    serverTime: string;
+    expiresAt: string;
+    meterMode: 'disabled' | 'shadow' | 'enforced';
+    disposition: 'unmetered' | 'ordinary' | 'unbilled_fail_open';
+    resourceOrigins: readonly string[];
+    resourceScopes: readonly NativeSessionResourceScope[];
+    tilesetIds: readonly string[];
+}>;
+/** Private graph classification data; it cannot authorize a resource request. */
+type HostedNativeResourcePolicy = Readonly<Pick<HostedNativeSessionAuthority, 'mapId' | 'resourceOrigins' | 'resourceScopes' | 'tilesetIds'>>;
+type SafeError = Readonly<{
+    code: HostedNativeSessionErrorCode;
+    kind: HostedNativeSessionErrorKind;
+}>;
+type Lifecycle = 'foreground' | 'background';
+type HostedNativeSessionState = Readonly<{
+    status: 'idle';
+    source: 'direct';
+    lifecycle: Lifecycle;
+}> | Readonly<{
+    status: 'idle' | 'loading';
+    source: 'hosted';
+    lifecycle: Lifecycle;
+    mapId: string;
+    sessionId: string;
+}> | Readonly<{
+    status: 'ready';
+    source: 'hosted';
+    lifecycle: Lifecycle;
+    mapId: string;
+    sessionId: string;
+    surfaceId: string;
+    credentialId: string;
+    credentialRevision: number;
+    deliveryPolicyRevision: number;
+}> | Readonly<{
+    status: 'error';
+    source: 'hosted';
+    lifecycle: Lifecycle;
+    mapId: string;
+    sessionId: string;
+    error: SafeError;
+}> | Readonly<{
+    status: 'disposed';
+    lifecycle: 'disposed';
+}>;
+type HostedNativeSessionController = Readonly<{
+    readonly state: HostedNativeSessionState;
+    acquire(): Promise<HostedNativeSessionAuthority | null>;
+    prepare?(): Promise<HostedNativeResourcePolicy | null>;
+    transportBudget(authority: HostedNativeSessionAuthority): number;
+    background(): void;
+    resume(): Promise<void>;
+    replaceBinding(binding: HostedNativeSessionBinding): void;
+    subscribe(listener: (state: HostedNativeSessionState) => void): () => void;
+    dispose(): void;
+}>;
+declare function createHostedNativeSessionController(input: {
+    binding: HostedNativeSessionBinding;
+    fetch: HostedNativeSessionFetch;
+    now: () => Date;
+    sessionIdFactory: () => string;
+}): HostedNativeSessionController;
+
+export { type HostedNativeResourcePolicy, type HostedNativeSessionAbortSignal, type HostedNativeSessionAuthority, type HostedNativeSessionBinding, type HostedNativeSessionBodyReader, type HostedNativeSessionController, HostedNativeSessionError, type HostedNativeSessionErrorCode, type HostedNativeSessionErrorKind, type HostedNativeSessionFetch, type HostedNativeSessionFetchInit, type HostedNativeSessionFetchResponse, type HostedNativeSessionState, type NativeSessionResourceScope, createHostedNativeSessionController };