@foldkit/ui 0.112.0

package/dist/toast/index.js

@@ -0,0 +1,146 @@
+import { Match as M } from 'effect';
+import { childAttributes, html, } from 'foldkit/html';
+import { defineView } from 'foldkit/submodel';
+import { Dismissed, DismissedAll, ElapsedDuration, GotAnimationMessage, HoveredEntry, LeftEntry, Position, Variant, } from './schema.js';
+import { DismissAfter, makeRuntime } from './update.js';
+export { Variant, Position, Dismissed, DismissedAll, ElapsedDuration, HoveredEntry, LeftEntry, GotAnimationMessage, DismissAfter, };
+const variantToRole = (variant) => M.value(variant).pipe(M.withReturnType(), M.when('Info', () => 'status'), M.when('Success', () => 'status'), M.when('Warning', () => 'alert'), M.when('Error', () => 'alert'), M.exhaustive);
+const positionToContainerStyle = (position) => {
+    const base = {
+        position: 'fixed',
+        display: 'flex',
+        gap: '8px',
+        padding: '16px',
+        margin: '0',
+        listStyle: 'none',
+        pointerEvents: 'none',
+        zIndex: '2147483600',
+    };
+    return M.value(position).pipe(M.withReturnType(), M.when('TopLeft', () => ({
+        ...base,
+        top: '0',
+        left: '0',
+        flexDirection: 'column-reverse',
+    })), M.when('TopCenter', () => ({
+        ...base,
+        top: '0',
+        left: '50%',
+        transform: 'translateX(-50%)',
+        flexDirection: 'column-reverse',
+    })), M.when('TopRight', () => ({
+        ...base,
+        top: '0',
+        right: '0',
+        flexDirection: 'column-reverse',
+    })), M.when('BottomLeft', () => ({
+        ...base,
+        bottom: '0',
+        left: '0',
+        flexDirection: 'column',
+    })), M.when('BottomCenter', () => ({
+        ...base,
+        bottom: '0',
+        left: '50%',
+        transform: 'translateX(-50%)',
+        flexDirection: 'column',
+    })), M.when('BottomRight', () => ({
+        ...base,
+        bottom: '0',
+        right: '0',
+        flexDirection: 'column',
+    })), M.exhaustive);
+};
+const DEFAULT_ARIA_LABEL = 'Notifications';
+/** Factory that binds `Toast` to a user-provided payload schema. The
+ *  returned module contains everything needed to wire a toast stack into an
+ *  app: `Model`, `Message`, `Entry`, `Added`, `init`, `update`, `show` /
+ *  `dismiss` / `dismissAll` helpers, and the headless `view`.
+ *
+ *  The payload is whatever content shape the consumer supplies via Schema.
+ *  The component never reads it. It flows through to `entryToView`. The
+ *  component itself owns only lifecycle and a11y fields (id, variant,
+ *  animation, dismiss timer, hover state).
+ *
+ *  Consume the bound module's exports everywhere. `Toast.Model` in your app
+ *  Model, `Toast.Message` in your parent Message union, `Toast.show` /
+ *  `Toast.dismiss` in your update, `Toast.view` in your view. The top-level
+ *  exports (`Variant`, `Position`, static message tags, `DismissAfter`) are
+ *  payload-independent and safe to reference when you need them without a
+ *  bound module, but the typical path is through the factory return.
+ *
+ *  @example
+ *  ```ts
+ *  const ToastPayload = S.Struct({
+ *    bodyText: S.String,
+ *    maybeLink: S.Option(S.Struct({
+ *      href: S.String,
+ *      text: S.String,
+ *    })),
+ *  })
+ *  export const Toast = Toast.make(ToastPayload)
+ *  ```
+ */
+export const make = (payloadSchema) => {
+    const runtime = makeRuntime(payloadSchema);
+    /** Renders a headless toast stack. The `<ol>` container is always present
+     *  in the DOM so screen readers can observe its `aria-live` region from
+     *  page load. Each entry becomes an `<li>` keyed by its id, with
+     *  animation data attributes (`data-enter`, `data-leave`,
+     *  `data-transition`, `data-closed`) and `data-variant` reflecting the
+     *  entry's variant. */
+    const view = defineView((model, viewInputs) => {
+        const h = html();
+        const { id, entries } = model;
+        const { position, entryToView, ariaLabel = DEFAULT_ARIA_LABEL, containerClassName, entryClassName, } = viewInputs;
+        const containerAttributes = [
+            h.Id(id),
+            h.Role('region'),
+            h.AriaLabel(ariaLabel),
+            h.AriaLive('polite'),
+            h.Style(positionToContainerStyle(position)),
+            ...(containerClassName ? [h.Class(containerClassName)] : []),
+        ];
+        const renderEntryItem = (entry) => {
+            const { transitionState } = entry.animation;
+            const animationAttributes = M.value(transitionState).pipe(M.when('EnterStart', () => [
+                h.DataAttribute('closed', ''),
+                h.DataAttribute('enter', ''),
+                h.DataAttribute('transition', ''),
+            ]), M.when('EnterAnimating', () => [
+                h.DataAttribute('enter', ''),
+                h.DataAttribute('transition', ''),
+            ]), M.when('LeaveStart', () => [
+                h.DataAttribute('leave', ''),
+                h.DataAttribute('transition', ''),
+            ]), M.when('LeaveAnimating', () => [
+                h.DataAttribute('closed', ''),
+                h.DataAttribute('leave', ''),
+                h.DataAttribute('transition', ''),
+            ]), M.orElse(() => []));
+            const itemAttributes = [
+                h.Id(entry.id),
+                h.Role(variantToRole(entry.variant)),
+                h.AriaAtomic(true),
+                h.DataAttribute('variant', entry.variant),
+                h.Style({ pointerEvents: 'auto' }),
+                h.OnMouseEnter(HoveredEntry({ entryId: entry.id })),
+                h.OnMouseLeave(LeftEntry({ entryId: entry.id })),
+                ...animationAttributes,
+                ...(entryClassName ? [h.Class(entryClassName)] : []),
+            ];
+            const handlers = {
+                dismiss: childAttributes([
+                    h.OnClick(Dismissed({ entryId: entry.id })),
+                ]),
+            };
+            return h.keyed('li')(entry.id, itemAttributes, [
+                entryToView(entry, handlers),
+            ]);
+        };
+        return h.keyed('ol')(id, containerAttributes, entries.map(renderEntryItem));
+    });
+    return {
+        ...runtime,
+        view,
+    };
+};

package/dist/toast/public.d.ts

@@ -0,0 +1,4 @@
+export { make, Variant, Position, Dismissed, DismissedAll, ElapsedDuration, HoveredEntry, LeftEntry, GotAnimationMessage, DismissAfter, } from './index.js';
+export type { EntryHandlers } from './index.js';
+export type { InitConfig, ShowInput } from './index.js';
+//# sourceMappingURL=public.d.ts.map

package/dist/toast/public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/toast/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,OAAO,EACP,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,SAAS,EACT,mBAAmB,EACnB,YAAY,GACb,MAAM,YAAY,CAAA;AAEnB,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAC/C,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA"}

package/dist/toast/public.js

@@ -0,0 +1 @@
+export { make, Variant, Position, Dismissed, DismissedAll, ElapsedDuration, HoveredEntry, LeftEntry, GotAnimationMessage, DismissAfter, } from './index.js';

package/dist/toast/schema.d.ts

@@ -0,0 +1,154 @@
+import { Duration, Schema as S } from 'effect';
+/** Semantic category of a toast. Drives the default ARIA role: `status` for
+ *  `Info` / `Success`, `alert` for `Warning` / `Error`. Also surfaced as
+ *  `data-variant` on each entry for per-variant CSS. This is the only
+ *  content-adjacent field the component owns. The rest of the entry's
+ *  content lives in the user-provided payload. */
+export declare const Variant: S.Literals<readonly ["Info", "Success", "Warning", "Error"]>;
+export type Variant = typeof Variant.Type;
+/** Where the toast viewport is anchored on the screen and how entries stack. */
+export declare const Position: S.Literals<readonly ["TopLeft", "TopCenter", "TopRight", "BottomLeft", "BottomCenter", "BottomRight"]>;
+export type Position = typeof Position.Type;
+/** Schema factory for a single toast entry. `payloadSchema` is user-provided
+ *  and defines the shape of per-entry content, whatever the consumer wants
+ *  to encode. The component itself owns only lifecycle + a11y fields: `id`,
+ *  `variant` (for ARIA role), `animation`, `maybeDuration`,
+ *  `pendingDismissVersion` (for cancellable auto-dismiss), and `isHovered`
+ *  (for pause-on-hover). */
+export declare const makeEntry: <A, I>(payloadSchema: S.Codec<A, I>) => S.Struct<{
+    readonly id: S.String;
+    readonly variant: S.Literals<readonly ["Info", "Success", "Warning", "Error"]>;
+    readonly animation: S.Struct<{
+        readonly id: S.String;
+        readonly isShowing: S.Boolean;
+        readonly transitionState: S.Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>;
+    }>;
+    readonly maybeDuration: S.Option<S.DurationFromMillis>;
+    readonly pendingDismissVersion: S.Number;
+    readonly isHovered: S.Boolean;
+    readonly payload: S.Codec<A, I, never, never>;
+}>;
+/** Schema factory for the toast container's state. `nextEntryKey` is a
+ *  monotonic counter used to generate unique entry IDs purely from Model
+ *  state. Thread the updated model through successive `show()` calls.
+ *  Calling `show()` twice against the same pre-update model in the same tick
+ *  will produce duplicate entry IDs. */
+export declare const makeModel: <A, I>(payloadSchema: S.Codec<A, I>) => S.Struct<{
+    readonly id: S.String;
+    readonly defaultDuration: S.DurationFromMillis;
+    readonly entries: S.$Array<S.Struct<{
+        readonly id: S.String;
+        readonly variant: S.Literals<readonly ["Info", "Success", "Warning", "Error"]>;
+        readonly animation: S.Struct<{
+            readonly id: S.String;
+            readonly isShowing: S.Boolean;
+            readonly transitionState: S.Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>;
+        }>;
+        readonly maybeDuration: S.Option<S.DurationFromMillis>;
+        readonly pendingDismissVersion: S.Number;
+        readonly isHovered: S.Boolean;
+        readonly payload: S.Codec<A, I, never, never>;
+    }>>;
+    readonly nextEntryKey: S.Number;
+}>;
+/** Sent when an entry should begin dismissing. Starts the leave animation;
+ *  the entry is removed from the stack when `TransitionedOut` fires. */
+export declare const Dismissed: import("foldkit/schema").CallableTaggedStruct<"Dismissed", {
+    entryId: S.String;
+}>;
+/** Sent when every currently-visible entry should begin dismissing. */
+export declare const DismissedAll: import("foldkit/schema").CallableTaggedStruct<"DismissedAll", {}>;
+/** Sent when an entry's auto-dismiss timer fires. Carries a version echoed
+ *  from the scheduling moment so stale timers (from hover or manual dismiss)
+ *  are discarded. */
+export declare const ElapsedDuration: import("foldkit/schema").CallableTaggedStruct<"ElapsedDuration", {
+    entryId: S.String;
+    version: S.Number;
+}>;
+/** Sent when the pointer enters an entry. Pauses the auto-dismiss timer by
+ *  advancing the entry's version. */
+export declare const HoveredEntry: import("foldkit/schema").CallableTaggedStruct<"HoveredEntry", {
+    entryId: S.String;
+}>;
+/** Sent when the pointer leaves an entry. Restarts the auto-dismiss timer
+ *  with the entry's full duration. */
+export declare const LeftEntry: import("foldkit/schema").CallableTaggedStruct<"LeftEntry", {
+    entryId: S.String;
+}>;
+/** Wraps a single entry's Animation submodel message for delegation. */
+export declare const GotAnimationMessage: import("foldkit/schema").CallableTaggedStruct<"GotAnimationMessage", {
+    entryId: S.String;
+    message: S.Union<[import("foldkit/schema").CallableTaggedStruct<"Showed", {}>, import("foldkit/schema").CallableTaggedStruct<"Hid", {}>, import("foldkit/schema").CallableTaggedStruct<"AdvancedAnimationFrame", {}>, import("foldkit/schema").CallableTaggedStruct<"EndedAnimation", {}>]>;
+}>;
+export type Dismissed = typeof Dismissed.Type;
+export type DismissedAll = typeof DismissedAll.Type;
+export type ElapsedDuration = typeof ElapsedDuration.Type;
+export type HoveredEntry = typeof HoveredEntry.Type;
+export type LeftEntry = typeof LeftEntry.Type;
+export type GotAnimationMessage = typeof GotAnimationMessage.Type;
+/** Factory for the `Added` message, which carries a fully-constructed entry
+ *  whose shape depends on the user-provided payload. */
+export declare const makeAdded: <A, I>(payloadSchema: S.Codec<A, I>) => import("foldkit/schema").CallableTaggedStruct<"Added", {
+    entry: S.Struct<{
+        readonly id: S.String;
+        readonly variant: S.Literals<readonly ["Info", "Success", "Warning", "Error"]>;
+        readonly animation: S.Struct<{
+            readonly id: S.String;
+            readonly isShowing: S.Boolean;
+            readonly transitionState: S.Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>;
+        }>;
+        readonly maybeDuration: S.Option<S.DurationFromMillis>;
+        readonly pendingDismissVersion: S.Number;
+        readonly isHovered: S.Boolean;
+        readonly payload: S.Codec<A, I, never, never>;
+    }>;
+}>;
+/** Factory for the union of all messages the toast component can produce. */
+export declare const makeMessage: <A, I>(payloadSchema: S.Codec<A, I>) => S.Union<readonly [import("foldkit/schema").CallableTaggedStruct<"Added", {
+    entry: S.Struct<{
+        readonly id: S.String;
+        readonly variant: S.Literals<readonly ["Info", "Success", "Warning", "Error"]>;
+        readonly animation: S.Struct<{
+            readonly id: S.String;
+            readonly isShowing: S.Boolean;
+            readonly transitionState: S.Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>;
+        }>;
+        readonly maybeDuration: S.Option<S.DurationFromMillis>;
+        readonly pendingDismissVersion: S.Number;
+        readonly isHovered: S.Boolean;
+        readonly payload: S.Codec<A, I, never, never>;
+    }>;
+}>, import("foldkit/schema").CallableTaggedStruct<"Dismissed", {
+    entryId: S.String;
+}>, import("foldkit/schema").CallableTaggedStruct<"DismissedAll", {}>, import("foldkit/schema").CallableTaggedStruct<"ElapsedDuration", {
+    entryId: S.String;
+    version: S.Number;
+}>, import("foldkit/schema").CallableTaggedStruct<"HoveredEntry", {
+    entryId: S.String;
+}>, import("foldkit/schema").CallableTaggedStruct<"LeftEntry", {
+    entryId: S.String;
+}>, import("foldkit/schema").CallableTaggedStruct<"GotAnimationMessage", {
+    entryId: S.String;
+    message: S.Union<[import("foldkit/schema").CallableTaggedStruct<"Showed", {}>, import("foldkit/schema").CallableTaggedStruct<"Hid", {}>, import("foldkit/schema").CallableTaggedStruct<"AdvancedAnimationFrame", {}>, import("foldkit/schema").CallableTaggedStruct<"EndedAnimation", {}>]>;
+}>]>;
+/** Factory for `DismissedToast`, the OutMessage emitted once an entry has
+ *  finished dismissing (leave-animation `TransitionedOut`). Carries the
+ *  payload so consumers can lift the dismissal into a domain Message
+ *  without looking the entry up from a stale model. */
+export declare const makeDismissedToast: <A, I>(payloadSchema: S.Codec<A, I>) => import("foldkit/schema").CallableTaggedStruct<"DismissedToast", {
+    payload: S.Codec<A, I, never, never>;
+}>;
+/** Factory for the union of out-messages the toast component can produce. */
+export declare const makeOutMessage: <A, I>(payloadSchema: S.Codec<A, I>) => S.Union<readonly [import("foldkit/schema").CallableTaggedStruct<"DismissedToast", {
+    payload: S.Codec<A, I, never, never>;
+}>]>;
+/** Configuration for creating a toast container model. `defaultDuration` is
+ *  applied to any `show()` call that doesn't provide its own `duration` or
+ *  pass `sticky: true`. Accepts any Effect Duration input; a bare number is
+ *  interpreted as milliseconds. */
+export type InitConfig = Readonly<{
+    id: string;
+    defaultDuration?: Duration.Input;
+}>;
+export declare const DEFAULT_DURATION: Duration.Duration;
+//# sourceMappingURL=schema.d.ts.map

package/dist/toast/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/toast/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,IAAI,CAAC,EAAE,MAAM,QAAQ,CAAA;AAU9C;;;;kDAIkD;AAClD,eAAO,MAAM,OAAO,8DAAsD,CAAA;AAC1E,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAIzC,gFAAgF;AAChF,eAAO,MAAM,QAAQ,wGAOnB,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAI3C;;;;;4BAK4B;AAC5B,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,EAAE,eAAe,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;EASxD,CAAA;AAIJ;;;;wCAIwC;AACxC,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,EAAE,eAAe,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;;;;;;EAMxD,CAAA;AAIJ;wEACwE;AACxE,eAAO,MAAM,SAAS;;EAAwC,CAAA;AAC9D,uEAAuE;AACvE,eAAO,MAAM,YAAY,mEAAoB,CAAA;AAC7C;;qBAEqB;AACrB,eAAO,MAAM,eAAe;;;EAG1B,CAAA;AACF;qCACqC;AACrC,eAAO,MAAM,YAAY;;EAA2C,CAAA;AACpE;sCACsC;AACtC,eAAO,MAAM,SAAS;;EAAwC,CAAA;AAC9D,wEAAwE;AACxE,eAAO,MAAM,mBAAmB;;;EAG9B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAC7C,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA;AACnD,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC,IAAI,CAAA;AACzD,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA;AACnD,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAC7C,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAA;AAEjE;wDACwD;AACxD,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,EAAE,eAAe,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;;;EACX,CAAA;AAEjD,6EAA6E;AAC7E,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,EAAE,eAAe,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;IAS1D,CAAA;AAEJ;;;uDAGuD;AACvD,eAAO,MAAM,kBAAkB,GAAI,CAAC,EAAE,CAAC,EAAE,eAAe,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;;EACpB,CAAA;AAEjD,6EAA6E;AAC7E,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,CAAC,EAAE,eAAe,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;;IACnB,CAAA;AAI9C;;;mCAGmC;AACnC,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC;IAChC,EAAE,EAAE,MAAM,CAAA;IACV,eAAe,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAA;CACjC,CAAC,CAAA;AAEF,eAAO,MAAM,gBAAgB,mBAAsB,CAAA"}

package/dist/toast/schema.js

@@ -0,0 +1,93 @@
+import { Duration, Schema as S } from 'effect';
+import { m } from 'foldkit/message';
+import { Message as AnimationMessage, Model as AnimationModel, } from '../animation/schema.js';
+// VARIANT
+/** Semantic category of a toast. Drives the default ARIA role: `status` for
+ *  `Info` / `Success`, `alert` for `Warning` / `Error`. Also surfaced as
+ *  `data-variant` on each entry for per-variant CSS. This is the only
+ *  content-adjacent field the component owns. The rest of the entry's
+ *  content lives in the user-provided payload. */
+export const Variant = S.Literals(['Info', 'Success', 'Warning', 'Error']);
+// POSITION
+/** Where the toast viewport is anchored on the screen and how entries stack. */
+export const Position = S.Literals([
+    'TopLeft',
+    'TopCenter',
+    'TopRight',
+    'BottomLeft',
+    'BottomCenter',
+    'BottomRight',
+]);
+// ENTRY
+/** Schema factory for a single toast entry. `payloadSchema` is user-provided
+ *  and defines the shape of per-entry content, whatever the consumer wants
+ *  to encode. The component itself owns only lifecycle + a11y fields: `id`,
+ *  `variant` (for ARIA role), `animation`, `maybeDuration`,
+ *  `pendingDismissVersion` (for cancellable auto-dismiss), and `isHovered`
+ *  (for pause-on-hover). */
+export const makeEntry = (payloadSchema) => S.Struct({
+    id: S.String,
+    variant: Variant,
+    animation: AnimationModel,
+    maybeDuration: S.Option(S.DurationFromMillis),
+    pendingDismissVersion: S.Number,
+    isHovered: S.Boolean,
+    payload: payloadSchema,
+});
+// MODEL
+/** Schema factory for the toast container's state. `nextEntryKey` is a
+ *  monotonic counter used to generate unique entry IDs purely from Model
+ *  state. Thread the updated model through successive `show()` calls.
+ *  Calling `show()` twice against the same pre-update model in the same tick
+ *  will produce duplicate entry IDs. */
+export const makeModel = (payloadSchema) => S.Struct({
+    id: S.String,
+    defaultDuration: S.DurationFromMillis,
+    entries: S.Array(makeEntry(payloadSchema)),
+    nextEntryKey: S.Number,
+});
+// MESSAGE
+/** Sent when an entry should begin dismissing. Starts the leave animation;
+ *  the entry is removed from the stack when `TransitionedOut` fires. */
+export const Dismissed = m('Dismissed', { entryId: S.String });
+/** Sent when every currently-visible entry should begin dismissing. */
+export const DismissedAll = m('DismissedAll');
+/** Sent when an entry's auto-dismiss timer fires. Carries a version echoed
+ *  from the scheduling moment so stale timers (from hover or manual dismiss)
+ *  are discarded. */
+export const ElapsedDuration = m('ElapsedDuration', {
+    entryId: S.String,
+    version: S.Number,
+});
+/** Sent when the pointer enters an entry. Pauses the auto-dismiss timer by
+ *  advancing the entry's version. */
+export const HoveredEntry = m('HoveredEntry', { entryId: S.String });
+/** Sent when the pointer leaves an entry. Restarts the auto-dismiss timer
+ *  with the entry's full duration. */
+export const LeftEntry = m('LeftEntry', { entryId: S.String });
+/** Wraps a single entry's Animation submodel message for delegation. */
+export const GotAnimationMessage = m('GotAnimationMessage', {
+    entryId: S.String,
+    message: AnimationMessage,
+});
+/** Factory for the `Added` message, which carries a fully-constructed entry
+ *  whose shape depends on the user-provided payload. */
+export const makeAdded = (payloadSchema) => m('Added', { entry: makeEntry(payloadSchema) });
+/** Factory for the union of all messages the toast component can produce. */
+export const makeMessage = (payloadSchema) => S.Union([
+    makeAdded(payloadSchema),
+    Dismissed,
+    DismissedAll,
+    ElapsedDuration,
+    HoveredEntry,
+    LeftEntry,
+    GotAnimationMessage,
+]);
+/** Factory for `DismissedToast`, the OutMessage emitted once an entry has
+ *  finished dismissing (leave-animation `TransitionedOut`). Carries the
+ *  payload so consumers can lift the dismissal into a domain Message
+ *  without looking the entry up from a stale model. */
+export const makeDismissedToast = (payloadSchema) => m('DismissedToast', { payload: payloadSchema });
+/** Factory for the union of out-messages the toast component can produce. */
+export const makeOutMessage = (payloadSchema) => S.Union([makeDismissedToast(payloadSchema)]);
+export const DEFAULT_DURATION = Duration.seconds(4);