Make Python the canonical browser projector

CLAUDE.md

@@ -55,9 +55,11 @@ the decision rests on. Use `restated` when a rewrite invalidates one. An `undo`
 event names the gesture withdrawn; it never deletes or invents a counter-event.
 
 Actions and reports share the registry-declared coordinate of owner widget,
-fold unit, and facet. Python and JavaScript derive winners, retractions, and
-settlement from the same declarations. Page-widget state is bounded by document
-version; widgets frozen into thread markup use the conversation window.
+fold unit, and facet. Python derives winners, retractions, settlement, asks,
+threads, and updates in one transaction-consistent browser view. JavaScript
+resolves that view onto live DOM nodes and overlays only unresolved local
+gestures. Page-widget state is bounded by document version; widgets frozen into
+thread markup use the conversation window.
 
 The page directory is the durable record and deployment unit. `index.html` is
 mutable author source; revisions and stamped versions are immutable. The event

plugins/leaf/skills/leaf/CLAUDE.md

@@ -86,7 +86,7 @@ highlight rules;
 `runtime/geometry.js` owns the shared readings of visible boxes and clipping;
 `runtime/navigation.js` owns reader travel and scroller selection;
 `runtime/anchors.js` owns anchor resolution, paint, and anchor-specific travel;
-`runtime/conversation/model.js` owns the thread fold;
+`runtime/conversation/model.js` adapts server-projected threads to browser callers;
 `runtime/conversation/messages.js` owns message rendering;
 `runtime/conversation/replies.js` owns reply drafts, mirrored send state, and delivery;
 `runtime/conversation/inline.js` owns conversation seats rendered into the page;
@@ -97,7 +97,8 @@ highlight rules;
 `runtime/conversation/reconcile.js` composes panel reconciliation;
 `runtime/projection/authored.js` owns captured authored state and restore
 statements; `runtime/projection/data.js` owns keyed runtime-data DOM
-reconciliation; `runtime/projection/fold.js` owns canonical action and report state;
+reconciliation; `runtime/projection/fold.js` adapts canonical action and report state
+to live DOM nodes and the local outbox;
 `runtime/projection.js` owns projection reconciliation and undo. The entry module
 composes their mutually dependent callbacks.
 
@@ -287,11 +288,11 @@ accepted event because its rendering failed.
 
 A recorded action may be optimistic because its gesture has already changed the
 DOM. Drag and edit are examples. `stageOutboxAction` gives that local value the
-same semantic coordinate as logged state and commits it on the exact widget and
-unit nodes that carry it. `stateProjection` overlays all surviving recorded
-outbox actions after logged winners in `outboxOrder`. Until a complete read
-accounts for an attempt, its local winner outranks any older log winner on the
-same coordinate.
+same semantic coordinate as the server view and commits it on the exact widget
+and unit nodes that carry it. The browser projection adapter overlays all
+surviving recorded outbox actions after authoritative winners in `outboxOrder`.
+Until a complete read accounts for an attempt, its local winner outranks any
+older log winner on the same coordinate.
 
 A press whose result has not changed the DOM waits for the log. Recordless
 settlements and completion presses do not enter the optimistic overlay. The
@@ -316,11 +317,11 @@ represents the DOM. Delivery may continue while that correction waits for a
 live drag or editor to finish.
 
 `accountOutbox` runs only after `receiveState` has installed and rendered a
-complete state. It links accepted events to entries, resolves readers waiting on
+complete state. It links receipt events to entries, resolves readers waiting on
 those events, removes non-action entries whose delivery is complete, and calls
-`releaseProjectedOutbox` for actions. Never remove an action merely because a
-POST returned 200 or because an attempt appears in an event array that failed
-partway through rendering.
+`releaseProjectedOutbox` for actions. Never remove an action merely because a POST
+returned 200 or because an attempt appears in a receipt list that failed partway
+through rendering.
 
 `unaccountedGesture` is true while undo is in flight, the outbox is nonempty, or
 a widget is visibly dragging. Navigation and undo both consult it. Navigating
@@ -352,7 +353,7 @@ therefore survives its response.
 The DOM is a projection of three ordered inputs:
 
 1. the authored state captured from this version;
-2. standing actions and reports in the authoritative log window;
+2. standing actions and reports in the server's transaction-consistent browser view;
 3. surviving optimistic recorded actions in the outbox.
 
 The semantic coordinate is
@@ -371,16 +372,24 @@ projections. `x-awaits.answers` says which actions actually close the request;
 orthogonal actions do not, and neither does a conversation standing in the widget's
 declared `x-conversation` seat — that takes the request off the reader's list without
 answering it, which is why this gate reads the projection with no seats in
-it. `x-awaits.rollup` derives a nested request from direct
-interventions and child roll-ups, using the same reducer in the browser and file
-projection.
-
-`stateProjection(upto)` is the pure derived view. It classifies every action and
-report, applies version and retraction windows, drops withdrawn actions and
-answered reports, folds the last action for each coordinate, retains report
-winners, overlays unresolved local records, and gives a reader action precedence
-over a provisional report on the same coordinate. Winners on independent
-coordinates compose in event order through `compareProjected`.
+it. `x-awaits.rollup` derives a nested request from direct interventions and child
+roll-ups in Python; the browser receives the resulting ids and awaiting values.
+
+Python's `state_projection` is the durable derived view. Under the same page
+transaction as `/api/state`, `browser_state` serializes its classified events and
+winners, asks, conversations, updates, undo candidates, receipts, and coverage at
+one `through_seq`. A normal response projects the revision the tab shows and the
+active revision it may install next. A version comparison requests its older base
+from `/api/view` at the exact `through_seq` already applied to the live DOM, so every
+view used together has the same sequence basis without every state read parsing all
+historical revisions. Page coordinates use that revision's document window;
+conversation coordinates use the unbounded frozen-markup window.
+
+The browser's `stateProjection` is a DOM adapter. It resolves those declared
+coordinates back to current widget modules and overlays unresolved local records.
+It does not derive retractions, settlements, thread structure, asks, updates, or
+undo eligibility from raw events. Winners on independent coordinates still
+compose in event order through `compareProjected`.
 
 The two durable channels share the coordinate model but retain their meaning:
 
@@ -394,8 +403,8 @@ The two durable channels share the coordinate model but retain their meaning:
 `stateProjection` is uncached because registry declarations resolve through the
 live DOM. Thread construction and recordless restoration can replace node
 identities. Its result has four views: `actions`, `reports`, `classified`, and
-`desired`. Add a consumer to one of these views instead of building another fold
-over raw `events`.
+`desired`. Add a browser consumer to one of these views or extend the Python wire
+view instead of building another fold over raw `events`.
 
 `committedProjection` is not a second state authority. It is a checkpoint of
 what node identities and semantic winner the DOM currently represents. Each
@@ -406,11 +415,11 @@ its authored baseline stands.
 
 `projectionCommitted` compares the desired coordinate with that checkpoint.
 Terminal events count as committed because this version has no applicable state
-to paint. `projectionCoverage` converts coordinate commits back to event
-coverage for `data-lf-applied`: superseded actions and answered reports are
-covered when the coordinate that represents them is committed, and an undo is
-covered when its target's coordinate has moved to the prior winner or authored
-baseline.
+to paint. The server supplies coverage records and `projectionCoverage` checks
+their coordinates against DOM commits for `data-lf-applied`: superseded actions
+and answered reports are covered when the coordinate that represents them is
+committed, and an undo is covered when its target's coordinate has moved to the
+prior winner or authored baseline.
 
 ### Reconciliation
 
@@ -518,9 +527,9 @@ documents written after this version. A widget instantiated inside frozen thread
 markup is in chrome and reads the whole action sequence because the conversation,
 not a page version, owns it.
 
-Threads also read the whole log. `retractionFloors(Infinity)` keeps a
-conversation current on a pinned page even when the document projection remains
-historical. Registry-declared `x-conversation` seats show an exact-section
+The server projects threads from the whole log, so a conversation stays current
+on a pinned page even when the document projection remains historical.
+Registry-declared `x-conversation` seats show an exact-section
 textual view while the owner exists in the current document; the Comments panel
 keeps the complete thread and its interactive replies. A root declared with
 `response: {kind: version, verb: <answer>}` keeps that exact-section view
@@ -529,8 +538,9 @@ response. Dropping the owner drops only the inline seat.
 
 `restated` and answered-report relations persist through version notes. The note
 records the version floor for each affected id or report event; silence in a
-later version does not revive retracted state. `retractedIds` uses containment,
-not a global id lookup, when deciding which detailed parts an action rests on.
+later version does not revive retracted state. Python's projection uses
+containment, not a global id lookup, when deciding which detailed parts an action
+rests on.
 
 ### Event sequences for modules
 
@@ -572,12 +582,12 @@ field, verb, or widget name. Claims use their required detail as `detail.text`
 and `text`. The state boundary performs this normalization once, before
 downstream code sees private status storage.
 
-`sequence` is the action traversal. It applies widget, optional verb, version
-window, and liveness in one place, then returns structured clones so modules
-cannot mutate the private event list. `watchActions` and `watchUpdates` subscribe
-the two public readings to `lf-actions` and invoke the callback immediately. The
-same rendering function therefore handles a module connected before the first
-state and one constructed by a later thread reconcile.
+`actionSequence` traverses the classified events in the installed server view,
+then returns structured clones so modules cannot mutate the reading.
+`updateSequence` filters the server-normalized update feed. `watchActions` and
+`watchUpdates` subscribe the two public readings to `lf-actions` and invoke the
+callback immediately. The same rendering function therefore handles a module
+connected before the first state and one constructed by a later thread reconcile.
 
 `lf-actions` fires after a complete state has reconciled, including a read whose
 event list did not grow and the heartbeat's re-application of the state the page
@@ -596,7 +606,7 @@ assertion is as old as its revision.
 `actionStands` answers whether one accepted action is still the reader's winner
 for its semantic coordinate. It treats a newly accepted event as standing when
 the tab has not yet installed an event list containing its id, then asks
-`stateProjection` once authoritative history contains it. Modules use this
+the installed projection once an authoritative receipt contains it. Modules use this
 after a send whose visible choreography depends on whether the accepted action
 survived later events.
 

plugins/leaf/skills/leaf/assets/leaf.js

@@ -1619,7 +1619,7 @@ mirrorDraft(generalInput, syncGeneral, "general");
 
 let approving = false;
 function paintApproval() {
-  const approved = runtime.events.some(
+  const approved = (runtime.browser?.conversation?.done ?? []).some(
     (e) =>
       e.kind === "done" &&
       e.revision === runtime.currentRevision &&
@@ -2006,27 +2006,16 @@ function allButTheReference(binding) {
 // page stands down under them — and each declares what it keeps, which is how the
 // reference's own key goes on working while every other one is suspended.
 
-const { askEntry, isAwaiting, projectedParent, threadMarkupAwaiting, unansweredAsks } =
-  createAskModel({
-    authoredParentOf: (node) => authoredParents.get(node),
-    awaitsAgent,
-    buildThreads,
-    closestAcross: (...args) => closestAcross(...args),
-    elementById: (...args) => elementById(...args),
-    inChrome: (node) => inChrome(node),
-    matchesProjectedWhen: (...args) => matchesProjectedWhen(...args),
-    matchesWhen,
-    pagePresented,
-    projectedFacet: (...args) => projectedFacet(...args),
-    quoted,
-    registry,
-    runtime,
-    seatRoot,
-    settledAway: (...args) => settledAway(...args),
-    stateCoordinate: (...args) => stateCoordinate(...args),
-    stateProjection: (...args) => stateProjection(...args),
-    tagsDeclaring,
-  });
+const { askEntry, isAwaiting, projectedParent, unansweredAsks } = createAskModel({
+  authoredParentOf: (node) => authoredParents.get(node),
+  closestAcross: (...args) => closestAcross(...args),
+  elementById: (...args) => elementById(...args),
+  pagePresented,
+  registry,
+  runtime,
+  stateProjection: (...args) => stateProjection(...args),
+  tagsDeclaring,
+});
 
 const {
   ASK_CONTROL,
@@ -3101,12 +3090,12 @@ const {
   chooserLabel: () => labelOf(CHOOSER),
   domFacet: (...args) => domFacet(...args),
   elementById: (...args) => elementById(...args),
-  foldedFacet: (...args) => foldedFacet(...args),
   inChrome: (...args) => inChrome(...args),
   quoted,
+  projectionFromView: (...args) => projectionFromView(...args),
+  sameLayer,
   showToast,
   stateCoordinate: (...args) => stateCoordinate(...args),
-  stateProjection: (...args) => stateProjection(...args),
   stateSpecs: (...args) => stateSpecs(...args),
   textBlockSelector: () => TEXT_BLOCK,
   versionBtn,
@@ -3392,9 +3381,6 @@ const runtimeProjection = createProjection(runtime, {
   projectedParent,
   quoteFrom,
   reachScrollers,
-  // Whether a reaction still paints, off the conversation's last fold — built after this
-  // module, so asked lazily.
-  reactionStanding: (e) => conversationRuntime.reactionStanding(e),
   rememberPassageParts,
   removeOutbox,
   renderQuiet,
@@ -3418,11 +3404,11 @@ const {
   committedProjection,
   coordinateProjectionCommitted,
   domFacet,
-  foldedFacet,
   markSettled,
   matchesProjectedWhen,
   paintPending,
   projectedFacet,
+  projectionFromView,
   projectionCommitted,
   rebuild,
   reconcileKnownState,
@@ -3431,13 +3417,10 @@ const {
   rememberAuthoredMarkup,
   resetAuthoredPage,
   requirementMatches,
-  retractedIds,
-  retractionFloors,
   stageOutboxAction,
   stateCoordinate,
   stateProjection,
   stateSpecs,
-  takenBack,
   undoable,
   unitOf,
   withdraw,
@@ -3519,8 +3502,6 @@ conversationRuntime = createConversation({
   renderQuiet,
   renderSaid,
   reportPageError,
-  retractedIds,
-  retractionFloors,
   runtime,
   saveDraft,
   scrollToElement,
@@ -3529,10 +3510,8 @@ conversationRuntime = createConversation({
   sendDraft,
   setPanel,
   settling,
-  takenBack,
   tellDraft,
   threadsBox,
-  threadMarkupAwaiting,
   toggleBtn,
   updateSequence,
   visualPartLabel,
@@ -3543,10 +3522,8 @@ conversationRuntime = createConversation({
 updateRuntime = createUpdates(runtime, {
   closestAcross,
   coordinateProjectionCommitted,
-  inChrome,
   projectionCommitted,
   stateProjection,
-  threadList: () => conversationRuntime.threadList,
 });
 
 anchorRuntime = createAnchors({