@playfast/reform 1.1.1 → 1.2.1

package/src/testkit/flight.testkit.ts

@@ -0,0 +1,84 @@
+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))
+
+// The runtime notifies on the microtask queue (scheduler, stateFamily, calcFamily),
+// so draining turns is exact where a duration is a guess: a microtask cannot be
+// starved by host load the way a 10ms budget can. Use this to let the graph
+// quiesce before asserting that something did NOT happen.
+export const flush = (turns = 3): Effect.Effect<void> =>
+  Effect.promise(() => new Promise<void>((resolve) => queueMicrotask(resolve))).pipe(
+    Effect.repeatN(Math.max(turns - 1, 0)),
+  )
+
+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

@@ -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

@@ -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

@@ -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

@@ -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/internal/ctx.ts

@@ -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

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
-}