@playfast/reform 1.1.1 → 1.2.0

package/src/compose/provide.ts

@@ -1,60 +1,201 @@
-import { type Context, Layer } from 'effect'
+import { Context, Effect, Layer, Predicate } from 'effect'
 import { InvalidProvideTarget } from '../internal/errors'
-import type { CompositionClass } from './composition'
 import {
+  type AnyFeatureBinding,
   type EngineServices,
-  type FeatureClass,
+  type FeatureBinding,
   type FeatureRequirement,
   isFeature,
-  type ProvidedBy,
+  tree,
 } 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'
-
-export function provide<C extends UiContract>(
-  contract: UiClass<C>,
-  view: ViewImpl<C>,
-): Layer.Layer<ViewImpl<C>>
-export function provide<Comp extends CompositionClass<AnyValue, AnyValue>>(
-  hole: SlotClass<Comp>,
-  composition: Comp,
-): Layer.Layer<CompositionClass<unknown>>
-export function provide<
-  Comp extends CompositionClass<AnyValue, AnyValue>,
-  ROut,
-  Requires extends ReadonlyArray<FeatureRequirement>,
-  SupportRequires extends ReadonlyArray<FeatureRequirement>,
+import type {
+  AnyComposition,
+  CompositionClass,
+  CompositionId,
+  RequiredSlotIdentities,
+} from './composition'
+import type {
+  AnyFeatureGraphSummary,
+  CompositionChildSummary,
+  ExactServiceExclude,
+  FeatureSummaryOpenServices,
+  FeatureSummarySupportOpenServices,
+} from '../graph/closure'
+import {
+  type AnyFeatureSlotTarget,
+  type AnySlot,
+  isSlot,
+  type SlotClass,
+  type SlotService,
+  type SlotTarget,
+} from './slot'
+import {
+  type CallableView,
+  type Contract,
+  type AnyUi,
+  isUi,
+  type UiName,
+  type UiContract,
+  type UiService,
+  type ViewImpl,
+} from './ui'
+
+type TargetOfSlotClass<Slot extends AnySlot> = InstanceType<Slot>['_slot']
+type NameOfSlotClass<Slot extends AnySlot> = InstanceType<Slot>['_slotName']
+type IdentityOfSlotClass<Slot extends AnySlot> = InstanceType<Slot>['_slotIdentity']
+type FeatureTargetOfSlotClass<Slot extends AnySlot> =
+  TargetOfSlotClass<Slot> extends AnyFeatureSlotTarget ? TargetOfSlotClass<Slot> : never
+
+type CompositionIdentityOf<Composition extends AnyComposition> =
+  InstanceType<Composition>['_compositionIdentity']
+
+// Preserve exact residual inputs that Layer.provideMerge's union subtraction hides.
+export const provideMergeExact =
+  <Provided, ProviderError, ProviderInput>(
+    provider: Layer.Layer<Provided, ProviderError, ProviderInput>,
+  ) =>
+  <Output, Error, Input>(
+    consumer: Layer.Layer<Output, Error, Input>,
+  ): Layer.Layer<
+    Provided | Output,
+    ProviderError | Error,
+    ProviderInput | Exclude<Input, Provided> | ExactServiceExclude<Input, Provided>
+  > =>
+    Layer.merge(
+      Layer.provideMerge(provider)(consumer),
+      Layer.effectDiscard(Effect.context<ExactServiceExclude<Input, Provided>>()),
+    )
+
+const compositionSlotLayer = <
+  Target extends SlotTarget,
+  SlotName extends string,
+  SlotIdentity,
+  P,
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  CompositionName extends string,
+  CompositionIdentity,
 >(
-  hole: SlotClass<Comp>,
-  feature: FeatureClass<
-    Comp extends CompositionClass<infer P, AnyValue> ? P : never,
-    Comp extends CompositionClass<AnyValue, infer C> ? C : never,
-    ROut,
-    Requires,
-    SupportRequires
+  slotDefinition: SlotClass<Target, SlotName, SlotIdentity>,
+  composition: CompositionClass<P, C, S, CompositionName, CompositionIdentity>,
+): Layer.Layer<SlotService<SlotName, SlotIdentity, CompositionChildSummary<CompositionIdentity>>> =>
+  Layer.succeed(
+    Context.GenericTag<
+      SlotService<SlotName, SlotIdentity, CompositionChildSummary<CompositionIdentity>>,
+      AnyComposition
+    >(slotDefinition.tag.key),
+    composition,
+  )
+
+export const provideExisting = <
+  P,
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  CompositionName extends string,
+  CompositionIdentity,
+  SlotName extends string,
+  SlotIdentity,
+>(
+  hole: SlotClass<
+    CompositionClass<P, C, S, CompositionName, CompositionIdentity>,
+    SlotName,
+    SlotIdentity
   >,
+  composition: NoInfer<CompositionClass<P, C, S, CompositionName, CompositionIdentity>>,
+): Layer.Layer<
+  SlotService<SlotName, SlotIdentity, CompositionChildSummary<CompositionIdentity>>,
+  never,
+  CompositionId<CompositionName, CompositionIdentity, RequiredSlotIdentities<C>>
+> =>
+  Layer.effect(
+    Context.GenericTag<
+      SlotService<SlotName, SlotIdentity, CompositionChildSummary<CompositionIdentity>>,
+      CompositionClass<P, C, S, CompositionName, CompositionIdentity>
+    >(hole.tag.key),
+    Effect.as(composition.tag, composition),
+  )
+
+const featureSlotLayer = <
+  Target extends SlotTarget,
+  SlotName extends string,
+  SlotIdentity,
+  Summary extends AnyFeatureGraphSummary,
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+>(
+  slotDefinition: SlotClass<Target, SlotName, SlotIdentity>,
+  binding: FeatureBinding<Summary, ROut, DirectRequires>,
+): Layer.Layer<SlotService<SlotName, SlotIdentity, Summary>> =>
+  Layer.succeed(
+    Context.GenericTag<SlotService<SlotName, SlotIdentity, Summary>, AnyFeatureBinding>(
+      slotDefinition.tag.key,
+    ),
+    binding,
+  )
+
+const isComposition = (candidate: unknown): candidate is AnyComposition =>
+  (typeof candidate === 'function' || typeof candidate === 'object') &&
+  candidate !== null &&
+  Predicate.hasProperty(candidate, 'manifest') &&
+  Predicate.isRecord(candidate.manifest) &&
+  candidate.manifest['kind'] === 'Composition' &&
+  Predicate.hasProperty(candidate, 'capture') &&
+  typeof candidate.capture === 'function'
+
+const isCallableView = (candidate: unknown): candidate is CallableView =>
+  typeof candidate === 'function'
+
+export function provide<U extends AnyUi>(
+  contract: U,
+  view: ViewImpl<Contract<U>>,
+): Layer.Layer<UiService<UiName<U>>>
+export function provide<Comp extends AnyComposition, N extends string, Identity>(
+  hole: SlotClass<Comp, N, Identity>,
+  composition: NoInfer<Comp>,
+): Layer.Layer<SlotService<N, Identity, CompositionChildSummary<CompositionIdentityOf<Comp>>>>
+export function provide<Slot extends AnySlot>(
+  hole: Slot,
+  feature: NoInfer<FeatureTargetOfSlotClass<Slot>>,
 ): Layer.Layer<
-  SlotChild,
+  SlotService<
+    NameOfSlotClass<Slot>,
+    IdentityOfSlotClass<Slot>,
+    FeatureTargetOfSlotClass<Slot>['summary']
+  >,
   never,
-  EngineServices | ProvidedBy<Requires> | ProvidedBy<SupportRequires>
+  | EngineServices
+  | FeatureSummaryOpenServices<FeatureTargetOfSlotClass<Slot>['summary']>
+  | FeatureSummarySupportOpenServices<FeatureTargetOfSlotClass<Slot>['summary']>
 >
-// 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> {
-  // 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>
-    | undefined
-  if (tag === undefined) {
-    return Layer.die(new InvalidProvideTarget())
+export function provide(...args: readonly [target: unknown, implementation: unknown]): unknown {
+  const [target, implementation] = args
+  if (isUi(target)) {
+    if (!isCallableView(implementation)) {
+      return Layer.die(new InvalidProvideTarget())
+    }
+    return target.capture<unknown>((contract) => Layer.succeed(contract.provider, implementation))
   }
-  if (isFeature(impl)) {
-    // 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), eager.layer)
+  if (!isSlot(target)) {
+    return Layer.die(new InvalidProvideTarget())
   }
-  return Layer.succeed(tag, impl)
+  return target.capture<unknown>((slotDefinition) => {
+    if (isFeature(implementation)) {
+      const native = tree<typeof implementation>(implementation.token)
+      return native.binding.capture<unknown>((featureBinding) => {
+        // Lazy features merge only eager support; default features merge their live module.
+        const eager = native.eagerModule ?? native.supportModule
+        const binding = featureSlotLayer(slotDefinition, featureBinding)
+        if (eager === undefined) {
+          return binding
+        }
+        return eager.capture<unknown>((module) => Layer.merge(binding, module.layer))
+      })
+    }
+    if (!isComposition(implementation)) {
+      return Layer.die(new InvalidProvideTarget())
+    }
+    return implementation.capture<unknown>((composition) =>
+      compositionSlotLayer(slotDefinition, composition),
+    )
+  })
 }

package/src/compose/slot.ts

@@ -1,40 +1,177 @@
-import { Context } from 'effect'
-import { definitionClass } from '../definition/definition'
-import type { CompositionClass } from './composition'
-import type { FeatureBinding } from '../feature/feature'
+import { Context, GlobalValue, MutableRef } from 'effect'
+import { type Manifest, definitionClass } from '../definition/definition'
+import type { AnyFeatureBinding, ProvideableFeature } from '../feature/feature'
+import type {
+  AnyFeatureGraphSummary,
+  FeatureSummaryCompositionIdentity,
+  FeatureSummaryCompositionProps,
+  FeatureSummaryContract,
+  FeatureSummaryMountProps,
+  FeatureSummaryName,
+  FeatureSummaryStates,
+  FeatureSummaryIdentity,
+  SlotBindingSummary,
+} from '../graph/closure'
 import type { Node } from '../ui/node'
-import type { AnyValue } from '../internal/variance'
+import type { AnyComposition, CompositionClass } from './composition'
 
 export type { Node }
 
-type AnyComposition = CompositionClass<AnyValue, AnyValue>
+export type { AnyComposition } from './composition'
 
-export type SlotChild = CompositionClass<unknown> | FeatureBinding
+type AnyProvideableFeature = ProvideableFeature<unknown, AnyFeatureGraphSummary>
 
-export interface SlotInstance<Comp extends AnyComposition> {
-  readonly _slot: Comp
+export type FeatureSlotTarget<Feature extends AnyProvideableFeature> = ProvideableFeature<
+  FeatureSummaryIdentity<Feature['summary']>,
+  Feature['summary']
+>
+
+export type AnyFeatureSlotTarget = FeatureSlotTarget<AnyProvideableFeature>
+
+export type SlotTarget = AnyComposition | AnyFeatureSlotTarget
+
+export type CompositionOfSlotTarget<Target extends SlotTarget> = Target extends AnyComposition
+  ? Target
+  : Target extends AnyFeatureSlotTarget
+    ? CompositionClass<
+        FeatureSummaryCompositionProps<Target['summary']>,
+        FeatureSummaryContract<Target['summary']>,
+        FeatureSummaryStates<Target['summary']>,
+        FeatureSummaryName<Target['summary']>,
+        FeatureSummaryCompositionIdentity<Target['summary']>
+      >
+    : never
+
+export type PropsOfSlotTarget<Target extends SlotTarget> = Target extends AnyComposition
+  ? Target['Props']
+  : Target extends AnyFeatureSlotTarget
+    ? FeatureSummaryMountProps<Target['summary']>
+    : never
+
+export type ContractOfSlotTarget<Target extends SlotTarget> = Target extends AnyComposition
+  ? Target['Contract']
+  : Target extends AnyFeatureSlotTarget
+    ? FeatureSummaryContract<Target['summary']>
+    : never
+
+export type SlotChild<Target extends SlotTarget> = Target extends AnyComposition
+  ? Target | (AnyFeatureBinding & { readonly composition: Target })
+  : Target extends AnyFeatureSlotTarget
+    ? AnyFeatureBinding & {
+        readonly summary: Target['summary']
+      }
+    : never
+
+export type AnySlotChild = AnyComposition | AnyFeatureBinding
+
+export interface AnySlotInstance {
+  readonly _slot: SlotTarget
+  readonly _slotName: string
+  readonly _slotIdentity: unknown
+}
+
+export interface SlotInstance<
+  Target extends SlotTarget,
+  N extends string,
+  Identity,
+> extends AnySlotInstance {
+  readonly _slot: Target
+  readonly _slotName: N
+  readonly _slotIdentity: Identity
 }
 
 export const SlotTypeId: unique symbol = Symbol.for('reform/Slot')
 export type SlotTypeId = typeof SlotTypeId
 
-export interface SlotClass<Comp extends AnyComposition = AnyComposition> {
-  new (): SlotInstance<Comp>
-  readonly [SlotTypeId]: SlotTypeId
+export const SlotServiceTypeId: unique symbol = Symbol.for('reform/SlotService')
+export type SlotServiceTypeId = typeof SlotServiceTypeId
+
+export interface SlotService<
+  N extends string,
+  Identity = unknown,
+  out Binding extends SlotBindingSummary = SlotBindingSummary,
+> {
+  readonly [SlotServiceTypeId]: {
+    readonly name: N
+    readonly identity: Identity
+    readonly binding: Binding
+  }
+}
+
+export interface SlotManifest<N extends string = string> extends Manifest {
   readonly kind: 'Slot'
-  readonly tag: Context.Tag<SlotChild, SlotChild>
+  readonly name: N
 }
 
-export const isSlot = (candidate: unknown): candidate is SlotClass =>
+export type SlotCapture<Result> = <Target extends SlotTarget, N extends string, Identity>(
+  slotDefinition: SlotClass<Target, N, Identity>,
+) => Result
+
+export interface AnySlot {
+  new (): AnySlotInstance
+  readonly [SlotTypeId]: SlotTypeId
+  readonly manifest: SlotManifest
+  readonly identity: symbol
+  readonly capture: <Result>(visit: SlotCapture<Result>) => Result
+}
+
+export interface SlotClass<Target extends SlotTarget, N extends string, Identity> {
+  new (): SlotInstance<Target, N, Identity>
+  readonly [SlotTypeId]: SlotTypeId
+  readonly manifest: SlotManifest<N>
+  readonly identity: symbol
+  readonly capture: <Result>(visit: SlotCapture<Result>) => Result
+  readonly tag: Context.Tag<SlotService<N, Identity>, SlotChild<Target>>
+  // Same runtime key, widened only after provide's typed overloads validate the child.
+  readonly provider: Context.Tag<SlotService<N, Identity>, AnySlotChild>
+}
+
+export const isSlot = (candidate: unknown): candidate is AnySlot =>
   (typeof candidate === 'function' || typeof candidate === 'object') &&
   candidate !== null &&
   SlotTypeId in candidate
 
-export type SlotProps<S> = S extends SlotInstance<infer Comp> ? Comp['Props'] : never
+export type TargetOfSlot<S> =
+  S extends SlotInstance<infer Target, infer _N, infer _Identity> ? Target : never
+
+export type SlotProps<S> =
+  S extends SlotInstance<infer Target, infer _N, infer _Identity>
+    ? PropsOfSlotTarget<Target>
+    : never
+
+export type SlotComposition<S> =
+  S extends SlotInstance<infer Target, infer _N, infer _Identity>
+    ? CompositionOfSlotTarget<Target>
+    : never
+
+export type SlotContract<S> =
+  S extends SlotInstance<infer Target, infer _N, infer _Identity>
+    ? ContractOfSlotTarget<Target>
+    : never
+
+const slotDefinitionSequence: MutableRef.MutableRef<number> = GlobalValue.globalValue(
+  Symbol.for('reform/SlotDefinitionSequence'),
+  () => MutableRef.make(0),
+)
+
+const nextSlotTagKey = (name: string): string =>
+  `reform/slot/${name}/${MutableRef.incrementAndGet(slotDefinitionSequence)}`
 
 export const slot =
-  (name: string) =>
-  <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 })
+  <const N extends string>(name: N) =>
+  <Self, Target extends SlotTarget = AnyComposition>(): SlotClass<Target, N, Self> => {
+    const key = nextSlotTagKey(name)
+    const identity = Symbol(name)
+    const tag = Context.GenericTag<SlotService<N, Self>, SlotChild<Target>>(key)
+    const provider = Context.GenericTag<SlotService<N, Self>, AnySlotChild>(key)
+    const manifest: SlotManifest<N> = { kind: 'Slot', name }
+    const slotDefinition: SlotClass<Target, N, Self> = definitionClass<SlotClass<Target, N, Self>>({
+      [SlotTypeId]: SlotTypeId,
+      manifest,
+      identity,
+      tag,
+      provider,
+      capture: <Result>(visit: SlotCapture<Result>): Result => visit(slotDefinition),
+    })
+    return slotDefinition
   }

package/src/compose/structure.test.ts

@@ -12,8 +12,8 @@ class Row extends Composition.make('Row', {
   title: 'Row',
   props: S.Struct({ label: S.String }),
   ui: RowUi,
-}) {}
-class RowSlot extends slot('Row')<typeof Row>() {}
+})<Row>() {}
+class RowSlot extends slot('Row')<RowSlot, typeof Row>() {}
 
 class ListUi extends ui('List')<{
   props: { total: number }
@@ -22,7 +22,10 @@ class ListUi extends ui('List')<{
 
 describe('structure combinators', () => {
   test('each produces one keyed entry per item, props mapped', () => {
-    const fill = each([{ id: 'a' }, { id: 'b' }], { key: (t) => t.id, props: (t) => ({ label: t.id }) })
+    const fill = each([{ id: 'a' }, { id: 'b' }], {
+      key: (t) => t.id,
+      props: (t) => ({ label: t.id }),
+    })
     expect(fill).toEqual({
       _tag: 'Each',
       items: [

package/src/compose/structure.ts

@@ -1,4 +1,5 @@
-import { Struct } from 'effect'
+import { Option, Struct } from 'effect'
+import { reuse } from '../internal/reuse'
 import type { SlotProps } from './slot'
 import type { EventsOf, UiContract } from './ui'
 
@@ -22,37 +23,129 @@ export type StructureSlots<C extends UiContract> = C extends {
   slots: infer S
 }
   ? { readonly [K in keyof S]: SlotFill<SlotProps<S[K]>> }
-  : Record<never, never>
+  : Readonly<Record<PropertyKey, never>>
 
-// events ride on the frame for hosts but are not serializable — excluded from structureEquals
-export interface Structure<C extends UiContract> {
+interface SerializableFrame<C extends UiContract> {
   readonly props: C['props']
   readonly slots: StructureSlots<C>
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- serializable frame shape; triggers ride optionally and the field is intentionally omitted from structureEquals
-  readonly events?: EventsOf<C>
 }
 
+interface TriggeredFrame<C extends UiContract> extends SerializableFrame<C> {
+  readonly events: EventsOf<C>
+}
+
+type MountFrame<C extends UiContract> = SerializableFrame<C> | TriggeredFrame<C>
+
 export const StructureTypeId: unique symbol = Symbol.for('reform/Structure')
 export type StructureTypeId = typeof StructureTypeId
 
-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)
+export interface Structure<C extends UiContract> {
+  readonly [StructureTypeId]: StructureTypeId
+  readonly props: C['props']
+  readonly slots: StructureSlots<C>
+  readonly events: EventsOf<C> | undefined
+}
+
+const frameEvents = <C extends UiContract>(frame: MountFrame<C>): Option.Option<EventsOf<C>> =>
+  'events' in frame ? Option.some(frame.events) : Option.none<EventsOf<C>>()
+
+export const mount = <C extends UiContract>(frame: MountFrame<C>): Structure<C> => ({
+  events: Option.getOrUndefined(frameEvents(frame)),
+  props: frame.props,
+  slots: frame.slots,
+  [StructureTypeId]: StructureTypeId,
+})
 
-// 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
 }
 
-export const each = <T, P>(collection: Iterable<T>, options: EachOptions<T, P>): EachFill<P> => ({
+interface EachRetention {
+  readonly elements: ReadonlyArray<unknown>
+  readonly fill: unknown
+}
+
+interface CollectionRetentions {
+  readonly byProps: WeakMap<object, WeakMap<object, EachRetention>>
+}
+
+// Stable collection and callback identities retain unchanged fills by reference.
+const eachRetentions = new WeakMap<object, CollectionRetentions>()
+const latestEachRetentions = new WeakMap<object, EachRetention>()
+
+const hasIdentity = (candidate: unknown): candidate is object =>
+  (typeof candidate === 'object' && candidate !== null) || typeof candidate === 'function'
+
+const collectionRetentionsFor = (collection: unknown): CollectionRetentions | undefined => {
+  if (!hasIdentity(collection)) {
+    return undefined
+  }
+  return (
+    eachRetentions.get(collection) ?? {
+      byProps: new WeakMap<object, WeakMap<object, EachRetention>>(),
+    }
+  )
+}
+
+const sameElements = (previous: ReadonlyArray<unknown>, next: ReadonlyArray<unknown>): boolean =>
+  previous.length === next.length &&
+  previous.every((element, index) => Object.is(element, next[index]))
+
+const isEachFill = <P>(candidate: unknown): candidate is EachFill<P> =>
+  isRecord(candidate) &&
+  candidate['_tag'] === 'Each' &&
+  Array.isArray(candidate['items']) &&
+  candidate['items'].every(
+    (entry) => isRecord(entry) && typeof entry['key'] === 'string' && 'props' in entry,
+  )
+
+const materializeEach = <T, P>(
+  elements: ReadonlyArray<T>,
+  options: EachOptions<T, P>,
+): EachFill<P> => ({
   _tag: 'Each',
-  items: Array.from(collection, (element) => ({
+  items: elements.map((element) => ({
     key: options.key(element),
     props: options.props(element),
   })),
 })
 
+const retainEach = <P>(previous: unknown, next: EachFill<P>): EachFill<P> => {
+  if (!isEachFill<P>(previous)) {
+    return next
+  }
+  if (deepEquals({ left: previous, right: next })) {
+    return previous
+  }
+  return reuse(previous, next)
+}
+
+export const each = <T, P>(collection: Iterable<T>, options: EachOptions<T, P>): EachFill<P> => {
+  const elements = Array.from(collection)
+  const collectionRetentions = collectionRetentionsFor(collection)
+  const retained = collectionRetentions?.byProps.get(options.props)?.get(options.key)
+  const latest = hasIdentity(collection) ? latestEachRetentions.get(collection) : undefined
+  if (
+    retained !== undefined &&
+    sameElements(retained.elements, elements) &&
+    isEachFill<P>(retained.fill)
+  ) {
+    return retained.fill
+  }
+  const fill = retainEach(retained?.fill ?? latest?.fill, materializeEach(elements, options))
+  if (hasIdentity(collection) && collectionRetentions !== undefined) {
+    const byKey =
+      collectionRetentions.byProps.get(options.props) ?? new WeakMap<object, EachRetention>()
+    const retention = { elements, fill }
+    byKey.set(options.key, retention)
+    collectionRetentions.byProps.set(options.props, byKey)
+    eachRetentions.set(collection, collectionRetentions)
+    latestEachRetentions.set(collection, retention)
+  }
+  return fill
+}
+
 export const one = <P>(props: P): OneFill<P> => ({ _tag: 'One', props })
 
 export const absent: AbsentFill = { _tag: 'Absent' }
@@ -96,10 +189,10 @@ const deepEquals = ({ left, right }: ValuePair): boolean => {
   return false
 }
 
-// events intentionally excluded (fresh function identities would break settle fixpoint)
 export const structureEquals = (
   left: Structure<UiContract>,
   right: Structure<UiContract>,
 ): boolean =>
+  // Events are fresh trigger functions, so equality covers serializable frame data only.
   deepEquals({ left: left.props, right: right.props }) &&
   deepEquals({ left: left.slots, right: right.slots })

package/src/compose/ui.test.ts

@@ -1,6 +1,6 @@
-import { expect, test } from 'vitest'
-import { Schema as S } from 'effect'
-import { isUi, ui } from '../index'
+import { expect, it, test } from '@effect/vitest'
+import { Effect, Layer, Schema as S } from 'effect'
+import { isUi, provide, Ui, ui } from '../index'
 
 test('type-only `ui` carries no wire schema', () => {
   class CounterUi extends ui('Counter')<{ props: { count: number } }>() {}
@@ -28,3 +28,19 @@ test('schema `ui` with no events omits the events schema', () => {
   expect(S.isSchema(TitleUi.manifest.props)).toBe(true)
   expect(TitleUi.manifest.events).toBeUndefined()
 })
+
+it.live('same-shaped UI definitions resolve their own views', () => {
+  class FirstUi extends ui('UiNominalFirst')<{ props: { label: string } }>() {}
+  class SecondUi extends ui('UiNominalSecond')<{ props: { label: string } }>() {}
+  const FirstView = Ui.make(FirstUi, ({ label }) => `first:${label}`)
+  const SecondView = Ui.make(SecondUi, ({ label }) => `second:${label}`)
+  const Live = Layer.mergeAll(provide(FirstUi, FirstView), provide(SecondUi, SecondView))
+
+  return Effect.gen(function* () {
+    const first = yield* FirstUi.impl
+    const second = yield* SecondUi.impl
+
+    expect(first({ label: 'value' }, {}, {})).toBe('first:value')
+    expect(second({ label: 'value' }, {}, {})).toBe('second:value')
+  }).pipe(Effect.provide(Live))
+})