You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
{{ message }}
Repository navigation
[$175] [Sentry: APP-M0W] HybridApp iOS: App Hang, Live Markdown parser blocks the main thread on the JS runtime lock #104744
A reanimated layout animation runs a Fabric mount on the main thread. The mount updates the props of a MarkdownTextInput, and Live Markdown parses the text right away on the main thread. The parser calls into a JS runtime and waits for its lock, and another thread holds that lock, so the main thread stays blocked until the watchdog kills the app.
Reproduction
Unknown. See the Sentry events linked from the Sentry issue.
changed the title [-][Sentry: APP-M0W] HybridApp iOS: App Hang, Live Markdown parser blocks the main thread on the JS runtime lock[/-][+][$175] [Sentry: APP-M0W] HybridApp iOS: App Hang, Live Markdown parser blocks the main thread on the JS runtime lock[/+]on Oct 22, 2026
Please re-state the problem that we are trying to solve in this issue.
On HybridApp iOS, the app sometimes freezes for 2 seconds or more, and the iOS watchdog reports a fatal App Hang. The main thread is blocked inside -[MarkdownParser parseUncached:withParserId:]. It is waiting on a std::recursive_mutex that guards a JS (worklet) runtime, and another thread holds that lock. The call chain is:
A Reanimated layout animation runs a Fabric mount on the main thread.
The mount calls MarkdownTextInputDecoratorComponentView updateProps → applyNewStyles.
applyNewStyles triggers textStorage:didProcessEditing, which synchronously calls the markdown parser.
The goal is that the main thread never blocks on a JS runtime lock because of Live Markdown. At minimum, a props or style update on a MarkdownTextInput must not trigger a synchronous JS call.
What is the root cause of that problem?
This analysis is from the stack trace only. There is no reproduction, so the details below are strong hypotheses.
The native parser calls into a JS runtime synchronously on the main thread.MarkdownParser.mm has to create JSI values (createStringFromUtf8) and run the parser worklet on a worklet runtime. That runtime is wrapped in a decorator that takes a recursive_mutex for every access. If any other thread is using the runtime, the main thread waits for it.
The re-parse is triggered by a props update, not only by a text edit.
updateProps → applyNewStyles rewrites the attributes of the whole text storage, which fires didProcessEditing and re-runs the parser.
The parse result only contains ranges (type, location, length, depth). It does not depend on markdownStyle.
Re-parsing on a style-only or layout-driven prop update is therefore unnecessary. When the parse cache misses, as with a new or long text, the call goes to the JS runtime and can block.
The runtime lock is held for a long time by another thread. A likely holder is the JS thread or the UI runtime running a long markdown parse worklet (long text, or parseExpensiMark invoked elsewhere via runOnRuntime/runOnJS). The Reanimated layout-animation path (executeLayoutAnimationsRequests → runSyncAndDiscard) makes this worse, because the mount runs inside a synchronous worklet-runtime section on the main thread. That creates a lock-ordering and contention window.
What changes do you think we should make in order to solve the problem?
1. Main fix, in react-native-live-markdown (native iOS). Do not call into JS when only styles or props change.
In MarkdownTextInputDecoratorComponentView, store the last parsed ranges together with the text and parserId they were computed from.
In applyNewStyles, if the text and parser are unchanged, re-apply attributes from the cached ranges and skip MarkdownParser parse:.
This removes the hang path from the stack trace, where a layout-animation mount only changes props or styles. It is also a performance win.
2. Defense in depth in react-native-live-markdown. For the unavoidable parse on the main thread (a real text change or the initial mount), avoid an unbounded wait on the runtime lock.
Use a dedicated worklet runtime for the markdown parser. It must be used only by Live Markdown and never shared with the UI runtime or user code.
Keep the existing parse cache and make sure it is populated before mount where possible. For example, pre-parse the defaultValue or value on the JS side.
If a non-blocking try-lock is available, fall back to plain unformatted text and schedule an async re-format on the next run loop tick instead of blocking.
3. In Expensify/App.
Verify that the markdown parser (parseExpensiMark) is only executed on the dedicated markdown runtime. Remove any usage on the JS thread or UI runtime (runOnRuntime, runOnUI and similar).
Audit the screens in the stack trace (Composer, MarkdownTextInput inside Animated.View or LayoutAnimation). Do not apply Reanimated layout/entering/exiting to an ancestor that remounts or relayouts a MarkdownTextInput. Animate a wrapper or use plain transforms instead.
After the live-markdown fix is released, bump the @expensify/react-native-live-markdown version in App's package.json and update the patch if one exists.
What alternative solutions did you explore? (Optional)
Increase the watchdog timeout or ignore the Sentry event: rejected, because the app is still frozen and gets killed.
Run parsing fully asynchronously in all cases: rejected for the main fix. Text would flash unstyled while the user types, and edits would need reconciling with stale results. It is kept only as a fallback for the contended case.
Replace the JS parser with a native (C++) parser: the most robust option, because it removes the runtime lock entirely. It is too large for this issue and is a possible follow-up.
Disable layout animations globally in App: rejected as overly broad and a UX regression. The targeted audit in step 3 is preferred.
Testing
Unit/native test (live-markdown): mount a MarkdownTextInput with text and spy on MarkdownParser parse:. Update only markdownStyle, layout props or the font. Assert that the parser is not called again and that the attributes are updated correctly. Change the text and assert that it is called once.
Contention test: in the live-markdown example app, hold the markdown runtime lock on a background thread, for example with a long-running worklet via runOnRuntime. Trigger a layout animation that changes the props of a MarkdownTextInput. Before the fix the main thread blocks. After the fix there is no hang, and the UI stays responsive.
Manual in HybridApp iOS: open a report with a long draft in the composer, then trigger navigation and layout animations such as opening and closing the emoji picker, attachments, and the keyboard. Confirm there are no freezes, and that markdown formatting (bold, links, mentions, code) is still highlighted correctly after style changes.
Monitoring: after release, watch Sentry issue APP-M0W for new events on the fixed version. It should stop recurring.
Updated 2026-10-25: Corrected based on feedback from TaduJR.
Proposal
Please re-state the problem that we are trying to solve in this issue.
The app freezes with a fatal App Hang (APP-M0W) while a Live Markdown input parses text on the main thread. The same hang appears on Android.
What is the root cause of that problem?
A lock-order deadlock between two worklet runtimes. TaduJR confirmed it with lldb on the iOS simulator.
The main thread holds the UI runtime lock and waits for the markdown runtime lock. A Reanimated layout animation flush mounts a MarkdownTextInput, and Live Markdown parses its text on the main thread through the LiveMarkdownRuntime.
The JS thread holds the markdown runtime lock and waits for the UI runtime lock. Our parser worklets read Reanimated SharedValues. On a runtime other than the UI runtime, a SharedValue read is a synchronous call into the UI runtime. Two parsers do this:
SearchAutocompleteInput.tsx:186 passes five SharedValues to parseForLiveMarkdown, which reads them several times per parse in filterOutRangesWithCorrectValue. So the Search bar can freeze the same way.
What changed to cause this?
Start: the Reanimated 4.3.1 upgrade on 2026-06-01 made SharedValue reads on other runtimes synchronous calls into the UI runtime.
APP-EF1 was the same deadlock. live-markdown 0.1.336 (from Bump react-native-live-markdown) only changed where it shows up in the stack.
APP-M0W was first seen on 9.4.74-2. The JS thread holds the markdown lock in all 25 events.
Android: the same hang appears as APP-KA6, APP-KY2, APP-KH2, APP-NC2 and APP-M9K. This change fixes those too.
What changes do you think we should make in order to solve the problem?
Never read a SharedValue inside a parser worklet. Capture the data in the parser closure instead, and keep the parsers stable while typing.
RNMarkdownTextInput: the default parser captures availableLoginsList in its closure. Pass a custom parser prop straight through instead of wrapping it.
SearchAutocompleteInput: pass one KnownFilterValues object of Sets (userLogins, currencies, categories, tags, exportedTo) to parseForLiveMarkdown, and use Set.has in filterOutRangesWithCorrectValue.
Use the closure, not a global on the markdown runtime. Live Markdown caches ranges by text and parser id. A global keeps stale highlights after a list changes, and the first parse can run before the effect sets it. With the closure, a list change gives the input a new parser id and it re-parses.
Keep the parsers stable. A list with a new identity means a new parser id, a new registration, and an uncached parse on the main thread. So:
Select categories and tags with useOnyx selectors.
Build each Set where its list is created. Building it later in the component hits a React Compiler memoization issue.
In useExportedToFilterOptions, read the policy IDs again after useCombinedExportTemplates. React Compiler drops memoization for a value made before a hook call and used after it, so the hook returned a new array on every render and the Search parser changed on every keystroke.
Remove the scheduleOnLiveMarkdownRuntime effects, the helper, and its mock in jest/setup.ts.
The library hardening in react-native-live-markdown (main-thread parse reads only the cache) is out of scope and will be a separate follow-up.
Tests
Update SearchAutocompleteUtilsTest to pass KnownFilterValues.
Add a test that useExportedToFilterOptions returns the same array across re-renders with unchanged data.
Add a test that SearchAutocompleteInput passes the same parser when only the query changes.
What alternative solutions did you explore? (Optional)
A global on the markdown runtime set by an effect: rejected, because it keeps stale cached highlights and can miss the first parse.
Library change only: stops the main thread from blocking, but a background parse can still block on the UI runtime.
Turn off locking on LiveMarkdownRuntime: unsafe, because the parser runs on several threads.
Confidence: high.TaduJR confirmed the lock owners with lldb.
Please re-state the problem that we are trying to solve in this issue.
On HybridApp iOS, the app can freeze for >2 seconds (Sentry APP-M0W App Hang) when mounting or updating RNMarkdownTextInput while a layout animation is flushing on the main thread. The main thread blocks inside -[MarkdownParser parseUncached:withParserId:] waiting for the LiveMarkdownRuntime mutex while holding the Reanimated UI runtime lock.
What is the root cause of that problem?
The hang is a classic AB-BA lock-order inversion between the Reanimated UI runtime mutex and the LiveMarkdownRuntime worker mutex:
Main thread (holds UI runtime lock -> waits for LiveMarkdownRuntime lock):
During a Reanimated layout animation flush on the main thread (-[REANodesManager performOperations] -> executeLayoutAnimationsRequests), the main thread holds the UI runtime lock and flushes Fabric mount mutations (RCTMountingManager.mm:83 -> -[MarkdownTextInputDecoratorComponentView updateProps:oldProps:] -> applyNewStyles -> -[RCTMarkdownUtils applyMarkdownFormatting:inputView:] -> -[MarkdownParser parseUncached:withParserId:]). Because the component view's RCTMarkdownUtils instance has its own parser cache (separate from the shadow node's cache), the cache misses on initial mount and synchronously enters LiveMarkdownRuntime, waiting on its std::recursive_mutex.
LiveMarkdownRuntime worker thread (holds LiveMarkdownRuntime lock -> waits for UI runtime lock):
In src/components/RNMarkdownTextInput.tsx:38 and 62-81, mentionsSharedVal is a Reanimated SharedValue (useSharedValue<string[]>(availableLoginsList)):
In react-native-reanimated, reading mentionsSharedVal.get() from a non-UI worker runtime (LiveMarkdownRuntime) calls getSync() (mutables.native.ts), which synchronously dispatches into the UI runtime and waits to acquire the UI runtime lock.
Why a simple useEffect-only runtime global is not enough on initial mount:
If mentionsSharedVal is removed and replaced only by a globalThis assignment inside useEffect(() => { scheduleOnLiveMarkdownRuntime(...); }, [availableLoginsList]), the very first synchronous parse during Fabric mount (RCTMountingManager Insert mutation) executes before React's useEffect and before the asynchronous scheduleOnRuntime task runs on LiveMarkdownRuntime. At that moment, the runtime global would still be undefined, causing existing draft @shortMentions to fail to highlight on initial mount.
What changes do you think we should make in order to solve the problem?
In src/components/RNMarkdownTextInput.tsx:
Remove useSharedValue (mentionsSharedVal) completely so parserWorklet never makes a synchronous cross-runtime getSync() call into the UI runtime while holding the LiveMarkdownRuntime lock.
Store availableLoginsList in a LiveMarkdownRuntime-local global (globalThis.__liveMarkdownAvailableLogins) WITH an initial closure fallback for synchronous mount parses:
Keep a ref (const initialAvailableLoginsRef = useRef(availableLoginsList);) captured once when parserWorklet is created so that if parserWorklet runs synchronously during the initial Fabric mount (before useEffect / scheduleOnLiveMarkdownRuntime has executed), globalThis.__liveMarkdownAvailableLogins ?? initialAvailableLogins already has the initial list without re-creating parserWorklet on every availableLoginsList update.
In useEffect, use scheduleOnLiveMarkdownRuntime to update globalThis.__liveMarkdownAvailableLogins = availableLoginsList directly on the markdown runtime whenever availableLoginsList changes:
(Note: scheduleOnLiveMarkdownRuntime in src/libs/scheduleOnLiveMarkdownRuntime/index.native.tsx accepts (worklet, ...args) and forwards ...args to scheduleOnRuntime, avoiding recreating the worklet closure on every render.)
What alternative solutions did you explore? (Optional)
Capturing availableLoginsList directly in parserWorklet's useCallback dependency array ([availableLoginsList, currentUserMentions, parser]): Rejected because availableLoginsList can contain up to 20,000 logins on large accounts; re-registering a new parserId and re-serializing the full array on every personal-details update would add unnecessary overhead.
Setting globalThis.__liveMarkdownAvailableLogins in useEffect without an initial fallback: Rejected because Fabric mount (updateProps -> applyNewStyles) invokes parserWorklet synchronously before useEffect runs, which would leave logins empty on initial mount.
changed the title [-][Due for payment 2026-11-13] [$175] [Sentry: APP-M0W] HybridApp iOS: App Hang, Live Markdown parser blocks the main thread on the JS runtime lock[/-][+][$175] [Sentry: APP-M0W] HybridApp iOS: App Hang, Live Markdown parser blocks the main thread on the JS runtime lock[/+]on Nov 9, 2026
Activity
melvin-bot commentedon Oct 22, 2026
Triggered auto assignment to Contributor-plus team member for initial proposal review - @TaduJR (
External)[-][Sentry: APP-M0W] HybridApp iOS: App Hang, Live Markdown parser blocks the main thread on the JS runtime lock[/-][+][$175] [Sentry: APP-M0W] HybridApp iOS: App Hang, Live Markdown parser blocks the main thread on the JS runtime lock[/+]melvin-bot commentedon Oct 22, 2026
Job added to Upwork: https://www.upwork.com/jobs/~022113270942362394935
Abdallah-1551 commentedon Oct 22, 2026
Proposal
Please re-state the problem that we are trying to solve in this issue.
On HybridApp iOS, the app sometimes freezes for 2 seconds or more, and the iOS watchdog reports a fatal App Hang. The main thread is blocked inside
-[MarkdownParser parseUncached:withParserId:]. It is waiting on astd::recursive_mutexthat guards a JS (worklet) runtime, and another thread holds that lock. The call chain is:MarkdownTextInputDecoratorComponentView updateProps→applyNewStyles.applyNewStylestriggerstextStorage:didProcessEditing, which synchronously calls the markdown parser.The goal is that the main thread never blocks on a JS runtime lock because of Live Markdown. At minimum, a props or style update on a
MarkdownTextInputmust not trigger a synchronous JS call.What is the root cause of that problem?
This analysis is from the stack trace only. There is no reproduction, so the details below are strong hypotheses.
MarkdownParser.mmhas to create JSI values (createStringFromUtf8) and run the parser worklet on a worklet runtime. That runtime is wrapped in a decorator that takes arecursive_mutexfor every access. If any other thread is using the runtime, the main thread waits for it.updateProps → applyNewStylesrewrites the attributes of the whole text storage, which firesdidProcessEditingand re-runs the parser.markdownStyle.parseExpensiMarkinvoked elsewhere viarunOnRuntime/runOnJS). The Reanimated layout-animation path (executeLayoutAnimationsRequests→runSyncAndDiscard) makes this worse, because the mount runs inside a synchronous worklet-runtime section on the main thread. That creates a lock-ordering and contention window.What changes do you think we should make in order to solve the problem?
1. Main fix, in
react-native-live-markdown(native iOS). Do not call into JS when only styles or props change.MarkdownTextInputDecoratorComponentView, store the last parsed ranges together with the text andparserIdthey were computed from.applyNewStyles, if the text and parser are unchanged, re-apply attributes from the cached ranges and skipMarkdownParser parse:.This removes the hang path from the stack trace, where a layout-animation mount only changes props or styles. It is also a performance win.
2. Defense in depth in
react-native-live-markdown. For the unavoidable parse on the main thread (a real text change or the initial mount), avoid an unbounded wait on the runtime lock.defaultValueorvalueon the JS side.3. In Expensify/App.
parseExpensiMark) is only executed on the dedicated markdown runtime. Remove any usage on the JS thread or UI runtime (runOnRuntime,runOnUIand similar).MarkdownTextInputinsideAnimated.VieworLayoutAnimation). Do not apply Reanimatedlayout/entering/exitingto an ancestor that remounts or relayouts aMarkdownTextInput. Animate a wrapper or use plain transforms instead.@expensify/react-native-live-markdownversion in App'spackage.jsonand update the patch if one exists.What alternative solutions did you explore? (Optional)
Testing
MarkdownTextInputwith text and spy onMarkdownParser parse:. Update onlymarkdownStyle, layout props or the font. Assert that the parser is not called again and that the attributes are updated correctly. Change the text and assert that it is called once.runOnRuntime. Trigger a layout animation that changes the props of aMarkdownTextInput. Before the fix the main thread blocks. After the fix there is no hang, and the UI stays responsive.MelvinBot commentedon Oct 22, 2026
Updated 2026-10-25: Corrected based on feedback from
TaduJR.Proposal
Please re-state the problem that we are trying to solve in this issue.
The app freezes with a fatal App Hang (APP-M0W) while a Live Markdown input parses text on the main thread. The same hang appears on Android.
What is the root cause of that problem?
A lock-order deadlock between two worklet runtimes.
TaduJRconfirmed it with lldb on the iOS simulator.MarkdownTextInput, and Live Markdown parses its text on the main thread through theLiveMarkdownRuntime.RNMarkdownTextInput.tsx:70readsmentionsSharedVal.get().SearchAutocompleteInput.tsx:186passes five SharedValues toparseForLiveMarkdown, which reads them several times per parse infilterOutRangesWithCorrectValue. So the Search bar can freeze the same way.What changed to cause this?
What changes do you think we should make in order to solve the problem?
Never read a SharedValue inside a parser worklet. Capture the data in the parser closure instead, and keep the parsers stable while typing.
RNMarkdownTextInput: the default parser capturesavailableLoginsListin its closure. Pass a customparserprop straight through instead of wrapping it.SearchAutocompleteInput: pass oneKnownFilterValuesobject of Sets (userLogins,currencies,categories,tags,exportedTo) toparseForLiveMarkdown, and useSet.hasinfilterOutRangesWithCorrectValue.useOnyxselectors.useExportedToFilterOptions, read the policy IDs again afteruseCombinedExportTemplates. React Compiler drops memoization for a value made before a hook call and used after it, so the hook returned a new array on every render and the Search parser changed on every keystroke.scheduleOnLiveMarkdownRuntimeeffects, the helper, and its mock injest/setup.ts.The library hardening in
react-native-live-markdown(main-thread parse reads only the cache) is out of scope and will be a separate follow-up.Tests
SearchAutocompleteUtilsTestto passKnownFilterValues.useExportedToFilterOptionsreturns the same array across re-renders with unchanged data.SearchAutocompleteInputpasses the same parser when only the query changes.What alternative solutions did you explore? (Optional)
LiveMarkdownRuntime: unsafe, because the parser runs on several threads.Confidence: high.
TaduJRconfirmed the lock owners with lldb.Implemented in Stop reading SharedValues in Live Markdown parsers to prevent an App Hang deadlock.
camesenin commentedon Oct 22, 2026
melvin-bot commentedon Oct 22, 2026
✅ Contributor details stored successfully. Thank you for contributing to Expensify!
shilo1979jk commentedon Oct 24, 2026
Proposal
Please re-state the problem that we are trying to solve in this issue.
On HybridApp iOS, the app can freeze for >2 seconds (Sentry
APP-M0WApp Hang) when mounting or updatingRNMarkdownTextInputwhile a layout animation is flushing on the main thread. The main thread blocks inside-[MarkdownParser parseUncached:withParserId:]waiting for theLiveMarkdownRuntimemutex while holding the Reanimated UI runtime lock.What is the root cause of that problem?
The hang is a classic AB-BA lock-order inversion between the Reanimated UI runtime mutex and the
LiveMarkdownRuntimeworker mutex:Main thread (holds UI runtime lock -> waits for
LiveMarkdownRuntimelock):During a Reanimated layout animation flush on the main thread (
-[REANodesManager performOperations]->executeLayoutAnimationsRequests), the main thread holds the UI runtime lock and flushes Fabric mount mutations (RCTMountingManager.mm:83->-[MarkdownTextInputDecoratorComponentView updateProps:oldProps:]->applyNewStyles->-[RCTMarkdownUtils applyMarkdownFormatting:inputView:]->-[MarkdownParser parseUncached:withParserId:]). Because the component view'sRCTMarkdownUtilsinstance has its own parser cache (separate from the shadow node's cache), the cache misses on initial mount and synchronously entersLiveMarkdownRuntime, waiting on itsstd::recursive_mutex.LiveMarkdownRuntimeworker thread (holdsLiveMarkdownRuntimelock -> waits for UI runtime lock):In
src/components/RNMarkdownTextInput.tsx:38and62-81,mentionsSharedValis a ReanimatedSharedValue(useSharedValue<string[]>(availableLoginsList)):In
react-native-reanimated, readingmentionsSharedVal.get()from a non-UI worker runtime (LiveMarkdownRuntime) callsgetSync()(mutables.native.ts), which synchronously dispatches into the UI runtime and waits to acquire the UI runtime lock.Why a simple
useEffect-only runtime global is not enough on initial mount:If
mentionsSharedValis removed and replaced only by aglobalThisassignment insideuseEffect(() => { scheduleOnLiveMarkdownRuntime(...); }, [availableLoginsList]), the very first synchronous parse during Fabric mount (RCTMountingManagerInsert mutation) executes before React'suseEffectand before the asynchronousscheduleOnRuntimetask runs onLiveMarkdownRuntime. At that moment, the runtime global would still beundefined, causing existing draft@shortMentionsto fail to highlight on initial mount.What changes do you think we should make in order to solve the problem?
In
src/components/RNMarkdownTextInput.tsx:useSharedValue(mentionsSharedVal) completely soparserWorkletnever makes a synchronous cross-runtimegetSync()call into the UI runtime while holding theLiveMarkdownRuntimelock.availableLoginsListin aLiveMarkdownRuntime-local global (globalThis.__liveMarkdownAvailableLogins) WITH an initial closure fallback for synchronous mount parses:const initialAvailableLoginsRef = useRef(availableLoginsList);) captured once whenparserWorkletis created so that ifparserWorkletruns synchronously during the initial Fabric mount (beforeuseEffect/scheduleOnLiveMarkdownRuntimehas executed),globalThis.__liveMarkdownAvailableLogins ?? initialAvailableLoginsalready has the initial list without re-creatingparserWorkleton everyavailableLoginsListupdate.useEffect, usescheduleOnLiveMarkdownRuntimeto updateglobalThis.__liveMarkdownAvailableLogins = availableLoginsListdirectly on the markdown runtime wheneveravailableLoginsListchanges:scheduleOnLiveMarkdownRuntimeinsrc/libs/scheduleOnLiveMarkdownRuntime/index.native.tsxaccepts(worklet, ...args)and forwards...argstoscheduleOnRuntime, avoiding recreating the worklet closure on every render.)What alternative solutions did you explore? (Optional)
availableLoginsListdirectly inparserWorklet'suseCallbackdependency array ([availableLoginsList, currentUserMentions, parser]): Rejected becauseavailableLoginsListcan contain up to 20,000 logins on large accounts; re-registering a newparserIdand re-serializing the full array on every personal-details update would add unnecessary overhead.globalThis.__liveMarkdownAvailableLoginsinuseEffectwithout an initial fallback: Rejected because Fabric mount (updateProps->applyNewStyles) invokesparserWorkletsynchronously beforeuseEffectruns, which would leaveloginsempty on initial mount.21 remaining items
mountiny commentedon Nov 6, 2026
Getting there.
jeffrey-graham commentedon Nov 7, 2026
melvin-bot commentedon Nov 7, 2026
TaduJR commentedon Nov 9, 2026
@MelvinBot
Please remove the Payment Label from the issue title.
[-][Due for payment 2026-11-13] [$175] [Sentry: APP-M0W] HybridApp iOS: App Hang, Live Markdown parser blocks the main thread on the JS runtime lock[/-][+][$175] [Sentry: APP-M0W] HybridApp iOS: App Hang, Live Markdown parser blocks the main thread on the JS runtime lock[/+]MelvinBot commentedon Nov 9, 2026
Removed “[Due for payment 2026-11-13]” from the issue title.
view run
melvin-bot commentedon Nov 12, 2026
@TaduJR Uh oh! This issue is overdue by 2 days. Don't forget to update your issues!
expensify-chore-bot commentedon Nov 18, 2026
@TaduJR Now this issue is 8 days overdue. Are you sure this should be a Daily? Feel free to change it!
expensify-chore-bot commentedon Nov 19, 2026
@mountiny @TaduJR this issue is now 4 weeks old, please consider:
Thanks!