@ankhorage/zora 25.8.11 → 25.8.13

package/src/features/layout/adapters/inbound/ScrollView.test.tsx

@@ -0,0 +1,234 @@
+// Renders the real ZORA ScrollView through react-native-web in a private happy-dom window.
+// The module mocks below are process-wide in Bun, so this file relies on the repository's
+// `bun test --isolate` script; DOM globals are restored in afterAll.
+import { afterAll, expect, mock, test } from 'bun:test';
+import { Window } from 'happy-dom';
+import React, { act } from 'react';
+import { createRoot } from 'react-dom/client';
+
+import type { ScrollGestureLock } from '../../../../types/layout';
+
+const browser = new Window();
+const globalKeys = [
+  'window',
+  'document',
+  'Node',
+  'navigator',
+  'ShadowRoot',
+  'IS_REACT_ACT_ENVIRONMENT',
+] as const;
+const previousGlobals = globalKeys.map(
+  (key) => [key, Object.getOwnPropertyDescriptor(globalThis, key)] as const,
+);
+Object.assign(globalThis, {
+  IS_REACT_ACT_ENVIRONMENT: true,
+  Node: browser.Node,
+  ShadowRoot: browser.ShadowRoot,
+  document: browser.document,
+  navigator: browser.navigator,
+  window: browser,
+});
+
+const reactNativeWeb = await import('react-native-web');
+await mock.module('react-native', () => reactNativeWeb);
+// ZORA's ScrollView only needs Surface's ScrollView and ThemeScope; the real package would load
+// native-only peers, so the DOM-capable react-native-web ScrollView stands in for the primitive.
+await mock.module('@ankhorage/surface', () => ({
+  ScrollView: reactNativeWeb.ScrollView,
+  ThemeScope: ({ children }: { readonly children: React.ReactNode }) => children,
+}));
+const { ScrollView } = await import('./ScrollView');
+const { useScrollGestureLock } = await import('./useScrollGestureLock');
+
+afterAll(() => {
+  browser.close();
+  for (const [key, descriptor] of previousGlobals) {
+    if (descriptor) Object.defineProperty(globalThis, key, descriptor);
+    else Reflect.deleteProperty(globalThis, key);
+  }
+});
+
+interface Mounted {
+  readonly deliveredScrolls: string[];
+  readonly locks: Map<string, ScrollGestureLock>;
+  readonly render: (element: React.ReactNode) => Promise<void>;
+  readonly swipe: (testID: string) => Promise<boolean>;
+  readonly unmount: () => Promise<void>;
+}
+
+/*** Mounts elements in a fresh container and records which ScrollViews still receive scroll input. */
+function mount(): Mounted {
+  const host = document.createElement('div');
+  document.body.append(host);
+  const root = createRoot(host);
+  const deliveredScrolls: string[] = [];
+  const locks = new Map<string, ScrollGestureLock>();
+  return {
+    deliveredScrolls,
+    locks,
+    render: (element) => act(() => Promise.resolve().then(() => root.render(element))),
+    // A disabled react-native-web ScrollView stops delivering wheel input to its handlers.
+    swipe: async (testID) => {
+      const target = host.querySelector<HTMLElement>(`[data-testid="${testID}"]`);
+      if (!target) throw new Error(`Missing ${testID}`);
+      const before = deliveredScrolls.length;
+      await act(() =>
+        Promise.resolve().then(() =>
+          target.dispatchEvent(new browser.Event('wheel', { bubbles: true })),
+        ),
+      );
+      // Bubbling may also reach an enabled ancestor, so only the scrolled ScrollView counts.
+      return deliveredScrolls.slice(before).includes(testID);
+    },
+    unmount: async () => {
+      await act(() => Promise.resolve().then(() => root.unmount()));
+      host.remove();
+    },
+  };
+}
+
+/*** Renders a tracked ZORA ScrollView whose descendants can reach its gesture lock. */
+function TrackedScrollView({
+  children,
+  id,
+  mounted,
+  scrollEnabled,
+}: {
+  readonly children?: React.ReactNode;
+  readonly id: string;
+  readonly mounted: Mounted;
+  readonly scrollEnabled?: boolean;
+}) {
+  return (
+    <ScrollView
+      scrollEnabled={scrollEnabled}
+      testID={id}
+      onWheel={() => mounted.deliveredScrolls.push(id)}
+    >
+      <LockProbe id={`${id}-lock`} mounted={mounted} />
+      {children}
+    </ScrollView>
+  );
+}
+
+/*** Publishes the nearest ScrollView gesture lock under a stable name. */
+function LockProbe({ id, mounted }: { readonly id: string; readonly mounted: Mounted }) {
+  mounted.locks.set(id, useScrollGestureLock());
+  return null;
+}
+
+/*** Acquires a lock inside React's act boundary so the ScrollView state update flushes. */
+async function acquire(mounted: Mounted, id: string): Promise<() => Promise<void>> {
+  let release: (() => void) | undefined;
+  await act(() =>
+    Promise.resolve().then(() => {
+      release = mounted.locks.get(id)?.acquire();
+    }),
+  );
+  return () =>
+    act(() =>
+      Promise.resolve().then(() => {
+        release?.();
+      }),
+    );
+}
+
+test('delivers scroll input to an unlocked ScrollView and suspends it while a descendant holds the lock', async () => {
+  const mounted = mount();
+  try {
+    await mounted.render(<TrackedScrollView id="page" mounted={mounted} />);
+    expect(await mounted.swipe('page')).toBe(true);
+
+    const release = await acquire(mounted, 'page-lock');
+    expect(await mounted.swipe('page')).toBe(false);
+
+    await release();
+    expect(await mounted.swipe('page')).toBe(true);
+  } finally {
+    await mounted.unmount();
+  }
+});
+
+test('suspends every ancestor ScrollView of a nested gesture and restores them together', async () => {
+  const mounted = mount();
+  try {
+    await mounted.render(
+      <TrackedScrollView id="outer" mounted={mounted}>
+        <TrackedScrollView id="inner" mounted={mounted} />
+      </TrackedScrollView>,
+    );
+
+    const release = await acquire(mounted, 'inner-lock');
+    expect(await mounted.swipe('inner')).toBe(false);
+    expect(await mounted.swipe('outer')).toBe(false);
+
+    await release();
+    expect(await mounted.swipe('inner')).toBe(true);
+    expect(await mounted.swipe('outer')).toBe(true);
+  } finally {
+    await mounted.unmount();
+  }
+});
+
+test('does not suspend sibling ScrollViews or the descendants of an outer ScrollView that did not lock', async () => {
+  const mounted = mount();
+  try {
+    await mounted.render(
+      <>
+        <TrackedScrollView id="left" mounted={mounted} />
+        <TrackedScrollView id="right" mounted={mounted} />
+      </>,
+    );
+
+    const release = await acquire(mounted, 'left-lock');
+    expect(await mounted.swipe('left')).toBe(false);
+    expect(await mounted.swipe('right')).toBe(true);
+
+    await release();
+    expect(await mounted.swipe('left')).toBe(true);
+  } finally {
+    await mounted.unmount();
+  }
+});
+
+test('keeps scrolling suspended until every simultaneous owner has released, and ignores double releases', async () => {
+  const mounted = mount();
+  try {
+    await mounted.render(<TrackedScrollView id="page" mounted={mounted} />);
+
+    const releaseFirst = await acquire(mounted, 'page-lock');
+    const releaseSecond = await acquire(mounted, 'page-lock');
+    await releaseFirst();
+    expect(await mounted.swipe('page')).toBe(false);
+
+    await releaseFirst();
+    expect(await mounted.swipe('page')).toBe(false);
+
+    await releaseSecond();
+    expect(await mounted.swipe('page')).toBe(true);
+
+    const releaseThird = await acquire(mounted, 'page-lock');
+    expect(await mounted.swipe('page')).toBe(false);
+    await releaseThird();
+    expect(await mounted.swipe('page')).toBe(true);
+  } finally {
+    await mounted.unmount();
+  }
+});
+
+test('never re-enables a ScrollView that the caller disabled explicitly', async () => {
+  const mounted = mount();
+  try {
+    await mounted.render(<TrackedScrollView id="page" mounted={mounted} scrollEnabled={false} />);
+    expect(await mounted.swipe('page')).toBe(false);
+
+    const release = await acquire(mounted, 'page-lock');
+    await release();
+    expect(await mounted.swipe('page')).toBe(false);
+
+    await mounted.render(<TrackedScrollView id="page" mounted={mounted} scrollEnabled />);
+    expect(await mounted.swipe('page')).toBe(true);
+  } finally {
+    await mounted.unmount();
+  }
+});

package/src/features/layout/adapters/inbound/ScrollView.tsx

@@ -3,16 +3,32 @@ import React from 'react';
 
 import type { ScrollViewProps } from '../../../../types/layout';
 import { withZoraThemeScope } from '../../../theme/adapters/inbound/withZoraThemeScope';
+import { createScrollGestureLock } from '../../utils/createScrollGestureLock';
+import { ScrollGestureLockContext } from './ScrollGestureLockContext';
+import { useScrollGestureLock } from './useScrollGestureLock';
 
 /*** Adapts the token-aware Surface ScrollView primitive to ZORA theme scope. */
 export const ScrollView = withZoraThemeScope(ScrollViewInner);
 
-/*** Forwards ZORA scrolling props to the published Surface ScrollView boundary. */
+/*** Forwards ZORA scrolling props to the published Surface ScrollView boundary and yields scrolling to active descendant gestures. */
 function ScrollViewInner({
   themeId: _themeId,
   mode: _mode,
   interactionPolicy: _interactionPolicy,
+  scrollEnabled = true,
   ...props
 }: ScrollViewProps) {
-  return <SurfaceScrollView {...props} />;
+  const parentLock = useScrollGestureLock();
+  const [activeGestures, setActiveGestures] = React.useState(0);
+  const lock = React.useMemo(
+    () =>
+      createScrollGestureLock(parentLock, (delta) => setActiveGestures((count) => count + delta)),
+    [parentLock],
+  );
+
+  return (
+    <ScrollGestureLockContext.Provider value={lock}>
+      <SurfaceScrollView {...props} scrollEnabled={scrollEnabled && activeGestures === 0} />
+    </ScrollGestureLockContext.Provider>
+  );
 }

package/src/features/layout/adapters/inbound/useScrollGestureLock.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+
+import type { ScrollGestureLock } from '../../../../types/layout';
+import { ScrollGestureLockContext } from './ScrollGestureLockContext';
+
+const unlockedScrollGesture: ScrollGestureLock = { acquire: () => () => undefined };
+
+/*** Resolves the nearest ZORA ScrollView lock, or an inert lock when no scroll container exists. */
+export function useScrollGestureLock(): ScrollGestureLock {
+  return React.useContext(ScrollGestureLockContext) ?? unlockedScrollGesture;
+}

package/src/features/layout/public.ts

@@ -3,6 +3,7 @@ export type {
   DividerProps,
   GridProps,
   ScreenProps,
+  ScrollGestureLock,
   ScrollViewProps,
   ViewProps,
 } from '../../types/layout';
@@ -11,4 +12,5 @@ export { Divider } from './adapters/inbound/Divider';
 export { Grid } from './adapters/inbound/Grid';
 export { Screen } from './adapters/inbound/Screen';
 export { ScrollView } from './adapters/inbound/ScrollView';
+export { useScrollGestureLock } from './adapters/inbound/useScrollGestureLock';
 export { View } from './adapters/inbound/View';

package/src/features/layout/utils/createScrollGestureLock.test.ts

@@ -0,0 +1,34 @@
+import { expect, test } from 'bun:test';
+
+import type { ScrollGestureLock } from '../../../types/layout';
+import { createScrollGestureLock } from './createScrollGestureLock';
+
+const inertParent: ScrollGestureLock = { acquire: () => () => undefined };
+
+test('reports one active gesture per acquisition and releases each exactly once', () => {
+  const deltas: number[] = [];
+  const lock = createScrollGestureLock(inertParent, (delta) => deltas.push(delta));
+
+  const releaseFirst = lock.acquire();
+  const releaseSecond = lock.acquire();
+  releaseFirst();
+  releaseFirst();
+  releaseSecond();
+
+  expect(deltas).toEqual([1, 1, -1, -1]);
+});
+
+test('suspends nested ancestor containers for the lifetime of the gesture', () => {
+  const outerDeltas: number[] = [];
+  const innerDeltas: number[] = [];
+  const outer = createScrollGestureLock(inertParent, (delta) => outerDeltas.push(delta));
+  const inner = createScrollGestureLock(outer, (delta) => innerDeltas.push(delta));
+
+  const release = inner.acquire();
+  expect(outerDeltas).toEqual([1]);
+  expect(innerDeltas).toEqual([1]);
+  release();
+
+  expect(outerDeltas).toEqual([1, -1]);
+  expect(innerDeltas).toEqual([1, -1]);
+});

package/src/features/layout/utils/createScrollGestureLock.ts

@@ -0,0 +1,21 @@
+import type { ScrollGestureLock } from '../../../types/layout';
+
+/*** Creates a lock that reports each held gesture to its scroll container and also suspends every ancestor container. */
+export function createScrollGestureLock(
+  parent: ScrollGestureLock,
+  onActiveGesturesChange: (delta: 1 | -1) => void,
+): ScrollGestureLock {
+  return {
+    acquire: () => {
+      const releaseParent = parent.acquire();
+      let released = false;
+      onActiveGesturesChange(1);
+      return () => {
+        if (released) return;
+        released = true;
+        onActiveGesturesChange(-1);
+        releaseParent();
+      };
+    },
+  };
+}

package/src/types/grid-interactions.ts

@@ -70,3 +70,9 @@ export interface GridInteractionsController {
   readonly keyDown: (key: string, pointer?: GridInteractionPointer) => boolean;
   readonly update: (props: GridInteractionsControllerProps) => void;
 }
+
+/** Gesture-scoped ownership of ancestor scrolling for one interaction surface. */
+export interface GridInteractionScrollLock {
+  readonly acquire: () => void;
+  readonly release: () => void;
+}

package/src/types/grid-view.ts

@@ -68,3 +68,48 @@ export interface TileGridProps extends ZoraBaseProps {
   onVisibleItemIdsChange?: (ids: readonly string[]) => void;
   renderItem: (item: TileGridItem) => React.ReactNode;
 }
+
+/** The two independent native scroll axes that back a GridView viewport. */
+export type GridScrollAxis = 'x' | 'y';
+
+/** A physical native scroll position in pixels. */
+export interface GridScrollPosition {
+  readonly x: number;
+  readonly y: number;
+}
+
+/** A programmatic native scroll request that GridView is still waiting to observe. */
+export interface GridPendingScroll {
+  readonly animated: boolean;
+  readonly expiresAt: number;
+  readonly target: number;
+}
+
+/** Native capabilities and clock used by the programmatic-versus-user scroll arbiter. */
+export interface GridScrollSyncOptions {
+  /** Requests a native scroll of one axis. */
+  readonly scrollTo: (axis: GridScrollAxis, offset: number, animated: boolean) => void;
+  /** Reports a genuine user scroll as the pixel displacement of the native offset. */
+  readonly onUserScroll: (axis: GridScrollAxis, displacement: number) => void;
+  /** Reconciles a late programmatic native frame without classifying it as a user pan. */
+  readonly onProgrammaticScroll: (axis: GridScrollAxis, displacement: number) => void;
+  readonly now?: () => number;
+  readonly schedule?: (callback: () => void, delay: number) => ReturnType<typeof setTimeout>;
+  readonly cancel?: (handle: ReturnType<typeof setTimeout>) => void;
+}
+
+/** Separates echoes of programmatic scrolls from user scrolling, independently per axis. */
+export interface GridScrollSync {
+  /** True when the baseline already matches the position within native tolerance. */
+  readonly isCurrent: (position: GridScrollPosition) => boolean;
+  /** Moves native scrolling to a viewport-derived position. */
+  readonly request: (position: GridScrollPosition, animated: boolean) => void;
+  /** Routes one native scroll event. */
+  readonly scrolled: (axis: GridScrollAxis, offset: number) => void;
+  /** Hands an axis to the user, adopting the native offset at the start of their drag. */
+  readonly dragBegan: (axis: GridScrollAxis, offset: number) => void;
+  /** Adopts the final native offset when a programmatic or momentum scroll ends. */
+  readonly scrollEnded: (axis: GridScrollAxis, offset: number) => void;
+  /** Cancels every pending settle timer. */
+  readonly dispose: () => void;
+}

package/src/types/layout.ts

@@ -30,3 +30,9 @@ export interface ScreenProps extends ZoraBaseProps {
   scroll?: boolean;
   width?: ZoraContentWidth;
 }
+
+/** Exclusive-gesture coordination between a ZORA scroll container and its descendant surfaces. */
+export interface ScrollGestureLock {
+  /** Suspends scrolling until the returned release function runs; releasing twice is harmless. */
+  readonly acquire: () => () => void;
+}

package/web-dist/chunks/{Accordion-v3rzy273.js → Accordion-11ej93t5.js}

@@ -1,16 +1,16 @@
 'use client';
 import {
   Button2
-} from "./Accordion-h4ekm5cp.js";
+} from "./Accordion-czcaf5x2.js";
 import {
   withZoraThemeScope
 } from "./Accordion-vj1m2wck.js";
 import {
   View2
-} from "./Accordion-vbzjq3z8.js";
+} from "./Accordion-ep35792s.js";
 import {
   Card2
-} from "./Accordion-wcmrasqx.js";
+} from "./Accordion-rqr10gn4.js";
 import {
   Text3
 } from "./Accordion-9rnsg9pk.js";

package/web-dist/chunks/{Accordion-ddrn94v3.js → Accordion-1hbt9k69.js}

@@ -4,7 +4,7 @@ import {
 } from "./Accordion-vj1m2wck.js";
 import {
   View2
-} from "./Accordion-vbzjq3z8.js";
+} from "./Accordion-ep35792s.js";
 import {
   Text3
 } from "./Accordion-9rnsg9pk.js";

package/web-dist/chunks/{Accordion-wpk8dxqp.js → Accordion-26prtnm7.js}

@@ -19,7 +19,7 @@ import {
 } from "./Accordion-vj1m2wck.js";
 import {
   View2
-} from "./Accordion-vbzjq3z8.js";
+} from "./Accordion-ep35792s.js";
 import {
   Text3
 } from "./Accordion-9rnsg9pk.js";

package/web-dist/chunks/{Accordion-0q2wzjdd.js → Accordion-2jy53kzk.js}

@@ -14,7 +14,7 @@ import {
 import {
   View2,
   Divider2
-} from "./Accordion-vbzjq3z8.js";
+} from "./Accordion-ep35792s.js";
 import {
   Pressable
 } from "./Accordion-nnv76yff.js";
@@ -23,7 +23,7 @@ import {
 } from "./Accordion-wyxmd0n0.js";
 import {
   SectionHeader2
-} from "./Accordion-ts788t7b.js";
+} from "./Accordion-g08740h4.js";
 import {
   useZoraTheme2
 } from "./Accordion-srjya6dz.js";

package/web-dist/chunks/{Accordion-geah5s4f.js → Accordion-4yq92mxp.js}

@@ -10,7 +10,7 @@ import {
 } from "./Accordion-1fsrnq73.js";
 import {
   View2
-} from "./Accordion-vbzjq3z8.js";
+} from "./Accordion-ep35792s.js";
 import {
   Text3
 } from "./Accordion-9rnsg9pk.js";

package/web-dist/chunks/{Accordion-8pkw32q9.js → Accordion-5pr1wqe3.js}

@@ -7,7 +7,7 @@ import {
 } from "./Accordion-vj1m2wck.js";
 import {
   View2
-} from "./Accordion-vbzjq3z8.js";
+} from "./Accordion-ep35792s.js";
 import {
   useZoraTheme2
 } from "./Accordion-srjya6dz.js";

package/web-dist/chunks/{Accordion-y3083394.js → Accordion-799z2zf6.js}

@@ -10,7 +10,7 @@ import {
 } from "./Accordion-1fsrnq73.js";
 import {
   View2
-} from "./Accordion-vbzjq3z8.js";
+} from "./Accordion-ep35792s.js";
 import {
   useZoraTheme2
 } from "./Accordion-srjya6dz.js";

package/web-dist/chunks/{Accordion-hecpczme.js → Accordion-9aczb0k2.js}

@@ -7,13 +7,13 @@ import {
 } from "./Accordion-vj1m2wck.js";
 import {
   View2
-} from "./Accordion-vbzjq3z8.js";
+} from "./Accordion-ep35792s.js";
 import {
   Text3
 } from "./Accordion-9rnsg9pk.js";
 import {
   Avatar2
-} from "./Accordion-w59y0jdf.js";
+} from "./Accordion-tyh8jj9d.js";
 import {
   Badge2
 } from "./Accordion-xgxxg1hz.js";

package/web-dist/chunks/{Accordion-rctfgyfv.js → Accordion-a4pz3vjj.js}

@@ -8,7 +8,7 @@ import {
 import {
   View2,
   Divider2
-} from "./Accordion-vbzjq3z8.js";
+} from "./Accordion-ep35792s.js";
 import {
   Heading2,
   Text3

package/web-dist/chunks/{Accordion-9jrxktne.js → Accordion-b337t2df.js}

@@ -28,7 +28,7 @@ import {
 } from "./Accordion-1fsrnq73.js";
 import {
   View2
-} from "./Accordion-vbzjq3z8.js";
+} from "./Accordion-ep35792s.js";
 import {
   resolveIconSize
 } from "./Accordion-961ncx4e.js";

package/web-dist/chunks/{Accordion-h4ekm5cp.js → Accordion-czcaf5x2.js}

@@ -19,7 +19,7 @@ import {
 } from "./Accordion-vj1m2wck.js";
 import {
   View2
-} from "./Accordion-vbzjq3z8.js";
+} from "./Accordion-ep35792s.js";
 import {
   resolveControlSize,
   resolveIconSize2,

package/web-dist/chunks/{Accordion-vbzjq3z8.js → Accordion-ep35792s.js}

@@ -251,6 +251,40 @@ function splitLayoutProps(props) {
   };
 }
 
+// src/features/layout/adapters/inbound/ScrollView.tsx
+import React4 from "react";
+
+// src/features/layout/utils/createScrollGestureLock.ts
+function createScrollGestureLock(parent, onActiveGesturesChange) {
+  return {
+    acquire: () => {
+      const releaseParent = parent.acquire();
+      let released = false;
+      onActiveGesturesChange(1);
+      return () => {
+        if (released)
+          return;
+        released = true;
+        onActiveGesturesChange(-1);
+        releaseParent();
+      };
+    }
+  };
+}
+
+// src/features/layout/adapters/inbound/ScrollGestureLockContext.ts
+import React2 from "react";
+var ScrollGestureLockContext = React2.createContext(undefined);
+
+// src/features/layout/adapters/inbound/useScrollGestureLock.ts
+import React3 from "react";
+var unlockedScrollGesture = { acquire: () => () => {
+  return;
+} };
+function useScrollGestureLock() {
+  return React3.useContext(ScrollGestureLockContext) ?? unlockedScrollGesture;
+}
+
 // src/features/layout/adapters/inbound/ScrollView.tsx
 import { jsx as jsx7 } from "react/jsx-runtime";
 var ScrollView2 = withZoraThemeScope(ScrollViewInner);
@@ -258,10 +292,18 @@ function ScrollViewInner({
   themeId: _themeId,
   mode: _mode,
   interactionPolicy: _interactionPolicy,
+  scrollEnabled = true,
   ...props
 }) {
-  return /* @__PURE__ */ jsx7(ScrollView, {
-    ...props
+  const parentLock = useScrollGestureLock();
+  const [activeGestures, setActiveGestures] = React4.useState(0);
+  const lock = React4.useMemo(() => createScrollGestureLock(parentLock, (delta) => setActiveGestures((count) => count + delta)), [parentLock]);
+  return /* @__PURE__ */ jsx7(ScrollGestureLockContext.Provider, {
+    value: lock,
+    children: /* @__PURE__ */ jsx7(ScrollView, {
+      ...props,
+      scrollEnabled: scrollEnabled && activeGestures === 0
+    })
   });
 }
 

package/web-dist/chunks/{Accordion-ts788t7b.js → Accordion-g08740h4.js}

@@ -4,7 +4,7 @@ import {
 } from "./Accordion-vj1m2wck.js";
 import {
   View2
-} from "./Accordion-vbzjq3z8.js";
+} from "./Accordion-ep35792s.js";
 import {
   Heading2,
   Text3

package/web-dist/chunks/{Accordion-9ygakvwk.js → Accordion-g2aqhct0.js}

@@ -4,16 +4,16 @@ import {
 } from "./Accordion-vj1m2wck.js";
 import {
   View2
-} from "./Accordion-vbzjq3z8.js";
+} from "./Accordion-ep35792s.js";
 import {
   ButtonGroup2
-} from "./Accordion-h4ekm5cp.js";
+} from "./Accordion-czcaf5x2.js";
 import {
   Card2
-} from "./Accordion-wcmrasqx.js";
+} from "./Accordion-rqr10gn4.js";
 import {
   List2
-} from "./Accordion-0q2wzjdd.js";
+} from "./Accordion-2jy53kzk.js";
 import {
   useZoraTheme2
 } from "./Accordion-srjya6dz.js";

package/web-dist/chunks/{Accordion-p1ebrt17.js → Accordion-gn8ptzwb.js}

@@ -7,7 +7,7 @@ import {
 } from "./Accordion-vj1m2wck.js";
 import {
   View2
-} from "./Accordion-vbzjq3z8.js";
+} from "./Accordion-ep35792s.js";
 import {
   Text3
 } from "./Accordion-9rnsg9pk.js";