@multiplatform.one/theme 7.63.4 → 7.64.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiplatform.one/theme",
-  "version": "7.63.4",
+  "version": "7.64.0",
   "description": "Tamagui theme system for multiplatform.one",
   "keywords": [
     "multiplatform",
@@ -72,8 +72,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@multiplatform.one/platform": "^7.63.4",
-    "@multiplatform.one/store": "^7.63.4",
+    "@multiplatform.one/platform": "^7.64.0",
+    "@multiplatform.one/store": "^7.64.0",
     "@tamagui/animations-react-native": "2.7.6",
     "@tamagui/colors": "2.7.6",
     "@tamagui/config": "2.7.6",
@@ -89,8 +89,8 @@
   },
   "devDependencies": {
     "@expo/prebuild-config": "55.0.18",
-    "@multiplatform.one/config": "7.63.4",
-    "@multiplatform.one/test-utils": "7.63.4",
+    "@multiplatform.one/config": "7.64.0",
+    "@multiplatform.one/test-utils": "7.64.0",
     "@tamagui/animations-css": "2.7.6",
     "@tamagui/animations-reanimated": "2.7.6",
     "@tamagui/font-inter": "2.7.6",

package/src/keyboardFocusRing.openFocus.spec.ts

@@ -0,0 +1,96 @@
+/**
+ * FZ-7944 round 2, LC-71: an overlay's open focus paints a ring only when the
+ * open came from the keyboard. Any other open lands on the frame, except a
+ * mouse open with a first text field, which takes the caret.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { ensureKeyboardModalityTracking, focusOnOpen } from "./keyboardFocusRing";
+
+function pointer(pointerType: "mouse" | "touch" | "pen") {
+  const event = new Event("pointerdown", { bubbles: true });
+  Object.defineProperty(event, "pointerType", { value: pointerType });
+  document.body.dispatchEvent(event);
+}
+
+function key() {
+  document.body.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
+}
+
+function overlay(tag: "button" | "input", type?: string) {
+  const frame = document.createElement("div");
+  frame.tabIndex = -1;
+  const target = document.createElement(tag);
+  if (type) target.setAttribute("type", type);
+  frame.append(target);
+  document.body.append(frame);
+  const focus = { frame: vi.spyOn(frame, "focus"), target: vi.spyOn(target, "focus") };
+  return { frame, target, focus };
+}
+
+describe("focusOnOpen (LC-71, FZ-7944)", () => {
+  beforeEach(() => ensureKeyboardModalityTracking());
+  afterEach(() => {
+    document.body.replaceChildren();
+  });
+
+  it("a keyboard open focuses the first control and paints its ring", () => {
+    key();
+    const { frame, target, focus } = overlay("button");
+    expect(focusOnOpen(target, frame)).toBe(target);
+    expect(focus.target).toHaveBeenCalledWith({ preventScroll: true, focusVisible: true });
+  });
+
+  it("a keyboard open still puts the caret in the first field", () => {
+    key();
+    const { frame, target, focus } = overlay("input");
+    expect(focusOnOpen(target, frame)).toBe(target);
+    expect(focus.target).toHaveBeenCalledWith({ preventScroll: true, focusVisible: true });
+  });
+
+  it("a mouse open lands on the frame, so the first button never rings", () => {
+    pointer("mouse");
+    const { frame, target, focus } = overlay("button");
+    expect(focusOnOpen(target, frame)).toBe(frame);
+    expect(focus.target).not.toHaveBeenCalled();
+    expect(focus.frame).toHaveBeenCalledWith({ preventScroll: true, focusVisible: false });
+  });
+
+  it("a mouse open puts the caret in a first text field", () => {
+    pointer("mouse");
+    const { frame, target, focus } = overlay("input");
+    expect(focusOnOpen(target, frame)).toBe(target);
+    expect(focus.target).toHaveBeenCalledWith({ preventScroll: true, focusVisible: false });
+  });
+
+  it("a touch open lands on the frame, not a text field, so no keyboard rises", () => {
+    pointer("touch");
+    const { frame, target, focus } = overlay("input");
+    expect(focusOnOpen(target, frame)).toBe(frame);
+    expect(focus.target).not.toHaveBeenCalled();
+    expect(focus.frame).toHaveBeenCalledWith({ preventScroll: true, focusVisible: false });
+  });
+
+  it("a touch open lands on the frame for a non-text control too", () => {
+    pointer("touch");
+    const { frame, target, focus } = overlay("input", "checkbox");
+    expect(focusOnOpen(target, frame)).toBe(frame);
+    expect(focus.target).not.toHaveBeenCalled();
+  });
+
+  it("a frame without a tabindex is made focusable, so it can take the open", () => {
+    pointer("mouse");
+    const { frame, target } = overlay("button");
+    frame.removeAttribute("tabindex");
+    expect(focusOnOpen(target, frame)).toBe(frame);
+    expect(frame.getAttribute("tabindex")).toBe("-1");
+    expect(document.activeElement).toBe(frame);
+  });
+
+  it("with nothing focusable the frame takes focus", () => {
+    pointer("mouse");
+    const frame = document.createElement("div");
+    frame.tabIndex = -1;
+    document.body.append(frame);
+    expect(focusOnOpen(null, frame)).toBe(frame);
+  });
+});

package/src/keyboardFocusRing.ts

@@ -11,6 +11,7 @@
  */
 
 let lastInputWasKeyboard = false;
+let lastPointerWasTouch = false;
 let hooked = false;
 
 /**
@@ -22,7 +23,14 @@ export function ensureKeyboardModalityTracking() {
   if (hooked || typeof document === "undefined") return;
   hooked = true;
   document.addEventListener("keydown", () => (lastInputWasKeyboard = true), true);
-  document.addEventListener("pointerdown", () => (lastInputWasKeyboard = false), true);
+  document.addEventListener(
+    "pointerdown",
+    (event) => {
+      lastInputWasKeyboard = false;
+      lastPointerWasTouch = event.pointerType === "touch";
+    },
+    true,
+  );
 }
 
 /**
@@ -36,6 +44,35 @@ export function wasKeyboardFocus(): boolean {
   return lastInputWasKeyboard;
 }
 
+function isTextEntry(node: HTMLElement): boolean {
+  if (node.isContentEditable || node.tagName === "TEXTAREA") return true;
+  if (node.tagName !== "INPUT") return false;
+  const type = (node as HTMLInputElement).type;
+  return !["button", "checkbox", "color", "file", "radio", "range", "reset", "submit"].includes(
+    type,
+  );
+}
+
+/**
+ * An overlay's open focus (LC-71, FZ-7944). Only a keyboard open lands on a
+ * control and rings it. Any other open (pointer, touch, mounted open) lands on
+ * the frame, which paints no ring: Chromium ignores `focusVisible: false` and
+ * rings a control focused before any input. A mouse open still puts the caret
+ * in a first text field, which shows LC-133's border; a touch open does not,
+ * so the keyboard does not rise over a sheet the user only looked at. A frame
+ * without a tabindex gets -1, or its focus() is a no-op and the browser's
+ * own pick stays. Returns the node that took focus.
+ */
+export function focusOnOpen(target: HTMLElement | null, frame: HTMLElement): HTMLElement {
+  ensureKeyboardModalityTracking();
+  const keyboard = lastInputWasKeyboard;
+  const caret = target !== null && isTextEntry(target) && !lastPointerWasTouch;
+  const node = target && (keyboard || caret) ? target : frame;
+  if (node === frame && !frame.hasAttribute("tabindex")) frame.tabIndex = -1;
+  node.focus({ preventScroll: true, focusVisible: keyboard } as FocusOptions);
+  return node;
+}
+
 import { FOCUS_VISIBLE_RING_INSET } from "./theme/focusState";
 
 /**

package/src/theme/createThemes.ts

@@ -700,6 +700,55 @@ const childrenHues = [
   "gray",
 ] as const;
 
+/**
+ * FZ-7944 round 2, LC-71: the keyboard ring is the accent, never a white or
+ * black neutral. A hue scope rings in its own accent ink. The roots, whose
+ * house accent is the neutral inverse, ring in the blue scope's ink, the
+ * default accent on Apple platforms. Solid accent sub-themes keep the on-fill
+ * ring they paint for content inside the fill.
+ */
+function holdFocusRingAccent(
+  themes: Record<string, Record<string, string>>,
+): Record<string, Record<string, string>> {
+  const out: Record<string, Record<string, string>> = { ...themes };
+  for (const scheme of ["light", "dark"] as const) {
+    const base = themes[scheme];
+    if (!base) continue;
+    const grounds = [base.color1, base.color2].map(luminanceOf);
+    if (grounds.some((lum) => lum === null)) continue;
+    const holds = (color: string | undefined): color is string => {
+      const lum = luminanceOf(color);
+      return (
+        lum !== null &&
+        isChromatic(color) &&
+        grounds.every((ground) => contrastRatio(lum, ground as number) >= minContrastRatio)
+      );
+    };
+    const rootRing = [base.accentColor, themes[`${scheme}_blue`]?.accentColor].find(holds);
+    for (const [name, theme] of Object.entries(themes)) {
+      if (name !== scheme && !name.startsWith(`${scheme}_`)) continue;
+      if (theme.outlineColor === undefined) continue;
+      const parts = name.split("_");
+      if (parts.includes("accent")) continue;
+      const hue = (childrenHues as readonly string[]).includes(parts[1] ?? "")
+        ? parts[1]
+        : undefined;
+      const scopeInk = hue ? themes[`${scheme}_${hue}`]?.accentColor : undefined;
+      const ring = holds(scopeInk) ? scopeInk : rootRing;
+      if (!ring || ring === theme.outlineColor) continue;
+      out[name] = { ...theme, outlineColor: ring };
+    }
+  }
+  return out;
+}
+
+function isChromatic(color: string | undefined): boolean {
+  const hex = color ? normalizeToHex(color) : null;
+  if (!hex) return false;
+  const channels = [1, 3, 5].map((index) => Number.parseInt(hex.slice(index, index + 2), 16));
+  return Math.max(...channels) - Math.min(...channels) >= 24;
+}
+
 export function createThemesBuilder(
   baseTheme: BaseThemeBuilderDefinition,
   accentTheme: ThemeBuilderDefinition,
@@ -769,12 +818,14 @@ export function createThemesBuilder(
   const initialTheme = tamaguiCreateThemes(
     createThemesProps as Parameters<typeof tamaguiCreateThemes>[0],
   );
-  const themes = holdColorThemeAccent(
-    holdSwitchTrack(
-      holdSyntaxFloor(
-        holdNamedInkFloor(
-          holdSelectedState(
-            holdAccentFloor(neutralizeSemanticEntryText(neutralizeTintText(initialTheme))),
+  const themes = holdFocusRingAccent(
+    holdColorThemeAccent(
+      holdSwitchTrack(
+        holdSyntaxFloor(
+          holdNamedInkFloor(
+            holdSelectedState(
+              holdAccentFloor(neutralizeSemanticEntryText(neutralizeTintText(initialTheme))),
+            ),
           ),
         ),
       ),

package/src/theme/focusState.spec.ts

@@ -28,13 +28,13 @@ import { defaultKnobs } from "./knobs";
 import { resolveKnobs } from "./resolveKnobs";
 
 describe("focusState tokens (DG-A11Y-01 / DG-STATE-01 / W12)", () => {
-  it("FOCUS_VISIBLE_RING meets ≥2px solid outline contract at offset 0 (F1)", () => {
+  it("FOCUS_VISIBLE_RING meets ≥2px solid outline contract at offset +2 (FZ-7944)", () => {
     expect(FOCUS_VISIBLE_RING.outlineWidth).toBeGreaterThanOrEqual(FOCUS_RING_MIN_WIDTH);
     expect(FOCUS_VISIBLE_RING.outlineStyle).toBe("solid");
     expect(FOCUS_VISIBLE_RING.outlineColor).toBe("$outlineColor");
-    // Board verify pass F1: offset 0 — not −2 (band inside the fill, where it
-    // measured 1.17–1.31:1 on solid intents) and not +2 (a gapped halo).
-    expect(FOCUS_VISIBLE_RING.outlineOffset).toBe(0);
+    // Not −2 (band inside the fill, 1.17–1.31:1 on solid intents). FZ-7944
+    // round 2: a 2px gap, the macOS and iPadOS keyboard ring.
+    expect(FOCUS_VISIBLE_RING.outlineOffset).toBe(2);
     expect(FOCUS_RING_MIN_CONTRAST).toBeGreaterThanOrEqual(3);
   });
 
@@ -121,14 +121,14 @@ describe("$outlineColor token contrast (DF-03 / DG-A11Y-01)", () => {
   }
 
   // MPO-41 — assert the RATIO on the surface the band actually draws on, not
-  // just the declaration. At offset 0 the band paints OUTSIDE the border box,
+  // just the declaration. At offset +2 the band paints OUTSIDE the border box,
   // on the page ground behind the control; intent Buttons pin the parent-scope
   // `$outlineColor` literal on the ring (LC-51), so the pair that must clear
   // the floor is base `outlineColor` × base ground — for accent and error
   // controls alike, in both schemes.
   for (const scheme of ["light", "dark"] as const) {
     for (const intent of ["accent", "error"] as const) {
-      it(`${scheme} ${intent}: offset-0 ring clears ≥3:1 on the page ground it draws on`, () => {
+      it(`${scheme} ${intent}: the ring clears ≥3:1 on the page ground it draws on`, () => {
         const base = themes[scheme];
         expect(themes[`${scheme}_${intent}`]).toBeTruthy();
         const ring = normalizeToHex(base.outlineColor);
@@ -175,21 +175,21 @@ describe("the ring still paints inside a clipped / fused group (LC-71 §4 inset
     expect(keyboardFocusRingProps).toEqual(FOCUS_VISIBLE_RING_INSET);
   });
 
-  it("ensureFocusVisibleRing honors the explicit per-call-site inset and defaults to 0", () => {
+  it("ensureFocusVisibleRing honors the explicit per-call-site inset and defaults to +2", () => {
     expect(ensureFocusVisibleRing({ outlineOffset: -2 }).outlineOffset).toBe(-2);
-    expect(ensureFocusVisibleRing({ outlineWidth: 3 }).outlineOffset).toBe(0);
-    expect(ensureFocusVisibleRing().outlineOffset).toBe(0);
+    expect(ensureFocusVisibleRing({ outlineWidth: 3 }).outlineOffset).toBe(2);
+    expect(ensureFocusVisibleRing().outlineOffset).toBe(2);
   });
 });
 
 describe("LC-71: keyboard-only; measure the ring / text node, not the frame", () => {
-  it("standalone ring paints a 2px band on the ring-carrying node's box at offset 0", () => {
+  it("standalone ring paints a 2px band 2px clear of the ring-carrying node's box", () => {
     // Measure the node that paints the outline (the ring carrier / text node),
     // never an ancestor Frame. Band = [offset, offset + width] from THAT box.
     const { outlineOffset, outlineWidth } = FOCUS_VISIBLE_RING;
     expect(outlineWidth).toBe(2);
-    expect(outlineOffset).toBe(0);
-    expect(outlineOffset + outlineWidth).toBe(2);
+    expect(outlineOffset).toBe(2);
+    expect(outlineOffset + outlineWidth).toBe(4);
   });
 
   it("chip dismiss rings the glyph node, not the 44px hit-box frame", () => {
@@ -287,10 +287,10 @@ describe("theme DEV warn (outline-none / positive-tabindex)", () => {
  * shipping and being found in a later audit.
  */
 describe("LC-71 §4: the sanctioned focus-ring offset set is closed (MPO-92)", () => {
-  it("is exactly three offsets — clipping inset, default, shape halo", () => {
+  it("is exactly three offsets — clipping inset, flush, default", () => {
     expect([...SANCTIONED_FOCUS_RING_OFFSETS]).toEqual([-2, 0, 2]);
     expect(FOCUS_RING_CLIPPED_OFFSET).toBe(-2);
-    expect(FOCUS_VISIBLE_RING.outlineOffset).toBe(0);
+    expect(FOCUS_VISIBLE_RING.outlineOffset).toBe(2);
     expect(FOCUS_RING_HALO_OFFSET).toBe(2);
   });
 
@@ -312,7 +312,7 @@ describe("LC-71 §4: the sanctioned focus-ring offset set is closed (MPO-92)", (
     });
     // The band spans [outlineOffset, outlineOffset + outlineWidth] from the
     // border edge — here [2, 4]. Inner edge ≥ 0 means it paints entirely on the
-    // surface BEHIND the control, exactly like the default offset 0, so it
+    // surface BEHIND the control, exactly like the default ring, so it
     // measures against the page ground and cannot reproduce the 1.17–1.31:1
     // inside-the-fill failure MPO-41 retired.
     expect(FOCUS_VISIBLE_RING_HALO.outlineOffset).toBeGreaterThanOrEqual(0);

package/src/theme/focusState.ts

@@ -48,31 +48,26 @@ export function focusRingColorMeetsContrast(ringColor: string, surfaceColor: str
 
 /**
  * ONE ring geometry (DG-A11Y-01 / LC-71 §4): 2px solid `$outlineColor` at
- * offset **0** — the band hugs the border box and paints OUTSIDE it, on the
- * surface behind the control (reference §10; board F1 verify pass: offset 0,
- * not −2 and not +2). Offset 0 is what makes the ≥3:1 floor computable: the
- * ring contrasts against the page ground, not the control's own fill. The
- * old flat inset (−2) painted the band INSIDE solid intent fills and sank to
- * 1.17–1.31:1 (light accent 1.27, light error 1.17, dark error 1.31) where
- * the same ring on the page ground clears 5.78–6.50:1 (MPO-41 / MPO-19 X7).
+ * offset **+2**, a band clear of the border box with a 2px gap, painted on the
+ * surface behind the control. FZ-7944 round 2 moved the default from 0 to +2
+ * (the macOS and iPadOS keyboard ring); the ≥3:1 floor stays computable
+ * because the band still paints on the page ground, never inside a fill. The
+ * old flat inset (−2) painted INSIDE solid intent fills and sank to
+ * 1.17–1.31:1 (MPO-41 / MPO-19 X7).
  *
- * The inset did not die — it moved to `FOCUS_VISIBLE_RING_INSET`, an
- * explicit per-call-site carve-out for clipping ancestors. MPO-19 X7 names
- * the same offset `FOCUS_RING_CLIPPED_OFFSET` so call sites do not type `-2`.
- *
- * MPO-92 ratified a second, shape-scoped carve-out on the other side:
- * `FOCUS_VISIBLE_RING_HALO` (+2) for pill/circular thumbs and inline text
- * links. The F1 "not +2" reading was about the DEFAULT — a blanket +2 on
- * every control — and it stands. The halo is a named carve-out with a written
- * shape scope, exactly as the inset is; `SANCTIONED_FOCUS_RING_OFFSETS` below
- * is the closed set of all three.
+ * Two carve-outs stay named: `FOCUS_VISIBLE_RING_INSET` (−2) for clipping
+ * ancestors, and `FOCUS_RING_FLUSH_OFFSET` (0) for rows and cells that sit
+ * edge to edge inside a padded overlay, where a gapped band would collide
+ * with the neighbour. `SANCTIONED_FOCUS_RING_OFFSETS` is the closed set.
  */
 export const FOCUS_RING_CLIPPED_OFFSET = -2;
+export const FOCUS_RING_FLUSH_OFFSET = 0;
+export const FOCUS_RING_HALO_OFFSET = 2;
 export const FOCUS_VISIBLE_RING = {
   outlineWidth: FOCUS_RING_MIN_WIDTH,
   outlineStyle: "solid" as const,
   outlineColor: "$outlineColor",
-  outlineOffset: 0,
+  outlineOffset: FOCUS_RING_HALO_OFFSET,
 } satisfies ControlStateProps;
 
 /**
@@ -94,29 +89,10 @@ export const FOCUS_VISIBLE_RING_INSET = {
 } satisfies ControlStateProps;
 
 /**
- * The LC-71 §4 halo carve-out (MPO-92, ratified 2026-09-02): the SAME ring,
- * pushed 2px clear of the border box, for the two shapes where a band hugging
- * the edge reads as part of the glyph instead of around it.
- *
- * Scope is by SHAPE, not by instance, and it is closed at two:
- *   - **pill / circular thumbs** — a round handle the user drags (Slider
- *     thumb, Rating star, TimeRangeScrubber handle). At offset 0 the band is
- *     concentric with the glyph's own edge and reads as a thicker glyph.
- *   - **inline text links** — a link inside a run of prose (markdown/mdx
- *     `Link`, ErrorSummary's summary link, backoffice "View All"). At offset 0
- *     the band crosses the line box and collides with ascenders/descenders of
- *     the surrounding text.
- *
- * NOT for standalone rectangles on the page ground — cards, tiles, rows,
- * fields. Those are the default `FOCUS_VISIBLE_RING` (offset 0), which is
- * what makes the Axiom 12 ≥3:1 floor computable against the page ground.
- *
- * Contrast is unaffected: like offset 0 the halo paints OUTSIDE the border
- * box, on the surface behind the control, so it measures against the same
- * page ground the default does — the 1.17–1.31:1 failures MPO-41 retired were
- * the INSET painting inside solid intent fills, a defect the halo cannot have.
+ * The halo (MPO-92): pill and circular thumbs and inline text links. Since
+ * FZ-7944 round 2 it equals the default ring; the name stays so those call
+ * sites keep saying why they hold +2 if the default ever moves again.
  */
-export const FOCUS_RING_HALO_OFFSET = 2;
 export const FOCUS_VISIBLE_RING_HALO = {
   ...FOCUS_VISIBLE_RING,
   outlineOffset: FOCUS_RING_HALO_OFFSET,
@@ -124,7 +100,7 @@ export const FOCUS_VISIBLE_RING_HALO = {
 
 /**
  * The CLOSED set of sanctioned focus-ring offsets (LC-71 §4). Three, and only
- * three: the default 0, the clipping inset −2, the shape halo +2. A call site
+ * three: the clipping inset −2, the flush 0, the default +2. A call site
  * that wants any other number is a rule gap, not a preference — file it and
  * amend §4, do not type the number. `focusState.spec.ts` asserts this set is
  * exactly what the repo paints, so a fourth offset fails a test instead of
@@ -132,8 +108,8 @@ export const FOCUS_VISIBLE_RING_HALO = {
  */
 export const SANCTIONED_FOCUS_RING_OFFSETS = [
   FOCUS_RING_CLIPPED_OFFSET,
+  FOCUS_RING_FLUSH_OFFSET,
   FOCUS_VISIBLE_RING.outlineOffset,
-  FOCUS_RING_HALO_OFFSET,
 ] as const;
 
 /** True when `offset` is one of the three offsets LC-71 §4 sanctions. */

package/src/theme/hairlineToken.spec.ts

@@ -50,7 +50,7 @@ describe("LC-148 HAIRLINE-TOKEN: borderWidth small is the theme's hairline", ()
       controlBorderOutlined: "$borderColorHairline",
       elevatedSurface: "$borderColorHairline",
     });
-    expect(edges({ borderWidth: "small" }, "dark").elevatedSurface).toBe("$color5");
+    expect(edges({ borderWidth: "small" }, "dark").elevatedSurface).toBe("transparent");
     expect(edges({ borderWidth: "none", fillStyle: "outlined" }).borderRadius).toBe(
       "$borderColorHairline",
     );
@@ -64,7 +64,7 @@ describe("LC-148 HAIRLINE-TOKEN: borderWidth small is the theme's hairline", ()
         controlBorderOutlined: "$borderColor",
         elevatedSurface: "$borderColor",
       });
-      expect(edges({ borderWidth }, "dark").elevatedSurface).toBe("$color6");
+      expect(edges({ borderWidth }, "dark").elevatedSurface).toBe("transparent");
     }
   });
 

package/src/theme/motion.spec.ts

@@ -1,6 +1,12 @@
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
 import { describe, expect, it } from "vitest";
+import { GAP_LG_KNOB } from "../audit/constraintAudit";
 import { animationConfig, animationDurations, motionStops } from "./animations/css";
+import { transitionProps } from "./transitionProps";
+import { transitionProps as nativeTransitionProps } from "./transitionProps.native";
 import {
+  motionExitFactor,
   motionFor,
   motionDurationMs,
   motionSeconds,
@@ -82,3 +88,134 @@ describe("motion durations", () => {
     expect(motionSettleMs(["quick", { opacity: "slow" }])).toBe(980);
   });
 });
+
+const bouncyStops = ["bouncy", "superBouncy"];
+const nonBouncy = motionStops.filter((stop) => !bouncyStops.includes(stop));
+const ms = (stop: unknown) => animationDurations[stop as keyof typeof animationDurations];
+
+function bezierYs(timing: string): number[] {
+  const match = timing.match(/cubic-bezier\(([^)]+)\)/);
+  if (!match) return [];
+  const [, y1, , y2] = match[1].split(",").map(Number);
+  return [y1, y2];
+}
+
+const publicRoot = path.resolve(__dirname, "../../..");
+
+function sources(dir: string, out: string[] = []): string[] {
+  for (const name of readdirSync(dir)) {
+    if (name === "node_modules" || name === "dist" || name === "types") continue;
+    const file = path.join(dir, name);
+    if (statSync(file).isDirectory()) sources(file, out);
+    else if (/\.tsx?$/.test(name) && !/\.(spec|test|stories)\.tsx?$|\.d\.ts$/.test(name)) {
+      out.push(file);
+    }
+  }
+  return out;
+}
+
+function enterExitObjects(source: string): string[] {
+  const objects: string[] = [];
+  for (const match of source.matchAll(
+    /\b(?:enterStyle|exitStyle)\s*(?:=\{|:)\s*(?:[^{}?]*\?\s*)?(\{[^{}]*\}|[A-Za-z_$][\w$]*)/g,
+  )) {
+    const value = match[1];
+    if (value.startsWith("{")) objects.push(value);
+    else {
+      const declared = source.match(
+        new RegExp(`\\b(?:const|let)\\s+${value}\\s*=\\s*(\\{[^{}]*\\})`),
+      );
+      if (declared) objects.push(declared[1]);
+    }
+  }
+  return objects;
+}
+
+function numbersIn(expression: string, source: string): number[] {
+  const values = [...expression.matchAll(/-?\d+(?:\.\d+)?/g)].map((m) => Math.abs(Number(m[0])));
+  for (const [identifier] of expression.matchAll(/[A-Za-z_$][\w$]*/g)) {
+    const declared = source.match(new RegExp(`\\bconst\\s+${identifier}\\s*=\\s*([^;\\n]+)`));
+    if (declared && !/[{(]/.test(declared[1])) {
+      values.push(
+        ...[...declared[1].matchAll(/-?\d+(?:\.\d+)?/g)].map((m) => Math.abs(Number(m[0]))),
+      );
+    }
+  }
+  return values;
+}
+
+describe("LC-178 MOTION-CHARACTER: quick in, quicker out, short and still", () => {
+  it("exits every role faster than it enters, about two thirds of the enter duration", () => {
+    for (const stop of motionStops) {
+      for (const [name, role] of Object.entries(motionFor(stop))) {
+        const enter = ms(role.transition);
+        const exit = ms(role.exit);
+        const shorter = nonBouncy.filter((candidate) => ms(candidate) < enter);
+        if (shorter.length === 0) {
+          expect(role.exit, `${stop}.${name}`).toBe(role.transition);
+          continue;
+        }
+        expect(exit, `${stop}.${name} exit`).toBeLessThan(enter);
+        const target = enter * motionExitFactor;
+        const best = Math.min(...shorter.map((candidate) => Math.abs(ms(candidate) - target)));
+        expect(Math.abs(exit - target), `${stop}.${name} exit near 2/3`).toBe(best);
+      }
+    }
+    for (const role of Object.values(motionFor("none"))) expect(role.exit).toBeUndefined();
+  });
+
+  it("never picks a bouncy stop, so no role overshoots opacity", () => {
+    for (const stop of motionStops) {
+      for (const [name, role] of Object.entries(motionFor(stop))) {
+        const presetBounce = name === "control" && bouncyStops.includes(stop);
+        for (const leg of presetBounce ? [role.exit] : [role.transition, role.exit]) {
+          expect(bouncyStops, `${stop}.${name}`).not.toContain(leg);
+          for (const y of bezierYs(animationConfig[leg as keyof typeof animationConfig])) {
+            expect(y, `${stop}.${name} ${String(leg)} curve`).toBeGreaterThanOrEqual(0);
+            expect(y, `${stop}.${name} ${String(leg)} curve`).toBeLessThanOrEqual(1);
+          }
+        }
+      }
+    }
+  });
+
+  it("hands the exit stop to the driver, and native springs clamp their overshoot", () => {
+    const { overlay } = motionFor("quick");
+    expect(transitionProps(overlay).transition).toEqual(["quicker", { exit: "quickest" }]);
+    expect(nativeTransitionProps(overlay).transition).toEqual([
+      "quicker",
+      { overshootClamping: true, exit: "quickest" },
+    ]);
+    const shortest = motionFor("quickestLessBouncy").control;
+    expect(nativeTransitionProps(shortest).transition).toEqual([
+      "quickestLessBouncy",
+      { overshootClamping: true },
+    ]);
+  });
+
+  it("keeps every enter and exit offset in public/* within gapLg and its opacity in [0, 1]", () => {
+    const limit = GAP_LG_KNOB.gapLg;
+    expect(limit).toBeGreaterThan(0);
+    const travel: string[] = [];
+    const opacity: string[] = [];
+    let seen = 0;
+    for (const file of sources(publicRoot)) {
+      const source = readFileSync(file, "utf8");
+      for (const object of enterExitObjects(source)) {
+        seen += 1;
+        const where = `${path.relative(publicRoot, file)}: ${object}`;
+        for (const [, axis, expression] of object.matchAll(/\b([xy])\s*:\s*([^,}]+)/g)) {
+          if (numbersIn(expression, source).some((value) => value > limit)) {
+            travel.push(`${where} (${axis} past gapLg ${limit})`);
+          }
+        }
+        for (const [, value] of object.matchAll(/\bopacity\s*:\s*(-?\d+(?:\.\d+)?)/g)) {
+          if (Number(value) < 0 || Number(value) > 1) opacity.push(where);
+        }
+      }
+    }
+    expect(seen).toBeGreaterThan(10);
+    expect(travel).toEqual([]);
+    expect(opacity).toEqual([]);
+  });
+});

package/src/theme/motion.ts

@@ -9,9 +9,12 @@ export type MotionRoleName = "control" | "overlay" | "scrim" | "reveal" | "slide
 
 export interface MotionRole {
   transition: TransitionProp | undefined;
+  exit?: TransitionProp | undefined;
   animateOnly: readonly string[];
 }
 
+export const motionExitFactor = 2 / 3;
+
 export const motionRoleProperties = {
   control: ["backgroundColor", "borderColor", "color", "opacity", "transform"],
   overlay: ["opacity", "transform"],
@@ -22,8 +25,8 @@ export const motionRoleProperties = {
 
 const nonBouncyStops = motionStops.filter((stop) => stop !== "superBouncy" && stop !== "bouncy");
 
-function nearestStop(duration: number): MotionStop {
-  return nonBouncyStops.reduce((nearest, candidate) =>
+function nearestStop(duration: number, stops: readonly MotionStop[] = nonBouncyStops): MotionStop {
+  return stops.reduce((nearest, candidate) =>
     Math.abs(animationDurations[candidate] - duration) <
     Math.abs(animationDurations[nearest] - duration)
       ? candidate
@@ -31,18 +34,28 @@ function nearestStop(duration: number): MotionStop {
   );
 }
 
+function exitStop(enter: MotionStop): MotionStop {
+  const enterMs = animationDurations[enter];
+  const shorter = nonBouncyStops.filter((stop) => animationDurations[stop] < enterMs);
+  return shorter.length === 0 ? enter : nearestStop(enterMs * motionExitFactor, shorter);
+}
+
 export function motionFor(stop: Animation): Record<MotionRoleName, MotionRole> {
   const transition = stop === "none" ? undefined : stop;
   const duration = motionDurationMs(transition);
-  const role = (name: MotionRoleName, factor: number): MotionRole => ({
-    transition:
+  const role = (name: MotionRoleName, factor: number): MotionRole => {
+    const enter =
       transition === undefined
         ? undefined
         : name === "control"
           ? transition
-          : nearestStop(duration * factor),
-    animateOnly: motionRoleProperties[name],
-  });
+          : nearestStop(duration * factor);
+    return {
+      transition: enter,
+      exit: enter === undefined ? undefined : exitStop(enter),
+      animateOnly: motionRoleProperties[name],
+    };
+  };
   return {
     control: role("control", 1),
     overlay: role("overlay", 0.8),

package/src/theme/mpo19Proof.spec.ts

@@ -208,9 +208,9 @@ describe("MPO-19 X5/X6 — surfaces address semantic tokens, so sub-themes work"
 });
 
 describe("MPO-19 X7 — the focus ring is inset only where a clip demands it", () => {
-  it("the default sits on the border-box edge, as Tamagui paints it", () => {
-    expect(FOCUS_VISIBLE_RING.outlineOffset).toBe(0);
-    expect(ensureFocusVisibleRing().outlineOffset).toBe(0);
+  it("the default sits 2px clear of the border box (FZ-7944 round 2)", () => {
+    expect(FOCUS_VISIBLE_RING.outlineOffset).toBe(2);
+    expect(ensureFocusVisibleRing().outlineOffset).toBe(2);
   });
 
   it("the ring shape itself is unchanged — 2px solid, non-removable", () => {

package/src/theme/overlaySurfaces.tsx

@@ -1,3 +1,4 @@
+import { focusOnOpen, wasKeyboardFocus } from "../keyboardFocusRing";
 import { transitionProps } from "./transitionProps";
 import { Surface } from "./Surface";
 import { useResolvedKnobs } from "./useResolvedKnobs";
@@ -40,7 +41,9 @@ const overlayFrameFocusStyle = {
 // tamagui's deferred path still runs. Dialog content sits in a native
 // <dialog> whose show() puts focus inside before the check in browsers,
 // so there FocusScope never calls the handler; useDialogShowFocus does
-// when show() left focus on something that is not a tab stop (MPO-470).
+// when show() left focus on something that is not a tab stop (MPO-470), or
+// on any control after a non-keyboard open, which Chromium would ring
+// (LC-71, FZ-7944).
 
 function isTabbableWithin(node: HTMLElement, container: HTMLElement): boolean {
   if (node.tabIndex < 0 || node.hidden || node.tagName === "A") return false;
@@ -67,8 +70,10 @@ function focusFirstTabbableOnOpen(event: Event): void {
   );
   if (!first) return;
   event.preventDefault();
-  first.focus({ preventScroll: true });
-  if (typeof HTMLInputElement !== "undefined" && first instanceof HTMLInputElement) first.select();
+  const focused = focusOnOpen(first, container);
+  if (typeof HTMLInputElement !== "undefined" && focused instanceof HTMLInputElement) {
+    focused.select();
+  }
 }
 
 type OpenAutoFocus = (event: Event) => void;
@@ -100,7 +105,7 @@ function useDialogShowFocus(onOpenAutoFocus: OpenAutoFocus): void {
     const content = document.getElementById(contentId);
     const focused = document.activeElement;
     if (!content || typeof HTMLElement === "undefined" || !(focused instanceof HTMLElement)) return;
-    if (!content.contains(focused) || focused.tabIndex >= 0) return;
+    if (!content.contains(focused) || (focused.tabIndex >= 0 && wasKeyboardFocus())) return;
     content.addEventListener(DIALOG_SHOW_FOCUS_EVENT, onOpenAutoFocus, { once: true });
     content.dispatchEvent(new CustomEvent(DIALOG_SHOW_FOCUS_EVENT, { cancelable: true }));
   }, [open, contentId]);

package/src/theme/resolveKnobs.spec.ts

@@ -315,7 +315,7 @@ describe("resolveKnobs", () => {
             scheme === "dark" ? "$color4" : "$background",
           );
           expect(knobProps.elevatedSurface.borderColor).toBe(
-            scheme === "dark" ? "$color6" : "$borderColor",
+            scheme === "dark" ? "transparent" : "$borderColor",
           );
           if (!key) {
             expect(knobProps.elevationChrome).toEqual({});

package/src/theme/resolveKnobs.ts

@@ -456,10 +456,10 @@ function elevationChromeFor(key: SizeKey | undefined): ElevationChromeProps {
   };
 }
 
-// v5's surface2 template steps: fill and edge two palette steps above the
-// base `$background`/`$borderColor` (color2/color4), one above Card's surface1.
-// The fill alone would land on the base edge step and erase the border.
-const surface2 = { fill: "$color4", edge: "$color6" } as const;
+// v5's surface2 template step: the fill two palette steps above the base
+// `$background` (color2), one above Card's surface1. A dark overlay separates
+// by this lighter fill and its shadow, with no light edge (HIG, FZ-7944).
+const surface2 = { fill: "$color4" } as const;
 
 // `$textMuted` is the theme's secondary ink (LC-152): the most muted ramp
 // step that clears 7:1 on the page and every card tier in its own scheme. A
@@ -801,7 +801,7 @@ export function resolveKnobs(
         }
       : {
           backgroundColor: scheme === "dark" ? surface2.fill : "$background",
-          borderColor: edge(scheme === "dark" ? surface2.edge : "$borderColor", borderWidthValue),
+          borderColor: scheme === "dark" ? "transparent" : edge("$borderColor", borderWidthValue),
           borderWidth: borderWidthValue,
           borderRadius: radiusToken,
           elevation: platformElevation(overlayElevationToken),

package/src/theme/transitionProps.native.ts

@@ -1,5 +1,6 @@
 import type { MotionRole } from "./motion";
 import type { TransitionProp } from "tamagui";
+import { animationConfig as nativeAnimationConfig } from "./animations/reactNative";
 
 /**
  * Native twin of `transitionProps.ts`.
@@ -23,12 +24,26 @@ export function transitionProps(
   const properties = [...role.animateOnly, ...extra].flatMap(
     (property) => nativeLonghands[property] ?? [property],
   );
+  if (typeof transition !== "string") return { transition, animateOnly: properties };
+  const exit = typeof role.exit === "string" && role.exit !== transition ? role.exit : undefined;
+  const clamp = isSpring(transition) && !presetBounce.has(transition);
+  if (!exit && !clamp) return { transition, animateOnly: properties };
   return {
-    transition,
+    transition: [
+      transition,
+      { ...(clamp ? { overshootClamping: true } : {}), ...(exit ? { exit } : {}) },
+    ],
     animateOnly: properties,
   };
 }
 
+function isSpring(stop: string): boolean {
+  const config = nativeAnimationConfig[stop as keyof typeof nativeAnimationConfig] as
+    | { type?: string }
+    | undefined;
+  return config !== undefined && config.type !== "timing";
+}
+
 /**
  * FZ-7919: tamagui expands `borderColor` into its four sides before the React
  * Native driver sees the style, and the driver matches `animateOnly` by exact
@@ -36,6 +51,8 @@ export function transitionProps(
  * (the bubbled focus of a field's text input) animated them. The animated
  * copy outranked the static one and held the previous focus or theme colour.
  */
+const presetBounce = new Set(["bouncy", "superBouncy"]);
+
 const nativeLonghands: Record<string, readonly string[]> = {
   borderColor: [
     "borderColor",

package/src/theme/transitionProps.spec.ts

@@ -24,7 +24,7 @@ describe("role property scopes", () => {
   });
   it("hyphenates the control scope and additional properties", () => {
     expect(transitionProps(motionFor("quick").control, ["maxHeight", "left"])).toEqual({
-      transition: "quick",
+      transition: ["quick", { exit: "quickerLessBouncy" }],
       animateOnly: [
         "background-color",
         "border-color",
@@ -41,7 +41,7 @@ describe("role property scopes", () => {
     expect(nativeTransitionProps(undefined)).toEqual({});
     expect(nativeTransitionProps("quick")).toEqual({ transition: "quick" });
     expect(nativeTransitionProps(motionFor("quick").control, ["maxHeight"])).toEqual({
-      transition: "quick",
+      transition: ["quick", { overshootClamping: true, exit: "quickerLessBouncy" }],
       animateOnly: [
         "backgroundColor",
         "borderColor",

package/src/theme/transitionProps.ts

@@ -22,13 +22,23 @@ export function transitionProps(
   if (!isRole) return { transition };
   const properties = [...role.animateOnly, ...extra];
   return {
-    transition,
+    transition: withExit(transition, role.exit),
     animateOnly: properties.map((property) =>
       property.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`),
     ),
   };
 }
 
+function withExit(
+  transition: TransitionProp | undefined,
+  exit: TransitionProp | undefined,
+): TransitionProp | undefined {
+  if (typeof transition !== "string" || typeof exit !== "string" || exit === transition) {
+    return transition;
+  }
+  return [transition, { exit }];
+}
+
 function isMotionRole(value: MotionRole | TransitionProp | undefined): value is MotionRole {
   return (
     typeof value === "object" &&

package/types/keyboardFocusRing.d.ts

@@ -22,6 +22,17 @@ export declare function ensureKeyboardModalityTracking(): void;
  * false) and during SSR.
  */
 export declare function wasKeyboardFocus(): boolean;
+/**
+ * An overlay's open focus (LC-71, FZ-7944). Only a keyboard open lands on a
+ * control and rings it. Any other open (pointer, touch, mounted open) lands on
+ * the frame, which paints no ring: Chromium ignores `focusVisible: false` and
+ * rings a control focused before any input. A mouse open still puts the caret
+ * in a first text field, which shows LC-133's border; a touch open does not,
+ * so the keyboard does not rise over a sheet the user only looked at. A frame
+ * without a tabindex gets -1, or its focus() is a no-op and the browser's
+ * own pick stays. Returns the node that took focus.
+ */
+export declare function focusOnOpen(target: HTMLElement | null, frame: HTMLElement): HTMLElement;
 /**
  * Standard manual ring props — the INSET ring geometry
  * (`FOCUS_VISIBLE_RING_INSET`: 2px solid `$outlineColor`, offset −2), spread

package/types/keyboardFocusRing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keyboardFocusRing.d.ts","sourceRoot":"","sources":["../src/keyboardFocusRing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH;;;;GAIG;AACH,wBAAgB,8BAA8B,SAK7C;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAG1C;AAID;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB;;;;;CAEzB,CAAC;AAEX;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,8uCA+BhC,CAAC;AAIH,uEAAuE;AACvE,wBAAgB,wBAAwB,IAAI,IAAI,CAO/C"}
+{"version":3,"file":"keyboardFocusRing.d.ts","sourceRoot":"","sources":["../src/keyboardFocusRing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH;;;;GAIG;AACH,wBAAgB,8BAA8B,SAY7C;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAG1C;AAWD;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,EAAE,KAAK,EAAE,WAAW,GAAG,WAAW,CAQvF;AAID;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB;;;;;CAEzB,CAAC;AAEX;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,8uCA+BhC,CAAC;AAIH,uEAAuE;AACvE,wBAAgB,wBAAwB,IAAI,IAAI,CAO/C"}

package/types/theme/createThemes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createThemes.d.ts","sourceRoot":"","sources":["../../src/theme/createThemes.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"createThemes.d.ts","sourceRoot":"","sources":["../../src/theme/createThemes.ts"],"names":[],"mappings":"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"}

package/types/theme/focusState.d.ts

@@ -16,26 +16,21 @@ export declare const FOCUS_RING_MIN_CONTRAST = 3;
 export declare function focusRingColorMeetsContrast(ringColor: string, surfaceColor: string): boolean;
 /**
  * ONE ring geometry (DG-A11Y-01 / LC-71 §4): 2px solid `$outlineColor` at
- * offset **0** — the band hugs the border box and paints OUTSIDE it, on the
- * surface behind the control (reference §10; board F1 verify pass: offset 0,
- * not −2 and not +2). Offset 0 is what makes the ≥3:1 floor computable: the
- * ring contrasts against the page ground, not the control's own fill. The
- * old flat inset (−2) painted the band INSIDE solid intent fills and sank to
- * 1.17–1.31:1 (light accent 1.27, light error 1.17, dark error 1.31) where
- * the same ring on the page ground clears 5.78–6.50:1 (MPO-41 / MPO-19 X7).
+ * offset **+2**, a band clear of the border box with a 2px gap, painted on the
+ * surface behind the control. FZ-7944 round 2 moved the default from 0 to +2
+ * (the macOS and iPadOS keyboard ring); the ≥3:1 floor stays computable
+ * because the band still paints on the page ground, never inside a fill. The
+ * old flat inset (−2) painted INSIDE solid intent fills and sank to
+ * 1.17–1.31:1 (MPO-41 / MPO-19 X7).
  *
- * The inset did not die — it moved to `FOCUS_VISIBLE_RING_INSET`, an
- * explicit per-call-site carve-out for clipping ancestors. MPO-19 X7 names
- * the same offset `FOCUS_RING_CLIPPED_OFFSET` so call sites do not type `-2`.
- *
- * MPO-92 ratified a second, shape-scoped carve-out on the other side:
- * `FOCUS_VISIBLE_RING_HALO` (+2) for pill/circular thumbs and inline text
- * links. The F1 "not +2" reading was about the DEFAULT — a blanket +2 on
- * every control — and it stands. The halo is a named carve-out with a written
- * shape scope, exactly as the inset is; `SANCTIONED_FOCUS_RING_OFFSETS` below
- * is the closed set of all three.
+ * Two carve-outs stay named: `FOCUS_VISIBLE_RING_INSET` (−2) for clipping
+ * ancestors, and `FOCUS_RING_FLUSH_OFFSET` (0) for rows and cells that sit
+ * edge to edge inside a padded overlay, where a gapped band would collide
+ * with the neighbour. `SANCTIONED_FOCUS_RING_OFFSETS` is the closed set.
  */
 export declare const FOCUS_RING_CLIPPED_OFFSET = -2;
+export declare const FOCUS_RING_FLUSH_OFFSET = 0;
+export declare const FOCUS_RING_HALO_OFFSET = 2;
 export declare const FOCUS_VISIBLE_RING: {
     outlineWidth: number;
     outlineStyle: "solid";
@@ -62,29 +57,10 @@ export declare const FOCUS_VISIBLE_RING_INSET: {
     outlineColor: string;
 };
 /**
- * The LC-71 §4 halo carve-out (MPO-92, ratified 2026-09-02): the SAME ring,
- * pushed 2px clear of the border box, for the two shapes where a band hugging
- * the edge reads as part of the glyph instead of around it.
- *
- * Scope is by SHAPE, not by instance, and it is closed at two:
- *   - **pill / circular thumbs** — a round handle the user drags (Slider
- *     thumb, Rating star, TimeRangeScrubber handle). At offset 0 the band is
- *     concentric with the glyph's own edge and reads as a thicker glyph.
- *   - **inline text links** — a link inside a run of prose (markdown/mdx
- *     `Link`, ErrorSummary's summary link, backoffice "View All"). At offset 0
- *     the band crosses the line box and collides with ascenders/descenders of
- *     the surrounding text.
- *
- * NOT for standalone rectangles on the page ground — cards, tiles, rows,
- * fields. Those are the default `FOCUS_VISIBLE_RING` (offset 0), which is
- * what makes the Axiom 12 ≥3:1 floor computable against the page ground.
- *
- * Contrast is unaffected: like offset 0 the halo paints OUTSIDE the border
- * box, on the surface behind the control, so it measures against the same
- * page ground the default does — the 1.17–1.31:1 failures MPO-41 retired were
- * the INSET painting inside solid intent fills, a defect the halo cannot have.
+ * The halo (MPO-92): pill and circular thumbs and inline text links. Since
+ * FZ-7944 round 2 it equals the default ring; the name stays so those call
+ * sites keep saying why they hold +2 if the default ever moves again.
  */
-export declare const FOCUS_RING_HALO_OFFSET = 2;
 export declare const FOCUS_VISIBLE_RING_HALO: {
     outlineOffset: number;
     outlineWidth: number;
@@ -93,13 +69,13 @@ export declare const FOCUS_VISIBLE_RING_HALO: {
 };
 /**
  * The CLOSED set of sanctioned focus-ring offsets (LC-71 §4). Three, and only
- * three: the default 0, the clipping inset −2, the shape halo +2. A call site
+ * three: the clipping inset −2, the flush 0, the default +2. A call site
  * that wants any other number is a rule gap, not a preference — file it and
  * amend §4, do not type the number. `focusState.spec.ts` asserts this set is
  * exactly what the repo paints, so a fourth offset fails a test instead of
  * shipping (MPO-92 AC-3).
  */
-export declare const SANCTIONED_FOCUS_RING_OFFSETS: readonly [-2, number, 2];
+export declare const SANCTIONED_FOCUS_RING_OFFSETS: readonly [-2, 0, number];
 /** True when `offset` is one of the three offsets LC-71 §4 sanctions. */
 export declare function isSanctionedFocusRingOffset(offset: number): boolean;
 /**

package/types/theme/focusState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"focusState.d.ts","sourceRoot":"","sources":["../../src/theme/focusState.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAEnD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,IAAI,CAAC;AACtC,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAuBzC;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAO5F;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAC5C,eAAO,MAAM,kBAAkB;;;;;CAKF,CAAC;AAE9B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,wBAAwB;;;;;CAGR,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,sBAAsB,IAAI,CAAC;AACxC,eAAO,MAAM,uBAAuB;;;;;CAGP,CAAC;AAE9B;;;;;;;GAOG;AACH,eAAO,MAAM,6BAA6B,0BAIhC,CAAC;AAEX,yEAAyE;AACzE,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEnE;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;CAED,CAAC;AAE9B,eAAO,MAAM,iBAAiB;;CAED,CAAC;AAE9B;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,iBAAiB,EAChE,QAAQ,CAAC,EAAE,CAAC,CAAC,GAAG,iBAAiB,CAAC,GAAG,IAAI,GACxC,CAAC,GAAG,iBAAiB,CAyBvB;AAED,mFAAmF;AACnF,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,iBAAiB,EAC1B,KAAK,EAAE,iBAAiB,GACvB,iBAAiB,CAKnB"}
+{"version":3,"file":"focusState.d.ts","sourceRoot":"","sources":["../../src/theme/focusState.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAEnD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,IAAI,CAAC;AACtC,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAuBzC;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAO5F;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAC5C,eAAO,MAAM,uBAAuB,IAAI,CAAC;AACzC,eAAO,MAAM,sBAAsB,IAAI,CAAC;AACxC,eAAO,MAAM,kBAAkB;;;;;CAKF,CAAC;AAE9B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,wBAAwB;;;;;CAGR,CAAC;AAE9B;;;;GAIG;AACH,eAAO,MAAM,uBAAuB;;;;;CAGP,CAAC;AAE9B;;;;;;;GAOG;AACH,eAAO,MAAM,6BAA6B,0BAIhC,CAAC;AAEX,yEAAyE;AACzE,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEnE;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;CAED,CAAC;AAE9B,eAAO,MAAM,iBAAiB;;CAED,CAAC;AAE9B;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,iBAAiB,EAChE,QAAQ,CAAC,EAAE,CAAC,CAAC,GAAG,iBAAiB,CAAC,GAAG,IAAI,GACxC,CAAC,GAAG,iBAAiB,CAyBvB;AAED,mFAAmF;AACnF,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,iBAAiB,EAC1B,KAAK,EAAE,iBAAiB,GACvB,iBAAiB,CAKnB"}

package/types/theme/motion.d.ts

@@ -4,8 +4,10 @@ export { motionDurationMs, motionHideDelayMs, motionSeconds, motionSettleMs } fr
 export type MotionRoleName = "control" | "overlay" | "scrim" | "reveal" | "slide";
 export interface MotionRole {
     transition: TransitionProp | undefined;
+    exit?: TransitionProp | undefined;
     animateOnly: readonly string[];
 }
+export declare const motionExitFactor: number;
 export declare const motionRoleProperties: {
     readonly control: readonly ["backgroundColor", "borderColor", "color", "opacity", "transform"];
     readonly overlay: readonly ["opacity", "transform"];

package/types/theme/motion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"motion.d.ts","sourceRoot":"","sources":["../../src/theme/motion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAIzC,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEpG,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;AAElF,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,cAAc,GAAG,SAAS,CAAC;IACvC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAED,eAAO,MAAM,oBAAoB;;;;;;CAM6B,CAAC;AAa/D,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAAC,cAAc,EAAE,UAAU,CAAC,CAmB7E"}
+{"version":3,"file":"motion.d.ts","sourceRoot":"","sources":["../../src/theme/motion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAIzC,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEpG,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;AAElF,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,cAAc,GAAG,SAAS,CAAC;IACvC,IAAI,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IAClC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAED,eAAO,MAAM,gBAAgB,QAAQ,CAAC;AAEtC,eAAO,MAAM,oBAAoB;;;;;;CAM6B,CAAC;AAmB/D,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAAC,cAAc,EAAE,UAAU,CAAC,CAuB7E"}

package/types/theme/overlaySurfaces.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"overlaySurfaces.d.ts","sourceRoot":"","sources":["../../src/theme/overlaySurfaces.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,EAML,KAAK,kBAAkB,IAAI,yBAAyB,EAEpD,KAAK,UAAU,EACf,KAAK,cAAc,EAEpB,MAAM,SAAS,CAAC;AAyDjB,KAAK,aAAa,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;AAmC5C;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,EAAE,eAAe,EAAE,EAAE;IAAE,eAAe,CAAC,EAAE,aAAa,CAAA;CAAE,GAAG,IAAI,CAG9F;AAID,MAAM,WAAW,wBAAwB;IACvC,4EAA4E;IAC5E,cAAc,EAAE,OAAO,CAAC;CACzB;AAED;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,mDAE9B,CAAC;AAEH,wBAAgB,sBAAsB,IAAI,wBAAwB,CAEjE;AAED,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C;AAQD,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,yBAAyB,EAAE,MAAM,CAAC,GAAG;IACzE,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,aAAa;eAJb,SAAS;WACb,UAAU;kDAcjB,CAAC;AA0CH;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;;;;;;;;eAEiB,SAAS;kDAelD,CAAC;AAOH,eAAO,MAAM,kBAAkB;eAxFlB,SAAS;WACb,UAAU;kDAiGlB,CAAC;AAgCF,eAAO,MAAM,kBAAkB;;;;;;;;eAEY,SAAS;kDAelD,CAAC;AAiBH,eAAO,MAAM,cAAc;eALd,SAAS;IACpB,iEAAiE;sBAC/C,aAAa;kDA0BhC,CAAC"}
+{"version":3,"file":"overlaySurfaces.d.ts","sourceRoot":"","sources":["../../src/theme/overlaySurfaces.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,EAML,KAAK,kBAAkB,IAAI,yBAAyB,EAEpD,KAAK,UAAU,EACf,KAAK,cAAc,EAEpB,MAAM,SAAS,CAAC;AA6DjB,KAAK,aAAa,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;AAmC5C;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,EAAE,eAAe,EAAE,EAAE;IAAE,eAAe,CAAC,EAAE,aAAa,CAAA;CAAE,GAAG,IAAI,CAG9F;AAID,MAAM,WAAW,wBAAwB;IACvC,4EAA4E;IAC5E,cAAc,EAAE,OAAO,CAAC;CACzB;AAED;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,mDAE9B,CAAC;AAEH,wBAAgB,sBAAsB,IAAI,wBAAwB,CAEjE;AAED,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C;AAQD,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,yBAAyB,EAAE,MAAM,CAAC,GAAG;IACzE,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,aAAa;eAJb,SAAS;WACb,UAAU;kDAcjB,CAAC;AA0CH;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;;;;;;;;eAEiB,SAAS;kDAelD,CAAC;AAOH,eAAO,MAAM,kBAAkB;eAxFlB,SAAS;WACb,UAAU;kDAiGlB,CAAC;AAgCF,eAAO,MAAM,kBAAkB;;;;;;;;eAEY,SAAS;kDAelD,CAAC;AAiBH,eAAO,MAAM,cAAc;eALd,SAAS;IACpB,iEAAiE;sBAC/C,aAAa;kDA0BhC,CAAC"}

package/types/theme/transitionProps.native.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transitionProps.native.d.ts","sourceRoot":"","sources":["../../src/theme/transitionProps.native.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,GAAG,cAAc,GAAG,SAAS,EAC7C,KAAK,GAAE,SAAS,MAAM,EAAO,GAC5B;IACD,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB,CAYA"}
+{"version":3,"file":"transitionProps.native.d.ts","sourceRoot":"","sources":["../../src/theme/transitionProps.native.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAG9C;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,GAAG,cAAc,GAAG,SAAS,EAC7C,KAAK,GAAE,SAAS,MAAM,EAAO,GAC5B;IACD,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB,CAmBA"}