npm - @playfast/reform - Versions diffs - 0.0.7 → 0.0.8 - Mend

@playfast/reform 0.0.7 → 0.0.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (237) hide show

package/package.json +2 -2
package/src/boundary/boundary.test.ts +301 -0
package/src/boundary/boundary.ts +192 -0
package/src/calc/asyncCalc.test.ts +556 -0
package/src/calc/asyncCalc.ts +267 -0
package/src/calc/asyncData.ts +96 -0
package/src/calc/calc.test.ts +287 -0
package/src/calc/calc.ts +120 -0
package/src/calc/calcFamily.test.ts +206 -0
package/src/calc/calcFamily.ts +194 -0
package/src/calc/compose.test.ts +68 -0
package/src/calc/compose.ts +69 -0
package/src/channel/channel.ts +269 -0
package/src/compose/composition.ts +112 -0
package/{dist/compose/host.d.ts → src/compose/host.ts} +9 -8
package/{dist/compose/props.js → src/compose/props.ts} +7 -5
package/src/compose/provide.ts +70 -0
package/{dist/compose/slot.d.ts → src/compose/slot.ts} +36 -19
package/src/compose/ui.test.ts +62 -0
package/src/compose/ui.ts +226 -0
package/src/compose/ui.typecheck.ts +56 -0
package/src/definition/definition.ts +76 -0
package/src/event/event.test.ts +23 -0
package/src/event/event.ts +65 -0
package/src/event/eventGroup.ts +14 -0
package/src/feature/feature.mount.test.ts +82 -0
package/src/feature/feature.test.ts +60 -0
package/{dist/feature/feature.d.ts → src/feature/feature.ts} +178 -92
package/src/feature/feature.typecheck.ts +108 -0
package/src/index.ts +176 -0
package/{dist/internal/capture.d.ts → src/internal/capture.ts} +13 -11
package/{dist/internal/ctx.d.ts → src/internal/ctx.ts} +8 -4
package/src/internal/errors.test.ts +33 -0
package/src/internal/errors.ts +145 -0
package/src/internal/inspect.test.ts +28 -0
package/src/internal/inspect.ts +34 -0
package/src/internal/queryDriver.ts +247 -0
package/src/internal/reuse.test.ts +116 -0
package/src/internal/reuse.ts +73 -0
package/src/internal/scheduler.ts +93 -0
package/{dist/internal/seeds.d.ts → src/internal/seeds.ts} +6 -3
package/src/internal/sources.ts +104 -0
package/{dist/internal/stateRegistry.js → src/internal/stateRegistry.ts} +18 -14
package/src/internal/store.test.ts +80 -0
package/src/internal/store.ts +105 -0
package/{dist/internal/track.d.ts → src/internal/track.ts} +17 -11
package/src/procedure/procedure.ts +89 -0
package/src/reducer/reducer.ts +137 -0
package/src/remote/remoteState.test.ts +695 -0
package/src/remote/remoteState.ts +571 -0
package/src/remote/remoteState.typecheck.ts +195 -0
package/src/runtime/bus.ts +40 -0
package/src/runtime/hardening.test.ts +69 -0
package/src/runtime/loop.test.ts +178 -0
package/src/runtime/loop.ts +171 -0
package/src/scene/scene.ts +76 -0
package/src/scene/seedScene.test.ts +169 -0
package/src/state/state.ts +94 -0
package/src/state/stateFamily.test.ts +138 -0
package/src/state/stateFamily.ts +174 -0
package/src/state/stateGroup.ts +105 -0
package/{dist/state/token.d.ts → src/state/token.ts} +22 -13
package/src/synced/syncedStore.ts +99 -0
package/{dist/ui/node.d.ts → src/ui/node.ts} +3 -3
package/{dist/ui/trigger.d.ts → src/ui/trigger.ts} +1 -2
package/src/wire/tree.test.ts +81 -0
package/src/wire/tree.ts +129 -0
package/src/wire/triggers.test.ts +76 -0
package/src/wire/triggers.ts +98 -0
package/dist/boundary/boundary.d.ts +0 -72
package/dist/boundary/boundary.d.ts.map +0 -1
package/dist/boundary/boundary.js +0 -83
package/dist/boundary/boundary.js.map +0 -1
package/dist/calc/asyncCalc.d.ts +0 -91
package/dist/calc/asyncCalc.d.ts.map +0 -1
package/dist/calc/asyncCalc.js +0 -95
package/dist/calc/asyncCalc.js.map +0 -1
package/dist/calc/asyncData.d.ts +0 -57
package/dist/calc/asyncData.d.ts.map +0 -1
package/dist/calc/asyncData.js +0 -34
package/dist/calc/asyncData.js.map +0 -1
package/dist/calc/calc.d.ts +0 -57
package/dist/calc/calc.d.ts.map +0 -1
package/dist/calc/calc.js +0 -58
package/dist/calc/calc.js.map +0 -1
package/dist/calc/calcFamily.d.ts +0 -57
package/dist/calc/calcFamily.d.ts.map +0 -1
package/dist/calc/calcFamily.js +0 -124
package/dist/calc/calcFamily.js.map +0 -1
package/dist/calc/compose.d.ts +0 -16
package/dist/calc/compose.d.ts.map +0 -1
package/dist/calc/compose.js +0 -7
package/dist/calc/compose.js.map +0 -1
package/dist/channel/channel.d.ts +0 -115
package/dist/channel/channel.d.ts.map +0 -1
package/dist/channel/channel.js +0 -138
package/dist/channel/channel.js.map +0 -1
package/dist/compose/composition.d.ts +0 -72
package/dist/compose/composition.d.ts.map +0 -1
package/dist/compose/composition.js +0 -46
package/dist/compose/composition.js.map +0 -1
package/dist/compose/host.d.ts.map +0 -1
package/dist/compose/host.js +0 -6
package/dist/compose/host.js.map +0 -1
package/dist/compose/props.d.ts +0 -13
package/dist/compose/props.d.ts.map +0 -1
package/dist/compose/props.js.map +0 -1
package/dist/compose/provide.d.ts +0 -22
package/dist/compose/provide.d.ts.map +0 -1
package/dist/compose/provide.js +0 -28
package/dist/compose/provide.js.map +0 -1
package/dist/compose/slot.d.ts.map +0 -1
package/dist/compose/slot.js +0 -23
package/dist/compose/slot.js.map +0 -1
package/dist/compose/ui.d.ts +0 -135
package/dist/compose/ui.d.ts.map +0 -1
package/dist/compose/ui.js +0 -63
package/dist/compose/ui.js.map +0 -1
package/dist/definition/definition.d.ts +0 -33
package/dist/definition/definition.d.ts.map +0 -1
package/dist/definition/definition.js +0 -42
package/dist/definition/definition.js.map +0 -1
package/dist/event/event.d.ts +0 -33
package/dist/event/event.d.ts.map +0 -1
package/dist/event/event.js +0 -30
package/dist/event/event.js.map +0 -1
package/dist/event/eventGroup.d.ts +0 -9
package/dist/event/eventGroup.d.ts.map +0 -1
package/dist/event/eventGroup.js +0 -4
package/dist/event/eventGroup.js.map +0 -1
package/dist/feature/feature.d.ts.map +0 -1
package/dist/feature/feature.js +0 -98
package/dist/feature/feature.js.map +0 -1
package/dist/index.d.ts +0 -53
package/dist/index.d.ts.map +0 -1
package/dist/index.js +0 -62
package/dist/index.js.map +0 -1
package/dist/internal/capture.d.ts.map +0 -1
package/dist/internal/capture.js +0 -12
package/dist/internal/capture.js.map +0 -1
package/dist/internal/ctx.d.ts.map +0 -1
package/dist/internal/ctx.js +0 -2
package/dist/internal/ctx.js.map +0 -1
package/dist/internal/errors.d.ts +0 -89
package/dist/internal/errors.d.ts.map +0 -1
package/dist/internal/errors.js +0 -102
package/dist/internal/errors.js.map +0 -1
package/dist/internal/inspect.d.ts +0 -17
package/dist/internal/inspect.d.ts.map +0 -1
package/dist/internal/inspect.js +0 -32
package/dist/internal/inspect.js.map +0 -1
package/dist/internal/queryDriver.d.ts +0 -65
package/dist/internal/queryDriver.d.ts.map +0 -1
package/dist/internal/queryDriver.js +0 -134
package/dist/internal/queryDriver.js.map +0 -1
package/dist/internal/reuse.d.ts +0 -10
package/dist/internal/reuse.d.ts.map +0 -1
package/dist/internal/reuse.js +0 -68
package/dist/internal/reuse.js.map +0 -1
package/dist/internal/scheduler.d.ts +0 -47
package/dist/internal/scheduler.d.ts.map +0 -1
package/dist/internal/scheduler.js +0 -70
package/dist/internal/scheduler.js.map +0 -1
package/dist/internal/seeds.d.ts.map +0 -1
package/dist/internal/seeds.js +0 -17
package/dist/internal/seeds.js.map +0 -1
package/dist/internal/sources.d.ts +0 -39
package/dist/internal/sources.d.ts.map +0 -1
package/dist/internal/sources.js +0 -59
package/dist/internal/sources.js.map +0 -1
package/dist/internal/stateRegistry.d.ts +0 -2
package/dist/internal/stateRegistry.d.ts.map +0 -1
package/dist/internal/stateRegistry.js.map +0 -1
package/dist/internal/store.d.ts +0 -47
package/dist/internal/store.d.ts.map +0 -1
package/dist/internal/store.js +0 -73
package/dist/internal/store.js.map +0 -1
package/dist/internal/track.d.ts.map +0 -1
package/dist/internal/track.js +0 -19
package/dist/internal/track.js.map +0 -1
package/dist/procedure/procedure.d.ts +0 -40
package/dist/procedure/procedure.d.ts.map +0 -1
package/dist/procedure/procedure.js +0 -50
package/dist/procedure/procedure.js.map +0 -1
package/dist/reducer/reducer.d.ts +0 -44
package/dist/reducer/reducer.d.ts.map +0 -1
package/dist/reducer/reducer.js +0 -63
package/dist/reducer/reducer.js.map +0 -1
package/dist/remote/remoteState.d.ts +0 -119
package/dist/remote/remoteState.d.ts.map +0 -1
package/dist/remote/remoteState.js +0 -270
package/dist/remote/remoteState.js.map +0 -1
package/dist/runtime/bus.d.ts +0 -27
package/dist/runtime/bus.d.ts.map +0 -1
package/dist/runtime/bus.js +0 -21
package/dist/runtime/bus.js.map +0 -1
package/dist/runtime/loop.d.ts +0 -45
package/dist/runtime/loop.d.ts.map +0 -1
package/dist/runtime/loop.js +0 -117
package/dist/runtime/loop.js.map +0 -1
package/dist/scene/scene.d.ts +0 -44
package/dist/scene/scene.d.ts.map +0 -1
package/dist/scene/scene.js +0 -31
package/dist/scene/scene.js.map +0 -1
package/dist/state/state.d.ts +0 -37
package/dist/state/state.d.ts.map +0 -1
package/dist/state/state.js +0 -46
package/dist/state/state.js.map +0 -1
package/dist/state/stateFamily.d.ts +0 -79
package/dist/state/stateFamily.d.ts.map +0 -1
package/dist/state/stateFamily.js +0 -99
package/dist/state/stateFamily.js.map +0 -1
package/dist/state/stateGroup.d.ts +0 -50
package/dist/state/stateGroup.d.ts.map +0 -1
package/dist/state/stateGroup.js +0 -54
package/dist/state/stateGroup.js.map +0 -1
package/dist/state/token.d.ts.map +0 -1
package/dist/state/token.js +0 -20
package/dist/state/token.js.map +0 -1
package/dist/synced/syncedStore.d.ts +0 -51
package/dist/synced/syncedStore.d.ts.map +0 -1
package/dist/synced/syncedStore.js +0 -43
package/dist/synced/syncedStore.js.map +0 -1
package/dist/ui/node.d.ts.map +0 -1
package/dist/ui/node.js +0 -2
package/dist/ui/node.js.map +0 -1
package/dist/ui/trigger.d.ts.map +0 -1
package/dist/ui/trigger.js +0 -2
package/dist/ui/trigger.js.map +0 -1
package/dist/wire/tree.d.ts +0 -66
package/dist/wire/tree.d.ts.map +0 -1
package/dist/wire/tree.js +0 -60
package/dist/wire/tree.js.map +0 -1
package/dist/wire/triggers.d.ts +0 -44
package/dist/wire/triggers.d.ts.map +0 -1
package/dist/wire/triggers.js +0 -31
package/dist/wire/triggers.js.map +0 -1

package/src/state/stateGroup.ts ADDED Viewed

@@ -0,0 +1,105 @@
+import { Layer } from 'effect'
+import { definitionClass } from '../definition/definition'
+import { DuplicateRegistration, UnknownGroupState } from '../internal/errors'
+// A group's members each carry a `store` tag, so the shared `StoresOf` (used for
+// calc inputs too) distributes them into the union of distinct stores their
+// `live` layer provides — no group-specific mapped type needed.
+import { type StoresOf } from '../internal/sources'
+import { type AnyState, live as stateLive, type StateClass, type StateName } from './state'
+import { StateToken } from './token'
+type ValueForName<Members extends ReadonlyArray<AnyState>, N extends string> =
+  Extract<Members[number], StateClass<N, any>> extends StateClass<any, infer A> ? A : never
+export interface StateGroupClass<Members extends ReadonlyArray<AnyState>> {
+  new (): {}
+  readonly kind: 'StateGroup'
+  readonly members: Members
+  /** Members indexed by name, so `select` is an O(1) lookup instead of a scan. */
+  readonly byName: ReadonlyMap<string, AnyState>
+}
+export type AnyStateGroup = StateGroupClass<ReadonlyArray<AnyState>>
+/**
+ * Compile-time uniqueness guard for `StateGroup.make`. Member names key the tag,
+ * the seed record, `byName`, and `select` — duplicates are unaddressable, so a
+ * repeated name is replaced (positionally) by this marker tuple, which a real
+ * `StateClass` is not assignable to. The offending argument fails to typecheck
+ * with the colliding name spelled out in the message, rather than collapsing
+ * silently. Runtime `make` throws the same clash for seeds the root tsconfig
+ * never typechecks (test files live outside it).
+ */
+type DuplicateStateName<N extends string> = readonly ['reform: duplicate state name in group', N]
+type NoDuplicateNames<
+  Members extends ReadonlyArray<AnyState>,
+  Seen extends string = never,
+> = Members extends readonly [infer Head extends AnyState, ...infer Tail extends ReadonlyArray<AnyState>]
+  ? readonly [
+      StateName<Head> extends Seen ? DuplicateStateName<StateName<Head>> : Head,
+      ...NoDuplicateNames<Tail, Seen | StateName<Head>>,
+    ]
+  : readonly []
+// The seed record `StateGroup.live` requires: one entry per member, keyed by the
+// member's name and typed to that member's value (so a missing or mistyped seed
+// is a compile error). Written against the group class, so call sites read
+// `GroupSeeds<typeof TodosStates>`.
+export type GroupSeeds<G extends AnyStateGroup> =
+  G extends StateGroupClass<infer Members>
+    ? { readonly [N in StateName<Members[number]>]: ValueForName<Members, N> }
+    : never
+/** Compose atomic States into a group provided (and addressed) as a unit. */
+export const make = <const Members extends ReadonlyArray<AnyState>>(
+  ...members: Members & NoDuplicateNames<Members>
+): StateGroupClass<Members> => {
+  // `byName` already de-dupes, so a smaller map than the member list means two
+  // members claimed one name — unaddressable, and a silent footgun on merge.
+  const names = members.map((m) => m.manifest.name)
+  const duplicate = names.find((name, i) => names.indexOf(name) !== i)
+  if (duplicate !== undefined) throw new DuplicateRegistration({ kind: 'state in group', name: duplicate })
+  return definitionClass<StateGroupClass<Members>>({
+    kind: 'StateGroup' as const,
+    members,
+    byName: new Map(members.map((m) => [m.manifest.name, m] as const)),
+  })
+}
+/**
+ * Address a member by its tag — `StateGroup.select(TodosStates, 'feed')` —
+ * yielding a `StateToken` for reads and calc inputs (still `yield*`-able).
+ *
+ * Data-first only (not `dual`): the member name's type depends on the group, and
+ * a group is not `Pipeable`, so a data-last form would be both more verbose and
+ * harder to type than the direct call. Effect reserves `dual` for operators on a
+ * `Pipeable` self with an independent value arg (e.g. `ref.pipe(Ref.set(v))`);
+ * this is not that shape.
+ */
+export const select = <Members extends ReadonlyArray<AnyState>, N extends StateName<Members[number]>>(
+  group: StateGroupClass<Members>,
+  name: N,
+): StateToken<N, ValueForName<Members, N>> => {
+  const member = group.byName.get(name)
+  if (member === undefined) throw new UnknownGroupState({ name })
+  return new StateToken(name, member.store) as StateToken<N, ValueForName<Members, N>>
+}
+/**
+ * Allocate every member's store as one merged layer, each seeded from `seeds`
+ * keyed by member name — `StateGroup.live(BoardStates, { board: { _tag: 'Idle' } })`.
+ */
+export const live = <Members extends ReadonlyArray<AnyState>>(
+  group: StateGroupClass<Members>,
+  seeds: GroupSeeds<StateGroupClass<Members>>,
+): Layer.Layer<StoresOf<Members>> => {
+  // Index the typed seed record by the member's runtime name — a genuine
+  // reflection boundary (string key into a mapped type). Each member's store
+  // layer is then merged; the union of stores is exactly `StoresOf<Members>`,
+  // which `reduce`'s single-layer accumulator can't express, so restate it.
+  const seedRecord = seeds as Record<string, unknown>
+  return group.members
+    .map((m) => stateLive(m, seedRecord[m.manifest.name]))
+    .reduce((a, b) => Layer.merge(a, b)) as Layer.Layer<StoresOf<Members>>
+}

package/{dist/state/token.d.ts → src/state/token.ts} RENAMED Viewed

@@ -1,16 +1,25 @@
-import { Context, Effect, Effectable } from 'effect';
-import type { Store } from '../internal/store';
+import { Context, Effect, Effectable } from 'effect'
+import type { Store } from '../internal/store'
+import { readTracked } from '../internal/track'
 /**
  * A reference to one slice of state: yieldable to its current value (`yield*`
  * reads + — under React — subscribes) and carrying the metadata calcs need
  * (its `name` and backing store tag). Returned by `StateGroup.select(group, name)`.
  */
-export declare class StateToken<out N extends string, in out A> extends Effectable.Class<A, never, Store<A>> {
-    readonly name: N;
-    readonly store: Context.Tag<Store<A>, Store<A>>;
-    constructor(name: N, store: Context.Tag<Store<A>, Store<A>>);
-    commit(): Effect.Effect<A, never, Store<A>>;
+export class StateToken<out N extends string, in out A> extends Effectable.Class<A, never, Store<A>> {
+  readonly name: N
+  readonly store: Context.Tag<Store<A>, Store<A>>
+  constructor(name: N, store: Context.Tag<Store<A>, Store<A>>) {
+    super()
+    this.name = name
+    this.store = store
+  }
+  commit(): Effect.Effect<A, never, Store<A>> {
+    return Effect.flatMap(this.store, readTracked)
+  }
 }
 /**
  * Anything a derived value can read and depend on: a named slice backed by a
  * subscribable store tag. A `StateToken` (group member), a `Calc`, and an
@@ -21,10 +30,10 @@ export declare class StateToken<out N extends string, in out A> extends Effectab
  * satisfy the same shape so the three are interchangeable as calc inputs.
  */
 export interface Source<out N extends string, in out A> {
-    readonly name: N;
-    readonly store: Context.Tag<Store<A>, Store<A>>;
+  readonly name: N
+  readonly store: Context.Tag<Store<A>, Store<A>>
 }
-export type AnySource = Source<string, any>;
-export type SourceName<S> = S extends Source<infer N, any> ? N : never;
-export type SourceValue<S> = S extends Source<any, infer A> ? A : never;
-//# sourceMappingURL=token.d.ts.map
+export type AnySource = Source<string, any>
+export type SourceName<S> = S extends Source<infer N, any> ? N : never
+export type SourceValue<S> = S extends Source<any, infer A> ? A : never

package/src/synced/syncedStore.ts ADDED Viewed

@@ -0,0 +1,99 @@
+import { Context, Effect, Layer, type Schema, type Scope } from 'effect'
+import { type Manifest, yieldableClass } from '../definition/definition'
+import { resolveScheduler } from '../internal/scheduler'
+import { makeDerivedStore, type Store } from '../internal/store'
+import { readTracked } from '../internal/track'
+import type { Source } from '../state/token'
+import type { StateOptions } from '../state/state'
+// `SyncedStore` is the seam between Reform's reactive `Store` and any *external*
+// reactive source — a PGlite live query, a TanStack DB collection, a socket feed.
+// It is the synchronous, useSyncExternalStore-shaped bridge: a source exposes a
+// `snapshot()` (the current value, synchronously) and a `subscribe(onChange)`,
+// which is exactly what `makeDerivedStore` consumes. Like `RemoteState`'s `truth`
+// store, a `SyncedStore` is written ONLY by its upstream subscription — never by a
+// user reducer — so the "state changes only in the loop (or its driver)" invariant
+// holds. `@playfast/reform-db` is the first consumer: it feeds a `SyncedStore` from
+// a SQL live query whose value is an `AsyncData<Rows>`.
+/**
+ * The contract an external reactive source implements. `snapshot` must return a
+ * stable reference until the value actually changes (the `makeDerivedStore`
+ * memoization contract `useSyncExternalStore` requires); `subscribe` returns an
+ * unsubscribe thunk, fired on every upstream change.
+ */
+export interface SyncedSource<A> {
+  readonly snapshot: () => A
+  readonly subscribe: (onChange: () => void) => () => void
+}
+export interface SyncedStoreManifest<N extends string, A> extends Manifest {
+  readonly kind: 'SyncedStore'
+  readonly name: N
+  readonly schema: Schema.Schema<A, any>
+  readonly title?: string
+  readonly description?: string
+}
+export interface SyncedStoreClass<out N extends string, in out A>
+  extends Effect.Effect<A, never, Store<A>>,
+    Source<N, A> {
+  new (): {}
+  readonly manifest: SyncedStoreManifest<N, A>
+  /** Internal DI tag holding the live store. `SyncedStore.live` allocates it. */
+  readonly store: Context.Tag<Store<A>, Store<A>>
+  /** The name, so the class doubles as a `Source` input to a calc/composition. */
+  readonly name: N
+}
+export type AnySyncedStore = SyncedStoreClass<string, any>
+export type SyncedValue<S> = S extends SyncedStoreClass<string, infer A> ? A : never
+/**
+ * Define an externally-synced slice: a reflectable manifest + an internal store
+ * tag, yieldable to its current value and usable as a calc/composition `Source`.
+ * Carries no source — that is supplied at wiring time by `SyncedStore.live`,
+ * exactly as `State.make` defers its seed to `State.live`.
+ */
+export const make = <const N extends string, A>(
+  name: N,
+  schema: Schema.Schema<A, any>,
+  options: StateOptions = {},
+): SyncedStoreClass<N, A> => {
+  const store = Context.GenericTag<Store<A>, Store<A>>(`reform/syncedStore/${name}`)
+  const manifest: SyncedStoreManifest<N, A> = {
+    kind: 'SyncedStore',
+    name,
+    schema,
+    ...(options.title !== undefined ? { title: options.title } : {}),
+    ...(options.description !== undefined ? { description: options.description } : {}),
+  }
+  const read = Effect.flatMap(store, readTracked)
+  return yieldableClass(read, { manifest, store, name })
+}
+/**
+ * Allocate a synced store's backing cell and bind it to an external source.
+ * `acquire` yields the source within the layer's scope (so it can open a live
+ * query / subscription whose `R` — e.g. a `Db` driver — is captured here); the
+ * store mirrors `snapshot()` and re-notifies on every `subscribe` change through
+ * the runtime's coalescing scheduler. The upstream subscription is released with
+ * the layer's scope.
+ */
+export const live = <A, R>(
+  // A minimal store-carrier — satisfied by a `SyncedStoreClass` and by any
+  // companion primitive (e.g. `@playfast/reform-db`'s `DbQuery`) that allocates
+  // its own `Store` tag, so the seam is reusable beyond `SyncedStore` itself.
+  def: { readonly store: Context.Tag<Store<A>, Store<A>> },
+  acquire: Effect.Effect<SyncedSource<A>, never, R>,
+): Layer.Layer<Store<A>, never, Exclude<R, Scope.Scope>> =>
+  Layer.scoped(
+    def.store,
+    Effect.gen(function* () {
+      const scheduler = yield* resolveScheduler
+      const source = yield* acquire
+      const { store, unsubscribe } = makeDerivedStore(source.snapshot, source.subscribe, scheduler)
+      yield* Effect.addFinalizer(() => Effect.sync(unsubscribe))
+      return store
+    }),
+  )

package/{dist/ui/node.d.ts → src/ui/node.ts} RENAMED Viewed

@@ -1,9 +1,9 @@
-import type { ReactNode } from 'react';
+import type { ReactNode } from 'react'
 /**
  * What a view renders. Reform targets React, so a node is a `ReactNode` — this
  * is a *type-only* dependency: core never imports the React runtime nor renders
  * anything itself (that is `@reform/react`). Typing it precisely lets the `.ui`
  * presentations author real JSX and lets slots be valid components.
  */
-export type Node = ReactNode;
-//# sourceMappingURL=node.d.ts.map
+export type Node = ReactNode

package/{dist/ui/trigger.d.ts → src/ui/trigger.ts} RENAMED Viewed

@@ -3,5 +3,4 @@
  * (High priority) through the runtime. The UI never sees Effect — it just calls
  * `events.submit({ text })`.
  */
-export type Trigger<P> = (payload: P) => void;
-//# sourceMappingURL=trigger.d.ts.map
+export type Trigger<P> = (payload: P) => void

package/src/wire/tree.test.ts ADDED Viewed

@@ -0,0 +1,81 @@
+import { expect, test } from 'vitest'
+import { Wire } from '../index'
+import type { WireNode, WireTree } from '../index'
+const node = (id: string, over: Partial<WireNode> = {}): WireNode => ({
+  id,
+  name: 'View',
+  parentId: null,
+  childIndex: 0,
+  slot: null,
+  key: null,
+  props: [],
+  ...over,
+})
+// `diff` / `apply` are a round trip: folding `diff(prev, next)` into `prev`
+// reconstructs `next` exactly, for any pair of trees.
+test('a fresh tree diffs to one upsert per node', () => {
+  const next: WireTree = [node('a'), node('b', { parentId: 'a', slot: 'body' })]
+  const patches = Wire.diff([], next)
+  expect(patches).toHaveLength(2)
+  expect(patches.every((patch) => patch._tag === 'Upsert')).toBe(true)
+  expect(Wire.apply([], patches)).toEqual(next)
+})
+test('unchanged nodes produce no patches', () => {
+  const tree: WireTree = [node('a'), node('b', { parentId: 'a' })]
+  expect(Wire.diff(tree, tree)).toHaveLength(0)
+})
+test('a changed prop upserts only that node', () => {
+  const prev: WireTree = [node('a', { props: [{ _tag: 'Data', name: 'count', value: 1 }] })]
+  const next: WireTree = [node('a', { props: [{ _tag: 'Data', name: 'count', value: 2 }] })]
+  const patches = Wire.diff(prev, next)
+  expect(patches).toEqual([{ _tag: 'Upsert', node: next[0] }])
+  expect(Wire.apply(prev, patches)).toEqual(next)
+})
+test('a removed node diffs to a delete', () => {
+  const prev: WireTree = [node('a'), node('b', { parentId: 'a' })]
+  const next: WireTree = [node('a')]
+  const patches = Wire.diff(prev, next)
+  expect(patches).toEqual([{ _tag: 'Delete', id: 'b' }])
+  expect(Wire.apply(prev, patches)).toEqual(next)
+})
+test('event props compare by handle, not by identity', () => {
+  const prev: WireTree = [node('a', { props: [{ _tag: 'Event', name: 'bump', handle: 'h1' }] })]
+  const same: WireTree = [node('a', { props: [{ _tag: 'Event', name: 'bump', handle: 'h1' }] })]
+  const changed: WireTree = [node('a', { props: [{ _tag: 'Event', name: 'bump', handle: 'h2' }] })]
+  expect(Wire.diff(prev, same)).toHaveLength(0)
+  expect(Wire.diff(prev, changed)).toHaveLength(1)
+})
+test('deletes precede upserts within a frame', () => {
+  const prev: WireTree = [node('old', { parentId: 'r', slot: 'body' }), node('r')]
+  const next: WireTree = [node('r'), node('new', { parentId: 'r', slot: 'body' })]
+  const patches = Wire.diff(prev, next)
+  const firstUpsert = patches.findIndex((patch) => patch._tag === 'Upsert')
+  const lastDelete = patches.map((patch) => patch._tag).lastIndexOf('Delete')
+  expect(lastDelete).toBeLessThan(firstUpsert)
+})
+test('roots and childrenOf order siblings by childIndex', () => {
+  const tree: WireTree = [
+    node('r1', { childIndex: 1 }),
+    node('r0', { childIndex: 0 }),
+    node('c1', { parentId: 'r0', childIndex: 1 }),
+    node('c0', { parentId: 'r0', childIndex: 0 }),
+  ]
+  expect(Wire.roots(tree).map((n) => n.id)).toEqual(['r0', 'r1'])
+  expect(Wire.childrenOf(tree, 'r0').map((n) => n.id)).toEqual(['c0', 'c1'])
+})
+test('nested deep prop changes are detected', () => {
+  const prev: WireTree = [node('a', { props: [{ _tag: 'Data', name: 'rows', value: [{ id: 1 }, { id: 2 }] }] })]
+  const next: WireTree = [node('a', { props: [{ _tag: 'Data', name: 'rows', value: [{ id: 1 }, { id: 3 }] }] })]
+  expect(Wire.diff(prev, next)).toHaveLength(1)
+  expect(Wire.diff(prev, prev)).toHaveLength(0)
+})

package/src/wire/tree.ts ADDED Viewed

@@ -0,0 +1,129 @@
+import { Match } from 'effect'
+/**
+ * The serializable model of a rendered UI tree, and the pure diff/apply over it.
+ *
+ * This is the renderer-neutral heart of the remote transport (REMOTE_UI.md §3):
+ * the server renders a scene to a `WireTree`, sends `diff(prev, next)` as
+ * `WirePatch`es, and the client folds them back with `apply`. No React, no
+ * Effect — pure data, so both ends and the proofs share one source of truth.
+ */
+/**
+ * A prop on a wire node: either an already-encoded data value, or a handle the
+ * client invokes to fire the server-side trigger (resolved by the trigger
+ * registry, REMOTE_UI.md §4). Streams, when added, become a third arm.
+ */
+export type WireProp =
+  | { readonly _tag: 'Data'; readonly name: string; readonly value: unknown }
+  | { readonly _tag: 'Event'; readonly name: string; readonly handle: string }
+/** One rendered UI contract instance, identified stably across frames. */
+export interface WireNode {
+  /** Stable identity across renders — the unit of diffing. */
+  readonly id: string
+  /** The UI contract name (`UiCapture.name`) the client looks up a presentation by. */
+  readonly name: string
+  /** Parent node id, or `null` for a root. */
+  readonly parentId: string | null
+  /** Order among siblings under the same parent. */
+  readonly childIndex: number
+  /** The slot name this node fills in its parent, or `null` for a root / direct child. */
+  readonly slot: string | null
+  /**
+   * The React `key` the parent gave this slot child (`createElement(slots.Row, { key })`),
+   * or `null` when none was set. It is the per-child identity a KEYED slot selects on: the
+   * client renders `<slots.Row slotKey={id} />` and the slot thunk picks the one wire child
+   * whose `key` matches, instead of rendering every child of that slot at every call site.
+   * Without it the client slot is render-all-children (correct for singleton slots, wrong for
+   * a list slot invoked once per item — it duplicates the whole list under each call).
+   */
+  readonly key: string | null
+  readonly props: ReadonlyArray<WireProp>
+}
+export type WireTree = ReadonlyArray<WireNode>
+/** A change to apply to a client's tree: upsert a node, or drop one by id. */
+export type WirePatch =
+  | { readonly _tag: 'Upsert'; readonly node: WireNode }
+  | { readonly _tag: 'Delete'; readonly id: string }
+const arraysEqual = (a: ReadonlyArray<unknown>, b: ReadonlyArray<unknown>): boolean =>
+  a.length === b.length && a.every((item, index) => deepEqual(item, b[index]))
+const recordsEqual = (a: Record<string, unknown>, b: Record<string, unknown>): boolean => {
+  const aKeys = Object.keys(a)
+  const bKeys = Object.keys(b)
+  return aKeys.length === bKeys.length && aKeys.every((key) => deepEqual(a[key], b[key]))
+}
+/** Structural equality over serializable wire values (and the tagged props that carry them). */
+const deepEqual = (a: unknown, b: unknown): boolean => {
+  if (a === b) return true
+  if (a === null || b === null) return false
+  if (Array.isArray(a)) return Array.isArray(b) && arraysEqual(a, b)
+  if (Array.isArray(b)) return false
+  if (typeof a === 'object' && typeof b === 'object') {
+    return recordsEqual(a as Record<string, unknown>, b as Record<string, unknown>)
+  }
+  return false
+}
+const nodesEqual = (a: WireNode, b: WireNode): boolean =>
+  a.name === b.name &&
+  a.parentId === b.parentId &&
+  a.childIndex === b.childIndex &&
+  a.slot === b.slot &&
+  a.key === b.key &&
+  deepEqual(a.props, b.props)
+const isUnchanged = (node: WireNode, previousById: ReadonlyMap<string, WireNode>): boolean => {
+  const previous = previousById.get(node.id)
+  return previous !== undefined && nodesEqual(previous, node)
+}
+/**
+ * The patches that turn `previous` into `next`. Deletes precede upserts so a
+ * client never holds a child whose reparented slot was freed in the same frame.
+ */
+export const diff = (previous: WireTree, next: WireTree): ReadonlyArray<WirePatch> => {
+  const previousById = new Map(previous.map((node) => [node.id, node]))
+  const nextById = new Map(next.map((node) => [node.id, node]))
+  const deletes = previous
+    .filter((node) => !nextById.has(node.id))
+    .map((node): WirePatch => ({ _tag: 'Delete', id: node.id }))
+  const upserts = next
+    .filter((node) => !isUnchanged(node, previousById))
+    .map((node): WirePatch => ({ _tag: 'Upsert', node }))
+  return [...deletes, ...upserts]
+}
+const upsertNode = (state: WireTree, node: WireNode): WireTree => {
+  const index = state.findIndex((existing) => existing.id === node.id)
+  if (index < 0) return [...state, node]
+  return [...state.slice(0, index), node, ...state.slice(index + 1)]
+}
+/** Fold patches into a client's tree (the receiving side's reducer). */
+export const apply = (state: WireTree, patches: ReadonlyArray<WirePatch>): WireTree =>
+  patches.reduce(
+    (current, patch) =>
+      Match.value(patch).pipe(
+        Match.tag('Delete', ({ id }) => current.filter((node) => node.id !== id)),
+        Match.tag('Upsert', ({ node }) => upsertNode(current, node)),
+        Match.exhaustive,
+      ),
+    state,
+  )
+/** The root nodes of a tree, in sibling order. */
+export const roots = (tree: WireTree): WireTree =>
+  tree.filter((node) => node.parentId === null).sort((a, b) => a.childIndex - b.childIndex)
+/** The children of a node, in sibling order. */
+export const childrenOf = (tree: WireTree, parentId: string): WireTree =>
+  tree.filter((node) => node.parentId === parentId).sort((a, b) => a.childIndex - b.childIndex)

package/src/wire/triggers.test.ts ADDED Viewed

@@ -0,0 +1,76 @@
+import { expect, test } from 'vitest'
+import { Effect, Exit, Schema as S } from 'effect'
+import { Triggers } from '../index'
+import type { Trigger } from '../index'
+const ByPayload = S.Struct({ by: S.Number })
+// The registry holds a live trigger behind a caller-provided handle, decodes the
+// wire payload through the contract's event schema, and fires — never shipping a
+// function, and validating at the seam.
+test('re-registering a handle overwrites it with the fresh trigger', () => {
+  const seen = Effect.runSync(
+    Effect.gen(function* () {
+      const registry = yield* Triggers.make
+      const calls: string[] = []
+      yield* registry.register('0:bump', () => void calls.push('stale'), ByPayload)
+      yield* registry.register('0:bump', () => void calls.push('fresh'), ByPayload)
+      yield* registry.invoke('0:bump', { by: 1 })
+      return calls
+    }),
+  )
+  expect(seen).toEqual(['fresh'])
+})
+test('invoke decodes the payload and fires the trigger with the decoded value', () => {
+  const seen = Effect.runSync(
+    Effect.gen(function* () {
+      const registry = yield* Triggers.make
+      const received: Array<{ by: number }> = []
+      const bump: Trigger<{ by: number }> = (payload) => void received.push(payload)
+      yield* registry.register('0:bump', bump, ByPayload)
+      yield* registry.invoke('0:bump', { by: 5 })
+      return received
+    }),
+  )
+  expect(seen).toEqual([{ by: 5 }])
+})
+test('invoke fails with ParseError when the wire payload violates the schema', () => {
+  const exit = Effect.runSyncExit(
+    Effect.gen(function* () {
+      const registry = yield* Triggers.make
+      yield* registry.register('0:bump', (() => {}) as Trigger<{ by: number }>, ByPayload)
+      yield* registry.invoke('0:bump', { by: 'not-a-number' })
+    }),
+  )
+  expect(Exit.isFailure(exit)).toBe(true)
+})
+test('invoke on an unknown handle fails with UnknownTrigger', () => {
+  const exit = Effect.runSyncExit(
+    Effect.gen(function* () {
+      const registry = yield* Triggers.make
+      yield* registry.invoke('t999', { by: 1 })
+    }),
+  )
+  expect(Exit.isFailure(exit)).toBe(true)
+  const error = Exit.isFailure(exit) ? exit.cause : undefined
+  expect(JSON.stringify(error)).toContain('UnknownTrigger')
+})
+test('a revoked handle no longer fires', () => {
+  const fired = Effect.runSync(
+    Effect.gen(function* () {
+      const registry = yield* Triggers.make
+      const calls: number[] = []
+      yield* registry.register('0:bump', ((p: { by: number }) => void calls.push(p.by)) as Trigger<{ by: number }>, ByPayload)
+      yield* registry.revoke('0:bump')
+      const exit = yield* Effect.exit(registry.invoke('0:bump', { by: 1 }))
+      return { calls, failed: Exit.isFailure(exit) }
+    }),
+  )
+  expect(fired.calls).toEqual([])
+  expect(fired.failed).toBe(true)
+})

package/src/wire/triggers.ts ADDED Viewed

@@ -0,0 +1,98 @@
+import { type Cause, Context, Data, Effect, Layer, type ParseResult, Ref, Schema } from 'effect'
+import type { Trigger } from '../ui/trigger'
+/**
+ * The server-side bridge for trigger handles (REMOTE_UI.md §4). A rendered
+ * `WireProp` of `_tag: 'Event'` carries a `handle`; the client invokes it by
+ * sending `(handle, encodedPayload)`. Here we hold the live `Trigger` and its
+ * payload schema, decode the wire payload, and fire — so the UI never ships a
+ * function, only a handle, and the payload is validated at the seam.
+ *
+ * Handles are caller-provided keys, by convention `${nodeId}:${eventName}`: a
+ * re-render re-`register`s the same handle with that frame's fresh trigger, so the
+ * handle is stable across frames (the client's in-flight handle stays valid) and
+ * the handle space never grows. The schema is the contract's own per-event wire
+ * schema (`WiredUiManifest.events`, Phase 1) — the single source of truth for the
+ * UI boundary, decoupled from which `Event` the composition binds behind it.
+ */
+export type TriggerHandle = string
+// `any` in the schema/trigger slots is the documented Schema-variance escape
+// (same reason as `CompositionConfig.props`); only the registrar's call site,
+// where the trigger and its schema agree, sees the precise type.
+interface TriggerEntry {
+  readonly trigger: Trigger<any>
+  readonly schema: Schema.Schema<any, any>
+}
+const UnknownTriggerBase: new (args: { readonly handle: TriggerHandle }) => Cause.YieldableError & {
+  readonly _tag: 'reform/UnknownTrigger'
+} & Readonly<{ readonly handle: TriggerHandle }> = Data.TaggedError('reform/UnknownTrigger')<{
+  readonly handle: TriggerHandle
+}>
+/** A wire message named a trigger handle the server no longer holds (a stale client). */
+export class UnknownTrigger extends UnknownTriggerBase {
+  override get message(): string {
+    return `reform: no trigger registered under handle '${this.handle}'`
+  }
+}
+export interface TriggerRegistryApi {
+  /** Register (or overwrite) a trigger + its payload schema under a handle key. */
+  readonly register: <P>(
+    handle: TriggerHandle,
+    trigger: Trigger<P>,
+    schema: Schema.Schema<P, any>,
+  ) => Effect.Effect<void>
+  /** Decode an encoded payload via the handle's schema and fire the trigger. */
+  readonly invoke: (
+    handle: TriggerHandle,
+    encodedPayload: unknown,
+  ) => Effect.Effect<void, UnknownTrigger | ParseResult.ParseError>
+  /** Drop a handle once its node unmounts (the Phase 2 tree diff signals it). */
+  readonly revoke: (handle: TriggerHandle) => Effect.Effect<void>
+}
+const TriggerRegistryBase: Context.TagClass<
+  TriggerRegistry,
+  'reform/wire/TriggerRegistry',
+  TriggerRegistryApi
+> = Context.Tag('reform/wire/TriggerRegistry')<TriggerRegistry, TriggerRegistryApi>()
+export class TriggerRegistry extends TriggerRegistryBase {}
+export const make: Effect.Effect<TriggerRegistryApi> = Effect.gen(function* () {
+  const entries = yield* Ref.make(new Map<TriggerHandle, TriggerEntry>())
+  const register = <P>(
+    handle: TriggerHandle,
+    trigger: Trigger<P>,
+    schema: Schema.Schema<P, any>,
+  ): Effect.Effect<void> =>
+    Ref.update(entries, (map) => new Map(map).set(handle, { trigger, schema }))
+  const invoke = (
+    handle: TriggerHandle,
+    encodedPayload: unknown,
+  ): Effect.Effect<void, UnknownTrigger | ParseResult.ParseError> =>
+    Effect.gen(function* () {
+      const entry = (yield* Ref.get(entries)).get(handle)
+      if (entry === undefined) return yield* Effect.fail(new UnknownTrigger({ handle }))
+      const payload = yield* Schema.decodeUnknown(entry.schema)(encodedPayload)
+      entry.trigger(payload)
+    })
+  const revoke = (handle: TriggerHandle): Effect.Effect<void> =>
+    Ref.update(entries, (map) => {
+      const next = new Map(map)
+      next.delete(handle)
+      return next
+    })
+  return { register, invoke, revoke }
+})
+/** Provide a fresh registry — one per remote connection (each client gets its own handle space). */
+export const layer: Layer.Layer<TriggerRegistry> = Layer.effect(TriggerRegistry, make)