@delali/narsil-react-native 0.3.1-next.155 → 0.3.1-next.156

package/NOTICE

@@ -0,0 +1,144 @@
+narsil
+Copyright 2026 Delali (https://sondelali.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+--------------------------------------------------------------------------------
+
+This product includes software from the Snowball project
+(https://snowballstem.org/).
+
+The search core's C sources under cpp/core/ in this package hold stemmers that
+the Snowball compiler generated as C from the algorithms in that project,
+together with the project's C runtime. The licence below covers both.
+
+Copyright (c) 2001, Dr Martin Porter
+Copyright (c) 2002, Richard Boulton
+Copyright (c) 2004,2005, Richard Boulton
+Copyright (c) 2013, Yoshiki Shibukawa
+Copyright (c) 2006-2025, Olly Betts
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+  1. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above copyright notice,
+     this list of conditions and the following disclaimer in the documentation
+     and/or other materials provided with the distribution.
+  3. Neither the name of the Snowball project nor the names of its contributors
+     may be used to endorse or promote products derived from this software
+     without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+--------------------------------------------------------------------------------
+
+This product includes software derived from fdlibm
+(http://www.netlib.org/fdlibm/), through the copy in the V8 project's
+src/base/ieee754.cc.
+
+The search core's C sources under cpp/core/ in this package hold a port of its
+logarithm and trigonometric functions to C. The two notices below cover the
+port.
+
+Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+
+Developed at SunSoft, a Sun Microsystems, Inc. business.
+Permission to use, copy, modify, and distribute this
+software is freely granted, provided that this notice
+is preserved.
+
+Copyright 2016 the V8 project authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of Google Inc. nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+--------------------------------------------------------------------------------
+
+This product includes data from the Unicode Character Database
+(https://www.unicode.org/).
+
+UNICODE LICENSE V3
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright © 1991-2026 Unicode, Inc.
+
+NOTICE TO USER: Carefully read the following legal agreement. BY
+DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR
+SOFTWARE, YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT
+DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of data files and any associated documentation (the "Data Files") or
+software and any associated documentation (the "Software") to deal in the
+Data Files or Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, and/or sell
+copies of the Data Files or Software, and to permit persons to whom the
+Data Files or Software are furnished to do so, provided that either (a)
+this copyright and permission notice appear with all copies of the Data
+Files or Software, or (b) this copyright and permission notice appear in
+associated Documentation.
+
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
+THIRD PARTY RIGHTS.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE
+BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES,
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA
+FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder shall
+not be used in advertising or otherwise to promote the sale, use or other
+dealings in these Data Files or Software without prior written
+authorization of the copyright holder.

package/NarsilReactNative.podspec

@@ -30,10 +30,10 @@ Pod::Spec.new do |s|
 
   s.source_files = [
     "cpp/*.{hpp,cpp}",
-    "cpp/core/src/*.{c,h}",
+    "cpp/core/src/**/*.{c,h}",
     "cpp/core/include/*.h",
   ]
-  s.private_header_files = ["cpp/*.hpp", "cpp/core/src/*.h", "cpp/core/include/*.h"]
+  s.private_header_files = ["cpp/*.hpp", "cpp/core/src/**/*.h", "cpp/core/include/*.h"]
 
   header_search_paths = "$(inherited) \"$(PODS_TARGET_SRCROOT)/cpp/core/include\""
   header_search_paths += " \"$(PODS_ROOT)/Headers/Public/RNWorklets\"" if links_worklets

package/android/CMakeLists.txt

@@ -9,7 +9,7 @@ if(NOT EXISTS ${CORE_DIRECTORY}/include/narsil_core.h)
   message(FATAL_ERROR "The package has no copy of the search core in cpp/core. Run `node scripts/copy-core.mjs` in the package directory first.")
 endif()
 
-file(GLOB CORE_SOURCES ${CORE_DIRECTORY}/src/*.c)
+file(GLOB_RECURSE CORE_SOURCES ${CORE_DIRECTORY}/src/*.c)
 file(GLOB BINDING_SOURCES ${CMAKE_SOURCE_DIR}/../cpp/*.cpp)
 
 add_library(${PACKAGE_NAME} SHARED

package/cpp/HybridNarsilCoreAnalysis.cpp

@@ -0,0 +1,277 @@
+#include "HostMemory.hpp"
+#include "HybridNarsilCoreImpl.hpp"
+
+#include <cerrno>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::narsil {
+
+namespace {
+
+enum AnalyseArgument : size_t {
+  ANALYSE_LANGUAGE,
+  ANALYSE_FLAGS,
+  ANALYSE_TEXT,
+  ANALYSE_STOP_WORDS,
+  ANALYSE_RECORD_BUFFER,
+  ANALYSE_RECORD_BYTE_OFFSET,
+  ANALYSE_RECORD_LENGTH,
+  ANALYSE_ARGUMENT_COUNT
+};
+
+enum TransformArgument : size_t { TRANSFORM_LANGUAGE, TRANSFORM_FLAGS, TRANSFORM_TEXT, TRANSFORM_ARGUMENT_COUNT };
+
+enum TokenRecord : size_t {
+  RECORD_POSITION,
+  RECORD_TERM_OFFSET,
+  RECORD_TERM_LENGTH,
+  RECORD_SURFACE_OFFSET,
+  RECORD_SURFACE_LENGTH,
+  RECORD_ORIGINAL_OFFSET,
+  RECORD_ORIGINAL_LENGTH,
+  RECORD_TERM_SLOT,
+  TOKEN_RECORD_WORDS
+};
+
+const uint16_t NO_UNITS[1] = {0};
+
+class StopWordSetState final : public jsi::NativeState {
+public:
+  StopWordSetState() = default;
+  ~StopWordSetState() override { narsil_stop_word_set_destroy(set); }
+  StopWordSetState(const StopWordSetState&) = delete;
+  StopWordSetState& operator=(const StopWordSetState&) = delete;
+  narsil_stop_word_set* set = nullptr;
+};
+
+uint32_t wholeArgument(const jsi::Value* arguments, size_t count, size_t index, const char* what) {
+  if (index >= count || !arguments[index].isNumber()) throwInvalid(std::string(what) + " must be a number");
+  double value = arguments[index].getNumber();
+  if (!std::isfinite(value) || value < 0 || value > UINT32_MAX || std::floor(value) != value) {
+    throwInvalid(std::string(what) + " must be a whole number from 0 to 4294967295");
+  }
+  return static_cast<uint32_t>(value);
+}
+
+uint32_t languageArgument(const jsi::Value* arguments, size_t count, size_t index) {
+  uint32_t language = wholeArgument(arguments, count, index, "The language index");
+  if (language >= narsil_language_count()) throwInvalid("The language index names no language module of the core");
+  return language;
+}
+
+void appendUnits(jsi::Runtime& runtime, const jsi::String& text, std::vector<uint16_t>& units, size_t limit) {
+  bool tooLong = false;
+  auto collect = [&units, &tooLong, limit](bool ascii, const void* data, size_t length) {
+    if (tooLong || length > limit - units.size()) {
+      tooLong = true;
+      return;
+    }
+    size_t start = units.size();
+    units.resize(start + length);
+    if (ascii) {
+      const auto* characters = static_cast<const unsigned char*>(data);
+      for (size_t index = 0; index < length; index++) units[start + index] = characters[index];
+    } else if (length > 0) {
+      std::memcpy(units.data() + start, data, length * sizeof(uint16_t));
+    }
+  };
+  text.getStringData(runtime, collect);
+  if (tooLong) throwInvalid("The text holds more code units than the core analyses at once");
+}
+
+const narsil_stop_word_set* stopWordsArgument(jsi::Runtime& runtime, const jsi::Value& value) {
+  if (value.isNull()) return nullptr;
+  if (value.isObject()) {
+    jsi::Object handle = value.getObject(runtime);
+    if (handle.hasNativeState<StopWordSetState>(runtime)) return handle.getNativeState<StopWordSetState>(runtime)->set;
+  }
+  throwInvalid("The stop words must be a set from createStopWordSet, or null");
+}
+
+uint32_t* recordsArgument(jsi::Runtime& runtime, const jsi::Value* arguments, size_t count, size_t* capacity) {
+  uint32_t byteOffset = wholeArgument(arguments, count, ANALYSE_RECORD_BYTE_OFFSET, "The record byte offset");
+  uint32_t length = wholeArgument(arguments, count, ANALYSE_RECORD_LENGTH, "The record length");
+  const jsi::Value& value = arguments[ANALYSE_RECORD_BUFFER];
+  if (!value.isObject()) throwInvalid("The records must be a Uint32Array");
+  jsi::Object object = value.getObject(runtime);
+  if (!object.isArrayBuffer(runtime)) throwInvalid("The records must be a Uint32Array");
+  jsi::ArrayBuffer buffer = object.getArrayBuffer(runtime);
+  size_t held = buffer.size(runtime);
+  if (length == 0 || byteOffset > held || static_cast<size_t>(length) > (held - byteOffset) / sizeof(uint32_t)) {
+    throwInvalid("The records reach past the end of their buffer, or hold no entry");
+  }
+  uint8_t* bytes = buffer.data(runtime) + byteOffset;
+  if (reinterpret_cast<uintptr_t>(bytes) % alignof(uint32_t) != 0) throwInvalid("The records are misaligned");
+  *capacity = length;
+  return reinterpret_cast<uint32_t*>(bytes);
+}
+
+bool writeRecords(const narsil_tokens& tokens, uint32_t* records, size_t capacity) {
+  records[0] = tokens.token_count;
+  if (capacity - 1 < static_cast<size_t>(tokens.token_count) * TOKEN_RECORD_WORDS) return false;
+  uint32_t* record = records + 1;
+  for (uint32_t index = 0; index < tokens.token_count; index++) {
+    const narsil_token& token = tokens.tokens[index];
+    record[RECORD_POSITION] = token.position;
+    record[RECORD_TERM_OFFSET] = token.term_offset;
+    record[RECORD_TERM_LENGTH] = token.term_length;
+    record[RECORD_SURFACE_OFFSET] = token.surface_offset;
+    record[RECORD_SURFACE_LENGTH] = token.surface_length;
+    record[RECORD_ORIGINAL_OFFSET] = token.original_offset;
+    record[RECORD_ORIGINAL_LENGTH] = token.original_length;
+    record[RECORD_TERM_SLOT] = token.term_slot;
+    record += TOKEN_RECORD_WORDS;
+  }
+  return true;
+}
+
+jsi::Value statusValue(narsil_status status) { return jsi::Value(-static_cast<double>(status)); }
+
+narsil_analyser* analyserOf(std::unique_ptr<narsil_analyser, AnalyserRelease>& held) {
+  if (held == nullptr) {
+    narsil_analyser* created = nullptr;
+    if (narsil_analyser_create(&created) != NARSIL_OK) return nullptr;
+    held.reset(created);
+  }
+  return held.get();
+}
+
+void readText(jsi::Runtime& runtime, const jsi::Value& value, const char* what, std::vector<uint16_t>& units) {
+  if (!value.isString()) throwInvalid(std::string(what) + " must be a string");
+  units.clear();
+  appendUnits(runtime, value.getString(runtime), units, NARSIL_MAX_ANALYSED_UNITS);
+}
+
+jsi::Value textOf(jsi::Runtime& runtime, std::u16string& out, const uint16_t* units, size_t length) {
+  out.resize(length);
+  if (length > 0) std::memcpy(out.data(), units, length * sizeof(uint16_t));
+  return jsi::String::createFromUtf16(runtime, out);
+}
+
+}
+
+void HybridNarsilCoreImpl::loadHybridMethods() {
+  HybridNarsilCoreSpec::loadHybridMethods();
+  registerHybrids(this, [](Prototype& prototype) {
+    prototype.registerRawHybridMethod("languageCount", 0, &HybridNarsilCoreImpl::languageCount);
+    prototype.registerRawHybridMethod("languageName", 1, &HybridNarsilCoreImpl::languageName);
+    prototype.registerRawHybridMethod("languageRevision", 1, &HybridNarsilCoreImpl::languageRevision);
+    prototype.registerRawHybridMethod("languageStopWords", 1, &HybridNarsilCoreImpl::languageStopWords);
+    prototype.registerRawHybridMethod("createStopWordSet", 1, &HybridNarsilCoreImpl::createStopWordSet);
+    prototype.registerRawHybridMethod("analyse", ANALYSE_ARGUMENT_COUNT, &HybridNarsilCoreImpl::analyse);
+    prototype.registerRawHybridMethod("transform", TRANSFORM_ARGUMENT_COUNT, &HybridNarsilCoreImpl::transform);
+    prototype.registerRawHybridMethod("keywordScore", KEYWORD_SCORE_ARGUMENT_COUNT,
+                                      &HybridNarsilCoreImpl::keywordScore);
+  });
+}
+
+HybridNarsilCoreImpl::RuntimeState& HybridNarsilCoreImpl::stateOf(jsi::Runtime& runtime) {
+  std::lock_guard<std::mutex> guard(_runtimeStateLock);
+  std::unique_ptr<RuntimeState>& held = _stateByRuntime[&runtime];
+  if (held == nullptr) held = std::make_unique<RuntimeState>();
+  return *held;
+}
+
+jsi::Value HybridNarsilCoreImpl::languageCount(jsi::Runtime&, const jsi::Value&, const jsi::Value*, size_t) {
+  return jsi::Value(static_cast<double>(narsil_language_count()));
+}
+
+jsi::Value HybridNarsilCoreImpl::languageName(jsi::Runtime& runtime, const jsi::Value&, const jsi::Value* arguments,
+                                              size_t count) {
+  return jsi::String::createFromAscii(runtime, narsil_language_name(languageArgument(arguments, count, 0)));
+}
+
+jsi::Value HybridNarsilCoreImpl::languageRevision(jsi::Runtime& runtime, const jsi::Value&,
+                                                  const jsi::Value* arguments, size_t count) {
+  return jsi::String::createFromAscii(runtime, narsil_language_revision(languageArgument(arguments, count, 0)));
+}
+
+jsi::Value HybridNarsilCoreImpl::languageStopWords(jsi::Runtime& runtime, const jsi::Value&,
+                                                   const jsi::Value* arguments, size_t count) {
+  narsil_word_list list = {nullptr, nullptr, 0};
+  if (narsil_language_stop_words(languageArgument(arguments, count, 0), &list) != NARSIL_OK) {
+    throwInvalid("The core holds no stop words for that language");
+  }
+  std::u16string& out = stateOf(runtime).textOut;
+  jsi::Array words(runtime, list.count);
+  for (uint32_t index = 0; index < list.count; index++) {
+    uint32_t start = list.offsets[index];
+    words.setValueAtIndex(runtime, index, textOf(runtime, out, list.units + start, list.offsets[index + 1] - start));
+  }
+  return words;
+}
+
+jsi::Value HybridNarsilCoreImpl::createStopWordSet(jsi::Runtime& runtime, const jsi::Value&,
+                                                   const jsi::Value* arguments, size_t count) {
+  if (count < 1 || !arguments[0].isObject() || !arguments[0].getObject(runtime).isArray(runtime)) {
+    throwInvalid("createStopWordSet takes one list of words");
+  }
+  jsi::Array list = arguments[0].getObject(runtime).getArray(runtime);
+  size_t wordCount = list.size(runtime);
+  if (wordCount >= UINT32_MAX) throwInvalid("createStopWordSet takes fewer than 4294967295 words");
+  std::vector<uint16_t> units;
+  std::vector<uint32_t> offsets(wordCount + 1, 0);
+  for (size_t index = 0; index < wordCount; index++) {
+    jsi::Value word = list.getValueAtIndex(runtime, index);
+    if (!word.isString()) throwInvalid("Every stop word must be a string");
+    size_t start = units.size();
+    appendUnits(runtime, word.getString(runtime), units, start + NARSIL_MAX_ANALYSED_UNITS);
+    if (units.size() > UINT32_MAX) throwInvalid("The stop words hold more code units than the core can index");
+    offsets[index + 1] = static_cast<uint32_t>(units.size());
+  }
+  auto state = std::make_shared<StopWordSetState>();
+  narsil_status status = narsil_stop_word_set_create(units.empty() ? NO_UNITS : units.data(), offsets.data(),
+                                                     static_cast<uint32_t>(wordCount), &state->set);
+  if (status == NARSIL_OUT_OF_MEMORY) throwSystemError(ENOMEM, "hold the stop words", "");
+  if (status != NARSIL_OK) throwInvalid("The core cannot hold those stop words");
+  jsi::Object handle(runtime);
+  handle.setNativeState(runtime, state);
+  return handle;
+}
+
+jsi::Value HybridNarsilCoreImpl::analyse(jsi::Runtime& runtime, const jsi::Value&, const jsi::Value* arguments,
+                                         size_t count) {
+  narsil_analysis_request request = {0, nullptr, 0, nullptr, 0};
+  request.language = languageArgument(arguments, count, ANALYSE_LANGUAGE);
+  request.flags = wholeArgument(arguments, count, ANALYSE_FLAGS, "The analysis flags");
+  if (count < ANALYSE_ARGUMENT_COUNT) throwInvalid("analyse takes seven arguments");
+  request.stop_words = stopWordsArgument(runtime, arguments[ANALYSE_STOP_WORDS]);
+  size_t capacity = 0;
+  uint32_t* records = recordsArgument(runtime, arguments, count, &capacity);
+  RuntimeState& analysis = stateOf(runtime);
+  readText(runtime, arguments[ANALYSE_TEXT], "The text", analysis.textUnits);
+  narsil_analyser* active = analyserOf(analysis.analyser);
+  if (active == nullptr) return statusValue(NARSIL_OUT_OF_MEMORY);
+  request.text = analysis.textUnits.empty() ? NO_UNITS : analysis.textUnits.data();
+  request.length = static_cast<uint32_t>(analysis.textUnits.size());
+  narsil_tokens tokens = {nullptr, 0, nullptr, 0};
+  narsil_status status = narsil_analyse(active, &request, &tokens);
+  if (status != NARSIL_OK) return statusValue(status);
+  if (!writeRecords(tokens, records, capacity)) return jsi::Value::null();
+  return textOf(runtime, analysis.textOut, tokens.units, tokens.unit_count);
+}
+
+jsi::Value HybridNarsilCoreImpl::transform(jsi::Runtime& runtime, const jsi::Value&, const jsi::Value* arguments,
+                                           size_t count) {
+  narsil_analysis_request request = {0, nullptr, 0, nullptr, 0};
+  request.language = languageArgument(arguments, count, TRANSFORM_LANGUAGE);
+  request.flags = wholeArgument(arguments, count, TRANSFORM_FLAGS, "The transform flags");
+  if (count < TRANSFORM_ARGUMENT_COUNT) throwInvalid("transform takes three arguments");
+  RuntimeState& analysis = stateOf(runtime);
+  readText(runtime, arguments[TRANSFORM_TEXT], "The token", analysis.textUnits);
+  narsil_analyser* active = analyserOf(analysis.analyser);
+  if (active == nullptr) return statusValue(NARSIL_OUT_OF_MEMORY);
+  request.text = analysis.textUnits.empty() ? NO_UNITS : analysis.textUnits.data();
+  request.length = static_cast<uint32_t>(analysis.textUnits.size());
+  narsil_term term = {nullptr, 0};
+  narsil_status status = narsil_transform(active, &request, &term);
+  if (status != NARSIL_OK) return statusValue(status);
+  return textOf(runtime, analysis.textOut, term.units, term.length);
+}
+
+}

package/cpp/HybridNarsilCoreImpl.hpp

@@ -1,20 +1,51 @@
 #pragma once
 
 #include "HybridNarsilCoreSpec.hpp"
+#include "narsil_analysis.h"
 #include "narsil_core.h"
+#include "narsil_keyword.h"
 
 #include <cstdint>
+#include <memory>
 #include <mutex>
+#include <string>
 #include <unordered_map>
 #include <unordered_set>
+#include <vector>
 
 namespace margelo::nitro::narsil {
 
+struct AnalyserRelease {
+  void operator()(narsil_analyser* analyser) const { narsil_analyser_destroy(analyser); }
+};
+
+inline constexpr size_t KEYWORD_SCORE_ARGUMENT_COUNT = 23;
+
+struct WorkspaceRelease {
+  void operator()(narsil_workspace* workspace) const { narsil_workspace_destroy(workspace); }
+};
+
 class HybridNarsilCoreImpl : public HybridNarsilCoreSpec {
 public:
   HybridNarsilCoreImpl() : HybridObject(TAG) {}
   ~HybridNarsilCoreImpl() override;
 
+  void loadHybridMethods() override;
+  jsi::Value languageCount(jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+                           size_t count);
+  jsi::Value languageName(jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+                          size_t count);
+  jsi::Value languageRevision(jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+                              size_t count);
+  jsi::Value languageStopWords(jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+                               size_t count);
+  jsi::Value createStopWordSet(jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+                               size_t count);
+  jsi::Value analyse(jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments, size_t count);
+  jsi::Value transform(jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments, size_t count);
+  jsi::Value keywordScore(jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+                          size_t count);
+
   double abiVersion() override;
   double workspaceBytes() override;
   std::shared_ptr<HybridNarsilAttachedGraphSpec> attachGraph(const GraphMemory& memory) override;
@@ -53,11 +84,23 @@ public:
                  const MemoryView& ordinals, double count, const MemoryView& totals) override;
   double quantise(const std::shared_ptr<HybridNarsilAttachedStoreSpec>& store, double metric,
                   const MemoryView& ordinals, double count) override;
+  double applyMath(double operation, const MemoryView& first, const MemoryView& second,
+                   const MemoryView& results) override;
 
   narsil_workspace* claimBackgroundSlot(uint32_t threadSlot);
   void releaseBackgroundSlot(uint32_t threadSlot);
 
 private:
+  struct RuntimeState {
+    std::unique_ptr<narsil_analyser, AnalyserRelease> analyser;
+    std::vector<uint16_t> textUnits;
+    std::u16string textOut;
+    std::unique_ptr<narsil_workspace, WorkspaceRelease> keywordWorkspace;
+    std::vector<narsil_keyword_column> keywordLengths;
+  };
+  RuntimeState& stateOf(jsi::Runtime& runtime);
+  std::mutex _runtimeStateLock;
+  std::unordered_map<jsi::Runtime*, std::unique_ptr<RuntimeState>> _stateByRuntime;
   narsil_workspace* workspace();
   narsil_workspace* _workspace = nullptr;
   std::mutex _backgroundLock;