@playfast/reform 1.1.1 → 1.2.1

package/src/remote/remoteState.ts

@@ -1,13 +1,5 @@
-import {
-  Context,
-  Effect,
-  Layer,
-  MutableRef,
-  Option,
-  Runtime,
-  Schema,
-} from 'effect'
-import { type AsyncData, narrowStore, widenStore } from '../calc/asyncData'
+import { Context, Effect, Iterable, Layer, MutableRef, Option, Runtime, Schema } from 'effect'
+import { type AnyAsyncData, AsyncData, narrowStore, widenStore } from '../calc/asyncData'
 import * as Channel from '../channel/channel'
 import * as Event from '../event/event'
 import {
@@ -16,42 +8,48 @@ import {
   RevisionSchema,
   revisionZero,
 } from '../internal/queryDriver'
+import { reuse as shareStructure } from '../internal/reuse'
 import { resolveScheduler } from '../internal/scheduler'
-import { type InputStores } from '../internal/sources'
-import { makeStore, type Store } from '../internal/store'
+import { type InputStores, sameKey } from '../internal/sources'
+import { makeDerivedStore } from '../internal/store'
 import * as Reducer from '../reducer/reducer'
 import { Bus, publish } from '../runtime/bus'
 import { Reducers } from '../runtime/loop'
 import * as State from '../state/state'
 import { type AnySource } from '../state/token'
-import {
-  looseSchema,
-  type PendingIntent,
-  type RemoteStateClass,
-  type RemoteStateSettled,
-} from './remoteStateDefinition'
+import { makePendingQueue, type PendingQueue } from './pendingQueue'
+import { looseSchema } from './remoteStateMake'
+import { queueReducerLayer, sendProcedureLayer } from './remoteStateSend'
 import type {
+  RemoteStateClass,
   RemoteStateLiveExternalApi,
-  RemoteStateLiveRuntimeExternalApi,
+  RemoteStatePendingStore,
+  RemoteStateSettled,
+  RemoteStateTruthStore,
+  RemoteStateVisibleStore,
   SettleLink,
-} from './remoteStateLiveTypes'
-import { makeOverlayLayer, makeQueueReducerLayer } from './remoteStateLayers'
-import { makeSendProcedureLayer } from './remoteStateSend'
-
-// Generation rule: intent acked at gen g settles only on Success with gen > g (no flicker).
-// apply must be idempotent: between refetch landing and settle, intent is applied over truth that already has it.
+  WaiterRegistration,
+} from './remoteStateTypes'
 
+export { make } from './remoteStateMake'
 export {
-  type FailedIntent,
-  make,
-  type PendingIntent,
-  type RemoteStateClass,
-  type RemoteStateConfigExternalApi,
-  type RemoteStateManifestExternalApi,
-  type RemoteStateSettled,
-} from './remoteStateDefinition'
-
-export type { RemoteStateLiveExternalApi } from './remoteStateLiveTypes'
+  RemoteStatePendingStoreTypeId,
+  RemoteStateTruthStoreTypeId,
+  RemoteStateVisibleStoreTypeId,
+} from './remoteStateTypes'
+export type {
+  FailedIntent,
+  PendingIntent,
+  RemoteStateClass,
+  RemoteStateConfigExternalApi,
+  RemoteStateLiveExternalApi,
+  RemoteStateManifestExternalApi,
+  RemoteStatePendingStore,
+  RemoteStateSchemaReflection,
+  RemoteStateSettled,
+  RemoteStateTruthStore,
+  RemoteStateVisibleStore,
+} from './remoteStateTypes'
 
 export const live = <
   N extends string,
@@ -67,21 +65,17 @@ export const live = <
   remote: RemoteStateClass<N, Inputs, Intents, A, E, Gated>,
   config: RemoteStateLiveExternalApi<Inputs, Intents, A, E, Gated, R, R2, SettledEvent>,
 ): Layer.Layer<
-  | Store<AsyncData<A, E, Gated>>
-  | Store<ReadonlyArray<PendingIntent<Event.EventType<Intents[number]>>>>,
+  RemoteStateVisibleStore<N> | RemoteStateTruthStore<N> | RemoteStatePendingStore<N>,
   never,
-  | InputStores<Inputs>
-  | R
-  | R2
-  | Reducers
-  | Channel.Procedures
-  | Channel.Channels
-  | Bus
+  InputStores<Inputs> | R | R2 | Reducers | Channel.Procedures | Channel.Channels | Bus
 > => {
   type I = Event.EventType<Intents[number]>
   const name = remote.manifest.name
   const truthTag = remote.truth.store
   const pendingTag = remote.pending.store
+  const pendingQueueTag = Context.GenericTag<PendingQueue<I>>(
+    `reform/remoteState/${name}/pendingQueue`,
+  )
 
   const Queued = Event.make(
     `${name}/Queued`,
@@ -107,53 +101,57 @@ export const live = <
 
   const driverLayer = Layer.scopedContext(
     Effect.gen(function* () {
-      // oxlint-disable-next-line reform-rules/no-type-assertion -- type-level erasure seam: `disabled` is `never` for non-gated definitions; read it back through the runtime view
-      const cfg = config as RemoteStateLiveRuntimeExternalApi<Inputs, A, E, R>
       const revision = Option.getOrUndefined(yield* Effect.serviceOption(revisionState.store))
       const runtime = yield* Effect.runtime<Bus>()
 
-      // Registry (not per-intent fibers): latest/exclusive cancel must not orphan waiters
-      const waiters = MutableRef.make<
-        ReadonlyArray<{ readonly opId: string; readonly waitFor: number }>
-      >([])
+      // Buckets, not cancellable fibers, keep waiters alive under latest/exclusive policies.
+      // Monotonic waitFor values make insertion order match generation order.
+      const waiters = new Map<number, Set<{ readonly opId: string }>>()
       const onSettled = (generation: number) => {
-        const due = MutableRef.get(waiters).filter((waiter) => waiter.waitFor <= generation)
-        if (due.length === 0) {
-          return
-        }
-        MutableRef.update(waiters, (all) => all.filter((waiter) => waiter.waitFor > generation))
-        // runSync: settle enqueued in same flush as converged value write
-        due.forEach((waiter) =>
-          Runtime.runSync(runtime)(
-            publish('Normal', Event.construct(Settled, { opId: waiter.opId })),
-          ),
+        Iterable.forEach(
+          Iterable.takeWhile(waiters, ([waitFor]) => waitFor <= generation),
+          ([waitFor, generationWaiters]) => {
+            waiters.delete(waitFor)
+            // runSync enqueues settles in the same flush as converged truth.
+            generationWaiters.forEach(({ opId }) =>
+              Runtime.runSync(runtime)(publish('Normal', Event.construct(Settled, { opId }))),
+            )
+          },
         )
       }
+      const registerWaiter = ({ opId, waitFor }: WaiterRegistration): void => {
+        const generationWaiters = waiters.get(waitFor)
+        if (generationWaiters === undefined) {
+          waiters.set(waitFor, new Set([{ opId }]))
+        } else {
+          generationWaiters.add({ opId })
+        }
+      }
 
-      // Persist only settled server truth (overlay is a separate store the driver never sees)
-      const persistOption = cfg.persist
+      const persistOption = config.persist
       const persistKey =
         persistOption === true || persistOption === undefined || persistOption === false
           ? name
-          : persistOption.key ?? name
+          : (persistOption.key ?? name)
       const persist =
         persistOption === undefined || persistOption === false
           ? undefined
-          : { key: persistKey, schema: remote.manifest.output }
-      const extraKey =
-        revision === undefined
-          ? undefined
-          : { read: () => revision.getSnapshot(), subscribe: (listener: () => void) => revision.subscribe(listener) }
+          : { key: persistKey, codec: remote.codec }
+      const revisionKey = (source: NonNullable<typeof revision>) => ({
+        read: () => source.getSnapshot(),
+        subscribe: (listener: () => void) => source.subscribe(listener),
+      })
+      const extraKey = revision === undefined ? undefined : revisionKey(revision)
       const driver = yield* makeQueryDriver({
         name,
         label: 'RemoteState',
         gated: remote.gated,
         inputs: remote.inputs,
-        query: cfg.query,
-        invalidateBy: cfg.invalidateBy,
-        disabled: cfg.disabled,
-        coalesce: cfg.coalesce,
-        reuse: cfg.reuse,
+        query: config.query,
+        invalidateBy: config.invalidateBy,
+        disabled: config.disabled,
+        coalesce: config.coalesce,
+        reuse: config.reuse,
         persist,
         extraKey,
         onSettled,
@@ -173,7 +171,7 @@ export const live = <
             Runtime.runSync(runtime)(
               publish(
                 'Normal',
-                Event.construct(settledConfig.event, settledConfig.payload(settledTruth)),
+                settledConfig.event.buildUnknown(settledConfig.payload(settledTruth)),
               ),
             )
           }
@@ -185,8 +183,7 @@ export const live = <
       }
       const link: SettleLink = {
         requested: driver.requested,
-        register: (opId, waitFor) =>
-          MutableRef.update(waiters, (all) => [...all, { opId, waitFor }]),
+        register: (opId, waitFor) => registerWaiter({ opId, waitFor }),
       }
       return Context.make(truthTag, narrowStore<A, E, Gated>(driver.store)).pipe(
         Context.add(linkTag, link),
@@ -194,48 +191,90 @@ export const live = <
     }),
   )
 
-  const overlayLayer = makeOverlayLayer<I, A, E, Gated>({
-    apply: config.apply,
-    pendingTag,
-    reuse: config.reuse,
-    storeTag: remote.store,
-    truthTag,
-  })
+  const overlayLayer = Layer.scoped(
+    remote.store,
+    Effect.gen(function* () {
+      const scheduler = yield* resolveScheduler
+      const feedStore = widenStore<A, E, Gated>(yield* truthTag)
+      const queue = yield* pendingQueueTag
+      const memo = MutableRef.make<
+        { readonly key: ReadonlyArray<unknown>; readonly output: AnyAsyncData<A, E> } | undefined
+      >(undefined)
+      const recompute = (): AnyAsyncData<A, E> => {
+        const feed = feedStore.getSnapshot()
+        const key = [feed, queue.revision()]
+        const prev = MutableRef.get(memo)
+        if (prev !== undefined && sameKey(key, prev.key)) {
+          return prev.output
+        }
+        // Full replay preserves observable value identity when apply allocates and reuse is off.
+        const applyPending = (base: A): A =>
+          queue.fold(base, (applied, entry) => config.apply(applied, entry.intent))
+        const overlaid: AnyAsyncData<A, E> =
+          feed._tag === 'Success'
+            ? AsyncData.success(applyPending(feed.value), feed.refetching)
+            : feed
+        const reusable =
+          config.reuse === true &&
+          prev !== undefined &&
+          prev.output._tag === 'Success' &&
+          overlaid._tag === 'Success'
+            ? shareStructure(prev.output.value, overlaid.value)
+            : undefined
+        const output: AnyAsyncData<A, E> =
+          reusable === undefined || overlaid._tag !== 'Success'
+            ? overlaid
+            : AsyncData.success(reusable, overlaid.refetching)
+        MutableRef.set(memo, { key, output })
+        return output
+      }
+      const subscribe = (listener: () => void): (() => void) => {
+        const offFeed = feedStore.subscribe(listener)
+        const offQueue = queue.store.subscribe(listener)
+        return () => {
+          offFeed()
+          offQueue()
+        }
+      }
+      const derived = makeDerivedStore(recompute, subscribe, scheduler)
+      yield* Effect.addFinalizer(() => Effect.sync(derived.unsubscribe))
+      return narrowStore<A, E, Gated>(derived.store)
+    }),
+  )
 
-  const queueReducerLayer = makeQueueReducerLayer<I>({
-    ackedTag: Acked.tag,
-    name: `${name}/pending`,
-    pendingTag,
-    queuedTag: Queued.tag,
-    settledTag: Settled.tag,
-  })
   const channel = config.channel ?? Channel.make(`${name}/sends`, { policy: { _tag: 'merge' } })
-  const procedureName = `${name}/send`
-  const sendHandles: ReadonlySet<string> = new Set(remote.intents.map((event) => event.tag))
-  const sendProcedureLayer = makeSendProcedureLayer<I, R2>({
+  const intentEvents = {
+    queued: Queued,
     acked: Acked,
-    channel,
-    failed: remote.Failed,
-    handles: sendHandles,
+    settled: Settled,
     invalidated: Invalidated,
+  }
+  const pendingReducer = queueReducerLayer({
+    name: `${name}/pending`,
+    queueTag: pendingQueueTag,
+    events: intentEvents,
+  })
+  const sendProcedure = sendProcedureLayer({
+    name: `${name}/send`,
+    channel,
+    handles: new Set(remote.intents.map((event) => event.tag)),
     linkTag,
-    name: procedureName,
-    queued: Queued,
+    failed: remote.Failed,
     send: config.send,
-    settled: Settled,
+    events: intentEvents,
   })
 
-  const pendingStoreLayer = Layer.effect(
-    pendingTag,
-    Effect.map(resolveScheduler, (scheduler) =>
-      makeStore<ReadonlyArray<PendingIntent<I>>>([], scheduler),
-    ),
+  const pendingStoreLayer = Layer.scopedContext(
+    Effect.map(resolveScheduler, (scheduler) => {
+      const queue = makePendingQueue<I>(scheduler)
+      return Context.make(pendingTag, queue.store).pipe(Context.add(pendingQueueTag, queue))
+    }),
   )
   return Layer.mergeAll(
     overlayLayer,
-    queueReducerLayer,
+    pendingReducer,
     Reducer.live(revisionReducer, bumpRevision),
-    sendProcedureLayer,
+    sendProcedure,
     Channel.live(channel),
   ).pipe(
     Layer.provideMerge(driverLayer),

package/src/remote/remoteState.typecheck.ts

@@ -3,7 +3,6 @@ import * as Boundary from '../boundary/boundary'
 import type { AsyncData } from '../calc/asyncData'
 import { type Channels, type Procedures } from '../channel/channel'
 import * as Event from '../event/event'
-import type { Store } from '../internal/store'
 import * as Reducer from '../reducer/reducer'
 import type { Bus } from '../runtime/bus'
 import { type Reducers } from '../runtime/loop'
@@ -12,8 +11,10 @@ import * as StateGroup from '../state/stateGroup'
 import { type AnySource, type Source } from '../state/token'
 import * as RemoteState from './remoteState'
 
-const AddIntentBase: Event.EventClass<'TAddIntent', { readonly id: string; readonly name: string }> =
-  Event.make('TAddIntent', S.Struct({ id: S.String, name: S.String }))
+const AddIntentBase: Event.EventClass<
+  'TAddIntent',
+  { readonly id: string; readonly name: string }
+> = Event.make('TAddIntent', S.Struct({ id: S.String, name: S.String }))
 class AddIntent extends AddIntentBase {}
 const RenameIntentBase: Event.EventClass<
   'TRenameIntent',
@@ -27,7 +28,10 @@ const PageBase: State.StateClass<'tcPage', number> = State.make('tcPage', S.Numb
 class Page extends PageBase {}
 const InputsBase: StateGroup.StateGroupClass<readonly [typeof Page]> = StateGroup.make(Page)
 class Inputs extends InputsBase {}
-const page: Source<'tcPage', number> = StateGroup.select(Inputs, 'tcPage')
+const page: Source<'tcPage', number, State.StateStore<'tcPage', number>> = StateGroup.select(
+  Inputs,
+  'tcPage',
+)
 
 const Row: S.Struct<{ id: typeof S.String; name: typeof S.String }> = S.Struct({
   id: S.String,
@@ -58,10 +62,11 @@ const ItemsBase: RemoteState.RemoteStateClass<
 class Items extends ItemsBase {}
 
 export const okLive: Layer.Layer<
-  | Store<AsyncData<ReadonlyArray<Row>, string, true>>
-  | Store<ReadonlyArray<RemoteState.PendingIntent<Intent>>>,
+  | RemoteState.RemoteStateVisibleStore<'TItems'>
+  | RemoteState.RemoteStateTruthStore<'TItems'>
+  | RemoteState.RemoteStatePendingStore<'TItems'>,
   never,
-  Store<number> | SendDep | Reducers | Procedures | Channels | Bus
+  State.StateStore<'tcPage', number> | SendDep | Reducers | Procedures | Channels | Bus
 > = RemoteState.live(Items, {
   query: ({ tcPage }) =>
     tcPage > 0 ? Effect.succeed<ReadonlyArray<Row>>([]) : Effect.fail('empty page'),
@@ -78,10 +83,11 @@ export const okLive: Layer.Layer<
 })
 
 export const badIntent: Layer.Layer<
-  | Store<AsyncData<ReadonlyArray<Row>, string, true>>
-  | Store<ReadonlyArray<RemoteState.PendingIntent<Intent>>>,
+  | RemoteState.RemoteStateVisibleStore<'TItems'>
+  | RemoteState.RemoteStateTruthStore<'TItems'>
+  | RemoteState.RemoteStatePendingStore<'TItems'>,
   never,
-  Store<number> | Reducers | Procedures | Channels | Bus
+  State.StateStore<'tcPage', number> | Reducers | Procedures | Channels | Bus
 > = RemoteState.live(Items, {
   query: () => Effect.succeed<ReadonlyArray<Row>>([]),
   send: () => Effect.void,
@@ -90,16 +96,20 @@ export const badIntent: Layer.Layer<
 })
 
 export const okLayer: Layer.Layer<
-  Store<AsyncData<ReadonlyArray<Row>, string, true>> | Store<ReadonlyArray<RemoteState.PendingIntent<Intent>>>,
+  | RemoteState.RemoteStateVisibleStore<'TItems'>
+  | RemoteState.RemoteStateTruthStore<'TItems'>
+  | RemoteState.RemoteStatePendingStore<'TItems'>,
   never,
-  Store<number> | SendDep | Reducers | Procedures | Channels | Bus
+  State.StateStore<'tcPage', number> | SendDep | Reducers | Procedures | Channels | Bus
 > = okLive
 
 // @ts-expect-error the send body's R2 must appear in the layer's requirements
 export const badLayer: Layer.Layer<
-  Store<AsyncData<ReadonlyArray<Row>, string, true>> | Store<ReadonlyArray<RemoteState.PendingIntent<Intent>>>,
+  | RemoteState.RemoteStateVisibleStore<'TItems'>
+  | RemoteState.RemoteStateTruthStore<'TItems'>
+  | RemoteState.RemoteStatePendingStore<'TItems'>,
   never,
-  Store<number> | Reducers | Procedures | Channels | Bus
+  State.StateStore<'tcPage', number> | Reducers | Procedures | Channels | Bus
 > = okLive
 
 const AlwaysItemsBase: RemoteState.RemoteStateClass<
@@ -118,10 +128,11 @@ const AlwaysItemsBase: RemoteState.RemoteStateClass<
 class AlwaysItems extends AlwaysItemsBase {}
 
 export const badDisabled: Layer.Layer<
-  | Store<AsyncData<ReadonlyArray<Row>, never, false>>
-  | Store<ReadonlyArray<RemoteState.PendingIntent<Event.EventType<typeof AddIntent>>>>,
+  | RemoteState.RemoteStateVisibleStore<'TAlwaysItems'>
+  | RemoteState.RemoteStateTruthStore<'TAlwaysItems'>
+  | RemoteState.RemoteStatePendingStore<'TAlwaysItems'>,
   never,
-  Store<number> | Reducers | Procedures | Channels | Bus
+  State.StateStore<'tcPage', number> | Reducers | Procedures | Channels | Bus
 > = RemoteState.live(AlwaysItems, {
   query: () => Effect.succeed<ReadonlyArray<Row>>([]),
   send: () => Effect.void,
@@ -145,19 +156,32 @@ export const noIdle: Effect.Effect.Success<typeof AlwaysItems>['_tag'] = idleArm
 // @ts-expect-error no `error` schema ⇒ no Error arm
 export const noError: Effect.Effect.Success<typeof AlwaysItems>['_tag'] = errorArm
 
-export const classAsSource: Source<'TItems', AsyncData<ReadonlyArray<Row>, string, true>> = Items
+export const classAsSource: Source<
+  'TItems',
+  AsyncData<ReadonlyArray<Row>, string, true>,
+  RemoteState.RemoteStateVisibleStore<'TItems'>
+> = Items
 export const classAsAnySource: AnySource = Items
 
-export const pendingAsSource: Source<'TItems/pending', ReadonlyArray<RemoteState.PendingIntent<Intent>>> =
-  Items.pending
+export const pendingAsSource: Source<
+  'TItems/pending',
+  ReadonlyArray<RemoteState.PendingIntent<Intent>>,
+  RemoteState.RemoteStatePendingStore<'TItems'>
+> = Items.pending
 
-export const truthAsSource: Source<'TItems/truth', AsyncData<ReadonlyArray<Row>, string, true>> =
-  Items.truth
+export const truthAsSource: Source<
+  'TItems/truth',
+  AsyncData<ReadonlyArray<Row>, string, true>,
+  RemoteState.RemoteStateTruthStore<'TItems'>
+> = Items.truth
 
 export const covered: Boundary.BoundaryClass<'TItemsBoundary', readonly [typeof Items]> =
   Boundary.make('TItemsBoundary', { over: [Items] })
 
-export const badReducerTarget: Reducer.StateReducerClass<State.AnyState, readonly [typeof AddIntent]> =
+export const badReducerTarget: Reducer.StateReducerClass<
+  State.AnyState,
+  readonly [typeof AddIntent]
+> =
   // @ts-expect-error the pending queue is not a reducible state
   Reducer.make('TBadReducer', {
     states: [Items.pending],

package/src/remote/remoteStateMake.ts

@@ -0,0 +1,97 @@
+import { Context, Effect, Schema } from 'effect'
+import type { AsyncData } from '../calc/asyncData'
+import { yieldableClass } from '../definition/definition'
+import * as Event from '../event/event'
+import { type GatedOf, gatedFlag, type QueryCodec } from '../internal/queryDriver'
+import type { Store } from '../internal/store'
+import { readTracked } from '../internal/track'
+import { type AnySource, type SourceCapture, StateToken } from '../state/token'
+import type {
+  FailedIntent,
+  PendingIntent,
+  RemoteStateClass,
+  RemoteStateConfigExternalApi,
+  RemoteStateManifestExternalApi,
+  RemoteStatePendingStore,
+  RemoteStateTruthStore,
+  RemoteStateVisibleStore,
+} from './remoteStateTypes'
+
+// Schema.Unknown is structural because Intents is open at make-time; the declaration preserves its authored payload type.
+export const looseSchema = <P>(schema: Schema.Schema.AnyNoContext): Schema.Schema<P, P, never> =>
+  Schema.declare((input): input is P => Schema.is(schema)(input))
+
+export const make = <
+  const N extends string,
+  const Inputs extends ReadonlyArray<AnySource>,
+  const Intents extends ReadonlyArray<Event.AnyEvent>,
+  OutputSchema extends Schema.Schema.AnyNoContext,
+  ErrorSchema extends Schema.Schema.AnyNoContext | undefined = undefined,
+  const AlwaysOn extends boolean = false,
+>(
+  name: N,
+  config: RemoteStateConfigExternalApi<Inputs, Intents, OutputSchema, ErrorSchema, AlwaysOn>,
+): RemoteStateClass<
+  N,
+  Inputs,
+  Intents,
+  Schema.Schema.Type<OutputSchema>,
+  ErrorSchema extends Schema.Schema.AnyNoContext ? Schema.Schema.Type<ErrorSchema> : never,
+  GatedOf<AlwaysOn>
+> => {
+  type A = Schema.Schema.Type<OutputSchema>
+  type E = ErrorSchema extends Schema.Schema.AnyNoContext ? Schema.Schema.Type<ErrorSchema> : never
+  type I = Event.EventType<Intents[number]>
+  const store = Context.GenericTag<
+    RemoteStateVisibleStore<N>,
+    Store<AsyncData<A, E, GatedOf<AlwaysOn>>>
+  >(`reform/remoteState/${name}`)
+  const truthTag = Context.GenericTag<
+    RemoteStateTruthStore<N>,
+    Store<AsyncData<A, E, GatedOf<AlwaysOn>>>
+  >(`reform/remoteState/${name}/truth`)
+  const pendingTag = Context.GenericTag<
+    RemoteStatePendingStore<N>,
+    Store<ReadonlyArray<PendingIntent<I>>>
+  >(`reform/remoteState/${name}/pending`)
+  const gated = gatedFlag(config.alwaysOn)
+  const manifest: RemoteStateManifestExternalApi<N> = {
+    kind: 'RemoteState',
+    name,
+    output: config.output,
+    gated,
+    intents: config.intents.map((event) => event.tag),
+    ...(config.error !== undefined ? { error: config.error } : {}),
+  }
+  const codec: QueryCodec<A> = {
+    encode: Schema.encode(config.output),
+    decode: Schema.decodeUnknown(config.output),
+  }
+  // Annotations preserve template-literal types for the public statics.
+  const truthName: `${N}/truth` = `${name}/truth`
+  const pendingName: `${N}/pending` = `${name}/pending`
+  const failedName: `${N}/Failed` = `${name}/Failed`
+  const read = Effect.flatMap(store, readTracked)
+  const remote: RemoteStateClass<N, Inputs, Intents, A, E, GatedOf<AlwaysOn>> = yieldableClass(
+    read,
+    {
+      manifest,
+      codec,
+      store,
+      name,
+      inputs: config.inputs,
+      intents: config.intents,
+      gated,
+      capture: <Result>(visit: SourceCapture<Result>): Result => visit(remote),
+      truth: new StateToken(truthName, truthTag),
+      pending: new StateToken(pendingName, pendingTag),
+      Failed: Event.make(
+        failedName,
+        looseSchema<FailedIntent<I>>(
+          Schema.Struct({ intent: Schema.Unknown, error: Schema.Unknown }),
+        ),
+      ),
+    },
+  )
+  return remote
+}