@shivaedev/reconciler 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## 0.1.0 - 2026-11-03
+
+### Added
+
+- Run scoped background reconciliation at startup, on changes keys or at a reported due time, with merged pending wakes and no polling interval.
+- Supervise failures independently with readable state, typed termination, resume and optional application-owned failure persistence.
+- Run keyed actions once while each key remains present, interrupting removed work and isolating child failures.

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,91 @@
-# Temporary Holding Version
+# @shivaedev/reconciler
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Keep background work in agreement with current data without repeatedly scanning an idle database. A reconciler wakes at startup, when its changes keys are invalidated, or when its next reported deadline arrives. Each has its own scope, readable state and resume operation.
+
+## Wake when there is work
+
+```ts
+const worker = yield* run({
+  keys: [tasks.list],
+  read: pendingTasks,
+  act: reconcileTasks,
+  due: (tasks, now) => nextDeadline(tasks, now),
+});
+```
+
+`run` comes from `@shivaedev/reconciler/run.ts`. The application supplies `tasks`, its read, action and deadline calculation. Changes arriving during an action merge into one pending pass, which reads current state once.
+
+## Using it
+
+### Connect writes and reads
+
+Use the same `collection` keys for your writes and reconciler. Provide native Reactivity to both; Platform's PostgreSQL layer already supplies it. Writes recorded through `changes` and `transact` wake readers after commit. A rollback never wakes them.
+
+```ts
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import { collection } from "@shivaedev/changes/keys.ts";
+import { run } from "@shivaedev/reconciler/run.ts";
+import { changes } from "@shivaedev/sql/changes.ts";
+import { transact } from "@shivaedev/sql/transact.ts";
+
+const tasks = collection("tasks", Schema.Int);
+const application = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const worker = yield* run({
+		keys: [tasks.list],
+		read: sql<{ id: number; title: string }>`select id, title from tasks order by id`,
+		act: (rows) => Effect.logInfo(rows),
+		onFailure: (cause) => sql`insert into worker_failures (cause) values (${String(cause)})`,
+	});
+	yield* Effect.gen(function* () {
+		yield* sql`update tasks set title = 'ready' where id = 1`;
+		yield* changes({ tasks: [tasks.item(1)] }).record();
+	}).pipe(transact({ onSqlError: (error) => error }));
+	return worker;
+});
+```
+
+Run `application` inside the application's lifetime scope with its SQL layer. The application creates its tables and chooses the failure record schema. `onFailure` is optional; no storage service or schema belongs to the engine. The callback runs after the failed generation's scope closes, and a stored record remains after resume.
+
+The subscription is registered before the first read. The engine consumes wakes from a single pending slot and reads only when it consumes one; it has no polling interval. A burst during a pass adds one subsequent pass. Reads and actions retain their typed errors and service requirements.
+
+### Deadlines
+
+`due(value, now)` returns an absolute timestamp in milliseconds or `undefined`. For several deadlines, return the earliest one that needs attention. The calculation runs after the action using that pass's read value and the current clock. Each pass replaces the old timer. A timestamp at or before `now` leaves no timer: the action should already handle that due work. Returning `undefined` removes the timer.
+
+### Supervision
+
+Types `Reconciler`, `State` and `Due` come from `@shivaedev/reconciler/Reconciler.ts`. `run` returns a `Reconciler<E>` with these native Effect values:
+
+| Member    | Meaning                                                                                           |
+| --------- | ------------------------------------------------------------------------------------------------- |
+| `state`   | Native `SubscriptionRef` with `running`, `waiting` and its `nextDue`, or `failed` and its `cause` |
+| `refresh` | Manually enqueue a pass                                                                           |
+| `await`   | Await termination, retaining typed errors and interruption                                        |
+| `resume`  | Start a fresh generation after failure                                                            |
+
+A defect or typed failure stops that reconciler and closes its scope. Other reconcilers continue. Resume starts with a new subscription, pending slot, timer and startup pass. The original service context is retained. Closing the owning scope interrupts the reconciler and removes its timer; interruption does not invoke `onFailure`. There is no automatic retry. If failure recording also fails, the failed state and `await` retain both causes.
+
+### Keyed work
+
+```ts
+import { each } from "@shivaedev/reconciler/each.ts";
+
+const worker = yield* each({
+  keys: [tasks.list],
+  read: pendingTasks,
+  key: (task) => task.id,
+  act: processTask,
+});
+```
+
+`each` starts scoped work for every unclaimed key. A successful action remains claimed while its key stays present, so another wake does not repeat it. Removing a key interrupts its unfinished action and releases its claim; reappearance starts fresh work. A child defect fails the reconciler and closes its sibling actions. The returned handle, optional `due` calculation and `onFailure` callback follow the same lifecycle as `run`. State describes the snapshot pass; keyed actions can remain active while it is waiting.
+
+### Install and limits
+
+```sh
+pnpm add @shivaedev/reconciler effect
+```
+
+Use `@shivaedev/sql` for SQL transaction announcements. Reactivity is process local; cross-process delivery uses the SQL package's existing notification binding. The reconciler provides no durable queue, distributed claim or exactly-once external side effect. Applications choose idempotency and transaction boundaries.

package/dist/PassState.d.ts

@@ -0,0 +1,9 @@
+import { Context, type Effect } from "effect";
+declare const PassState_base: Context.ServiceClass<PassState, "@shivaedev/reconciler/PassState", {
+    readonly running: Effect.Effect<void>;
+    readonly waiting: (nextDue: number | undefined) => Effect.Effect<void>;
+}>;
+export declare class PassState extends PassState_base {
+}
+export {};
+//# sourceMappingURL=PassState.d.ts.map

package/dist/PassState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PassState.d.ts","sourceRoot":"","sources":["../src/PassState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;;sBAK1B,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;sBACnB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;;AAJxE,qBAAa,SAAU,SAAQ,cAMO;CAAG"}

package/dist/PassState.js

@@ -0,0 +1,4 @@
+import { Context } from "effect";
+export class PassState extends Context.Service()("@shivaedev/reconciler/PassState") {
+}
+//# sourceMappingURL=PassState.js.map

package/dist/PassState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PassState.js","sourceRoot":"","sources":["../src/PassState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAe,MAAM,QAAQ,CAAC;AAE9C,MAAM,OAAO,SAAU,SAAQ,OAAO,CAAC,OAAO,EAM3C,CAAC,iCAAiC,CAAC;CAAG"}

package/dist/Reconciler.d.ts

@@ -0,0 +1,18 @@
+import type { Cause, Effect, SubscriptionRef } from "effect";
+export type State<E> = {
+    readonly status: "running";
+} | {
+    readonly status: "waiting";
+    readonly nextDue: number | undefined;
+} | {
+    readonly status: "failed";
+    readonly cause: Cause.Cause<E>;
+};
+export interface Reconciler<E> {
+    readonly await: Effect.Effect<void, E>;
+    readonly refresh: Effect.Effect<void>;
+    readonly resume: Effect.Effect<void>;
+    readonly state: SubscriptionRef.SubscriptionRef<State<E>>;
+}
+export type Due<TValue> = (value: TValue, now: number) => number | undefined;
+//# sourceMappingURL=Reconciler.d.ts.map

package/dist/Reconciler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Reconciler.d.ts","sourceRoot":"","sources":["../src/Reconciler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAE7D,MAAM,MAAM,KAAK,CAAC,CAAC,IAChB;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAA;CAAE,GAC9B;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,GACpE;IAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;CAAE,CAAC;AAEjE,MAAM,WAAW,UAAU,CAAC,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;CAC1D;AAED,MAAM,MAAM,GAAG,CAAC,MAAM,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC"}

package/dist/Reconciler.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Reconciler.js.map

package/dist/Reconciler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Reconciler.js","sourceRoot":"","sources":["../src/Reconciler.ts"],"names":[],"mappings":""}

package/dist/claimRows.d.ts

@@ -0,0 +1,7 @@
+import { Cause, Effect, Fiber } from "effect";
+type Claims<TKey, E> = Map<TKey, {
+    fiber?: Fiber.Fiber<unknown, E>;
+}>;
+export declare const claimRows: <TRow, TKey, E, R>(claims: Claims<TKey, E>, rows: readonly TRow[], keyOf: (row: TRow) => TKey, act: (row: TRow) => Effect.Effect<unknown, E, R>, fail: (cause: Cause.Cause<E>) => Effect.Effect<unknown>) => Effect.Effect<void, never, import("effect/Scope").Scope | Exclude<R, import("effect/Scope").Scope>>;
+export {};
+//# sourceMappingURL=claimRows.d.ts.map

package/dist/claimRows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claimRows.d.ts","sourceRoot":"","sources":["../src/claimRows.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,EAAQ,KAAK,EAAE,MAAM,QAAQ,CAAC;AAEpD,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,GAAG,CAAC,IAAI,EAAE;IAAE,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAA;CAAE,CAAC,CAAC;AActE,eAAO,MAAM,SAAS,GAAgC,IAAI,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,+DAGxD,IAAI,KAAK,IAAI,aACf,IAAI,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC,gBAClC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,wGAsBtD,CAAC"}

package/dist/claimRows.js

@@ -0,0 +1,31 @@
+import { Cause, Effect, Exit, Fiber } from "effect";
+const releaseAbsent = Effect.fnUntraced(function* (claims, matching) {
+    for (const [key, claim] of claims) {
+        if (matching.has(key)) {
+            continue;
+        }
+        claims.delete(key);
+        if (claim.fiber !== undefined) {
+            yield* Fiber.interrupt(claim.fiber);
+        }
+    }
+});
+export const claimRows = Effect.fnUntraced(function* (claims, rows, keyOf, act, fail) {
+    yield* releaseAbsent(claims, new Set(rows.map(keyOf)));
+    for (const row of rows) {
+        const key = keyOf(row);
+        if (claims.has(key)) {
+            continue;
+        }
+        const claim = {};
+        claims.set(key, claim);
+        claim.fiber = yield* Effect.forkScoped(Effect.scoped(Effect.suspend(() => act(row))).pipe(Effect.onExit((exit) => {
+            if (Exit.isSuccess(exit)) {
+                return Effect.void;
+            }
+            claims.delete(key);
+            return Cause.hasInterruptsOnly(exit.cause) ? Effect.void : fail(exit.cause);
+        })));
+    }
+});
+//# sourceMappingURL=claimRows.js.map

package/dist/claimRows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claimRows.js","sourceRoot":"","sources":["../src/claimRows.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAIpD,MAAM,aAAa,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAW,MAAuB,EAAE,QAA2B;IAC/G,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,EAAE,CAAC;QACnC,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACvB,SAAS;QACV,CAAC;QACD,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACnB,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YAC/B,KAAK,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACrC,CAAC;IACF,CAAC;AACF,CAAC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EACnD,MAAuB,EACvB,IAAqB,EACrB,KAA0B,EAC1B,GAAgD,EAChD,IAAuD;IAEvD,KAAK,CAAC,CAAC,aAAa,CAAC,MAAM,EAAE,IAAI,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACvD,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACxB,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;QACvB,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACrB,SAAS;QACV,CAAC;QACD,MAAM,KAAK,GAAwC,EAAE,CAAC;QACtD,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACvB,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,UAAU,CACrC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CACjD,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;YACtB,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC1B,OAAO,MAAM,CAAC,IAAI,CAAC;YACpB,CAAC;YACD,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACnB,OAAO,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC7E,CAAC,CAAC,CACF,CACD,CAAC;IACH,CAAC;AACF,CAAC,CAAC,CAAC"}

package/dist/each.d.ts

@@ -0,0 +1,10 @@
+import { Effect, type Scope } from "effect";
+import type * as Reactivity from "effect/reactivity/Reactivity";
+import type { Reconciler } from "#Reconciler.ts";
+import type { Options } from "#run.ts";
+export interface EachOptions<TRow, TKey, TReadError, TReadServices, TActError, TActServices, TRecordError = never, TRecordServices = never> extends Omit<Options<readonly TRow[], TReadError, TReadServices, TActError, TActServices, TRecordError, TRecordServices>, "act"> {
+    readonly act: (row: TRow) => Effect.Effect<unknown, TActError, TActServices>;
+    readonly key: (row: TRow) => TKey;
+}
+export declare function each<TRow, TKey, TReadError, TReadServices, TActError, TActServices, TRecordError = never, TRecordServices = never>(options: EachOptions<TRow, TKey, TReadError, TReadServices, TActError, TActServices, TRecordError, TRecordServices>): Effect.Effect<Reconciler<TReadError | TActError | TRecordError>, never, TReadServices | TActServices | TRecordServices | Reactivity.Reactivity | Scope.Scope>;
+//# sourceMappingURL=each.d.ts.map

package/dist/each.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"each.d.ts","sourceRoot":"","sources":["../src/each.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAc,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAC;AACxD,OAAO,KAAK,KAAK,UAAU,MAAM,8BAA8B,CAAC;AAEhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAIvC,MAAM,WAAW,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,GAAG,KAAK,EAAE,eAAe,GAAG,KAAK,CACzI,SAAQ,IAAI,CAAC,OAAO,CAAC,SAAS,IAAI,EAAE,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,CAAC,EAAE,KAAK,CAAC;IAChI,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;IAC7E,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,IAAI,CAAC;CAClC;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,GAAG,KAAK,EAAE,eAAe,GAAG,KAAK,EACjI,OAAO,EAAE,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,CAAC,GACjH,MAAM,CAAC,MAAM,CACf,UAAU,CAAC,UAAU,GAAG,SAAS,GAAG,YAAY,CAAC,EACjD,KAAK,EACL,aAAa,GAAG,YAAY,GAAG,eAAe,GAAG,UAAU,CAAC,UAAU,GAAG,KAAK,CAAC,KAAK,CACpF,CAeA"}

package/dist/each.js

@@ -0,0 +1,14 @@
+import { Effect } from "effect";
+import { claimRows } from "#claimRows.ts";
+import { supervise } from "#supervise.ts";
+import { watch } from "#watch.ts";
+export function each(options) {
+    return supervise((pending) => Effect.gen(function* () {
+        const claims = new Map();
+        return yield* watch({
+            ...options,
+            act: (rows, fail) => claimRows(claims, rows, options.key, options.act, fail),
+        }, pending);
+    }), options);
+}
+//# sourceMappingURL=each.js.map

package/dist/each.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"each.js","sourceRoot":"","sources":["../src/each.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAA0B,MAAM,QAAQ,CAAC;AAExD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG1C,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAQlC,MAAM,UAAU,IAAI,CACnB,OAAmH;IAMnH,OAAO,SAAS,CACf,CAAC,OAAO,EAAE,EAAE,CACX,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QACnB,MAAM,MAAM,GAAG,IAAI,GAAG,EAAqD,CAAC;QAC5E,OAAO,KAAK,CAAC,CAAC,KAAK,CAClB;YACC,GAAG,OAAO;YACV,GAAG,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC;SAC5E,EACD,OAAO,CACP,CAAC;IACH,CAAC,CAAC,EACH,OAAO,CACP,CAAC;AACH,CAAC"}

package/dist/run.d.ts

@@ -0,0 +1,13 @@
+import type { Effect, Scope } from "effect";
+import type * as Reactivity from "effect/reactivity/Reactivity";
+import type { Key } from "@shivaedev/changes/keys.ts";
+import type { Due, Reconciler } from "#Reconciler.ts";
+import { type FailureHandler } from "#supervise.ts";
+export interface Options<TValue, TReadError, TReadServices, TActError, TActServices, TRecordError = never, TRecordServices = never> extends FailureHandler<TReadError | TActError, TRecordError, TRecordServices> {
+    readonly act: (value: TValue) => Effect.Effect<unknown, TActError, TActServices>;
+    readonly due?: Due<TValue>;
+    readonly keys: readonly Key[];
+    readonly read: Effect.Effect<TValue, TReadError, TReadServices>;
+}
+export declare function run<TValue, TReadError, TReadServices, TActError, TActServices, TRecordError = never, TRecordServices = never>(options: Options<TValue, TReadError, TReadServices, TActError, TActServices, TRecordError, TRecordServices>): Effect.Effect<Reconciler<TReadError | TActError | TRecordError>, never, TReadServices | TActServices | TRecordServices | Reactivity.Reactivity | Scope.Scope>;
+//# sourceMappingURL=run.d.ts.map

package/dist/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,KAAK,KAAK,UAAU,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,4BAA4B,CAAC;AACtD,OAAO,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,KAAK,cAAc,EAAa,MAAM,eAAe,CAAC;AAG/D,MAAM,WAAW,OAAO,CAAC,MAAM,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,GAAG,KAAK,EAAE,eAAe,GAAG,KAAK,CACjI,SAAQ,cAAc,CAAC,UAAU,GAAG,SAAS,EAAE,YAAY,EAAE,eAAe,CAAC;IAC7E,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;IACjF,QAAQ,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,EAAE,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,aAAa,CAAC,CAAC;CAChE;AAED,wBAAgB,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,GAAG,KAAK,EAAE,eAAe,GAAG,KAAK,EAC5H,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,CAAC,GACzG,MAAM,CAAC,MAAM,CACf,UAAU,CAAC,UAAU,GAAG,SAAS,GAAG,YAAY,CAAC,EACjD,KAAK,EACL,aAAa,GAAG,YAAY,GAAG,eAAe,GAAG,UAAU,CAAC,UAAU,GAAG,KAAK,CAAC,KAAK,CACpF,CAEA"}

package/dist/run.js

@@ -0,0 +1,6 @@
+import { supervise } from "#supervise.ts";
+import { watch } from "#watch.ts";
+export function run(options) {
+    return supervise((pending) => watch(options, pending), options);
+}
+//# sourceMappingURL=run.js.map

package/dist/run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.js","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AAIA,OAAO,EAAuB,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAUlC,MAAM,UAAU,GAAG,CAClB,OAA2G;IAM3G,OAAO,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,KAAK,CAA+D,OAAO,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;AAC/H,CAAC"}

package/dist/supervise.d.ts

@@ -0,0 +1,8 @@
+import { Cause, Effect, Queue, type Scope } from "effect";
+import { PassState } from "#PassState.ts";
+import type { Reconciler } from "#Reconciler.ts";
+export interface FailureHandler<E, TRecordError, TRecordServices> {
+    readonly onFailure?: (cause: Cause.Cause<E>) => Effect.Effect<unknown, TRecordError, TRecordServices>;
+}
+export declare const supervise: <E, R, TRecordError = never, TRecordServices = never>(open: (pending: Queue.Queue<void>) => Effect.Effect<never, E, R | Scope.Scope | PassState>, options: FailureHandler<E, TRecordError, TRecordServices>) => Effect.Effect<Reconciler<E | TRecordError>, never, R | TRecordServices | Scope.Scope>;
+//# sourceMappingURL=supervise.d.ts.map

package/dist/supervise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervise.d.ts","sourceRoot":"","sources":["../src/supervise.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAY,MAAM,EAAQ,KAAK,EAAE,KAAK,KAAK,EAA8B,MAAM,QAAQ,CAAC;AACtG,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,UAAU,EAAS,MAAM,gBAAgB,CAAC;AAExD,MAAM,WAAW,cAAc,CAAC,CAAC,EAAE,YAAY,EAAE,eAAe;IAC/D,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,YAAY,EAAE,eAAe,CAAC,CAAC;CACtG;AAED,eAAO,MAAM,SAAS,GAAgC,CAAC,EAAE,CAAC,EAAE,YAAY,UAAU,eAAe,0BAChF,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,KAAK,GAAG,SAAS,CAAC,qJAwDzF,CAAC"}

package/dist/supervise.js

@@ -0,0 +1,45 @@
+import { Cause, Deferred, Effect, Exit, Queue, Semaphore, SubscriptionRef } from "effect";
+import { PassState } from "#PassState.ts";
+export const supervise = Effect.fnUntraced(function* (open, options) {
+    const lifetime = yield* Effect.scope;
+    const context = yield* Effect.context();
+    const state = yield* SubscriptionRef.make({ status: "running" });
+    const lock = yield* Semaphore.make(1);
+    let completion = yield* Deferred.make();
+    let refresh = Effect.void;
+    const launch = Effect.uninterruptible(Effect.gen(function* () {
+        const pending = yield* Queue.sliding(1);
+        refresh = Queue.offer(pending, undefined).pipe(Effect.asVoid);
+        const finished = yield* Deferred.make();
+        completion = finished;
+        yield* SubscriptionRef.set(state, { status: "running" });
+        const work = Effect.gen(function* () {
+            const opening = open(pending).pipe(Effect.provideService(PassState, {
+                running: SubscriptionRef.set(state, { status: "running" }),
+                waiting: (nextDue) => SubscriptionRef.set(state, { nextDue, status: "waiting" }),
+            }));
+            const exit = yield* Effect.exit(Effect.scoped(opening));
+            if (Exit.isSuccess(exit) || Cause.hasInterruptsOnly(exit.cause)) {
+                return yield* Deferred.done(finished, exit);
+            }
+            const recorded = yield* Effect.exit(Effect.suspend(() => options.onFailure?.(exit.cause) ?? Effect.void));
+            const cause = Exit.isFailure(recorded) ? Cause.combine(exit.cause, recorded.cause) : exit.cause;
+            yield* SubscriptionRef.set(state, { cause, status: "failed" });
+            return yield* Deferred.failCause(finished, cause);
+        });
+        yield* Effect.forkIn(work.pipe(Effect.asVoid, Effect.onExit((exit) => Deferred.done(finished, exit)), Effect.provideContext(context)), lifetime);
+    }));
+    yield* launch;
+    return {
+        await: Effect.suspend(() => Deferred.await(completion)),
+        refresh: Effect.suspend(() => refresh),
+        resume: Semaphore.withPermit(lock)(Effect.gen(function* () {
+            const current = yield* SubscriptionRef.get(state);
+            if (current.status === "failed") {
+                yield* launch;
+            }
+        })),
+        state,
+    };
+});
+//# sourceMappingURL=supervise.js.map

package/dist/supervise.js.map

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

package/dist/watch.d.ts

@@ -0,0 +1,13 @@
+import { type Cause, Effect, Queue, type Scope } from "effect";
+import * as Reactivity from "effect/reactivity/Reactivity";
+import { type Key } from "@shivaedev/changes/keys.ts";
+import { PassState } from "#PassState.ts";
+import type { Due } from "#Reconciler.ts";
+export interface Work<TValue, E, R> {
+    readonly act: (value: TValue, fail: (cause: Cause.Cause<E>) => Effect.Effect<unknown>) => Effect.Effect<unknown, E, R>;
+    readonly due?: Due<TValue>;
+    readonly keys: readonly Key[];
+    readonly read: Effect.Effect<TValue, E, R>;
+}
+export declare const watch: <TValue, E, R>(work: Work<TValue, E, R>, pending: Queue.Queue<void, never>) => Effect.Effect<never, E, R | PassState | Reactivity.Reactivity | Scope.Scope>;
+//# sourceMappingURL=watch.d.ts.map

package/dist/watch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../src/watch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAmB,MAAM,EAAe,KAAK,EAAE,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC7F,OAAO,KAAK,UAAU,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAE,KAAK,GAAG,EAAY,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAE1C,MAAM,WAAW,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC;IACjC,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IACvH,QAAQ,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,EAAE,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAC3C;AAED,eAAO,MAAM,KAAK,GAAgC,MAAM,EAAE,CAAC,EAAE,CAAC,8IA8B5D,CAAC"}

package/dist/watch.js

@@ -0,0 +1,28 @@
+import { Clock, Deferred, Effect, FiberHandle, Queue } from "effect";
+import * as Reactivity from "effect/reactivity/Reactivity";
+import { readKeys } from "@shivaedev/changes/keys.ts";
+import { PassState } from "#PassState.ts";
+export const watch = Effect.fnUntraced(function* (work, pending) {
+    const state = yield* PassState;
+    const reactivity = yield* Reactivity.Reactivity;
+    const failed = yield* Deferred.make();
+    const timer = yield* FiberHandle.make();
+    yield* Effect.acquireRelease(Effect.sync(() => reactivity.registerUnsafe(readKeys(work.keys), () => Queue.offerUnsafe(pending, undefined))), (release) => Effect.sync(release));
+    yield* Queue.offer(pending, undefined);
+    const consume = Effect.forever(Effect.gen(function* () {
+        yield* Queue.take(pending);
+        yield* FiberHandle.clear(timer);
+        yield* state.running;
+        const value = yield* work.read;
+        yield* work.act(value, (cause) => Deferred.failCause(failed, cause));
+        const now = yield* Clock.currentTimeMillis;
+        const reported = work.due?.(value, now);
+        const nextDue = reported !== undefined && reported > now ? reported : undefined;
+        if (nextDue !== undefined) {
+            yield* FiberHandle.run(timer, Effect.andThen(Effect.sleep(nextDue - now), Queue.offer(pending, undefined)).pipe(Effect.asVoid));
+        }
+        yield* state.waiting(nextDue);
+    }));
+    return yield* Effect.raceFirst(consume, Deferred.await(failed));
+});
+//# sourceMappingURL=watch.js.map

package/dist/watch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch.js","sourceRoot":"","sources":["../src/watch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,EAAc,MAAM,QAAQ,CAAC;AAC7F,OAAO,KAAK,UAAU,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAY,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAU1C,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAC/C,IAAwB,EACxB,OAA0B;IAE1B,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,SAAS,CAAC;IAC/B,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC;IAChD,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAY,CAAC;IAChD,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,WAAW,CAAC,IAAI,EAAQ,CAAC;IAC9C,KAAK,CAAC,CAAC,MAAM,CAAC,cAAc,CAC3B,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,WAAW,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,EAC9G,CAAC,OAAO,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CACjC,CAAC;IACF,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IACvC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAC7B,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QACnB,KAAK,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC3B,KAAK,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAChC,KAAK,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC;QACrB,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;QAC/B,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;QACrE,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC;QAC3C,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QACxC,MAAM,OAAO,GAAG,QAAQ,KAAK,SAAS,IAAI,QAAQ,GAAG,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;QAChF,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC3B,KAAK,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,GAAG,GAAG,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;QACjI,CAAC;QACD,KAAK,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAC/B,CAAC,CAAC,CACF,CAAC;IACF,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;AACjE,CAAC,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,74 @@
 {
   "name": "@shivaedev/reconciler",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Change-driven background reconciliation with scoped supervision for Effect applications",
+  "keywords": [
+    "effect"
+  ],
+  "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/reconciler#readme",
+  "bugs": {
+    "url": "https://github.com/ShivaeDev/platform/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ShivaeDev/platform.git",
+    "directory": "packages/reconciler"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "imports": {
+    "#test/*": "./src/test-support/*",
+    "#*.ts": {
+      "source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "exports": {
+    "./*.ts": {
+      "source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/test-support",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "dependencies": {
+    "@shivaedev/changes": "0.9.0"
+  },
+  "devDependencies": {
+    "@shivaedev/quality": "0.57.1",
+    "@shivaedev/sql": "0.35.0",
+    "@shivaedev/test-sql": "0.18.0",
+    "@shivaedev/test-story": "0.36.0",
+    "@types/node": "24.19.2",
+    "effect": "4.0.6",
+    "typescript": "7.0.2",
+    "vitest": "5.0.5"
+  },
+  "peerDependencies": {
+    "effect": "4.0.6"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc --project tsconfig.build.json",
+    "ready": "pnpm typecheck && pnpm test && pnpm build",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
 }

package/src/PassState.ts

@@ -0,0 +1,9 @@
+import { Context, type Effect } from "effect";
+
+export class PassState extends Context.Service<
+	PassState,
+	{
+		readonly running: Effect.Effect<void>;
+		readonly waiting: (nextDue: number | undefined) => Effect.Effect<void>;
+	}
+>()("@shivaedev/reconciler/PassState") {}

package/src/Reconciler.ts

@@ -0,0 +1,15 @@
+import type { Cause, Effect, SubscriptionRef } from "effect";
+
+export type State<E> =
+	| { readonly status: "running" }
+	| { readonly status: "waiting"; readonly nextDue: number | undefined }
+	| { readonly status: "failed"; readonly cause: Cause.Cause<E> };
+
+export interface Reconciler<E> {
+	readonly await: Effect.Effect<void, E>;
+	readonly refresh: Effect.Effect<void>;
+	readonly resume: Effect.Effect<void>;
+	readonly state: SubscriptionRef.SubscriptionRef<State<E>>;
+}
+
+export type Due<TValue> = (value: TValue, now: number) => number | undefined;

package/src/claimRows.ts

@@ -0,0 +1,44 @@
+import { Cause, Effect, Exit, Fiber } from "effect";
+
+type Claims<TKey, E> = Map<TKey, { fiber?: Fiber.Fiber<unknown, E> }>;
+
+const releaseAbsent = Effect.fnUntraced(function* <TKey, E>(claims: Claims<TKey, E>, matching: ReadonlySet<TKey>) {
+	for (const [key, claim] of claims) {
+		if (matching.has(key)) {
+			continue;
+		}
+		claims.delete(key);
+		if (claim.fiber !== undefined) {
+			yield* Fiber.interrupt(claim.fiber);
+		}
+	}
+});
+
+export const claimRows = Effect.fnUntraced(function* <TRow, TKey, E, R>(
+	claims: Claims<TKey, E>,
+	rows: readonly TRow[],
+	keyOf: (row: TRow) => TKey,
+	act: (row: TRow) => Effect.Effect<unknown, E, R>,
+	fail: (cause: Cause.Cause<E>) => Effect.Effect<unknown>,
+) {
+	yield* releaseAbsent(claims, new Set(rows.map(keyOf)));
+	for (const row of rows) {
+		const key = keyOf(row);
+		if (claims.has(key)) {
+			continue;
+		}
+		const claim: { fiber?: Fiber.Fiber<unknown, E> } = {};
+		claims.set(key, claim);
+		claim.fiber = yield* Effect.forkScoped(
+			Effect.scoped(Effect.suspend(() => act(row))).pipe(
+				Effect.onExit((exit) => {
+					if (Exit.isSuccess(exit)) {
+						return Effect.void;
+					}
+					claims.delete(key);
+					return Cause.hasInterruptsOnly(exit.cause) ? Effect.void : fail(exit.cause);
+				}),
+			),
+		);
+	}
+});

package/src/each.ts

@@ -0,0 +1,36 @@
+import { Effect, type Fiber, type Scope } from "effect";
+import type * as Reactivity from "effect/reactivity/Reactivity";
+import { claimRows } from "#claimRows.ts";
+import type { Reconciler } from "#Reconciler.ts";
+import type { Options } from "#run.ts";
+import { supervise } from "#supervise.ts";
+import { watch } from "#watch.ts";
+
+export interface EachOptions<TRow, TKey, TReadError, TReadServices, TActError, TActServices, TRecordError = never, TRecordServices = never>
+	extends Omit<Options<readonly TRow[], TReadError, TReadServices, TActError, TActServices, TRecordError, TRecordServices>, "act"> {
+	readonly act: (row: TRow) => Effect.Effect<unknown, TActError, TActServices>;
+	readonly key: (row: TRow) => TKey;
+}
+
+export function each<TRow, TKey, TReadError, TReadServices, TActError, TActServices, TRecordError = never, TRecordServices = never>(
+	options: EachOptions<TRow, TKey, TReadError, TReadServices, TActError, TActServices, TRecordError, TRecordServices>,
+): Effect.Effect<
+	Reconciler<TReadError | TActError | TRecordError>,
+	never,
+	TReadServices | TActServices | TRecordServices | Reactivity.Reactivity | Scope.Scope
+> {
+	return supervise(
+		(pending) =>
+			Effect.gen(function* () {
+				const claims = new Map<TKey, { fiber?: Fiber.Fiber<unknown, TActError> }>();
+				return yield* watch<readonly TRow[], TReadError | TActError, TReadServices | TActServices | Scope.Scope>(
+					{
+						...options,
+						act: (rows, fail) => claimRows(claims, rows, options.key, options.act, fail),
+					},
+					pending,
+				);
+			}),
+		options,
+	);
+}

package/src/run.ts

@@ -0,0 +1,24 @@
+import type { Effect, Scope } from "effect";
+import type * as Reactivity from "effect/reactivity/Reactivity";
+import type { Key } from "@shivaedev/changes/keys.ts";
+import type { Due, Reconciler } from "#Reconciler.ts";
+import { type FailureHandler, supervise } from "#supervise.ts";
+import { watch } from "#watch.ts";
+
+export interface Options<TValue, TReadError, TReadServices, TActError, TActServices, TRecordError = never, TRecordServices = never>
+	extends FailureHandler<TReadError | TActError, TRecordError, TRecordServices> {
+	readonly act: (value: TValue) => Effect.Effect<unknown, TActError, TActServices>;
+	readonly due?: Due<TValue>;
+	readonly keys: readonly Key[];
+	readonly read: Effect.Effect<TValue, TReadError, TReadServices>;
+}
+
+export function run<TValue, TReadError, TReadServices, TActError, TActServices, TRecordError = never, TRecordServices = never>(
+	options: Options<TValue, TReadError, TReadServices, TActError, TActServices, TRecordError, TRecordServices>,
+): Effect.Effect<
+	Reconciler<TReadError | TActError | TRecordError>,
+	never,
+	TReadServices | TActServices | TRecordServices | Reactivity.Reactivity | Scope.Scope
+> {
+	return supervise((pending) => watch<TValue, TReadError | TActError, TReadServices | TActServices>(options, pending), options);
+}

package/src/supervise.ts

@@ -0,0 +1,66 @@
+import { Cause, Deferred, Effect, Exit, Queue, type Scope, Semaphore, SubscriptionRef } from "effect";
+import { PassState } from "#PassState.ts";
+import type { Reconciler, State } from "#Reconciler.ts";
+
+export interface FailureHandler<E, TRecordError, TRecordServices> {
+	readonly onFailure?: (cause: Cause.Cause<E>) => Effect.Effect<unknown, TRecordError, TRecordServices>;
+}
+
+export const supervise = Effect.fnUntraced(function* <E, R, TRecordError = never, TRecordServices = never>(
+	open: (pending: Queue.Queue<void>) => Effect.Effect<never, E, R | Scope.Scope | PassState>,
+	options: FailureHandler<E, TRecordError, TRecordServices>,
+): Effect.fn.Return<Reconciler<E | TRecordError>, never, R | TRecordServices | Scope.Scope> {
+	const lifetime = yield* Effect.scope;
+	const context = yield* Effect.context<R | TRecordServices>();
+	const state = yield* SubscriptionRef.make<State<E | TRecordError>>({ status: "running" });
+	const lock = yield* Semaphore.make(1);
+	let completion = yield* Deferred.make<void, E | TRecordError>();
+	let refresh: Effect.Effect<void> = Effect.void;
+	const launch = Effect.uninterruptible(
+		Effect.gen(function* () {
+			const pending = yield* Queue.sliding<void>(1);
+			refresh = Queue.offer(pending, undefined).pipe(Effect.asVoid);
+			const finished = yield* Deferred.make<void, E | TRecordError>();
+			completion = finished;
+			yield* SubscriptionRef.set(state, { status: "running" });
+			const work = Effect.gen(function* () {
+				const opening = open(pending).pipe(
+					Effect.provideService(PassState, {
+						running: SubscriptionRef.set(state, { status: "running" }),
+						waiting: (nextDue) => SubscriptionRef.set(state, { nextDue, status: "waiting" }),
+					}),
+				);
+				const exit = yield* Effect.exit(Effect.scoped(opening));
+				if (Exit.isSuccess(exit) || Cause.hasInterruptsOnly(exit.cause)) {
+					return yield* Deferred.done(finished, exit);
+				}
+				const recorded = yield* Effect.exit(Effect.suspend(() => options.onFailure?.(exit.cause) ?? Effect.void));
+				const cause = Exit.isFailure(recorded) ? Cause.combine(exit.cause, recorded.cause) : exit.cause;
+				yield* SubscriptionRef.set(state, { cause, status: "failed" });
+				return yield* Deferred.failCause(finished, cause);
+			});
+			yield* Effect.forkIn(
+				work.pipe(
+					Effect.asVoid,
+					Effect.onExit((exit) => Deferred.done(finished, exit)),
+					Effect.provideContext(context),
+				),
+				lifetime,
+			);
+		}),
+	);
+	yield* launch;
+	return {
+		await: Effect.suspend(() => Deferred.await(completion)),
+		refresh: Effect.suspend(() => refresh),
+		resume: Semaphore.withPermit(lock)(
+			Effect.gen(function* () {
+				const current = yield* SubscriptionRef.get(state);
+				if (current.status === "failed") {
+					yield* launch;
+				}
+			}),
+		),
+		state,
+	};
+});

package/src/watch.ts

@@ -0,0 +1,44 @@
+import { type Cause, Clock, Deferred, Effect, FiberHandle, Queue, type Scope } from "effect";
+import * as Reactivity from "effect/reactivity/Reactivity";
+import { type Key, readKeys } from "@shivaedev/changes/keys.ts";
+import { PassState } from "#PassState.ts";
+import type { Due } from "#Reconciler.ts";
+
+export interface Work<TValue, E, R> {
+	readonly act: (value: TValue, fail: (cause: Cause.Cause<E>) => Effect.Effect<unknown>) => Effect.Effect<unknown, E, R>;
+	readonly due?: Due<TValue>;
+	readonly keys: readonly Key[];
+	readonly read: Effect.Effect<TValue, E, R>;
+}
+
+export const watch = Effect.fnUntraced(function* <TValue, E, R>(
+	work: Work<TValue, E, R>,
+	pending: Queue.Queue<void>,
+): Effect.fn.Return<never, E, R | Reactivity.Reactivity | Scope.Scope | PassState> {
+	const state = yield* PassState;
+	const reactivity = yield* Reactivity.Reactivity;
+	const failed = yield* Deferred.make<never, E>();
+	const timer = yield* FiberHandle.make<void>();
+	yield* Effect.acquireRelease(
+		Effect.sync(() => reactivity.registerUnsafe(readKeys(work.keys), () => Queue.offerUnsafe(pending, undefined))),
+		(release) => Effect.sync(release),
+	);
+	yield* Queue.offer(pending, undefined);
+	const consume = Effect.forever(
+		Effect.gen(function* () {
+			yield* Queue.take(pending);
+			yield* FiberHandle.clear(timer);
+			yield* state.running;
+			const value = yield* work.read;
+			yield* work.act(value, (cause) => Deferred.failCause(failed, cause));
+			const now = yield* Clock.currentTimeMillis;
+			const reported = work.due?.(value, now);
+			const nextDue = reported !== undefined && reported > now ? reported : undefined;
+			if (nextDue !== undefined) {
+				yield* FiberHandle.run(timer, Effect.andThen(Effect.sleep(nextDue - now), Queue.offer(pending, undefined)).pipe(Effect.asVoid));
+			}
+			yield* state.waiting(nextDue);
+		}),
+	);
+	return yield* Effect.raceFirst(consume, Deferred.await(failed));
+});