diff --git a/android/src/main/cpp/MarkdownParser.cpp b/android/src/main/cpp/MarkdownParser.cpp
index 4edd28ec9..c98baa770 100644
--- a/android/src/main/cpp/MarkdownParser.cpp
+++ b/android/src/main/cpp/MarkdownParser.cpp
@@ -11,11 +11,15 @@ namespace livemarkdown {
       jni::alias_ref<jhybridobject> jThis,
       jni::alias_ref<jni::JString> text,
       const int parserId) {
+    const auto markdownWorklet = expensify::livemarkdown::findMarkdownWorklet(parserId);
+    if (markdownWorklet == nullptr) {
+      // Null tells the Java side apart from a parser that returned no ranges.
+      return nullptr;
+    }
+
     const auto markdownRuntime = expensify::livemarkdown::getMarkdownRuntime();
     jsi::Runtime &rt = markdownRuntime->getJSIRuntime();
 
-    const auto markdownWorklet = expensify::livemarkdown::getMarkdownWorklet(parserId);
-
     const auto input = jsi::String::createFromUtf8(rt, text->toStdString());
     const auto output = markdownRuntime->runGuarded(markdownWorklet, input);
 
diff --git a/android/src/main/java/com/expensify/livemarkdown/MarkdownParser.java b/android/src/main/java/com/expensify/livemarkdown/MarkdownParser.java
index 3e108db70..260925b92 100644
--- a/android/src/main/java/com/expensify/livemarkdown/MarkdownParser.java
+++ b/android/src/main/java/com/expensify/livemarkdown/MarkdownParser.java
@@ -1,6 +1,7 @@
 package com.expensify.livemarkdown;
 
 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.util.RNLog;
@@ -29,7 +30,8 @@ public MarkdownParser(@NonNull ReactContext reactContext) {
     mReactContext = reactContext;
   }
 
-  private native String nativeParse(@NonNull String text, int parserId);
+  // Returns null when no parser is registered under `parserId`.
+  private native @Nullable String nativeParse(@NonNull String text, int parserId);
 
   public synchronized List<MarkdownRange> parse(@NonNull String text, int parserId) {
     try {
@@ -53,6 +55,13 @@ public synchronized List<MarkdownRange> parse(@NonNull String text, int parserId
         Systrace.endSection(0);
       }
 
+      if (json == null) {
+        // The parser is registered before the view is committed, so this points at a broken registration. Leave the
+        // cache alone so the next parse picks the parser up once it is registered.
+        RNLog.w(mReactContext, "[react-native-live-markdown] No parser registered for parserId " + parserId);
+        return Collections.emptyList();
+      }
+
       List<MarkdownRange> markdownRanges = new LinkedList<>();
       try {
         Systrace.beginSection(0, "markdownRanges");
diff --git a/apple/MarkdownParser.h b/apple/MarkdownParser.h
index 1d73622d6..f506f5ffc 100644
--- a/apple/MarkdownParser.h
+++ b/apple/MarkdownParser.h
@@ -23,7 +23,9 @@ NS_ASSUME_NONNULL_BEGIN
 // is parsed as soon as it finishes.
 //
 // `completion` runs on the background queue once the text is cached. It is
-// skipped if a newer call replaced this one, since that call reports instead.
+// skipped if a newer call replaced this one, since that call reports instead,
+// and if no parser is registered under `parserId`, since nothing was cached
+// and a new measure would find nothing either.
 - (void)warmCacheAsyncForText:(nonnull NSString *)text
                  withParserId:(nonnull NSNumber *)parserId
                    completion:(nullable void (^)(void))completion;
diff --git a/apple/MarkdownParser.mm b/apple/MarkdownParser.mm
index 89bb209b4..3c438f766 100644
--- a/apple/MarkdownParser.mm
+++ b/apple/MarkdownParser.mm
@@ -171,13 +171,13 @@ - (void)drainPendingWarmups
       _pendingCompletion = nil;
     }
 
-    [self parse:text withParserId:parserId];
+    BOOL cached = [self parseIfRegistered:text withParserId:parserId] != nil;
 
     BOOL superseded;
     @synchronized (self) {
       superseded = _pendingText != nil;
     }
-    if (completion != nil && !superseded) {
+    if (completion != nil && !superseded && cached) {
       completion();
     }
   }
@@ -185,6 +185,14 @@ - (void)drainPendingWarmups
 
 - (NSArray<MarkdownRange *> *)parse:(nonnull NSString *)text
                        withParserId:(nonnull NSNumber *)parserId
+{
+  return [self parseIfRegistered:text withParserId:parserId] ?: @[];
+}
+
+// Returns nil when no parser is registered under `parserId`. Nothing is cached
+// then, so the next parse picks the parser up once it is registered.
+- (nullable NSArray<MarkdownRange *> *)parseIfRegistered:(nonnull NSString *)text
+                                            withParserId:(nonnull NSNumber *)parserId
 {
   NSArray<MarkdownRange *> *cached = [self cachedRangesForText:text withParserId:parserId];
   if (cached != nil) {
@@ -200,25 +208,29 @@ - (void)drainPendingWarmups
   // Two threads may end up parsing the same text at the same time. That is
   // fine: they run one after the other and produce the same result.
   NSArray<MarkdownRange *> *markdownRanges = [self parseUncached:text withParserId:parserId];
+  if (markdownRanges == nil) {
+    return nil;
+  }
 
   [self cacheMarkdownRanges:markdownRanges forText:text withParserId:parserId];
 
   return markdownRanges;
 }
 
-- (NSArray<MarkdownRange *> *)parseUncached:(nonnull NSString *)text
-                               withParserId:(nonnull NSNumber *)parserId
+- (nullable NSArray<MarkdownRange *> *)parseUncached:(nonnull NSString *)text
+                                        withParserId:(nonnull NSNumber *)parserId
 {
+  const auto markdownWorklet = expensify::livemarkdown::findMarkdownWorklet([parserId intValue]);
+  if (markdownWorklet == nullptr) {
+    // The parser is registered before the view is committed, but a queued
+    // warmup may run after it is unregistered on unmount or a parser change.
+    RCTLogWarn(@"[react-native-live-markdown] No parser registered for parserId %@", parserId);
+    return nil;
+  }
+
   const auto &markdownRuntime = expensify::livemarkdown::getMarkdownRuntime();
   jsi::Runtime &rt = markdownRuntime->getJSIRuntime();
 
-  std::shared_ptr<SerializableWorklet> markdownWorklet;
-  try {
-    markdownWorklet = expensify::livemarkdown::getMarkdownWorklet([parserId intValue]);
-  } catch (const std::out_of_range &error) {
-    return @[];
-  }
-
   const auto &input = jsi::String::createFromUtf8(rt, [text UTF8String]);
 
   jsi::Value output;
diff --git a/cpp/MarkdownGlobal.cpp b/cpp/MarkdownGlobal.cpp
index 67f93eb43..cd1658694 100644
--- a/cpp/MarkdownGlobal.cpp
+++ b/cpp/MarkdownGlobal.cpp
@@ -19,14 +19,11 @@ std::shared_ptr<WorkletRuntime> getMarkdownRuntime() {
 
 std::unordered_map<int, std::shared_ptr<SerializableWorklet>> globalMarkdownShareableWorklets;
 std::mutex globalMarkdownShareableWorkletsMutex;
-int nextParserId = 1;
 
-const int registerMarkdownWorklet(const std::shared_ptr<SerializableWorklet> &markdownWorklet) {
+void registerMarkdownWorklet(const int parserId, 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) {
@@ -34,9 +31,10 @@ void unregisterMarkdownWorklet(const int parserId) {
   globalMarkdownShareableWorklets.erase(parserId);
 }
 
-std::shared_ptr<SerializableWorklet> getMarkdownWorklet(const int parserId) {
+std::shared_ptr<SerializableWorklet> findMarkdownWorklet(const int parserId) {
   std::unique_lock<std::mutex> lock(globalMarkdownShareableWorkletsMutex);
-  return globalMarkdownShareableWorklets.at(parserId);
+  const auto it = globalMarkdownShareableWorklets.find(parserId);
+  return it == globalMarkdownShareableWorklets.end() ? nullptr : it->second;
 }
 
 } // namespace livemarkdown
diff --git a/cpp/MarkdownGlobal.h b/cpp/MarkdownGlobal.h
index e18172613..739d7b6e3 100644
--- a/cpp/MarkdownGlobal.h
+++ b/cpp/MarkdownGlobal.h
@@ -14,11 +14,14 @@ void setMarkdownRuntime(const std::shared_ptr<WorkletRuntime> &markdownWorkletRu
 
 std::shared_ptr<WorkletRuntime> getMarkdownRuntime();
 
-const int registerMarkdownWorklet(const std::shared_ptr<SerializableWorklet> &markdownWorklet);
+// JS picks the id, one per mounted input, so the decorator view can carry it
+// in the same commit that registers the worklet.
+void registerMarkdownWorklet(const int parserId, const std::shared_ptr<SerializableWorklet> &markdownWorklet);
 
 void unregisterMarkdownWorklet(const int parserId);
 
-std::shared_ptr<SerializableWorklet> getMarkdownWorklet(const int parserId);
+// Returns nullptr when nothing is registered under `parserId`.
+std::shared_ptr<SerializableWorklet> findMarkdownWorklet(const int parserId);
 
 } // namespace livemarkdown
 } // namespace expensify
diff --git a/cpp/RuntimeDecorator.cpp b/cpp/RuntimeDecorator.cpp
index f7ed5f91b..211b286cc 100644
--- a/cpp/RuntimeDecorator.cpp
+++ b/cpp/RuntimeDecorator.cpp
@@ -21,10 +21,11 @@ void injectJSIBindings(jsi::Runtime &rt) {
   rt.global().setProperty(rt, "jsi_registerMarkdownWorklet", jsi::Function::createFromHostFunction(
       rt,
       jsi::PropNameID::forAscii(rt, "jsi_registerMarkdownWorklet"),
-      1,
+      2,
       [](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);
+        const auto parserId = static_cast<int>(args[0].asNumber());
+        registerMarkdownWorklet(parserId, extractSerializableOrThrow<SerializableWorklet>(rt, args[1]));
+        return jsi::Value::undefined();
       }));
 
   rt.global().setProperty(rt, "jsi_unregisterMarkdownWorklet", jsi::Function::createFromHostFunction(
diff --git a/example/src/AlwaysPaintedView.tsx b/example/src/AlwaysPaintedView.tsx
new file mode 100644
index 000000000..0abbf8dba
--- /dev/null
+++ b/example/src/AlwaysPaintedView.tsx
@@ -0,0 +1,25 @@
+import type {ViewProps} from 'react-native';
+import {NativeComponentRegistry} from 'react-native';
+
+// RN declares the view config types but does not export them, so they are read back off the registry signature.
+type ViewConfigProvider = Parameters<typeof NativeComponentRegistry.get>[1];
+type StyleAttributes = NonNullable<
+  NonNullable<ReturnType<ViewConfigProvider>['validAttributes']>['style']
+>;
+
+// React hides a host view under a hidden <Activity> by setting `display: none` on it.
+// Pinning `display` to `contents` in the view config drops that write, so the subtree stays
+// painted and native code keeps applying styles to an input whose JS side is hidden.
+const pinnedDisplayStyleAttributes: StyleAttributes = {
+  display: {process: () => 'contents'},
+};
+
+const AlwaysPaintedView = NativeComponentRegistry.get<ViewProps>(
+  'AlwaysPaintedView',
+  () => ({
+    uiViewClassName: 'RCTView',
+    validAttributes: {style: pinnedDisplayStyleAttributes},
+  }),
+);
+
+export default AlwaysPaintedView;
diff --git a/example/src/App.tsx b/example/src/App.tsx
index ce6b1db83..edd53e954 100644
--- a/example/src/App.tsx
+++ b/example/src/App.tsx
@@ -4,9 +4,30 @@ import {
   MarkdownTextInput,
   parseExpensiMark,
 } from '@expensify/react-native-live-markdown';
+import type {MarkdownRange} from '@expensify/react-native-live-markdown';
 import * as TEST_CONST from './testConstants';
 import {PlatformInfo} from './PlatformInfo';
 import {handleFormatSelection} from './formatSelectionUtils';
+import AlwaysPaintedView from './AlwaysPaintedView';
+
+// Passes an explicit max length: with react-native-worklets 0.10.2 the default parameter of `parseExpensiMark` is
+// evaluated before the worklet closure is available and throws on the worklet runtime.
+function parser(input: string) {
+  'worklet';
+
+  return parseExpensiMark(input, 4000);
+}
+
+function strikethroughParser(input: string): MarkdownRange[] {
+  'worklet';
+
+  return input.length === 0
+    ? []
+    : [{type: 'strikethrough', start: 0, length: input.length}];
+}
+
+// Choosing a wrapper while the input is visible remounts it, so each hide and reveal cycle runs with a fixed wrapper.
+type ActivityWrapper = 'none' | 'alwaysPainted';
 
 export default function App() {
   const [value, setValue] = React.useState(TEST_CONST.EXAMPLE_CONTENT);
@@ -16,6 +37,11 @@ export default function App() {
   const [textFontSizeState, setTextFontSizeState] = React.useState(false);
   const [emojiFontSizeState, setEmojiFontSizeState] = React.useState(false);
   const [caretHidden, setCaretHidden] = React.useState(false);
+  const [activityWrapper, setActivityWrapper] =
+    React.useState<ActivityWrapper>('none');
+  const [activityHidden, setActivityHidden] = React.useState(false);
+  const [useStrikethroughParser, setUseStrikethroughParser] =
+    React.useState(false);
   const [selection, setSelection] = React.useState({start: 0, end: 0});
 
   const style = React.useMemo(() => {
@@ -36,27 +62,39 @@ export default function App() {
 
   const ref = React.useRef<MarkdownTextInput>(null);
 
+  const input = (
+    <MarkdownTextInput
+      multiline={multiline}
+      formatSelection={handleFormatSelection}
+      autoCapitalize="none"
+      caretHidden={caretHidden}
+      value={value}
+      onChangeText={setValue}
+      style={[styles.input, style]}
+      ref={ref}
+      markdownStyle={markdownStyle}
+      parser={useStrikethroughParser ? strikethroughParser : parser}
+      placeholder="Type here..."
+      onSelectionChange={e => setSelection(e.nativeEvent.selection)}
+      selection={selection}
+      id={TEST_CONST.INPUT_ID}
+      maxLength={30000}
+    />
+  );
+
   return (
     <ScrollView contentContainerStyle={styles.container} style={styles.content}>
       <PlatformInfo />
       <Text>{multiline ? 'multiline' : 'singleline'}</Text>
-      <MarkdownTextInput
-        multiline={multiline}
-        formatSelection={handleFormatSelection}
-        autoCapitalize="none"
-        caretHidden={caretHidden}
-        value={value}
-        onChangeText={setValue}
-        style={[styles.input, style]}
-        ref={ref}
-        markdownStyle={markdownStyle}
-        parser={parseExpensiMark}
-        placeholder="Type here..."
-        onSelectionChange={e => setSelection(e.nativeEvent.selection)}
-        selection={selection}
-        id={TEST_CONST.INPUT_ID}
-        maxLength={30000}
-      />
+      <React.Activity mode={activityHidden ? 'hidden' : 'visible'}>
+        {activityWrapper === 'alwaysPainted' ? (
+          <AlwaysPaintedView style={styles.alwaysPainted}>
+            {input}
+          </AlwaysPaintedView>
+        ) : (
+          input
+        )}
+      </React.Activity>
       <Text style={styles.text}>{JSON.stringify(value)}</Text>
       <Button
         testID="focus"
@@ -122,6 +160,31 @@ export default function App() {
         title="Toggle caret hidden"
         onPress={() => setCaretHidden(prev => !prev)}
       />
+      <Button
+        title={
+          activityWrapper === 'none'
+            ? 'Use AlwaysPaintedView'
+            : 'Use regular view'
+        }
+        disabled={activityHidden}
+        onPress={() =>
+          setActivityWrapper(prev =>
+            prev === 'none' ? 'alwaysPainted' : 'none',
+          )
+        }
+      />
+      <Button
+        title={activityHidden ? 'Show Activity' : 'Hide Activity'}
+        onPress={() => setActivityHidden(prev => !prev)}
+      />
+      <Button
+        title={
+          useStrikethroughParser
+            ? 'Use ExpensiMark parser'
+            : 'Use strikethrough parser'
+        }
+        onPress={() => setUseStrikethroughParser(prev => !prev)}
+      />
       <Button
         title="Toggle all"
         onPress={() => {
@@ -154,6 +217,9 @@ const styles = StyleSheet.create({
   content: {
     marginTop: 60,
   },
+  alwaysPainted: {
+    display: 'contents',
+  },
   input: {
     fontSize: 20,
     width: 300,
diff --git a/package-lock.json b/package-lock.json
index 04a55a4bd..b522fb14b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -28,6 +28,7 @@
         "@release-it/conventional-changelog": "^5.0.0",
         "@types/jest": "^29.5.14",
         "@types/react": "^19.2.0",
+        "@types/react-dom": "^19.2.7",
         "@typescript-eslint/eslint-plugin": "^8.53.1",
         "@typescript-eslint/parser": "^8.53.1",
         "del-cli": "^5.0.0",
@@ -5288,6 +5289,16 @@
         "csstype": "^3.2.2"
       }
     },
+    "node_modules/@types/react-dom": {
+      "version": "19.2.7",
+      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.7.tgz",
+      "integrity": "sha512-I8bPpDLcHBv1qiIiXDCy71Rt8eQDKJP0sMSWJphDdAcdqiJ1sGpZamavoEIRZmYzjia9LuEb2HlYdDpmoENpvQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/react": "^19.2.0"
+      }
+    },
     "node_modules/@types/semver": {
       "version": "7.5.8",
       "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.5.8.tgz",
diff --git a/package.json b/package.json
index 7c67d13e0..566d13020 100644
--- a/package.json
+++ b/package.json
@@ -74,6 +74,7 @@
     "@release-it/conventional-changelog": "^5.0.0",
     "@types/jest": "^29.5.14",
     "@types/react": "^19.2.0",
+    "@types/react-dom": "^19.2.7",
     "@typescript-eslint/eslint-plugin": "^8.53.1",
     "@typescript-eslint/parser": "^8.53.1",
     "del-cli": "^5.0.0",
diff --git a/src/MarkdownTextInput.tsx b/src/MarkdownTextInput.tsx
index 935b05548..cebb79898 100644
--- a/src/MarkdownTextInput.tsx
+++ b/src/MarkdownTextInput.tsx
@@ -1,66 +1,19 @@
 import {StyleSheet, TextInput, processColor} from 'react-native';
 import React from 'react';
 import type {TextInputProps} from 'react-native';
-import {createSerializable, createWorkletRuntime} from 'react-native-worklets';
-import type {SerializableRef, WorkletFunction, WorkletRuntime} from 'react-native-worklets';
 import MarkdownTextInputDecoratorViewNativeComponent from './MarkdownTextInputDecoratorViewNativeComponent';
 import type {MarkdownStyle} from './MarkdownTextInputDecoratorViewNativeComponent';
-import NativeLiveMarkdownModule from './NativeLiveMarkdownModule';
 import {mergeMarkdownStyleWithDefault} from './styleUtils';
 import type {PartialMarkdownStyle} from './styleUtils';
-import type {InlineImagesInputProps, MarkdownRange} from './commonTypes';
-
-declare global {
-  // eslint-disable-next-line no-var
-  var jsi_setMarkdownRuntime: (runtime: WorkletRuntime) => void;
-  // eslint-disable-next-line no-var
-  var jsi_registerMarkdownWorklet: (shareableWorklet: SerializableRef<WorkletFunction<[string], MarkdownRange[]>>) => number;
-  // eslint-disable-next-line no-var
-  var jsi_unregisterMarkdownWorklet: (parserId: number) => void;
-}
-
-let initialized = false;
-let workletRuntime: WorkletRuntime | undefined;
-
-function getWorkletRuntime(): WorkletRuntime {
-  if (workletRuntime === undefined) {
-    throw new Error(
-      "[react-native-live-markdown] Worklet runtime hasn't been created yet. Please avoid calling `getWorkletRuntime()` in top-level scope. Instead, call `getWorkletRuntime()` directly in `runOnRuntime` arguments list.",
-    );
-  }
-  return workletRuntime;
-}
-
-function initializeLiveMarkdownIfNeeded() {
-  if (initialized) {
-    return;
-  }
-  if (NativeLiveMarkdownModule) {
-    NativeLiveMarkdownModule.install();
-  }
-  if (!global.jsi_setMarkdownRuntime) {
-    throw new Error('[react-native-live-markdown] global.jsi_setMarkdownRuntime is not available');
-  }
-  workletRuntime = createWorkletRuntime({name: 'LiveMarkdownRuntime'});
-  global.jsi_setMarkdownRuntime(workletRuntime);
-  initialized = true;
-}
-
-function registerParser(parser: (input: string) => MarkdownRange[]): number {
-  initializeLiveMarkdownIfNeeded();
-  const serializableWorklet = createSerializable(parser as WorkletFunction<[string], MarkdownRange[]>);
-  const parserId = global.jsi_registerMarkdownWorklet(serializableWorklet);
-  return parserId;
-}
-
-function unregisterParser(parserId: number) {
-  global.jsi_unregisterMarkdownWorklet(parserId);
-}
+import type {InlineImagesInputProps} from './commonTypes';
+import useParserId from './useParserId';
+import {getWorkletRuntime} from './workletRuntime';
+import type {ParserWorklet} from './workletRuntime';
 
 interface MarkdownTextInputProps extends TextInputProps, InlineImagesInputProps {
   markdownStyle?: PartialMarkdownStyle;
   formatSelection?: (text: string, selectionStart: number, selectionEnd: number, formatCommand: string) => FormatSelectionResult;
-  parser: (value: string) => MarkdownRange[];
+  parser: ParserWorklet;
 }
 
 type FormatSelectionResult = {
@@ -104,13 +57,7 @@ const MarkdownTextInput = React.forwardRef<MarkdownTextInput, MarkdownTextInputP
     throw new Error('[react-native-live-markdown] `parser` is not a worklet');
   }
 
-  const parserId = React.useMemo(() => {
-    return registerParser(props.parser);
-  }, [props.parser]);
-
-  React.useEffect(() => {
-    return () => unregisterParser(parserId);
-  }, [parserId]);
+  const parserId = useParserId(props.parser);
 
   return (
     <MarkdownTextInputDecoratorViewNativeComponent
diff --git a/src/__tests__/parserRegistration.test.tsx b/src/__tests__/parserRegistration.test.tsx
new file mode 100644
index 000000000..63985c5f5
--- /dev/null
+++ b/src/__tests__/parserRegistration.test.tsx
@@ -0,0 +1,299 @@
+import {expect} from '@jest/globals';
+import React, {Activity, StrictMode, Suspense, act} from 'react';
+import {createRoot} from 'react-dom/client';
+import type {Root} from 'react-dom/client';
+import type {SerializableRef} from 'react-native-worklets';
+import type {MarkdownRange} from '../commonTypes';
+import MarkdownTextInput from '../MarkdownTextInput';
+import type {MarkdownTextInputProps} from '../MarkdownTextInput';
+
+/**
+ * The parser worklet lives in a C++ registry keyed by the `parserId` prop the decorator view carries. The registry is
+ * replaced by a map of worklets here, the decorator view by an element that exposes its `parserId` as a DOM attribute and
+ * counts its renders, and the native text input by a plain `<input>`, so the component renders in jsdom through `react-dom`.
+ */
+type Parser = MarkdownTextInputProps['parser'];
+
+// `createSerializable` is mocked to return the worklet itself, so the map holds the parser functions.
+const liveParsers = new Map<number, SerializableRef<Parser>>();
+const registerWorklet = jest.fn((parserId: number, worklet: SerializableRef<Parser>) => {
+  liveParsers.set(parserId, worklet);
+});
+const unregisterWorklet = jest.fn((parserId: number) => {
+  liveParsers.delete(parserId);
+});
+let decoratorRenderCount = 0;
+
+jest.mock('react-native', () => ({
+  Platform: {OS: 'ios', select: (options: {ios?: unknown; default?: unknown}) => options.ios ?? options.default},
+  StyleSheet: {create: <T,>(styles: T) => styles},
+  TextInput: (props: {testID?: string}) => <input data-testid={props.testID} />,
+  TurboModuleRegistry: {get: () => null},
+  processColor: (color: unknown) => color,
+}));
+
+jest.mock('react-native-worklets', () => ({
+  createSerializable: (worklet: unknown) => worklet,
+  createWorkletRuntime: () => ({}),
+}));
+
+jest.mock('../MarkdownTextInputDecoratorViewNativeComponent', () => ({
+  __esModule: true,
+  default: (props: {parserId: number; children: React.ReactNode}) => {
+    decoratorRenderCount += 1;
+    return <div data-parser-id={props.parserId}>{props.children}</div>;
+  },
+}));
+
+// The worklets babel plugin does not run under Jest, so the hash that marks a function as a worklet is attached by hand.
+function createParserWorklet() {
+  return Object.assign((): MarkdownRange[] => [], {__workletHash: 1});
+}
+
+const parser = createParserWorklet();
+
+let container: HTMLDivElement;
+let root: Root;
+
+function renderIntoRoot(element: React.ReactElement) {
+  act(() => {
+    root.render(element);
+  });
+}
+
+function renderInActivity(isHidden: boolean, currentParser: Parser = parser) {
+  renderIntoRoot(
+    <Activity mode={isHidden ? 'hidden' : 'visible'}>
+      <MarkdownTextInput parser={currentParser} />
+    </Activity>,
+  );
+}
+
+function getDecoratorParserIds(): number[] {
+  return Array.from(container.querySelectorAll('[data-parser-id]'), (element) => {
+    const attribute = element.getAttribute('data-parser-id');
+    const parserId = Number(attribute);
+    if (attribute == null || !Number.isInteger(parserId) || parserId <= 0) {
+      throw new Error('The decorator view rendered without a parser id');
+    }
+    return parserId;
+  });
+}
+
+function getDecoratorParserId(): number {
+  const parserIds = getDecoratorParserIds();
+  const [parserId] = parserIds;
+  if (parserId === undefined || parserIds.length !== 1) {
+    throw new Error(`Expected one decorator view, found ${parserIds.length}`);
+  }
+  return parserId;
+}
+
+function expectDecoratorOnTheOnlyLiveParserId(expectedParser: Parser = parser) {
+  expect(liveParsers.get(getDecoratorParserId())).toBe(expectedParser);
+  expect(liveParsers.size).toBe(1);
+}
+
+describe('MarkdownTextInput parser registration', () => {
+  beforeEach(() => {
+    liveParsers.clear();
+    registerWorklet.mockClear();
+    unregisterWorklet.mockClear();
+    decoratorRenderCount = 0;
+    global.jsi_setMarkdownRuntime = jest.fn();
+    global.jsi_registerMarkdownWorklet = registerWorklet;
+    global.jsi_unregisterMarkdownWorklet = unregisterWorklet;
+
+    container = document.createElement('div');
+    document.body.appendChild(container);
+    root = createRoot(container);
+  });
+
+  afterEach(() => {
+    act(() => {
+      root.unmount();
+    });
+    container.remove();
+    expect(liveParsers.size).toBe(0);
+  });
+
+  it('registers the parser once and carries its id in the first render', () => {
+    renderIntoRoot(<MarkdownTextInput parser={parser} />);
+
+    expect(decoratorRenderCount).toBe(1);
+    expect(registerWorklet).toHaveBeenCalledTimes(1);
+    expectDecoratorOnTheOnlyLiveParserId();
+  });
+
+  it('unregisters the parser on unmount', () => {
+    renderIntoRoot(<MarkdownTextInput parser={parser} />);
+    const parserId = getDecoratorParserId();
+
+    act(() => {
+      root.unmount();
+    });
+
+    expect(unregisterWorklet).toHaveBeenCalledWith(parserId);
+    expect(liveParsers.size).toBe(0);
+  });
+
+  it('keeps the registration when rerendering with the same parser', () => {
+    renderIntoRoot(<MarkdownTextInput parser={parser} />);
+    const initialParserId = getDecoratorParserId();
+
+    renderIntoRoot(
+      <MarkdownTextInput
+        parser={parser}
+        value="*updated*"
+      />,
+    );
+
+    expect(getDecoratorParserId()).toBe(initialParserId);
+    expect(registerWorklet).toHaveBeenCalledTimes(1);
+    expect(unregisterWorklet).not.toHaveBeenCalled();
+    expectDecoratorOnTheOnlyLiveParserId();
+  });
+
+  it('registers the parser of an initially hidden <Activity> and drops it when the Activity is removed while hidden', () => {
+    renderInActivity(true);
+    expectDecoratorOnTheOnlyLiveParserId();
+
+    renderIntoRoot(<div />);
+
+    expect(liveParsers.size).toBe(0);
+  });
+
+  it('does not register a parser when React abandons a suspended render', () => {
+    const pending = new Promise<never>(() => {
+      // Keep the subtree suspended until its render is abandoned.
+    });
+    function Suspend(): React.ReactNode {
+      throw pending;
+    }
+
+    renderIntoRoot(
+      <Suspense fallback={<span>Loading</span>}>
+        <MarkdownTextInput parser={parser} />
+        <Suspend />
+      </Suspense>,
+    );
+
+    expect(container.textContent).toBe('Loading');
+    expect(registerWorklet).not.toHaveBeenCalled();
+    expect(liveParsers.size).toBe(0);
+
+    renderIntoRoot(<MarkdownTextInput parser={parser} />);
+    expectDecoratorOnTheOnlyLiveParserId();
+  });
+
+  it('registers once under StrictMode', () => {
+    renderIntoRoot(
+      <StrictMode>
+        <MarkdownTextInput parser={parser} />
+      </StrictMode>,
+    );
+
+    expect(registerWorklet).toHaveBeenCalledTimes(1);
+    expect(unregisterWorklet).not.toHaveBeenCalled();
+    expectDecoratorOnTheOnlyLiveParserId();
+  });
+
+  it('keeps the same registration while a <Activity> is hidden and revealed', () => {
+    renderInActivity(false);
+    const parserId = getDecoratorParserId();
+
+    renderInActivity(true);
+    expect(getDecoratorParserId()).toBe(parserId);
+    expectDecoratorOnTheOnlyLiveParserId();
+
+    const renderCountBeforeReveal = decoratorRenderCount;
+    renderInActivity(false);
+
+    expect(getDecoratorParserId()).toBe(parserId);
+    expect(decoratorRenderCount).toBe(renderCountBeforeReveal + 1);
+    expect(registerWorklet).toHaveBeenCalledTimes(1);
+    expect(unregisterWorklet).not.toHaveBeenCalled();
+    expectDecoratorOnTheOnlyLiveParserId();
+  });
+
+  it('switches to a replacement parser while the <Activity> is still hidden', () => {
+    renderInActivity(false);
+    const initialParserId = getDecoratorParserId();
+
+    renderInActivity(true);
+    const nextParser = createParserWorklet();
+    renderInActivity(true, nextParser);
+
+    expect(getDecoratorParserId()).not.toBe(initialParserId);
+    expect(unregisterWorklet).toHaveBeenCalledWith(initialParserId);
+    expectDecoratorOnTheOnlyLiveParserId(nextParser);
+
+    renderInActivity(false, nextParser);
+
+    expect(registerWorklet).toHaveBeenCalledTimes(2);
+    expectDecoratorOnTheOnlyLiveParserId(nextParser);
+  });
+
+  it('unregisters an input removed inside a hidden <Activity>', () => {
+    renderInActivity(false);
+    renderInActivity(true);
+    const parserId = getDecoratorParserId();
+
+    renderIntoRoot(
+      <Activity mode="hidden">
+        <div />
+      </Activity>,
+    );
+
+    expect(unregisterWorklet).toHaveBeenCalledWith(parserId);
+    expect(liveParsers.size).toBe(0);
+  });
+
+  it('gives inputs using the same parser their own registrations', () => {
+    renderIntoRoot(
+      <div>
+        <MarkdownTextInput
+          key="first"
+          parser={parser}
+        />
+        <MarkdownTextInput
+          key="second"
+          parser={parser}
+        />
+      </div>,
+    );
+    const ids = getDecoratorParserIds();
+    expect(ids).toHaveLength(2);
+    expect(ids[0]).not.toBe(ids[1]);
+    expect(registerWorklet).toHaveBeenCalledTimes(2);
+    expect(liveParsers.size).toBe(2);
+
+    renderIntoRoot(
+      <div>
+        <MarkdownTextInput
+          key="second"
+          parser={parser}
+        />
+      </div>,
+    );
+    expect(unregisterWorklet).toHaveBeenCalledWith(ids[0]);
+    expect(getDecoratorParserId()).toBe(ids[1]);
+    expectDecoratorOnTheOnlyLiveParserId();
+
+    renderIntoRoot(<div />);
+    expect(unregisterWorklet).toHaveBeenCalledTimes(2);
+    expect(liveParsers.size).toBe(0);
+  });
+
+  it('moves the decorator to a new id and drops the previous one when the parser changes identity', () => {
+    renderIntoRoot(<MarkdownTextInput parser={parser} />);
+    const initialParserId = getDecoratorParserId();
+
+    const nextParser = createParserWorklet();
+    renderIntoRoot(<MarkdownTextInput parser={nextParser} />);
+
+    expect(getDecoratorParserId()).not.toBe(initialParserId);
+    expect(unregisterWorklet).toHaveBeenCalledWith(initialParserId);
+    expectDecoratorOnTheOnlyLiveParserId(nextParser);
+  });
+});
diff --git a/src/useParserId.ts b/src/useParserId.ts
new file mode 100644
index 000000000..966481c0a
--- /dev/null
+++ b/src/useParserId.ts
@@ -0,0 +1,38 @@
+import React from 'react';
+import {createSerializable} from 'react-native-worklets';
+import {initializeLiveMarkdownIfNeeded} from './workletRuntime';
+import type {ParserWorklet} from './workletRuntime';
+
+let nextParserId = 1;
+
+// Ids are picked in JS so a render can hand one to the native view before any effect runs.
+function allocateParserId(): number {
+  const parserId = nextParserId;
+  nextParserId += 1;
+  return parserId;
+}
+
+function registerParser(parserId: number, parser: ParserWorklet) {
+  initializeLiveMarkdownIfNeeded();
+  global.jsi_registerMarkdownWorklet(parserId, createSerializable(parser));
+}
+
+function unregisterParser(parserId: number) {
+  global.jsi_unregisterMarkdownWorklet(parserId);
+}
+
+// An insertion effect is the only effect React runs before the host tree commits, does not run twice under StrictMode
+// and keeps connected inside a hidden <Activity>. A parser change gets a fresh id because the native side caches ranges
+// by text and parser id.
+function useParserId(parser: ParserWorklet): number {
+  const registration = React.useMemo(() => ({parser, parserId: allocateParserId()}), [parser]);
+
+  React.useInsertionEffect(() => {
+    registerParser(registration.parserId, registration.parser);
+    return () => unregisterParser(registration.parserId);
+  }, [registration]);
+
+  return registration.parserId;
+}
+
+export default useParserId;
diff --git a/src/workletRuntime.ts b/src/workletRuntime.ts
new file mode 100644
index 000000000..4f87228d1
--- /dev/null
+++ b/src/workletRuntime.ts
@@ -0,0 +1,49 @@
+import {createWorkletRuntime} from 'react-native-worklets';
+import type {SerializableRef, WorkletRuntime} from 'react-native-worklets';
+import NativeLiveMarkdownModule from './NativeLiveMarkdownModule';
+import type {MarkdownRange} from './commonTypes';
+
+// A function compiled with the 'worklet' directive. The type cannot express that, so `MarkdownTextInput` checks it at
+// runtime and throws otherwise.
+type ParserWorklet = (input: string) => MarkdownRange[];
+
+// `NativeLiveMarkdownModule.install()` puts these functions on the global object from `injectJSIBindings` in
+// `cpp/RuntimeDecorator.cpp`. Both sides must agree on the signatures.
+declare global {
+  // eslint-disable-next-line no-var
+  var jsi_setMarkdownRuntime: (runtime: WorkletRuntime) => void;
+  // eslint-disable-next-line no-var
+  var jsi_registerMarkdownWorklet: (parserId: number, shareableWorklet: SerializableRef<ParserWorklet>) => void;
+  // eslint-disable-next-line no-var
+  var jsi_unregisterMarkdownWorklet: (parserId: number) => void;
+}
+
+let initialized = false;
+let workletRuntime: WorkletRuntime | undefined;
+
+function getWorkletRuntime(): WorkletRuntime {
+  if (workletRuntime === undefined) {
+    throw new Error(
+      "[react-native-live-markdown] Worklet runtime hasn't been created yet. Please avoid calling `getWorkletRuntime()` in top-level scope. Instead, call `getWorkletRuntime()` directly in `runOnRuntime` arguments list.",
+    );
+  }
+  return workletRuntime;
+}
+
+function initializeLiveMarkdownIfNeeded() {
+  if (initialized) {
+    return;
+  }
+  if (NativeLiveMarkdownModule) {
+    NativeLiveMarkdownModule.install();
+  }
+  if (!global.jsi_setMarkdownRuntime) {
+    throw new Error('[react-native-live-markdown] global.jsi_setMarkdownRuntime is not available');
+  }
+  workletRuntime = createWorkletRuntime({name: 'LiveMarkdownRuntime'});
+  global.jsi_setMarkdownRuntime(workletRuntime);
+  initialized = true;
+}
+
+export type {ParserWorklet};
+export {getWorkletRuntime, initializeLiveMarkdownIfNeeded};