create-foldkit-app 0.29.0 → 0.29.1

package/dist/templates/examples/stopwatch/src/main.ts

@@ -8,7 +8,7 @@ import {
   flow,
   pipe,
 } from 'effect'
-import { Command, Runtime, Subscription } from 'foldkit'
+import { Command, Runtime, Subscription, type Update } from 'foldkit'
 import { Document, Html, HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
 import { evo } from 'foldkit/struct'
@@ -64,62 +64,54 @@ export const DetermineTickTime = Command.define('DetermineTickTime', {
 // UPDATE
 
 export const update = (model: Model, message: Message) =>
-  Message.match<readonly [Model, ReadonlyArray<Command.Command<Message>>]>(
-    message,
-    {
-      ClickedStart: () => [
-        model,
-        [DetermineStartTime({ elapsedMs: model.elapsedMs })],
-      ],
-
-      CompletedDetermineStartTime: ({ startTime }) => [
-        evo(model, {
-          isRunning: () => true,
-          startTime: () => startTime,
-        }),
-        [],
-      ],
-
-      ClickedStop: () => [
-        evo(model, {
-          isRunning: () => false,
-        }),
-        [],
-      ],
-
-      ClickedReset: () => [
-        evo(model, {
-          elapsedMs: () => 0,
-          isRunning: () => false,
-          startTime: () => 0,
-        }),
-        [],
-      ],
-
-      Ticked: () => [
-        model,
-        [DetermineTickTime({ startTime: model.startTime })],
-      ],
-
-      CompletedDetermineTickTime: ({ elapsedMs }) => [
-        evo(model, {
-          elapsedMs: () => elapsedMs,
-        }),
-        [],
-      ],
-    },
-  )
+  Message.match<Update.Return<Model, Message>>(message, {
+    ClickedStart: () => ({
+      model,
+      commands: [DetermineStartTime({ elapsedMs: model.elapsedMs })],
+    }),
+
+    CompletedDetermineStartTime: ({ startTime }) => ({
+      model: evo(model, {
+        isRunning: () => true,
+        startTime: () => startTime,
+      }),
+    }),
+
+    ClickedStop: () => ({
+      model: evo(model, {
+        isRunning: () => false,
+      }),
+    }),
+
+    ClickedReset: () => ({
+      model: evo(model, {
+        elapsedMs: () => 0,
+        isRunning: () => false,
+        startTime: () => 0,
+      }),
+    }),
+
+    Ticked: () => ({
+      model,
+      commands: [DetermineTickTime({ startTime: model.startTime })],
+    }),
+
+    CompletedDetermineTickTime: ({ elapsedMs }) => ({
+      model: evo(model, {
+        elapsedMs: () => elapsedMs,
+      }),
+    }),
+  })
 
 // INIT
 
-export const init: Runtime.ApplicationInit<Model, Message> = () => [
-  {
+export const init: Runtime.ApplicationInit<Model, Message> = () => ({
+  model: {
     elapsedMs: 0,
     isRunning: false,
     startTime: 0,
   },
-  [],
-]
+})
 
 // SUBSCRIPTION
 

package/dist/templates/examples/todo/src/main.ts

@@ -10,7 +10,7 @@ import {
   String,
 } from 'effect'
 import { KeyValueStore } from 'effect/unstable/persistence'
-import { Command, Runtime } from 'foldkit'
+import { Command, Runtime, type Update } from 'foldkit'
 import { Document, Html, HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
 import { ts } from 'foldkit/schema'
@@ -90,198 +90,190 @@ export type Flags = typeof Flags.Type
 
 // INIT
 
-export const init: Runtime.ApplicationInit<Model, Message, Flags> = flags => [
-  {
+export const init: Runtime.ApplicationInit<Model, Message, Flags> = flags => ({
+  model: {
     todos: Option.getOrElse(flags.todos, () => []),
     newTodoText: '',
     filter: 'All',
     editing: NotEditing(),
   },
-  [],
-]
+})
 
 // UPDATE
 
+type UpdateReturn = Update.Return<Model, Message>
+
 export const update = (model: Model, message: Message) =>
-  Message.match<readonly [Model, ReadonlyArray<Command.Command<Message>>]>(
-    message,
-    {
-      UpdatedNewTodo: ({ text }) => [
-        evo(model, {
-          newTodoText: () => text,
-        }),
-        [],
-      ],
+  Message.match<UpdateReturn>(message, {
+    UpdatedNewTodo: ({ text }) => ({
+      model: evo(model, {
+        newTodoText: () => text,
+      }),
+    }),
 
-      UpdatedEditingTodo: ({ text }) => [
-        evo(model, {
-          editing: () =>
-            M.value(model.editing).pipe(
-              M.tagsExhaustive({
-                NotEditing: () => model.editing,
-                Editing: ({ id }) => Editing({ id, text }),
-              }),
-            ),
-        }),
-        [],
-      ],
+    UpdatedEditingTodo: ({ text }) => ({
+      model: evo(model, {
+        editing: () =>
+          M.value(model.editing).pipe(
+            M.tagsExhaustive({
+              NotEditing: () => model.editing,
+              Editing: ({ id }) => Editing({ id, text }),
+            }),
+          ),
+      }),
+    }),
 
-      AddedTodo: () => {
-        if (String.isEmpty(String.trim(model.newTodoText))) {
-          return [model, []]
-        }
+    AddedTodo: () => {
+      if (String.isEmpty(String.trim(model.newTodoText))) {
+        return { model }
+      }
 
-        return [model, [GenerateTodo({ text: String.trim(model.newTodoText) })]]
-      },
+      return {
+        model,
+        commands: [GenerateTodo({ text: String.trim(model.newTodoText) })],
+      }
+    },
 
-      CompletedGenerateTodo: ({ id, timestamp, text }) => {
-        const newTodo: Todo = {
-          id,
-          text,
-          completed: false,
-          createdAt: timestamp,
-        }
+    CompletedGenerateTodo: ({ id, timestamp, text }) => {
+      const newTodo: Todo = {
+        id,
+        text,
+        completed: false,
+        createdAt: timestamp,
+      }
 
-        const updatedTodos = [...model.todos, newTodo]
+      const updatedTodos = [...model.todos, newTodo]
 
-        return [
-          evo(model, {
-            todos: () => updatedTodos,
-            newTodoText: () => '',
-          }),
-          [SaveTodos({ todos: updatedTodos })],
-        ]
-      },
+      return {
+        model: evo(model, {
+          todos: () => updatedTodos,
+          newTodoText: () => '',
+        }),
+        commands: [SaveTodos({ todos: updatedTodos })],
+      }
+    },
 
-      DeletedTodo: ({ id }) => {
-        const updatedTodos = Array.filter(model.todos, todo => todo.id !== id)
+    DeletedTodo: ({ id }) => {
+      const updatedTodos = Array.filter(model.todos, todo => todo.id !== id)
 
-        return [
-          evo(model, {
-            todos: () => updatedTodos,
-          }),
-          [SaveTodos({ todos: updatedTodos })],
-        ]
-      },
+      return {
+        model: evo(model, {
+          todos: () => updatedTodos,
+        }),
+        commands: [SaveTodos({ todos: updatedTodos })],
+      }
+    },
 
-      ToggledTodo: ({ id }) => {
-        const updatedTodos = Array.map(model.todos, todo =>
-          todo.id === id
-            ? evo(todo, { completed: completed => !completed })
-            : todo,
-        )
+    ToggledTodo: ({ id }) => {
+      const updatedTodos = Array.map(model.todos, todo =>
+        todo.id === id
+          ? evo(todo, { completed: completed => !completed })
+          : todo,
+      )
 
-        return [
-          evo(model, {
-            todos: () => updatedTodos,
-          }),
-          [SaveTodos({ todos: updatedTodos })],
-        ]
-      },
+      return {
+        model: evo(model, {
+          todos: () => updatedTodos,
+        }),
+        commands: [SaveTodos({ todos: updatedTodos })],
+      }
+    },
 
-      StartedEditing: ({ id }) => {
-        const maybeTodo = Array.findFirst(model.todos, todo => todo.id === id)
-        return [
-          evo(model, {
-            editing: () =>
-              Editing({
-                id,
-                text: Option.match(maybeTodo, {
-                  onNone: () => '',
-                  onSome: todo => todo.text,
-                }),
+    StartedEditing: ({ id }) => {
+      const maybeTodo = Array.findFirst(model.todos, todo => todo.id === id)
+      return {
+        model: evo(model, {
+          editing: () =>
+            Editing({
+              id,
+              text: Option.match(maybeTodo, {
+                onNone: () => '',
+                onSome: todo => todo.text,
               }),
-          }),
-          [],
-        ]
-      },
-
-      SavedEdit: () =>
-        M.value(model.editing).pipe(
-          M.withReturnType<
-            readonly [Model, ReadonlyArray<Command.Command<Message>>]
-          >(),
-          M.tagsExhaustive({
-            NotEditing: () => [model, []],
-
-            Editing: ({ id, text }) => {
-              if (String.isEmpty(String.trim(text))) {
-                return [
-                  evo(model, {
-                    editing: () => NotEditing(),
-                  }),
-                  [],
-                ]
-              }
+            }),
+        }),
+      }
+    },
 
-              const updatedTodos = Array.map(model.todos, todo =>
-                todo.id === id
-                  ? evo(todo, { text: () => String.trim(text) })
-                  : todo,
-              )
+    SavedEdit: () =>
+      M.value(model.editing).pipe(
+        M.withReturnType<UpdateReturn>(),
+        M.tagsExhaustive({
+          NotEditing: () => ({ model }),
 
-              return [
-                evo(model, {
-                  todos: () => updatedTodos,
+          Editing: ({ id, text }) => {
+            if (String.isEmpty(String.trim(text))) {
+              return {
+                model: evo(model, {
                   editing: () => NotEditing(),
                 }),
-                [SaveTodos({ todos: updatedTodos })],
-              ]
-            },
-          }),
-        ),
-
-      CancelledEdit: () => [
-        evo(model, {
-          editing: () => NotEditing(),
+              }
+            }
+
+            const updatedTodos = Array.map(model.todos, todo =>
+              todo.id === id
+                ? evo(todo, { text: () => String.trim(text) })
+                : todo,
+            )
+
+            return {
+              model: evo(model, {
+                todos: () => updatedTodos,
+                editing: () => NotEditing(),
+              }),
+              commands: [SaveTodos({ todos: updatedTodos })],
+            }
+          },
         }),
-        [],
-      ],
-
-      ToggledAll: () => {
-        const allCompleted = Array.every(model.todos, todo => todo.completed)
-        const updatedTodos = Array.map(model.todos, todo =>
-          evo(todo, {
-            completed: () => !allCompleted,
-          }),
-        )
-
-        return [
-          evo(model, {
-            todos: () => updatedTodos,
-          }),
-          [SaveTodos({ todos: updatedTodos })],
-        ]
-      },
-
-      ClearedCompleted: () => {
-        const updatedTodos = Array.filter(model.todos, todo => !todo.completed)
+      ),
 
-        return [
-          evo(model, {
-            todos: () => updatedTodos,
-          }),
-          [SaveTodos({ todos: updatedTodos })],
-        ]
-      },
+    CancelledEdit: () => ({
+      model: evo(model, {
+        editing: () => NotEditing(),
+      }),
+    }),
 
-      SelectedFilter: ({ filter }) => [
-        evo(model, {
-          filter: () => filter,
+    ToggledAll: () => {
+      const allCompleted = Array.every(model.todos, todo => todo.completed)
+      const updatedTodos = Array.map(model.todos, todo =>
+        evo(todo, {
+          completed: () => !allCompleted,
         }),
-        [],
-      ],
+      )
 
-      SucceededSaveTodos: ({ todos }) => [
-        evo(model, {
-          todos: () => todos,
+      return {
+        model: evo(model, {
+          todos: () => updatedTodos,
         }),
-        [],
-      ],
+        commands: [SaveTodos({ todos: updatedTodos })],
+      }
+    },
+
+    ClearedCompleted: () => {
+      const updatedTodos = Array.filter(model.todos, todo => !todo.completed)
 
-      FailedSaveTodos: () => [model, []],
+      return {
+        model: evo(model, {
+          todos: () => updatedTodos,
+        }),
+        commands: [SaveTodos({ todos: updatedTodos })],
+      }
     },
-  )
+
+    SelectedFilter: ({ filter }) => ({
+      model: evo(model, {
+        filter: () => filter,
+      }),
+    }),
+
+    SucceededSaveTodos: ({ todos }) => ({
+      model: evo(model, {
+        todos: () => todos,
+      }),
+    }),
+
+    FailedSaveTodos: () => ({ model }),
+  })
 
 // COMMAND
 

package/dist/templates/examples/ui-showcase/src/main.ts

@@ -211,17 +211,17 @@ export const init: Runtime.RoutingApplicationInit<Model, Message, Flags> = (
   flags: Flags,
   url: Url,
 ) => {
-  const [initialUiModel, uiCommands] = uiInit(flags.today)
+  const uiInit_ = uiInit(flags.today)
 
-  return [
-    {
+  return {
+    model: {
       route: urlToAppRoute(url),
-      uiModel: initialUiModel,
+      uiModel: uiInit_.model,
     },
-    Command.mapMessages(uiCommands, message =>
+    commands: Command.mapMessages(uiInit_.commands, message =>
       Message.GotUiMessage({ message }),
     ),
-  ]
+  }
 }
 
 // UPDATE
@@ -241,58 +241,57 @@ const foldUi = Update.foldChild({
   toParentMessage: toUiMessage,
 })
 
+const foldMobileMenuDialogOutMessage = M.type<Dialog.OutMessage>().pipe(
+  M.withReturnType<Update.Step<Model, Message>>(),
+  M.tagsExhaustive({
+    Opened: () => model => ({ model }),
+    Closed: () => model => ({ model }),
+  }),
+)
+
+const foldMobileMenuDialogClose = Update.foldChildStep({
+  update: Dialog.close,
+  read: (model: Model) => Option.some(model.uiModel.mobileMenuDialog),
+  write: (model, nextMobileMenuDialog) =>
+    evo(model, {
+      uiModel: evo({ mobileMenuDialog: () => nextMobileMenuDialog }),
+    }),
+  toParentMessage: toMobileMenuDialogMessage,
+  foldOutMessage: foldMobileMenuDialogOutMessage,
+})
+
+type UpdateReturn = Update.Return<Model, Message>
+
 export const update = (model: Model, message: Message) =>
-  Message.match<readonly [Model, ReadonlyArray<Command.Command<Message>>]>(
-    message,
-    {
-      CompletedNavigateInternal: () => [model, []],
-      CompletedLoadExternal: () => [model, []],
-
-      ClickedLink: ({ request }) =>
-        M.value(request).pipe(
-          M.tagsExhaustive({
-            Internal: ({
-              url,
-            }): [
-              Model,
-              ReadonlyArray<
-                Command.Command<typeof Message.CompletedNavigateInternal>
-              >,
-            ] => [model, [NavigateInternal({ url: urlToString(url) })]],
-            External: ({
-              href,
-            }): [
-              Model,
-              ReadonlyArray<
-                Command.Command<typeof Message.CompletedLoadExternal>
-              >,
-            ] => [model, [LoadExternal({ href })]],
+  Message.match<UpdateReturn>(message, {
+    CompletedNavigateInternal: () => ({ model }),
+    CompletedLoadExternal: () => ({ model }),
+
+    ClickedLink: ({ request }) =>
+      M.value(request).pipe(
+        M.withReturnType<UpdateReturn>(),
+        M.tagsExhaustive({
+          Internal: ({ url }) => ({
+            model,
+            commands: [NavigateInternal({ url: urlToString(url) })],
           }),
-        ),
-
-      ChangedUrl: ({ url }) => {
-        const [nextMobileMenuDialog, mobileMenuDialogCommands] = Dialog.close(
-          model.uiModel.mobileMenuDialog,
-        )
-
-        return [
-          evo(model, {
-            route: () => urlToAppRoute(url),
-            uiModel: uiModel =>
-              evo(uiModel, {
-                mobileMenuDialog: () => nextMobileMenuDialog,
-              }),
+          External: ({ href }) => ({
+            model,
+            commands: [LoadExternal({ href })],
           }),
-          Command.mapMessages(
-            mobileMenuDialogCommands,
-            toMobileMenuDialogMessage,
-          ),
-        ]
-      },
+        }),
+      ),
 
-      GotUiMessage: ({ message }) => foldUi(model, message),
-    },
-  )
+    ChangedUrl: ({ url }) =>
+      Update.combine(model, [
+        stepModel => ({
+          model: evo(stepModel, { route: () => urlToAppRoute(url) }),
+        }),
+        foldMobileMenuDialogClose,
+      ]),
+
+    GotUiMessage: ({ message }) => foldUi(model, message),
+  })
 
 // VIEW
 

package/dist/templates/examples/ui-showcase/src/scene.test.ts

@@ -22,11 +22,11 @@ import {
 import { uiInit } from './ui/init'
 
 const today = Calendar.make(2026, 4, 16)
-const [initialUiModel] = uiInit(today)
+const uiInit_ = uiInit(today)
 
 const modelForRoute = (route: Model['route']): Model => ({
   route,
-  uiModel: initialUiModel,
+  uiModel: uiInit_.model,
 })
 
 const homeModel = modelForRoute(HomeRoute())

package/dist/templates/examples/ui-showcase/src/story.test.ts

@@ -11,11 +11,11 @@ import { HomeRoute, Message, type Model, update } from './main'
 import { uiInit } from './ui/init'
 
 const today = Calendar.make(2026, 4, 16)
-const [initialUiModel] = uiInit(today)
+const uiInit_ = uiInit(today)
 
 const initialModel: Model = {
   route: HomeRoute(),
-  uiModel: initialUiModel,
+  uiModel: uiInit_.model,
 }
 
 const urlOrThrow = (raw: string) =>

package/dist/templates/examples/ui-showcase/src/ui/init.ts

@@ -1,5 +1,5 @@
 import { Option } from 'effect'
-import { Calendar, Command } from 'foldkit'
+import { Calendar, type Update } from 'foldkit'
 
 import {
   Animation,
@@ -23,10 +23,10 @@ import type { UiMessage } from './message'
 import type { UiModel } from './model'
 import { Toast } from './toast'
 
-export const uiInit = (
-  today: Calendar.CalendarDate,
-): [UiModel, ReadonlyArray<Command.Command<UiMessage>>] => [
-  {
+type InitReturn = Update.Return<UiModel, UiMessage>
+
+export const uiInit = (today: Calendar.CalendarDate): InitReturn => ({
+  model: {
     mobileMenuDialog: Dialog.init({ id: 'mobile-menu' }),
     buttonClickCount: 0,
     inputDemoValue: '',
@@ -181,5 +181,4 @@ export const uiInit = (
       rowHeightPx: 56,
     }),
   },
-  [],
-]
+})