@playfast/reform 1.0.1 → 1.2.0

package/src/compose/ui.ts

@@ -1,223 +1,222 @@
 import type { FunctionComponent } from 'react'
 import { Context, type Schema } from 'effect'
+import type { AST } from 'effect/SchemaAST'
 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 AnySlot, type AnySlotInstance, type Node, type SlotProps } from './slot'
 
-export interface UiContract {
+// Field presence drives conditional slot/event inference; Option would erase it.
+interface UiContractOptionalFields {
+  slots: Record<string, AnySlotInstance>
+  events: Record<string, Trigger<never>>
+}
+
+export interface UiContract extends Partial<UiContractOptionalFields> {
   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.
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- presence drives `extends {...}` contract inference (see note above)
-  slots?: Record<string, SlotInstance<any>>
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- presence drives `extends {...}` contract inference (see note above)
-  events?: Record<string, Trigger<any>>
 }
 
 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.
+export type EventsOf<C extends UiContract> = C extends { events: infer E }
+  ? E
+  : Readonly<Record<PropertyKey, never>>
+
+// slotKey is framework-only selection; Partial also permits prop-less remote placeholders.
 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.
       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 }>
+        Partial<SlotProps<S[K]> & { readonly slotKey: string }>
       > & { readonly props: ReadonlyArray<SlotProps<S[K]>> }
     }
-  : Record<never, never>
+  : Readonly<Record<PropertyKey, 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 {
+export const UiServiceTypeId: unique symbol = Symbol.for('reform/UiService')
+export type UiServiceTypeId = typeof UiServiceTypeId
+
+export interface UiService<N extends string> {
+  readonly [UiServiceTypeId]: N
+}
+
+export type CallableView = (...args: ReadonlyArray<never>) => unknown
+
+export interface UiSchemaReflection {
+  readonly ast: AST
+}
+
+interface UiManifestOptionalFields {
+  readonly props: UiSchemaReflection
+  readonly events: Readonly<Record<string, UiSchemaReflection>>
+}
+
+export interface UiManifest extends Manifest, Partial<UiManifestOptionalFields> {
   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.
-  // 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>
-  // 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>>>
 }
 
-/** 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: UiSchemaReflection
 }
 
-// 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.
-export interface UiClass<C extends UiContract> {
+export type UiCapture<Result> = <C extends UiContract, N extends string>(
+  contract: UiClass<C, N>,
+) => Result
+
+export interface UiReflection<
+  out C extends UiContract = UiContract,
+  out N extends string = string,
+> {
+  new (): {}
+  readonly [UiTypeId]: UiTypeId
+  readonly manifest: UiManifest & { readonly name: N }
+  readonly Contract: C
+}
+
+export interface AnyUi {
   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).
-  // 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.
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- presence drives `extends {...}` derivation (DerivedSlots)
-  readonly slots?: Readonly<Record<string, SlotClass>>
+  readonly capture: <Result>(visit: UiCapture<Result>) => Result
+}
+
+export interface UiClass<C extends UiContract, N extends string> extends UiReflection<C, N> {
+  readonly capture: <Result>(visit: UiCapture<Result>) => Result
+  readonly impl: Context.Tag<UiService<N>, ViewImpl<C>>
+  readonly provider: Context.Tag<UiService<N>, CallableView>
+}
+
+export type Contract<U> = U extends UiReflection<infer C, infer _N> ? C : never
+export type UiName<U> = U extends UiReflection<infer _C, infer N> ? N : never
+
+export type WiredUi<C extends UiContract, N extends string> = UiClass<C, N> & {
+  readonly manifest: WiredUiManifest
+}
+
+interface WireSchemasOptionalFields {
+  readonly events: Readonly<Record<string, Schema.Schema.AnyNoContext>>
+  readonly slots: Readonly<Record<string, AnySlot>>
+}
+
+export interface WireSchemas extends Partial<WireSchemasOptionalFields> {
+  readonly props: Schema.Schema.AnyNoContext
 }
 
 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>
+  : Readonly<Record<PropertyKey, never>>
 
 type DerivedSlots<Sch extends WireSchemas> = Sch extends {
-  readonly slots: infer S extends Record<string, SlotClass>
+  readonly slots: infer S extends Record<string, AnySlot>
 }
   ? { 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.
- */
+  : Readonly<Record<PropertyKey, never>>
+
 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> =>
+export const isUi = (candidate: unknown): candidate is AnyUi =>
   (typeof candidate === 'function' || typeof candidate === 'object') &&
   candidate !== null &&
   UiTypeId in candidate
 
-const buildUi = <C extends UiContract, M extends UiManifest>(
-  name: string,
+type UiDefinitionStatics<
+  C extends UiContract,
+  N extends string,
+  M extends UiManifest & { readonly name: N },
+> = Pick<
+  UiClass<C, N> & { readonly manifest: M },
+  typeof UiTypeId | 'manifest' | 'impl' | 'provider' | 'capture'
+>
+
+const buildUi = <
+  N extends string,
+  C extends UiContract,
+  M extends UiManifest & { readonly name: N },
+>(
+  name: N,
   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 }>({
+): UiClass<C, N> & { readonly manifest: M } => {
+  const impl = Context.GenericTag<UiService<N>, ViewImpl<C>>(`reform/ui/${name}`)
+  const provider = Context.GenericTag<UiService<N>, CallableView>(`reform/ui/${name}`)
+  const contract = definitionClass<UiClass<C, N> & { readonly manifest: M }>({
     [UiTypeId]: UiTypeId,
     manifest,
     impl,
-  })
+    provider,
+    capture: <Result>(visit: UiCapture<Result>): Result => visit(contract),
+  } satisfies UiDefinitionStatics<C, N, M>)
+  return contract
 }
 
-/**
- * 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>>
+type UiDefinition<N extends string> = (<C extends UiContract>() => UiClass<C, N>) | AnyUi
+
+export function ui<const N extends string>(name: N): <C extends UiContract>() => UiClass<C, N>
+export function ui<const N extends string, const Sch extends WireSchemas>(
+  name: N,
+  schemas: Sch,
+): WiredUi<DerivedContract<Sch>, N>
 // 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
-export function ui(name: string, schemas?: WireSchemas): unknown {
+export function ui<const N extends string>(name: N, schemas?: WireSchemas): UiDefinition<N> {
   if (schemas === undefined) {
-    return <C extends UiContract>(): UiClass<C> => buildUi<C, UiManifest>(name, { kind: 'Ui', name })
+    return <C extends UiContract>(): UiClass<C, N> =>
+      buildUi<N, C, UiManifest & { readonly name: N }>(name, {
+        kind: 'Ui',
+        name,
+      })
   }
   const eventFields = schemas.events === undefined ? {} : { events: schemas.events }
-  const manifest: WiredUiManifest = { kind: 'Ui', name, props: schemas.props, ...eventFields }
-  return buildUi<DerivedContract<WireSchemas>, WiredUiManifest>(name, manifest)
+  const manifest: WiredUiManifest & { readonly name: N } = {
+    kind: 'Ui',
+    name,
+    props: schemas.props,
+    ...eventFields,
+  }
+  return buildUi<N, DerivedContract<WireSchemas>, WiredUiManifest & { readonly name: N }>(
+    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 })
+export type MadeViewCapture<Result> = <C extends UiContract, N extends string, U extends AnyUi>(
+  view: MadeView<C, N, U>,
+) => Result
+
+export type MadeView<
+  C extends UiContract,
+  N extends string,
+  U extends AnyUi = UiClass<C, N>,
+> = ViewImpl<C> & {
+  readonly [UiViewContract]: U
+  readonly capture: <Result>(visit: MadeViewCapture<Result>) => Result
+}
+
+export type AnyMadeView = CallableView & {
+  readonly [UiViewContract]: AnyUi
+  readonly capture: <Result>(visit: MadeViewCapture<Result>) => Result
+}
+
+export const make = <U extends AnyUi>(
+  contract: U,
+  view: ViewImpl<Contract<U>>,
+): MadeView<Contract<U>, UiName<U>, U> => {
+  // oxlint-disable-next-line reform-rules/no-object-assign -- `view` is callable; spread would drop callability, so its reflection statics are attached in place
+  const made: MadeView<Contract<U>, UiName<U>, U> = Object.assign(view, {
+    [UiViewContract]: contract,
+    capture: <Result>(visit: MadeViewCapture<Result>): Result => visit(made),
+  })
+  return made
+}

package/src/compose/ui.typecheck.ts

@@ -1,12 +1,5 @@
-// 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 { slot, type SlotService } from './slot'
 import {
   type Contract,
   type DerivedContract,
@@ -15,13 +8,32 @@ import {
   ui,
   type UiClass,
   type UiContract,
+  type UiService,
   type WiredUi,
 } from './ui'
 
-declare function acceptsAny<C extends UiContract>(contract: UiClass<C>): void
-declare function acceptsWired<C extends UiContract>(contract: WiredUi<C>): void
+type ExpectFalse<Value extends false> = Value
+
+declare function acceptsAny<C extends UiContract, N extends string>(contract: UiClass<C, N>): void
+declare function acceptsWired<C extends UiContract, N extends string>(contract: WiredUi<C, N>): void
 
 class LocalUi extends ui('Local')<{ props: { n: number } }>() {}
+class SameShapeUi extends ui('SameShape')<{ props: { n: number } }>() {}
+class FirstSlot extends slot('FirstSlot')<FirstSlot>() {}
+class SecondSlot extends slot('SecondSlot')<SecondSlot>() {}
+
+type SameShapedUiDefinitionsRemainDistinct = ExpectFalse<
+  typeof LocalUi extends typeof SameShapeUi ? true : false
+>
+type SameShapedSlotDefinitionsRemainDistinct = ExpectFalse<
+  typeof FirstSlot extends typeof SecondSlot ? true : false
+>
+type WrongUiDoesNotCloseRequirement = ExpectFalse<
+  UiService<'SameShape'> extends UiService<'Local'> ? true : false
+>
+type WrongSlotDoesNotCloseRequirement = ExpectFalse<
+  SlotService<'SecondSlot', SecondSlot> extends SlotService<'FirstSlot', FirstSlot> ? true : false
+>
 const wiredSchemas: {
   readonly props: S.Struct<{ n: typeof S.Number }>
   readonly events: { readonly bump: S.Struct<{ by: typeof S.Number }> }
@@ -29,24 +41,21 @@ const wiredSchemas: {
   props: S.Struct({ n: S.Number }),
   events: { bump: S.Struct({ by: S.Number }) },
 }
-const WiredUiClassBase: WiredUi<DerivedContract<typeof wiredSchemas>> = ui('Wired', wiredSchemas)
+const WiredUiClassBase: WiredUi<DerivedContract<typeof wiredSchemas>, 'Wired'> = 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(
+const derivedView: MadeView<Contract<typeof WiredUiClass>, 'Wired'> = make(
   WiredUiClass,
   ({ n: count }, _slots, { bump }) => {
     const numeric: number = count
@@ -54,3 +63,16 @@ export const derivedView: MadeView<Contract<typeof WiredUiClass>> = make(
     return `${numeric}`
   },
 )
+
+type UiTypeProofs = [
+  SameShapedUiDefinitionsRemainDistinct,
+  SameShapedSlotDefinitionsRemainDistinct,
+  WrongUiDoesNotCloseRequirement,
+  WrongSlotDoesNotCloseRequirement,
+]
+declare const uiTypeProofs: UiTypeProofs
+
+void uiTypeProofs
+void derivedView
+
+export {}

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,55 +30,41 @@ 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>(
+export function yieldableClass<A, E, R, Statics extends object>(
   read: Effect.Effect<A, E, R>,
   statics: Statics,
-): { new (): {} } & Effect.Effect<A, E, R> & Statics => {
+): { new (): {} } & Effect.Effect<A, E, R> & Statics
+export function yieldableClass(
+  read: Effect.Effect<unknown, unknown, unknown>,
+  statics: object,
+): unknown {
   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 })
+    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
+  return Base
 }
 
-/**
- * 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`.
+export function definitionClass<Class>(statics: object): Class
+export function definitionClass(statics: object): unknown {
   const Base = class {}
   Reflect.ownKeys(statics).forEach((key) => {
     const staticValue = Reflect.get(statics, key)
-    Object.defineProperty(Base, key, { value: staticValue, writable: true, enumerable: true, configurable: true })
+    Object.defineProperty(Base, key, {
+      value: staticValue,
+      writable: true,
+      enumerable: true,
+      configurable: true,
+    })
   })
   attachInspectable(Base, () => describe(statics))
-  // oxlint-disable-next-line reform-rules/no-type-assertion -- the one documented seam: phantom type-only fields mean the assembled class cannot structurally satisfy Class
-  return Base as unknown as Class
+  return Base
 }