ZaStoGram/TMessagesProj/jni/twidget/patches/README.md
2026-11-12 04:43:03 +02:00

245 lines
25 KiB
Markdown
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# The widget projects and the changes made to them here
The widget renderer is built from two public Telegram repositories, git submodules in `jni/twidget/` (since
2026-11-07; plain-file copies before), next to the Android bridge (`twidget-bridge.cpp/.h`, `twidget.cmake`).
Both are used exactly at the pinned commits: Telegram changes to them go into the repositories themselves,
and this file lists what earlier patches became there.
| Submodule (`jni/twidget/…`) | Repository | Version |
|---|---|---|
| `widget-sandbox/` | github.com/TelegramMessenger/widget-sandbox | `c498cef` on `v0.6.3` (2026-11-10: the QuickJS pin moves to `ca3594d`, `await using` only in async functions, bundles unchanged; `v0.6.3` at `7a2ec35` before it: 2026-11-09: QuickJS parser label hardening, failed `new_label()` allocations fail the parse instead of reaching `fd->label_slots[-1]`; the six `corpus/attacks/render-*` widgets for native renderers; the bundles differ only in the version stamp. `v0.6.2` before it: the same for `push_scope()`; `v0.6.1`: the QuickJS security release), unchanged |
| `widget-sandbox/packages/ios/Sources/CQuickJS/quickjs/` | its submodule, github.com/TelegramMessenger/quickjs | `ca3594d` (2026-11-10: `await using` in a for-in/of head is a SyntaxError outside async functions, its disposal ran `OP_await` in a normal frame whose exit skipped `close_var_refs()`, a use-after-return from widget script; the interpreter refuses suspending a normal frame; reported against 13.2.1. On top of `b02310a`, 2026-11-09: new_label() allocation failures fail the parse instead of reaching `fd->label_slots[-1]`, with a test, on top of `09bb809`: the same for push_scope() and `fd->scopes[-1]`, on top of `1a402cb`, branch `fixes-backport`, 2026-11-06: memory-safety fixes from quickjs-ng after 0.17.0 on `c24d6b0`, among them the RegExp bytecode use-after-free of the widget RCE report), pinned by widget-sandbox; only its `quickjs.c`, `dtoa.c`, `libregexp.c` and `libunicode.c` are compiled (its own `test262` submodule is `update = none`) |
| `twidget/` | github.com/TelegramMessenger/twidget | `4769d72` (2026-11-09: list markers out of a style's range are decimal, roman past 3999 drew one 'M' per thousand. `8c6d311` before it: var() substitution is capped at 16,384 tokens per declaration, and a layout pass at 100,000 + 50 per element boxes, past which the renderer freezes with its badge: nested var() and nested flex/grid/table boxes ran out of memory or hung the host thread. `f385525` before it: repeating gradients of a zero or tiny period draw their average colour; `repeating-linear-gradient(red 50%, blue 50%)` grew its stops until the engine ran out of memory. On main after the reorganisation (`f083a1f`: `core/`, `litehtml/` at the top), which changed only paths since `db9afca`'s layout fixes) |
What the Android build compiles (`jni/twidget/twidget.cmake`, into `libtwidget.so` alone, not the client library, but for the client's share below): widget-sandbox's C++ core
(`packages/desktop/sandbox`, without `icu_intl.cpp`, Windows' ICU: Android answers Intl from Java) and QuickJS, twidget's `core/src` and its litehtml fork
(`litehtml`); `twidget.cmake` generates `tw_ua_stylesheet.h` from widget-sandbox's `profile.json`, as twidget's CMake does. The JS bundles in `assets/WidgetSandbox/WidgetJS` are widget-sandbox's
`packages/desktop/WidgetJS` of the same commit, byte for byte; `manifest.txt` is their SHA-256.
The Java side is in `org.telegram.utils.twidget` (the bridge's `WidgetSandboxNative` and `WidgetSandboxBackend`,
the session and the message, painting, the chat's widget messages in `WidgetMedia`, the debug runners), except what
draws a widget into a View, which stays in `org.telegram.ui.Components`: `RichWidgetBlock` (the chat bubble),
`WidgetInlinePreview` (an inline result) and `WidgetSandboxPlayer` (frames and touches between the two).
## Processes (since 2026-11-07)
A widget's code (its JavaScript in QuickJS, the validator, the TwidgetCore renderer) runs in an isolated process,
`WidgetEngineService` (`android:isolatedProcess`, `:widgets`): no permissions, no network (no `inet` group), no access
to the app's files, SELinux `isolated_app`; on every Android widgets run on (6+). One process holds every widget,
each session on threads of its own with a QuickJS runtime of its own: it keeps the app's accounts, messages and keys
from widget code, not one widget from another (a process per bot was tried and dropped on 2026-11-08 for the memory,
about 25 MB PSS a process). It is bound with `BIND_IMPORTANT`, so it runs in the client's scheduling group (top-app
with the chat on screen; in `foreground` a weak phone kept it on slow cores). The process loads only `libtwidget.so`
and the bundles from the APK's assets (`WidgetSandboxNative#registerResources`); `ApplicationLoader` starts nothing of
the client there. When it dies every shown widget restarts (`RichWidgetBlock#restartWidget`, twice a minute at most).
- Start: the app binds the engine 3 s after `postInitApplication` and keeps it for its lifetime
(`WidgetRemoteEngine#prewarm`, `IWidgetEngine#warmup` loads the bundles), so a widget's first frame does not wait for
the process: on the Fold emulator a first session took 356 ms cold (206 ms to bind, 69 ms bundles) and ~40 ms warm.
An idle engine takes no CPU. Low-RAM devices and the kill switch keep the lazy start (first widget, 30 s idle unbind).
- Death: the client gives the binding up (`WidgetRemoteEngine#drop`) and binds afresh for the next session, or on the
next return to the foreground (prewarm), instead of waiting for the system to bring the service back: on One UI and
MIUI 14 it never did for an isolated process, so after the engine was killed in the background no widget started
("Widget engine did not start") until the app restarted (a Galaxy A24 on 7297, reproduced with `am crash`).
- seccomp (`twidget-seccomp.cpp`, `WidgetEngineService#onCreate`, before any session): exec, process creation,
ptrace, perf events, eBPF, io_uring, keyrings, module and mount calls, non-`AF_UNIX` sockets, kernel-mode
`userfaultfd`. Audit for now (`SECCOMP_ENFORCE`): the calls trap, are logged as `TwidgetSeccomp` and redone through
an escape hatch the filter lets through, so nothing changes; exec and process creation get EPERM even then. Enforce
kills the process on them. Not filtered: `ioctl` (ART's GC makes userfaultfd ioctls with SIGSYS blocked, where any
trap kills the process) and user-mode `userfaultfd` (ART's GC on Android 14+). Calls the system's own app filter
refuses as well come back ENOSYS in audit (stacked filters report our trap data). Needs `SECCOMP_FILTER_FLAG_TSYNC`;
without it the engine runs unfiltered and logs so.
- The client (`WidgetRemoteEngine`) creates sessions over `IWidgetEngine` (AIDL, oneway after `create`) and gets each
session's calls back over `IWidgetEngineCallback`, synchronously, so frames keep their order and the engine waits for
the painter as it did in-process. The engine's backend (`WidgetEngineBackend`) answers layout itself (text widths,
decoded images, Intl) and sends the client what it paints with: fonts by their parameters, images as pixels (a
parcelled `Bitmap`), canvas batches, display lists (in 256 KB parts above that; only those large calls share a lock,
so the host thread's signals never wait for the recorder's frame, which serialised every tick behind the client's
draw). Font metrics come back from the
client's `defineFont`, so layout and painting use one font. MIUI's `Typeface.create` reads a font setting from
`Settings`, which an isolated process is refused: there the engine makes no fonts and asks the client for each
width (`textWidth`, cached per font). Painting (RenderNodes,
canvases, filters, layers) stays in the client, as do requests, actions, storage and the gesture arbiter.
- What comes back is untrusted: `WidgetGate` keeps the user- and bot-facing part of the engine's policy in the client,
never stricter than it (links and `copyText` one per delivered press, requests with `can_query` one in flight, as a
press's or under `background_query`, wallet calls by a press or the grant, haptics at 10 a second, the engine's sizes
and link rules); `WidgetSandboxBackend` caps fonts, layers, display ops, canvas batches and frames per second.
- A process that dies (a crash, the system) ends its sessions (`WidgetSandboxSession#onEngineDied`); a shown widget
starts again through its block, twice a minute at most (`WidgetSandboxMessage#onEngineDied`). The client process
lives on. A process is unbound 30 s after its last session.
- The client never loads `libtwidget.so` (since 2026-11-09): QuickJS, the validator and the renderer are mapped only
into the engine process. What the client runs of the same code, widget-sandbox's gesture policy
(`gesture_policy.cpp`) and twidget's CPU filter pass (`core/src/filters.cpp`), neither of which reads widget code, is
compiled into the client library as an object library (`twidget_client_sources` in `twidget.cmake`, JNI in
`jni/twidget/twidget-client.cpp`, Java `WidgetClientNative`). Private builds can run the engine in-process for
comparisons (`WidgetConformanceActivity --ez inProcess true`), which loads `libtwidget.so` into the client at that
session's create; every other build always isolates.
## Updating
1. Check out the new commit in the submodule and stage it: `git -C TMessagesProj/jni/twidget/widget-sandbox checkout
<tag>`, then `git submodule update --init --recursive TMessagesProj/jni/twidget/widget-sandbox` for the QuickJS
commit it pins (a fresh clone needs the same command). Ninja rebuilds by the checked-out files' times, which are
the checkout's own, so no objects go stale (the copies dated by `git archive` once linked old and new code
together: heap corruption at the first `~WidgetHost`, 2026-10-21 and 2026-10-23).
2. A change Telegram needs goes into the repository first (a branch or `main`, as its owners take it), then step 1.
3. Copy the bundles, regenerate `assets/WidgetSandbox/manifest.txt` (`<sha256> <name>` with one space, which
`WidgetSandboxResources` splits on: `shasum` writes two), update the table above and the versions in `WidgetStressRunner`.
New TwidgetCore sources are compiled by name in `twidget.cmake` (widget-sandbox's by a glob). A new or renamed JNI
callback goes into both backends, `WidgetSandboxBackend` and `WidgetEngineBackend`, and `IWidgetEngineCallback`.
## twidget: no changes
The layout the conformance set (`auto/28-grid-percent-fill`, `29-grid-svg-marks`, `30-svg-fill-box`) and the bot demos'
poll, duel and ticker drew wrong, and a canvas sized by its CSS width alone, were `twidget-layout.patch` here from
2026-10-31 and are in twidget itself since `db9afca` (2026-11-02):
- `render_grid.cpp`: an item across a flexible track has no automatic minimum and grows only the flexible tracks; a
replaced item with a % width has no minimum; a % height of an item needs this grid's own height, not an ancestor's;
flexible rows take a share per `fr`, as the columns do.
- `render_block.cpp`: `aspect-ratio` from the width after `max-width` and `min-width`.
- `render_image.cpp`: a % height with nothing to resolve against is the ratio's.
- `transform-box: fill-box` (and `stroke-box`, the same centre) on SVG shapes: `string_id.h`, `style.cpp`,
`css_properties`, `el_svg.cpp`.
- `renderer.cpp`: a drawn `<canvas>` no longer passes its `width` and `height` attributes to the fork's image, where they
became its style: with only a CSS width its height stayed at the attribute and the widget's own coordinates missed
(TwidgetCore's `core_tests.cpp` checks it). The widget case is `tests/canvas-aspect.html` (no number: widget-sandbox's
`auto/37` is another case), not in widget-sandbox's set yet. A canvas not drawn on yet still has them.
The Telegram changes that used to be `twidget-telegram.patch` are in twidget itself since 2026-10-20
(`3f242e4`…`edfafc8`: line height, right alignment, `var()` in cascade order, out-of-flow children of flex
and grid, collapsed table borders, SVG gradient strokes, rounded dashed/dotted and double borders, the image
placeholder's aspect). The border snapping to device pixels (Telegram `5b74389`) was dropped earlier: the
fork's half-CSS-px widths are what the conformance set measures.
What the bridge implements for `9f68fbc`'s `Backend` (`twidget-bridge.cpp`, `WidgetSandboxBackend`):
- `canvas_run` hands a batch to `WidgetCanvas` as int words (`encodeCanvasOp`), not as `twlite::to_json`: on the Redmi Note 8T
JSON took most of `receive` on a canvas-drawn widget.
- Display lists (the frame's and layer contents) go to Java in the bridge's binary form (`encodeDisplayList`, read
by `WidgetDisplayList` as untrusted input: bounds-checked, counts checked before allocating), not as
`twlite::to_json` (since 2026-11-08). On the Redmi Note 11 `dom-tick/1000` went from 22 to 10.5 ms per frame and
`svg-path/4000` from 14 to 6 (parse 6 ms → 0.1, serialise 1–2 ms → 0.1). The stress kit's `parse` now covers the
header only; decoding happens while painting, in `canvas`. Points keep full float precision (JSON rounded to
hundredths). The composition stays JSON (small), as does the selectable text; `WidgetSandboxSession#dump`
converts the list back to to_json's keys (`WidgetDisplayList#toJson`).
- `create_font` takes the OpenType features (`tnum=1,zero=1`, from `font-variant-numeric` and
`font-feature-settings`); `WidgetSandboxBackend#featureSettings` turns them into
`Paint#setFontFeatureSettings` syntax (`"tnum" 1, "zero" 1`).
- `FontMetrics::em_ascent` / `em_descent` (the OS/2 em box for canvas `textBaseline`) stay 0: Android does
not expose the OS/2 table, and the core then normalises ascent and descent itself.
- A damaged PNG: twidget's `png_intact_rows` (`src/png.cpp`, compiled) is the same rule as
`WidgetPng`, which keeps doing it on the Java side, where BitmapFactory refuses such a PNG outright.
- `bg_color` of an outgoing bubble with a gradient: the gradient spans the chat's height and moves under the
bubble as it scrolls, so `WidgetSandboxTheme` passes the average of its colours (sdk-v1 §5.1).
- The theme's text tokens (`WidgetTheme.text`, v0.1.1) for the UA layer: `WidgetSandboxTheme` passes the chat's
text size, the message paint's line height and the text's inset in the bubble; `parseTheme` reads them.
- Who gets a press (sdk-v1 §5.5, v0.1.2; v0.1.3: vertical drags are always the chat's, `y` is always false): the
host's `onGesture` claim (`x`, `hold` from `touch-action`)
goes to the player (signal 3), which feeds it with the press to widget-sandbox's own C++ `GestureArbiter`
through the bridge (`WidgetGestureArbiter`, no Java copy of the policy). A verdict for the bubble ends the
press for the widget (`touch` action 3, `pointercancel`) and frees the chat's recognizers: the list scroll,
swipe-to-reply (`ChatActivity`'s list keeps tracking a swipe while the widget may still give it), the
message menu: a hold over the widget opens it at the policy's 500 ms from the arbiter's verdict
(`ChatMessageCell#onWidgetHold`, with the widget's `pointercancel`); the cell's own long press, on the system's
timeout, skips presses over the widget (`ChatMessageCell#onLongPress`). A double tap over the widget is the
widget's (`ChatActivity#hasDoubleTap` is false for it); the renderer sends the widget its `dblclick` and
`contextmenu` itself. The conformance runner's touches go through the same arbiter as a bubble.
The chat list hands a cell a copy of each DOWN first (`RecyclerListView`: no down time, no tool type); the
player sends the widget the DOWN of the real event that follows.
- A mouse (Chromebook, DeX, a tablet's mouse): its presses go to the arbiter and the renderer as a mouse's
(`MotionEvent#getToolType`, the secondary button, the modifier keys): its drags and holds are the widget's, the
list never pans or swipes under it, a right click opens the menu or the widget's `contextmenu`. Hover events
(`ChatMessageCell#onHoverEvent` → `RichWidgetBlock#onHoverEvent`) give the widget `:hover` and the over/out
events, and the renderer's CSS cursor (signal 11) becomes the cell's `PointerIcon` (API 24). No keyboard and no
wheel: both are out of profile 1 (D4, D3a).
- The finger rule (v0.3.0, `docs/decisions.md` "User activation"): TwidgetCore marks a finger's or a pen's `pointerdown`
and compatibility `mousedown` untrusted itself since `710bb77` (the bridge did it before): the gesture counts from the
release, and a press that becomes the chat's scroll calls nothing. A mouse keeps its press.
- Strict limits (v0.3.0): `WidgetHost` stops the widget at the validator's counted caps and runs the main-thread
window itself; the bridge scales `mainThreadQuotaMs` with the CPU multiplier as it does `cpuQuotaMs`.
- Heavy boxes (v0.6.0): TwidgetCore counts them before each frame (`src/paint_policy.cpp`) and answers `WidgetHost`'s
`policy` itself; its `limit` message reaches the host with the renderer's other output (`AndroidRenderer#dispatch`),
and `WidgetHost` stops the widget. The validator's time (`chargeValidator`) and the bundles' version stamps
(`bundle_stamp.cpp`, `bundle-mismatch`) are `WidgetHost`'s and `SandboxEngine`'s own: nothing in the bridge.
- Touch text selection (sdk-v1 §5.10): the bridge sends `Renderer::selectable_text_json()` to
`WidgetSandboxBackend#selectableText` after a layout that changes it; `WidgetText` turns it into
`android.text.Layout`s that `RichWidgetBlock` hands to the chat's `TextSelectionHelper`. The renderer's
own mouse selection is not used on Android. A run's matrix (where its transforms and layer show it) is
applied when it only moves and scales; a turned or skewed run is selected where layout put it.
- The time over the widget (v0.4.0, sdk-v1 §2.17, §5.12): with no caption below the widget (none, or shown above it,
`invert_media`), a bubble (not the compact incoming layout) and no reactions row, `ChatMessageCell` draws the time
over the widget's bottom right corner on the backing it draws over a photo, 6 dp inside the widget's edges; the
bubble has no time line and ends 2 dp under the widget, whose bottom corner away from the tail follows the bubble's.
An incoming message's backing is 6 dp inside the widget's right edge; an outgoing one's sits as over a photo (the
ticks over media keep to the cell's width). The band (23 dp: the backing and the 6 dp under it) and the corner (6 dp,
the backing: the time, its padding, an outgoing message's ticks; 4 dp before it), rounded up to whole CSS px, go to
the host as `contentSafeArea`: at creation in the sdk JSON of
`WidgetSandboxNative#create`, from the layout's estimate (`RichWidgetBlock#estimateSafeArea`: the cell's own time text,
`ChatMessageCell#timeString`, and a channel post's views), so a widget measured off screen already has the band in its height; then the cell's own numbers on its layout
(`WidgetSandboxNative#safeArea` → `setContentSafeArea`, only when they change). The right corner in a right-to-left
interface too: the chat draws the time on the right there as well. Taps on the time stay the bubble's as before.
The conformance runner passes a test's `safeArea` (auto/36, visual/17).
- Debug: `WidgetSandboxNative#conformance` makes every session report its `data-conformance` attribute
(signal 9) for `WidgetConformanceRunner`.
- The resize anchor (sdk-v1 §2.12, §5.6, v0.1.3): the bridge adds `WidgetDiagnostics::resizeAnchor` to the
diagnostics (signal 4); `WidgetSandboxSession` puts it on the next recorded frame (`Frame#anchorBottom`) and
`WidgetSandboxMessage` keeps the shown frame's. `RichWidgetBlock#relayout` keeps the cell's top for `top`
(`forceUpdate(cell, true, true)`, as "Summarize" does) and leaves `bottom` to the chat, laid out from its
bottom; while the bubble animates, the frame is clipped to its drawn bounds and moves with the anchored edge
(`TransitionParams#deltaTop` / `deltaBottom`). The anchor is kept with each cached height (`widget_heights.anchor`,
database version 181): before its first frame a widget opens on the anchor of its latest cached height.
Only a cell the list shows keeps its top; one laid out off screen changes height as any message does.
- The payload (`WidgetMedia#inflate`): zlib (RFC 1950) since the server's `gzcompress` switch; gzip (`1f 8b`)
is still read for messages sent before it.
- Not used: `Renderer::set_resize_tracking` (a guess of which side to keep still; the widget's anchor decides).
- The widget's state and requests (sdk-v1 §5.11, v0.2.0): `WidgetMedia` passes each message's `chat_data` /
`public_data` as `data` and the server's flags as `context` (`is_copy`, `can_query`, `background_query` as they are;
the chat type, none for a copy; the account as `viewer` only with `can_query`; `preview` for an inline result) in the
sdk JSON of `WidgetSandboxNative#create`. `updateMessageWidgetData` (the account's pts sequence; a supergroup's state
comes with the usual post edit) is stored with the message (`MessagesStorage#updateMessageWidgetData`) and reaches the
live widget through `WidgetSandboxNative#data` (`setData`). Requests (signal 12) go out as
`messages.getBotWidgetQueryAnswer` and come back through `answerRequest`: `WIDGET_RESPONSE_TIMEOUT` a timeout,
`FLOOD_WAIT` rate limited, anything else (and 30 s without an answer) failed. `copyText` (signal 13) copies and shows
the text (the system shows it on Android 13+). `watchPublicData` (signal 14): one poll per shared widget (`widget_id`)
with a watching widget on screen, `messages.getWidgetPublicData` with the last hash at the server's period (30 s
before the first answer, 5–3600 s); a new value goes to every widget of that id and is stored. The network marker
(`RichWidgetBlock`): a globe at the widget's top trailing corner where the message has `can_query`, explained on a
tap; none in a private chat with a bot (`WidgetMedia#showsNetworkMarker`). Inline results (`botInlineMessageWidget`) are previews (`WidgetInlinePreview` in `ContextLinkCell`, no input)
and are sent as widgets; a forwarded widget keeps its header (drop_author does not apply).
- Haptics need a touch (v0.2.2): TwidgetCore reports the press's start (`gesture`) but not its end, so the bridge
posts the framework's `{ type: 'release' }` when the primary pointer goes up or is cancelled.
- The wallet (v0.5.0, sdk-v1 §2.18, §5.13; the server's API as agreed in `2e575a7`): `context.wallet` where the
widget may ask its bot and `config.walletAvailable` (the country) allows it. A request with `{ wallet: true }` goes out
as `widgetQueryTypeData` with `with_wallet`. A wallet call (`onWallet`, signal 19) opens `GramWalletWidget`, the
wallet's own window: the bot of the message in its header (`via_bot_id`, else the author or the forward's author,
a bot; otherwise `badRequest`), taps ignored for its first 0.7 s, the preview's fee, "Top up" (onramp) while the
wallet holds less than the transaction. On confirmation the transfer goes out by `wallet.sendTransfer` and the
message's normalised hash (TEP-467, `WalletMessageHash`: the server's `msg_hash` is its plain hash) goes to the bot as
`widgetQueryTypeSentTransaction`, in base64 (the server refuses hex with `WIDGET_MSG_HASH_INVALID` and gives the bot
hex itself); `signData` is signed for `bot<bot_id>` (a
throwaway TON Connect session for the engine: it takes no part in the signature) and goes as
`widgetQueryTypeSignData`; both with the device's wallet (`userWallet`: the address, the balance, the key and the
contract's StateInit, TON Connect's `walletStateInit`). The window closed or declined answers `rejected` (4), the
wallet's refusal `badRequest` (5). A plain request on a server without the query types yet
(`INPUT_METHOD_INVALID` / `INPUT_CONSTRUCTOR_INVALID`) goes again in its earlier form
(`TL_messages_getBotWidgetQueryAnswer_layer233`), and the account keeps that form until the app restarts; a wallet
query fails there.
`FilterPush`/`FilterPop` and `Backdrop` (`filter`, `backdrop-filter`) are drawn by the Java painter
(`WidgetSandboxPainter`): on API 31+ on a hardware canvas through `RenderEffect`; otherwise `filter` goes
through twidget's shared CPU pass (`core/src/filters.cpp`, `WidgetClientNative#filterPixels` in the client library) on
a bitmap of the content, as twidget's own Android painter does. `backdrop-filter` needs the pixels under
it and stays API 31+ only.
## widget-sandbox: no changes
`v0.1.2` has the hidden timers' order in every glue copy, which Telegram carried as
`widget-sandbox-telegram.patch` until `b66576f` (a hidden widget's timers wait at least a second plus a tenth
of their own delay, so `setTimeout` 20, 10, 0 run 0, 10, 20; conformance `auto/15-js-runtime-a`), and the
gesture policy (below). The JS bundles are `v0.6.3`'s, stamped `version=0.6.3 protocol=1 profile=1 sdk=1`: with
bundles of another protocol, profile or sdk the engine refuses to boot (`bundle-mismatch`).
Telegram's earlier change (`holdScripts` / `releaseScripts` in the C++ `SandboxEngine` and `WidgetHost`: a
static first layout with the scripts held back) is not carried onto `v0.1.0`; the chat uses the cached
height or the message's size anchors instead. The Android-only `getrandom` shim
(`WidgetSandboxAndroidCompat.h`) is gone: `v0.1.0` uses `arc4random_buf` on Android itself.