@playfast/reform 0.1.0 → 1.1.1

package/src/compose/provide.ts

@@ -4,54 +4,44 @@ import type { CompositionClass } from './composition'
 import {
   type EngineServices,
   type FeatureClass,
+  type FeatureRequirement,
   isFeature,
   type ProvidedBy,
-  type RequireCarrier,
 } from '../feature/feature'
 import { isSlot, type SlotChild, type SlotClass } from './slot'
 import { isUi, type UiClass, type UiContract, type ViewImpl } from './ui'
+import type { AnyValue } from '../internal/variance'
 
-/**
- * Wire an implementation to a contract. Provides a `.make` presentation to a UI
- * contract, a child composition into a parent's slot, or a `Feature` into a slot.
- * The compose code never imports its implementations — they meet here.
- */
 export function provide<C extends UiContract>(
   contract: UiClass<C>,
   view: ViewImpl<C>,
 ): Layer.Layer<ViewImpl<C>>
-export function provide<Comp extends CompositionClass<any, any>>(
+export function provide<Comp extends CompositionClass<AnyValue, AnyValue>>(
   hole: SlotClass<Comp>,
   composition: Comp,
 ): Layer.Layer<CompositionClass<unknown>>
-/**
- * Fill a slot with a feature. The slot's child composition type
- * (`CompositionClass<P, C>`) must match the feature's mounted composition, so the
- * facade/contract stays typed. The returned layer surfaces the feature's shared
- * requirement (`EngineServices | ProvidedBy<Requires>`) as an open `RIn`, so the
- * scene that wires it won't compile unless it provides the matching `Core` — even
- * for a lazy feature whose own `.live` layer isn't built until mount.
- */
 export function provide<
-  Comp extends CompositionClass<any, any>,
+  Comp extends CompositionClass<AnyValue, AnyValue>,
   ROut,
-  Requires extends ReadonlyArray<RequireCarrier>,
+  Requires extends ReadonlyArray<FeatureRequirement>,
+  SupportRequires extends ReadonlyArray<FeatureRequirement>,
 >(
   hole: SlotClass<Comp>,
   feature: FeatureClass<
-    Comp extends CompositionClass<infer P, any> ? P : never,
-    Comp extends CompositionClass<any, infer C> ? C : never,
+    Comp extends CompositionClass<infer P, AnyValue> ? P : never,
+    Comp extends CompositionClass<AnyValue, infer C> ? C : never,
     ROut,
-    Requires
+    Requires,
+    SupportRequires
   >,
-): Layer.Layer<SlotChild, never, EngineServices | ProvidedBy<Requires>>
+): Layer.Layer<
+  SlotChild,
+  never,
+  EngineServices | ProvidedBy<Requires> | ProvidedBy<SupportRequires>
+>
 // oxlint-disable-next-line reform-rules/no-multiple-primitive-params -- erased implementation signature of the 2-arg overloaded `provide`; the typed public API is the overloads above
 export function provide(target: unknown, impl: unknown): Layer.Layer<never, never, unknown> {
-  // Discriminate the target by its nominal brand, not by which DI-hole property
-  // happens to exist: a UI contract provides under its `impl` tag, a slot under
-  // its `tag`. Anything else is a wiring mistake. The overloads above pair
-  // `impl` with the chosen tag; this implementation sees both erased, so view
-  // the tag loosely (the one documented cast) to provide the service under it.
+  // Brand-discriminate: UI → impl tag, slot → tag; cast is the erased DI seam
   // oxlint-disable-next-line reform-rules/no-type-assertion -- erased DI tag widening at the provide seam (Context.Tag is invariant); overloads pair impl with the right tag
   const tag = (isUi(target) ? target.impl : isSlot(target) ? target.tag : undefined) as
     | Context.Tag<unknown, unknown>
@@ -60,15 +50,11 @@ export function provide(target: unknown, impl: unknown): Layer.Layer<never, neve
     return Layer.die(new InvalidProvideTarget())
   }
   if (isFeature(impl)) {
-    const eager = impl.eagerModule
-    // Lazy: bind the `FeatureBinding`; the host drives load → mount, painting the
-    // placeholders. Default: bind the composition (so the existing `Compose` path
-    // renders it, no host, no flash) and merge the eager `.live` layer, whose `RIn`
-    // surfaces to the scene. Either way the overload's return type carries the
-    // shared `RIn`, so the scene still type-demands `Core`.
+    // Default: merge live module now; lazy: eager placeholder support only
+    const eager = impl.eagerModule ?? impl.supportModule
     return eager === undefined
       ? Layer.succeed(tag, impl.binding)
-      : Layer.merge(Layer.succeed(tag, impl.binding.composition), eager.layer)
+      : Layer.merge(Layer.succeed(tag, impl.binding), eager.layer)
   }
   return Layer.succeed(tag, impl)
 }

package/src/compose/slot.ts

@@ -3,41 +3,18 @@ import { definitionClass } from '../definition/definition'
 import type { CompositionClass } from './composition'
 import type { FeatureBinding } from '../feature/feature'
 import type { Node } from '../ui/node'
+import type { AnyValue } from '../internal/variance'
 
 export type { Node }
 
-/** Any composition, used where only the slot's structural role matters. */
-type AnyComposition = CompositionClass<any, any>
+type AnyComposition = CompositionClass<AnyValue, AnyValue>
 
-/**
- * What a slot can be filled with: a plain child composition (the host renders it
- * directly), or a `FeatureBinding` from `provide(slot, Feature)` (the host drives
- * its lazy/eager mount lifecycle). The slot's DI tag holds one of these; the host
- * discriminates by the `FeatureBinding` brand.
- */
 export type SlotChild = CompositionClass<unknown> | FeatureBinding
 
-/**
- * Phantom instance shape: `ItemSlot` used as a *type* denotes this. It carries
- * the child *composition* type `Comp`, so the slot knows both the external props
- * the parent renders it with (`Comp['Props']`) and the child's full UI contract
- * (`Comp['Contract']` — props + events + slots) that reflection consumers, the
- * proof facade, drive.
- */
 export interface SlotInstance<Comp extends AnyComposition> {
   readonly _slot: Comp
 }
 
-/**
- * A DI hole for a child composition. The parent declares
- * `slot('Item')<typeof TodoItem>()` and renders through it; the concrete child
- * is wired with `provide(Item, TodoItem)`, so the parent never imports the
- * child's *implementation* (the `typeof` is a type-only reference to the
- * definition). `Comp` lives only in the phantom instance (so `SlotClass` is
- * covariant and a `{ Item: ItemSlot }` map is well-typed); the match is enforced
- * by `provide`'s signature, not the (invariant) tag.
- */
-/** Nominal brand identifying a slot at runtime (Effect's `TypeId` idiom). */
 export const SlotTypeId: unique symbol = Symbol.for('reform/Slot')
 export type SlotTypeId = typeof SlotTypeId
 
@@ -45,23 +22,18 @@ export interface SlotClass<Comp extends AnyComposition = AnyComposition> {
   new (): SlotInstance<Comp>
   readonly [SlotTypeId]: SlotTypeId
   readonly kind: 'Slot'
-  /** Internal DI tag the filling child (composition or feature binding) is provided under. */
   readonly tag: Context.Tag<SlotChild, SlotChild>
 }
 
-/** Whether a value is a slot — discriminates a `provide` target by brand. */
 export const isSlot = (candidate: unknown): candidate is SlotClass =>
   (typeof candidate === 'function' || typeof candidate === 'object') &&
   candidate !== null &&
   SlotTypeId in candidate
 
-/** The props a slot renders with — the child composition's external props. */
 export type SlotProps<S> = S extends SlotInstance<infer Comp> ? Comp['Props'] : never
 
 export const slot =
   (name: string) =>
-  // Defaulted so a slot whose child carries no meaningful props/contract can be
-  // declared bare (`slot('Tree')()`); pass `typeof Child` to type the facade.
   <Comp extends AnyComposition = AnyComposition>(): SlotClass<Comp> => {
     const tag = Context.GenericTag<SlotChild, SlotChild>(`reform/slot/${name}`)
     return definitionClass<SlotClass<Comp>>({ [SlotTypeId]: SlotTypeId, kind: 'Slot' as const, tag })

package/src/compose/structure.test.ts

@@ -7,10 +7,6 @@ import { absent, each, isStructure, mount, one, structureEquals, when } from './
 
 type List = Contract<typeof ListUi>
 
-// A minimal parent/child contract pair: a list parent with one keyed slot, so the
-// type-level `mount` checks have a real contract to bind against. Row carries a
-// props schema so its external props (`Comp['Props']`) are `{ label: string }`,
-// which is what each fill is checked against.
 class RowUi extends ui('Row')<{ props: { label: string } }>() {}
 class Row extends Composition.make('Row', {
   title: 'Row',
@@ -65,8 +61,6 @@ describe('structure combinators', () => {
   })
 })
 
-// Type-level contract enforcement — never called; exists only so the negative
-// cases are typechecked. Each `@ts-expect-error` must sit on the line that errors.
 export const _typeChecks = (): void => {
   mount<List>({
     props: { total: 1 },

package/src/compose/structure.ts

@@ -2,64 +2,29 @@ import { Struct } from 'effect'
 import type { SlotProps } from './slot'
 import type { EventsOf, UiContract } from './ui'
 
-/**
- * Structure-as-data (the headless-structure keystone). A composition's logic
- * body returns this *value* instead of a React node: pure, serializable data that
- * describes — for this frame — the composition's own props and, per declared slot,
- * how that slot is filled (a list / a singleton / absent). The engine, the wire
- * server, and the proof harness consume this directly, so none of them needs to
- * evaluate a view or import React to discover structure. Presentation (React)
- * resolves a contract's markup separately, by name, on a host.
- *
- * `live` accepts BOTH a `Node` (legacy view body) and a `Structure` during the
- * migration; hosts discriminate at runtime via {@link isStructure}.
- */
-
-/** A list slot fill: one keyed entry per item. `key` is the SINGLE source of both
- *  the wire `key` and the per-item `StateFamily` key — they can no longer drift. */
 export interface EachFill<P> {
   readonly _tag: 'Each'
   readonly items: ReadonlyArray<{ readonly key: string; readonly props: P }>
 }
 
-/** A singleton slot fill — the slot renders exactly one child with these props. */
 export interface OneFill<P> {
   readonly _tag: 'One'
   readonly props: P
 }
 
-/** A slot that renders nothing this frame (the data-driven analog of `cond && …`). */
 export interface AbsentFill {
   readonly _tag: 'Absent'
 }
 
-/** How one declared slot is filled this frame, typed by the child's external props. */
 export type SlotFill<P> = EachFill<P> | OneFill<P> | AbsentFill
 
-/** The per-slot fill map a contract's structure carries — one fill per declared slot,
- *  each typed by that child composition's external props (`SlotProps`). Empty when the
- *  contract declares no slots. */
 export type StructureSlots<C extends UiContract> = C extends {
   slots: infer S
 }
   ? { readonly [K in keyof S]: SlotFill<SlotProps<S[K]>> }
   : Record<never, never>
 
-/**
- * The data a composition's logic returns for one frame: its computed props plus,
- * for every declared slot, a fill description. Strict against the contract — props
- * must match, and every declared slot must be filled (use {@link when} for
- * conditional presence). Carries the child's contract per slot (via `SlotProps`),
- * so consumers can select and descend into sub-compositions type-safely.
- *
- * `events` rides ON the structure: because a `mount(...)`-returning body never
- * calls its view, the event triggers it acquired (`yield* Event.trigger(X)`) are
- * no longer captured by a view's `CaptureSink` record — they must travel with the
- * frame so hosts can register them (proof `actions`, the wire `TriggerRegistry`,
- * the react presentation `events` arg). Triggers are functions, so `events` is NOT
- * serializable and is intentionally excluded from {@link structureEquals}. Typed to
- * the contract's event map; omit it (defaults to `{}`) when the contract has none.
- */
+// events ride on the frame for hosts but are not serializable — excluded from structureEquals
 export interface Structure<C extends UiContract> {
   readonly props: C['props']
   readonly slots: StructureSlots<C>
@@ -67,29 +32,14 @@ export interface Structure<C extends UiContract> {
   readonly events?: EventsOf<C>
 }
 
-/** Runtime brand distinguishing a `Structure` value from a React `Node` (added by
- *  {@link mount}; the authoring TYPE intentionally omits it so structure literals stay
- *  plain). */
 export const StructureTypeId: unique symbol = Symbol.for('reform/Structure')
 export type StructureTypeId = typeof StructureTypeId
 
-/**
- * Assemble a frame's structure, checked against the contract `C`. Identity at
- * runtime apart from stamping the {@link StructureTypeId} brand; its real job is
- * the compile-time contract check. `C` is recovered from the surrounding `live`
- * body's return type (contextual typing), so call sites read `mount({ props, slots })`.
- * A leaf composition (no declared slots) passes `slots: {}`. `events` defaults to an
- * empty map when omitted, so a frame always carries an `events` record for hosts.
- */
 export const mount = <C extends UiContract>(structure: Structure<C>): Structure<C> =>
   // oxlint-disable-next-line reform-rules/no-object-assign -- merge infers the empty `events` default as EventsOf<C>; a spread would force an `as` cast instead
   Object.assign({ [StructureTypeId]: StructureTypeId, events: {} }, structure)
 
-/**
- * A list slot fill. `key` derives the stable identity for BOTH the wire node and
- * the per-item state family — passing the same id source to both is no longer
- * possible to get wrong. `props` maps each item to the child's external props.
- */
+// key is the single source for both wire key and per-item StateFamily key
 export interface EachOptions<T, P> {
   readonly key: (item: T) => string
   readonly props: (item: T) => P
@@ -103,23 +53,16 @@ export const each = <T, P>(collection: Iterable<T>, options: EachOptions<T, P>):
   })),
 })
 
-/** A singleton slot fill — render one child with these external props. */
 export const one = <P>(props: P): OneFill<P> => ({ _tag: 'One', props })
 
-/** The shared empty fill — a slot that renders nothing this frame. */
 export const absent: AbsentFill = { _tag: 'Absent' }
 
-/** Conditional presence: the fill when `cond`, otherwise {@link absent}. */
 export const when = <F extends SlotFill<unknown>>(cond: boolean, fill: F): F | AbsentFill =>
   cond ? fill : absent
 
-/** Whether a frame value is a `Structure` (vs a legacy React `Node`). The runtime
- *  discriminator hosts use during the migration, replacing React's `isValidElement`. */
 export const isStructure = (frame: unknown): frame is Structure<UiContract> =>
   typeof frame === 'object' && frame !== null && StructureTypeId in frame
 
-/** Whether a value is a plain record (not an array) — narrows for the deep compare
- *  below without a cast. */
 const isRecord = (candidate: unknown): candidate is Record<string, unknown> =>
   typeof candidate === 'object' && candidate !== null && !Array.isArray(candidate)
 
@@ -128,8 +71,6 @@ interface ValuePair {
   readonly right: unknown
 }
 
-/** Minimal structural deep-equality for serializable shapes (plain JSON — the
- *  UI-contract guarantee). Avoids a heavyweight dep for the settle comparison. */
 const deepEquals = ({ left, right }: ValuePair): boolean => {
   if (Object.is(left, right)) {
     return true
@@ -155,12 +96,7 @@ const deepEquals = ({ left, right }: ValuePair): boolean => {
   return false
 }
 
-/** Structural equality over two structures — props and every slot fill compared by
- *  value. `events` is intentionally excluded: triggers are functions, freshly
- *  acquired each render, so comparing them by identity would never match and would
- *  break the settle fixpoint. The `StructureTypeId` brand is a symbol key, so
- *  `Object.keys` skips it. Used by the proof/server settle loop to detect a
- *  two-frame fixpoint. */
+// events intentionally excluded (fresh function identities would break settle fixpoint)
 export const structureEquals = (
   left: Structure<UiContract>,
   right: Structure<UiContract>,

package/src/compose/ui.test.ts

@@ -2,10 +2,6 @@ import { expect, test } from 'vitest'
 import { Schema as S } from 'effect'
 import { isUi, ui } from '../index'
 
-// `ui` has two authoring forms with one source of truth each: the type-only form
-// (local, no schema) and the schema form (wired, the type is *derived*). Both are
-// the same contract at runtime; only the wired form carries reflectable schemas.
-
 test('type-only `ui` carries no wire schema', () => {
   class CounterUi extends ui('Counter')<{ props: { count: number } }>() {}
   expect(CounterUi.manifest.kind).toBe('Ui')

package/src/compose/ui.ts

@@ -3,50 +3,25 @@ import { Context, type Schema } from 'effect'
 import { type Manifest, definitionClass } from '../definition/definition'
 import type { Trigger } from '../ui/trigger'
 import { type Node, type SlotClass, type SlotInstance, type SlotProps } from './slot'
+import type { AnyValue } from '../internal/variance'
 
 export interface UiContract {
   props: unknown
-  // `slots`/`events` are optional so a local contract literal (`ui('X')<{ props }>()`)
-  // stays terse AND so `C extends { slots: infer S }` / `{ events: infer E }`
-  // discriminates their presence (SlotsOf/EventsOf). Option<T> would break both the
-  // ergonomic authoring form and that conditional-type inference.
+  // Optional so local `ui('X')<{ props }>()` stays terse and `C extends { slots/events: … }` discriminates presence
   // oxlint-disable-next-line reform-rules/no-optional-fields -- presence drives `extends {...}` contract inference (see note above)
-  slots?: Record<string, SlotInstance<any>>
+  slots?: Record<string, SlotInstance<AnyValue>>
   // oxlint-disable-next-line reform-rules/no-optional-fields -- presence drives `extends {...}` contract inference (see note above)
-  events?: Record<string, Trigger<any>>
+  events?: Record<string, Trigger<AnyValue>>
 }
 
 type PropsOf<C extends UiContract> = C['props']
-/** The contract's event map (`{ [name]: Trigger<P> }`), or empty when it declares
- *  none. Exported so a `Structure<C>` can type its optional `events` field to the
- *  same map a composition body acquires. */
 export type EventsOf<C extends UiContract> = C extends { events: infer E } ? E : Record<never, never>
-// A slot is a React COMPONENT whose props are OPTIONAL (a `Partial`): a parent that
-// drives a child supplies them (`<slots.Item id=… />` / `createElement(slots.Item, {…})`),
-// but a placeholder render (the remote client, where the per-child props were captured
-// server-side and the framework expands the children) omits them (`<slots.Item />`).
-// One `Ui.make` view thus serves both renderers. The child still reads its own
-// props/state — these are only the external props the parent feeds, advisory at the
-// slot boundary. Typing it as `FunctionComponent` makes both JSX and `createElement` work.
-//
-// `slotKey` is the universal KEYED-SLOT selector (see `WireNode.key`): for a LIST slot
-// invoked once per item (`<slots.Row slotKey={id} />`), the remote client renders only the
-// one wire child whose React `key` matches, instead of every child of that slot at every
-// call site (which duplicates the whole list under each call). It is framework-handled, not
-// forwarded to the child, so it is allowed on EVERY slot and never collides with a child's
-// own props. Omit it for singleton slots (`<slots.Create />`) — they render all children.
+// Slots are Partial FunctionComponents: parent may supply props; remote placeholder omits them.
+// slotKey selects one keyed list child on the wire; framework-handled, never a child prop.
 type SlotsOf<C extends UiContract> = C extends { slots: infer S }
   ? {
-      // `slotKey` goes INSIDE the `Partial<…>` (not intersected outside) so that when a slot's
-      // child props are `any` the whole thing still collapses to `any` (`any & X = any`), keeping
-      // the component assignable to a bare `(props: unknown) => Node` slot-renderer shape. An
-      // outer intersection would leave a required-shape object that `unknown` can't satisfy.
-      //
-      // A slot handle is BOTH renderable (the `FunctionComponent` — places the keyed children)
-      // AND inspectable (`.props` — the array of per-child fill props the structure carried, one
-      // entry per mounted child, typed by the child contract). A presentation can read the fills
-      // (`slots.Item.props.length`, a header, layout decisions) and still render them
-      // (`<slots.Item/>`); it never DERIVES multiplicity — the engine already fixed it. Read-only.
+      // slotKey inside Partial so `any` child props still collapse to `any` (outer & would break unknown)
+      // Handle = renderable FC + inspectable `.props` fills (engine fixes multiplicity)
       readonly [K in keyof S]: FunctionComponent<
         // oxlint-disable-next-line reform-rules/no-optional-fields -- React/JSX component-prop shape (`<slots.Row slotKey={id} />`); singleton slots omit it, framework-handled
         Partial<SlotProps<S[K]> & { readonly slotKey?: string }>
@@ -54,84 +29,51 @@ type SlotsOf<C extends UiContract> = C extends { slots: infer S }
     }
   : Record<never, never>
 
-/** What `.make` authors: the pure presentation. Slots are injected by the renderer. */
 export type ViewImpl<C extends UiContract> = (
   props: PropsOf<C>,
   slots: SlotsOf<C>,
   events: EventsOf<C>,
 ) => Node
 
-/** Nominal brand identifying a UI contract at runtime (Effect's `TypeId` idiom). */
 export const UiTypeId: unique symbol = Symbol.for('reform/Ui')
 export type UiTypeId = typeof UiTypeId
 
-/**
- * The reflectable descriptor a contract carries. The wire `props` / `events`
- * schemas are present *only* on the schema (wired) form — the type-only form
- * carries neither, so a local contract has no schema cost and no schema surface.
- */
 export interface UiManifest extends Manifest {
   readonly kind: 'Ui'
-  // `any` in the encoded/context slots is required by Schema's variance for
-  // branded/Class schemas; only the decoded type is ever read off these.
-  // Present only on the wired form, so `extends { props: … }` discriminates the two
-  // authoring forms — Option<T> would erase that wire/type-only distinction.
+  // Schema variance needs any in encoded/context; present only on wired form for discrimination
   // oxlint-disable-next-line reform-rules/no-optional-fields -- wire manifest field present only on the wired form (see note above)
-  readonly props?: Schema.Schema<any, any>
+  readonly props?: Schema.Schema.AnyNoContext
   // oxlint-disable-next-line reform-rules/no-optional-fields -- wire manifest field present only on the wired form (see note above)
-  readonly events?: Readonly<Record<string, Schema.Schema<any, any>>>
+  readonly events?: Readonly<Record<string, Schema.Schema.AnyNoContext>>
 }
 
-/** A `UiManifest` whose wire schema is present — the runtime brand of a remote-capable contract. */
 export interface WiredUiManifest extends UiManifest {
-  readonly props: Schema.Schema<any, any>
+  readonly props: Schema.Schema.AnyNoContext
 }
 
-// A branded, extendable class carrying the wire `manifest` + the DI `impl` tag. Not
-// yieldable: bodies return a `Structure`, and the host reads `impl` to resolve the view.
+// Not yieldable: bodies return Structure; host resolves view via `impl`
 export interface UiClass<C extends UiContract> {
   new (): {}
   readonly [UiTypeId]: UiTypeId
   readonly manifest: UiManifest
-  /** Internal DI tag the `Ui.make` presentation is provided under. */
   readonly impl: Context.Tag<ViewImpl<C>, ViewImpl<C>>
 }
 
-/**
- * Recover a contract's `UiContract` type from its `Ui` class — `Ui.Contract<typeof
- * SomeUi>`. Lets a consumer (a proof, a reflection tool) name the contract derived
- * from a wired `ui('X', {…})` without re-declaring it.
- */
 export type Contract<U> = U extends UiClass<infer C> ? C : never
 
-/**
- * A contract authored with wire schemas. Structurally a `UiClass<C>` whose
- * manifest *carries* the schemas (`WiredUiManifest`), so it is the subtype the
- * remote seam (`provideRemote`, the wire registry) demands while plain `provide`
- * / `scene` / `Composition.make` keep accepting any `UiClass<C>`.
- */
 export type WiredUi<C extends UiContract> = UiClass<C> & { readonly manifest: WiredUiManifest }
 
-/** The wire schemas a contract is authored from: props, a payload schema per event, and
- *  (type-only) the slots the view fills. Slots carry no wire schema — the children that
- *  fill them are their own contracts — but declaring them here threads typed slots into
- *  the derived contract, so a WIRED contract can also have slots (e.g. a parent whose
- *  props the client reads AND that renders slot children). */
 export interface WireSchemas {
-  readonly props: Schema.Schema<any, any>
-  // `events`/`slots` optional so `Sch extends { events: … }` / `{ slots: … }`
-  // derives the contract's facade only when declared (DerivedEvents/DerivedSlots).
+  readonly props: Schema.Schema.AnyNoContext
   // oxlint-disable-next-line reform-rules/no-optional-fields -- presence drives `extends {...}` derivation (DerivedEvents)
-  readonly events?: Readonly<Record<string, Schema.Schema<any, any>>>
-  // Slots are declared with their slot CLASSES (`slot('X')<typeof Child>()`), the
-  // same values `Composition.make({ slots })` takes — NOT `SlotInstance`s. The
-  // contract's slot facade is derived from them below.
+  readonly events?: Readonly<Record<string, Schema.Schema.AnyNoContext>>
+  // Slot CLASSES (not instances) so the contract facade derives InstanceType
   // oxlint-disable-next-line reform-rules/no-optional-fields -- presence drives `extends {...}` derivation (DerivedSlots)
   readonly slots?: Readonly<Record<string, SlotClass>>
 }
 
 type DerivedEvents<Sch extends WireSchemas> = Sch extends {
-  readonly events: infer E extends Record<string, Schema.Schema<any, any>>
+  readonly events: infer E extends Record<string, Schema.Schema.AnyNoContext>
 }
   ? { readonly [K in keyof E]: Trigger<Schema.Schema.Type<E[K]>> }
   : Record<never, never>
@@ -142,19 +84,12 @@ type DerivedSlots<Sch extends WireSchemas> = Sch extends {
   ? { readonly [K in keyof S]: InstanceType<S[K]> }
   : Record<never, never>
 
-/**
- * The `UiContract` a set of wire schemas denotes — props and event-payload
- * *types* derived from the schemas via `Schema.Type`, plus any declared slots. The
- * schema is the single source of truth; the contract type is inferred, never written
- * a second time.
- */
 export type DerivedContract<Sch extends WireSchemas> = {
   readonly props: Schema.Schema.Type<Sch['props']>
   readonly slots: DerivedSlots<Sch>
   readonly events: DerivedEvents<Sch>
 }
 
-/** Whether a value is a UI contract — discriminates a `provide` target by brand. */
 export const isUi = (candidate: unknown): candidate is UiClass<UiContract> =>
   (typeof candidate === 'function' || typeof candidate === 'object') &&
   candidate !== null &&
@@ -165,8 +100,6 @@ const buildUi = <C extends UiContract, M extends UiManifest>(
   manifest: M,
 ): UiClass<C> & { readonly manifest: M } => {
   const impl = Context.GenericTag<ViewImpl<C>, ViewImpl<C>>(`reform/ui/${name}`)
-  // Extendable definition class (`class Counter extends ui('Counter', …) {}`); resolved
-  // by name on a host via `impl`, never yielded.
   return definitionClass<UiClass<C> & { readonly manifest: M }>({
     [UiTypeId]: UiTypeId,
     manifest,
@@ -174,19 +107,6 @@ const buildUi = <C extends UiContract, M extends UiManifest>(
   })
 }
 
-/**
- * A renderer-neutral UI contract: `.make` authors the presentation, a composition
- * names it, and `@reform/react` resolves it to a view. Core defines the contract.
- *
- * Two authoring forms, one source of truth each:
- *
- * - **Type-only (local):** `ui('Counter')<{ props: { count: number } }>()` — no
- *   schema, no ceremony, exactly as before.
- * - **Schema (wired):** `ui('Counter', { props: S.Struct({ count: S.Number }) })`
- *   — the schema *is* the definition; the contract type is derived via
- *   `Schema.Type` (never re-written), and the result is a `WiredUi` the remote
- *   seam accepts. Make a local contract remote by rewriting this one line.
- */
 export function ui(name: string): <C extends UiContract>() => UiClass<C>
 export function ui<const Sch extends WireSchemas>(name: string, schemas: Sch): WiredUi<DerivedContract<Sch>>
 // oxlint-disable-next-line reform-rules/min-var-name -- `ui` is the public framework contract-authoring API; renaming would break every caller across the monorepo
@@ -199,25 +119,11 @@ export function ui(name: string, schemas?: WireSchemas): unknown {
   return buildUi<DerivedContract<WireSchemas>, WiredUiManifest>(name, manifest)
 }
 
-/** Brand under which a `Ui.make` view carries its own contract. */
 export const UiViewContract: unique symbol = Symbol.for('reform/ui/view-contract')
 export type UiViewContract = typeof UiViewContract
 
-/**
- * A `Ui.make` view that carries its contract, so a consumer can recover the
- * contract (its wire name + props schema) straight from the view — no separate
- * registration call. This is what makes the remote client view-set
- * (`remoteViews<AppContract>({ Some: SomeView, … })`) work with the very same
- * `Ui.make` views the local renderer uses.
- */
 export type MadeView<C extends UiContract> = ViewImpl<C> & { readonly [UiViewContract]: UiClass<C> }
 
-/**
- * Author the pure presentation for a contract — `Ui.make(TodoAppUi, (props,
- * slots, events) => node)`. The contract argument fixes the view's types AND is
- * carried on the returned view (`MadeView`), so the same view is reusable as a
- * remote client presentation. Wire the result with `provide(contract, view)`.
- */
 export const make = <C extends UiContract>(contract: UiClass<C>, view: ViewImpl<C>): MadeView<C> =>
   // oxlint-disable-next-line reform-rules/no-object-assign -- `view` is a callable function; spread would drop callability, so the brand is attached in place
   Object.assign(view, { [UiViewContract]: contract })

package/src/compose/ui.typecheck.ts

@@ -1,11 +1,3 @@
-// Type-level proofs enforced by `tsc --noEmit` over `src` (not a vitest file).
-// These guard the schema-first seam: the wired form is the single source of
-// truth (props/event types derived, never re-written), a wired contract is a
-// plain `UiClass` (so `provide` / `scene` / `Composition.make` accept it), and
-// the remote seam (`WiredUi`) rejects a type-only contract. If a guarantee
-// regresses, a `@ts-expect-error` goes unused or an assignment fails, and `tsc`
-// breaks.
-
 import { Schema as S } from 'effect'
 import {
   type Contract,
@@ -32,20 +24,14 @@ const wiredSchemas: {
 const WiredUiClassBase: WiredUi<DerivedContract<typeof wiredSchemas>> = ui('Wired', wiredSchemas)
 class WiredUiClass extends WiredUiClassBase {}
 
-// POSITIVE: both forms are a `UiClass` — plain wiring (provide/scene/Composition) accepts either.
 acceptsAny(LocalUi)
 acceptsAny(WiredUiClass)
 
-// POSITIVE: the schema form is a `WiredUi` — the remote seam accepts it.
 acceptsWired(WiredUiClass)
 
-// NEGATIVE: a type-only contract has no wire schema, so the remote seam rejects it.
 // @ts-expect-error -- LocalUi is `UiClass`, not `WiredUi`
 acceptsWired(LocalUi)
 
-// POSITIVE: props/event types are DERIVED from the schemas — authoring a presentation
-// against the wired contract sees `n: number` and `bump: Trigger<{ by: number }>`,
-// none of it written a second time.
 export const derivedView: MadeView<Contract<typeof WiredUiClass>> = make(
   WiredUiClass,
   ({ n: count }, _slots, { bump }) => {