@delali/narsil-react-native 0.0.0-stage → 0.3.1-next.146

package/lib/engine/stand-ins/atomics.js

@@ -0,0 +1,236 @@
+const INTEGER_ARRAY_TYPES = [
+    Int8Array,
+    Uint8Array,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    BigInt64Array,
+    BigUint64Array,
+];
+const WAITABLE_ARRAY_TYPES = [Int32Array, BigInt64Array];
+const waitersByBuffer = new WeakMap();
+const NATIVE_LOAD = 0;
+const NATIVE_STORE = 1;
+const NATIVE_ADD = 2;
+const NATIVE_SUB = 3;
+const NATIVE_AND = 4;
+const NATIVE_OR = 5;
+const NATIVE_XOR = 6;
+const NATIVE_EXCHANGE = 7;
+const NATIVE_COMPARE_EXCHANGE = 8;
+let nativeAtomics = null;
+const nativeOwnership = new WeakMap();
+function nativeElementKind(array) {
+    if (array instanceof Int8Array)
+        return 0;
+    if (array instanceof Uint8Array)
+        return 1;
+    if (array instanceof Int16Array)
+        return 2;
+    if (array instanceof Uint16Array)
+        return 3;
+    if (array instanceof Int32Array)
+        return 4;
+    if (array instanceof Uint32Array)
+        return 5;
+    return -1;
+}
+function onNativeMemory(array) {
+    if (nativeAtomics === null)
+        return -1;
+    const kind = nativeElementKind(array);
+    if (kind < 0)
+        return -1;
+    let owned = nativeOwnership.get(array.buffer);
+    if (owned === undefined) {
+        owned = nativeAtomics.ownsMemory(array.buffer);
+        nativeOwnership.set(array.buffer, owned);
+    }
+    return owned ? kind : -1;
+}
+function nativeAtomic(atomics, operation, kind, array, position, value, replacement) {
+    const byteIndex = array.byteOffset + position * array.BYTES_PER_ELEMENT;
+    return atomics.atomic(operation, kind, array.buffer, byteIndex, Number(value), Number(replacement));
+}
+function isOneOf(array, types) {
+    for (const type of types) {
+        if (array instanceof type)
+            return true;
+    }
+    return false;
+}
+function requireIndex(array, index) {
+    const position = Number(index);
+    if (!Number.isInteger(position) || position < 0 || position >= array.length) {
+        throw new RangeError(`Atomics index ${String(index)} lies outside the array of ${array.length} elements`);
+    }
+    return position;
+}
+function requireIntegerArray(array) {
+    if (!isOneOf(array, INTEGER_ARRAY_TYPES))
+        throw new TypeError('Atomics needs an integer typed array');
+    return array;
+}
+function asElement(array, value) {
+    if (array instanceof BigInt64Array || array instanceof BigUint64Array)
+        return BigInt(value);
+    return Number(value);
+}
+function readModifyWrite(array, index, value, operation, combine) {
+    const target = requireIntegerArray(array);
+    const position = requireIndex(target, index);
+    const kind = onNativeMemory(target);
+    if (kind >= 0 && nativeAtomics !== null) {
+        return nativeAtomic(nativeAtomics, operation, kind, target, position, value, 0);
+    }
+    const previous = target[position];
+    target[position] = combine(previous, asElement(target, value));
+    return previous;
+}
+function sameAsStored(array, stored, value) {
+    const scratch = new array.constructor(1);
+    scratch[0] = asElement(array, value);
+    return scratch[0] === stored;
+}
+function waitersAt(array, position) {
+    let byIndex = waitersByBuffer.get(array.buffer);
+    if (byIndex === undefined) {
+        byIndex = new Map();
+        waitersByBuffer.set(array.buffer, byIndex);
+    }
+    const byteIndex = array.byteOffset + position * array.BYTES_PER_ELEMENT;
+    let waiters = byIndex.get(byteIndex);
+    if (waiters === undefined) {
+        waiters = [];
+        byIndex.set(byteIndex, waiters);
+    }
+    return waiters;
+}
+function forgetWaiters(array, position, waiters) {
+    if (waiters.length > 0)
+        return;
+    const byIndex = waitersByBuffer.get(array.buffer);
+    if (byIndex === undefined)
+        return;
+    byIndex.delete(array.byteOffset + position * array.BYTES_PER_ELEMENT);
+    if (byIndex.size === 0)
+        waitersByBuffer.delete(array.buffer);
+}
+function requireWaitable(array, index) {
+    if (!isOneOf(array, WAITABLE_ARRAY_TYPES))
+        throw new TypeError('Atomics waits only on an Int32Array or a BigInt64Array');
+    const target = array;
+    return { target, position: requireIndex(target, index) };
+}
+function waitAsync(array, index, value, timeout) {
+    const { target, position } = requireWaitable(array, index);
+    if (!sameAsStored(target, target[position], value))
+        return { async: false, value: 'not-equal' };
+    const limit = timeout === undefined || Number.isNaN(Number(timeout)) ? Infinity : Math.max(0, Number(timeout));
+    if (limit === 0)
+        return { async: false, value: 'timed-out' };
+    const waiters = waitersAt(target, position);
+    const settled = new Promise(resolve => {
+        let timer;
+        const waiter = {
+            settle(result) {
+                if (timer !== undefined)
+                    clearTimeout(timer);
+                resolve(result);
+            },
+        };
+        waiters.push(waiter);
+        if (Number.isFinite(limit)) {
+            timer = setTimeout(() => {
+                const at = waiters.indexOf(waiter);
+                if (at !== -1)
+                    waiters.splice(at, 1);
+                forgetWaiters(target, position, waiters);
+                resolve('timed-out');
+            }, limit);
+        }
+    });
+    return { async: true, value: settled };
+}
+function notify(array, index, count) {
+    const target = requireIntegerArray(array);
+    const position = requireIndex(target, index);
+    if (!isOneOf(target, WAITABLE_ARRAY_TYPES))
+        return 0;
+    const byIndex = waitersByBuffer.get(target.buffer);
+    const waiters = byIndex?.get(target.byteOffset + position * target.BYTES_PER_ELEMENT);
+    if (waiters === undefined)
+        return 0;
+    const wanted = count === undefined ? waiters.length : Math.max(0, Math.floor(Number(count)));
+    const woken = waiters.splice(0, wanted);
+    forgetWaiters(target, position, waiters);
+    for (const waiter of woken)
+        waiter.settle('ok');
+    return woken.length;
+}
+function wait(array, index, value) {
+    const { target, position } = requireWaitable(array, index);
+    if (!sameAsStored(target, target[position], value))
+        return 'not-equal';
+    throw new TypeError('Atomics.wait would block the only thread of this runtime, so it cannot wait here');
+}
+const standInAtomics = {
+    add: (array, index, value) => readModifyWrite(array, index, value, NATIVE_ADD, (a, b) => a + b),
+    sub: (array, index, value) => readModifyWrite(array, index, value, NATIVE_SUB, (a, b) => a - b),
+    and: (array, index, value) => readModifyWrite(array, index, value, NATIVE_AND, (a, b) => a & b),
+    or: (array, index, value) => readModifyWrite(array, index, value, NATIVE_OR, (a, b) => a | b),
+    xor: (array, index, value) => readModifyWrite(array, index, value, NATIVE_XOR, (a, b) => a ^ b),
+    exchange: (array, index, value) => readModifyWrite(array, index, value, NATIVE_EXCHANGE, (_a, b) => b),
+    compareExchange(array, index, expected, replacement) {
+        const target = requireIntegerArray(array);
+        const position = requireIndex(target, index);
+        const kind = onNativeMemory(target);
+        if (kind >= 0 && nativeAtomics !== null) {
+            return nativeAtomic(nativeAtomics, NATIVE_COMPARE_EXCHANGE, kind, target, position, expected, replacement);
+        }
+        const previous = target[position];
+        if (sameAsStored(target, previous, expected)) {
+            ;
+            target[position] = asElement(target, replacement);
+        }
+        return previous;
+    },
+    load(array, index) {
+        const target = requireIntegerArray(array);
+        const position = requireIndex(target, index);
+        const kind = onNativeMemory(target);
+        if (kind >= 0 && nativeAtomics !== null) {
+            return nativeAtomic(nativeAtomics, NATIVE_LOAD, kind, target, position, 0, 0);
+        }
+        return target[position];
+    },
+    store(array, index, value) {
+        const target = requireIntegerArray(array);
+        const position = requireIndex(target, index);
+        const kind = onNativeMemory(target);
+        if (kind >= 0 && nativeAtomics !== null) {
+            nativeAtomic(nativeAtomics, NATIVE_STORE, kind, target, position, value, 0);
+            return Math.trunc(Number(value));
+        }
+        const element = asElement(target, value);
+        target[position] = element;
+        return typeof element === 'bigint' ? element : Math.trunc(element);
+    },
+    isLockFree: (size) => size === 1 || size === 2 || size === 4 || size === 8,
+    wait,
+    waitAsync,
+    notify,
+    pause: () => { },
+};
+export function installAtomics(native) {
+    if (typeof globalThis.Atomics === 'object')
+        return;
+    nativeAtomics = native;
+    Object.defineProperty(globalThis, 'Atomics', {
+        value: standInAtomics,
+        writable: true,
+        configurable: true,
+        enumerable: false,
+    });
+}

package/lib/engine/stand-ins/crypto.d.ts

@@ -0,0 +1,2 @@
+import type { NarsilHost } from '../../specs/host.nitro';
+export declare function installCrypto(host: NarsilHost): void;

package/lib/engine/stand-ins/crypto.js

@@ -0,0 +1,65 @@
+const MAX_RANDOM_BYTES_PER_CALL = 65_536;
+const UUID_BYTES = 16;
+const UUID_VERSION_BYTE = 6;
+const UUID_VARIANT_BYTE = 8;
+const UUID_HYPHEN_AFTER_BYTES = new Set([4, 6, 8, 10]);
+function isIntegerArray(view) {
+    return (view instanceof Int8Array ||
+        view instanceof Uint8Array ||
+        view instanceof Uint8ClampedArray ||
+        view instanceof Int16Array ||
+        view instanceof Uint16Array ||
+        view instanceof Int32Array ||
+        view instanceof Uint32Array ||
+        view instanceof BigInt64Array ||
+        view instanceof BigUint64Array);
+}
+function namedError(message, name) {
+    const error = new Error(message);
+    error.name = name;
+    return error;
+}
+export function installCrypto(host) {
+    const scope = globalThis;
+    const existing = scope.crypto;
+    if (typeof existing?.getRandomValues === 'function' && typeof existing.randomUUID === 'function')
+        return;
+    function getRandomValues(array) {
+        if (!ArrayBuffer.isView(array) || !isIntegerArray(array)) {
+            throw namedError('getRandomValues fills only an integer typed array', 'TypeMismatchError');
+        }
+        if (array.byteLength > MAX_RANDOM_BYTES_PER_CALL) {
+            throw namedError(`getRandomValues fills at most ${MAX_RANDOM_BYTES_PER_CALL} bytes per call, not ${array.byteLength}`, 'QuotaExceededError');
+        }
+        host.fillRandom(array.buffer, array.byteOffset, array.byteLength);
+        return array;
+    }
+    function randomUUID() {
+        const bytes = new Uint8Array(UUID_BYTES);
+        host.fillRandom(bytes.buffer, 0, UUID_BYTES);
+        bytes[UUID_VERSION_BYTE] = ((bytes[UUID_VERSION_BYTE] ?? 0) & 0x0f) | 0x40;
+        bytes[UUID_VARIANT_BYTE] = ((bytes[UUID_VARIANT_BYTE] ?? 0) & 0x3f) | 0x80;
+        let text = '';
+        for (let index = 0; index < UUID_BYTES; index++) {
+            if (UUID_HYPHEN_AFTER_BYTES.has(index))
+                text += '-';
+            text += (bytes[index] ?? 0).toString(16).padStart(2, '0');
+        }
+        return text;
+    }
+    const crypto = existing ?? {};
+    if (typeof crypto.getRandomValues !== 'function') {
+        Object.defineProperty(crypto, 'getRandomValues', { value: getRandomValues, writable: true, configurable: true });
+    }
+    if (typeof crypto.randomUUID !== 'function') {
+        Object.defineProperty(crypto, 'randomUUID', { value: randomUUID, writable: true, configurable: true });
+    }
+    if (existing === undefined) {
+        Object.defineProperty(globalThis, 'crypto', {
+            value: crypto,
+            writable: true,
+            configurable: true,
+            enumerable: false,
+        });
+    }
+}

package/lib/engine/stand-ins/process.d.ts

@@ -0,0 +1,2 @@
+import type { NarsilHost } from '../../specs/host.nitro';
+export declare function installProcess(host: NarsilHost): void;

package/lib/engine/stand-ins/process.js

@@ -0,0 +1,22 @@
+const MILLISECONDS_PER_SECOND = 1_000;
+export function installProcess(host) {
+    const scope = globalThis;
+    const existing = scope.process;
+    const processInfo = existing ?? {};
+    if (typeof processInfo.pid !== 'number') {
+        Object.defineProperty(processInfo, 'pid', { value: host.processId(), writable: true, configurable: true });
+    }
+    if (typeof processInfo.uptime !== 'function') {
+        const startedAtMs = host.processStartedAtMs();
+        const uptime = () => Math.max(0, Date.now() - startedAtMs) / MILLISECONDS_PER_SECOND;
+        Object.defineProperty(processInfo, 'uptime', { value: uptime, writable: true, configurable: true });
+    }
+    if (existing === undefined) {
+        Object.defineProperty(globalThis, 'process', {
+            value: processInfo,
+            writable: true,
+            configurable: true,
+            enumerable: false,
+        });
+    }
+}

package/lib/engine/stand-ins/streams.d.ts

@@ -0,0 +1 @@
+export declare function installStreams(): void;

package/lib/engine/stand-ins/streams.js

@@ -0,0 +1,31 @@
+import { ByteLengthQueuingStrategy, CountQueuingStrategy, ReadableByteStreamController, ReadableStream, ReadableStreamBYOBReader, ReadableStreamBYOBRequest, ReadableStreamDefaultController, ReadableStreamDefaultReader, TransformStream, TransformStreamDefaultController, WritableStream, WritableStreamDefaultController, WritableStreamDefaultWriter, } from 'web-streams-polyfill';
+const STREAM_CLASSES = {
+    ByteLengthQueuingStrategy,
+    CountQueuingStrategy,
+    ReadableByteStreamController,
+    ReadableStream,
+    ReadableStreamBYOBReader,
+    ReadableStreamBYOBRequest,
+    ReadableStreamDefaultController,
+    ReadableStreamDefaultReader,
+    TransformStream,
+    TransformStreamDefaultController,
+    WritableStream,
+    WritableStreamDefaultController,
+    WritableStreamDefaultWriter,
+};
+export function installStreams() {
+    const scope = globalThis;
+    if (typeof scope.ReadableStream === 'function')
+        return;
+    for (const [name, streamClass] of Object.entries(STREAM_CLASSES)) {
+        if (scope[name] !== undefined)
+            continue;
+        Object.defineProperty(globalThis, name, {
+            value: streamClass,
+            writable: true,
+            configurable: true,
+            enumerable: false,
+        });
+    }
+}

package/lib/engine/stand-ins/structured-clone.d.ts

@@ -0,0 +1 @@
+export declare function installStructuredClone(): void;

package/lib/engine/stand-ins/structured-clone.js

@@ -0,0 +1,121 @@
+const ERROR_CONSTRUCTORS = {
+    Error,
+    EvalError,
+    RangeError,
+    ReferenceError,
+    SyntaxError,
+    TypeError,
+    URIError,
+};
+function dataCloneError(message) {
+    const DomException = globalThis.DOMException;
+    if (DomException !== undefined)
+        return new DomException(message, 'DataCloneError');
+    const error = new Error(message);
+    error.name = 'DataCloneError';
+    return error;
+}
+function typedArrayConstructorOf(view) {
+    const viewType = view.constructor;
+    if (typeof viewType !== 'function')
+        return null;
+    const scope = globalThis;
+    const name = viewType.name;
+    if (typeof name !== 'string' || scope[name] !== viewType)
+        return null;
+    return viewType;
+}
+function cloneValue(value, memory) {
+    if (typeof value === 'symbol')
+        throw dataCloneError('A symbol cannot be cloned');
+    if (typeof value === 'function')
+        throw dataCloneError('A function cannot be cloned');
+    if (value === null || typeof value !== 'object')
+        return value;
+    const remembered = memory.get(value);
+    if (remembered !== undefined || memory.has(value))
+        return remembered;
+    if (value instanceof Date) {
+        const copy = new Date(value.getTime());
+        memory.set(value, copy);
+        return copy;
+    }
+    if (value instanceof RegExp) {
+        const copy = new RegExp(value.source, value.flags);
+        memory.set(value, copy);
+        return copy;
+    }
+    if (value instanceof Boolean || value instanceof Number || value instanceof String) {
+        const copy = Object(value.valueOf());
+        memory.set(value, copy);
+        return copy;
+    }
+    if (typeof BigInt !== 'undefined' && Object.prototype.toString.call(value) === '[object BigInt]') {
+        const copy = Object(value.valueOf());
+        memory.set(value, copy);
+        return copy;
+    }
+    if (value instanceof ArrayBuffer) {
+        const copy = value.slice(0, value.byteLength);
+        memory.set(value, copy);
+        return copy;
+    }
+    if (ArrayBuffer.isView(value)) {
+        const buffer = cloneValue(value.buffer, memory);
+        if (value instanceof DataView) {
+            const copy = new DataView(buffer, value.byteOffset, value.byteLength);
+            memory.set(value, copy);
+            return copy;
+        }
+        const ViewType = typedArrayConstructorOf(value);
+        if (ViewType === null)
+            throw dataCloneError('This kind of array buffer view cannot be cloned');
+        const length = value.length;
+        const copy = new ViewType(buffer, value.byteOffset, length);
+        memory.set(value, copy);
+        return copy;
+    }
+    if (value instanceof Map) {
+        const copy = new Map();
+        memory.set(value, copy);
+        for (const [key, entry] of value)
+            copy.set(cloneValue(key, memory), cloneValue(entry, memory));
+        return copy;
+    }
+    if (value instanceof Set) {
+        const copy = new Set();
+        memory.set(value, copy);
+        for (const entry of value)
+            copy.add(cloneValue(entry, memory));
+        return copy;
+    }
+    if (value instanceof Error) {
+        const ErrorType = ERROR_CONSTRUCTORS[value.name] ?? Error;
+        const copy = new ErrorType(value.message);
+        memory.set(value, copy);
+        if (typeof value.stack === 'string')
+            copy.stack = value.stack;
+        if ('cause' in value)
+            copy.cause = cloneValue(value.cause, memory);
+        return copy;
+    }
+    const copy = (Array.isArray(value) ? new Array(value.length) : {});
+    memory.set(value, copy);
+    for (const key of Object.keys(value)) {
+        copy[key] = cloneValue(value[key], memory);
+    }
+    return copy;
+}
+function structuredCloneStandIn(value) {
+    return cloneValue(value, new Map());
+}
+export function installStructuredClone() {
+    if (typeof globalThis.structuredClone === 'function')
+        return;
+    Object.defineProperty(globalThis, 'structuredClone', {
+        value: structuredCloneStandIn,
+        writable: true,
+        configurable: true,
+        enumerable: false,
+    });
+}

package/lib/engine/streamed.d.ts

@@ -0,0 +1,6 @@
+import type { DurabilityConfig, Narsil, NarsilConfig, ReactNativeHost } from '@delali/narsil';
+import type { StreamedMethod } from '../methods';
+export declare function withPhoneDurability<T extends {
+    durability?: DurabilityConfig | null;
+}>(config: T, durabilitySetElsewhere?: boolean): Omit<T, 'durability'> & Pick<NarsilConfig, 'durability'>;
+export declare function callStreamed(narsil: Narsil, host: ReactNativeHost, method: StreamedMethod, args: readonly unknown[]): Promise<unknown>;

package/lib/engine/streamed.js

@@ -0,0 +1,29 @@
+import { DEFAULT_DURABILITY_DIRECTORY } from '../constants';
+import { collectStream, fileChunks, resolveAppPath, writeStreamToFile } from './byte-files';
+export function withPhoneDurability(config, durabilitySetElsewhere = false) {
+    const { durability, ...rest } = config;
+    if (durability === null || durabilitySetElsewhere)
+        return rest;
+    return { ...rest, durability: { directory: DEFAULT_DURABILITY_DIRECTORY, ...durability } };
+}
+export function callStreamed(narsil, host, method, args) {
+    const indexName = args[0];
+    switch (method) {
+        case 'snapshot':
+            return narsil.snapshot(indexName).then(collectStream);
+        case 'exportDocuments':
+            return narsil.exportDocuments(indexName).then(collectStream);
+        case 'snapshotToFile':
+            return narsil
+                .snapshot(indexName)
+                .then(stream => writeStreamToFile(host.files, stream, resolveAppPath(host, args[1])));
+        case 'exportDocumentsToFile':
+            return narsil
+                .exportDocuments(indexName)
+                .then(stream => writeStreamToFile(host.files, stream, resolveAppPath(host, args[1])));
+        case 'restoreFromFile':
+            return narsil.restore(indexName, fileChunks(host.files, resolveAppPath(host, args[1])));
+        case 'importDocumentExportFromFile':
+            return narsil.importDocumentExport(indexName, fileChunks(host.files, resolveAppPath(host, args[1])));
+    }
+}

package/lib/engine/transfer.d.ts

@@ -0,0 +1,3 @@
+import type { TransferredError } from '../transferred';
+export declare function transferredError(error: unknown, seen?: Map<object, unknown>): TransferredError;
+export declare function transferable(value: unknown, seen?: Map<object, unknown>): unknown;

package/lib/engine/transfer.js

@@ -0,0 +1,77 @@
+function isPlainObject(value) {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function viewCopy(view) {
+    if (view.byteOffset === 0 && view.byteLength === view.buffer.byteLength)
+        return view;
+    const copy = new Uint8Array(view.byteLength);
+    copy.set(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+    if (view instanceof DataView)
+        return new DataView(copy.buffer);
+    const Constructor = view.constructor;
+    return new Constructor(copy.buffer);
+}
+export function transferredError(error, seen = new Map()) {
+    if (!(error instanceof Error)) {
+        return { transferredError: true, name: 'Error', message: String(error), code: undefined, details: undefined };
+    }
+    const coded = error;
+    return {
+        transferredError: true,
+        name: error.name,
+        message: error.message,
+        code: typeof coded.code === 'string' ? coded.code : undefined,
+        details: coded.details === undefined ? undefined : transferable(coded.details, seen),
+    };
+}
+export function transferable(value, seen = new Map()) {
+    if (value === null || typeof value !== 'object')
+        return typeof value === 'function' ? undefined : value;
+    const known = seen.get(value);
+    if (known !== undefined)
+        return known;
+    if (ArrayBuffer.isView(value)) {
+        const copy = viewCopy(value);
+        seen.set(value, copy);
+        return copy;
+    }
+    if (value instanceof Error) {
+        const copy = transferredError(value, seen);
+        seen.set(value, copy);
+        return copy;
+    }
+    if (Array.isArray(value)) {
+        const copy = new Array(value.length);
+        seen.set(value, copy);
+        for (let index = 0; index < value.length; index++)
+            copy[index] = transferable(value[index], seen);
+        return copy;
+    }
+    if (value instanceof Map) {
+        const copy = new Map();
+        seen.set(value, copy);
+        for (const [key, entry] of value)
+            copy.set(transferable(key, seen), transferable(entry, seen));
+        return copy;
+    }
+    if (value instanceof Set) {
+        const copy = new Set();
+        seen.set(value, copy);
+        for (const entry of value)
+            copy.add(transferable(entry, seen));
+        return copy;
+    }
+    if (value instanceof Date || value instanceof RegExp || value instanceof ArrayBuffer)
+        return value;
+    if (!isPlainObject(value))
+        return value;
+    const copy = {};
+    seen.set(value, copy);
+    for (const key of Object.keys(value)) {
+        const entry = transferable(value[key], seen);
+        if (entry !== undefined)
+            copy[key] = entry;
+    }
+    return copy;
+}

package/lib/errors.d.ts

@@ -0,0 +1,25 @@
+import { type TransferredError } from './transferred';
+/**
+ * An error that the engine raised, as it reaches the app's JS thread. `code`
+ * holds the engine's error code, such as `INDEX_NOT_FOUND`, and `details`
+ * holds the values behind the failure.
+ *
+ * @public
+ */
+export interface PhoneNarsilError extends Error {
+    readonly code: string;
+    readonly details: Record<string, unknown>;
+}
+/**
+ * Reports whether a value is an error that the Narsil engine raised, whether
+ * it reached the app from the engine's runtime or from this package.
+ *
+ * @param value - Anything that a rejected promise or a `catch` block holds.
+ * @returns True when the value carries a Narsil error code.
+ *
+ * @public
+ */
+export declare function isNarsilError(value: unknown): value is PhoneNarsilError;
+export declare function nativeDependencyMissing(cause: unknown): PhoneNarsilError;
+export declare function rebuiltError(transferred: TransferredError): Error;
+export declare function rebuiltValue(value: unknown): unknown;