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

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

@@ -0,0 +1,29 @@
+import { HostedNativeSessionFetch } from './session.js';
+import { N as NativeAdmissionEvent, a as NativeAdmissionResource, b as NativeContextAck, c as NativeAdmissionResult, d as NativeRemovalAck } from '../native-admission-contract-k7LKE1vW.js';
+
+declare function createReactNativeAdmissionTransport(): Readonly<{
+    bridge: Readonly<{
+        subscribe(listener: (event: NativeAdmissionEvent) => void): () => void;
+        install(): Promise<Readonly<{
+            installation: string;
+        }>>;
+        registerContext(installation: string, registration: Readonly<{
+            mapId: string | null;
+            resources: readonly NativeAdmissionResource[];
+        }>): Promise<NativeContextAck>;
+        extendContext?(installation: string, context: string, resources: readonly NativeAdmissionResource[]): Promise<Readonly<{
+            resources: number;
+        }>>;
+        retireContext(installation: string, context: string): Promise<Readonly<{
+            retired: true;
+        }>>;
+        completeBatch(installation: string, context: string, generation: number, batch: string, results: readonly NativeAdmissionResult[]): Promise<Readonly<{
+            accepted: number;
+        }>>;
+        remove(installation: string): Promise<NativeRemovalAck>;
+    }>;
+    fetchForContext: (context: string) => HostedNativeSessionFetch;
+    subscribeLifecycle(listener: (foreground: boolean) => void): () => void;
+}>;
+
+export { createReactNativeAdmissionTransport };

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

@@ -0,0 +1,351 @@
+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-admission-bridge.ts
+import { NativeEventEmitter, NativeModules } from "react-native";
+
+// src/native-admission-url.ts
+import {
+  resolveTileflowNativeManifestUrl,
+  resolveTileflowNativeResourceUrl
+} from "@tileflow/core/native";
+
+// src/native-admission-contract.ts
+var nativeAdmissionLimits = Object.freeze({
+  contexts: 16,
+  resources: 128,
+  queueDepth: 128,
+  batchSize: 8,
+  urlCharacters: 2048,
+  bridgeBytes: 524288,
+  grantCharacters: 24576,
+  waitMs: 3e4,
+  validitySafetyMs: 1e3,
+  redirects: 3,
+  responseBytes: 8388608
+});
+
+// src/native-admission-url.ts
+var isNativeToken = (value) => typeof value === "string" && /^[A-Za-z0-9_.-]{1,96}$/u.test(value) && !value.startsWith("tf_");
+
+// src/native-admission-owner.ts
+var NativeAdmissionError = class extends Error {
+  constructor(code) {
+    super("Native resource admission failed.");
+    __publicField(this, "code");
+    this.name = "NativeAdmissionError";
+    this.code = code;
+  }
+};
+
+// src/native-bootstrap-contract.ts
+var nativeBootstrapLimits = Object.freeze({
+  queueDepth: 32,
+  requestBytes: 2048,
+  responseBytes: 65536,
+  timeoutMs: 3e4
+});
+
+// src/native-admission-wire.ts
+var unavailable = () => new NativeAdmissionError("NATIVE_ADMISSION_UNAVAILABLE");
+var invalid = () => new NativeAdmissionError("NATIVE_ADMISSION_INVALID");
+var cancelled = () => new NativeAdmissionError("NATIVE_ADMISSION_CANCELLED");
+function decodeBoundedBase64(value) {
+  if (typeof value !== "string" || value.length > Math.ceil(nativeBootstrapLimits.responseBytes / 3) * 4 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(value))
+    throw invalid();
+  const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+  const length = value.length / 4 * 3 - padding;
+  if (length > nativeBootstrapLimits.responseBytes) throw invalid();
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  const bytes = new Uint8Array(length);
+  let offset = 0;
+  for (let index = 0; index < value.length; index += 4) {
+    const a = alphabet.indexOf(value[index]);
+    const b = alphabet.indexOf(value[index + 1]);
+    const c = value[index + 2] === "=" ? 0 : alphabet.indexOf(value[index + 2]);
+    const d = value[index + 3] === "=" ? 0 : alphabet.indexOf(value[index + 3]);
+    if (index + 4 === value.length && (padding === 2 && (b & 15) !== 0 || padding === 1 && (c & 3) !== 0))
+      throw invalid();
+    const word = a * 262144 + b * 4096 + c * 64 + d;
+    if (offset < length) bytes[offset++] = word >>> 16 & 255;
+    if (offset < length) bytes[offset++] = word >>> 8 & 255;
+    if (offset < length) bytes[offset++] = word & 255;
+  }
+  return bytes;
+}
+function responseFromWire(reply, isAborted, release) {
+  if (!reply || !Number.isInteger(reply.status) || reply.status < 100 || reply.status > 599 || typeof reply.cacheControl !== "string" || reply.cacheControl.length > 1024)
+    throw invalid();
+  const status = reply.status;
+  const cacheControl = reply.cacheControl;
+  let bytes = decodeBoundedBase64(reply.bodyBase64);
+  let readerTaken = false;
+  let done = false;
+  const clear = () => {
+    bytes.fill(0);
+    bytes = new Uint8Array(0);
+    done = true;
+    release();
+  };
+  const response = Object.freeze({
+    status,
+    headers: Object.freeze({
+      get(name) {
+        return name.toLowerCase() === "cache-control" ? cacheControl : null;
+      }
+    }),
+    body: Object.freeze({
+      getReader() {
+        if (readerTaken) throw invalid();
+        readerTaken = true;
+        return Object.freeze({
+          async read() {
+            if (isAborted()) {
+              clear();
+              throw cancelled();
+            }
+            if (done) return { done: true };
+            done = true;
+            const value = bytes;
+            bytes = new Uint8Array(0);
+            release();
+            return { done: false, value };
+          },
+          cancel: clear
+        });
+      }
+    })
+  });
+  return { response, clear };
+}
+function createNativeAdmissionWire(native, listen) {
+  let installation = null;
+  let sequence = 0;
+  const reservations = /* @__PURE__ */ new Set();
+  const lifecycle = /* @__PURE__ */ new Set();
+  async function safe(action) {
+    try {
+      return await action();
+    } catch {
+      throw unavailable();
+    }
+  }
+  function retireContext(context) {
+    const gate = installation?.contexts.get(context);
+    if (!gate) return;
+    gate.live = false;
+    for (const abort of [...gate.cancel]) abort();
+    installation?.contexts.delete(context);
+  }
+  function retireInstallation() {
+    if (!installation) return;
+    for (const context of [...installation.contexts.keys()]) retireContext(context);
+    installation = null;
+  }
+  function publishLifecycle(foreground) {
+    for (const listener of [...lifecycle]) {
+      try {
+        listener(foreground);
+      } catch {
+      }
+    }
+  }
+  const bridge = Object.freeze({
+    subscribe(listener) {
+      return listen((event) => {
+        if (event && event.installation === installation?.id) {
+          if (event.kind === "retired") retireContext(event.context);
+          if (event.kind === "ownershipLost") retireInstallation();
+          if (event.kind === "lifecycle") {
+            if (!event.foreground) {
+              for (const gate of installation?.contexts.values() ?? [])
+                for (const abort of [...gate.cancel]) abort();
+            }
+            publishLifecycle(event.foreground === true);
+          }
+        }
+        listener(event);
+      });
+    },
+    async install() {
+      const ack = await safe(() => native.install());
+      if (!ack || !isNativeToken(ack.installation)) throw invalid();
+      retireInstallation();
+      installation = { id: ack.installation, contexts: /* @__PURE__ */ new Map() };
+      return Object.freeze({ installation: ack.installation });
+    },
+    registerContext: (id, registration) => safe(() => native.registerContext(id, registration)),
+    extendContext: (id, context, resources) => safe(() => {
+      if (!native.extendContext) throw unavailable();
+      return native.extendContext(id, context, resources);
+    }),
+    retireContext(id, context) {
+      if (id === installation?.id) retireContext(context);
+      return safe(() => native.retireContext(id, context));
+    },
+    completeBatch: (id, context, generation, batch, results) => safe(() => native.completeBatch(id, context, generation, batch, results)),
+    remove(id) {
+      if (id === installation?.id) retireInstallation();
+      return safe(() => native.remove(id));
+    }
+  });
+  function fetchForContext(context) {
+    const installed = installation;
+    if (!installed || !isNativeToken(context)) throw invalid();
+    let gate = installed.contexts.get(context);
+    if (!gate) {
+      if (installed.contexts.size >= nativeAdmissionLimits.contexts) throw unavailable();
+      gate = { live: true, cancel: /* @__PURE__ */ new Set() };
+      installed.contexts.set(context, gate);
+    }
+    const scope = gate;
+    return (url, init) => {
+      const active = () => installation === installed && scope.live && !init.signal.aborted;
+      if (!active()) return Promise.reject(cancelled());
+      if (reservations.size >= nativeBootstrapLimits.queueDepth)
+        return Promise.reject(unavailable());
+      const credential = init.headers["X-Tileflow-Mobile-Client"];
+      if (init.method !== "POST" || init.credentials !== "omit" || typeof init.body !== "string" || init.body.length > nativeBootstrapLimits.requestBytes || typeof credential !== "string" || !/^tf_public_[0-9a-f]{48}$/u.test(credential) || sequence >= Number.MAX_SAFE_INTEGER)
+        return Promise.reject(invalid());
+      const request = `${installed.id}.${++sequence}`;
+      reservations.add(request);
+      return new Promise((resolve, reject) => {
+        let settled = false;
+        let aborted = false;
+        let dispatched = false;
+        let nativeFinished = false;
+        let bodyFinished = true;
+        let clearBody;
+        const cleanup = () => init.signal.removeEventListener("abort", abort);
+        const release = () => {
+          if (!nativeFinished || !bodyFinished) return;
+          reservations.delete(request);
+          scope.cancel.delete(abort);
+          cleanup();
+          clearBody = void 0;
+        };
+        const abort = () => {
+          if (aborted) return;
+          aborted = true;
+          cleanup();
+          clearBody?.();
+          bodyFinished = true;
+          if (dispatched && !nativeFinished)
+            void safe(() => native.cancelBootstrap(installed.id, context, request)).catch(
+              () => void 0
+            );
+          if (!settled) {
+            settled = true;
+            reject(cancelled());
+          }
+          release();
+        };
+        scope.cancel.add(abort);
+        init.signal.addEventListener("abort", abort, { once: true });
+        if (!active()) {
+          nativeFinished = true;
+          abort();
+          return;
+        }
+        let pending;
+        try {
+          dispatched = true;
+          pending = Promise.resolve(
+            native.bootstrap(installed.id, context, request, url, credential, init.body)
+          );
+        } catch {
+          nativeFinished = true;
+          settled = true;
+          cleanup();
+          release();
+          reject(unavailable());
+          return;
+        }
+        pending.then(
+          (reply) => {
+            nativeFinished = true;
+            if (settled) {
+              release();
+              return;
+            }
+            if (!active()) {
+              abort();
+              return;
+            }
+            settled = true;
+            try {
+              const result = responseFromWire(
+                reply,
+                () => aborted || !active(),
+                () => {
+                  bodyFinished = true;
+                  release();
+                }
+              );
+              bodyFinished = false;
+              clearBody = result.clear;
+              resolve(result.response);
+            } catch {
+              release();
+              reject(invalid());
+            }
+          },
+          () => {
+            nativeFinished = true;
+            if (!settled) {
+              settled = true;
+              cleanup();
+              reject(unavailable());
+            }
+            release();
+          }
+        );
+      });
+    };
+  }
+  return Object.freeze({
+    bridge,
+    fetchForContext,
+    subscribeLifecycle(listener) {
+      if (typeof listener !== "function") throw invalid();
+      lifecycle.add(listener);
+      let live = true;
+      return () => {
+        if (!live) return;
+        live = false;
+        lifecycle.delete(listener);
+      };
+    }
+  });
+}
+
+// src/native-admission-bridge.ts
+function createReactNativeAdmissionTransport() {
+  const module = NativeModules.TileflowNativeAdmission;
+  for (const name of [
+    "install",
+    "registerContext",
+    "retireContext",
+    "completeBatch",
+    "remove",
+    "bootstrap",
+    "cancelBootstrap",
+    "addListener",
+    "removeListeners"
+  ]) {
+    if (!module || typeof module[name] !== "function")
+      throw new NativeAdmissionError("NATIVE_ADMISSION_UNAVAILABLE");
+  }
+  const emitter = new NativeEventEmitter(module);
+  return createNativeAdmissionWire(module, (listener) => {
+    const subscription = emitter.addListener(
+      "TileflowNativeAdmissionEvent",
+      (event) => listener(event)
+    );
+    return () => subscription.remove();
+  });
+}
+export {
+  createReactNativeAdmissionTransport
+};

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

@@ -0,0 +1,78 @@
+import { e as NativeAdmissionCode, a as NativeAdmissionResource, f as NativeAdmissionBridge, d as NativeRemovalAck } from '../native-admission-contract-k7LKE1vW.js';
+import { HostedNativeResourcePolicy, createHostedNativeSessionController, HostedNativeSessionFetch, HostedNativeSessionController } from './session.js';
+
+type SessionInput = Parameters<typeof createHostedNativeSessionController>[0];
+type NativeMapAdmissionInput = Omit<SessionInput, 'fetch' | 'sessionIdFactory'> & Readonly<{
+    fetch?: HostedNativeSessionFetch;
+    sessionIdFactory?: () => string;
+    resources: readonly NativeAdmissionResource[];
+    onRetired?: () => void;
+}>;
+type NativeMapAdmission = Readonly<{
+    context: string;
+    generation: number;
+    scope: Readonly<{
+        installation: string;
+        context: string;
+    }>;
+    readonly state: Readonly<{
+        status: 'active' | 'retired';
+        context: string;
+    }>;
+    prepare(): Promise<HostedNativeResourcePolicy | null>;
+    discriminate(url: string): string;
+    discriminateForTest(url: string): string;
+    extendResources(resources: readonly NativeAdmissionResource[]): Promise<Readonly<{
+        resources: number;
+    }>>;
+    retire(): Promise<Readonly<{
+        retired: true;
+    }>>;
+}>;
+declare class NativeAdmissionError extends Error {
+    readonly code: NativeAdmissionCode;
+    constructor(code: NativeAdmissionCode);
+}
+declare function createNativeAdmissionOwner(options: {
+    bridge: NativeAdmissionBridge;
+    sessionFetch?: (context: string) => HostedNativeSessionFetch;
+    createController?: (input: SessionInput) => HostedNativeSessionController;
+    onObservation?: (observation: Readonly<{
+        context: string;
+        status: number;
+    }>) => void;
+}): Readonly<{
+    install: () => Promise<Readonly<{
+        installation: string;
+    }>>;
+    openMap: (input: NativeMapAdmissionInput) => Promise<NativeMapAdmission>;
+    replaceMap(previous: NativeMapAdmission, input: NativeMapAdmissionInput): Promise<Readonly<{
+        context: string;
+        generation: number;
+        scope: Readonly<{
+            installation: string;
+            context: string;
+        }>;
+        readonly state: Readonly<{
+            status: "active" | "retired";
+            context: string;
+        }>;
+        prepare(): Promise<HostedNativeResourcePolicy | null>;
+        discriminate(url: string): string;
+        discriminateForTest(url: string): string;
+        extendResources(resources: readonly NativeAdmissionResource[]): Promise<Readonly<{
+            resources: number;
+        }>>;
+        retire(): Promise<Readonly<{
+            retired: true;
+        }>>;
+    }>>;
+    dispose: () => Promise<NativeRemovalAck>;
+    readonly state: Readonly<{
+        status: "ready" | "error" | "disposed" | "idle" | "installing";
+        contexts: number;
+        pendingRegistrations: number;
+    }>;
+}>;
+
+export { NativeAdmissionError, type NativeMapAdmission, type NativeMapAdmissionInput, createNativeAdmissionOwner };