@playfast/reform 1.3.0 → 1.4.1

package/src/channel/channel-throttle-frames.test.ts

@@ -0,0 +1,163 @@
+import { expect, it } from '@effect/vitest'
+import { Clock, Duration, Effect, Layer, Option, Schema as S, TestClock } from 'effect'
+import { Channel, Engine, Event, Procedure } from '../index'
+import { Channels } from './channel'
+
+// The drain loop notifies on the macrotask/microtask queue; draining turns is
+// exact where a duration would be a guess.
+const settle = Effect.yieldNow().pipe(Effect.repeatN(30))
+
+// `runtime/loop.ts` hands a whole frame to a channel as N synchronous `offer`
+// calls:
+//
+//   ordered.forEach((envelope) => {
+//     procedures.channelsFor(envelope.event._tag).forEach((channelName) => {
+//       channels.get(channelName)?.offer(envelope.event)
+//     })
+//   })
+//
+// Reaching the registration is that exact code path — it only removes the
+// scheduling luck of getting N publishes into one `Queue.takeAll`. Everything
+// downstream (the queue, the policy stream, `runMatching`) is untouched.
+const offerFrame = (
+  name: string,
+  events: ReadonlyArray<{ readonly _tag: string }>,
+): Effect.Effect<void, never, Channels> =>
+  Effect.gen(function* () {
+    const channels = yield* Channels
+    yield* Option.match(Option.fromNullable(channels.byName.get(name)), {
+      onNone: () => Effect.dieMessage(`reform: no live channel '${name}'`),
+      onSome: (registration) =>
+        Effect.sync(() => {
+          events.forEach((event) => registration.offer(event))
+        }),
+    })
+  })
+
+const throttlePolicy = (
+  units: number,
+  strategy: Option.Option<'enforce' | 'shape'>,
+): Channel.ChannelPolicy => ({
+  _tag: 'throttle',
+  units,
+  duration: Duration.seconds(1),
+  cost: Option.none(),
+  burst: Option.none(),
+  strategy,
+})
+
+// ---------------------------------------------------------------------------
+// BUG 1 — a throttled lane charges the whole frame as one indivisible chunk,
+// so an `enforce` lane drops events it had the budget to admit.
+//
+// `channel.ts` throttles the raw event stream, which `Stream.fromQueue` emits
+// one chunk per frame. `cost: (chunk) => Chunk.size(chunk) * cost` prices the
+// frame, and `enforce` drops any chunk it cannot pay for *in full*. A lane
+// rated `2 per second` therefore admits 2 of 3 events when they arrive in
+// three frames, and 0 of 3 when the same three arrive in one frame.
+// ---------------------------------------------------------------------------
+it.effect('a throttle lane admits the events a frame has budget for', () => {
+  class Tick extends Event.make('HuntEnforceTick', S.Struct({ n: S.Number })) {}
+  class Spread extends Channel.make('HuntEnforceSpread', {
+    policy: throttlePolicy(2, Option.some('enforce' as const)),
+  }) {}
+  class Burst extends Channel.make('HuntEnforceBurst', {
+    policy: throttlePolicy(2, Option.some('enforce' as const)),
+  }) {}
+  class SpreadWork extends Procedure.make('HuntEnforceSpreadWork', {
+    events: [Tick],
+    channel: Spread,
+  }) {}
+  class BurstWork extends Procedure.make('HuntEnforceBurstWork', {
+    events: [Tick],
+    channel: Burst,
+  }) {}
+
+  const spread: Array<number> = []
+  const burst: Array<number> = []
+  const layer = Layer.mergeAll(
+    Channel.live(Spread),
+    Channel.live(Burst),
+    Procedure.live(SpreadWork, function* (event) {
+      spread.push(event.n)
+    }),
+    Procedure.live(BurstWork, function* (event) {
+      burst.push(event.n)
+    }),
+  ).pipe(Layer.provideMerge(Engine))
+
+  const ticks = [
+    Event.construct(Tick, { n: 1 }),
+    Event.construct(Tick, { n: 2 }),
+    Event.construct(Tick, { n: 3 }),
+  ]
+
+  return Effect.gen(function* () {
+    // Control: the same three events, one per frame, on the same policy.
+    yield* Effect.forEach(ticks, (tick) =>
+      offerFrame('HuntEnforceSpread', [tick]).pipe(Effect.zipRight(settle)),
+    )
+    // The bucket holds 2 units and the clock never moves, so 1 and 2 are
+    // admitted and 3 is dropped. This is what `enforce` is supposed to do.
+    expect(spread).toEqual([1, 2])
+
+    // Same policy, same three events, one frame.
+    yield* offerFrame('HuntEnforceBurst', ticks)
+    yield* settle
+    yield* TestClock.adjust(Duration.seconds(10))
+    yield* settle
+
+    // The lane has the same 2 units of budget, so 1 and 2 must run. Today the
+    // queue hands the parked stream `[1]` and then `[2, 3]`: the second chunk
+    // is priced at 2 against the 1 unit left, cannot be paid for in full, and
+    // is discarded whole — event 2 is dropped even though the lane had exactly
+    // the budget for it, and it never comes back.
+    expect(burst).toEqual([1, 2])
+  }).pipe(Effect.provide(layer))
+})
+
+// ---------------------------------------------------------------------------
+// BUG 2 — the same whole-frame pricing makes the default `shape` strategy
+// stall the head of a frame and then release the frame simultaneously.
+//
+// On a lane rated `1 per second`, three events in one frame produce: no run at
+// t=0 (the frame waits until it can pay for all three) and then three runs
+// starting together at t=2000. Both halves are wrong: the bucket starts full so
+// the first event is owed an immediate run, and three concurrent starts inside
+// one second is the opposite of the rate the policy declares.
+// ---------------------------------------------------------------------------
+it.effect('a throttle lane paces a frame instead of releasing it at once', () => {
+  class Tick extends Event.make('HuntShapeTick', S.Struct({ n: S.Number })) {}
+  class Lane extends Channel.make('HuntShapeLane', {
+    policy: throttlePolicy(1, Option.none()),
+  }) {}
+  class Work extends Procedure.make('HuntShapeWork', { events: [Tick], channel: Lane }) {}
+
+  const startedAt: Array<number> = []
+  const layer = Layer.mergeAll(
+    Channel.live(Lane),
+    Procedure.live(Work, function* () {
+      const now = yield* Clock.currentTimeMillis
+      startedAt.push(now)
+    }),
+  ).pipe(Layer.provideMerge(Engine))
+
+  return Effect.gen(function* () {
+    yield* offerFrame('HuntShapeLane', [
+      Event.construct(Tick, { n: 1 }),
+      Event.construct(Tick, { n: 2 }),
+      Event.construct(Tick, { n: 3 }),
+    ])
+    yield* settle
+
+    // The token bucket starts full, so the head of the frame owes no wait.
+    expect(startedAt).toEqual([0])
+
+    yield* TestClock.adjust(Duration.seconds(10))
+    yield* settle
+
+    expect(startedAt).toHaveLength(3)
+    // A lane rated `1 per second` must never start two runs in the same instant.
+    expect(new Set(startedAt).size).toBe(3)
+  }).pipe(Effect.provide(layer))
+})

package/src/channel/channel.ts

@@ -186,6 +186,11 @@ export const live = (channel: ChannelClass): Layer.Layer<never, never, Channels
         ),
         Match.tag('throttle', (policy) =>
           events.pipe(
+            // One event per chunk. The drain hands a whole frame over as N offers,
+            // which arrives as one chunk; `Stream.throttle` prices a chunk whole and
+            // drops (or delays) any it cannot pay for in full, so a frame of three on
+            // a lane rated `2 per second` loses all three rather than admitting two.
+            Stream.rechunk(1),
             Stream.throttle({
               cost: (chunk) => Chunk.size(chunk) * Option.getOrElse(policy.cost, () => 1),
               units: policy.units,

package/src/compose/compose-identity.test.ts

@@ -0,0 +1,175 @@
+import { expect, it } from '@effect/vitest'
+import { Data, Effect, Layer, Option, Schema as S } from 'effect'
+import {
+  absent,
+  AsyncCalc,
+  Boundary,
+  Composition,
+  each,
+  mount,
+  provide,
+  slot,
+  State,
+  StateGroup,
+  structureEquals,
+  Ui,
+  ui,
+} from '../index'
+import type { Contract } from './ui'
+import { makeFlightGate, until } from '../testkit/flight.testkit'
+
+// ---------------------------------------------------------------------------
+// 1. compose/composition.ts:78 — `parseProps` is built with `decodeUnknownOption`,
+//    so it parses the schema's ENCODED side. But `PropsOf<Config>` (and therefore
+//    `CompositionClass['Props']`, `RenderEnv.props`, `SlotProps`, and every
+//    `one(...)`/`each(...)` fill) is the schema's TYPE side, and every call site
+//    (react/compose.ts:198, proof/engineSink.ts:137, reform-remote/wireRender.ts:63,
+//    feature/featureFactory.ts:62) hands it an already-decoded Type value. This is
+//    the same defect the package already fixed for `State` (state.ts:105, "check the
+//    Type side — decodeUnknownSync would reject transforming schemas") and `Event`
+//    (event.ts:53); the props path was missed. A composition whose props schema is
+//    not an identity transform can never render.
+
+const propsSchema = S.Struct({ count: S.NumberFromString })
+
+class StampUi extends ui('hunt.StampUi')<{ props: { readonly count: number } }>() {}
+class Stamp extends Composition.make('hunt.Stamp', {
+  title: 'Stamp',
+  props: propsSchema,
+  ui: StampUi,
+})<Stamp>() {}
+
+it('composition: parseProps accepts the props value its own Props type declares', () => {
+  // The declared Props type of this composition is `{ count: number }` — this
+  // assignment is what the framework's own typing promises a parent may render with.
+  const props: typeof Stamp.Props = { count: 3 }
+  // `Schema.validateOption` — what State/Event/`makeFeatureInputParser` use for an
+  // already-decoded domain value — accepts it:
+  expect(S.validateOption(propsSchema)(props)).toEqual(Option.some({ count: 3 }))
+  // `parseProps` accepts only the ENCODED form, which no call site ever holds:
+  expect(Stamp.parseProps({ count: '3' })).toEqual(Option.some({ count: 3 }))
+  expect(Stamp.parseProps(props)).toEqual(Option.some({ count: 3 }))
+})
+
+// ---------------------------------------------------------------------------
+// 2. compose/ui.ts:150-151 — a Ui contract's runtime tag key is `reform/ui/${name}`
+//    with no per-definition discriminator, unlike `slot()` (slot.ts:150) and
+//    `Composition.make` (composition.ts:57) which both mint a sequenced key so that
+//    independently authored same-name definitions stay distinct. Two features that
+//    each declare `ui('Header')` silently share one provider entry: the last
+//    `provide` wins and the wrong view renders for the other contract.
+
+it.live('ui: independently authored same-name contracts resolve their own views', () => {
+  class First extends ui('hunt.Header')<{ props: { readonly label: string } }>() {}
+  class Second extends ui('hunt.Header')<{ props: { readonly label: string } }>() {}
+  const FirstView = Ui.make(First, ({ label }) => `first:${label}`)
+  const SecondView = Ui.make(Second, ({ label }) => `second:${label}`)
+  const Live = Layer.mergeAll(provide(First, FirstView), provide(Second, SecondView))
+  return Effect.gen(function* () {
+    const first = yield* First.impl
+    const second = yield* Second.impl
+    expect(second({ label: 'x' }, {}, {})).toBe('second:x')
+    expect(first({ label: 'x' }, {}, {})).toBe('first:x')
+  }).pipe(Effect.provide(Live))
+})
+
+// ---------------------------------------------------------------------------
+// 3. calc/queryState.ts:37 read through boundary/boundary.ts:194 — when the inputs
+//    move, a withheld previous-key result reads Loading, so the Boundary re-pends.
+//    `keepPreviousData: true` is documented as retaining the previous key's PAYLOAD
+//    ("safe when the payload is only displayed"), but the same switch also republishes
+//    the previous key's ERROR as the new key's `Error` arm. Here nothing is being
+//    "kept" — the failed key produced no data at all — yet the Boundary reports
+//    Errored for a key that is still in flight and has never failed.
+
+class Boom extends Data.TaggedError('hunt.Boom')<{ readonly detail: string }> {}
+
+const keyGate = makeFlightGate()
+Effect.runSync(keyGate.hold)
+
+it.live('boundary: a previous key’s error must not gate the key now in flight', () => {
+  class Subject extends State.make('subject', S.Number) {}
+  class Inputs extends StateGroup.make(Subject) {}
+  class Q extends AsyncCalc.make('hunt.Q', {
+    inputs: [StateGroup.select(Inputs, 'subject')],
+    output: S.Number,
+    error: S.instanceOf(Boom),
+    alwaysOn: true,
+  }) {}
+  class Gate extends Boundary.make('hunt.Gate', { over: [Q] }) {}
+  const TestLayer = Boundary.live(Gate).pipe(
+    Layer.provideMerge(
+      AsyncCalc.live(Q, {
+        keepPreviousData: true,
+        query: ({ subject }) =>
+          subject === 1
+            ? Effect.fail(new Boom({ detail: 'subject-1 failed' }))
+            : keyGate.through(Effect.succeed(subject)),
+      }),
+    ),
+    Layer.provideMerge(StateGroup.live(Inputs, { subject: 1 })),
+  )
+  return Effect.gen(function* () {
+    const subject = yield* StateGroup.select(Inputs, 'subject').store
+    const qStore = yield* Q.store
+    const store = yield* Gate.store
+
+    yield* until(
+      () => store.get()._tag,
+      (t) => t === 'Errored',
+    )
+
+    subject.set(2)
+    // The gate proves the query for subject 2 is parked in flight and has never settled.
+    yield* keyGate.awaitEntry(1)
+    expect(store.get()._tag).toBe('Pending')
+    // Root cause: the arm itself reports key 1's failure as key 2's state.
+    expect(qStore.get()._tag).not.toBe('Error')
+
+    yield* keyGate.release
+    yield* until(
+      () => store.get()._tag,
+      (t) => t === 'Ready',
+    )
+  }).pipe(Effect.provide(TestLayer))
+})
+
+// ---------------------------------------------------------------------------
+// 4. compose/structure.ts:170-186 — `deepEquals` classifies every non-array object as
+//    a bag of own enumerable keys, so any value that carries its data outside such keys
+//    (Date, Map, Set, class instances) compares EQUAL to every other value of its kind.
+//    That verdict feeds `retainEach` (structure.ts:114), which then hands back the
+//    PREVIOUS render's fill: `each` returns props holding a stale value, not merely a
+//    stale equality answer.
+
+class StampedUi extends ui('hunt.StampedUi')<{ props: { readonly at: Date } }>() {}
+class Stamped extends Composition.make('hunt.Stamped', {
+  title: 'Stamped',
+  ui: StampedUi,
+})<Stamped>() {}
+class RowSlot extends slot('Row')<RowSlot, typeof Stamped>() {}
+class BoardUi extends ui('hunt.BoardUi')<{
+  props: { readonly at: Date }
+  slots: { Row: RowSlot }
+}>() {}
+type Board = Contract<typeof BoardUi>
+
+it('each: a changed prop value must not be retained from the previous fill', () => {
+  const rows = [{ id: 'a' }]
+  const first = each(rows, {
+    key: (row) => row.id,
+    props: (row) => ({ at: new Date(1), id: row.id }),
+  })
+  const second = each(rows, {
+    key: (row) => row.id,
+    props: (row) => ({ at: new Date(2), id: row.id }),
+  })
+  expect(first.items[0]?.props.at.getTime()).toBe(1)
+  expect(second.items[0]?.props.at.getTime()).toBe(2)
+})
+
+it('structureEquals: frames whose props differ must not compare equal', () => {
+  const left = mount<Board>({ props: { at: new Date(1) }, slots: { Row: absent } })
+  const right = mount<Board>({ props: { at: new Date(2) }, slots: { Row: absent } })
+  expect(structureEquals(left, right)).toBe(false)
+})

package/src/compose/composition.ts

@@ -50,7 +50,6 @@ export type {
   SlotClassesOf,
 } from './compositionTypes'
 
-
 const compositionDefinitionSequence: MutableRef.MutableRef<number> = GlobalValue.globalValue(
   Symbol.for('reform/CompositionDefinitionSequence'),
   () => MutableRef.make(0),
@@ -75,8 +74,14 @@ export const make =
     const propsSchema = Schema.make<PropsOf<Config>, EncodedPropsOf<Config>>(
       config.props?.ast ?? Schema.Unknown.ast,
     )
-    const parseProps: (input: unknown) => Option.Option<PropsOf<Config>> =
-      Schema.decodeUnknownOption(propsSchema)
+    // Both sides. `PropsOf<Config>` — and so every value a parent renders with — is
+    // the schema's Type, which is what the in-process call sites hold; a decode-only
+    // parser rejects a transforming props schema's own declared props. Props
+    // arriving over the wire are Encoded, so that reading has to keep working too.
+    const validateProps = Schema.validateOption(propsSchema)
+    const decodeProps = Schema.decodeUnknownOption(propsSchema)
+    const parseProps = (input: unknown): Option.Option<PropsOf<Config>> =>
+      Option.orElse(validateProps(input), () => decodeProps(input))
     const tag = Context.GenericTag<
       CompositionId<N, Self, RequiredSlotIdentities<C>>,
       CompositionService<PropsOf<Config>, C>
@@ -100,7 +105,6 @@ export const make =
     return composition
   }
 
-
 export const live = <
   P,
   C extends UiContract,

package/src/compose/structure.ts

@@ -1,4 +1,4 @@
-import { Option, Struct } from 'effect'
+import { Equal, Option, Struct } from 'effect'
 import { reuse } from '../internal/reuse'
 import type { SlotProps } from './slot'
 import type { EventsOf, UiContract } from './ui'
@@ -164,6 +164,29 @@ interface ValuePair {
   readonly right: unknown
 }
 
+// A structural comparison is only meaningful over own enumerable keys when those
+// keys are the whole value — true of JSON-shaped records, false of everything
+// carrying its state anywhere else.
+const isPlainRecord = (candidate: unknown): candidate is Record<string, unknown> => {
+  if (!isRecord(candidate)) {
+    return false
+  }
+  const prototype = Object.getPrototypeOf(candidate)
+  return prototype === Object.prototype || prototype === null
+}
+
+const recordEntriesEqual = (
+  left: Record<string, unknown>,
+  right: Record<string, unknown>,
+  leftKeys: ReadonlyArray<string>,
+): boolean =>
+  leftKeys.length === Struct.keys(right).length &&
+  leftKeys.every(
+    (key) =>
+      Object.prototype.hasOwnProperty.call(right, key) &&
+      deepEquals({ left: left[key], right: right[key] }),
+  )
+
 const deepEquals = ({ left, right }: ValuePair): boolean => {
   if (Object.is(left, right)) {
     return true
@@ -174,19 +197,28 @@ const deepEquals = ({ left, right }: ValuePair): boolean => {
       left.every((element, index) => deepEquals({ left: element, right: right[index] }))
     )
   }
-  if (isRecord(left) && isRecord(right)) {
-    const leftKeys = Struct.keys(left)
-    const rightKeys = Struct.keys(right)
-    return (
-      leftKeys.length === rightKeys.length &&
-      leftKeys.every(
-        (key) =>
-          Object.prototype.hasOwnProperty.call(right, key) &&
-          deepEquals({ left: left[key], right: right[key] }),
-      )
-    )
+  if (isPlainRecord(left) && isPlainRecord(right)) {
+    return recordEntriesEqual(left, right, Struct.keys(left))
+  }
+  // Not a plain record. Own enumerable keys describe nothing about a `Date`, `Map` or
+  // `Set` — comparing by them calls every one of them empty, and so equal — so ask
+  // the value itself first.
+  if (Equal.equals(left, right)) {
+    return true
   }
-  return false
+  // Effect containers say no whenever they wrap a freshly allocated record, because
+  // their own equality bottoms out in reference identity. They do carry their payload
+  // in own properties, so descend: two structurally equal `Option.some({…})` are the
+  // same frame. A value with no own keys (a `Date`, a `Map`) has already answered.
+  if (!isRecord(left) || !isRecord(right)) {
+    return false
+  }
+  const leftKeys = Struct.keys(left)
+  return (
+    leftKeys.length > 0 &&
+    Object.getPrototypeOf(left) === Object.getPrototypeOf(right) &&
+    recordEntriesEqual(left, right, leftKeys)
+  )
 }
 
 export const structureEquals = (

package/src/compose/ui.ts

@@ -1,5 +1,5 @@
 import type { FunctionComponent } from 'react'
-import { Context, type Schema } from 'effect'
+import { Context, GlobalValue, MutableRef, type Schema } from 'effect'
 import type { AST } from 'effect/SchemaAST'
 import { type Manifest, definitionClass } from '../definition/definition'
 import type { Trigger } from '../ui/trigger'
@@ -139,6 +139,18 @@ type UiDefinitionStatics<
   typeof UiTypeId | 'manifest' | 'impl' | 'provider' | 'capture'
 >
 
+// Same rationale as `slot()` and `Composition.make`: two independently authored
+// definitions that happen to share a name are two contracts, not one. Keying the
+// runtime tag by name alone collapses them, and the last `provide` wins silently.
+// The wire still identifies a view by `manifest.name`, which is untouched.
+const uiDefinitionSequence: MutableRef.MutableRef<number> = GlobalValue.globalValue(
+  Symbol.for('reform/UiDefinitionSequence'),
+  () => MutableRef.make(0),
+)
+
+const nextUiTagKey = (name: string): string =>
+  `reform/ui/${name}/${MutableRef.incrementAndGet(uiDefinitionSequence)}`
+
 const buildUi = <
   N extends string,
   C extends UiContract,
@@ -147,8 +159,9 @@ const buildUi = <
   name: N,
   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 key = nextUiTagKey(name)
+  const impl = Context.GenericTag<UiService<N>, ViewImpl<C>>(key)
+  const provider = Context.GenericTag<UiService<N>, CallableView>(key)
   const contract = definitionClass<UiClass<C, N> & { readonly manifest: M }>({
     [UiTypeId]: UiTypeId,
     manifest,
@@ -213,8 +226,12 @@ 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, {
+  // Branded on a fresh wrapper rather than on `view` itself: the caller's function is
+  // theirs, and attaching in place lets a second `Ui.make` over the same view rebrand
+  // the first contract's binding out from under it.
+  const wrapped: ViewImpl<Contract<U>> = (props, slots, events) => view(props, slots, events)
+  // oxlint-disable-next-line reform-rules/no-object-assign -- `wrapped` is callable; spread would drop callability, so its reflection statics are attached in place
+  const made: MadeView<Contract<U>, UiName<U>, U> = Object.assign(wrapped, {
     [UiViewContract]: contract,
     capture: <Result>(visit: MadeViewCapture<Result>): Result => visit(made),
   })

package/src/event/event.ts

@@ -1,9 +1,10 @@
 import { Effect, Layer, MutableRef, Option, PubSub, Runtime, Schema } from 'effect'
 import { type Manifest, definitionClass } from '../definition/definition'
-import { resolveScheduler } from '../internal/scheduler'
+import { resolveScheduler, withInlineNotifications } from '../internal/scheduler'
 import { Bus, publish, type Tagged } from '../runtime/bus'
+import { applyReducers, Reducers } from '../runtime/loop'
 import type { Source } from '../state/token'
-import type { Trigger } from '../ui/trigger'
+import { taggedTrigger, type Trigger } from '../ui/trigger'
 
 export type EventOf<N extends string, P> = Tagged & { readonly _tag: N } & P
 
@@ -52,12 +53,40 @@ export const make = <const N extends string, P, Encoded>(
   // (e.g. a real Option, whose _tag lives on the prototype).
   const validatePayload = Schema.validateSync(schema)
   const buildUnknown = (payload: unknown): Tagged => build(validatePayload(payload))
+  // A trigger is the UI's edge of the loop: it runs inside a discrete DOM event, and
+  // React decides what the DOM should look like before that event finishes. Deferring
+  // the reducer to the drain fiber means the props React reads back are one turn stale,
+  // which is what rewrites a controlled input's value and drops the caret to the end.
+  // So reducers for this one event run here, before the trigger returns, and the
+  // envelope goes out marked `reduced` for the channel/procedure half. Every batched
+  // path — `Event.dispatch`, procedure fan-out, streams — is untouched and still
+  // coalesces on the drain loop.
   const trigger = Effect.gen(function* () {
     const bus = yield* Bus
+    // Optional: a bus can be provided without a reducer registry (bare harnesses,
+    // some test layers), and those keep the original deferred behaviour.
+    const reducers = yield* Effect.serviceOption(Reducers)
     const runtime = yield* Effect.runtime<never>()
-    return (payload: P) => {
-      Runtime.runSync(runtime)(PubSub.publish(bus, { priority: 'High', event: build(payload) }))
-    }
+    return taggedTrigger(name, (payload: P) => {
+      const built = build(payload)
+      const reduced = Option.match(reducers, {
+        onNone: () => false,
+        onSome: (registry) =>
+          withInlineNotifications(() => {
+            const failures = applyReducers({ registry, event: built })
+            failures.forEach((failure) =>
+              Effect.runSync(
+                Effect.logError(
+                  `reform: reducer threw handling '${failure.event._tag}'`,
+                  failure.error,
+                ),
+              ),
+            )
+            return true
+          }),
+      })
+      Runtime.runSync(runtime)(PubSub.publish(bus, { priority: 'High', event: built, reduced }))
+    })
   })
   const event: EventClass<N, P> = definitionClass<EventClass<N, P>>({
     manifest: { kind: 'Event' as const, name, schema },

package/src/event/syncTrigger.test.ts

@@ -0,0 +1,66 @@
+import { Effect, Layer, MutableRef, Schema as S } from 'effect'
+import { it } from '@effect/vitest'
+import { describe, expect } from 'vitest'
+import { until } from '../testkit/flight.testkit'
+import { Engine } from '../runtime/loop'
+import { publish } from '../runtime/bus'
+import * as Event from './event'
+import * as Reducer from '../reducer/reducer'
+import * as State from '../state/state'
+
+class Counter extends State.make('sync-trigger-counter', S.Number) {}
+class Bumped extends Event.make('SyncTriggerBumped', S.Struct({ to: S.Number })) {}
+class Fold extends Reducer.make('SyncTriggerFold', {
+  states: [Counter],
+  events: [Bumped],
+}) {}
+
+const makeLayer = (runs: MutableRef.MutableRef<number>) =>
+  Reducer.live(Fold, (_current: number, event: { readonly to: number }) => {
+    MutableRef.set(runs, MutableRef.get(runs) + 1)
+    return event.to
+  }).pipe(Layer.provideMerge(Layer.mergeAll(State.live(Counter, 0), Engine)))
+
+describe('synchronous trigger path', () => {
+  it.live('applies a reducer exactly once — the drain must not re-apply it', () => {
+    const runs = MutableRef.make(0)
+    return Effect.gen(function* () {
+      const bump = yield* Event.trigger(Bumped)
+      const store = yield* Counter.store
+
+      yield* Effect.sync(() => bump({ to: 7 }))
+
+      // Already applied before the trigger returned, with no turn of the loop.
+      expect(MutableRef.get(runs)).toBe(1)
+      expect(store.get()).toBe(7)
+
+      // The envelope still reaches the drain for channels and procedures; give it
+      // several turns and prove the reducer was not run a second time.
+      yield* until(
+        () => MutableRef.get(runs),
+        (count) => count > 1,
+        20,
+      )
+      expect(MutableRef.get(runs)).toBe(1)
+      expect(store.get()).toBe(7)
+    }).pipe(Effect.provide(makeLayer(runs)))
+  })
+
+  it.live('leaves Event.dispatch on the batched drain', () => {
+    const runs = MutableRef.make(0)
+    return Effect.gen(function* () {
+      const store = yield* Counter.store
+
+      yield* publish('Normal', Event.construct(Bumped, { to: 3 }))
+
+      // Nothing synchronous about this path: it is still the drain fiber's job.
+      expect(MutableRef.get(runs)).toBe(0)
+
+      yield* until(
+        () => store.get(),
+        (value) => value === 3,
+      )
+      expect(MutableRef.get(runs)).toBe(1)
+    }).pipe(Effect.provide(makeLayer(runs)))
+  })
+})