@rivetkit/effect 2.3.3-rc.1 → 2.3.3-rc.2

package/src/State.test.ts

@@ -36,6 +36,26 @@ describe("State", () => {
 		}),
 	);
 
+	it.effect(
+		"getAndSet returns the previous value and commits the new value",
+		() =>
+			Effect.gen(function* () {
+				const { s, cell } = yield* makeCellState(10);
+				const previous = yield* State.getAndSet(s, 15);
+				assert.strictEqual(previous, 10);
+				assert.strictEqual(cell.value, 15);
+			}),
+	);
+
+	it.effect("setAndGet returns the committed value", () =>
+		Effect.gen(function* () {
+			const { s, cell } = yield* makeCellState(10);
+			const next = yield* State.setAndGet(s, 15);
+			assert.strictEqual(next, 15);
+			assert.strictEqual(cell.value, 15);
+		}),
+	);
+
 	it.effect("update applies f over read/write", () =>
 		Effect.gen(function* () {
 			const { s, cell } = yield* makeCellState(10);
@@ -44,6 +64,38 @@ describe("State", () => {
 		}),
 	);
 
+	it.effect("updateEffect applies an Effectful f over read/write", () =>
+		Effect.gen(function* () {
+			const { s, cell } = yield* makeCellState(10);
+			yield* State.updateEffect(s, (n) => Effect.succeed(n + 5));
+			assert.strictEqual(cell.value, 15);
+		}),
+	);
+
+	it.effect(
+		"getAndUpdate returns the previous value and commits the new value",
+		() =>
+			Effect.gen(function* () {
+				const { s, cell } = yield* makeCellState(10);
+				const previous = yield* State.getAndUpdate(s, (n) => n + 5);
+				assert.strictEqual(previous, 10);
+				assert.strictEqual(cell.value, 15);
+			}),
+	);
+
+	it.effect(
+		"getAndUpdateEffect returns the previous value and commits the new value",
+		() =>
+			Effect.gen(function* () {
+				const { s, cell } = yield* makeCellState(10);
+				const previous = yield* State.getAndUpdateEffect(s, (n) =>
+					Effect.succeed(n + 5),
+				);
+				assert.strictEqual(previous, 10);
+				assert.strictEqual(cell.value, 15);
+			}),
+	);
+
 	it.effect("updateAndGet returns the new value and commits it", () =>
 		Effect.gen(function* () {
 			const { s, cell } = yield* makeCellState(10);
@@ -53,6 +105,17 @@ describe("State", () => {
 		}),
 	);
 
+	it.effect("updateAndGetEffect returns the new value and commits it", () =>
+		Effect.gen(function* () {
+			const { s, cell } = yield* makeCellState(10);
+			const next = yield* State.updateAndGetEffect(s, (n) =>
+				Effect.succeed(n + 5),
+			);
+			assert.strictEqual(next, 15);
+			assert.strictEqual(cell.value, 15);
+		}),
+	);
+
 	it.effect("modify returns B and commits the new value", () =>
 		Effect.gen(function* () {
 			const { s, cell } = yield* makeCellState("a");
@@ -65,6 +128,17 @@ describe("State", () => {
 		}),
 	);
 
+	it.effect("modifyEffect returns B and commits the new value", () =>
+		Effect.gen(function* () {
+			const { s, cell } = yield* makeCellState("a");
+			const b = yield* State.modifyEffect(s, (str) =>
+				Effect.succeed([str.length, `${str}b`] as const),
+			);
+			assert.strictEqual(b, 1);
+			assert.strictEqual(cell.value, "ab");
+		}),
+	);
+
 	it.effect(
 		"update is atomic across concurrent fibers (no lost updates)",
 		() =>
@@ -89,7 +163,7 @@ describe("State", () => {
 			);
 			assert.deepStrictEqual(initial, [0]);
 
-			State.publishUnsafe(s, 7);
+			yield* s[State.RuntimeTypeId].publishEffect(Effect.succeed(7));
 			const later = yield* State.changes(s).pipe(
 				Stream.take(1),
 				Stream.runCollect,
@@ -103,11 +177,17 @@ describe("State", () => {
 			const { s } = yield* makeCellState(0);
 			yield* Effect.scoped(
 				Effect.gen(function* () {
-					const sub = yield* PubSub.subscribe(s.pubsub);
+					const sub = yield* PubSub.subscribe(
+						s[State.RuntimeTypeId].pubsub,
+					);
 					assert.strictEqual(yield* PubSub.take(sub), 0);
 
-					yield* State.publish(s, 1);
-					yield* State.publish(s, 2);
+					yield* s[State.RuntimeTypeId].publishEffect(
+						Effect.succeed(1),
+					);
+					yield* s[State.RuntimeTypeId].publishEffect(
+						Effect.succeed(2),
+					);
 					assert.strictEqual(yield* PubSub.take(sub), 1);
 					assert.strictEqual(yield* PubSub.take(sub), 2);
 				}),
@@ -115,6 +195,19 @@ describe("State", () => {
 		}),
 	);
 
+	it.effect("shuts down the backing pubsub when its scope closes", () =>
+		Effect.gen(function* () {
+			const pubsub = yield* Effect.scoped(
+				Effect.gen(function* () {
+					const { s } = yield* makeCellState(0);
+					return s[State.RuntimeTypeId].pubsub;
+				}),
+			);
+
+			assert.isTrue(yield* PubSub.isShutdown(pubsub));
+		}),
+	);
+
 	it.effect("set does NOT auto-publish — the runtime does", () =>
 		Effect.gen(function* () {
 			const { s } = yield* makeCellState(0);
@@ -146,6 +239,61 @@ describe("State", () => {
 
 			yield* s.pipe(State.update((n) => n * 2));
 			assert.strictEqual(yield* State.get(s), 10);
+
+			yield* s.pipe(State.updateEffect((n) => Effect.succeed(n + 1)));
+			assert.strictEqual(yield* State.get(s), 11);
+		}),
+	);
+
+	it.effect("supports instance methods", () =>
+		Effect.gen(function* () {
+			const { s, cell } = yield* makeCellState(0);
+			assert.strictEqual(yield* s.get, 0);
+
+			yield* s.set(5);
+			assert.strictEqual(cell.value, 5);
+
+			const beforeSet = yield* s.getAndSet(6);
+			assert.strictEqual(beforeSet, 5);
+			assert.strictEqual(cell.value, 6);
+
+			const afterSet = yield* s.setAndGet(7);
+			assert.strictEqual(afterSet, 7);
+			assert.strictEqual(cell.value, 7);
+
+			yield* s.update((n) => n * 2);
+			assert.strictEqual(yield* s.get, 14);
+
+			yield* s.updateEffect((n) => Effect.succeed(n + 1));
+			assert.strictEqual(yield* s.get, 15);
+
+			const previousUpdate = yield* s.getAndUpdate((n) => n + 1);
+			assert.strictEqual(previousUpdate, 15);
+			assert.strictEqual(yield* s.get, 16);
+
+			const previousEffectUpdate = yield* s.getAndUpdateEffect((n) =>
+				Effect.succeed(n + 1),
+			);
+			assert.strictEqual(previousEffectUpdate, 16);
+			assert.strictEqual(yield* s.get, 17);
+
+			const next = yield* s.updateAndGet((n) => n + 1);
+			assert.strictEqual(next, 18);
+
+			const effectNext = yield* s.updateAndGetEffect((n) =>
+				Effect.succeed(n + 1),
+			);
+			assert.strictEqual(effectNext, 19);
+
+			const previous = yield* s.modify((n) => [n, n + 1] as const);
+			assert.strictEqual(previous, 19);
+			assert.strictEqual(yield* s.get, 20);
+
+			const effectPrevious = yield* s.modifyEffect((n) =>
+				Effect.succeed([n, n + 1] as const),
+			);
+			assert.strictEqual(effectPrevious, 20);
+			assert.strictEqual(yield* s.get, 21);
 		}),
 	);
 
@@ -178,4 +326,15 @@ describe("State", () => {
 			assert.isTrue(Exit.isFailure(exit));
 		}),
 	);
+
+	it.effect("Effectful update failure does not write", () =>
+		Effect.gen(function* () {
+			const { s, cell } = yield* makeCellState(0);
+			const exit = yield* Effect.exit(
+				State.updateEffect(s, () => Effect.fail("boom" as const)),
+			);
+			assert.isTrue(Exit.isFailure(exit));
+			assert.strictEqual(cell.value, 0);
+		}),
+	);
 });

package/src/State.ts

@@ -26,6 +26,7 @@ import {
 	Predicate,
 	PubSub,
 	Semaphore,
+	Scope,
 	Stream,
 	type Types,
 } from "effect";
@@ -33,6 +34,15 @@ import { dual } from "effect/Function";
 
 const TypeId = "~@rivetkit/effect/State";
 
+/**
+ * Internal access to `State`'s backing store and publish machinery.
+ *
+ * @internal
+ */
+export const RuntimeTypeId: unique symbol = Symbol.for(
+	"~@rivetkit/effect/State/Runtime",
+) as never;
+
 /**
  * A view over a persisted state cell with a subscribable change stream.
  *
@@ -45,17 +55,97 @@ export interface State<A, E = never, R = never>
 	extends Variance<A, E, R>,
 		Pipeable.Pipeable,
 		Inspectable.Inspectable {
+	/**
+	 * Retrieves the persisted value.
+	 */
+	readonly get: Effect.Effect<A, E, R>;
+	/**
+	 * Retrieves the persisted value and sets a new value atomically.
+	 */
+	readonly getAndSet: (value: A) => Effect.Effect<A, E, R>;
+	/**
+	 * Retrieves the current value and updates it atomically with the result of
+	 * applying a function.
+	 */
+	readonly getAndUpdate: (f: (a: A) => A) => Effect.Effect<A, E, R>;
+	/**
+	 * Retrieves the current value and updates it atomically with the result of
+	 * applying an effectful function.
+	 */
+	readonly getAndUpdateEffect: <E2, R2>(
+		f: (a: A) => Effect.Effect<A, E2, R2>,
+	) => Effect.Effect<A, E | E2, R | R2>;
+	/**
+	 * Modifies atomically with a function that computes a return value and
+	 * a new value.
+	 */
+	readonly modify: <B>(
+		f: (a: A) => readonly [B, A],
+	) => Effect.Effect<B, E, R>;
+	/**
+	 * Modifies atomically with an effectful function that computes a return value
+	 * and a new value.
+	 */
+	readonly modifyEffect: <B, E2, R2>(
+		f: (a: A) => Effect.Effect<readonly [B, A], E2, R2>,
+	) => Effect.Effect<B, E | E2, R | R2>;
+	/**
+	 * Writes the persisted value.
+	 */
+	readonly set: (value: A) => Effect.Effect<void, E, R>;
+	/**
+	 * Sets the persisted value and returns the new value.
+	 */
+	readonly setAndGet: (value: A) => Effect.Effect<A, E, R>;
+	/**
+	 * Updates the persisted value with the result of applying a function.
+	 */
+	readonly update: (f: (a: A) => A) => Effect.Effect<void, E, R>;
+	/**
+	 * Updates the persisted value with the result of applying an effectful function.
+	 */
+	readonly updateEffect: <E2, R2>(
+		f: (a: A) => Effect.Effect<A, E2, R2>,
+	) => Effect.Effect<void, E | E2, R | R2>;
+	/**
+	 * Updates the persisted value with the result of applying an effectful function
+	 * and returns the new value.
+	 */
+	readonly updateAndGet: (f: (a: A) => A) => Effect.Effect<A, E, R>;
+	/**
+	 * Updates the persisted value with the result of applying an effectful function
+	 * and returns the new value.
+	 */
+	readonly updateAndGetEffect: <E2, R2>(
+		f: (a: A) => Effect.Effect<A, E2, R2>,
+	) => Effect.Effect<A, E | E2, R | R2>;
+	/**
+	 * Creates a stream that emits the current persisted value and all subsequent
+	 * changes.
+	 */
+	readonly changes: Stream.Stream<A>;
+	/**
+	 * Internal access to `State`'s backing store and publish machinery.
+	 *
+	 * @internal
+	 */
+	readonly [RuntimeTypeId]: StateRuntime<A, E, R>;
+}
+
+/**
+ * Runtime-only hooks for wiring actor state persistence and change
+ * notifications.
+ *
+ * @internal
+ */
+export interface StateRuntime<A, E = never, R = never> {
+	readonly publish: (value: A) => Effect.Effect<boolean>;
+	readonly publishEffect: <E2, R2>(
+		effect: Effect.Effect<A, E2, R2>,
+	) => Effect.Effect<boolean, E2, R2>;
 	readonly read: () => Effect.Effect<A, E, R>;
 	readonly write: (value: A) => Effect.Effect<void, E, R>;
 	readonly pubsub: PubSub.PubSub<A>;
-	/**
-	 * Serializes writes (`set`, `update`, `modify`) so the read/apply/
-	 * write triple is atomic. The runtime may also use this semaphore
-	 * to serialize its own decode-and-publish work from
-	 * `onStateChange`, keeping the change stream's order consistent
-	 * with the write order.
-	 */
-	readonly semaphore: Semaphore.Semaphore;
 }
 
 export const isState = (u: unknown): u is State<unknown, unknown> =>
@@ -86,47 +176,192 @@ const Proto = {
  * The current value (per `read()`) is published to the pubsub on
  * construction so any subscription obtained later replays it.
  *
- * The PubSub is not explicitly shut down — it's reclaimed by GC when
- * the `State` and any subscribers become unreachable.
+ * The backing PubSub is scoped and shuts down when the current
+ * `Scope` closes.
  */
 export const make = Effect.fnUntraced(function* <A, E, R>(
 	read: () => Effect.Effect<A, E, R>,
 	write: (value: A) => Effect.Effect<void, E, R>,
-): Effect.fn.Return<State<A, E, R>, E, R> {
+): Effect.fn.Return<State<A, E, R>, E, R | Scope.Scope> {
 	const pubsub = yield* PubSub.unbounded<A>({ replay: 1 });
+	yield* Effect.addFinalizer(() => PubSub.shutdown(pubsub));
 	const initial = yield* read();
-	PubSub.publishUnsafe(pubsub, initial);
+	yield* PubSub.publish(pubsub, initial);
 	const self = Object.create(Proto);
-	self.read = read;
-	self.write = write;
-	self.pubsub = pubsub;
-	self.semaphore = Semaphore.makeUnsafe(1);
+	const semaphore = yield* Semaphore.make(1);
+	self[RuntimeTypeId] = {
+		read,
+		write,
+		pubsub,
+		publish: (value: A) => PubSub.publish(pubsub, value),
+		publishEffect: <E2, R2>(effect: Effect.Effect<A, E2, R2>) =>
+			Semaphore.withPermit(
+				semaphore,
+				Effect.flatMap(effect, (value) =>
+					PubSub.publish(pubsub, value),
+				),
+			),
+	};
+	self.get = Effect.suspend(() => self[RuntimeTypeId].read());
+	self.set = (value: A) => Semaphore.withPermit(semaphore, write(value));
+	self.getAndSet = (value: A) =>
+		Semaphore.withPermit(
+			semaphore,
+			Effect.flatMap(read(), (previous) =>
+				Effect.as(write(value), previous),
+			),
+		);
+	self.setAndGet = (value: A) =>
+		Semaphore.withPermit(semaphore, Effect.as(write(value), value));
+	self.update = (f: (a: A) => A) =>
+		Semaphore.withPermit(
+			semaphore,
+			Effect.flatMap(read(), (a) => write(f(a))),
+		);
+	self.updateEffect = <E2, R2>(f: (a: A) => Effect.Effect<A, E2, R2>) =>
+		Semaphore.withPermit(
+			semaphore,
+			Effect.flatMap(read(), (a) => Effect.flatMap(f(a), write)),
+		);
+	self.getAndUpdate = (f: (a: A) => A) =>
+		Semaphore.withPermit(
+			semaphore,
+			Effect.flatMap(read(), (previous) =>
+				Effect.as(write(f(previous)), previous),
+			),
+		);
+	self.getAndUpdateEffect = <E2, R2>(f: (a: A) => Effect.Effect<A, E2, R2>) =>
+		Semaphore.withPermit(
+			semaphore,
+			Effect.flatMap(read(), (previous) =>
+				Effect.flatMap(f(previous), (next) =>
+					Effect.as(write(next), previous),
+				),
+			),
+		);
+	self.updateAndGet = (f: (a: A) => A) =>
+		Semaphore.withPermit(
+			semaphore,
+			Effect.flatMap(read(), (a) => {
+				const next = f(a);
+				return Effect.as(write(next), next);
+			}),
+		);
+	self.updateAndGetEffect = <E2, R2>(f: (a: A) => Effect.Effect<A, E2, R2>) =>
+		Semaphore.withPermit(
+			semaphore,
+			Effect.flatMap(read(), (a) =>
+				Effect.flatMap(f(a), (next) => Effect.as(write(next), next)),
+			),
+		);
+	self.modify = <B>(f: (a: A) => readonly [B, A]) =>
+		Semaphore.withPermit(
+			semaphore,
+			Effect.flatMap(read(), (a) => {
+				const [b, next] = f(a);
+				return Effect.as(write(next), b);
+			}),
+		);
+	self.modifyEffect = <B, E2, R2>(
+		f: (a: A) => Effect.Effect<readonly [B, A], E2, R2>,
+	) =>
+		Semaphore.withPermit(
+			semaphore,
+			Effect.flatMap(read(), (a) =>
+				Effect.flatMap(f(a), ([b, next]) => Effect.as(write(next), b)),
+			),
+		);
+	self.changes = Stream.fromPubSub(pubsub);
 	return self;
 });
 
-/**
- * Reads the current value.
- */
 export const get = <A, E, R>(self: State<A, E, R>): Effect.Effect<A, E, R> =>
-	self.read();
+	self.get;
+
+export const getAndSet: {
+	<A>(value: A): <E, R>(self: State<A, E, R>) => Effect.Effect<A, E, R>;
+	<A, E, R>(self: State<A, E, R>, value: A): Effect.Effect<A, E, R>;
+} = dual(
+	2,
+	<A, E, R>(self: State<A, E, R>, value: A): Effect.Effect<A, E, R> =>
+		self.getAndSet(value),
+);
+
+export const getAndUpdate: {
+	<A>(f: (a: A) => A): <E, R>(self: State<A, E, R>) => Effect.Effect<A, E, R>;
+	<A, E, R>(self: State<A, E, R>, f: (a: A) => A): Effect.Effect<A, E, R>;
+} = dual(
+	2,
+	<A, E, R>(self: State<A, E, R>, f: (a: A) => A): Effect.Effect<A, E, R> =>
+		self.getAndUpdate(f),
+);
+
+export const getAndUpdateEffect: {
+	<A, E2, R2>(
+		f: (a: A) => Effect.Effect<A, E2, R2>,
+	): <E, R>(self: State<A, E, R>) => Effect.Effect<A, E | E2, R | R2>;
+	<A, E, R, E2, R2>(
+		self: State<A, E, R>,
+		f: (a: A) => Effect.Effect<A, E2, R2>,
+	): Effect.Effect<A, E | E2, R | R2>;
+} = dual(
+	2,
+	<A, E, R, E2, R2>(
+		self: State<A, E, R>,
+		f: (a: A) => Effect.Effect<A, E2, R2>,
+	): Effect.Effect<A, E | E2, R | R2> => self.getAndUpdateEffect(f),
+);
+
+export const modify: {
+	<A, B>(
+		f: (a: A) => readonly [B, A],
+	): <E, R>(self: State<A, E, R>) => Effect.Effect<B, E, R>;
+	<A, E, R, B>(
+		self: State<A, E, R>,
+		f: (a: A) => readonly [B, A],
+	): Effect.Effect<B, E, R>;
+} = dual(
+	2,
+	<A, E, R, B>(
+		self: State<A, E, R>,
+		f: (a: A) => readonly [B, A],
+	): Effect.Effect<B, E, R> => self.modify(f),
+);
+
+export const modifyEffect: {
+	<A, B, E2, R2>(
+		f: (a: A) => Effect.Effect<readonly [B, A], E2, R2>,
+	): <E, R>(self: State<A, E, R>) => Effect.Effect<B, E | E2, R | R2>;
+	<A, E, R, B, E2, R2>(
+		self: State<A, E, R>,
+		f: (a: A) => Effect.Effect<readonly [B, A], E2, R2>,
+	): Effect.Effect<B, E | E2, R | R2>;
+} = dual(
+	2,
+	<A, E, R, B, E2, R2>(
+		self: State<A, E, R>,
+		f: (a: A) => Effect.Effect<readonly [B, A], E2, R2>,
+	): Effect.Effect<B, E | E2, R | R2> => self.modifyEffect(f),
+);
 
-/**
- * Replaces the value. Serialized with `update` / `modify` so writes
- * happen in invocation order.
- */
 export const set: {
 	<A>(value: A): <E, R>(self: State<A, E, R>) => Effect.Effect<void, E, R>;
 	<A, E, R>(self: State<A, E, R>, value: A): Effect.Effect<void, E, R>;
 } = dual(
 	2,
 	<A, E, R>(self: State<A, E, R>, value: A): Effect.Effect<void, E, R> =>
-		Semaphore.withPermit(self.semaphore, self.write(value)),
+		self.set(value),
+);
+
+export const setAndGet: {
+	<A>(value: A): <E, R>(self: State<A, E, R>) => Effect.Effect<A, E, R>;
+	<A, E, R>(self: State<A, E, R>, value: A): Effect.Effect<A, E, R>;
+} = dual(
+	2,
+	<A, E, R>(self: State<A, E, R>, value: A): Effect.Effect<A, E, R> =>
+		self.setAndGet(value),
 );
 
-/**
- * Updates the value by applying `f` to the current value. The
- * read/apply/write triple is atomic across fibers.
- */
 export const update: {
 	<A>(
 		f: (a: A) => A,
@@ -137,88 +372,49 @@ export const update: {
 	<A, E, R>(
 		self: State<A, E, R>,
 		f: (a: A) => A,
-	): Effect.Effect<void, E, R> =>
-		Semaphore.withPermit(
-			self.semaphore,
-			Effect.flatMap(self.read(), (a) => self.write(f(a))),
-		),
+	): Effect.Effect<void, E, R> => self.update(f),
+);
+
+export const updateEffect: {
+	<A, E2, R2>(
+		f: (a: A) => Effect.Effect<A, E2, R2>,
+	): <E, R>(self: State<A, E, R>) => Effect.Effect<void, E | E2, R | R2>;
+	<A, E, R, E2, R2>(
+		self: State<A, E, R>,
+		f: (a: A) => Effect.Effect<A, E2, R2>,
+	): Effect.Effect<void, E | E2, R | R2>;
+} = dual(
+	2,
+	<A, E, R, E2, R2>(
+		self: State<A, E, R>,
+		f: (a: A) => Effect.Effect<A, E2, R2>,
+	): Effect.Effect<void, E | E2, R | R2> => self.updateEffect(f),
 );
 
-/**
- * Updates the value by applying `f` and returns the new value. The
- * read/apply/write triple is atomic across fibers.
- */
 export const updateAndGet: {
 	<A>(f: (a: A) => A): <E, R>(self: State<A, E, R>) => Effect.Effect<A, E, R>;
 	<A, E, R>(self: State<A, E, R>, f: (a: A) => A): Effect.Effect<A, E, R>;
 } = dual(
 	2,
 	<A, E, R>(self: State<A, E, R>, f: (a: A) => A): Effect.Effect<A, E, R> =>
-		Semaphore.withPermit(
-			self.semaphore,
-			Effect.flatMap(self.read(), (a) => {
-				const next = f(a);
-				return Effect.as(self.write(next), next);
-			}),
-		),
+		self.updateAndGet(f),
 );
 
-/**
- * Atomically replaces the value with the second element of `f(prev)`
- * and returns the first. The read/apply/write triple is atomic across
- * fibers.
- */
-export const modify: {
-	<A, B>(
-		f: (a: A) => readonly [B, A],
-	): <E, R>(self: State<A, E, R>) => Effect.Effect<B, E, R>;
-	<A, E, R, B>(
+export const updateAndGetEffect: {
+	<A, E2, R2>(
+		f: (a: A) => Effect.Effect<A, E2, R2>,
+	): <E, R>(self: State<A, E, R>) => Effect.Effect<A, E | E2, R | R2>;
+	<A, E, R, E2, R2>(
 		self: State<A, E, R>,
-		f: (a: A) => readonly [B, A],
-	): Effect.Effect<B, E, R>;
+		f: (a: A) => Effect.Effect<A, E2, R2>,
+	): Effect.Effect<A, E | E2, R | R2>;
 } = dual(
 	2,
-	<A, E, R, B>(
+	<A, E, R, E2, R2>(
 		self: State<A, E, R>,
-		f: (a: A) => readonly [B, A],
-	): Effect.Effect<B, E, R> =>
-		Semaphore.withPermit(
-			self.semaphore,
-			Effect.flatMap(self.read(), (a) => {
-				const [b, next] = f(a);
-				return Effect.as(self.write(next), b);
-			}),
-		),
+		f: (a: A) => Effect.Effect<A, E2, R2>,
+	): Effect.Effect<A, E | E2, R | R2> => self.updateAndGetEffect(f),
 );
 
-/**
- * Stream of every value published to this `State`. New subscribers
- * immediately see the most recent value (replay = 1), then every
- * subsequent publish.
- */
 export const changes = <A, E, R>(self: State<A, E, R>): Stream.Stream<A> =>
-	Stream.fromPubSub(self.pubsub);
-
-/**
- * Publish a value to the change stream as an `Effect`. Does not
- * modify the underlying store.
- */
-export const publish: {
-	<A>(value: A): <E, R>(self: State<A, E, R>) => Effect.Effect<boolean>;
-	<A, E, R>(self: State<A, E, R>, value: A): Effect.Effect<boolean>;
-} = dual(
-	2,
-	<A, E, R>(self: State<A, E, R>, value: A): Effect.Effect<boolean> =>
-		PubSub.publish(self.pubsub, value),
-);
-
-/**
- * Synchronous variant of {@link publish}. Returns `true` when the
- * publish succeeded, `false` if the pubsub is shut down. The runtime
- * uses this from rivetkit's `onStateChange` callback to feed the
- * change stream.
- */
-export const publishUnsafe = <A, E, R>(
-	self: State<A, E, R>,
-	value: A,
-): boolean => PubSub.publishUnsafe(self.pubsub, value);
+	self.changes;