@artooi/ag-ui-web-component 0.48.0 → 0.49.0

package/dist/tools/chat_surface_tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chat_surface_tools.d.ts","sourceRoot":"","sources":["../../src/tools/chat_surface_tools.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE5D,kFAAkF;AAClF,eAAO,MAAM,YAAY,YAAI,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,cAAc,CAAU,CAAC;AAE9F,yCAAyC;AACzC,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvD,oEAAoE;AACpE,MAAM,WAAW,iBAAiB;IAChC,gEAAgE;IAChE,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,gDAAgD;IAChD,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,2DAA2D;IAC3D,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B;;;;;;;OAOG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,6DAA6D;IAC7D,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,gDAAgD;IAChD,QAAQ,CAAC,GAAG,EAAE;QACZ,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;KACzB,CAAC;IACF;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,EAAE;QACjB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;KACzB,CAAC;CACH;AAED,sDAAsD;AACtD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,UAAU,CAE/D;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B,eAAe,IAAI,iBAAiB,CAAC;IACrC;;;;;OAKG;IACH,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC;IAC/E,YAAY,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;CACnF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,WAAW,GAAG,UAAU,EAAE,CA8GzE"}
+{"version":3,"file":"chat_surface_tools.d.ts","sourceRoot":"","sources":["../../src/tools/chat_surface_tools.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE5D,kFAAkF;AAClF,eAAO,MAAM,YAAY,YAAI,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,cAAc,CAAU,CAAC;AAE9F,yCAAyC;AACzC,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvD,oEAAoE;AACpE,MAAM,WAAW,iBAAiB;IAChC,gEAAgE;IAChE,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,gDAAgD;IAChD,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,2DAA2D;IAC3D,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B;;;;;;;OAOG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,6DAA6D;IAC7D,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,gDAAgD;IAChD,QAAQ,CAAC,GAAG,EAAE;QACZ,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;KACzB,CAAC;IACF;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,EAAE;QACjB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;KACzB,CAAC;CACH;AAED,sDAAsD;AACtD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,UAAU,CAE/D;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B,eAAe,IAAI,iBAAiB,CAAC;IACrC;;;;;OAKG;IACH,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC;IAC/E,YAAY,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;CACnF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,WAAW,GAAG,UAAU,EAAE,CA4GzE"}

package/dist/ui/placement/dock_styles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dock_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/placement/dock_styles.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,EAAE,MAsFzB,CAAC"}
+{"version":3,"file":"dock_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/placement/dock_styles.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,EAAE,MA0FzB,CAAC"}

package/dist/ui/placement/panel_placement.d.ts

@@ -62,6 +62,11 @@ export declare class PanelPlacement {
      * Drop the dragged size and its stored copy, so the placement's own size and
      * the host's tokens apply again. For a host entering a sized state of its
      * own, which a user's drag would otherwise outrank.
+     *
+     * A docked panel the user dragged off its dock goes back to it as well, and
+     * the stored spot with it: there the position is part of the same resting
+     * state the host is asking for. A corner panel keeps a dragged position, as
+     * it always has.
      */
     resetSize(): void;
     /**

package/dist/ui/placement/panel_placement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel_placement.d.ts","sourceRoot":"","sources":["../../../src/ui/placement/panel_placement.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACvF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAuGlD;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,uDAAuD;IACvD,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,8CAA8C;IAC9C,QAAQ,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC;IAClC,uCAAuC;IACvC,QAAQ,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC;IAClC,kEAAkE;IAClE,QAAQ,CAAC,WAAW,EAAE,MAAM,OAAO,CAAC;IACpC,iCAAiC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,SAAS,CAAC;IAClC,qDAAqD;IACrD,QAAQ,CAAC,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IACzD,kDAAkD;IAClD,QAAQ,CAAC,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAChE,iDAAiD;IACjD,QAAQ,CAAC,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD,uEAAuE;IACvE,QAAQ,CAAC,qBAAqB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;CAC1E;AAED;;;;;;;GAOG;AACH,qBAAa,cAAc;;IAGzB,YAAY,IAAI,EAAE,aAAa,EAE9B;IAED;;;OAGG;IACH,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAOzC;IAED;;;;OAIG;IACH,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAS5C;IAED,mFAAmF;IACnF,gBAAgB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAqBxC;IAED,sDAAsD;IACtD,WAAW,IAAI,IAAI,CAElB;IAED;;;;OAIG;IACH,SAAS,IAAI,IAAI,CAOhB;IAED;;;;OAIG;IACH,QAAQ,CAAC,KAAK,iBAAiC;IAqE/C;;;;;;OAMG;IACH,QAAQ,IAAI,OAAO,CAKlB;IAED,+EAA+E;IAC/E,eAAe,IAAI,iBAAiB,CAyBnC;IAED,oEAAoE;IACpE,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,GAAE;QAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CA2CjF;IA0HD,sEAAsE;IACtE,gBAAgB,IAAI,IAAI,CAYvB;IA0CD;;;;;;OAMG;IACH,gBAAgB,IAAI,IAAI,CAQvB;IAcD;;;;;;;;;OASG;IACH,QAAQ,CAAC,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,GAAG,MAAM,CAmBzD;IAsFD;;;;;;;;;;;;OAYG;IACH,qBAAqB,IAAI,IAAI,CAgD5B;IA8PD;;;;;OAKG;IACH,uBAAuB,IAAI,IAAI,CAmB9B;IAiCD;;;;OAIG;IACH,uBAAuB,IAAI,IAAI,CAU9B;CAuHF"}
+{"version":3,"file":"panel_placement.d.ts","sourceRoot":"","sources":["../../../src/ui/placement/panel_placement.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACvF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAgHlD;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,uDAAuD;IACvD,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,8CAA8C;IAC9C,QAAQ,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC;IAClC,uCAAuC;IACvC,QAAQ,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC;IAClC,kEAAkE;IAClE,QAAQ,CAAC,WAAW,EAAE,MAAM,OAAO,CAAC;IACpC,iCAAiC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,SAAS,CAAC;IAClC,qDAAqD;IACrD,QAAQ,CAAC,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IACzD,kDAAkD;IAClD,QAAQ,CAAC,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAChE,iDAAiD;IACjD,QAAQ,CAAC,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD,uEAAuE;IACvE,QAAQ,CAAC,qBAAqB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;CAC1E;AAED;;;;;;;GAOG;AACH,qBAAa,cAAc;;IAGzB,YAAY,IAAI,EAAE,aAAa,EAE9B;IAED;;;OAGG;IACH,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAOzC;IAED;;;;OAIG;IACH,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAS5C;IAED,mFAAmF;IACnF,gBAAgB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAqBxC;IAED,sDAAsD;IACtD,WAAW,IAAI,IAAI,CAElB;IAED;;;;;;;;;OASG;IACH,SAAS,IAAI,IAAI,CAchB;IAED;;;;OAIG;IACH,QAAQ,CAAC,KAAK,iBAAiC;IA2F/C;;;;;;OAMG;IACH,QAAQ,IAAI,OAAO,CAKlB;IAED,+EAA+E;IAC/E,eAAe,IAAI,iBAAiB,CA+BnC;IAED,oEAAoE;IACpE,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,GAAE;QAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAmDjF;IAmID,sEAAsE;IACtE,gBAAgB,IAAI,IAAI,CAYvB;IA0CD;;;;;;OAMG;IACH,gBAAgB,IAAI,IAAI,CAQvB;IAiBD;;;;;;;;;OASG;IACH,QAAQ,CAAC,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,GAAG,MAAM,CA8BzD;IA4LD;;;;;;;;;;;;OAYG;IACH,qBAAqB,IAAI,IAAI,CAgD5B;IAyQD;;;;;OAKG;IACH,uBAAuB,IAAI,IAAI,CA0B9B;IAiCD;;;;OAIG;IACH,uBAAuB,IAAI,IAAI,CAiB9B;CAgIF"}

package/dist/ui/placement/surface_for.d.ts

@@ -37,10 +37,18 @@ export interface Surface {
     readonly collapseTo: CollapseTarget;
     /**
      * Whether a gesture may move the launcher. The rest have nowhere to put it:
-     * the rail is a docked edge, `header` and `null` have no launcher, and a
-     * full-bleed panel covers the screen it would be opening into.
+     * the rail is a docked edge, `header` and `null` have no launcher, a
+     * full-bleed panel covers the screen it would be opening into, and the bar
+     * and the host's own control are not a launcher at all.
      */
     readonly launcherDraggable: boolean;
+    /**
+     * Whether the header drag and `moveTo` may move the open panel. The same
+     * answer as {@link launcherDraggable} for every placement on its own; the two
+     * part under `collapse-to="bar"` and `"none"`, where a corner panel still
+     * moves like one but has no launcher left to drag.
+     */
+    readonly panelMovable: boolean;
     /**
      * Which axes the resize grips may change. A full-bleed layout is the whole
      * viewport by definition and cannot be resized; a docked panel owns its
@@ -69,10 +77,11 @@ export interface Surface {
  * state, never a placement's own shape: `bar` applies where the placement
  * collapses to `launcher`, so the sidebar keeps its rail and an embedded chat
  * its header bar, and `none` applies to every collapsible placement. Absent,
- * `auto` and any other value leave the placement as it was. A docked surface
- * cannot be moved -- the panel rises from the bar or the host's anchor, and a
- * position the user dragged would take it away from either -- so both turn
- * the launcher drag off, and with it the header drag and `moveTo`.
+ * `auto` and any other value leave the placement as it was. Both turn the
+ * launcher drag off, because there is no launcher left to drag, and keep the
+ * placement's own answer for moving the panel: a corner panel rises from the
+ * bar or the anchor until the user drags it somewhere else, and a placement
+ * that owns its position keeps owning it.
  */
 export declare function surfaceFor(placement: string | null, collapseTo?: string | null): Surface;
 //# sourceMappingURL=surface_for.d.ts.map

package/dist/ui/placement/surface_for.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"surface_for.d.ts","sourceRoot":"","sources":["../../../src/ui/placement/surface_for.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,MAAM,GAAG,IAAI,CAAC;AAEpF;;;;;;;GAOG;AACH,MAAM,WAAW,OAAO;IACtB,4EAA4E;IAC5E,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC;AA2DD;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,EAAE,UAAU,GAAE,MAAM,GAAG,IAAW,GAAG,OAAO,CAS9F"}
+{"version":3,"file":"surface_for.d.ts","sourceRoot":"","sources":["../../../src/ui/placement/surface_for.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,MAAM,GAAG,IAAI,CAAC;AAEpF;;;;;;;GAOG;AACH,MAAM,WAAW,OAAO;IACtB,4EAA4E;IAC5E,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC;AA2ED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,EAAE,UAAU,GAAE,MAAM,GAAG,IAAW,GAAG,OAAO,CAS9F"}

package/dist/ui/progress/tool_group_styles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool_group_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/progress/tool_group_styles.ts"],"names":[],"mappings":"AAmCA,eAAO,MAAM,iBAAiB,EAAE,MAqP/B,CAAC"}
+{"version":3,"file":"tool_group_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/progress/tool_group_styles.ts"],"names":[],"mappings":"AAmCA,eAAO,MAAM,iBAAiB,EAAE,MAsP/B,CAAC"}

package/dist/ui/shell/token_styles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"token_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/shell/token_styles.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,EAAE,MA8a1B,CAAC"}
+{"version":3,"file":"token_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/shell/token_styles.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,EAAE,MA4c1B,CAAC"}

package/dist/ui/themes/quiet_styles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quiet_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/themes/quiet_styles.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY,EAAE,MA8G1B,CAAC"}
+{"version":3,"file":"quiet_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/themes/quiet_styles.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY,EAAE,MA8H1B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artooi/ag-ui-web-component",
-  "version": "0.48.0",
+  "version": "0.49.0",
   "description": "Framework-free <ag-ui-chat> Web Component over the AG-UI protocol. Drop-in chat sidebar with a pluggable client-side tool registry, DOM driver primitives, animations, and destructive-action confirmation modal.",
   "type": "module",
   "main": "./dist/index.js",

package/src/core/ag_ui_chat.ts

@@ -1128,7 +1128,8 @@ export class AgUiChat extends HTMLElement {
       return;
     }
     // collapse-to changes the surface the way placement does -- a docked panel
-    // cannot be moved, so the same handover applies -- and is live the same way.
+    // has no launcher to drag, and keeps its own dragged spot apart from the
+    // corner's, so the same handover applies -- and is live the same way.
     if (name === "placement" || name === "collapse-to") {
       // A placement owns the axes it fixes, so hand those back before anything
       // else: a size dragged under the previous placement would otherwise sit
@@ -2076,7 +2077,9 @@ export class AgUiChat extends HTMLElement {
    * `movable` folds two separate reasons into the one answer a caller needs:
    * a placement that places itself owns its position, and a panel that fills
    * the screen has nowhere to go. Reporting them apart would make every caller
-   * re-derive the same conjunction.
+   * re-derive the same conjunction. A corner panel docked under
+   * `collapse-to="bar"` or `"none"` is movable on a wide viewport, like the
+   * corner panel it is.
    */
   describeSurface(): ChatSurfaceReport {
     return this.#placement.describeSurface();
@@ -2091,7 +2094,8 @@ export class AgUiChat extends HTMLElement {
    * the corner it opens from is re-picked, and switching placement hands
    * everything back. What it must not do is claim a move it did not make --
    * hence the boolean, and hence {@link describeSurface} existing so a caller
-   * can ask first.
+   * can ask first. A docked panel moves too, within the room above its bar or
+   * anchor, and remembers the spot as a header drag would.
    */
   moveTo(corner: ChatCorner, options: { readonly announce?: boolean } = {}): boolean {
     return this.#placement.moveTo(corner, options);
@@ -2100,6 +2104,9 @@ export class AgUiChat extends HTMLElement {
   /**
    * Drop a size the user dragged, and its stored copy, so the placement's
    * default and the host's `--ag-ui-width` / `--ag-ui-height` apply again.
+   * Under `collapse-to="bar"` or `"none"` it also returns a panel the user
+   * dragged off its dock to the dock, and forgets the stored spot; a corner
+   * panel keeps a dragged position.
    */
   resetSize(): void {
     this.#placement.resetSize();

package/src/tools/chat_surface_tools.ts

@@ -161,11 +161,9 @@ export function createChatSurfaceTools(surface: ChatSurface): ClientTool[] {
             moved: false,
             reason: report.fullBleed
               ? "the panel fills the screen, so there is nowhere to move it to"
-              : report.collapseTo === "bar" || report.collapseTo === "none"
-                ? "the panel is docked: it rises from the page's bottom bar and stays there"
-                : report.draggable === false
-                  ? "this page has turned off moving the panel"
-                  : `the "${report.placement ?? ""}" placement owns the panel's position`,
+              : report.draggable === false
+                ? "this page has turned off moving the panel"
+                : `the "${report.placement ?? ""}" placement owns the panel's position`,
             suggestion: report.collapsible ? "minimise_chat" : null,
           };
         }

package/src/ui/placement/dock_styles.ts

@@ -16,7 +16,11 @@ export const DOCK_STYLES: string = `
    The cap follows the token block's rule: what the host left free less the
    one gutter the anchored edge spends, so a panel grown to the cap runs from
    just above the bar to the far edge. A host therefore needs no inset to keep
-   the panel off its bar; --ag-ui-inset still wins when set.
+   the panel off its bar; --ag-ui-inset still wins when set. A panel the user
+   dragged off its dock is written there inline, which is how the dragged spot
+   outranks every rule below, the anchor gap included; the element holds that
+   spot above the bar or the anchor itself, and drops it on a phone, where the
+   small-viewport block reads the same property first.
 
    These blocks restate tokens and nothing else, and sit ahead of the phone
    block at no more weight than it has, so on a phone the panel is the screen

package/src/ui/placement/panel_placement.ts

@@ -50,6 +50,15 @@ const DOCK_RIGHT = "--_dock-right";
 /** Per-tab persistence key for a dragged launcher position. */
 const LAUNCHER_KEY = "ag-ui-chat:launcher";
 
+/**
+ * Persistence key for where the user dragged a docked panel. Its own key, not
+ * the launcher's: a spot stored under the corner launcher describes another
+ * surface, and reading it here would open every panel away from the bar for a
+ * host that switched to the bar after its users had dragged their corner
+ * panels.
+ */
+const DOCK_KEY = "ag-ui-chat:dock";
+
 /** A stored `{ left, top }` pair, or null for anything that is not one. */
 function asPoint(value: unknown): { readonly left: number; readonly top: number } | null {
   if (typeof value !== "object" || value === null) {
@@ -157,7 +166,7 @@ export class PanelPlacement {
    */
   enablePanelDrag(header: HTMLElement): void {
     enablePanelDrag(header, {
-      enabled: () => !this.#host.collapsed() && this.#launcherDraggable(),
+      enabled: () => !this.#host.collapsed() && this.#canDragPanel(),
       rect: () => this.#host.element.getBoundingClientRect(),
       apply: (box, from) => this.#movePanel(box, from),
       commit: (box, from) => this.#commitPanel(box, from),
@@ -213,11 +222,23 @@ export class PanelPlacement {
    * Drop the dragged size and its stored copy, so the placement's own size and
    * the host's tokens apply again. For a host entering a sized state of its
    * own, which a user's drag would otherwise outrank.
+   *
+   * A docked panel the user dragged off its dock goes back to it as well, and
+   * the stored spot with it: there the position is part of the same resting
+   * state the host is asking for. A corner panel keeps a dragged position, as
+   * it always has.
    */
   resetSize(): void {
     this.#host.element.style.removeProperty(DRAG_WIDTH);
     this.#host.element.style.removeProperty(DRAG_HEIGHT);
     this.#host.clearPreference(SIZE_KEY);
+    if (this.#docked()) {
+      if (this.#dockPos !== null) {
+        this.#host.element.style.removeProperty("--ag-ui-inset");
+      }
+      this.#dockPos = null;
+      this.#storeDockPosition(null);
+    }
     // The anchor was measured against the dragged box; the resting one may
     // pin different edges.
     this.syncResizeAnchor();
@@ -250,6 +271,25 @@ export class PanelPlacement {
    */
   #panelPos: { readonly left: number; readonly top: number } | null = null;
 
+  /**
+   * Where the user dragged a docked panel, in viewport coordinates, or null
+   * while it stands on the bar or the anchor.
+   *
+   * Apart from the two corner positions above because it moves nothing else:
+   * a docked panel has no launcher to carry, and the corner it opens from is
+   * the dock's. Held as the user stated it and never as clamped, so a bar that
+   * grew, or a phone that took the panel full-bleed, gives the spot back
+   * unchanged once there is room for it again.
+   */
+  #dockPos: { readonly left: number; readonly top: number } | null = null;
+
+  /**
+   * The line a docked panel stays above, in viewport coordinates: the bar's
+   * top, or the anchor's. Infinite where neither is drawn. Measured by
+   * syncDock, which runs on every change either can make.
+   */
+  #dockTop = Number.POSITIVE_INFINITY;
+
   /**
    * The corner the panel opens away from, once this element is placing itself.
    * Null means the host's layout still decides, and the anchor is measured.
@@ -281,7 +321,10 @@ export class PanelPlacement {
    * rather than collapsed to nothing.
    */
   #withinViewport(box: PanelRect): PanelRect {
-    const viewport = this.#viewport();
+    // A docked panel that moves has its room stop at the dock, so no grip
+    // pulls it over the bar it minimises to. A placement that owns its
+    // position keeps the bound it always had.
+    const viewport = this.#docked() && this.#panelMovable() ? this.#dockRoom() : this.#viewport();
     // The same bound a drag stops at, so a grip pulled to the edge and a panel
     // dragged to it come to rest on the same line. The inner Math.max/min pair
     // keeps an already-inverted box from turning inside out.
@@ -321,8 +364,14 @@ export class PanelPlacement {
       collapseTo: this.#surface().collapseTo,
       collapsed: this.#host.collapsed(),
       collapsible: this.#host.collapsible(),
-      movable: this.#launcherDraggable() && !fullBleed,
-      draggable: this.#launcherDraggable(),
+      movable: this.#panelMovable() && !fullBleed,
+      // Whether the page left moving on, which is not the same question as
+      // whether this panel moves: a docked sidebar's position is owned by its
+      // placement, and reporting that as the host having turned moving off is
+      // the sentence the move refusal would then get wrong.
+      draggable:
+        this.#host.element.getAttribute("data-launcher-drag") !== "false" &&
+        (this.#surface().launcherDraggable || this.#docked()),
       fullBleed,
       box: {
         left: Math.round(box.left),
@@ -341,7 +390,7 @@ export class PanelPlacement {
 
   /** The move behind `AgUiChat.moveTo`, whose doc is the contract. */
   moveTo(corner: ChatCorner, options: { readonly announce?: boolean } = {}): boolean {
-    if (!this.#launcherDraggable()) {
+    if (!this.#panelMovable()) {
       return false;
     }
     const restore = options.announce === true ? this.#captureGeometry() : null;
@@ -351,23 +400,31 @@ export class PanelPlacement {
       return false;
     }
     const [edgeY, edgeX] = corner.split("-");
+    // A docked panel's bottom corners are above its dock, not on the bar.
+    const docked = this.#docked();
+    const room = docked ? this.#dockRoom() : viewport;
     // Every term is an absolute screen coordinate, because that is what the
     // clamps and the insets both speak. The usable box carries an origin, so
     // its near edge is `viewport.left`, not zero, and its far edge is
     // `viewport.left + viewport.width` -- a margin applied to the extents
     // alone would send the agent's own move under the chrome the host
     // reserved, which is the failure the usable box exists to prevent.
-    const nearX = viewport.left + EDGE_MARGIN;
-    const nearY = viewport.top + EDGE_MARGIN;
+    const nearX = room.left + EDGE_MARGIN;
+    const nearY = room.top + EDGE_MARGIN;
     const left =
-      edgeX === "left"
-        ? nearX
-        : Math.max(nearX, viewport.left + viewport.width - EDGE_MARGIN - box.width);
+      edgeX === "left" ? nearX : Math.max(nearX, room.left + room.width - EDGE_MARGIN - box.width);
     const top =
-      edgeY === "top"
-        ? nearY
-        : Math.max(nearY, viewport.top + viewport.height - EDGE_MARGIN - box.height);
+      edgeY === "top" ? nearY : Math.max(nearY, room.top + room.height - EDGE_MARGIN - box.height);
     const host = { left, top, right: left + box.width, bottom: top + box.height };
+    if (docked) {
+      this.#dockPos = { left, top };
+      this.#writeDockInset(host);
+      this.#storeDockPosition(this.#dockPos);
+      if (restore !== null) {
+        this.#host.announceSurfaceChange(this.#host.strings().chatMoved, restore);
+      }
+      return true;
+    }
     // Both axes measured, rather than one read twice: a host can restyle the
     // launcher as a pill, and squaring it here would put it off the corner.
     const launcherWidth = this.#host.launcher.offsetWidth;
@@ -401,6 +458,7 @@ export class PanelPlacement {
     const corner = this.#host.element.getAttribute("data-expand-corner");
     const launcherPos = this.#launcherPos;
     const panelPos = this.#panelPos;
+    const dockPos = this.#dockPos;
     const expandCorner = this.#expandCorner;
     return () => {
       this.#restoreProperty("--ag-ui-inset", inset);
@@ -412,7 +470,15 @@ export class PanelPlacement {
       }
       this.#launcherPos = launcherPos;
       this.#panelPos = panelPos;
+      this.#dockPos = dockPos;
       this.#expandCorner = expandCorner;
+      if (this.#docked()) {
+        // The dock's own record, and only that: the launcher's belongs to the
+        // corner surface and has nothing to undo here.
+        this.#storeDockPosition(dockPos);
+        this.syncResizeAnchor();
+        return;
+      }
       // Erased rather than rewritten when there was nothing to go back to.
       // #storeLauncherPosition returns early for a null position, which would
       // leave the move this is undoing sitting in storage -- and since that
@@ -583,7 +649,10 @@ export class PanelPlacement {
     return surfaceFor(element.getAttribute("placement"), element.getAttribute("collapse-to"));
   }
 
-  /** Whether the panel rises from the bottom bar or the host's anchor. */
+  /**
+   * Whether the panel rises from the bottom bar or the host's anchor, until the
+   * user drags it somewhere else.
+   */
   #docked(): boolean {
     const target = this.#surface().collapseTo;
     return target === "bar" || target === "none";
@@ -617,9 +686,122 @@ export class PanelPlacement {
       element.style.removeProperty(DOCK_RIGHT);
     }
     element.toggleAttribute("data-dock-anchored", target === "none" && anchor !== null);
+    this.#dockTop =
+      target === "bar" && height > 0
+        ? bar.getBoundingClientRect().top
+        : target === "none" && anchor !== null
+          ? anchor.getBoundingClientRect().top
+          : Number.POSITIVE_INFINITY;
+    // Every change the dock can make passes through here -- the bar's height
+    // arrives by a ResizeObserver after the first restore, and a bar that grew
+    // since the drag would otherwise cover the panel's foot -- so the dragged
+    // spot is held against it here rather than only when it is restored.
+    this.#placeDocked();
     return height;
   }
 
+  /**
+   * The part of the usable viewport a docked panel may stand in: all of it
+   * above the dock's line. The bar is what it minimises to, and the anchor is
+   * the host's own way back, so a dragged panel never covers either.
+   */
+  #dockRoom(): ViewportBox {
+    const viewport = this.#viewport();
+    const bottom = Math.min(viewport.top + viewport.height, this.#dockTop);
+    return { ...viewport, height: Math.max(0, bottom - viewport.top) };
+  }
+
+  /**
+   * Put a docked panel back where the user dragged it, held inside its room.
+   *
+   * The inline inset comes off first, which is both how the panel's resting
+   * box is measured and what leaves a phone full-bleed: the small-viewport
+   * block reads the host's inset before its own, so a dragged spot written
+   * there would hold the panel off the screen's edges. The spot itself stays,
+   * for the next time there is room for it.
+   */
+  #placeDocked(): void {
+    if (!this.#docked() || !this.#panelMovable() || this.dragging()) {
+      return;
+    }
+    const at = this.#dockPos ?? this.#readDockPosition();
+    if (at === null) {
+      return;
+    }
+    this.#dockPos = at;
+    this.#host.element.style.removeProperty("--ag-ui-inset");
+    const rest = this.#host.element.getBoundingClientRect();
+    if (coversViewport(rest, this.#viewport())) {
+      return;
+    }
+    // Measured at the dock, so the inset below is written from the corner the
+    // dock holds still and a resize grows the panel away from it.
+    this.syncResizeAnchor();
+    this.#writeDockInset(
+      clampPanel(
+        { left: at.left, top: at.top, right: at.left + rest.width, bottom: at.top + rest.height },
+        this.#dockRoom(),
+        SCREEN_EDGE_MARGIN,
+      ),
+    );
+  }
+
+  /** Write the inset that stands a docked panel at `box`. */
+  #writeDockInset(box: PanelRect): void {
+    this.#host.element.style.setProperty(
+      "--ag-ui-inset",
+      insetFrom(this.#anchor, box, this.#screen()),
+    );
+  }
+
+  /** Remember a docked panel's dragged spot, or forget it for null. */
+  #storeDockPosition(at: { readonly left: number; readonly top: number } | null): void {
+    if (at === null) {
+      this.#host.clearPreference(DOCK_KEY);
+      return;
+    }
+    this.#host.writePreference(DOCK_KEY, JSON.stringify({ left: at.left, top: at.top }));
+  }
+
+  /** The stored spot of a docked panel, or null for none or anything corrupt. */
+  #readDockPosition(): { readonly left: number; readonly top: number } | null {
+    const raw = this.#host.readPreference(DOCK_KEY);
+    if (raw === null) {
+      return null;
+    }
+    try {
+      return asPoint(JSON.parse(raw));
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Whether the header drag and moveTo may move the open panel: the
+   * placement's answer, unless the host turned moving off.
+   */
+  #panelMovable(): boolean {
+    return (
+      this.#host.element.getAttribute("data-launcher-drag") !== "false" &&
+      this.#surface().panelMovable
+    );
+  }
+
+  /**
+   * Whether a header drag may start now. A docked panel on a phone is the
+   * screen, and a drag there would pull it off the edges it fills; a corner
+   * panel's header is left as it was.
+   */
+  #canDragPanel(): boolean {
+    if (!this.#panelMovable()) {
+      return false;
+    }
+    return (
+      !this.#docked() ||
+      !coversViewport(this.#host.element.getBoundingClientRect(), this.#viewport())
+    );
+  }
+
   /**
    * Whether this placement lets the launcher be dragged, read per interaction
    * because `placement` is a live attribute. `data-launcher-drag="false"` opts
@@ -863,6 +1045,13 @@ export class PanelPlacement {
    * other still names the old one would move the launcher for no reason.
    */
   #movePanel(box: PanelRect, from: PanelRect): { held: PanelRect; launcher: LauncherBox | null } {
+    if (this.#docked()) {
+      // Inside the room above the dock, with nothing carried along.
+      const held = clampPanel(box, this.#dockRoom(), SCREEN_EDGE_MARGIN);
+      this.#dockPos = { left: held.left, top: held.top };
+      this.#writeDockInset(held);
+      return { held, launcher: null };
+    }
     if (!this.#launcherDraggable()) {
       return { held: box, launcher: null };
     }
@@ -936,6 +1125,10 @@ export class PanelPlacement {
     // again. Recomputing it is how the two came apart: releasing the drag
     // moved the bubble by the panel's whole travel a second time.
     const { held, launcher } = this.#movePanel(box, from);
+    if (this.#docked()) {
+      this.#storeDockPosition({ left: held.left, top: held.top });
+      return;
+    }
     if (launcher === null) {
       return;
     }
@@ -1026,6 +1219,13 @@ export class PanelPlacement {
    * unreachable -- it is the only way back to a collapsed conversation.
    */
   restoreLauncherPosition(): void {
+    // Before the launcher's record is read at all: it belongs to the corner
+    // surface, and seeding anything from it would put a spot dragged there on
+    // a panel that should stand on its dock.
+    if (this.#docked()) {
+      this.#placeDocked();
+      return;
+    }
     const stored = this.#readLauncherPosition();
     const launcher = this.#launcherPos ?? stored;
     if (launcher === null) {
@@ -1083,6 +1283,13 @@ export class PanelPlacement {
    * the switch inline and pins a sidebar to wherever the floating launcher was.
    */
   releaseLauncherPosition(): void {
+    // A dragged dock spot belongs to a docked panel that moves. Any other
+    // surface hands it back; a docked one keeps it, and syncDock holds it
+    // against the new dock.
+    if (this.#dockPos !== null && !(this.#docked() && this.#panelMovable())) {
+      this.#dockPos = null;
+      this.#host.element.style.removeProperty("--ag-ui-inset");
+    }
     if (this.#launcherDraggable()) {
       return;
     }
@@ -1110,11 +1317,12 @@ export class PanelPlacement {
    */
   #applyResize(grip: ResizeGrip, box: PanelRect): PanelRect {
     box = this.#withinViewport(box);
-    if (this.#docked()) {
-      // A docked panel keeps its resize but never its position: the edges it
+    if (this.#docked() && this.#dockPos === null) {
+      // A panel standing on its dock keeps it through a resize: the edges it
       // stands on are the bar's or the anchor's, and a grip on one of them
       // would write the position below and take the panel off its dock. So
       // the pinned edges stay where they are and only the free ones follow.
+      // Once dragged off, it resizes like a corner panel, below.
       const now = this.#host.element.getBoundingClientRect();
       box = {
         left: grip.x === this.#anchor.x ? now.left : box.left,
@@ -1126,6 +1334,11 @@ export class PanelPlacement {
       return box;
     }
     this.#applySize({ width: box.right - box.left, height: box.bottom - box.top });
+    if (this.#docked()) {
+      // Any grip moves the top-left corner the spot is kept as, including one
+      // on a free edge, which leaves the inset alone.
+      this.#dockPos = { left: box.left, top: box.top };
+    }
     if (grip.x !== this.#anchor.x && grip.y !== this.#anchor.y) {
       return box;
     }
@@ -1161,6 +1374,9 @@ export class PanelPlacement {
     const held = this.#applyResize(grip, box);
     this.#persistSize({ width: held.right - held.left, height: held.bottom - held.top });
     this.#storeLauncherPosition();
+    if (this.#dockPos !== null) {
+      this.#storeDockPosition(this.#dockPos);
+    }
     // Re-stamp after the drag: a host whose layout changed underneath us would
     // otherwise keep the tab-reachable grip in the old corner, which reads as
     // the control being in the wrong place even though the drag was right.