react-native-marcus 0.1.0

package/apple/RCTMarcusStyle+Codegen.h

@@ -0,0 +1,18 @@
+#import <RNMarcus/RCTMarcusStyle.h>
+
+#import <react/renderer/components/RNMarcusSpec/Props.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+// Conversion from the codegen props struct lives in a separate category so that
+// `RCTMarcusStyle.h` itself stays free of C++. Only the component view and
+// the shadow node need this header; everything downstream can import the plain
+// one.
+@interface RCTMarcusStyle (Codegen)
+
+- (instancetype)initWithStruct:
+  (const facebook::react::MarcusTextInputDecoratorViewMarkdownStyleStruct &)style;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/apple/RCTMarcusStyle+Codegen.mm

@@ -0,0 +1,64 @@
+#import <RNMarcus/RCTMarcusStyle+Codegen.h>
+
+#import <React/RCTConversions.h>
+
+@implementation RCTMarcusStyle (Codegen)
+
+- (instancetype)initWithStruct:
+  (const facebook::react::MarcusTextInputDecoratorViewMarkdownStyleStruct &)style {
+  if (self = [super init]) {
+    self.syntaxColor = RCTUIColorFromSharedColor(style.syntax.color);
+
+    self.linkColor = RCTUIColorFromSharedColor(style.link.color);
+
+    self.headingFontSize = style.heading.fontSize;
+    self.headingScale = style.heading.scale;
+
+    self.emojiFontSize = style.emoji.fontSize;
+    self.emojiFontFamily = RCTNSStringFromString(style.emoji.fontFamily);
+
+    self.blockquoteBorderColor =
+      RCTUIColorFromSharedColor(style.blockquote.borderColor);
+    self.blockquoteBorderWidth = style.blockquote.borderWidth;
+    self.blockquoteMarginLeft = style.blockquote.marginLeft;
+    self.blockquotePaddingLeft = style.blockquote.paddingLeft;
+
+    self.orderedListMarginLeft = style.orderedList.marginLeft;
+    self.orderedListPaddingLeft = style.orderedList.paddingLeft;
+
+    self.unorderedListMarginLeft = style.unorderedList.marginLeft;
+    self.unorderedListPaddingLeft = style.unorderedList.paddingLeft;
+
+    self.codeFontFamily = RCTNSStringFromString(style.code.fontFamily);
+    self.codeFontSize = style.code.fontSize;
+    self.codeColor = RCTUIColorFromSharedColor(style.code.color);
+    self.codeBackgroundColor =
+      RCTUIColorFromSharedColor(style.code.backgroundColor);
+
+    self.preFontFamily = RCTNSStringFromString(style.pre.fontFamily);
+    self.preFontSize = style.pre.fontSize;
+    self.preColor = RCTUIColorFromSharedColor(style.pre.color);
+    self.preBackgroundColor =
+      RCTUIColorFromSharedColor(style.pre.backgroundColor);
+
+    self.mentionHereColor = RCTUIColorFromSharedColor(style.mentionHere.color);
+    self.mentionHereBackgroundColor =
+      RCTUIColorFromSharedColor(style.mentionHere.backgroundColor);
+    self.mentionHereBorderRadius = style.mentionHere.borderRadius;
+
+    self.mentionUserColor = RCTUIColorFromSharedColor(style.mentionUser.color);
+    self.mentionUserBackgroundColor =
+      RCTUIColorFromSharedColor(style.mentionUser.backgroundColor);
+    self.mentionUserBorderRadius = style.mentionUser.borderRadius;
+
+    self.mentionReportColor =
+      RCTUIColorFromSharedColor(style.mentionReport.color);
+    self.mentionReportBackgroundColor =
+      RCTUIColorFromSharedColor(style.mentionReport.backgroundColor);
+    self.mentionReportBorderRadius = style.mentionReport.borderRadius;
+  }
+
+  return self;
+}
+
+@end

package/apple/RCTMarcusStyle.h

@@ -0,0 +1,41 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTMarcusStyle : NSObject
+
+@property(nonatomic) UIColor *syntaxColor;
+@property(nonatomic) UIColor *linkColor;
+@property(nonatomic) CGFloat headingFontSize;
+@property(nonatomic) CGFloat headingScale;
+@property(nonatomic) CGFloat emojiFontSize;
+@property(nonatomic) NSString *emojiFontFamily;
+@property(nonatomic) UIColor *blockquoteBorderColor;
+@property(nonatomic) CGFloat blockquoteBorderWidth;
+@property(nonatomic) CGFloat blockquoteMarginLeft;
+@property(nonatomic) CGFloat blockquotePaddingLeft;
+@property(nonatomic) CGFloat orderedListMarginLeft;
+@property(nonatomic) CGFloat orderedListPaddingLeft;
+@property(nonatomic) CGFloat unorderedListMarginLeft;
+@property(nonatomic) CGFloat unorderedListPaddingLeft;
+@property(nonatomic) NSString *codeFontFamily;
+@property(nonatomic) CGFloat codeFontSize;
+@property(nonatomic) UIColor *codeColor;
+@property(nonatomic) UIColor *codeBackgroundColor;
+@property(nonatomic) NSString *preFontFamily;
+@property(nonatomic) CGFloat preFontSize;
+@property(nonatomic) UIColor *preColor;
+@property(nonatomic) UIColor *preBackgroundColor;
+@property(nonatomic) UIColor *mentionHereColor;
+@property(nonatomic) UIColor *mentionHereBackgroundColor;
+@property(nonatomic) CGFloat mentionHereBorderRadius;
+@property(nonatomic) UIColor *mentionUserColor;
+@property(nonatomic) UIColor *mentionUserBackgroundColor;
+@property(nonatomic) CGFloat mentionUserBorderRadius;
+@property(nonatomic) UIColor *mentionReportColor;
+@property(nonatomic) UIColor *mentionReportBackgroundColor;
+@property(nonatomic) CGFloat mentionReportBorderRadius;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/apple/RCTMarcusStyle.m

@@ -0,0 +1,5 @@
+#import <RNMarcus/RCTMarcusStyle.h>
+
+@implementation RCTMarcusStyle
+
+@end

package/apple/RCTMarcusUtils.h

@@ -0,0 +1,26 @@
+#import <RNMarcus/RCTMarcusStyle.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+// Parses and formats in one step for the view layer.
+//
+// Parsing is stateful (it owns the parser's memo cache) so it stays here rather
+// than moving to Swift; formatting itself is a stateless Swift call. One
+// instance is owned per text input and only ever touched on the main thread.
+@interface RCTMarcusUtils : NSObject
+
+// Nullable: both are assigned after init (props arrive after the view
+// hierarchy is built), and applyMarkdownFormatting: bails out when either is
+// still nil.
+@property(nonatomic, nullable) RCTMarcusStyle *markdownStyle;
+@property(nonatomic, nullable) NSNumber *parserId;
+
+- (void)applyMarkdownFormatting:
+          (nonnull NSMutableAttributedString *)attributedString
+      withDefaultTextAttributes:
+        (nonnull NSDictionary<NSAttributedStringKey, id> *)defaultTextAttributes;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/apple/RCTMarcusUtils.mm

@@ -0,0 +1,26 @@
+#import <RNMarcus/MarkdownSwiftInterop.h>
+#import <RNMarcus/RCTMarcusUtils.h>
+
+@implementation RCTMarcusUtils
+
+- (void)applyMarkdownFormatting:
+          (nonnull NSMutableAttributedString *)attributedString
+      withDefaultTextAttributes:
+        (nonnull NSDictionary<NSAttributedStringKey, id> *)defaultTextAttributes {
+  // `markdownStyle` and `parserId` may not be set yet: props are applied after
+  // the view hierarchy is built.
+  if (_markdownStyle == nil || _parserId == nil) {
+    return;
+  }
+
+  NSArray<MarcusRange *> *markdownRanges =
+    [[MarkdownParser sharedParser] parse:attributedString.string
+                            withParserId:_parserId];
+
+  [MarkdownFormatter formatAttributedString:attributedString
+                      defaultTextAttributes:defaultTextAttributes
+                                     ranges:markdownRanges
+                                      style:_markdownStyle];
+}
+
+@end

package/apple/RCTTextInput+AdaptiveImageGlyph.h

@@ -0,0 +1,16 @@
+#import <React/RCTUITextField.h>
+#import <React/RCTUITextView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTUITextField (AdaptiveImageGlyph)
+- (void)marcus_insertAdaptiveImageGlyph:(id)glyph
+                       replacementRange:(NSRange)replacementRange;
+@end
+
+@interface RCTUITextView (AdaptiveImageGlyph)
+- (void)marcus_insertAdaptiveImageGlyph:(id)glyph
+                       replacementRange:(NSRange)replacementRange;
+@end
+
+NS_ASSUME_NONNULL_END

package/apple/RCTTextInput+AdaptiveImageGlyph.mm

@@ -0,0 +1,79 @@
+#import <RNMarcus/MarkdownSwiftInterop.h>
+#import <RNMarcus/RCTTextInput+AdaptiveImageGlyph.h>
+
+#import <objc/runtime.h>
+
+// Kept as .mm rather than .m: plain Objective-C translation units in this pod
+// compile with modules enabled, which makes importing any React header build
+// the React clang module -- and that fails against React Native's prebuilt
+// xcframework. Objective-C++ uses textual includes and avoids it.
+
+// Installs `marcus_insertAdaptiveImageGlyph:replacementRange:` in place
+// of UIKit's `insertAdaptiveImageGlyph:replacementRange:`. The handler itself
+// is in Swift; only the runtime plumbing has to live here, because Swift cannot
+// define
+// `+load`.
+static void
+RCTMarcusSwizzleAdaptiveImageGlyph(Class targetClass, SEL swizzledSelector) {
+  if (@available(iOS 18.0, *)) {
+    SEL originalSelector = @selector(insertAdaptiveImageGlyph:
+                                             replacementRange:);
+
+    if (![targetClass instancesRespondToSelector:originalSelector]) {
+      return;
+    }
+
+    Method originalMethod =
+      class_getInstanceMethod(targetClass, originalSelector);
+    Method swizzledMethod =
+      class_getInstanceMethod(targetClass, swizzledSelector);
+    if (!originalMethod || !swizzledMethod) {
+      return;
+    }
+
+    BOOL didAddMethod = class_addMethod(
+      targetClass, originalSelector, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod)
+    );
+    if (didAddMethod) {
+      class_replaceMethod(targetClass, swizzledSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod));
+    } else {
+      method_exchangeImplementations(originalMethod, swizzledMethod);
+    }
+  }
+}
+
+@implementation RCTUITextField (AdaptiveImageGlyph)
+
++ (void)load {
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    RCTMarcusSwizzleAdaptiveImageGlyph([self class], @selector(marcus_insertAdaptiveImageGlyph:
+                                                                              replacementRange:));
+  });
+}
+
+- (void)marcus_insertAdaptiveImageGlyph:(id)glyph
+                       replacementRange:(NSRange)replacementRange {
+  // Deliberately does not call through to the original: the glyph is pasted as
+  // a plain image instead of being inserted as an adaptive glyph.
+  [MarkdownAdaptiveImageGlyph handlePasteInTextInputView:self glyph:glyph];
+}
+
+@end
+
+@implementation RCTUITextView (AdaptiveImageGlyph)
+
++ (void)load {
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    RCTMarcusSwizzleAdaptiveImageGlyph([self class], @selector(marcus_insertAdaptiveImageGlyph:
+                                                                              replacementRange:));
+  });
+}
+
+- (void)marcus_insertAdaptiveImageGlyph:(id)glyph
+                       replacementRange:(NSRange)replacementRange {
+  [MarkdownAdaptiveImageGlyph handlePasteInTextInputView:self glyph:glyph];
+}
+
+@end

package/apple/RCTTextInputComponentView+Marcus.h

@@ -0,0 +1,11 @@
+#import <React/RCTTextInputComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTTextInputComponentView (Marcus)
+
+- (BOOL)marcus__textOf:(NSAttributedString *)newText equals:(NSAttributedString *)oldText;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/apple/RCTTextInputComponentView+Marcus.mm

@@ -0,0 +1,79 @@
+#import <RNMarcus/MarkdownAttributes.h>
+#import <RNMarcus/MarcusTextInputDecoratorComponentView.h>
+#import <RNMarcus/RCTTextInputComponentView+Marcus.h>
+#import <objc/message.h>
+
+@implementation RCTTextInputComponentView (Marcus)
+
+- (BOOL)marcus__textOf:(NSAttributedString *)newText
+                  equals:(NSAttributedString *)oldText {
+  __block BOOL isMarkdownTextInput = false;
+  [oldText enumerateAttribute:RCTMarcusTextAttributeName
+                      inRange:NSMakeRange(0, oldText.length)
+                      options:0
+                   usingBlock:^(id value, NSRange range, BOOL *stop) {
+                     if (value) {
+                       isMarkdownTextInput = true;
+                       *stop = YES;
+                     }
+                   }];
+  if (isMarkdownTextInput) {
+    return [newText.string isEqualToString:oldText.string];
+  }
+
+  return [self marcus__textOf:newText equals:oldText];
+}
+
+- (void)marcus_didAddSubview:(UIView *)subview {
+  [self marcus_didAddSubview:subview];
+
+  // React Native swaps `_backedTextInputView` in place when `multiline`
+  // changes: it removes the old view from this component view and adds a new
+  // one. That never touches the decorator's own subviews, so its didAddSubview:
+  // does not fire and its observers would stay bound to the discarded view --
+  // keeping it alive and leaving the new, visible one unformatted.
+  UIView *parent = self.superview;
+  if ([parent isKindOfClass:[MarcusTextInputDecoratorComponentView class]]) {
+    [(MarcusTextInputDecoratorComponentView *)
+        parent reattachTextInputObservers];
+  }
+}
+
+// Installs `swizzledSelector` in place of `originalSelector` on `cls`.
+//
+// method_exchangeImplementations alone is only safe when `cls` implements
+// `originalSelector` itself. For an inherited method -- didAddSubview:, for
+// instance -- class_getInstanceMethod returns the *superclass's* method, and
+// exchanging it rewrites UIView for every view in the app. So the
+// implementation is added to this class first; when that succeeds, the
+// "call the original" selector is pointed at the inherited implementation.
+static void
+RCTMarcusSwizzle(Class cls, SEL originalSelector, SEL swizzledSelector) {
+  Method originalMethod = class_getInstanceMethod(cls, originalSelector);
+  Method swizzledMethod = class_getInstanceMethod(cls, swizzledSelector);
+  if (originalMethod == NULL || swizzledMethod == NULL) {
+    return;
+  }
+
+  BOOL didAddMethod = class_addMethod(cls, originalSelector, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod));
+  if (didAddMethod) {
+    class_replaceMethod(cls, swizzledSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod));
+  } else {
+    method_exchangeImplementations(originalMethod, swizzledMethod);
+  }
+}
+
++ (void)load {
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    Class cls = [self class];
+
+    // Implemented by this class, so this is a plain exchange.
+    RCTMarcusSwizzle(cls, @selector(_textOf:equals:), @selector(marcus__textOf:equals:));
+
+    // Inherited from UIView, so this must go through class_addMethod.
+    RCTMarcusSwizzle(cls, @selector(didAddSubview:), @selector(marcus_didAddSubview:));
+  });
+}
+
+@end

package/cpp/MarkdownCxx.modulemap

@@ -0,0 +1,8 @@
+// Exposes the pure-C++ parser to Swift. Kept separate from the pod's generated
+// Objective-C umbrella, which Swift parses in Objective-C mode and therefore
+// cannot contain any C++.
+module MarkdownCxx {
+  header "MarkdownWorkletParser.h"
+  requires cplusplus
+  export *
+}

package/cpp/MarkdownGlobal.cpp

@@ -0,0 +1,48 @@
+#include "MarkdownGlobal.h"
+
+#include <unordered_map>
+
+using namespace facebook;
+
+namespace bulletpoint {
+namespace marcus {
+
+std::shared_ptr<WorkletRuntime> globalMarkdownWorkletRuntime;
+
+void
+setMarkdownRuntime(const std::shared_ptr<WorkletRuntime> &markdownWorkletRuntime) {
+  globalMarkdownWorkletRuntime = markdownWorkletRuntime;
+}
+
+std::shared_ptr<WorkletRuntime>
+getMarkdownRuntime() {
+  return globalMarkdownWorkletRuntime;
+}
+
+std::unordered_map<int, std::shared_ptr<SerializableWorklet>> globalMarkdownShareableWorklets;
+std::mutex globalMarkdownShareableWorkletsMutex;
+int nextParserId = 1;
+
+const int
+registerMarkdownWorklet(const std::shared_ptr<SerializableWorklet> &markdownWorklet) {
+  assert(markdownWorklet != nullptr);
+  auto parserId = nextParserId++;
+  std::unique_lock<std::mutex> lock(globalMarkdownShareableWorkletsMutex);
+  globalMarkdownShareableWorklets[parserId] = markdownWorklet;
+  return parserId;
+}
+
+void
+unregisterMarkdownWorklet(const int parserId) {
+  std::unique_lock<std::mutex> lock(globalMarkdownShareableWorkletsMutex);
+  globalMarkdownShareableWorklets.erase(parserId);
+}
+
+std::shared_ptr<SerializableWorklet>
+getMarkdownWorklet(const int parserId) {
+  std::unique_lock<std::mutex> lock(globalMarkdownShareableWorkletsMutex);
+  return globalMarkdownShareableWorklets.at(parserId);
+}
+
+} // namespace marcus
+} // namespace bulletpoint

package/cpp/MarkdownGlobal.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+using namespace facebook;
+using namespace worklets;
+
+namespace bulletpoint {
+namespace marcus {
+
+void
+setMarkdownRuntime(
+  const std::shared_ptr<WorkletRuntime> &markdownWorkletRuntime
+);
+
+std::shared_ptr<WorkletRuntime>
+getMarkdownRuntime();
+
+const int
+registerMarkdownWorklet(
+  const std::shared_ptr<SerializableWorklet> &markdownWorklet
+);
+
+void
+unregisterMarkdownWorklet(const int parserId);
+
+std::shared_ptr<SerializableWorklet>
+getMarkdownWorklet(const int parserId);
+
+} // namespace marcus
+} // namespace bulletpoint

package/cpp/MarkdownWorkletParser.cpp

@@ -0,0 +1,93 @@
+#include "MarkdownWorkletParser.h"
+
+#include "MarkdownGlobal.h"
+
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+namespace bulletpoint {
+namespace marcus {
+
+namespace {
+
+bool
+requiresDepth(const std::string &type) {
+  return type == "blockquote" || type == "heading" ||
+    type == "list-ordered" || type == "list-unordered";
+}
+
+constexpr int kMaxDepth = 6;
+
+} // namespace
+
+ParseResult
+parseMarkdown(const std::string &utf8Text, size_t textLengthUtf16, int parserId) {
+  const auto &markdownRuntime = getMarkdownRuntime();
+  jsi::Runtime &rt = markdownRuntime->getJSIRuntime();
+
+  std::shared_ptr<SerializableWorklet> markdownWorklet;
+  try {
+    markdownWorklet = getMarkdownWorklet(parserId);
+  } catch (const std::out_of_range &) {
+    // Parser was never registered, or was already unregistered.
+    return {};
+  }
+
+  const auto &input = jsi::String::createFromUtf8(rt, utf8Text);
+
+  jsi::Value output;
+  try {
+    output = markdownRuntime->runGuarded(markdownWorklet, input);
+  } catch (const jsi::JSError &) {
+    // Skip formatting; runGuarded will have surfaced the error in LogBox.
+    return {};
+  }
+
+  std::vector<MarkdownRange> ranges;
+  try {
+    const auto &items = output.asObject(rt).asArray(rt);
+    const size_t count = items.size(rt);
+    ranges.reserve(count);
+
+    for (size_t i = 0; i < count; ++i) {
+      const auto &item = items.getValueAtIndex(rt, i).asObject(rt);
+      auto type = item.getProperty(rt, "type").asString(rt).utf8(rt);
+      const auto start =
+        static_cast<int>(item.getProperty(rt, "start").asNumber());
+      const auto length =
+        static_cast<int>(item.getProperty(rt, "length").asNumber());
+      int depth = 1;
+      if (item.hasProperty(rt, "depth")) {
+        depth = static_cast<int>(item.getProperty(rt, "depth").asNumber());
+
+        if (requiresDepth(type) && depth < 1) {
+          return {{}, "range of type '" + type + "' has a `depth` of " + std::to_string(depth) + ", which must be at least 1"};
+        }
+
+        if (depth > kMaxDepth) {
+          depth = kMaxDepth;
+        }
+      } else if (requiresDepth(type)) {
+        return {{}, "range of type '" + type + "' is missing `depth`"};
+      }
+
+      // `start` is checked explicitly because the offsets come from JS and a
+      // negative one would wrap when converted to an unsigned platform range.
+      if (length <= 0 || start < 0 ||
+          static_cast<size_t>(start) + static_cast<size_t>(length) >
+            textLengthUtf16) {
+        continue;
+      }
+
+      ranges.push_back(MarkdownRange{std::move(type), start, length, depth});
+    }
+  } catch (const jsi::JSError &error) {
+    return {{}, error.getMessage()};
+  }
+
+  return {std::move(ranges), ""};
+}
+
+} // namespace marcus
+} // namespace bulletpoint

package/cpp/MarkdownWorkletParser.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <cstddef>
+#include <string>
+#include <vector>
+
+namespace bulletpoint {
+namespace marcus {
+
+struct MarkdownRange {
+  std::string type;
+  int start;
+  int length;
+  int depth;
+};
+
+struct ParseResult {
+  std::vector<MarkdownRange> ranges;
+
+  // Non-empty when the worklet returned something that didn't match the
+  // expected schema. Reporting is left to the caller so this stays free of any
+  // platform logging dependency.
+  std::string schemaError;
+};
+
+// Runs a registered markdown parser worklet and returns the ranges it produced.
+//
+// Stateless and lock-free on purpose. Running the worklet waits on the markdown
+// runtime, and holding a lock across that wait is what allowed a background
+// parse to block the main thread until iOS killed the app
+// (Expensify/react-native-live-markdown#772). Caching therefore belongs to the
+// caller, which must not hold its cache lock while calling this.
+//
+// `utf8Text` is the text to parse, UTF-8 encoded for the JSI boundary.
+//
+// `textLengthUtf16` is the same text's length in UTF-16 code units. It is
+// passed separately rather than derived from `utf8Text.size()` because the
+// worklet reports range offsets in UTF-16 units, matching JS string indices.
+// For any non-ASCII text the UTF-8 byte count is larger, so validating against
+// it would let out-of-bounds ranges through.
+ParseResult
+parseMarkdown(const std::string &utf8Text, size_t textLengthUtf16, int parserId);
+
+} // namespace marcus
+} // namespace bulletpoint

package/cpp/RuntimeDecorator.cpp

@@ -0,0 +1,39 @@
+#include "RuntimeDecorator.h"
+#include "MarkdownGlobal.h"
+
+using namespace facebook;
+using namespace worklets;
+
+namespace bulletpoint {
+namespace marcus {
+
+void
+injectJSIBindings(jsi::Runtime &rt) {
+
+  rt.global().setProperty(
+    rt, "jsi_setMarcusRuntime", jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "jsi_setMarcusRuntime"), 1, [](jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) -> jsi::Value {
+      setMarkdownRuntime(extractWorkletRuntime(rt, args[0]));
+      return jsi::Value::undefined();
+    })
+  );
+
+  rt.global().setProperty(
+    rt, "jsi_registerMarcusWorklet", jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "jsi_registerMarcusWorklet"), 1, [](jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) -> jsi::Value {
+      const auto parserId = registerMarkdownWorklet(
+        extractSerializableOrThrow<SerializableWorklet>(rt, args[0])
+      );
+      return jsi::Value(parserId);
+    })
+  );
+
+  rt.global().setProperty(
+    rt, "jsi_unregisterMarcusWorklet", jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "jsi_unregisterMarcusWorklet"), 1, [](jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) -> jsi::Value {
+      auto parserId = static_cast<int>(args[0].asNumber());
+      unregisterMarkdownWorklet(parserId);
+      return jsi::Value::undefined();
+    })
+  );
+}
+
+} // namespace marcus
+} // namespace bulletpoint

package/cpp/RuntimeDecorator.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+using namespace facebook;
+
+namespace bulletpoint {
+namespace marcus {
+
+void
+injectJSIBindings(jsi::Runtime &rt);
+
+} // namespace marcus
+} // namespace bulletpoint