Long guides and case studies now have a small `↑ Top` link at the bottom right. It appears after scrolling, returns smoothly to the page header, and moves keyboard focus back to navigation. Reduced-motion users return immediately; the native `#top` link also works without JavaScript. The link is shared by all 11 styled website pages. The README and style guide document it, and the evidence notes retain the original browser-example digest alongside its later navigation addition. Validation: - Website preparation and verification: 12 HTML pages, 195 local references, SVG XML, the six-file ZIP and the sole manual Pages publisher. - Oxfmt, `git diff --check` and `npm run check:fast` with Node.js 24.18.0. - Focused browser checks at `/` and `/rea/`: 22 routes, 21 pointer returns, six keyboard returns, five viewport widths, smooth scrolling, reduced motion, focus return and the no-JavaScript anchor. - Existing site interactions: 24 routes, 68 copy buttons, 20 comparison steps, two CSV exports, two ZIP downloads and eight viewport widths from 320px to 1440px. Code excerpts are unchanged. - Desktop and mobile rendering reviewed. Downloadable Electron source and CSV export source/data are unchanged. Publication continues through the existing manual Pages workflow after merge.
466 lines
20 KiB
HTML
466 lines
20 KiB
HTML
<!doctype html>
|
||
<html lang="en">
|
||
<head>
|
||
<meta charset="utf-8" />
|
||
<meta name="viewport" content="width=device-width, initial-scale=1" />
|
||
<title>Following Notion's clipboard through Electron — REA</title>
|
||
<meta
|
||
name="description"
|
||
content="Follow Notion's clipboard API through Electron's preload, IPC wrappers and main process, with short code excerpts and a look at its rich clipboard format."
|
||
/>
|
||
<meta name="theme-color" content="#ffffff" />
|
||
<link rel="icon" href="../../assets/favicon.svg" type="image/svg+xml" />
|
||
<link rel="stylesheet" href="../../assets/styles.css" />
|
||
<script src="../../assets/main.js" defer></script>
|
||
</head>
|
||
<body id="top">
|
||
<a class="skip-link" href="#main">Skip to content</a>
|
||
<header class="site-header">
|
||
<div class="container header-inner">
|
||
<a class="brand" href="../../" aria-label="REA home"
|
||
><span class="brand-name">REA</span
|
||
><span class="brand-caption">Reverse Engineer Anything</span></a
|
||
>
|
||
<nav class="navigation" aria-label="Main navigation">
|
||
<a href="../">Showcases</a>
|
||
<a class="nav-start" href="../../get-started/">Get started</a>
|
||
<a href="../../guides/">Guides</a>
|
||
<a href="https://github.com/morluto/rea">GitHub</a>
|
||
</nav>
|
||
</div>
|
||
</header>
|
||
<main id="main" class="container">
|
||
<div class="page-heading">
|
||
<p class="breadcrumb">
|
||
<a href="../../">Home</a> / <a href="../">Showcases</a> / Notion
|
||
</p>
|
||
<p class="eyebrow">Case study · Electron</p>
|
||
<h1>How Notion copies<br />text and HTML.</h1>
|
||
<p class="lede">
|
||
Trace a clipboard call from Notion's page API, through the preload and
|
||
main process, to Electron's clipboard writer.
|
||
</p>
|
||
<p class="page-meta">Notion Desktop 7.6.1 · JavaScript · REA</p>
|
||
</div>
|
||
|
||
<figure class="workflow-figure">
|
||
<p class="figure-title">The bridge inside Notion's desktop package</p>
|
||
<ol class="flow-steps notion-bridge-flow">
|
||
<li>
|
||
<span class="flow-label">01 · Page-facing API</span>
|
||
<span class="flow-node"><code>clipboard.write(data)</code></span>
|
||
<span class="flow-note"
|
||
>The preload exposes a callable method.</span
|
||
>
|
||
</li>
|
||
<li>
|
||
<span class="flow-label">02 · Preload wrapper</span>
|
||
<span class="flow-node"><code>ipcRenderer.invoke</code></span>
|
||
<span class="flow-note"
|
||
>The wrapper sends the channel and arguments.</span
|
||
>
|
||
</li>
|
||
<li>
|
||
<span class="flow-label">03 · Main-process handler</span>
|
||
<span class="flow-node"><code>ipcMain.handle</code></span>
|
||
<span class="flow-note"
|
||
>The receiver checks which page sent it.</span
|
||
>
|
||
</li>
|
||
<li>
|
||
<span class="flow-label">04 · System clipboard</span>
|
||
<span class="flow-node"><code>clipboard.write(data)</code></span>
|
||
<span class="flow-note"
|
||
>Electron writes the supplied text and HTML.</span
|
||
>
|
||
</li>
|
||
</ol>
|
||
<p class="flow-result">
|
||
One channel joins the two sides:
|
||
<code class="notion-channel">notion:clipboard:write</code>
|
||
</p>
|
||
<figcaption>
|
||
The packaged code uses the same channel in the preload and main
|
||
process. Resolving the wrappers reveals the Electron calls behind
|
||
those names.
|
||
</figcaption>
|
||
</figure>
|
||
|
||
<div class="article-layout">
|
||
<nav class="contents" aria-label="On this page">
|
||
<p>In this case study</p>
|
||
<ul>
|
||
<li><a href="#clipboard">Follow the clipboard bridge</a></li>
|
||
<li><a href="#rich-clipboard">Keeping a block's structure</a></li>
|
||
<li><a href="#continue">More examples and sources</a></li>
|
||
</ul>
|
||
</nav>
|
||
<article class="article" aria-label="Notion Electron case study">
|
||
<section class="article-section" id="clipboard">
|
||
<h2>Where does the copy operation go?</h2>
|
||
<p>
|
||
The page sees a method called <code>clipboard.write</code>. Its
|
||
implementation in the preload is a wrapper. The useful question is
|
||
what that wrapper sends, and which code receives it.
|
||
</p>
|
||
<div class="agent-terminal">
|
||
<div class="terminal-header">
|
||
<span class="terminal-title"
|
||
><span class="terminal-dots" aria-hidden="true"
|
||
><i></i><i></i><i></i></span
|
||
>Your coding agent</span
|
||
><button
|
||
class="copy-button"
|
||
type="button"
|
||
data-copy="notion-prompt"
|
||
aria-label="Copy Notion analysis prompt"
|
||
>
|
||
Copy
|
||
</button>
|
||
</div>
|
||
<p class="terminal-prompt">
|
||
<span class="prompt-symbol" aria-hidden="true">›</span
|
||
><span id="notion-prompt"
|
||
>Use REA to trace how Notion copies text and HTML to the
|
||
system clipboard. Show the code at each step.</span
|
||
><span class="terminal-cursor" aria-hidden="true"></span>
|
||
</p>
|
||
</div>
|
||
<p class="caption">
|
||
An example prompt with Notion's local application package
|
||
available to your coding agent.
|
||
</p>
|
||
|
||
<h3 class="small-heading">REA finds where to start reading</h3>
|
||
<p>
|
||
Analyzing the tab preload with REA locates the API exposed to the
|
||
page and the call that sends an IPC request. Both findings come
|
||
with source ranges in the minified bundle:
|
||
</p>
|
||
<figure class="workflow-figure">
|
||
<p class="figure-title">REA findings → two places to open</p>
|
||
<div class="rea-query-pair">
|
||
<div class="code-block">
|
||
<div class="code-header"><span>Exposed page API</span></div>
|
||
<pre><code>api_key: "__electronApi"
|
||
api_status: "dynamic"
|
||
source: preload.js:1:22764–22828</code></pre>
|
||
</div>
|
||
<div class="code-block">
|
||
<div class="code-header"><span>Renderer IPC call</span></div>
|
||
<pre><code>operation: "invoke"
|
||
channel_expression: "e"
|
||
source: preload.js:1:6486–6522</code></pre>
|
||
</div>
|
||
</div>
|
||
<figcaption>
|
||
Selected fields from a fresh
|
||
<code>analyze_javascript_application</code> result on Notion's
|
||
tab preload, recorded with REA 4.1.0. Positions use the original
|
||
bundle's line and zero-based column.
|
||
</figcaption>
|
||
</figure>
|
||
<p>
|
||
The agent opens those locations, finds the clipboard member in the
|
||
assembled API, and reads <code>invokerInMain</code>. Its call site
|
||
supplies
|
||
<code class="notion-channel">notion:clipboard:write</code>. That
|
||
name gives the agent something precise to look for in the main
|
||
bundle. The four excerpts below show the route it connects.
|
||
</p>
|
||
|
||
<h3 class="small-heading">Four short pieces of code</h3>
|
||
<p class="caption">
|
||
Simplified from the packaged JavaScript, with readable variable
|
||
names. Unrelated members are omitted.
|
||
</p>
|
||
<ol class="rea-queries">
|
||
<li>
|
||
<h4>Start at the API exposed to the page</h4>
|
||
<div class="code-block">
|
||
<div class="code-header">
|
||
<span>tab_browser_view/preload.js · API member</span
|
||
><button
|
||
class="copy-button"
|
||
type="button"
|
||
data-copy="notion-preload-source"
|
||
aria-label="Copy Notion preload excerpt"
|
||
>
|
||
Copy
|
||
</button>
|
||
</div>
|
||
<pre><code id="notion-preload-source">const clipboardApi = {
|
||
write: invokerInMain(<span class="notion-channel">"notion:clipboard:write"</span>)
|
||
};
|
||
|
||
// Included in the API exposed through contextBridge:
|
||
// window.__electronApi.clipboard</code></pre>
|
||
</div>
|
||
<p>
|
||
This member supplies the channel name. The implementation of
|
||
<code>invokerInMain</code> tells us how the request leaves the
|
||
page's process.
|
||
</p>
|
||
</li>
|
||
<li>
|
||
<h4>Resolve the preload's wrapper</h4>
|
||
<div class="code-block">
|
||
<div class="code-header">
|
||
<span>tab_browser_view/preload.js · IPC helper</span
|
||
><button
|
||
class="copy-button"
|
||
type="button"
|
||
data-copy="notion-invoke-source"
|
||
aria-label="Copy Notion invoke wrapper excerpt"
|
||
>
|
||
Copy
|
||
</button>
|
||
</div>
|
||
<pre><code id="notion-invoke-source">function invokerInMain(channel) {
|
||
return (...args) => invokeInMainAndReturnResult(channel, ...args);
|
||
}
|
||
|
||
function invokeInMainAndReturnResult(channel, ...args) {
|
||
return ipcRenderer.invoke(channel, ...args);
|
||
}</code></pre>
|
||
</div>
|
||
<p>
|
||
The returned function forwards the arguments through
|
||
Electron's request-and-response IPC. We can now look for
|
||
<code class="notion-channel">notion:clipboard:write</code>
|
||
on the main-process side.
|
||
</p>
|
||
</li>
|
||
<li>
|
||
<h4>Check how the receiver is registered</h4>
|
||
<div class="code-block">
|
||
<div class="code-header">
|
||
<span>main/index.js · handler helper</span
|
||
><button
|
||
class="copy-button"
|
||
type="button"
|
||
data-copy="notion-handler-source"
|
||
aria-label="Copy Notion handler wrapper excerpt"
|
||
>
|
||
Copy
|
||
</button>
|
||
</div>
|
||
<pre><code id="notion-handler-source">const handleRequestFromRenderer = {
|
||
addListener(channel, handler) {
|
||
ipcMain.handle(channel, handler);
|
||
}
|
||
};</code></pre>
|
||
</div>
|
||
<p>
|
||
The main process uses another wrapper. Its
|
||
<code>addListener</code> method registers an
|
||
<code>ipcMain.handle</code> receiver for that channel.
|
||
</p>
|
||
</li>
|
||
<li>
|
||
<h4>Find the write and its sender check</h4>
|
||
<div class="code-block">
|
||
<div class="code-header">
|
||
<span>main/index.js · clipboard receiver</span
|
||
><button
|
||
class="copy-button"
|
||
type="button"
|
||
data-copy="notion-write-source"
|
||
aria-label="Copy Notion clipboard receiver excerpt"
|
||
>
|
||
Copy
|
||
</button>
|
||
</div>
|
||
<pre><code id="notion-write-source">handleRequestFromRenderer.addListener(
|
||
<span class="notion-channel">"notion:clipboard:write"</span>,
|
||
(event, data) =>
|
||
isNotionWebContents(event.sender)
|
||
? clipboard.write(data)
|
||
: undefined
|
||
);</code></pre>
|
||
</div>
|
||
<p>
|
||
This is the destination. After checking the sender, the
|
||
handler passes the supplied data to Electron's clipboard API.
|
||
The channel and the two resolved wrappers connect the exposed
|
||
method to this call.
|
||
</p>
|
||
</li>
|
||
</ol>
|
||
</section>
|
||
|
||
<section class="article-section" id="rich-clipboard">
|
||
<h2>How does a copied block keep its structure?</h2>
|
||
<p>
|
||
Notion's web editor sends text and HTML through
|
||
<code>electronApi.clipboard.write</code>. It keeps the block data
|
||
locally and puts an ID in the copied HTML to connect them.
|
||
</p>
|
||
<figure class="workflow-figure">
|
||
<p class="figure-title">HTML links to saved block data</p>
|
||
<div class="notion-clipboard-grid">
|
||
<div class="code-block">
|
||
<div class="code-header">
|
||
<span>Sent to the system clipboard</span>
|
||
</div>
|
||
<pre><code>text: "Project notes"
|
||
html: "<p>Project notes</p>"
|
||
+ "<!-- notionvc: <span class="notion-channel"><copy-id></span> -->"</code></pre>
|
||
</div>
|
||
<div class="code-block">
|
||
<div class="code-header">
|
||
<span>Saved locally by Notion</span>
|
||
</div>
|
||
<pre><code>id: <span class="notion-channel"><copy-id></span>
|
||
mimeTypes:
|
||
text/_notion-blocks-v3-production
|
||
→ structured block data</code></pre>
|
||
</div>
|
||
</div>
|
||
<ol
|
||
class="notion-mini-flow"
|
||
aria-label="Restoring rich clipboard data on paste"
|
||
>
|
||
<li>Read the HTML ID</li>
|
||
<li>Find the same local ID</li>
|
||
<li>Restore Notion block data</li>
|
||
</ol>
|
||
<figcaption>
|
||
Illustrative text and ID. The recorded module test restores the
|
||
block data when IDs match; a stale entry returns only text and
|
||
HTML.
|
||
</figcaption>
|
||
</figure>
|
||
<p>
|
||
On paste, Notion looks for the HTML ID and checks it against the
|
||
saved copy. Matching IDs restore the block data.
|
||
</p>
|
||
<p class="caption">
|
||
Clipboard format recorded from web assets cached on July 13, 2026.
|
||
</p>
|
||
</section>
|
||
|
||
<section class="article-section" id="continue">
|
||
<h2>More examples and sources</h2>
|
||
<details class="evidence-details" id="markdown">
|
||
<summary>Another example: Markdown tables</summary>
|
||
<p>
|
||
Notion parses Markdown into block data. This example shows how a
|
||
table becomes header and data rows.
|
||
</p>
|
||
<figure class="workflow-figure">
|
||
<p class="figure-title">
|
||
A table through Notion's Markdown parser
|
||
</p>
|
||
<div class="notion-table-example">
|
||
<div class="code-block">
|
||
<div class="code-header"><span>Markdown input</span></div>
|
||
<pre><code>| A | B |
|
||
| - | - |
|
||
| 1 | 2 |</code></pre>
|
||
</div>
|
||
<div class="code-block">
|
||
<div class="code-header">
|
||
<span>Structured parser output · excerpt</span>
|
||
</div>
|
||
<pre><code>table · headerRow: true
|
||
table_row
|
||
cells: ["A"], ["B"]
|
||
table_row
|
||
cells: ["1"], ["2"]</code></pre>
|
||
</div>
|
||
</div>
|
||
<figcaption>
|
||
Recorded output from an extracted Markdown parser. The table
|
||
becomes rows and cells.
|
||
</figcaption>
|
||
</figure>
|
||
</details>
|
||
<details class="evidence-details">
|
||
<summary>Another path: the offline SQLite connection</summary>
|
||
<p>
|
||
Notion's renderer requests <code>getSqliteMeta</code> through
|
||
IPC. The main process creates a message channel and gives one
|
||
port to the renderer and the other to a SQLite utility process.
|
||
Subsequent statement batches and results travel over that port.
|
||
</p>
|
||
<p>
|
||
Following this handoff explains where the database work runs,
|
||
and why tracing only the initial IPC request misses the later
|
||
conversation.
|
||
</p>
|
||
</details>
|
||
<details class="evidence-details">
|
||
<summary>Sources and how to read the excerpts</summary>
|
||
<p>
|
||
The clipboard bridge comes from Notion Desktop 7.6.1's
|
||
<code>app.asar</code>: the tab preload and
|
||
<code>main/index.js</code>. The excerpts expand minified
|
||
variable names and omit unrelated code; the sender-check helper
|
||
is shown with its underlying
|
||
<code>isNotionWebContents</code> call.
|
||
</p>
|
||
<p>
|
||
The virtual clipboard and Markdown examples come from web assets
|
||
cached on July 13, 2026, including modules <code>747001</code>,
|
||
<code>58169</code>, <code>736810</code> and <code>422457</code>.
|
||
Those assets have their own version. Saved probes executed
|
||
extracted modules and small harnesses; their outputs describe
|
||
those probes rather than a captured desktop UI session.
|
||
</p>
|
||
<p>
|
||
The REA result shown here is a focused analysis of the saved tab
|
||
preload, recorded with the published REA 4.1.0 package. It
|
||
locates the API and invoke operation. The clipboard member and
|
||
matching receiver are connected by reading their wrapper
|
||
implementations in the package.
|
||
</p>
|
||
<p>
|
||
The Markdown example uses parser module <code>422457</code>.
|
||
Saved module tests show that both page and chat filters preserve
|
||
this table. The paste/import, structured Markdown and AI/chat
|
||
parsers have separate entry points and intermediate formats.
|
||
</p>
|
||
</details>
|
||
<ul class="reading-list">
|
||
<li>
|
||
<a href="../../guides/javascript/"
|
||
>JavaScript application guide</a
|
||
><span
|
||
>Follow a small Electron application's export feature.</span
|
||
>
|
||
</li>
|
||
<li>
|
||
<a href="../dx-ball/">DX-Ball reconstruction</a
|
||
><span
|
||
>Follow native instructions to a checked C function.</span
|
||
>
|
||
</li>
|
||
</ul>
|
||
<div class="actions">
|
||
<a class="button" href="../../get-started/"
|
||
>Analyze your own app</a
|
||
>
|
||
</div>
|
||
</section>
|
||
</article>
|
||
</div>
|
||
</main>
|
||
<footer class="site-footer">
|
||
<div class="container footer-inner">
|
||
<p>REA · Reverse Engineer Anything</p>
|
||
<div class="footer-links">
|
||
<a href="https://github.com/morluto/rea">Source</a
|
||
><a href="https://github.com/morluto/rea/blob/main/LICENSE"
|
||
>MIT license</a
|
||
><a href="https://discord.gg/GkcryMnJDM">Community</a>
|
||
</div>
|
||
</div>
|
||
</footer>
|
||
<p class="sr-only" id="copy-status" role="status" aria-live="polite"></p>
|
||
<a class="back-to-top" href="#top" aria-label="Back to top">
|
||
<span aria-hidden="true">↑</span> Top
|
||
</a>
|
||
</body>
|
||
</html>
|