@rivetkit/effect 0.0.0-sqlite-uds.37f9e48 → 0.0.0-sqlite-profiling-compat.4a9a623

package/src/State.test.ts

@@ -36,26 +36,6 @@ 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);
@@ -64,38 +44,6 @@ 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);
@@ -105,17 +53,6 @@ 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");
@@ -128,17 +65,6 @@ 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)",
 		() =>
@@ -163,7 +89,7 @@ describe("State", () => {
 			);
 			assert.deepStrictEqual(initial, [0]);
 
-			yield* s[State.RuntimeTypeId].publishEffect(Effect.succeed(7));
+			State.publishUnsafe(s, 7);
 			const later = yield* State.changes(s).pipe(
 				Stream.take(1),
 				Stream.runCollect,
@@ -177,17 +103,11 @@ describe("State", () => {
 			const { s } = yield* makeCellState(0);
 			yield* Effect.scoped(
 				Effect.gen(function* () {
-					const sub = yield* PubSub.subscribe(
-						s[State.RuntimeTypeId].pubsub,
-					);
+					const sub = yield* PubSub.subscribe(s.pubsub);
 					assert.strictEqual(yield* PubSub.take(sub), 0);
 
-					yield* s[State.RuntimeTypeId].publishEffect(
-						Effect.succeed(1),
-					);
-					yield* s[State.RuntimeTypeId].publishEffect(
-						Effect.succeed(2),
-					);
+					yield* State.publish(s, 1);
+					yield* State.publish(s, 2);
 					assert.strictEqual(yield* PubSub.take(sub), 1);
 					assert.strictEqual(yield* PubSub.take(sub), 2);
 				}),
@@ -195,19 +115,6 @@ 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);
@@ -239,61 +146,6 @@ 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);
 		}),
 	);
 
@@ -326,15 +178,4 @@ 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,7 +26,6 @@ import {
 	Predicate,
 	PubSub,
 	Semaphore,
-	Scope,
 	Stream,
 	type Types,
 } from "effect";
@@ -34,15 +33,6 @@ 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.
  *
@@ -55,97 +45,17 @@ 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> =>
@@ -176,192 +86,47 @@ const Proto = {
  * The current value (per `read()`) is published to the pubsub on
  * construction so any subscription obtained later replays it.
  *
- * The backing PubSub is scoped and shuts down when the current
- * `Scope` closes.
+ * The PubSub is not explicitly shut down — it's reclaimed by GC when
+ * the `State` and any subscribers become unreachable.
  */
 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 | Scope.Scope> {
+): Effect.fn.Return<State<A, E, R>, E, R> {
 	const pubsub = yield* PubSub.unbounded<A>({ replay: 1 });
-	yield* Effect.addFinalizer(() => PubSub.shutdown(pubsub));
 	const initial = yield* read();
-	yield* PubSub.publish(pubsub, initial);
+	PubSub.publishUnsafe(pubsub, initial);
 	const self = Object.create(Proto);
-	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);
+	self.read = read;
+	self.write = write;
+	self.pubsub = pubsub;
+	self.semaphore = Semaphore.makeUnsafe(1);
 	return self;
 });
 
+/**
+ * Reads the current value.
+ */
 export const get = <A, E, R>(self: State<A, E, R>): Effect.Effect<A, E, R> =>
-	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),
-);
+	self.read();
 
+/**
+ * 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> =>
-		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),
+		Semaphore.withPermit(self.semaphore, self.write(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,
@@ -372,49 +137,88 @@ export const update: {
 	<A, E, R>(
 		self: State<A, E, R>,
 		f: (a: A) => 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),
+	): Effect.Effect<void, E, R> =>
+		Semaphore.withPermit(
+			self.semaphore,
+			Effect.flatMap(self.read(), (a) => self.write(f(a))),
+		),
 );
 
+/**
+ * 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> =>
-		self.updateAndGet(f),
+		Semaphore.withPermit(
+			self.semaphore,
+			Effect.flatMap(self.read(), (a) => {
+				const next = f(a);
+				return Effect.as(self.write(next), next);
+			}),
+		),
 );
 
-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>(
+/**
+ * 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>(
 		self: State<A, E, R>,
-		f: (a: A) => Effect.Effect<A, E2, R2>,
-	): Effect.Effect<A, E | E2, R | R2>;
+		f: (a: A) => readonly [B, A],
+	): Effect.Effect<B, E, R>;
 } = dual(
 	2,
-	<A, E, R, E2, R2>(
+	<A, E, R, B>(
 		self: State<A, E, R>,
-		f: (a: A) => Effect.Effect<A, E2, R2>,
-	): Effect.Effect<A, E | E2, R | R2> => self.updateAndGetEffect(f),
+		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);
+			}),
+		),
 );
 
+/**
+ * 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> =>
-	self.changes;
+	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);