@flamingo-stack/openframe-frontend-core 0.0.449-snapshot.20260718143201 → 0.0.449

package/dist/components/chat/quick-action-wall.d.ts

@@ -1,96 +0,0 @@
-import * as React from 'react';
-import { type MarqueeSyncController, type MarqueeWallFadeEdge, type MarqueeWallProps } from '../ui/marquee-wall';
-import type { QuickActionTheme, QuickActionThemeAccents } from './quick-action-chip';
-import type { QuickActionChip } from './chat-quick-action-row';
-/** Skeleton label widths (ch) — realistic spread, cycled. THE wall-skeleton
- *  spread, shared with the company-hub deck's ChipWall: sized so a 24-item
- *  wall overflows typical caps at any viewport width (same fill + fade as
- *  the loaded state — zero height jump when data lands). */
-export declare const WALL_SKELETON_LABEL_CH: number[];
-/** Deterministic index-alternating merge — the mixed "one stream" pile
- *  (deck slide 3's IT+SEC blend and its Storybook mirror). Input order
- *  stable → the blend never reshuffles across renders or consumers. */
-export declare function interleave<T>(a: ReadonlyArray<T>, b: ReadonlyArray<T>): T[];
-export interface QuickActionWallProps {
-    /** The wall's chips — the shared {@link QuickActionChip} shape (same as the
-     *  chat rows), including per-chip `theme`/`lozenge` for mixed IT/SEC
-     *  streams. Chips with `onSelect` render as buttons; without, as tags. */
-    chips: ReadonlyArray<QuickActionChip>;
-    /** Wall-default theme (fae/mingo/it/sec) for chips without their own. */
-    theme?: QuickActionTheme;
-    /** Server-configured per-theme accent overrides
-     *  ({@link QuickActionThemeAccents}) — inject the agents' configured colors
-     *  (resolve via `accentFromIdentityIcon`); the built-in theme accents are
-     *  fallback-only. Per-chip `themeAccent` still wins. */
-    themeAccents?: QuickActionThemeAccents;
-    /** `'animated'` (default): marquee + overflow fades. `'plain'`: no motion,
-     *  no blur — the consumer's per-surface opt-out (forwarded to
-     *  {@link MarqueeWall}; in brick mode the rows render static and the
-     *  stack-level fades are skipped). */
-    mode?: 'animated' | 'plain';
-    /** Render every chip's theme lozenge (classification walls). Per-chip
-     *  `lozenge` values still win. */
-    lozenges?: boolean;
-    /** Marquee axis — defaults to where `fade` sits (see {@link MarqueeWall}). */
-    axis?: MarqueeWallProps['axis'];
-    reverse?: boolean;
-    /** px/s. Default 40 (MarqueeWall default). */
-    speed?: number;
-    /** Marquee on/off (auto-off when content fits / reduced motion / loading). */
-    animate?: boolean;
-    pauseOnHover?: boolean;
-    fade?: MarqueeWallFadeEdge | ReadonlyArray<MarqueeWallFadeEdge>;
-    /** Color behind the wall — the fades blend into it. */
-    fadeColor?: string;
-    fadeSize?: MarqueeWallProps['fadeSize'];
-    /** THE wall pitch — one value drives the chip gap, the clone-seam gap, and
-     *  (in brick mode) the row-stack gap, so the courses read as a uniform wall
-     *  and the seam is invisible by construction. Default
-     *  `var(--spacing-system-xsf)`. */
-    copyGap?: number | string;
-    /** Pad the track by REPEATING the chips up to this count (suffixed keys) so
-     *  one copy always overflows the container and the loop engages — without
-     *  it a wall whose content roughly fits its box goes static (the marquee
-     *  only loops what overflows). Defaults to `rows × 14` in brick mode;
-     *  unset otherwise (capped walls that always overflow, and FLIP-tracked
-     *  walls where repeats would duplicate flip ids, need no padding). */
-    minChips?: number;
-    /**
-     * BRICK-WALL mode: render this many stacked independent single-row
-     * marquees (chips distributed round-robin) instead of one track. Rows pack
-     * their chips edge-to-edge like bricks — a grid would column-align chips
-     * of different widths and leave holes — and each row loops on its own
-     * wrap, so the courses stagger organically. Horizontal only; the fades
-     * draw ONCE over the whole stack.
-     */
-    rows?: number;
-    /** Draw skeleton chips instead of `chips` (the shared
-     *  {@link QuickActionChipSkeleton} — 1:1 geometry with loaded chips).
-     *  Callers own the policy (`loading` flag vs skeleton-when-empty). */
-    loading?: boolean;
-    skeletonCount?: number;
-    /** Outer container (sizing: height cap for vertical walls). */
-    className?: string;
-    /** Per-copy layout — default a wrapping chip wall. Override for single-row
-     *  marquee strips (`flex-nowrap`). */
-    contentClassName?: string;
-    /** Pair with sibling walls under one position driver (resolve strips). */
-    sync?: MarqueeSyncController;
-}
-/**
- * <QuickActionWall> — THE quick-action chip wall: a themed pile of the shared
- * chip on the shared {@link MarqueeWall} engine. One component for every
- * surface that shows "the work the agents do" — homepage hero tabs, deck
- * panels, marketing strips — whether static-with-fade or endlessly scrolling
- * (axis follows the fade), interactive or decorative.
- *
- * Clone-copy chips stay INTERACTIVE (pointer cursor + working click) — the
- * loop paints clones inside the viewport (reverse walls even START on the
- * clone copy), and a visible chip that ignores clicks reads as broken. A11y
- * holds via the clone wrapper: aria-hidden + focus suppression (the standard
- * Swiper/Splide loop-clone treatment, same as CardsStrip). `pauseOnHover`
- * (default on) freezes the track under a pointing cursor so chips never
- * dodge a click.
- */
-export declare function QuickActionWall({ chips, theme, themeAccents, mode, lozenges, axis, reverse, speed, animate, pauseOnHover, fade, fadeColor, fadeSize, copyGap, minChips, rows, loading, skeletonCount, className, contentClassName, sync, }: QuickActionWallProps): React.JSX.Element;
-//# sourceMappingURL=quick-action-wall.d.ts.map

package/dist/components/chat/quick-action-wall.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"quick-action-wall.d.ts","sourceRoot":"","sources":["../../../src/components/chat/quick-action-wall.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAGL,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACtB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAA;AAEpF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AAM9D;;;4DAG4D;AAC5D,eAAO,MAAM,sBAAsB,UAAmD,CAAA;AAEtF;;uEAEuE;AACvE,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAO3E;AAUD,MAAM,WAAW,oBAAoB;IACnC;;8EAE0E;IAC1E,KAAK,EAAE,aAAa,CAAC,eAAe,CAAC,CAAA;IACrC,yEAAyE;IACzE,KAAK,CAAC,EAAE,gBAAgB,CAAA;IACxB;;;4DAGwD;IACxD,YAAY,CAAC,EAAE,uBAAuB,CAAA;IACtC;;;0CAGsC;IACtC,IAAI,CAAC,EAAE,UAAU,GAAG,OAAO,CAAA;IAC3B;sCACkC;IAClC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,8EAA8E;IAC9E,IAAI,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,8EAA8E;IAC9E,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,IAAI,CAAC,EAAE,mBAAmB,GAAG,aAAa,CAAC,mBAAmB,CAAC,CAAA;IAC/D,uDAAuD;IACvD,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAA;IACvC;;;uCAGmC;IACnC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACzB;;;;;0EAKsE;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;;0EAEsE;IACtE,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;0CACsC;IACtC,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,0EAA0E;IAC1E,IAAI,CAAC,EAAE,qBAAqB,CAAA;CAC7B;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,EAC9B,KAAK,EACL,KAAK,EACL,YAAY,EACZ,IAAiB,EACjB,QAAgB,EAChB,IAAI,EACJ,OAAO,EACP,KAAK,EACL,OAAc,EACd,YAAY,EACZ,IAAI,EACJ,SAAS,EACT,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,OAAe,EACf,aAAkB,EAClB,SAAS,EACT,gBAAgB,EAChB,IAAI,GACL,EAAE,oBAAoB,qBA4FtB"}

package/dist/components/ui/marquee-wall.d.ts

@@ -1,159 +0,0 @@
-import * as React from 'react';
-export type MarqueeWallFadeEdge = 'top' | 'bottom' | 'left' | 'right';
-/** @internal per-instance sync membership (transform writer + driver-role
- *  promotion callback, so a surviving member can be re-elected). */
-interface MarqueeSyncMember {
-    apply: (pos: number) => void;
-    makeDriver: () => void;
-}
-/**
- * Pairs two (or more) <MarqueeWall> instances to ONE position driver so their
- * tracks stay pixel-locked (the FreeTrialCTA resolve strips: a pending and a
- * resolved copy of the same chips, clip-path'd at the avatar line). The first
- * mounted instance claims the driver role and runs the shared rAF; the others
- * only register their `apply` transforms. If the driver unmounts while
- * members survive, the next member is promoted — the pair must merely be
- * geometry-identical while mounted together.
- */
-export interface MarqueeSyncController {
-    /** @internal registered members in mount order. */
-    members: Set<MarqueeSyncMember>;
-    /** @internal current driver member. */
-    driver: MarqueeSyncMember | null;
-    /** @internal last driver-written position — a promoted driver's engine
-     *  seeds from it, so re-election never snaps the pair back to 0. */
-    position: number;
-}
-export declare function useMarqueeSync(): MarqueeSyncController;
-export interface MarqueeTrackOffset {
-    /** Applied translation (px) along each axis. */
-    x: number;
-    y: number;
-    /** Loop wrap size (single copy + seam gap) along each axis; 0 on the
-     *  non-scroll axis. Lets morph engines treat a chip and its loop clone as
-     *  ONE identity `wrap` apart (the Swiper loop-clone model) and fly the
-     *  copy the viewer actually sees. */
-    wrapX: number;
-    wrapY: number;
-}
-/** Last known translation + wrap of the wall registered under `trackId`
- *  (live or already unmounted). Zeros for unknown ids / static walls. */
-export declare function getMarqueeTrackOffset(trackId: string): MarqueeTrackOffset;
-/**
- * The translation ACTUALLY applied to a wall's track right now, read from the
- * DOM of the `data-marquee-track` container. Morph engines use this on the
- * CAPTURE side (never the registry): a same-id wall freshly remounted in the
- * current commit has not applied any transform yet, while the registry still
- * holds its predecessor's final drift for the flight-side lookup.
- */
-export declare function getMarqueeAppliedOffset(trackContainer: Element): {
-    x: number;
-    y: number;
-};
-/**
- * The loop-clone twin of an element inside a wall's PRIMARY copy (same index
- * in the `data-marquee-copy="clone"` copy), or null when there is no clone /
- * the element isn't in the primary copy. Owns the wall's internal DOM shape
- * so morph engines don't hardcode it; `selector` scopes which descendants
- * count as items (default: direct structure-preserving lookup by class is the
- * caller's job — pass the item selector, e.g. `'.flipchip'`).
- */
-export declare function getMarqueeCloneTwin(trackContainer: Element, el: Element, selector: string): HTMLElement | null;
-export interface MarqueeWallProps {
-    /**
-     * Presentation mode — the consumer's one switch for "do I want the
-     * blur + marquee here at all":
-     * - `'animated'` (default): endless marquee when content overflows, with
-     *   the overflow fades.
-     * - `'plain'`: no motion, no fades — a plain clipped wall. All marquee
-     *   machinery (engine, clone copy, fades) is skipped entirely.
-     */
-    mode?: 'animated' | 'plain';
-    /**
-     * Marquee axis. Defaults to where the fade sits — the animation's job is to
-     * reveal what the fade hides: a `bottom`/`top` fade clips rows → vertical
-     * (content travels bottom→top); a `left`/`right`-only fade clips columns →
-     * horizontal (content travels right→left). No fade → horizontal.
-     */
-    axis?: 'x' | 'y';
-    /** Reverse travel: `x` reversed moves content right, `y` reversed moves it
-     *  down. Default false (left / up). */
-    reverse?: boolean;
-    /** Scroll speed in px/s (the CardsStrip unit — one speed language across
-     *  every marquee). Default 40: calm chip-wall drift, slower than the 60 the
-     *  card strips cruise at. */
-    speed?: number;
-    /** Master switch. Even when true the marquee auto-disables while the content
-     *  fits the container and under `prefers-reduced-motion` (static wall). */
-    animate?: boolean;
-    /** Freeze while a hover-capable pointer is anywhere over the wall — content
-     *  must never move under a pointing cursor (required for interactive chip
-     *  walls). Default true. */
-    pauseOnHover?: boolean;
-    /** Edge fade(s) — the "there's more" affordance. ONE spelling of the
-     *  clip-and-fade across every wall surface. */
-    fade?: MarqueeWallFadeEdge | ReadonlyArray<MarqueeWallFadeEdge>;
-    /** The color the fades blend INTO — must match the surface behind the wall
-     *  or the gradient paints a visible box. Default the page background. */
-    fadeColor?: string;
-    /** Fade thickness: one value for all edges or a per-edge map. Defaults:
-     *  40px vertical edges, 112px horizontal edges (the shipped hero-wall
-     *  geometry). */
-    fadeSize?: number | string | Partial<Record<MarqueeWallFadeEdge, number | string>>;
-    /** Gap between the two track copies — match the content's own item gap so
-     *  the seam is invisible. A CSS length string (e.g. `var(--tlcl-chipgap)`)
-     *  lets responsive CSS own the value; the true seam distance is MEASURED
-     *  from the rendered copies either way. Default 8. */
-    copyGap?: number | string;
-    /** Outer container class — sizing lives here (height cap for `y`, width for
-     *  `x`). The container is always `relative overflow-hidden`. */
-    className?: string;
-    /** Class on EACH track copy — the wall's own layout (e.g. a wrapping chip
-     *  row `flex flex-wrap gap-2`, or a fixed-width grid). */
-    contentClassName?: string;
-    /** Inline style on EACH track copy — for values classes can't carry (e.g.
-     *  an item gap driven by the same variable as `copyGap`, so chip pitch and
-     *  seam pitch stay one value by construction). */
-    contentStyle?: React.CSSProperties;
-    /**
-     * Wall content — ONE copy; the wall clones it for the endless loop (clone
-     * `aria-hidden` + focus-suppressed but still clickable). Pass a render
-     * callback to vary the clone copy (e.g. omit `data-flip-id`s / render
-     * decorative chips). Children must be clone-safe: ref-free, unique-DOM-id-
-     * free, mount-effect-free (same contract as <CardsStrip> children mode).
-     */
-    children: React.ReactNode | ((ctx: {
-        isClone: boolean;
-    }) => React.ReactNode);
-    /** Pair this wall with sibling walls under one shared position driver. */
-    sync?: MarqueeSyncController;
-    /** Stable id for FLIP coordination: publishes the wall's live offset via
-     *  {@link getMarqueeTrackOffset} and stamps `data-marquee-track` on the
-     *  container so morph engines can drift-correct captured positions. */
-    trackId?: string;
-}
-/** The wall's edge-fade overlays — exported so composite walls (stacked row
- *  marquees) can draw ONE set of fades over the whole stack instead of
- *  per-row copies. Parent must be `relative`. Overlays sit at z-1, ABOVE
- *  FLIP flight ghosts (z-0 by contract): an in-flight chip dissolves under
- *  the blur exactly like a resting chip. */
-export declare function MarqueeWallFades({ fade, fadeColor, fadeSize, }: {
-    fade?: MarqueeWallFadeEdge | ReadonlyArray<MarqueeWallFadeEdge>;
-    fadeColor?: string;
-    fadeSize?: MarqueeWallProps['fadeSize'];
-}): React.JSX.Element;
-/**
- * <MarqueeWall> — THE endless-scroll wall container: a clipped area whose
- * content loops as a marquee along either axis, fading out where the clip
- * cuts. Built on the same `useMarqueeEngine` core as <CardsStrip> (the news /
- * logo / bites strips) with a TRANSFORM driver instead of a scroller — no
- * inner scrollable area is created, so it is safe inside surfaces that forbid
- * nested scrollers (the deck's mobile single-fold panels).
- *
- * Static by circumstance, not by variant: when the content fits the container
- * (or `prefers-reduced-motion`) the wall renders a single static copy with
- * its fades — byte-identical to the old non-animated walls.
- */
-export declare function MarqueeWall({ mode, axis: axisProp, reverse, speed, animate, pauseOnHover, fade, fadeColor, fadeSize, copyGap, className, contentClassName, contentStyle, children, sync, trackId, }: MarqueeWallProps): React.JSX.Element;
-export {};
-//# sourceMappingURL=marquee-wall.d.ts.map

package/dist/components/ui/marquee-wall.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"marquee-wall.d.ts","sourceRoot":"","sources":["../../../src/components/ui/marquee-wall.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAW9B,MAAM,MAAM,mBAAmB,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAA;AASrE;oEACoE;AACpE,UAAU,iBAAiB;IACzB,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;IAC5B,UAAU,EAAE,MAAM,IAAI,CAAA;CACvB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,qBAAqB;IACpC,mDAAmD;IACnD,OAAO,EAAE,GAAG,CAAC,iBAAiB,CAAC,CAAA;IAC/B,uCAAuC;IACvC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAA;IAChC;wEACoE;IACpE,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,wBAAgB,cAAc,IAAI,qBAAqB,CAEtD;AAMD,MAAM,WAAW,kBAAkB;IACjC,gDAAgD;IAChD,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT;;;yCAGqC;IACrC,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd;AAgBD;yEACyE;AACzE,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,kBAAkB,CAEzE;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,cAAc,EAAE,OAAO,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAMzF;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,OAAO,EACvB,EAAE,EAAE,OAAO,EACX,QAAQ,EAAE,MAAM,GACf,WAAW,GAAG,IAAI,CAOpB;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,UAAU,GAAG,OAAO,CAAA;IAC3B;;;;;OAKG;IACH,IAAI,CAAC,EAAE,GAAG,GAAG,GAAG,CAAA;IAChB;2CACuC;IACvC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;iCAE6B;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;+EAC2E;IAC3E,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;gCAE4B;IAC5B,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB;mDAC+C;IAC/C,IAAI,CAAC,EAAE,mBAAmB,GAAG,aAAa,CAAC,mBAAmB,CAAC,CAAA;IAC/D;6EACyE;IACzE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;qBAEiB;IACjB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,mBAAmB,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,CAAA;IAClF;;;0DAGsD;IACtD,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACzB;oEACgE;IAChE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;8DAC0D;IAC1D,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;sDAEkD;IAClD,YAAY,CAAC,EAAE,KAAK,CAAC,aAAa,CAAA;IAClC;;;;;;OAMG;IACH,QAAQ,EAAE,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,GAAG,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,KAAK,CAAC,SAAS,CAAC,CAAA;IAC5E,0EAA0E;IAC1E,IAAI,CAAC,EAAE,qBAAqB,CAAA;IAC5B;;2EAEuE;IACvE,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAoBD;;;;4CAI4C;AAC5C,wBAAgB,gBAAgB,CAAC,EAC/B,IAAI,EACJ,SAA6B,EAC7B,QAAQ,GACT,EAAE;IACD,IAAI,CAAC,EAAE,mBAAmB,GAAG,aAAa,CAAC,mBAAmB,CAAC,CAAA;IAC/D,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAA;CACxC,qBA0BA;AAyBD;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,EAC1B,IAAiB,EACjB,IAAI,EAAE,QAAQ,EACd,OAAe,EACf,KAAU,EACV,OAAc,EACd,YAAmB,EACnB,IAAI,EACJ,SAA6B,EAC7B,QAAQ,EACR,OAAW,EACX,SAAS,EACT,gBAAgB,EAChB,YAAY,EACZ,QAAQ,EACR,IAAI,EACJ,OAAO,GACR,EAAE,gBAAgB,qBAsNlB"}

package/dist/hooks/ui/use-marquee-engine.d.ts

@@ -1,73 +0,0 @@
-import { type MutableRefObject } from 'react';
-/**
- * THE marquee animation core (single source of truth) — extracted verbatim
- * from <CardsStrip> so every endless-scroll surface (card strips, logo strips,
- * quick-action walls, chip marquees) shares ONE rAF position engine ("unify
- * means delete variations").
- *
- * The engine is axis- and driver-agnostic: it owns a FLOAT position ref, a
- * velocity envelope, seam wrapping, and an optional chevron-style glide; the
- * caller decides what a position "means" via `apply` — writing
- * `scroller.scrollLeft` (CardsStrip: a real scroller the user can also drag)
- * or a `translate` transform (MarqueeWall: decorative tracks, incl. vertical —
- * mandatory inside surfaces that forbid inner scrollers, e.g. the deck's
- * mobile single-fold panels).
- *
- * Engine semantics (do not "simplify"):
- * - Position lives in a FLOAT ref, never read-modify-write from the DOM:
- *   scrollLeft reads back rounded values, so sub-pixel increments
- *   (speed/fps < 1px) get eaten by rounding — stutter + measurably slower
- *   than the configured speed.
- * - Velocity envelope (~250ms time constant) eases between 0 and `speed`
- *   instead of binary stop/start — pause decelerates, resume accelerates from
- *   the current position (GSAP-marquee behavior; hard cuts read as jank).
- * - Glide consumes a signed remaining-distance, wrapping modulo the copy size
- *   each frame, so seam warps are invisible to it (browser smooth-scroll
- *   animates toward an ABSOLUTE target and lunges after a warp).
- * - `isPaused` is evaluated every frame — the caller owns the pause-reason
- *   set (hover, viewport, tab visibility, suppress windows); the engine only
- *   turns it into a smooth velocity target.
- */
-export interface MarqueeEngineOptions {
-    /** Master switch — the rAF runs only while true. On (re)activation the
-     *  position resyncs from `readBack` when provided. */
-    active: boolean;
-    /** Cruise speed in px/s. */
-    speed: number;
-    /** Per-frame pause verdict (caller-owned reason set). `now` is the rAF
-     *  timestamp, for suppress-until comparisons. */
-    isPaused: (now: number) => boolean;
-    /** Single-copy size in px (the wrap modulus). Return <= 0 to disable
-     *  wrapping (position advances unwrapped — callers should size tracks so
-     *  this never happens while active). */
-    getWrapSize: () => number;
-    /** Lower bound of the wrap range: positions stay in
-     *  [wrapMin, wrapMin + wrapSize). Default 0. Scroller drivers with USER
-     *  scrolling pass their seam-warp buffer here so engine-written positions
-     *  never enter the re-center zones — an exact-edge warp check is racy
-     *  against the rAF (the engine nudges the scroller off the edge before the
-     *  scroll handler samples it → "stuck at the left edge"). */
-    getWrapMin?: () => number;
-    /** Write the position to the DOM (scrollLeft assignment or transform). */
-    apply: (pos: number) => void;
-    /** Read the externally-mutated position back (real scrollers: user drag /
-     *  native smooth scroll move scrollLeft under the engine). Omit for
-     *  transform drivers — nothing external can move them. */
-    readBack?: () => number;
-    /** Called at the end of every frame (e.g. hover re-resolution after the
-     *  track moved under a stationary pointer). */
-    onAfterFrame?: () => void;
-}
-export interface MarqueeEngineHandle {
-    /** The engine's float position (px along the axis, 0 ≤ pos < wrap while
-     *  wrapping). Callers may write it together with their own DOM write (seam
-     *  warp on manual scroll). */
-    posRef: MutableRefObject<number>;
-    /** Accumulate a signed glide distance (chevron navigation). Runs through
-     *  the engine's own tween — never native smooth scroll while wrapping. */
-    glideBy: (px: number) => void;
-    /** Wrap an arbitrary position into [0, wrapSize). */
-    wrap: (pos: number) => number;
-}
-export declare function useMarqueeEngine(options: MarqueeEngineOptions): MarqueeEngineHandle;
-//# sourceMappingURL=use-marquee-engine.d.ts.map

package/dist/hooks/ui/use-marquee-engine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-marquee-engine.d.ts","sourceRoot":"","sources":["../../../src/hooks/ui/use-marquee-engine.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkC,KAAK,gBAAgB,EAAE,MAAM,OAAO,CAAA;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,WAAW,oBAAoB;IACnC;0DACsD;IACtD,MAAM,EAAE,OAAO,CAAA;IACf,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAA;IACb;qDACiD;IACjD,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAA;IAClC;;4CAEwC;IACxC,WAAW,EAAE,MAAM,MAAM,CAAA;IACzB;;;;;iEAK6D;IAC7D,UAAU,CAAC,EAAE,MAAM,MAAM,CAAA;IACzB,0EAA0E;IAC1E,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;IAC5B;;8DAE0D;IAC1D,QAAQ,CAAC,EAAE,MAAM,MAAM,CAAA;IACvB;mDAC+C;IAC/C,YAAY,CAAC,EAAE,MAAM,IAAI,CAAA;CAC1B;AAED,MAAM,WAAW,mBAAmB;IAClC;;kCAE8B;IAC9B,MAAM,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;IAChC;8EAC0E;IAC1E,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IAC7B,qDAAqD;IACrD,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;CAC9B;AAKD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,GAAG,mBAAmB,CA8EnF"}

package/dist/hooks/ui/use-suppress-clone-focus.d.ts

@@ -1,24 +0,0 @@
-/**
- * Keep a marquee clone's content pointer-CLICKABLE while taking it out of the
- * accessibility tree and the keyboard tab order. Shared by every endless-loop
- * surface that renders a second track copy (<CardsStrip> managed cells,
- * <MarqueeWall> clone copies).
- *
- * `inert` (the previous approach) does all three at once: a11y-hidden,
- * un-focusable AND un-clickable. That third effect was the "news marquee stops
- * being clickable after you scroll it for a while" bug — the 2-copy endless
- * loop ALWAYS paints clone cards inside the viewport near the copy seam, so a
- * user who manually scrolls and parks there is looking at real-looking cards
- * that silently swallow every click. Clones must therefore stay clickable (a
- * click on ANY visible card must open its link — mouse, ⌘-click, middle-click
- * and context-menu all handled natively by the clone's own anchor).
- *
- * The a11y contract is still met without `inert`: the caller keeps
- * `aria-hidden` on the clone wrapper (out of the a11y tree) and this hook
- * forces every focusable descendant to `tabindex="-1"` (out of the tab order →
- * no duplicate tab stops, no aria-hidden-focus violation). Re-applied on
- * subtree mutation. This is the standard loop-clone treatment used by
- * Swiper/Splide.
- */
-export declare function useSuppressCloneFocus(active: boolean): import("react").RefObject<HTMLDivElement | null>;
-//# sourceMappingURL=use-suppress-clone-focus.d.ts.map

package/dist/hooks/ui/use-suppress-clone-focus.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-suppress-clone-focus.d.ts","sourceRoot":"","sources":["../../../src/hooks/ui/use-suppress-clone-focus.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,OAAO,oDA2BpD"}

package/src/components/chat/quick-action-wall.tsx

@@ -1,247 +0,0 @@
-'use client'
-
-import * as React from 'react'
-import { cn } from '../../utils/cn'
-import {
-  MarqueeWall,
-  MarqueeWallFades,
-  type MarqueeSyncController,
-  type MarqueeWallFadeEdge,
-  type MarqueeWallProps,
-} from '../ui/marquee-wall'
-import { QuickActionChipSkeleton } from './quick-action-chip'
-import type { QuickActionTheme, QuickActionThemeAccents } from './quick-action-chip'
-import { QuickActionChipFromData } from './chat-quick-action-row'
-import type { QuickActionChip } from './chat-quick-action-row'
-
-// =============================================================================
-// Shared wall constants
-// =============================================================================
-
-/** Skeleton label widths (ch) — realistic spread, cycled. THE wall-skeleton
- *  spread, shared with the company-hub deck's ChipWall: sized so a 24-item
- *  wall overflows typical caps at any viewport width (same fill + fade as
- *  the loaded state — zero height jump when data lands). */
-export const WALL_SKELETON_LABEL_CH = [17, 24, 14, 20, 15, 25, 12, 21, 16, 19, 13, 23]
-
-/** Deterministic index-alternating merge — the mixed "one stream" pile
- *  (deck slide 3's IT+SEC blend and its Storybook mirror). Input order
- *  stable → the blend never reshuffles across renders or consumers. */
-export function interleave<T>(a: ReadonlyArray<T>, b: ReadonlyArray<T>): T[] {
-  const out: T[] = []
-  for (let i = 0; i < Math.max(a.length, b.length); i++) {
-    if (a[i] !== undefined) out.push(a[i])
-    if (b[i] !== undefined) out.push(b[i])
-  }
-  return out
-}
-
-// Brick-mode padding default: ~14 columns of chips per row (~3200px) — one
-// row copy overflows any sensible container, so the loop always engages.
-const DEFAULT_MIN_CHIPS_PER_ROW = 14
-
-// =============================================================================
-// Types
-// =============================================================================
-
-export interface QuickActionWallProps {
-  /** The wall's chips — the shared {@link QuickActionChip} shape (same as the
-   *  chat rows), including per-chip `theme`/`lozenge` for mixed IT/SEC
-   *  streams. Chips with `onSelect` render as buttons; without, as tags. */
-  chips: ReadonlyArray<QuickActionChip>
-  /** Wall-default theme (fae/mingo/it/sec) for chips without their own. */
-  theme?: QuickActionTheme
-  /** Server-configured per-theme accent overrides
-   *  ({@link QuickActionThemeAccents}) — inject the agents' configured colors
-   *  (resolve via `accentFromIdentityIcon`); the built-in theme accents are
-   *  fallback-only. Per-chip `themeAccent` still wins. */
-  themeAccents?: QuickActionThemeAccents
-  /** `'animated'` (default): marquee + overflow fades. `'plain'`: no motion,
-   *  no blur — the consumer's per-surface opt-out (forwarded to
-   *  {@link MarqueeWall}; in brick mode the rows render static and the
-   *  stack-level fades are skipped). */
-  mode?: 'animated' | 'plain'
-  /** Render every chip's theme lozenge (classification walls). Per-chip
-   *  `lozenge` values still win. */
-  lozenges?: boolean
-  /** Marquee axis — defaults to where `fade` sits (see {@link MarqueeWall}). */
-  axis?: MarqueeWallProps['axis']
-  reverse?: boolean
-  /** px/s. Default 40 (MarqueeWall default). */
-  speed?: number
-  /** Marquee on/off (auto-off when content fits / reduced motion / loading). */
-  animate?: boolean
-  pauseOnHover?: boolean
-  fade?: MarqueeWallFadeEdge | ReadonlyArray<MarqueeWallFadeEdge>
-  /** Color behind the wall — the fades blend into it. */
-  fadeColor?: string
-  fadeSize?: MarqueeWallProps['fadeSize']
-  /** THE wall pitch — one value drives the chip gap, the clone-seam gap, and
-   *  (in brick mode) the row-stack gap, so the courses read as a uniform wall
-   *  and the seam is invisible by construction. Default
-   *  `var(--spacing-system-xsf)`. */
-  copyGap?: number | string
-  /** Pad the track by REPEATING the chips up to this count (suffixed keys) so
-   *  one copy always overflows the container and the loop engages — without
-   *  it a wall whose content roughly fits its box goes static (the marquee
-   *  only loops what overflows). Defaults to `rows × 14` in brick mode;
-   *  unset otherwise (capped walls that always overflow, and FLIP-tracked
-   *  walls where repeats would duplicate flip ids, need no padding). */
-  minChips?: number
-  /**
-   * BRICK-WALL mode: render this many stacked independent single-row
-   * marquees (chips distributed round-robin) instead of one track. Rows pack
-   * their chips edge-to-edge like bricks — a grid would column-align chips
-   * of different widths and leave holes — and each row loops on its own
-   * wrap, so the courses stagger organically. Horizontal only; the fades
-   * draw ONCE over the whole stack.
-   */
-  rows?: number
-  /** Draw skeleton chips instead of `chips` (the shared
-   *  {@link QuickActionChipSkeleton} — 1:1 geometry with loaded chips).
-   *  Callers own the policy (`loading` flag vs skeleton-when-empty). */
-  loading?: boolean
-  skeletonCount?: number
-  /** Outer container (sizing: height cap for vertical walls). */
-  className?: string
-  /** Per-copy layout — default a wrapping chip wall. Override for single-row
-   *  marquee strips (`flex-nowrap`). */
-  contentClassName?: string
-  /** Pair with sibling walls under one position driver (resolve strips). */
-  sync?: MarqueeSyncController
-}
-
-// =============================================================================
-// Component
-// =============================================================================
-
-/**
- * <QuickActionWall> — THE quick-action chip wall: a themed pile of the shared
- * chip on the shared {@link MarqueeWall} engine. One component for every
- * surface that shows "the work the agents do" — homepage hero tabs, deck
- * panels, marketing strips — whether static-with-fade or endlessly scrolling
- * (axis follows the fade), interactive or decorative.
- *
- * Clone-copy chips stay INTERACTIVE (pointer cursor + working click) — the
- * loop paints clones inside the viewport (reverse walls even START on the
- * clone copy), and a visible chip that ignores clicks reads as broken. A11y
- * holds via the clone wrapper: aria-hidden + focus suppression (the standard
- * Swiper/Splide loop-clone treatment, same as CardsStrip). `pauseOnHover`
- * (default on) freezes the track under a pointing cursor so chips never
- * dodge a click.
- */
-export function QuickActionWall({
-  chips,
-  theme,
-  themeAccents,
-  mode = 'animated',
-  lozenges = false,
-  axis,
-  reverse,
-  speed,
-  animate = true,
-  pauseOnHover,
-  fade,
-  fadeColor,
-  fadeSize,
-  copyGap,
-  minChips,
-  rows,
-  loading = false,
-  skeletonCount = 24,
-  className,
-  contentClassName,
-  sync,
-}: QuickActionWallProps) {
-  // Repeat-pad the track (stable suffixed keys; repeats keep the full chip —
-  // identical selected/interactive state, so every visible instance behaves
-  // the same and the clone copy stays geometry-identical by construction).
-  const padTarget = minChips ?? (rows ? rows * DEFAULT_MIN_CHIPS_PER_ROW : undefined)
-  const track = React.useMemo(() => {
-    if (!padTarget || chips.length === 0 || chips.length >= padTarget) return chips
-    const repeats = Math.ceil(padTarget / chips.length)
-    return Array.from({ length: repeats }, (_, r) =>
-      r === 0 ? chips : chips.map(chip => ({ ...chip, id: `${chip.id}__r${r}` })),
-    ).flat()
-  }, [chips, padTarget])
-
-  const renderSkeletons = (count: number, offset = 0) =>
-    Array.from({ length: count }, (_, i) => (
-      <QuickActionChipSkeleton
-        key={i}
-        lozenge={lozenges}
-        labelCh={WALL_SKELETON_LABEL_CH[(offset + i) % WALL_SKELETON_LABEL_CH.length]}
-      />
-    ))
-
-  const renderChipNodes = (list: ReadonlyArray<QuickActionChip>) =>
-    list.map(chip => (
-      <QuickActionChipFromData
-        key={chip.id}
-        chip={chip}
-        defaultTheme={theme}
-        themeAccents={themeAccents}
-        defaultLozenge={lozenges}
-        interactive={!!chip.onSelect}
-        className="max-w-full"
-      />
-    ))
-
-  const renderChips = () => (loading ? renderSkeletons(skeletonCount) : renderChipNodes(track))
-
-  // ONE pitch for chips, clone seams, and (brick mode) the row stack — a
-  // custom `copyGap` moves all three together, so no seam can ever disagree
-  // with the chip gap.
-  const gap = copyGap ?? 'var(--spacing-system-xsf)'
-
-  // ---- BRICK-WALL mode: stacked independent row marquees ---------------------
-  if (rows && rows > 0) {
-    const rowLists = Array.from({ length: rows }, (_, r) => track.filter((_, i) => i % rows === r))
-    const skelPerRow = Math.ceil(skeletonCount / rows)
-    return (
-      <div className={cn('relative flex flex-col overflow-hidden', className)} style={{ gap }}>
-        {rowLists.map((list, r) => (
-          <MarqueeWall
-            key={r}
-            mode={mode}
-            axis="x"
-            reverse={reverse}
-            speed={speed}
-            animate={animate && !loading}
-            pauseOnHover={pauseOnHover}
-            copyGap={gap}
-            contentClassName={cn('flex items-center', contentClassName)}
-            contentStyle={{ gap }}
-          >
-            {loading ? renderSkeletons(skelPerRow, r * 3) : renderChipNodes(list)}
-          </MarqueeWall>
-        ))}
-        {mode === 'animated' && (
-          <MarqueeWallFades fade={fade} fadeColor={fadeColor} fadeSize={fadeSize} />
-        )}
-      </div>
-    )
-  }
-
-  return (
-    <MarqueeWall
-      mode={mode}
-      axis={axis}
-      reverse={reverse}
-      speed={speed}
-      // Skeleton walls stay put — the marquee starts when real chips land.
-      animate={animate && !loading}
-      pauseOnHover={pauseOnHover}
-      fade={fade}
-      fadeColor={fadeColor}
-      fadeSize={fadeSize}
-      copyGap={gap}
-      className={className}
-      contentClassName={cn('flex flex-wrap content-start items-start', contentClassName)}
-      contentStyle={{ gap }}
-      sync={sync}
-    >
-      {renderChips()}
-    </MarqueeWall>
-  )
-}