@foldkit/ui 0.156.0 → 0.157.0

package/dist/toast/index.d.ts

@@ -1,4 +1,4 @@
-import { Schema as S } from 'effect';
+import { Schema } from 'effect';
 import { type ChildAttribute, type Html } from 'foldkit/html';
 import { Message, Position, Variant } from './schema.js';
 import { WaitBeforeDismissal } from './update.js';
@@ -34,80 +34,80 @@ export type EntryHandlers = Readonly<{
  *
  *  @example
  *  ```ts
- *  const ToastPayload = S.Struct({
- *    bodyText: S.String,
- *    maybeLink: S.Option(S.Struct({
- *      href: S.String,
- *      text: S.String,
+ *  const ToastPayload = Schema.Struct({
+ *    bodyText: Schema.String,
+ *    maybeLink: Schema.Option(Schema.Struct({
+ *      href: Schema.String,
+ *      text: Schema.String,
  *    })),
  *  })
  *  export const Toast = Toast.make(ToastPayload)
  *  ```
  */
-export declare const make: <A, I>(payloadSchema: S.Codec<A, I>) => {
-    readonly 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"]>;
+export declare const make: <A, I>(payloadSchema: Schema.Codec<A, I>) => {
+    readonly Entry: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly variant: Schema.Literals<readonly ["Info", "Success", "Warning", "Error"]>;
+        readonly animation: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly isShowing: Schema.Boolean;
+            readonly transitionState: Schema.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 maybeDuration: Schema.Option<Schema.DurationFromMillis>;
+        readonly pendingDismissVersion: Schema.Number;
+        readonly isHovered: Schema.Boolean;
+        readonly payload: Schema.Codec<A, I, never, never>;
     }>;
-    readonly Model: 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 Model: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly defaultDuration: Schema.DurationFromMillis;
+        readonly entries: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly variant: Schema.Literals<readonly ["Info", "Success", "Warning", "Error"]>;
+            readonly animation: Schema.Struct<{
+                readonly id: Schema.String;
+                readonly isShowing: Schema.Boolean;
+                readonly transitionState: Schema.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 maybeDuration: Schema.Option<Schema.DurationFromMillis>;
+            readonly pendingDismissVersion: Schema.Number;
+            readonly isHovered: Schema.Boolean;
+            readonly payload: Schema.Codec<A, I, never, never>;
         }>>;
-        readonly nextEntryKey: S.Number;
+        readonly nextEntryKey: Schema.Number;
     }>;
     readonly Message: import("foldkit/message").MessageUnion<{
         readonly Added: {
-            readonly 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 entry: Schema.Struct<{
+                readonly id: Schema.String;
+                readonly variant: Schema.Literals<readonly ["Info", "Success", "Warning", "Error"]>;
+                readonly animation: Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly isShowing: Schema.Boolean;
+                    readonly transitionState: Schema.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 maybeDuration: Schema.Option<Schema.DurationFromMillis>;
+                readonly pendingDismissVersion: Schema.Number;
+                readonly isHovered: Schema.Boolean;
+                readonly payload: Schema.Codec<A, I, never, never>;
             }>;
         };
         readonly Dismissed: {
-            entryId: S.String;
+            entryId: Schema.String;
         };
         readonly DismissedAll: {};
         readonly CompletedWaitBeforeDismissal: {
-            entryId: S.String;
-            version: S.Number;
+            entryId: Schema.String;
+            version: Schema.Number;
         };
         readonly HoveredEntry: {
-            entryId: S.String;
+            entryId: Schema.String;
         };
         readonly LeftEntry: {
-            entryId: S.String;
+            entryId: Schema.String;
         };
         readonly GotAnimationMessage: {
-            entryId: S.String;
+            entryId: Schema.String;
             message: import("foldkit/message").MessageUnion<{
                 readonly Showed: {};
                 readonly Hid: {};
@@ -118,26 +118,26 @@ export declare const make: <A, I>(payloadSchema: S.Codec<A, I>) => {
     }>;
     readonly OutMessage: import("foldkit/message").MessageUnion<{
         readonly DismissedToast: {
-            readonly payload: S.Codec<A, I, never, never>;
+            readonly payload: Schema.Codec<A, I, never, never>;
         };
     }>;
     readonly Added: import("foldkit/schema").CallableTaggedStruct<"Added", {
-        readonly 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 entry: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly variant: Schema.Literals<readonly ["Info", "Success", "Warning", "Error"]>;
+            readonly animation: Schema.Struct<{
+                readonly id: Schema.String;
+                readonly isShowing: Schema.Boolean;
+                readonly transitionState: Schema.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 maybeDuration: Schema.Option<Schema.DurationFromMillis>;
+            readonly pendingDismissVersion: Schema.Number;
+            readonly isHovered: Schema.Boolean;
+            readonly payload: Schema.Codec<A, I, never, never>;
         }>;
     }>;
     readonly DismissedToast: import("foldkit/schema").CallableTaggedStruct<"DismissedToast", {
-        readonly payload: S.Codec<A, I, never, never>;
+        readonly payload: Schema.Codec<A, I, never, never>;
     }>;
     readonly init: (config: Readonly<{
         id: string;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/toast/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,MAAM,IAAI,CAAC,EAAE,MAAM,QAAQ,CAAA;AAChD,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,IAAI,EAAmB,MAAM,cAAc,CAAA;AAG9E,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AACxD,OAAO,EAAE,mBAAmB,EAAe,MAAM,aAAa,CAAA;AAE9D,YAAY,EACV,4BAA4B,EAC5B,SAAS,EACT,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,UAAU,EACV,SAAS,GACV,MAAM,aAAa,CAAA;AACpB,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAE5C,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,mBAAmB,EAAE,CAAA;AA0E1D;;;;qDAIqD;AACrD,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IACnC,OAAO,EAAE,aAAa,CAAC,cAAc,CAAC,CAAA;CACvC,CAAC,CAAA;AAIF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAUzC,QAAQ;qBACL,CAAC,KAAK;;;;;;;;;;;;SAAO,EAAE,QAAQ,EAAE,aAAa,KAAK,IAAI;oBAChD,MAAM;6BACG,MAAM;yBACV,MAAM;;CAyF1B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/toast/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAE,MAAM,QAAQ,CAAA;AACtC,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,IAAI,EAAmB,MAAM,cAAc,CAAA;AAG9E,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AACxD,OAAO,EAAE,mBAAmB,EAAe,MAAM,aAAa,CAAA;AAE9D,YAAY,EACV,4BAA4B,EAC5B,SAAS,EACT,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,UAAU,EACV,SAAS,GACV,MAAM,aAAa,CAAA;AACpB,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAE5C,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,mBAAmB,EAAE,CAAA;AA0E1D;;;;qDAIqD;AACrD,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IACnC,OAAO,EAAE,aAAa,CAAC,cAAc,CAAC,CAAA;CACvC,CAAC,CAAA;AAIF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,iBAAiB,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAU9C,QAAQ;qBACL,CAAC,KAAK;;;;;;;;;;;;SAAO,EAAE,QAAQ,EAAE,aAAa,KAAK,IAAI;oBAChD,MAAM;6BACG,MAAM;yBACV,MAAM;;CAyF1B,CAAA"}

package/dist/toast/index.js

@@ -1,12 +1,12 @@
 import { brandViewResult as __foldkitBrandViewResult } from 'foldkit/brand'
-import { Match as M } from 'effect';
+import { Match } from 'effect';
 import { childAttributes } from 'foldkit/html';
 import { defineView } from 'foldkit/submodel';
 import { Message, Position, Variant } from './schema.js';
 import { WaitBeforeDismissal, makeRuntime } from './update.js';
 export * as test from './test.js';
 export { Message, Variant, Position, WaitBeforeDismissal };
-const variantToRole = (variant) => __foldkitBrandViewResult((M.value(variant).pipe(M.withReturnType(), M.when('Info', () => __foldkitBrandViewResult(('status'), "@foldkit/ui/toast/index.js#anonymous")), M.when('Success', () => __foldkitBrandViewResult(('status'), "@foldkit/ui/toast/index.js#anonymous~2")), M.when('Warning', () => __foldkitBrandViewResult(('alert'), "@foldkit/ui/toast/index.js#anonymous~3")), M.when('Error', () => __foldkitBrandViewResult(('alert'), "@foldkit/ui/toast/index.js#anonymous~4")), M.exhaustive)), "@foldkit/ui/toast/index.js#variantToRole");
+const variantToRole = (variant) => __foldkitBrandViewResult((Match.value(variant).pipe(Match.withReturnType(), Match.when('Info', () => __foldkitBrandViewResult(('status'), "@foldkit/ui/toast/index.js#anonymous")), Match.when('Success', () => __foldkitBrandViewResult(('status'), "@foldkit/ui/toast/index.js#anonymous~2")), Match.when('Warning', () => __foldkitBrandViewResult(('alert'), "@foldkit/ui/toast/index.js#anonymous~3")), Match.when('Error', () => __foldkitBrandViewResult(('alert'), "@foldkit/ui/toast/index.js#anonymous~4")), Match.exhaustive)), "@foldkit/ui/toast/index.js#variantToRole");
 const positionToContainerStyle = (position) => {
     const base = {
         position: 'fixed',
@@ -18,39 +18,39 @@ const positionToContainerStyle = (position) => {
         pointerEvents: 'none',
         zIndex: '2147483600',
     };
-    return __foldkitBrandViewResult((M.value(position).pipe(M.withReturnType(), M.when('TopLeft', () => (__foldkitBrandViewResult(({
+    return __foldkitBrandViewResult((Match.value(position).pipe(Match.withReturnType(), Match.when('TopLeft', () => (__foldkitBrandViewResult(({
         ...base,
         top: '0',
         left: '0',
         flexDirection: 'column-reverse',
-    }), "@foldkit/ui/toast/index.js#anonymous~5"))), M.when('TopCenter', () => (__foldkitBrandViewResult(({
+    }), "@foldkit/ui/toast/index.js#anonymous~5"))), Match.when('TopCenter', () => (__foldkitBrandViewResult(({
         ...base,
         top: '0',
         left: '50%',
         transform: 'translateX(-50%)',
         flexDirection: 'column-reverse',
-    }), "@foldkit/ui/toast/index.js#anonymous~6"))), M.when('TopRight', () => (__foldkitBrandViewResult(({
+    }), "@foldkit/ui/toast/index.js#anonymous~6"))), Match.when('TopRight', () => (__foldkitBrandViewResult(({
         ...base,
         top: '0',
         right: '0',
         flexDirection: 'column-reverse',
-    }), "@foldkit/ui/toast/index.js#anonymous~7"))), M.when('BottomLeft', () => (__foldkitBrandViewResult(({
+    }), "@foldkit/ui/toast/index.js#anonymous~7"))), Match.when('BottomLeft', () => (__foldkitBrandViewResult(({
         ...base,
         bottom: '0',
         left: '0',
         flexDirection: 'column',
-    }), "@foldkit/ui/toast/index.js#anonymous~8"))), M.when('BottomCenter', () => (__foldkitBrandViewResult(({
+    }), "@foldkit/ui/toast/index.js#anonymous~8"))), Match.when('BottomCenter', () => (__foldkitBrandViewResult(({
         ...base,
         bottom: '0',
         left: '50%',
         transform: 'translateX(-50%)',
         flexDirection: 'column',
-    }), "@foldkit/ui/toast/index.js#anonymous~9"))), M.when('BottomRight', () => (__foldkitBrandViewResult(({
+    }), "@foldkit/ui/toast/index.js#anonymous~9"))), Match.when('BottomRight', () => (__foldkitBrandViewResult(({
         ...base,
         bottom: '0',
         right: '0',
         flexDirection: 'column',
-    }), "@foldkit/ui/toast/index.js#anonymous~10"))), M.exhaustive)), "@foldkit/ui/toast/index.js#positionToContainerStyle");
+    }), "@foldkit/ui/toast/index.js#anonymous~10"))), Match.exhaustive)), "@foldkit/ui/toast/index.js#positionToContainerStyle");
 };
 const DEFAULT_ARIA_LABEL = 'Notifications';
 /** Factory that binds `Toast` to a user-provided payload schema. The
@@ -73,11 +73,11 @@ const DEFAULT_ARIA_LABEL = 'Notifications';
  *
  *  @example
  *  ```ts
- *  const ToastPayload = S.Struct({
- *    bodyText: S.String,
- *    maybeLink: S.Option(S.Struct({
- *      href: S.String,
- *      text: S.String,
+ *  const ToastPayload = Schema.Struct({
+ *    bodyText: Schema.String,
+ *    maybeLink: Schema.Option(Schema.Struct({
+ *      href: Schema.String,
+ *      text: Schema.String,
  *    })),
  *  })
  *  export const Toast = Toast.make(ToastPayload)
@@ -104,21 +104,21 @@ export const make = (payloadSchema) => {
         ];
         const renderEntryItem = (entry) => {
             const { transitionState } = entry.animation;
-            const animationAttributes = M.value(transitionState).pipe(M.when('EnterStart', () => __foldkitBrandViewResult(([
+            const animationAttributes = Match.value(transitionState).pipe(Match.when('EnterStart', () => __foldkitBrandViewResult(([
                 h.DataAttribute('closed', ''),
                 h.DataAttribute('enter', ''),
                 h.DataAttribute('transition', ''),
-            ]), "@foldkit/ui/toast/index.js#anonymous~12")), M.when('EnterAnimating', () => __foldkitBrandViewResult(([
+            ]), "@foldkit/ui/toast/index.js#anonymous~12")), Match.when('EnterAnimating', () => __foldkitBrandViewResult(([
                 h.DataAttribute('enter', ''),
                 h.DataAttribute('transition', ''),
-            ]), "@foldkit/ui/toast/index.js#anonymous~13")), M.when('LeaveStart', () => __foldkitBrandViewResult(([
+            ]), "@foldkit/ui/toast/index.js#anonymous~13")), Match.when('LeaveStart', () => __foldkitBrandViewResult(([
                 h.DataAttribute('leave', ''),
                 h.DataAttribute('transition', ''),
-            ]), "@foldkit/ui/toast/index.js#anonymous~14")), M.when('LeaveAnimating', () => __foldkitBrandViewResult(([
+            ]), "@foldkit/ui/toast/index.js#anonymous~14")), Match.when('LeaveAnimating', () => __foldkitBrandViewResult(([
                 h.DataAttribute('closed', ''),
                 h.DataAttribute('leave', ''),
                 h.DataAttribute('transition', ''),
-            ]), "@foldkit/ui/toast/index.js#anonymous~15")), M.orElse(() => __foldkitBrandViewResult(([]), "@foldkit/ui/toast/index.js#anonymous~16")));
+            ]), "@foldkit/ui/toast/index.js#anonymous~15")), Match.orElse(() => __foldkitBrandViewResult(([]), "@foldkit/ui/toast/index.js#anonymous~16")));
             const itemAttributes = [
                 h.Id(entry.id),
                 h.Role(variantToRole(entry.variant)),

package/dist/toast/schema.d.ts

@@ -1,13 +1,13 @@
-import { Duration, Schema as S } from 'effect';
+import { Duration, Schema } 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 declare const Variant: Schema.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 declare const Position: Schema.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
@@ -15,60 +15,60 @@ export type Position = typeof Position.Type;
  *  `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"]>;
+export declare const makeEntry: <A, I>(payloadSchema: Schema.Codec<A, I>) => Schema.Struct<{
+    readonly id: Schema.String;
+    readonly variant: Schema.Literals<readonly ["Info", "Success", "Warning", "Error"]>;
+    readonly animation: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly isShowing: Schema.Boolean;
+        readonly transitionState: Schema.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 maybeDuration: Schema.Option<Schema.DurationFromMillis>;
+    readonly pendingDismissVersion: Schema.Number;
+    readonly isHovered: Schema.Boolean;
+    readonly payload: Schema.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"]>;
+export declare const makeModel: <A, I>(payloadSchema: Schema.Codec<A, I>) => Schema.Struct<{
+    readonly id: Schema.String;
+    readonly defaultDuration: Schema.DurationFromMillis;
+    readonly entries: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly variant: Schema.Literals<readonly ["Info", "Success", "Warning", "Error"]>;
+        readonly animation: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly isShowing: Schema.Boolean;
+            readonly transitionState: Schema.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 maybeDuration: Schema.Option<Schema.DurationFromMillis>;
+        readonly pendingDismissVersion: Schema.Number;
+        readonly isHovered: Schema.Boolean;
+        readonly payload: Schema.Codec<A, I, never, never>;
     }>>;
-    readonly nextEntryKey: S.Number;
+    readonly nextEntryKey: Schema.Number;
 }>;
 /** Payload-independent Message variants shared by every bound Toast module. */
 export declare const Message: import("foldkit/message").MessageUnion<{
     readonly Dismissed: {
-        entryId: S.String;
+        entryId: Schema.String;
     };
     readonly DismissedAll: {};
     readonly CompletedWaitBeforeDismissal: {
-        entryId: S.String;
-        version: S.Number;
+        entryId: Schema.String;
+        version: Schema.Number;
     };
     readonly HoveredEntry: {
-        entryId: S.String;
+        entryId: Schema.String;
     };
     readonly LeftEntry: {
-        entryId: S.String;
+        entryId: Schema.String;
     };
     readonly GotAnimationMessage: {
-        entryId: S.String;
+        entryId: Schema.String;
         message: import("foldkit/message").MessageUnion<{
             readonly Showed: {};
             readonly Hid: {};
@@ -84,38 +84,38 @@ export type HoveredEntry = typeof Message.HoveredEntry.Type;
 export type LeftEntry = typeof Message.LeftEntry.Type;
 export type GotAnimationMessage = typeof Message.GotAnimationMessage.Type;
 /** Factory for the union of all messages the toast component can produce. */
-export declare const makeMessage: <A, I>(payloadSchema: S.Codec<A, I>) => import("foldkit/message").MessageUnion<{
+export declare const makeMessage: <A, I>(payloadSchema: Schema.Codec<A, I>) => import("foldkit/message").MessageUnion<{
     readonly 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"]>;
+        entry: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly variant: Schema.Literals<readonly ["Info", "Success", "Warning", "Error"]>;
+            readonly animation: Schema.Struct<{
+                readonly id: Schema.String;
+                readonly isShowing: Schema.Boolean;
+                readonly transitionState: Schema.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 maybeDuration: Schema.Option<Schema.DurationFromMillis>;
+            readonly pendingDismissVersion: Schema.Number;
+            readonly isHovered: Schema.Boolean;
+            readonly payload: Schema.Codec<A, I, never, never>;
         }>;
     };
     readonly Dismissed: {
-        entryId: S.String;
+        entryId: Schema.String;
     };
     readonly DismissedAll: {};
     readonly CompletedWaitBeforeDismissal: {
-        entryId: S.String;
-        version: S.Number;
+        entryId: Schema.String;
+        version: Schema.Number;
     };
     readonly HoveredEntry: {
-        entryId: S.String;
+        entryId: Schema.String;
     };
     readonly LeftEntry: {
-        entryId: S.String;
+        entryId: Schema.String;
     };
     readonly GotAnimationMessage: {
-        entryId: S.String;
+        entryId: Schema.String;
         message: import("foldkit/message").MessageUnion<{
             readonly Showed: {};
             readonly Hid: {};
@@ -125,9 +125,9 @@ export declare const makeMessage: <A, I>(payloadSchema: S.Codec<A, I>) => import
     };
 }>;
 /** Factory for the union of out-messages the toast component can produce. */
-export declare const makeOutMessage: <A, I>(payloadSchema: S.Codec<A, I>) => import("foldkit/message").MessageUnion<{
+export declare const makeOutMessage: <A, I>(payloadSchema: Schema.Codec<A, I>) => import("foldkit/message").MessageUnion<{
     readonly DismissedToast: {
-        payload: S.Codec<A, I, never, never>;
+        payload: Schema.Codec<A, I, never, never>;
     };
 }>;
 /** Configuration for creating a toast container model. `defaultDuration` is

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

@@ -1 +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,iBAAiB,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;EASxD,CAAA;AAIJ;;;;wCAIwC;AACxC,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;;;;;;EAMxD,CAAA;AAIJ,+EAA+E;AAC/E,eAAO,MAAM,OAAO;;QACL,OAAO;;;;QAGlB,OAAO;QACP,OAAO;;;QAEO,OAAO;;;QACV,OAAO;;;QAElB,OAAO;QACP,OAAO;;;;;;;EAET,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,OAAO,OAAO,CAAC,SAAS,CAAC,IAAI,CAAA;AACrD,MAAM,MAAM,YAAY,GAAG,OAAO,OAAO,CAAC,YAAY,CAAC,IAAI,CAAA;AAC3D,MAAM,MAAM,4BAA4B,GACtC,OAAO,OAAO,CAAC,4BAA4B,CAAC,IAAI,CAAA;AAClD,MAAM,MAAM,YAAY,GAAG,OAAO,OAAO,CAAC,YAAY,CAAC,IAAI,CAAA;AAC3D,MAAM,MAAM,SAAS,GAAG,OAAO,OAAO,CAAC,SAAS,CAAC,IAAI,CAAA;AACrD,MAAM,MAAM,mBAAmB,GAAG,OAAO,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAA;AAEzE,6EAA6E;AAC7E,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;;QAEjD,KAAK;;;;;;;;;;;;;;;QACD,OAAO;;;;QAGlB,OAAO;QACP,OAAO;;;QAEO,OAAO;;;QACV,OAAO;;;QAElB,OAAO;QACP,OAAO;;;;;;;EAET,CAAA;AAEJ,6EAA6E;AAC7E,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;;QACxB,OAAO;;EAAoB,CAAA;AAIpE;;;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"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/toast/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAOzC;;;;kDAIkD;AAClD,eAAO,MAAM,OAAO,mEAA2D,CAAA;AAC/E,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAIzC,gFAAgF;AAChF,eAAO,MAAM,QAAQ,6GAOnB,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAI3C;;;;;4BAK4B;AAC5B,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,iBAAiB,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;EAS7D,CAAA;AAIJ;;;;wCAIwC;AACxC,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,iBAAiB,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;;;;;;EAM7D,CAAA;AAIJ,+EAA+E;AAC/E,eAAO,MAAM,OAAO;;QACL,OAAO;;;;QAGlB,OAAO;QACP,OAAO;;;QAEO,OAAO;;;QACV,OAAO;;;QAElB,OAAO;QACP,OAAO;;;;;;;EAET,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,OAAO,OAAO,CAAC,SAAS,CAAC,IAAI,CAAA;AACrD,MAAM,MAAM,YAAY,GAAG,OAAO,OAAO,CAAC,YAAY,CAAC,IAAI,CAAA;AAC3D,MAAM,MAAM,4BAA4B,GACtC,OAAO,OAAO,CAAC,4BAA4B,CAAC,IAAI,CAAA;AAClD,MAAM,MAAM,YAAY,GAAG,OAAO,OAAO,CAAC,YAAY,CAAC,IAAI,CAAA;AAC3D,MAAM,MAAM,SAAS,GAAG,OAAO,OAAO,CAAC,SAAS,CAAC,IAAI,CAAA;AACrD,MAAM,MAAM,mBAAmB,GAAG,OAAO,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAA;AAEzE,6EAA6E;AAC7E,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,iBAAiB,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;;QAEtD,KAAK;;;;;;;;;;;;;;;QACD,OAAO;;;;QAGlB,OAAO;QACP,OAAO;;;QAEO,OAAO;;;QACV,OAAO;;;QAElB,OAAO;QACP,OAAO;;;;;;;EAET,CAAA;AAEJ,6EAA6E;AAC7E,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,CAAC,iBAAiB,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;;QAC7B,OAAO;;EAAoB,CAAA;AAIpE;;;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

@@ -1,17 +1,17 @@
 import { brandViewResult as __foldkitBrandViewResult } from 'foldkit/brand'
-import { Duration, Schema as S } from 'effect';
+import { Duration, Schema } from 'effect';
 import { defineMessageUnion } from 'foldkit/message';
-import { Message as AnimationMessage, Model as AnimationModel, } from '../animation/schema.js';
+import * as Animation 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']);
+export const Variant = Schema.Literals(['Info', 'Success', 'Warning', 'Error']);
 // POSITION
 /** Where the toast viewport is anchored on the screen and how entries stack. */
-export const Position = S.Literals([
+export const Position = Schema.Literals([
     'TopLeft',
     'TopCenter',
     'TopRight',
@@ -26,13 +26,13 @@ export const Position = S.Literals([
  *  `variant` (for ARIA role), `animation`, `maybeDuration`,
  *  `pendingDismissVersion` (for cancellable auto-dismiss), and `isHovered`
  *  (for pause-on-hover). */
-export const makeEntry = (payloadSchema) => __foldkitBrandViewResult((S.Struct({
-    id: S.String,
+export const makeEntry = (payloadSchema) => __foldkitBrandViewResult((Schema.Struct({
+    id: Schema.String,
     variant: Variant,
-    animation: AnimationModel,
-    maybeDuration: S.Option(S.DurationFromMillis),
-    pendingDismissVersion: S.Number,
-    isHovered: S.Boolean,
+    animation: Animation.Model,
+    maybeDuration: Schema.Option(Schema.DurationFromMillis),
+    pendingDismissVersion: Schema.Number,
+    isHovered: Schema.Boolean,
     payload: payloadSchema,
 })), "@foldkit/ui/toast/schema.js#makeEntry");
 // MODEL
@@ -41,42 +41,42 @@ export const makeEntry = (payloadSchema) => __foldkitBrandViewResult((S.Struct({
  *  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) => __foldkitBrandViewResult((S.Struct({
-    id: S.String,
-    defaultDuration: S.DurationFromMillis,
-    entries: S.Array(makeEntry(payloadSchema)),
-    nextEntryKey: S.Number,
+export const makeModel = (payloadSchema) => __foldkitBrandViewResult((Schema.Struct({
+    id: Schema.String,
+    defaultDuration: Schema.DurationFromMillis,
+    entries: Schema.Array(makeEntry(payloadSchema)),
+    nextEntryKey: Schema.Number,
 })), "@foldkit/ui/toast/schema.js#makeModel");
 // MESSAGE
 /** Payload-independent Message variants shared by every bound Toast module. */
 export const Message = defineMessageUnion({
-    Dismissed: { entryId: S.String },
+    Dismissed: { entryId: Schema.String },
     DismissedAll: {},
     CompletedWaitBeforeDismissal: {
-        entryId: S.String,
-        version: S.Number,
+        entryId: Schema.String,
+        version: Schema.Number,
     },
-    HoveredEntry: { entryId: S.String },
-    LeftEntry: { entryId: S.String },
+    HoveredEntry: { entryId: Schema.String },
+    LeftEntry: { entryId: Schema.String },
     GotAnimationMessage: {
-        entryId: S.String,
-        message: AnimationMessage,
+        entryId: Schema.String,
+        message: Animation.Message,
     },
 });
 /** Factory for the union of all messages the toast component can produce. */
 export const makeMessage = (payloadSchema) => __foldkitBrandViewResult((defineMessageUnion({
     Added: { entry: makeEntry(payloadSchema) },
-    Dismissed: { entryId: S.String },
+    Dismissed: { entryId: Schema.String },
     DismissedAll: {},
     CompletedWaitBeforeDismissal: {
-        entryId: S.String,
-        version: S.Number,
+        entryId: Schema.String,
+        version: Schema.Number,
     },
-    HoveredEntry: { entryId: S.String },
-    LeftEntry: { entryId: S.String },
+    HoveredEntry: { entryId: Schema.String },
+    LeftEntry: { entryId: Schema.String },
     GotAnimationMessage: {
-        entryId: S.String,
-        message: AnimationMessage,
+        entryId: Schema.String,
+        message: Animation.Message,
     },
 })), "@foldkit/ui/toast/schema.js#makeMessage");
 /** Factory for the union of out-messages the toast component can produce. */

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

@@ -1 +1 @@
-{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../src/toast/test.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,eAAe,CAAA;AAUtC;;;2BAG2B;AAC3B,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAC,CAAA;AAIF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,UAAU,0BAGpB,eAAe,iKAUf,CAAA"}
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../src/toast/test.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,eAAe,CAAA;AAMtC;;;2BAG2B;AAC3B,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAC,CAAA;AAIF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,UAAU,0BAGpB,eAAe,iKAUf,CAAA"}

package/dist/toast/test.js

@@ -1,6 +1,6 @@
 import { brandViewResult as __foldkitBrandViewResult } from 'foldkit/brand'
 import * as Story from 'foldkit/story';
-import { Message as AnimationMessage, WaitForAnimationSettled, WaitForPaint, } from '../animation/index.js';
+import * as Animation from '../animation/index.js';
 import { Message } from './schema.js';
 import { WaitBeforeDismissal } from './update.js';
 const DEFAULT_VERSION = 0;
@@ -35,7 +35,7 @@ const DEFAULT_VERSION = 0;
  *  )
  *  ```
  */
-export const drainEntry = ({ entryId, version = DEFAULT_VERSION, }) => __foldkitBrandViewResult((Story.Command.resolveAll([WaitForPaint, AnimationMessage.CompletedWaitForPaint()], [WaitForAnimationSettled, AnimationMessage.EndedAnimation()], [
+export const drainEntry = ({ entryId, version = DEFAULT_VERSION, }) => __foldkitBrandViewResult((Story.Command.resolveAll([Animation.WaitForPaint, Animation.Message.CompletedWaitForPaint()], [Animation.WaitForAnimationSettled, Animation.Message.EndedAnimation()], [
     WaitBeforeDismissal,
     Message.CompletedWaitBeforeDismissal({ entryId, version }),
-], [WaitForPaint, AnimationMessage.CompletedWaitForPaint()], [WaitForAnimationSettled, AnimationMessage.EndedAnimation()])), "@foldkit/ui/toast/test.js#drainEntry");
+], [Animation.WaitForPaint, Animation.Message.CompletedWaitForPaint()], [Animation.WaitForAnimationSettled, Animation.Message.EndedAnimation()])), "@foldkit/ui/toast/test.js#drainEntry");