@playfast/reform 0.0.5 → 0.0.8

package/src/index.ts

@@ -25,7 +25,7 @@ export { composeCalcs } from './calc/compose'
 // query-swapping helpers and layer types without re-spelling them.
 export type { InputsObject, InputStores, InvalidateBy } from './internal/sources'
 export {
-  type AsyncData,
+  AsyncData,
   type AsyncError,
   type AsyncIdle,
   type AsyncLoading,
@@ -36,6 +36,10 @@ export * as RemoteState from './remote/remoteState'
 // 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'
+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'
 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.
@@ -67,17 +71,39 @@ export {
 export { CurrentSlots, type SlotHost } from './compose/host'
 export * as Ui from './compose/ui'
 export {
+  type DerivedContract,
   isUi,
   type LogicView,
+  type MadeView,
   ui,
   type UiClass,
   type UiContract,
+  type UiManifest,
   UiTypeId,
+  UiViewContract,
   type ViewImpl,
+  type WireSchemas,
+  type WiredUi,
+  type WiredUiManifest,
 } from './compose/ui'
 export { provide } 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'
@@ -120,8 +146,10 @@ export { CurrentTracker, type Subscribable, type Tracker } from './internal/trac
 export { CaptureSink, type CaptureSinkApi, type UiCapture } from './internal/capture'
 export {
   AsyncReducer,
+  AsyncSceneLayer,
   DuplicateRegistration,
   FeatureLoadFailed,
+  forceSync,
   InvalidProvideTarget,
   SlotRenderingUnavailable,
   UnknownGroupState,
@@ -134,7 +162,15 @@ export {
   makeScheduler,
   Notifications,
   notificationsLayer,
+  resolveScheduler,
   type Scheduler,
 } from './internal/scheduler'
-export type { Store } from './internal/store'
+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/capture.ts

@@ -24,7 +24,7 @@ export interface CaptureSinkApi {
  * replacing any presentation. Production never provides it, so nothing is
  * recorded and there is no cost beyond one `serviceOption` lookup per render.
  */
-export class CaptureSink extends 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/errors.test.ts

@@ -0,0 +1,33 @@
+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)
+})
+
+it('passes a synchronous layer build through unchanged', () => {
+  const syncLayer = Layer.succeed(Thing, 1)
+  const runtime = ManagedRuntime.make(syncLayer)
+  const context = forceSync(() => runtime.runSync(Effect.context<Thing>()))
+  expect(Context.get(context, Thing)).toBe(1)
+})
+
+it('re-throws a non-async error untouched', () => {
+  class Boom extends Error {}
+  expect(() =>
+    forceSync(() => {
+      throw new Boom('nope')
+    }),
+  ).toThrow(Boom)
+})

package/src/internal/errors.ts

@@ -1,4 +1,4 @@
-import { Data } from 'effect'
+import { Cause, Data, Option, Runtime } from 'effect'
 
 /**
  * Tagged errors for the framework's synchronous boundaries. Even when thrown
@@ -7,62 +7,138 @@ import { Data } from 'effect'
  * 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 }
+
+const SlotRenderingUnavailableBase: TaggedErrorClass<
+  'reform/SlotRenderingUnavailable',
+  { readonly slot: string }
+> = Data.TaggedError('reform/SlotRenderingUnavailable')<{ readonly slot: string }>
+
 /** A `<slots.X/>` was rendered without a render-target host to realize it. */
-export class SlotRenderingUnavailable extends Data.TaggedError('reform/SlotRenderingUnavailable')<{
-  readonly slot: string
-}> {
+export class SlotRenderingUnavailable extends SlotRenderingUnavailableBase {
   override get message(): string {
     return `reform: rendering slot '${this.slot}' requires @reform/react`
   }
 }
 
+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 Data.TaggedError('reform/InvalidProvideTarget')<{}> {
+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 }>
+
 /** `StateGroup.select(group, name)` named a state the group does not contain. */
-export class UnknownGroupState extends Data.TaggedError('reform/UnknownGroupState')<{
-  readonly name: string
-}> {
+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 }>
+
 /**
  * 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 Data.TaggedError('reform/FeatureLoadFailed')<{
-  readonly cause: unknown
-}> {
+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')<{}>
+
 /** A reducer fold returned a thenable — folds must be pure synchronous writes. */
-export class AsyncReducer extends Data.TaggedError('reform/AsyncReducer')<{}> {
+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.
+ */
+export class AsyncSceneLayer extends AsyncSceneLayerBase {
+  override get message(): string {
+    return (
+      'reform: a scene layer performed async work while building. Reform builds the ' +
+      'scene synchronously so the first frame can render — a layer acquire must be ' +
+      'synchronous (Layer.sync/Layer.succeed). For async setup (open a connection, ' +
+      'fetch config), use Resource.live from @playfast/reform-resource, which builds ' +
+      'synchronously and resolves in the background.'
+    )
+  }
+}
+
+/**
+ * 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
+  if (!Runtime.isFiberFailure(error)) return false
+  const die = Cause.dieOption(error[Runtime.FiberFailureCauseId])
+  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 => {
+  try {
+    return thunk()
+  } catch (error) {
+    if (isAsyncBuildDefect(error)) throw new AsyncSceneLayer()
+    throw error
+  }
+}
+
+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.
  */
-export class DuplicateRegistration extends 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}'`
   }

package/src/internal/inspect.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from '@effect/vitest'
+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/queryDriver.ts

@@ -44,7 +44,7 @@ export const gatedFlag = <AlwaysOn extends boolean>(alwaysOn: AlwaysOn | undefin
 // package index, so the editor catalog (which only indexes module exports)
 // never sees it.
 export type Revision = number & Brand.Brand<'reform/Revision'>
-export const Revision = Brand.nominal<Revision>()
+export const Revision: Brand.Brand.Constructor<Revision> = Brand.nominal<Revision>()
 export const RevisionSchema: Schema.Schema<Revision, number> = Schema.Number.pipe(
   Schema.brand('reform/Revision'),
 )

package/src/internal/reuse.test.ts

@@ -0,0 +1,116 @@
+import { describe, expect, it } from '@effect/vitest'
+import { Data, Schema as S } from 'effect'
+import { reuse } from './reuse'
+
+// The structural-sharing pass behind `reuse: true`: identities move only where
+// values moved, and the result is always value-equal to the fresh output.
+
+describe('reuse', () => {
+  it('returns the previous value when the next is deeply value-equal', () => {
+    const prev = { a: [1, 2, { b: 'x' }], c: { d: true } }
+    const next = { a: [1, 2, { b: 'x' }], c: { d: true } }
+    expect(reuse(prev, next)).toBe(prev)
+  })
+
+  it('keeps identity of unchanged array elements while replacing changed ones', () => {
+    const e0 = { id: 1, name: 'a' }
+    const e1 = { id: 2, name: 'b' }
+    const prev = [e0, e1]
+    const next = [{ id: 1, name: 'a' }, { id: 2, name: 'B' }]
+    const out = reuse(prev, next)
+    expect(out).not.toBe(prev)
+    expect(out[0]).toBe(e0)
+    expect(out[1]).not.toBe(e1)
+    expect(out[1]).toEqual({ id: 2, name: 'B' })
+  })
+
+  it('keeps identity of unchanged record subtrees', () => {
+    const left = { items: [1, 2, 3] }
+    const prev = { left, right: { items: [4] } }
+    const next = { left: { items: [1, 2, 3] }, right: { items: [4, 5] } }
+    const out = reuse(prev, next)
+    expect(out.left).toBe(left)
+    expect(out.right).not.toBe(prev.right)
+    expect(out).toEqual(next)
+  })
+
+  it('substitutes Equal-implementing instances by value equality', () => {
+    class Row extends S.Class<Row>('Row')({ id: S.Number, name: S.String }) {}
+    const prevRow = new Row({ id: 1, name: 'a' })
+    const prev = { rows: [prevRow] }
+    const next = { rows: [new Row({ id: 1, name: 'a' })] }
+    const out = reuse(prev, next)
+    expect(out).toBe(prev)
+
+    const tagged = Data.struct({ k: 'v' })
+    const out2 = reuse({ t: tagged }, { t: Data.struct({ k: 'v' }) })
+    expect(out2.t).toBe(tagged)
+  })
+
+  it('walks INTO a differing Schema class, keeping its unchanged children', () => {
+    class Row extends S.Class<Row>('Row')({ id: S.Number, name: S.String }) {}
+    class View extends S.Class<View>('View')({ title: S.String, rows: S.Array(Row) }) {}
+    const keep = new Row({ id: 1, name: 'a' })
+    const prev = new View({ title: 't', rows: [keep, new Row({ id: 2, name: 'b' })] })
+    const next = new View({ title: 't', rows: [new Row({ id: 1, name: 'a' }), new Row({ id: 2, name: 'B' })] })
+    const out = reuse(prev, next)
+    // The container changed (row 2 renamed) so a fresh View comes back — but it
+    // is still a View (prototype preserved) and the untouched row keeps its
+    // exact previous identity.
+    expect(out).not.toBe(prev)
+    expect(out).toBeInstanceOf(View)
+    expect(out.rows[0]).toBe(keep)
+    expect(out.rows[1]).not.toBe(prev.rows[1])
+    expect(out.rows[1]?.name).toBe('B')
+    expect(out).toStrictEqual(next)
+  })
+
+  it('compares Dates by instant (Effect Equal) and treats other class instances as opaque leaves', () => {
+    // Effect's `Equal.equals` compares Dates structurally: same instant ⇒ the
+    // previous identity is kept.
+    const prev = { at: new Date(0) }
+    const out = reuse(prev, { at: new Date(0) })
+    expect(out.at).toBe(prev.at)
+
+    // A class without Equal: never recursed into, the fresh leaf wins even
+    // when its fields look identical.
+    class Opaque {
+      readonly v: number
+      constructor(v: number) {
+        this.v = v
+      }
+    }
+    const nextOpaque = { o: new Opaque(1) }
+    const out2 = reuse({ o: new Opaque(1) }, nextOpaque)
+    expect(out2.o).toBe(nextOpaque.o)
+  })
+
+  it('returns next below the depth bound', () => {
+    type Nest = { readonly n?: Nest; readonly v: number }
+    const deep = (depth: number): Nest => (depth === 0 ? { v: 0 } : { v: depth, n: deep(depth - 1) })
+    const prev = deep(20)
+    const next = deep(20)
+    const out = reuse(prev, next)
+    // Value-equal throughout — shared down to the bound, fresh below it.
+    expect(out).toEqual(next)
+  })
+
+  it('is value-equal to next and mutates neither argument', () => {
+    const prev = { a: [{ x: 1 }], b: 'keep' }
+    const next = { a: [{ x: 2 }], b: 'keep' }
+    const prevCopy = structuredClone(prev)
+    const nextCopy = structuredClone(next)
+    const out = reuse(prev, next)
+    expect(out).toEqual(nextCopy)
+    expect(prev).toEqual(prevCopy)
+    expect(next).toEqual(nextCopy)
+  })
+
+  it('shares nothing when shapes diverge (added/removed keys)', () => {
+    const prev = { a: 1, b: 2 }
+    const next = { a: 1 }
+    const out = reuse<Record<string, number>>(prev, next)
+    expect(out).toEqual({ a: 1 })
+    expect(out).not.toBe(prev)
+  })
+})

package/src/internal/scheduler.ts

@@ -69,7 +69,9 @@ export const defaultScheduler: Scheduler = makeScheduler()
  * state/calc layers, those stores coalesce on it instead of the global default,
  * isolating their notification timing from other runtimes in the same process.
  */
-export class Notifications extends Context.Tag('reform/Notifications')<Notifications, Scheduler>() {}
+const NotificationsBase: Context.TagClass<Notifications, 'reform/Notifications', Scheduler> =
+  Context.Tag('reform/Notifications')<Notifications, Scheduler>()
+export class Notifications extends NotificationsBase {}
 
 /**
  * A fresh per-runtime scheduler. Merged into `Engine`, so a runtime that wires

package/src/internal/sources.ts

@@ -47,8 +47,8 @@ export type InvalidateBy<Inputs extends ReadonlyArray<AnySource>> = (
 const inputKey = (input: AnySource): string =>
   Predicate.hasProperty(input, 'manifest') &&
   Predicate.isRecord(input.manifest) &&
-  Predicate.isString(input.manifest.name)
-    ? input.manifest.name
+  Predicate.isString(input.manifest['name'])
+    ? input.manifest['name']
     : input.name
 
 /** Element-wise value equality of two invalidation keys. */

package/src/internal/stateRegistry.ts

@@ -0,0 +1,32 @@
+import { Effect } from 'effect'
+
+/**
+ * Module-load registry of the DI tag identifiers minted by `State.make` /
+ * `StateFamily.make`. Two distinct definitions that claim one identifier (e.g.
+ * `State.make('open')` in two different features) otherwise collapse silently —
+ * `Layer.merge` resolves identical tags to the rightmost, with no error. Here we
+ * surface the clash.
+ *
+ * Warned, not thrown — mirroring duplicate reducer/procedure names: a cross-
+ * feature clash is a footgun, but a module may legitimately be re-evaluated under
+ * the same identifier (HMR), so a hard throw would punish dev reloads. The
+ * `warned` set keeps that to one warning per identifier regardless of reloads.
+ * In-group clashes (where every member is addressable by name) are a harder error
+ * — see `StateGroup.make`, which throws.
+ */
+const claimed = new Set<string>()
+const warned = new Set<string>()
+
+export const claimStateTag = (identifier: string): void => {
+  if (!claimed.has(identifier)) {
+    claimed.add(identifier)
+    return
+  }
+  if (warned.has(identifier)) return
+  warned.add(identifier)
+  Effect.runSync(
+    Effect.logWarning(
+      `reform: duplicate state tag '${identifier}' — two definitions collide and the last merged wins; namespace the name per feature`,
+    ),
+  )
+}

package/src/internal/store.test.ts

@@ -0,0 +1,80 @@
+import { expect, test } from 'vitest'
+import { makeStore } from './store'
+
+const tick = () => new Promise<void>((resolve) => queueMicrotask(resolve))
+
+// A const counter we increment in place — subscriber callbacks need somewhere to
+// tally without a reassigned `let`.
+const counter = () => ({ n: 0 })
+
+test('subscribe observes changes; getSnapshot is always current', async () => {
+  const store = makeStore(0)
+  const notifications = counter()
+  store.subscribe(() => {
+    notifications.n++
+  })
+
+  store.set(1)
+  expect(store.getSnapshot()).toBe(1) // snapshot is synchronous
+  await tick()
+  expect(notifications.n).toBe(1)
+})
+
+test('a no-op write notifies no one', async () => {
+  const store = makeStore('same')
+  const notifications = counter()
+  store.subscribe(() => {
+    notifications.n++
+  })
+
+  store.set('same')
+  await tick()
+  expect(notifications.n).toBe(0)
+  expect(store.getSnapshot()).toBe('same')
+})
+
+test('a batch of writes coalesces into a single notification per microtask', async () => {
+  const store = makeStore(0)
+  const notifications = counter()
+  store.subscribe(() => {
+    notifications.n++
+  })
+
+  store.set(1)
+  store.set(2)
+  store.set(3)
+  expect(store.getSnapshot()).toBe(3)
+  await tick()
+  expect(notifications.n).toBe(1)
+})
+
+test('stores are independent — one slice does not wake another', async () => {
+  const a = makeStore(0)
+  const b = makeStore(0)
+  const aWakes = counter()
+  const bWakes = counter()
+  a.subscribe(() => {
+    aWakes.n++
+  })
+  b.subscribe(() => {
+    bWakes.n++
+  })
+
+  a.set(1)
+  await tick()
+  expect(aWakes.n).toBe(1)
+  expect(bWakes.n).toBe(0)
+})
+
+test('unsubscribe stops notifications', async () => {
+  const store = makeStore(0)
+  const notifications = counter()
+  const unsubscribe = store.subscribe(() => {
+    notifications.n++
+  })
+
+  unsubscribe()
+  store.set(1)
+  await tick()
+  expect(notifications.n).toBe(0)
+})

package/src/internal/track.ts

@@ -23,7 +23,9 @@ export interface Tracker {
  * The active render's dependency tracker (D5). Present only while a composition
  * is rendering under `@reform/react`; absent in procedures and headless reads.
  */
-export class CurrentTracker extends Context.Tag('reform/Tracker')<CurrentTracker, Tracker>() {}
+const CurrentTrackerBase: Context.TagClass<CurrentTracker, 'reform/Tracker', Tracker> =
+  Context.Tag('reform/Tracker')<CurrentTracker, Tracker>()
+export class CurrentTracker extends CurrentTrackerBase {}
 
 /**
  * Read a store's current snapshot and, if a tracker is active, record the store