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

package/cpp/core/src/walk.c

@@ -0,0 +1,231 @@
+#include "internal.h"
+
+#include "../include/narsil_core.h"
+
+#include <math.h>
+#include <stdatomic.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+static int lists_fit_the_workspace(const narsil_graph *graph) {
+  int32_t max_neighbours = load_word(graph->header, NARSIL_GRAPH_WORD_M);
+  int32_t max_base_neighbours = load_word(graph->header, NARSIL_GRAPH_WORD_MMAX0);
+  if (max_neighbours <= 0 || max_base_neighbours <= 0) { return 0; }
+  return max_neighbours < MAX_NEIGHBOURS_PER_LIST && max_base_neighbours < MAX_NEIGHBOURS_PER_LIST;
+}
+
+int graph_is_complete(const narsil_graph *graph) {
+  return graph->header != NULL && graph->node_levels != NULL && graph->level0 != NULL && graph->upper_base != NULL &&
+         graph->upper != NULL && graph->locks != NULL && graph->tombstones != NULL && graph->incoming != NULL &&
+         graph->nearest_link_due != NULL && graph->held_locks != NULL;
+}
+
+static void begin_visit_round(narsil_workspace *workspace) {
+  workspace->stamp += 1;
+  if (workspace->stamp == UINT32_MAX) {
+    memset(workspace->visited, 0, (size_t)workspace->visited_capacity * sizeof *workspace->visited);
+    workspace->stamp = 1;
+  }
+}
+
+static int claim_unvisited_node(const walk_context *context, int32_t ordinal) {
+  narsil_workspace *workspace = context->workspace;
+  if (ordinal < 0 || (uint32_t)ordinal >= context->slots || workspace->visited[ordinal] == workspace->stamp) {
+    return 0;
+  }
+  workspace->visited[ordinal] = workspace->stamp;
+  return node_top_layer(context, ordinal) >= 0;
+}
+
+static int accepts(narsil_ordinal_set accepted, int32_t ordinal) {
+  if (accepted.bits == NULL) { return 1; }
+  uint32_t index = (uint32_t)ordinal / BITS_PER_BYTE;
+  if (index >= accepted.bytes) { return 0; }
+  return (accepted.bits[index] & (1U << ((uint32_t)ordinal % BITS_PER_BYTE))) != 0;
+}
+
+static narsil_status keep_candidate(const walk_context *context, layer_search search, scored_node node,
+                                    double *furthest) {
+  narsil_workspace *workspace = context->workspace;
+  narsil_status status = heap_push(&workspace->frontier, node);
+  if (status != NARSIL_OK) { return status; }
+  if (search.excludes_tombstones && is_tombstoned(context, node.ordinal)) { return NARSIL_OK; }
+  if (!accepts(search.accepted, node.ordinal)) { return NARSIL_OK; }
+  status = heap_push(&workspace->found, node);
+  if (status != NARSIL_OK) { return status; }
+  if (workspace->found.size > search.candidate_limit) { heap_pop(&workspace->found); }
+  *furthest = workspace->found.distances[0];
+  return NARSIL_OK;
+}
+
+static narsil_status seed_entry_points(const walk_context *context, layer_search search, double *furthest) {
+  narsil_workspace *workspace = context->workspace;
+  for (uint32_t i = 0; i < workspace->entry_point_count; i++) {
+    int32_t entry = workspace->entry_points[i];
+    if (!claim_unvisited_node(context, entry)) { continue; }
+    double distance = walk_distance(context, entry);
+    if (distance == HUGE_VAL) { continue; }
+    scored_node node = {entry, distance};
+    narsil_status status = keep_candidate(context, search, node, furthest);
+    if (status != NARSIL_OK) { return status; }
+  }
+  return NARSIL_OK;
+}
+
+static narsil_status expand_node(const walk_context *context, layer_search search, double *furthest) {
+  narsil_workspace *workspace = context->workspace;
+  int32_t pending[MAX_NEIGHBOURS_PER_LIST];
+  node_layer position = {workspace->frontier.top.ordinal, search.layer};
+  uint32_t count = read_neighbours(context, position, workspace->neighbours);
+  uint32_t pending_count = 0;
+  for (uint32_t i = 0; i < count; i++) {
+    int32_t neighbour = workspace->neighbours[i];
+    if (!claim_unvisited_node(context, neighbour)) { continue; }
+    pending[pending_count] = neighbour;
+    pending_count += 1;
+    prefetch_for_walk(context, neighbour);
+  }
+  for (uint32_t i = 0; i < pending_count; i++) {
+    double distance = walk_distance(context, pending[i]);
+    if (distance == HUGE_VAL) { continue; }
+    if (distance < *furthest || workspace->found.size < search.candidate_limit) {
+      scored_node node = {pending[i], distance};
+      narsil_status status = keep_candidate(context, search, node, furthest);
+      if (status != NARSIL_OK) { return status; }
+    }
+  }
+  return NARSIL_OK;
+}
+
+static narsil_status drain_found(distance_heap *found, narsil_candidates *out) {
+  uint32_t size = found->size;
+  if (size > out->capacity) { return NARSIL_INVALID_ARGUMENT; }
+  out->count = size;
+  for (uint32_t i = size; i > 0; i--) {
+    heap_pop(found);
+    out->ordinals[i - 1] = found->top.ordinal;
+    out->distances[i - 1] = found->top.distance;
+  }
+  return NARSIL_OK;
+}
+
+narsil_status search_layer(const walk_context *context, layer_search search, narsil_candidates *out) {
+  narsil_workspace *workspace = context->workspace;
+  begin_visit_round(workspace);
+  workspace->frontier.size = 0;
+  workspace->found.size = 0;
+  double furthest = HUGE_VAL;
+  narsil_status status = seed_entry_points(context, search, &furthest);
+  if (status != NARSIL_OK) { return status; }
+  while (heap_pop(&workspace->frontier)) {
+    if (workspace->frontier.top.distance > furthest && workspace->found.size >= search.candidate_limit) { break; }
+    status = expand_node(context, search, &furthest);
+    if (status != NARSIL_OK) { return status; }
+  }
+  return drain_found(&workspace->found, out);
+}
+
+static double centroid_dot_of(const narsil_store *store) {
+  double centroid_dot = 0;
+  for (uint32_t i = 0; i < store->dimension; i++) {
+    centroid_dot += (double)store->centroid[i] * (double)store->centroid[i];
+  }
+  return centroid_dot;
+}
+
+narsil_status begin_walk(walk_context *context, narsil_workspace *workspace, const narsil_graph *graph,
+                         const narsil_store *store, uint32_t metric) {
+  if (workspace == NULL || graph == NULL || store == NULL) { return NARSIL_INVALID_ARGUMENT; }
+  if (!graph_is_complete(graph) || !store_is_complete(store)) { return NARSIL_INVALID_ARGUMENT; }
+  if (store->dimension == 0 || !is_metric(metric) || !is_code_width(store->bits)) { return NARSIL_INVALID_ARGUMENT; }
+  if (!lists_fit_the_workspace(graph)) { return NARSIL_INVALID_ARGUMENT; }
+
+  memset(context, 0, sizeof *context);
+  context->graph = graph;
+  context->store = store;
+  context->workspace = workspace;
+  context->metric = (narsil_metric)metric;
+  context->fence = &workspace->fence;
+  int holds_codes = store->bits != 0 && store->records_per_block > 0;
+  int calibrated = holds_codes && load_word(store->header, NARSIL_STORE_WORD_CALIBRATED) == 1;
+  context->pairs_use_codes = calibrated;
+  context->uses_codes = calibrated && load_word(store->header, NARSIL_STORE_WORD_CODE_COUNT) > 0;
+  if (holds_codes) {
+    context->code_bytes = code_bytes_of(store->dimension, store->bits);
+    context->record_bytes = context->code_bytes + NARSIL_OSQ_TRAILER_BYTES;
+  }
+  if (context->uses_codes || context->pairs_use_codes) { context->centroid_dot = centroid_dot_of(store); }
+  return workspace_reserve_dimension(workspace, store->dimension);
+}
+
+void walk_with_query(walk_context *context, const float *vector) {
+  context->query.values = vector;
+  if (context->uses_codes) {
+    prepare_code(context->workspace, context->store, context->metric, vector, &context->code);
+    return;
+  }
+  context->query.magnitude = (double)kernel_magnitude(vector, context->store->dimension);
+}
+
+void walk_with_placement_query(walk_context *context, const float *vector) {
+  if (!context->uses_codes) {
+    walk_with_query(context, vector);
+    return;
+  }
+  context->query.values = vector;
+  const narsil_store *store = context->store;
+  prepare_code_with_bits(context->workspace, store, context->metric, vector, placement_query_bits_of(store->bits),
+                         &context->code);
+}
+
+narsil_status read_graph_extent(walk_context *context) {
+  int32_t slots = load_word(context->graph->header, NARSIL_GRAPH_WORD_SLOTS);
+  int32_t store_slots = load_word(context->store->header, NARSIL_STORE_WORD_SLOTS);
+  context->slots = slots < 0 ? 0 : (uint32_t)slots;
+  context->store_slots = store_slots < 0 ? 0 : (uint32_t)store_slots;
+  return workspace_reserve_visited(context->workspace, context->slots);
+}
+
+void use_single_entry(narsil_workspace *workspace, int32_t ordinal) {
+  workspace->entry_points[0] = ordinal;
+  workspace->entry_point_count = 1;
+}
+
+narsil_status descend_layers(const walk_context *context, int32_t first, int32_t last, narsil_candidates *out) {
+  for (int32_t layer = first; layer >= last; layer--) {
+    layer_search search = {1, layer, 0, {NULL, 0}};
+    narsil_status status = search_layer(context, search, out);
+    if (status != NARSIL_OK) { return status; }
+    if (out->count > 0) { use_single_entry(context->workspace, out->ordinals[0]); }
+  }
+  return NARSIL_OK;
+}
+
+narsil_status narsil_search(narsil_workspace *workspace, const narsil_graph *graph, const narsil_store *store,
+                            const narsil_search_request *request, narsil_candidates *nearest) {
+  if (request == NULL || request->query == NULL || nearest == NULL) { return NARSIL_INVALID_ARGUMENT; }
+  if (request->candidate_count == 0 || nearest->capacity < request->candidate_count) { return NARSIL_INVALID_ARGUMENT; }
+  walk_context context;
+  narsil_status status = begin_walk(&context, workspace, graph, store, request->metric);
+  if (status != NARSIL_OK) { return status; }
+  if (request->thread_slot >= graph->thread_slots) { return NARSIL_INVALID_ARGUMENT; }
+  context.thread_slot = request->thread_slot;
+  walk_with_query(&context, request->query);
+  nearest->count = 0;
+
+  graph_lock_shared(graph, request->thread_slot);
+  status = read_graph_extent(&context);
+  int32_t entry = load_word(graph->header, NARSIL_GRAPH_WORD_ENTRY_POINT);
+  if (status == NARSIL_OK && entry != NO_ENTRY_POINT) {
+    status = workspace_reserve_entry_points(workspace, 1);
+    if (status == NARSIL_OK) {
+      use_single_entry(workspace, entry);
+      status = descend_layers(&context, load_word(graph->header, NARSIL_GRAPH_WORD_TOP_LAYER), 1, nearest);
+    }
+    layer_search base = {request->candidate_count, 0, 1, request->accepted};
+    if (status == NARSIL_OK) { status = search_layer(&context, base, nearest); }
+  }
+  graph_unlock_shared(graph, request->thread_slot);
+  return status;
+}

package/cpp/core/src/workspace.c

@@ -0,0 +1,167 @@
+#include "internal.h"
+
+#include "../include/narsil_core.h"
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define INITIAL_VISITED_CAPACITY 1024
+#define INITIAL_ENTRY_POINT_CAPACITY 256
+#define WIDEST_PLANE_CODE_BITS 2
+#define STORED_VECTOR_COPIES 3
+
+int32_t narsil_core_abi_version(void) { return NARSIL_CORE_ABI_VERSION; }
+
+uint32_t grown_capacity(uint32_t first, uint32_t needed) {
+  uint32_t capacity = first;
+  while (capacity < needed) {
+    if (capacity > UINT32_MAX / 2) { return needed; }
+    capacity *= 2;
+  }
+  return capacity;
+}
+
+narsil_status narsil_workspace_create(narsil_workspace **workspace) {
+  if (workspace == NULL) { return NARSIL_INVALID_ARGUMENT; }
+  narsil_workspace *created = calloc(1, sizeof *created);
+  if (created == NULL) { return NARSIL_OUT_OF_MEMORY; }
+  created->found.greatest_first = 1;
+  *workspace = created;
+  return NARSIL_OK;
+}
+
+static void release_code(prepared_code *code) {
+  free(code->levels);
+  free(code->low_levels);
+  free(code->high_levels);
+  free(code->planes);
+  memset(code, 0, sizeof *code);
+}
+
+static void release_dimension_scratch(narsil_workspace *workspace) {
+  release_code(&workspace->code);
+  free(workspace->normalised);
+  free(workspace->centred);
+  free(workspace->placed_vector);
+  free(workspace->stored_vector);
+  free(workspace->other_vector);
+  workspace->normalised = NULL;
+  workspace->centred = NULL;
+  workspace->placed_vector = NULL;
+  workspace->stored_vector = NULL;
+  workspace->other_vector = NULL;
+  workspace->dimension_capacity = 0;
+  workspace->dimension_scratch_bytes = 0;
+}
+
+void narsil_workspace_destroy(narsil_workspace *workspace) {
+  if (workspace == NULL) { return; }
+  heap_release(&workspace->frontier);
+  heap_release(&workspace->found);
+  release_dimension_scratch(workspace);
+  list_release(&workspace->layer_candidates);
+  list_release(&workspace->link_candidates);
+  list_release(&workspace->repair_candidates);
+  list_release(&workspace->dropped_links);
+  free(workspace->selections);
+  free(workspace->selection_counts);
+  free(workspace->visited);
+  free(workspace->entry_points);
+  free(workspace);
+}
+
+static size_t list_bytes(const scored_list *list) {
+  return (size_t)list->capacity * (sizeof(int32_t) + sizeof(double));
+}
+
+static size_t link_bytes(const narsil_workspace *workspace) {
+  size_t selected = (size_t)workspace->selection_layers * workspace->selection_stride * sizeof(int32_t);
+  size_t counts = (size_t)workspace->selection_layers * sizeof(uint32_t);
+  return list_bytes(&workspace->layer_candidates) + list_bytes(&workspace->link_candidates) +
+         list_bytes(&workspace->repair_candidates) + list_bytes(&workspace->dropped_links) + selected + counts;
+}
+
+narsil_status workspace_reserve_links(narsil_workspace *workspace, const narsil_graph *graph, uint32_t layers) {
+  uint32_t stride = list_limit(graph, 0) > list_limit(graph, 1) ? list_limit(graph, 0) : list_limit(graph, 1);
+  if (layers <= workspace->selection_layers && stride <= workspace->selection_stride) { return NARSIL_OK; }
+  uint32_t held_layers = layers > workspace->selection_layers ? layers : workspace->selection_layers;
+  uint32_t held_stride = stride > workspace->selection_stride ? stride : workspace->selection_stride;
+  int32_t *selections = calloc((size_t)held_layers * held_stride, sizeof *selections);
+  uint32_t *counts = calloc(held_layers, sizeof *counts);
+  if (selections == NULL || counts == NULL) {
+    free(selections);
+    free(counts);
+    return NARSIL_OUT_OF_MEMORY;
+  }
+  free(workspace->selections);
+  free(workspace->selection_counts);
+  workspace->selections = selections;
+  workspace->selection_counts = counts;
+  workspace->selection_layers = held_layers;
+  workspace->selection_stride = held_stride;
+  return NARSIL_OK;
+}
+
+size_t narsil_workspace_bytes(const narsil_workspace *workspace) {
+  if (workspace == NULL) { return 0; }
+  size_t heap_entry = sizeof(int32_t) + sizeof(double);
+  return sizeof *workspace + ((size_t)workspace->frontier.capacity * heap_entry) +
+         ((size_t)workspace->found.capacity * heap_entry) + ((size_t)workspace->visited_capacity * sizeof(uint32_t)) +
+         ((size_t)workspace->entry_point_capacity * sizeof(int32_t)) + workspace->dimension_scratch_bytes +
+         link_bytes(workspace);
+}
+
+narsil_status workspace_reserve_dimension(narsil_workspace *workspace, uint32_t dimension) {
+  if (dimension <= workspace->dimension_capacity) { return NARSIL_OK; }
+  release_dimension_scratch(workspace);
+  size_t pairs = ((size_t)dimension + 1) / 2;
+  size_t planes = (size_t)QUERY_PLANES * code_bytes_of(dimension, WIDEST_PLANE_CODE_BITS);
+  workspace->normalised = calloc(dimension, sizeof(double));
+  workspace->centred = calloc(dimension, sizeof(double));
+  workspace->placed_vector = calloc(dimension, sizeof(float));
+  workspace->stored_vector = calloc(dimension, sizeof(float));
+  workspace->other_vector = calloc(dimension, sizeof(float));
+  workspace->code.levels = calloc(dimension, 1);
+  workspace->code.low_levels = calloc(pairs, 1);
+  workspace->code.high_levels = calloc(pairs, 1);
+  workspace->code.planes = calloc(planes, 1);
+  if (workspace->normalised == NULL || workspace->centred == NULL || workspace->placed_vector == NULL ||
+      workspace->stored_vector == NULL || workspace->other_vector == NULL || workspace->code.levels == NULL ||
+      workspace->code.low_levels == NULL || workspace->code.high_levels == NULL || workspace->code.planes == NULL) {
+    release_dimension_scratch(workspace);
+    return NARSIL_OUT_OF_MEMORY;
+  }
+  workspace->dimension_capacity = dimension;
+  workspace->dimension_scratch_bytes = (2 * (size_t)dimension * sizeof(double)) +
+                                       (STORED_VECTOR_COPIES * (size_t)dimension * sizeof(float)) + dimension +
+                                       (2 * pairs) + planes;
+  return NARSIL_OK;
+}
+
+narsil_status workspace_reserve_visited(narsil_workspace *workspace, uint32_t slots) {
+  if (slots <= workspace->visited_capacity) { return NARSIL_OK; }
+  uint32_t held = workspace->visited_capacity == 0 ? INITIAL_VISITED_CAPACITY : workspace->visited_capacity;
+  uint32_t capacity = grown_capacity(held, slots);
+  uint32_t *visited = calloc(capacity, sizeof *visited);
+  if (visited == NULL) { return NARSIL_OUT_OF_MEMORY; }
+  if (workspace->visited != NULL) {
+    memcpy(visited, workspace->visited, (size_t)workspace->visited_capacity * sizeof *visited);
+    free(workspace->visited);
+  }
+  workspace->visited = visited;
+  workspace->visited_capacity = capacity;
+  return NARSIL_OK;
+}
+
+narsil_status workspace_reserve_entry_points(narsil_workspace *workspace, uint32_t count) {
+  if (count <= workspace->entry_point_capacity) { return NARSIL_OK; }
+  uint32_t held = workspace->entry_point_capacity == 0 ? INITIAL_ENTRY_POINT_CAPACITY : workspace->entry_point_capacity;
+  uint32_t capacity = grown_capacity(held, count);
+  int32_t *entry_points = realloc(workspace->entry_points, (size_t)capacity * sizeof *entry_points);
+  if (entry_points == NULL) { return NARSIL_OUT_OF_MEMORY; }
+  workspace->entry_points = entry_points;
+  workspace->entry_point_capacity = capacity;
+  return NARSIL_OK;
+}

package/ios/PrivacyInfo.xcprivacy

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>NSPrivacyTracking</key>
+	<false/>
+	<key>NSPrivacyTrackingDomains</key>
+	<array/>
+	<key>NSPrivacyCollectedDataTypes</key>
+	<array/>
+	<key>NSPrivacyAccessedAPITypes</key>
+	<array>
+		<dict>
+			<key>NSPrivacyAccessedAPIType</key>
+			<string>NSPrivacyAccessedAPICategoryFileTimestamp</string>
+			<key>NSPrivacyAccessedAPITypeReasons</key>
+			<array>
+				<string>C617.1</string>
+			</array>
+		</dict>
+	</array>
+</dict>
+</plist>

package/lib/client.d.ts

@@ -0,0 +1,19 @@
+import type { PhoneNarsil, PhoneNarsilConfig } from './types';
+/**
+ * Starts a Narsil engine on the app's own JS runtime and resolves with a
+ * client whose methods each return a promise. The engine takes the same
+ * settings as on Node.js, function settings such as embedding adapters,
+ * plugins, and an id generator included. File reads, file writes, file
+ * syncs, and vector searches run on native threads, and a long import or
+ * search yields to the app between steps.
+ *
+ * @param config - The engine settings. `durability` defaults to a
+ * write-ahead log in the `narsil` directory of the app's private storage,
+ * and `null` keeps every index in memory alone.
+ * @returns The client, once the engine has started.
+ * @throws A `NarsilError` with `NATIVE_DEPENDENCY_MISSING` when the app's
+ * build lacks the native module, as in Expo Go.
+ *
+ * @public
+ */
+export declare function createNarsil(config?: PhoneNarsilConfig): Promise<PhoneNarsil>;

package/lib/client.js

@@ -0,0 +1,41 @@
+import { createNarsil as createEngine } from '@delali/narsil';
+import { installEngineHost, installedHost } from './engine/install';
+import { callStreamed, withPhoneDurability } from './engine/streamed';
+import { FORWARDED_METHODS, STREAMED_METHODS } from './methods';
+import { loadNativeObjects } from './native-objects';
+function phoneNarsil(narsil, host) {
+    const client = {};
+    for (const method of FORWARDED_METHODS) {
+        const target = narsil[method];
+        client[method] = async (...args) => target.apply(narsil, args);
+    }
+    for (const method of STREAMED_METHODS) {
+        client[method] = async (...args) => callStreamed(narsil, host, method, args);
+    }
+    client.on = narsil.on.bind(narsil);
+    client.off = narsil.off.bind(narsil);
+    client.shutdown = async () => narsil.shutdown();
+    return client;
+}
+/**
+ * Starts a Narsil engine on the app's own JS runtime and resolves with a
+ * client whose methods each return a promise. The engine takes the same
+ * settings as on Node.js, function settings such as embedding adapters,
+ * plugins, and an id generator included. File reads, file writes, file
+ * syncs, and vector searches run on native threads, and a long import or
+ * search yields to the app between steps.
+ *
+ * @param config - The engine settings. `durability` defaults to a
+ * write-ahead log in the `narsil` directory of the app's private storage,
+ * and `null` keeps every index in memory alone.
+ * @returns The client, once the engine has started.
+ * @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 = {}) {
+    installEngineHost(await loadNativeObjects(), true);
+    const narsil = await createEngine(withPhoneDurability(config));
+    return phoneNarsil(narsil, installedHost());
+}

package/lib/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const FILE_CHUNK_BYTES = 1048576;
+export declare const DEFAULT_DURABILITY_DIRECTORY = "narsil";
+export declare const ENGINE_RUNTIME_NAME = "narsil-engine";
+export declare const WORKLET_TRANSFER_TURN_BUDGET_MS = 8;
+export declare const WORKLET_TRANSFER_PART_TARGET_MS = 4;
+export declare const WORKLET_TRANSFER_FIRST_PART_ITEMS = 32;
+export declare const WORKLET_TRANSFER_LARGEST_PART_ITEMS = 4096;
+export declare const WORKLET_JSON_PART_MAX_DEPTH = 64;
+export declare const APP_TIMER_WAIT_BEFORE_RUN_LOOP_HOP_MS = 100;

package/lib/constants.js

@@ -0,0 +1,9 @@
+export const FILE_CHUNK_BYTES = 1_048_576;
+export const DEFAULT_DURABILITY_DIRECTORY = 'narsil';
+export const ENGINE_RUNTIME_NAME = 'narsil-engine';
+export const WORKLET_TRANSFER_TURN_BUDGET_MS = 8;
+export const WORKLET_TRANSFER_PART_TARGET_MS = 4;
+export const WORKLET_TRANSFER_FIRST_PART_ITEMS = 32;
+export const WORKLET_TRANSFER_LARGEST_PART_ITEMS = 4_096;
+export const WORKLET_JSON_PART_MAX_DEPTH = 64;
+export const APP_TIMER_WAIT_BEFORE_RUN_LOOP_HOP_MS = 100;

package/lib/engine/byte-files.d.ts

@@ -0,0 +1,5 @@
+import type { ReactNativeFiles, ReactNativeHost } from '@delali/narsil';
+export declare function resolveAppPath(host: ReactNativeHost, path: string): string;
+export declare function writeStreamToFile(files: ReactNativeFiles, stream: ReadableStream<Uint8Array>, path: string): Promise<number>;
+export declare function fileChunks(files: ReactNativeFiles, path: string): AsyncGenerator<Uint8Array>;
+export declare function collectStream(stream: ReadableStream<Uint8Array>): Promise<Uint8Array>;

package/lib/engine/byte-files.js

@@ -0,0 +1,97 @@
+import { FILE_CHUNK_BYTES } from '../constants';
+const CURRENT_POSITION = -1;
+function invalidPath(message) {
+    return Object.assign(new TypeError(message), { code: 'EINVAL' });
+}
+export function resolveAppPath(host, path) {
+    if (typeof path !== 'string' || path.length === 0)
+        throw invalidPath('A file path must be a non-empty string');
+    if (path.includes('\0'))
+        throw invalidPath('A file path cannot hold a NUL character');
+    if (path.startsWith('/'))
+        return path;
+    const directory = host.appStorageDirectory();
+    return directory.endsWith('/') ? `${directory}${path}` : `${directory}/${path}`;
+}
+async function writeAll(files, descriptor, chunk) {
+    let written = 0;
+    while (written < chunk.byteLength) {
+        const end = Math.min(chunk.byteLength, written + FILE_CHUNK_BYTES);
+        const count = await files.writeAsync(descriptor, chunk.subarray(written, end), CURRENT_POSITION);
+        if (count <= 0)
+            throw Object.assign(new Error('The file accepted no more bytes'), { code: 'EIO' });
+        written += count;
+    }
+}
+function temporaryNameFor(path) {
+    const suffix = new Uint8Array(8);
+    globalThis.crypto.getRandomValues(suffix);
+    let text = '';
+    for (const byte of suffix)
+        text += byte.toString(16).padStart(2, '0');
+    return `${path}.partial-${text}`;
+}
+export async function writeStreamToFile(files, stream, path) {
+    const temporary = temporaryNameFor(path);
+    const descriptor = files.open(temporary, 'wx');
+    const reader = stream.getReader();
+    let total = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            await writeAll(files, descriptor, value);
+            total += value.byteLength;
+        }
+        await files.syncAsync(descriptor);
+    }
+    catch (error) {
+        await reader.cancel(error).catch(() => undefined);
+        files.close(descriptor);
+        try {
+            files.unlink(temporary);
+        }
+        catch { }
+        throw error;
+    }
+    files.close(descriptor);
+    files.rename(temporary, path);
+    return total;
+}
+export async function* fileChunks(files, path) {
+    const descriptor = files.open(path, 'r');
+    try {
+        let position = 0;
+        for (;;) {
+            const chunk = new Uint8Array(FILE_CHUNK_BYTES);
+            const count = await files.readAsync(descriptor, chunk, position);
+            if (count === 0)
+                return;
+            position += count;
+            yield count === chunk.byteLength ? chunk : chunk.subarray(0, count);
+        }
+    }
+    finally {
+        files.close(descriptor);
+    }
+}
+export async function collectStream(stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    let total = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        chunks.push(value);
+        total += value.byteLength;
+    }
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+}

package/lib/engine/core.d.ts

@@ -0,0 +1,3 @@
+import type { NativeCore } from '@delali/narsil';
+import type { NarsilCore } from '../specs/core.nitro';
+export declare function adaptCore(core: NarsilCore, nativeThreads: boolean): NativeCore;