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

package/lib/worklets/client.js

@@ -0,0 +1,144 @@
+import { isWorkletFunction } from 'react-native-worklets';
+import { rebuiltError, rebuiltValue } from '../errors';
+import { FORWARDED_METHODS, STREAMED_METHODS } from '../methods';
+import { loadNativeObjects } from '../native-objects';
+import { jsonOfPart } from './json-part';
+import { boxNativeObjects, sendCall, sendCallPart, sendCallPartText, sendDropCallParts, sendListen, sendOpen, startEngineRuntime, } from './runtime';
+import { enqueueCall } from './transfer-queue';
+const pendingCalls = new Map();
+const handlersByInstance = new Map();
+let nextCallId = 1;
+function settleCall(callId, outcome) {
+    const pending = pendingCalls.get(callId);
+    if (pending === undefined)
+        return;
+    pendingCalls.delete(callId);
+    if (outcome.ok)
+        pending.resolve(outcome.value);
+    else
+        pending.reject(rebuiltError(outcome.error));
+}
+function deliverEvent(instanceId, event, payload) {
+    const handlers = handlersByInstance.get(instanceId)?.get(event);
+    if (handlers === undefined)
+        return;
+    const rebuilt = rebuiltValue(payload);
+    for (const handler of [...handlers]) {
+        try {
+            handler(rebuilt);
+        }
+        catch (error) {
+            setTimeout(() => {
+                throw error;
+            }, 0);
+        }
+    }
+}
+function request(send) {
+    return new Promise((resolve, reject) => {
+        const callId = nextCallId++;
+        pendingCalls.set(callId, { resolve, reject });
+        try {
+            send(callId);
+        }
+        catch (error) {
+            pendingCalls.delete(callId);
+            reject(error);
+        }
+    });
+}
+function phoneNarsil(runtime, instanceId) {
+    const handlers = new Map();
+    handlersByInstance.set(instanceId, handlers);
+    function call(method, args) {
+        return new Promise((resolve, reject) => {
+            const callId = nextCallId++;
+            pendingCalls.set(callId, { resolve, reject });
+            enqueueCall(args, {
+                sendPart: (argIndex, items) => {
+                    const text = jsonOfPart(items);
+                    if (text === null)
+                        sendCallPart(runtime, callId, argIndex, items);
+                    else
+                        sendCallPartText(runtime, callId, argIndex, text);
+                },
+                sendCall: (values, partedArgs) => sendCall(runtime, callId, settleCall, instanceId, method, values, partedArgs),
+                dropParts: () => sendDropCallParts(runtime, callId),
+                fail: error => {
+                    pendingCalls.delete(callId);
+                    reject(error);
+                },
+            });
+        });
+    }
+    const client = {};
+    for (const method of [...FORWARDED_METHODS, ...STREAMED_METHODS]) {
+        client[method] = (...args) => call(method, args);
+    }
+    client.on = (event, handler) => {
+        let registered = handlers.get(event);
+        if (registered === undefined) {
+            registered = new Set();
+            handlers.set(event, registered);
+        }
+        const first = registered.size === 0;
+        registered.add(handler);
+        if (first)
+            sendListen(runtime, instanceId, event, deliverEvent, true);
+    };
+    client.off = (event, handler) => {
+        const registered = handlers.get(event);
+        if (registered === undefined || !registered.delete(handler))
+            return;
+        if (registered.size > 0)
+            return;
+        handlers.delete(event);
+        sendListen(runtime, instanceId, event, deliverEvent, false);
+    };
+    client.shutdown = async () => {
+        try {
+            await call('shutdown', []);
+        }
+        finally {
+            handlers.clear();
+            handlersByInstance.delete(instanceId);
+        }
+    };
+    return client;
+}
+/**
+ * Starts a Narsil engine on its own Worklets runtime and resolves with a
+ * client whose methods send each request to that runtime, so the engine's
+ * JavaScript work leaves the app's JS thread free. Every engine that this
+ * function starts shares one runtime, and each engine keeps its own indexes.
+ * The app needs `react-native-worklets` with Bundle Mode turned on. The
+ * client copies each batch that an insert sends across to the engine's
+ * runtime before the engine indexes it, as JSON text when the batch holds
+ * plain data. On a physical iPhone and a physical Android phone, inserts took
+ * 6% to 57% longer than on the app's own JS runtime, depending on the number
+ * of documents and on durability, and an import from a file, which sends only
+ * the file's path across, took up to 11% longer. In return, the longest pause
+ * that a 10 ms timer on the app's JS thread saw during an insert of 50,000
+ * documents fell from 111 ms to 30 ms on the Android phone and from 144 ms to
+ * 74 ms on the iPhone.
+ *
+ * @param config - The engine settings that cross to the engine's runtime as
+ * data. `durability` defaults to a write-ahead log in the `narsil` directory
+ * of the app's private storage.
+ * @param setup - A worklet that returns the settings that hold functions,
+ * such as embedding adapters, plugins, or an id generator.
+ * @returns The client, once the engine has started on its runtime.
+ * @throws A `NarsilError` with `NATIVE_DEPENDENCY_MISSING` when the app's
+ * build lacks the native module, as in Expo Go.
+ *
+ * @public
+ */
+export async function createNarsil(config = {}, setup) {
+    if (setup !== undefined && !isWorkletFunction(setup)) {
+        throw new TypeError("The setup function must be a worklet, so start its body with the 'worklet' directive");
+    }
+    const natives = await loadNativeObjects();
+    const runtime = startEngineRuntime(await boxNativeObjects(natives));
+    const instanceId = await request(callId => sendOpen(runtime, callId, settleCall, config, setup));
+    return phoneNarsil(runtime, instanceId);
+}

package/lib/worklets/index.d.ts

@@ -0,0 +1,4 @@
+export { isNarsilError, type PhoneNarsilError } from '../errors';
+export type { PhoneEventHandler, PhoneNarsil } from '../types';
+export { createNarsil } from './client';
+export type { EngineSetup, WorkletNarsilConfig } from './types';

package/lib/worklets/index.js

@@ -0,0 +1,2 @@
+export { isNarsilError } from '../errors';
+export { createNarsil } from './client';

package/lib/worklets/instances.d.ts

@@ -0,0 +1,15 @@
+import { type NarsilEventMap } from '@delali/narsil';
+import { type EngineMethod } from '../methods';
+import type { CallOutcome } from '../transferred';
+import type { EngineSetup, WorkletNarsilConfig } from './types';
+type Settle = (callId: number, outcome: CallOutcome) => void;
+type DeliverEvent = (instanceId: number, event: EventName, payload: unknown) => void;
+type EventName = keyof NarsilEventMap;
+export declare function recordEngineStartFailure(error: unknown): void;
+export declare function openOnEngine(callId: number, settle: Settle, config: WorkletNarsilConfig, setup: EngineSetup | undefined): void;
+export declare function stageCallPart(callId: number, argIndex: number, items: readonly unknown[]): void;
+export declare function stageCallPartText(callId: number, argIndex: number, text: string): void;
+export declare function dropCallParts(callId: number): void;
+export declare function callOnEngine(callId: number, settle: Settle, instanceId: number, method: EngineMethod, args: readonly unknown[], partedArgs: readonly number[]): void;
+export declare function listenOnEngine(instanceId: number, event: EventName, forward: DeliverEvent, listening: boolean): void;
+export {};

package/lib/worklets/instances.js

@@ -0,0 +1,194 @@
+import { createNarsil, ErrorCodes, NarsilError, } from '@delali/narsil';
+import { scheduleOnRN } from 'react-native-worklets';
+import { installedHost } from '../engine/install';
+import { callStreamed, withPhoneDurability } from '../engine/streamed';
+import { transferable, transferredError } from '../engine/transfer';
+import { FORWARDED_METHODS, STREAMED_METHODS } from '../methods';
+const FORWARDED = new Set(FORWARDED_METHODS);
+const STREAMED = new Set(STREAMED_METHODS);
+const UNDELIVERABLE_OUTCOME = {
+    ok: false,
+    error: {
+        transferredError: true,
+        name: 'Error',
+        message: "The engine's runtime could not send this call's outcome back to the app",
+        code: undefined,
+        details: undefined,
+    },
+};
+const instances = new Map();
+const stagedParts = new Map();
+const failedCalls = new Map();
+const engineStart = { failed: false, error: undefined };
+let nextInstanceId = 1;
+function instanceOf(instanceId) {
+    const instance = instances.get(instanceId);
+    if (instance === undefined) {
+        throw new NarsilError(ErrorCodes.INSTANCE_SHUT_DOWN, 'This Narsil instance has been shut down');
+    }
+    return instance;
+}
+function failureOf(error) {
+    return { ok: false, error: transferredError(error) };
+}
+function deliver(settle, callId, outcome) {
+    try {
+        scheduleOnRN(settle, callId, outcome());
+        return;
+    }
+    catch (error) {
+        try {
+            scheduleOnRN(settle, callId, failureOf(error));
+            return;
+        }
+        catch { }
+    }
+    try {
+        scheduleOnRN(settle, callId, UNDELIVERABLE_OUTCOME);
+    }
+    catch { }
+}
+function report(settle, callId, work) {
+    let pending;
+    try {
+        pending = work();
+    }
+    catch (error) {
+        deliver(settle, callId, () => failureOf(error));
+        return;
+    }
+    pending.then(value => deliver(settle, callId, () => ({ ok: true, value: transferable(value) })), error => deliver(settle, callId, () => failureOf(error)));
+}
+export function recordEngineStartFailure(error) {
+    engineStart.failed = true;
+    engineStart.error = error;
+}
+async function openInstance(config, setup) {
+    if (engineStart.failed)
+        throw engineStart.error;
+    const fromSetup = setup === undefined ? {} : await setup();
+    const merged = { ...withPhoneDurability(config, fromSetup.durability !== undefined), ...fromSetup };
+    const narsil = await createNarsil(merged);
+    const instanceId = nextInstanceId++;
+    instances.set(instanceId, { narsil, listeners: new Map() });
+    return instanceId;
+}
+async function shutdown(instanceId) {
+    const instance = instances.get(instanceId);
+    if (instance === undefined)
+        return;
+    instances.delete(instanceId);
+    for (const [event, listener] of instance.listeners)
+        instance.narsil.off(event, listener);
+    instance.listeners.clear();
+    await instance.narsil.shutdown();
+}
+function dispatch(instanceId, method, args) {
+    if (method === 'shutdown')
+        return shutdown(instanceId);
+    const { narsil } = instanceOf(instanceId);
+    if (FORWARDED.has(method)) {
+        const target = narsil[method];
+        return Promise.resolve(target.apply(narsil, [...args]));
+    }
+    if (!STREAMED.has(method))
+        throw new TypeError(`The Narsil engine has no method called ${String(method)}`);
+    return callStreamed(narsil, installedHost(), method, args);
+}
+export function openOnEngine(callId, settle, config, setup) {
+    report(settle, callId, () => openInstance(config, setup));
+}
+function failCall(callId, error) {
+    stagedParts.delete(callId);
+    failedCalls.set(callId, error);
+}
+function stageItems(callId, argIndex, items) {
+    if (!Array.isArray(items))
+        throw new TypeError('A part of a call reached the engine without its items');
+    let parts = stagedParts.get(callId);
+    if (parts === undefined) {
+        parts = new Map();
+        stagedParts.set(callId, parts);
+    }
+    let staged = parts.get(argIndex);
+    if (staged === undefined) {
+        staged = [];
+        parts.set(argIndex, staged);
+    }
+    for (const item of items)
+        staged.push(item);
+}
+export function stageCallPart(callId, argIndex, items) {
+    if (failedCalls.has(callId))
+        return;
+    try {
+        stageItems(callId, argIndex, items);
+    }
+    catch (error) {
+        failCall(callId, error);
+    }
+}
+export function stageCallPartText(callId, argIndex, text) {
+    if (failedCalls.has(callId))
+        return;
+    try {
+        stageItems(callId, argIndex, JSON.parse(text));
+    }
+    catch (error) {
+        failCall(callId, error);
+    }
+}
+export function dropCallParts(callId) {
+    stagedParts.delete(callId);
+    failedCalls.delete(callId);
+}
+function withStagedParts(callId, args, partedArgs) {
+    const parts = stagedParts.get(callId);
+    const failure = failedCalls.get(callId);
+    stagedParts.delete(callId);
+    if (failedCalls.delete(callId))
+        throw failure;
+    const values = [...args];
+    for (const argIndex of partedArgs)
+        values[argIndex] = parts?.get(argIndex) ?? [];
+    return values;
+}
+export function callOnEngine(callId, settle, instanceId, method, args, partedArgs) {
+    report(settle, callId, () => dispatch(instanceId, method, partedArgs.length === 0 ? args : withStagedParts(callId, args, partedArgs)));
+}
+function forwardEvent(forward, instanceId, event, payload) {
+    try {
+        scheduleOnRN(forward, instanceId, event, transferable(payload));
+    }
+    catch { }
+}
+function changeListener(instanceId, event, forward, listening) {
+    const instance = instances.get(instanceId);
+    if (instance === undefined)
+        return;
+    const existing = instance.listeners.get(event);
+    if (!listening) {
+        if (existing === undefined)
+            return;
+        instance.listeners.delete(event);
+        instance.narsil.off(event, existing);
+        return;
+    }
+    if (existing !== undefined)
+        return;
+    const listener = (payload) => forwardEvent(forward, instanceId, event, payload);
+    instance.listeners.set(event, listener);
+    try {
+        instance.narsil.on(event, listener);
+    }
+    catch (error) {
+        instance.listeners.delete(event);
+        throw error;
+    }
+}
+export function listenOnEngine(instanceId, event, forward, listening) {
+    try {
+        changeListener(instanceId, event, forward, listening);
+    }
+    catch { }
+}

package/lib/worklets/json-part.d.ts

@@ -0,0 +1 @@
+export declare function jsonOfPart(items: readonly unknown[]): string | null;

package/lib/worklets/json-part.js

@@ -0,0 +1,42 @@
+import { WORKLET_JSON_PART_MAX_DEPTH } from '../constants';
+function encodesExactly(value, depth) {
+    switch (typeof value) {
+        case 'string':
+        case 'boolean':
+            return true;
+        case 'number':
+            return Number.isFinite(value) && !Object.is(value, -0);
+        case 'object':
+            break;
+        default:
+            return false;
+    }
+    if (value === null)
+        return true;
+    if (depth >= WORKLET_JSON_PART_MAX_DEPTH)
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype === Array.prototype) {
+        const items = value;
+        for (let index = 0; index < items.length; index++) {
+            if (!(index in items) || !encodesExactly(items[index], depth + 1))
+                return false;
+        }
+        return true;
+    }
+    if (prototype !== Object.prototype && prototype !== null)
+        return false;
+    const record = value;
+    for (const key of Object.keys(record)) {
+        if (!encodesExactly(record[key], depth + 1))
+            return false;
+    }
+    return true;
+}
+export function jsonOfPart(items) {
+    for (const item of items) {
+        if (!encodesExactly(item, 1))
+            return null;
+    }
+    return JSON.stringify(items);
+}

package/lib/worklets/runtime.d.ts

@@ -0,0 +1,25 @@
+import type { BoxedHybridObject } from 'react-native-nitro-modules';
+import { type WorkletRuntime } from 'react-native-worklets';
+import { type NativeObjects } from '../engine/host';
+import type { EngineMethod } from '../methods';
+import type { NarsilCore } from '../specs/core.nitro';
+import type { NarsilFiles } from '../specs/files.nitro';
+import type { NarsilHost } from '../specs/host.nitro';
+import type { CallOutcome } from '../transferred';
+import type { EngineSetup, WorkletNarsilConfig } from './types';
+type Settle = (callId: number, outcome: CallOutcome) => void;
+type DeliverEvent = (instanceId: number, event: string, payload: unknown) => void;
+export interface BoxedNativeObjects {
+    host: BoxedHybridObject<NarsilHost>;
+    files: BoxedHybridObject<NarsilFiles>;
+    core: BoxedHybridObject<NarsilCore>;
+}
+export declare function boxNativeObjects(natives: NativeObjects): Promise<BoxedNativeObjects>;
+export declare function startEngineRuntime({ host, files, core }: BoxedNativeObjects): WorkletRuntime;
+export declare function sendOpen(runtime: WorkletRuntime, callId: number, settle: Settle, config: WorkletNarsilConfig, setup: EngineSetup | undefined): void;
+export declare function sendCall(runtime: WorkletRuntime, callId: number, settle: Settle, instanceId: number, method: EngineMethod, args: readonly unknown[], partedArgs: readonly number[]): void;
+export declare function sendCallPart(runtime: WorkletRuntime, callId: number, argIndex: number, items: readonly unknown[]): void;
+export declare function sendCallPartText(runtime: WorkletRuntime, callId: number, argIndex: number, text: string): void;
+export declare function sendDropCallParts(runtime: WorkletRuntime, callId: number): void;
+export declare function sendListen(runtime: WorkletRuntime, instanceId: number, event: string, deliver: DeliverEvent, listening: boolean): void;
+export {};

package/lib/worklets/runtime.js

@@ -0,0 +1,80 @@
+import { createWorkletRuntime, scheduleOnRuntime } from 'react-native-worklets';
+import { ENGINE_RUNTIME_NAME } from '../constants';
+import { adoptAppThreadPriorityOn, installWorkletDispatcherOn, threadPriorityOf, } from '../engine/host';
+import { installEngineHost } from '../engine/install';
+import { callOnEngine, dropCallParts, listenOnEngine, openOnEngine, recordEngineStartFailure, stageCallPart, stageCallPartText, } from './instances';
+let engineRuntime = null;
+export async function boxNativeObjects(natives) {
+    const { NitroModules } = await import('react-native-nitro-modules');
+    return {
+        host: NitroModules.box(natives.host),
+        files: NitroModules.box(natives.files),
+        core: NitroModules.box(natives.core),
+    };
+}
+export function startEngineRuntime({ host, files, core }) {
+    if (engineRuntime !== null)
+        return engineRuntime;
+    const appThreadPriority = threadPriorityOf(host.unbox());
+    const runtime = createWorkletRuntime({
+        name: ENGINE_RUNTIME_NAME,
+        initializer: () => {
+            'worklet';
+            try {
+                const nativeHost = host.unbox();
+                const nativeThreads = installWorkletDispatcherOn(nativeHost);
+                installEngineHost({ host: nativeHost, files: files.unbox(), core: core.unbox() }, nativeThreads);
+            }
+            catch (error) {
+                recordEngineStartFailure(error);
+            }
+        },
+    });
+    if (appThreadPriority !== null) {
+        scheduleOnRuntime(runtime, (priority) => {
+            'worklet';
+            try {
+                adoptAppThreadPriorityOn(host.unbox(), priority);
+            }
+            catch { }
+        }, appThreadPriority);
+    }
+    engineRuntime = runtime;
+    return runtime;
+}
+export function sendOpen(runtime, callId, settle, config, setup) {
+    scheduleOnRuntime(runtime, (id, deliver, settings, prepare) => {
+        'worklet';
+        openOnEngine(id, deliver, settings, prepare);
+    }, callId, settle, config, setup);
+}
+export function sendCall(runtime, callId, settle, instanceId, method, args, partedArgs) {
+    scheduleOnRuntime(runtime, (id, deliver, instance, name, values, parted) => {
+        'worklet';
+        callOnEngine(id, deliver, instance, name, values, parted);
+    }, callId, settle, instanceId, method, args, partedArgs);
+}
+export function sendCallPart(runtime, callId, argIndex, items) {
+    scheduleOnRuntime(runtime, (id, index, part) => {
+        'worklet';
+        stageCallPart(id, index, part);
+    }, callId, argIndex, items);
+}
+export function sendCallPartText(runtime, callId, argIndex, text) {
+    scheduleOnRuntime(runtime, (id, index, part) => {
+        'worklet';
+        stageCallPartText(id, index, part);
+    }, callId, argIndex, text);
+}
+export function sendDropCallParts(runtime, callId) {
+    scheduleOnRuntime(runtime, (id) => {
+        'worklet';
+        dropCallParts(id);
+    }, callId);
+}
+export function sendListen(runtime, instanceId, event, deliver, listening) {
+    scheduleOnRuntime(runtime, (instance, name, forward, on) => {
+        'worklet';
+        listenOnEngine(instance, name, forward, on);
+    }, instanceId, event, deliver, listening);
+}

package/lib/worklets/transfer-queue.d.ts

@@ -0,0 +1,7 @@
+export interface CallSends {
+    sendPart(argIndex: number, items: readonly unknown[]): void;
+    sendCall(args: readonly unknown[], partedArgs: readonly number[]): void;
+    dropParts(): void;
+    fail(error: unknown): void;
+}
+export declare function enqueueCall(args: readonly unknown[], sends: CallSends): void;

package/lib/worklets/transfer-queue.js

@@ -0,0 +1,79 @@
+import { WORKLET_TRANSFER_FIRST_PART_ITEMS, WORKLET_TRANSFER_LARGEST_PART_ITEMS, WORKLET_TRANSFER_PART_TARGET_MS, WORKLET_TRANSFER_TURN_BUDGET_MS, } from '../constants';
+import { afterAppTurn } from './app-turns';
+const waiting = [];
+let sending = false;
+function sendWaiting() {
+    sending = true;
+    const turnStarted = performance.now();
+    while (waiting.length > 0) {
+        const transfer = waiting[0];
+        let finished;
+        try {
+            finished = transfer.sendNextStep();
+        }
+        catch (error) {
+            finished = true;
+            transfer.fail(error);
+        }
+        if (finished)
+            waiting.shift();
+        if (waiting.length > 0 && performance.now() - turnStarted >= WORKLET_TRANSFER_TURN_BUDGET_MS) {
+            afterAppTurn(sendWaiting);
+            return;
+        }
+    }
+    sending = false;
+}
+function enqueue(transfer) {
+    waiting.push(transfer);
+    if (!sending)
+        sendWaiting();
+}
+function nextPartItems(sentItems, elapsedMs) {
+    const perItemMs = elapsedMs / sentItems;
+    if (perItemMs <= 0)
+        return WORKLET_TRANSFER_LARGEST_PART_ITEMS;
+    const fitting = Math.floor(WORKLET_TRANSFER_PART_TARGET_MS / perItemMs);
+    return Math.min(WORKLET_TRANSFER_LARGEST_PART_ITEMS, Math.max(1, fitting));
+}
+export function enqueueCall(args, sends) {
+    const partedArgs = [];
+    for (const [index, value] of args.entries()) {
+        if (Array.isArray(value) && value.length > WORKLET_TRANSFER_FIRST_PART_ITEMS)
+            partedArgs.push(index);
+    }
+    let argPosition = 0;
+    let offset = 0;
+    let partItems = WORKLET_TRANSFER_FIRST_PART_ITEMS;
+    let sentAnyPart = false;
+    function sendNextStep() {
+        const argIndex = partedArgs[argPosition];
+        if (argIndex === undefined) {
+            const remaining = args.map((value, index) => (partedArgs.includes(index) ? null : value));
+            sends.sendCall(remaining, partedArgs);
+            return true;
+        }
+        const items = args[argIndex];
+        const part = items.slice(offset, offset + partItems);
+        const started = performance.now();
+        sends.sendPart(argIndex, part);
+        sentAnyPart = true;
+        partItems = nextPartItems(part.length, performance.now() - started);
+        offset += part.length;
+        if (offset >= items.length) {
+            argPosition += 1;
+            offset = 0;
+        }
+        return false;
+    }
+    function fail(error) {
+        if (sentAnyPart) {
+            try {
+                sends.dropParts();
+            }
+            catch { }
+        }
+        sends.fail(error);
+    }
+    enqueue({ sendNextStep, fail });
+}

package/lib/worklets/types.d.ts

@@ -0,0 +1,26 @@
+import type { DurabilityConfig, NarsilConfig } from '@delali/narsil';
+/**
+ * The engine settings that an app passes to the engine on its own Worklets
+ * runtime. Each value has to cross to that runtime as data, so the settings
+ * that hold a function, such as an embedding adapter or a plugin, go in an
+ * {@link EngineSetup} worklet instead.
+ *
+ * `durability` defaults to a write-ahead log in a `narsil` directory inside
+ * the app's private storage, and `null` keeps the index in memory alone. A
+ * relative `directory` resolves against that private storage.
+ *
+ * @public
+ */
+export type WorkletNarsilConfig = Omit<NarsilConfig, 'persistence' | 'invalidation' | 'plugins' | 'idGenerator' | 'embedding' | 'embeddingAdapters' | 'rerankAdapters' | 'events' | 'durability'> & {
+    durability?: DurabilityConfig | null;
+};
+/**
+ * A worklet that runs on the engine's runtime before the engine starts, and
+ * returns the settings that hold functions, such as `embeddingAdapters`,
+ * `plugins`, or `idGenerator`. Its values override the matching values of
+ * {@link WorkletNarsilConfig}. Mark the function with the `'worklet'`
+ * directive, and register a language or a tokenizer inside it.
+ *
+ * @public
+ */
+export type EngineSetup = () => Partial<NarsilConfig> | Promise<Partial<NarsilConfig>>;

package/lib/worklets/types.js

@@ -0,0 +1 @@
+export {};

package/nitro.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "https://nitro.margelo.com/nitro.schema.json",
+  "cxxNamespace": ["narsil"],
+  "ios": {
+    "iosModuleName": "NarsilReactNative"
+  },
+  "android": {
+    "androidNamespace": ["narsil"],
+    "androidCxxLibName": "NarsilReactNative"
+  },
+  "autolinking": {
+    "NarsilHost": {
+      "all": {
+        "language": "c++",
+        "implementationClassName": "HybridNarsilHostImpl"
+      }
+    },
+    "NarsilFiles": {
+      "all": {
+        "language": "c++",
+        "implementationClassName": "HybridNarsilFilesImpl"
+      }
+    },
+    "NarsilCore": {
+      "all": {
+        "language": "c++",
+        "implementationClassName": "HybridNarsilCoreImpl"
+      }
+    }
+  },
+  "ignorePaths": ["**/node_modules", "examples"]
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true