@rikalabs/akter 0.1.0-alpha.0

package/dist/testing/conformance/subscriptions/operator.js

@@ -0,0 +1,128 @@
+import { Effect, Exit, Option } from "effect";
+import { OperatorRuntime } from "../../../runtime/operators/repair.js";
+import { ActorTest } from "../../actor-test.js";
+import { SubFollower, SubOrder } from "./actors.js";
+import { drain, followerLog, query, run, sourceRows } from "./harness.js";
+/** Operator skip and listing of stuck subscription rows. */
+export const subscriptionOperatorConformance = [
+    {
+        name: "skips a stuck row's events through a cursor for an operator, records the skip, and delivers a marker for the range",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const operators = yield* OperatorRuntime;
+            const follower = yield* SubFollower.get("skip-follower");
+            yield* follower.Follow({ source: "skip-a" });
+            yield* drain;
+            fixture.behave = (entry) => (entry.includes("/skip-a#2:") ? "defect" : "apply");
+            yield* (yield* SubOrder.get("skip-a")).PlaceMany({ customerId: "s", count: 3 });
+            yield* drain;
+            const [stuck] = yield* sourceRows("skip-a");
+            expect(stuck).toMatchObject({ delivered: "1", attempts: 1 });
+            const skipped = yield* operators
+                .skip({
+                target: { tenant: test.tenant, actorType: "SubOrder", actorId: "skip-a" },
+                subscriberType: "SubFollower",
+                subscription: "FollowedOrders",
+                subscriberId: "skip-follower",
+                through: "2",
+                audit: {
+                    operator: "oncall",
+                    action: "subscriptions.skip",
+                    tenant: test.tenant,
+                    actorType: "SubOrder",
+                    actorId: "skip-a",
+                    target: "SubFollower.FollowedOrders/skip-follower",
+                    capability: Option.none(),
+                    reason: "bad payload",
+                },
+            })
+                .pipe(Effect.exit);
+            expect(Exit.isSuccess(skipped)).toBe(true);
+            fixture.behave = () => "apply";
+            yield* drain;
+            expect(yield* followerLog("skip-follower")).toEqual([
+                "skip-a#1:OrderPlaced",
+                "skip-a~gap:1-2",
+                "skip-a#3:OrderPlaced",
+            ]);
+            expect(yield* sourceRows("skip-a")).toMatchObject([
+                { delivered: "3", attempts: 0, last_error: null },
+            ]);
+            const audit = yield* query((sql) => sql `
+              SELECT action, reason, outcome FROM durable.operator_audit
+              WHERE tenant_id = ${test.tenant} AND actor_id = 'skip-a'`);
+            expect(audit.length).toBe(1);
+            expect(audit[0]).toMatchObject({ action: "subscriptions.skip", reason: "bad payload" });
+            expect(audit[0].outcome).toContain('"after":"1"');
+            expect(audit[0].outcome).toContain('"through":"2"');
+            const again = yield* operators
+                .skip({
+                target: { tenant: test.tenant, actorType: "SubOrder", actorId: "skip-a" },
+                subscriberType: "SubFollower",
+                subscription: "FollowedOrders",
+                subscriberId: "skip-follower",
+                through: "3",
+                audit: {
+                    operator: "oncall",
+                    action: "subscriptions.skip",
+                    tenant: test.tenant,
+                    capability: Option.none(),
+                },
+            })
+                .pipe(Effect.exit);
+            expect(Exit.isFailure(again)).toBe(true);
+        })),
+    },
+    {
+        name: "lists a failing row with its lag and last error for an operator, and drops it once skipped",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const operators = yield* OperatorRuntime;
+            const follower = yield* SubFollower.get("lag-follower");
+            yield* follower.Follow({ source: "lag-a" });
+            yield* follower.Follow({ source: "lag-b" });
+            yield* drain;
+            fixture.behave = (entry) => (entry.includes("/lag-a#2:") ? "defect" : "apply");
+            yield* (yield* SubOrder.get("lag-a")).PlaceMany({ customerId: "l", count: 3 });
+            yield* (yield* SubOrder.get("lag-b")).PlaceMany({ customerId: "l", count: 3 });
+            yield* drain;
+            const page = { tenant: test.tenant, minAttempts: 1, limit: 100 };
+            /** Other cases in this file leave their own rows behind in the tenant. */
+            const lagging = (input) => Effect.map(operators.lagging(input), (rows) => rows.filter((row) => row.sourceId.startsWith("lag-")));
+            const failing = yield* lagging(page);
+            expect(new Set(failing.map((entry) => entry.sourceId))).toEqual(new Set(["lag-a"]));
+            const row = failing.find((entry) => entry.subscriberType === "SubFollower");
+            expect(row).toMatchObject({
+                sourceType: "SubOrder",
+                sourceId: "lag-a",
+                subscriberId: "lag-follower",
+                delivered: "1",
+                head: "3",
+                lag: "2",
+                attempts: 1,
+            });
+            expect(row.lastError).toContain("lag-a#2");
+            expect(yield* lagging({ ...page, minAttempts: 8 })).toEqual([]);
+            expect(yield* lagging({ ...page, tenant: `${test.tenant}-other` })).toEqual([]);
+            yield* operators.skip({
+                target: { tenant: test.tenant, actorType: "SubOrder", actorId: "lag-a" },
+                subscriberType: "SubFollower",
+                subscription: "FollowedOrders",
+                subscriberId: "lag-follower",
+                through: "2",
+                audit: {
+                    operator: "oncall",
+                    action: "subscriptions.skip",
+                    tenant: test.tenant,
+                    capability: Option.none(),
+                    reason: "bad payload",
+                },
+            });
+            fixture.behave = () => "apply";
+            yield* drain;
+            const remaining = (yield* lagging(page)).map((entry) => entry.subscriberType);
+            expect(remaining.length).toBe(failing.length - 1);
+            expect(remaining).not.toContain("SubFollower");
+        })),
+    },
+];

package/dist/testing/conformance/subscriptions/retention.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceCase } from "../../conformance.ts";
+import { type SubscriptionsFixture } from "./actors.ts";
+/** Wake, retention holds, gaps, broadcasts, and workflow waits. */
+export declare const subscriptionsRetentionConformance: ReadonlyArray<ConformanceCase<SubscriptionsFixture>>;

package/dist/testing/conformance/subscriptions/retention.js

@@ -0,0 +1,288 @@
+import { Effect, Fiber, Schema, Stream } from "effect";
+import { ActorTest } from "../../actor-test.js";
+import { CLAIM_LEASE } from "../outbox.js";
+import { Live, ShipOrder, SubFollower, SubJournal, SubOrder, SubShipment, } from "./actors.js";
+import { crashOnce, drain, followerLog, logOf, LogState, pauseOnce, query, run, sourceRows, subscriber, tagMismatches, } from "./harness.js";
+import { Tenant } from "../../../index.js";
+const journalRow = (source, subscriberType) => Effect.gen(function* () {
+    const test = yield* ActorTest;
+    return (yield* query((sql) => sql `
+        SELECT delivered::text AS delivered, gaps::text AS gaps, gap_through::text AS gap_through
+        FROM actor_subscriptions WHERE tenant_id = ${test.tenant} AND source_type = 'SubJournal'
+          AND source_id = ${source} AND subscriber_type = ${subscriberType}`))[0];
+});
+const journalEvents = (source) => ActorTest.use((test) => test
+    .inspect({ tenant: test.tenant, actor: "SubJournal", id: source })
+    .pipe(Effect.map((inspection) => inspection.events)));
+/** Wake, retention holds, gaps, broadcasts, and workflow waits. */
+export const subscriptionsRetentionConformance = [
+    {
+        name: "keeps events above the lowest subscriber cursor inside the hold, then prunes past it and delivers one RetentionGap, then resumes",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const journal = yield* SubJournal.get("hold-j");
+            yield* (yield* SubFollower.get("hold-f")).FollowJournal({ source: "hold-j" });
+            yield* drain;
+            fixture.behave = (entry) => (entry.startsWith("SubFollower/hold-f/") ? "defect" : "apply");
+            yield* journal.Record({ customerId: "hold-c", count: 3 });
+            yield* drain;
+            yield* test.advance("90 minutes");
+            yield* test.cleanup;
+            expect(yield* journalEvents("hold-j")).toBe(3);
+            yield* test.advance("40 minutes");
+            yield* test.cleanup;
+            expect(yield* journalEvents("hold-j")).toBe(0);
+            fixture.behave = () => "apply";
+            yield* journal.Record({ customerId: "hold-c", count: 1 });
+            yield* test.advance("300 seconds");
+            expect(yield* followerLog("hold-f")).toEqual(["hold-j~gap:0-3", "hold-j#4:OrderPlaced"]);
+            expect(yield* journalRow("hold-j", "SubFollower")).toMatchObject({
+                delivered: "4",
+                gap_through: null,
+            });
+        })),
+    },
+    {
+        name: 'reports RetentionGap first for a from: "start" subscription after pruning',
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const journal = yield* SubJournal.get("pruned-j");
+            yield* journal.Record({ customerId: "pruned-c", count: 2 });
+            yield* drain;
+            yield* test.advance("3 hours");
+            yield* test.cleanup;
+            yield* journal.Record({ customerId: "pruned-c", count: 1 });
+            yield* (yield* SubFollower.get("pruned-jf")).FollowJournal({
+                source: "pruned-j",
+                from: "start",
+            });
+            yield* drain;
+            expect(yield* followerLog("pruned-jf")).toEqual([
+                "pruned-j~gap:0-2",
+                "pruned-j#3:OrderPlaced",
+            ]);
+        })),
+    },
+    {
+        name: "counts an id-routed gap on the row and delivers a singleton-routed gap",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const journal = yield* SubJournal.get("routegap-j");
+            fixture.behave = (entry) => (entry.includes("/routegap-j#") ? "defect" : "apply");
+            yield* journal.Record({ customerId: "routegap-c", count: 2 });
+            yield* drain;
+            yield* test.advance("3 hours");
+            yield* test.cleanup;
+            expect(yield* journalEvents("routegap-j")).toBe(0);
+            fixture.behave = () => "apply";
+            yield* journal.Record({ customerId: "routegap-c", count: 1 });
+            yield* test.advance("300 seconds");
+            expect(yield* logOf("SubSummary", "routegap-c")).toEqual(["routegap-j#3:OrderPlaced"]);
+            expect(yield* journalRow("routegap-j", "SubSummary")).toMatchObject({
+                gaps: "1",
+                delivered: "3",
+            });
+            expect((yield* logOf("SubDashboard", "singleton")).filter((entry) => entry.startsWith("routegap-j"))).toEqual(["routegap-j~gap:0-2", "routegap-j#3:OrderPlaced"]);
+            expect(yield* journalRow("routegap-j", "SubDashboard")).toMatchObject({ gaps: "0" });
+        })),
+    },
+    {
+        name: "repeats a gap's id and range on redelivery after pruning advances",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const journal = yield* SubJournal.get("repeat-j");
+            yield* (yield* SubFollower.get("repeat-f")).FollowJournal({ source: "repeat-j" });
+            yield* drain;
+            fixture.behave = (entry) => entry.startsWith("SubFollower/repeat-f/") ? "defect" : "apply";
+            yield* journal.Record({ customerId: "repeat-c", count: 2 });
+            yield* drain;
+            yield* test.advance("3 hours");
+            yield* test.cleanup;
+            fixture.behave = () => "apply";
+            const settle = crashOnce(fixture, "beforeSettle", subscriber("repeat-f"));
+            yield* journal.Record({ customerId: "repeat-c", count: 1 });
+            yield* test.advance("300 seconds");
+            expect(settle.crashed).toBe(true);
+            expect(yield* journalRow("repeat-j", "SubFollower")).toMatchObject({
+                delivered: "0",
+                gap_through: "2",
+            });
+            yield* test.advance("3 hours");
+            yield* test.cleanup;
+            expect(yield* journalEvents("repeat-j")).toBe(0);
+            yield* test.advance(CLAIM_LEASE);
+            yield* test.advance("300 seconds");
+            expect(yield* followerLog("repeat-f")).toEqual([
+                "repeat-j~gap:0-2",
+                "repeat-j#3:OrderPlaced",
+            ]);
+            for (const entry of ["repeat-j~gap:0-2", "repeat-j#3:OrderPlaced"])
+                expect(fixture.runs.filter((run) => run === `SubFollower/repeat-f/${entry}`).length).toBe(1);
+            expect(yield* journalRow("repeat-j", "SubFollower")).toMatchObject({
+                delivered: "3",
+                gap_through: null,
+            });
+        })),
+    },
+    {
+        name: "acknowledges a RetentionGap redelivered after its receipt was pruned without running the handler again",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const journal = yield* SubJournal.get("gapreceipt-j");
+            yield* (yield* SubFollower.get("gapreceipt-f")).FollowJournal({ source: "gapreceipt-j" });
+            yield* drain;
+            fixture.behave = (entry) => entry.startsWith("SubFollower/gapreceipt-f/") ? "defect" : "apply";
+            yield* journal.Record({ customerId: "gapreceipt-c", count: 2 });
+            yield* drain;
+            yield* test.advance("3 hours");
+            yield* test.cleanup;
+            expect(yield* journalEvents("gapreceipt-j")).toBe(0);
+            fixture.behave = () => "apply";
+            const settle = crashOnce(fixture, "beforeSettle", subscriber("gapreceipt-f"));
+            yield* journal.Record({ customerId: "gapreceipt-c", count: 1 });
+            yield* test.advance("300 seconds");
+            expect(settle.crashed).toBe(true);
+            expect(yield* followerLog("gapreceipt-f")).toContain("gapreceipt-j~gap:0-2");
+            expect(yield* journalRow("gapreceipt-j", "SubFollower")).toMatchObject({
+                delivered: "0",
+            });
+            yield* query((sql) => sql `DELETE FROM actor_receipts WHERE tenant_id = ${test.tenant}
+              AND actor_type = 'SubFollower' AND actor_id = 'gapreceipt-f' AND command = 'OnOrder'`);
+            yield* test.advance(CLAIM_LEASE);
+            yield* test.advance("300 seconds");
+            expect(yield* followerLog("gapreceipt-f")).toEqual([
+                "gapreceipt-j~gap:0-2",
+                "gapreceipt-j#3:OrderPlaced",
+            ]);
+            for (const entry of ["gapreceipt-j~gap:0-2", "gapreceipt-j#3:OrderPlaced"])
+                expect(fixture.runs.filter((run) => run === `SubFollower/gapreceipt-f/${entry}`).length).toBe(1);
+            expect(yield* journalRow("gapreceipt-j", "SubFollower")).toMatchObject({
+                delivered: "3",
+                gap_through: null,
+            });
+        })),
+    },
+    {
+        name: "delivers a RetentionGap, never a skip, when retention prunes a claimed row's events before it reads them",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const journal = yield* SubJournal.get("claimrace-j");
+            yield* (yield* SubFollower.get("claimrace-f")).FollowJournal({ source: "claimrace-j" });
+            yield* drain;
+            fixture.behave = (entry) => entry.startsWith("SubFollower/claimrace-f/") ? "defect" : "apply";
+            yield* journal.Record({ customerId: "claimrace-c", count: 2 });
+            yield* drain;
+            yield* test.advance("3 hours");
+            fixture.behave = () => "apply";
+            const pause = yield* pauseOnce(fixture, "afterClaim", (request) => request.ref.id === "claimrace-j" && request.commandId === "claimrace-f");
+            const delivering = yield* test.advance("300 seconds").pipe(Effect.forkChild);
+            yield* pause.reached;
+            yield* test.cleanup;
+            expect(yield* journalEvents("claimrace-j")).toBe(0);
+            yield* pause.release;
+            yield* Fiber.join(delivering);
+            yield* test.advance("300 seconds");
+            expect(yield* followerLog("claimrace-f")).toEqual(["claimrace-j~gap:0-2"]);
+            expect(yield* journalRow("claimrace-j", "SubFollower")).toMatchObject({
+                delivered: "2",
+                gap_through: null,
+            });
+        })),
+    },
+    {
+        name: "widens no tombstone at startup, so it gains no tag and never becomes due",
+        run: ({ expect, environment, fixture }) => Effect.gen(function* () {
+            const tenant = yield* Effect.promise(() => run(environment, fixture, Effect.gen(function* () {
+                const test = yield* ActorTest;
+                const follower = yield* SubFollower.get("tomb-follower");
+                yield* follower.Follow({ source: "tomb-order" });
+                yield* drain;
+                yield* follower.Unfollow("tomb-order");
+                yield* drain;
+                yield* query((sql) => sql `UPDATE actor_subscriptions SET events = ARRAY['OrderPlaced']
+                  WHERE tenant_id = ${test.tenant} AND source_id = 'tomb-order'
+                    AND subscriber_id = 'tomb-follower'`);
+                expect(yield* sourceRows("tomb-order")).toMatchObject([
+                    { epoch: "2", active: false, due: false },
+                ]);
+                return test.tenant;
+            })));
+            yield* environment.restart;
+            yield* Effect.promise(() => run(environment, fixture, Effect.gen(function* () {
+                const row = query((sql) => sql `
+                  SELECT to_jsonb(events)::text AS events, active, due_at_ms IS NOT NULL AS due
+                  FROM actor_subscriptions WHERE tenant_id = ${tenant}
+                    AND source_id = 'tomb-order' AND subscriber_id = 'tomb-follower'`);
+                const tags = query((sql) => sql `SELECT event FROM actor_subscription_tags
+                  WHERE tenant_id = ${tenant} AND source_id = 'tomb-order'`);
+                expect(yield* row).toEqual([{ events: '["OrderPlaced"]', active: false, due: false }]);
+                expect(yield* tags).toEqual([]);
+                expect(yield* tagMismatches).toEqual([]);
+                yield* Effect.gen(function* () {
+                    yield* (yield* SubOrder.get("tomb-order")).CancelOrder("t");
+                }).pipe(Effect.provideService(Tenant, tenant));
+                yield* drain;
+                expect(yield* row).toEqual([{ events: '["OrderPlaced"]', active: false, due: false }]);
+                const { state } = yield* (yield* ActorTest).inspect({
+                    tenant,
+                    actor: "SubFollower",
+                    id: "tomb-follower",
+                });
+                expect((yield* Schema.decodeUnknownEffect(LogState)(state).pipe(Effect.orDie)).log ?? []).toEqual([]);
+            })));
+        }).pipe(Effect.runPromise),
+    },
+    {
+        name: "wakes a hibernated subscriber and commits the delivery",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            yield* (yield* SubFollower.get("sleepy-f")).Follow({ source: "sleepy-o" });
+            yield* drain;
+            yield* test.hibernate({ tenant: test.tenant, actor: "SubFollower", id: "sleepy-f" });
+            yield* (yield* SubOrder.get("sleepy-o")).Place({ customerId: "s", amount: 1 });
+            yield* drain;
+            expect(yield* followerLog("sleepy-f")).toEqual(["sleepy-o#1:OrderPlaced"]);
+        })),
+    },
+    {
+        name: "flushes a delivery's broadcast to the parked subscriber's connection after commit, and discards it on declared failure",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const ref = { tenant: test.tenant, actor: "SubSummary", id: "live-c" };
+            const connection = yield* test.connect(ref, Live, undefined);
+            yield* test.hibernate(ref);
+            fixture.behave = (entry) => (entry.includes("live-o#1:") ? "refuse" : "apply");
+            const order = yield* SubOrder.get("live-o");
+            yield* order.Place({ customerId: "live-c", amount: 1 });
+            yield* order.Place({ customerId: "live-c", amount: 2 });
+            yield* drain;
+            const frames = yield* connection.frames.pipe(Stream.take(1), Stream.runCollect, Effect.timeout("10 seconds"));
+            expect(Array.from(frames)).toEqual(["live-o#2:OrderPlaced"]);
+            expect(yield* logOf("SubSummary", "live-c")).toEqual(["live-o#2:OrderPlaced"]);
+            yield* connection.close;
+        })),
+    },
+    {
+        name: "resolves an owner wait from a subscription delivery that re-emits",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const shipment = yield* SubShipment.get("wf-ship");
+            const execution = yield* shipment.PlaceOrder("wf-order");
+            const workflow = yield* SubShipment.run(ShipOrder, execution);
+            yield* drain;
+            yield* (yield* SubOrder.get("wf-order")).Place({ customerId: "wf", amount: 1 });
+            yield* drain;
+            expect(yield* workflow.result.pipe(Effect.timeout("20 seconds"))).toBe("paid");
+        })),
+    },
+    {
+        name: "subscribes in the workflow's start turn and delivers after the start commits",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            yield* (yield* SubOrder.get("wf-early")).Place({ customerId: "wf", amount: 1 });
+            const shipment = yield* SubShipment.get("wf-early-ship");
+            const execution = yield* shipment.PlaceOrder("wf-early");
+            const workflow = yield* SubShipment.run(ShipOrder, execution);
+            yield* drain;
+            expect(yield* workflow.result.pipe(Effect.timeout("20 seconds"))).toBe("paid");
+        })),
+    },
+];

package/dist/testing/conformance/subscriptions/routing.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceCase } from "../../conformance.ts";
+import { type SubscriptionsFixture } from "./actors.ts";
+/** Routing, start positions, and first delivery of event subscriptions. */
+export declare const subscriptionRoutingConformance: ReadonlyArray<ConformanceCase<SubscriptionsFixture>>;

package/dist/testing/conformance/subscriptions/routing.js

@@ -0,0 +1,179 @@
+import { Effect } from "effect";
+import { Refused, SubFollower, SubOrder } from "./actors.js";
+import { cursorRows, drain, followerLog, logOf, outboxOf, run, sourceRows, tagMismatches, } from "./harness.js";
+/** Routing, start positions, and first delivery of event subscriptions. */
+export const subscriptionRoutingConformance = [
+    {
+        name: "routes each event to the id route returns",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const first = yield* SubOrder.get("route-1");
+            const second = yield* SubOrder.get("route-2");
+            yield* first.Place({ customerId: "route-alice", amount: 1 });
+            yield* second.Place({ customerId: "route-bob", amount: 2 });
+            yield* first.Note("not subscribed");
+            yield* first.CancelOrder("route-alice");
+            yield* drain;
+            expect(yield* logOf("SubSummary", "route-alice")).toEqual([
+                "route-1#1:OrderPlaced",
+                "route-1#3:OrderCancelled",
+            ]);
+            expect(yield* logOf("SubSummary", "route-bob")).toEqual(["route-2#1:OrderPlaced"]);
+            expect(yield* sourceRows("route-1", "SubSummary")).toEqual([
+                {
+                    subscriber_type: "SubSummary",
+                    subscription: "CustomerOrders",
+                    subscriber_id: "",
+                    epoch: "0",
+                    active: true,
+                    delivered: "3",
+                    due: false,
+                    attempts: 0,
+                    last_error: null,
+                },
+            ]);
+            expect(yield* cursorRows("SubSummary", "route-alice")).toEqual([
+                {
+                    subscription: "CustomerOrders",
+                    source_id: "route-1",
+                    epoch: "0",
+                    active: true,
+                    applied: "3",
+                },
+            ]);
+            expect(yield* tagMismatches).toEqual([]);
+        })),
+    },
+    {
+        name: "routes to the tenant's singleton with route: Actor.singleton",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const before = (yield* logOf("SubDashboard", "singleton")).length;
+            yield* (yield* SubOrder.get("fan-1")).Place({ customerId: "fan-a", amount: 1 });
+            yield* (yield* SubOrder.get("fan-2")).Place({ customerId: "fan-b", amount: 1 });
+            yield* (yield* SubOrder.get("fan-2")).CancelOrder("fan-b");
+            yield* drain;
+            const log = (yield* logOf("SubDashboard", "singleton")).slice(before);
+            expect([...log].sort()).toEqual(["fan-1#1:OrderPlaced", "fan-2#1:OrderPlaced"]);
+        })),
+    },
+    {
+        name: 'delivers events committed after the registration and none before, with from: "now"',
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const order = yield* SubOrder.get("now-order");
+            const follower = yield* SubFollower.get("now-follower");
+            yield* order.Place({ customerId: "now-x", amount: 1 });
+            yield* follower.Follow({ source: "now-order" });
+            yield* drain;
+            yield* order.Place({ customerId: "now-x", amount: 2 });
+            yield* order.Note("ignored");
+            yield* order.CancelOrder("now-x");
+            yield* drain;
+            expect(yield* followerLog("now-follower")).toEqual([
+                "now-order#2:OrderPlaced",
+                "now-order#4:OrderCancelled",
+            ]);
+            expect(yield* cursorRows("SubFollower", "now-follower")).toEqual([
+                {
+                    subscription: "FollowedOrders",
+                    source_id: "now-order",
+                    epoch: "1",
+                    active: true,
+                    applied: "4",
+                },
+            ]);
+            expect(yield* tagMismatches).toEqual([]);
+        })),
+    },
+    {
+        name: 'delivers retained history to a from: "start" subscription on a source that never emits again',
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const order = yield* SubOrder.get("start-order");
+            yield* order.PlaceMany({ customerId: "start-x", count: 3 });
+            yield* order.Note("between");
+            yield* order.CancelOrder("start-x");
+            yield* drain;
+            yield* (yield* SubFollower.get("start-follower")).Follow({
+                source: "start-order",
+                from: "start",
+            });
+            yield* drain;
+            expect(yield* followerLog("start-follower")).toEqual([
+                "start-order#1:OrderPlaced",
+                "start-order#2:OrderPlaced",
+                "start-order#3:OrderPlaced",
+                "start-order#5:OrderCancelled",
+            ]);
+        })),
+    },
+    {
+        name: "resumes after an explicit cursor",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const order = yield* SubOrder.get("cursor-order");
+            yield* order.PlaceMany({ customerId: "cursor-x", count: 3 });
+            yield* (yield* SubFollower.get("cursor-follower")).Follow({
+                source: "cursor-order",
+                from: "2",
+            });
+            yield* drain;
+            yield* order.CancelOrder("cursor-x");
+            yield* drain;
+            expect(yield* followerLog("cursor-follower")).toEqual([
+                "cursor-order#3:OrderPlaced",
+                "cursor-order#4:OrderCancelled",
+            ]);
+        })),
+    },
+    {
+        name: "stages nothing when the subscribing turn fails with a declared error",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const follower = yield* SubFollower.get("refused-follower");
+            const refused = yield* follower.FollowThenRefuse("refused-order").pipe(Effect.flip);
+            expect(refused).toBeInstanceOf(Refused);
+            yield* (yield* SubOrder.get("refused-order")).Place({ customerId: "r", amount: 1 });
+            yield* drain;
+            expect(yield* cursorRows("SubFollower", "refused-follower")).toEqual([]);
+            expect(yield* outboxOf("SubFollower", "refused-follower", "control")).toBe(0);
+            expect((yield* sourceRows("refused-order")).filter((row) => row.subscriber_type === "SubFollower")).toEqual([]);
+            expect(yield* followerLog("refused-follower")).toEqual([]);
+        })),
+    },
+    {
+        name: "delivers Rejected and deactivates the subscription for a cursor above the source's head",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const order = yield* SubOrder.get("reject-order");
+            yield* order.PlaceMany({ customerId: "reject-x", count: 2 });
+            const follower = yield* SubFollower.get("reject-follower");
+            yield* follower.Follow({ source: "reject-order", from: "9" });
+            yield* drain;
+            expect(yield* followerLog("reject-follower")).toEqual(["reject-order!rejected:9"]);
+            expect(yield* cursorRows("SubFollower", "reject-follower")).toEqual([
+                {
+                    subscription: "FollowedOrders",
+                    source_id: "reject-order",
+                    epoch: "1",
+                    active: false,
+                    applied: "9",
+                },
+            ]);
+            expect((yield* sourceRows("reject-order")).filter((row) => row.subscriber_type === "SubFollower")).toMatchObject([
+                { subscriber_id: "reject-follower", epoch: "1", active: false, due: false },
+            ]);
+            yield* order.Place({ customerId: "reject-x", amount: 3 });
+            yield* drain;
+            expect(yield* followerLog("reject-follower")).toEqual(["reject-order!rejected:9"]);
+            expect(yield* tagMismatches).toEqual([]);
+        })),
+    },
+    {
+        name: "subscribes to a source that has never been created, and delivers its first event",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            yield* (yield* SubFollower.get("early-follower")).Follow({ source: "early-order" });
+            yield* drain;
+            expect(yield* sourceRows("early-order")).toMatchObject([
+                { subscriber_id: "early-follower", active: true, delivered: "0" },
+            ]);
+            yield* (yield* SubOrder.get("early-order")).Place({ customerId: "early-x", amount: 1 });
+            yield* drain;
+            expect(yield* followerLog("early-follower")).toEqual(["early-order#1:OrderPlaced"]);
+        })),
+    },
+];

package/dist/testing/conformance/subscriptions.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceCase } from "../conformance.ts";
+import type { SubscriptionsFixture } from "./subscriptions/actors.ts";
+/** Subscription cases: routing, start positions, delivery, and failure handling of event subscriptions. */
+export declare const subscriptionsConformance: ReadonlyArray<ConformanceCase<SubscriptionsFixture>>;

package/dist/testing/conformance/subscriptions.js

@@ -0,0 +1,19 @@
+import { subscriptionAccessConformance } from "./subscriptions/access.js";
+import { subscriptionDeliveryConformance } from "./subscriptions/delivery.js";
+import { subscriptionDeployConformance } from "./subscriptions/deploys.js";
+import { subscriptionEpochConformance } from "./subscriptions/epochs.js";
+import { subscriptionFailureConformance } from "./subscriptions/failures.js";
+import { subscriptionFeedConformance } from "./subscriptions/feeds.js";
+import { subscriptionOperatorConformance } from "./subscriptions/operator.js";
+import { subscriptionRoutingConformance } from "./subscriptions/routing.js";
+/** Subscription cases: routing, start positions, delivery, and failure handling of event subscriptions. */
+export const subscriptionsConformance = [
+    ...subscriptionRoutingConformance,
+    ...subscriptionEpochConformance,
+    ...subscriptionFeedConformance,
+    ...subscriptionDeliveryConformance,
+    ...subscriptionOperatorConformance,
+    ...subscriptionFailureConformance,
+    ...subscriptionAccessConformance,
+    ...subscriptionDeployConformance,
+];