@charcuterie/ui 1.0.0 → 1.0.1

package/dist/Select/Select.d.ts

@@ -7,7 +7,7 @@ export type SelectOption = {
 };
 export type SelectOptionGroup = {
     label: string;
-    options: SelectOption[];
+    options: readonly SelectOption[];
 };
 export type SelectItem = SelectOption | SelectOptionGroup;
 /**
@@ -35,7 +35,15 @@ export type SelectProps = Omit<ComponentPropsWithRef<"select">, "disabled" | "on
      */
     label?: string;
     onChange?: (value: string) => void;
-    options: SelectItem[];
+    /**
+     * `readonly`, because a caller's list is usually a constant and
+     * TypeScript will not hand a `readonly` array to a mutable
+     * parameter — image-viewer hit `TS4104` on an `as const` options
+     * table and had to spread a copy at every call. This component
+     * only ever `.map`s over it, so demanding a mutable array was
+     * asking for a permission it never uses.
+     */
+    options: readonly SelectItem[];
     /**
      * A disabled first entry, not a real option. Reads as a prompt to
      * a sighted user and cannot be submitted, which is what a

package/dist/Select/Select.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Select.d.ts","sourceRoot":"","sources":["../../src/Select/Select.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACtD,OAAO,KAAK,EAEV,qBAAqB,EACrB,SAAS,EACV,MAAM,OAAO,CAAA;AAYd,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,YAAY,EAAE,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,YAAY,GAAG,iBAAiB,CAAA;AAEzD;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,WAAW,GAAG,IAAI,CAC5B,qBAAqB,CAAC,QAAQ,CAAC,EAC/B,UAAU,GAAG,UAAU,GAAG,MAAM,GAAG,OAAO,CAC3C,GAAG;IACF,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAClC,OAAO,EAAE,UAAU,EAAE,CAAA;IACrB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,IAAI,CAAC,EAAE,WAAW,CAAA;IAClB,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,MAAM,GAAI,+FAUpB,WAAW,KAAG,SA8EhB,CAAA"}
+{"version":3,"file":"Select.d.ts","sourceRoot":"","sources":["../../src/Select/Select.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACtD,OAAO,KAAK,EAEV,qBAAqB,EACrB,SAAS,EACV,MAAM,OAAO,CAAA;AAYd,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,SAAS,YAAY,EAAE,CAAA;CACjC,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,YAAY,GAAG,iBAAiB,CAAA;AAEzD;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,WAAW,GAAG,IAAI,CAC5B,qBAAqB,CAAC,QAAQ,CAAC,EAC/B,UAAU,GAAG,UAAU,GAAG,MAAM,GAAG,OAAO,CAC3C,GAAG;IACF,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAClC;;;;;;;OAOG;IACH,OAAO,EAAE,SAAS,UAAU,EAAE,CAAA;IAC9B;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,IAAI,CAAC,EAAE,WAAW,CAAA;IAClB,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,MAAM,GAAI,+FAUpB,WAAW,KAAG,SA8EhB,CAAA"}

package/dist/Select/Select.js.map

@@ -1 +1 @@
-{"version":3,"file":"Select.js","sourceRoot":"","sources":["../../src/Select/Select.tsx"],"names":[],"mappings":";AAOA,OAAO,EACL,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EACL,cAAc,EACd,gBAAgB,GACjB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAwD/C,MAAM,UAAU,GAAG,CACjB,IAAgB,EACW,EAAE,CAAC,SAAS,IAAI,IAAI,CAAA;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,EACrB,SAAS,EACT,UAAU,GAAG,KAAK,EAClB,KAAK,EACL,QAAQ,EACR,OAAO,EACP,WAAW,EACX,IAAI,GAAG,IAAI,EACX,KAAK,EACL,GAAG,WAAW,EACF,EAAa,EAAE,CAAC,CAC5B,eAAK,SAAS,EAAC,0CAA0C,aACvD,qBACM,WAAW,gBACH,KAAK,EACjB,SAAS,EAAE,WAAW,CACpB,iLAAiL;YACjL,0DAA0D;YAC1D,2DAA2D;YAC3D,2DAA2D;YAC3D,wCAAwC;YACxC,MAAM,EACN,kBAAkB,CAAC,IAAI,CAAC,EACxB,sBAAsB,EACtB,4BAA4B,EAC5B,gBAAgB,EAChB,cAAc,EACd,SAAS,CACV,EACD,YAAY,EACV,KAAK;gBACL,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,EAE9C,QAAQ,EAAE,UAAU,EACpB,QAAQ,EAAE,CACR,WAA2C,EAC3C,EAAE;gBACF,QAAQ,EAAE,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,CAAC,CAAA;YAC7C,CAAC,aAEA,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAClC,iBAAQ,QAAQ,QAAC,KAAK,EAAC,EAAE,YACtB,WAAW,GACL,CACV,EAEA,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CACpB,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CACjB,mBAA2B,KAAK,EAAE,IAAI,CAAC,KAAK,YACzC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAC5B,iBACE,QAAQ,EAAE,MAAM,CAAC,UAAU,EAE3B,KAAK,EAAE,MAAM,CAAC,KAAK,YAElB,MAAM,CAAC,KAAK,IAHR,MAAM,CAAC,KAAK,CAIV,CACV,CAAC,IATW,IAAI,CAAC,KAAK,CAUd,CACZ,CAAC,CAAC,CAAC,CACF,iBACE,QAAQ,EAAE,IAAI,CAAC,UAAU,EAEzB,KAAK,EAAE,IAAI,CAAC,KAAK,YAEhB,IAAI,CAAC,KAAK,IAHN,IAAI,CAAC,KAAK,CAIR,CACV,CACF,IACM,EAET,6BAGc,MAAM,EAClB,SAAS,EAAC,kEAAkE,EAC5E,IAAI,EAAC,MAAM,EACX,SAAS,EAAE,KAAK,EAChB,MAAM,EAAC,cAAc,EACrB,aAAa,EAAC,OAAO,EACrB,cAAc,EAAC,OAAO,EACtB,WAAW,EAAE,IAAI,EACjB,OAAO,EAAC,WAAW,EACnB,KAAK,EAAC,4BAA4B,YAElC,eAAM,CAAC,EAAC,cAAc,GAAG,GACrB,IACF,CACP,CAAA"}
+{"version":3,"file":"Select.js","sourceRoot":"","sources":["../../src/Select/Select.tsx"],"names":[],"mappings":";AAOA,OAAO,EACL,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EACL,cAAc,EACd,gBAAgB,GACjB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAgE/C,MAAM,UAAU,GAAG,CACjB,IAAgB,EACW,EAAE,CAAC,SAAS,IAAI,IAAI,CAAA;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,EACrB,SAAS,EACT,UAAU,GAAG,KAAK,EAClB,KAAK,EACL,QAAQ,EACR,OAAO,EACP,WAAW,EACX,IAAI,GAAG,IAAI,EACX,KAAK,EACL,GAAG,WAAW,EACF,EAAa,EAAE,CAAC,CAC5B,eAAK,SAAS,EAAC,0CAA0C,aACvD,qBACM,WAAW,gBACH,KAAK,EACjB,SAAS,EAAE,WAAW,CACpB,iLAAiL;YACjL,0DAA0D;YAC1D,2DAA2D;YAC3D,2DAA2D;YAC3D,wCAAwC;YACxC,MAAM,EACN,kBAAkB,CAAC,IAAI,CAAC,EACxB,sBAAsB,EACtB,4BAA4B,EAC5B,gBAAgB,EAChB,cAAc,EACd,SAAS,CACV,EACD,YAAY,EACV,KAAK;gBACL,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,EAE9C,QAAQ,EAAE,UAAU,EACpB,QAAQ,EAAE,CACR,WAA2C,EAC3C,EAAE;gBACF,QAAQ,EAAE,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,CAAC,CAAA;YAC7C,CAAC,aAEA,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAClC,iBAAQ,QAAQ,QAAC,KAAK,EAAC,EAAE,YACtB,WAAW,GACL,CACV,EAEA,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CACpB,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CACjB,mBAA2B,KAAK,EAAE,IAAI,CAAC,KAAK,YACzC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAC5B,iBACE,QAAQ,EAAE,MAAM,CAAC,UAAU,EAE3B,KAAK,EAAE,MAAM,CAAC,KAAK,YAElB,MAAM,CAAC,KAAK,IAHR,MAAM,CAAC,KAAK,CAIV,CACV,CAAC,IATW,IAAI,CAAC,KAAK,CAUd,CACZ,CAAC,CAAC,CAAC,CACF,iBACE,QAAQ,EAAE,IAAI,CAAC,UAAU,EAEzB,KAAK,EAAE,IAAI,CAAC,KAAK,YAEhB,IAAI,CAAC,KAAK,IAHN,IAAI,CAAC,KAAK,CAIR,CACV,CACF,IACM,EAET,6BAGc,MAAM,EAClB,SAAS,EAAC,kEAAkE,EAC5E,IAAI,EAAC,MAAM,EACX,SAAS,EAAE,KAAK,EAChB,MAAM,EAAC,cAAc,EACrB,aAAa,EAAC,OAAO,EACrB,cAAc,EAAC,OAAO,EACtB,WAAW,EAAE,IAAI,EACjB,OAAO,EAAC,WAAW,EACnB,KAAK,EAAC,4BAA4B,YAElC,eAAM,CAAC,EAAC,cAAc,GAAG,GACrB,IACF,CACP,CAAA"}

package/dist/slotProps.d.ts

@@ -105,6 +105,17 @@ export type SlotProps = Pick<InputHTMLAttributes<HTMLElement>, "aria-describedby
  * `isRequired || undefined`, so a plain spread would let an inner
  * `Field` with no error erase an outer one's `aria-invalid` — the
  * same silent drop, one level down.
+ *
+ * ### The wiring is not a value, and does not last-write-win
+ *
+ * `ref` and the `on*` handlers are merged rather than replaced, by
+ * `mergeSlotWiring`. This was the 1.0.0 hole: `mergeSlotProps`
+ * settled the five *attributes* and left the two props that are not
+ * attributes on last-write-wins, so a `Menu` and a `Tooltip` on one
+ * trigger each handed it a floating-ui `refs.setReference` and the
+ * inner one won. The outer panel had no anchor and rendered in the
+ * corner of the viewport — no error, no failing test, and it looks
+ * like a CSS bug.
  */
 export declare const mergeSlotProps: <OwnProps extends Record<string, unknown>>(receivedProps: SlotProps, ownProps: OwnProps) => OwnProps & SlotProps;
 //# sourceMappingURL=slotProps.d.ts.map

package/dist/slotProps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slotProps.d.ts","sourceRoot":"","sources":["../src/slotProps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,OAAO,CAAA;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;AACH,MAAM,MAAM,SAAS,GAAG,IAAI,CAC1B,mBAAmB,CAAC,WAAW,CAAC,EAC9B,kBAAkB,GAClB,cAAc,GACd,eAAe,GACf,IAAI,GACJ,UAAU,CACb,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,cAAc,GACzB,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAExC,eAAe,SAAS,EACxB,UAAU,QAAQ,KACjB,QAAQ,GAAG,SAoBb,CAAA"}
+{"version":3,"file":"slotProps.d.ts","sourceRoot":"","sources":["../src/slotProps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,OAAO,CAAA;AAIhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;AACH,MAAM,MAAM,SAAS,GAAG,IAAI,CAC1B,mBAAmB,CAAC,WAAW,CAAC,EAC9B,kBAAkB,GAClB,cAAc,GACd,eAAe,GACf,IAAI,GACJ,UAAU,CACb,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,cAAc,GACzB,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAExC,eAAe,SAAS,EACxB,UAAU,QAAQ,KACjB,QAAQ,GAAG,SA2Bb,CAAA"}

package/dist/slotProps.js

@@ -1,3 +1,4 @@
+import { mergeSlotWiring } from "./slotWiring.js";
 /**
  * Merge what arrived from above with what this component writes
  * itself.
@@ -21,6 +22,17 @@
  * `isRequired || undefined`, so a plain spread would let an inner
  * `Field` with no error erase an outer one's `aria-invalid` — the
  * same silent drop, one level down.
+ *
+ * ### The wiring is not a value, and does not last-write-win
+ *
+ * `ref` and the `on*` handlers are merged rather than replaced, by
+ * `mergeSlotWiring`. This was the 1.0.0 hole: `mergeSlotProps`
+ * settled the five *attributes* and left the two props that are not
+ * attributes on last-write-wins, so a `Menu` and a `Tooltip` on one
+ * trigger each handed it a floating-ui `refs.setReference` and the
+ * inner one won. The outer panel had no anchor and rendered in the
+ * corner of the viewport — no error, no failing test, and it looks
+ * like a CSS bug.
  */
 export const mergeSlotProps = (receivedProps, ownProps) => {
     const definedOwnProps = Object.fromEntries(Object.entries(ownProps).filter(([, value]) => value !== undefined));
@@ -34,6 +46,10 @@ export const mergeSlotProps = (receivedProps, ownProps) => {
         ...receivedProps,
         ...definedOwnProps,
         "aria-describedby": describedBy === "" ? undefined : describedBy,
+        // Last, because it is the only merge that has to beat
+        // `definedOwnProps` — it is composing what that spread would
+        // otherwise have thrown away.
+        ...mergeSlotWiring(receivedProps, definedOwnProps),
     };
 };
 //# sourceMappingURL=slotProps.js.map

package/dist/slotProps.js.map

@@ -1 +1 @@
-{"version":3,"file":"slotProps.js","sourceRoot":"","sources":["../src/slotProps.ts"],"names":[],"mappings":"AA6FA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAG5B,aAAwB,EACxB,QAAkB,EACI,EAAE;IACxB,MAAM,eAAe,GAAG,MAAM,CAAC,WAAW,CACxC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,MAAM,CAC7B,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,KAAK,SAAS,CACnC,CACU,CAAA;IAEb,MAAM,WAAW,GAAG;QAClB,aAAa,CAAC,kBAAkB,CAAC;QACjC,QAAQ,CAAC,kBAAkB,CAAC;KAC7B;SACE,MAAM,CAAC,OAAO,CAAC;SACf,IAAI,CAAC,GAAG,CAAC,CAAA;IAEZ,OAAO;QACL,GAAG,aAAa;QAChB,GAAG,eAAe;QAClB,kBAAkB,EAChB,WAAW,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW;KAC/C,CAAA;AACH,CAAC,CAAA"}
+{"version":3,"file":"slotProps.js","sourceRoot":"","sources":["../src/slotProps.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AA6FjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAG5B,aAAwB,EACxB,QAAkB,EACI,EAAE;IACxB,MAAM,eAAe,GAAG,MAAM,CAAC,WAAW,CACxC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,MAAM,CAC7B,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,KAAK,SAAS,CACnC,CACU,CAAA;IAEb,MAAM,WAAW,GAAG;QAClB,aAAa,CAAC,kBAAkB,CAAC;QACjC,QAAQ,CAAC,kBAAkB,CAAC;KAC7B;SACE,MAAM,CAAC,OAAO,CAAC;SACf,IAAI,CAAC,GAAG,CAAC,CAAA;IAEZ,OAAO;QACL,GAAG,aAAa;QAChB,GAAG,eAAe;QAClB,kBAAkB,EAChB,WAAW,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW;QAC9C,sDAAsD;QACtD,6DAA6D;QAC7D,8BAA8B;QAC9B,GAAG,eAAe,CAChB,aAAwC,EACxC,eAAe,CAChB;KACF,CAAA;AACH,CAAC,CAAA"}

package/dist/slotWiring.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The two props a slot may not overwrite, and how it merges them.
+ *
+ * `mergeSlotProps` next door settles the five *attributes* two
+ * nested slots both write, and last-write-wins is right for four of
+ * them. It is not right for the wiring, because neither of these is
+ * a value:
+ *
+ *  - **`ref`** is a subscription. `Menu` and `Tooltip` on one trigger
+ *    both hand it a floating-ui `refs.setReference` — the anchor each
+ *    of them positions its panel against — and the inner one used to
+ *    replace the outer one's. Nothing threw. The outer panel simply
+ *    had no reference element, so floating-ui left it at
+ *    `left: 0; top: 0` in the corner of the viewport, which reads as
+ *    a CSS bug and is not one.
+ *  - **`on*`** is a listener, and listeners are plural.
+ *
+ * ### Why this is not imported from `@charcuterie/logic`
+ *
+ * `useClonedChild`'s `mergeClonedProps` applies the same rule one
+ * level down — between a slot and the element a caller wrote — and
+ * the two are near-identical. Sharing them means a new public export
+ * on `@charcuterie/logic`, which is a `minor`; this is a patch, and
+ * the duplication is thirty lines against a wrong version number.
+ * Queued in `docs/2026-08-02-reported-by-consumers-queued-for-1-1.md`.
+ */
+/**
+ * The keys of `ownProps` that must not simply replace the ones
+ * `receivedProps` arrived with. Spread **last**, over both.
+ */
+export declare const mergeSlotWiring: (receivedProps: Record<string, unknown>, ownProps: Record<string, unknown>) => Record<string, unknown>;
+//# sourceMappingURL=slotWiring.d.ts.map

package/dist/slotWiring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotWiring.d.ts","sourceRoot":"","sources":["../src/slotWiring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAuGH;;;GAGG;AACH,eAAO,MAAM,eAAe,GAC1B,eAAe,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACtC,UAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAqCtB,CAAA"}

package/dist/slotWiring.js

@@ -0,0 +1,115 @@
+/**
+ * The two props a slot may not overwrite, and how it merges them.
+ *
+ * `mergeSlotProps` next door settles the five *attributes* two
+ * nested slots both write, and last-write-wins is right for four of
+ * them. It is not right for the wiring, because neither of these is
+ * a value:
+ *
+ *  - **`ref`** is a subscription. `Menu` and `Tooltip` on one trigger
+ *    both hand it a floating-ui `refs.setReference` — the anchor each
+ *    of them positions its panel against — and the inner one used to
+ *    replace the outer one's. Nothing threw. The outer panel simply
+ *    had no reference element, so floating-ui left it at
+ *    `left: 0; top: 0` in the corner of the viewport, which reads as
+ *    a CSS bug and is not one.
+ *  - **`on*`** is a listener, and listeners are plural.
+ *
+ * ### Why this is not imported from `@charcuterie/logic`
+ *
+ * `useClonedChild`'s `mergeClonedProps` applies the same rule one
+ * level down — between a slot and the element a caller wrote — and
+ * the two are near-identical. Sharing them means a new public export
+ * on `@charcuterie/logic`, which is a `minor`; this is a patch, and
+ * the duplication is thirty lines against a wrong version number.
+ * Queued in `docs/2026-08-02-reported-by-consumers-queued-for-1-1.md`.
+ */
+const isEventHandlerName = (name) => /^on[A-Z]/.test(name);
+const isMergeableRef = (value) => typeof value === "function" ||
+    (typeof value === "object" &&
+        value !== null &&
+        "current" in value);
+const setRef = (ref, node) => {
+    if (typeof ref === "function") {
+        return ref(node);
+    }
+    ref.current = node;
+    return undefined;
+};
+/**
+ * Every pair of refs ever merged, so the same two always come back
+ * as the **same function** — which is load-bearing rather than
+ * frugal.
+ *
+ * React re-runs a callback ref whenever its identity changes between
+ * renders, detaching with the old one and attaching with the new.
+ * Both refs here are floating-ui `setReference`s, and calling one
+ * sets state; a merged ref rebuilt every render would call both
+ * twice per render, each call scheduling the render that rebuilds
+ * it. `mergeSlotProps` is a plain function called during render, so
+ * it cannot reach for `useMemo` — the memo has to be in the identity
+ * of the inputs, which is what a `WeakMap` of `WeakMap`s is.
+ */
+const mergedRefs = new WeakMap();
+const mergeRefs = (first, second) => {
+    const bySecond = mergedRefs.get(first) ??
+        new WeakMap();
+    mergedRefs.set(first, bySecond);
+    const cached = bySecond.get(second);
+    if (cached) {
+        return cached;
+    }
+    const merged = (node) => {
+        const cleanups = [
+            setRef(first, node),
+            setRef(second, node),
+        ];
+        // Per ref: one that returned a cleanup has opted out of being
+        // called with `null`, and one that did not still expects it.
+        return () => {
+            for (const [index, cleanup] of cleanups.entries()) {
+                if (typeof cleanup === "function") {
+                    cleanup();
+                }
+                else {
+                    setRef(index === 0 ? first : second, null);
+                }
+            }
+        };
+    };
+    bySecond.set(second, merged);
+    return merged;
+};
+const chainHandlers = (first, second) => (...args) => {
+    // Outer first, the same order `aria-describedby` is joined in:
+    // the merge order is structural — whoever wrapped whom — and the
+    // author of the nesting is the one who chose it.
+    first(...args);
+    second(...args);
+};
+/**
+ * The keys of `ownProps` that must not simply replace the ones
+ * `receivedProps` arrived with. Spread **last**, over both.
+ */
+export const mergeSlotWiring = (receivedProps, ownProps) => Object.fromEntries(Object.entries(ownProps).flatMap(([name, ownValue]) => {
+    const receivedValue = receivedProps[name];
+    if (name === "ref" &&
+        isMergeableRef(receivedValue) &&
+        isMergeableRef(ownValue)) {
+        return [
+            [name, mergeRefs(receivedValue, ownValue)],
+        ];
+    }
+    if (isEventHandlerName(name) &&
+        typeof receivedValue === "function" &&
+        typeof ownValue === "function") {
+        return [
+            [
+                name,
+                chainHandlers(receivedValue, ownValue),
+            ],
+        ];
+    }
+    return [];
+}));
+//# sourceMappingURL=slotWiring.js.map

package/dist/slotWiring.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotWiring.js","sourceRoot":"","sources":["../src/slotWiring.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@charcuterie/ui",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "The Charcuterie components. Tokens for look, @charcuterie/logic for state, ARIA that agents can actually drive.",
   "license": "MIT",
   "type": "module",
@@ -43,7 +43,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@charcuterie/logic": "1.0.0",
+    "@charcuterie/logic": "1.0.1",
     "@charcuterie/tokens": "1.0.0",
     "@floating-ui/react": "^0.27.20"
   },

package/src/Menu/Menu.mdx

@@ -101,3 +101,26 @@ a keystroke buffer and a timer in a component that has neither, for a menu you c
 three arrow presses.
 
 <Canvas of={MenuStories.Interactive} />
+
+## One trigger, two slots
+
+A `Menu` and a `Tooltip` on the same button — the obvious thing to write, and until 1.0.1
+it did not work.
+
+Both components clone onto the trigger and both hand it a floating-ui
+`refs.setReference` — the element each of them positions its panel against. Every merge in
+the library was last-write-wins, so the inner `Tooltip` wrote its ref and the `Menu`'s was
+gone. A menu with no reference element is not an error: floating-ui simply leaves the panel
+at `left: 0; top: 0`, in the corner of the viewport, which reads as a CSS bug.
+
+A `ref` is a subscription and an `on*` is a listener, and neither survives being replaced.
+So both are **merged** now — between two slots by `mergeSlotWiring`, and between a slot and
+the element you wrote by `useClonedChild`, which is what makes
+`<Menu trigger={<Button ref={buttonRef} onClick={toggle} />} />` keep your ref *and* your
+handler.
+
+`SharedTrigger` is padded so the trigger sits away from the viewport origin: at the corner,
+an anchored panel and an unanchored one land in the same place, and the test asserts that
+padding is still there before it asserts anything else.
+
+<Canvas of={MenuStories.SharedTrigger} />

package/src/Menu/Menu.stories.tsx

@@ -13,6 +13,7 @@ import {
   SettingsIcon,
   UndoIcon,
 } from "../icons.storyHelpers.tsx"
+import { Tooltip } from "../Tooltip/Tooltip.tsx"
 import type { MenuItem } from "./Menu.tsx"
 import { Menu } from "./Menu.tsx"
 
@@ -72,6 +73,40 @@ const MenuHarness = ({
   )
 }
 
+/**
+ * The same harness, with a `Tooltip` between the `Menu` and the
+ * button — two components cloning onto **one** trigger, which is what
+ * image-viewer wanted and could not have.
+ */
+const TooltipTriggerHarness = ({
+  isInitiallyVisible = false,
+  tip,
+  triggerLabel,
+}: {
+  isInitiallyVisible?: boolean
+  tip: string
+  triggerLabel: string
+}): ReactNode => {
+  const { hide, isVisible, toggle } = useVisibility({
+    isVisible: isInitiallyVisible,
+  })
+
+  return (
+    <Menu
+      isVisible={isVisible}
+      items={BAY_ACTIONS}
+      onDismiss={hide}
+      trigger={
+        <Tooltip label={tip}>
+          <Button appearance="outline" onClick={toggle}>
+            {triggerLabel}
+          </Button>
+        </Tooltip>
+      }
+    />
+  )
+}
+
 const meta = {
   title: "Components/Menu",
   component: Menu,
@@ -143,6 +178,38 @@ export const AllStates: Story = {
   ),
 }
 
+/**
+ * **One trigger, two slots.** `Menu` and `Tooltip` both clone onto
+ * the button and both hand it a `ref` — floating-ui's
+ * `refs.setReference`, which is the anchor each of them positions
+ * against. Until 1.0.1 the second clone's ref simply replaced the
+ * first's, so the panel it belonged to had no anchor and rendered in
+ * the top-left corner of the viewport.
+ *
+ * Hover the button and open the menu: the tip and the panel are both
+ * attached to it.
+ */
+export const SharedTrigger: Story = {
+  args: {
+    isVisible: false,
+    onDismiss: noop,
+    trigger: <Button appearance="outline">Actions</Button>,
+  },
+  render: () => (
+    // Padded, and the padding is load-bearing rather than pretty: an
+    // anchor that has been dropped leaves floating-ui at
+    // `left: 0; top: 0`, so a trigger sitting in the corner of the
+    // viewport is a trigger where "anchored" and "not anchored" look
+    // identical. `Menu.test.tsx` asserts the padding is still here.
+    <div className="p-16">
+      <TooltipTriggerHarness
+        tip="Everything that can be done to this bay."
+        triggerLabel="Bay 5"
+      />
+    </div>
+  ),
+}
+
 /**
  * Open it and arrow down. Focus lands on the first item **on
  * opening** — a menu that leaves the caret on the trigger is one a

package/src/Menu/Menu.test.tsx

@@ -7,8 +7,12 @@ import { mountStory } from "../mountStory.testHelpers.ts"
 import { expectAgentDrivable } from "../testing/index.ts"
 import * as stories from "./Menu.stories.tsx"
 
-const { AllStates, AllVariants, Interactive } =
-  composeStories(stories)
+const {
+  AllStates,
+  AllVariants,
+  Interactive,
+  SharedTrigger,
+} = composeStories(stories)
 
 test("the menu is named, and its items are menuitems", async () => {
   const { canvas, canvasElement } =
@@ -200,3 +204,110 @@ test("the menu is not portalled out of its canvas", async () => {
 
   await expectNoAxeViolations(canvasElement)
 })
+
+/**
+ * **One trigger, two slots** — the defect image-viewer reported, and
+ * the one shape `mergeSlotProps` did not cover when it shipped in
+ * 1.0.0.
+ *
+ * `Menu` and `Tooltip` both clone onto the button and both hand it a
+ * floating-ui `refs.setReference`. That is not an attribute, so
+ * last-write-wins destroyed one of them: the inner `Tooltip` wrote
+ * its own and the `Menu` was left with **no reference element at
+ * all**. Nothing threw, nothing was unnamed, axe was clean, and the
+ * panel rendered at `left: 0; top: 0` — a positioning bug that reads
+ * as CSS.
+ *
+ * So the assertion is geometric, and it is the only kind that can
+ * see this: the panel is where the trigger is. Nothing in `Menu`
+ * writes that number — floating-ui computes it from the reference
+ * element, and a dropped ref means no reference element.
+ */
+const expectAnchoredTrigger = (trigger: HTMLElement) => {
+  const triggerRect = trigger.getBoundingClientRect()
+
+  // The precondition, stated rather than assumed. An unanchored
+  // panel lands at the viewport origin, so a trigger that also sits
+  // at the origin makes every assertion below pass for the wrong
+  // reason. The story's padding is what keeps them apart, and this
+  // is where its removal fails.
+  expect(triggerRect.left).toBeGreaterThan(32)
+
+  expect(triggerRect.top).toBeGreaterThan(32)
+
+  return triggerRect
+}
+
+test("a menu sharing its trigger with a tooltip is still anchored to it", async () => {
+  const { canvas, canvasElement } =
+    await mountStory(SharedTrigger)
+
+  const trigger = expectAgentDrivable(canvas, {
+    name: "Bay 5",
+    role: "button",
+  })
+
+  const triggerRect = expectAnchoredTrigger(trigger)
+
+  await userEvent.click(trigger)
+
+  const menu = await waitFor(() =>
+    expectAgentDrivable(canvas, { role: "menu" }),
+  )
+
+  // `bottom-start` with `offset(4)`: flush with the trigger's
+  // inline start, four pixels below it. Before the fix this read
+  // `left 0, top 0` — and it read that *forever*, so waiting for it
+  // costs a timeout rather than hiding a failure. The wait is for
+  // floating-ui's first position, which lands a frame after the
+  // panel does.
+  await waitFor(() => {
+    const menuRect = menu.getBoundingClientRect()
+
+    expect(Math.round(menuRect.left)).toBe(
+      Math.round(triggerRect.left),
+    )
+
+    expect(Math.round(menuRect.top)).toBe(
+      Math.round(triggerRect.bottom) + 4,
+    )
+  })
+
+  await expectNoAxeViolations(canvasElement)
+})
+
+/**
+ * The other ref, in the same composition — because a fix that
+ * reversed the priority instead of merging would leave *this* one
+ * pointing at nothing and the test above would still pass.
+ */
+test("the tooltip sharing that trigger is anchored to it too", async () => {
+  const { canvas } = await mountStory(SharedTrigger)
+
+  const trigger = expectAgentDrivable(canvas, {
+    name: "Bay 5",
+    role: "button",
+  })
+
+  const triggerRect = expectAnchoredTrigger(trigger)
+
+  trigger.focus()
+
+  const tip = await waitFor(() =>
+    expectAgentDrivable(canvas, { role: "tooltip" }),
+  )
+
+  // The **main axis** only: `top` with `offset(6)`. The cross axis
+  // is not asserted because `shift({ padding: 8 })` legitimately
+  // moves it — a 229px tip over a 71px button cannot be centred
+  // this close to the edge — and an assertion that has to allow for
+  // that is one an unanchored tip at the viewport origin would also
+  // satisfy. This one it cannot: unanchored reads `bottom 24`.
+  await waitFor(() => {
+    const tipRect = tip.getBoundingClientRect()
+
+    expect(Math.round(tipRect.bottom)).toBe(
+      Math.round(triggerRect.top) - 6,
+    )
+  })
+})

package/src/Popover/Popover.mdx

@@ -85,6 +85,11 @@ announces nothing.
 have. An extra `<div>` around it is how a toolbar's layout quietly changes, and it is why
 this is the pattern v1 chose and M2 ported.
 
+It **composes** rather than overwrites: your button's own `ref` and its own `onClick` are
+still called, with the popover's added. Until 1.0.1 they were replaced — silently, because a
+ref that is never called and a handler that never runs both look exactly like nothing
+happening.
+
 ## Escape *is* pressable here
 
 Unlike `Modal`'s. `useDismiss` listens for a keydown rather than relying on a UA default

package/src/Select/Select.stories.tsx

@@ -9,11 +9,19 @@ import { Field } from "../Field/Field.tsx"
 import type { SelectItem } from "./Select.tsx"
 import { Select } from "./Select.tsx"
 
-const PROFILES: SelectItem[] = [
+/**
+ * `as const satisfies`, which is a **typecheck** of the `readonly`
+ * widening as much as it is a story: a consumer's options table is
+ * usually a constant, and until 1.0.1 handing one to `options`
+ * failed with `TS4104` — image-viewer copied the array at every call
+ * site to get past it. If that widening is ever reverted, this line
+ * is where `yarn typecheck` says so.
+ */
+const PROFILES = [
   { label: "Lossless remux", value: "lossless" },
   { label: "Compressed 1080p", value: "compressed" },
   { isDisabled: true, label: "Dolby Vision", value: "dv" },
-]
+] as const satisfies readonly SelectItem[]
 
 const GROUPED: SelectItem[] = [
   {

package/src/Select/Select.tsx

@@ -23,7 +23,7 @@ export type SelectOption = {
 
 export type SelectOptionGroup = {
   label: string
-  options: SelectOption[]
+  options: readonly SelectOption[]
 }
 
 export type SelectItem = SelectOption | SelectOptionGroup
@@ -56,7 +56,15 @@ export type SelectProps = Omit<
    */
   label?: string
   onChange?: (value: string) => void
-  options: SelectItem[]
+  /**
+   * `readonly`, because a caller's list is usually a constant and
+   * TypeScript will not hand a `readonly` array to a mutable
+   * parameter — image-viewer hit `TS4104` on an `as const` options
+   * table and had to spread a copy at every call. This component
+   * only ever `.map`s over it, so demanding a mutable array was
+   * asking for a permission it never uses.
+   */
+  options: readonly SelectItem[]
   /**
    * A disabled first entry, not a real option. Reads as a prompt to
    * a sighted user and cannot be submitted, which is what a

package/src/slotProps.ts

@@ -1,5 +1,7 @@
 import type { InputHTMLAttributes } from "react"
 
+import { mergeSlotWiring } from "./slotWiring.ts"
+
 /**
  * The props a **cloning ancestor** injects into the control below it.
  *
@@ -114,6 +116,17 @@ export type SlotProps = Pick<
  * `isRequired || undefined`, so a plain spread would let an inner
  * `Field` with no error erase an outer one's `aria-invalid` — the
  * same silent drop, one level down.
+ *
+ * ### The wiring is not a value, and does not last-write-win
+ *
+ * `ref` and the `on*` handlers are merged rather than replaced, by
+ * `mergeSlotWiring`. This was the 1.0.0 hole: `mergeSlotProps`
+ * settled the five *attributes* and left the two props that are not
+ * attributes on last-write-wins, so a `Menu` and a `Tooltip` on one
+ * trigger each handed it a floating-ui `refs.setReference` and the
+ * inner one won. The outer panel had no anchor and rendered in the
+ * corner of the viewport — no error, no failing test, and it looks
+ * like a CSS bug.
  */
 export const mergeSlotProps = <
   OwnProps extends Record<string, unknown>,
@@ -139,5 +152,12 @@ export const mergeSlotProps = <
     ...definedOwnProps,
     "aria-describedby":
       describedBy === "" ? undefined : describedBy,
+    // Last, because it is the only merge that has to beat
+    // `definedOwnProps` — it is composing what that spread would
+    // otherwise have thrown away.
+    ...mergeSlotWiring(
+      receivedProps as Record<string, unknown>,
+      definedOwnProps,
+    ),
   }
 }

package/src/slotWiring.ts

@@ -0,0 +1,173 @@
+/**
+ * The two props a slot may not overwrite, and how it merges them.
+ *
+ * `mergeSlotProps` next door settles the five *attributes* two
+ * nested slots both write, and last-write-wins is right for four of
+ * them. It is not right for the wiring, because neither of these is
+ * a value:
+ *
+ *  - **`ref`** is a subscription. `Menu` and `Tooltip` on one trigger
+ *    both hand it a floating-ui `refs.setReference` — the anchor each
+ *    of them positions its panel against — and the inner one used to
+ *    replace the outer one's. Nothing threw. The outer panel simply
+ *    had no reference element, so floating-ui left it at
+ *    `left: 0; top: 0` in the corner of the viewport, which reads as
+ *    a CSS bug and is not one.
+ *  - **`on*`** is a listener, and listeners are plural.
+ *
+ * ### Why this is not imported from `@charcuterie/logic`
+ *
+ * `useClonedChild`'s `mergeClonedProps` applies the same rule one
+ * level down — between a slot and the element a caller wrote — and
+ * the two are near-identical. Sharing them means a new public export
+ * on `@charcuterie/logic`, which is a `minor`; this is a patch, and
+ * the duplication is thirty lines against a wrong version number.
+ * Queued in `docs/2026-08-02-reported-by-consumers-queued-for-1-1.md`.
+ */
+
+const isEventHandlerName = (name: string) =>
+  /^on[A-Z]/.test(name)
+
+type MergeableRef =
+  | ((node: unknown) => unknown)
+  | { current: unknown }
+
+const isMergeableRef = (
+  value: unknown,
+): value is MergeableRef =>
+  typeof value === "function" ||
+  (typeof value === "object" &&
+    value !== null &&
+    "current" in value)
+
+const setRef = (ref: MergeableRef, node: unknown) => {
+  if (typeof ref === "function") {
+    return ref(node)
+  }
+
+  ref.current = node
+
+  return undefined
+}
+
+/**
+ * Every pair of refs ever merged, so the same two always come back
+ * as the **same function** — which is load-bearing rather than
+ * frugal.
+ *
+ * React re-runs a callback ref whenever its identity changes between
+ * renders, detaching with the old one and attaching with the new.
+ * Both refs here are floating-ui `setReference`s, and calling one
+ * sets state; a merged ref rebuilt every render would call both
+ * twice per render, each call scheduling the render that rebuilds
+ * it. `mergeSlotProps` is a plain function called during render, so
+ * it cannot reach for `useMemo` — the memo has to be in the identity
+ * of the inputs, which is what a `WeakMap` of `WeakMap`s is.
+ */
+const mergedRefs = new WeakMap<
+  MergeableRef,
+  WeakMap<MergeableRef, (node: unknown) => () => void>
+>()
+
+const mergeRefs = (
+  first: MergeableRef,
+  second: MergeableRef,
+) => {
+  const bySecond =
+    mergedRefs.get(first) ??
+    new WeakMap<
+      MergeableRef,
+      (node: unknown) => () => void
+    >()
+
+  mergedRefs.set(first, bySecond)
+
+  const cached = bySecond.get(second)
+
+  if (cached) {
+    return cached
+  }
+
+  const merged = (node: unknown) => {
+    const cleanups = [
+      setRef(first, node),
+      setRef(second, node),
+    ]
+
+    // Per ref: one that returned a cleanup has opted out of being
+    // called with `null`, and one that did not still expects it.
+    return () => {
+      for (const [index, cleanup] of cleanups.entries()) {
+        if (typeof cleanup === "function") {
+          cleanup()
+        } else {
+          setRef(index === 0 ? first : second, null)
+        }
+      }
+    }
+  }
+
+  bySecond.set(second, merged)
+
+  return merged
+}
+
+const chainHandlers =
+  (
+    first: (...args: unknown[]) => unknown,
+    second: (...args: unknown[]) => unknown,
+  ) =>
+  (...args: unknown[]) => {
+    // Outer first, the same order `aria-describedby` is joined in:
+    // the merge order is structural — whoever wrapped whom — and the
+    // author of the nesting is the one who chose it.
+    first(...args)
+
+    second(...args)
+  }
+
+/**
+ * The keys of `ownProps` that must not simply replace the ones
+ * `receivedProps` arrived with. Spread **last**, over both.
+ */
+export const mergeSlotWiring = (
+  receivedProps: Record<string, unknown>,
+  ownProps: Record<string, unknown>,
+): Record<string, unknown> =>
+  Object.fromEntries(
+    Object.entries(ownProps).flatMap(
+      ([name, ownValue]): [string, unknown][] => {
+        const receivedValue = receivedProps[name]
+
+        if (
+          name === "ref" &&
+          isMergeableRef(receivedValue) &&
+          isMergeableRef(ownValue)
+        ) {
+          return [
+            [name, mergeRefs(receivedValue, ownValue)],
+          ]
+        }
+
+        if (
+          isEventHandlerName(name) &&
+          typeof receivedValue === "function" &&
+          typeof ownValue === "function"
+        ) {
+          return [
+            [
+              name,
+              chainHandlers(
+                receivedValue as (
+                  ...args: unknown[]
+                ) => unknown,
+                ownValue as (...args: unknown[]) => unknown,
+              ),
+            ],
+          ]
+        }
+
+        return []
+      },
+    ),
+  )