@playfast/reform 1.1.1 → 1.2.0

package/src/remote/remoteStateDefinition.ts

@@ -1,135 +0,0 @@
-import { Context, Effect, Schema } from 'effect'
-import type { Effect as EffectType } from 'effect/Effect'
-import { type Manifest, yieldableClass } from '../definition/definition'
-import * as Event from '../event/event'
-import { readTracked } from '../internal/track'
-import type { AnySchema } from '../internal/variance'
-import type { GatedOf } from '../internal/queryDriver'
-import { gatedFlag } from '../internal/queryDriver'
-import type { AnySource } from '../state/token'
-import { StateToken } from '../state/token'
-import type { Store } from '../internal/store'
-import type { AsyncData, AsyncError, AsyncSuccess } from '../calc/asyncData'
-
-export interface PendingIntent<I> {
-  readonly opId: string
-  readonly intent: I
-  readonly status: 'sending' | 'confirmed'
-}
-
-export interface FailedIntent<I> {
-  readonly intent: I
-  readonly error: unknown
-}
-
-export type RemoteStateSettled<A, E> = AsyncSuccess<A> | AsyncError<E>
-
-// ExternalApi: optional `intent` only on Queued envelopes
-export interface QueueFoldEventExternalApi<I> {
-  readonly _tag: string
-  readonly opId: string
-  readonly intent?: I
-}
-
-export interface RemoteStateManifestExternalApi<N extends string, A, E> extends Manifest {
-  readonly kind: 'RemoteState'
-  readonly name: N
-  readonly output: AnySchema<A>
-  readonly error?: AnySchema<E>
-  readonly gated: boolean
-  readonly intents: ReadonlyArray<string>
-}
-
-export interface RemoteStateClass<
-  out N extends string,
-  out Inputs extends ReadonlyArray<AnySource>,
-  in out Intents extends ReadonlyArray<Event.AnyEvent>,
-  in out A,
-  in out E,
-  in out Gated extends boolean,
-> extends EffectType<AsyncData<A, E, Gated>, never, Store<AsyncData<A, E, Gated>>> {
-  new (): {}
-  readonly manifest: RemoteStateManifestExternalApi<N, A, E>
-  readonly store: Context.Tag<Store<AsyncData<A, E, Gated>>, Store<AsyncData<A, E, Gated>>>
-  readonly name: N
-  readonly inputs: Inputs
-  readonly intents: Intents
-  readonly gated: Gated
-  readonly truth: StateToken<`${N}/truth`, AsyncData<A, E, Gated>>
-  // pending is a Source (not StateClass) so user reducers cannot target it
-  readonly pending: StateToken<
-    `${N}/pending`,
-    ReadonlyArray<PendingIntent<Event.EventType<Intents[number]>>>
-  >
-  readonly Failed: Event.EventClass<`${N}/Failed`, FailedIntent<Event.EventType<Intents[number]>>>
-}
-
-export interface RemoteStateConfigExternalApi<
-  Inputs extends ReadonlyArray<AnySource>,
-  Intents extends ReadonlyArray<Event.AnyEvent>,
-  A,
-  E,
-  AlwaysOn extends boolean,
-> {
-  readonly inputs: Inputs
-  readonly output: AnySchema<A>
-  readonly error?: AnySchema<E>
-  readonly alwaysOn?: AlwaysOn
-  readonly intents: Intents
-}
-
-// Schema.Unknown in intent slot: Intents is open at make-time; event schemas are reflective only
-export const looseSchema = <P>(schema: Schema.Schema.AnyNoContext): AnySchema<P> => schema
-
-export const make = <
-  const N extends string,
-  const Inputs extends ReadonlyArray<AnySource>,
-  const Intents extends ReadonlyArray<Event.AnyEvent>,
-  A,
-  E = never,
-  const AlwaysOn extends boolean = false,
->(
-  name: N,
-  config: RemoteStateConfigExternalApi<Inputs, Intents, A, E, AlwaysOn>,
-): RemoteStateClass<N, Inputs, Intents, A, E, GatedOf<AlwaysOn>> => {
-  type I = Event.EventType<Intents[number]>
-  const store = Context.GenericTag<Store<AsyncData<A, E, GatedOf<AlwaysOn>>>>(
-    `reform/remoteState/${name}`,
-  )
-  const truthTag = Context.GenericTag<Store<AsyncData<A, E, GatedOf<AlwaysOn>>>>(
-    `reform/remoteState/${name}/truth`,
-  )
-  const pendingTag = Context.GenericTag<Store<ReadonlyArray<PendingIntent<I>>>>(
-    `reform/remoteState/${name}/pending`,
-  )
-  const gated = gatedFlag(config.alwaysOn)
-  const manifest: RemoteStateManifestExternalApi<N, A, E> = {
-    kind: 'RemoteState',
-    name,
-    output: config.output,
-    gated,
-    intents: config.intents.map((event) => event.tag),
-    ...(config.error !== undefined ? { error: config.error } : {}),
-  }
-  // Annotated consts preserve template-literal types for interface matching
-  const truthName: `${N}/truth` = `${name}/truth`
-  const pendingName: `${N}/pending` = `${name}/pending`
-  const failedName: `${N}/Failed` = `${name}/Failed`
-  const read = Effect.flatMap(store, readTracked)
-  return yieldableClass(read, {
-    manifest,
-    store,
-    name,
-    inputs: config.inputs,
-    intents: config.intents,
-    gated,
-    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 }),
-      ),
-    ),
-  })
-}

package/src/remote/remoteStateLayers.ts

@@ -1,118 +0,0 @@
-import { Context, Effect, Layer, MutableRef } from 'effect'
-import { type AnyAsyncData, AsyncData, narrowStore, widenStore } from '../calc/asyncData'
-import { reuse as shareStructure } from '../internal/reuse'
-import { resolveScheduler } from '../internal/scheduler'
-import { sameKey } from '../internal/sources'
-import { makeDerivedStore, type Store } from '../internal/store'
-import { narrowHandled } from '../runtime/bus'
-import { type ReducerEntry, Reducers } from '../runtime/loop'
-import type { PendingIntent, QueueFoldEventExternalApi } from './remoteStateDefinition'
-
-interface OverlayLayerOptions<I, A, E, Gated extends boolean> {
-  readonly apply: (current: A, intent: I) => A
-  readonly pendingTag: Context.Tag<Store<ReadonlyArray<PendingIntent<I>>>, Store<ReadonlyArray<PendingIntent<I>>>>
-  readonly reuse: boolean | undefined
-  readonly storeTag: Context.Tag<Store<AsyncData<A, E, Gated>>, Store<AsyncData<A, E, Gated>>>
-  readonly truthTag: Context.Tag<Store<AsyncData<A, E, Gated>>, Store<AsyncData<A, E, Gated>>>
-}
-
-export const makeOverlayLayer = <I, A, E, Gated extends boolean>(
-  options: OverlayLayerOptions<I, A, E, Gated>,
-): Layer.Layer<Store<AsyncData<A, E, Gated>>, never, Store<AsyncData<A, E, Gated>> | Store<ReadonlyArray<PendingIntent<I>>>> =>
-  Layer.scoped(
-    options.storeTag,
-    Effect.gen(function* () {
-      const scheduler = yield* resolveScheduler
-      const feedStore = widenStore<A, E, Gated>(yield* options.truthTag)
-      const queueStore = yield* options.pendingTag
-      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 pending = queueStore.getSnapshot()
-        const key = [feed, pending]
-        const previous = MutableRef.get(memo)
-        if (previous !== undefined && sameKey(key, previous.key)) {
-          return previous.output
-        }
-        const applyPending = (base: A): A =>
-          pending.reduce((applied, entry) => options.apply(applied, entry.intent), base)
-        const overlaid: AnyAsyncData<A, E> =
-          feed._tag === 'Success' ? AsyncData.success(applyPending(feed.value), feed.refetching) : feed
-        const output =
-          options.reuse === true &&
-          previous !== undefined &&
-          previous.output._tag === 'Success' &&
-          overlaid._tag === 'Success'
-            ? AsyncData.success(shareStructure(previous.output.value, overlaid.value), overlaid.refetching)
-            : overlaid
-        MutableRef.set(memo, { key, output })
-        return output
-      }
-      const subscribe = (listener: () => void): (() => void) => {
-        const offFeed = feedStore.subscribe(listener)
-        const offQueue = queueStore.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)
-    }),
-  )
-
-interface QueueReducerOptions<I> {
-  readonly ackedTag: string
-  readonly name: string
-  readonly pendingTag: Context.Tag<Store<ReadonlyArray<PendingIntent<I>>>, Store<ReadonlyArray<PendingIntent<I>>>>
-  readonly queuedTag: string
-  readonly settledTag: string
-}
-
-export const makeQueueReducerLayer = <I>(
-  options: QueueReducerOptions<I>,
-): Layer.Layer<never, never, Reducers | Store<ReadonlyArray<PendingIntent<I>>>> => {
-  const handles: ReadonlySet<string> = new Set([options.queuedTag, options.ackedTag, options.settledTag])
-  const fold = (
-    queue: ReadonlyArray<PendingIntent<I>>,
-    event: QueueFoldEventExternalApi<I>,
-  ): ReadonlyArray<PendingIntent<I>> => {
-    if (event._tag === options.queuedTag) {
-      return event.intent === undefined
-        ? queue
-        : [...queue, { opId: event.opId, intent: event.intent, status: 'sending' }]
-    }
-    if (event._tag === options.ackedTag) {
-      const sending = queue.some((entry) => entry.opId === event.opId && entry.status === 'sending')
-      if (!sending) {
-        return queue
-      }
-      return queue.map((entry) =>
-        entry.opId === event.opId ? { ...entry, status: 'confirmed' as const } : entry,
-      )
-    }
-    return queue.some((entry) => entry.opId === event.opId)
-      ? queue.filter((entry) => entry.opId !== event.opId)
-      : queue
-  }
-  return Layer.scopedDiscard(
-    Effect.gen(function* () {
-      const reducers = yield* Reducers
-      if (reducers.entries.some((entry) => entry.name === options.name)) {
-        yield* Effect.logWarning(`reform: duplicate reducer name '${options.name}' registered`)
-      }
-      const store = yield* options.pendingTag
-      const entry: ReducerEntry = {
-        name: options.name,
-        handles,
-        apply: (event) => store.set(fold(store.get(), narrowHandled(event))),
-      }
-      yield* Effect.acquireRelease(Effect.sync(() => reducers.register(entry)), () =>
-        Effect.sync(() => reducers.unregister(entry)),
-      )
-    }),
-  )
-}

package/src/remote/remoteStateLiveTypes.ts

@@ -1,59 +0,0 @@
-import { Effect } from 'effect'
-import * as Event from '../event/event'
-import * as Channel from '../channel/channel'
-import type { InputsObject, InvalidateBy } from '../internal/sources'
-import type { AnySource } from '../state/token'
-import type { RemoteStateSettled } from './remoteStateDefinition'
-
-type EventPayload<Ev extends Event.AnyEvent> = Ev extends Event.EventClass<string, infer P>
-  ? P
-  : never
-
-export type RemoteStateLiveExternalApi<
-  Inputs extends ReadonlyArray<AnySource>,
-  Intents extends ReadonlyArray<Event.AnyEvent>,
-  A,
-  E,
-  Gated extends boolean,
-  R,
-  R2,
-  SettledEvent extends Event.AnyEvent = never,
-> = {
-  readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
-  // Any failure settles + Failed; response value ignored — truth via invalidated query
-  readonly send: (intent: Event.EventType<Intents[number]>) => Effect.Effect<unknown, unknown, R2>
-  // Must be idempotent against truth that already carries the intent
-  readonly apply: (value: A, intent: Event.EventType<Intents[number]>) => A
-  readonly channel?: Channel.ChannelClass
-  readonly invalidateBy?: InvalidateBy<Inputs>
-  readonly invalidateOn?: ReadonlyArray<Event.AnyEvent>
-  readonly coalesce?: 'switch' | 'trailing'
-  readonly reuse?: boolean
-  readonly settled?: {
-    readonly event: SettledEvent
-    readonly payload: (result: RemoteStateSettled<A, E>) => EventPayload<SettledEvent>
-  }
-  // Only settled server truth is persisted (overlay is a separate store)
-  readonly persist?:
-    | boolean
-    | { readonly key?: string | ((inputs: InputsObject<Inputs>) => string) }
-} & (Gated extends true
-  ? { readonly disabled?: (inputs: InputsObject<Inputs>) => boolean }
-  : { readonly disabled?: never })
-
-// Runtime view: `disabled` is `never` at type level for non-gated definitions
-export type RemoteStateLiveRuntimeExternalApi<Inputs extends ReadonlyArray<AnySource>, A, E, R> = {
-  readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
-  readonly invalidateBy?: InvalidateBy<Inputs>
-  readonly disabled?: (inputs: InputsObject<Inputs>) => boolean
-  readonly coalesce?: 'switch' | 'trailing'
-  readonly reuse?: boolean
-  readonly persist?:
-    | boolean
-    | { readonly key?: string | ((inputs: InputsObject<Inputs>) => string) }
-}
-
-export interface SettleLink {
-  readonly requested: () => number
-  readonly register: (opId: string, waitFor: number) => void
-}

package/src/remote/remoteStateSend.ts

@@ -1,64 +0,0 @@
-import { Context, Effect, Either, Layer } from 'effect'
-import * as Channel from '../channel/channel'
-import * as Event from '../event/event'
-import { Bus, narrowHandled } from '../runtime/bus'
-import type { SettleLink } from './remoteStateLiveTypes'
-
-interface SendProcedureOptions<I, R> {
-  readonly acked: Event.EventClass<string, { readonly opId: string }>
-  readonly channel: Channel.ChannelClass
-  readonly failed: Event.EventClass<string, { readonly intent: I; readonly error: unknown }>
-  readonly handles: ReadonlySet<string>
-  readonly invalidated: Event.EventClass<string, {}>
-  readonly linkTag: Context.Tag<SettleLink, SettleLink>
-  readonly name: string
-  readonly queued: Event.EventClass<string, { readonly opId: string; readonly intent: I }>
-  readonly send: (intent: I) => Effect.Effect<unknown, unknown, R>
-  readonly settled: Event.EventClass<string, { readonly opId: string }>
-}
-
-export const makeSendProcedureLayer = <I, R>(
-  options: SendProcedureOptions<I, R>,
-): Layer.Layer<never, never, Channel.Procedures | SettleLink | Bus | R> =>
-  Layer.scopedDiscard(
-    Effect.gen(function* () {
-      const procedures = yield* Channel.Procedures
-      if (procedures.entries.some((entry) => entry.name === options.name)) {
-        yield* Effect.logWarning(`reform: duplicate procedure name '${options.name}' registered`)
-      }
-      const link = yield* options.linkTag
-      const runtime = yield* Effect.runtime<Bus | R>()
-      const deliver = Effect.fn('deliver')(
-        function* (intent: I): Effect.fn.Return<void, never, Bus | R> {
-          const opId = yield* Effect.sync(() => crypto.randomUUID())
-          yield* Event.dispatch(options.queued, { opId, intent })
-          const outcome = yield* options.send(intent).pipe(
-            Effect.catchAllDefect((defect) => Effect.fail(defect)),
-            Effect.either,
-            Effect.onInterrupt(() => Event.dispatch(options.settled, { opId })),
-          )
-          yield* Either.match(outcome, {
-            onLeft: (error) =>
-              Effect.zipRight(
-                Event.dispatch(options.failed, { intent, error }),
-                Event.dispatch(options.settled, { opId }),
-              ),
-            onRight: () =>
-              Effect.sync(() => link.register(opId, link.requested() + 1)).pipe(
-                Effect.zipRight(Event.dispatch(options.acked, { opId })),
-                Effect.zipRight(Event.dispatch(options.invalidated, {})),
-              ),
-          })
-        },
-      )
-      const entry: Channel.ProcedureEntry = {
-        name: options.name,
-        channelName: options.channel.manifest.name,
-        handles: options.handles,
-        run: (event) => Effect.provide(deliver(narrowHandled<I>(event)), runtime),
-      }
-      yield* Effect.acquireRelease(Effect.sync(() => procedures.register(entry)), () =>
-        Effect.sync(() => procedures.unregister(entry)),
-      )
-    }),
-  )