@playfast/reform 1.1.1 → 1.2.1

package/src/calc/calcFamily.test.ts

@@ -1,8 +1,8 @@
 import { expect, it } from '@effect/vitest'
-import { Context, Duration, Effect, Exit, Layer, Schema as S, Scope } from 'effect'
+import { Context, Effect, Exit, Layer, Schema as S, Scope } from 'effect'
 import { CalcFamily, State, StateGroup } from '../index'
+import { flush } from '../testkit/flight.testkit'
 
-const tick = Effect.sleep(Duration.millis(1))
 
 const Board = S.Record({ key: S.String, value: S.Number })
 
@@ -33,7 +33,7 @@ it.live('a member derives from the shared inputs and recomputes when they change
     expect(yield* CalcFamily.read(Slice, 'b')).toBe(10)
 
     feed.set({ a: 2, b: 10 })
-    yield* tick
+    yield* flush()
     expect(yield* CalcFamily.read(Slice, 'a')).toBe(2)
   }).pipe(Effect.provide(TestLayer))
 })
@@ -55,28 +55,88 @@ it.live('a member only notifies when its own slice of the projection moves', ()
     })
 
     feed.set({ a: 2, b: 10 })
-    yield* tick
+    yield* flush()
     expect(wakes).toEqual({ a: 1, b: 0 })
 
     feed.set({ a: 2, b: 11 })
-    yield* tick
+    yield* flush()
     expect(wakes).toEqual({ a: 1, b: 1 })
   }).pipe(Effect.provide(TestLayer))
 })
 
-it.live('reading does not recompute while the shared inputs are unchanged (memoized per member)', () => {
-  const { Inputs, Slice, SliceLive, runs } = fixture()
-  const TestLayer = SliceLive.pipe(
-    Layer.provideMerge(StateGroup.live(Inputs, { feed: { a: 1 } })),
+const reuseFixture = () => {
+  class Feed extends State.make('reuse-feed', Board) {}
+  class Revision extends State.make('reuse-revision', S.Number) {}
+  class Inputs extends StateGroup.make(Feed, Revision) {}
+  class Presentation extends CalcFamily.make('ReusePresentation', {
+    key: S.String,
+    inputs: [StateGroup.select(Inputs, 'reuse-feed'), StateGroup.select(Inputs, 'reuse-revision')],
+    output: S.Struct({ nested: S.Array(S.Struct({ value: S.Number })) }),
+  }) {}
+  const PresentationLive = CalcFamily.live(
+    Presentation,
+    (key) =>
+      ({ 'reuse-feed': feed }) => ({
+        nested: [{ value: feed[key] ?? 0 }],
+      }),
+    { reuse: true },
+  )
+  return { Inputs, Presentation, PresentationLive }
+}
+
+it.live('reuse preserves each member output when equal and replaces it when changed', () => {
+  const { Inputs, Presentation, PresentationLive } = reuseFixture()
+  const TestLayer = PresentationLive.pipe(
+    Layer.provideMerge(
+      StateGroup.live(Inputs, { 'reuse-feed': { a: 1, b: 1 }, 'reuse-revision': 0 }),
+    ),
   )
   return Effect.gen(function* () {
-    yield* CalcFamily.read(Slice, 'a')
-    yield* CalcFamily.read(Slice, 'a')
-    yield* CalcFamily.read(Slice, 'a')
-    expect(runs.get('a')).toBe(1)
+    const feed = yield* StateGroup.select(Inputs, 'reuse-feed').store
+    const revision = yield* StateGroup.select(Inputs, 'reuse-revision').store
+    const family = yield* Presentation.store
+    const initialA = family.at('a').get()
+    const initialB = family.at('b').get()
+    const wakes = { a: 0, b: 0 }
+    family.at('a').subscribe(() => {
+      wakes.a += 1
+    })
+    family.at('b').subscribe(() => {
+      wakes.b += 1
+    })
+
+    expect(Object.is(initialA.nested, initialB.nested)).toBe(false)
+    revision.set(1)
+    yield* flush()
+    expect(Object.is(family.at('a').get().nested, initialA.nested)).toBe(true)
+    expect(Object.is(family.at('b').get().nested, initialB.nested)).toBe(true)
+    expect(wakes).toEqual({ a: 0, b: 0 })
+
+    feed.set({ a: 2, b: 1 })
+    yield* flush()
+    expect(family.at('a').get().nested).toEqual([{ value: 2 }])
+    expect(Object.is(family.at('a').get().nested, initialA.nested)).toBe(false)
+    expect(Object.is(family.at('b').get().nested, initialB.nested)).toBe(true)
+    expect(wakes).toEqual({ a: 1, b: 0 })
   }).pipe(Effect.provide(TestLayer))
 })
 
+it.live(
+  'reading does not recompute while the shared inputs are unchanged (memoized per member)',
+  () => {
+    const { Inputs, Slice, SliceLive, runs } = fixture()
+    const TestLayer = SliceLive.pipe(
+      Layer.provideMerge(StateGroup.live(Inputs, { feed: { a: 1 } })),
+    )
+    return Effect.gen(function* () {
+      yield* CalcFamily.read(Slice, 'a')
+      yield* CalcFamily.read(Slice, 'a')
+      yield* CalcFamily.read(Slice, 'a')
+      expect(runs.get('a')).toBe(1)
+    }).pipe(Effect.provide(TestLayer))
+  },
+)
+
 it.live('invalidateBy: shared-input churn outside the key recomputes no member', () => {
   class Feed extends State.make('feed', Board) {}
   class Noise extends State.make('noise', S.Number) {}
@@ -89,10 +149,11 @@ it.live('invalidateBy: shared-input churn outside the key recomputes no member',
   }) {}
   const SliceLive = CalcFamily.live(
     Slice,
-    (key) => ({ feed }) => {
-      runs.set(key, (runs.get(key) ?? 0) + 1)
-      return feed[key] ?? 0
-    },
+    (key) =>
+      ({ feed }) => {
+        runs.set(key, (runs.get(key) ?? 0) + 1)
+        return feed[key] ?? 0
+      },
     { invalidateBy: ({ feed }) => [feed] },
   )
   const TestLayer = SliceLive.pipe(
@@ -104,7 +165,7 @@ it.live('invalidateBy: shared-input churn outside the key recomputes no member',
     expect(runs.get('a')).toBe(1)
 
     noise.set(99)
-    yield* tick
+    yield* flush()
     expect(yield* CalcFamily.read(Slice, 'a')).toBe(1)
     expect(runs.get('a')).toBe(1)
   }).pipe(Effect.provide(TestLayer))
@@ -112,9 +173,7 @@ it.live('invalidateBy: shared-input churn outside the key recomputes no member',
 
 it.live('forget releases the member and its upstream subscription', () => {
   const { Inputs, Slice, SliceLive, runs } = fixture()
-  const TestLayer = SliceLive.pipe(
-    Layer.provideMerge(StateGroup.live(Inputs, { feed: { a: 1 } })),
-  )
+  const TestLayer = SliceLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { feed: { a: 1 } })))
   return Effect.gen(function* () {
     const feed = yield* StateGroup.select(Inputs, 'feed').store
     const family = yield* Slice.store
@@ -125,7 +184,7 @@ it.live('forget releases the member and its upstream subscription', () => {
     expect(family.size()).toBe(0)
     const before = runs.get('a') ?? 0
     feed.set({ a: 2 })
-    yield* tick
+    yield* flush()
     expect(runs.get('a') ?? 0).toBe(before)
 
     expect(family.at('a').get()).toBe(2)
@@ -143,15 +202,14 @@ it.live('evictWhenUnused: an idle member is dropped on the next microtask and un
   }) {}
   const SliceLive = CalcFamily.live(
     Slice,
-    (key) => ({ feed }) => {
-      runs.set(key, (runs.get(key) ?? 0) + 1)
-      return feed[key] ?? 0
-    },
+    (key) =>
+      ({ feed }) => {
+        runs.set(key, (runs.get(key) ?? 0) + 1)
+        return feed[key] ?? 0
+      },
     { evictWhenUnused: true },
   )
-  const TestLayer = SliceLive.pipe(
-    Layer.provideMerge(StateGroup.live(Inputs, { feed: { a: 1 } })),
-  )
+  const TestLayer = SliceLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { feed: { a: 1 } })))
   return Effect.gen(function* () {
     const feed = yield* StateGroup.select(Inputs, 'feed').store
     const family = yield* Slice.store
@@ -159,11 +217,11 @@ it.live('evictWhenUnused: an idle member is dropped on the next microtask and un
     expect(family.size()).toBe(1)
 
     off()
-    yield* tick
+    yield* flush()
     expect(family.size()).toBe(0)
     const before = runs.get('a') ?? 0
     feed.set({ a: 2 })
-    yield* tick
+    yield* flush()
     expect(runs.get('a') ?? 0).toBe(before)
   }).pipe(Effect.provide(TestLayer))
 })
@@ -187,7 +245,7 @@ it.live('the layer finalizer clears every member (no live subscriptions leak)',
       expect(family.size()).toBe(0)
       const before = [runs.get('a') ?? 0, runs.get('b') ?? 0]
       feed.set({ a: 9, b: 9 })
-      yield* tick
+      yield* flush()
       expect([runs.get('a') ?? 0, runs.get('b') ?? 0]).toEqual(before)
     }),
   )

package/src/calc/calcFamily.ts

@@ -1,4 +1,4 @@
-import { Context, Effect, Layer, MutableRef } from 'effect'
+import { Context, Effect, Layer, MutableRef, type Schema } from 'effect'
 import { type Manifest, definitionClass } from '../definition/definition'
 import {
   type InputsObject,
@@ -9,45 +9,70 @@ import {
 } from '../internal/sources'
 import { resolveScheduler } from '../internal/scheduler'
 import { resolveInstrumentation, stateUpdateHook } from '../runtime/instrumentation'
+import { reuse } from '../internal/reuse'
 import { makeDerivedStore, type Store } from '../internal/store'
 import { readTracked } from '../internal/track'
 import { type FamilyOptions, type FamilyStore } from '../state/stateFamily'
 import { type AnySource } from '../state/token'
-import type { AnySchema } from '../internal/variance'
 
-export interface CalcFamilyManifest<N extends string, K, Out> extends Manifest {
+export interface CalcFamilySchemaReflection {
+  readonly ast: Schema.Schema<unknown, unknown, unknown>['ast']
+}
+
+export interface CalcFamilyManifest<N extends string> extends Manifest {
   readonly kind: 'CalcFamily'
   readonly name: N
-  readonly key: AnySchema<K>
-  readonly output: AnySchema<Out>
+  readonly key: CalcFamilySchemaReflection
+  readonly output: CalcFamilySchemaReflection
+}
+
+export const CalcFamilyStoreTypeId: unique symbol = Symbol.for('reform/CalcFamilyStore')
+export type CalcFamilyStoreTypeId = typeof CalcFamilyStoreTypeId
+
+export interface CalcFamilyStore<N extends string, in out K, in out Out> extends FamilyStore<
+  K,
+  Out
+> {
+  readonly [CalcFamilyStoreTypeId]: N
 }
 
 export interface CalcFamilyClass<
-  out N extends string,
-  out Inputs extends ReadonlyArray<AnySource>,
-  in out K,
-  in out Out,
+  N extends string,
+  Inputs extends ReadonlyArray<AnySource>,
+  K,
+  Out,
 > {
   new (): { readonly Key: K }
-  readonly manifest: CalcFamilyManifest<N, K, Out>
-  readonly store: Context.Tag<FamilyStore<K, Out>, FamilyStore<K, Out>>
+  readonly manifest: CalcFamilyManifest<N>
+  readonly store: Context.Tag<CalcFamilyStore<N, K, Out>, FamilyStore<K, Out>>
   readonly inputs: Inputs
 }
 
-export interface CalcFamilyConfig<Inputs extends ReadonlyArray<AnySource>, K, Out> {
-  readonly key: AnySchema<K>
+export interface CalcFamilyConfig<
+  Inputs extends ReadonlyArray<AnySource>,
+  KeySchema extends Schema.Schema.AnyNoContext,
+  OutputSchema extends Schema.Schema.AnyNoContext,
+> {
+  readonly key: KeySchema
   readonly inputs: Inputs
-  readonly output: AnySchema<Out>
+  readonly output: OutputSchema
 }
 
-export const make = <const N extends string, const Inputs extends ReadonlyArray<AnySource>, K, Out>(
+export const make = <
+  const N extends string,
+  const Inputs extends ReadonlyArray<AnySource>,
+  KeySchema extends Schema.Schema.AnyNoContext,
+  OutputSchema extends Schema.Schema.AnyNoContext,
+>(
   name: N,
-  config: CalcFamilyConfig<Inputs, K, Out>,
-): CalcFamilyClass<N, Inputs, K, Out> => {
-  const store = Context.GenericTag<FamilyStore<K, Out>, FamilyStore<K, Out>>(
+  config: CalcFamilyConfig<Inputs, KeySchema, OutputSchema>,
+): CalcFamilyClass<N, Inputs, Schema.Schema.Type<KeySchema>, Schema.Schema.Type<OutputSchema>> => {
+  type K = Schema.Schema.Type<KeySchema>
+  type Out = Schema.Schema.Type<OutputSchema>
+  const store = Context.GenericTag<CalcFamilyStore<N, K, Out>, FamilyStore<K, Out>>(
     `reform/calcFamily/${name}`,
   )
-  const manifest: CalcFamilyManifest<N, K, Out> = {
+  const manifest: CalcFamilyManifest<N> = {
     kind: 'CalcFamily',
     name,
     key: config.key,
@@ -63,19 +88,21 @@ export const make = <const N extends string, const Inputs extends ReadonlyArray<
 export const read = <N extends string, Inputs extends ReadonlyArray<AnySource>, K, Out>(
   family: CalcFamilyClass<N, Inputs, K, Out>,
   key: K,
-): Effect.Effect<Out, never, FamilyStore<K, Out>> =>
+): Effect.Effect<Out, never, CalcFamilyStore<N, K, Out>> =>
   Effect.flatMap(family.store, (familyStore) => readTracked(familyStore.at(key)))
 
-export interface CalcFamilyLiveOptionsExternalApi<Inputs extends ReadonlyArray<AnySource>>
-  extends FamilyOptions {
+export interface CalcFamilyLiveOptionsExternalApi<
+  Inputs extends ReadonlyArray<AnySource>,
+> extends FamilyOptions {
   readonly invalidateBy?: InvalidateBy<Inputs>
+  readonly reuse?: boolean
 }
 
 export const live = <N extends string, Inputs extends ReadonlyArray<AnySource>, K, Out>(
   family: CalcFamilyClass<N, Inputs, K, Out>,
   compute: (key: K) => (inputs: InputsObject<Inputs>) => Out,
   options: CalcFamilyLiveOptionsExternalApi<Inputs> = {},
-): Layer.Layer<FamilyStore<K, Out>, never, InputStores<Inputs>> =>
+): Layer.Layer<CalcFamilyStore<N, K, Out>, never, InputStores<Inputs>> =>
   Layer.scoped(
     family.store,
     Effect.gen(function* () {
@@ -96,7 +123,9 @@ export const live = <N extends string, Inputs extends ReadonlyArray<AnySource>,
         subscribers.delete(key)
       }
 
-      const createMember = (key: K): { readonly store: Store<Out>; readonly unsubscribe: () => void } => {
+      const createMember = (
+        key: K,
+      ): { readonly store: Store<Out>; readonly unsubscribe: () => void } => {
         const body = compute(key)
         const memo = MutableRef.make<
           { readonly key: ReadonlyArray<unknown>; readonly output: Out } | undefined
@@ -109,7 +138,9 @@ export const live = <N extends string, Inputs extends ReadonlyArray<AnySource>,
             return prev.output
           }
           const end = instrumentation.calcRecomputed(family.manifest.name)
-          const output = body(args)
+          const fresh = body(args)
+          const output =
+            options.reuse === true && prev !== undefined ? reuse(prev.output, fresh) : fresh
           end()
           MutableRef.set(memo, { key: memoKey, output })
           return output

package/src/calc/compose.ts

@@ -13,20 +13,7 @@ export function composeCalcs<LOut, LErr, LIn, AOut, AErr, AIn, BOut, BErr, BIn>(
   LErr | AErr | BErr,
   BIn | Exclude<AIn | Exclude<LIn, AOut>, BOut>
 >
-export function composeCalcs<
-  LOut,
-  LErr,
-  LIn,
-  AOut,
-  AErr,
-  AIn,
-  BOut,
-  BErr,
-  BIn,
-  COut,
-  CErr,
-  CIn,
->(
+export function composeCalcs<LOut, LErr, LIn, AOut, AErr, AIn, BOut, BErr, BIn, COut, CErr, CIn>(
   leaf: Layer.Layer<LOut, LErr, LIn>,
   upstream1: Layer.Layer<AOut, AErr, AIn>,
   upstream2: Layer.Layer<BOut, BErr, BIn>,

package/src/channel/channel.ts

@@ -1,14 +1,27 @@
-import { Chunk, Context, Duration, Effect, Exit, Layer, Match, Option, Queue, Scope, Stream } from 'effect'
+import {
+  Chunk,
+  Context,
+  Duration,
+  Effect,
+  Exit,
+  Layer,
+  Match,
+  Option,
+  Queue,
+  Scope,
+  Stream,
+} from 'effect'
 import { type Manifest, definitionClass } from '../definition/definition'
 import type { Tagged } from '../runtime/bus'
 import { resolveInstrumentation } from '../runtime/instrumentation'
-import { type ProcedureEntry, Procedures } from './procedureRegistry'
+import { type ProcedureEntry, Procedures } from './procedures'
+
 export {
   type ProcedureEntry,
   type ProcedureRegistry,
   Procedures,
   proceduresLayer,
-} from './procedureRegistry'
+} from './procedures'
 
 export type ChannelPolicy =
   | { readonly _tag: 'merge' }
@@ -53,7 +66,9 @@ const ChannelsBase: Context.TagClass<
 > = Context.Tag('reform/Channels')<Channels, { readonly byName: Map<string, ChannelRuntime> }>()
 export class Channels extends ChannelsBase {}
 
-export const channelsLayer: Layer.Layer<Channels> = Layer.sync(Channels, () => ({ byName: new Map() }))
+export const channelsLayer: Layer.Layer<Channels> = Layer.sync(Channels, () => ({
+  byName: new Map(),
+}))
 
 export const make = (name: string, config: ChannelConfig): ChannelClass =>
   definitionClass<ChannelClass>({
@@ -155,9 +170,13 @@ export const live = (channel: ChannelClass): Layer.Layer<never, never, Channels
 
       const events = Stream.fromQueue(queue)
       const driven: Stream.Stream<unknown> = Match.value(channel.policy).pipe(
-        Match.tag('merge', () => Stream.mapEffect(events, runMatching, { concurrency: 'unbounded' })),
+        Match.tag('merge', () =>
+          Stream.mapEffect(events, runMatching, { concurrency: 'unbounded' }),
+        ),
         Match.tag('latest', () =>
-          Stream.flatMap(events, (event) => Stream.fromEffect(runMatching(event)), { switch: true }),
+          Stream.flatMap(events, (event) => Stream.fromEffect(runMatching(event)), {
+            switch: true,
+          }),
         ),
         Match.tag('debounce', (policy) =>
           events.pipe(

package/src/channel/{procedureRegistry.ts → procedures.ts}

@@ -1,4 +1,5 @@
-import { Context, Effect, Layer } from 'effect'
+import { Context, type Effect, Layer, Option } from 'effect'
+import { makeBucketCache } from '../internal/bucketCache'
 import type { Tagged } from '../runtime/bus'
 
 export interface ProcedureEntry {
@@ -10,9 +11,11 @@ export interface ProcedureEntry {
 
 export interface ProcedureRegistry {
   readonly entries: Array<ProcedureEntry>
-  readonly byTag: Map<string, Array<ProcedureEntry>>
-  readonly channelsByTag: Map<string, Array<string>>
-  readonly byChannelTag: Map<string, Map<string, Array<ProcedureEntry>>>
+  readonly byName: Map<string, Set<ProcedureEntry>>
+  readonly byTag: Map<string, Set<ProcedureEntry>>
+  readonly channelsByTag: Map<string, Set<string>>
+  readonly channelsFor: (tag: string) => ReadonlyArray<string>
+  readonly byChannelTag: Map<string, Map<string, Set<ProcedureEntry>>>
   readonly register: (entry: ProcedureEntry) => void
   readonly unregister: (entry: ProcedureEntry) => void
 }
@@ -31,45 +34,56 @@ const getOrCreate = <K, V>(map: Map<K, V>, key: K, make: () => V): V => {
   return created
 }
 
-const dropFrom = <K, T>(map: Map<K, Array<T>>, key: K, target: T): void => {
+const dropFrom = <K, T>(map: Map<K, Set<T>>, key: K, target: T): void => {
   const bucket = map.get(key)
   if (bucket === undefined) {
     return
   }
-  const next = bucket.filter((candidate) => candidate !== target)
-  if (next.length === 0) {
+  bucket.delete(target)
+  if (bucket.size === 0) {
     map.delete(key)
-  } else {
-    map.set(key, next)
   }
 }
 
 const makeProcedureRegistry = (): ProcedureRegistry => {
-  const state: { entries: Array<ProcedureEntry> } = { entries: [] }
-  const byTag = new Map<string, Array<ProcedureEntry>>()
-  const channelsByTag = new Map<string, Array<string>>()
-  const byChannelTag = new Map<string, Map<string, Array<ProcedureEntry>>>()
+  const entries = new Set<ProcedureEntry>()
+  const byName = new Map<string, Set<ProcedureEntry>>()
+  const byTag = new Map<string, Set<ProcedureEntry>>()
+  const channelsByTag = new Map<string, Set<string>>()
+  const channelsFor = makeBucketCache(channelsByTag)
+  const byChannelTag = new Map<string, Map<string, Set<ProcedureEntry>>>()
+  const snapshot: { value: Option.Option<Array<ProcedureEntry>> } = {
+    value: Option.some([]),
+  }
   return {
     get entries() {
-      return state.entries
+      return Option.getOrElse(snapshot.value, () => {
+        const current = Array.from(entries)
+        snapshot.value = Option.some(current)
+        return current
+      })
     },
+    byName,
     byTag,
     channelsByTag,
+    channelsFor: channelsFor.read,
     byChannelTag,
     register: (entry) => {
-      state.entries = [...state.entries, entry]
+      entries.add(entry)
+      snapshot.value = Option.none()
+      getOrCreate(byName, entry.name, () => new Set()).add(entry)
       entry.handles.forEach((tag) => {
-        byTag.set(tag, [...getOrCreate(byTag, tag, () => []), entry])
-        const channels = getOrCreate(channelsByTag, tag, () => [])
-        if (!channels.includes(entry.channelName)) {
-          channelsByTag.set(tag, [...channels, entry.channelName])
-        }
+        getOrCreate(byTag, tag, () => new Set()).add(entry)
+        getOrCreate(channelsByTag, tag, () => new Set()).add(entry.channelName)
+        channelsFor.invalidate(tag)
         const channelMap = getOrCreate(byChannelTag, entry.channelName, () => new Map())
-        channelMap.set(tag, [...getOrCreate(channelMap, tag, () => []), entry])
+        getOrCreate(channelMap, tag, () => new Set()).add(entry)
       })
     },
     unregister: (entry) => {
-      state.entries = state.entries.filter((existing) => existing !== entry)
+      entries.delete(entry)
+      snapshot.value = Option.none()
+      dropFrom(byName, entry.name, entry)
       entry.handles.forEach((tag) => {
         dropFrom(byTag, tag, entry)
         const channelMap = byChannelTag.get(entry.channelName)
@@ -77,6 +91,7 @@ const makeProcedureRegistry = (): ProcedureRegistry => {
           dropFrom(channelMap, tag, entry)
           if (channelMap.get(tag) === undefined) {
             dropFrom(channelsByTag, tag, entry.channelName)
+            channelsFor.invalidate(tag)
           }
           if (channelMap.size === 0) {
             byChannelTag.delete(entry.channelName)
@@ -87,4 +102,7 @@ const makeProcedureRegistry = (): ProcedureRegistry => {
   }
 }
 
-export const proceduresLayer: Layer.Layer<Procedures> = Layer.sync(Procedures, makeProcedureRegistry)
+export const proceduresLayer: Layer.Layer<Procedures> = Layer.sync(
+  Procedures,
+  makeProcedureRegistry,
+)

package/src/compose/composition.test.ts

@@ -0,0 +1,19 @@
+import { Option, Schema } from 'effect'
+import { expect, it } from '@effect/vitest'
+import { make } from './composition'
+import { ui } from './ui'
+
+class ItemUi extends ui('composition.parser.ItemUi')<{
+  props: { readonly label: string }
+}>() {}
+
+class Item extends make('composition.parser.Item', {
+  title: 'Item',
+  props: Schema.Struct({ label: Schema.String }),
+  ui: ItemUi,
+})<Item>() {}
+
+it('validates reflected props against the composition schema', () => {
+  expect(Item.parseProps({ label: 'ready' })).toEqual(Option.some({ label: 'ready' }))
+  expect(Option.isNone(Item.parseProps({ label: 1 }))).toBe(true)
+})