@shivaedev/effect-changes 0.0.0 → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+## 0.1.0 - 2026-09-26
+
+### Added
+
+- Add `makeChannel`: record changes inside a transaction and publish them once,
+  deduplicated by key, only after the outermost frame for their owner commits.
+  Nested frames merge on commit and are discarded on rollback; frames are kept
+  per transaction owner.
+- Wrap exit-reporting native transactions with `within`, Promise-committing
+  drivers with `open` and `settle`, and non-transactional work with `batch`.
+- Publish exactly when the database committed, including when the caller is
+  interrupted while `COMMIT` is in flight.
+- Log a sink failure after commit, whether a failed Effect, a defect or a
+  synchronous throw, and keep the committed result by default;
+  `onPublishFailure: "die"` raises a defect instead.
+- Expose `channel.Sink` and `channel.Observer` as `Context.Reference`s: tests
+  can swap the sink for a scope and observe every recorded, published and
+  discarded change.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ShivaeDev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,127 @@
 # @shivaedev/effect-changes
 
-This version only reserves the name. Releases are published from https://github.com/ShivaeDev/platform.
+Commit-bound change channels for Effect. Code that writes rows records the changes it made; the channel publishes them only after the transaction that wrote them commits, once, deduplicated. A rollback, a failed `COMMIT` or an interruption before `COMMIT` publishes nothing.
+
+The package imports only `effect` and runs in browsers and servers. It knows nothing about SQL or any ORM: a channel binds to a database through two things you supply, the transaction owner and the native transaction.
+
+```ts
+import { makeChannel } from "@shivaedev/effect-changes";
+import { Effect } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+
+interface ChangeEvent {
+  readonly userId: string;
+  readonly domain: string;
+}
+declare const bus: { readonly emit: (event: ChangeEvent) => void };
+
+const liveChanges = makeChannel<ChangeEvent, SqlClient.SqlClient>({
+  name: "LiveChanges",
+  owner: Effect.map(SqlClient.SqlClient, (sql) => sql.transactionService),
+  key: (event) => `${event.userId}:${event.domain}`,
+  publish: (events) => Effect.sync(() => events.forEach((event) => bus.emit(event))),
+});
+
+const addMember = (owner: string, member: string) =>
+  Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    yield* sql`insert into membership (owner, member) values (${owner}, ${member})`;
+    yield* liveChanges.record([
+      { userId: owner, domain: "memberships" },
+      { userId: member, domain: "memberships" },
+    ]);
+  });
+
+const program = Effect.flatMap(SqlClient.SqlClient, (sql) => liveChanges.within(sql.withTransaction)(addMember("owner", "member")));
+```
+
+## API
+
+```ts
+makeChannel<A, R = never>(options: ChannelOptions<A, R>): Channel<A, R>
+
+type Publish<A, R = never> = (changes: ReadonlyArray<A>) => Effect<void, unknown, R>;
+type PublishFailure = "log" | "die";
+type Outcome = "committed" | "rolledBack";
+
+interface ChannelOptions<A, R> {
+  readonly name: string;
+  readonly owner: Effect<unknown, never, R>;
+  readonly key?: (change: A) => unknown;
+  readonly publish: Publish<A, R>;
+  readonly onPublishFailure?: PublishFailure;
+  readonly unowned?: Effect<void, never, R>;
+}
+
+interface Channel<A, R> {
+  readonly record: (changes: Iterable<A>) => Effect<void, never, R>;
+  readonly within: <X, E, R2, E2, R3>(
+    native: (body: Effect<X, E, R2>) => Effect<X, E2, R3>,
+  ) => (body: Effect<X, E, R2>) => Effect<X, E2, R | R3>;
+  readonly open: Effect<Frame, never, R>;
+  readonly batch: <X, E, R2>(body: Effect<X, E, R2>) => Effect<X, E, R | R2>;
+  readonly Sink: Context.Reference<Publish<A, R>>;
+  readonly Observer: Context.Reference<Observer<A>>;
+}
+
+interface Frame {
+  readonly provide: <X, E, R>(body: Effect<X, E, R>) => Effect<X, E, R>;
+  readonly settle: (outcome: Outcome) => Effect<void>;
+}
+
+type Observation<A> =
+  | { readonly _tag: "Recorded"; readonly changes: ReadonlyArray<A> }
+  | { readonly _tag: "Published"; readonly changes: ReadonlyArray<A> }
+  | { readonly _tag: "Discarded"; readonly changes: ReadonlyArray<A> };
+type Observer<A> = (observation: Observation<A>) => Effect<void>;
+```
+
+- `owner` identifies the transaction a change belongs to, usually one value per database or connection pool. Frames are kept per owner.
+- `key` deduplicates changes. It defaults to the change itself (`Set` semantics). The first occurrence of a key keeps its place.
+- `record` accepts any number of changes; one write may notify several subjects.
+- `within(native)` wraps a native transaction combinator whose success means `COMMIT` (or savepoint release) happened, such as `sql.withTransaction`.
+- `open` and `settle` are for drivers that report the commit through a Promise, such as Prisma's interactive `$transaction`. Open a frame, run the body with `frame.provide`, and settle it with the driver's outcome.
+- `batch` defers publishing for work outside a transaction, for example one request. Its writes were autocommitted, so it publishes on any exit.
+- `unowned` is an optional guard that runs when a change is recorded, or a root frame opened, with no transaction frame for the owner. Use it to refuse native transactions the channel cannot observe.
+
+## Semantics
+
+| Situation | Root frame | Nested frame (savepoint) |
+| --- | --- | --- |
+| Body succeeds and the native transaction commits | Publish the distinct changes once, before `within` returns | Merge into the parent frame |
+| Typed failure, defect, interruption before `COMMIT`, or failed `COMMIT` | Discard | Discard; the parent keeps its own changes |
+| `record` after the frame settled | Die | Die |
+| `record` with no frame for the owner | Run `unowned`, then publish immediately | n/a |
+
+- A frame for owner B opened inside a frame for owner A is a root for B: it publishes when B commits, even if A rolls back later. Re-entering A inside B joins A's frame.
+- The publish decision follows the commit, not the fiber. `within` runs the native combinator uninterruptibly apart from the body, so an interruption that arrives while `COMMIT` is in flight takes effect after it; the changes publish if the database committed, and the caller still sees the interruption. The native combinator must run the body once and succeed only when it committed.
+- `settle` is idempotent and uninterruptible; the first outcome wins. Publishing is uninterruptible.
+- A `batch` inside a transaction merges into it on any exit and follows the transaction's outcome. Transactions inside a batch merge into it when they commit.
+
+## Publish failures
+
+The data is committed by the time a sink runs, so a failing sink cannot undo it. With the default `onPublishFailure: "log"`, a failed Effect, a defect, or a sink function that throws synchronously is logged once as an error with its full cause, the channel name and the change count; the span is annotated, and the caller's committed result stands. `"die"` turns the failure into a defect instead. Retries belong in the sink.
+
+## Testing
+
+`channel.Sink` and `channel.Observer` are `Context.Reference`s. Provide them to a test's scope; production code that never provides them uses the configured sink and no observer.
+
+```ts
+const published: Array<ChangeEvent> = [];
+const captureSink = Layer.succeed(liveChanges.Sink, (events: ReadonlyArray<ChangeEvent>) => Effect.sync(() => published.push(...events)));
+
+const observations: Array<Observation<ChangeEvent>> = [];
+const observe = Layer.succeed(liveChanges.Observer, (observation: Observation<ChangeEvent>) => Effect.sync(() => observations.push(observation)));
+```
+
+- The sink override replaces `publish` for everything that runs in its scope, including frames settled later from that scope. The failure policy still applies.
+- The observer sees every accepted `record` call as `Recorded` (its distinct changes), every frame dropped by a rollback or failed commit as `Discarded` (including changes merged into it from committed savepoints), and every publish as `Published` (what the sink receives). A change recorded in a rolled-back savepoint therefore appears as `Recorded` and `Discarded`.
+
+## Limits
+
+- Delivery is in-process. A crash between `COMMIT` and publishing loses the changes, together with the in-process subscribers that would have received them.
+- There is no cross-process delivery. PostgreSQL `NOTIFY` is itself commit-bound and would be the natural transport; it is not implemented.
+- Changes with the same key are not merged; the first one wins.
+- Only changes that code records are published. Writes made by triggers, cascades or raw SQL that does not call `record` are invisible to the channel.
+
+This release targets Effect `4.0.0-rc.112`.

package/dist/channel.d.ts

@@ -0,0 +1,22 @@
+import { Context, Effect } from "effect";
+import { type Frame } from "./frame.ts";
+import { type Observer } from "./observe.ts";
+import { type Publish, type PublishFailure } from "./publish.ts";
+export interface ChannelOptions<A, R> {
+    readonly name: string;
+    readonly owner: Effect.Effect<unknown, never, R>;
+    readonly key?: (change: A) => unknown;
+    readonly publish: Publish<A, R>;
+    readonly onPublishFailure?: PublishFailure;
+    readonly unowned?: Effect.Effect<void, never, R>;
+}
+export interface Channel<A, R> {
+    readonly record: (changes: Iterable<A>) => Effect.Effect<void, never, R>;
+    readonly within: <X, E, R2, E2, R3>(native: (body: Effect.Effect<X, E, R2>) => Effect.Effect<X, E2, R3>) => (body: Effect.Effect<X, E, R2>) => Effect.Effect<X, E2, R | R3>;
+    readonly open: Effect.Effect<Frame, never, R>;
+    readonly batch: <X, E, R2>(body: Effect.Effect<X, E, R2>) => Effect.Effect<X, E, R | R2>;
+    readonly Sink: Context.Reference<Publish<A, R>>;
+    readonly Observer: Context.Reference<Observer<A>>;
+}
+export declare const makeChannel: <A, R = never>(options: ChannelOptions<A, R>) => Channel<A, R>;
+//# sourceMappingURL=channel.d.ts.map

package/dist/channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../src/channel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAQ,MAAM,QAAQ,CAAC;AAC/C,OAAO,EAAoB,KAAK,KAAK,EAAyC,MAAM,YAAY,CAAC;AACjG,OAAO,EAAoB,KAAK,QAAQ,EAAc,MAAM,cAAc,CAAC;AAC3E,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,cAAc,EAAa,MAAM,cAAc,CAAC;AAE5E,MAAM,WAAW,cAAc,CAAC,CAAC,EAAE,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;IACjD,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,OAAO,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAChC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,cAAc,CAAC;IAC3C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;CACjD;AAED,MAAM,WAAW,OAAO,CAAC,CAAC,EAAE,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;IACzE,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EACjC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,KAC/D,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IACrE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;IAC9C,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IACzF,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAChD,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;CAClD;AAID,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,SAAS,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAkErF,CAAC"}

package/dist/channel.js

@@ -0,0 +1,59 @@
+import { Context, Effect, Exit } from "effect";
+import { add, keyed, makeBuffer, makeFrame, settled } from "./frame.js";
+import { unobserved } from "./observe.js";
+import { publisher } from "./publish.js";
+let channels = 0;
+export const makeChannel = (options) => {
+    const { name } = options;
+    const prefix = `@shivaedev/effect-changes/${name}/${channels++}`;
+    const Frames = Context.Reference(`${prefix}/Frames`, { defaultValue: () => new Map() });
+    const CurrentSink = Context.Reference(`${prefix}/Sink`, { defaultValue: () => options.publish });
+    const CurrentObserver = Context.Reference(`${prefix}/Observer`, { defaultValue: () => unobserved });
+    const keyOf = options.key ?? ((change) => change);
+    const publish = publisher(name, options.onPublishFailure ?? "log");
+    const guard = options.unowned ?? Effect.void;
+    const unguarded = (frame) => frame === undefined || frame.kind === "batch";
+    const observe = (observation) => Effect.flatMap(Effect.service(CurrentObserver), (observer) => observer(observation));
+    const deliver = (changes) => Effect.andThen(observe({ _tag: "Published", changes }), Effect.flatMap(Effect.service(CurrentSink), (sink) => publish(sink, changes)));
+    const locate = Effect.gen(function* () {
+        const owner = yield* options.owner;
+        const frames = yield* Frames;
+        return { owner, frames, frame: frames.get(owner) };
+    });
+    const record = Effect.fn("Changes.record")(function* (changes) {
+        const { frame } = yield* locate;
+        if (unguarded(frame))
+            yield* guard;
+        const entries = keyed(changes, keyOf);
+        if (frame !== undefined)
+            yield* add(name, frame, entries);
+        if (entries.size === 0)
+            return;
+        const distinct = [...entries.values()];
+        yield* observe({ _tag: "Recorded", changes: distinct });
+        if (frame === undefined)
+            yield* deliver(distinct);
+    });
+    const openAs = (kind) => Effect.gen(function* () {
+        const { owner, frames, frame: parent } = yield* locate;
+        if (parent !== undefined && !parent.open)
+            return yield* settled(name);
+        if (kind === "transaction" && unguarded(parent))
+            yield* guard;
+        const buffer = makeBuffer(kind, parent);
+        const inner = new Map(frames).set(owner, buffer);
+        const context = yield* Effect.context();
+        return makeFrame({
+            name,
+            buffer,
+            provide: (body) => Effect.provideService(body, Frames, inner),
+            publish: (changes) => Effect.provideContext(deliver(changes), context),
+            discard: (changes) => Effect.provideContext(observe({ _tag: "Discarded", changes }), context),
+        });
+    });
+    const open = openAs("transaction");
+    const within = (native) => (body) => Effect.uninterruptibleMask((restore) => Effect.flatMap(open, (frame) => Effect.onExit(native(restore(frame.provide(body))), (exit) => frame.settle(Exit.isSuccess(exit) ? "committed" : "rolledBack"))));
+    const batch = (body) => Effect.uninterruptibleMask((restore) => Effect.flatMap(openAs("batch"), (frame) => Effect.onExit(restore(frame.provide(body)), () => frame.settle("committed"))));
+    return { record, within, open, batch, Sink: CurrentSink, Observer: CurrentObserver };
+};
+//# sourceMappingURL=channel.js.map

package/dist/channel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.js","sourceRoot":"","sources":["../src/channel.ts"],"names":[],"mappings":"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"}

package/dist/frame.d.ts

@@ -0,0 +1,24 @@
+import { Effect } from "effect";
+export type Outcome = "committed" | "rolledBack";
+export interface Frame {
+    readonly provide: <X, E, R>(body: Effect.Effect<X, E, R>) => Effect.Effect<X, E, R>;
+    readonly settle: (outcome: Outcome) => Effect.Effect<void>;
+}
+export interface Buffer<A> {
+    readonly kind: "transaction" | "batch";
+    readonly changes: Map<unknown, A>;
+    readonly parent: Buffer<A> | undefined;
+    open: boolean;
+}
+export declare const makeBuffer: <A>(kind: Buffer<A>["kind"], parent: Buffer<A> | undefined) => Buffer<A>;
+export declare const settled: (name: string) => Effect.Effect<never>;
+export declare const add: <A>(name: string, buffer: Buffer<A>, entries: Iterable<readonly [unknown, A]>) => Effect.Effect<void>;
+export declare const keyed: <A>(changes: Iterable<A>, keyOf: (change: A) => unknown) => Map<unknown, A>;
+export declare const makeFrame: <A>(options: {
+    readonly name: string;
+    readonly buffer: Buffer<A>;
+    readonly provide: <X, E, R>(body: Effect.Effect<X, E, R>) => Effect.Effect<X, E, R>;
+    readonly publish: (changes: ReadonlyArray<A>) => Effect.Effect<void>;
+    readonly discard: (changes: ReadonlyArray<A>) => Effect.Effect<void>;
+}) => Frame;
+//# sourceMappingURL=frame.d.ts.map

package/dist/frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame.d.ts","sourceRoot":"","sources":["../src/frame.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,MAAM,MAAM,OAAO,GAAG,WAAW,GAAG,YAAY,CAAC;AAEjD,MAAM,WAAW,KAAK;IACrB,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IACpF,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CAC3D;AAED,MAAM,WAAW,MAAM,CAAC,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IACvC,IAAI,EAAE,OAAO,CAAC;CACd;AAED,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,MAAM,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,QAAQ,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,KAAG,MAAM,CAAC,CAAC,CAK7F,CAAC;AAEH,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CACyE,CAAC;AAEpI,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,MAAM,MAAM,EAAE,QAAQ,MAAM,CAAC,CAAC,CAAC,EAAE,SAAS,QAAQ,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAKpG,CAAC;AAElB,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,SAAS,QAAQ,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,KAAK,OAAO,KAAG,GAAG,CAAC,OAAO,EAAE,CAAC,CAO5F,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,SAAS;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IACpF,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACrE,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CACrE,KAAG,KAWH,CAAC"}

package/dist/frame.js

@@ -0,0 +1,40 @@
+import { Effect } from "effect";
+export const makeBuffer = (kind, parent) => ({
+    kind,
+    changes: new Map(),
+    parent,
+    open: true,
+});
+export const settled = (name) => Effect.die(new Error(`${name}: changes arrived after their transaction settled; record them before the transaction body returns`));
+export const add = (name, buffer, entries) => buffer.open
+    ? Effect.sync(() => {
+        for (const [key, change] of entries)
+            if (!buffer.changes.has(key))
+                buffer.changes.set(key, change);
+    })
+    : settled(name);
+export const keyed = (changes, keyOf) => {
+    const entries = new Map();
+    for (const change of changes) {
+        const key = keyOf(change);
+        if (!entries.has(key))
+            entries.set(key, change);
+    }
+    return entries;
+};
+export const makeFrame = (options) => {
+    const { name, buffer } = options;
+    const settle = Effect.fn("Changes.settle")(function* (outcome) {
+        if (!buffer.open)
+            return;
+        buffer.open = false;
+        if (outcome === "committed" && buffer.parent !== undefined)
+            return yield* add(name, buffer.parent, buffer.changes);
+        const changes = [...buffer.changes.values()];
+        if (changes.length === 0)
+            return;
+        yield* outcome === "committed" ? options.publish(changes) : options.discard(changes);
+    }, Effect.uninterruptible);
+    return { provide: options.provide, settle };
+};
+//# sourceMappingURL=frame.js.map

package/dist/frame.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame.js","sourceRoot":"","sources":["../src/frame.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAgBhC,MAAM,CAAC,MAAM,UAAU,GAAG,CAAI,IAAuB,EAAE,MAA6B,EAAa,EAAE,CAAC,CAAC;IACpG,IAAI;IACJ,OAAO,EAAE,IAAI,GAAG,EAAE;IAClB,MAAM;IACN,IAAI,EAAE,IAAI;CACV,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,IAAY,EAAwB,EAAE,CAC7D,MAAM,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,GAAG,IAAI,oGAAoG,CAAC,CAAC,CAAC;AAEpI,MAAM,CAAC,MAAM,GAAG,GAAG,CAAI,IAAY,EAAE,MAAiB,EAAE,OAAwC,EAAuB,EAAE,CACxH,MAAM,CAAC,IAAI;IACV,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;QACjB,KAAK,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,IAAI,OAAO;YAAE,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;gBAAE,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IACpG,CAAC,CAAC;IACH,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAElB,MAAM,CAAC,MAAM,KAAK,GAAG,CAAI,OAAoB,EAAE,KAA6B,EAAmB,EAAE;IAChG,MAAM,OAAO,GAAG,IAAI,GAAG,EAAc,CAAC;IACtC,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC9B,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;QAC1B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IACjD,CAAC;IACD,OAAO,OAAO,CAAC;AAChB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,SAAS,GAAG,CAAI,OAM5B,EAAS,EAAE;IACX,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IACjC,MAAM,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC,gBAAgB,CAAC,CAAC,QAAQ,CAAC,EAAE,OAAgB;QACrE,IAAI,CAAC,MAAM,CAAC,IAAI;YAAE,OAAO;QACzB,MAAM,CAAC,IAAI,GAAG,KAAK,CAAC;QACpB,IAAI,OAAO,KAAK,WAAW,IAAI,MAAM,CAAC,MAAM,KAAK,SAAS;YAAE,OAAO,KAAK,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;QACnH,MAAM,OAAO,GAAG,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;QAC7C,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QACjC,KAAK,CAAC,CAAC,OAAO,KAAK,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACtF,CAAC,EAAE,MAAM,CAAC,eAAe,CAAC,CAAC;IAC3B,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;AAC7C,CAAC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { type Channel, type ChannelOptions, makeChannel } from "./channel.ts";
+export type { Frame, Outcome } from "./frame.ts";
+export type { Observation, Observer } from "./observe.ts";
+export type { Publish, PublishFailure } from "./publish.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,cAAc,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC9E,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACjD,YAAY,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAC1D,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { makeChannel } from "./channel.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqC,WAAW,EAAE,MAAM,cAAc,CAAC"}

package/dist/observe.d.ts

@@ -0,0 +1,14 @@
+import { Effect } from "effect";
+export type Observation<A> = {
+    readonly _tag: "Recorded";
+    readonly changes: ReadonlyArray<A>;
+} | {
+    readonly _tag: "Published";
+    readonly changes: ReadonlyArray<A>;
+} | {
+    readonly _tag: "Discarded";
+    readonly changes: ReadonlyArray<A>;
+};
+export type Observer<A> = (observation: Observation<A>) => Effect.Effect<void>;
+export declare const unobserved: (_observation: unknown) => Effect.Effect<void>;
+//# sourceMappingURL=observe.d.ts.map

package/dist/observe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observe.d.ts","sourceRoot":"","sources":["../src/observe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,MAAM,MAAM,WAAW,CAAC,CAAC,IACtB;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,CAAA;CAAE,GACjE;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,CAAA;CAAE,GAClE;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,CAAA;CAAE,CAAC;AAEtE,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AAE/E,eAAO,MAAM,UAAU,GAAI,cAAc,OAAO,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAgB,CAAC"}

package/dist/observe.js

@@ -0,0 +1,3 @@
+import { Effect } from "effect";
+export const unobserved = (_observation) => Effect.void;
+//# sourceMappingURL=observe.js.map

package/dist/observe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observe.js","sourceRoot":"","sources":["../src/observe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAShC,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,YAAqB,EAAuB,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC"}

package/dist/publish.d.ts

@@ -0,0 +1,5 @@
+import { Effect } from "effect";
+export type PublishFailure = "log" | "die";
+export type Publish<A, R = never> = (changes: ReadonlyArray<A>) => Effect.Effect<void, unknown, R>;
+export declare const publisher: <A, R>(name: string, policy: PublishFailure) => ((sink: Publish<A, R>, changes: ReadonlyArray<A>) => Effect.Effect<void, never, R>);
+//# sourceMappingURL=publish.d.ts.map

package/dist/publish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish.d.ts","sourceRoot":"","sources":["../src/publish.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,KAAK,CAAC;AAE3C,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;AAEnG,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,EAC7B,MAAM,MAAM,EACZ,QAAQ,cAAc,KACpB,CAAC,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAW1D,CAAC"}

package/dist/publish.js

@@ -0,0 +1,9 @@
+import { Effect } from "effect";
+export const publisher = (name, policy) => Effect.fn("Changes.publish")(function* (sink, changes) {
+    yield* Effect.annotateCurrentSpan({ "changes.channel": name, "changes.count": changes.length });
+    const sent = Effect.suspend(() => sink(changes));
+    if (policy === "die")
+        return yield* Effect.orDie(sent);
+    yield* Effect.catchCause(sent, (cause) => Effect.andThen(Effect.annotateCurrentSpan("changes.published", false), Effect.logError("Changes.publish failed after the changes were committed; the committed result stands", cause)).pipe(Effect.annotateLogs({ channel: name, changes: changes.length })));
+}, Effect.uninterruptible);
+//# sourceMappingURL=publish.js.map

package/dist/publish.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish.js","sourceRoot":"","sources":["../src/publish.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAMhC,MAAM,CAAC,MAAM,SAAS,GAAG,CACxB,IAAY,EACZ,MAAsB,EACgE,EAAE,CACxF,MAAM,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAC,QAAQ,CAAC,EAAE,IAAmB,EAAE,OAAyB;IACrF,KAAK,CAAC,CAAC,MAAM,CAAC,mBAAmB,CAAC,EAAE,iBAAiB,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAChG,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IACjD,IAAI,MAAM,KAAK,KAAK;QAAE,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACvD,KAAK,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,CACxC,MAAM,CAAC,OAAO,CACb,MAAM,CAAC,mBAAmB,CAAC,mBAAmB,EAAE,KAAK,CAAC,EACtD,MAAM,CAAC,QAAQ,CAAC,sFAAsF,EAAE,KAAK,CAAC,CAC9G,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CACvE,CAAC;AACH,CAAC,EAAE,MAAM,CAAC,eAAe,CAAC,CAAC"}

package/package.json

@@ -1,14 +1,58 @@
 {
   "name": "@shivaedev/effect-changes",
-  "version": "0.0.0",
-  "description": "Name reservation. The first release is published from https://github.com/ShivaeDev/platform.",
+  "version": "0.1.0",
+  "description": "Commit-bound change channels for Effect: publish recorded changes only after the transaction commits",
+  "type": "module",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShivaeDev/platform.git",
     "directory": "packages/effect-changes"
   },
+  "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/effect-changes#readme",
+  "bugs": {
+    "url": "https://github.com/ShivaeDev/platform/issues"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "source": "./src/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
+  },
+  "peerDependencies": {
+    "effect": "4.0.0-rc.112"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.1",
+    "@typescript/native": "npm:typescript@7.0.2",
+    "effect": "4.0.0-rc.112",
+    "typescript": "npm:@typescript/typescript6@6.0.2",
+    "vitest": "4.1.9"
+  },
+  "scripts": {
+    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc6 --project tsconfig.build.json",
+    "check": "biome check .",
+    "test": "vitest run",
+    "test:package": "node scripts/test-package.mjs",
+    "typecheck": "tsc --noEmit",
+    "typecheck:compat": "tsc6 --noEmit",
+    "ready": "pnpm check && pnpm typecheck && pnpm typecheck:compat && pnpm test && pnpm build && pnpm test:package"
   }
-}
+}

package/src/channel.ts

@@ -0,0 +1,94 @@
+import { Context, Effect, Exit } from "effect";
+import { add, type Buffer, type Frame, keyed, makeBuffer, makeFrame, settled } from "./frame.ts";
+import { type Observation, type Observer, unobserved } from "./observe.ts";
+import { type Publish, type PublishFailure, publisher } from "./publish.ts";
+
+export interface ChannelOptions<A, R> {
+	readonly name: string;
+	readonly owner: Effect.Effect<unknown, never, R>;
+	readonly key?: (change: A) => unknown;
+	readonly publish: Publish<A, R>;
+	readonly onPublishFailure?: PublishFailure;
+	readonly unowned?: Effect.Effect<void, never, R>;
+}
+
+export interface Channel<A, R> {
+	readonly record: (changes: Iterable<A>) => Effect.Effect<void, never, R>;
+	readonly within: <X, E, R2, E2, R3>(
+		native: (body: Effect.Effect<X, E, R2>) => Effect.Effect<X, E2, R3>,
+	) => (body: Effect.Effect<X, E, R2>) => Effect.Effect<X, E2, R | R3>;
+	readonly open: Effect.Effect<Frame, never, R>;
+	readonly batch: <X, E, R2>(body: Effect.Effect<X, E, R2>) => Effect.Effect<X, E, R | R2>;
+	readonly Sink: Context.Reference<Publish<A, R>>;
+	readonly Observer: Context.Reference<Observer<A>>;
+}
+
+let channels = 0;
+
+export const makeChannel = <A, R = never>(options: ChannelOptions<A, R>): Channel<A, R> => {
+	const { name } = options;
+	const prefix = `@shivaedev/effect-changes/${name}/${channels++}`;
+	const Frames = Context.Reference<ReadonlyMap<unknown, Buffer<A>>>(`${prefix}/Frames`, { defaultValue: () => new Map() });
+	const CurrentSink = Context.Reference<Publish<A, R>>(`${prefix}/Sink`, { defaultValue: () => options.publish });
+	const CurrentObserver = Context.Reference<Observer<A>>(`${prefix}/Observer`, { defaultValue: () => unobserved });
+	const keyOf = options.key ?? ((change: A): unknown => change);
+	const publish = publisher<A, R>(name, options.onPublishFailure ?? "log");
+	const guard = options.unowned ?? Effect.void;
+	const unguarded = (frame: Buffer<A> | undefined) => frame === undefined || frame.kind === "batch";
+	const observe = (observation: Observation<A>) => Effect.flatMap(Effect.service(CurrentObserver), (observer) => observer(observation));
+	const deliver = (changes: ReadonlyArray<A>) =>
+		Effect.andThen(
+			observe({ _tag: "Published", changes }),
+			Effect.flatMap(Effect.service(CurrentSink), (sink) => publish(sink, changes)),
+		);
+
+	const locate = Effect.gen(function* () {
+		const owner = yield* options.owner;
+		const frames = yield* Frames;
+		return { owner, frames, frame: frames.get(owner) };
+	});
+
+	const record = Effect.fn("Changes.record")(function* (changes: Iterable<A>) {
+		const { frame } = yield* locate;
+		if (unguarded(frame)) yield* guard;
+		const entries = keyed(changes, keyOf);
+		if (frame !== undefined) yield* add(name, frame, entries);
+		if (entries.size === 0) return;
+		const distinct = [...entries.values()];
+		yield* observe({ _tag: "Recorded", changes: distinct });
+		if (frame === undefined) yield* deliver(distinct);
+	});
+
+	const openAs = (kind: Buffer<A>["kind"]) =>
+		Effect.gen(function* () {
+			const { owner, frames, frame: parent } = yield* locate;
+			if (parent !== undefined && !parent.open) return yield* settled(name);
+			if (kind === "transaction" && unguarded(parent)) yield* guard;
+			const buffer = makeBuffer(kind, parent);
+			const inner = new Map(frames).set(owner, buffer);
+			const context = yield* Effect.context<R>();
+			return makeFrame({
+				name,
+				buffer,
+				provide: (body) => Effect.provideService(body, Frames, inner),
+				publish: (changes) => Effect.provideContext(deliver(changes), context),
+				discard: (changes) => Effect.provideContext(observe({ _tag: "Discarded", changes }), context),
+			});
+		});
+
+	const open = openAs("transaction");
+
+	const within: Channel<A, R>["within"] = (native) => (body) =>
+		Effect.uninterruptibleMask((restore) =>
+			Effect.flatMap(open, (frame) =>
+				Effect.onExit(native(restore(frame.provide(body))), (exit) => frame.settle(Exit.isSuccess(exit) ? "committed" : "rolledBack")),
+			),
+		);
+
+	const batch: Channel<A, R>["batch"] = (body) =>
+		Effect.uninterruptibleMask((restore) =>
+			Effect.flatMap(openAs("batch"), (frame) => Effect.onExit(restore(frame.provide(body)), () => frame.settle("committed"))),
+		);
+
+	return { record, within, open, batch, Sink: CurrentSink, Observer: CurrentObserver };
+};

package/src/frame.ts

@@ -0,0 +1,60 @@
+import { Effect } from "effect";
+
+export type Outcome = "committed" | "rolledBack";
+
+export interface Frame {
+	readonly provide: <X, E, R>(body: Effect.Effect<X, E, R>) => Effect.Effect<X, E, R>;
+	readonly settle: (outcome: Outcome) => Effect.Effect<void>;
+}
+
+export interface Buffer<A> {
+	readonly kind: "transaction" | "batch";
+	readonly changes: Map<unknown, A>;
+	readonly parent: Buffer<A> | undefined;
+	open: boolean;
+}
+
+export const makeBuffer = <A>(kind: Buffer<A>["kind"], parent: Buffer<A> | undefined): Buffer<A> => ({
+	kind,
+	changes: new Map(),
+	parent,
+	open: true,
+});
+
+export const settled = (name: string): Effect.Effect<never> =>
+	Effect.die(new Error(`${name}: changes arrived after their transaction settled; record them before the transaction body returns`));
+
+export const add = <A>(name: string, buffer: Buffer<A>, entries: Iterable<readonly [unknown, A]>): Effect.Effect<void> =>
+	buffer.open
+		? Effect.sync(() => {
+				for (const [key, change] of entries) if (!buffer.changes.has(key)) buffer.changes.set(key, change);
+			})
+		: settled(name);
+
+export const keyed = <A>(changes: Iterable<A>, keyOf: (change: A) => unknown): Map<unknown, A> => {
+	const entries = new Map<unknown, A>();
+	for (const change of changes) {
+		const key = keyOf(change);
+		if (!entries.has(key)) entries.set(key, change);
+	}
+	return entries;
+};
+
+export const makeFrame = <A>(options: {
+	readonly name: string;
+	readonly buffer: Buffer<A>;
+	readonly provide: <X, E, R>(body: Effect.Effect<X, E, R>) => Effect.Effect<X, E, R>;
+	readonly publish: (changes: ReadonlyArray<A>) => Effect.Effect<void>;
+	readonly discard: (changes: ReadonlyArray<A>) => Effect.Effect<void>;
+}): Frame => {
+	const { name, buffer } = options;
+	const settle = Effect.fn("Changes.settle")(function* (outcome: Outcome) {
+		if (!buffer.open) return;
+		buffer.open = false;
+		if (outcome === "committed" && buffer.parent !== undefined) return yield* add(name, buffer.parent, buffer.changes);
+		const changes = [...buffer.changes.values()];
+		if (changes.length === 0) return;
+		yield* outcome === "committed" ? options.publish(changes) : options.discard(changes);
+	}, Effect.uninterruptible);
+	return { provide: options.provide, settle };
+};

package/src/index.ts

@@ -0,0 +1,4 @@
+export { type Channel, type ChannelOptions, makeChannel } from "./channel.ts";
+export type { Frame, Outcome } from "./frame.ts";
+export type { Observation, Observer } from "./observe.ts";
+export type { Publish, PublishFailure } from "./publish.ts";

package/src/observe.ts

@@ -0,0 +1,10 @@
+import { Effect } from "effect";
+
+export type Observation<A> =
+	| { readonly _tag: "Recorded"; readonly changes: ReadonlyArray<A> }
+	| { readonly _tag: "Published"; readonly changes: ReadonlyArray<A> }
+	| { readonly _tag: "Discarded"; readonly changes: ReadonlyArray<A> };
+
+export type Observer<A> = (observation: Observation<A>) => Effect.Effect<void>;
+
+export const unobserved = (_observation: unknown): Effect.Effect<void> => Effect.void;

package/src/publish.ts

@@ -0,0 +1,21 @@
+import { Effect } from "effect";
+
+export type PublishFailure = "log" | "die";
+
+export type Publish<A, R = never> = (changes: ReadonlyArray<A>) => Effect.Effect<void, unknown, R>;
+
+export const publisher = <A, R>(
+	name: string,
+	policy: PublishFailure,
+): ((sink: Publish<A, R>, changes: ReadonlyArray<A>) => Effect.Effect<void, never, R>) =>
+	Effect.fn("Changes.publish")(function* (sink: Publish<A, R>, changes: ReadonlyArray<A>) {
+		yield* Effect.annotateCurrentSpan({ "changes.channel": name, "changes.count": changes.length });
+		const sent = Effect.suspend(() => sink(changes));
+		if (policy === "die") return yield* Effect.orDie(sent);
+		yield* Effect.catchCause(sent, (cause) =>
+			Effect.andThen(
+				Effect.annotateCurrentSpan("changes.published", false),
+				Effect.logError("Changes.publish failed after the changes were committed; the committed result stands", cause),
+			).pipe(Effect.annotateLogs({ channel: name, changes: changes.length })),
+		);
+	}, Effect.uninterruptible);