User Inbox

This file is the persistent inbox for mid-stream user requests, bug reports,

and architectural constraints.

Process:

• Add new user guidance here as it arrives.
• Do not switch lanes immediately unless the new item is a blocker or clearly

supersedes the current highest-leverage work.

• Re-read this file before starting a new implementation slice and after

finishing one.

• Prune completed or clearly superseded items during those re-reads so this

file stays current instead of turning into a stale backlog dump.

• Keep the checked-in docs surface honest too: README.md, the living

document in src/ui/templates.ts, and the support matrices should reflect

the actual shipped product rather than stale plans.

• If a work slice changes the live product contract, queue, or support status,

update the current-truth docs in the same slice instead of deferring docs

cleanup to “later”.

• Track active agents in NEXT.md whenever more than one agent is working in

the repo. Record owner, task, write scope, and status, then prune stale

entries aggressively.

• Do not treat every user mention as an automatic lane switch. Triage each new

item deliberately:

- work it now if it blocks or directly corrects active work

- delegate it if it can move safely in parallel

- record it here for later if it matters but should not interrupt the current

critical path

• If a requested approach looks brittle, contradictory, or likely to harm the

product, push back clearly and discuss the tradeoff instead of acting like a

yes-man.

Active Guidance

• The renderer contract is non-negotiable: the DOM must be a projection of

authoritative editor/render data, not the place where final layout decisions

get invented. Resolve word positions, block geometry, and element placement in

the data/model pipeline before DOM projection whenever the product surface is

meant to be authoritative.

• Do not rely on brittle DOM-driven post-calculation to decide final document

positions. Avoid "render something, measure it, then patch it into place"

systems for core document surfaces unless there is an explicit, temporary, and

clearly tracked migration exception.

• There should be zero meaningful distinction between "active" and "passive"

block rendering paths for projected semantic content. Editing must reuse the

same renderer-owned geometry contract instead of swapping to a second layout

engine, overlay, or blur-time handoff path.

• In-document controls such as slash insertion and block affordances should be

native page components anchored from renderer/editor-owned coordinates, not

floating viewport overlays that visually drift from the document.

• Hit testing, insertion anchors, and block targeting should come from the

authoritative block/source model and predeclared geometry, not from ad hoc DOM

guesses, hover hacks, or reverse-engineered page shape.

• Prefixed block geometry must be declared by the renderer. Do not reintroduce

post-render DOM measurement loops to "correct" heading/caption/bibliography

prefix widths after paint.

• Slash commands and block insertion are now the top product issue. Treat any

brittle, bolted-on, modal-feeling behavior there as a real architecture bug,

not as acceptable interim UX.

• Do not preserve or re-polish the active/passive block split. Move toward one

renderer-owned block surface that stays honest before, during, and after

interaction instead of swapping DOM modes on focus changes.

• Routine lightweight verification is not the current lane. Spend the effort on

the live UX and let the user judge the product behavior directly unless they

explicitly ask for verification work.

• Prefer a single authoritative semantic render path for passive and active

text. Do not keep growing separate edit-only parsing/layout behavior when the

shared path can be improved instead.

• Keep any lighter/fallback edit mode vestigial and clearly treated as unused;

new behavior should land in the shared authoritative path, not in a side

lane.

• Semantic editing should preserve the same wrapper styling and KP reflow

contract as passive rendering. If editing and non-editing diverge, treat that

as a shared renderer/fragment bug rather than papering it over in the editor.

• Semantic typography styles should come from semantic classes defined in a

single CSS file, not from inline font / color / line-height mutation on

nodes.

• Inline style="" on semantic document nodes should be limited to geometry,

positioning, or genuine inline overrides.

• Semantic edit caret became too small / hard to see after the style changes;

keep inherited edit-surface typography through CSS classes so caret metrics

stay correct.

• Active semantic edit hit targets must line up with the rendered text itself;

projected edit surfaces need the same role class / typography metrics as the

passive renderer.

• Compatibility reporting should stay renderer/editor declared. Do not drift

back toward reverse-engineering DOM shape when explicit ownership metadata is

available.

• The underlying Computer Modern DOM fonts appear to have a baseline/vertical

offset mismatch versus expected metrics. Treat caret size, click-hit drift,

and line-alignment issues as possibly downstream symptoms of that font issue,

not just edit-surface bugs.

• The rebuilt CM font bundle is still missing some text ligatures such as ff

and ffi. There is a related article in the colony knowledge base; check it

when returning to the font cleanup lane.

• There is a colony knowledge-base note about BaKoMa font encoding. Check

whether it still matters after the canonical CTAN-backed font rebuild before

making further assumptions about CM font encoding behavior.

• After the semantic font/style system is properly carved out, run a full sweep

of the CSS against LaTeX/article defaults with one or two peer agents, fix

obvious issues, and report what they found, fixed, and recommend next.

• Do not keep switching lanes every time the user mentions an issue. Record it

here and fold it into the work deliberately.

• The remaining document-chrome audit should move beyond the corrected

TOC/chapter defaults. Keep checking page chrome and class-owned defaults

against LaTeX rather than freezing the current browser-ish approximations.

• Display-math blocks currently look poor in semantic mode. Treat block math

rendering quality, sizing, spacing, and surrounding chrome as an active

product issue rather than acceptable placeholder output.

• Faithful-mode math layout is also reported broken. Keep it separate from the

semantic DOM pass, but treat it as an active renderer regression rather than

a cosmetic complaint.

• Do not emit or depend on Private Use Area glyphs in renderer output. Keep

faithful glyph access on raw font slots or real Unicode only.

• [2026-04-06 13:48] Core user-facing semantic UX and UI issues take priority over more smoke tests, harness work, or similar side systems. Treat slash commands, insertion UI, and direct editing feel as the main product lane.
• [2026-04-06 13:48] Slash commands must only surface commands that are valid for the current location/context, and selecting a command must insert the exact intended structure instead of the wrong wrapper or element.
• [2026-04-06 13:48] If blurring or unfocusing a semantic block causes it to visibly reflow again, treat that as a real architecture bug and likely evidence of separate active/passive render paths. Fix the shared renderer-owned path instead of hiding the symptom.
• [2026-04-06 13:48] The block insertion affordance now belongs in the Notion-style left gutter anchor zone. Remaining work in that lane is hardening it across more block families and keeping the slash launcher/context filtering honest from that anchored entry point.
• [2026-04-06 15:58] Source/render scroll sync is now source-offset anchored in the unwrapped editor. Treat future regressions there as mapping/geometry bugs, not as a place to reintroduce scroll-ratio guesses.
• [2026-04-06 15:58] Block-edge insertion now includes declared prefix/label geometry for prefixed blocks. Keep extending that renderer-owned geometry contract instead of falling back to DOM hover hacks for labels and prefixes.
• [2026-04-06 16:18] Do not run two separate JS hover controllers over the same semantic block surface. Block insertion hover must stay block-owned from the event target and renderer-declared geometry; stale overlay chrome should be removed or rebuilt on that same ownership seam instead of competing with it.
• [2026-04-06 16:27] Slash launcher and inline block UI should resolve the active semantic surface from the live edit session, not from global document.querySelector(...) guesses over the rendered DOM.
• [2026-04-06 16:36] Preview scroll ownership should stay singular. Do not stack a second editor-scroll listener in main.ts on top of the core editor scroll sync path; compare-mode sync should plug into the same editor-owned seam instead.
• [2026-04-06 16:44] Click ownership should go through one typed semantic interaction target path. Do not make block edit, widget edit, math edit, and render-only source jumps each rediscover their target with separate selector trees.
• [2026-04-06 16:52] Prefixed editable labels such as caption labels, heading labels, and bibliography keys should publish renderer-declared edit-anchor geometry too. Do not leave them on widget-editor DOM-rect fallback positioning.
• [2026-04-06 16:58] Page-projected widget and math editors should not silently fall back to raw DOM-rect positioning when declared anchor geometry is missing. Treat missing page-frame anchor geometry as a renderer contract bug, not as permission to guess.
• [2026-04-06 17:04] Source-sync cursor follow should prefer authoritative editor blocks before scanning fine-grained [data-src-offset] fragments. Keep preview mapping rooted in block ownership, with fragment/line scans as fallback rather than first choice.
• [2026-04-06 17:12] Slash launcher anchor placement should resolve from caret-adjacent text or line geometry before any surface-level fallback. Do not anchor the menu to the whole active block just because collapsed selection geometry is thin or missing.
• [2026-04-06 17:16] Semantic slash execution must restore the live edit session and caret selection before dispatching the chosen command. Do not let dropdown interaction run commands against a dead or guessed selection state.
• [2026-04-06 18:44] Slash launcher pointer interaction should not blur or commit the active semantic block session. Treat the launcher as session-owned command chrome, not as a separate focus system that kicks editing back to body mid-click.
• [2026-04-06 17:21] Manual scrolling in the main semantic preview must not mirror back into editor scroll state outside explicit compare mode. Preview->editor scroll feedback in normal mode is a product bug, not a convenience feature.
• [2026-04-06 18:53] A live semantic edit session means the page side owns scroll. Do not let hidden editorEl scroll bookkeeping drag pagesWorkspace around while block/widget/math editing is active.
• [2026-04-06 17:29] Block-insert hover should resolve from the hovered block owner’s declared geometry, not from per-pointer page scans. Treat native-feeling hover as a geometry ownership problem, not as something to brute-force with pointermove and repeated DOM queries.
• [2026-04-06 17:36] Inline toolbar ownership must stay on the live semantic edit session too. Do not let toolbar targeting or action dispatch fall back to global DOM guesses or a dead selection state.
• [2026-04-06 17:39] Secondary formatting chrome such as the format bar should follow the same session-owned rule. If it targets semantic editing, it should resolve context and dispatch through the live edit session before falling back to raw source behavior.
• [2026-04-06 17:46] Toolbar buttons should not maintain their own handcrafted insertion engine. Route toolbar formatting and structural insert actions through the same shared command execution path as slash and other command surfaces.
• [2026-04-06 18:01] Page-frame-hosted widget and math editors already live in document coordinates. Do not keep repositioning them on every captured scroll event as if they were viewport overlays; reserve scroll-driven repositioning for the fallback workspace-hosted case only.
• [2026-04-06 18:06] Widget and math editor anchor reacquisition after rerender should stay host-local. Do not search the whole workspace when the editor already knows which page frame or host surface owns it.
• [2026-04-06 18:12] The format bar should declare shared command ids, not duplicate insertion templates, for commands already owned by the central insert-command system. Keep local wrap definitions only for genuinely local exceptions.
• [2026-04-06 18:20] Slash validity filtering should consider ancestor container scope, not only the immediate parent block. Nested contexts under container constraints such as minipage should stay honest even when the direct parent is an inner quote, list item, or similar child block.
• [2026-04-06 18:27] The command palette should not act like a global god-mode insert list. Its text insert commands should be filtered from the same live context rules as the rest of the editor so invalid structural commands do not leak in through a separate surface.
• [2026-04-06 18:31] The inline semantic toolbar should not carry its own insertion templates either. If an action already exists in the shared insert-command system, the inline toolbar should dispatch by shared command id instead of maintaining a parallel wrap definition.
• [2026-04-06 19:07] Text insert execution should require an explicit live target and validity context. Do not let command surfaces silently fall through from semantic intent into raw source mutation just because the first lane failed.
• [2026-04-06 19:07] Command surfaces that open asynchronously, especially the command palette, should capture their insert target at open time and execute against that captured lane. If the live target is widget/math/non-rich semantic, surface no text insert commands instead of guessing source.
• [2026-04-06 19:16] The inline semantic toolbar should be hosted under the owning page/frame, not document.body, and should ride document geometry instead of a global viewport overlay plus scroll listener chase loop.
• [2026-04-06 19:24] Widget and math editors should require a page-frame host plus declared renderer geometry. Missing page geometry is a renderer contract failure; do not reopen DOM-rect fallback positioning as a backup system.
• [2026-04-06 19:31] Source keyboard shortcuts such as Ctrl+B and Ctrl+I should route through the same shared text-insert execution path as slash, toolbar, and palette. Do not keep manual wrap shortcuts as a parallel insert system.
• [2026-04-06 19:40] Command chrome should reflect live insert truth, not just execution truth. Toolbar and format-bar buttons should disable when the active lane cannot honestly run them instead of surfacing clickable dead ends.
• [2026-04-06 20:02] The block-edge + affordance should own its own session handoff on pointerdown. Do not rely on generic outside-click handlers to commit semantic sessions before insertion UI opens; that turns the affordance into a dead or flaky click path.
• [2026-04-06 20:16] Renderer passes must not blindly restore a stale preview scrollTop after layout. If the user or another live owner moved the workspace while render work was in flight, preserve the newer scroll owner instead of snapping the preview back.
• [2026-04-06 20:24] Block-edge hover must not rebuild visible block fragments and sibling anchors on hover. Keep hover lookup O(1) from document/render-invalidated geometry caches instead of scan-and-sort work in the pointer path.
• [2026-04-06 20:31] The block editor’s pointer capture must respect the shared semantic interaction target model before treating a pointerdown as an outside click. Widget, math, and render-only targets should keep ownership of their own activation/jump paths instead of being preempted by block blur.
• [2026-04-06 20:39] Source-sync lookup should not rediscover preview candidates with fresh querySelectorAll scans on every cursor move. Build visible offset/line/block lookup snapshots from the same document/render invalidation seam and keep the hot cursor-follow path data-driven.
• [2026-04-06 20:48] Shared command chrome must actually be session-owned end to end. The format bar, top toolbar, slash launcher, palette, and block-edge affordance should not trigger generic block blur on pointerdown before their own command handlers run.
• [2026-04-06 20:56] The block-edge affordance should own the whole hit corridor between the + and the block edge so pointer travel stays inside one component. Do not use hover hide timers to fake that corridor; make the corridor real and clickable.
• [2026-04-06 23:02] Hidden block-edge affordance chrome must not remain in the hit-testing path. If the + is visually hidden, its corridor should also be pointer-events: none so invisible gutter UI cannot steal hover or clicks from the document.
• [2026-04-06 23:08] Block-edge geometry should warm on the render invalidation seam, not on first hover. Keep visibility checks and geometry snapshot rebuilding out of the hover hot path so block targeting stays immediate.
• [2026-04-06 23:27] Source-owned special surfaces must remove duplicate child edit lanes, not just hide them. Figure shells, table children, and footnote fallbacks should each have one clear source owner instead of a shell plus separately editable child widgets/lines.
• [2026-04-06 23:43] Source-owned semantic blocks should be hit-testable at the block root, not only through child line fragments. Once a block declares editorBlockEditKind="source", its root surface should own clicks across the block frame instead of leaving dead zones that depend on text child hits.
• [2026-04-06 23:57] Source-owned block ownership must outrank descendant widget, math, and render-only markers in the central semantic interaction router. Once a block declares editorBlockEditKind="source", treat all descendant projection detail as display-only for click targeting instead of letting child metadata reopen competing edit/jump lanes.
• [2026-04-06 21:17] Single-page semantic blocks with a coherent source range and frame must still publish one block-owned source shell even when rich projection fidelity checks fail. Do not bail out before setting block geometry/source ownership and leave visible text in a dead mixed state.
• [2026-04-06 21:28] Source-owned compound blocks such as tables should not instantiate nested pseudo-editor blocks and then scrub them after render. Use a real display-only projection path for child content under a source-owned container instead of “create editable block, then neuter it.”
• [2026-04-06 21:52] Source-owned tables must keep every child cell lane display-only, including styled-line fallback rendering and plain text cells. Do not rely on pointer-events: none to hide interactive child semantics that should not exist in the first place.
• [2026-04-06 21:36] Source-sync and explicit source jumps should treat source-owned blocks as the authoritative owner, not descend into child data-src-* fragments inside those blocks. Once a block owns source editing, its children are display detail, not competing navigation targets.
• [2026-04-06 21:44] Source-owned fallback blocks should render child lines as display-only. Do not leave inline math, links, source markers, or render-only affordances interactive underneath a container that already owns source editing.
• [2026-04-06] Widget and math edit anchors should also stay renderer-declared. Do not drift back toward getBoundingClientRect()-driven overlay positioning plus post-render chase loops for inline links, images, figures, or math targets.
• [2026-04-06] After the current insertion/hover blockers are fixed, run a full smell-test audit across the editor surface. Look for bolted-on behavior, contradictory pathways, laggy hover/click systems, duplicated render ownership, and any other component or interaction that does not pass a production-path sanity check.