@crewlethq/ui 0.35.0 → 0.36.0

package/dist/LinkInterstitial/index.js

@@ -1,6 +1,6 @@
-export { LinkInterstitial, openExternal } from '../chunk-KD2IRYCT.js';
-import '../chunk-5CLW2CXT.js';
+export { LinkInterstitial, openExternal } from '../chunk-5WDXPHEW.js';
 import '../chunk-XEGZHHRH.js';
+import '../chunk-5CLW2CXT.js';
 import '../chunk-SZZRIHGT.js';
 import '../chunk-PQADV6P6.js';
 import '../chunk-OMV5W53A.js';

package/dist/ListInput/index.js

@@ -1,10 +1,11 @@
-export { ListInput } from '../chunk-Z6VW6CXX.js';
-import '../chunk-6QFAK2WV.js';
+export { ListInput } from '../chunk-IQH3DDZ2.js';
+import '../chunk-IUYUS2SO.js';
 import '../chunk-SMBKXWML.js';
+import '../chunk-YSGLEHND.js';
 import '../chunk-PQADV6P6.js';
+import '../chunk-RSAQOKH3.js';
 import '../chunk-OMV5W53A.js';
 import '../chunk-R25RGPUB.js';
-import '../chunk-RSAQOKH3.js';
 import '../chunk-4FQT6ZAY.js';
 import '../chunk-BZFWDIV6.js';
 import '../chunk-ODEQTPFM.js';

package/dist/LivePreview/LivePreview.d.ts

@@ -1,27 +1,54 @@
 import { type ReactNode } from 'react';
 /**
- * Real content drawn small: a live, scaled-down snapshot of a page, a grid or
- * a frame inside a fixed box, the way a gallery card previews what it opens.
+ * Real content drawn small, once: a scaled-down snapshot of a page, a grid or
+ * a slide, rendered by the content's own renderer from its real data and
+ * then frozen, the way a gallery card previews what it opens.
  *
  * LAID OUT AT FULL SIZE, THEN SCALED. The content is given `width` CSS pixels
  * to lay itself out in, exactly as it would on its own page, and the whole is
  * scaled down to the box with a CSS transform, so the preview is the page
  * itself at a smaller size and never a second layout of it. Left out, the
- * content fills the box unscaled (a slide stage that scales itself).
+ * content fills the box unscaled.
  *
- * DRAWN ONLY WHEN IT CAN BE SEEN, AND ONLY SO MANY AT ONCE. The content is
- * mounted while the box is within `rootMargin` of the viewport and the
- * shared budget (`LivePreviewBudgetProvider`, twelve by default) grants it a
- * slot, and unmounted when it scrolls away, giving the slot back. Until the
- * content says it has drawn (`useLivePreview().ready()`), while it waits for a
- * slot, when it failed (`fail()`) and in a browser with no
- * IntersectionObserver, the box shows `fallback`.
+ * RENDERED ONCE, THEN A STILL COPY. The content is mounted once the box has
+ * stayed within `rootMargin` (a screen, by default) of what its scroll
+ * container shows for `dwellMs` and the shared budget
+ * (`LivePreviewBudgetProvider`) grants it one of the renders it allows at
+ * once. It reads what it needs and draws, out of sight behind the stand-in.
+ * When it says it has drawn (`useLivePreview().ready()`) its render is given
+ * to the next box, and once the page's fonts have loaded and the layout has
+ * settled, what it drew is copied (its DOM, cloned: `stills.ts`), the copy
+ * fades in over the stand-in, and the content is unmounted in the same
+ * commit. From then on the preview holds nothing live: no React tree under
+ * it, no subscription, no observer of its own and no timer, and it never
+ * reads, polls or redraws again. A copy laid out at `width` is scaled to its
+ * box by one observer the provider's copies share, so a resized window
+ * rescales it rather than drawing it again; one with no `width` is drawn
+ * again only if its box changes size.
  *
- * NEVER INTERACTIVE, NEVER ANNOUNCED. The live layer is `inert`, takes no
- * pointer and is hidden from assistive technology: nothing in it can be
- * focused or clicked, and whatever surrounds the preview (a card's link)
- * names what it shows. The swap from the stand-in to the content is a short
- * fade, and none under `prefers-reduced-motion`.
+ * KEPT FOR THE PAGE. With a `snapshot` key, the copy is kept by the provider
+ * under that key, and a preview mounted again under it (a card back after a
+ * filter, a change of shape or a page of results) shows the same copy at
+ * once, with nothing read. A page loaded afresh draws afresh.
+ *
+ * A FRAME CANNOT BE COPIED. Content that runs a page in a frame (`frame`)
+ * lives in another document: there is nothing in this one to clone, and a
+ * clone of the frame would load the page again. So a framed preview keeps its
+ * frame once drawn, fading it in over the stand-in. Kept frames are capped
+ * apart; one the reader has left is taken back only when a frame coming near
+ * needs its place, and shows its stand-in until it is drawn again.
+ *
+ * Until it has drawn, while it waits for a render, when it failed (`fail()`,
+ * or no drawing within `LIVE_PREVIEW_RENDER_MS`), and in a browser with no
+ * IntersectionObserver, the box shows `fallback`. What has drawn is shown
+ * over it, and the stand-in is hidden once the fade is done: fading the
+ * stand-in out at the same time showed both at half strength halfway through.
+ *
+ * NEVER INTERACTIVE, NEVER ANNOUNCED. The live layer and the copy are
+ * `inert`, take no pointer and are hidden from assistive technology: nothing
+ * in them can be focused or clicked, and whatever surrounds the preview (a
+ * card's link) names what it shows. Under `prefers-reduced-motion` nothing
+ * fades.
  */
 /**
  * How long a box stays near the viewport before its content is asked for: a
@@ -29,39 +56,92 @@ import { type ReactNode } from 'react';
  * past does not.
  */
 export declare const LIVE_PREVIEW_DWELL_MS = 120;
-/** Gives the previews under it a budget of their own, `max` live at once. */
-export declare function LivePreviewBudgetProvider({ max, children }: {
+/**
+ * How far ahead of what its scroll container shows a box starts rendering: a
+ * whole screen in each direction. A snapshot costs nothing once it is taken,
+ * so drawing a screen ahead is paid once, and it is what lets a reader
+ * scrolling at any pace meet every card already drawn. Measured on a gallery
+ * of 44 cards at 1440 by 900 with the CPU slowed fourfold, 200 pixels ahead
+ * left cards on screen before their first draw in about sixty samples of a
+ * scroll down and back; a screen ahead left none, and the first screen was
+ * drawn within a frame or two of the time it took before.
+ */
+export declare const LIVE_PREVIEW_MARGIN = "100% 0px";
+/**
+ * The longest a render may take before it gives up and keeps its stand-in.
+ * A preview is a glimpse: content that has not drawn in fifteen seconds is
+ * waiting on a read that is failing slowly, and holding one of the budget's
+ * few renders for it would hold the rest of a gallery up behind it. Fifteen
+ * is past the ten seconds a page in a frame is given to answer at all
+ * (`FRAME_HELLO_TIMEOUT_MS`) and its grace after, so a frame settles itself
+ * first.
+ */
+export declare const LIVE_PREVIEW_RENDER_MS = 15000;
+/**
+ * Gives the previews under it a budget and a store of their own: `max`
+ * rendering at once, `maxFrames` frames kept, and up to `kept` still copies
+ * kept by key for as long as the provider is mounted.
+ */
+export declare function LivePreviewBudgetProvider({ max, maxFrames, kept, children, }: {
     max?: number | undefined;
+    maxFrames?: number | undefined;
+    kept?: number | undefined;
     children: ReactNode;
 }): import("react").JSX.Element;
 export interface LivePreviewSignals {
-    /** The content has drawn: the stand-in gives way to it. */
+    /** The content has drawn: it is copied and the copy shown, or for a frame, the frame is shown. */
     ready: () => void;
-    /** The content has nothing to draw or could not draw: the stand-in stays, and the slot is given back. */
+    /** The content has nothing to draw or could not draw: the stand-in stays, and the render is given back. */
     fail: () => void;
 }
 /** What live content tells the preview around it. Outside one, both do nothing. */
 export declare function useLivePreview(): LivePreviewSignals;
-/** Where a preview is in its life. */
+/**
+ * Where a preview is in its life: `idle` (not asked for), `waiting` (asked,
+ * no render yet), `live` (rendering), `ready` (drawn: a still copy, or a kept
+ * frame) and `failed` (the stand-in for good).
+ */
 export type LivePreviewState = 'idle' | 'waiting' | 'live' | 'ready' | 'failed';
 export interface LivePreviewProps {
-    /** What is drawn small. Mounted only while the preview is live. */
+    /** What is drawn small. Mounted only while it renders, or for a frame while it is kept. */
     children: ReactNode;
-    /** The stand-in, drawn whenever the content is not. */
+    /** The stand-in, drawn whenever nothing else is. */
     fallback: ReactNode;
     /** The width, in CSS pixels, the content lays itself out at before it is scaled to the box. */
     width?: number | undefined;
-    /** How near the viewport the box comes before its content is mounted. */
+    /** How near what its scroll container shows the box comes before its content is rendered (`LIVE_PREVIEW_MARGIN`). */
     rootMargin?: string | undefined;
-    /** Nothing live is drawn: the stand-in only (no content to show, or a host that has turned previews off). */
+    /** Nothing is drawn: the stand-in only (no content to show, or a host that has turned previews off). */
     disabled?: boolean | undefined;
+    /**
+     * The content runs a page in a frame: it is kept rather than copied, and
+     * counts against the budget's frames for as long as it is.
+     */
+    frame?: boolean | undefined;
+    /**
+     * What is drawn, as a key: previews under one provider with the same key
+     * share one still copy, so a preview mounted again shows it at once and
+     * renders nothing. A key names a version of the content; content that has
+     * changed takes a new key and is drawn afresh.
+     */
+    snapshot?: string | undefined;
     /** How long the box stays near the viewport before its content is asked for, in ms. */
     dwellMs?: number | undefined;
     /** Told each time the state moves, for a host that measures. */
     onStateChange?: ((state: LivePreviewState) => void) | undefined;
     className?: string | undefined;
 }
-export declare function LivePreview({ children, fallback, width, rootMargin, disabled, dwellMs, onStateChange, className }: LivePreviewProps): import("react").JSX.Element;
+/**
+ * The element a box is scrolled by: the nearest ancestor that scrolls, or
+ * null for the window. An observer's margin grows its root and nothing else,
+ * and every scroller between the box and the root clips it at its own edge.
+ */
+export declare function scrollRoot(el: Element): Element | null;
+/**
+ * A preview whose `snapshot` key changes is another preview: what it holds
+ * belongs to the content it drew, so it starts again under the new key.
+ */
+export declare function LivePreview(props: LivePreviewProps): import("react").JSX.Element;
 export interface PreviewScaleProps {
     children: ReactNode;
     /** The width, in CSS pixels, the content is laid out at. */

package/dist/LivePreview/budget.d.ts

@@ -1,34 +1,78 @@
 /**
- * How many live previews draw at once: the budget a gallery's cards share.
+ * How many live previews render at once: the budget a gallery's cards share.
  *
- * WHY A BUDGET. A live preview is real content drawn small: a page of prose,
- * a grid of cells, a slide, or a sandboxed frame running a page of its own. A
- * gallery of two hundred artifacts that drew every one would run two hundred
- * of them, most never seen. A preview asks for a slot when it comes near the
- * viewport and gives it back when it leaves; past the cap it waits, drawing
- * its stand-in, and is granted a slot the moment one is free, the oldest ask
- * first.
+ * A PREVIEW RENDERS ONCE. Real content (a page of prose, a grid of cells, a
+ * slide, a board of figures) is mounted near the viewport, reads what it
+ * needs, draws, and is then kept as a still copy with nothing live behind it.
+ * What costs is the RENDER: the reads, the mount and the layout, all at once
+ * as a row of cards scrolls near. So the budget bounds how many render at the
+ * same moment (`max`), and a slot is given back the moment its content has
+ * drawn; past the cap an ask waits, drawing its stand-in, and is granted the
+ * moment a render finishes, the oldest ask first.
+ *
+ * A FRAME IS THE EXCEPTION. A page in a frame lives in another document and
+ * cannot be copied, so a framed preview that has drawn keeps its page, and a
+ * page running in a frame is by far the dearest thing a preview holds. Frames
+ * kept are capped apart (`maxFrames`): a kept frame that leaves the viewport
+ * is parked, and taken back (`reclaim`) only when a frame coming near needs
+ * its place, the one the reader left longest ago first. One on screen is
+ * never taken back for another.
  *
  * Plain bookkeeping with no layout, so it is tested without a browser.
  */
 /**
- * The most previews live at once by default. A gallery at 1440 shows two or
- * three rows of three cards with a row of margin either side, so twelve keeps
- * everything a reader can scroll to in a moment live, and is the number of
- * pages a design's canvas already runs at once (`CANVAS_BOARD_MAX_LIVE`).
+ * The most previews rendering at once. Six is the number of connections a
+ * browser opens to one host over HTTP/1.1, which is how a preview's reads
+ * (an outline, a board and its datasets, a frame's ticket) reach their
+ * server: a seventh render would only queue its reads behind the first six,
+ * while holding its mount and layout open beside them.
+ */
+export declare const LIVE_PREVIEW_MAX = 6;
+/**
+ * The most frames kept at once. A frame is a page in another document, often
+ * in a process of its own; twelve is the number of pages a design's canvas
+ * runs at once (`CANVAS_BOARD_MAX_LIVE`).
  */
-export declare const LIVE_PREVIEW_MAX = 12;
+export declare const LIVE_PREVIEW_MAX_FRAMES = 12;
+/** One preview's hold on the budget, from its ask to its release. */
+export interface LivePreviewSlot {
+    /** Gives back everything it holds, or withdraws the ask if it was never granted. Calling it again does nothing. */
+    release(): void;
+    /**
+     * The content has drawn: its render slot is given back. A frame keeps its
+     * place among the frames until it is released or reclaimed; anything else
+     * holds nothing more, as if released.
+     */
+    drawn(): void;
+    /**
+     * A kept frame left the viewport: it stays, and may be reclaimed when a
+     * frame coming near needs its place. Before the grant the ask is
+     * withdrawn, since nothing was drawn. A render that is not a frame runs on
+     * to its end wherever it is, so for one this does nothing.
+     */
+    park(): void;
+    /** Back near the viewport: answers whether the slot is still held, and if so it is no longer reclaimable. */
+    resume(): boolean;
+}
 export interface LivePreviewBudget {
-    /** The most slots granted at once. */
+    /** The most renders at once. */
     readonly max: number;
+    /** The most frames kept at once. */
+    readonly maxFrames: number;
     /**
-     * Asks for a slot. `grant` is called once, now or when a slot frees. The
-     * answer gives the slot back, or withdraws the ask if it was never granted;
-     * calling it again does nothing.
+     * Asks for a slot. `grant` is called once, now or when a slot frees.
+     * `reclaim` is called if a parked frame is taken back, so the holder tears
+     * its page down; nothing else is ever reclaimed. `frame` says the content
+     * runs a page in a frame, which counts against `maxFrames` for as long as
+     * it is kept.
      */
-    request(grant: () => void): () => void;
-    /** Slots held now, for a test or a measurement. */
+    request(grant: () => void, reclaim?: () => void, frame?: boolean): LivePreviewSlot;
+    /** Renders in progress, for a test or a measurement. */
     live(): number;
+    /** Frames kept, rendering or drawn. */
+    frames(): number;
+    /** Kept frames that left the viewport. */
+    parked(): number;
     /** Asks waiting now. */
     waiting(): number;
 }
@@ -47,4 +91,4 @@ export declare const immediately: LivePreviewSchedule;
  * preview does.
  */
 export declare const perFrame: LivePreviewSchedule;
-export declare function createLivePreviewBudget(max?: number, schedule?: LivePreviewSchedule): LivePreviewBudget;
+export declare function createLivePreviewBudget(max?: number, schedule?: LivePreviewSchedule, maxFrames?: number): LivePreviewBudget;

package/dist/LivePreview/index.d.ts

@@ -1,5 +1,7 @@
 import './LivePreview.css';
-export { LIVE_PREVIEW_DWELL_MS, LivePreview, LivePreviewBudgetProvider, PreviewScale, useLivePreview } from './LivePreview.js';
+export { LIVE_PREVIEW_DWELL_MS, LIVE_PREVIEW_MARGIN, LIVE_PREVIEW_RENDER_MS, LivePreview, LivePreviewBudgetProvider, PreviewScale, useLivePreview } from './LivePreview.js';
 export type { LivePreviewProps, LivePreviewSignals, LivePreviewState, PreviewScaleProps } from './LivePreview.js';
-export { createLivePreviewBudget, immediately, LIVE_PREVIEW_MAX, perFrame } from './budget.js';
-export type { LivePreviewBudget, LivePreviewSchedule } from './budget.js';
+export { createLivePreviewBudget, immediately, LIVE_PREVIEW_MAX, LIVE_PREVIEW_MAX_FRAMES, perFrame } from './budget.js';
+export type { LivePreviewBudget, LivePreviewSchedule, LivePreviewSlot } from './budget.js';
+export { createLivePreviewStills, LIVE_PREVIEW_STILLS_KEPT } from './stills.js';
+export type { LivePreviewKept, LivePreviewStill, LivePreviewStills } from './stills.js';

package/dist/LivePreview/index.js

@@ -1,2 +1,2 @@
-export { LIVE_PREVIEW_DWELL_MS, LIVE_PREVIEW_MAX, LivePreview, LivePreviewBudgetProvider, PreviewScale, createLivePreviewBudget, immediately, perFrame, useLivePreview } from '../chunk-KF6YGL4B.js';
+export { LIVE_PREVIEW_DWELL_MS, LIVE_PREVIEW_MARGIN, LIVE_PREVIEW_MAX, LIVE_PREVIEW_MAX_FRAMES, LIVE_PREVIEW_RENDER_MS, LIVE_PREVIEW_STILLS_KEPT, LivePreview, LivePreviewBudgetProvider, PreviewScale, createLivePreviewBudget, createLivePreviewStills, immediately, perFrame, useLivePreview } from '../chunk-XGBLRDSU.js';
 import '../chunk-ODEQTPFM.js';

package/dist/LivePreview/stills.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Still copies: what a live preview drew, kept as plain DOM with nothing live
+ * behind it, and where they are kept between one mount and the next.
+ *
+ * A COPY IS THE DRAWN DOM, CLONED. It holds no React tree, no subscription,
+ * no observer and no timer: it is what the content looked like the moment it
+ * said it had drawn, and it never changes after. Nothing in it loads or runs:
+ * a canvas is copied as an image of what it drew, and anything that would
+ * load again (a frame, a video, audio, an embedded object) is left out of
+ * the copy, since a clone of one starts again from nothing.
+ *
+ * KEPT BY KEY for as long as the store lives. A gallery's cards mount and
+ * unmount as its filters, shape and pages change; a card that comes back
+ * under the same key is given the copy it already drew, so it reads nothing
+ * and draws nothing again until the page is loaded afresh.
+ */
+/** A still copy: the nodes, and the width they were laid out at before they were scaled. */
+export interface LivePreviewStill {
+    nodes: Node[];
+    /** The layout width the content was given, or undefined where it filled the box at its own size. */
+    width: number | undefined;
+    /** The box's size when it was drawn: a copy with no layout width is good at this size only. */
+    size: {
+        w: number;
+        h: number;
+    };
+}
+/** What a key holds: a still copy, or a preview that had nothing to draw. */
+export type LivePreviewKept = LivePreviewStill | 'failed';
+export interface LivePreviewStills {
+    get(key: string): LivePreviewKept | undefined;
+    put(key: string, kept: LivePreviewKept): void;
+    forget(key: string): void;
+    /**
+     * Tells `told` the box's size whenever it changes, and answers how to stop.
+     * ONE ResizeObserver for every copy the store's previews show: a copy is
+     * scaled to its box when the box changes size (a window resized, a panel
+     * opened), and a gallery holds one observer rather than one per card.
+     */
+    watch(el: Element, told: (size: {
+        w: number;
+        h: number;
+    }) => void): () => void;
+}
+/**
+ * The most still copies a store keeps, the oldest dropped first. Two hundred
+ * is four pages of a listing at fifty, the size a gallery asks the engine
+ * for; a preview whose copy was dropped draws again when it comes back.
+ */
+export declare const LIVE_PREVIEW_STILLS_KEPT = 200;
+export declare function createLivePreviewStills(kept?: number): LivePreviewStills;
+/**
+ * A still copy of `nodes`: cloned, each canvas replaced by an image of what
+ * it drew (or left blank where its pixels cannot be read), and every element
+ * that would load again left out.
+ */
+export declare function copyOf(nodes: readonly Node[]): Node[];

package/dist/LivePreview-BROGKR4N.css

@@ -0,0 +1,113 @@
+/*
+ * A live preview: the stand-in, the still copy of what the content drew and
+ * the live layer it is drawn in, stacked in that order in one box. The box
+ * takes its size from its parent (a card's preview area), so it fills it and
+ * clips whatever the content lays out past its edge.
+ */
+
+.crewlet-live-preview {
+  position: relative;
+  display: block;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  contain: layout paint;
+}
+
+.crewlet-live-preview__fallback {
+  position: absolute;
+  inset: 0;
+  display: flex;
+}
+
+/* THE STILL COPY: static DOM over the stand-in, which it hides. A copy just
+   taken fades in; one the preview was given back from its store is simply
+   there, so a card scrolled or filtered back to is as it was. */
+.crewlet-live-preview__still {
+  position: absolute;
+  inset: 0;
+  display: block;
+  overflow: hidden;
+  pointer-events: none;
+  user-select: none;
+}
+
+.crewlet-live-preview[data-fresh] > .crewlet-live-preview__still {
+  animation: crewlet-live-preview-arrive var(--motion-duration-base) var(--motion-easing-out);
+}
+
+@keyframes crewlet-live-preview-arrive {
+  from {
+    opacity: 0;
+  }
+}
+
+/* A COPY IS FROZEN: what it drew never moves, so nothing in it animates or
+   transitions, whatever the content's own styles ask of the elements it
+   copied (a skeleton's shimmer, a chart's entrance). */
+.crewlet-live-preview__still *,
+.crewlet-live-preview__still *::before,
+.crewlet-live-preview__still *::after {
+  animation: none !important;
+  transition: none !important;
+}
+
+/* THE LIVE LAYER renders out of sight: content that is copied is never seen
+   live, only its copy is. A frame's page is kept rather than copied, so a
+   framed preview's live layer is what fades in once it has drawn. */
+.crewlet-live-preview__live {
+  position: absolute;
+  inset: 0;
+  display: block;
+  overflow: hidden;
+  opacity: 0;
+  pointer-events: none;
+  user-select: none;
+}
+
+.crewlet-live-preview[data-frame] > .crewlet-live-preview__live {
+  transition: opacity var(--motion-duration-base) var(--motion-easing-out);
+}
+
+.crewlet-live-preview[data-frame][data-state='ready'] > .crewlet-live-preview__live {
+  opacity: 1;
+}
+
+/* LAID OUT AT ITS OWN SIZE from the top left corner, and scaled from there:
+   to the box's width, its top left the box's, or whole and centred. */
+.crewlet-preview-scale {
+  position: absolute;
+  inset: 0;
+  display: block;
+  overflow: hidden;
+}
+
+.crewlet-preview-scale__layer {
+  position: absolute;
+  top: 0;
+  left: 0;
+  display: block;
+  overflow: hidden;
+  transform-origin: 0 0;
+}
+
+/* WHAT IS UNDER A DRAWING is hidden only once it has faded in. Fading the
+   stand-in out at the same time showed both at half strength halfway
+   through: a double exposure. */
+.crewlet-live-preview[data-state='ready'] > .crewlet-live-preview__fallback {
+  visibility: hidden;
+  /* Visibility is discrete and stays visible for the whole of a transition
+     to hidden, so this holds it exactly as long as the fade above. A copy
+     given back from the store is ready from its first style, which runs no
+     transition, so its stand-in is never shown at all. */
+  transition: visibility var(--motion-duration-base) linear;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .crewlet-live-preview[data-fresh] > .crewlet-live-preview__still,
+  .crewlet-live-preview[data-frame] > .crewlet-live-preview__live,
+  .crewlet-live-preview[data-state='ready'] > .crewlet-live-preview__fallback {
+    animation: none;
+    transition: none;
+  }
+}

package/dist/PresenterView/index.js

@@ -1,6 +1,6 @@
-export { PresenterView, formatStopwatch } from '../chunk-THROPJZC.js';
+export { PresenterView, formatStopwatch } from '../chunk-DEMALFHY.js';
+import '../chunk-NQGPD6NX.js';
 import '../chunk-6VOS2GMB.js';
-import '../chunk-LV4APO72.js';
 import '../chunk-RK4XPHVG.js';
 import '../chunk-OMV5W53A.js';
 import '../chunk-R25RGPUB.js';

package/dist/PrincipalPicker/index.js

@@ -1,10 +1,11 @@
-export { PrincipalPicker } from '../chunk-AYB6AYNH.js';
-import '../chunk-QS4ZGTEU.js';
+export { PrincipalPicker } from '../chunk-GMLAKNFY.js';
+import '../chunk-PPFX6GRK.js';
 import '../chunk-F73MC7EZ.js';
-import '../chunk-6QFAK2WV.js';
 import '../chunk-CI3VPIJN.js';
 import '../chunk-5AQBPHZD.js';
 import '../chunk-PZKHBB7D.js';
+import '../chunk-IUYUS2SO.js';
+import '../chunk-YSGLEHND.js';
 import '../chunk-PQADV6P6.js';
 import '../chunk-R25RGPUB.js';
 import '../chunk-4FQT6ZAY.js';

package/dist/RichEditor/index.js

@@ -1,4 +1,4 @@
-export { RichEditor, preloadRichEditor } from '../chunk-3VD3G3IL.js';
+export { RichEditor, preloadRichEditor } from '../chunk-T5RQGI6O.js';
 export { RICH_EDITOR_LABELS, richEditorLabels } from '../chunk-CSQTDGTS.js';
 import '../chunk-BAKPMH3S.js';
 import '../chunk-SZZRIHGT.js';

package/dist/Select/index.js

@@ -1,5 +1,6 @@
-export { Select } from '../chunk-BQ7AKL2N.js';
+export { Select } from '../chunk-VKKUGZ3G.js';
 import '../chunk-F73MC7EZ.js';
+import '../chunk-YSGLEHND.js';
 import '../chunk-OMV5W53A.js';
 import '../chunk-R25RGPUB.js';
 import '../chunk-ODEQTPFM.js';

package/dist/{Select-A54YS5EP.css → Select-W3CHTZXP.css}

@@ -71,10 +71,16 @@
  * leave the other bare.
  */
 .crewlet-select:focus-within {
-  outline: 1px solid var(--color-focus);
+  outline: 2px solid var(--color-focus);
   outline-offset: -1px;
 }
 
+/* Narrowed and tinted for a pointer, as the text box's ring is. See Input.css. */
+:root[data-crewlet-focus='pointer'] .crewlet-select:focus-within {
+  outline-width: 1px;
+  outline-color: var(--color-border-selected);
+}
+
 /*
  * A FILTER THAT IS ON. The accent border says where the reader is and the
  * accent INK says what it is set to. It used to be the accent FILL with the
@@ -133,6 +139,10 @@
   outline-color: var(--color-feedback-danger);
 }
 
+:root[data-crewlet-focus='pointer'] .crewlet-select.is-error:focus-within {
+  outline-color: var(--color-feedback-danger);
+}
+
 .crewlet-select.is-disabled {
   opacity: 0.6;
   cursor: not-allowed;
@@ -426,10 +436,16 @@ svg.crewlet-select__chevron {
  * outset ring on the input would be cut by the menu's own `overflow: hidden`.
  */
 .crewlet-select__search:focus-within {
-  outline: 1px solid var(--color-focus);
+  outline: 2px solid var(--color-focus);
   outline-offset: -1px;
 }
 
+/* Narrowed and tinted for a pointer, as the text box's ring is. See Input.css. */
+:root[data-crewlet-focus='pointer'] .crewlet-select__search:focus-within {
+  outline-width: 1px;
+  outline-color: var(--color-border-selected);
+}
+
 .crewlet-select__search {
   display: flex;
   align-items: center;

package/dist/ShareDialog/index.js

@@ -1,14 +1,15 @@
-export { ARTIFACT_ROLES, SHAREABLE_ROLES, ShareDialog, roleAtLeast } from '../chunk-CCLNGVCM.js';
-import '../chunk-BQ7AKL2N.js';
+export { ARTIFACT_ROLES, SHAREABLE_ROLES, ShareDialog, roleAtLeast } from '../chunk-2DV4THNQ.js';
+import '../chunk-VKKUGZ3G.js';
+import '../chunk-XEGZHHRH.js';
+import '../chunk-F73MC7EZ.js';
 import '../chunk-W46LPU4R.js';
 import '../chunk-STJ7QBC3.js';
 import '../chunk-DTIW4CHZ.js';
-import '../chunk-XEGZHHRH.js';
-import '../chunk-F73MC7EZ.js';
 import '../chunk-SZZRIHGT.js';
 import '../chunk-CI3VPIJN.js';
 import '../chunk-5AQBPHZD.js';
 import '../chunk-PZKHBB7D.js';
+import '../chunk-YSGLEHND.js';
 import '../chunk-PQADV6P6.js';
 import '../chunk-RTPQDNW3.js';
 import '../chunk-OMV5W53A.js';

package/dist/SheetColumnEditor/index.js

@@ -1,17 +1,18 @@
-export { SHEET_COLUMN_EDITOR_LABELS, SheetColumnEditor, SheetColumnTypeGlyph } from '../chunk-MAD6WPER.js';
-import '../chunk-BQ7AKL2N.js';
+export { SHEET_COLUMN_EDITOR_LABELS, SheetColumnEditor, SheetColumnTypeGlyph } from '../chunk-FG4O64DV.js';
+import '../chunk-VKKUGZ3G.js';
 import '../chunk-FFMCMSJB.js';
 import '../chunk-F73MC7EZ.js';
-import '../chunk-OOMXLJ3S.js';
+import '../chunk-LFSIKGRQ.js';
 import '../chunk-Z7JYG5TF.js';
 import '../chunk-SUXP4OBT.js';
 import '../chunk-AYKXMIOR.js';
-import '../chunk-CPEPST4S.js';
-import '../chunk-6QFAK2WV.js';
-import '../chunk-SMBKXWML.js';
+import '../chunk-PJIPUEJ3.js';
 import '../chunk-CCAXYHQS.js';
 import '../chunk-VL6CUNSX.js';
 import '../chunk-RKKO7QHH.js';
+import '../chunk-IUYUS2SO.js';
+import '../chunk-SMBKXWML.js';
+import '../chunk-YSGLEHND.js';
 import '../chunk-BHHIIK3M.js';
 import '../chunk-PQADV6P6.js';
 import '../chunk-BUVCV3WI.js';