@playfast/reform 0.1.0 → 1.1.1

package/src/definition/definition.ts

@@ -1,14 +1,9 @@
 import { Effect } from 'effect'
 import { attachInspectable } from '../internal/inspect'
 
-/** A definition's `toJSON`: its reflectable manifest, else its raw statics. */
 const describe = (statics: object): unknown =>
   ('manifest' in statics ? Reflect.get(statics, 'manifest') : undefined) ?? statics
 
-/**
- * The reflectable descriptor every primitive carries (principle #6). The editor
- * and proof packages read these without running any logic.
- */
 export type Kind =
   | 'State'
   | 'StateGroup'
@@ -35,49 +30,22 @@ export interface Manifest {
   readonly name: string
 }
 
-/**
- * Build a class whose *static* side is itself an Effect, so `yield* TheClass`
- * runs `read` and returns its value (the same mechanism `Context.Tag` uses).
- * Subclasses inherit the protocol through the prototype chain, so the user's
- * `class FeedState extends State.make(...) {}` is yieldable too.
- *
- * `statics` (manifest, `.live`, tag, …) are attached as own properties
- * and likewise inherited by the subclass.
- */
 export const yieldableClass = <A, E, R, Statics extends object>(
   read: Effect.Effect<A, E, R>,
   statics: Statics,
 ): { new (): {} } & Effect.Effect<A, E, R> & Statics => {
   class Base {}
   Object.setPrototypeOf(Base, read)
-  // `defineProperty` over `Reflect.ownKeys`, not `Object.assign` over
-  // `Object.entries`: a static can shadow a non-writable own property of the
-  // class function (notably `name`, which a `Source`-shaped definition like a
-  // Calc carries) and `assign` would throw on those; and `ownKeys` (unlike
-  // `entries`) carries symbol-keyed statics — the `TypeId` brands.
   Reflect.ownKeys(statics).forEach((key) => {
     const staticValue = Reflect.get(statics, key)
     Object.defineProperty(Base, key, { value: staticValue, writable: true, enumerable: true, configurable: true })
   })
-  // Print like an Effect value (the manifest), not `[object Object]`.
   attachInspectable(Base, () => describe(statics))
   // oxlint-disable-next-line reform-rules/no-type-assertion -- phantom-shaped static side cannot structurally satisfy the yieldable Effect & Statics type
   return Base as never
 }
 
-/**
- * Build a *definition class*: an empty constructible carrying static marker data
- * (manifest, tag, policy, members, …) that the editor and proof packages reflect
- * on. Definition interfaces declare phantom, type-only fields — a composition's
- * `Props`, a family instance's `Key` — that exist purely for inference and have
- * no runtime value, so the assembled object cannot *structurally* satisfy the
- * interface. The one assertion to `Class` lives here, documented, instead of a
- * scattered `as never` / `as unknown as` at every `*.make`.
- */
 export const definitionClass = <Class>(statics: object): Class => {
-  // `defineProperty` over `Reflect.ownKeys`, not `Object.assign`: a static can
-  // shadow a non-writable own property of the class function (notably `name`)
-  // and `assign` would throw, and `ownKeys` carries the symbol-keyed `TypeId`.
   const Base = class {}
   Reflect.ownKeys(statics).forEach((key) => {
     const staticValue = Reflect.get(statics, key)

package/src/event/event.test.ts

@@ -2,9 +2,6 @@ import { expect, test } from 'vitest'
 import { Schema as S } from 'effect'
 import { Event } from '../index'
 
-// An event is a pure data fact: `Event.construct` builds the tagged value the
-// bus carries, and the class carries the reflectable `manifest` + `tag`.
-
 test('Event.construct builds the tagged value `{ _tag, ...payload }`', () => {
   class Added extends Event.make('Added', S.Struct({ id: S.String })) {}
   expect(Event.construct(Added, { id: 'x' })).toEqual({ _tag: 'Added', id: 'x' })

package/src/event/event.ts

@@ -1,42 +1,36 @@
-import { Effect, PubSub, Runtime, type Schema } from 'effect'
+import { Effect, PubSub, Runtime } from 'effect'
 import { type Manifest, definitionClass } from '../definition/definition'
 import { Bus, publish, type Tagged } from '../runtime/bus'
 import type { Trigger } from '../ui/trigger'
+import type { AnySchema, AnyValue } from '../internal/variance'
 
-/** The dispatched value of an event: `{ _tag, ...payload }`, matched with `Match.tags`. */
 export type EventOf<N extends string, P> = Tagged & { readonly _tag: N } & P
 
 export interface EventManifest<N extends string, P> extends Manifest {
   readonly kind: 'Event'
   readonly name: N
-  readonly schema: Schema.Schema<P, any>
+  readonly schema: AnySchema<P>
 }
 
 export interface EventClass<out N extends string, in out P> {
   new (): {}
   readonly manifest: EventManifest<N, P>
   readonly tag: N
-  /** Carrier for `Event.construct` — builds the tagged value `{ _tag, ...payload }`. */
   readonly build: (payload: P) => EventOf<N, P>
-  /** Carrier for `Event.trigger` — the UI callback effect (High priority). */
   readonly trigger: Effect.Effect<Trigger<P>, never, Bus>
 }
 
-export type AnyEvent = EventClass<string, any>
+export type AnyEvent = EventClass<string, AnyValue>
 export type EventType<E> = E extends EventClass<infer N, infer P> ? EventOf<N, P> : never
 
-/** A pure data fact. Events depend on nothing — only reducers tie them to state. */
 export const make = <const N extends string, P>(
   name: N,
-  schema: Schema.Schema<P, any>,
+  schema: AnySchema<P>,
 ): EventClass<N, P> => {
   const build = (payload: P): EventOf<N, P> => ({ _tag: name, ...payload })
   const trigger = Effect.gen(function* () {
     const bus = yield* Bus
     const runtime = yield* Effect.runtime<never>()
-    // Dispatch synchronously: on the unbounded bus `publish` only enqueues and
-    // returns, so `runSync` never suspends and no fiber is forked per UI event.
-    // The drain loop still folds reducers on its own fiber — publish is pure offer.
     return (payload: P) => {
       Runtime.runSync(runtime)(PubSub.publish(bus, { priority: 'High', event: build(payload) }))
     }
@@ -49,17 +43,14 @@ export const make = <const N extends string, P>(
   })
 }
 
-/** Construct the tagged value for an event (used for `boot` events). */
 export const construct = <N extends string, P>(event: EventClass<N, P>, payload: P): EventOf<N, P> =>
   event.build(payload)
 
-/** Dispatch as a follow-up (Normal priority) from a procedure/effect. */
 export const dispatch = <N extends string, P>(
   event: EventClass<N, P>,
   payload: P,
 ): Effect.Effect<void, never, Bus> => publish('Normal', event.build(payload))
 
-/** A callback for the UI that dispatches at High priority via the runtime. */
 export const trigger = <N extends string, P>(
   event: EventClass<N, P>,
 ): Effect.Effect<Trigger<P>, never, Bus> => event.trigger

package/src/event/eventGroup.ts

@@ -7,7 +7,6 @@ export interface EventGroupClass<Members extends ReadonlyArray<AnyEvent>> {
   readonly members: Members
 }
 
-/** Compose events into a group, the same variadic shape as `StateGroup`/`RpcGroup`. */
 export const make = <const Members extends ReadonlyArray<AnyEvent>>(
   ...members: Members
 ): EventGroupClass<Members> =>

package/src/feature/feature.mount.test.ts

@@ -1,33 +1,41 @@
-import { type Cause, Duration, Effect, Exit, Layer, ManagedRuntime, Scope } from 'effect'
-import { Schema as S } from 'effect'
-import { expect, test } from 'vitest'
-import * as Composition from '../compose/composition'
-import { ui } from '../compose/ui'
-import * as Event from '../event/event'
-import * as Reducer from '../reducer/reducer'
-import * as State from '../state/state'
-import { publish } from '../runtime/bus'
-import { Engine, Reducers } from '../runtime/loop'
-import * as Feature from './feature'
-import { type EngineServices, featureModule, mountFeature } from './feature'
+import { type Cause, Duration, Effect, Exit, Layer, Scope } from "effect";
+import { Schema as S } from "effect";
+import { expect, it } from "@effect/vitest";
+import * as Composition from "../compose/composition";
+import { ui } from "../compose/ui";
+import * as Event from "../event/event";
+import * as Reducer from "../reducer/reducer";
+import * as State from "../state/state";
+import { publish } from "../runtime/bus";
+import { Engine, Reducers } from "../runtime/loop";
+import * as Feature from "./feature";
+import { type EngineServices, featureModule, mountFeature } from "./feature";
 
 // A self-contained feature: a Count state + a reducer that folds Tick. The base
 // seeds Count; the logic provides the reducer over it and leaves the engine
 // (Reducers registry) OPEN, so `mountFeature` builds it against the live engine.
-class Tick extends Event.make('Tick', S.Struct({})) {}
-class Count extends State.make('count', S.Number) {}
-class CountReducer extends Reducer.make('CountReducer', { states: [Count], events: [Tick] }) {}
+class Tick extends Event.make("Tick", S.Struct({})) {}
+class Count extends State.make("count", S.Number) {}
+class CountReducer extends Reducer.make("CountReducer", {
+  states: [Count],
+  events: [Tick],
+}) {}
 
 const mod = featureModule(
   [],
-  Reducer.live(CountReducer, (n) => n + 1).pipe(Layer.provideMerge(State.live(Count, 0))),
-)
+  Reducer.live(CountReducer, (n) => n + 1).pipe(
+    Layer.provideMerge(State.live(Count, 0)),
+  ),
+);
 
 // A trivial composition to hang the feature off (definitions only).
-class CtrUi extends ui('CtrUi')<{ props: {}; events: {} }>() {}
-class CtrComp extends Composition.make('CtrComp', { title: 'Counter', ui: CtrUi }) {}
+class CtrUi extends ui("CtrUi")<{ props: {}; events: {} }>() {}
+class CtrComp extends Composition.make("CtrComp", {
+  title: "Counter",
+  ui: CtrUi,
+}) {}
 
-class CounterFeature extends Feature.make('counter', {
+class CounterFeature extends Feature.make("counter", {
   composition: CtrComp,
   module: mod,
   boot: [Event.construct(Tick, {})],
@@ -41,42 +49,46 @@ const waitUntil = <A, R>(
   Effect.flatMap(read, (a) =>
     pred(a)
       ? Effect.succeed(a)
-      : Effect.flatMap(Effect.sleep(Duration.millis(1)), () => waitUntil(read, pred)),
-  ).pipe(Effect.timeout(Duration.seconds(2)))
+      : Effect.flatMap(Effect.sleep(Duration.millis(1)), () =>
+          waitUntil(read, pred),
+        ),
+  ).pipe(Effect.timeout(Duration.seconds(2)));
 
-test('a mounted feature registers on the shared loop, boots, and folds dispatched events', async () => {
-  const runtime = ManagedRuntime.make(Engine)
-  try {
-    await runtime.runPromise(
-      Effect.gen(function* () {
-        const engineContext = yield* Effect.context<EngineServices>()
-        const reducers = yield* Reducers
-        const baseline = reducers.entries.length
+it.scopedLive(
+  "a mounted feature registers on the shared loop, boots, and folds dispatched events",
+  () =>
+    Effect.gen(function* () {
+      const engineContext = yield* Effect.context<EngineServices>();
+      const reducers = yield* Reducers;
+      const baseline = reducers.entries.length;
 
-        const scope = yield* Scope.make()
-        const ctx = yield* mountFeature(CounterFeature.binding, engineContext).pipe(
-          Effect.provideService(Scope.Scope, scope),
-        )
-        // Registered into the SHARED registry.
-        expect(reducers.entries.length).toBe(baseline + 1)
+      const scope = yield* Scope.make();
+      const ctx = yield* mountFeature(
+        CounterFeature.binding,
+        engineContext,
+      ).pipe(Effect.provideService(Scope.Scope, scope));
+      // Registered into the SHARED registry.
+      expect(reducers.entries.length).toBe(baseline + 1);
 
-        // boot dispatched Tick → Count folds to 1 on the shared loop.
-        const booted = yield* waitUntil(Count.pipe(Effect.provide(ctx)), (n) => n === 1)
-        expect(booted).toBe(1)
+      // boot dispatched Tick → Count folds to 1 on the shared loop.
+      const booted = yield* waitUntil(
+        Count.pipe(Effect.provide(ctx)),
+        (n) => n === 1,
+      );
+      expect(booted).toBe(1);
 
-        // A further dispatch on the shared bus folds again → 2.
-        yield* publish('High', Event.construct(Tick, {}))
-        const folded = yield* waitUntil(Count.pipe(Effect.provide(ctx)), (n) => n === 2)
-        expect(folded).toBe(2)
+      // A further dispatch on the shared bus folds again → 2.
+      yield* publish("High", Event.construct(Tick, {}));
+      const folded = yield* waitUntil(
+        Count.pipe(Effect.provide(ctx)),
+        (n) => n === 2,
+      );
+      expect(folded).toBe(2);
 
-        // Unmount: closing the feature scope unregisters its reducer — the entry is
-        // reclaimed, not left folding onto an orphaned store.
-        yield* Scope.close(scope, Exit.succeed(undefined))
-        expect(reducers.entries.length).toBe(baseline)
-        expect(reducers.byTag.get('Tick')).toBeUndefined()
-      }),
-    )
-  } finally {
-    await runtime.dispose()
-  }
-})
+      // Unmount: closing the feature scope unregisters its reducer — the entry is
+      // reclaimed, not left folding onto an orphaned store.
+      yield* Scope.close(scope, Exit.succeed(undefined));
+      expect(reducers.entries.length).toBe(baseline);
+      expect(reducers.byTag.get("Tick")).toBeUndefined();
+    }).pipe(Effect.provide(Engine)),
+);

package/src/feature/feature.test.ts

@@ -1,60 +1,81 @@
-import { Effect, Layer, Option } from 'effect'
-import { expect, test } from 'vitest'
-import * as Composition from '../compose/composition'
-import { ui } from '../compose/ui'
-import * as Feature from './feature'
-import { featureModule, isFeature, isFeatureBinding, lazyImport } from './feature'
+import { Effect, Layer, Option } from "effect";
+import { expect, it } from "@effect/vitest";
+import * as Composition from "../compose/composition";
+import { ui } from "../compose/ui";
+import * as Feature from "./feature";
+import {
+  featureModule,
+  isFeature,
+  isFeatureBinding,
+  lazyImport,
+} from "./feature";
 
 // Minimal composition surface to hang features off — definitions only, no logic.
-class TestUi extends ui('TestUi')<{ props: {}; events: {} }>() {}
-class TestComp extends Composition.make('TestComp', { title: 'Test', ui: TestUi }) {}
-class FailComp extends Composition.make('FailComp', { title: 'Fail', ui: TestUi }) {}
+class TestUi extends ui("TestUi")<{ props: {}; events: {} }>() {}
+class TestComp extends Composition.make("TestComp", {
+  title: "Test",
+  ui: TestUi,
+}) {}
+class FailComp extends Composition.make("FailComp", {
+  title: "Fail",
+  ui: TestUi,
+}) {}
 
 // A trivial loaded module: empty layer, no shared requirements.
-const mod = featureModule([], Layer.empty)
+const mod = featureModule([], Layer.empty);
 
-class LazyFeature extends Feature.make('lazyFeature', {
-  loadingStrategy: 'lazy',
+class LazyFeature extends Feature.make("lazyFeature", {
+  loadingStrategy: "lazy",
   composition: TestComp,
   load: lazyImport(() => Promise.resolve({ default: mod })),
   placeholder: { loading: TestComp, failed: FailComp },
 }) {}
 
-class EagerFeature extends Feature.make('eagerFeature', {
+class EagerFeature extends Feature.make("eagerFeature", {
   composition: TestComp,
   module: mod,
 }) {}
 
-test('a lazy feature reflects as a Feature manifest with placeholders, no chunk loaded', () => {
-  expect(LazyFeature.manifest.kind).toBe('Feature')
-  expect(LazyFeature.manifest.name).toBe('lazyFeature')
-  expect(LazyFeature.manifest.strategy).toBe('lazy')
-  expect(LazyFeature.manifest.composition.name).toBe('TestComp')
-  expect(Option.getOrThrow(LazyFeature.manifest.placeholder).loading.name).toBe('TestComp')
-  expect(Option.getOrThrow(LazyFeature.manifest.placeholder).failed.name).toBe('FailComp')
-  expect(LazyFeature.eagerModule).toBeUndefined()
-})
-
-test('an eager feature reflects as default strategy with its module available', () => {
-  expect(EagerFeature.manifest.strategy).toBe('default')
-  expect(Option.isNone(EagerFeature.manifest.placeholder)).toBe(true)
-  expect(EagerFeature.eagerModule).toBe(mod)
-})
-
-test('isFeature / isFeatureBinding discriminate', () => {
-  expect(isFeature(LazyFeature)).toBe(true)
-  expect(isFeature(TestComp)).toBe(false)
-  expect(isFeature(null)).toBe(false)
-  expect(isFeatureBinding(LazyFeature.binding)).toBe(true)
-  expect(isFeatureBinding(TestComp)).toBe(false)
-})
-
-test('load is an Effect (not a thenable) that yields the module and its requires', async () => {
-  // No `.then` on `load` — it is an Effect, run on the Effect runtime.
-  expect(typeof (LazyFeature.load as { then?: unknown }).then).toBe('undefined')
-  const loaded = await Effect.runPromise(LazyFeature.load)
-  expect(loaded.requires).toEqual([])
-  expect(loaded).toBe(mod)
-  // default strategy resolves immediately to its module.
-  expect(await Effect.runPromise(EagerFeature.load)).toBe(mod)
-})
+it("a lazy feature reflects as a Feature manifest with placeholders, no chunk loaded", () => {
+  expect(LazyFeature.manifest.kind).toBe("Feature");
+  expect(LazyFeature.manifest.name).toBe("lazyFeature");
+  expect(LazyFeature.manifest.strategy).toBe("lazy");
+  expect(LazyFeature.manifest.composition.name).toBe("TestComp");
+  expect(Option.getOrThrow(LazyFeature.manifest.placeholder).loading.name).toBe(
+    "TestComp",
+  );
+  expect(Option.getOrThrow(LazyFeature.manifest.placeholder).failed.name).toBe(
+    "FailComp",
+  );
+  expect(LazyFeature.eagerModule).toBeUndefined();
+});
+
+it("an eager feature reflects as default strategy with its module available", () => {
+  expect(EagerFeature.manifest.strategy).toBe("default");
+  expect(Option.isNone(EagerFeature.manifest.placeholder)).toBe(true);
+  expect(EagerFeature.eagerModule).toBe(mod);
+});
+
+it("isFeature / isFeatureBinding discriminate", () => {
+  expect(isFeature(LazyFeature)).toBe(true);
+  expect(isFeature(TestComp)).toBe(false);
+  expect(isFeature(null)).toBe(false);
+  expect(isFeatureBinding(LazyFeature.binding)).toBe(true);
+  expect(isFeatureBinding(TestComp)).toBe(false);
+});
+
+it.live(
+  "load is an Effect (not a thenable) that yields the module and its requires",
+  () =>
+    Effect.gen(function* () {
+      // No `.then` on `load` — it is an Effect, run on the Effect runtime.
+      expect(typeof (LazyFeature.load as { then?: unknown }).then).toBe(
+        "undefined",
+      );
+      const loaded = yield* LazyFeature.load;
+      expect(loaded.requires).toEqual([]);
+      expect(loaded).toBe(mod);
+      // default strategy resolves immediately to its module.
+      expect(yield* EagerFeature.load).toBe(mod);
+    }),
+);