@botiverse/porthole 0.15.2 → 0.16.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (109) hide show
  1. package/CHANGELOG.md +89 -0
  2. package/dist/bridge/bridge.d.ts +1 -8
  3. package/dist/bridge/bridge.js +0 -7
  4. package/dist/check/page-source.js +1 -1
  5. package/dist/check/page.js +1 -1
  6. package/dist/compile/policy.d.ts +0 -7
  7. package/dist/compile/policy.js +1 -10
  8. package/dist/config/capabilities.d.ts +8 -14
  9. package/dist/config/capabilities.js +4 -5
  10. package/dist/config/schema.d.ts +2 -13
  11. package/dist/config/validate.js +0 -24
  12. package/dist/conformance/behavior.js +26 -37
  13. package/dist/conformance/clipboard.js +47 -1
  14. package/dist/conformance/harness-source.js +1 -1
  15. package/dist/displays/displays.js +1 -3
  16. package/dist/guide/limits.js +1 -1
  17. package/dist/guide/runtime.js +1 -1
  18. package/dist/host/create-host.d.ts +1 -1
  19. package/dist/host/create-host.js +6 -51
  20. package/dist/host/door.d.ts +1 -1
  21. package/dist/host/locate.d.ts +1 -1
  22. package/dist/host/locate.js +2 -2
  23. package/dist/host/outcome.d.ts +5 -12
  24. package/dist/host/outcome.js +8 -16
  25. package/dist/host/types.d.ts +6 -22
  26. package/dist/index.d.ts +2 -4
  27. package/dist/index.js +2 -4
  28. package/dist/isolation/served.d.ts +9 -14
  29. package/dist/isolation/served.js +17 -31
  30. package/dist/isolation/types.d.ts +2 -19
  31. package/dist/isolation/types.js +0 -17
  32. package/dist/platform/focus-field.d.ts +11 -0
  33. package/dist/platform/focus-field.js +18 -0
  34. package/dist/platform/types.d.ts +6 -22
  35. package/dist/platform/web.js +8 -98
  36. package/dist/presets/presets.d.ts +0 -2
  37. package/dist/presets/presets.js +0 -1
  38. package/dist/react/frame.d.ts +0 -8
  39. package/dist/react/frame.js +0 -4
  40. package/dist/runtime/contract.d.ts +2 -2
  41. package/dist/runtime/contract.js +2 -2
  42. package/dist/runtime/types.generated.js +6 -6
  43. package/dist/server/files.js +7 -23
  44. package/dist/server/host.d.ts +1 -1
  45. package/dist/server/index.d.ts +1 -1
  46. package/dist/server/index.js +4 -6
  47. package/dist/server/naming.js +1 -1
  48. package/dist/server/pages.d.ts +9 -2
  49. package/dist/server/pages.js +28 -8
  50. package/dist/server/server.js +28 -166
  51. package/dist/server/types.d.ts +7 -7
  52. package/dist/shell/plan.js +2 -2
  53. package/dist/shell/runtime.js +1 -9
  54. package/docs/ADOPTING.md +42 -135
  55. package/docs/ARCHITECTURE.md +0 -33
  56. package/docs/DECISIONS.md +296 -9
  57. package/docs/DESIGN.md +27 -50
  58. package/docs/THREAT_MODEL.md +140 -242
  59. package/package.json +1 -1
  60. package/src/bridge/bridge.ts +1 -17
  61. package/src/check/page.ts +1 -1
  62. package/src/compile/policy.ts +1 -11
  63. package/src/config/capabilities.ts +8 -14
  64. package/src/config/schema.ts +2 -13
  65. package/src/config/validate.ts +0 -28
  66. package/src/conformance/behavior.ts +50 -52
  67. package/src/conformance/clipboard.ts +56 -1
  68. package/src/displays/displays.ts +1 -3
  69. package/src/guide/limits.ts +1 -1
  70. package/src/guide/runtime.ts +1 -1
  71. package/src/host/create-host.ts +6 -52
  72. package/src/host/door.ts +1 -1
  73. package/src/host/locate.ts +2 -2
  74. package/src/host/outcome.ts +8 -21
  75. package/src/host/types.ts +6 -20
  76. package/src/index.ts +2 -4
  77. package/src/isolation/served.ts +18 -37
  78. package/src/isolation/types.ts +2 -24
  79. package/src/platform/focus-field.ts +18 -0
  80. package/src/platform/types.ts +6 -21
  81. package/src/platform/web.ts +8 -116
  82. package/src/presets/presets.ts +0 -3
  83. package/src/react/frame.tsx +0 -10
  84. package/src/runtime/contract.ts +4 -4
  85. package/src/runtime/types.generated.ts +6 -6
  86. package/src/server/files.ts +4 -19
  87. package/src/server/host.ts +1 -1
  88. package/src/server/index.ts +4 -16
  89. package/src/server/naming.ts +1 -1
  90. package/src/server/pages.ts +38 -12
  91. package/src/server/server.ts +29 -189
  92. package/src/server/types.ts +7 -7
  93. package/src/shell/plan.ts +2 -2
  94. package/src/shell/runtime.ts +1 -9
  95. package/types/runtime/v1/artifact.d.ts +2 -3
  96. package/types/runtime/v1/assets.d.ts +1 -1
  97. package/types/runtime/v1/chat.d.ts +2 -2
  98. package/types/runtime/v1/comments.d.ts +1 -1
  99. package/types/runtime/v1/downloads.d.ts +2 -2
  100. package/types/runtime/v1/links.d.ts +2 -2
  101. package/dist/platform/focus-guard.d.ts +0 -252
  102. package/dist/platform/focus-guard.js +0 -764
  103. package/dist/server/nested.d.ts +0 -66
  104. package/dist/server/nested.js +0 -120
  105. package/dist/shell/frame.d.ts +0 -28
  106. package/dist/shell/frame.js +0 -338
  107. package/src/platform/focus-guard.ts +0 -999
  108. package/src/server/nested.ts +0 -156
  109. package/src/shell/frame.ts +0 -371
@@ -5,7 +5,7 @@ What Porthole protects, from whom, and where that protection ends. For each way
5
5
  guaranteed. [ADOPTING.md](ADOPTING.md) says how to set each one up, and
6
6
  [DESIGN.md](DESIGN.md) lists every defense with the test that proves it.
7
7
 
8
- **Status.** This describes Porthole 0.15.2 (2026-11-11). A review on 2026-10-19 found gaps, and every decision it led to
8
+ **Status.** This describes Porthole 0.16.0 (2026-11-11). A review on 2026-10-19 found gaps, and every decision it led to
9
9
  has merged ([§8](#8-fixes-in-flight) lists them). P096 changed the negative-control runner and CI,
10
10
  and the shipped conformance probes' messages and timing, not what they check. P104 (0.9.0's
11
11
  annotation markers) had a review of its own, and P105, in 0.10.0, is what it led to. 0.11.0 was
@@ -74,6 +74,31 @@ placed down the document and moved by a scroll-driven animation in the layer's c
74
74
  so they no longer trail the text for the frames before the scroll event is heard. No message and
75
75
  no reading is added (the scroll offset was read already, P132), and the layer still adds nothing to
76
76
  what a page can scroll. No wall moves.
77
+ 0.15.3: P148, a nested page's real presses: the page's runtime tells its shell each press the
78
+ browser itself made (a mouse down, a finger up, Enter or Space on a native control, a click on
79
+ one), over a `MessagePort` the shell sends at each load and the runtime takes before any content
80
+ runs; the shell tells the host when it heard the last, and the host takes it as it takes the
81
+ shell's activation turning on (§7 "The keyboard"). It gives back what P111 accepted as a loss: a
82
+ press in the page within 5 s of the last gesture. It rests on the runtime's lock on
83
+ `document.open` and on a nested page's frames being opaque, and is not installed where either
84
+ fails. The nested shell's script and the served shell runtime change (their pins, P144 and P145).
85
+ Also in 0.15.3, after the audit of 0.15.1: the four helpers a content Worker of a host's own calls
86
+ with host origins (`statusPage`, `doorResponse`, `doorStatusResponse`, `nestedShellCsp`) check
87
+ each one and throw on a bad one, as P145 said they did; the origins are the host's own
88
+ configuration, never content's.
89
+ 0.16.0: P149 takes out what guessed at the person's intent, and what was built to make the
90
+ guess better. Gone: nested pages (`nested: true`, P111 and all that followed it: the shell on a
91
+ label of its own, its word on the person's press, P114, P120 to P122, P136, P148); the focus
92
+ guard (P109: a display that takes the keyboard keeps it until the person clicks back, the
93
+ accepted risk of §5, now without a guard in front of it); the proof of a click asked of
94
+ `sendPrompt`, `openLink`, `downloadFile`, `comments.open`, `artifact.publish`, `assets.delete`
95
+ and a marker's `activated` (P105's second point). Kept: `copyText`'s click (the clipboard is the
96
+ person's, and nothing else stands between a page and it), every confirmation, every rate (the
97
+ three that had none get 30 a minute), the mute, and every isolation wall: no origin, sandbox,
98
+ CSP or message check changes. What a page gains is the power to ask at a moment it picks: a
99
+ confirmation the person didn't prompt, a composer or a comment view opening unasked. Each is a
100
+ nuisance a host bounds (it may refuse, back off, or name the `user-activation` gate again), and
101
+ none carries anything out or writes anything by itself (§5, §7).
77
102
 
78
103
  ## 1. Two layers
79
104
 
@@ -137,8 +162,8 @@ the agent, but it is not a wall.
137
162
  them;
138
163
  - the host's fallback for a frame that showed nothing ("open this in a new tab to sign in",
139
164
  "you no longer have access", with a link) is drawn from Porthole's pages' word only, never
140
- from what the content says (P124, P125; a url-mode app aside, S6). For a served display that
141
- isn't nested — where a same-scope sibling could otherwise speak for it ([§7](#the-display-layer)) —
165
+ from what the content says (P124, P125; a url-mode app aside, S6). For a served display —
166
+ where a same-scope sibling could otherwise speak for it ([§7](#the-display-layer)) —
142
167
  that word comes from a **door**: a page of Porthole's on the display's origin, in a hidden
143
168
  opaque frame of the host's that no content can reach, taken before the content is framed. The
144
169
  content frame's own word is then never taken, and its silence is a timeout, never a fallback.
@@ -182,14 +207,22 @@ Porthole does not protect against these.
182
207
  - **Deceptive content.** Content may draw anything in its frame, a fake sign-in form included.
183
208
  Porthole limits where what is typed into it can go and keeps the host's approvals outside the
184
209
  frame; it doesn't judge what content shows.
185
- - **A display taking the keyboard** (accepted risk, P123). Content can move focus into its frame
186
- (`focus()` and the like) while the person types in the host's page, and receive the keys typed
187
- after it. Porthole's guard takes the keyboard back and stops a display that keeps taking it, but
188
- only as best effort (§7 "The keyboard"): on a nested page it doesn't cover typing slower than one
189
- key per 250 ms, which is most people, phones included. Browsers give a host no way to prevent it,
190
- and the person sees their text stop appearing. The walls that hold regardless: content can't read
191
- the host's page, its storage or another display, and a nested page's sealed address stays in a
192
- shell no content shares.
210
+ - **A display taking the keyboard** (accepted risk, P123, P149). Content can move focus into its
211
+ frame (`focus()` and the like) while the person types in the host's page, and receive the keys
212
+ typed after it, until the person sees their text stop appearing and clicks back. Browsers give a
213
+ host no way to prevent it, nor to tell such a move from the person's own click into the frame
214
+ (the host's page sees no press inside a cross-site frame). From 0.13 to 0.15 a guard took such
215
+ moves back on its best guess; the guess refused people's own clicks, and 0.16.0 removed it
216
+ (§7 "The keyboard"). The walls that hold regardless: content can't read the host's page, its
217
+ storage or another display, and can't move focus into a field of the host's.
218
+ - **A page asking at a moment it picks** (accepted risk, P149). No proof of a click is asked of a
219
+ host function but `copyText`: a page can call `sendPrompt`, `openLink`, `downloadFile`,
220
+ `comments.open`, `artifact.publish` or `assets.delete` as it loads or on a timer. Each still
221
+ ends at the person (a confirmation with the whole effect, or a composer that posts nothing by
222
+ itself), within a rate, and declines mute the display; so the cost is an interruption, which
223
+ the host may refuse or space out. The click check it replaces proved little (any click on the
224
+ host's page in the last 5 s passed it) and refused real clicks where the engine didn't pass the
225
+ activation up.
193
226
  - **Wrong results.** A chart can plot the wrong numbers, and a report can say false things.
194
227
  - **Malicious prompts.** A gated `sendPrompt` hands the host's confirm function the whole text (the
195
228
  default dialog shows all of it); whether that text is hostile is not Porthole's call. Nor is text
@@ -228,7 +261,7 @@ Whatever the use:
228
261
  - Draw a frame's fallback (what `frameFallback` words, or your own) from its `outcome` alone, never
229
262
  from a message of your own reading off the frame's window: a `blocked` outcome is the word of a
230
263
  page of Porthole's server, a gateway or your own pages, never of an opaque frame or of content in
231
- a frame that speaks (P124, P125). For a served display that isn't nested, that word is its
264
+ a frame that speaks (P124, P125). For a served display, that word is its
232
265
  **door**'s (a page of Porthole's on the display's origin, framed hidden and opaque before the
233
266
  content, which a same-scope sibling can't reach, P125); its content frame's own word is never
234
267
  taken, and its silence is a `timeout`. A `blocked` before any frame (`sign-in`, `denied`,
@@ -277,25 +310,19 @@ Whatever the use:
277
310
  shortcuts that write (an `r` that resolves, Cmd+Enter that posts) need it too (P137). That's the
278
311
  host's duty: Porthole doesn't guarantee it.
279
312
  - Know that a display can take the keyboard: a page calls `focus()` on its own input whenever it
280
- likes (on Chromium and WebKit with no gesture), and what the person goes on typing goes to it.
281
- `createHost` (every `PortholeView` too) gives focus back when it leaves one of the page's text
282
- fields for a frame without the person's press on the frame or a Tab, tells the display
283
- (`focusTaken`), and stops a display that keeps doing it (§7 "The keyboard", P109). Move focus
284
- into a display yourself with `display.focus()`, never the frame's own `focus()`; move it into
285
- your composer with `focusField(field)`, not the field's own `focus()` (Firefox ignores that while
286
- a fighting frame holds focus); and with a platform of your own, implement its focus guard
287
- (`focused`, `onFocusTaken`, `focus`) or accept that a display can read what is typed beside it.
313
+ likes (on Chromium and WebKit with no gesture), and what the person goes on typing goes to it
314
+ until they click back. Nothing gives it back for them (§5, §7 "The keyboard"). Where a field
315
+ must never lose a key to a page, show no untrusted display beside it. Move focus into a display
316
+ yourself with `display.focus()`, and into your composer with `focusField(field)`, not the
317
+ field's own `focus()` (Firefox ignores that while a frame that takes focus back on its blur
318
+ holds it).
288
319
  - Call `annotations.focusMark(id)` only as the person's key closes your view of that mark, and know
289
320
  it can be dropped (P135, P137): one that has to wait while the frame finds its marks, or that the
290
321
  frame takes more than 100 ms after you sent it because its page is busy, lands only if the focus
291
322
  is in the frame by then, and in the normal flow it is on your `<body>`. Nothing says so. If
292
323
  the focus is still on your body a moment later, the person hasn't moved on: `display.focus()`,
293
- then `focusMark(id)` again. Look first: that move is yours, the focus guard doesn't judge it, and
294
- a move after the person went on to a button of yours takes the keyboard from them. On a nested
295
- page, use `display.focus()`: it tells the page's shell to pass the focus on (P136), and the frame's
296
- own `focus()` stops at the shell, so a word that waits is dropped even after it. On Firefox,
297
- `display.focus()` inside a key's own handler moves nothing: call it from a task (measured on a
298
- nested page). Nothing leaks either way: the keyboard stays out of the page.
324
+ then `focusMark(id)` again. Look first: that move is yours, and a move after the person went on
325
+ to a button of yours takes the keyboard from them. Nothing leaks either way.
299
326
  - List every app origin in `appOrigins` (`hostOrigins` in `/server`): only those may frame content,
300
327
  only those are a frame's host (heard and told), and only those are checked against the content
301
328
  domain for a shared site.
@@ -303,7 +330,7 @@ Whatever the use:
303
330
  may then be an ancestor of your frames, above your own page, and is never their host. Your page
304
331
  must still be the frame's parent: an outer page that frames content directly (with an address it
305
332
  got from somewhere) is let in by the browser, but the frame takes nothing from it (no handshake,
306
- no host function), Porthole's own pages and a nested page's shell tell it nothing, and what it
333
+ no host function), Porthole's own pages tell it nothing, and what it
307
334
  can hear is the content's own word to its parent (`*`), which it must treat as untrusted. Your
308
335
  app page's own `frame-ancestors` is yours to set; Porthole never sends it. Name exact origins of
309
336
  that one product, and drop them when it stops framing you.
@@ -339,9 +366,9 @@ Whatever the use:
339
366
 
340
367
  | Host function | Default gates |
341
368
  | --- | --- |
342
- | `sendPrompt` | a user gesture, then the host's confirmation, given the whole text |
343
- | `openLink` | a gesture and a confirmation; http(s) only, no credentials in the URL |
344
- | `downloadFile` | a gesture and a confirmation |
369
+ | `sendPrompt` | the host's confirmation, given the whole text; 30 a minute |
370
+ | `openLink` | a confirmation; http(s) only, no credentials in the URL; 30 a minute |
371
+ | `downloadFile` | a confirmation; 30 a minute |
345
372
  | `copyText` | a gesture, 30 a minute; the host writes the clipboard |
346
373
  | `callTool` | a confirmation, 30 a minute |
347
374
  | `setModelContext` | 30 a minute, then the host's `show`: the person sees the whole update first |
@@ -391,9 +418,11 @@ Whatever the use:
391
418
  in it for what it is, and characters that draw as a blank (a no-break space, the wide spaces)
392
419
  pass, a few bits each, bounded by the length limit (P100, accepted). A host that opts out of
393
420
  `show` (`withoutShow: true`) lets content write into the model's turns text nobody saw (S5).
394
- - The host's gesture check reads its own page's `navigator.userActivation` (in an engine without
395
- it, the check passes). A gesture shows a moment of intent, not consent: the person may have
396
- clicked the host a moment before.
421
+ - The host's gesture check (`copyText`'s, and any a host names) reads its own page's
422
+ `navigator.userActivation` (in an engine without it, the check passes). A gesture shows a
423
+ moment of intent, not consent: the person may have clicked the host a moment before.
424
+ - No proof of a click is asked of `sendPrompt`, `openLink` or `downloadFile` (P149): a widget can
425
+ ask for one as it loads. The confirmation is the wall, the rate and the mute its bounds (§5).
397
426
  - Availability ([§5](#5-out-of-scope)).
398
427
 
399
428
  ### S2. Live widgets: content that reads the host's data
@@ -477,48 +506,9 @@ encrypted into the path, since WebKit keeps no cookie in a frame (P083).
477
506
  with `srcdoc` loads and runs (a page of the set with its own shell), and every other frame
478
507
  (another site, another path of the origin, a scheme, an empty one) and plugin is removed: the
479
508
  page's `frame-src` opens its version's path alone, which also governs every navigation of its
480
- frames. Not for a nested page (refused).
509
+ frames.
481
510
  - With a per-request check (`authorize`), the host decides again on every request; a deny is a
482
511
  403 that says `denied`.
483
- - A nested page (`nested: true`, P111): the framed address answers Porthole's shell alone, its
484
- script the only one its CSP runs, framing and fetching only the origin's sealed files' prefix.
485
- **The shell's origin hosts nothing but the shell, its opaque page, the sealed files and status
486
- pages** (P114, porthole#56): the shell, the page and its files are served on a label of the
487
- scope's own, `porthole-<24 base32>` (`nestedLabelOf`), never on the scope's label, where its
488
- other displays (inline and live widgets, MCP apps, artifacts that aren't nested) run agent-made
489
- content with `allow-same-origin`. `/server` holds it: that label answers no clean address,
490
- entry, asset, library, app or other display, and takes no other instance's ticket, cookie or
491
- sealed address; the scope's label answers no nested page (its clean address goes on to the
492
- shell's label with a one-time ticket); no host's naming makes a `porthole-` label. So no
493
- content, of any scope, can read the shell's realm (its word to the host, the page's sealed
494
- address) or drive it (`leak/served/nested-siblings.spec.ts`, negative control `shell-label`).
495
- Porthole holds the shell to that label outside `/server` too (P121), for a content Worker of a
496
- host's own: the host's mount refuses a nested page located on any other label before a frame
497
- is made (a host error, `locate`; negative control `nested-host-label`), the shell frames
498
- nothing and says nothing on any other origin, and `nestedShellResponse` and `frameShellScript`
499
- refuse one. What else such a Worker serves on that label is its own (below).
500
- The page is the shell's child, `sandbox="allow-scripts"` (never `allow-same-origin`, held by a
501
- static check over every sandbox Porthole writes) and the same sandbox in its own CSP, so it is an
502
- opaque origin in its frame and on a tab; it is loaded, and loads its files, at its sealed address
503
- without a cookie, and its files then carry `Cross-Origin-Resource-Policy: cross-origin` and
504
- `Access-Control-Allow-Origin: *` (an opaque page's own loads are cross-origin: the address is
505
- the access, never the request's origin). So whoever holds a page's sealed address can read its
506
- files from any origin, a page of their own included, until the address ends (an hour on its own,
507
- P083): it is a bearer credential, as safe as it is unleaked. Porthole keeps it out of what it
508
- says: no referrer goes with any load (`Referrer-Policy: no-referrer`, the shell's frame
509
- `referrerpolicy="no-referrer"`), the host's reports name it as `./` (P083), and the shell's own
510
- answer is `no-store`. The page itself can read it (its address) and so pass it on by any channel
511
- it has, as it can pass on its files' bytes. The page has none of the origin's storage, and nothing
512
- of the shell's realm: messages between them go by `postMessage`, the page's trusted by
513
- `event.source`, and the shell drops what the page says in the shell's own namespace. Only the
514
- shell (same-origin) renews the page's address; a module the page loaded keeps one that ends
515
- within the hour. Every answer below the sealed prefix carries a CSP sandbox, never
516
- `allow-same-origin` (a page's `allow-scripts`, every other file's runs nothing): a file opened on
517
- a tab of its own (an SVG or XML file with a script) is opaque, never the shell's origin (negative
518
- control `file-sandbox`). The sandbox refuses no worker (measured on the four engines): a nested
519
- page's workers come from Blob URLs (a worker from its set's own script is refused by its opaque
520
- origin, sandbox or not), and those load the set's scripts. Assets and Porthole's libraries aren't
521
- served to a nested page yet.
522
512
 
523
513
  **The host must**
524
514
 
@@ -532,11 +522,6 @@ encrypted into the path, since WebKit keeps no cookie in a frame (P083).
532
522
  uncached (the default; `authorizeTtlSeconds` in the host kit) or call `content.forget(…)` when
533
523
  revoking, or a cached answer holds for up to that long.
534
524
  - Send the page's `frame-src`.
535
- - With nested pages, route the shell's label (`porthole-<…>.<domain>`) to the content server as
536
- every content label is (a wildcard needs nothing; a pattern of the host's own, `a-*`, must add
537
- it). A content Worker of the host's own serves nested pages on that label alone, and nothing
538
- else there (P114): Porthole refuses the shell anywhere else (P121), but can't see what else a
539
- Worker of the host's own answers on it. Its page's and files' CSPs come from `nestedFileCsp`.
540
525
 
541
526
  **Not guaranteed**
542
527
 
@@ -584,7 +569,7 @@ the attacker (c), and its readers are strangers.
584
569
  - `authorize` is the host's takedown switch.
585
570
  - An embedded document (P143, `Grant.embed`, only where the host set `embeds`): its answers say
586
571
  `frame-ancestors *` for that session alone, never a reader's; it is anonymous, with no level or
587
- user, an artifact's page that isn't nested; its plan names no host, so it hears no one, Porthole
572
+ user, an artifact's page; its plan names no host, so it hears no one, Porthole
588
573
  tells no parent anything, no capability or runtime host function runs, and no door is minted. The
589
574
  flag is signed into the session and the sealed address. Every other session's answers are, byte
590
575
  for byte, what the same server without `embeds` answers, while an embed session of the same
@@ -672,8 +657,8 @@ the attacker (c), and its readers are strangers.
672
657
  are ignored. Served, the proxy's CSP comes from what the session carries, signed, never from a
673
658
  message.
674
659
  - The default gates are stricter than the spec's "MAY": `callTool` needs a confirmation and has a
675
- rate (30 a minute), `sendPrompt` and `openLink` a gesture and a confirmation. For a view, the
676
- gesture check is the host's (the shell doesn't speak for an MCP view).
660
+ rate (30 a minute), `sendPrompt` and `openLink` a confirmation and the same rate. For a view,
661
+ a gesture check a host names is the host's alone (the shell doesn't speak for an MCP view).
677
662
 
678
663
  **The host must**
679
664
 
@@ -784,7 +769,7 @@ can be handed to the display with the widest network.
784
769
 
785
770
  **What sharing a scope costs, which Porthole does not stop** (the premise is a scope its author
786
771
  controls — one person's artifact and its versions, one session's widgets — not a scope shared across
787
- people who distrust each other). A scope's displays that aren't nested share one origin and run
772
+ people who distrust each other). A scope's displays share one origin and run
788
773
  content there with `allow-same-origin`, so one reaches another's document (`top[i]`) and its storage.
789
774
  P125 stops a sibling speaking Porthole's word for another display (its door says how loading went,
790
775
  unreachably), but a sibling of the scope can still, against another display of it:
@@ -799,8 +784,8 @@ unreachably), but a sibling of the scope can still, against another display of i
799
784
  - read a sandbox-proxy view's HTML once the host has sent it into the view.
800
785
 
801
786
  These are the costs of putting displays an author controls in one scope. To deny them, put displays
802
- that distrust each other in **different scopes** (different origins), or nest them (`nested: true`),
803
- whose shell and page a sibling can't reach (P114). What a sibling cannot do is forge Porthole's own
787
+ that distrust each other in **different scopes** (different origins): there is no other way since
788
+ 0.16.0 removed nested pages (P149). What a sibling cannot do is forge Porthole's own
804
789
  fallback (a sign-in prompt with a link out): that is the door's wall (P125).
805
790
 
806
791
  ## 7. The display layer and the app runtime
@@ -827,7 +812,7 @@ tab to sign in", "You can't open this anymore") with a link out of the page: UI
827
812
  for the host's and Porthole's, which content must not be able to summon. A `blocked` comes from a
828
813
  frame status (`porthole/notifications/frame-status`), and nothing in that message says who sent
829
814
  it: Porthole's status pages are documents of the frame's own window and origin, as content is. So
830
- the host takes one only where content can't have said it. **A served display that isn't nested** (a
815
+ the host takes one only where content can't have said it. **A served display** (a
831
816
  served shell, a page, a view through the sandbox proxy) is framed on its scope's origin, where the
832
817
  scope's others run content with `allow-same-origin`: one of them reaches a new document there before
833
818
  its first script runs and could speak for it, so **no frame status from its own frame is ever
@@ -835,11 +820,9 @@ taken** (each run, the first is dropped with one `frame-status` host error), and
835
820
  `timeout`, never a fallback. Its word comes from its **door** instead (P125): a page of Porthole's
836
821
  on the same origin, in a hidden opaque frame of the host's own (`sandbox="allow-scripts"`, no name,
837
822
  `inert`, 0×0) that no content shares an origin with and no sandboxed sibling can navigate, taken
838
- before the content frame is made — `open`, or `blocked` and why. A **nested page's shell** (on a
839
- label of its own, P114) keeps the ordering rule (its runtime's word opens every document that holds
840
- content). An **opaque frame**'s every status is the content's; a **url-mode app**'s is taken (S6).
823
+ before the content frame is made — `open`, or `blocked` and why. An **opaque frame**'s every status is the content's; a **url-mode app**'s is taken (S6).
841
824
 
842
- This closes the audit of 2026-10-30 (P124-1): before P125, a served display that isn't nested could
825
+ This closes the audit of 2026-10-30 (P124-1): before P125, a served display could
843
826
  be spoken for by a same-scope sibling — the sibling reached a new document of its scope (`top[i]`,
844
827
  same origin before the shell ran), posted a frame status taken as the run's first word, or stopped
845
828
  or rewrote it so its silence read as `framing`, or reloaded a running one into a new run it spoke
@@ -849,7 +832,7 @@ P124-2 is closed too: a file set's entry must be a page (`.html`/`.htm`; `checkF
849
832
  `admitFiles`, `lintFiles` refuse another), and a set stored before that rule answers Porthole's
850
833
  `not-found` status page — the door says `not-found`, never an inert file that says nothing.
851
834
 
852
- The known costs that remain are the costs of sharing a scope (S7). A served non-nested location
835
+ The known costs that remain are the costs of sharing a scope (S7). A served location
853
836
  without a door (a server older than the host, a locator that drops it, a clean address framed as it
854
837
  is) is refused before any frame: `blocked: locate` and a `door` host error (P125). A clean address
855
838
  is for a tab: in a frame the content origin answers it with a page that has no script and goes
@@ -859,15 +842,14 @@ found) is the display's outcome with no frame built. P125 also records why no ti
859
842
  in for that: a `load` event is not a committed document (DECISIONS P125).
860
843
 
861
844
  **Annotations** (`annotate`, P053, P104, P107). The shell that draws marks and reports anchors shares
862
- its realm with the content (a nested page's too: its marks are drawn by the runtime in the page's
863
- own frame, below the shell, P111), so:
845
+ its realm with the content, so:
864
846
 
865
847
  - *What content learns.* Everything the host sends in a `show` is posted into the frame's window,
866
848
  where the content can listen: each mark's id, anchor and, where given, `count` (the number on
867
849
  its marker). A host gives ids that say nothing (never a person's name or a comment's words), and
868
850
  a count only where the page may know how many there are. Who commented and what they wrote stay
869
- in the host's own UI, outside the frame, and so does what the person types there, within the
870
- keyboard's limits below (P109).
851
+ in the host's own UI, outside the frame, and so does what the person types there, unless a
852
+ page takes the keyboard meanwhile ("The keyboard" below).
871
853
  - *Drafts* (P107). A mark with `kind: "draft"` (a comment its author hasn't posted) is drawn apart,
872
854
  a dashed line and a hollow marker with no number, so the page also learns which of its marks are
873
855
  drafts: that the person viewing it is writing a comment there, before they post it. That is new
@@ -895,15 +877,12 @@ own frame, below the shell, P111), so:
895
877
  P107), without a click on it and with any box. It can draw look-alike markers, or lay its own elements over Porthole's.
896
878
  The host takes each report only for what it asked for and its own shown ids, rebuilt within
897
879
  `ANNOTATION_LIMITS`, at 120 a minute; `activated` for a mark without a marker, or an id it
898
- doesn't show, is dropped (negative control `annotation-activated`). `activated` is also taken
899
- only while the host's page has transient user activation, which a real marker click or tap gives
900
- it (P105, measured on all three engines; control `annotation-activated-gesture`). That stops a
901
- page opening the host's view with no gesture at all, nothing more: activation lasts 5 s after any
902
- gesture anywhere on the page (a click on the host's own UI, typing in the content, the click that
903
- opened the display), and a fake posted then, on a timer or a scroll, is taken; one posted on the
904
- person's own press in the content lands under their pointer. The guard on the host's view (§6) is
905
- the defence, not this. Where the platform can't tell (a custom one whose `userActivation()`
906
- answers undefined), the report passes, as the gesture gate does.
880
+ doesn't show, is dropped (negative control `annotation-activated`). No proof of a gesture is
881
+ asked of it (0.16.0, P149; from 0.10 to 0.15, P105 took one only while the host's page had
882
+ transient user activation, which lasts 5 s after any gesture anywhere on the page, so a fake
883
+ posted on a timer or a scroll passed anyway): a page can open the host's view for one of its
884
+ shown marks at any moment, and one posted on the person's own press in the content lands under
885
+ their pointer. The guard on the host's view (§6) is the defence.
907
886
  - *Labels.* An anchor's `label` is the page's text: the words selected, or an element's own words,
908
887
  else its `alt`, `aria-label` or `title`, which the person never sees on the page. The host takes
909
888
  out of every label everything a person can't see (every format character, bidi controls and
@@ -978,7 +957,7 @@ own frame, below the shell, P111), so:
978
957
  its own tab stop, and tell that the person is on one (`document.activeElement` is the layer, its
979
958
  own element's `focusout` names it). None of that gives it what it lacks: a marker's press has no
980
959
  power but `activated`, which it can fake anyway within the host's checks, keys go to a marker only
981
- while the frame has the focus, so nothing typed in the host passes through it (P109 is unchanged),
960
+ while the frame has the focus, so nothing typed in the host passes through it,
982
961
  and a page's made-up key or `click()` is no trusted click. Assistive technology now reads the
983
962
  marker's name, the page's own words after the shell's, in quotes that bound nothing (P134: a
984
963
  text anchor's `label`, an element's quote, or what follows the tag in its `label`). A host can't
@@ -988,8 +967,8 @@ own frame, below the shell, P111), so:
988
967
  the page's word. A host reads its own page instead, as the report arrives: is the frame element
989
968
  `document.activeElement`? The page can't fake that reading, and that is all it gets. It tells that
990
969
  the focus is in the frame, not that a key was pressed: a pointer's click after the person was
991
- in the frame reads the same, and the page can move the focus into its frame itself, from anywhere
992
- but one of the host's text fields (the guard lets that be, P109). **The page can still forge
970
+ in the frame reads the same, and the page can move the focus into its frame itself, from
971
+ anywhere (nothing takes such a move back, P149). **The page can still forge
993
972
  `activated` while the person really is in the frame, and this signal doesn't stop that.** A host
994
973
  that moves the keyboard into its view on the signal takes §6's second exception, with its
995
974
  conditions: a page can put the person's next keys in that view, and keeping those keys from posting
@@ -1001,15 +980,12 @@ own frame, below the shell, P111), so:
1001
980
  `marker-focus`: a page that replaced it is handed the marker otherwise); with no such marker it does
1002
981
  nothing. The page reads the message, so it learns a card closed, and can take the focus back at once
1003
982
  or forge the message and focus a marker itself, which gives it nothing a fake `activated` doesn't:
1004
- a host can't rely on the focus landing. To the focus guard the move is the frame's own, so from a
1005
- host's text field that still has focus it is undone and counted (P109), not passed as the host's:
1006
- no window was opened in the guard for it.
983
+ a host can't rely on the focus landing.
1007
984
  A word that has to wait while the frame finds its marks is up to a second old when it could land
1008
985
  (P135). A word the shell doesn't park can be as old: the frame takes it when its thread is free, a
1009
986
  busy page changes nothing the shell can see, and a frame out of process doesn't stop the host's
1010
987
  page meanwhile (P137). A marker's `focus()` takes the keyboard with no gesture on Chromium and
1011
- WebKit, past a guard that defends only text fields: a person gone on to a host's button would be
1012
- pulled back. So the shell drops a parked word unless the focus is in its document as it lands, and
988
+ WebKit: a person gone on to a host's button would be pulled back. So the shell drops a parked word unless the focus is in its document as it lands, and
1013
989
  a word older than 100 ms unless the focus is there as it comes, by `hasFocus` as it was before
1014
990
  content ran (control `marker-has-focus`: a page that replaced it to say yes gets the landing
1015
991
  otherwise; `marker-late` takes the first test out, `marker-busy` the second). A word's age is the
@@ -1090,11 +1066,13 @@ read and rewrite). It shares its realm with the content, so:
1090
1066
  the browser's find on Cmd+F (Apple) or Ctrl+F (elsewhere) in the frame and says `requested`; a
1091
1067
  page that handles the key itself keeps it. The page can say `requested` without the key, or keep
1092
1068
  the key from the shell. The host takes it only while the platform says the page's focus is in
1093
- the frame (a press on it or a Tab put it there, P109; control `find-requested-focus`): a page
1094
- can't open the host's bar, which takes focus, while the person types in the host's composer, so
1095
- their next keys can't be steered into the bar and from there into the frame as queries. With the
1096
- person already in the frame the page has their keys anyway, and the bar moves the keyboard out of
1097
- it. Where a platform can't tell, it passes, as the gesture gate does. Open the bar, nothing more.
1069
+ the frame (control `find-requested-focus`): a page that hasn't the keyboard can't open the
1070
+ host's bar, which takes focus, while the person types in the host's composer, so their next
1071
+ keys aren't steered into the bar and from there into the frame as queries. That holds where a
1072
+ page can't take the keyboard by itself (Firefox, without the person's gesture); on Chromium and
1073
+ WebKit a page takes it first ("The keyboard" below), and then has the keys anyway. A real
1074
+ press of the shortcut is always in the frame, so the rule refuses none. Where a platform can't
1075
+ tell, it passes. Open the bar, nothing more.
1098
1076
  - *What content can always do.* Hide, cover or move the layer, change its words so the count
1099
1077
  changes, reach the layer through built-ins it patched (as annotations' layer, P105), or make the
1100
1078
  search dear: linear in its text, at most 1,000 matches kept and 10,000 looked at, a query of 256
@@ -1102,111 +1080,34 @@ read and rewrite). It shares its realm with the content, so:
1102
1080
  queries only the latest searched (the others answered superseded); in an opaque frame that
1103
1081
  shares the host's process that time is the host's too ([§5](#5-out-of-scope)).
1104
1082
 
1105
- **The keyboard** (P109). Any display, of any kind and any version, can move the keyboard into its
1106
- frame: `element.focus()` runs in the content's realm, where nothing of Porthole can stop it, and on
1107
- Chromium and WebKit it needs no gesture. What the person goes on typing then goes to the page,
1108
- which can keep it (`db`) or send it out through any egress it has. The page knows when it matters:
1109
- its shell reports `selected` when the host opens a composer on it, and draft marks (P107) say
1110
- where the person is writing. P107 and P108 didn't make this possible; they put the person's
1111
- unposted words beside the frame and tell the page when.
1112
-
1113
- - *What holds* (the web platform's focus guard, in every `createHost` display): when focus leaves
1114
- one of the host page's text fields (a text area, an `<input>` that takes text, an editable region,
1115
- in open shadow roots too) for a display's frame, and the person didn't move it there, focus goes
1116
- back to the field once the engine has finished the move, the guard watches that it stays there
1117
- (a page that takes it again on its own blur, which the take-back fires, is caught, as is focus
1118
- left on nothing), and the display hears `focusTaken`. Three such moves within 10 s that came while
1119
- the person typed or that kept focus from staying back, or five within 2 s, stop the display. The
1120
- person moved it if they pressed Tab just before; pressed the frame (on Chromium and WebKit the
1121
- frame element is `:active` as focus moves; on Firefox, which doesn't blur the window or show the
1122
- press, the pointer came over the frame after the field got focus and after the person last
1123
- typed); made a gesture the host's own events don't explain (the page has activation, but no
1124
- key, press or click of its own for longer than activation lasts, and the field has had focus that
1125
- long: a press or an assistive technology's activation in a frame); or the host moved it
1126
- (`display.focus()`).
1127
- Measured on all three engines: a page calling `focus()` every 700 ms down to a busy loop, or
1128
- taking focus back on its own blur, while the person types a sentence gets no key of it on
1129
- Chromium and WebKit and at most one on Firefox before it is stopped or gives up (negative
1130
- controls `focus-guard`, and `focus-guard-watch` on Firefox); a press on the page's own field, a
1131
- Tab into the frame, and an activation in the frame that sends the host no event keep the
1132
- keyboard there. `comments.open` needs that focus in the calling frame, moved there by the
1133
- person, and not just after a press on the host's page (the app runtime, below).
1134
- - *What doesn't*: a page gets the keys typed before focus is back (on Firefox, the keys of an
1135
- animation frame: one in a sentence, measured on a slowed machine too; a few more can be lost to
1136
- nothing while a take-back is fought, and the composer then has focus again); on Firefox a host's plain
1137
- `focus()` doesn't move focus from a frame that holds it with the person's gesture and takes it
1138
- back on its blur (no focus event: the keys go to the frame), so a composer that opens focused
1139
- must use `focusField`; on Firefox a page keeps the keyboard if the pointer came over its frame after
1140
- the person last typed and after the field got focus (a person who typed, moved the pointer over
1141
- the frame, and types on without clicking); moves between two frames, or from what isn't a text
1142
- field, aren't judged (a frame beside another: S7); and a platform of the host's own has no guard
1143
- unless it implements one. The guard can take a person's own move for the page's (a press on
1144
- Firefox with the pointer resting over the frame since before the field got focus; an assistive
1145
- technology's activation within 5 s of their key or press on the page): focus goes back, and
1146
- their next press once the pointer has left the frame and come back, a Tab, or an activation 5 s
1147
- later keeps it.
1148
- - *Full Chromium* (P111, measured on Chromium 153, not the headless shell): a cross-site frame is
1149
- out of process, and the host's page sees nothing of a press in it (no `:active`, no `:hover`, no
1150
- pointer event past the frame's edge). For a served page that isn't nested, a person's real click
1151
- into its field is taken back every time there (the display stopped at the third), and
1152
- `comments.open` from a real click is refused within 5 s of any input on the host's page
1153
- (porthole#53). Nest it.
1154
- - *A nested page* (P111, P120, P122): the guard asks the page's shell, a realm the page can't
1155
- reach above its frame, whose transient activation turns on only from a press or key in the page
1156
- (activation goes up, never down). A move into the frame is the person's if the shell's
1157
- activation turned on within the last second and the host's page had no trusted press or key
1158
- since; or a Tab, the host's own move, or a press the engine shows on the frame element. Nothing
1159
- else counts as a press: no pointer over the frame, no host-wide activation. A move the shell
1160
- hasn't spoken of yet waits for its word at most 500 ms (the host asks it to look at once,
1161
- `porthole/shell/look`), then is taken back. The shell passes a focus on to the page by the host's
1162
- word (`porthole/shell/focus`, P136), which only `display.focus()` sends and no page can say. A key the person types into the page turns its
1163
- activation on as a press does, so (P120, after the audit of P111's guard, NG-1): where the
1164
- host's page sees the pointer over its frames (Firefox; Chromium and WebKit where the frame is in
1165
- their process, once the pointer has been over one), an activation while the pointer isn't over
1166
- the frame, within a second of the person typing on the host's page, is no press; and in a fight
1167
- over a text field (a take-back, or the person leaving a frame that took focus itself), a frame
1168
- that takes focus again is judged as any frame is, its shell not asked: taken back at once and
1169
- counted, and an activation it reports then is no one's gesture until it lapses, for
1170
- `comments.open` too. Measured on full Chromium, the headless shell, WebKit and Firefox
1171
- (`leak/served/nested.spec.ts`): a real click into the page's field keeps the keyboard; the
1172
- page's `focus()` as it loads, on a timer while the person types, right after a click on the
1173
- host's own button, 1.2 to 4.5 s after the person paused typing, and 700 ms after they pressed it
1174
- and went back to the composer is taken back; a page that holds the keyboard from its load, or
1175
- takes it while the person types, and takes it back on its own blur gets at most two keys of a
1176
- sentence on Firefox and is stopped (none on Chromium, where a page can't take focus back on its
1177
- blur), and its `comments.open` on a key it got reaches no handler on Firefox and full Chromium
1178
- (on Chromium with frames in process it can: below); what a page says in the shell's name, to its
1179
- parent or to the host's window, moves nothing (negative controls `shell-namespace`,
1180
- `shell-host-input`, `pointer-rule`, `nested-fight`). *What doesn't*: a press in the page within
1181
- 5 s of the last one turns no activation on, so a second move into it after the person went back
1182
- to the host's page is taken back until 5 s after their last press or key in the page, or they
1183
- Tab in; the page gets the keys typed while a move waits for the shell's word, or before focus is
1184
- back. No press of the person's comes within 250 ms of a key they typed on the host's page (a
1185
- hand goes from the keys to the pointer first): a move into the frame, or the shell's activation
1186
- turning on, that soon is their next key landing in the page, and is taken back, on every engine
1187
- (P122, after CI saw full Chromium let such a page keep the keyboard: its key outran the shell's
1188
- answer; negative control `key-press`). So a page that takes the keyboard while the person types
1189
- is taken back whatever the timing. *Still*: on full Chromium, where neither the host's page nor
1190
- the shell sees the pointer over the page, a key typed more than 250 ms after the person's last
1191
- one that reaches the page before the shell answers the host's ask (the time a message takes
1192
- between processes) is taken for a press, and the page keeps the keyboard and its `comments.open`
1193
- opens; and so, more often, where Chromium keeps the page's frames in the host's process (the
1194
- headless shell; a person's Chrome without full site isolation, Chrome on Android) until the
1195
- host's page has seen the pointer over one of the page's frames, since the page's input runs
1196
- before the ask there (measured in P122's review on the headless shell: a person typing one key
1197
- every 450 ms lost 34 of 36 keys to the page in 1 run of 8, and the page was not stopped). 0.13 took such a move back; a person typing slower than one key in 250 ms
1198
- is the case left, and only a key that lands within that message's time of the page's move
1199
- (P122); a press back into the page within 300 ms of a fight putting focus in the host's field is
1200
- taken back on full Chromium; where the pointer is seen, an assistive technology's activation in
1201
- the page within a second of typing on the host's page with the pointer elsewhere is taken back
1202
- (a Tab, or one a second later, keeps it); a shell without `navigator.userActivation` leaves
1203
- 0.13's rule. A page that holds the thread it shares with its shell (WebKit; Firefox and Chromium
1204
- where the frames share a process) from its own click handler would push the moment the shell
1205
- sees its activation past the person's next keys on the host's page: so the shell looks and beats
1206
- every 50 ms and says how long it went without a look, and an activation it reports after a stall
1207
- of over 100 ms (its own, or no word heard) is no one's gesture until it lapses (P111, after its
1208
- review; negative control `shell-stall`). The cost: in those engines a page that keeps its thread
1209
- busy has the person's real click taken for uncertain until it is idle.
1083
+ **The keyboard** (P109, P149). Any display, of any kind and any version, can move the keyboard
1084
+ into its frame: `element.focus()` runs in the content's realm, where nothing of Porthole can stop
1085
+ it, and on Chromium and WebKit it needs no gesture. What the person goes on typing then goes to the
1086
+ page, which can keep it (`db`) or send it out through any egress it has, until the person sees
1087
+ their words stop appearing and clicks back. The page knows when it matters: its shell reports
1088
+ `selected` when the host opens a composer on it, and draft marks (P107) say where the person is
1089
+ writing. P107 and P108 didn't make this possible; they put the person's unposted words beside the
1090
+ frame and tell the page when.
1091
+
1092
+ - *Nothing takes it back* (0.16.0, P149). From 0.13 to 0.15 `createHost` guarded every display
1093
+ (P109): a move of the keyboard from one of the host's text fields into a frame was undone unless
1094
+ the guard judged it the person's own. It had to guess. The host's page sees no press inside a
1095
+ cross-site frame on full Chromium (the frame is out of process) nor on Firefox, so the guard
1096
+ read what it could (`:active`, the pointer's place, the time since the person's last key, and
1097
+ for a nested page its shell's word on its activation, then on its presses: P111, P120, P122,
1098
+ P148), and each rule refused some real clicks while a page could still pass for the person
1099
+ where the signals ran out (a key typed slower than 250 ms apart, P123). A wall that guesses is
1100
+ no wall, and its wrong guesses were the person's own clicks refused; it is gone, with the
1101
+ nested pages built to feed it.
1102
+ - *What holds without it.* Content can't read the host's page or its fields, can't move focus
1103
+ into a field of the host's, and gets no key typed while the focus is in the host's page. A page
1104
+ that takes the keyboard gets the keys typed after its move and before the person notices: what
1105
+ they meant for the host's composer, not what is already in it.
1106
+ - *What a host does.* Shows no untrusted display beside a field that must never lose a key (a
1107
+ password, a payment field); opens the views a display's report asks for without focus (§6);
1108
+ and moves focus itself with `display.focus()` and `focusField(field)`, which land on every
1109
+ engine (Firefox ignores a field's plain `focus()` while a frame that takes focus back on its
1110
+ blur holds it).
1210
1111
 
1211
1112
  ### The app runtime
1212
1113
 
@@ -1229,8 +1130,9 @@ section.
1229
1130
  declarations allow (P093).
1230
1131
  - `db`: another person's `data/users/<id>` is refused at every level; `me` is the host's id for
1231
1132
  the viewer, and paths in answers say `data/users/me`, never that id.
1232
- - What changes the artifact for everyone needs, by default, a gesture and a confirmation:
1233
- `artifact.publish` and `assets.delete` (a host's `methodGates` for them replace these).
1133
+ - What changes the artifact for everyone needs, by default, a confirmation with its whole effect:
1134
+ `artifact.publish` and `assets.delete` (a host's `methodGates` for them replace this; no proof
1135
+ of a click is asked since 0.16.0, P149).
1234
1136
  - A `db.batch` runs under the gates of each of its writes, and a `db.watch` under those of `get`
1235
1137
  or `query`, as well as their own; a batch that needs a confirmation is confirmed once, whole
1236
1138
  (P094).
@@ -1239,15 +1141,11 @@ section.
1239
1141
  code-typed asset runs as code only when an admin uploaded it where uploaded code may run, and
1240
1142
  only while the config still lets uploaded code run, asked at every load, in bearer mode too
1241
1143
  (where every artifact config must; P103); anything else is a download.
1242
- - `comments` is write-only: the page learns only whether the composer opened. It opens only from
1243
- a gesture with the host page's focus in the calling frame (P109: a press in it or a Tab into it;
1244
- not the person typing in the host's UI, nor a gesture in another display; negative control
1245
- `comments-in-frame`). In a nested page (P111) it opens too while the page's shell saw the
1246
- person's gesture within the last second, with no press or key on the host's page since: a real
1247
- click on the page's button a moment after typing in the host's composer opens it, on full
1248
- Chromium too (porthole#53); with no click it is refused, whatever the page says in the shell's
1249
- name, and so is one on a key of the person's that reached the page while it fought for the
1250
- keyboard, or, where the host's page sees the pointer, while the pointer was elsewhere (P120). A
1144
+ - `comments` is write-only: the page learns only whether the composer opened. It reaches the
1145
+ host's handler whenever the page calls it, at most 30 times a minute; no proof of a click is
1146
+ asked (0.16.0, P149; from 0.13 to 0.15 it needed a gesture with the host page's focus in the
1147
+ calling frame, P109, which refused real clicks wherever the guess at that focus was wrong).
1148
+ Whether the composer opens is the host's handler's answer. A
1251
1149
  draft it gives (P108) is at most 2,000 characters of text a person can
1252
1150
  see (P109): nothing invisible (zero-width characters, bidi and tag characters, controls but a
1253
1151
  new line and a tab; U+200C and U+200D only between two letters or marks, where Persian and the
@@ -1306,22 +1204,22 @@ section.
1306
1204
  - In bearer mode, assets are served by id alone, without the host's check.
1307
1205
  - A draft is the page's words in the person's composer: a person who posts it without reading
1308
1206
  posts what the page chose, and an agent that reads the comment takes it as theirs. Porthole
1309
- bounds what can hide in it (visible text, 2,000 characters) and when it opens (a gesture with the
1310
- person in the calling frame, P109: before P109, any gesture on the host's page in the last 5 s,
1311
- typing in its own composer included); reading it is the person's. A page can still open the
1312
- composer on the person's own press in its frame, at a moment it chooses (the second click of a
1313
- double click, a field it asked them to type into): the composer's duties above are the bound.
1207
+ bounds what can hide in it (visible text, 2,000 characters) and how often it is asked (30 a
1208
+ minute); reading it is the person's. A page opens the composer at a moment it chooses, with a
1209
+ press of the person's or with none (P149): the composer's duties above are the bound.
1314
1210
 
1315
1211
  ## 8. Fixes in flight
1316
1212
 
1317
1213
  The decisions below come from the 2026-10-19 review, and all of them have merged. Each row says
1318
1214
  what was wrong, what holds now, and the limit its decision accepts, if any. Later reviews' decisions
1319
1215
  are in the status line and in DECISIONS.md: P105 (after the review of P104), P109 (after the review
1320
- of 0.12.0's drafts), P111 (a nested page, S3; in 0.14.0), P114 (a nested page's shell on a label of
1321
- its own, after porthole#56; in 0.14.1), P124 (a frame status is the word of Porthole's pages, after
1322
- the audit raft-security-audit#16; in 0.14.5: §4, §6, §7, S6), P125 (a served display that isn't
1323
- nested takes its word from a door no same-scope content can reach, after the audit of 2026-10-30
1324
- found P124 held only for a nested display or one alone in its scope; in 0.14.6: §4, §6, §7, S7).
1216
+ of 0.12.0's drafts), P111 (a nested page; in 0.14.0, removed in 0.16.0), P114 (a nested page's
1217
+ shell on a label of its own, after porthole#56; in 0.14.1, removed in 0.16.0), P124 (a frame
1218
+ status is the word of Porthole's pages, after the audit raft-security-audit#16; in 0.14.5: §4,
1219
+ §6, §7, S6), P125 (a served display takes its word from a door no same-scope content can reach,
1220
+ after the audit of 2026-10-30 found P124 held only for a display alone in its scope; in 0.14.6:
1221
+ §4, §6, §7, S7), P149 (what guessed at the person's intent is taken out: nested pages, the focus
1222
+ guard, the proof of a click but `copyText`'s; in 0.16.0: the status line, §5, §6, §7).
1325
1223
 
1326
1224
  | Decision | State | What it closes | Sections |
1327
1225
  | --- | --- | --- | --- |