@necessarysdk/react-native 0.0.0-stage → 0.1.5

package/lib/transport.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * How the SDK's messages reach your backend: by default over HTTPS, under the base URL your app
+ * sets (the public guide, section 4).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpTransport = void 0;
+const errors_1 = require("./errors");
+const release_1 = require("./util/release");
+const target_1 = require("./util/target");
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * JSON over HTTPS under [baseUrl]. A release build refuses any other scheme, so a mistyped
+ * endpoint fails loudly instead of sending tokens in the clear.
+ */
+class HttpTransport {
+    constructor(baseUrl, options = {}) {
+        this.running = new Set();
+        this.closed = false;
+        this.baseUrl = baseUrl;
+        this.timeoutMs = options.timeoutMs ?? 15000;
+        this.fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
+    }
+    get base() {
+        if (this.baseUrl.length === 0) {
+            throw new errors_1.ApiException('No API base URL was set for the backend.', { code: 'api_base_url_missing' });
+        }
+        if ((0, release_1.isReleaseBuild)() && !this.baseUrl.toLowerCase().startsWith('https://')) {
+            throw new errors_1.ApiException('The API base URL must be an https:// URL in a release build.', {
+                code: 'api_base_url_insecure',
+            });
+        }
+        return this.baseUrl.endsWith('/') ? this.baseUrl.substring(0, this.baseUrl.length - 1) : this.baseUrl;
+    }
+    async send(method, path, options = {}) {
+        const url = `${this.base}${(0, target_1.normalizedTarget)(path)}`;
+        if (this.closed) {
+            throw new errors_1.ApiException('HTTP connection failed: the transport is closed.');
+        }
+        const headers = {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+            ...(options.bearerToken != null ? { Authorization: `Bearer ${options.bearerToken}` } : {}),
+            ...(options.headers ?? {}),
+        };
+        const controller = new AbortController();
+        this.running.add(controller);
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, this.timeoutMs);
+        let status;
+        let text;
+        try {
+            const response = await this.fetchImpl(url, {
+                method,
+                headers,
+                body: method === 'GET' ? undefined : options.encodedBody ?? '{}',
+                signal: controller.signal,
+            });
+            status = response.status;
+            text = await response.text();
+        }
+        catch (error) {
+            if (timedOut) {
+                throw new errors_1.ApiException('The server did not respond before the timeout.');
+            }
+            if (this.closed) {
+                throw new errors_1.ApiException('HTTP connection failed: the transport is closed.');
+            }
+            const words = error instanceof Error ? error.message : String(error);
+            throw new errors_1.ApiException(`Network connection failed: ${words}`);
+        }
+        finally {
+            clearTimeout(timer);
+            this.running.delete(controller);
+        }
+        let decoded = {};
+        if (text.trim().length > 0) {
+            let parsed;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+                parsed = undefined;
+            }
+            if (!isObject(parsed)) {
+                throw new errors_1.ApiException('The server returned a non-JSON response.', { statusCode: status });
+            }
+            decoded = parsed;
+        }
+        if (status < 200 || status >= 300) {
+            const error = decoded['error'];
+            const refusal = isObject(error) ? error : null;
+            const details = refusal?.['details'];
+            const message = refusal?.['message'];
+            const code = refusal?.['code'];
+            throw new errors_1.ApiException(typeof message === 'string' ? message : `The server rejected the request (${status}).`, {
+                statusCode: status,
+                code: typeof code === 'string' ? code : undefined,
+                details: isObject(details) ? details : undefined,
+            });
+        }
+        return decoded;
+    }
+    close() {
+        this.closed = true;
+        for (const controller of this.running) {
+            controller.abort();
+        }
+        this.running.clear();
+    }
+}
+exports.HttpTransport = HttpTransport;

package/lib/util/bytes.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Bytes, the same on the phone and in Node: UTF-8, base64url without padding and SHA-256, written
+ * here so that nothing depends on what a JavaScript engine happens to provide.
+ */
+/** The UTF-8 bytes of [text]; a lone surrogate becomes U+FFFD, as every UTF-8 encoder writes it. */
+export declare function utf8Encode(text: string): Uint8Array;
+/** The text of UTF-8 [bytes]; a malformed sequence becomes U+FFFD. */
+export declare function utf8Decode(bytes: Uint8Array): string;
+/** Base64url without padding: how every binary value travels. */
+export declare function base64UrlNoPadding(bytes: Uint8Array | readonly number[]): string;
+/** The bytes of base64url [text], with or without padding; throws on any other character. */
+export declare function base64UrlDecode(text: string): Uint8Array;
+/** The SHA-256 digest of [bytes]. */
+export declare function sha256(bytes: Uint8Array): Uint8Array;
+/** Lowercase hex of [bytes]. */
+export declare function hex(bytes: Uint8Array): string;
+/** The SHA-256 of [text]'s UTF-8 bytes, in lowercase hex. */
+export declare function sha256Hex(text: string): string;

package/lib/util/bytes.js

@@ -0,0 +1,207 @@
+"use strict";
+/**
+ * Bytes, the same on the phone and in Node: UTF-8, base64url without padding and SHA-256, written
+ * here so that nothing depends on what a JavaScript engine happens to provide.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utf8Encode = utf8Encode;
+exports.utf8Decode = utf8Decode;
+exports.base64UrlNoPadding = base64UrlNoPadding;
+exports.base64UrlDecode = base64UrlDecode;
+exports.sha256 = sha256;
+exports.hex = hex;
+exports.sha256Hex = sha256Hex;
+/** The UTF-8 bytes of [text]; a lone surrogate becomes U+FFFD, as every UTF-8 encoder writes it. */
+function utf8Encode(text) {
+    const out = [];
+    for (let i = 0; i < text.length; i++) {
+        let code = text.charCodeAt(i);
+        if (code >= 0xd800 && code <= 0xdbff && i + 1 < text.length) {
+            const next = text.charCodeAt(i + 1);
+            if (next >= 0xdc00 && next <= 0xdfff) {
+                code = 0x10000 + ((code - 0xd800) << 10) + (next - 0xdc00);
+                i++;
+            }
+            else {
+                code = 0xfffd;
+            }
+        }
+        else if (code >= 0xd800 && code <= 0xdfff) {
+            code = 0xfffd;
+        }
+        if (code < 0x80) {
+            out.push(code);
+        }
+        else if (code < 0x800) {
+            out.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
+        }
+        else if (code < 0x10000) {
+            out.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+        }
+        else {
+            out.push(0xf0 | (code >> 18), 0x80 | ((code >> 12) & 0x3f), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+        }
+    }
+    return Uint8Array.from(out);
+}
+/** The text of UTF-8 [bytes]; a malformed sequence becomes U+FFFD. */
+function utf8Decode(bytes) {
+    let out = '';
+    let i = 0;
+    while (i < bytes.length) {
+        const b0 = bytes[i];
+        let code = 0xfffd;
+        let length = 1;
+        if (b0 < 0x80) {
+            code = b0;
+        }
+        else if (b0 >= 0xc2 && b0 < 0xe0 && i + 1 < bytes.length && (bytes[i + 1] & 0xc0) === 0x80) {
+            code = ((b0 & 0x1f) << 6) | (bytes[i + 1] & 0x3f);
+            length = 2;
+        }
+        else if (b0 >= 0xe0 && b0 < 0xf0 && i + 2 < bytes.length &&
+            (bytes[i + 1] & 0xc0) === 0x80 && (bytes[i + 2] & 0xc0) === 0x80) {
+            const value = ((b0 & 0x0f) << 12) | ((bytes[i + 1] & 0x3f) << 6) | (bytes[i + 2] & 0x3f);
+            if (value >= 0x800 && (value < 0xd800 || value > 0xdfff)) {
+                code = value;
+                length = 3;
+            }
+        }
+        else if (b0 >= 0xf0 && b0 < 0xf5 && i + 3 < bytes.length &&
+            (bytes[i + 1] & 0xc0) === 0x80 && (bytes[i + 2] & 0xc0) === 0x80 && (bytes[i + 3] & 0xc0) === 0x80) {
+            const value = ((b0 & 0x07) << 18) | ((bytes[i + 1] & 0x3f) << 12) | ((bytes[i + 2] & 0x3f) << 6) | (bytes[i + 3] & 0x3f);
+            if (value >= 0x10000 && value <= 0x10ffff) {
+                code = value;
+                length = 4;
+            }
+        }
+        if (code > 0xffff) {
+            code -= 0x10000;
+            out += String.fromCharCode(0xd800 + (code >> 10), 0xdc00 + (code & 0x3ff));
+        }
+        else {
+            out += String.fromCharCode(code);
+        }
+        i += length;
+    }
+    return out;
+}
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+/** Base64url without padding: how every binary value travels. */
+function base64UrlNoPadding(bytes) {
+    let out = '';
+    let i = 0;
+    for (; i + 2 < bytes.length; i += 3) {
+        const n = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+        out += ALPHABET[(n >> 18) & 63] + ALPHABET[(n >> 12) & 63] + ALPHABET[(n >> 6) & 63] + ALPHABET[n & 63];
+    }
+    const rest = bytes.length - i;
+    if (rest === 1) {
+        const n = bytes[i] << 16;
+        out += ALPHABET[(n >> 18) & 63] + ALPHABET[(n >> 12) & 63];
+    }
+    else if (rest === 2) {
+        const n = (bytes[i] << 16) | (bytes[i + 1] << 8);
+        out += ALPHABET[(n >> 18) & 63] + ALPHABET[(n >> 12) & 63] + ALPHABET[(n >> 6) & 63];
+    }
+    return out;
+}
+/** The bytes of base64url [text], with or without padding; throws on any other character. */
+function base64UrlDecode(text) {
+    const clean = text.replace(/=+$/, '');
+    const out = [];
+    let buffer = 0;
+    let bits = 0;
+    for (const char of clean) {
+        const value = ALPHABET.indexOf(char === '+' ? '-' : char === '/' ? '_' : char);
+        if (value < 0) {
+            throw new TypeError(`Not base64url: ${JSON.stringify(text)}`);
+        }
+        buffer = (buffer << 6) | value;
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            out.push((buffer >> bits) & 0xff);
+        }
+    }
+    return Uint8Array.from(out);
+}
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+/** The SHA-256 digest of [bytes]. */
+function sha256(bytes) {
+    const h = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const bitLength = bytes.length * 8;
+    const padded = new Uint8Array(((bytes.length + 9 + 63) >> 6) << 6);
+    padded.set(bytes);
+    padded[bytes.length] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.length - 8, Math.floor(bitLength / 0x100000000));
+    view.setUint32(padded.length - 4, bitLength >>> 0);
+    const w = new Uint32Array(64);
+    for (let offset = 0; offset < padded.length; offset += 64) {
+        for (let t = 0; t < 16; t++) {
+            w[t] = view.getUint32(offset + t * 4);
+        }
+        for (let t = 16; t < 64; t++) {
+            const x = w[t - 15];
+            const y = w[t - 2];
+            const s0 = ((x >>> 7) | (x << 25)) ^ ((x >>> 18) | (x << 14)) ^ (x >>> 3);
+            const s1 = ((y >>> 17) | (y << 15)) ^ ((y >>> 19) | (y << 13)) ^ (y >>> 10);
+            w[t] = (w[t - 16] + s0 + w[t - 7] + s1) >>> 0;
+        }
+        let a = h[0], b = h[1], c = h[2], d = h[3], e = h[4], f = h[5], g = h[6], k = h[7];
+        for (let t = 0; t < 64; t++) {
+            const S1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
+            const ch = (e & f) ^ (~e & g);
+            const t1 = (k + S1 + ch + K[t] + w[t]) >>> 0;
+            const S0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const t2 = (S0 + maj) >>> 0;
+            k = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        h[0] = (h[0] + a) >>> 0;
+        h[1] = (h[1] + b) >>> 0;
+        h[2] = (h[2] + c) >>> 0;
+        h[3] = (h[3] + d) >>> 0;
+        h[4] = (h[4] + e) >>> 0;
+        h[5] = (h[5] + f) >>> 0;
+        h[6] = (h[6] + g) >>> 0;
+        h[7] = (h[7] + k) >>> 0;
+    }
+    const out = new Uint8Array(32);
+    const outView = new DataView(out.buffer);
+    for (let i = 0; i < 8; i++) {
+        outView.setUint32(i * 4, h[i]);
+    }
+    return out;
+}
+/** Lowercase hex of [bytes]. */
+function hex(bytes) {
+    let out = '';
+    for (const byte of bytes) {
+        out += (byte < 16 ? '0' : '') + byte.toString(16);
+    }
+    return out;
+}
+/** The SHA-256 of [text]'s UTF-8 bytes, in lowercase hex. */
+function sha256Hex(text) {
+    return hex(sha256(utf8Encode(text)));
+}

package/lib/util/native.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The SDK's native modules, loaded when first used -- so that tests, which replace them, never
+ * load React Native -- and their failures as [NativeKeyException]s.
+ */
+import { NativeKeyException } from '../errors';
+import type { Spec as InstallationKeySpec } from '../native/NativeNecessaryInstallationKey';
+import type { Spec as IntegritySpec } from '../native/NativeNecessaryIntegrity';
+import type { Spec as SecureScreenSpec } from '../native/NativeNecessarySecureScreen';
+import type { Spec as StepUpKeySpec } from '../native/NativeNecessaryStepUpKey';
+import type { Spec as StorageSpec } from '../native/NativeNecessaryStorage';
+export declare function installationKeyModule(): InstallationKeySpec | null;
+export declare function integrityModule(): IntegritySpec | null;
+export declare function stepUpKeyModule(): StepUpKeySpec | null;
+export declare function secureScreenModule(): SecureScreenSpec | null;
+export declare function storageModule(): StorageSpec | null;
+/** The phone's platform, as the guide names it: `android` or `ios`. */
+export declare function currentPlatform(): string;
+/** A native module's refusal, with the code and the words it gave. */
+export declare function nativeFailure(error: unknown, fallback: string): NativeKeyException;
+export declare function isObject(value: unknown): value is Record<string, unknown>;

package/lib/util/native.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * The SDK's native modules, loaded when first used -- so that tests, which replace them, never
+ * load React Native -- and their failures as [NativeKeyException]s.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installationKeyModule = installationKeyModule;
+exports.integrityModule = integrityModule;
+exports.stepUpKeyModule = stepUpKeyModule;
+exports.secureScreenModule = secureScreenModule;
+exports.storageModule = storageModule;
+exports.currentPlatform = currentPlatform;
+exports.nativeFailure = nativeFailure;
+exports.isObject = isObject;
+const errors_1 = require("../errors");
+/* eslint-disable @typescript-eslint/no-require-imports */
+function installationKeyModule() {
+    return require('../native/NativeNecessaryInstallationKey').default ?? null;
+}
+function integrityModule() {
+    return require('../native/NativeNecessaryIntegrity').default ?? null;
+}
+function stepUpKeyModule() {
+    return require('../native/NativeNecessaryStepUpKey').default ?? null;
+}
+function secureScreenModule() {
+    return require('../native/NativeNecessarySecureScreen').default ?? null;
+}
+function storageModule() {
+    return require('../native/NativeNecessaryStorage').default ?? null;
+}
+/** The phone's platform, as the guide names it: `android` or `ios`. */
+function currentPlatform() {
+    return require('react-native').Platform.OS;
+}
+/* eslint-enable @typescript-eslint/no-require-imports */
+/** A native module's refusal, with the code and the words it gave. */
+function nativeFailure(error, fallback) {
+    if (error instanceof errors_1.NativeKeyException) {
+        return error;
+    }
+    const failure = (typeof error === 'object' && error !== null ? error : {});
+    const code = typeof failure.code === 'string' && failure.code.length > 0 ? failure.code : 'NATIVE_ERROR';
+    const message = typeof failure.message === 'string' && failure.message.length > 0 ? failure.message : fallback;
+    return new errors_1.NativeKeyException(code, message);
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/lib/util/release.d.ts

@@ -0,0 +1,2 @@
+/** Whether this is a release build: React Native's `__DEV__` false. Tests in Node have none. */
+export declare function isReleaseBuild(): boolean;

package/lib/util/release.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isReleaseBuild = isReleaseBuild;
+/** Whether this is a release build: React Native's `__DEV__` false. Tests in Node have none. */
+function isReleaseBuild() {
+    return typeof __DEV__ !== 'undefined' && __DEV__ === false;
+}

package/lib/util/target.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A request's target as a proof names it: its path and its query, normalized exactly as the
+ * request is sent -- an escape of an unreserved character decoded, every other escape in upper
+ * case, a character a path or a query may not hold escaped as UTF-8, and dot segments removed.
+ * The transport sends the same normalized target, so what is signed is what is sent.
+ */
+export interface Target {
+    /** The path, without the query. */
+    path: string;
+    /** The query as sent, without its `?`; empty when there is none. */
+    query: string;
+    /** Whether the target has a `?` at all. */
+    hasQuery: boolean;
+}
+/** [target] -- a path with its query, such as `/v1/items?limit=5` -- as a proof names it. */
+export declare function parseTarget(target: string): Target;
+/** [target] as the transport sends it: the same normalized path and query. */
+export declare function normalizedTarget(target: string): string;

package/lib/util/target.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * A request's target as a proof names it: its path and its query, normalized exactly as the
+ * request is sent -- an escape of an unreserved character decoded, every other escape in upper
+ * case, a character a path or a query may not hold escaped as UTF-8, and dot segments removed.
+ * The transport sends the same normalized target, so what is signed is what is sent.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTarget = parseTarget;
+exports.normalizedTarget = normalizedTarget;
+const UNRESERVED = /[A-Za-z0-9\-._~]/;
+const SUB_DELIMS = "!$&'()*+,;=";
+const PATH_EXTRA = ':@/';
+const QUERY_EXTRA = ':@/?';
+function allowed(char, extra) {
+    return UNRESERVED.test(char) || SUB_DELIMS.includes(char) || extra.includes(char);
+}
+function isHex(code) {
+    return (code >= 48 && code <= 57) || (code >= 65 && code <= 70) || (code >= 97 && code <= 102);
+}
+function escapeByte(byte) {
+    return '%' + (byte < 16 ? '0' : '') + byte.toString(16).toUpperCase();
+}
+function escapeCodePoint(code) {
+    const bytes = [];
+    if (code < 0x80) {
+        bytes.push(code);
+    }
+    else if (code < 0x800) {
+        bytes.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
+    }
+    else if (code < 0x10000) {
+        bytes.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+    }
+    else {
+        bytes.push(0xf0 | (code >> 18), 0x80 | ((code >> 12) & 0x3f), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+    }
+    return bytes.map(escapeByte).join('');
+}
+function normalize(component, extra) {
+    let out = '';
+    for (let i = 0; i < component.length; i++) {
+        const char = component[i];
+        const code = component.charCodeAt(i);
+        if (code < 128 && allowed(char, extra)) {
+            out += char;
+        }
+        else if (char === '%') {
+            const valid = i + 2 < component.length &&
+                isHex(component.charCodeAt(i + 1)) && isHex(component.charCodeAt(i + 2));
+            if (!valid) {
+                out += '%25';
+                continue;
+            }
+            const value = parseInt(component.substr(i + 1, 2), 16);
+            const decoded = String.fromCharCode(value);
+            if (UNRESERVED.test(decoded)) {
+                out += decoded;
+            }
+            else {
+                out += component.substr(i, 3).toUpperCase();
+            }
+            i += 2;
+        }
+        else if (code >= 0xd800 && code <= 0xdbff && i + 1 < component.length &&
+            component.charCodeAt(i + 1) >= 0xdc00 && component.charCodeAt(i + 1) <= 0xdfff) {
+            out += escapeCodePoint(0x10000 + ((code - 0xd800) << 10) + (component.charCodeAt(i + 1) - 0xdc00));
+            i++;
+        }
+        else if (code >= 0xd800 && code <= 0xdfff) {
+            out += escapeCodePoint(0xfffd);
+        }
+        else {
+            out += escapeCodePoint(code);
+        }
+    }
+    return out;
+}
+function removeDotSegments(path) {
+    if (!(path.startsWith('.') || path.includes('/.'))) {
+        return path;
+    }
+    const output = [];
+    let appendSlash = false;
+    for (const segment of path.split('/')) {
+        appendSlash = false;
+        if (segment === '..') {
+            if (output.length > 0) {
+                output.pop();
+                if (output.length === 0) {
+                    output.push('');
+                }
+            }
+            appendSlash = true;
+        }
+        else if (segment === '.') {
+            appendSlash = true;
+        }
+        else {
+            output.push(segment);
+        }
+    }
+    if (appendSlash) {
+        output.push('');
+    }
+    return output.join('/');
+}
+/** [target] -- a path with its query, such as `/v1/items?limit=5` -- as a proof names it. */
+function parseTarget(target) {
+    let rest = target;
+    const hash = rest.indexOf('#');
+    if (hash >= 0) {
+        rest = rest.substring(0, hash);
+    }
+    const mark = rest.indexOf('?');
+    const rawPath = mark >= 0 ? rest.substring(0, mark) : rest;
+    const rawQuery = mark >= 0 ? rest.substring(mark + 1) : '';
+    return {
+        path: removeDotSegments(normalize(rawPath, PATH_EXTRA)),
+        query: normalize(rawQuery, QUERY_EXTRA),
+        hasQuery: mark >= 0,
+    };
+}
+/** [target] as the transport sends it: the same normalized path and query. */
+function normalizedTarget(target) {
+    const parsed = parseTarget(target);
+    return parsed.hasQuery ? `${parsed.path}?${parsed.query}` : parsed.path;
+}

package/package.json

@@ -1,6 +1,83 @@
 {
   "name": "@necessarysdk/react-native",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.5",
+  "description": "Device integrity for React Native apps: a key the SDK never exports, signed measurements of the phone and the app, and request proofs. The app's backend decides.",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "react-native": "src/index.ts",
+  "source": "src/index.ts",
+  "files": [
+    "src",
+    "lib",
+    "android/build.gradle",
+    "android/src/main",
+    "ios",
+    "NecessaryReactNative.podspec",
+    "doc",
+    "contract",
+    "vectors",
+    "CHANGELOG.md",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "jest",
+    "prepack": "npm run build"
+  },
+  "keywords": [
+    "react-native",
+    "device-integrity",
+    "device-binding",
+    "proof-of-possession",
+    "secure-enclave",
+    "keystore",
+    "tamper-detection",
+    "necessary"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/merajhasan88/necessary_reactnative.git"
+  },
+  "homepage": "https://necessarysdk.com",
+  "bugs": {
+    "url": "https://github.com/merajhasan88/necessary_reactnative/issues"
+  },
+  "license": "Apache-2.0",
+  "author": "Meraj Hasan",
+  "peerDependencies": {
+    "react-native": ">=0.76.0"
+  },
+  "devDependencies": {
+    "@types/jest": "29.5.14",
+    "@types/node": "^24.19.2",
+    "jest": "29.7.0",
+    "react-native": "0.88.1",
+    "ts-jest": "29.4.15",
+    "typescript": "6.0.3"
+  },
+  "codegenConfig": {
+    "name": "NecessarySpec",
+    "type": "modules",
+    "jsSrcsDir": "src/native",
+    "android": {
+      "javaPackageName": "com.necessarysdk.reactnative"
+    },
+    "ios": {
+      "modulesProvider": {
+        "NecessaryInstallationKey": "NecessaryInstallationKey",
+        "NecessaryIntegrity": "NecessaryIntegrity",
+        "NecessaryStepUpKey": "NecessaryStepUpKey",
+        "NecessarySecureScreen": "NecessarySecureScreen",
+        "NecessaryStorage": "NecessaryStorage"
+      }
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">= 20.19.4"
+  }
+}