create-foldkit-app 0.32.0 → 0.32.1

package/dist/templates/examples/query-sync/src/main.ts

@@ -2,10 +2,10 @@ import { clsx } from 'clsx'
 import {
   Array,
   Effect,
-  Match as M,
+  Match,
   Option,
   Order,
-  Schema as S,
+  Schema,
   SchemaTransformation,
   String,
   Types,
@@ -25,9 +25,15 @@ import { AnchorConfig } from '@foldkit/ui/listbox'
 
 import { type Dinosaur, dinosaurs } from './data'
 
-const Diet = S.Literals(['Carnivore', 'Herbivore', 'Omnivore'])
-const Period = S.Literals(['Triassic', 'Jurassic', 'Cretaceous'])
-const SortColumn = S.Literals(['Name', 'Period', 'Diet', 'Length', 'Weight'])
+const Diet = Schema.Literals(['Carnivore', 'Herbivore', 'Omnivore'])
+const Period = Schema.Literals(['Triassic', 'Jurassic', 'Cretaceous'])
+const SortColumn = Schema.Literals([
+  'Name',
+  'Period',
+  'Diet',
+  'Length',
+  'Weight',
+])
 type SortColumn = typeof SortColumn.Type
 
 export const Sorting = defineTaggedUnion({
@@ -44,12 +50,12 @@ const periodFilterItems: ReadonlyArray<string> = ['', ...Period.literals]
 
 const SORT_PARAM_SEPARATOR = ':'
 
-const optionFromValidParam = <A extends string>(schema: S.Codec<A, A>) => {
-  const decode = S.decodeUnknownOption(schema)
+const optionFromValidParam = <A extends string>(schema: Schema.Codec<A, A>) => {
+  const decode = Schema.decodeUnknownOption(schema)
 
-  return S.OptionFromOptional(S.String).pipe(
-    S.decodeTo(
-      S.Option(schema),
+  return Schema.OptionFromOptional(Schema.String).pipe(
+    Schema.decodeTo(
+      Schema.Option(schema),
       SchemaTransformation.transform({
         decode: (maybeRaw: Option.Option<string>): Option.Option<A> =>
           Option.flatMap(maybeRaw, decode),
@@ -60,14 +66,14 @@ const optionFromValidParam = <A extends string>(schema: S.Codec<A, A>) => {
   )
 }
 
-const SortDirection = S.Literals(['Ascending', 'Descending'])
+const SortDirection = Schema.Literals(['Ascending', 'Descending'])
 
 const sortingFromParam = (() => {
-  const decodeColumn = S.decodeUnknownOption(SortColumn)
-  const decodeDirection = S.decodeUnknownOption(SortDirection)
+  const decodeColumn = Schema.decodeUnknownOption(SortColumn)
+  const decodeDirection = Schema.decodeUnknownOption(SortDirection)
 
-  return S.OptionFromOptional(S.String).pipe(
-    S.decodeTo(
+  return Schema.OptionFromOptional(Schema.String).pipe(
+    Schema.decodeTo(
       Sorting,
       SchemaTransformation.transform({
         decode: (maybeRaw: Option.Option<string>): Sorting =>
@@ -90,10 +96,14 @@ const sortingFromParam = (() => {
                   ),
                 }),
                 Option.map(({ column, direction }) =>
-                  M.value(direction).pipe(
-                    M.when('Ascending', () => Sorting.Ascending({ column })),
-                    M.when('Descending', () => Sorting.Descending({ column })),
-                    M.exhaustive,
+                  Match.value(direction).pipe(
+                    Match.when('Ascending', () =>
+                      Sorting.Ascending({ column }),
+                    ),
+                    Match.when('Descending', () =>
+                      Sorting.Descending({ column }),
+                    ),
+                    Match.exhaustive,
                   ),
                 ),
                 Option.getOrElse(() => Sorting.Unsorted()),
@@ -115,12 +125,12 @@ const sortingFromParam = (() => {
 
 export const AppRoute = defineRouteUnion({
   Browse: {
-    search: S.Option(S.String),
+    search: Schema.Option(Schema.String),
     sorting: Sorting,
-    diet: S.Option(Diet),
-    period: S.Option(Period),
+    diet: Schema.Option(Diet),
+    period: Schema.Option(Period),
   },
-  NotFound: { path: S.String },
+  NotFound: { path: Schema.String },
 })
 
 export type AppRoute = typeof AppRoute.Type
@@ -128,8 +138,8 @@ export type AppRoute = typeof AppRoute.Type
 export const browseRouter = pipe(
   Route.root,
   Route.query(
-    S.Struct({
-      search: S.OptionFromOptional(S.String),
+    Schema.Struct({
+      search: Schema.OptionFromOptional(Schema.String),
       sorting: sortingFromParam,
       diet: optionFromValidParam(Diet),
       period: optionFromValidParam(Period),
@@ -143,7 +153,7 @@ const urlToAppRoute = Route.parseUrlWithFallback(routeParser, AppRoute.NotFound)
 
 // MODEL
 
-export const Model = S.Struct({
+export const Model = Schema.Struct({
   route: AppRoute,
   dietListbox: Listbox.Model,
   periodListbox: Listbox.Model,
@@ -158,7 +168,7 @@ export const Message = defineMessageUnion({
   CompletedReplaceFilters: {},
   ClickedLink: { request: UrlRequest },
   ChangedUrl: { url: Url },
-  ChangedSearchInput: { value: S.String },
+  ChangedSearchInput: { value: Schema.String },
   ClickedColumnHeader: { column: SortColumn },
   GotDietListboxMessage: { message: Listbox.Message },
   GotPeriodListboxMessage: { message: Listbox.Message },
@@ -178,9 +188,9 @@ const emptyBrowseFields: BrowseFields = {
 }
 
 const routeToBrowseFields = (route: AppRoute): BrowseFields =>
-  M.value(route).pipe(
-    M.tag('Browse', route => route),
-    M.orElse(() => emptyBrowseFields),
+  Match.value(route).pipe(
+    Match.tag('Browse', route => route),
+    Match.orElse(() => emptyBrowseFields),
   )
 
 export const init: Runtime.RoutingApplicationInit<Model, Message> = (
@@ -216,18 +226,18 @@ const columnSortDirection = (
 const nextSorting = (sorting: Sorting, column: SortColumn): Sorting =>
   pipe(
     columnSortDirection(sorting, column),
-    M.value,
-    M.when('Unsorted', () => Sorting.Ascending({ column })),
-    M.when('Ascending', () => Sorting.Descending({ column })),
-    M.when('Descending', () => Sorting.Unsorted()),
-    M.exhaustive,
+    Match.value,
+    Match.when('Unsorted', () => Sorting.Ascending({ column })),
+    Match.when('Ascending', () => Sorting.Descending({ column })),
+    Match.when('Descending', () => Sorting.Unsorted()),
+    Match.exhaustive,
   )
 
 const selectionToParam = <A extends string>(
   maybeSelectedItem: Option.Option<string>,
-  schema: S.Codec<A, A>,
+  schema: Schema.Codec<A, A>,
 ): Option.Option<A> => {
-  const decode = S.decodeUnknownOption(schema)
+  const decode = Schema.decodeUnknownOption(schema)
 
   return pipe(
     maybeSelectedItem,
@@ -238,10 +248,10 @@ const selectionToParam = <A extends string>(
 
 export const ReplaceFilters = Command.define('ReplaceFilters', {
   args: {
-    search: S.Option(S.String),
+    search: Schema.Option(Schema.String),
     sorting: Sorting,
-    diet: S.Option(Diet),
-    period: S.Option(Period),
+    diet: Schema.Option(Diet),
+    period: Schema.Option(Period),
   },
   messages: [Message.CompletedReplaceFilters],
   execute: fields =>
@@ -251,14 +261,14 @@ export const ReplaceFilters = Command.define('ReplaceFilters', {
 })
 
 const NavigateInternal = Command.define('NavigateInternal', {
-  args: { url: S.String },
+  args: { url: Schema.String },
   messages: [Message.CompletedNavigateInternal],
   execute: ({ url }) =>
     pushUrl(url).pipe(Effect.as(Message.CompletedNavigateInternal())),
 })
 
 const LoadExternal = Command.define('LoadExternal', {
-  args: { href: S.String },
+  args: { href: Schema.String },
   messages: [Message.CompletedLoadExternal],
   execute: ({ href }) =>
     load(href).pipe(Effect.as(Message.CompletedLoadExternal())),
@@ -269,27 +279,24 @@ type UpdateReturn = Update.Return<Model, Message>
 const DietListbox = Listbox.create<string>()
 const PeriodListbox = Listbox.create<string>()
 
-const foldDietListboxOutMessage: (
-  outMessage: Listbox.OutMessage,
-) => Update.Step<Model, Message> = M.type<Listbox.OutMessage>().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    Selected:
-      ({ value }) =>
-      model => {
-        const fields = routeToBrowseFields(model.route)
-        return {
-          model,
-          commands: [
-            ReplaceFilters({
-              ...fields,
-              diet: selectionToParam(Option.some(value), Diet),
-            }),
-          ],
-        }
-      },
-  }),
-)
+const foldDietListboxOutMessage = Listbox.OutMessage.match<
+  Update.Step<Model, Message>
+>({
+  Selected:
+    ({ value }) =>
+    model => {
+      const fields = routeToBrowseFields(model.route)
+      return {
+        model,
+        commands: [
+          ReplaceFilters({
+            ...fields,
+            diet: selectionToParam(Option.some(value), Diet),
+          }),
+        ],
+      }
+    },
+})
 
 const foldDietListbox = Update.foldChild({
   update: DietListbox.update,
@@ -300,27 +307,24 @@ const foldDietListbox = Update.foldChild({
   foldOutMessage: foldDietListboxOutMessage,
 })
 
-const foldPeriodListboxOutMessage: (
-  outMessage: Listbox.OutMessage,
-) => Update.Step<Model, Message> = M.type<Listbox.OutMessage>().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    Selected:
-      ({ value }) =>
-      model => {
-        const fields = routeToBrowseFields(model.route)
-        return {
-          model,
-          commands: [
-            ReplaceFilters({
-              ...fields,
-              period: selectionToParam(Option.some(value), Period),
-            }),
-          ],
-        }
-      },
-  }),
-)
+const foldPeriodListboxOutMessage = Listbox.OutMessage.match<
+  Update.Step<Model, Message>
+>({
+  Selected:
+    ({ value }) =>
+    model => {
+      const fields = routeToBrowseFields(model.route)
+      return {
+        model,
+        commands: [
+          ReplaceFilters({
+            ...fields,
+            period: selectionToParam(Option.some(value), Period),
+          }),
+        ],
+      }
+    },
+})
 
 const foldPeriodListbox = Update.foldChild({
   update: PeriodListbox.update,
@@ -439,11 +443,11 @@ const filterAndSort = (fields: BrowseFields): ReadonlyArray<Dinosaur> =>
   )
 
 const sortIndicator = (column: SortColumn, sorting: Sorting): string =>
-  M.value(columnSortDirection(sorting, column)).pipe(
-    M.when('Unsorted', () => ''),
-    M.when('Ascending', () => '↑'),
-    M.when('Descending', () => '↓'),
-    M.exhaustive,
+  Match.value(columnSortDirection(sorting, column)).pipe(
+    Match.when('Unsorted', () => ''),
+    Match.when('Ascending', () => '↑'),
+    Match.when('Descending', () => '↓'),
+    Match.exhaustive,
   )
 
 const BADGE_BASE = 'px-2 py-0.5 rounded-full text-xs font-medium'
@@ -503,19 +507,19 @@ const dinosaurRowView = (dinosaur: Dinosaur, h: HtmlBuilder<Message>): Html =>
   )
 
 const sortAriaLabel = (column: SortColumn, sorting: Sorting): string =>
-  M.value(columnSortDirection(sorting, column)).pipe(
-    M.when('Unsorted', () => `Sort by ${column}`),
-    M.when('Ascending', () => `Sort by ${column}, currently ascending`),
-    M.when('Descending', () => `Sort by ${column}, currently descending`),
-    M.exhaustive,
+  Match.value(columnSortDirection(sorting, column)).pipe(
+    Match.when('Unsorted', () => `Sort by ${column}`),
+    Match.when('Ascending', () => `Sort by ${column}, currently ascending`),
+    Match.when('Descending', () => `Sort by ${column}, currently descending`),
+    Match.exhaustive,
   )
 
 const ariaSortValue = (column: SortColumn, sorting: Sorting): string =>
-  M.value(columnSortDirection(sorting, column)).pipe(
-    M.when('Unsorted', () => 'none'),
-    M.when('Ascending', () => 'ascending'),
-    M.when('Descending', () => 'descending'),
-    M.exhaustive,
+  Match.value(columnSortDirection(sorting, column)).pipe(
+    Match.when('Unsorted', () => 'none'),
+    Match.when('Ascending', () => 'ascending'),
+    Match.when('Descending', () => 'descending'),
+    Match.exhaustive,
   )
 
 const sortableColumnHeader = (
@@ -852,9 +856,9 @@ const notFoundView = (path: string, h: HtmlBuilder<Message>): Html =>
   )
 
 const routeTitle = (route: Model['route']): string =>
-  M.value(route).pipe(
-    M.tag('Browse', () => 'Dinosaur Explorer'),
-    M.orElse(() => 'Not Found | Dinosaur Explorer'),
+  Match.value(route).pipe(
+    Match.tag('Browse', () => 'Dinosaur Explorer'),
+    Match.orElse(() => 'Not Found | Dinosaur Explorer'),
   )
 
 export const view = (model: Model, h: HtmlBuilder<Message>): Document => {

package/dist/templates/examples/route-transitions/src/data.ts

@@ -1,10 +1,10 @@
-import { Array, Option, Schema as S, pipe } from 'effect'
+import { Array, Option, Schema, pipe } from 'effect'
 
-export const Painting = S.Struct({
-  id: S.Number,
-  title: S.String,
-  artist: S.String,
-  gradient: S.String,
+export const Painting = Schema.Struct({
+  id: Schema.Number,
+  title: Schema.String,
+  artist: Schema.String,
+  gradient: Schema.String,
 })
 export type Painting = typeof Painting.Type
 

package/dist/templates/examples/route-transitions/src/main.ts

@@ -1,12 +1,4 @@
-import {
-  Array,
-  Duration,
-  Effect,
-  Match as M,
-  Option,
-  Schema as S,
-  pipe,
-} from 'effect'
+import { Array, Duration, Effect, Match, Option, Schema, pipe } from 'effect'
 import { Command, Runtime, Update } from 'foldkit'
 import { Document, Html, HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
@@ -35,30 +27,30 @@ const MAX_LOGGED_TRANSITIONS = 20
 
 // MODEL
 
-export const CatalogStatus = S.Literals(['Idle', 'Loading', 'Ready'])
+export const CatalogStatus = Schema.Literals(['Idle', 'Loading', 'Ready'])
 export type CatalogStatus = typeof CatalogStatus.Type
 
 export const PaintingStatus = defineTaggedUnion({
   Idle: {},
-  Loading: { paintingId: S.Number },
-  Ready: { paintingId: S.Number },
+  Loading: { paintingId: Schema.Number },
+  Ready: { paintingId: Schema.Number },
 })
 export type PaintingStatus = typeof PaintingStatus.Type
 
-export const LoggedTransition = S.Struct({
-  sequenceNumber: S.Number,
-  maybePreviousRoute: S.Option(AppRoute),
+export const LoggedTransition = Schema.Struct({
+  sequenceNumber: Schema.Number,
+  maybePreviousRoute: Schema.Option(AppRoute),
   nextRoute: AppRoute,
 })
 export type LoggedTransition = typeof LoggedTransition.Type
 
-export const Model = S.Struct({
+export const Model = Schema.Struct({
   route: AppRoute,
-  transitionLog: S.Array(LoggedTransition),
+  transitionLog: Schema.Array(LoggedTransition),
   catalogStatus: CatalogStatus,
   paintingStatus: PaintingStatus,
-  studioDraft: S.String,
-  maybeSavedDraft: S.Option(S.String),
+  studioDraft: Schema.String,
+  maybeSavedDraft: Schema.Option(Schema.String),
 })
 export type Model = typeof Model.Type
 
@@ -70,9 +62,9 @@ export const Message = defineMessageUnion({
   ClickedLink: { request: UrlRequest },
   ChangedUrl: { url: Url },
   SucceededLoadCatalog: {},
-  SucceededLoadPainting: { paintingId: S.Number },
-  UpdatedStudioDraft: { value: S.String },
-  SucceededSaveDraft: { draft: S.String },
+  SucceededLoadPainting: { paintingId: Schema.Number },
+  UpdatedStudioDraft: { value: Schema.String },
+  SucceededSaveDraft: { draft: Schema.String },
 })
 
 export type Message = typeof Message.Type
@@ -80,14 +72,14 @@ export type Message = typeof Message.Type
 // COMMAND
 
 const NavigateInternal = Command.define('NavigateInternal', {
-  args: { url: S.String },
+  args: { url: Schema.String },
   messages: [Message.CompletedNavigateInternal],
   execute: ({ url }) =>
     pushUrl(url).pipe(Effect.as(Message.CompletedNavigateInternal())),
 })
 
 const LoadExternal = Command.define('LoadExternal', {
-  args: { href: S.String },
+  args: { href: Schema.String },
   messages: [Message.CompletedLoadExternal],
   execute: ({ href }) =>
     load(href).pipe(Effect.as(Message.CompletedLoadExternal())),
@@ -101,7 +93,7 @@ export const LoadCatalog = Command.define('LoadCatalog', {
 })
 
 export const LoadPainting = Command.define('LoadPainting', {
-  args: { paintingId: S.Number },
+  args: { paintingId: Schema.Number },
   messages: [Message.SucceededLoadPainting],
   execute: ({ paintingId }) =>
     Effect.sleep(PAINTING_LATENCY).pipe(
@@ -110,7 +102,7 @@ export const LoadPainting = Command.define('LoadPainting', {
 })
 
 export const SaveDraft = Command.define('SaveDraft', {
-  args: { draft: S.String },
+  args: { draft: Schema.String },
   messages: [Message.SucceededSaveDraft],
   execute: ({ draft }) =>
     Effect.sleep(SAVE_LATENCY).pipe(
@@ -748,9 +740,11 @@ const transitionLogView = (
   )
 
 const routeTitle = (route: AppRoute): string =>
-  M.value(route).pipe(
-    M.tag('Home', () => 'Route Transitions'),
-    M.orElse(currentRoute => `${routeLabel(currentRoute)} | Route Transitions`),
+  Match.value(route).pipe(
+    Match.tag('Home', () => 'Route Transitions'),
+    Match.orElse(
+      currentRoute => `${routeLabel(currentRoute)} | Route Transitions`,
+    ),
   )
 
 export const view = (model: Model, h: HtmlBuilder<Message>): Document => {

package/dist/templates/examples/route-transitions/src/route.ts

@@ -1,13 +1,13 @@
-import { Schema as S, pipe } from 'effect'
+import { Schema, pipe } from 'effect'
 import { Route } from 'foldkit'
 import { defineRouteUnion, int, literal, slash } from 'foldkit/route'
 
 export const AppRoute = defineRouteUnion({
   Home: {},
   Gallery: {},
-  Painting: { paintingId: S.Number },
+  Painting: { paintingId: Schema.Number },
   Studio: {},
-  NotFound: { path: S.String },
+  NotFound: { path: Schema.String },
 })
 
 export type AppRoute = typeof AppRoute.Type

package/dist/templates/examples/routing/src/fileTree.ts

@@ -1,4 +1,4 @@
-import { Array, Match as M, Option, Schema as S, pipe } from 'effect'
+import { Array, Match, Option, Schema, pipe } from 'effect'
 import { taggedStruct } from 'foldkit/schema'
 
 export type File = typeof File.Type
@@ -10,16 +10,18 @@ export type Directory = Readonly<{
 export type FileTreeEntry = File | Directory
 
 export const File = taggedStruct('File', {
-  name: S.String,
-  sizeInBytes: S.Number,
+  name: Schema.String,
+  sizeInBytes: Schema.Number,
 })
 
 export const Directory = taggedStruct('Directory', {
-  name: S.String,
-  entries: S.Array(S.suspend((): S.Codec<FileTreeEntry> => FileTreeEntry)),
+  name: Schema.String,
+  entries: Schema.Array(
+    Schema.suspend((): Schema.Codec<FileTreeEntry> => FileTreeEntry),
+  ),
 })
 
-export const FileTreeEntry = S.Union([File, Directory])
+export const FileTreeEntry = Schema.Union([File, Directory])
 
 export const fileTree: ReadonlyArray<FileTreeEntry> = [
   Directory({
@@ -57,8 +59,8 @@ const findDirectoryEntries = (
   pipe(
     Array.findFirst(entries, entry => entry.name === name),
     Option.flatMap(entry =>
-      M.value(entry).pipe(
-        M.tagsExhaustive({
+      Match.value(entry).pipe(
+        Match.tagsExhaustive({
           File: () => Option.none(),
           Directory: directory => Option.some(directory.entries),
         }),

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

@@ -1,4 +1,4 @@
-import { Array, Effect, Match as M, Option, Schema as S } from 'effect'
+import { Array, Effect, Match, Option, Schema } from 'effect'
 import { Command, Runtime, Update } from 'foldkit'
 import { Document, Html, HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
@@ -28,7 +28,7 @@ export { AppRoute } from './route'
 
 // MODEL
 
-export const Model = S.Struct({
+export const Model = Schema.Struct({
   route: AppRoute,
   peoplePage: People.Model,
 })
@@ -54,9 +54,9 @@ export const init: Runtime.RoutingApplicationInit<Model, Message> = (
 ) => {
   const route = urlToAppRoute(url)
 
-  const initialPeopleRoute = M.value(route).pipe(
-    M.tag('People', peopleRoute => peopleRoute),
-    M.orElse(() => AppRoute.People({ searchText: Option.none() })),
+  const initialPeopleRoute = Match.value(route).pipe(
+    Match.tag('People', peopleRoute => peopleRoute),
+    Match.orElse(() => AppRoute.People({ searchText: Option.none() })),
   )
 
   const peopleInit = People.init(initialPeopleRoute)
@@ -71,14 +71,14 @@ export const init: Runtime.RoutingApplicationInit<Model, Message> = (
 // COMMAND
 
 const NavigateInternal = Command.define('NavigateInternal', {
-  args: { url: S.String },
+  args: { url: Schema.String },
   messages: [Message.CompletedNavigateInternal],
   execute: ({ url }) =>
     pushUrl(url).pipe(Effect.as(Message.CompletedNavigateInternal())),
 })
 
 const LoadExternal = Command.define('LoadExternal', {
-  args: { href: S.String },
+  args: { href: Schema.String },
   messages: [Message.CompletedLoadExternal],
   execute: ({ href }) =>
     load(href).pipe(Effect.as(Message.CompletedLoadExternal())),
@@ -127,10 +127,12 @@ export const update = (model: Model, message: Message) =>
     ChangedUrl: ({ url }) => {
       const nextRoute = urlToAppRoute(url)
 
-      const routeSteps = M.value(nextRoute).pipe(
-        M.withReturnType<ReadonlyArray<Update.Step<Model, Message>>>(),
-        M.tag('People', peopleRoute => [foldPeopleRouteChanged(peopleRoute)]),
-        M.orElse(() => []),
+      const routeSteps = Match.value(nextRoute).pipe(
+        Match.withReturnType<ReadonlyArray<Update.Step<Model, Message>>>(),
+        Match.tag('People', peopleRoute => [
+          foldPeopleRouteChanged(peopleRoute),
+        ]),
+        Match.orElse(() => []),
       )
 
       return Update.combine(model, [setRoute(nextRoute), ...routeSteps])
@@ -372,8 +374,8 @@ const entryListView = (
             ],
             [entry.name],
           ),
-          M.value(entry).pipe(
-            M.tagsExhaustive({
+          Match.value(entry).pipe(
+            Match.tagsExhaustive({
               File: file =>
                 h.span(
                   [h.Class('text-sm text-gray-500')],
@@ -484,8 +486,8 @@ const filesView = (
   const content = Option.match(maybeEntry, {
     onNone: () => missingEntryView(path, h),
     onSome: entry =>
-      M.value(entry).pipe(
-        M.tagsExhaustive({
+      Match.value(entry).pipe(
+        Match.tagsExhaustive({
           File: file => fileDetailView(file, h),
           Directory: directory => entryListView(path, directory.entries, h),
         }),
@@ -518,15 +520,15 @@ const notFoundView = (path: string, h: HtmlBuilder<Message>): Html =>
   )
 
 const routeTitle = (route: Model['route']): string =>
-  M.value(route).pipe(
-    M.tag('Home', () => 'Routing'),
-    M.tag('Person', ({ personId }) => `Person ${personId} | Routing`),
-    M.tag('FilesIndex', () => 'Files | Routing'),
-    M.tag(
+  Match.value(route).pipe(
+    Match.tag('Home', () => 'Routing'),
+    Match.tag('Person', ({ personId }) => `Person ${personId} | Routing`),
+    Match.tag('FilesIndex', () => 'Files | Routing'),
+    Match.tag(
       'Files',
       ({ path }) => `${Array.lastNonEmpty(path)} | Files | Routing`,
     ),
-    M.orElse(({ _tag }) => `${_tag} | Routing`),
+    Match.orElse(({ _tag }) => `${_tag} | Routing`),
   )
 
 export const view = (model: Model, h: HtmlBuilder<Message>): Document => {