@avocadostudio-ai/preview-adapter 0.21.1 → 0.23.0

package/NOTICE

@@ -0,0 +1,8 @@
+Avocado Studio
+Copyright 2026 Avocado Studio Contributors
+
+This product includes software developed by the Avocado Studio
+Contributors (https://www.avocadostudio.dev).
+
+Licensed under the Apache License, Version 2.0. See LICENSE for the
+full license text.

package/dist/bridge-controller.js

@@ -120,6 +120,21 @@ export function attachBridge(config) {
             }
             return;
         }
+        /*
+         * Which block types the site renders at a fixed position. The editor holds
+         * the site's manifest and the page does not, so it says so — on mount (with
+         * `setSelectionMode`, since postMessage has no buffering) and whenever the
+         * manifest changes. A selected block's controls are rebuilt at once, so a
+         * message that lands after the click still takes effect.
+         */
+        if (msg.type === "setBlockConstraints") {
+            const types = Array.isArray(msg.payload.fixedBlockTypes) ? msg.payload.fixedBlockTypes : [];
+            state.fixedBlockTypes = new Set(types.filter((type) => typeof type === "string"));
+            if (state.selectedBlockId) {
+                bridge.applyBlockFocus(state.selectedBlockId, false, state.selectedEditablePath ?? undefined, { scrollIntoView: false });
+            }
+            return;
+        }
         if (msg.type === "applyPatch") {
             if (state.serverVersion !== msg.fromVersion) {
                 emitPatchAck(msg.txId, false, "version_mismatch");

package/dist/bridge-functions.d.ts

@@ -157,6 +157,17 @@ export declare function parseListItemPath(editablePath?: string | null): {
     listKey: string;
     index: number;
 } | null;
+/**
+ * Can a text edit at this path be committed?
+ *
+ * Three shapes: a top-level field (`title`), a field of a list row
+ * (`items[1].title`), and an entry of a list of strings (`paragraphs[1]`,
+ * `kind: "stringList"`). The third was missing, so an entry marked on the page
+ * selected with the right path and then refused the double-click — the one
+ * kind of list whose rows *are* text could not be typed into. The editor writes
+ * it back as the whole list with that entry replaced, and refuses when the
+ * entry turns out to be an object rather than a string.
+ */
 export declare function supportsInlineEditablePath(editablePath: string): boolean;
 export declare function readNodeText(node: HTMLElement): string;
 export declare function placeCaretAtEnd(node: HTMLElement): void;
@@ -169,6 +180,50 @@ export declare function computeMoveAfter(blockId: string, direction: "up" | "dow
     canMove: boolean;
     afterBlockId: string | null;
 };
+/**
+ * Whether the blocks directly above and below position `idx` are fixed.
+ *
+ * Moving a block up swaps it with the one above; if that one is fixed — a
+ * section the site always draws in the same place — the swap moves the fixed
+ * block too, and the ops engine refuses it. So the button is disabled rather
+ * than offered and refused. Pure, over one flag per block in page order, so it
+ * can be tested without a DOM.
+ */
+export declare function fixedNeighborFlags(fixedFlags: readonly boolean[], idx: number): {
+    above: boolean;
+    below: boolean;
+};
+/**
+ * Does a click on a link here select the block rather than follow the link?
+ *
+ * In selection mode, yes — when the link sits in a block. The bridge used to
+ * route every same-origin link click through the preview's navigation before
+ * selection had a look, so on a site whose CTAs, nav items and footer contact
+ * details are all anchors, those could only be reached through the property
+ * panel, and a block made of nothing but links could not be selected by click
+ * at all. With selection mode off the preview is a page to browse, and links
+ * navigate as before.
+ *
+ * Chrome is the exception. A block marked `data-block-chrome` — the built-in
+ * site header and footer — is the site's navigation, drawn so that it keeps
+ * behaving like it in the editor; its links still navigate, as its other
+ * controls still work.
+ */
+export declare function linkClickSelects(target: Element, selectionModeOn: boolean): boolean;
+/**
+ * Is this block node fixed in place?
+ *
+ * The editor says which *types* are fixed — it holds the site's manifest, the
+ * page does not — with a `setBlockConstraints` message. A site may also mark a
+ * node itself with `data-block-fixed`, the way chrome is marked with
+ * `data-block-chrome`.
+ */
+export declare function isFixedBlockNode(node: HTMLElement, fixedTypes: ReadonlySet<string>): boolean;
+/** `fixedNeighborFlags` for the block on the page, in the order the page draws it. */
+export declare function fixedNeighbors(blockId: string, fixedTypes: ReadonlySet<string>, preferredNode?: HTMLElement | null): {
+    above: boolean;
+    below: boolean;
+};
 export declare function computeInsertBefore(blockId: string, preferredNode?: HTMLElement | null): {
     afterBlockId: string | null;
     beforeBlockId: string;
@@ -356,6 +411,8 @@ export type BridgeState = {
         editablePath: string;
         initialValue: string;
         isMultiline: boolean;
+        /** Overlay controls lifted out of the node for the edit — see `startInlineEdit`. */
+        liftedControls: Element[];
     } | null;
     serverVersion: number;
     liveDraftActiveBlockId: string | null;
@@ -371,6 +428,13 @@ export type BridgeState = {
         editablePath: string;
         scope: AiLoadingScope;
     } | null;
+    /**
+     * Block types the site renders at a fixed position, from the editor's
+     * `setBlockConstraints`. Such a block gets no move, delete or add controls,
+     * and its neighbours cannot be moved across it. Empty until the editor says
+     * otherwise, so an older editor changes nothing.
+     */
+    fixedBlockTypes: Set<string>;
 };
 export declare function createBridgeState(): BridgeState;
 export type BridgeFunctions = ReturnType<typeof createBridgeFunctions>;

package/dist/bridge-functions.js

@@ -421,10 +421,21 @@ export function parseListItemPath(editablePath) {
         return null;
     return { listKey: match[1], index: Number(match[2]) };
 }
+/**
+ * Can a text edit at this path be committed?
+ *
+ * Three shapes: a top-level field (`title`), a field of a list row
+ * (`items[1].title`), and an entry of a list of strings (`paragraphs[1]`,
+ * `kind: "stringList"`). The third was missing, so an entry marked on the page
+ * selected with the right path and then refused the double-click — the one
+ * kind of list whose rows *are* text could not be typed into. The editor writes
+ * it back as the whole list with that entry replaced, and refuses when the
+ * entry turns out to be an object rather than a string.
+ */
 export function supportsInlineEditablePath(editablePath) {
     if (!editablePath)
         return false;
-    if (!/^[A-Za-z_][A-Za-z0-9_]*(?:\[[0-9]+\]\.[A-Za-z_][A-Za-z0-9_]*)?$/.test(editablePath))
+    if (!/^[A-Za-z_][A-Za-z0-9_]*(?:\[[0-9]+\](?:\.[A-Za-z_][A-Za-z0-9_]*)?)?$/.test(editablePath))
         return false;
     if (/(^|\.)(?:ctaHref|secondaryCtaHref|imageUrl|imageAlt|href|url)$/i.test(editablePath))
         return false;
@@ -432,6 +443,8 @@ export function supportsInlineEditablePath(editablePath) {
         return false;
     return true;
 }
+/** What the overlay itself mounts inside a marked element, as opposed to the site's markup. */
+const OVERLAY_CHILD_SELECTOR = ".editor-list-item-controls, .editor-list-item-add, .editor-list-item-delete, .editor-list-item-move, .editor-delete-confirm";
 export function readNodeText(node) {
     /*
      * `innerText` is the *rendered* text, and this value is what gets committed
@@ -515,6 +528,69 @@ export function computeMoveAfter(blockId, direction, preferredNode) {
         return { canMove: false, afterBlockId: null };
     return { canMove: true, afterBlockId: order[idx + 1] ?? null };
 }
+/**
+ * Whether the blocks directly above and below position `idx` are fixed.
+ *
+ * Moving a block up swaps it with the one above; if that one is fixed — a
+ * section the site always draws in the same place — the swap moves the fixed
+ * block too, and the ops engine refuses it. So the button is disabled rather
+ * than offered and refused. Pure, over one flag per block in page order, so it
+ * can be tested without a DOM.
+ */
+export function fixedNeighborFlags(fixedFlags, idx) {
+    if (idx < 0 || idx >= fixedFlags.length)
+        return { above: false, below: false };
+    return {
+        above: idx > 0 && fixedFlags[idx - 1] === true,
+        below: idx < fixedFlags.length - 1 && fixedFlags[idx + 1] === true
+    };
+}
+/**
+ * Does a click on a link here select the block rather than follow the link?
+ *
+ * In selection mode, yes — when the link sits in a block. The bridge used to
+ * route every same-origin link click through the preview's navigation before
+ * selection had a look, so on a site whose CTAs, nav items and footer contact
+ * details are all anchors, those could only be reached through the property
+ * panel, and a block made of nothing but links could not be selected by click
+ * at all. With selection mode off the preview is a page to browse, and links
+ * navigate as before.
+ *
+ * Chrome is the exception. A block marked `data-block-chrome` — the built-in
+ * site header and footer — is the site's navigation, drawn so that it keeps
+ * behaving like it in the editor; its links still navigate, as its other
+ * controls still work.
+ */
+export function linkClickSelects(target, selectionModeOn) {
+    if (!selectionModeOn)
+        return false;
+    const block = target.closest("[data-block-id]");
+    if (!block)
+        return false;
+    return !(block.matches("[data-block-chrome]") || block.querySelector("[data-block-chrome]") !== null);
+}
+/**
+ * Is this block node fixed in place?
+ *
+ * The editor says which *types* are fixed — it holds the site's manifest, the
+ * page does not — with a `setBlockConstraints` message. A site may also mark a
+ * node itself with `data-block-fixed`, the way chrome is marked with
+ * `data-block-chrome`.
+ */
+export function isFixedBlockNode(node, fixedTypes) {
+    if (node.hasAttribute("data-block-fixed"))
+        return true;
+    const type = node.getAttribute("data-block-type");
+    return type !== null && fixedTypes.has(type);
+}
+/** `fixedNeighborFlags` for the block on the page, in the order the page draws it. */
+export function fixedNeighbors(blockId, fixedTypes, preferredNode) {
+    const nodes = orderedBlockNodes();
+    let idx = preferredNode && preferredNode.isConnected ? nodes.indexOf(preferredNode) : -1;
+    if (idx === -1)
+        idx = nodes.findIndex((node) => node.getAttribute("data-block-id") === blockId);
+    return fixedNeighborFlags(nodes.map((node) => isFixedBlockNode(node, fixedTypes)), idx);
+}
 export function computeInsertBefore(blockId, preferredNode) {
     const { idx, order } = blockOrderIndex(blockId, preferredNode);
     if (idx <= 0)
@@ -837,6 +913,7 @@ export function createBridgeState() {
         hoveredBlockRoot: null,
         observer: null,
         activeShimmer: null,
+        fixedBlockTypes: new Set(),
     };
 }
 /**
@@ -1089,6 +1166,7 @@ export function createBridgeFunctions(state, callbacks, config) {
         s.node.textContent = s.initialValue;
         s.node.setAttribute("contenteditable", "false");
         s.node.classList.remove("editor-inline-editing");
+        s.node.append(...s.liftedControls);
         state.inlineEditing = null;
     };
     const commitInlineEdit = () => {
@@ -1099,6 +1177,7 @@ export function createBridgeFunctions(state, callbacks, config) {
         s.node.classList.remove("editor-inline-editing");
         state.inlineEditing = null;
         const nextValue = readNodeText(s.node);
+        s.node.append(...s.liftedControls);
         if (nextValue === s.initialValue)
             return;
         callbacks.onInlineTextCommitted({ slug, blockId: s.blockId, blockType: s.blockType, editablePath: s.editablePath, value: nextValue });
@@ -1108,13 +1187,22 @@ export function createBridgeFunctions(state, callbacks, config) {
             return;
         if (!isInlineEditable(args.node))
             return;
-        if (args.node.children.length > 0)
+        if (Array.from(args.node.children).some((child) => !child.matches(OVERLAY_CHILD_SELECTOR)))
             return;
         const existing = state.inlineEditing;
         if (existing?.node === args.node)
             return;
         if (existing)
             commitInlineEdit();
+        /*
+         * A `stringList` entry is both the field and its list row, so the row's
+         * move/delete/add controls are mounted *inside* the text being edited.
+         * Lift them out for the edit — typed into, a select-all deletes them, and
+         * the value read back would include them — and put them back after.
+         */
+        const liftedControls = Array.from(args.node.children);
+        for (const control of liftedControls)
+            control.remove();
         const initialValue = readNodeText(args.node);
         state.inlineEditing = {
             node: args.node,
@@ -1122,7 +1210,8 @@ export function createBridgeFunctions(state, callbacks, config) {
             blockType: args.blockType,
             editablePath: args.editablePath,
             initialValue,
-            isMultiline: isMultilineEditable(args.node, args.editablePath)
+            isMultiline: isMultilineEditable(args.node, args.editablePath),
+            liftedControls
         };
         args.node.setAttribute("contenteditable", "true");
         args.node.classList.add("editor-inline-editing");
@@ -1142,6 +1231,9 @@ export function createBridgeFunctions(state, callbacks, config) {
         const blockType = selected.getAttribute("data-block-type") ?? "Block";
         if (!blockId)
             return;
+        // A block the site renders in a fixed place cannot be deleted.
+        if (isFixedBlockNode(selected, state.fixedBlockTypes))
+            return;
         const del = document.createElement("button");
         del.type = "button";
         del.className = "editor-selected-delete";
@@ -1487,14 +1579,17 @@ export function createBridgeFunctions(state, callbacks, config) {
         moveUpBtn.setAttribute("data-tooltip", "Move up");
         moveUpBtn.innerHTML = '<svg viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="m5 12 7-7 7 7"/><path d="M12 19V5"/></svg>';
         const upResult = computeMoveAfter(blockId, "up", match);
-        moveUpBtn.disabled = !upResult.canMove;
+        const fixedAround = fixedNeighbors(blockId, state.fixedBlockTypes, match);
+        moveUpBtn.disabled = !upResult.canMove || fixedAround.above;
         if (!upResult.canMove)
             moveUpBtn.setAttribute("data-tooltip", "Already at the top");
+        else if (fixedAround.above)
+            moveUpBtn.setAttribute("data-tooltip", "The block above is fixed in place");
         moveUpBtn.addEventListener("click", (event) => {
             event.preventDefault();
             event.stopPropagation();
             const move = computeMoveAfter(blockId, "up", match);
-            if (!move.canMove)
+            if (!move.canMove || fixedNeighbors(blockId, state.fixedBlockTypes, match).above)
                 return;
             state.pendingScrollAnchorY = match.getBoundingClientRect().top;
             state.pendingScrollIntoView = true;
@@ -1507,14 +1602,16 @@ export function createBridgeFunctions(state, callbacks, config) {
         moveDownBtn.setAttribute("data-tooltip", "Move down");
         moveDownBtn.innerHTML = '<svg viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="m19 12-7 7-7-7"/><path d="M12 5v14"/></svg>';
         const downResult = computeMoveAfter(blockId, "down", match);
-        moveDownBtn.disabled = !downResult.canMove;
+        moveDownBtn.disabled = !downResult.canMove || fixedAround.below;
         if (!downResult.canMove)
             moveDownBtn.setAttribute("data-tooltip", "Already at the bottom");
+        else if (fixedAround.below)
+            moveDownBtn.setAttribute("data-tooltip", "The block below is fixed in place");
         moveDownBtn.addEventListener("click", (event) => {
             event.preventDefault();
             event.stopPropagation();
             const move = computeMoveAfter(blockId, "down", match);
-            if (!move.canMove)
+            if (!move.canMove || fixedNeighbors(blockId, state.fixedBlockTypes, match).below)
                 return;
             state.pendingScrollAnchorY = match.getBoundingClientRect().top;
             state.pendingScrollIntoView = true;
@@ -1552,17 +1649,24 @@ export function createBridgeFunctions(state, callbacks, config) {
         const effectivePath = editablePath ?? (previousSelectedBlockId === blockId ? previousEditablePath ?? undefined : undefined);
         const isChromeBlock = match.querySelector("[data-block-chrome]") !== null || match.matches("[data-block-chrome]");
         if (!isChromeBlock) {
-            // Move buttons live inside the floating badge above the block so they
-            // don't overlap block content. mountSelectedDeleteHandle does the same.
-            const badge = match.querySelector(":scope > .editor-block-badge");
-            if (badge) {
-                badge.append(moveUpBtn, moveDownBtn);
-            }
-            else {
-                match.prepend(moveUpBtn, moveDownBtn);
+            /*
+             * A fixed block — a section the site always draws in the same place —
+             * gets no move, delete or add controls: every one of them could only end
+             * in a refusal. Its list rows and fields are still edited as usual.
+             */
+            if (!isFixedBlockNode(match, state.fixedBlockTypes)) {
+                // Move buttons live inside the floating badge above the block so they
+                // don't overlap block content. mountSelectedDeleteHandle does the same.
+                const badge = match.querySelector(":scope > .editor-block-badge");
+                if (badge) {
+                    badge.append(moveUpBtn, moveDownBtn);
+                }
+                else {
+                    match.prepend(moveUpBtn, moveDownBtn);
+                }
+                match.prepend(addTopBtn);
+                match.append(addBtn);
             }
-            match.prepend(addTopBtn);
-            match.append(addBtn);
             mountListItemDeleteHandles(match, blockId);
             mountSelectedDeleteHandle();
         }
@@ -1695,8 +1799,16 @@ export function createBridgeFunctions(state, callbacks, config) {
         // Only hijack plain-modifier, same-tab, same-origin, non-download clicks —
         // modifier-clicks, target=_blank, downloads, mailto/tel/hash, and
         // cross-origin links fall through to their default behavior.
+        //
+        // Unless selection mode is on and the link is in a block: then the click
+        // is a selection, and the link must not be followed by anybody — not the
+        // router, not the browser. See `linkClickSelects`.
         const anchor = target?.closest("a");
-        if (anchor &&
+        const selectsInstead = !!anchor && !!target && linkClickSelects(target, document.documentElement.hasAttribute("data-editor-selection-mode"));
+        if (selectsInstead) {
+            event.preventDefault();
+        }
+        else if (anchor &&
             event.button === 0 &&
             !event.metaKey && !event.ctrlKey && !event.shiftKey && !event.altKey &&
             (!anchor.target || anchor.target === "_self") &&
@@ -1928,6 +2040,13 @@ export function createBridgeFunctions(state, callbacks, config) {
         const result = computeMoveAfter(blockId, direction, selectedNode);
         if (!result.canMove)
             return;
+        // The same rules as the buttons: a fixed block does not move, and nothing
+        // moves across one.
+        if (selectedNode && isFixedBlockNode(selectedNode, state.fixedBlockTypes))
+            return;
+        const fixedAround = fixedNeighbors(blockId, state.fixedBlockTypes, selectedNode);
+        if (direction === "up" ? fixedAround.above : fixedAround.below)
+            return;
         event.preventDefault();
         event.stopPropagation();
         state.pendingScrollIntoView = true;

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export { PreviewBridge } from "./preview-bridge.tsx";
 export { PreviewBridgeCore } from "./preview-bridge-core.tsx";
 export type { PreviewBridgeConfig, PreviewBridgeCoreProps } from "./preview-bridge-core.tsx";
 export { getPreviewWrapperProps } from "./selectable.ts";
-export { createBridgeFunctions, createBridgeState, findBlockNode, findEditableNode, scrollBlockIntoView, parseListItemPath, supportsInlineEditablePath, readNodeText, placeCaretAtEnd, orderedBlockNodes, blockOrderIndex, computeMoveAfter, computeInsertBefore, groupListItemNodes, commonItemRoot, markdownToHtml, withPreviewParams, setNestedLabelsVisibility, clearChildFocus, clearListItemSelection, removeOverlayControls, clearAllHighlights, showSkeleton, removeSkeletons, ensureBlockBadges, applyAiFieldLoading, clearAiFieldLoading, isAiFieldLoadingApplied, cleanupOverlayElements, isImageEditable, isInlineEditable, isMultilineEditable, missingBlockWrapperWarning, previewIntegrationWarnings, } from "./bridge-functions.ts";
+export { createBridgeFunctions, createBridgeState, findBlockNode, findEditableNode, scrollBlockIntoView, parseListItemPath, supportsInlineEditablePath, linkClickSelects, readNodeText, placeCaretAtEnd, orderedBlockNodes, blockOrderIndex, computeMoveAfter, computeInsertBefore, groupListItemNodes, commonItemRoot, markdownToHtml, withPreviewParams, setNestedLabelsVisibility, clearChildFocus, clearListItemSelection, removeOverlayControls, clearAllHighlights, showSkeleton, removeSkeletons, ensureBlockBadges, applyAiFieldLoading, clearAiFieldLoading, isAiFieldLoadingApplied, cleanupOverlayElements, isImageEditable, isInlineEditable, isMultilineEditable, missingBlockWrapperWarning, previewIntegrationWarnings, } from "./bridge-functions.ts";
 export type { AiLoadingScope, BridgeCallbacks, BridgeState, BridgeFunctions } from "./bridge-functions.ts";
 export { LivePreviewProvider, useLivePreviewBlocks, useLivePreviewBridgeApi, } from "./live-preview-store.tsx";
 export type { LivePreviewPage, LivePreviewBridgeApi } from "./live-preview-store.tsx";

package/dist/index.js

@@ -1,5 +1,5 @@
 export { PreviewBridge } from "./preview-bridge.js";
 export { PreviewBridgeCore } from "./preview-bridge-core.js";
 export { getPreviewWrapperProps } from "./selectable.js";
-export { createBridgeFunctions, createBridgeState, findBlockNode, findEditableNode, scrollBlockIntoView, parseListItemPath, supportsInlineEditablePath, readNodeText, placeCaretAtEnd, orderedBlockNodes, blockOrderIndex, computeMoveAfter, computeInsertBefore, groupListItemNodes, commonItemRoot, markdownToHtml, withPreviewParams, setNestedLabelsVisibility, clearChildFocus, clearListItemSelection, removeOverlayControls, clearAllHighlights, showSkeleton, removeSkeletons, ensureBlockBadges, applyAiFieldLoading, clearAiFieldLoading, isAiFieldLoadingApplied, cleanupOverlayElements, isImageEditable, isInlineEditable, isMultilineEditable, missingBlockWrapperWarning, previewIntegrationWarnings, } from "./bridge-functions.js";
+export { createBridgeFunctions, createBridgeState, findBlockNode, findEditableNode, scrollBlockIntoView, parseListItemPath, supportsInlineEditablePath, linkClickSelects, readNodeText, placeCaretAtEnd, orderedBlockNodes, blockOrderIndex, computeMoveAfter, computeInsertBefore, groupListItemNodes, commonItemRoot, markdownToHtml, withPreviewParams, setNestedLabelsVisibility, clearChildFocus, clearListItemSelection, removeOverlayControls, clearAllHighlights, showSkeleton, removeSkeletons, ensureBlockBadges, applyAiFieldLoading, clearAiFieldLoading, isAiFieldLoadingApplied, cleanupOverlayElements, isImageEditable, isInlineEditable, isMultilineEditable, missingBlockWrapperWarning, previewIntegrationWarnings, } from "./bridge-functions.js";
 export { LivePreviewProvider, useLivePreviewBlocks, useLivePreviewBridgeApi, } from "./live-preview-store.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avocadostudio-ai/preview-adapter",
-  "version": "0.21.1",
+  "version": "0.23.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,10 +34,12 @@
   },
   "files": [
     "dist",
-    "src/styles.css"
+    "src/styles.css",
+    "LICENSE",
+    "NOTICE"
   ],
   "dependencies": {
-    "@avocadostudio-ai/shared": "^0.21.1"
+    "@avocadostudio-ai/shared": "^0.23.0"
   },
   "peerDependencies": {
     "next": ">=15.0.0",

package/src/styles.css

@@ -312,13 +312,15 @@
   position: absolute;
   inset: 0;
   background: var(--aifx-sweep);
-  transform: translateX(120%);
+  transform: translateX(-120%);
   animation: aifx-shimmer-slide 2.9s cubic-bezier(0.4, 0, 0.2, 1) infinite;
 }
 
+/* Left to right, the direction text is read in — and the direction every
+   other shimmer in the editor already ran. */
 @keyframes aifx-shimmer-slide {
-  0% { transform: translateX(120%); }
-  100% { transform: translateX(-120%); }
+  0% { transform: translateX(-120%); }
+  100% { transform: translateX(120%); }
 }
 
 /* Fixed, so it frames what the user is looking at wherever they scroll. */
@@ -403,7 +405,7 @@ body:has(.aifx-shimmer-overlay) > .aifx-page-shimmer::before {
     animation: none !important;
   }
 
-  /* A stopped sweep rests off-canvas at translateX(120%), which left nothing
+  /* A stopped sweep rests off-canvas at translateX(-120%), which left nothing
      on screen at all. Hold a still tint instead; the page frame's border
      already reads without motion. */
   .aifx-shimmer-overlay::before {