@astryxdesign/core 0.7.6-canary.fdabeba → 0.7.6

package/dist/hooks/useScrollOverflow.js

@@ -4,28 +4,11 @@
 
 /**
  * @file useScrollOverflow.ts
- * @input Uses React useRef, useState, useCallback, useEffect
- * @output Exports useScrollOverflow hook for tracking scroll position edges
+ * @input React refs, state and effects
+ * @output useScrollOverflow, which tracks the overflow at the scroll edges
  * @position Core hook; used by Carousel and TabList for fade-edge and button
  *   state
  *
- * Observes a scroll container and reports whether content overflows at the
- * start, end, or both edges. Updates on every scroll, and while the container
- * is rendered on what else changes the overflow with or without the
- * container resizing: its own size, a child's size (a slide's content
- * growing), a child added or removed, and its class or style (a new gap or
- * padding). A layout read on an element the browser is not
- * rendering (an ancestor with `display: none`, or a `content-visibility:
- * hidden` subtree) either answers zeros or makes the browser lay out that
- * whole hidden subtree for the answer, so an observation delivered for a
- * hidden container, and the measurement at registration inside one, are
- * skipped; the hook keeps its last state until the resize observation that
- * follows the reveal (one frame after it paints). A scroll is measured
- * whether or not the container is rendered: a scroll of a hidden container
- * is script's (a selected tab revealed under a hidden panel), its layout is
- * already the scroll's, and a reveal at the same size brings no resize to
- * measure it with.
- *
  * SYNC: When modified, update:
  * - /packages/core/src/hooks/index.ts
  */
@@ -130,10 +113,10 @@ export function useScrollOverflow() {
     });
   }, []);
 
-  // Registration, resize and content changes: only a rendered container. A
-  // hidden one has no edges to report, and reading its layout would make the
-  // browser render the hidden subtree it sits in; the resize observation that
-  // follows the reveal measures again.
+  // Only a rendered container is measured at registration and on a resize or
+  // content change. A layout read on a hidden one makes the browser render
+  // its hidden subtree. The resize observation after the reveal measures
+  // again.
   const measure = useCallback(() => {
     const el = elRef.current;
     if (el && isRendered(el)) {
@@ -141,10 +124,9 @@ export function useScrollOverflow() {
     }
   }, [measureNow]);
 
-  // A scroll: measured hidden or not. Script scrolled the hidden container
-  // (its layout is already the scroll's), and a reveal at the same size
-  // brings no resize observation, so this is the read that keeps the edges
-  // right for it.
+  // A scroll is measured hidden or not. Script scrolled the hidden container,
+  // so its layout is already current. A reveal at the same size brings no
+  // resize observation, so this read keeps the edges right.
   const measureOnScroll = useCallback(() => {
     const el = elRef.current;
     if (el) {

package/dist/hooks/useScrollableArea.d.ts

@@ -4,10 +4,8 @@
  * @output Safe prop getters, native keyboard entry, and stable per-axis effective scroll state
  * @position Canonical behavior core for ScrollableArea and structure-owning adopters
  *
- * Geometry and style signals coalesce into one full measurement per frame. A
- * scroll only moves the offset, so its event re-derives the logical edges
- * from box geometry: no computed-style read and no extra frame while the
- * user scrolls.
+ * Geometry and style signals cause one full measurement per frame. A scroll
+ * moves only the offset, so it reads only box geometry.
  *
  * SYNC: When modified, update:
  * - /packages/core/src/hooks/useScrollableArea.doc.mjs

package/dist/hooks/useScrollableArea.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useScrollableArea.d.ts","sourceRoot":"","sources":["../../src/hooks/useScrollableArea.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAOL,KAAK,aAAa,EAEnB,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AAmB5C,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;AACrD,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,SAAS,CAAC;AACnD,MAAM,MAAM,uBAAuB,GAAG,gBAAgB,GAAG,QAAQ,CAAC;AAElE,MAAM,MAAM,oBAAoB,GAC5B;IAAC,KAAK,EAAE,SAAS,CAAA;CAAC,GAClB;IAAC,KAAK,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAA;CAAC,GAC7D;IACE,KAAK,EAAE,mBAAmB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;CAC3B,CAAC;AAEN,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,eAAe,CAAC;IACxB,KAAK,EAAE,eAAe,CAAC;CACxB;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,UAAU,CAAC;IACjB,cAAc,EAAE,oBAAoB,CAAC;IACrC,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,iBAAiB,CAAC,EAAE,uBAAuB,CAAC;CAC7C;AAED,MAAM,MAAM,sBAAsB,CAAC,CAAC,SAAS,WAAW,IAAI,SAAS,CAAC,CAAC,CAAC,GACtE,aAAa,CAAC,CAAC,CAAC,CAAC;AAEnB,MAAM,WAAW,uBAAuB;IACtC,gBAAgB,CAAC,CAAC,SAAS,WAAW,EACpC,KAAK,CAAC,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAChC,sBAAsB,CAAC,CAAC,CAAC,CAAC;IAC7B,eAAe,CAAC,CAAC,SAAS,WAAW,EACnC,KAAK,CAAC,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAChC,sBAAsB,CAAC,CAAC,CAAC,CAAC;IAC7B,KAAK,EAAE,mBAAmB,CAAC;CAC5B;AAkGD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,IAAI,EACJ,cAAc,EACd,UAAoB,EACpB,iBAAoC,GACrC,EAAE,wBAAwB,GAAG,uBAAuB,CA+YpD"}
+{"version":3,"file":"useScrollableArea.d.ts","sourceRoot":"","sources":["../../src/hooks/useScrollableArea.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAOL,KAAK,aAAa,EAEnB,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AAmB5C,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;AACrD,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,SAAS,CAAC;AACnD,MAAM,MAAM,uBAAuB,GAAG,gBAAgB,GAAG,QAAQ,CAAC;AAElE,MAAM,MAAM,oBAAoB,GAC5B;IAAC,KAAK,EAAE,SAAS,CAAA;CAAC,GAClB;IAAC,KAAK,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAA;CAAC,GAC7D;IACE,KAAK,EAAE,mBAAmB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;CAC3B,CAAC;AAEN,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,eAAe,CAAC;IACxB,KAAK,EAAE,eAAe,CAAC;CACxB;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,UAAU,CAAC;IACjB,cAAc,EAAE,oBAAoB,CAAC;IACrC,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,iBAAiB,CAAC,EAAE,uBAAuB,CAAC;CAC7C;AAED,MAAM,MAAM,sBAAsB,CAAC,CAAC,SAAS,WAAW,IAAI,SAAS,CAAC,CAAC,CAAC,GACtE,aAAa,CAAC,CAAC,CAAC,CAAC;AAEnB,MAAM,WAAW,uBAAuB;IACtC,gBAAgB,CAAC,CAAC,SAAS,WAAW,EACpC,KAAK,CAAC,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAChC,sBAAsB,CAAC,CAAC,CAAC,CAAC;IAC7B,eAAe,CAAC,CAAC,SAAS,WAAW,EACnC,KAAK,CAAC,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAChC,sBAAsB,CAAC,CAAC,CAAC,CAAC;IAC7B,KAAK,EAAE,mBAAmB,CAAC;CAC5B;AAkGD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,IAAI,EACJ,cAAc,EACd,UAAoB,EACpB,iBAAoC,GACrC,EAAE,wBAAwB,GAAG,uBAAuB,CA0YpD"}

package/dist/hooks/useScrollableArea.js

@@ -8,10 +8,8 @@
  * @output Safe prop getters, native keyboard entry, and stable per-axis effective scroll state
  * @position Canonical behavior core for ScrollableArea and structure-owning adopters
  *
- * Geometry and style signals coalesce into one full measurement per frame. A
- * scroll only moves the offset, so its event re-derives the logical edges
- * from box geometry: no computed-style read and no extra frame while the
- * user scrolls.
+ * Geometry and style signals cause one full measurement per frame. A scroll
+ * moves only the offset, so it reads only box geometry.
  *
  * SYNC: When modified, update:
  * - /packages/core/src/hooks/useScrollableArea.doc.mjs
@@ -184,15 +182,12 @@ export function useScrollableArea({
       frame = window.requestAnimationFrame(measure);
     };
 
-    // A scroll moves the offset and nothing else, so it only re-derives the
-    // logical edges, from box geometry, as the scroll event is dispatched.
-    // Browsers fire it at most once per frame, before animation-frame
-    // callbacks, when style and layout are normally still clean from the last
-    // frame: no computed style is read, no frame is requested, and the edges
-    // are current in the frame that moved. Anything a scroll cannot explain
-    // (overflow appearing or going away on a requested axis, or an offset
-    // whose sign the measured writing direction rules out) schedules the
-    // full measurement, as every other invalidation does.
+    // A scroll moves only the offset, so it derives the logical edges from
+    // box geometry when the event fires. Style and layout are usually still
+    // clean then, so no computed style is read and no frame is requested.
+    // When the scroll cannot explain a change (overflow on a requested axis
+    // appears or goes away, or the offset sign does not match the writing
+    // direction), it schedules the full measurement.
     const onScroll = () => {
       if (!isActive || frame != null) {
         // A full measurement is already pending for this frame.
@@ -292,14 +287,12 @@ export function useScrollableArea({
     };
   }, [axis, content, viewport]);
 
-  // The first measure reads the viewport before this hook has let an
-  // overflowing axis scroll (it is `clip` until then), so it finds overflow
-  // but no scrollable axis yet. Measure again in the same commit once an axis
-  // has just gained overflow (or the axis mapping changed), so the viewport is
-  // a tab stop from the first frame it scrolls, not an animation frame later
-  // (`spec:AST-025` FR12). Only on a gain: content that fits only once a
-  // scrollbar takes space would otherwise flip overflow back and forth inside
-  // one commit; a loss waits for the next frame, as before.
+  // The first measure runs before an overflowing axis can scroll (it is
+  // `clip` until then). So when an axis gains overflow, or the axis mapping
+  // changes, measure again in the same commit. Then the viewport is a tab
+  // stop from the first frame it scrolls (AST-025). Do this only on a gain:
+  // content that fits only when a scrollbar takes space would flip in one
+  // commit. A loss waits for the next frame.
   const previousOverflowRef = useRef(INITIAL_OVERFLOW);
   const previousMappingRef = useRef(INITIAL_MAPPING);
   useIsomorphicLayoutEffect(() => {

package/dist/hooks/useSettledOpen.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns `requested` as it was on the server and in the hydrating render,
+ * until `current` first differs from it after hydration or the caller
+ * releases it; `none` otherwise. Compare the result with `current` to know
+ * whether the open in effect is the settled one. The second element releases
+ * it: an overlay whose settled entry still runs a transition (a sheet's
+ * collapsed rise) calls it when that transition ends, so motion within the
+ * same open (a drag's settle) animates as usual.
+ *
+ * @param requested What the caller asks to have open (the `isOpen` prop, or
+ *   the switcher's `activeSheet` prop).
+ * @param current What is open in this render, once hydrated.
+ * @param none The value meaning nothing is open (`false` or `null`).
+ */
+export declare function useSettledOpen<T>(requested: T, current: T, none: T): [settled: T, release: () => void];
+//# sourceMappingURL=useSettledOpen.d.ts.map

package/dist/hooks/useSettledOpen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSettledOpen.d.ts","sourceRoot":"","sources":["../../src/hooks/useSettledOpen.ts"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,SAAS,EAAE,CAAC,EACZ,OAAO,EAAE,CAAC,EACV,IAAI,EAAE,CAAC,GACN,CAAC,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC,CAUnC"}

package/dist/hooks/useSettledOpen.js

@@ -0,0 +1,44 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+'use client';
+
+/**
+ * @file useSettledOpen.ts
+ * @input Uses React useState and useIsHydrating
+ * @output Exports useSettledOpen (internal; not re-exported from hooks/index.ts)
+ * @position Internal utility; read by Dialog, Drawer, BottomSheet and
+ *   BottomSheetSwitcher so an overlay open on the server opens settled after
+ *   hydration (spec:AST-013 FR13)
+ *
+ * An overlay open on the server renders closed until hydration, since nothing
+ * can make it modal before then. It was still present on page load, so the
+ * open right after hydration plays no entry motion. This hook remembers what
+ * was open on the server (an open flag, or a switcher's active step) until
+ * that first stops being in effect after hydration; later opens animate.
+ */
+import { useCallback, useState } from 'react';
+import { useIsHydrating } from "./useIsHydrating.js";
+
+/**
+ * Returns `requested` as it was on the server and in the hydrating render,
+ * until `current` first differs from it after hydration or the caller
+ * releases it; `none` otherwise. Compare the result with `current` to know
+ * whether the open in effect is the settled one. The second element releases
+ * it: an overlay whose settled entry still runs a transition (a sheet's
+ * collapsed rise) calls it when that transition ends, so motion within the
+ * same open (a drag's settle) animates as usual.
+ *
+ * @param requested What the caller asks to have open (the `isOpen` prop, or
+ *   the switcher's `activeSheet` prop).
+ * @param current What is open in this render, once hydrated.
+ * @param none The value meaning nothing is open (`false` or `null`).
+ */
+export function useSettledOpen(requested, current, none) {
+  const isHydrating = useIsHydrating();
+  const [settled, setSettled] = useState(() => isHydrating ? requested : none);
+  if (settled !== none && !isHydrating && current !== settled) {
+    setSettled(none);
+  }
+  const release = useCallback(() => setSettled(none), [none]);
+  return [settled, release];
+}

package/dist/hooks/useStreamingText.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useStreamingText.d.ts","sourceRoot":"","sources":["../../src/hooks/useStreamingText.ts"],"names":[],"mappings":"AA+BA;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC;AAEhE,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,KAAK,CAAC,EAAE,kBAAkB,CAAC;CAC5B;AAwCD;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAW3E;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,OAAO,EACpB,OAAO,CAAC,EAAE,uBAAuB,GAChC,MAAM,CAiGR"}
+{"version":3,"file":"useStreamingText.d.ts","sourceRoot":"","sources":["../../src/hooks/useStreamingText.ts"],"names":[],"mappings":"AAoBA;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC;AAEhE,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,KAAK,CAAC,EAAE,kBAAkB,CAAC;CAC5B;AAuCD;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAU3E;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,OAAO,EACpB,OAAO,CAAC,EAAE,uBAAuB,GAChC,MAAM,CA2FR"}

package/dist/hooks/useStreamingText.js

@@ -4,21 +4,10 @@
 
 /**
  * @file useStreamingText.ts
- * @input Uses React useState, useEffect, useRef, useMediaQuery, useTheme
- * @output Exports useStreamingText hook for smooth text streaming
- * @position Core hook; smooths bursty streamed text into steady character reveal
- *
- * Decouples the arrival rate of streamed chunks from the display rate,
- * draining characters at a steady pace using requestAnimationFrame. The
- * reveal cadence advances by a fixed number of UTF-16 code units per tick;
- * the rendered slice is then snapped back to the nearest grapheme cluster
- * boundary (see snapToGraphemeBoundary) so a tick landing inside a
- * surrogate pair, flag sequence, or ZWJ emoji doesn't render a lone
- * surrogate or a partial glyph for one frame.
- *
- * Animation timing derives from Astryx motion tokens (via useTheme) when
- * an Theme provider is present. Falls back to sensible defaults when
- * used outside a theme provider.
+ * @input React state, effects and refs; useMediaQuery; useTheme
+ * @output useStreamingText hook for smooth text streaming
+ * @position Core hook; smooths bursty streamed text into a steady reveal.
+ *   Timing comes from the motion tokens, with defaults outside a theme.
  *
  * SYNC: When modified, update:
  * - /packages/core/src/hooks/index.ts (exports)
@@ -60,9 +49,8 @@ const CHARS_PER_TICK = {
   instant: Infinity
 };
 
-// Reuse a single segmenter when the runtime supports Intl.Segmenter.
-// Granularity is fixed and locale doesn't affect grapheme-cluster
-// boundaries, so one instance is safe to share across calls.
+// One shared segmenter. The granularity is fixed, and the locale does not
+// change grapheme boundaries.
 const graphemeSegmenter = typeof Intl.Segmenter === 'function' ? new Intl.Segmenter(undefined, {
   granularity: 'grapheme'
 }) : null;
@@ -87,9 +75,8 @@ export function snapToGraphemeBoundary(text, offset) {
     return offset;
   }
   if (graphemeSegmenter) {
-    // `containing` only returns undefined for an out-of-range index; offset
-    // is already guarded to [1, text.length - 1] above, so this is always
-    // defined at runtime — the `??` is to satisfy the type, which is wider.
+    // The guard above keeps offset in range, so `containing` is defined. The
+    // `??` satisfies the wider type.
     return graphemeSegmenter.segment(text).containing(offset)?.index ?? offset;
   }
   return isLowSurrogate(text.charCodeAt(offset)) ? offset - 1 : offset;
@@ -124,9 +111,8 @@ export function useStreamingText(targetText, isStreaming, options) {
   const speed = options?.speed ?? 'natural';
   const charsPerTick = CHARS_PER_TICK[speed];
 
-  // Derive tick timing from Astryx motion tokens when available.
-  // natural → --duration-fast-min (frame-level cadence from the theme)
-  // fast → half that, floored at 4ms (roughly 2x speed)
+  // Tick timing comes from the motion tokens: natural uses
+  // --duration-fast-min, and fast uses half of it, at least 4ms.
   const {
     token
   } = useTheme();
@@ -138,8 +124,8 @@ export function useStreamingText(targetText, isStreaming, options) {
     if (base == null) {
       return speed === 'fast' ? FALLBACK_TICK_MS_FAST : FALLBACK_TICK_MS;
     }
-    // Scale: use ~1/10th of the theme's fast-min duration as the per-frame tick.
-    // This maps a 130ms token to ~13ms tick (natural) or ~6.5ms tick (fast).
+    // The per-frame tick is about 1/10 of the fast-min duration, so a 130ms
+    // token gives a 13ms tick (natural) or a 6.5ms tick (fast).
     const tick = speed === 'fast' ? base / 20 : base / 10;
     return Math.max(4, Math.round(tick));
   }, [token, speed]);
@@ -148,8 +134,6 @@ export function useStreamingText(targetText, isStreaming, options) {
   const displayedLenRef = useRef(0);
   const lastTickRef = useRef(0);
   const rafRef = useRef(null);
-
-  // Keep target ref in sync
   targetRef.current = targetText;
 
   // Reset when target clears (new message)
@@ -161,8 +145,6 @@ export function useStreamingText(targetText, isStreaming, options) {
       setDisplayedLen(0);
     }
   }
-
-  // Snap to full text when streaming ends
   const prevIsStreamingRef = useRef(isStreaming);
   if (isStreaming !== prevIsStreamingRef.current) {
     prevIsStreamingRef.current = isStreaming;
@@ -172,13 +154,9 @@ export function useStreamingText(targetText, isStreaming, options) {
     }
   }
 
-  // Respect the user's reduced-motion preference — skip the progressive
-  // reveal and snap straight to the full text. Uses the package's SSR-safe
-  // useMediaQuery (useMediaQuery.ts) so the read stays in sync if the
-  // preference changes mid-stream.
+  // Reduced motion skips the progressive reveal and shows the full text.
+  // useMediaQuery follows a preference change mid-stream.
   const prefersReducedMotion = useMediaQuery('(prefers-reduced-motion: reduce)');
-
-  // Animation loop
   useEffect(() => {
     if (!isStreaming || speed === 'instant' || prefersReducedMotion) {
       return;

package/dist/hooks/useTreeFocus.d.ts

@@ -170,9 +170,19 @@ export type UseTreeFocusInternalOptions = UseTreeFocusOptions & {
      */
     matchLabelledBy?: boolean;
 };
+/** What the package's own components get beyond the public hook. */
+export type UseTreeFocusInternalReturn<T extends HTMLElement = HTMLElement> = UseTreeFocusReturn<T> & {
+    /**
+     * With `hasRovingTabIndex`, makes `item` the tree's one Tab stop, by the
+     * same rule the hook's own moves follow: a disabled or hidden row never
+     * takes it, and the stop stays where it is. TreeList calls it when it
+     * moves focus to a collapsing row.
+     */
+    takeTabStop: (item: HTMLElement) => void;
+};
 /**
  * The implementation behind {@link useTreeFocus}. Not exported from the
  * package; the public hook calls it without the internal options.
  */
-export declare function useTreeFocusInternal<T extends HTMLElement = HTMLElement>(options?: UseTreeFocusInternalOptions): UseTreeFocusReturn<T>;
+export declare function useTreeFocusInternal<T extends HTMLElement = HTMLElement>(options?: UseTreeFocusInternalOptions): UseTreeFocusInternalReturn<T>;
 //# sourceMappingURL=useTreeFocus.d.ts.map

package/dist/hooks/useTreeFocus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTreeFocus.d.ts","sourceRoot":"","sources":["../../src/hooks/useTreeFocus.ts"],"names":[],"mappings":"AAmCA;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC;IAEhD;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,MAAM,CAAC;IAEzC;;;;;OAKG;IACH,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC;IAE5C;;;;OAIG;IACH,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC;IAE7C;;;;;OAKG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,MAAM,GAAG,SAAS,CAAC;IAEtD;;;;OAIG;IACH,cAAc,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAEtC;;;;;;;;;OASG;IACH,UAAU,CAAC,EAAE,CACX,IAAI,EAAE,WAAW,EACjB,EAAE,EAAE,MAAM,GAAG,SAAS,KACnB,OAAO,GAAG,SAAS,CAAC;IAEzB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB,gEAAgE;IAChE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,cAAc,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC;IAElD;;;;;;;;;;;;;;;;OAgBG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW;IACrE,iEAAiE;IACjE,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAEnC,wDAAwD;IACxD,aAAa,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,aAAa,KAAK,IAAI,CAAC;IAEhD;;;;OAIG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;IAE3C,gDAAgD;IAChD,UAAU,EAAE,MAAM,IAAI,CAAC;IAEvB,+CAA+C;IAC/C,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB;AAwBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,wBAAgB,YAAY,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EAC9D,OAAO,GAAE,mBAAwB,GAChC,kBAAkB,CAAC,CAAC,CAAC,CAIvB;AAED;;;;;GAKG;AACH,MAAM,MAAM,2BAA2B,GAAG,mBAAmB,GAAG;IAC9D;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EACtE,OAAO,GAAE,2BAAgC,GACxC,kBAAkB,CAAC,CAAC,CAAC,CAiXvB"}
+{"version":3,"file":"useTreeFocus.d.ts","sourceRoot":"","sources":["../../src/hooks/useTreeFocus.ts"],"names":[],"mappings":"AAoCA;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC;IAEhD;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,MAAM,CAAC;IAEzC;;;;;OAKG;IACH,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC;IAE5C;;;;OAIG;IACH,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC;IAE7C;;;;;OAKG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,MAAM,GAAG,SAAS,CAAC;IAEtD;;;;OAIG;IACH,cAAc,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAEtC;;;;;;;;;OASG;IACH,UAAU,CAAC,EAAE,CACX,IAAI,EAAE,WAAW,EACjB,EAAE,EAAE,MAAM,GAAG,SAAS,KACnB,OAAO,GAAG,SAAS,CAAC;IAEzB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB,gEAAgE;IAChE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,cAAc,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC;IAElD;;;;;;;;;;;;;;;;OAgBG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW;IACrE,iEAAiE;IACjE,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAEnC,wDAAwD;IACxD,aAAa,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,aAAa,KAAK,IAAI,CAAC;IAEhD;;;;OAIG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;IAE3C,gDAAgD;IAChD,UAAU,EAAE,MAAM,IAAI,CAAC;IAEvB,+CAA+C;IAC/C,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB;AAwBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,wBAAgB,YAAY,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EAC9D,OAAO,GAAE,mBAAwB,GAChC,kBAAkB,CAAC,CAAC,CAAC,CAQvB;AAED;;;;;GAKG;AACH,MAAM,MAAM,2BAA2B,GAAG,mBAAmB,GAAG;IAC9D;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,oEAAoE;AACpE,MAAM,MAAM,0BAA0B,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,IACxE,kBAAkB,CAAC,CAAC,CAAC,GAAG;IACtB;;;;;OAKG;IACH,WAAW,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC;CAC1C,CAAC;AAEJ;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EACtE,OAAO,GAAE,2BAAgC,GACxC,0BAA0B,CAAC,CAAC,CAAC,CAoY/B"}

package/dist/hooks/useTreeFocus.js

@@ -16,6 +16,7 @@
 import { useCallback, useRef } from 'react';
 import { useIsomorphicLayoutEffect } from "./useIsomorphicLayoutEffect.js";
 import { isRtlElement } from "./isRtlElement.js";
+import { findTypeaheadMatch, nextTypeaheadBuffer } from "../utils/typeaheadMatch.js";
 
 /** Keys handled by the tree keyboard model (used to gate typeahead). */
 const NAVIGATION_KEYS = new Set(['ArrowDown', 'ArrowUp', 'ArrowRight', 'ArrowLeft', 'Home', 'End', 'Enter', ' ']);
@@ -89,11 +90,15 @@ function itemLabelText(item, matchLabelledBy) {
 
 export function useTreeFocus(options = {}) {
   // The flag is pinned off here so an untyped options object cannot smuggle
-  // it through the public hook.
-  return useTreeFocusInternal({
+  // it through the public hook, and the internal stop move stays internal.
+  const {
+    takeTabStop: _takeTabStop,
+    ...result
+  } = useTreeFocusInternal({
     ...options,
     matchLabelledBy: false
   });
+  return result;
 }
 
 /**
@@ -103,6 +108,8 @@ export function useTreeFocus(options = {}) {
  * `UseTreeFocusOptions` stays exactly as released.
  */
 
+/** What the package's own components get beyond the public hook. */
+
 /**
  * The implementation behind {@link useTreeFocus}. Not exported from the
  * package; the public hook calls it without the internal options.
@@ -223,13 +230,16 @@ export function useTreeFocusInternal(options = {}) {
   }, [getItems, focusEnabledFrom]);
   const runTypeahead = useCallback((e, items, currentIndex) => {
     const state = typeaheadRef.current;
+    // The same buffer step as useTypeahead: a repeat means "next match", and
+    // a lone combining mark typed first is not a letter to jump to.
+    const nextBuffer = nextTypeaheadBuffer(state.buffer, e.key);
+    if (nextBuffer == null) {
+      return;
+    }
     if (state.timer != null) {
       clearTimeout(state.timer);
     }
-    // "aa" would match nothing; a repeat means "next match" (useTypeahead).
-    const char = e.key.toLowerCase();
-    const isRepeatSameChar = state.buffer.length > 0 && state.buffer.split('').every(c => c === char);
-    state.buffer = isRepeatSameChar ? char : state.buffer + char;
+    state.buffer = nextBuffer;
     state.timer = setTimeout(() => {
       typeaheadRef.current.buffer = '';
     }, typeaheadResetMs);
@@ -239,7 +249,11 @@ export function useTreeFocusInternal(options = {}) {
     const start = hasCurrent ? currentIndex : 0;
     const offset = hasCurrent && query.length === 1 ? 1 : 0;
     const ordered = [...items.slice(start + offset), ...items.slice(0, start + offset)];
-    const match = ordered.find(item => !itemDisabled(item) && itemLabelText(item, matchLabelledBy).toLowerCase().startsWith(query));
+    const enabled = ordered.filter(item => !itemDisabled(item));
+    // Case, accents, stroked letters and Turkish i fold away, and a typed
+    // mark prefers the exact match.
+    const matchIndex = findTypeaheadMatch(enabled.map((_, i) => i), i => itemLabelText(enabled[i], matchLabelledBy), query);
+    const match = matchIndex >= 0 ? enabled[matchIndex] : undefined;
     if (match != null) {
       e.preventDefault();
       focusItem(match);
@@ -382,11 +396,21 @@ export function useTreeFocusInternal(options = {}) {
       syncTabStops();
     }
   }, [hasRovingTabIndex, syncTabStops]);
+  const takeTabStop = useCallback(item => {
+    if (!hasRovingTabIndex || itemDisabled(item)) {
+      return;
+    }
+    const items = getItems();
+    if (items.includes(item)) {
+      moveTabStop(items, item);
+    }
+  }, [getItems, hasRovingTabIndex, itemDisabled, moveTabStop]);
   return {
     treeRef,
     handleKeyDown,
     handleFocus,
     focusFirst,
-    focusLast
+    focusLast,
+    takeTabStop
   };
 }

package/dist/hooks/useTypeahead.d.ts

@@ -41,7 +41,9 @@ export interface UseTypeaheadReturn {
  * First-character ("type-ahead") search for a collection.
  *
  * Buffers printable keystrokes (resetting after `resetMs` of inactivity),
- * matches items whose label starts with the buffer, and cycles from the
+ * matches items whose label starts with the buffer (ignoring case, accents,
+ * stroked letters and Turkish dotted/dotless i, the same in every locale:
+ * `architecture:internationalization` INV17), and cycles from the
  * current index — so pressing "s" repeatedly walks through the "s" items
  * instead of sticking on the first. Space is reserved for activation and is
  * only treated as typeahead while a buffer is already active.

package/dist/hooks/useTypeahead.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTypeahead.d.ts","sourceRoot":"","sources":["../../src/hooks/useTypeahead.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,aAAa,EAAE,MAAM,aAAa,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;IAE9D;;;OAGG;IACH,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAEjC;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,MAAM,CAAC;IAE/B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;CACzC;AAED,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,SAAS,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,aAAa,GAAG,aAAa,KAAK,OAAO,CAAC;IAC/D,gDAAgD;IAChD,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AA+BD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,kBAAkB,CAmG7E"}
+{"version":3,"file":"useTypeahead.d.ts","sourceRoot":"","sources":["../../src/hooks/useTypeahead.ts"],"names":[],"mappings":"AAoBA,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,aAAa,EAAE,MAAM,aAAa,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;IAE9D;;;OAGG;IACH,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAEjC;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,MAAM,CAAC;IAE/B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;CACzC;AAED,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,SAAS,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,aAAa,GAAG,aAAa,KAAK,OAAO,CAAC;IAC/D,gDAAgD;IAChD,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AA+BD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,kBAAkB,CAgG7E"}

package/dist/hooks/useTypeahead.js

@@ -4,7 +4,8 @@
 
 /**
  * @file useTypeahead.ts
- * @input Uses React useCallback/useEffect/useRef
+ * @input Uses React useCallback/useEffect/useRef, shared type-to-select
+ *   matching (utils/typeaheadMatch)
  * @output Exports useTypeahead hook for first-character (type-to-focus) search
  * @position Core hook; adds APG typeahead to menus, listboxes, and other
  *   collections. Composes with useListFocus/useGridFocus (or any collection)
@@ -14,6 +15,7 @@
  * - /packages/core/src/hooks/index.ts
  */
 import { useCallback, useEffect, useRef } from 'react';
+import { findTypeaheadMatch, nextTypeaheadBuffer } from "../utils/typeaheadMatch.js";
 /**
  * Whether a key event represents a single printable character (a type-to-focus
  * candidate) rather than a control/navigation key or a shortcut chord.
@@ -43,7 +45,9 @@ function isComposingKey(e) {
  * First-character ("type-ahead") search for a collection.
  *
  * Buffers printable keystrokes (resetting after `resetMs` of inactivity),
- * matches items whose label starts with the buffer, and cycles from the
+ * matches items whose label starts with the buffer (ignoring case, accents,
+ * stroked letters and Turkish dotted/dotless i, the same in every locale:
+ * `architecture:internationalization` INV17), and cycles from the
  * current index — so pressing "s" repeatedly walks through the "s" items
  * instead of sticking on the first. Space is reserved for activation and is
  * only treated as typeahead while a buffer is already active.
@@ -102,16 +106,18 @@ export function useTypeahead(options) {
     if (!isPrintableCharacter(e) && !isSpaceMidType) {
       return false;
     }
+
+    // A lone combining mark typed first is not a letter to jump to; after
+    // a letter it is part of that letter. A repeat of the same letter
+    // cycles rather than filtering deeper (APG behavior).
+    const nextBuffer = nextTypeaheadBuffer(bufferRef.current, e.key);
+    if (nextBuffer == null) {
+      return false;
+    }
     const labels = getItemLabels();
     if (labels.length === 0) {
       return false;
     }
-
-    // Pressing the SAME single character repeatedly cycles to the next match
-    // rather than filtering deeper (APG behavior).
-    const char = e.key.toLowerCase();
-    const isRepeatSameChar = bufferRef.current.length > 0 && bufferRef.current.split('').every(c => c === char);
-    const nextBuffer = isRepeatSameChar ? char : bufferRef.current + char;
     bufferRef.current = nextBuffer;
     scheduleReset();
     const current = getCurrentIndex?.() ?? -1;
@@ -124,17 +130,17 @@ export function useTypeahead(options) {
     // Once the buffer is longer it is refining a match, so the current item
     // stays in range. With nothing current there is nothing to advance past.
     const offset = hasCurrent && nextBuffer.length === 1 ? 1 : 0;
+    const order = [];
     for (let i = 0; i < count; i++) {
       const index = (start + offset + i + count) % count;
-      if (isDisabled?.(index)) {
-        continue;
-      }
-      const label = labels[index];
-      if (label != null && label.trim().toLowerCase().startsWith(nextBuffer)) {
-        onMatch(index);
-        return true;
+      if (!isDisabled?.(index)) {
+        order.push(index);
       }
     }
+    const match = findTypeaheadMatch(order, i => labels[i], nextBuffer);
+    if (match >= 0) {
+      onMatch(match);
+    }
     return true;
   }, [getItemLabels, onMatch, getCurrentIndex, scheduleReset, isDisabled]);
   return {

package/dist/i18n/InternationalizationContext.d.ts

@@ -8,7 +8,7 @@ export interface InternationalizationContextValue {
     translate: ReturnType<typeof getResolve>;
 }
 /**
- * Default value falls through to the shipped en catalog in resolve().
+ * Default value falls through to the shipped English fallback in resolve().
  * A consumer that doesn't render a provider still gets English defaults.
  */
 export declare const InternationalizationContext: import("react").Context<InternationalizationContextValue>;

package/dist/i18n/InternationalizationContext.js

@@ -24,7 +24,7 @@
 import { createContext } from 'react';
 import { getResolve } from "./resolve.js";
 /**
- * Default value falls through to the shipped en catalog in resolve().
+ * Default value falls through to the shipped English fallback in resolve().
  * A consumer that doesn't render a provider still gets English defaults.
  */
 export const InternationalizationContext = /*#__PURE__*/createContext({

package/dist/i18n/englishFallback.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @file englishFallback.ts
+ * @input English key-to-message maps registered at module scope by the Core
+ *   modules that name those keys
+ * @output registerEnglishFallback and the read-only englishFallback map
+ * @position The shipped English fallback resolve.ts reads after the locale
+ *   chain.
+ *
+ * A Core module that names catalog keys registers the English for exactly
+ * those keys from its generated map (`i18n/generated-english/`, derived by
+ * scripts/generate-i18n-runtime.mjs):
+ *
+ *   import english from '../i18n/generated-english/Button/Button.generated';
+ *   registerEnglishFallback(english);
+ *
+ * so a component carries the English it can show rather than the whole
+ * catalog. Registration runs when the module loads, before any of its code
+ * can look a key up, so a key resolves wherever the module naming it is
+ * loaded. Public paths that resolve arbitrary Astryx keys register the whole
+ * catalog through fullEnglishFallback.ts.
+ *
+ * SYNC: When modified, update these files to stay in sync:
+ * - /packages/core/src/i18n/resolve.ts
+ * - /packages/core/src/i18n/fullEnglishFallback.ts
+ * - /scripts/i18n-english-fallback.mjs
+ */
+import type { RuntimeCatalog } from './types.js';
+/** The English registered so far, keyed by catalog key. */
+export declare const englishFallback: RuntimeCatalog;
+/** Add a module's English to the shipped fallback. */
+export declare function registerEnglishFallback(messages: RuntimeCatalog): void;
+//# sourceMappingURL=englishFallback.d.ts.map

package/dist/i18n/englishFallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"englishFallback.d.ts","sourceRoot":"","sources":["../../src/i18n/englishFallback.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,SAAS,CAAC;AAI5C,2DAA2D;AAC3D,eAAO,MAAM,eAAe,EAAE,cAA2B,CAAC;AAE1D,sDAAsD;AACtD,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI,CAEtE"}

package/dist/i18n/englishFallback.js

@@ -0,0 +1,38 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file englishFallback.ts
+ * @input English key-to-message maps registered at module scope by the Core
+ *   modules that name those keys
+ * @output registerEnglishFallback and the read-only englishFallback map
+ * @position The shipped English fallback resolve.ts reads after the locale
+ *   chain.
+ *
+ * A Core module that names catalog keys registers the English for exactly
+ * those keys from its generated map (`i18n/generated-english/`, derived by
+ * scripts/generate-i18n-runtime.mjs):
+ *
+ *   import english from '../i18n/generated-english/Button/Button.generated';
+ *   registerEnglishFallback(english);
+ *
+ * so a component carries the English it can show rather than the whole
+ * catalog. Registration runs when the module loads, before any of its code
+ * can look a key up, so a key resolves wherever the module naming it is
+ * loaded. Public paths that resolve arbitrary Astryx keys register the whole
+ * catalog through fullEnglishFallback.ts.
+ *
+ * SYNC: When modified, update these files to stay in sync:
+ * - /packages/core/src/i18n/resolve.ts
+ * - /packages/core/src/i18n/fullEnglishFallback.ts
+ * - /scripts/i18n-english-fallback.mjs
+ */
+
+const registered = {};
+
+/** The English registered so far, keyed by catalog key. */
+export const englishFallback = registered;
+
+/** Add a module's English to the shipped fallback. */
+export function registerEnglishFallback(messages) {
+  Object.assign(registered, messages);
+}