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

package/src/engine/host.ts

@@ -0,0 +1,111 @@
+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'
+import { adaptCore } from './core'
+import { adaptFiles } from './files'
+import { withNativeCode } from './native-error'
+
+export interface NativeObjects {
+  host: NarsilHost
+  files: NarsilFiles
+  core: NarsilCore
+}
+
+function bufferOf(view: ArrayBufferView): ArrayBuffer {
+  return view.buffer as ArrayBuffer
+}
+
+function collectGarbageOn(host: NarsilHost): boolean {
+  const collect: unknown = Reflect.get(host, 'collectGarbage')
+  if (typeof collect !== 'function') return false
+  return Reflect.apply(collect, host, []) === true
+}
+
+export function installWorkletDispatcherOn(host: NarsilHost): boolean {
+  const install: unknown = Reflect.get(host, 'installWorkletDispatcher')
+  if (typeof install !== 'function') return false
+  return Reflect.apply(install, host, []) === true
+}
+
+export function threadPriorityOf(host: NarsilHost): number | null {
+  const read: unknown = Reflect.get(host, 'threadPriority')
+  if (typeof read !== 'function') return null
+  const priority: unknown = Reflect.apply(read, host, [])
+  return typeof priority === 'number' && Number.isFinite(priority) ? priority : null
+}
+
+export function adoptAppThreadPriorityOn(host: NarsilHost, appThreadPriority: number): boolean {
+  const adopt: unknown = Reflect.get(host, 'adoptAppThreadPriority')
+  if (typeof adopt !== 'function') return false
+  return Reflect.apply(adopt, host, [appThreadPriority]) === true
+}
+
+export function adaptHost({ host, files, core }: NativeObjects, nativeThreads: boolean): ReactNativeHost {
+  return {
+    reserveMemory(bytes: number): ArrayBuffer {
+      try {
+        return host.reserveMemory(bytes)
+      } catch (error) {
+        throw withNativeCode(error)
+      }
+    },
+    allocateMemory(bytes: number): ArrayBuffer {
+      try {
+        return host.allocateMemory(bytes)
+      } catch (error) {
+        throw withNativeCode(error)
+      }
+    },
+    ownsMemory: (buffer: ArrayBufferLike) => host.ownsMemory(buffer as ArrayBuffer),
+    fillRandom(target: Uint8Array): void {
+      host.fillRandom(bufferOf(target), target.byteOffset, target.byteLength)
+    },
+    processId: () => host.processId(),
+    processStartedAtMs: () => host.processStartedAtMs(),
+    processIsAlive: (processId: number) => host.processIsAlive(processId),
+    processMemory: () => host.processMemory(),
+    collectGarbage: () => collectGarbageOn(host),
+    appStorageDirectory(): string {
+      try {
+        return host.appStorageDirectory()
+      } catch (error) {
+        throw withNativeCode(error)
+      }
+    },
+    deflateRaw(raw: Uint8Array): Uint8Array {
+      try {
+        return new Uint8Array(host.deflateRaw(bufferOf(raw), raw.byteOffset, raw.byteLength))
+      } catch (error) {
+        throw withNativeCode(error)
+      }
+    },
+    inflateRaw(compressed: Uint8Array, rawByteLength: number): Uint8Array {
+      try {
+        return new Uint8Array(
+          host.inflateRaw(bufferOf(compressed), compressed.byteOffset, compressed.byteLength, rawByteLength),
+        )
+      } catch (error) {
+        throw withNativeCode(error)
+      }
+    },
+    gzip(data: Uint8Array): Uint8Array {
+      try {
+        return new Uint8Array(host.gzip(bufferOf(data), data.byteOffset, data.byteLength))
+      } catch (error) {
+        throw withNativeCode(error)
+      }
+    },
+    gunzip(compressed: Uint8Array, maxByteLength: number): Uint8Array {
+      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/src/engine/install.ts

@@ -0,0 +1,31 @@
+import type { ReactNativeHost } from '@delali/narsil'
+import { adaptHost, type NativeObjects } 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(): ReactNativeHost {
+  const host = (globalThis as Record<symbol, unknown>)[REACT_NATIVE_HOST_KEY]
+  if (host === undefined) throw new Error('The Narsil engine runtime started without its native host')
+  return host as ReactNativeHost
+}
+
+export function installEngineHost(natives: NativeObjects, nativeThreads: boolean): void {
+  const scope = globalThis as Record<symbol, unknown>
+  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/src/engine/native-error.ts

@@ -0,0 +1,10 @@
+const NATIVE_ERROR_CODE = /^[^[]*\[(E[A-Z0-9_]+)\]/
+
+export function withNativeCode(error: unknown): unknown {
+  if (!(error instanceof Error)) return error
+  if ((error as { code?: unknown }).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/src/engine/stand-ins/atomics.ts

@@ -0,0 +1,288 @@
+type IntegerArray =
+  | Int8Array
+  | Uint8Array
+  | Int16Array
+  | Uint16Array
+  | Int32Array
+  | Uint32Array
+  | BigInt64Array
+  | BigUint64Array
+
+type Element = number | bigint
+
+type WaitResult = 'ok' | 'not-equal' | 'timed-out'
+
+interface Waiter {
+  settle(result: WaitResult): void
+}
+
+const INTEGER_ARRAY_TYPES: ReadonlyArray<abstract new (...args: never[]) => IntegerArray> = [
+  Int8Array,
+  Uint8Array,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  BigInt64Array,
+  BigUint64Array,
+]
+
+const WAITABLE_ARRAY_TYPES: ReadonlyArray<abstract new (...args: never[]) => IntegerArray> = [Int32Array, BigInt64Array]
+
+const waitersByBuffer = new WeakMap<ArrayBufferLike, Map<number, Waiter[]>>()
+
+export interface NativeAtomics {
+  ownsMemory(buffer: ArrayBuffer): boolean
+  atomic(
+    operation: number,
+    elementKind: number,
+    buffer: ArrayBuffer,
+    byteIndex: number,
+    value: number,
+    replacement: number,
+  ): number
+}
+
+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: NativeAtomics | null = null
+const nativeOwnership = new WeakMap<ArrayBufferLike, boolean>()
+
+function nativeElementKind(array: IntegerArray): number {
+  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: IntegerArray): number {
+  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 as ArrayBuffer)
+    nativeOwnership.set(array.buffer, owned)
+  }
+  return owned ? kind : -1
+}
+
+function nativeAtomic(
+  atomics: NativeAtomics,
+  operation: number,
+  kind: number,
+  array: IntegerArray,
+  position: number,
+  value: unknown,
+  replacement: unknown,
+): number {
+  const byteIndex = array.byteOffset + position * array.BYTES_PER_ELEMENT
+  return atomics.atomic(operation, kind, array.buffer as ArrayBuffer, byteIndex, Number(value), Number(replacement))
+}
+
+function isOneOf(array: unknown, types: ReadonlyArray<abstract new (...args: never[]) => IntegerArray>): boolean {
+  for (const type of types) {
+    if (array instanceof type) return true
+  }
+  return false
+}
+
+function requireIndex(array: IntegerArray, index: unknown): number {
+  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: unknown): IntegerArray {
+  if (!isOneOf(array, INTEGER_ARRAY_TYPES)) throw new TypeError('Atomics needs an integer typed array')
+  return array as IntegerArray
+}
+
+function asElement(array: IntegerArray, value: unknown): Element {
+  if (array instanceof BigInt64Array || array instanceof BigUint64Array) return BigInt(value as bigint)
+  return Number(value)
+}
+
+function readModifyWrite(
+  array: unknown,
+  index: unknown,
+  value: unknown,
+  operation: number,
+  combine: (previous: Element, operand: Element) => Element,
+): Element {
+  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] as Element
+  ;(target as unknown as Element[])[position] = combine(previous, asElement(target, value))
+  return previous
+}
+
+function sameAsStored(array: IntegerArray, stored: Element, value: unknown): boolean {
+  const scratch = new (array.constructor as new (length: number) => IntegerArray)(1)
+  ;(scratch as unknown as Element[])[0] = asElement(array, value)
+  return scratch[0] === stored
+}
+
+function waitersAt(array: IntegerArray, position: number): Waiter[] {
+  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: IntegerArray, position: number, waiters: Waiter[]): void {
+  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: unknown, index: unknown): { target: IntegerArray; position: number } {
+  if (!isOneOf(array, WAITABLE_ARRAY_TYPES))
+    throw new TypeError('Atomics waits only on an Int32Array or a BigInt64Array')
+  const target = array as IntegerArray
+  return { target, position: requireIndex(target, index) }
+}
+
+function waitAsync(
+  array: unknown,
+  index: unknown,
+  value: unknown,
+  timeout?: number,
+): { async: false; value: WaitResult } | { async: true; value: Promise<WaitResult> } {
+  const { target, position } = requireWaitable(array, index)
+  if (!sameAsStored(target, target[position] as Element, 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<WaitResult>(resolve => {
+    let timer: ReturnType<typeof setTimeout> | undefined
+    const waiter: 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: unknown, index: unknown, count?: number): number {
+  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: unknown, index: unknown, value: unknown): WaitResult {
+  const { target, position } = requireWaitable(array, index)
+  if (!sameAsStored(target, target[position] as Element, 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: unknown, index: unknown, value: unknown) =>
+    readModifyWrite(array, index, value, NATIVE_ADD, (a, b) => (a as number) + (b as number)),
+  sub: (array: unknown, index: unknown, value: unknown) =>
+    readModifyWrite(array, index, value, NATIVE_SUB, (a, b) => (a as number) - (b as number)),
+  and: (array: unknown, index: unknown, value: unknown) =>
+    readModifyWrite(array, index, value, NATIVE_AND, (a, b) => (a as number) & (b as number)),
+  or: (array: unknown, index: unknown, value: unknown) =>
+    readModifyWrite(array, index, value, NATIVE_OR, (a, b) => (a as number) | (b as number)),
+  xor: (array: unknown, index: unknown, value: unknown) =>
+    readModifyWrite(array, index, value, NATIVE_XOR, (a, b) => (a as number) ^ (b as number)),
+  exchange: (array: unknown, index: unknown, value: unknown) =>
+    readModifyWrite(array, index, value, NATIVE_EXCHANGE, (_a, b) => b),
+  compareExchange(array: unknown, index: unknown, expected: unknown, replacement: unknown): Element {
+    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] as Element
+    if (sameAsStored(target, previous, expected)) {
+      ;(target as unknown as Element[])[position] = asElement(target, replacement)
+    }
+    return previous
+  },
+  load(array: unknown, index: unknown): Element {
+    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] as Element
+  },
+  store(array: unknown, index: unknown, value: unknown): Element {
+    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 as unknown as Element[])[position] = element
+    return typeof element === 'bigint' ? element : Math.trunc(element)
+  },
+  isLockFree: (size: number) => size === 1 || size === 2 || size === 4 || size === 8,
+  wait,
+  waitAsync,
+  notify,
+  pause: () => {},
+}
+
+export function installAtomics(native: NativeAtomics): void {
+  if (typeof (globalThis as { Atomics?: unknown }).Atomics === 'object') return
+  nativeAtomics = native
+  Object.defineProperty(globalThis, 'Atomics', {
+    value: standInAtomics,
+    writable: true,
+    configurable: true,
+    enumerable: false,
+  })
+}

package/src/engine/stand-ins/crypto.ts

@@ -0,0 +1,81 @@
+import type { NarsilHost } from '../../specs/host.nitro'
+
+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])
+
+interface CryptoLike {
+  getRandomValues?: unknown
+  randomUUID?: unknown
+}
+
+function isIntegerArray(view: ArrayBufferView): boolean {
+  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: string, name: string): Error {
+  const error = new Error(message)
+  error.name = name
+  return error
+}
+
+export function installCrypto(host: NarsilHost): void {
+  const scope = globalThis as { crypto?: CryptoLike }
+  const existing = scope.crypto
+  if (typeof existing?.getRandomValues === 'function' && typeof existing.randomUUID === 'function') return
+
+  function getRandomValues<T extends ArrayBufferView>(array: T): T {
+    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 as ArrayBuffer, array.byteOffset, array.byteLength)
+    return array
+  }
+
+  function randomUUID(): string {
+    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: CryptoLike = 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/src/engine/stand-ins/process.ts

@@ -0,0 +1,30 @@
+import type { NarsilHost } from '../../specs/host.nitro'
+
+const MILLISECONDS_PER_SECOND = 1_000
+
+interface ProcessLike {
+  pid?: unknown
+  uptime?: unknown
+}
+
+export function installProcess(host: NarsilHost): void {
+  const scope = globalThis as { process?: ProcessLike }
+  const existing = scope.process
+  const processInfo: ProcessLike = 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/src/engine/stand-ins/streams.ts

@@ -0,0 +1,45 @@
+import {
+  ByteLengthQueuingStrategy,
+  CountQueuingStrategy,
+  ReadableByteStreamController,
+  ReadableStream,
+  ReadableStreamBYOBReader,
+  ReadableStreamBYOBRequest,
+  ReadableStreamDefaultController,
+  ReadableStreamDefaultReader,
+  TransformStream,
+  TransformStreamDefaultController,
+  WritableStream,
+  WritableStreamDefaultController,
+  WritableStreamDefaultWriter,
+} from 'web-streams-polyfill'
+
+const STREAM_CLASSES: Readonly<Record<string, unknown>> = {
+  ByteLengthQueuingStrategy,
+  CountQueuingStrategy,
+  ReadableByteStreamController,
+  ReadableStream,
+  ReadableStreamBYOBReader,
+  ReadableStreamBYOBRequest,
+  ReadableStreamDefaultController,
+  ReadableStreamDefaultReader,
+  TransformStream,
+  TransformStreamDefaultController,
+  WritableStream,
+  WritableStreamDefaultController,
+  WritableStreamDefaultWriter,
+}
+
+export function installStreams(): void {
+  const scope = globalThis as Record<string, unknown>
+  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,
+    })
+  }
+}