create-foldkit-app 0.32.0 → 0.32.1

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

@@ -1,13 +1,13 @@
-import { Schema as S } from 'effect'
+import { Schema } from 'effect'
 import { AsyncData } from 'foldkit'
 
 import { RadioGroup } from '@foldkit/ui'
 
 import { ChartMode, PackageId, Period, Telemetry } from './domain'
 
-export const TelemetryAsyncData = AsyncData.Schema(Telemetry, S.String)
+export const TelemetryAsyncData = AsyncData.Schema(Telemetry, Schema.String)
 
-export const Model = S.Struct({
+export const Model = Schema.Struct({
   telemetry: TelemetryAsyncData.schema,
   chartMode: ChartMode,
   chartModeRadioGroup: RadioGroup.Model,
@@ -15,8 +15,8 @@ export const Model = S.Struct({
   packageRadioGroup: RadioGroup.Model,
   period: Period,
   periodRadioGroup: RadioGroup.Model,
-  maybeChartHostId: S.Option(S.String),
-  maybeChartError: S.Option(S.String),
-  maybeSelectedDatumId: S.Option(S.String),
+  maybeChartHostId: Schema.Option(Schema.String),
+  maybeChartError: Schema.Option(Schema.String),
+  maybeSelectedDatumId: Schema.Option(Schema.String),
 })
 export type Model = typeof Model.Type

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

@@ -1,4 +1,4 @@
-import { Context, Effect, Layer, Schema as S } from 'effect'
+import { Context, Effect, Layer, Schema } from 'effect'
 import { HttpClient } from 'effect/unstable/http'
 
 import type { PackageSpec } from './domain'
@@ -11,27 +11,31 @@ const NPM_REGISTRY_API = 'https://registry.npmjs.org'
 
 // SCHEMA
 
-export const NpmDownloadDay = S.Struct({
-  day: S.String,
-  downloads: S.Number,
+export const NpmDownloadDay = Schema.Struct({
+  day: Schema.String,
+  downloads: Schema.Number,
 })
 
-export const NpmDownloadsResponse = S.Struct({
-  downloads: S.Array(NpmDownloadDay),
+export const NpmDownloadsResponse = Schema.Struct({
+  downloads: Schema.Array(NpmDownloadDay),
 })
 
-export const NpmVersionMetadata = S.Struct({
-  dependencies: S.OptionFromOptional(S.Record(S.String, S.String)),
-  peerDependencies: S.OptionFromOptional(S.Record(S.String, S.String)),
+export const NpmVersionMetadata = Schema.Struct({
+  dependencies: Schema.OptionFromOptional(
+    Schema.Record(Schema.String, Schema.String),
+  ),
+  peerDependencies: Schema.OptionFromOptional(
+    Schema.Record(Schema.String, Schema.String),
+  ),
 })
 export type NpmVersionMetadata = typeof NpmVersionMetadata.Type
 
-export const NpmPackument = S.Struct({
-  name: S.String,
-  time: S.Record(S.String, S.String),
-  versions: S.Record(S.String, NpmVersionMetadata),
-  'dist-tags': S.Struct({
-    latest: S.String,
+export const NpmPackument = Schema.Struct({
+  name: Schema.String,
+  time: Schema.Record(Schema.String, Schema.String),
+  versions: Schema.Record(Schema.String, NpmVersionMetadata),
+  'dist-tags': Schema.Struct({
+    latest: Schema.String,
   }),
 })
 

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

@@ -1,18 +1,18 @@
-import { Effect, Option, Queue, Schema as S, Stream, pipe } from 'effect'
+import { Effect, Option, Queue, Schema, Stream, pipe } from 'effect'
 import { Subscription } from 'foldkit'
 
 import { getChart } from './chartHost'
 import { Message } from './message'
 import type { Model } from './model'
 
-const ChartClickPayload = S.Struct({
-  data: S.OptionFromOptional(S.Struct({ id: S.String })),
+const ChartClickPayload = Schema.Struct({
+  data: Schema.OptionFromOptional(Schema.Struct({ id: Schema.String })),
 })
 
 const chartClickToDatumId = (event: unknown): Option.Option<string> =>
   pipe(
     event,
-    S.decodeUnknownOption(ChartClickPayload),
+    Schema.decodeUnknownOption(ChartClickPayload),
     Option.flatMap(({ data }) => data),
     Option.map(({ id }) => id),
   )
@@ -55,7 +55,7 @@ const chartEvents = (hostId: string): Stream.Stream<Message> =>
 
 export const subscriptions = Subscription.make<Model, Message>()(entry => ({
   chartEvents: entry(
-    { maybeChartHostId: S.Option(S.String) },
+    { maybeChartHostId: Schema.Option(Schema.String) },
     {
       modelToDependencies: model => ({
         maybeChartHostId: model.maybeChartHostId,

package/dist/templates/examples/charting/src/telemetry.test.ts

@@ -1,4 +1,4 @@
-import { Array, Effect, Layer, Match as M, String } from 'effect'
+import { Array, Effect, Layer, Match, String } from 'effect'
 import { HttpClient, HttpClientResponse } from 'effect/unstable/http'
 import { expect, test } from 'vitest'
 
@@ -14,13 +14,16 @@ import { fetchRawTelemetry, transformTelemetry } from './telemetry'
 test('folds public API responses into a Telemetry value', async () => {
   const mockClient = HttpClient.make(request =>
     Effect.sync(() => {
-      const body = M.value(request.url).pipe(
-        M.when(String.includes('/contributors'), () => [
+      const body = Match.value(request.url).pipe(
+        Match.when(String.includes('/contributors'), () => [
           { login: 'devin', contributions: 42 },
         ]),
-        M.when(String.includes('/issues'), () => [{}, { pull_request: {} }]),
-        M.when(String.includes('/pulls'), () => [{ id: 1 }]),
-        M.when(String.includes('/releases'), () => [
+        Match.when(String.includes('/issues'), () => [
+          {},
+          { pull_request: {} },
+        ]),
+        Match.when(String.includes('/pulls'), () => [{ id: 1 }]),
+        Match.when(String.includes('/releases'), () => [
           {
             tag_name: 'v0.115.0',
             published_at: '2026-06-20T12:00:00Z',
@@ -28,18 +31,21 @@ test('folds public API responses into a Telemetry value', async () => {
             draft: false,
           },
         ]),
-        M.when(String.includes('/stargazers'), () => [
+        Match.when(String.includes('/stargazers'), () => [
           { starred_at: '2026-06-15T12:00:00Z' },
         ]),
-        M.when(String.includes('/stats/commit_activity'), () => [
+        Match.when(String.includes('/stats/commit_activity'), () => [
           { week: 1781481600, total: 5 },
         ]),
-        M.when(String.includes('/stats/code_frequency'), () => [
+        Match.when(String.includes('/stats/code_frequency'), () => [
           [1781481600, 120, -35],
         ]),
-        M.when(String.includes('api.npmjs.org'), () => mockNpmDownloads),
-        M.when(String.includes('registry.npmjs.org'), () => mockNpmPackument),
-        M.orElse(() => mockGitHubRepository),
+        Match.when(String.includes('api.npmjs.org'), () => mockNpmDownloads),
+        Match.when(
+          String.includes('registry.npmjs.org'),
+          () => mockNpmPackument,
+        ),
+        Match.orElse(() => mockGitHubRepository),
       )
 
       return HttpClientResponse.fromWeb(

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

@@ -1,12 +1,4 @@
-import {
-  Array,
-  Clock,
-  Effect,
-  Option,
-  Order,
-  Record as Record_,
-  pipe,
-} from 'effect'
+import { Array, Clock, Effect, Option, Order, Record, pipe } from 'effect'
 
 import {
   ContributorSummary,
@@ -109,19 +101,20 @@ const lastWeekDownloads = (
     }),
   )
 
-const recordSize = (record: Readonly<Record<string, string>>): number =>
-  Array.length(Record_.keys(record))
+const recordSize = (
+  record: Readonly<globalThis.Record<string, string>>,
+): number => Array.length(Record.keys(record))
 
 const dependenciesOrEmpty = (
-  maybeDependencies: Option.Option<Readonly<Record<string, string>>>,
-): Readonly<Record<string, string>> =>
-  Option.getOrElse(maybeDependencies, Record_.empty<string, string>)
+  maybeDependencies: Option.Option<Readonly<globalThis.Record<string, string>>>,
+): Readonly<globalThis.Record<string, string>> =>
+  Option.getOrElse(maybeDependencies, Record.empty<string, string>)
 
 const latestMetadata = (
   packument: typeof NpmPackument.Type,
 ): NpmVersionMetadata =>
   Option.getOrElse(
-    Record_.get(packument.versions, packument['dist-tags'].latest),
+    Record.get(packument.versions, packument['dist-tags'].latest),
     () => ({
       dependencies: Option.none(),
       peerDependencies: Option.none(),
@@ -137,7 +130,7 @@ export const dependencyEdgesForPackage = (
 
   const dependencyEdges = Array.map(
     Array.filter(packageSpecs, spec =>
-      Array.contains(Record_.keys(dependencies), spec.npmName),
+      Array.contains(Record.keys(dependencies), spec.npmName),
     ),
     spec =>
       DependencyEdge.make({
@@ -149,7 +142,7 @@ export const dependencyEdgesForPackage = (
 
   const peerDependencyEdges = Array.map(
     Array.filter(packageSpecs, spec =>
-      Array.contains(Record_.keys(peerDependencies), spec.npmName),
+      Array.contains(Record.keys(peerDependencies), spec.npmName),
     ),
     spec =>
       DependencyEdge.make({
@@ -178,7 +171,7 @@ export const packageSnapshotFromResponses = (
   const downloadsByWeek = weeklyDownloads(downloads, weekStarts)
 
   const publishedAt = Option.getOrElse(
-    Record_.get(packument.time, distTags.latest),
+    Record.get(packument.time, distTags.latest),
     () => 'unknown',
   )
   const totalDownloads = Array.reduce(

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

@@ -1,4 +1,4 @@
-import { Array, Match as M, Option, Result, pipe } from 'effect'
+import { Array, Option, Result, pipe } from 'effect'
 import { AsyncData, Command, Update } from 'foldkit'
 import { evo } from 'foldkit/struct'
 
@@ -70,14 +70,12 @@ const selectedControl =
     }
   }
 
-const foldChartModeRadioGroupOutMessage = M.type<
+const foldChartModeRadioGroupOutMessage = RadioGroup.OutMessage.match<
+  Update.Step<Model, Message>,
   RadioGroup.OutMessage<ChartMode>
->().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    Selected: ({ value }) => selectedControl(evo({ chartMode: () => value })),
-  }),
-)
+>({
+  Selected: ({ value }) => selectedControl(evo({ chartMode: () => value })),
+})
 
 const foldChartModeRadioGroup = Update.foldChild({
   update: ChartModeRadioGroup.update,
@@ -89,14 +87,12 @@ const foldChartModeRadioGroup = Update.foldChild({
   foldOutMessage: foldChartModeRadioGroupOutMessage,
 })
 
-const foldPeriodRadioGroupOutMessage = M.type<
+const foldPeriodRadioGroupOutMessage = RadioGroup.OutMessage.match<
+  Update.Step<Model, Message>,
   RadioGroup.OutMessage<Period>
->().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    Selected: ({ value }) => selectedControl(evo({ period: () => value })),
-  }),
-)
+>({
+  Selected: ({ value }) => selectedControl(evo({ period: () => value })),
+})
 
 const foldPeriodRadioGroup = Update.foldChild({
   update: PeriodRadioGroup.update,
@@ -107,15 +103,13 @@ const foldPeriodRadioGroup = Update.foldChild({
   foldOutMessage: foldPeriodRadioGroupOutMessage,
 })
 
-const foldPackageRadioGroupOutMessage = M.type<
+const foldPackageRadioGroupOutMessage = RadioGroup.OutMessage.match<
+  Update.Step<Model, Message>,
   RadioGroup.OutMessage<PackageId>
->().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    Selected: ({ value }) =>
-      selectedControl(evo({ selectedPackageId: () => value })),
-  }),
-)
+>({
+  Selected: ({ value }) =>
+    selectedControl(evo({ selectedPackageId: () => value })),
+})
 
 const foldPackageRadioGroup = Update.foldChild({
   update: PackageRadioGroup.update,

package/dist/templates/examples/charting/src/view/chart.ts

@@ -1,5 +1,5 @@
 import * as echarts from 'echarts/core'
-import { Effect, Option, Schema as S } from 'effect'
+import { Effect, Option, Schema } from 'effect'
 import { Mount } from 'foldkit'
 import type { Html } from 'foldkit/html'
 import { HtmlBuilder } from 'foldkit/html'
@@ -54,7 +54,7 @@ const mountChart = (element: Element, hostId: string) =>
   })
 
 export const MountChart = Mount.define('MountChart', {
-  args: { hostId: S.String },
+  args: { hostId: Schema.String },
   messages: [Message.SucceededMountChart, Message.FailedMountChart],
   execute: ({ element, hostId }) => mountChart(element, hostId),
 })

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

@@ -1,4 +1,4 @@
-import { Schema as S } from 'effect'
+import { Schema } from 'effect'
 import { Runtime, type Update } from 'foldkit'
 import { Document, HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
@@ -8,7 +8,7 @@ import { Button } from '@foldkit/ui'
 
 // MODEL
 
-export const Model = S.Struct({ count: S.Number })
+export const Model = Schema.Struct({ count: Schema.Number })
 export type Model = typeof Model.Type
 
 // MESSAGE

package/dist/templates/examples/counters/src/counter.ts

@@ -1,4 +1,4 @@
-import { Schema as S } from 'effect'
+import { Schema } from 'effect'
 import { Submodel, type Update } from 'foldkit'
 import { defineMessageUnion } from 'foldkit/message'
 import { evo } from 'foldkit/struct'
@@ -7,7 +7,7 @@ import { Button } from '@foldkit/ui'
 
 // MODEL
 
-export const Model = S.Struct({ count: S.Number })
+export const Model = Schema.Struct({ count: Schema.Number })
 export type Model = typeof Model.Type
 
 export const init: Model = { count: 0 }

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

@@ -1,4 +1,4 @@
-import { Array, Option, Schema as S, pipe } from 'effect'
+import { Array, Option, Schema, pipe } from 'effect'
 import { Runtime, Update } from 'foldkit'
 import { Document, Html, HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
@@ -10,15 +10,15 @@ import * as Counter from './counter'
 
 // MODEL
 
-const Row = S.Struct({
-  id: S.String,
+const Row = Schema.Struct({
+  id: Schema.String,
   counter: Counter.Model,
 })
 type Row = typeof Row.Type
 
-export const Model = S.Struct({
-  rows: S.Array(Row),
-  nextRowId: S.Number,
+export const Model = Schema.Struct({
+  rows: Schema.Array(Row),
+  nextRowId: Schema.Number,
 })
 export type Model = typeof Model.Type
 
@@ -26,9 +26,9 @@ export type Model = typeof Model.Type
 
 export const Message = defineMessageUnion({
   ClickedAddRow: {},
-  ClickedRemoveRow: { id: S.String },
+  ClickedRemoveRow: { id: Schema.String },
   GotCounterMessage: {
-    id: S.String,
+    id: Schema.String,
     message: Counter.Message,
   },
 })

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

@@ -1,4 +1,4 @@
-import { Duration, Effect, Schema as S, Stream } from 'effect'
+import { Duration, Effect, Schema, Stream } from 'effect'
 import { Command, Port, Runtime, Subscription, type Update } from 'foldkit'
 import { Html, HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
@@ -8,7 +8,10 @@ import { Button } from '@foldkit/ui'
 
 // MODEL
 
-export const Model = S.Struct({ count: S.Number, step: S.Number })
+export const Model = Schema.Struct({
+  count: Schema.Number,
+  step: Schema.Number,
+})
 export type Model = typeof Model.Type
 
 // MESSAGE
@@ -16,7 +19,7 @@ export type Model = typeof Model.Type
 export const Message = defineMessageUnion({
   Ticked: {},
   ClickedAdvance: {},
-  ChangedStep: { step: S.Number },
+  ChangedStep: { step: Schema.Number },
   CompletedReportCount: {},
 })
 
@@ -25,13 +28,13 @@ export type Message = typeof Message.Type
 // PORT
 
 export const ports = {
-  inbound: { stepChanged: Port.inbound(S.Number) },
-  outbound: { countChanged: Port.outbound(S.Number) },
+  inbound: { stepChanged: Port.inbound(Schema.Number) },
+  outbound: { countChanged: Port.outbound(Schema.Number) },
 }
 
 // INIT
 
-export const Flags = S.Struct({ initialCount: S.Number })
+export const Flags = Schema.Struct({ initialCount: Schema.Number })
 export type Flags = typeof Flags.Type
 
 export const init: Runtime.ElementInit<Model, Message, Flags> = flags => ({
@@ -41,7 +44,7 @@ export const init: Runtime.ElementInit<Model, Message, Flags> = flags => ({
 // COMMAND
 
 export const ReportCount = Command.define('ReportCount', {
-  args: { count: S.Number },
+  args: { count: Schema.Number },
   messages: [Message.CompletedReportCount],
   execute: ({ count }) =>
     Port.emit(ports.outbound.countChanged, count).pipe(

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

@@ -1,5 +1,5 @@
 import clsx from 'clsx'
-import { Array, Duration, Effect, Random, Schema as S } from 'effect'
+import { Array, Duration, Effect, Random, Schema } from 'effect'
 import { Command, FieldValidation, Runtime, type Update } from 'foldkit'
 import {
   Field,
@@ -33,16 +33,16 @@ const emailRules = makeRules({
 const Submission = defineTaggedUnion({
   NotSubmitted: {},
   Submitting: {},
-  SubmitSuccess: { confirmationText: S.String },
-  SubmitError: { error: S.String },
+  SubmitSuccess: { confirmationText: Schema.String },
+  SubmitError: { error: Schema.String },
 })
 
 type Submission = typeof Submission.Type
 
-export const Model = S.Struct({
-  name: Field(S.String),
-  email: Field(S.String),
-  messageText: Field(S.String),
+export const Model = Schema.Struct({
+  name: Field(Schema.String),
+  email: Field(Schema.String),
+  messageText: Field(Schema.String),
   submission: Submission,
 })
 export type Model = typeof Model.Type
@@ -50,12 +50,12 @@ export type Model = typeof Model.Type
 // MESSAGE
 
 export const Message = defineMessageUnion({
-  UpdatedName: { value: S.String },
-  UpdatedEmail: { value: S.String },
-  CompletedValidateEmail: { field: Field(S.String) },
-  UpdatedMessageText: { value: S.String },
+  UpdatedName: { value: Schema.String },
+  UpdatedEmail: { value: Schema.String },
+  CompletedValidateEmail: { field: Field(Schema.String) },
+  UpdatedMessageText: { value: Schema.String },
   ClickedFormSubmit: {},
-  SucceededSubmitForm: { name: S.String },
+  SucceededSubmitForm: { name: Schema.String },
   FailedSubmitForm: {},
 })
 
@@ -89,7 +89,7 @@ const isEmailOnWaitlist = (email: string): Effect.Effect<boolean> =>
   })
 
 export const ValidateEmail = Command.define('ValidateEmail', {
-  args: { email: S.String },
+  args: { email: Schema.String },
   messages: [Message.CompletedValidateEmail],
   execute: ({ email }) =>
     Effect.gen(function* () {
@@ -212,7 +212,11 @@ export const update = (model: Model, message: Message) =>
 const FAKE_API_DELAY_MS = 500
 
 export const SubmitForm = Command.define('SubmitForm', {
-  args: { name: S.String, email: S.String, messageText: S.String },
+  args: {
+    name: Schema.String,
+    email: Schema.String,
+    messageText: Schema.String,
+  },
   messages: [Message.SucceededSubmitForm, Message.FailedSubmitForm],
   execute: ({ name }) =>
     Effect.gen(function* () {

package/dist/templates/examples/generative-art/src/command.ts

@@ -1,4 +1,4 @@
-import { Effect, Option, Random, Schema as S } from 'effect'
+import { Effect, Option, Random, Schema } from 'effect'
 import { Command } from 'foldkit'
 
 import {
@@ -63,7 +63,12 @@ const BURST_INITIAL_SPEED_SCALE_MAX = 2.2
 const BURST_HUE_JITTER_DEGREES = 30
 
 export const GenerateBurstParticle = Command.define('GenerateBurstParticle', {
-  args: { x: S.Number, y: S.Number, angle: S.Number, hueAnchor: S.Number },
+  args: {
+    x: Schema.Number,
+    y: Schema.Number,
+    angle: Schema.Number,
+    hueAnchor: Schema.Number,
+  },
   messages: [Message.CompletedGenerateBurstParticle],
   execute: ({ x, y, angle, hueAnchor }) =>
     Effect.gen(function* () {

package/dist/templates/examples/generative-art/src/message.ts

@@ -1,30 +1,30 @@
-import { Schema as S } from 'effect'
+import { Schema } from 'effect'
 import { defineMessageUnion } from 'foldkit/message'
 
 import { Slider } from '@foldkit/ui'
 
 const generatedParticleFields = {
-  x: S.Number,
-  y: S.Number,
-  baseHue: S.Number,
-  hueDriftPerSecond: S.Number,
-  lifespanMs: S.Number,
-  speed: S.Number,
-  initialAngle: S.Option(S.Number),
-  initialSpeedScale: S.Number,
+  x: Schema.Number,
+  y: Schema.Number,
+  baseHue: Schema.Number,
+  hueDriftPerSecond: Schema.Number,
+  lifespanMs: Schema.Number,
+  speed: Schema.Number,
+  initialAngle: Schema.Option(Schema.Number),
+  initialSpeedScale: Schema.Number,
 }
 
 export const Message = defineMessageUnion({
-  TickedFrame: { deltaTimeMs: S.Number },
+  TickedFrame: { deltaTimeMs: Schema.Number },
   CompletedGenerateAmbientParticle: generatedParticleFields,
   CompletedGenerateBurstParticle: generatedParticleFields,
   PressedCanvas: {
-    x: S.Number,
-    y: S.Number,
+    x: Schema.Number,
+    y: Schema.Number,
   },
   MovedPointer: {
-    x: S.Number,
-    y: S.Number,
+    x: Schema.Number,
+    y: Schema.Number,
   },
   ClickedTogglePlay: {},
   ClickedReset: {},

package/dist/templates/examples/generative-art/src/model.ts

@@ -1,33 +1,33 @@
-import { Schema as S } from 'effect'
+import { Schema } from 'effect'
 
 import { Slider } from '@foldkit/ui'
 
-export const Point = S.Struct({ x: S.Number, y: S.Number })
+export const Point = Schema.Struct({ x: Schema.Number, y: Schema.Number })
 export type Point = typeof Point.Type
 
-export const Particle = S.Struct({
-  id: S.Number,
-  trail: S.Array(Point),
-  baseHue: S.Number,
-  hueDriftPerSecond: S.Number,
-  ageMs: S.Number,
-  lifespanMs: S.Number,
-  speed: S.Number,
-  bornAtSeconds: S.Number,
-  initialAngle: S.Option(S.Number),
-  initialSpeedScale: S.Number,
+export const Particle = Schema.Struct({
+  id: Schema.Number,
+  trail: Schema.Array(Point),
+  baseHue: Schema.Number,
+  hueDriftPerSecond: Schema.Number,
+  ageMs: Schema.Number,
+  lifespanMs: Schema.Number,
+  speed: Schema.Number,
+  bornAtSeconds: Schema.Number,
+  initialAngle: Schema.Option(Schema.Number),
+  initialSpeedScale: Schema.Number,
 })
 export type Particle = typeof Particle.Type
 
-export const Model = S.Struct({
-  particles: S.Array(Particle),
-  nextId: S.Number,
-  elapsedSeconds: S.Number,
-  maybeMousePosition: S.Option(Point),
-  isRunning: S.Boolean,
-  flowStrength: S.Number,
+export const Model = Schema.Struct({
+  particles: Schema.Array(Particle),
+  nextId: Schema.Number,
+  elapsedSeconds: Schema.Number,
+  maybeMousePosition: Schema.Option(Point),
+  isRunning: Schema.Boolean,
+  flowStrength: Schema.Number,
   flowStrengthSlider: Slider.Model,
-  noiseScale: S.Number,
+  noiseScale: Schema.Number,
   noiseScaleSlider: Slider.Model,
 })
 export type Model = typeof Model.Type