npm - @playfast/reform - Versions diffs - 1.1.1 → 1.2.0 - Mend

@playfast/reform 1.1.1 → 1.2.0

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 (85) hide show

package/README.md +85 -55
package/package.json +17 -17
package/src/boundary/boundary.test.ts +62 -16
package/src/boundary/boundary.ts +141 -32
package/src/calc/asyncCalc.invalidate.test.ts +516 -18
package/src/calc/asyncCalc.test.ts +207 -175
package/src/calc/asyncCalc.ts +168 -39
package/src/calc/calc.test.ts +3 -5
package/src/calc/calc.ts +44 -18
package/src/calc/calcFamily.test.ts +80 -22
package/src/calc/calcFamily.ts +56 -25
package/src/calc/compose.ts +1 -14
package/src/channel/channel.ts +128 -11
package/src/compose/composition.test.ts +19 -0
package/src/compose/composition.ts +346 -62
package/src/compose/props.ts +13 -6
package/src/compose/provide.ts +187 -46
package/src/compose/slot.ts +156 -19
package/src/compose/structure.test.ts +6 -3
package/src/compose/structure.ts +106 -13
package/src/compose/ui.test.ts +19 -3
package/src/compose/ui.ts +147 -54
package/src/compose/ui.typecheck.ts +40 -4
package/src/definition/definition.ts +22 -9
package/src/event/event.fromSource.test.ts +172 -0
package/src/event/event.test.ts +10 -0
package/src/event/event.ts +102 -18
package/src/feature/feature.mount.test.ts +123 -56
package/src/feature/feature.test.ts +67 -63
package/src/feature/feature.ts +1317 -197
package/src/feature/feature.typecheck.ts +253 -61
package/src/graph/closure.ts +403 -0
package/src/index.ts +171 -245
package/src/internal/bucketCache.ts +39 -0
package/src/internal/capture.ts +9 -4
package/src/internal/env.ts +1 -3
package/src/internal/errors.ts +21 -10
package/src/internal/queryDriver.ts +120 -15
package/src/internal/queryDriverStore.ts +8 -5
package/src/internal/queryDriverTypes.ts +3 -1
package/src/internal/reuse.test.ts +10 -3
package/src/internal/reuse.ts +5 -2
package/src/internal/scheduler.ts +4 -1
package/src/internal/sources.ts +25 -11
package/src/internal/track.ts +3 -2
package/src/internal.ts +222 -0
package/src/namespace/namespace.ts +46 -25
package/src/procedure/procedure.ts +38 -11
package/src/reducer/reducer.ts +78 -34
package/src/remote/remoteState.test.ts +515 -339
package/src/remote/remoteState.ts +572 -107
package/src/remote/remoteState.typecheck.ts +47 -23
package/src/runtime/appRuntime.activation.test.ts +100 -0
package/src/runtime/appRuntime.test.ts +157 -105
package/src/runtime/appRuntime.ts +394 -33
package/src/runtime/eventBudget.test.ts +1 -4
package/src/runtime/eventBudget.ts +9 -8
package/src/runtime/hardening.test.ts +4 -9
package/src/runtime/instrumentation.test.ts +174 -192
package/src/runtime/instrumentation.ts +6 -11
package/src/runtime/loop.test.ts +36 -0
package/src/runtime/loop.ts +69 -40
package/src/scene/featureScene.test.ts +4 -2
package/src/scene/scene.ts +234 -64
package/src/scene/seedScene.test.ts +69 -86
package/src/state/state.nominal.typecheck.ts +68 -0
package/src/state/state.test.ts +17 -0
package/src/state/state.ts +79 -26
package/src/state/stateFamily.test.ts +14 -0
package/src/state/stateFamily.ts +55 -22
package/src/state/stateGroup.ts +53 -17
package/src/state/token.ts +40 -10
package/src/synced/syncedStore.ts +46 -23
package/src/testkit/flight.testkit.ts +75 -0
package/src/wire/tree.test.ts +8 -4
package/src/wire/triggers.test.ts +6 -2
package/src/wire/triggers.ts +14 -10
package/src/calc/asyncCalcDefinitions.ts +0 -48
package/src/channel/procedureRegistry.ts +0 -90
package/src/feature/featureBinding.ts +0 -48
package/src/internal/ctx.ts +0 -9
package/src/remote/remoteStateDefinition.ts +0 -135
package/src/remote/remoteStateLayers.ts +0 -118
package/src/remote/remoteStateLiveTypes.ts +0 -59
package/src/remote/remoteStateSend.ts +0 -64

package/src/state/stateGroup.ts CHANGED Viewed

@@ -1,13 +1,25 @@
-import { Array as Arr, Layer, Option } from 'effect'
+import { Array as Arr, Context, Effect, Layer, Option } from 'effect'
 import { definitionClass } from '../definition/definition'
 import { DuplicateRegistration, UnknownGroupState } from '../internal/errors'
 import { type StoresOf } from '../internal/sources'
-import { type AnyState, live as stateLive, type StateClass, type StateName } from './state'
+import type { Store } from '../internal/store'
+import {
+  type AnyState,
+  live as stateLive,
+  type StateName,
+  type StateStore,
+  type StateValue,
+} from './state'
 import { StateToken } from './token'
-import type { AnyValue } from '../internal/variance'
-type ValueForName<Members extends ReadonlyArray<AnyState>, N extends string> =
-  Extract<Members[number], StateClass<N, AnyValue>> extends StateClass<string, infer A> ? A : never
+type MemberForName<Members extends ReadonlyArray<AnyState>, N extends string> = Extract<
+  Members[number],
+  { readonly manifest: { readonly name: N } }
+>
+type ValueForName<Members extends ReadonlyArray<AnyState>, N extends string> = StateValue<
+  MemberForName<Members, N>
+>
 export interface StateGroupClass<Members extends ReadonlyArray<AnyState>> {
   new (): {}
@@ -23,7 +35,10 @@ type DuplicateStateName<N extends string> = readonly ['reform: duplicate state n
 type NoDuplicateNames<
   Members extends ReadonlyArray<AnyState>,
   Seen extends string = never,
-> = Members extends readonly [infer Head extends AnyState, ...infer Tail extends ReadonlyArray<AnyState>]
+> = 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>>,
@@ -43,7 +58,9 @@ type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) exten
 type EntrySeeds<G> = G extends AnyStateGroup ? GroupSeeds<G> : never
-export type SeedsOf<St extends ReadonlyArray<unknown>> = Partial<UnionToIntersection<EntrySeeds<St[number]>>>
+export type SeedsOf<St extends ReadonlyArray<unknown>> = Partial<
+  UnionToIntersection<EntrySeeds<St[number]>>
+>
 export const make = <const Members extends ReadonlyArray<AnyState>>(
   ...members: Members & NoDuplicateNames<Members>
@@ -66,7 +83,10 @@ export const make = <const Members extends ReadonlyArray<AnyState>>(
   })
 }
-export const select = <Members extends ReadonlyArray<AnyState>, N extends StateName<Members[number]>>(
+export const select = <
+  Members extends ReadonlyArray<AnyState>,
+  N extends StateName<Members[number]>,
+>(
   group: StateGroupClass<Members>,
   name: N,
 ): StateToken<N, ValueForName<Members, N>> => {
@@ -75,17 +95,33 @@ export const select = <Members extends ReadonlyArray<AnyState>, N extends StateN
     // oxlint-disable-next-line reform-rules/no-throw -- definition-time invariant; sync lookup has no Effect context (see internal/errors.ts)
     throw new UnknownGroupState({ name })
   }
-  return new StateToken(name, member.store)
+  const store = Context.GenericTag<
+    StateStore<N, ValueForName<Members, N>>,
+    Store<ValueForName<Members, N>>
+  >(`reform/state/${name}`)
+  return new StateToken(name, store)
 }
-export const live = <Members extends ReadonlyArray<AnyState>>(
+export function live<Members extends ReadonlyArray<AnyState>>(
   group: StateGroupClass<Members>,
   seeds: GroupSeeds<StateGroupClass<Members>>,
-): Layer.Layer<StoresOf<Members>> => {
-  // oxlint-disable-next-line reform-rules/no-type-assertion -- reflection boundary: index a mapped seed type by runtime member name
-  const seedRecord = seeds as Record<string, unknown>
-  // oxlint-disable-next-line reform-rules/no-type-assertion -- union-of-stores Rout can't be expressed by reduce's single-layer accumulator
-  return group.members
-    .map((member) => stateLive(member, seedRecord[member.manifest.name]))
-    .reduce((accumulator, layer) => Layer.merge(accumulator, layer)) as Layer.Layer<StoresOf<Members>>
+): Layer.Layer<StoresOf<Members>>
+export function live(
+  group: AnyStateGroup,
+  seeds: Readonly<Record<string, unknown>>,
+): Layer.Layer<never> {
+  const layers = group.members.map((member) =>
+    member.capture<Layer.Layer<never>>((state) =>
+      Layer.unwrapEffect(
+        state.decodeUnknown(seeds[state.manifest.name]).pipe(
+          Effect.orDie,
+          Effect.map((seed) => stateLive(state, seed)),
+        ),
+      ),
+    ),
+  )
+  return layers.reduce<Layer.Layer<never>>(
+    (merged, memberLayer) => Layer.merge(merged, memberLayer),
+    Layer.empty,
+  )
 }

package/src/state/token.ts CHANGED Viewed

@@ -1,26 +1,56 @@
 import { Context, Effect, Effectable } from 'effect'
 import type { Store } from '../internal/store'
-import type { AnyValue } from '../internal/variance'
 import { readTracked } from '../internal/track'
+import type { StateStore } from './state'
-export class StateToken<out N extends string, in out A> extends Effectable.Class<A, never, Store<A>> {
+export class StateToken<
+  N extends string,
+  in out A,
+  Identifier = StateStore<N, A>,
+> extends Effectable.Class<A, never, Identifier> {
   readonly name: N
-  readonly store: Context.Tag<Store<A>, Store<A>>
-  constructor(name: N, store: Context.Tag<Store<A>, Store<A>>) {
+  readonly store: Context.Tag<Identifier, Store<A>>
+  constructor(name: N, store: Context.Tag<Identifier, Store<A>>) {
     super()
     this.name = name
     this.store = store
   }
-  commit(): Effect.Effect<A, never, Store<A>> {
+  commit(): Effect.Effect<A, never, Identifier> {
     return Effect.flatMap(this.store, readTracked)
   }
+  capture<Result>(visit: SourceCapture<Result>): Result {
+    return visit(this)
+  }
+}
+export type SourceCapture<Result> = <N extends string, A, Identifier>(
+  source: Source<N, A, Identifier>,
+) => Result
+export interface AnySource {
+  readonly name: string
+  readonly store: { readonly key: string }
 }
-export interface Source<out N extends string, in out A> {
+export interface Source<N extends string, A, Identifier> extends AnySource {
   readonly name: N
-  readonly store: Context.Tag<Store<A>, Store<A>>
+  readonly store: Context.Tag<Identifier, Store<A>>
 }
-export type AnySource = Source<string, AnyValue>
-export type SourceName<S> = S extends Source<infer N, AnyValue> ? N : never
-export type SourceValue<S> = S extends Source<AnyValue, infer A> ? A : never
+export type SourceName<S> = S extends {
+  readonly manifest: { readonly name: infer N extends string }
+}
+  ? N
+  : S extends { readonly name: infer N extends string }
+    ? N
+    : never
+export type SourceValue<S> = S extends {
+  readonly store: Context.Tag<infer _Identifier, Store<infer A>>
+}
+  ? A
+  : never
+export type SourceIdentifier<S> = S extends {
+  readonly store: Context.Tag<infer Identifier, infer _Service>
+}
+  ? Identifier
+  : never

package/src/synced/syncedStore.ts CHANGED Viewed

@@ -1,49 +1,66 @@
-import { Context, Effect, Layer, Option, type Scope } from 'effect'
+import { Context, Effect, Layer, Option, type Schema, type Scope } from 'effect'
 import type { Effect as EffectType } from 'effect/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 { AnySource, Source, SourceCapture } from '../state/token'
 import type { StateOptions } from '../state/state'
-import type { AnySchema, AnyValue } from '../internal/variance'
 export interface SyncedSource<A> {
   readonly snapshot: () => A
   readonly subscribe: (onChange: () => void) => () => void
 }
-export interface SyncedStoreManifest<N extends string, A> extends Manifest {
+export interface SyncedStoreSchemaReflection {
+  readonly ast: Schema.Schema<unknown, unknown, unknown>['ast']
+}
+export interface SyncedStoreManifest<N extends string> extends Manifest {
   readonly kind: 'SyncedStore'
   readonly name: N
-  readonly schema: AnySchema<A>
+  readonly schema: SyncedStoreSchemaReflection
   readonly title: Option.Option<string>
   readonly description: Option.Option<string>
 }
-export interface SyncedStoreClass<out N extends string, in out A>
-  extends EffectType<A, never, Store<A>>,
-    Source<N, A> {
+export const SyncedStoreIdentifierTypeId: unique symbol = Symbol.for('reform/SyncedStoreIdentifier')
+export type SyncedStoreIdentifierTypeId = typeof SyncedStoreIdentifierTypeId
+export interface SyncedStoreIdentifier<N extends string, in out A> extends Store<A> {
+  readonly [SyncedStoreIdentifierTypeId]: N
+}
+export interface SyncedStoreClass<N extends string, in out A>
+  extends
+    EffectType<A, never, SyncedStoreIdentifier<N, A>>,
+    Source<N, A, SyncedStoreIdentifier<N, A>> {
   new (): {}
-  readonly manifest: SyncedStoreManifest<N, A>
-  readonly store: Context.Tag<Store<A>, Store<A>>
+  readonly manifest: SyncedStoreManifest<N>
+  readonly store: Context.Tag<SyncedStoreIdentifier<N, A>, Store<A>>
   readonly name: N
+  readonly capture: <Result>(visit: SourceCapture<Result>) => Result
 }
-export interface StoreCarrier<A> {
-  readonly store: Context.Tag<Store<A>, Store<A>>
+export interface StoreCarrier<Identifier, A> {
+  readonly store: Context.Tag<Identifier, Store<A>>
 }
-export type AnySyncedStore = SyncedStoreClass<string, AnyValue>
-export type SyncedValue<S> = S extends SyncedStoreClass<string, infer A> ? A : never
+export type AnySyncedStore = AnySource & {
+  readonly manifest: Manifest & { readonly kind: 'SyncedStore' }
+}
+export type SyncedValue<S> = S extends SyncedStoreClass<infer _N, infer A> ? A : never
-export const make = <const N extends string, A>(
+export const make = <const N extends string, ValueSchema extends Schema.Schema.AnyNoContext>(
   name: N,
-  schema: AnySchema<A>,
+  schema: ValueSchema,
   options: StateOptions = {},
-): SyncedStoreClass<N, A> => {
-  const store = Context.GenericTag<Store<A>, Store<A>>(`reform/syncedStore/${name}`)
-  const manifest: SyncedStoreManifest<N, A> = {
+): SyncedStoreClass<N, Schema.Schema.Type<ValueSchema>> => {
+  type A = Schema.Schema.Type<ValueSchema>
+  const store = Context.GenericTag<SyncedStoreIdentifier<N, A>, Store<A>>(
+    `reform/syncedStore/${name}`,
+  )
+  const manifest: SyncedStoreManifest<N> = {
     kind: 'SyncedStore',
     name,
     schema,
@@ -51,13 +68,19 @@ export const make = <const N extends string, A>(
     description: Option.fromNullable(options.description),
   }
   const read = Effect.flatMap(store, readTracked)
-  return yieldableClass(read, { manifest, store, name })
+  const synced: SyncedStoreClass<N, A> = yieldableClass(read, {
+    manifest,
+    store,
+    name,
+    capture: <Result>(visit: SourceCapture<Result>): Result => visit(synced),
+  })
+  return synced
 }
-export const live = <A, R>(
-  def: StoreCarrier<A>,
+export const live = <Identifier, A, R>(
+  def: StoreCarrier<Identifier, A>,
   acquire: Effect.Effect<SyncedSource<A>, never, R>,
-): Layer.Layer<Store<A>, never, Exclude<R, Scope.Scope>> =>
+): Layer.Layer<Identifier, never, Exclude<R, Scope.Scope>> =>
   Layer.scoped(
     def.store,
     Effect.gen(function* () {

package/src/testkit/flight.testkit.ts ADDED Viewed

@@ -0,0 +1,75 @@
+import { Deferred, Duration, Effect, MutableRef, Option } from 'effect'
+// Coalescing/cancellation semantics are only meaningful while a query is still
+// in flight. Tests used to build that overlap by racing wall-clock — a 25ms
+// query delay against 5ms gaps between input writes — which silently stops
+// overlapping on a loaded machine: the runs serialize, every key gets its own
+// flight, and the assertion fails reporting a coalescing bug that isn't there.
+// A gate makes the overlap explicit: hold the flight open, land the burst,
+// release.
+export const tick = (ms = 10): Effect.Effect<void> => Effect.sleep(Duration.millis(ms))
+export const until = <A>(
+  read: () => A,
+  predicate: (value: A) => boolean,
+  rounds = 200,
+): Effect.Effect<A> =>
+  Effect.suspend(() => {
+    const value = read()
+    return predicate(value) || rounds <= 0
+      ? Effect.succeed(value)
+      : Effect.flatMap(tick(10), () => until(read, predicate, rounds - 1))
+  })
+export interface FlightGate {
+  /** Wrap a query body: it records its entry, then parks while the gate holds. */
+  readonly through: <A, E, R>(body: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  /** Park every flight that reaches the gate from now on. */
+  readonly hold: Effect.Effect<void>
+  /** Let the parked flights settle; later flights pass straight through. */
+  readonly release: Effect.Effect<void>
+  /** Resolve once `count` flights have reached the gate. */
+  readonly awaitEntry: (count: number) => Effect.Effect<void>
+  /** How many flights have reached the gate. */
+  readonly entered: () => number
+}
+export const makeFlightGate = (): FlightGate => {
+  const latch = MutableRef.make(Option.none<Deferred.Deferred<void>>())
+  const entered = MutableRef.make(0)
+  return {
+    through: (body) =>
+      body.pipe(
+        Effect.tap(() =>
+          Effect.suspend(() => {
+            MutableRef.update(entered, (count) => count + 1)
+            return Option.match(MutableRef.get(latch), {
+              onNone: () => Effect.void,
+              onSome: (parked) => Deferred.await(parked),
+            })
+          }),
+        ),
+      ),
+    hold: Effect.flatMap(Deferred.make<void>(), (parked) =>
+      Effect.sync(() => MutableRef.set(latch, Option.some(parked))),
+    ),
+    release: Effect.suspend(() => {
+      const parked = MutableRef.get(latch)
+      MutableRef.set(latch, Option.none())
+      return Option.match(parked, {
+        onNone: () => Effect.void,
+        onSome: (deferred) => Effect.asVoid(Deferred.succeed(deferred, undefined)),
+      })
+    }),
+    awaitEntry: (count) =>
+      Effect.asVoid(
+        until(
+          () => MutableRef.get(entered),
+          (reached) => reached >= count,
+        ),
+      ),
+    entered: () => MutableRef.get(entered),
+  }
+}

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

@@ -1,6 +1,6 @@
 import { expect, test } from 'vitest'
-import { Wire } from '../index'
-import type { WireNode, WireTree } from '../index'
+import * as Wire from './tree'
+import type { WireNode, WireTree } from './tree'
 const node = (id: string, over: Partial<WireNode> = {}): WireNode => ({
   id,
@@ -71,8 +71,12 @@ test('roots and childrenOf order siblings by childIndex', () => {
 })
 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 }] }] })]
+  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/triggers.test.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import { expect, test } from 'vitest'
 import { Effect, Exit, Schema as S } from 'effect'
-import { Triggers } from '../index'
+import * as Triggers from './triggers'
 import type { Trigger } from '../index'
 const ByPayload = S.Struct({ by: S.Number })
@@ -61,7 +61,11 @@ test('a revoked handle no longer fires', () => {
     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.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) }

package/src/wire/triggers.ts CHANGED Viewed

@@ -1,12 +1,10 @@
 import { type Cause, Context, Data, Effect, Layer, type ParseResult, Ref, Schema } from 'effect'
 import type { Trigger } from '../ui/trigger'
-import type { AnySchema, AnyValue } from '../internal/variance'
 export type TriggerHandle = string
 interface TriggerEntry {
-  readonly trigger: Trigger<AnyValue>
-  readonly schema: Schema.Schema.AnyNoContext
+  readonly invoke: (encodedPayload: unknown) => Effect.Effect<void, ParseResult.ParseError, never>
 }
 const UnknownTriggerBase: new (args: { readonly handle: TriggerHandle }) => Cause.YieldableError & {
@@ -22,10 +20,10 @@ export class UnknownTrigger extends UnknownTriggerBase {
 }
 export interface TriggerRegistryApi {
-  readonly register: <P>(
+  readonly register: <P, Encoded>(
     handle: TriggerHandle,
     trigger: Trigger<P>,
-    schema: AnySchema<P>,
+    schema: Schema.Schema<P, Encoded, never>,
   ) => Effect.Effect<void>
   readonly invoke: (
     handle: TriggerHandle,
@@ -45,12 +43,19 @@ 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>(
+  const register = <P, Encoded>(
     handle: TriggerHandle,
     trigger: Trigger<P>,
-    schema: AnySchema<P>,
+    schema: Schema.Schema<P, Encoded, never>,
   ): Effect.Effect<void> =>
-    Ref.update(entries, (map) => new Map(map).set(handle, { trigger, schema }))
+    Ref.update(entries, (map) =>
+      new Map(map).set(handle, {
+        invoke: (encodedPayload) =>
+          Schema.decodeUnknown(schema)(encodedPayload).pipe(
+            Effect.map((payload) => trigger(payload)),
+          ),
+      }),
+    )
   const invoke = Effect.fn('invoke')(function* (
     handle: TriggerHandle,
@@ -60,8 +65,7 @@ export const make: Effect.Effect<TriggerRegistryApi> = Effect.gen(function* () {
     if (entry === undefined) {
       return yield* Effect.fail(new UnknownTrigger({ handle }))
     }
-    const payload = yield* Schema.decodeUnknown(entry.schema)(encodedPayload)
-    entry.trigger(payload)
+    yield* entry.invoke(encodedPayload)
   })
   const revoke = (handle: TriggerHandle): Effect.Effect<void> =>

package/src/calc/asyncCalcDefinitions.ts DELETED Viewed

@@ -1,48 +0,0 @@
-import { Context, Effect } from 'effect'
-import { yieldableClass } from '../definition/definition'
-import { type GatedOf, gatedFlag } from '../internal/queryDriver'
-import type { Store } from '../internal/store'
-import { readTracked } from '../internal/track'
-import { Queries } from '../runtime/queries'
-import type { AnySource } from '../state/token'
-import type { AsyncData } from './asyncData'
-import type { AsyncCalcClass, AsyncCalcConfig, AsyncCalcManifest } from './asyncCalc'
-export const make = <
-  const N extends string,
-  const Inputs extends ReadonlyArray<AnySource>,
-  A,
-  E = never,
-  const AlwaysOn extends boolean = false,
->(
-  name: N,
-  config: AsyncCalcConfig<Inputs, A, E, AlwaysOn>,
-): AsyncCalcClass<N, Inputs, A, E, GatedOf<AlwaysOn>> => {
-  const store = Context.GenericTag<Store<AsyncData<A, E, GatedOf<AlwaysOn>>>>(
-    `reform/asyncCalc/${name}`,
-  )
-  const gated = gatedFlag(config.alwaysOn)
-  const manifest: AsyncCalcManifest<N, A, E> = {
-    kind: 'AsyncCalc',
-    name,
-    output: config.output,
-    gated,
-    ...(config.error !== undefined ? { error: config.error } : {}),
-  }
-  const read = Effect.flatMap(store, readTracked)
-  return yieldableClass(read, { manifest, store, name, inputs: config.inputs, gated })
-}
-export interface NamedCalc {
-  readonly name: string
-}
-export const invalidate = (calc: NamedCalc): Effect.Effect<void, never, Queries> =>
-  Effect.flatMap(Queries, (queries) =>
-    Effect.sync(() => queries.byName.get(calc.name)?.invalidate()),
-  )
-export const refetch = (calc: NamedCalc): Effect.Effect<void, never, Queries> =>
-  Effect.flatMap(Queries, (queries) =>
-    Effect.sync(() => queries.byName.get(calc.name)?.refetch()),
-  )

package/src/channel/procedureRegistry.ts DELETED Viewed

@@ -1,90 +0,0 @@
-import { Context, Effect, Layer } from 'effect'
-import type { Tagged } from '../runtime/bus'
-export interface ProcedureEntry {
-  readonly name: string
-  readonly channelName: string
-  readonly handles: ReadonlySet<string>
-  readonly run: (event: Tagged) => Effect.Effect<unknown, unknown, never>
-}
-export interface ProcedureRegistry {
-  readonly entries: Array<ProcedureEntry>
-  readonly byTag: Map<string, Array<ProcedureEntry>>
-  readonly channelsByTag: Map<string, Array<string>>
-  readonly byChannelTag: Map<string, Map<string, Array<ProcedureEntry>>>
-  readonly register: (entry: ProcedureEntry) => void
-  readonly unregister: (entry: ProcedureEntry) => void
-}
-const ProceduresBase: Context.TagClass<Procedures, 'reform/Procedures', ProcedureRegistry> =
-  Context.Tag('reform/Procedures')<Procedures, ProcedureRegistry>()
-export class Procedures extends ProceduresBase {}
-const getOrCreate = <K, V>(map: Map<K, V>, key: K, make: () => V): V => {
-  const existing = map.get(key)
-  if (existing !== undefined) {
-    return existing
-  }
-  const created = make()
-  map.set(key, created)
-  return created
-}
-const dropFrom = <K, T>(map: Map<K, Array<T>>, key: K, target: T): void => {
-  const bucket = map.get(key)
-  if (bucket === undefined) {
-    return
-  }
-  const next = bucket.filter((candidate) => candidate !== target)
-  if (next.length === 0) {
-    map.delete(key)
-  } else {
-    map.set(key, next)
-  }
-}
-const makeProcedureRegistry = (): ProcedureRegistry => {
-  const state: { entries: Array<ProcedureEntry> } = { entries: [] }
-  const byTag = new Map<string, Array<ProcedureEntry>>()
-  const channelsByTag = new Map<string, Array<string>>()
-  const byChannelTag = new Map<string, Map<string, Array<ProcedureEntry>>>()
-  return {
-    get entries() {
-      return state.entries
-    },
-    byTag,
-    channelsByTag,
-    byChannelTag,
-    register: (entry) => {
-      state.entries = [...state.entries, entry]
-      entry.handles.forEach((tag) => {
-        byTag.set(tag, [...getOrCreate(byTag, tag, () => []), entry])
-        const channels = getOrCreate(channelsByTag, tag, () => [])
-        if (!channels.includes(entry.channelName)) {
-          channelsByTag.set(tag, [...channels, entry.channelName])
-        }
-        const channelMap = getOrCreate(byChannelTag, entry.channelName, () => new Map())
-        channelMap.set(tag, [...getOrCreate(channelMap, tag, () => []), entry])
-      })
-    },
-    unregister: (entry) => {
-      state.entries = state.entries.filter((existing) => existing !== entry)
-      entry.handles.forEach((tag) => {
-        dropFrom(byTag, tag, entry)
-        const channelMap = byChannelTag.get(entry.channelName)
-        if (channelMap !== undefined) {
-          dropFrom(channelMap, tag, entry)
-          if (channelMap.get(tag) === undefined) {
-            dropFrom(channelsByTag, tag, entry.channelName)
-          }
-          if (channelMap.size === 0) {
-            byChannelTag.delete(entry.channelName)
-          }
-        }
-      })
-    },
-  }
-}
-export const proceduresLayer: Layer.Layer<Procedures> = Layer.sync(Procedures, makeProcedureRegistry)

package/src/feature/featureBinding.ts DELETED Viewed

@@ -1,48 +0,0 @@
-import { Effect, Layer, Option } from 'effect'
-import type { Manifest } from '../definition/definition'
-import type { CompositionClass } from '../compose/composition'
-import type { Tagged } from '../runtime/bus'
-import type { FeatureLoadFailed } from '../internal/errors'
-import type { FeatureRequirement } from './feature'
-export interface FailedProps {
-  readonly error: FeatureLoadFailed
-  readonly retry: () => void
-}
-export interface FeatureManifest extends Manifest {
-  readonly kind: 'Feature'
-  readonly name: string
-  readonly strategy: 'lazy' | 'default'
-  readonly composition: Manifest & { readonly kind: 'Composition' }
-  readonly placeholder: Option.Option<{
-    readonly loading: Manifest & { readonly kind: 'Composition' }
-    readonly failed: Manifest & { readonly kind: 'Composition' }
-  }>
-}
-export interface LoadedModule {
-  readonly requires: ReadonlyArray<FeatureRequirement>
-  readonly usesInput: boolean
-  readonly layer: Layer.Layer<never, never, unknown>
-}
-export const FeatureBindingTypeId: unique symbol = Symbol.for('reform/FeatureBinding')
-export type FeatureBindingTypeId = typeof FeatureBindingTypeId
-export interface FeatureBindingExternalApi {
-  readonly [FeatureBindingTypeId]: FeatureBindingTypeId
-  readonly manifest: FeatureManifest
-  readonly composition: CompositionClass<unknown>
-  readonly strategy: 'lazy' | 'default'
-  readonly load: Effect.Effect<LoadedModule, FeatureLoadFailed>
-  readonly placeholder?: {
-    readonly loading: CompositionClass<unknown>
-    readonly failed: CompositionClass<unknown>
-  }
-  readonly boot: ReadonlyArray<Tagged>
-}
-export type FeatureBinding = FeatureBindingExternalApi
-export const isFeatureBinding = (candidate: unknown): candidate is FeatureBinding =>
-  typeof candidate === 'object' && candidate !== null && FeatureBindingTypeId in candidate

package/src/internal/ctx.ts DELETED Viewed

@@ -1,9 +0,0 @@
-import type { Effect } from 'effect'
-import type { YieldWrap } from 'effect/Utils'
-import type { AnyValue } from './variance'
-export type Ctx<Eff> = [Eff] extends [never]
-  ? never
-  : [Eff] extends [YieldWrap<Effect.Effect<AnyValue, AnyValue, infer R>>]
-    ? R
-    : never