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

package/lib/engine/core.js

@@ -0,0 +1,113 @@
+import { withNativeCode } from './native-error';
+const ABSENT_REGION = { buffer: new ArrayBuffer(0), byteOffset: 0, byteLength: 0 };
+function viewOf(array) {
+    return { buffer: array.buffer, byteOffset: array.byteOffset, byteLength: array.byteLength };
+}
+function graphMemoryOf(memory) {
+    return {
+        graphHeader: viewOf(memory.graphHeader),
+        nodeLevels: viewOf(memory.nodeLevels),
+        level0: viewOf(memory.level0),
+        upperBase: viewOf(memory.upperBase),
+        upper: viewOf(memory.upper),
+        locks: viewOf(memory.locks),
+        tombstones: viewOf(memory.tombstones),
+        incoming: viewOf(memory.incoming),
+        nearestLinkDue: viewOf(memory.nearestLinkDue),
+        heldLocks: viewOf(memory.heldLocks),
+    };
+}
+function storeMemoryOf(memory) {
+    return {
+        storeHeader: viewOf(memory.storeHeader),
+        dimension: memory.dimension,
+        bits: memory.bits,
+        recordsPerBlock: memory.recordsPerBlock,
+        vectorsPerBlock: memory.vectorsPerBlock,
+        vectorStrideBytes: memory.vectorStrideBytes,
+        codePresent: viewOf(memory.codePresent),
+        centroid: viewOf(memory.centroid),
+        magnitudes: viewOf(memory.magnitudes),
+        present: viewOf(memory.present),
+        vectorFile: viewOf(memory.vectorFile),
+        vectorOffset: viewOf(memory.vectorOffset),
+        vectorFiles: memory.vectorFiles,
+        codeBlocks: memory.codeBlocks.map(viewOf),
+        vectorBlocks: memory.vectorBlocks.map(block => (block === null ? ABSENT_REGION : viewOf(block))),
+    };
+}
+function graphOf(handle) {
+    return handle;
+}
+function storeOf(handle) {
+    return handle;
+}
+function backgroundCalls(core) {
+    return {
+        async connectUnreachedAsync(graph, store, metric, nearby, threadSlot) {
+            try {
+                const outcome = await core.connectUnreachedAsync(graphOf(graph), storeOf(store), metric, viewOf(nearby), threadSlot);
+                return { status: outcome.status, wakes: new Int32Array(outcome.wakes) };
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        async searchAsync(graph, store, query, metric, candidateCount, threadSlot, accepted) {
+            try {
+                const hits = await core.searchAsync(graphOf(graph), storeOf(store), viewOf(query), metric, candidateCount, threadSlot, accepted === null ? ABSENT_REGION : viewOf(accepted), accepted !== null);
+                return {
+                    count: hits.count,
+                    ordinals: new Int32Array(hits.ordinals),
+                    distances: new Float64Array(hits.distances),
+                };
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        async scoreAsync(store, query, metric, ordinals, count, threadSlot) {
+            try {
+                const scores = await core.scoreAsync(storeOf(store), viewOf(query), metric, viewOf(ordinals), count, threadSlot);
+                return { status: scores.status, distances: new Float64Array(scores.distances) };
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+    };
+}
+export function adaptCore(core, nativeThreads) {
+    return {
+        abiVersion: () => core.abiVersion(),
+        workspaceBytes: () => core.workspaceBytes(),
+        attachGraph(memory) {
+            try {
+                return core.attachGraph(graphMemoryOf(memory));
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        attachStore(memory) {
+            try {
+                return core.attachStore(storeMemoryOf(memory));
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        detachStore: store => storeOf(store).detach(),
+        search(graph, store, query, metric, candidateCount, threadSlot, ordinals, distances, accepted) {
+            return core.search(graphOf(graph), storeOf(store), viewOf(query), metric, candidateCount, threadSlot, viewOf(ordinals), viewOf(distances), accepted === null ? ABSENT_REGION : viewOf(accepted), accepted !== null);
+        },
+        score: (store, query, metric, ordinals, count, distances) => core.score(storeOf(store), viewOf(query), metric, viewOf(ordinals), count, viewOf(distances)),
+        ...(nativeThreads ? backgroundCalls(core) : {}),
+        place: (graph, store, metric, ordinal, topLayer, graphHeldAlone, threadSlot, wakes) => core.place(graphOf(graph), storeOf(store), metric, ordinal, topLayer, graphHeldAlone, threadSlot, viewOf(wakes)),
+        remove: (graph, ordinal, threadSlot, wakes) => core.remove(graphOf(graph), ordinal, threadSlot, viewOf(wakes)),
+        compact: (graph, store, metric, threadSlot, wakes) => core.compact(graphOf(graph), storeOf(store), metric, threadSlot, viewOf(wakes)),
+        connectUnreached: (graph, store, metric, nearby, threadSlot, wakes) => core.connectUnreached(graphOf(graph), storeOf(store), metric, viewOf(nearby), threadSlot, viewOf(wakes)),
+        measure: (store, metric, ordinals, count, totals) => core.measure(storeOf(store), metric, viewOf(ordinals), count, viewOf(totals)),
+        quantise: (store, metric, ordinals, count) => core.quantise(storeOf(store), metric, viewOf(ordinals), count),
+    };
+}

package/lib/engine/files.d.ts

@@ -0,0 +1,3 @@
+import type { ReactNativeFiles } from '@delali/narsil';
+import type { NarsilFiles } from '../specs/files.nitro';
+export declare function adaptFiles(files: NarsilFiles, nativeThreads: boolean): ReactNativeFiles;

package/lib/engine/files.js

@@ -0,0 +1,188 @@
+import { withNativeCode } from './native-error';
+function rejectedWithNativeCode(error) {
+    return Promise.reject(withNativeCode(error));
+}
+function blockingFiles(files) {
+    return {
+        open(path, flags) {
+            try {
+                return files.open(path, flags);
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        close(descriptor) {
+            try {
+                files.close(descriptor);
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        read(descriptor, target, position) {
+            try {
+                return files.read(descriptor, target.buffer, target.byteOffset, target.byteLength, position);
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        write(descriptor, source, position) {
+            try {
+                return files.write(descriptor, source.buffer, source.byteOffset, source.byteLength, position);
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        sync(descriptor) {
+            try {
+                files.sync(descriptor);
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        truncate(descriptor, byteLength) {
+            try {
+                files.truncate(descriptor, byteLength);
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        descriptorStatus(descriptor) {
+            try {
+                return files.descriptorStatus(descriptor);
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        pathStatus(path) {
+            try {
+                return files.pathStatus(path);
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        makeDirectory(path) {
+            try {
+                files.makeDirectory(path);
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        readDirectory(path) {
+            try {
+                return files.readDirectory(path);
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        rename(from, to) {
+            try {
+                files.rename(from, to);
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        unlink(path) {
+            try {
+                files.unlink(path);
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        removeDirectory(path) {
+            try {
+                files.removeDirectory(path);
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        link(existingPath, newPath) {
+            try {
+                files.link(existingPath, newPath);
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+    };
+}
+function onTheCallingThread(blocking) {
+    return {
+        ...blocking,
+        readAsync: async (descriptor, target, position) => blocking.read(descriptor, target, position),
+        writeAsync: async (descriptor, source, position) => blocking.write(descriptor, source, position),
+        syncAsync: async (descriptor) => blocking.sync(descriptor),
+    };
+}
+function onNativeThreads(files, blocking) {
+    const pendingByDescriptor = new Map();
+    function inOrder(descriptor, run) {
+        const previous = pendingByDescriptor.get(descriptor);
+        let started;
+        if (previous !== undefined) {
+            started = previous.then(run, run);
+        }
+        else {
+            try {
+                started = run();
+            }
+            catch (error) {
+                started = Promise.reject(error);
+            }
+        }
+        const settled = started.then(() => { }, () => { });
+        pendingByDescriptor.set(descriptor, settled);
+        settled.then(() => {
+            if (pendingByDescriptor.get(descriptor) === settled)
+                pendingByDescriptor.delete(descriptor);
+        });
+        return started.catch(rejectedWithNativeCode);
+    }
+    return {
+        ...blocking,
+        close(descriptor) {
+            const pending = pendingByDescriptor.get(descriptor);
+            if (pending === undefined) {
+                blocking.close(descriptor);
+                return;
+            }
+            pendingByDescriptor.delete(descriptor);
+            pending.then(() => {
+                try {
+                    files.close(descriptor);
+                }
+                catch { }
+            });
+        },
+        readAsync(descriptor, target, position) {
+            return inOrder(descriptor, async () => {
+                const bytes = await files.readAsync(descriptor, target.byteLength, position);
+                target.set(new Uint8Array(bytes));
+                return bytes.byteLength;
+            });
+        },
+        writeAsync(descriptor, source, position) {
+            const bytes = pendingByDescriptor.has(descriptor) ? source.slice() : source;
+            return inOrder(descriptor, () => files.writeAsync(descriptor, bytes.buffer, bytes.byteOffset, bytes.byteLength, position));
+        },
+        syncAsync(descriptor) {
+            return inOrder(descriptor, () => files.syncAsync(descriptor));
+        },
+    };
+}
+export function adaptFiles(files, nativeThreads) {
+    const blocking = blockingFiles(files);
+    return nativeThreads ? onNativeThreads(files, blocking) : onTheCallingThread(blocking);
+}

package/lib/engine/host.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNativeHost } from '@delali/narsil';
+import type { NarsilCore } from '../specs/core.nitro';
+import type { NarsilFiles } from '../specs/files.nitro';
+import type { NarsilHost } from '../specs/host.nitro';
+export interface NativeObjects {
+    host: NarsilHost;
+    files: NarsilFiles;
+    core: NarsilCore;
+}
+export declare function installWorkletDispatcherOn(host: NarsilHost): boolean;
+export declare function threadPriorityOf(host: NarsilHost): number | null;
+export declare function adoptAppThreadPriorityOn(host: NarsilHost, appThreadPriority: number): boolean;
+export declare function adaptHost({ host, files, core }: NativeObjects, nativeThreads: boolean): ReactNativeHost;

package/lib/engine/host.js

@@ -0,0 +1,102 @@
+import { adaptCore } from './core';
+import { adaptFiles } from './files';
+import { withNativeCode } from './native-error';
+function bufferOf(view) {
+    return view.buffer;
+}
+function collectGarbageOn(host) {
+    const collect = Reflect.get(host, 'collectGarbage');
+    if (typeof collect !== 'function')
+        return false;
+    return Reflect.apply(collect, host, []) === true;
+}
+export function installWorkletDispatcherOn(host) {
+    const install = Reflect.get(host, 'installWorkletDispatcher');
+    if (typeof install !== 'function')
+        return false;
+    return Reflect.apply(install, host, []) === true;
+}
+export function threadPriorityOf(host) {
+    const read = Reflect.get(host, 'threadPriority');
+    if (typeof read !== 'function')
+        return null;
+    const priority = Reflect.apply(read, host, []);
+    return typeof priority === 'number' && Number.isFinite(priority) ? priority : null;
+}
+export function adoptAppThreadPriorityOn(host, appThreadPriority) {
+    const adopt = Reflect.get(host, 'adoptAppThreadPriority');
+    if (typeof adopt !== 'function')
+        return false;
+    return Reflect.apply(adopt, host, [appThreadPriority]) === true;
+}
+export function adaptHost({ host, files, core }, nativeThreads) {
+    return {
+        reserveMemory(bytes) {
+            try {
+                return host.reserveMemory(bytes);
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        allocateMemory(bytes) {
+            try {
+                return host.allocateMemory(bytes);
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        ownsMemory: (buffer) => host.ownsMemory(buffer),
+        fillRandom(target) {
+            host.fillRandom(bufferOf(target), target.byteOffset, target.byteLength);
+        },
+        processId: () => host.processId(),
+        processStartedAtMs: () => host.processStartedAtMs(),
+        processIsAlive: (processId) => host.processIsAlive(processId),
+        processMemory: () => host.processMemory(),
+        collectGarbage: () => collectGarbageOn(host),
+        appStorageDirectory() {
+            try {
+                return host.appStorageDirectory();
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        deflateRaw(raw) {
+            try {
+                return new Uint8Array(host.deflateRaw(bufferOf(raw), raw.byteOffset, raw.byteLength));
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        inflateRaw(compressed, rawByteLength) {
+            try {
+                return new Uint8Array(host.inflateRaw(bufferOf(compressed), compressed.byteOffset, compressed.byteLength, rawByteLength));
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        gzip(data) {
+            try {
+                return new Uint8Array(host.gzip(bufferOf(data), data.byteOffset, data.byteLength));
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        gunzip(compressed, maxByteLength) {
+            try {
+                return new Uint8Array(host.gunzip(bufferOf(compressed), compressed.byteOffset, compressed.byteLength, maxByteLength));
+            }
+            catch (error) {
+                throw withNativeCode(error);
+            }
+        },
+        files: adaptFiles(files, nativeThreads),
+        core: adaptCore(core, nativeThreads),
+    };
+}

package/lib/engine/install.d.ts

@@ -0,0 +1,4 @@
+import type { ReactNativeHost } from '@delali/narsil';
+import { type NativeObjects } from './host';
+export declare function installedHost(): ReactNativeHost;
+export declare function installEngineHost(natives: NativeObjects, nativeThreads: boolean): void;

package/lib/engine/install.js

@@ -0,0 +1,29 @@
+import { adaptHost } from './host';
+import { installAtomics } from './stand-ins/atomics';
+import { installCrypto } from './stand-ins/crypto';
+import { installProcess } from './stand-ins/process';
+import { installStreams } from './stand-ins/streams';
+import { installStructuredClone } from './stand-ins/structured-clone';
+const REACT_NATIVE_HOST_KEY = Symbol.for('@delali/narsil-react-native/host');
+export function installedHost() {
+    const host = globalThis[REACT_NATIVE_HOST_KEY];
+    if (host === undefined)
+        throw new Error('The Narsil engine runtime started without its native host');
+    return host;
+}
+export function installEngineHost(natives, nativeThreads) {
+    const scope = globalThis;
+    if (scope[REACT_NATIVE_HOST_KEY] !== undefined)
+        return;
+    installStructuredClone();
+    installStreams();
+    installAtomics(natives.host);
+    installCrypto(natives.host);
+    installProcess(natives.host);
+    Object.defineProperty(globalThis, REACT_NATIVE_HOST_KEY, {
+        value: adaptHost(natives, nativeThreads),
+        writable: false,
+        configurable: false,
+        enumerable: false,
+    });
+}

package/lib/engine/native-error.d.ts

@@ -0,0 +1 @@
+export declare function withNativeCode(error: unknown): unknown;

package/lib/engine/native-error.js

@@ -0,0 +1,12 @@
+const NATIVE_ERROR_CODE = /^[^[]*\[(E[A-Z0-9_]+)\]/;
+export function withNativeCode(error) {
+    if (!(error instanceof Error))
+        return error;
+    if (error.code !== undefined)
+        return error;
+    const match = NATIVE_ERROR_CODE.exec(error.message);
+    if (match === null)
+        return error;
+    Object.defineProperty(error, 'code', { value: match[1], enumerable: true, configurable: true, writable: true });
+    return error;
+}

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

@@ -0,0 +1,5 @@
+export interface NativeAtomics {
+    ownsMemory(buffer: ArrayBuffer): boolean;
+    atomic(operation: number, elementKind: number, buffer: ArrayBuffer, byteIndex: number, value: number, replacement: number): number;
+}
+export declare function installAtomics(native: NativeAtomics): void;