@dxos/react-ui-feed 0.11.1

package/dist/types/src/stories/assistant.stories.d.ts

@@ -0,0 +1,38 @@
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+/**
+ * The plugin-assistant use case, end to end: a reader typing prompts into a conversation while an
+ * agent streams multi-block answers into its tail — status, reasoning, a tool call and its result,
+ * then the answer, exactly the block sequence a model emits (`streamTurn`).
+ *
+ * Everything here goes through the shipping path and the model's *told* APIs: a typed prompt is
+ * `model.append`, the agent's turn mutates one identity via `model.stream`, and the follow keeps
+ * the tail at rest because the reader is there — scrolling up withdraws it, returning restores it.
+ * The `debug` arg turns on the generic Debug table (`@dxos/react-ui-feed/debug`), with probes over
+ * the frame rate, the model, the window and the widget census — every aspect readable live.
+ */
+type StoryArgs = {
+    count?: number;
+    debug?: boolean;
+    scrollPastEnd?: boolean;
+    wordsPerChunk?: number;
+    chunkDelay?: number;
+};
+declare const meta: Meta<StoryArgs>;
+export default meta;
+type Story = StoryObj<StoryArgs>;
+/** The loop, hands on: type a prompt, or press ▶ and watch. No play — this one is for people. */
+export declare const Default: Story;
+/**
+ * The whole conversation loop, driven as a reader would drive it.
+ *
+ * A prompt is typed and entered; the agent answers in blocks; the tail stays at rest through the
+ * stream (the follow at work); scrolling up mid-answer withdraws the follow and the feed holds
+ * still under a growing document.
+ */
+export declare const Assistant: Story;
+/**
+ * Scrolling away mid-answer stops the follow, and it stays stopped: a reader looking at history is
+ * not dragged back by the stream. Returning to the tail opts back in.
+ */
+export declare const Interrupted: Story;
+//# sourceMappingURL=assistant.stories.d.ts.map

package/dist/types/src/stories/assistant.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistant.stories.d.ts","sourceRoot":"","sources":["../../../../src/stories/assistant.stories.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAcjE;;;;;;;;;;GAUG;AACH,KAAK,SAAS,GAAG;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAiPF,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,SAAS,CAUzB,CAAC;eAEa,IAAI;AAEnB,KAAK,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC;AAiBjC,iGAAiG;AACjG,eAAO,MAAM,OAAO,EAAE,KAAU,CAAC;AAEjC;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,EAAE,KA+DvB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,KAsCzB,CAAC"}

package/dist/types/src/stories/baseline.stories.d.ts

@@ -0,0 +1,32 @@
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import { type FeedStoryProps } from '../testing';
+/**
+ * The bisection ladder for scroll stability.
+ *
+ * Each rung adds one thing to the one before it, so a defect can be attributed rather than guessed
+ * at: if a rung is still and the next one moves, the difference between them is the cause. The
+ * statusbar's `jumps` (rows moving on screen against the scroll, sampled per frame) and `shifts`
+ * (rows whose offset changed after layout) are the readings; both should be zero on a still feed.
+ *
+ * 1. **Plain** — no editor at all, every row a fixed height declared in advance. Nothing here can be
+ *    measured wrong, so any movement belongs to the list itself.
+ * 2. **Uniform** — one editor per row, every row the identical document, so a single estimate is
+ *    exactly right for all of them. What this adds over Plain is CodeMirror construction.
+ * 3. **Varied** — one editor per row, contents of different lengths, so the estimate is wrong for
+ *    most rows and the list corrects as it goes. What this adds is measurement error.
+ *
+ * Above the ladder sit the call-site stories (`MessageList/Assistant` and friends), which add
+ * per-message renderers, block widgets and streaming.
+ */
+declare const meta: Meta<FeedStoryProps>;
+export default meta;
+type Story = StoryObj<FeedStoryProps>;
+/** The feed at rest — the varied rung, which is the one that matters. No play. */
+export declare const Default: Story;
+/** Rung 1: fixed heights, no editor. If this moves, the list is at fault. */
+export declare const Plain: Story;
+/** Rung 2: an editor per row, all identical — adds CodeMirror construction. */
+export declare const Uniform: Story;
+/** Rung 3: an editor per row, varied lengths — adds measurement error. */
+export declare const Varied: Story;
+//# sourceMappingURL=baseline.stories.d.ts.map

package/dist/types/src/stories/baseline.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseline.stories.d.ts","sourceRoot":"","sources":["../../../../src/stories/baseline.stories.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAIjE,OAAO,EAAa,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5D;;;;;;;;;;;;;;;;;GAiBG;AACH,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,cAAc,CAmB9B,CAAC;eAEa,IAAI;AAEnB,KAAK,KAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,CAAC;AAEtC,kFAAkF;AAClF,eAAO,MAAM,OAAO,EAAE,KAErB,CAAC;AAEF,6EAA6E;AAC7E,eAAO,MAAM,KAAK,EAAE,KAInB,CAAC;AAEF,+EAA+E;AAC/E,eAAO,MAAM,OAAO,EAAE,KAIrB,CAAC;AAEF,0EAA0E;AAC1E,eAAO,MAAM,MAAM,EAAE,KAIpB,CAAC"}

package/dist/types/src/stories/bridge.stories.d.ts

@@ -0,0 +1,72 @@
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React from 'react';
+import { type FeedScenario } from '../testing';
+declare const DefaultStory: ({ scenario, count, sticky, scrollPastEnd, }: {
+    scenario: FeedScenario;
+    count: number;
+    sticky?: boolean;
+    scrollPastEnd?: boolean;
+}) => React.JSX.Element;
+declare const meta: Meta<typeof DefaultStory>;
+export default meta;
+type Story = StoryObj<typeof DefaultStory>;
+/** The bridge passively: real messages on the window, nothing asserted. */
+export declare const Default: Story;
+/** Fixed-height rows, no editor: whatever moves here is the placement and nothing else. */
+export declare const Plain: Story;
+/** One editor per row, all identical. */
+export declare const Uniform: Story;
+/** A chat's shape: per-message renderers, block widgets, a per-message estimate. */
+export declare const Assistant: Story;
+/**
+ * A chat's tail: the last message rests on the bottom, and stays there as answers arrive.
+ *
+ * The invariant `baseline/tail` holds the current engine to, pointed at the new one. Read from the
+ * last row's own bottom edge rather than the scroll offset: an offset can be at the document's end
+ * while the last message is nowhere near the screen, which is what both of that story's defects
+ * looked like from outside.
+ *
+ * It failed for a while, and what it caught was not the tail arithmetic either time. First a stale
+ * `getId` — `Window` held the closure it was constructed with, so an appended row's measurement was
+ * filed under one id and read back under another and the row was re-measured every commit, which
+ * React ends by exceeding the update limit. Then a follow re-derived from proximity, which its own
+ * corrections disengage. Both presented as "the tail is in the wrong place".
+ */
+export declare const Tail: Story;
+/**
+ * The tail, with a viewport's worth of space reserved past it.
+ *
+ * The case the old engine cannot do at all: its reserve is a DOM spacer, so the element and the
+ * virtualizer disagree about where the document ends and an offset inside the reserve is beyond the
+ * virtualizer's maximum, where `scrollToOffset` declines to move. The feed opened at the document's
+ * end with its last message near the top of an empty screen — reported from a real session, and the
+ * reason `baseline/tail` has no `VariedPastEnd`.
+ *
+ * Here the reserve is a term in the sizer and `endOffset` is the last row's own end, so "the end of
+ * the content" and "the end of the document" are two numbers in one coordinate system rather than
+ * two systems.
+ */
+export declare const VariedPastEnd: Story;
+/**
+ * Scrolling moves the content by exactly what was scrolled, and by nothing else.
+ *
+ * Reported from a real session as the feed "jumping as soon as it starts to scroll". Measurement
+ * *is* allowed to move things — a row that turns out taller pushes the rows after it, and that is
+ * the list working — so the reading is the row the reader is looking at: whatever is under the top
+ * of the viewport when a step begins must be exactly one step higher when it ends.
+ *
+ * That is what a re-base breaks and what an anchor cannot: re-basing the document rewrites every
+ * position including the ones above the reader, so a correction anywhere lands as a jump here.
+ */
+export declare const Scrolling: Story;
+/**
+ * The top of the conversation exists.
+ *
+ * A feed opened at its tail derives every position above the reader from estimates; rows measuring
+ * taller than assumed push row 0 negative, where no scroll can reach it — the reader arrives at the
+ * top and the first messages are simply not there (seen live: the flagship opened with its first
+ * prompt missing). The start edge is repaid by shifting content and scroll together, so this drives
+ * to the top and asks the one absolute fact of content space: row 0 starts at zero.
+ */
+export declare const Top: Story;
+//# sourceMappingURL=bridge.stories.d.ts.map

package/dist/types/src/stories/bridge.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.stories.d.ts","sourceRoot":"","sources":["../../../../src/stories/bridge.stories.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,KAA+C,MAAM,OAAO,CAAC;AAOpE,OAAO,EAAE,KAAK,YAAY,EAAiC,MAAM,YAAY,CAAC;AAmB9E,QAAA,MAAM,YAAY,gDAKf;IACD,QAAQ,EAAE,YAAY,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,sBA+DA,CAAC;AAEF,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,OAAO,YAAY,CAKnC,CAAC;eAEa,IAAI;AAEnB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,YAAY,CAAC,CAAC;AAkE3C,2EAA2E;AAC3E,eAAO,MAAM,OAAO,EAAE,KAErB,CAAC;AAEF,2FAA2F;AAC3F,eAAO,MAAM,KAAK,EAAE,KAAgC,CAAC;AAErD,yCAAyC;AACzC,eAAO,MAAM,OAAO,EAAE,KAAkC,CAAC;AAEzD,oFAAoF;AACpF,eAAO,MAAM,SAAS,EAAE,KAAoC,CAAC;AAE7D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,IAAI,EAAE,KA8BlB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,EAAE,KA6B3B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,EAAE,KA4CvB,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,GAAG,EAAE,KAwBjB,CAAC"}

package/dist/types/src/stories/construction.stories.d.ts

@@ -0,0 +1,17 @@
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React from 'react';
+declare const ConstructionProfile: ({ runs }: {
+    runs?: number;
+}) => React.JSX.Element;
+declare const meta: Meta<typeof ConstructionProfile>;
+export default meta;
+type Story = StoryObj<typeof ConstructionProfile>;
+/**
+ * How long one item takes to build, by extension set.
+ *
+ * The first fill mounts a viewport of rows in one go, so the `×22 rows` column is the wall-clock
+ * cost of that fill — the number to compare against the >1s `baseline/Uniform` takes to appear.
+ * Read it from the story, or from the `[item construction]` line the storybook test run prints.
+ */
+export declare const Default: Story;
+//# sourceMappingURL=construction.stories.d.ts.map

package/dist/types/src/stories/construction.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"construction.stories.d.ts","sourceRoot":"","sources":["../../../../src/stories/construction.stories.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,KAAsC,MAAM,OAAO,CAAC;AA4E3D,QAAA,MAAM,mBAAmB,aAAmB;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,sBA6B5D,CAAC;AAgBF,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,OAAO,mBAAmB,CAK1C,CAAC;eAEa,IAAI;AAEnB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAElD;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,EAAE,KAAU,CAAC"}

package/dist/types/src/stories/fill.stories.d.ts

@@ -0,0 +1,51 @@
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import { type FeedStoryProps } from '../testing';
+/**
+ * How long the first fill takes, and what it spends the time on.
+ *
+ * `baseline/Uniform` visibly fills from the bottom up over more than a second, which construction
+ * cost does not explain — `stories/construction` measures one item at ~0.4ms, so a viewport of them
+ * is ~8ms. The remaining explanation is the number of *passes*: every measured row changes the
+ * offsets below it, and each correction the virtualizer makes costs a frame. This samples the DOM
+ * once per animation frame and reports how many frames the list took to stop changing.
+ */
+declare const meta: Meta<FeedStoryProps>;
+export default meta;
+type Story = StoryObj<FeedStoryProps>;
+/** Passive: the first fill, watched rather than measured. */
+export declare const Default: Story;
+/** No editor at all: the floor, and what every other case is compared against. */
+export declare const Plain: Story;
+/**
+ * The same feed, a tenth the length.
+ *
+ * A virtualized list mounts a viewport's worth of rows either way, so a cost that follows the count
+ * belongs to the model — building the messages, projecting them — and a cost that does not belongs
+ * to the rows on screen. Which one it is decides where the fix goes.
+ */
+export declare const PlainShort: Story;
+/** One editor per row, all identical — construction, and nothing else, added to `Plain`. */
+export declare const Uniform: Story;
+/**
+ * The same feed with space reserved past the end.
+ *
+ * The reserved space is part of the document, so everything that reads the element's own maximum —
+ * the tail test, the follow's target, the opening offset — has to stop short of it instead. This is
+ * where that is checked.
+ */
+/** Tall uneven rows and space past the end: the case where the opening jump is most wrong. */
+export declare const PlainPastEnd: Story;
+export declare const UniformPastEnd: Story;
+export declare const UniformShort: Story;
+/**
+ * Contents of different lengths, so the estimate is wrong for most rows.
+ *
+ * The one rung where the rebuild is still not atomic: the reader is put back by index, and with rows
+ * of every height the offsets around the landing point are mostly estimates, so the virtualizer
+ * retries across a frame and the page is seen to move in it. Restoring by offset instead lands in
+ * one frame and then spends a second correcting itself — measured at 69–96 of 150 frames changing,
+ * against one here. Recorded in `chat-ui/TASKS.md`; the allowance is what is measured today, so a
+ * regression past it still fails.
+ */
+export declare const Varied: Story;
+//# sourceMappingURL=fill.stories.d.ts.map

package/dist/types/src/stories/fill.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fill.stories.d.ts","sourceRoot":"","sources":["../../../../src/stories/fill.stories.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAKjE,OAAO,EAAa,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5D;;;;;;;;GAQG;AACH,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,cAAc,CAK9B,CAAC;eAEa,IAAI;AAEnB,KAAK,KAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,CAAC;AA2KtC,6DAA6D;AAC7D,eAAO,MAAM,OAAO,EAAE,KAErB,CAAC;AAEF,kFAAkF;AAClF,eAAO,MAAM,KAAK,EAAE,KAGnB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,KAGxB,CAAC;AAEF,4FAA4F;AAC5F,eAAO,MAAM,OAAO,EAAE,KAGrB,CAAC;AAEF;;;;;;GAMG;AACH,8FAA8F;AAC9F,eAAO,MAAM,YAAY,EAAE,KAG1B,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,KAQ5B,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,KAG1B,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,EAAE,KAGpB,CAAC"}

package/dist/types/src/stories/horizontal.stories.d.ts

@@ -0,0 +1,17 @@
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React from 'react';
+declare const DefaultStory: () => React.JSX.Element;
+declare const meta: Meta<typeof DefaultStory>;
+export default meta;
+type Story = StoryObj<typeof DefaultStory>;
+/** The horizontal strip, passively. No play. */
+export declare const Default: Story;
+/**
+ * The block-axis invariants, on the inline axis, with editors.
+ *
+ * Nothing here names a direction the arithmetic could hide behind: rows are tracked by index, a
+ * scroll must move them by what was scrolled, and the far end must be reachable — the same three
+ * readings `bridge/*` takes vertically.
+ */
+export declare const InlineContent: Story;
+//# sourceMappingURL=horizontal.stories.d.ts.map

package/dist/types/src/stories/horizontal.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"horizontal.stories.d.ts","sourceRoot":"","sources":["../../../../src/stories/horizontal.stories.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,KAA0B,MAAM,OAAO,CAAC;AA6B/C,QAAA,MAAM,YAAY,yBAyBjB,CAAC;AAEF,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,OAAO,YAAY,CAKnC,CAAC;eAEa,IAAI;AAEnB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,YAAY,CAAC,CAAC;AAU3C,gDAAgD;AAChD,eAAO,MAAM,OAAO,EAAE,KAAU,CAAC;AAEjC;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,EAAE,KAsC3B,CAAC"}

package/dist/types/src/stories/mount.stories.d.ts

@@ -0,0 +1,19 @@
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+type MountProfileProps = {
+    count?: number;
+    runs?: number;
+};
+declare const meta: Meta<MountProfileProps>;
+export default meta;
+type Story = StoryObj<MountProfileProps>;
+/**
+ * Per-row mount cost up the ladder.
+ *
+ * `plain` has no editor at all, `uniform` adds one identical editor per row, `assistant` adds
+ * per-message renderers and block widgets. `ms/row` is the number that decides whether the first
+ * fill is worth optimizing in the item or in the list.
+ */
+export declare const Default: Story;
+/** The same rows in a shorter feed: anything that changes here scales with the model, not the view. */
+export declare const Short: Story;
+//# sourceMappingURL=mount.stories.d.ts.map

package/dist/types/src/stories/mount.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mount.stories.d.ts","sourceRoot":"","sources":["../../../../src/stories/mount.stories.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAyDjE,KAAK,iBAAiB,GAAG;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AA4IF,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,iBAAiB,CAKjC,CAAC;eAEa,IAAI;AAEnB,KAAK,KAAK,GAAG,QAAQ,CAAC,iBAAiB,CAAC,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,EAAE,KAAsD,CAAC;AAE7E,uGAAuG;AACvG,eAAO,MAAM,KAAK,EAAE,KAAqD,CAAC"}

package/dist/types/src/stories/navigation.stories.d.ts

@@ -0,0 +1,33 @@
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import { type FeedStoryProps } from '../testing';
+/**
+ * Arrow keys step between the feed's stops, one press one stop.
+ *
+ * The property under test is that a press always moves, and always to the adjacent stop: a smooth
+ * scroll passes through every range between here and its target, and the cursor follows the range
+ * whenever the reader scrolls past it — so a navigation that does not defend its destination
+ * overwrites it mid-flight and the next press steps from a row the animation was crossing. The
+ * symptom is an arrow that sometimes moves and sometimes returns to the row it just left.
+ */
+declare const meta: Meta<FeedStoryProps>;
+export default meta;
+type Story = StoryObj<FeedStoryProps>;
+/** Passive: the feed with its stops, for driving by hand. */
+export declare const Default: Story;
+/**
+ * Every press moves, and lands on a stop.
+ *
+ * `assistant` makes every second message a prompt and only prompts are stops, so a stop is an even
+ * index — which is what makes "landed on a stop" checkable rather than merely "moved". The first
+ * press is the odd one out: the feed opens on the last message, an answer, so the nearest stop above
+ * it is one index away where every step afterwards is two.
+ */
+export declare const Arrows: Story;
+/**
+ * The same property where every message is a stop.
+ *
+ * `plain` names no `isAnchor`, so a press steps one message — and its rows are tall and unequal,
+ * which is the case where the offset moves furthest between two stops.
+ */
+export declare const Plain: Story;
+//# sourceMappingURL=navigation.stories.d.ts.map

package/dist/types/src/stories/navigation.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.stories.d.ts","sourceRoot":"","sources":["../../../../src/stories/navigation.stories.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAKjE,OAAO,EAAa,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5D;;;;;;;;GAQG;AACH,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,cAAc,CAK9B,CAAC;eAEa,IAAI;AAEnB,KAAK,KAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,CAAC;AA4CtC,6DAA6D;AAC7D,eAAO,MAAM,OAAO,EAAE,KAErB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,EAAE,KAmCpB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,KAenB,CAAC"}

package/dist/types/src/stories/streaming.stories.d.ts

@@ -0,0 +1,17 @@
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import { type FeedStoryProps } from '../testing';
+/**
+ * The deciding case: a model answering into the tail while the reader watches.
+ *
+ * Every other rung measures a feed that has stopped. This one measures the feed doing the thing it
+ * exists for — a row growing on every frame, re-parsing its markdown as it goes, while the list
+ * follows the tail it keeps moving. Streaming is where the follow, the measurement and the item's
+ * reconciliation all run at once, and it is the only place their interaction shows.
+ */
+declare const meta: Meta<FeedStoryProps>;
+export default meta;
+type Story = StoryObj<FeedStoryProps>;
+/** Passive: press ▶ yourself. */
+export declare const Default: Story;
+export declare const Streaming: Story;
+//# sourceMappingURL=streaming.stories.d.ts.map

package/dist/types/src/stories/streaming.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.stories.d.ts","sourceRoot":"","sources":["../../../../src/stories/streaming.stories.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAKjE,OAAO,EAAa,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5D;;;;;;;GAOG;AACH,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,cAAc,CAQ9B,CAAC;eAEa,IAAI;AAEnB,KAAK,KAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,CAAC;AAkEtC,iCAAiC;AACjC,eAAO,MAAM,OAAO,EAAE,KAAU,CAAC;AAEjC,eAAO,MAAM,SAAS,EAAE,KA+BvB,CAAC"}

package/dist/types/src/stories/tail.stories.d.ts

@@ -0,0 +1,47 @@
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import { type FeedStoryProps } from '../testing';
+/**
+ * A feed opened at its tail shows its last message, and stays there.
+ *
+ * Both halves matter and both have been broken. The feed has landed at the tail the *estimate*
+ * predicted — 60,000px into a document that measured 71,565 — and been marked positioned there, so
+ * it opened part-way up the conversation and crept the rest of the way at two rows a second. And
+ * with space reserved past the end it has scrolled straight through the last message into the blank
+ * area below it, because the follow chased the element's own maximum rather than the last row.
+ *
+ * So the reading here is the **last row's own bottom edge**, measured against the viewport's, rather
+ * than the scroll offset: an offset can be at the document's end while the last message is nowhere
+ * near the screen. It has to arrive there, and it has to stop.
+ */
+declare const meta: Meta<FeedStoryProps>;
+export default meta;
+type Story = StoryObj<FeedStoryProps>;
+/** Passive: open at the tail and look. */
+export declare const Default: Story;
+/** Tall, uneven rows: the case where the estimate is furthest from the truth. */
+export declare const Plain: Story;
+export declare const PlainPastEnd: Story;
+/** Short rows, all identical: the estimate is right, so the tail should be right immediately. */
+export declare const Uniform: Story;
+export declare const UniformPastEnd: Story;
+/** A chat's shape: per-message renderers, block widgets, and a per-row estimate. */
+export declare const Assistant: Story;
+export declare const AssistantPastEnd: Story;
+/**
+ * The rung the reader actually opened: an editor per row, contents of different lengths.
+ *
+ * `plain` and `uniform` are estimates that happen to be right, and `assistant` is 200 rows rather
+ * than 500. This is the one where the estimate is wrong for nearly every row *and* the document is
+ * long.
+ *
+ * Its `scrollPastEnd` twin is **not** here, and deliberately. It fails, and what it fails on is not
+ * fixable in this engine: the reserved space is a DOM spacer, so it is in the element's
+ * `scrollHeight` and not in the virtualizer's total, and an offset inside it is beyond the
+ * virtualizer's own maximum — `scrollToOffset` then silently declines to move (verified: the element
+ * stayed exactly where it was). The feed opens at the document's end with its last message near the
+ * top of an empty screen. Two coordinate systems for one document is the defect the placement layer
+ * exists to remove, so the requirement is stated where it can be met: `bridge/VariedPastEnd`.
+ */
+export declare const Varied: Story;
+export declare const VariedPastEnd: Story;
+//# sourceMappingURL=tail.stories.d.ts.map

package/dist/types/src/stories/tail.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tail.stories.d.ts","sourceRoot":"","sources":["../../../../src/stories/tail.stories.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAKjE,OAAO,EAAa,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5D;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,cAAc,CAK9B,CAAC;eAEa,IAAI;AAEnB,KAAK,KAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,CAAC;AAsDtC,0CAA0C;AAC1C,eAAO,MAAM,OAAO,EAAE,KAErB,CAAC;AAEF,iFAAiF;AACjF,eAAO,MAAM,KAAK,EAAE,KAGnB,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,KAG1B,CAAC;AAEF,iGAAiG;AACjG,eAAO,MAAM,OAAO,EAAE,KAGrB,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,KAG5B,CAAC;AAEF,oFAAoF;AACpF,eAAO,MAAM,SAAS,EAAE,KAGvB,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,KAG9B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,MAAM,EAAE,KAGpB,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,KAG3B,CAAC"}

package/dist/types/src/stories/widget.stories.d.ts

@@ -0,0 +1,16 @@
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import { type FeedStoryProps } from '../testing';
+/**
+ * A widget the reader opened stays open when its row leaves the window and comes back.
+ *
+ * This is the one blocker on retrofitting `plugin-assistant`, whose tool panels are exactly this: a
+ * disclosure whose open flag is React state inside the widget, which dies with the item. In a
+ * thread that is one long document the question never arises, because nothing ever unmounts.
+ */
+declare const meta: Meta<FeedStoryProps>;
+export default meta;
+type Story = StoryObj<FeedStoryProps>;
+/** Passive: toggle the panels by hand. */
+export declare const Default: Story;
+export declare const Reopened: Story;
+//# sourceMappingURL=widget.stories.d.ts.map

package/dist/types/src/stories/widget.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widget.stories.d.ts","sourceRoot":"","sources":["../../../../src/stories/widget.stories.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAKjE,OAAO,EAAa,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5D;;;;;;GAMG;AACH,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,cAAc,CAM9B,CAAC;eAEa,IAAI;AAEnB,KAAK,KAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,CAAC;AAkBtC,0CAA0C;AAC1C,eAAO,MAAM,OAAO,EAAE,KAErB,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,KAuDtB,CAAC"}

package/dist/types/src/testing/FeedStory.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import { type FeedScenario } from './scenarios';
+export type FeedStoryProps = {
+    /**
+     * Which downstream call site to approximate. Each supplies its own renderer, chrome and follow
+     * behaviour; everything else — the list, virtualization, selection, search — is the same engine.
+     * Omitted, the story runs the synthetic mixed feed the measurements were taken against.
+     */
+    scenario?: FeedScenario;
+    /** Messages of seeded history; 0 starts empty. */
+    count?: number;
+    /** Outline every item and every block inside it; the toolbar toggles it too. */
+    debug?: boolean;
+    /** Begin streaming turns on mount. */
+    streaming?: boolean;
+    wordsPerChunk?: number;
+    chunkDelay?: number;
+    estimateSize?: number;
+    /** Reserve space below the last row so any message can be brought to the top. */
+    scrollPastEnd?: boolean;
+};
+/**
+ * The one renderer every `MessageList` story uses; the stories differ only by args.
+ *
+ * Seeded history, a search over the model, message-set selection, and a play control that streams
+ * turns into the tail until stopped — one harness, so a story is a set of arguments rather than
+ * another component to keep in step.
+ */
+export declare const FeedStory: ({ scenario, scrollPastEnd, count, debug: debugProp, streaming: streamingProp, wordsPerChunk, chunkDelay, estimateSize, }: FeedStoryProps) => React.JSX.Element;
+//# sourceMappingURL=FeedStory.d.ts.map

package/dist/types/src/testing/FeedStory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeedStory.d.ts","sourceRoot":"","sources":["../../../../src/testing/FeedStory.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAoD,MAAM,OAAO,CAAC;AAazE,OAAO,EAAE,KAAK,YAAY,EAAkB,MAAM,aAAa,CAAC;AAmFhE,MAAM,MAAM,cAAc,GAAG;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gFAAgF;IAChF,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,sCAAsC;IACtC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iFAAiF;IACjF,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,6HASnB,cAAc,sBA+LhB,CAAC"}

package/dist/types/src/testing/MessageWindow.d.ts

@@ -0,0 +1,48 @@
+import React, { type ComponentType } from 'react';
+import { type Message } from '@dxos/types';
+import { type MessageChromeProps } from '../components';
+import { type MessageRenderer } from '../model';
+import { type WindowController, type WindowState } from '../virtualizer';
+/**
+ * A feed of real messages placed by `Window`, and nothing else.
+ *
+ * The bridge between the placement layer and the thing it has to replace. `placement/*` proves the
+ * shape against boxes that cannot lie about their size; `baseline/*` proves the current engine
+ * against real editors. This is where those meet: the same messages, the same renderer and the same
+ * chrome as a feed, but placed by the new module — so the baseline invariants can be pointed at it
+ * and answer whether the replacement is ready, rather than the question being settled by argument.
+ *
+ * Deliberately *not* wired into `MessageList.Root`. Root owns the follow, the sticky tail, the
+ * anchors and the cursor as well as the virtualizer, so swapping the placement inside it is not a
+ * swap but a reimplementation — and doing that before this exists would leave nothing to check it
+ * against.
+ */
+export type MessageWindowProps = {
+    messages: Message.Message[];
+    renderer?: MessageRenderer;
+    Chrome?: ComponentType<MessageChromeProps>;
+    Custom?: ComponentType<{
+        content: any;
+        message: Message.Message;
+    }>;
+    /** Extent of a row before it has been measured; a function where rows differ widely. */
+    estimateSize?: number | ((message: Message.Message, index: number) => number);
+    gutter?: 'sm' | 'md' | 'lg';
+    /** Keep the last message against the bottom as content arrives — a chat's standing intent. */
+    sticky?: boolean;
+    /**
+     * Empty extent after the last row, so it can be brought to the top of the viewport.
+     *
+     * A number, computed by the host from its own container. Not a `scrollPastEnd` mode: with the
+     * window placed rather than the rows, the reserve is a term in the sizer and nothing else in the
+     * engine knows about it (§7) — which is what the old engine could not say, since its reserve was
+     * a DOM spacer outside the virtualizer's coordinate space.
+     */
+    reserve?: number;
+    onChange?: (state: WindowState) => void;
+    controllerRef?: React.Ref<WindowController>;
+};
+export declare const MessageWindow: ({ messages, renderer, Chrome, Custom, estimateSize, gutter, sticky, reserve, onChange, controllerRef, }: MessageWindowProps) => React.JSX.Element;
+/** Kept for the stories that drive it; the ref is the same handle `placement/*` uses. */
+export declare const useMessageWindow: () => React.RefObject<WindowController | null>;
+//# sourceMappingURL=MessageWindow.d.ts.map

package/dist/types/src/testing/MessageWindow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageWindow.d.ts","sourceRoot":"","sources":["../../../../src/testing/MessageWindow.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,EAAE,KAAK,aAAa,EAA0C,MAAM,OAAO,CAAC;AAG1F,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAA4B,KAAK,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAElF,OAAO,EAAE,KAAK,eAAe,EAAmB,MAAM,UAAU,CAAC;AACjE,OAAO,EAAU,KAAK,gBAAgB,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAEjF;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC;IAC5B,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,MAAM,CAAC,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAAC;IAC3C,MAAM,CAAC,EAAE,aAAa,CAAC;QAAE,OAAO,EAAE,GAAG,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;KAAE,CAAC,CAAC;IACnE,wFAAwF;IACxF,YAAY,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IAC9E,MAAM,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;IAC5B,8FAA8F;IAC9F,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IACxC,aAAa,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;CAC7C,CAAC;AAIF,eAAO,MAAM,aAAa,4GAWvB,kBAAkB,sBA+CpB,CAAC;AA0BF,yFAAyF;AACzF,eAAO,MAAM,gBAAgB,gDAAuC,CAAC"}

package/dist/types/src/testing/controls.d.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+import { type Message } from '@dxos/types';
+/**
+ * Controls for attributing what a row costs to mount.
+ *
+ * `baseline/mount` measures a whole feed with its fixtures already built and finds ~2ms for a row
+ * with no editor against ~15ms for a row with one — while the same editor constructed into an
+ * offscreen container costs 0.4ms (`baseline/construction`). These render the *same* rows through
+ * the same chrome, differing only in what is inside them, so the gap can be attributed rather than
+ * argued about.
+ */
+export type ControlContent = {
+    data?: unknown;
+};
+/** The floor: the row's text, and no editor at all. */
+export declare const TextItem: ({ content }: {
+    content: ControlContent;
+    message: Message.Message;
+}) => React.JSX.Element;
+export declare const BareEditorItem: ({ content }: {
+    content: ControlContent;
+    message: Message.Message;
+}) => React.JSX.Element;
+export declare const ThemedEditorItem: ({ content }: {
+    content: ControlContent;
+    message: Message.Message;
+}) => React.JSX.Element;
+export declare const MarkdownEditorItem: ({ content }: {
+    content: ControlContent;
+    message: Message.Message;
+}) => React.JSX.Element;
+export declare const DecoratedEditorItem: ({ content }: {
+    content: ControlContent;
+    message: Message.Message;
+}) => React.JSX.Element;
+/**
+ * The real item, reached the same way the probes are.
+ *
+ * The rung that separates *what the editor is configured with* from *what the component does around
+ * it*: everything outside this component is identical to `uniform-decorated`.
+ */
+export declare const MarkdownProbeItem: ({ content }: {
+    content: ControlContent;
+    message: Message.Message;
+}) => React.JSX.Element;
+//# sourceMappingURL=controls.d.ts.map

package/dist/types/src/testing/controls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controls.d.ts","sourceRoot":"","sources":["../../../../src/testing/controls.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAkC,MAAM,OAAO,CAAC;AAEvD,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAU3C;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAEhD,uDAAuD;AACvD,eAAO,MAAM,QAAQ,gBAAiB;IAAE,OAAO,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;CAAE,sBAE1F,CAAC;AAiBF,eAAO,MAAM,cAAc,gBAAiB;IAAE,OAAO,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;CAAE,sBAEhG,CAAC;AAEF,eAAO,MAAM,gBAAgB,gBAAiB;IAAE,OAAO,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;CAAE,sBAElG,CAAC;AAEF,eAAO,MAAM,kBAAkB,gBAAiB;IAAE,OAAO,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;CAAE,sBAEpG,CAAC;AAEF,eAAO,MAAM,mBAAmB,gBAAiB;IAAE,OAAO,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;CAAE,sBAErG,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,gBAAiB;IAAE,OAAO,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;CAAE,sBAEnG,CAAC"}

package/dist/types/src/testing/debug/FeedStats.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { type ThemedClassName } from '@dxos/react-ui';
+import { type FrameMeter } from '../../debug';
+export type FeedStatsProps = ThemedClassName<{
+    meter: FrameMeter;
+    streaming?: boolean;
+    selected?: number;
+    hits?: number;
+}>;
+/**
+ * Everything measured about a feed, floating over it.
+ *
+ * It sits above the viewport rather than in a statusbar because a statusbar is part of the layout
+ * being measured: a block of readouts that grows or wraps changes the height of the scroll
+ * container, and every number in it would then describe a viewport the readouts themselves resized.
+ */
+export declare const FeedStats: ({ classNames, meter, streaming, selected, hits }: FeedStatsProps) => React.JSX.Element;
+//# sourceMappingURL=FeedStats.d.ts.map

package/dist/types/src/testing/debug/FeedStats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeedStats.d.ts","sourceRoot":"","sources":["../../../../../src/testing/debug/FeedStats.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAyC,MAAM,OAAO,CAAC;AAE9D,OAAO,EAAc,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAIlE,OAAO,EAAE,KAAK,UAAU,EAA+B,MAAM,aAAa,CAAC;AA8E3E,MAAM,MAAM,cAAc,GAAG,eAAe,CAAC;IAC3C,KAAK,EAAE,UAAU,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,qDAA8D,cAAc,sBA+EjG,CAAC"}

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

@@ -0,0 +1,4 @@
+export * from './FeedStats';
+export * from './sweep';
+export * from './use-feed-debug';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/testing/debug/index.ts"],"names":[],"mappings":"AAYA,cAAc,aAAa,CAAC;AAE5B,cAAc,SAAS,CAAC;AACxB,cAAc,kBAAkB,CAAC"}

package/dist/types/src/testing/debug/sweep.d.ts

@@ -0,0 +1,18 @@
+export type SweepOptions = {
+    /** Travel speed in px/s. @default 3000 */
+    velocity?: number;
+    /** Time for one leg (ms). @default 5000 */
+    duration?: number;
+    /** Called once the return leg lands, or when cancelled. */
+    onDone?: () => void;
+};
+/**
+ * Scrolls an element down and back at a fixed speed.
+ *
+ * A measured pass has to be one repeatable gesture or the numbers cannot be compared between
+ * stories, and a 2,000-row feed is far too long to fling by hand. Fixed speed for a fixed time —
+ * rather than a fixed fraction of the document — so the two stories being compared travel the same
+ * distance even though they disagree about how tall the document is until their rows have measured.
+ */
+export declare const sweepScroll: (element: HTMLElement, { velocity, duration, onDone }?: SweepOptions) => () => void;
+//# sourceMappingURL=sweep.d.ts.map

package/dist/types/src/testing/debug/sweep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sweep.d.ts","sourceRoot":"","sources":["../../../../../src/testing/debug/sweep.ts"],"names":[],"mappings":"AAkBA,MAAM,MAAM,YAAY,GAAG;IACzB,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,YACb,WAAW,mCACsC,YAAY,eA+CvE,CAAC"}