create-foldkit-app 0.32.0 → 0.32.1

package/dist/templates/examples/auth/src/update.ts

@@ -1,4 +1,4 @@
-import { Effect, Match as M, Option, Schema as S } from 'effect'
+import { Effect, Match, Option, Schema } from 'effect'
 import { Command, Update } from 'foldkit'
 import { UrlRequest, load, pushUrl, replaceUrl } from 'foldkit/navigation'
 import { evo } from 'foldkit/struct'
@@ -16,14 +16,14 @@ import {
 } from './route'
 
 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())),
@@ -51,27 +51,24 @@ const RedirectToHome = Command.define('RedirectToHome', {
 })
 
 type UpdateReturn = Update.Return<Model, Message>
-const withUpdateReturn = M.withReturnType<UpdateReturn>()
-
-const foldLoggedOutOutMessage: (
-  outMessage: LoggedOut.OutMessage,
-) => Update.Step<Model, Message> = M.type<LoggedOut.OutMessage>().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    SucceededLogin:
-      ({ session }) =>
-      () => ({
-        model: LoggedIn.init(AppRoute.Dashboard(), session),
-        commands: [SaveSession({ session }), RedirectToDashboard()],
-      }),
-  }),
-)
+const withUpdateReturn = Match.withReturnType<UpdateReturn>()
+
+const foldLoggedOutOutMessage = LoggedOut.OutMessage.match<
+  Update.Step<Model, Message>
+>({
+  SucceededLogin:
+    ({ session }) =>
+    () => ({
+      model: LoggedIn.init(AppRoute.Dashboard(), session),
+      commands: [SaveSession({ session }), RedirectToDashboard()],
+    }),
+})
 
 const foldLoggedOut = Update.foldChild({
   update: LoggedOut.update,
   read: (model: Model) =>
-    M.value(model).pipe(
-      M.tagsExhaustive({
+    Match.value(model).pipe(
+      Match.tagsExhaustive({
         LoggedOut: loggedOutModel => Option.some(loggedOutModel),
         LoggedIn: () => Option.none(),
       }),
@@ -81,23 +78,20 @@ const foldLoggedOut = Update.foldChild({
   foldOutMessage: foldLoggedOutOutMessage,
 })
 
-const foldLoggedInOutMessage: (
-  outMessage: LoggedIn.OutMessage,
-) => Update.Step<Model, Message> = M.type<LoggedIn.OutMessage>().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    RequestedLogout: () => () => ({
-      model: LoggedOut.init(AppRoute.Home()),
-      commands: [ClearSession(), RedirectToHome()],
-    }),
+const foldLoggedInOutMessage = LoggedIn.OutMessage.match<
+  Update.Step<Model, Message>
+>({
+  RequestedLogout: () => () => ({
+    model: LoggedOut.init(AppRoute.Home()),
+    commands: [ClearSession(), RedirectToHome()],
   }),
-)
+})
 
 const foldLoggedIn = Update.foldChild({
   update: LoggedIn.update,
   read: (model: Model) =>
-    M.value(model).pipe(
-      M.tagsExhaustive({
+    Match.value(model).pipe(
+      Match.tagsExhaustive({
         LoggedOut: () => Option.none(),
         LoggedIn: loggedInModel => Option.some(loggedInModel),
       }),
@@ -124,25 +118,28 @@ export const update = (model: Model, message: Message) =>
     ChangedUrl: ({ url }) => {
       const route = urlToAppRoute(url)
 
-      return M.value(model).pipe(
+      return Match.value(model).pipe(
         withUpdateReturn,
-        M.tagsExhaustive({
+        Match.tagsExhaustive({
           LoggedOut: loggedOutModel =>
-            M.value(route).pipe(
+            Match.value(route).pipe(
               withUpdateReturn,
-              M.tag('Home', 'Login', 'NotFound', route => ({
+              Match.tag('Home', 'Login', 'NotFound', route => ({
                 model: evo(loggedOutModel, { route: () => route }),
               })),
-              M.orElse(() => ({ model, commands: [RedirectToLogin()] })),
+              Match.orElse(() => ({ model, commands: [RedirectToLogin()] })),
             ),
 
           LoggedIn: loggedInModel =>
-            M.value(route).pipe(
+            Match.value(route).pipe(
               withUpdateReturn,
-              M.tag('Dashboard', 'Settings', 'NotFound', route => ({
+              Match.tag('Dashboard', 'Settings', 'NotFound', route => ({
                 model: evo(loggedInModel, { route: () => route }),
               })),
-              M.orElse(() => ({ model, commands: [RedirectToDashboard()] })),
+              Match.orElse(() => ({
+                model,
+                commands: [RedirectToDashboard()],
+              })),
             ),
         }),
       )

package/dist/templates/examples/auth/src/view.ts

@@ -1,13 +1,13 @@
-import { Match as M } from 'effect'
+import { Match } from 'effect'
 import { type Document, HtmlBuilder } from 'foldkit/html'
 
 import { Message } from './message'
 import { LoggedIn, LoggedOut, Model } from './model'
 
 const title = (model: Model): string =>
-  M.value(model.route).pipe(
-    M.tag('Home', () => 'Auth'),
-    M.orElse(({ _tag }) => `${_tag} | Auth`),
+  Match.value(model.route).pipe(
+    Match.tag('Home', () => 'Auth'),
+    Match.orElse(({ _tag }) => `${_tag} | Auth`),
   )
 
 export const view = (model: Model, h: HtmlBuilder<Message>): Document => ({
@@ -15,8 +15,8 @@ export const view = (model: Model, h: HtmlBuilder<Message>): Document => ({
   body: h.div(
     [h.Class('min-h-screen bg-gray-100')],
     [
-      M.value(model).pipe(
-        M.tagsExhaustive({
+      Match.value(model).pipe(
+        Match.tagsExhaustive({
           LoggedOut: loggedOutModel =>
             h.submodel({
               slotId: 'logged-out',

package/dist/templates/examples/canvas-art/src/main.ts

@@ -1,12 +1,4 @@
-import {
-  Array,
-  Effect,
-  Number,
-  Option,
-  Random,
-  Schema as S,
-  pipe,
-} from 'effect'
+import { Array, Effect, Number, Option, Random, Schema, pipe } from 'effect'
 import { Canvas, Command, Runtime, Subscription, type Update } from 'foldkit'
 import { Document, Html, HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
@@ -36,36 +28,36 @@ const PALETTE: ReadonlyArray<string> = [
 ]
 const FALLBACK_COLOR = '#ffffff'
 
-const Ball = S.Struct({
-  id: S.Number,
-  x: S.Number,
-  y: S.Number,
-  vx: S.Number,
-  vy: S.Number,
-  radius: S.Number,
-  color: S.String,
+const Ball = Schema.Struct({
+  id: Schema.Number,
+  x: Schema.Number,
+  y: Schema.Number,
+  vx: Schema.Number,
+  vy: Schema.Number,
+  radius: Schema.Number,
+  color: Schema.String,
 })
 type Ball = typeof Ball.Type
 
-export const Model = S.Struct({
-  balls: S.Array(Ball),
-  nextId: S.Number,
-  isRunning: S.Boolean,
+export const Model = Schema.Struct({
+  balls: Schema.Array(Ball),
+  nextId: Schema.Number,
+  isRunning: Schema.Boolean,
 })
 export type Model = typeof Model.Type
 
 // MESSAGE
 
 export const Message = defineMessageUnion({
-  TickedFrame: { deltaTime: S.Number },
-  ClickedCanvas: { x: S.Number, y: S.Number },
+  TickedFrame: { deltaTime: Schema.Number },
+  ClickedCanvas: { x: Schema.Number, y: Schema.Number },
   CompletedGenerateBall: {
-    x: S.Number,
-    y: S.Number,
-    vx: S.Number,
-    vy: S.Number,
-    radius: S.Number,
-    color: S.String,
+    x: Schema.Number,
+    y: Schema.Number,
+    vx: Schema.Number,
+    vy: Schema.Number,
+    radius: Schema.Number,
+    color: Schema.String,
   },
   ClickedClear: {},
   ClickedTogglePlay: {},
@@ -82,7 +74,7 @@ export const init: Runtime.ApplicationInit<Model, Message> = () => ({
 // COMMAND
 
 export const GenerateBall = Command.define('GenerateBall', {
-  args: { x: S.Number, y: S.Number },
+  args: { x: Schema.Number, y: Schema.Number },
   messages: [Message.CompletedGenerateBall],
   execute: ({ x, y }) =>
     Effect.gen(function* () {

package/dist/templates/examples/charting/src/command.ts

@@ -1,4 +1,4 @@
-import { Effect, Layer, Option, Schema as S } from 'effect'
+import { Effect, Layer, Option, Schema } from 'effect'
 import { Command, Http } from 'foldkit'
 
 import { getChart } from './chartHost'
@@ -31,12 +31,12 @@ export const FetchTelemetry = Command.define('FetchTelemetry', {
 
 export const SyncChart = Command.define('SyncChart', {
   args: {
-    hostId: S.String,
+    hostId: Schema.String,
     telemetry: Telemetry,
     chartMode: ChartMode,
     selectedPackageId: PackageId,
     period: Period,
-    maybeSelectedDatumId: S.Option(S.String),
+    maybeSelectedDatumId: Schema.Option(Schema.String),
   },
   messages: [Message.SucceededSyncChart, Message.FailedSyncChart],
   execute: args =>

package/dist/templates/examples/charting/src/domain.ts

@@ -1,12 +1,12 @@
-import { Array, Option, Schema as S, pipe } from 'effect'
+import { Array, Option, Schema, pipe } from 'effect'
 
 // MODEL
 
-export const ChartMode = S.Literals(['Adoption', 'Velocity', 'Ecosystem'])
+export const ChartMode = Schema.Literals(['Adoption', 'Velocity', 'Ecosystem'])
 export type ChartMode = typeof ChartMode.Type
 export const chartModes: ReadonlyArray<ChartMode> = ChartMode.literals
 
-export const Period = S.Literals([
+export const Period = Schema.Literals([
   'LastEightWeeks',
   'LastSixteenWeeks',
   'LastYear',
@@ -14,15 +14,20 @@ export const Period = S.Literals([
 export type Period = typeof Period.Type
 export const periods: ReadonlyArray<Period> = Period.literals
 
-export const PackageId = S.Literals(['Core', 'Ui', 'Devtools', 'VitePlugin'])
+export const PackageId = Schema.Literals([
+  'Core',
+  'Ui',
+  'Devtools',
+  'VitePlugin',
+])
 export type PackageId = typeof PackageId.Type
 export const packageIds: ReadonlyArray<PackageId> = PackageId.literals
 
-export const PackageSpec = S.Struct({
+export const PackageSpec = Schema.Struct({
   id: PackageId,
-  npmName: S.String,
-  displayName: S.String,
-  role: S.String,
+  npmName: Schema.String,
+  displayName: Schema.String,
+  role: Schema.String,
 })
 export type PackageSpec = typeof PackageSpec.Type
 
@@ -53,68 +58,68 @@ export const packageSpecs: ReadonlyArray<PackageSpec> = [
   },
 ]
 
-export const WeeklyTelemetry = S.Struct({
-  weekStart: S.String,
-  cumulativeStars: S.Number,
-  commits: S.Number,
-  releases: S.Number,
+export const WeeklyTelemetry = Schema.Struct({
+  weekStart: Schema.String,
+  cumulativeStars: Schema.Number,
+  commits: Schema.Number,
+  releases: Schema.Number,
 })
 export type WeeklyTelemetry = typeof WeeklyTelemetry.Type
 
-export const WeeklyDownloads = S.Struct({
-  weekStart: S.String,
-  downloads: S.Number,
+export const WeeklyDownloads = Schema.Struct({
+  weekStart: Schema.String,
+  downloads: Schema.Number,
 })
 export type WeeklyDownloads = typeof WeeklyDownloads.Type
 
-export const PackageSnapshot = S.Struct({
+export const PackageSnapshot = Schema.Struct({
   id: PackageId,
-  npmName: S.String,
-  displayName: S.String,
-  role: S.String,
-  latestVersion: S.String,
-  publishedAt: S.String,
-  totalDownloads: S.Number,
-  lastWeekDownloads: S.Number,
-  dependencyCount: S.Number,
-  downloadsByWeek: S.Array(WeeklyDownloads),
+  npmName: Schema.String,
+  displayName: Schema.String,
+  role: Schema.String,
+  latestVersion: Schema.String,
+  publishedAt: Schema.String,
+  totalDownloads: Schema.Number,
+  lastWeekDownloads: Schema.Number,
+  dependencyCount: Schema.Number,
+  downloadsByWeek: Schema.Array(WeeklyDownloads),
 })
 export type PackageSnapshot = typeof PackageSnapshot.Type
 
-export const DependencyEdge = S.Struct({
+export const DependencyEdge = Schema.Struct({
   source: PackageId,
   target: PackageId,
-  kind: S.Literals(['Dependency', 'PeerDependency']),
+  kind: Schema.Literals(['Dependency', 'PeerDependency']),
 })
 export type DependencyEdge = typeof DependencyEdge.Type
 
-export const ContributorSummary = S.Struct({
-  login: S.String,
-  contributions: S.Number,
-  avatarUrl: S.Option(S.String),
+export const ContributorSummary = Schema.Struct({
+  login: Schema.String,
+  contributions: Schema.Number,
+  avatarUrl: Schema.Option(Schema.String),
 })
 export type ContributorSummary = typeof ContributorSummary.Type
 
-export const RepositorySnapshot = S.Struct({
-  stars: S.Number,
-  forks: S.Number,
-  watchers: S.Number,
-  openIssues: S.Number,
-  openPullRequests: S.Number,
-  visibleContributors: S.Number,
-  pushedAt: S.String,
-  defaultBranch: S.String,
+export const RepositorySnapshot = Schema.Struct({
+  stars: Schema.Number,
+  forks: Schema.Number,
+  watchers: Schema.Number,
+  openIssues: Schema.Number,
+  openPullRequests: Schema.Number,
+  visibleContributors: Schema.Number,
+  pushedAt: Schema.String,
+  defaultBranch: Schema.String,
 })
 export type RepositorySnapshot = typeof RepositorySnapshot.Type
 
-export const Telemetry = S.Struct({
-  fetchedAt: S.Number,
+export const Telemetry = Schema.Struct({
+  fetchedAt: Schema.Number,
   repository: RepositorySnapshot,
-  packages: S.Array(PackageSnapshot),
-  weeks: S.Array(WeeklyTelemetry),
-  dependencyEdges: S.Array(DependencyEdge),
-  topContributors: S.Array(ContributorSummary),
-  warnings: S.Array(S.String),
+  packages: Schema.Array(PackageSnapshot),
+  weeks: Schema.Array(WeeklyTelemetry),
+  dependencyEdges: Schema.Array(DependencyEdge),
+  topContributors: Schema.Array(ContributorSummary),
+  warnings: Schema.Array(Schema.String),
 })
 export type Telemetry = typeof Telemetry.Type
 

package/dist/templates/examples/charting/src/echarts.ts

@@ -13,7 +13,7 @@ import * as echarts from 'echarts/core'
 import { LabelLayout, UniversalTransition } from 'echarts/features'
 import { CanvasRenderer } from 'echarts/renderers'
 import type { EChartsOption } from 'echarts/types/dist/shared'
-import { Array, Match as M, Option, String, pipe } from 'effect'
+import { Array, Match, Option, String, pipe } from 'effect'
 
 import {
   type ChartMode,
@@ -382,11 +382,11 @@ const weekToDatumLabels =
   ]
 
 export const makeChartOption = (args: ChartOptionArgs) =>
-  M.value(args.chartMode).pipe(
-    M.when('Adoption', () => adoptionOption(args)),
-    M.when('Velocity', () => velocityOption(args)),
-    M.when('Ecosystem', () => ecosystemOption(args)),
-    M.exhaustive,
+  Match.value(args.chartMode).pipe(
+    Match.when('Adoption', () => adoptionOption(args)),
+    Match.when('Velocity', () => velocityOption(args)),
+    Match.when('Ecosystem', () => ecosystemOption(args)),
+    Match.exhaustive,
   )
 
 const findDatumLabelById =

package/dist/templates/examples/charting/src/githubApi.ts

@@ -6,8 +6,8 @@ import {
   Layer,
   Number,
   Option,
-  Schema as S,
   Schedule,
+  Schema,
 } from 'effect'
 import { HttpClient, HttpClientRequest } from 'effect/unstable/http'
 
@@ -25,41 +25,41 @@ const RELEASE_PAGE_SIZE = 100
 
 // SCHEMA
 
-export const GitHubRepositoryResponse = S.Struct({
-  stargazers_count: S.Number,
-  forks_count: S.Number,
-  watchers_count: S.Number,
-  open_issues_count: S.Number,
-  pushed_at: S.String,
-  default_branch: S.String,
+export const GitHubRepositoryResponse = Schema.Struct({
+  stargazers_count: Schema.Number,
+  forks_count: Schema.Number,
+  watchers_count: Schema.Number,
+  open_issues_count: Schema.Number,
+  pushed_at: Schema.String,
+  default_branch: Schema.String,
 })
 
-export const GitHubContributorResponse = S.Struct({
-  login: S.String,
-  contributions: S.Number,
-  avatar_url: S.OptionFromOptional(S.String),
+export const GitHubContributorResponse = Schema.Struct({
+  login: Schema.String,
+  contributions: Schema.Number,
+  avatar_url: Schema.OptionFromOptional(Schema.String),
 })
 export type GitHubContributorResponse = typeof GitHubContributorResponse.Type
 
-export const GitHubIssueResponse = S.Struct({
-  pull_request: S.OptionFromOptional(S.Unknown),
+export const GitHubIssueResponse = Schema.Struct({
+  pull_request: Schema.OptionFromOptional(Schema.Unknown),
 })
 
-export const GitHubPullRequestResponse = S.Struct({
-  id: S.Number,
+export const GitHubPullRequestResponse = Schema.Struct({
+  id: Schema.Number,
 })
 
-export const GitHubReleaseResponse = S.Struct({
-  published_at: S.OptionFromOptional(S.String),
+export const GitHubReleaseResponse = Schema.Struct({
+  published_at: Schema.OptionFromOptional(Schema.String),
 })
 
-export const GitHubStargazerResponse = S.Struct({
-  starred_at: S.String,
+export const GitHubStargazerResponse = Schema.Struct({
+  starred_at: Schema.String,
 })
 
-export const GitHubCommitActivityResponse = S.Struct({
-  week: S.Number,
-  total: S.Number,
+export const GitHubCommitActivityResponse = Schema.Struct({
+  week: Schema.Number,
+  total: Schema.Number,
 })
 
 // SERVICE
@@ -104,7 +104,7 @@ class GitHubStatError extends Data.TaggedError('GitHubStatError') {}
 
 const fetchOptionalGitHubStat =
   (client: HttpClient.HttpClient) =>
-  <A, I>(schema: S.Codec<A, I>) =>
+  <A, I>(schema: Schema.Codec<A, I>) =>
   (path: string, label: string): Effect.Effect<GitHubStatResult<A>, never> => {
     const url = `${GITHUB_REPOSITORY_API}${path}`
 
@@ -128,7 +128,7 @@ const fetchOptionalGitHubStat =
       }
 
       const data = yield* response.json.pipe(
-        Effect.flatMap(json => S.decodeUnknownEffect(schema)(json)),
+        Effect.flatMap(json => Schema.decodeUnknownEffect(schema)(json)),
         Effect.option,
       )
 
@@ -178,19 +178,19 @@ export const GitHubApiLive: Layer.Layer<
     const fetchStat_ = fetchOptionalGitHubStat(client)
     return {
       fetchRepository: fetch_(GitHubRepositoryResponse)(GITHUB_REPOSITORY_API),
-      fetchContributors: fetch_(S.Array(GitHubContributorResponse))(
+      fetchContributors: fetch_(Schema.Array(GitHubContributorResponse))(
         makeUrl(`${GITHUB_REPOSITORY_API}/contributors`, {
           per_page: '100',
           anon: 'false',
         }),
       ),
-      fetchIssues: fetch_(S.Array(GitHubIssueResponse))(
+      fetchIssues: fetch_(Schema.Array(GitHubIssueResponse))(
         makeUrl(`${GITHUB_REPOSITORY_API}/issues`, {
           state: 'open',
           per_page: '100',
         }),
       ),
-      fetchPullRequests: fetch_(S.Array(GitHubPullRequestResponse))(
+      fetchPullRequests: fetch_(Schema.Array(GitHubPullRequestResponse))(
         makeUrl(`${GITHUB_REPOSITORY_API}/pulls`, {
           state: 'open',
           per_page: '100',
@@ -198,7 +198,7 @@ export const GitHubApiLive: Layer.Layer<
       ),
       fetchReleases: (yearCutoffMilliseconds: number) => {
         const fetchPage = (page: number) =>
-          fetch_(S.Array(GitHubReleaseResponse))(
+          fetch_(Schema.Array(GitHubReleaseResponse))(
             makeUrl(`${GITHUB_REPOSITORY_API}/releases`, {
               per_page: `${RELEASE_PAGE_SIZE}`,
               page: `${page}`,
@@ -252,7 +252,7 @@ export const GitHubApiLive: Layer.Layer<
         return Effect.forEach(
           Array.range(1, Math.max(1, pageCount)),
           page =>
-            fetch_(S.Array(GitHubStargazerResponse))(
+            fetch_(Schema.Array(GitHubStargazerResponse))(
               makeUrl(`${GITHUB_REPOSITORY_API}/stargazers`, {
                 per_page: `${STARGAZER_PAGE_SIZE}`,
                 page: `${page}`,
@@ -262,10 +262,9 @@ export const GitHubApiLive: Layer.Layer<
           { concurrency: 'unbounded' },
         ).pipe(Effect.map(Array.flatten))
       },
-      fetchCommitActivity: fetchStat_(S.Array(GitHubCommitActivityResponse))(
-        '/stats/commit_activity',
-        'Commit activity',
-      ),
+      fetchCommitActivity: fetchStat_(
+        Schema.Array(GitHubCommitActivityResponse),
+      )('/stats/commit_activity', 'Commit activity'),
     }
   }),
 )

package/dist/templates/examples/charting/src/http.ts

@@ -1,4 +1,4 @@
-import { Effect, Record as Record_, Schema as S } from 'effect'
+import { Effect, Record, Schema } from 'effect'
 import { HttpClient, HttpClientRequest } from 'effect/unstable/http'
 
 // CONSTANT
@@ -16,7 +16,7 @@ export const errorMessage = (error: unknown): string =>
 
 export const makeUrl = (
   url: string,
-  params: Readonly<Record<string, string>>,
+  params: Readonly<globalThis.Record<string, string>>,
 ): string => {
   const searchParams = new URLSearchParams(params)
   return `${url}?${searchParams.toString()}`
@@ -27,10 +27,10 @@ export const encodePackageName = (packageName: string): string =>
 
 export const fetchJson =
   (client: HttpClient.HttpClient) =>
-  <A, I>(schema: S.Codec<A, I>) =>
+  <A, I>(schema: Schema.Codec<A, I>) =>
   (
     url: string,
-    headers: Readonly<Record<string, string>> = Record_.empty(),
+    headers: Readonly<globalThis.Record<string, string>> = Record.empty(),
   ): Effect.Effect<A, Error> =>
     Effect.gen(function* () {
       const request = HttpClientRequest.get(url).pipe(
@@ -44,7 +44,7 @@ export const fetchJson =
         )
       }
 
-      return yield* S.decodeUnknownEffect(schema)(yield* response.json).pipe(
-        Effect.mapError(error => new Error(errorMessage(error))),
-      )
+      return yield* Schema.decodeUnknownEffect(schema)(
+        yield* response.json,
+      ).pipe(Effect.mapError(error => new Error(errorMessage(error))))
     })

package/dist/templates/examples/charting/src/message.ts

@@ -1,4 +1,4 @@
-import { Schema as S } from 'effect'
+import { Schema } from 'effect'
 import { defineMessageUnion } from 'foldkit/message'
 
 import { RadioGroup } from '@foldkit/ui'
@@ -11,13 +11,13 @@ export const Message = defineMessageUnion({
   GotPeriodRadioGroupMessage: { message: RadioGroup.Message },
   ClickedRefresh: {},
   ClickedRetry: {},
-  ClickedChartDatum: { datumId: S.String },
+  ClickedChartDatum: { datumId: Schema.String },
   SucceededFetchTelemetry: { telemetry: Telemetry },
-  FailedFetchTelemetry: { error: S.String },
-  SucceededMountChart: { hostId: S.String },
-  FailedMountChart: { reason: S.String },
+  FailedFetchTelemetry: { error: Schema.String },
+  SucceededMountChart: { hostId: Schema.String },
+  FailedMountChart: { reason: Schema.String },
   SucceededSyncChart: {},
-  FailedSyncChart: { reason: S.String },
+  FailedSyncChart: { reason: Schema.String },
 })
 
 export type Message = typeof Message.Type