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

package/src/worklets/runtime.ts

@@ -0,0 +1,190 @@
+import type { BoxedHybridObject } from 'react-native-nitro-modules'
+import { createWorkletRuntime, scheduleOnRuntime, type WorkletRuntime } from 'react-native-worklets'
+import { ENGINE_RUNTIME_NAME } from '../constants'
+import {
+  adoptAppThreadPriorityOn,
+  installWorkletDispatcherOn,
+  type NativeObjects,
+  threadPriorityOf,
+} from '../engine/host'
+import { installEngineHost } from '../engine/install'
+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 {
+  callOnEngine,
+  dropCallParts,
+  listenOnEngine,
+  openOnEngine,
+  recordEngineStartFailure,
+  stageCallPart,
+  stageCallPartText,
+} from './instances'
+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>
+}
+
+let engineRuntime: WorkletRuntime | null = null
+
+export async function boxNativeObjects(natives: NativeObjects): Promise<BoxedNativeObjects> {
+  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 }: BoxedNativeObjects): WorkletRuntime {
+  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: number) => {
+        'worklet'
+        try {
+          adoptAppThreadPriorityOn(host.unbox(), priority)
+        } catch {}
+      },
+      appThreadPriority,
+    )
+  }
+  engineRuntime = runtime
+  return runtime
+}
+
+export function sendOpen(
+  runtime: WorkletRuntime,
+  callId: number,
+  settle: Settle,
+  config: WorkletNarsilConfig,
+  setup: EngineSetup | undefined,
+): void {
+  scheduleOnRuntime(
+    runtime,
+    (id: number, deliver: Settle, settings: WorkletNarsilConfig, prepare: EngineSetup | undefined) => {
+      'worklet'
+      openOnEngine(id, deliver, settings, prepare)
+    },
+    callId,
+    settle,
+    config,
+    setup,
+  )
+}
+
+export function sendCall(
+  runtime: WorkletRuntime,
+  callId: number,
+  settle: Settle,
+  instanceId: number,
+  method: EngineMethod,
+  args: readonly unknown[],
+  partedArgs: readonly number[],
+): void {
+  scheduleOnRuntime(
+    runtime,
+    (
+      id: number,
+      deliver: Settle,
+      instance: number,
+      name: EngineMethod,
+      values: readonly unknown[],
+      parted: readonly number[],
+    ) => {
+      'worklet'
+      callOnEngine(id, deliver, instance, name, values, parted)
+    },
+    callId,
+    settle,
+    instanceId,
+    method,
+    args,
+    partedArgs,
+  )
+}
+
+export function sendCallPart(
+  runtime: WorkletRuntime,
+  callId: number,
+  argIndex: number,
+  items: readonly unknown[],
+): void {
+  scheduleOnRuntime(
+    runtime,
+    (id: number, index: number, part: readonly unknown[]) => {
+      'worklet'
+      stageCallPart(id, index, part)
+    },
+    callId,
+    argIndex,
+    items,
+  )
+}
+
+export function sendCallPartText(runtime: WorkletRuntime, callId: number, argIndex: number, text: string): void {
+  scheduleOnRuntime(
+    runtime,
+    (id: number, index: number, part: string) => {
+      'worklet'
+      stageCallPartText(id, index, part)
+    },
+    callId,
+    argIndex,
+    text,
+  )
+}
+
+export function sendDropCallParts(runtime: WorkletRuntime, callId: number): void {
+  scheduleOnRuntime(
+    runtime,
+    (id: number) => {
+      'worklet'
+      dropCallParts(id)
+    },
+    callId,
+  )
+}
+
+export function sendListen(
+  runtime: WorkletRuntime,
+  instanceId: number,
+  event: string,
+  deliver: DeliverEvent,
+  listening: boolean,
+): void {
+  scheduleOnRuntime(
+    runtime,
+    (instance: number, name: string, forward: DeliverEvent, on: boolean) => {
+      'worklet'
+      listenOnEngine(instance, name as Parameters<typeof listenOnEngine>[1], forward, on)
+    },
+    instanceId,
+    event,
+    deliver,
+    listening,
+  )
+}

package/src/worklets/transfer-queue.ts

@@ -0,0 +1,98 @@
+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'
+
+interface Transfer {
+  sendNextStep(): boolean
+  fail(error: unknown): void
+}
+
+export interface CallSends {
+  sendPart(argIndex: number, items: readonly unknown[]): void
+  sendCall(args: readonly unknown[], partedArgs: readonly number[]): void
+  dropParts(): void
+  fail(error: unknown): void
+}
+
+const waiting: Transfer[] = []
+let sending = false
+
+function sendWaiting(): void {
+  sending = true
+  const turnStarted = performance.now()
+  while (waiting.length > 0) {
+    const transfer = waiting[0]
+    let finished: boolean
+    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: Transfer): void {
+  waiting.push(transfer)
+  if (!sending) sendWaiting()
+}
+
+function nextPartItems(sentItems: number, elapsedMs: number): number {
+  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: readonly unknown[], sends: CallSends): void {
+  const partedArgs: number[] = []
+  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(): boolean {
+    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] as readonly unknown[]
+    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: unknown): void {
+    if (sentAnyPart) {
+      try {
+        sends.dropParts()
+      } catch {}
+    }
+    sends.fail(error)
+  }
+
+  enqueue({ sendNextStep, fail })
+}

package/src/worklets/types.ts

@@ -0,0 +1,37 @@
+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>>