The model mangles Markdown it can see (Seed-X dropped the ** and the
glued-on colon in '**Pagerite**: ...'), so emphasis now crosses stripped,
inline in its sentence, and the syntax is weight-mapped back like links.
Also fix _place_marks swallowing trailing punctuation into the inner text
(end at the slice's last unit) — same-language round trips are now exact.
- Node.language sets an article's primary language, inherited down the
hierarchy, configured per row in the structure tab; English is now a
regular language in the lang tab, still the root fallback
- Flags map a base tag to the language's home country (en → GB,
pt → PT); explicit variant tags resolve their own region
- Lang tab flag grid: geographic group rows, shading-only selection
- ConnNote.vue: a status strip for the WebSocket-backed panels (page and
banner editors, analytics view) — "connecting…" while the socket is
pending (the staggered slot included), "reconnecting in ~N s…" during
backoff, hidden once open. A pending/lost socket no longer reads as a
silently empty or stale panel.
- PageEditor/BannerEditor: CodeMirror stays non-editable until the
page/banner doc has been accepted — typing before it would be clobbered
by the accept. A mere disconnect keeps the editor live: text stashes
and pending saves flush on reconnect.
- LangSelect.vue: one language selector for the page and structure tabs
(small flag, clean dropdown), v-modeled on the shell-wide editorLang —
switching in either panel switches both AND the page preview. While the
panel is open the selection overrides the normal language preferences
(swapdoc.setLangOverride: loadPlain and pagerite.js fetches/prefetches
pin ?lang=, the primary language by its own code); closing restores.
- reconnect.js: every socket (page/banner editors, analytics view, the
activity channel) now connects through a staggered slot — simultaneous
attempts at page load (Vite's HMR socket plus ours, repeated on every
refresh) trip the browser's WebSocket throttling, leaving all sockets
to the host "pending" for minutes, which was the recurring empty
editor. A watchdog closes sockets stuck CONNECTING so they reschedule
through the policy (jittered exponential backoff, reset only by a
healthy connection) instead of hanging forever; a reconnected editor
re-opens its document when the previous open died with its socket.
- segments.py: a block of plain text with inline links now stays ONE wire
segment (Mark/Span) — the link label crosses in sentence context, so
translations come back grammatically coherent instead of incompatible
snippets. join() re-inserts the link markdown into the translated block
at weight-mapped positions (word units; CJK ideographs and kana runs
count one unit each), degrading to the source label on empty slices and
still rejecting markup injection. No sentinels on the wire: boundaries
are found by text processing alone.
- translate.py: the Dispatcher tracks Span (offsets + link marks) for the
in-flight job.
- pagerite/segments.py replaces masking.py: a fragment is parsed with the
project's own markdown-it (markdown.make_md(verbatim=True), byte-identical
tokens) and split into pure-prose segments with source spans; only the
segments plus per-segment context surrounds cross the wire (Job.texts /
contexts / Result.texts) and translations splice back by offset — markup
can no longer break, it never leaves the server. Count/empty/non-prose
results are rejected and skipped for the run.
- Localization machinery out of app.py: the translator dispatcher (clients,
job pipeline, validation skip-list) moves into translate.Dispatcher;
translated-edit recording moves into i18n (add_patch, set_title_translation,
clear_translations). app.py keeps only the routes.
- Structure editor localized: flag strip switches the language titles are
shown/edited in (GET /_api/pages?lang= flags translated rows, originals
dimmed); retitling in a translation writes a per-language title fragment
via StructureOp.lang — slugs, order and hierarchy stay language-independent.
- Localization tab: refresh-all button (DELETE /_api/translations) drops
machine translations, keeps user patches and clears the skip-list so the
dispatcher re-translates everything.
- PageEditor always opens in the primary language; editor socket gets
reconnect/doc-mismatch logging. Reference translator: per-segment calls
with context prompts, deterministic punctuation matching and the "<"
markup-bleed cut.
- New editor-shell tab (lang): translatable languages as clickable flag
tiles (shared langs.js mapping of the 28 Seed-X languages to flags),
saved via the settings round-trip; translator service URL(s) shown.
- Bootstrap seeds translate_langs with Spanish and Chinese (the original
language is never a target).
- GET /_api/settings also returns primary_lang.
- PageEditor's flag/name helpers move to the shared langs.js.
- pagerite/masking.py: technical spans (code, URLs, {placeholders}, attrs,
footnote/link labels, container names, HTML tags) become numbered sentinels
for the LLM round trip; results are restored by number and rejected when a
sentinel is mangled (skipped for the rest of the run, stays pending).
Chunks with no prose left after masking are never dispatched.
- Data.translate_key -> translate_keys dict (key -> name); the first key is
generated at bootstrap, result transactions record the key as user=, and
startup logs the service URL(s) via translate.log_service_urls.
- Fix /_translate proxying through the Vite dev server (missing slash).
- Server replicates a ?lang= override onto the navigation links it
renders (nav, sidebar, cards, brand), so clicks and prefetches stay in
the chosen language even without JS; link_lang is part of the ETag and
body cache key (query and header renders of the same language differ
in their links).
- pagerite.js drops the Accept-Language header hack: the remembered
language rides internal fetches as ?lang= instead (added when a link
lacks one), the page cache keys on path+query, and history/address bar
keep the pretty query-less URL.
- Canonical names the actually served language (plain URL for the
original, ?lang= for translations); hreflang alternates are site-wide
from translate_langs, identical on every page: x-default (the plain
autodetecting URL) first, then every language explicitly, default
included, emitted right after canonical before the social tags.
- pagerite/i18n.py: parse_accept_language, select_language, Translation struct,
get_translation/available_languages stubs
- app.py: language threaded through show_page/_render_html/_cached_body,
ETag and Vary: accept-language
- views.py: <html lang>, translated nav titles with fallback, canonical
with ?lang=, hreflang alternates
- pagerite.js: strip ?lang= via replaceState, send it as Accept-Language
on fetch-navigation/preloads, lang-aware page cache
- docs/localization.md: negotiation + URL scheme + phase-2 fragment model
- docs/migrate.md: migrate_v3 content-addressed chunk storage plan
Clicking a figure image opens a full-viewport overlay: the image as
large as fits (100vw, flex-shrunk to leave exactly the caption's
height) with the caption below. Click or any key closes it; wheel and
touch scrolling stop at the overlay (overscroll-behavior: contain).
Styling lives in the base theme: blurred dark backdrop (theme-tunable
via --lightbox-bg / --lightbox-text), soft shadow, reduced-motion-aware
open animation.
::: aside / .margin blocks no longer split the column segments: they
stay inside the .colseg at their anchor point, so the surrounding text
is measured and laid out as a single columned layout (split-off sides
previously lost .cols when too short on their own).
The zone placements (multicol side zone, sidebar track, wide gutter)
now position the boxes absolutely off the article's left border —
unaffected by any column layout inside — with the vertical spot coming
from the unset top (where the box occurs in the text). Narrow widths
keep the in-column float fallback. Trade-off: out-of-flow boxes no
longer stack via clear, so boxes anchored close together may overlap.
migrate_v1 now also rebuilds the legacy flat pages store as the menu
tree (moved from the app lifespan, raw-dict level); migrate_v2 now also
backfills missing AVIF/WebP/JPEG derivatives on disk (moved from the
lifespan) and drops the obsolete version field. The version render
counter was cache-invalidation state, not database state: replaced by an
in-memory render generation that clears the page-body LRU and feeds page
ETags. The legacy Page struct and Data.pages/version fields are removed;
old databases lose the stale keys on re-serialization.
Uploaded images (SVGs rasterized, GIFs excepted) are stored as the
original (hash.orig.ext, internal only, never served) plus AVIF primary
and WebP/JPEG fallback derivatives re-encoded from it. Pages link the
bare hash; the server serves a format only when Accept lists it
explicitly (image/avif -> AVIF, image/webp -> WebP, else JPEG) with
vary: accept, while an explicit extension pins the format. Favicons go
through the same pipeline at 192px. migrate_v2 rewrites old
/_f/{hash}.avif article links, a startup backfill creates missing
derivatives, and twitter:image pins the .webp variant for X's scraper.
uploadImage and insertTable no longer inject at the cursor: on a
non-empty line (e.g. inside an existing image tag) the block goes on a
fresh blank-separated line after it, never into it.
PUT /_api/files now runs raster uploads through mediapreview.dispatch
(temp file for format routing: pyvips, ffmpeg for HEIC/HEIF/AVIF),
storing the untouched original as <hash>.orig<ext> and serving the
AVIF derivative <hash>.avif in links. SVG/GIF and failed conversions
fall back to plain <hash><ext> storage. FileStore.delete removes the
whole hash pair. Adds mediapreview[standard] dependency.
Cursor-driven editor→page scroll sync pinned the cursor's page position
at a fixed window height, so every cursor move dragged the page along.
Now the page scrolls only when the cursor's mapped position crosses a
viewport edge margin, and just enough to bring it back inside.
- Image insert always adds an empty "" caption with the cursor inside.
- Fenced blocks (``` code, ::: aside) share one toggle: clicked inside
one it is removed and the content selected; otherwise the selection
(expanded to whole lines) is wrapped, cursor left on the opener line.
- Code button: inline wrap toggles (selection preserved, backtick runs),
line-spanning selections make fenced blocks.
- Link button toggles: clicked inside [label](url) it unwraps.
- Block classes via two pickers (placement, AA size) with current-class
indication and a "normal" reset; placement replaces ::: container
names, fences get their own attribute line.
- New .small/.large/.huge text-size classes (0.7/1.5/3em); base body is
exactly 1rem so the scale is uniform.
- .left/.right floats generalized from figures to any block.
- Toolbar polish: non-emoji glyphs, scaled-up symbols, borderless
hover/active states, reordered (B/i and size last).
- Editor panel no longer closes on Escape.
- CodeMirror editors capture Tab/Shift-Tab for indent/dedent.
_block_attrs now applies a trailing {...} to the block when it ends the
last text line after whitespace (some text {.small}), not only on a line
of its own; a space is what keeps the braces off an image/link ending the
line. Glued-to-text braces stay literal.
The cube view-transition block moves out of pagerite.css into transition
designs (pagerite/themes/{name}/transition.css), handled like banner
designs: served from disk at /_themes/..., injected by the backend as
#pagerite-transition after the banner sheet, and picked site-wide in the
site settings (Data.transition, default cube; GET/PUT /_api/settings
carry transition + the designs found on disk). The site editor swaps the
sheet in place on change; the dev-mode order fixup knows the new id.
Designs: cube (unchanged), crossfade (all navigations), slide (sideways,
both pages moving together) and reveal (clip-path wipe over the
stationary old page) — the latter two mirrored on history-back and
crossfading within a section like cube.
Also compress the site settings form into a two-column grid: site name +
favicon on one row, theme + transition on the next.
Anchored h1/h2s carry data-line (markdown source line, top-level
headings only) and h2s get dimmed section pens that open the page
editor at that section. Editor scroll sync is now piecewise-linear
keyed on those anchors: the page follows the cursor (fractional,
wrap-aware, fixed window anchor; editor scroll no longer drives it),
the editor follows page scroll with a progress-based viewport anchor,
so document ends line up exactly in both directions. The editor always
follows the URL — fetch-navigation retargets it — with unsaved text
stashed per path for the session and restored on return. Banner pen
removed (the tab stays in the shell); top-right order is now
analytics, site settings, login/logout.
Long-enough articles (3+ in-body h1/h2) get slug ids (python-slugify,
mirroring the editor's slugify.js) and the heading text becomes a
self-link (a.anchor) for clean link copying; {#id} always wins,
duplicates get -2/-3 suffixes, h3+ never. The implicit page title is
now injected as '# {title}' into the markdown (render(title=...)), so
it takes the same first-h1 path as an explicit one: no id, href=""
self-link scrolling to top, not counted toward the threshold. The
.body wrapper is gone — segments are direct article children — and the
editor preview swaps the whole article in one go. pagerite.js tracks
the reading position in the location hash (last tagged heading above
the viewport middle; cleared at the top, never on unscrollable pages)
and scrolls to anchors after fetch-navigation.
The first positional CLI argument (default localhost) names the site's
public hostname and its data directory under the cwd, replacing the
CWD-relative pagerite.* files. The public origin (https://<hostname>)
is now authoritative configuration instead of a value learned from
admin browsers: POST /_api/site-url, Data.site_url and the pagerite.js
reporter are removed, and page rendering, sitemap, robots.txt and
analytics own_origin all use SITE_URL consistently (localhost falls
back to the request's base URL).
render() now segments the body into .colseg wrappers and flags .multicol
itself, replacing the fragile colseg injection in pagerite.js. Columns
are capped at two; shrink-wrapped figures left-align inside columns.
New {.margin} breakout (and ::: aside) drops blocks into the left gutter
on wide viewports, falling back to in-column floats.
LeoVasanko