@playfast/reform 0.0.10 → 0.0.11

package/src/remote/remoteState.ts

@@ -79,7 +79,18 @@ export interface FailedIntent<I> {
   readonly error: unknown
 }
 
-export interface RemoteStateManifest<N extends string, A, E> extends Manifest {
+// The erased event envelope the queue reducer folds over (bus boundary shape ⇒
+// `ExternalApi` postfix exempts the optional `intent` field). Only `Queued`
+// carries an `intent`; ack/settle envelopes name an op only.
+interface QueueFoldEventExternalApi<I> {
+  readonly _tag: string
+  readonly opId: string
+  readonly intent?: I
+}
+
+// Reflective metadata read by chrome/dev tools (boundary shape ⇒ `ExternalApi`
+// postfix exempts it from `no-optional-fields`).
+export interface RemoteStateManifestExternalApi<N extends string, A, E> extends Manifest {
   readonly kind: 'RemoteState'
   readonly name: N
   /** Schema of the server value (`Success` arm / `apply`'s domain). */
@@ -100,7 +111,7 @@ export interface RemoteStateClass<
   in out Gated extends boolean,
 > extends Effect.Effect<AsyncData<A, E, Gated>, never, Store<AsyncData<A, E, Gated>>> {
   new (): {}
-  readonly manifest: RemoteStateManifest<N, A, E>
+  readonly manifest: RemoteStateManifestExternalApi<N, A, E>
   /** The OVERLAID view (`pending.reduce(apply, truth)`) — what `yield*` reads. */
   readonly store: Context.Tag<Store<AsyncData<A, E, Gated>>, Store<AsyncData<A, E, Gated>>>
   /** The name, so the class doubles as a `Source` input to another calc. */
@@ -126,7 +137,9 @@ export interface RemoteStateClass<
   readonly Failed: Event.EventClass<`${N}/Failed`, FailedIntent<Event.EventType<Intents[number]>>>
 }
 
-export interface RemoteStateConfig<
+// Public definition-surface config (boundary shape ⇒ `ExternalApi` postfix
+// exempts the optional option fields from `no-optional-fields`).
+export interface RemoteStateConfigExternalApi<
   Inputs extends ReadonlyArray<AnySource>,
   Intents extends ReadonlyArray<Event.AnyEvent>,
   A,
@@ -167,7 +180,7 @@ export const make = <
   const AlwaysOn extends boolean = false,
 >(
   name: N,
-  config: RemoteStateConfig<Inputs, Intents, A, E, AlwaysOn>,
+  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>>>>(
@@ -180,7 +193,7 @@ export const make = <
     `reform/remoteState/${name}/pending`,
   )
   const gated = gatedFlag(config.alwaysOn)
-  const manifest: RemoteStateManifest<N, A, E> = {
+  const manifest: RemoteStateManifestExternalApi<N, A, E> = {
     kind: 'RemoteState',
     name,
     output: config.output,
@@ -216,7 +229,7 @@ export const make = <
  * The `.live` config: the query (same contract as `AsyncCalc.live`), the
  * delivery effect, and the pure per-intent fold.
  */
-export type RemoteStateLive<
+export type RemoteStateLiveExternalApi<
   Inputs extends ReadonlyArray<AnySource>,
   Intents extends ReadonlyArray<Event.AnyEvent>,
   A,
@@ -247,10 +260,36 @@ export type RemoteStateLive<
   readonly coalesce?: 'switch' | 'trailing'
   /** Structural sharing across refetches AND overlay recomputes — see `AsyncCalc.live`. */
   readonly reuse?: boolean
+  /**
+   * Persist the converged `Success` truth through the optional host `QueryStore`
+   * — see `AsyncCalc.live`. Only the settled SERVER value is written: the driver's
+   * `persistWrite` runs in the success lane after `settleSuccess`, while the
+   * optimistic overlay lives in a separate downstream store the driver never
+   * sees — so a persisted value can never capture an un-acked mutation. `true`
+   * keys by the remote state's name; `{ key }` overrides (a function of the
+   * inputs for a keyed family). Values (de)serialize through the `output` schema.
+   */
+  readonly persist?:
+    | boolean
+    | { readonly key?: string | ((inputs: InputsObject<Inputs>) => string) }
 } & (Gated extends true
   ? { readonly disabled?: (inputs: InputsObject<Inputs>) => boolean }
   : { readonly disabled?: never })
 
+// Loose runtime view: `disabled` is erased to `never` for non-gated definitions
+// at the type level, so the driver reads config back through this (boundary ⇒
+// `ExternalApi` postfix exempts its optional fields).
+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) }
+}
+
 /** The seam between the send procedure and the query driver (module-private). */
 interface SettleLink {
   /** The driver's highest REQUESTED run generation (see `QueryDriver.requested`). */
@@ -278,7 +317,7 @@ export const live = <
   R2,
 >(
   remote: RemoteStateClass<N, Inputs, Intents, A, E, Gated>,
-  config: RemoteStateLive<Inputs, Intents, A, E, Gated, R, R2>,
+  config: RemoteStateLiveExternalApi<Inputs, Intents, A, E, Gated, R, R2>,
 ): Layer.Layer<
   | Store<AsyncData<A, E, Gated>>
   | Store<ReadonlyArray<PendingIntent<Event.EventType<Intents[number]>>>>,
@@ -312,9 +351,13 @@ export const live = <
   // The hidden revision pair (the `invalidateOn` machinery, unconditional here:
   // `Invalidated` always drives it; user `invalidateOn` events join the same fold).
   const revisionState = State.make(`${name}/revision`, RevisionSchema)
+  const extraInvalidateOn = Option.getOrElse(
+    Option.fromNullable(config.invalidateOn),
+    (): ReadonlyArray<Event.AnyEvent> => [],
+  )
   const revisionReducer = Reducer.make(`${name}/revision`, {
     states: [revisionState],
-    events: [Invalidated, ...(config.invalidateOn ?? [])],
+    events: [Invalidated, ...extraInvalidateOn],
   })
 
   // The settle link, keyed per live so two remote states never cross-resolve.
@@ -325,13 +368,8 @@ export const live = <
     Effect.gen(function* () {
       // `disabled` is rejected at the type level for non-gated definitions
       // (erased to `never` there); read it through a loose view for the runtime.
-      const cfg = config as {
-        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
-      }
+      // 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>
       // Requirement-free read (`serviceOption`): the assembly below always
       // provides the revision store alongside this driver.
       const revision = Option.getOrUndefined(yield* Effect.serviceOption(revisionState.store))
@@ -345,17 +383,35 @@ export const live = <
       >([])
       const onSettled = (generation: number) => {
         const due = MutableRef.get(waiters).filter((waiter) => waiter.waitFor <= generation)
-        if (due.length === 0) return
+        if (due.length === 0) {
+          return
+        }
         MutableRef.update(waiters, (all) => all.filter((waiter) => waiter.waitFor > generation))
         // Dispatch synchronously (`publish` only enqueues on the unbounded bus):
         // the settle is enqueued in the same flush as the converged value write.
-        for (const waiter of due) {
+        due.forEach((waiter) =>
           Runtime.runSync(runtime)(
             publish('Normal', Event.construct(Settled, { opId: waiter.opId })),
-          )
-        }
+          ),
+        )
       }
 
+      // Persist mirrors `AsyncCalc.live`: only the settled truth reaches the
+      // store (see the `persist` doc above), so it needs no extra success/overlay
+      // guard. `true` keys by name; `{ key }` overrides (a function for a family).
+      const persistOption = cfg.persist
+      const persistKey =
+        persistOption === true || persistOption === undefined || persistOption === false
+          ? 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) }
       const driver = yield* makeQueryDriver({
         name,
         label: 'RemoteState',
@@ -366,13 +422,8 @@ export const live = <
         disabled: cfg.disabled,
         coalesce: cfg.coalesce,
         reuse: cfg.reuse,
-        extraKey:
-          revision === undefined
-            ? undefined
-            : {
-                read: () => revision.getSnapshot(),
-                subscribe: (listener) => revision.subscribe(listener),
-              },
+        persist,
+        extraKey,
         onSettled,
       })
       const link: SettleLink = {
@@ -402,17 +453,16 @@ export const live = <
         const pending = queueStore.getSnapshot()
         const key = [feed, pending]
         const prev = MutableRef.get(memo)
-        if (prev !== undefined && sameKey(key, prev.key)) return prev.output
+        if (prev !== undefined && sameKey(key, prev.key)) {
+          return prev.output
+        }
         // `apply` runs over every `Success` — including `refetching: true`, so
         // queued intents stay visible while the server converges; the other
         // arms pass through by reference.
+        const applyPending = (base: A): A =>
+          pending.reduce((applied, entry) => config.apply(applied, entry.intent), base)
         const overlaid: AnyAsyncData<A, E> =
-          feed._tag === 'Success'
-            ? AsyncData.success(
-                pending.reduce((value, entry) => config.apply(value, entry.intent), feed.value),
-                feed.refetching,
-              )
-            : feed
+          feed._tag === 'Success' ? AsyncData.success(applyPending(feed.value), feed.refetching) : feed
         // With `reuse`, also reconcile consecutive overlay outputs: the fold
         // rebuilds the value per recompute, so untouched subtrees would
         // otherwise lose identity every time the queue moves.
@@ -449,24 +499,35 @@ export const live = <
   const queueHandles: ReadonlySet<string> = new Set([Queued.tag, Acked.tag, Settled.tag])
   const foldQueue = (
     queue: ReadonlyArray<PendingIntent<I>>,
-    event: { readonly _tag: string; readonly opId: string; readonly intent?: I },
-  ): ReadonlyArray<PendingIntent<I>> =>
+    event: QueueFoldEventExternalApi<I>,
+  ): ReadonlyArray<PendingIntent<I>> => {
     // `Queued` is the arm carrying the intent (the `undefined` guard is for the
-    // type only — every `Queued` carries one). An ack/settle for an id that is
+    // type only — every `Queued` carries one).
+    if (event._tag === Queued.tag) {
+      if (event.intent === undefined) {
+        return queue
+      }
+      return [...queue, { opId: event.opId, intent: event.intent, status: 'sending' }]
+    }
+    // An ack flips a still-sending op to confirmed; an ack for an id that is
     // absent (or already confirmed) keeps the same reference — a true no-op.
-    event._tag === Queued.tag
-      ? event.intent === undefined
-        ? queue
-        : [...queue, { opId: event.opId, intent: event.intent, status: 'sending' }]
-      : event._tag === Acked.tag
-        ? queue.some((entry) => entry.opId === event.opId && entry.status === 'sending')
-          ? queue.map((entry) =>
-              entry.opId === event.opId ? { ...entry, status: 'confirmed' as const } : entry,
-            )
-          : queue
-        : queue.some((entry) => entry.opId === event.opId)
-          ? queue.filter((entry) => entry.opId !== event.opId)
-          : queue
+    if (event._tag === Acked.tag) {
+      const stillSending = queue.some(
+        (entry) => entry.opId === event.opId && entry.status === 'sending',
+      )
+      if (!stillSending) {
+        return queue
+      }
+      return queue.map((entry) =>
+        entry.opId === event.opId ? { ...entry, status: 'confirmed' as const } : entry,
+      )
+    }
+    // Settle drops the op if present; absent ⇒ same reference, a true no-op.
+    if (!queue.some((entry) => entry.opId === event.opId)) {
+      return queue
+    }
+    return queue.filter((entry) => entry.opId !== event.opId)
+  }
   const queueReducerLayer = Layer.scopedDiscard(
     Effect.gen(function* () {
       const reducers = yield* Reducers
@@ -502,8 +563,8 @@ export const live = <
       const link = yield* linkTag
       // Snapshot the body's full context (Bus + the send's R2) so `run` is total.
       const runtime = yield* Effect.runtime<Bus | R2>()
-      const deliver = (intent: I): Effect.Effect<void, never, Bus | R2> =>
-        Effect.gen(function* () {
+      const deliver = Effect.fn('deliver')(
+        function* (intent: I): Effect.fn.Return<void, never, Bus | R2> {
           const opId = yield* Effect.sync(() => crypto.randomUUID())
           yield* Event.dispatch(Queued, { opId, intent })
           const outcome = yield* config.send(intent).pipe(

package/src/remote/remoteState.typecheck.ts

@@ -25,6 +25,9 @@ const RenameIntentBase: Event.EventClass<
 > = Event.make('TRenameIntent', S.Struct({ id: S.String, name: S.String }))
 class RenameIntent extends RenameIntentBase {}
 type Intent = Event.EventType<typeof AddIntent> | Event.EventType<typeof RenameIntent>
+// An undeclared intent tag, named so the negative `apply` below avoids an inline
+// object-type parameter.
+type DeleteIntentTag = { readonly _tag: 'TDeleteIntent' }
 
 const PageBase: State.StateClass<'tcPage', number> = State.make('tcPage', S.Number)
 class Page extends PageBase {}
@@ -94,7 +97,7 @@ export const badIntent: Layer.Layer<
   query: () => Effect.succeed<ReadonlyArray<Row>>([]),
   send: () => Effect.void,
   // @ts-expect-error 'TDeleteIntent' is not in the declared intent union
-  apply: (rows: ReadonlyArray<Row>, intent: { readonly _tag: 'TDeleteIntent' }) => rows,
+  apply: (rows: ReadonlyArray<Row>, intent: DeleteIntentTag) => rows,
 })
 
 // --- layer requirement honesty: RIn is complete and exact ---

package/src/runtime/bus.ts

@@ -12,7 +12,9 @@ export interface Tagged {
  * generic `Tagged`, and this restores the typed view. The one documented home
  * for that boundary cast, shared by `Reducer.live` and `Procedure.live`.
  */
-export const narrowHandled = <E>(event: Tagged): E => event as never
+export const narrowHandled = <E>(event: Tagged): E =>
+  // oxlint-disable-next-line reform-rules/no-type-assertion -- documented runtime re-narrow of a routed Tagged envelope to its handler's declared event union (see jsdoc above)
+  event as never
 
 /** UI-originated events are High; procedure-emitted follow-ups are Normal (DESIGN #46). */
 export type Priority = 'High' | 'Normal'

package/src/runtime/hardening.test.ts

@@ -51,7 +51,7 @@ it.effect('two different channels registered under one name are rejected', () =>
     const exit = yield* Effect.scoped(Layer.build(layer)).pipe(Effect.exit)
     expect(Exit.isFailure(exit)).toBe(true)
     if (Exit.isFailure(exit)) {
-      expect(Cause.pretty(exit.cause)).toContain('duplicate Channel')
+      expect(Cause.pretty(exit.cause)).toContain('already live with a different policy')
     }
   })
 })

package/src/runtime/loop.ts

@@ -1,4 +1,4 @@
-import { Chunk, Context, Effect, Layer, PubSub, Queue } from 'effect'
+import { Array as Arr, Chunk, Context, Effect, Layer, Option, PubSub, Queue } from 'effect'
 import {
   Channels,
   channelsLayer,
@@ -44,37 +44,67 @@ const ReducersBase: Context.TagClass<Reducers, 'reform/Reducers', ReducerRegistr
   Context.Tag('reform/Reducers')<Reducers, ReducerRegistry>()
 export class Reducers extends ReducersBase {}
 
-/** Drop an item from a `Map<string, Array>` bucket, pruning the key when it empties. */
-const dropFromBuckets = <T>(map: Map<string, Array<T>>, key: string, item: T): void => {
+/** Drop a target from a `Map<string, Array>` bucket, pruning the key when it empties. */
+const dropFromBuckets = <T>(map: Map<string, Array<T>>, key: string, target: T): void => {
   const bucket = map.get(key)
-  if (bucket === undefined) return
-  const next = bucket.filter((entry) => entry !== item)
-  if (next.length === 0) map.delete(key)
-  else map.set(key, next)
+  if (bucket === undefined) {
+    return
+  }
+  const next = bucket.filter((entry) => entry !== target)
+  if (next.length === 0) {
+    map.delete(key)
+  } else {
+    map.set(key, next)
+  }
 }
 
 const makeReducerRegistry = (): ReducerRegistry => {
-  const entries: Array<ReducerEntry> = []
   const byTag = new Map<string, Array<ReducerEntry>>()
+  // Single live array reference, replaced immutably on register/unregister and
+  // exposed through the `entries` getter so consumers always read the current set.
+  const state: { entries: Array<ReducerEntry> } = { entries: [] }
   return {
-    entries,
+    get entries() {
+      return state.entries
+    },
     byTag,
     register: (entry) => {
-      entries.push(entry)
-      for (const tag of entry.handles) {
+      state.entries = [...state.entries, entry]
+      entry.handles.forEach((tag) => {
         const bucket = byTag.get(tag)
-        if (bucket === undefined) byTag.set(tag, [entry])
-        else bucket.push(entry)
-      }
+        if (bucket === undefined) {
+          byTag.set(tag, [entry])
+        } else {
+          byTag.set(tag, [...bucket, entry])
+        }
+      })
     },
     unregister: (entry) => {
-      const index = entries.indexOf(entry)
-      if (index >= 0) entries.splice(index, 1)
-      for (const tag of entry.handles) dropFromBuckets(byTag, tag, entry)
+      state.entries = state.entries.filter((existing) => existing !== entry)
+      entry.handles.forEach((tag) => dropFromBuckets(byTag, tag, entry))
     },
   }
 }
 
+/** Read a bucket array, defaulting to empty without a falsy fallback. */
+const bucketOf = <V>(map: Map<string, Array<V>>, tag: string): Array<V> =>
+  Option.getOrElse(Option.fromNullable(map.get(tag)), (): Array<V> => [])
+
+/** Run one reducer in isolation; a synchronous throw becomes a collected failure. */
+const isolateApply = (
+  reducer: ReducerEntry,
+  event: Tagged,
+): Option.Option<{ readonly event: Tagged; readonly error: unknown }> =>
+  Effect.runSync(
+    Effect.match(
+      Effect.try({ try: () => reducer.apply(event), catch: (error) => error }),
+      {
+        onFailure: (error) => Option.some({ event, error }),
+        onSuccess: () => Option.none(),
+      },
+    ),
+  )
+
 export const reducersLayer: Layer.Layer<Reducers> = Layer.sync(Reducers, makeReducerRegistry)
 
 /** High before Normal; within a priority class, dispatch order is preserved. */
@@ -101,42 +131,33 @@ const drain = Effect.gen(function* () {
 
         // Stable priority order: High-dispatched (UI) events fold before
         // Normal-dispatched (procedure follow-up) events in the same frame. A
-        // two-bucket partition does this in O(m) with no comparator — push order
+        // two-bucket partition does this in O(m) with no comparator — partition
         // preserves intra-priority dispatch order — instead of sorting the frame.
-        const high: Array<Envelope> = []
-        const normal: Array<Envelope> = []
-        for (const envelope of frame) {
-          if (rank(envelope.priority) === 0) high.push(envelope)
-          else normal.push(envelope)
-        }
-        const ordered = high.concat(normal)
+        const [high, normal] = Arr.partition(frame, (envelope) => rank(envelope.priority) !== 0)
+        const ordered = [...high, ...normal]
 
         // One synchronous block: every reducer write for the frame coalesces into
         // a single notification flush. Routing to channels happens here too, so
         // procedure bodies (run later, off their channel fibers) see post-batch
         // state. No `yield*` in between, or the flush could fire early.
-        const failures: Array<{ readonly event: Tagged; readonly error: unknown }> = []
-        yield* Effect.sync(() => {
-          for (const envelope of ordered) {
-            for (const reducer of reducers.byTag.get(envelope.event._tag) ?? []) {
-              // Isolate each fold: a synchronous throw in one reducer must not
-              // abandon the rest of the frame nor (via the `forever` below) kill
-              // the drain fiber and freeze the whole app. Collect and log after.
-              try {
-                reducer.apply(envelope.event)
-              } catch (error) {
-                failures.push({ event: envelope.event, error })
-              }
-            }
-          }
-          for (const envelope of ordered) {
-            // Offer to each DISTINCT channel once. Routing per-procedure would
-            // offer a shared channel multiple times for one event, and each offer
-            // re-runs every procedure on it — duplicate execution.
-            for (const channelName of procedures.channelsByTag.get(envelope.event._tag) ?? []) {
+        const failures = yield* Effect.sync(() => {
+          // Isolate each fold: a synchronous throw in one reducer must not abandon
+          // the rest of the frame nor (via the `forever` below) kill the drain fiber
+          // and freeze the whole app. Collect failures here, log after the block.
+          const collected = Arr.flatMap(ordered, (envelope) =>
+            Arr.filterMap(bucketOf(reducers.byTag, envelope.event._tag), (reducer) =>
+              isolateApply(reducer, envelope.event),
+            ),
+          )
+          // Offer to each DISTINCT channel once. Routing per-procedure would offer a
+          // shared channel multiple times for one event, and each offer re-runs every
+          // procedure on it — duplicate execution.
+          ordered.forEach((envelope) => {
+            bucketOf(procedures.channelsByTag, envelope.event._tag).forEach((channelName) => {
               channels.get(channelName)?.offer(envelope.event)
-            }
-          }
+            })
+          })
+          return collected
         })
         yield* Effect.forEach(
           failures,

package/src/runtime/queries.ts

@@ -45,7 +45,9 @@ const makeQueryRegistry = (): QueryRegistry => {
     // re-registration (re-mount before the old scope's finalizer runs) must not
     // be clobbered by the stale handle's unregister.
     unregister: (handle) => {
-      if (byName.get(handle.name) === handle) byName.delete(handle.name)
+      if (byName.get(handle.name) === handle) {
+        byName.delete(handle.name)
+      }
     },
   }
 }

package/src/scene/scene.ts

@@ -1,4 +1,4 @@
-import { Layer } from 'effect'
+import { Layer, Struct } from 'effect'
 import type { CompositionClass, CompositionService } from '../compose/composition'
 import type { UiContract } from '../compose/ui'
 import type { EventOf } from '../event/event'
@@ -41,6 +41,14 @@ export interface Scene<
   /** Closed wiring (logic + views), each layer seeding its own live state. */
   readonly provide: ReadonlyArray<Layer.Layer<MountedServices, never, never>>
   /** Events dispatched once the runtime is live (e.g. `RequestedTodos`). */
+  // oxlint-disable-next-line reform-rules/no-optional-fields -- presence-optional boot read as `scene.boot ?? []` across non-batch hosts (drive/proof/remote/react/editor); Option would break them
+  readonly boot?: ReadonlyArray<BootEvent>
+}
+
+/** Closed wiring + optional boot events handed to {@link scene}. */
+export interface SceneConfig {
+  readonly provide: ReadonlyArray<Layer.Layer<MountedServices, never, never>>
+  // oxlint-disable-next-line reform-rules/no-optional-fields -- mirrors Scene.boot; presence-optional to keep the authoring call site terse and back-compatible
   readonly boot?: ReadonlyArray<BootEvent>
 }
 
@@ -51,10 +59,7 @@ export interface Scene<
  */
 export const scene = <C extends UiContract, S extends ReadonlyArray<unknown>>(
   composition: CompositionClass<unknown, C, S>,
-  config: {
-    readonly provide: ReadonlyArray<Layer.Layer<MountedServices, never, never>>
-    readonly boot?: ReadonlyArray<BootEvent>
-  },
+  config: SceneConfig,
 ): Scene<C, S> => ({
   kind: 'Scene',
   composition,
@@ -79,10 +84,13 @@ export const seedScene = <C extends UiContract, S extends ReadonlyArray<unknown>
   base: Scene<C, S>,
   seeds: SeedsOf<S>,
 ): Scene<C, S> =>
-  Object.keys(seeds).length === 0
+  Struct.keys(seeds).length === 0
     ? base
     : { ...base, provide: base.provide.map(Layer.locally(CurrentSeedOverrides, seeds)) }
 
 /** Reflection guard: is this exported value a scene? */
-export const isScene = (v: unknown): v is Scene =>
-  typeof v === 'object' && v !== null && (v as { readonly kind?: unknown }).kind === 'Scene'
+export const isScene = (candidate: unknown): candidate is Scene =>
+  typeof candidate === 'object' &&
+  candidate !== null &&
+  'kind' in candidate &&
+  candidate.kind === 'Scene'

package/src/state/state.ts

@@ -6,18 +6,20 @@ import { claimStateTag } from '../internal/stateRegistry'
 import { makeStore, type Store } from '../internal/store'
 import { readTracked } from '../internal/track'
 
-export interface StateOptions {
+export interface StateOptionsExternalApi {
   readonly title?: string
   readonly description?: string
 }
+export type StateOptions = StateOptionsExternalApi
 
-export interface StateManifest<N extends string, A> extends Manifest {
+export interface StateManifestExternalApi<N extends string, A> extends Manifest {
   readonly kind: 'State'
   readonly name: N
   readonly schema: Schema.Schema<A, any>
   readonly title?: string
   readonly description?: string
 }
+export type StateManifest<N extends string, A> = StateManifestExternalApi<N, A>
 
 export interface StateClass<out N extends string, in out A> extends Effect.Effect<A, never, Store<A>> {
   new (): {}
@@ -68,14 +70,13 @@ const resolveSeed = <S extends AnyState>(
   state: S,
   initial: StateValue<S>,
 ): Effect.Effect<StateValue<S>> =>
-  Effect.map(FiberRef.get(CurrentSeedOverrides), (overrides) =>
-    state.manifest.name in overrides
-      ? Option.getOrElse(
-          Schema.decodeUnknownOption(state.manifest.schema)(overrides[state.manifest.name]),
-          () => initial,
-        )
-      : initial,
-  )
+  Effect.map(FiberRef.get(CurrentSeedOverrides), (overrides) => {
+    if (!(state.manifest.name in overrides)) {
+      return initial
+    }
+    const override = Schema.decodeUnknownOption(state.manifest.schema)(overrides[state.manifest.name])
+    return Option.getOrElse(override, () => initial)
+  })
 
 /**
  * Allocate a state's store, seeded with `initial` — `State.live(Feed, seed)`.