@playfast/reform 1.0.1 → 1.2.0

package/src/index.ts

@@ -1,28 +1,35 @@
-// Reform core — the renderer-neutral primitives and runtime.
-// Definitions (`X.make`) are separate from implementations (`.live`)
-// throughout, and nothing self-registers on import (principle #1, #6).
-
 export * as State from './state/state'
+export type { StateClass, StateStore, StateValue } from './state/state'
 export * as StateGroup from './state/stateGroup'
+export type { SeedsOf } from './state/stateGroup'
 export * as StateFamily from './state/stateFamily'
-export { StateToken } from './state/token'
-export type { AnySource, Source } from './state/token'
+export type {
+  FamilyKey,
+  FamilyValue,
+  StateFamilyClass,
+  StateFamilyStore,
+} from './state/stateFamily'
 
 export * as Event from './event/event'
-// Direct type re-export alongside the namespace (TS2742 nameability): inferred
-// types of layers built over intent/event unions reference `EventOf`, and the
-// declaration emitter can only name it through a plain export.
-export type { EventOf } from './event/event'
+// TS2742: direct type exports allow declaration emit to name event-derived types.
+export type {
+  EventClass,
+  EventOf,
+  EventPayload,
+  SourceChange,
+  SourceEventConfig,
+  SourceEventConfigExternalApi,
+} from './event/event'
 export * as EventGroup from './event/eventGroup'
 
 export * as Reducer from './reducer/reducer'
 export * as Calc from './calc/calc'
+export type { CalcClass, CalcStore } from './calc/calc'
 export * as CalcFamily from './calc/calcFamily'
+export type { CalcFamilyClass, CalcFamilyStore } from './calc/calcFamily'
 export * as AsyncCalc from './calc/asyncCalc'
+export type { AsyncCalcClass, AsyncCalcStore } from './calc/asyncCalc'
 export { composeCalcs } from './calc/compose'
-// The inputs-object/key/store types appearing in `AsyncCalc.live` /
-// `RemoteState.live` signatures, exported so app code can annotate
-// query-swapping helpers and layer types without re-spelling them.
 export type { InputsObject, InputStores, InvalidateBy } from './internal/sources'
 export {
   AsyncData,
@@ -31,138 +38,118 @@ export {
   type AsyncLoading,
   type AsyncSuccess,
 } from './calc/asyncData'
-// The flat, data-oriented query value (`data`/`error`/`isFetching`/`isStale`) an
-// `AsyncCalc` is driven by; `toAsyncData` projects it onto the matchable arms.
 export { isLoading, type QueryState, toAsyncData } from './calc/queryState'
-// Optional host seams an `AsyncCalc` consults — persistence and lifecycle signals.
-// Concrete implementations live in edge packages (e.g. `@playfast/reform-query-browser`).
-export {
-  noopQueryStore,
-  QueryStore,
-  type QueryStoreApi,
-  resolveQueryStore,
-} from './internal/queryStore'
-export {
-  noopQueryEvents,
-  QueryEvents,
-  type QueryEventsApi,
-  resolveQueryEvents,
-} from './internal/queryEvents'
+
 export * as RemoteState from './remote/remoteState'
-// Direct type re-exports alongside the namespace (TS2742 nameability): an app
-// layer's inferred type references these (`Store<ReadonlyArray<PendingIntent<…>>>`),
-// and the declaration emitter can only name them through a plain export.
-export type { FailedIntent, PendingIntent, RemoteStateClass } from './remote/remoteState'
+// TS2742: direct exports keep pending and failed state types nameable.
+export type {
+  FailedIntent,
+  PendingIntent,
+  RemoteStateClass,
+  RemoteStatePendingStore,
+  RemoteStateSettled,
+  RemoteStateTruthStore,
+  RemoteStateVisibleStore,
+} from './remote/remoteState'
 export * as SyncedStore from './synced/syncedStore'
-// Direct type re-export alongside the namespace (TS2742 nameability): adapters
-// (e.g. `@playfast/reform-db`) annotate the source handed to `SyncedStore.live`.
-export type { SyncedSource, SyncedStoreClass } from './synced/syncedStore'
+// TS2742: adapters need a directly nameable synchronized source type.
+export type { SyncedSource, SyncedStoreClass, SyncedStoreIdentifier } from './synced/syncedStore'
 export * as Boundary from './boundary/boundary'
-// Direct type re-exports alongside the namespace (same TS2742 nameability
-// reason as the RemoteState types above): app code annotates props with these.
+// TS2742: direct exports keep boundary state types nameable.
 export type {
   BoundaryErrored,
   BoundaryPending,
   BoundaryReady,
   BoundaryState,
+  BoundaryStore,
 } from './boundary/boundary'
+
 export * as Procedure from './procedure/procedure'
+export type { ProcedureClass, ProcedureConfig } from './procedure/procedure'
 export * as Channel from './channel/channel'
+export type { ChannelClass, ChannelPolicy } from './channel/channel'
+export * as Namespace from './namespace/namespace'
+export type { FeatureNamespace } from './namespace/namespace'
 
 export * as Composition from './compose/composition'
+export { liveScoped } from './compose/composition'
 export type {
+  CompositionActivation,
   CompositionClass,
+  CompositionId,
   CompositionService,
   Frame,
   RenderEnv,
+  ScopedCompositionLiveConfig,
 } from './compose/composition'
 export {
   absent,
+  type AbsentFill,
   each,
   type EachFill,
   isStructure,
   mount,
   one,
   type OneFill,
-  type AbsentFill,
   type SlotFill,
   type Structure,
   structureEquals,
   type StructureSlots,
-  StructureTypeId,
   when,
 } from './compose/structure'
 export { Props } from './compose/props'
 export {
+  type CompositionOfSlotTarget,
+  type ContractOfSlotTarget,
+  type FeatureSlotTarget,
   isSlot,
   type Node,
+  type PropsOfSlotTarget,
   slot,
   type SlotClass,
+  type SlotComposition,
+  type SlotContract,
   type SlotInstance,
   type SlotProps,
-  SlotTypeId,
+  type SlotService,
+  type SlotTarget,
+  type TargetOfSlot,
 } from './compose/slot'
-export { type SlotRenderer } from './compose/host'
 export * as Ui from './compose/ui'
 export {
+  type CallableView,
   type DerivedContract,
   isUi,
   type MadeView,
   ui,
   type UiClass,
   type UiContract,
-  type UiManifest,
-  UiTypeId,
+  type UiService,
   UiViewContract,
   type ViewImpl,
-  type WireSchemas,
-  type WiredUi,
-  type WiredUiManifest,
 } from './compose/ui'
-export { provide } from './compose/provide'
+export { provide, provideExisting, provideMergeExact } from './compose/provide'
 export type { Trigger } from './ui/trigger'
 
-// Wire: the serializable rendered-tree model + pure diff/apply the remote
-// transport sends over the wire and the client folds back. See REMOTE_UI.md §3.
-export * as Wire from './wire/tree'
-export type { WireNode, WirePatch, WireProp, WireTree } from './wire/tree'
-
-// Triggers: the server-side handle registry bridging client trigger invocations
-// back to live triggers, decoding payloads via the event schema. See REMOTE_UI.md §4.
-export * as Triggers from './wire/triggers'
-export {
-  TriggerRegistry,
-  type TriggerHandle,
-  type TriggerRegistryApi,
-  UnknownTrigger,
-} from './wire/triggers'
-
-// Feature: the lazy/eager code-split unit. Definitions stay eager and reflectable;
-// the heavy `.live` layer loads on demand (an Effect, never a Promise). See LAZY.md.
 export * as Feature from './feature/feature'
 export {
-  type EngineServices,
+  type EagerFeatureClass,
   type FailedProps,
-  type FeatureBinding,
-  FeatureBindingTypeId,
   type FeatureClass,
-  type FeatureManifest,
   featureModule,
   type FeatureModule,
+  type FeatureModuleInput,
   isFeature,
   isFeatureBinding,
   lazyImport,
-  type LoadedModule,
-  mountFeature,
+  type LazyFeatureClass,
   type Placeholders,
-  type ProvidedBy,
-  type RequireCarrier,
 } from './feature/feature'
-export { type SlotChild } from './compose/slot'
 
-// A scene bundles a composition with the closed wiring that runs it — the single
-// handle the react host, proofs, and the dev tool all consume.
 export {
+  type CapturedScene,
+  featureScene,
+  type FeatureSceneConfig,
   isScene,
   type MountedServices,
   profiledScene,
@@ -171,69 +158,24 @@ export {
   sceneInstrumentation,
   seedScene,
 } from './scene/scene'
-export type { SeedsOf } from './state/stateGroup'
 
-// Runtime surface for hosts (`@reform/react`) and headless tests.
-export { Bus, busLayer, type Envelope, type Priority, publish, type Tagged } from './runtime/bus'
-// The renderer-neutral scene runtime: hosts layer their lifecycle on top;
-// headless tests/proofs/drive scripts consume it directly.
+export { type Priority, publish } from './runtime/bus'
 export {
   type AppRuntime,
   type FeatureMountHandlers,
   makeAppRuntime,
+  type RuntimeFeatureAvailability,
   type RuntimeHandle,
 } from './runtime/appRuntime'
-export { Engine, type ReducerEntry, Reducers, reducersLayer } from './runtime/loop'
-// The profiler SPI: synchronous hooks the engine calls on its hot paths, plus
-// the FiberRef seam `@playfast/reform-profiler` writes through (`profiledScene`).
-export {
-  CurrentInstrumentation,
-  type Instrumentation,
-  noopInstrumentation,
-  resolveInstrumentation,
-  type SpanEnd,
-} from './runtime/instrumentation'
-// The runtime-wide registry of live query handles. `AsyncCalc.invalidate` /
-// `AsyncCalc.refetch` and provider layers act on a query by name through it.
-export { Queries, queriesLayer, type QueryHandle, type QueryRegistry } from './runtime/queries'
-export {
-  type ChannelClass,
-  type ChannelPolicy,
-  type ChannelRuntime,
-  Channels,
-  channelsLayer,
-  type ProcedureEntry,
-  Procedures,
-  proceduresLayer,
-} from './channel/channel'
-export { CurrentTracker, type Subscribable, type Tracker } from './internal/track'
-export { CaptureSink, type CaptureSinkApi, type UiCapture } from './internal/capture'
+export { Engine } from './runtime/loop'
+export type { EventBudget, ReformOptions } from './runtime/eventBudget'
 export {
   AsyncReducer,
   AsyncSceneLayer,
   DuplicateRegistration,
+  EventLoopOverflow,
   FeatureLoadFailed,
   forceSync,
   InvalidProvideTarget,
   UnknownGroupState,
 } from './internal/errors'
-// Notification scheduler: hosts that need per-runtime isolation (concurrent SSR,
-// multiple mounted roots) provide `Notifications` upstream of their state layers;
-// everything else coalesces on the process-wide default.
-export {
-  defaultScheduler,
-  makeScheduler,
-  Notifications,
-  notificationsLayer,
-  resolveScheduler,
-  type Scheduler,
-} from './internal/scheduler'
-export { makeStore, type Store } from './internal/store'
-export type { FamilyStore } from './state/stateFamily'
-// Primitive-authoring toolkit — exported for first-party companion packages
-// (e.g. `@playfast/reform-db`, `@playfast/reform-resource`) that build their own
-// first-class `Source`s which must participate in dependency tracking and
-// reflection exactly like a `Calc`.
-export { type Kind, type Manifest, yieldableClass } from './definition/definition'
-export { readTracked } from './internal/track'
-export { sameKey, wireSources, type WiredSources } from './internal/sources'

package/src/internal/bucketCache.ts

@@ -0,0 +1,39 @@
+import { Option } from 'effect'
+
+/**
+ * A read-through snapshot cache over a tag-indexed `Map<string, Set<T>>`.
+ *
+ * The registries keep mutable `Set` buckets so register/unregister stay O(1),
+ * but the dispatch loop must iterate a *snapshot*: an entry registered while a
+ * frame is folding must not join the fold already in flight (`Set` iteration is
+ * live, an array copy is not). Copying per event would pay that snapshot on
+ * every dispatch, so the copy is cached and dropped only when the bucket
+ * actually changes — registration is rare, dispatch is not.
+ *
+ * A tag with no bucket returns a shared empty array and is never cached, so
+ * events nothing handles allocate nothing and cannot grow the cache.
+ */
+export interface BucketCache<T> {
+  readonly read: (tag: string) => ReadonlyArray<T>
+  readonly invalidate: (tag: string) => void
+}
+
+export const makeBucketCache = <T>(source: Map<string, Set<T>>): BucketCache<T> => {
+  const empty: ReadonlyArray<T> = []
+  const cache = new Map<string, ReadonlyArray<T>>()
+  const build = (tag: string): ReadonlyArray<T> =>
+    Option.match(Option.fromNullable(source.get(tag)), {
+      onNone: (): ReadonlyArray<T> => empty,
+      onSome: (bucket) => {
+        const current: ReadonlyArray<T> = Array.from(bucket)
+        cache.set(tag, current)
+        return current
+      },
+    })
+  return {
+    read: (tag) => Option.getOrElse(Option.fromNullable(cache.get(tag)), () => build(tag)),
+    invalidate: (tag) => {
+      cache.delete(tag)
+    },
+  }
+}

package/src/internal/capture.ts

@@ -1,39 +1,24 @@
 import { Context } from 'effect'
 import type { Trigger } from '../ui/trigger'
 
-/**
- * A single rendered UI node's observable surface: which contract rendered, the
- * props it received, and the event triggers it was handed. This is exactly what
- * a headless inspector (the proof facade, the dev tool) needs — no DOM, no JSX.
- */
-export interface UiCapture {
+export interface CapturedRender {
   readonly name: string
   readonly props: unknown
   readonly events: Record<string, Trigger<unknown>>
-  /**
-   * The stable slot-fill key this render was mounted under (an `each` item's
-   * `key`, or a synthesized singleton key for a `one`). Present only on the
-   * structure path — the legacy Node path defers slot expansion to host
-   * components and has no fill key, so it is omitted there. Lets the proof
-   * facade select a child by key (`byKey`) instead of by render index.
-   */
   // oxlint-disable-next-line reform-rules/no-optional-fields -- omitted (not Option-none) on the legacy Node path; built in compose/structure.ts and read by the proof package, both outside this batch
   readonly key?: string
 }
 
-/** Where captured renders are reported, when a capturing host is present. */
+export type UiCapture = CapturedRender
+
 export interface CaptureSinkApi {
-  record(capture: UiCapture): void
+  record(capture: CapturedRender): void
 }
 
-/**
- * An OPTIONAL service. Core's `ui` read consults it via `serviceOption`: when a
- * capturing host provides it (proofs, the dev tool), every resolved view reports
- * its `(props, events)` before rendering, giving a faithful tree without
- * replacing any presentation. Production never provides it, so nothing is
- * recorded and there is no cost beyond one `serviceOption` lookup per render.
- */
-const CaptureSinkBase: Context.TagClass<CaptureSink, 'reform/internal/CaptureSink', CaptureSinkApi> =
-  Context.Tag('reform/internal/CaptureSink')<CaptureSink, CaptureSinkApi>()
+const CaptureSinkBase: Context.TagClass<
+  CaptureSink,
+  'reform/internal/CaptureSink',
+  CaptureSinkApi
+> = Context.Tag('reform/internal/CaptureSink')<CaptureSink, CaptureSinkApi>()
 
 export class CaptureSink extends CaptureSinkBase {}

package/src/internal/env.ts

@@ -0,0 +1,7 @@
+declare const process: { readonly env: { readonly NODE_ENV: string | undefined } } | undefined
+
+export const isDev: boolean =
+  typeof process === 'undefined' ||
+  typeof process.env === 'undefined' ||
+  // oxlint-disable-next-line reform-rules/no-process-env -- must stay a static member expression so bundlers substitute it and DCE dev-only branches; Config resolves at runtime and cannot
+  process.env.NODE_ENV !== 'production'

package/src/internal/errors.test.ts

@@ -2,15 +2,9 @@ import { expect, it } from '@effect/vitest'
 import { Context, Effect, Layer, ManagedRuntime } from 'effect'
 import { AsyncSceneLayer, forceSync } from '../index'
 
-// `forceSync` is the sync-build boundary: reform materialises a scene's layer graph
-// with `runSync` so the first frame renders synchronously (D2). A layer whose acquire
-// suspends makes that `runSync` throw Effect's opaque `AsyncFiberException`; the
-// boundary translates it into `AsyncSceneLayer`, which names the cause and the fix.
-
 class Thing extends Context.Tag('test/Thing')<Thing, number>() {}
 
 it('translates an async layer build into AsyncSceneLayer', () => {
-  // A layer whose acquire suspends — exactly what a consumer trips on.
   const asyncLayer = Layer.effect(Thing, Effect.as(Effect.sleep('1 millis'), 1))
   const runtime = ManagedRuntime.make(asyncLayer)
   expect(() => forceSync(() => runtime.runSync(Effect.context<Thing>()))).toThrow(AsyncSceneLayer)

package/src/internal/errors.ts

@@ -1,80 +1,58 @@
 import { Cause, Data, Option, Runtime } from 'effect'
 
-/**
- * Tagged errors for the framework's synchronous boundaries. Even when thrown
- * (React render, layer build, reflection), an error carries a `_tag` and its
- * structured fields — never a bare `Error` — so callers and tooling can match on
- * it. `Data.TaggedError` subclasses are real `Error`s, so `throw` still works.
- */
-
-/**
- * The constructor shape `Data.TaggedError(tag)<A>` produces, named so the
- * generated `.d.ts` can describe the `extends` base under `isolatedDeclarations`
- * (which forbids an inferred expression in an extends clause).
- */
 type TaggedErrorClass<Tag extends string, A extends Record<string, unknown>> = new (
   args: A,
 ) => Cause.YieldableError & { readonly _tag: Tag } & Readonly<A>
 
-/** The fieldless variant — a `Data.TaggedError(tag)<{}>` constructor. */
-type EmptyTaggedErrorClass<Tag extends string> = new () => Cause.YieldableError & { readonly _tag: Tag }
+type EmptyTaggedErrorClass<Tag extends string> = new () => Cause.YieldableError & {
+  readonly _tag: Tag
+}
 
 const InvalidProvideTargetBase: EmptyTaggedErrorClass<'reform/InvalidProvideTarget'> =
   Data.TaggedError('reform/InvalidProvideTarget')<{}>
 
-/** `provide(target, …)` was handed something that is neither a ui contract nor a slot. */
 export class InvalidProvideTarget extends InvalidProvideTargetBase {
   override get message(): string {
     return 'reform: provide target is neither a ui contract nor a slot'
   }
 }
 
-const UnknownGroupStateBase: TaggedErrorClass<'reform/UnknownGroupState', { readonly name: string }> =
-  Data.TaggedError('reform/UnknownGroupState')<{ readonly name: string }>
+const UnknownGroupStateBase: TaggedErrorClass<
+  'reform/UnknownGroupState',
+  { readonly name: string }
+> = Data.TaggedError('reform/UnknownGroupState')<{ readonly name: string }>
 
-/** `StateGroup.select(group, name)` named a state the group does not contain. */
 export class UnknownGroupState extends UnknownGroupStateBase {
   override get message(): string {
     return `reform: unknown state '${this.name}' in group`
   }
 }
 
-const FeatureLoadFailedBase: TaggedErrorClass<'reform/FeatureLoadFailed', { readonly cause: unknown }> =
-  Data.TaggedError('reform/FeatureLoadFailed')<{ readonly cause: unknown }>
+const FeatureLoadFailedBase: TaggedErrorClass<
+  'reform/FeatureLoadFailed',
+  { readonly cause: unknown }
+> = Data.TaggedError('reform/FeatureLoadFailed')<{ readonly cause: unknown }>
 
-/**
- * A lazy `Feature`'s `load` Effect failed — the dynamic `import()` rejected (a
- * missing chunk, a network failure, a module-eval throw). Surfaced as a typed
- * failure the host hands to the feature's `placeholder.failed`, never a bare
- * rejection. `cause` is the original rejection value.
- */
 export class FeatureLoadFailed extends FeatureLoadFailedBase {
   override get message(): string {
     return `reform: a feature failed to load (${String(this.cause)})`
   }
 }
 
-const AsyncReducerBase: EmptyTaggedErrorClass<'reform/AsyncReducer'> =
-  Data.TaggedError('reform/AsyncReducer')<{}>
+const AsyncReducerBase: EmptyTaggedErrorClass<'reform/AsyncReducer'> = Data.TaggedError(
+  'reform/AsyncReducer',
+)<{}>
 
-/** A reducer fold returned a thenable — folds must be pure synchronous writes. */
 export class AsyncReducer extends AsyncReducerBase {
   override get message(): string {
     return 'reform: a reducer fold must be synchronous (it returned a Promise)'
   }
 }
 
-const AsyncSceneLayerBase: EmptyTaggedErrorClass<'reform/AsyncSceneLayer'> =
-  Data.TaggedError('reform/AsyncSceneLayer')<{}>
-
-/**
- * A scene layer performed async work during reform's synchronous layer build.
- * Reform materialises a scene's layer graph with `runSync` so the first frame
- * renders synchronously (D2); a `Layer.effect`/`scoped` whose acquire suspends
- * (HTTP, opening a DB, `Effect.sleep`) makes that `runSync` throw Effect's opaque
- * `AsyncFiberException`. `forceSync` catches it and rethrows this, which names the
- * cause and the sanctioned fix instead of pointing at Effect internals.
- */
+const AsyncSceneLayerBase: EmptyTaggedErrorClass<'reform/AsyncSceneLayer'> = Data.TaggedError(
+  'reform/AsyncSceneLayer',
+)<{}>
+
 export class AsyncSceneLayer extends AsyncSceneLayerBase {
   override get message(): string {
     return (
@@ -87,12 +65,6 @@ export class AsyncSceneLayer extends AsyncSceneLayerBase {
   }
 }
 
-/**
- * Whether a thrown value is Effect's "ran async under runSync" defect. `runSync`
- * throws the bare `AsyncFiberException`; a `ManagedRuntime.runSync` whose layer
- * build suspends instead throws a `FiberFailure` carrying it as a `Die`, so both
- * shapes are checked.
- */
 const isAsyncBuildDefect = (error: unknown): boolean => {
   if (Runtime.isAsyncFiberException(error)) {
     return true
@@ -104,12 +76,6 @@ const isAsyncBuildDefect = (error: unknown): boolean => {
   return Option.isSome(die) && Runtime.isAsyncFiberException(die.value)
 }
 
-/**
- * Run a synchronous runtime read (the scene layer build / context capture) and
- * translate Effect's async-fiber defect into `AsyncSceneLayer`; any other throw
- * passes through unchanged. The single home for the sync-build boundary, shared by
- * the React host and the remote server.
- */
 export const forceSync = <A>(thunk: () => A): A => {
   // oxlint-disable-next-line reform-rules/no-try-catch -- sync-build boundary must throw the exact value, which Effect.runSync would re-wrap in a FiberFailure
   try {
@@ -123,16 +89,27 @@ export const forceSync = <A>(thunk: () => A): A => {
 const DuplicateRegistrationBase: TaggedErrorClass<
   'reform/DuplicateRegistration',
   { readonly kind: string; readonly name: string }
-> = Data.TaggedError('reform/DuplicateRegistration')<{ readonly kind: string; readonly name: string }>
-
-/**
- * Two distinct primitives were registered under one name into the same runtime —
- * a silent footgun, since names key DI tags and channel lanes. Thrown for a
- * channel name reused with a different policy (the second would otherwise be
- * dropped). Reducer/procedure name clashes are warned (logged), not thrown.
- */
+> = Data.TaggedError('reform/DuplicateRegistration')<{
+  readonly kind: string
+  readonly name: string
+}>
+
 export class DuplicateRegistration extends DuplicateRegistrationBase {
   override get message(): string {
     return `reform: duplicate ${this.kind} registered under name '${this.name}'`
   }
 }
+
+const EventLoopOverflowBase: TaggedErrorClass<
+  'reform/EventLoopOverflow',
+  { readonly count: number; readonly limit: number }
+> = Data.TaggedError('reform/EventLoopOverflow')<{ readonly count: number; readonly limit: number }>
+
+export class EventLoopOverflow extends EventLoopOverflowBase {
+  override get message(): string {
+    return (
+      `reform: ${this.count} events processed without yielding to the event loop ` +
+      `(limit ${this.limit}) — likely an infinite event feedback loop; the runtime has been halted`
+    )
+  }
+}

package/src/internal/inspect.test.ts

@@ -3,24 +3,18 @@ import { Schema as S } from 'effect'
 import { State } from '../index'
 import { makeStore } from './store'
 
-// Every reform value should print like an Effect value (an `_id`-tagged JSON),
-// not `[object Object]` — via `toJSON`/`toString`/the Node inspect symbol.
-
 describe('Inspectable', () => {
   it('a Store reports its current value as tagged JSON', () => {
     const store = makeStore(41)
     expect(store.toJSON()).toEqual({ _id: 'reform/Store', value: 41 })
     store.set(42)
     expect(store.toJSON()).toEqual({ _id: 'reform/Store', value: 42 })
-    // toString and JSON.stringify route through the same toJSON.
     expect(JSON.parse(JSON.stringify(store))).toEqual({ _id: 'reform/Store', value: 42 })
     expect(store.toString()).toContain('reform/Store')
   })
 
   it('a definition reports its manifest', () => {
     class Count extends State.make('count', S.Number) {}
-    // Inspectable is attached at runtime (definitions are reflected via their
-    // manifest); reach the method through a typed view.
     const inspectable = Count as unknown as { toJSON(): unknown }
     expect(inspectable.toJSON()).toBe(Count.manifest)
     expect(String(Count)).toContain('"kind": "State"')

package/src/internal/inspect.ts

@@ -2,24 +2,12 @@ import { format, type Inspectable, NodeInspectSymbol } from 'effect/Inspectable'
 
 export { type Inspectable, NodeInspectSymbol }
 
-/**
- * The `Inspectable` trio built around a `toJSON`, so every reform value prints
- * like an Effect value — `_id`-tagged JSON under `console.log`, Node's
- * inspector, `JSON.stringify`, and `String(...)` — instead of `[object Object]`.
- * Mirrors Effect's `BaseProto` / `Inspectable.Class` (`Inspectable.ts:170`).
- */
 export const inspectable = (toJSON: () => unknown): Inspectable => ({
   toJSON,
   toString: () => format(toJSON()),
   [NodeInspectSymbol]: () => toJSON(),
 })
 
-/**
- * Attach the `Inspectable` trio to an existing object as *non-enumerable* own
- * properties (so they don't show up in `Object.keys`/`for…in` over a definition
- * class). Used where the value is built by other means — the definition classes,
- * whose statics are merged in separately.
- */
 export const attachInspectable = <T extends object>(target: T, toJSON: () => unknown): T => {
   const trio = inspectable(toJSON)
   Reflect.ownKeys(trio).forEach((key) => {