@dxos/react-ui-feed 0.11.1

package/dist/types/src/debug/use-debug.d.ts

@@ -0,0 +1,19 @@
+import React, { type PropsWithChildren } from 'react';
+import { DebugModel, type DebugProbe } from './debug-model';
+export type DebugProviderProps = PropsWithChildren<{
+    model?: DebugModel;
+}>;
+/**
+ * Scope for probes. Anything under it may instrument itself; a `Debug` table under the same
+ * provider renders whatever registered. No provider, no cost: the hooks below no-op.
+ */
+export declare const DebugProvider: ({ model: provided, children }: DebugProviderProps) => React.JSX.Element;
+export declare const useDebugModel: () => DebugModel | undefined;
+/**
+ * Register live readouts for as long as the component is mounted.
+ *
+ * The probe reads state through a closure, so the component never re-renders for the table's sake;
+ * `deps` re-registers when the closure would go stale (a rebuilt model, a new element).
+ */
+export declare const useDebugProbes: (probes: () => DebugProbe[], deps?: unknown[]) => void;
+//# sourceMappingURL=use-debug.d.ts.map

package/dist/types/src/debug/use-debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-debug.d.ts","sourceRoot":"","sources":["../../../../src/debug/use-debug.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,EAAE,KAAK,iBAAiB,EAAiD,MAAM,OAAO,CAAC;AAErG,OAAO,EAAE,UAAU,EAAE,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAI5D,MAAM,MAAM,kBAAkB,GAAG,iBAAiB,CAAC;IAAE,KAAK,CAAC,EAAE,UAAU,CAAA;CAAE,CAAC,CAAC;AAE3E;;;GAGG;AACH,eAAO,MAAM,aAAa,kCAAmC,kBAAkB,sBAG9E,CAAC;AAEF,eAAO,MAAM,aAAa,QAAO,UAAU,GAAG,SAAqC,CAAC;AAEpF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,WAAY,MAAM,UAAU,EAAE,SAAQ,OAAO,EAAE,KAAQ,IAWjF,CAAC"}

package/dist/types/src/hooks/follow.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Speeds are expressed in **rows**, not pixels: a feed of tall messages and one of short replies
+ * should travel at the same perceived rate, and only a row-relative unit gives that.
+ */
+export type FollowOptions = {
+    /** Ceiling on travel speed, rows/s. */
+    maxSpeed?: number;
+    /** Rate the speed ramps up, rows/s². */
+    acceleration?: number;
+    /** Rate the speed sheds on approach, rows/s². Lower than `acceleration` gives a longer landing. */
+    deceleration?: number;
+    /** Height of a row in px, sampled each frame so a measured list can refine it. */
+    rowHeight?: () => number;
+    /** Empty space reserved below the last row, which the follow must stop short of. */
+    trailing?: () => number;
+};
+/** The physics runs in pixels; rows are converted at the boundary by {@link ScrollFollower}. */
+export type VelocityStep = {
+    /** Current speed, px/s. */
+    velocity: number;
+    /** Remaining distance to the target, px. */
+    distance: number;
+    /** Elapsed time since the last step, seconds. */
+    dt: number;
+    /** Ceiling, px/s. */
+    maxSpeed: number;
+    /** Ramp-up rate, px/s². */
+    acceleration: number;
+    /** Approach rate, px/s². Defaults to `acceleration`. */
+    deceleration?: number;
+};
+/**
+ * Speed for the next frame of a follow.
+ *
+ * Ramps up to `maxSpeed` and back down so the travel starts and ends gently rather than jumping.
+ * The cap is whichever is lower: the ceiling, or the speed from which the remaining distance can
+ * still be shed at `acceleration` (`v = sqrt(2·a·d)`) — that second term is what turns the arrival
+ * into a deceleration instead of a stop, and what keeps a growing target at cruise speed.
+ *
+ * Acceleration is rate-limited so a start is gradual; **deceleration is not**, because the braking
+ * curve is already a smooth ramp to zero and easing onto it instead leaves the speed above the
+ * curve for the whole approach — the follow then runs out of distance while still moving and the
+ * arrival reads as a stop rather than a landing.
+ */
+export declare const stepVelocity: ({ velocity, distance, dt, maxSpeed, acceleration, deceleration, }: VelocityStep) => number;
+/**
+ * **Not wired into `MessageList` at present.** The placement engine follows the tail by holding an
+ * intent and correcting the offset, which arrives instantly; this class is the animated travel the
+ * old engine used, kept with its tests because the glide is worth having back and nothing about it
+ * was wrong. Wiring it is a decision about feel, not a repair.
+ */
+/**
+ * Keeps an element scrolled to its bottom while its content grows.
+ *
+ * Native `scrollTo({ behavior: 'smooth' })` restarts its easing on every call, so a target that
+ * moves every chunk never leaves the start of the curve — the motion reads as a stutter. This
+ * carries velocity across frames instead: it accelerates as a stream begins, cruises while content
+ * keeps arriving, and decelerates onto the tail when it stops.
+ *
+ * `@dxos/ui-editor`'s `createCrawler` follows a streaming CodeMirror document the same way, with a
+ * critically-damped spring. The two are deliberately separate: that one is bound to `view.scrollDOM`
+ * and driven by editor effects, where a feed owns its own scroll container. The models differ in
+ * feel — a spring's speed falls off with distance, where this holds a ceiling and brakes onto the
+ * target, which keeps a fast stream at a constant rate rather than an ever-widening lag.
+ */
+export declare class ScrollFollower {
+    #private;
+    private readonly _element;
+    constructor(_element: HTMLElement, { maxSpeed, acceleration, deceleration, rowHeight, trailing }?: FollowOptions);
+    get running(): boolean;
+    /** Current speed, rows/s. Exposed so a harness can show the ramp. */
+    get velocity(): number;
+    /** Starts (or continues) travelling towards the bottom. Safe to call on every content change. */
+    start(): void;
+    /**
+     * Coasts to a halt, shedding speed at `deceleration` — what a stream ending or a stop control
+     * means. Cutting the animation instead would halt mid-glide, which is the one motion the reader
+     * cannot have caused and so reads as a fault.
+     */
+    stop(): void;
+    /**
+     * Halts immediately, discarding the velocity — the reader has taken over, or the list is going
+     * away. Coasting here would fight a hand already on the scrollbar.
+     */
+    cancel(): void;
+    /** Jumps to the bottom with no animation. */
+    jump(): void;
+}
+//# sourceMappingURL=follow.d.ts.map

package/dist/types/src/hooks/follow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"follow.d.ts","sourceRoot":"","sources":["../../../../src/hooks/follow.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,uCAAuC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mGAAmG;IACnG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kFAAkF;IAClF,SAAS,CAAC,EAAE,MAAM,MAAM,CAAC;IACzB,oFAAoF;IACpF,QAAQ,CAAC,EAAE,MAAM,MAAM,CAAC;CACzB,CAAC;AAkBF,gGAAgG;AAChG,MAAM,MAAM,YAAY,GAAG;IACzB,2BAA2B;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,EAAE,EAAE,MAAM,CAAC;IACX,qBAAqB;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,2BAA2B;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,wDAAwD;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,sEAOtB,YAAY,KAAG,MAIjB,CAAC;AAEF;;;;;GAKG;AACH;;;;;;;;;;;;;GAaG;AACH,qBAAa,cAAc;;IAavB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAD3B,YACmB,QAAQ,EAAE,WAAW,EACtC,EACE,QAA4B,EAC5B,YAAmC,EACnC,YAAmC,EACnC,SAAoC,EACpC,QAAkB,EACnB,GAAE,aAAkB,EAOtB;IAaD,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,qEAAqE;IACrE,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,iGAAiG;IACjG,KAAK,IAAI,IAAI,CAQZ;IAED;;;;OAIG;IACH,IAAI,IAAI,IAAI,CAOX;IAED;;;OAGG;IACH,MAAM,IAAI,IAAI,CAOb;IAED,6CAA6C;IAC7C,IAAI,IAAI,IAAI,CAGX;CAkDF"}

package/dist/types/src/hooks/follow.stories.d.ts

@@ -0,0 +1,25 @@
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+type StoryProps = {
+    count?: number;
+    /** rows/s */
+    maxSpeed?: number;
+    /** rows/s² */
+    acceleration?: number;
+    /** rows/s²; defaults to `acceleration` */
+    deceleration?: number;
+    /** Append an item every `growInterval` ms while following, to test a moving target. */
+    grow?: boolean;
+    growInterval?: number;
+};
+declare const meta: Meta<StoryProps>;
+export default meta;
+type Story = StoryObj<StoryProps>;
+/** Fixed target: press play and watch it ramp up, cruise, then brake onto the last row. */
+export declare const Default: Story;
+/** Moving target: rows keep arriving, so the follow should hold its cruise speed rather than stutter. */
+export declare const Growing: Story;
+/** Slower and gentler — the dials, for comparing feel. */
+export declare const Gentle: Story;
+/** Brakes harder than it accelerates: a quick pick-up with a long, soft landing. */
+export declare const LateBraking: Story;
+//# sourceMappingURL=follow.stories.d.ts.map

package/dist/types/src/hooks/follow.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"follow.stories.d.ts","sourceRoot":"","sources":["../../../../src/hooks/follow.stories.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAYjE,KAAK,UAAU,GAAG;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0CAA0C;IAC1C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uFAAuF;IACvF,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAgJF,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UAAU,CAM1B,CAAC;eAEa,IAAI;AAEnB,KAAK,KAAK,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAC;AAElC,2FAA2F;AAC3F,eAAO,MAAM,OAAO,EAAE,KAAU,CAAC;AAEjC,yGAAyG;AACzG,eAAO,MAAM,OAAO,EAAE,KAErB,CAAC;AAEF,0DAA0D;AAC1D,eAAO,MAAM,MAAM,EAAE,KAEpB,CAAC;AAEF,oFAAoF;AACpF,eAAO,MAAM,WAAW,EAAE,KAEzB,CAAC"}

package/dist/types/src/hooks/follow.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=follow.test.d.ts.map

package/dist/types/src/hooks/follow.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"follow.test.d.ts","sourceRoot":"","sources":["../../../../src/hooks/follow.test.ts"],"names":[],"mappings":""}

package/dist/types/src/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export * from './follow';
+export * from './useDecorations';
+export * from './useFeedNavigation';
+export * from './useFollow';
+export * from './useItemSelection';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/hooks/index.ts"],"names":[],"mappings":"AAIA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC"}

package/dist/types/src/hooks/useDecorations.d.ts

@@ -0,0 +1,31 @@
+import React, { type PropsWithChildren } from 'react';
+/**
+ * A range of one item's rendered text that some producer wants painted (SPEC: Decoration).
+ *
+ * Search is ONE producer — mentions, lint results and diff spans are others — which is why this is
+ * not called a hit: the item painting the range does not care where it came from, and the list does
+ * not know it exists at all.
+ */
+export type Decoration = {
+    /** Item (message) id. */
+    id: string;
+    range: {
+        offset: number;
+        length: number;
+    };
+    /** Producer tag: 'search' | 'mention' | ... */
+    kind: string;
+};
+export type DecorationsProviderProps = PropsWithChildren<{
+    decorations?: readonly Decoration[];
+}>;
+/**
+ * THE PATTERN for cross-cutting per-item data (SPEC §Aspects), not a feed feature: a provider at
+ * the host carries what producers made, and an item asks for its own by id. The list neither knows
+ * nor routes — `hits` left its API entirely. Grouped once per change rather than filtered per item,
+ * so a long feed stays O(decorations).
+ */
+export declare const DecorationsProvider: ({ decorations, children }: DecorationsProviderProps) => React.JSX.Element;
+/** An item's own decorations. Items work without a provider — they are simply undecorated. */
+export declare const useDecorations: (id: string) => readonly Decoration[];
+//# sourceMappingURL=useDecorations.d.ts.map

package/dist/types/src/hooks/useDecorations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDecorations.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useDecorations.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,EAAE,KAAK,iBAAiB,EAAsC,MAAM,OAAO,CAAC;AAE1F;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,yBAAyB;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1C,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAIF,MAAM,MAAM,wBAAwB,GAAG,iBAAiB,CAAC;IACvD,WAAW,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;CACrC,CAAC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,8BAA+B,wBAAwB,sBAatF,CAAC;AAIF,8FAA8F;AAC9F,eAAO,MAAM,cAAc,OAAQ,MAAM,KAAG,SAAS,UAAU,EAE9D,CAAC"}

package/dist/types/src/hooks/useFeedNavigation.d.ts

@@ -0,0 +1,44 @@
+import { type RefObject } from 'react';
+import { type Stop } from '../model';
+import { type WindowController } from '../virtualizer';
+export type UseFeedNavigationOptions = {
+    controller: RefObject<WindowController | null>;
+    /** The stops policy's current answer; asked per press, so a policy change needs no rewiring. */
+    stops: () => readonly Stop[];
+    /** The row containing the scroll offset — the cursor, derived and never set beside the scroll. */
+    current: () => number;
+    count: () => number;
+    /** Align the last stop to the end unless space is reserved past it (the reserve is scrollable). */
+    scrollPastEnd?: boolean;
+    /**
+     * Told before every jump, with the target index — the follow's `onNavigate` goes here. Without
+     * it a navigation races the follow's correction effect, which runs before the jump's scroll
+     * event can withdraw the intent and snaps the reader straight back to the tail they just left.
+     * The follow may move the view only while content is arriving AND the reader has pinned
+     * themselves to the bottom; navigating into the feed un-pins by definition.
+     */
+    onNavigate?: (index: number) => void;
+};
+export type FeedNavigation = {
+    /** Move by `delta` stops. Every press travels: see below. */
+    step: (delta: number) => void;
+    /** Jump to a stop (or a raw index), aligning the last row to the end where that is what it means. */
+    jumpTo: (index: number, behavior?: ScrollBehavior) => void;
+    first: () => void;
+    last: () => void;
+};
+/**
+ * The one navigation seam (SPEC: useFeedNavigation): toolbar buttons, arrow keys, the outline rail
+ * and the minimap all call this, so they cannot disagree about what a step is.
+ *
+ * Stepping is from the row containing the scroll offset. The stop above it begins strictly higher
+ * and the stop below strictly lower, so every press moves the viewport — an index compared against
+ * a position cannot promise that while positions are still being measured. Steps glide (corrections
+ * move the window, not the scroll, so nothing cancels the animation); far jumps are instant, since
+ * a glide across unmounted rows is a journey over a blank screen.
+ *
+ * Distinct from react-ui-list's `useListNavigation`, which is focus traversal over fully-mounted
+ * rows — a different problem in the same naming family.
+ */
+export declare const useFeedNavigation: ({ controller, stops, current, count, scrollPastEnd, onNavigate, }: UseFeedNavigationOptions) => FeedNavigation;
+//# sourceMappingURL=useFeedNavigation.d.ts.map

package/dist/types/src/hooks/useFeedNavigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFeedNavigation.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useFeedNavigation.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,SAAS,EAAe,MAAM,OAAO,CAAC;AAEpD,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,MAAM,MAAM,wBAAwB,GAAG;IACrC,UAAU,EAAE,SAAS,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;IAC/C,gGAAgG;IAChG,KAAK,EAAE,MAAM,SAAS,IAAI,EAAE,CAAC;IAC7B,kGAAkG;IAClG,OAAO,EAAE,MAAM,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,MAAM,CAAC;IACpB,mGAAmG;IACnG,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,6DAA6D;IAC7D,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B,qGAAqG;IACrG,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IAC3D,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,sEAO3B,wBAAwB,KAAG,cAgC7B,CAAC"}

package/dist/types/src/hooks/useFollow.d.ts

@@ -0,0 +1,46 @@
+import { type RefObject } from 'react';
+import { type Placement } from '../virtualizer/placement';
+export type FollowHandle = {
+    /**
+     * A navigation is the reader answering "do you want the tail?" — and it must answer *before* the
+     * scroll moves. The intent is otherwise withdrawn by the scroll event the jump raises, which is
+     * asynchronous: the correction effect can run in between, still believe the reader is following,
+     * and snap them straight back to the tail they just left. Found by the outline rail — a click
+     * near the top of a sticky feed moved the list a few pixels and no further.
+     */
+    onNavigate: (index: number) => void;
+};
+export type UseFollowOptions = {
+    scrollerRef: RefObject<HTMLElement | null>;
+    /** The placement whose `endOffset` is the tail's resting place. */
+    placement: Placement;
+    /** Total content extent — the correction re-runs when it changes, which is how growth is noticed. */
+    extent: number;
+    count: number;
+    axis?: 'block' | 'inline';
+    /** Empty extent after the last row; the end the follow rests at is before it. */
+    reserve?: number;
+    /** The standing intent: off means this hook does nothing at all. */
+    enabled?: boolean;
+    /**
+     * Travel to a moved tail instead of teleporting (DECIDED: default on).
+     *
+     * The glide only covers gaps up to a viewport: beyond that the reader could not have followed the
+     * motion anyway, and the travel would cross rows whose extents are still estimates.
+     */
+    glide?: boolean;
+};
+/**
+ * The sticky tail as an intent (SPEC: useFollow) — a policy over the window, not part of it.
+ *
+ * Withdrawn by one thing only: a scroll that moves *backwards*. That is the reader; a correction
+ * never moves the offset back, it moves the end away. Re-deriving the intent from proximity on
+ * every commit cannot survive its own corrections — measuring the tail grows the document under a
+ * reader who has not moved, the gap opens past any threshold worth having, and the follow reads
+ * that as the reader leaving and disengages for good (`bridge/Tail`, the second defect).
+ *
+ * Reusable for any streaming container — transcripts, logs — because nothing here knows about
+ * messages: it needs a scroller, a placement, and the two numbers that say the content grew.
+ */
+export declare const useFollow: ({ scrollerRef, placement, extent, count, axis, reserve, enabled, glide, }: UseFollowOptions) => FollowHandle;
+//# sourceMappingURL=useFollow.d.ts.map

package/dist/types/src/hooks/useFollow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFollow.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useFollow.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,SAAS,EAAiD,MAAM,OAAO,CAAC;AAEtF,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAS1D,MAAM,MAAM,YAAY,GAAG;IACzB;;;;;;OAMG;IACH,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IAC3C,mEAAmE;IACnE,SAAS,EAAE,SAAS,CAAC;IACrB,qGAAqG;IACrG,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC1B,iFAAiF;IACjF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,SAAS,8EASnB,gBAAgB,KAAG,YA6LrB,CAAC"}

package/dist/types/src/hooks/useItemSelection.d.ts

@@ -0,0 +1,34 @@
+import React, { type MouseEvent, type PropsWithChildren } from 'react';
+/** What an item can do about its own selection — the item-side face of the host's selection model. */
+export type ItemSelection = {
+    selected: boolean;
+    /** Additive when the gesture says so (meta/ctrl); the mode is the provider's business. */
+    toggle: (additive?: boolean) => void;
+};
+export type ItemSelectionValue = {
+    selectedIds?: ReadonlySet<string>;
+    onSelect?: (id: string, additive: boolean) => void;
+};
+export type ItemSelectionProviderProps = PropsWithChildren<ItemSelectionValue>;
+/**
+ * The item-side hook of the decoration pattern applied to selection (SPEC: useItemSelection): an
+ * item asks for its own `{ selected, toggle }` by id instead of the list threading `selectedIds`
+ * through props. Selection is model-space ids, so virtualization is untouched: an unmounted item is
+ * still selected, and mounts knowing it.
+ *
+ * The provider is deliberately the thinnest thing that works — a set and a callback. Mode policies
+ * (single | multi | range) belong to `react-ui-list`'s `useListSelection`, which a host composes
+ * *above* this provider; teaching this package about modes would be rebuilding that hook.
+ */
+export declare const ItemSelectionProvider: ({ selectedIds, onSelect, children }: ItemSelectionProviderProps) => React.JSX.Element;
+/**
+ * The whole selection value, for a component that renders many items in one pass.
+ *
+ * A row loop cannot call `useItemSelection` per row — hooks do not run in loops — so the viewport
+ * reads the value once and derives per-row state; item-shaped components use the per-id hook.
+ */
+export declare const useItemSelectionValue: () => ItemSelectionValue;
+export declare const useItemSelection: (id: string) => ItemSelection;
+/** Reads the additive intent off a gesture, so callers do not each invent the modifier rule. */
+export declare const isAdditive: (event: MouseEvent | globalThis.MouseEvent) => boolean;
+//# sourceMappingURL=useItemSelection.d.ts.map

package/dist/types/src/hooks/useItemSelection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useItemSelection.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useItemSelection.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,EAAE,KAAK,UAAU,EAAE,KAAK,iBAAiB,EAA0C,MAAM,OAAO,CAAC;AAE/G,sGAAsG;AACtG,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,OAAO,CAAC;IAClB,0FAA0F;IAC1F,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAClC,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC;CACpD,CAAC;AAIF,MAAM,MAAM,0BAA0B,GAAG,iBAAiB,CAAC,kBAAkB,CAAC,CAAC;AAE/E;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,wCAAyC,0BAA0B,sBAEpG,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,QAAO,kBAAsD,CAAC;AAEhG,eAAO,MAAM,gBAAgB,OAAQ,MAAM,KAAG,aAI7C,CAAC;AAEF,gGAAgG;AAChG,eAAO,MAAM,UAAU,UAAW,UAAU,GAAG,UAAU,CAAC,UAAU,KAAG,OACrB,CAAC"}

package/dist/types/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from './hooks';
+export * from './components';
+export * from './model';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAIA,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC"}

package/dist/types/src/model/feed-model.d.ts

@@ -0,0 +1,67 @@
+import { type Message } from '@dxos/types';
+/**
+ * What an item renders. The engine is renderer-agnostic: a message may resolve to a markdown
+ * document, to raw HTML (email bodies, which are not markdown and cannot be a CodeMirror document),
+ * or to a caller-supplied component.
+ */
+export type ItemContent = {
+    kind: 'markdown';
+    text: string;
+} | {
+    kind: 'html';
+    html: string;
+} | {
+    kind: 'custom';
+    key: string;
+    data?: unknown;
+};
+/** Resolves a message to the content its item renders. One per scenario (chat, email, …). */
+export type MessageRenderer = (message: Message.Message) => ItemContent;
+/**
+ * Default renderer: an `text/html` block wins (email), otherwise every block is flattened to
+ * markdown. Block kinds the engine does not know become fenced JSON so nothing renders as blank.
+ */
+export declare const defaultRenderer: MessageRenderer;
+/**
+ * Assistant chat: as {@link defaultRenderer}, plus the reader's own turns marked with `<prompt>`.
+ *
+ * Separate because the tag is only meaningful where a widget registry knows it — a feed rendered
+ * without one would show the reader their own angle brackets, which is what a human chat, a
+ * transcript and a comment list all are.
+ */
+export declare const chatRenderer: MessageRenderer;
+/** Plain text of a message, used by search and copy so both read the same projection. */
+export declare const messageText: (message: Message.Message, renderer: MessageRenderer) => string;
+export type SearchHit = {
+    messageId: string;
+    /** Index into the message list, so the virtualizer can scroll to it without a second lookup. */
+    index: number;
+    /** Offset into the message's rendered text. */
+    offset: number;
+    length: number;
+};
+/**
+ * Search the model rather than the DOM.
+ *
+ * Virtualization means most messages are not mounted, and a `viewType` filter can hide blocks that
+ * are still in the model — neither is reachable by a per-view CodeMirror search, so thread-wide find
+ * has to run over the projection.
+ */
+export declare const searchFeed: (messages: readonly Message.Message[], renderer: MessageRenderer, query: string) => SearchHit[];
+/** A point in the feed: a message plus an offset into its rendered text. */
+export type FeedAnchor = {
+    messageId: string;
+    offset: number;
+};
+export type FeedRange = {
+    from: FeedAnchor;
+    to: FeedAnchor;
+};
+/**
+ * Text between two anchors, spanning message boundaries.
+ *
+ * Native selection cannot span separate editor instances, and unmounted messages are not in the DOM
+ * at all, so cross-message copy is reconstructed from the model.
+ */
+export declare const sliceFeed: (messages: readonly Message.Message[], renderer: MessageRenderer, range: FeedRange) => string;
+//# sourceMappingURL=feed-model.d.ts.map

package/dist/types/src/model/feed-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feed-model.d.ts","sourceRoot":"","sources":["../../../../src/model/feed-model.ts"],"names":[],"mappings":"AAIA,OAAO,EAAqB,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAE9D;;;;GAIG;AACH,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAEpD,6FAA6F;AAC7F,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,KAAK,WAAW,CAAC;AAExE;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,eAA4D,CAAC;AAE3F;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,eAA2D,CAAC;AA2EvF,yFAAyF;AACzF,eAAO,MAAM,WAAW,YAAa,OAAO,CAAC,OAAO,YAAY,eAAe,KAAG,MAUjF,CAAC;AAaF,MAAM,MAAM,SAAS,GAAG;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,gGAAgG;IAChG,KAAK,EAAE,MAAM,CAAC;IACd,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,aACX,SAAS,OAAO,CAAC,OAAO,EAAE,YAC1B,eAAe,SAClB,MAAM,KACZ,SAAS,EAiBX,CAAC;AAMF,4EAA4E;AAC5E,MAAM,MAAM,UAAU,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/D,MAAM,MAAM,SAAS,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,EAAE,EAAE,UAAU,CAAA;CAAE,CAAC;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,SAAS,aACV,SAAS,OAAO,CAAC,OAAO,EAAE,YAC1B,eAAe,SAClB,SAAS,KACf,MAwBF,CAAC"}

package/dist/types/src/model/feed-model.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=feed-model.test.d.ts.map

package/dist/types/src/model/feed-model.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feed-model.test.d.ts","sourceRoot":"","sources":["../../../../src/model/feed-model.test.ts"],"names":[],"mappings":""}

package/dist/types/src/model/feed.d.ts

@@ -0,0 +1,66 @@
+import { type Message } from '@dxos/types';
+import { type MessageRenderer, type SearchHit } from './feed-model';
+import { ListModel } from './list-model';
+/**
+ * One position navigation can land on (SPEC: Stop).
+ *
+ * Produced by a pluggable policy over the model and consumed identically by every driver —
+ * toolbar, arrow keys, outliner, minimap — which is what keeps the rails and the keymap from
+ * growing parallel wiring.
+ */
+export type Stop = {
+    index: number;
+    id: string;
+    label?: string;
+};
+/** The built-in policies; a host may hand a function instead. */
+export type StopsPolicy = 'message' | 'prompt' | ((message: Message.Message, index: number) => boolean);
+export type FeedModelOptions = {
+    messages?: readonly Message.Message[];
+    stops?: StopsPolicy;
+    /** Paged history: consumed when the window reaches the start edge. Paging is the model's business. */
+    loadBefore?: () => Promise<readonly Message.Message[]>;
+    /** The forward twin, for feeds that are windows into something longer. */
+    loadAfter?: () => Promise<readonly Message.Message[]>;
+};
+/**
+ * The native case, not an add-on (SPEC: FeedModel): a ListModel of messages carrying the feed's
+ * own semantics — the stops policy, the streaming tail, and iteration. The list consumes this and
+ * nothing else; `hits`, `isAnchor` and `streamingId` all left the props API and live here or in
+ * the decoration provider.
+ *
+ * ECHO/queue bindings adapt to this outside the package; `fromMessages` adapts the plain case.
+ */
+export declare class FeedModel extends ListModel<Message.Message> {
+    #private;
+    constructor({ messages, stops, loadBefore, loadAfter }?: FeedModelOptions);
+    get messages(): readonly Message.Message[];
+    /** The tail message reconciling by delta; its item must not remount per chunk. */
+    get streamingId(): string | undefined;
+    setStreaming(id: string | undefined): void;
+    /** A chunk arrived for the streaming tail: same identity, longer content. */
+    stream(id: string): void;
+    setStops(stops: StopsPolicy): void;
+    /**
+     * The positions navigation can land on, under the current policy.
+     *
+     * Recomputed on demand rather than cached: a policy is a predicate over the model, and the model
+     * knows when it changed — callers that want reactivity derive from `rowsAtom`.
+     */
+    stops(): Stop[];
+    /**
+     * The window reached the start: ask the source for history.
+     *
+     * The model owns iteration (SPEC F-7.2) — the pages arrive as a prepend, which the virtualizer
+     * is told about, so nothing on screen moves (F-1.1). Serialized, because edges are reached once
+     * per frame while the reader sits on them.
+     */
+    more(edge: 'start' | 'end'): Promise<boolean>;
+    /** Model-level search, since virtualization hides most items from any DOM search. */
+    search(query: string, renderer?: MessageRenderer): SearchHit[];
+    /** The rendered text of one message, for previews and rails. */
+    textOf(id: string, renderer?: MessageRenderer): string | undefined;
+}
+/** The plain case: a feed over an array the host already has. */
+export declare const fromMessages: (messages: readonly Message.Message[], options?: Omit<FeedModelOptions, 'messages'>) => FeedModel;
+//# sourceMappingURL=feed.d.ts.map

package/dist/types/src/model/feed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feed.d.ts","sourceRoot":"","sources":["../../../../src/model/feed.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,SAAS,EAA4C,MAAM,cAAc,CAAC;AAC9G,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC;;;;;;GAMG;AACH,MAAM,MAAM,IAAI,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,iEAAiE;AACjE,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,QAAQ,GAAG,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC;AAExG,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,EAAE,SAAS,OAAO,CAAC,OAAO,EAAE,CAAC;IACtC,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,sGAAsG;IACtG,UAAU,CAAC,EAAE,MAAM,OAAO,CAAC,SAAS,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IACvD,0EAA0E;IAC1E,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,SAAS,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;CACvD,CAAC;AAEF;;;;;;;GAOG;AACH,qBAAa,SAAU,SAAQ,SAAS,CAAC,OAAO,CAAC,OAAO,CAAC;;IAOvD,YAAY,EAAE,QAAa,EAAE,KAAiB,EAAE,UAAU,EAAE,SAAS,EAAE,GAAE,gBAAqB,EAK7F;IAED,IAAI,QAAQ,IAAI,SAAS,OAAO,CAAC,OAAO,EAAE,CAEzC;IAED,kFAAkF;IAClF,IAAI,WAAW,IAAI,MAAM,GAAG,SAAS,CAEpC;IAED,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CASzC;IAED,6EAA6E;IAC7E,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAEvB;IAED,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAEjC;IAED;;;;;OAKG;IACH,KAAK,IAAI,IAAI,EAAE,CAgBd;IAED;;;;;;OAMG;IACG,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAuBlD;IAED,qFAAqF;IACrF,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,GAAE,eAAiC,GAAG,SAAS,EAAE,CAE9E;IAED,gEAAgE;IAChE,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,GAAE,eAAiC,GAAG,MAAM,GAAG,SAAS,CAIlF;CACF;AAED,iEAAiE;AACjE,eAAO,MAAM,YAAY,aAAc,SAAS,OAAO,CAAC,OAAO,EAAE,YAAW,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC,cACrE,CAAC"}

package/dist/types/src/model/feed.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=feed.test.d.ts.map

package/dist/types/src/model/feed.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feed.test.d.ts","sourceRoot":"","sources":["../../../../src/model/feed.test.ts"],"names":[],"mappings":""}

package/dist/types/src/model/index.d.ts

@@ -0,0 +1,5 @@
+export * from './feed-model';
+export * from './feed';
+export * from './list-model';
+export * from './useListModel';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/model/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/model/index.ts"],"names":[],"mappings":"AAIA,cAAc,cAAc,CAAC;AAC7B,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC"}

package/dist/types/src/model/list-model.d.ts

@@ -0,0 +1,61 @@
+import * as Atom from 'effect/unstable/reactivity/Atom';
+/**
+ * What one change to the model actually was — told, never inferred.
+ *
+ * The virtualizer's anchor survives a prepend only if it knows the prepend happened (SPEC F-7.1);
+ * the engine used to reconstruct that by scanning for the previous first id, which is the model's
+ * knowledge recovered from its absence. Here the model says so. The identity scan still exists in
+ * exactly one place — `replace`, the adapter for hosts that hand over a whole new array — because
+ * that is the one caller that genuinely does not know.
+ */
+export type ListChange = {
+    prepended?: number;
+    appended?: number;
+    /** Ids whose content changed in place — a streaming tail, an edit. */
+    updated?: readonly string[];
+};
+export type ListModelOptions<T> = {
+    items?: readonly T[];
+    /** Identity of an item. Measurements, selection and decorations are all keyed by this. */
+    getId: (item: T) => string;
+};
+/**
+ * The low-level reactive collection the virtualizer binds to (SPEC: ListModel).
+ *
+ * Two faces on one state, deliberately: a plain synchronous face (`count`, `at`, `subscribe`) that
+ * the virtualizer consumes without dragging an atom registry into every story and test, and an
+ * atom face (`rowsAtom`) for hosts that live in atom-land — derivations (stops, decorations,
+ * readouts) hang off the atom rather than becoming parallel props. Both are the same array; the
+ * subscribe face is not a fallback but the binding's contract.
+ */
+export declare class ListModel<T> {
+    #private;
+    /** The rows as an atom, for derivations. Registry-managed by whoever consumes it. */
+    readonly rowsAtom: Atom.Writable<readonly T[]>;
+    constructor({ items, getId }: ListModelOptions<T>);
+    get count(): number;
+    get items(): readonly T[];
+    getId: (index: number) => string;
+    at: (index: number) => T | undefined;
+    indexOf(id: string): number;
+    subscribe(listener: (change: ListChange) => void): () => void;
+    append(items: readonly T[]): void;
+    prepend(items: readonly T[]): void;
+    /** An item changed in place — same identity, new content. */
+    update(id: string): void;
+    /**
+     * Replace one item with a successor of the same identity — the streaming case for *frozen*
+     * items. An ECHO object mutates and `update` announces it; a schema-made message is frozen, so
+     * the chunk arrives as a fresh value under the old id. Same event either way: `updated`.
+     */
+    patch(id: string, next: T): void;
+    /**
+     * The adapter for hosts that hand over a whole new array (a React prop, a query result).
+     *
+     * The one place the prepend inference survives, because this is the one caller that genuinely
+     * does not know what changed: the old first item is found in the new array, and everything before
+     * it was prepended. The virtualizer itself is always told (SPEC F-7.1).
+     */
+    replace(items: readonly T[]): void;
+}
+//# sourceMappingURL=list-model.d.ts.map

package/dist/types/src/model/list-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-model.d.ts","sourceRoot":"","sources":["../../../../src/model/list-model.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,IAAI,MAAM,iCAAiC,CAAC;AAGxD;;;;;;;;GAQG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sEAAsE;IACtE,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI;IAChC,KAAK,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC;IACrB,0FAA0F;IAC1F,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC;CAC5B,CAAC;AAEF;;;;;;;;GAQG;AACH,qBAAa,SAAS,CAAC,CAAC;;IAKtB,qFAAqF;IACrF,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;IAG/C,YAAY,EAAE,KAAU,EAAE,KAAK,EAAE,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAOrD;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,KAAK,IAAI,SAAS,CAAC,EAAE,CAExB;IAED,KAAK,UAAW,MAAM,KAAG,MAAM,CAG7B;IAEF,EAAE,UAAW,MAAM,KAAG,CAAC,GAAG,SAAS,CAAuB;IAE1D,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAE1B;IAED,SAAS,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,GAAG,MAAM,IAAI,CAG5D;IAED,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,IAAI,CAOhC;IAED,OAAO,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,IAAI,CAOjC;IAED,6DAA6D;IAC7D,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAEvB;IAED;;;;OAIG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAQ/B;IAED;;;;;;OAMG;IACH,OAAO,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,IAAI,CAkBjC;CAQF"}

package/dist/types/src/model/list-model.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=list-model.test.d.ts.map

package/dist/types/src/model/list-model.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-model.test.d.ts","sourceRoot":"","sources":["../../../../src/model/list-model.test.ts"],"names":[],"mappings":""}

package/dist/types/src/model/useListModel.d.ts

@@ -0,0 +1,22 @@
+import { type Message } from '@dxos/types';
+import { FeedModel, type FeedModelOptions } from './feed';
+import { ListModel } from './list-model';
+/**
+ * A model over an array the host re-creates per render — the React-prop case.
+ *
+ * The model is stable; the array is folded into it with `replace`, which is where the prepend
+ * inference lives (and the only place — SPEC F-7.1). In an effect rather than during render: the
+ * model publishes synchronously to its subscribers, and a subscriber invalidating itself while the
+ * host is still rendering is a cross-component update React rejects. The window it opens is one
+ * frame, and the window's own subscription closes it.
+ */
+export declare const useListModel: <T>(items: readonly T[], getId: (item: T) => string) => ListModel<T>;
+/**
+ * The feed-shaped twin, for a host that re-creates its message array per render.
+ *
+ * Streaming through this adapter is a `replace` whose length does not change; the model still
+ * publishes, so the window still re-renders, and the streaming item reconciles by document delta
+ * exactly as it would under a told update.
+ */
+export declare const useFeedModel: (messages: readonly Message.Message[], options?: Omit<FeedModelOptions, 'messages'>) => FeedModel;
+//# sourceMappingURL=useListModel.d.ts.map

package/dist/types/src/model/useListModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useListModel.d.ts","sourceRoot":"","sources":["../../../../src/model/useListModel.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,QAAQ,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,SAAS,CAAC,EAAE,SAAS,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,KAAG,SAAS,CAAC,CAAC,CAU5F,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,aACb,SAAS,OAAO,CAAC,OAAO,EAAE,YAC3B,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC,KAC1C,SAUF,CAAC"}