@rikalabs/akter 0.1.0-alpha.0

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

@@ -0,0 +1,253 @@
+import { Effect, Schema } from "effect";
+import { User } from "../../../index.js";
+import { InternalActors } from "../../../runtime/actors.js";
+import { Outcome, Request } from "../../../runtime/request.js";
+import { InternalCommandId } from "../../../identity/command.js";
+import { deliveryCommandId } from "../../../runtime/subscriptions/identity.js";
+import { ActorTest, executeForTest } from "../../actor-test.js";
+import { CLAIM_LEASE } from "../outbox.js";
+import { Refused, SubFollower, SubGated, SubGateOrder, SubOrder, } from "./actors.js";
+import { crashOnce, cursorRows, deliveryRequest, drain, followerLog, handlerRuns, logOf, outboxOf, query, run, sourceRows, subscriber, } from "./harness.js";
+/** Exactly-once delivery, receipts, and derived command ids of event subscriptions. */
+export const subscriptionDeliveryConformance = [
+    {
+        name: "acknowledges a redelivery whose receipt was pruned without running the handler",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            yield* (yield* SubFollower.get("pruned-follower")).Follow({ source: "pruned-order" });
+            yield* drain;
+            crashOnce(fixture, "beforeSettle", subscriber("pruned-follower"));
+            yield* (yield* SubOrder.get("pruned-order")).Place({ customerId: "p", amount: 1 });
+            yield* drain;
+            expect(handlerRuns(fixture, "SubFollower/pruned-follower")).toBe(1);
+            expect(yield* sourceRows("pruned-order")).toMatchObject([{ delivered: "0" }]);
+            yield* query((sql) => sql `DELETE FROM actor_receipts WHERE tenant_id = ${test.tenant}
+              AND actor_type = 'SubFollower' AND actor_id = 'pruned-follower' AND command = 'OnOrder'`);
+            yield* test.advance(CLAIM_LEASE);
+            expect(handlerRuns(fixture, "SubFollower/pruned-follower")).toBe(1);
+            expect(yield* followerLog("pruned-follower")).toEqual(["pruned-order#1:OrderPlaced"]);
+            expect(yield* sourceRows("pruned-order")).toMatchObject([
+                { delivered: "1", due: false },
+            ]);
+        })),
+    },
+    {
+        name: "applies each committed source event once when the relay dies before and after the subscriber's commit",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const order = yield* SubOrder.get("crash-order");
+            yield* (yield* SubFollower.get("crash-follower")).Follow({ source: "crash-order" });
+            yield* drain;
+            const commit = crashOnce(fixture, "beforeCommit", subscriber("crash-follower"));
+            yield* order.Place({ customerId: "c", amount: 1 });
+            yield* drain;
+            expect(commit.crashed).toBe(true);
+            const settle = crashOnce(fixture, "beforeSettle", subscriber("crash-follower"));
+            yield* order.Place({ customerId: "c", amount: 2 });
+            yield* drain;
+            expect(settle.crashed).toBe(true);
+            yield* test.advance(CLAIM_LEASE);
+            yield* test.advance(CLAIM_LEASE);
+            expect(yield* followerLog("crash-follower")).toEqual([
+                "crash-order#1:OrderPlaced",
+                "crash-order#2:OrderPlaced",
+            ]);
+            expect(yield* test.receiptsFor({ tenant: test.tenant, actor: "SubFollower", id: "crash-follower" }, "OnOrder")).toBe(2);
+        })),
+    },
+    {
+        name: "acknowledges a stale routed delivery as AlreadyApplied after a NotCreated skip and a later creation",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const internal = yield* InternalActors;
+            const order = yield* SubGateOrder.get("gate-order");
+            yield* order.Place({ customerId: "gate-sub", amount: 1 });
+            yield* drain;
+            expect(handlerRuns(fixture, "SubGated/gate-sub")).toBe(0);
+            expect(yield* cursorRows("SubGated", "gate-sub")).toMatchObject([
+                { subscription: "GatedOrders", source_id: "gate-order", applied: "1" },
+            ]);
+            yield* (yield* SubGated.get("gate-sub")).OpenGated();
+            yield* query((sql) => sql `DELETE FROM actor_receipts WHERE tenant_id = ${test.tenant}
+              AND actor_type = 'SubGated' AND actor_id = 'gate-sub' AND command = 'OnGated'`);
+            const stale = yield* deliveryRequest({
+                subscriber: "gate-sub",
+                source: "gate-order",
+                epoch: "0",
+                cursor: "1",
+                route: {
+                    actor: "SubGated",
+                    subscription: "GatedOrders",
+                    command: "OnGated",
+                    source: "SubGateOrder",
+                },
+            });
+            expect(yield* internal.deliver(stale)).toEqual(Outcome.cases.Acknowledged.make({ reason: "AlreadyApplied" }));
+            expect(handlerRuns(fixture, "SubGated/gate-sub")).toBe(0);
+            yield* order.Place({ customerId: "gate-sub", amount: 2 });
+            yield* drain;
+            expect(yield* logOf("SubGated", "gate-sub")).toEqual(["gate-order#2:OrderPlaced"]);
+        })),
+    },
+    {
+        name: "refuses a stale runner's delivery below the applied cursor after a lease takeover",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const internal = yield* InternalActors;
+            yield* (yield* SubFollower.get("stale-follower")).Follow({ source: "stale-order" });
+            yield* drain;
+            yield* (yield* SubOrder.get("stale-order")).PlaceMany({ customerId: "s", count: 2 });
+            yield* drain;
+            yield* query((sql) => sql `DELETE FROM actor_receipts WHERE tenant_id = ${test.tenant}
+              AND actor_type = 'SubFollower' AND actor_id = 'stale-follower'`);
+            const stale = yield* deliveryRequest({
+                subscriber: "stale-follower",
+                source: "stale-order",
+                epoch: "1",
+                cursor: "1",
+            });
+            expect(yield* internal.deliver(stale)).toEqual(Outcome.cases.Acknowledged.make({ reason: "AlreadyApplied" }));
+            const older = yield* deliveryRequest({
+                subscriber: "stale-follower",
+                source: "stale-order",
+                epoch: "0",
+                cursor: "2",
+            });
+            expect(yield* internal.deliver(older)).toEqual(Outcome.cases.Acknowledged.make({ reason: "Stale" }));
+            expect(handlerRuns(fixture, "SubFollower/stale-follower")).toBe(2);
+        })),
+    },
+    {
+        name: "advances past a declared failure and replays its receipt",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const internal = yield* InternalActors;
+            yield* (yield* SubFollower.get("declared-follower")).Follow({
+                source: "declared-order",
+            });
+            yield* drain;
+            fixture.behave = (entry) => (entry.endsWith("#1:OrderPlaced") ? "refuse" : "apply");
+            yield* (yield* SubOrder.get("declared-order")).PlaceMany({ customerId: "d", count: 2 });
+            yield* drain;
+            expect(yield* followerLog("declared-follower")).toEqual([
+                "declared-order#2:OrderPlaced",
+            ]);
+            expect(yield* cursorRows("SubFollower", "declared-follower")).toMatchObject([
+                { applied: "2" },
+            ]);
+            const replay = yield* internal.deliver(yield* deliveryRequest({
+                subscriber: "declared-follower",
+                source: "declared-order",
+                epoch: "1",
+                cursor: "1",
+            }));
+            expect(Outcome.guards.Failure(replay)).toBe(true);
+            expect(handlerRuns(fixture, "SubFollower/declared-follower")).toBe(2);
+        })),
+    },
+    {
+        name: "replays after a schema-compatible deploy instead of CommandConflict",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const internal = yield* InternalActors;
+            yield* (yield* SubFollower.get("deploy-follower")).Follow({ source: "deploy-order" });
+            yield* drain;
+            yield* (yield* SubOrder.get("deploy-order")).Place({ customerId: "d", amount: 1 });
+            yield* drain;
+            const redelivered = yield* deliveryRequest({
+                subscriber: "deploy-follower",
+                source: "deploy-order",
+                epoch: "1",
+                cursor: "1",
+                extra: true,
+            });
+            expect(Outcome.guards.Success(yield* internal.deliver(redelivered))).toBe(true);
+            expect(handlerRuns(fixture, "SubFollower/deploy-follower")).toBe(1);
+        })),
+    },
+    {
+        name: "derives distinct command ids for two subscriptions, two subscribers, and two epochs of one source",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const subscriber = { tenant: "t", actor: "SubFollower", id: "a" };
+            const envelope = {
+                subscription: "FollowedOrders",
+                sourceType: "SubOrder",
+                sourceId: "o",
+                epoch: "1",
+                kind: "event",
+                position: "1",
+            };
+            const ids = yield* Effect.forEach([
+                [subscriber, envelope],
+                [subscriber, { ...envelope, subscription: "Other" }],
+                [{ ...subscriber, id: "b" }, envelope],
+                [subscriber, { ...envelope, epoch: "2" }],
+                [subscriber, { ...envelope, kind: "gap" }],
+            ], ([ref, env]) => deliveryCommandId({
+                subscriber: ref,
+                envelope: env,
+                issuedAt: 1_000,
+                retryWindowMs: 60_000,
+            }));
+            expect(new Set(ids).size).toBe(ids.length);
+            expect(yield* deliveryCommandId({
+                subscriber,
+                envelope,
+                issuedAt: 1_000,
+                retryWindowMs: 60_000,
+            })).toBe(ids[0]);
+            for (const id of ids) {
+                expect(Schema.is(InternalCommandId)(id)).toBe(true);
+                expect(id.startsWith("v1.1000.61000.")).toBe(true);
+                expect(id.split(".")[3][14]).toBe("8");
+            }
+        })),
+    },
+    {
+        name: "accepts a version-8 derived id on System delivery and rejects it at external admission",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            yield* (yield* SubFollower.get("external-follower")).Follow({
+                source: "external-order",
+            });
+            yield* drain;
+            yield* (yield* SubOrder.get("external-order")).Place({ customerId: "e", amount: 1 });
+            yield* drain;
+            expect(handlerRuns(fixture, "SubFollower/external-follower")).toBe(1);
+            const delivery = yield* deliveryRequest({
+                subscriber: "external-follower",
+                source: "external-order",
+                epoch: "1",
+                cursor: "1",
+            });
+            const withEnvelope = yield* executeForTest(delivery).pipe(Effect.flip);
+            expect(withEnvelope.reason._tag).toBe("Unauthorized");
+            const { delivery: _, ...bare } = delivery;
+            const withCaller = yield* executeForTest(Request.make(bare)).pipe(Effect.flip);
+            expect(withCaller.reason._tag).toBe("Unauthorized");
+            const asUser = yield* executeForTest(Request.make({
+                ...bare,
+                ref: { ...bare.ref, actor: "SubFollower" },
+                caller: User.make({ subject: "alice" }),
+                command: "Touch",
+                payload: "{}",
+            })).pipe(Effect.flip);
+            expect(asUser.reason._tag).toBe("InvalidCommandId");
+            expect(handlerRuns(fixture, "SubFollower/external-follower")).toBe(1);
+        })),
+    },
+    {
+        name: "delivers nothing for a rolled-back source turn",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            yield* (yield* SubFollower.get("rollback-follower")).Follow({
+                source: "rollback-order",
+            });
+            yield* drain;
+            const order = yield* SubOrder.get("rollback-order");
+            expect(yield* order.PlaceThenRefuse("rb").pipe(Effect.flip)).toBeInstanceOf(Refused);
+            yield* order.PlaceThenDie("rb").pipe(Effect.exit);
+            yield* drain;
+            expect(yield* outboxOf("SubOrder", "rollback-order", "feed")).toBe(0);
+            expect(yield* followerLog("rollback-follower")).toEqual([]);
+            expect(yield* logOf("SubSummary", "rb")).toEqual([]);
+            expect(handlerRuns(fixture, "SubFollower/rollback-follower")).toBe(0);
+        })),
+    },
+];

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

@@ -0,0 +1,4 @@
+import type { ConformanceCase } from "../../conformance.ts";
+import { type SubscriptionsFixture } from "./actors.ts";
+/** Deploy-time registration checks and tag-summary upkeep of event subscriptions. */
+export declare const subscriptionDeployConformance: ReadonlyArray<ConformanceCase<SubscriptionsFixture>>;

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

@@ -0,0 +1,162 @@
+import { Cause, Effect, Exit, Layer } from "effect";
+import { SqlClient } from "effect/sql";
+import { Tenant } from "../../../index.js";
+import { ActorTest } from "../../actor-test.js";
+import { SubFollower, SubOrder, subOrderLayer } from "./actors.js";
+import { drain, followerLog, handlerRuns, query, run, sourceRows, tagMismatches, } from "./harness.js";
+import { CLAIM_LEASE } from "../outbox.js";
+/** Deploy-time registration checks and tag-summary upkeep of event subscriptions. */
+export const subscriptionDeployConformance = [
+    {
+        name: "delivers a class added to a dynamic subscription by a deploy, and never narrows a row",
+        run: ({ expect, environment, fixture }) => Effect.gen(function* () {
+            const tenant = yield* Effect.promise(() => run(environment, fixture, Effect.gen(function* () {
+                const test = yield* ActorTest;
+                yield* (yield* SubFollower.get("widen-follower")).Follow({ source: "widen-order" });
+                yield* drain;
+                yield* query((sql) => sql `UPDATE actor_subscriptions SET events = ARRAY['OrderPlaced']
+                  WHERE tenant_id = ${test.tenant} AND source_id = 'widen-order'
+                    AND subscriber_id = 'widen-follower'`);
+                yield* query((sql) => sql `DELETE FROM actor_subscription_tags WHERE tenant_id = ${test.tenant}
+                  AND source_id = 'widen-order' AND event = 'OrderCancelled'`);
+                expect(yield* tagMismatches).toEqual([]);
+                return test.tenant;
+            })));
+            yield* environment.restart;
+            yield* Effect.promise(() => run(environment, fixture, Effect.gen(function* () {
+                const events = query((sql) => sql `SELECT to_jsonb(events)::text AS events
+                  FROM actor_subscriptions WHERE tenant_id = ${tenant}
+                    AND source_id = 'widen-order' AND subscriber_id = 'widen-follower'`);
+                expect((yield* events)[0].events).toBe('["OrderCancelled", "OrderPlaced"]');
+                expect(yield* tagMismatches).toEqual([]);
+                yield* Effect.gen(function* () {
+                    yield* (yield* SubOrder.get("widen-order")).CancelOrder("w");
+                }).pipe(Effect.provideService(Tenant, tenant));
+                yield* drain;
+                const { state } = yield* (yield* ActorTest).inspect({
+                    tenant,
+                    actor: "SubFollower",
+                    id: "widen-follower",
+                });
+                expect(state).toEqual({ log: ["widen-order#1:OrderCancelled"] });
+            })));
+        }).pipe(Effect.runPromise),
+    },
+    {
+        name: "never claims a row widened with a class this runner does not declare, and leaves it due",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            yield* (yield* SubFollower.get("older-follower")).Follow({ source: "older-order" });
+            yield* drain;
+            yield* query((sql) => sql `UPDATE actor_subscriptions
+              SET events = ARRAY['OrderCancelled', 'OrderNoted', 'OrderPlaced']
+              WHERE tenant_id = ${test.tenant} AND source_id = 'older-order'
+                AND subscriber_id = 'older-follower'`);
+            yield* (yield* SubOrder.get("older-order")).Place({ customerId: "o", amount: 1 });
+            yield* drain;
+            yield* test.advance(CLAIM_LEASE);
+            expect(handlerRuns(fixture, "SubFollower/older-follower")).toBe(0);
+            expect(yield* followerLog("older-follower")).toEqual([]);
+            expect(yield* sourceRows("older-order")).toMatchObject([
+                {
+                    subscriber_id: "older-follower",
+                    active: true,
+                    delivered: "0",
+                    due: true,
+                    attempts: 0,
+                },
+            ]);
+            yield* query((sql) => sql `UPDATE actor_subscriptions SET events = ARRAY['OrderCancelled', 'OrderPlaced']
+              WHERE tenant_id = ${test.tenant} AND source_id = 'older-order'
+                AND subscriber_id = 'older-follower'`);
+            yield* test.advance(CLAIM_LEASE);
+            expect(yield* followerLog("older-follower")).toEqual(["older-order#1:OrderPlaced"]);
+            expect(yield* tagMismatches).toEqual([]);
+        })),
+    },
+    {
+        name: "fails registration of a source served without a subscriber type that routes from it",
+        requiresFreshDatabase: true,
+        requiresIndependentConnections: true,
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const database = yield* environment.freshDatabase;
+            const runtime = (record) => Layer.build(Layer.fresh(subOrderLayer).pipe(Layer.provideMerge(ActorTest.layer({ database })))).pipe(Effect.flatMap((context) => record.pipe(Effect.provideContext(context))), Effect.scoped, Effect.exit);
+            const alone = yield* runtime(query((sql) => sql `INSERT INTO actor_routed_subscriptions (source_type, subscriber_type, subscription)
+                VALUES ('SubOrder', 'SubSummary', 'CustomerOrders')`));
+            expect(Exit.isSuccess(alone)).toBe(true);
+            const partial = yield* runtime(Effect.void);
+            expect(Exit.isFailure(partial) &&
+                Cause.pretty(partial.cause).includes("Actor SubOrder is registered without the subscriber types that route from it")).toBe(true);
+        })),
+        timeoutMs: 60_000,
+    },
+    {
+        name: "keeps the tag summary equal to the rows after every insert, widen, and delete",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const followers = ["tags-a", "tags-b", "tags-c"];
+            for (const id of followers)
+                yield* (yield* SubFollower.get(id)).Follow({ source: "tags-order" });
+            yield* drain;
+            expect(yield* tagMismatches).toEqual([]);
+            const counts = () => query((sql) => sql `SELECT event, rows FROM actor_subscription_tags
+                WHERE tenant_id = ${test.tenant} AND source_id = 'tags-order' ORDER BY event`);
+            expect(yield* counts()).toEqual([
+                { event: "OrderCancelled", rows: 3 },
+                { event: "OrderPlaced", rows: 3 },
+            ]);
+            yield* (yield* SubFollower.get("tags-b")).Unfollow("tags-order");
+            yield* drain;
+            expect(yield* counts()).toEqual([
+                { event: "OrderCancelled", rows: 2 },
+                { event: "OrderPlaced", rows: 2 },
+            ]);
+            yield* (yield* SubOrder.get("tags-order")).Place({ customerId: "tags-x", amount: 1 });
+            yield* drain;
+            expect(yield* counts()).toEqual([
+                { event: "OrderCancelled", rows: 4 },
+                { event: "OrderPlaced", rows: 5 },
+            ]);
+            yield* (yield* SubFollower.get("tags-a")).Unfollow("tags-order");
+            yield* (yield* SubFollower.get("tags-c")).Unfollow("tags-order");
+            yield* drain;
+            expect(yield* counts()).toEqual([
+                { event: "OrderCancelled", rows: 2 },
+                { event: "OrderPlaced", rows: 3 },
+            ]);
+            expect(yield* tagMismatches).toEqual([]);
+        })),
+    },
+    {
+        name: "keeps the tag summary exact when many subscriptions of one source change at once, and deletes counts that reach zero",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const ids = Array.from({ length: 16 }, (_, index) => `crowd-${index}`);
+            const counts = query((sql) => sql `SELECT event, rows
+              FROM actor_subscription_tags
+              WHERE tenant_id = ${test.tenant} AND source_id = 'crowd-order' ORDER BY event`);
+            yield* Effect.forEach(ids, (id) => SubFollower.get(id).pipe(Effect.flatMap((follower) => follower.Follow({ source: "crowd-order" }))), { concurrency: "unbounded", discard: true });
+            yield* drain;
+            expect(yield* counts).toEqual([
+                { event: "OrderCancelled", rows: 16 },
+                { event: "OrderPlaced", rows: 16 },
+            ]);
+            yield* Effect.forEach(ids, (id, index) => SubFollower.get(id).pipe(Effect.flatMap((follower) => index % 2 === 0
+                ? follower.Unfollow("crowd-order")
+                : follower
+                    .Unfollow("crowd-order")
+                    .pipe(Effect.andThen(follower.Follow({ source: "crowd-order" }))))), { concurrency: "unbounded", discard: true });
+            yield* drain;
+            expect(yield* counts).toEqual([
+                { event: "OrderCancelled", rows: 8 },
+                { event: "OrderPlaced", rows: 8 },
+            ]);
+            expect(yield* tagMismatches).toEqual([]);
+            yield* Effect.forEach(ids, (id) => SubFollower.get(id).pipe(Effect.flatMap((follower) => follower.Unfollow("crowd-order"))), { concurrency: "unbounded", discard: true });
+            yield* drain;
+            expect(yield* counts).toEqual([]);
+            expect(yield* tagMismatches).toEqual([]);
+        })),
+        timeoutMs: 60_000,
+    },
+];

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

@@ -0,0 +1,4 @@
+import type { ConformanceCase } from "../../conformance.ts";
+import { type SubscriptionsFixture } from "./actors.ts";
+/** Unsubscribe, resubscribe, and control-row epochs of event subscriptions. */
+export declare const subscriptionEpochConformance: ReadonlyArray<ConformanceCase<SubscriptionsFixture>>;

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

@@ -0,0 +1,169 @@
+import { Effect, Fiber } from "effect";
+import { ActorTest } from "../../actor-test.js";
+import { CLAIM_LEASE } from "../outbox.js";
+import { SubFollower, SubOrder } from "./actors.js";
+import { cursorRows, drain, followerLog, handlerRuns, outboxOf, pauseOnce, run, sourceRows, subscriber, tagMismatches, } from "./harness.js";
+/** Unsubscribe, resubscribe, and control-row epochs of event subscriptions. */
+export const subscriptionEpochConformance = [
+    {
+        name: "runs no handler for a delivery in flight when unsubscribe commits",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const follower = yield* SubFollower.get("inflight-follower");
+            yield* follower.Follow({ source: "inflight-order" });
+            yield* drain;
+            const pause = yield* pauseOnce(fixture, "beforeDelivery", subscriber("inflight-follower"));
+            yield* (yield* SubOrder.get("inflight-order")).Place({ customerId: "i", amount: 1 });
+            const draining = yield* drain.pipe(Effect.forkChild);
+            yield* pause.reached;
+            yield* follower.Unfollow("inflight-order");
+            yield* pause.release;
+            yield* Fiber.join(draining);
+            yield* drain;
+            expect(handlerRuns(fixture, "SubFollower/inflight-follower")).toBe(0);
+            expect(yield* followerLog("inflight-follower")).toEqual([]);
+            expect(yield* sourceRows("inflight-order")).toMatchObject([
+                { subscriber_id: "inflight-follower", epoch: "2", active: false, due: false },
+            ]);
+            expect(yield* tagMismatches).toEqual([]);
+        })),
+    },
+    {
+        name: "keeps the newest epoch when subscribe and unsubscribe control rows are delivered out of order",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const follower = yield* SubFollower.get("order-follower");
+            const pause = yield* test.pauseNext("afterClaim");
+            yield* follower.Follow({ source: "order-order" });
+            const draining = yield* drain.pipe(Effect.forkChild);
+            yield* pause.reached;
+            yield* follower.Unfollow("order-order");
+            for (;;) {
+                const rows = yield* sourceRows("order-order");
+                if (rows.some((row) => row.epoch === "2"))
+                    break;
+                yield* Effect.sleep("20 millis");
+            }
+            yield* pause.release;
+            yield* Fiber.join(draining);
+            yield* (yield* SubOrder.get("order-order")).Place({ customerId: "o", amount: 1 });
+            yield* drain;
+            expect(yield* sourceRows("order-order")).toMatchObject([
+                { subscriber_id: "order-follower", epoch: "2", active: false, due: false },
+            ]);
+            expect(yield* followerLog("order-follower")).toEqual([]);
+            expect(yield* tagMismatches).toEqual([]);
+        })),
+    },
+    {
+        name: 'runs no stale-epoch delivery after unsubscribe and resubscribe with from: "start", and applies the new epoch from cursor 1',
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const follower = yield* SubFollower.get("resub-follower");
+            yield* follower.Follow({ source: "resub-order" });
+            yield* drain;
+            const pause = yield* pauseOnce(fixture, "beforeDelivery", subscriber("resub-follower"));
+            yield* (yield* SubOrder.get("resub-order")).Place({ customerId: "r", amount: 1 });
+            const draining = yield* drain.pipe(Effect.forkChild);
+            yield* pause.reached;
+            yield* follower.Unfollow("resub-order");
+            yield* follower.Follow({ source: "resub-order", from: "start" });
+            for (;;) {
+                const rows = yield* sourceRows("resub-order");
+                if (rows.some((row) => row.epoch === "3"))
+                    break;
+                yield* Effect.sleep("20 millis");
+            }
+            yield* pause.release;
+            yield* Fiber.join(draining);
+            yield* drain;
+            expect(yield* followerLog("resub-follower")).toEqual(["resub-order#1:OrderPlaced"]);
+            expect(handlerRuns(fixture, "SubFollower/resub-follower")).toBe(1);
+            expect(yield* cursorRows("SubFollower", "resub-follower")).toMatchObject([
+                { epoch: "3", active: true, applied: "1" },
+            ]);
+            expect(yield* sourceRows("resub-order")).toMatchObject([
+                { subscriber_id: "resub-follower", epoch: "3", active: true, delivered: "1" },
+            ]);
+            expect(yield* tagMismatches).toEqual([]);
+        })),
+    },
+    {
+        name: 'fences a delivery settling after unsubscribe and resubscribe with from: "start", keeping the tag summary exact',
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const follower = yield* SubFollower.get("late-follower");
+            yield* follower.Follow({ source: "late-order" });
+            yield* drain;
+            const pause = yield* pauseOnce(fixture, "beforeSettle", subscriber("late-follower"));
+            yield* (yield* SubOrder.get("late-order")).Place({ customerId: "l", amount: 1 });
+            const draining = yield* drain.pipe(Effect.forkChild);
+            yield* pause.reached;
+            expect(handlerRuns(fixture, "SubFollower/late-follower")).toBe(1);
+            yield* follower.Unfollow("late-order");
+            yield* follower.Follow({ source: "late-order", from: "start" });
+            for (;;) {
+                const rows = yield* sourceRows("late-order");
+                if (rows.some((row) => row.epoch === "3"))
+                    break;
+                yield* Effect.sleep("20 millis");
+            }
+            yield* pause.release;
+            yield* Fiber.join(draining);
+            yield* drain;
+            expect(handlerRuns(fixture, "SubFollower/late-follower")).toBe(2);
+            expect(yield* followerLog("late-follower")).toEqual([
+                "late-order#1:OrderPlaced",
+                "late-order#1:OrderPlaced",
+            ]);
+            expect(yield* cursorRows("SubFollower", "late-follower")).toMatchObject([
+                { epoch: "3", active: true, applied: "1" },
+            ]);
+            expect(yield* sourceRows("late-order")).toMatchObject([
+                {
+                    subscriber_id: "late-follower",
+                    epoch: "3",
+                    active: true,
+                    delivered: "1",
+                    due: false,
+                },
+            ]);
+            expect(yield* tagMismatches).toEqual([]);
+        })),
+    },
+    {
+        name: "makes no change when a control row reruns at the same epoch after a crash",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const order = yield* SubOrder.get("rerun-order");
+            yield* order.Place({ customerId: "x", amount: 1 });
+            yield* test.crashNext("beforeOutboxDelete");
+            yield* (yield* SubFollower.get("rerun-follower")).Follow({ source: "rerun-order" });
+            yield* drain;
+            expect(yield* outboxOf("SubFollower", "rerun-follower", "control")).toBe(1);
+            const registered = yield* sourceRows("rerun-order");
+            yield* order.Place({ customerId: "x", amount: 2 });
+            yield* drain;
+            yield* test.advance(CLAIM_LEASE);
+            expect(yield* outboxOf("SubFollower", "rerun-follower", "control")).toBe(0);
+            expect(yield* followerLog("rerun-follower")).toEqual(["rerun-order#2:OrderPlaced"]);
+            expect(registered).toMatchObject([{ epoch: "1", delivered: "1" }]);
+            expect(yield* sourceRows("rerun-order")).toMatchObject([
+                { epoch: "1", active: true, delivered: "2" },
+            ]);
+            expect(yield* tagMismatches).toEqual([]);
+        })),
+    },
+    {
+        name: "registers a subscription once when the relay dies after the control claim, before the registration statement",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            yield* test.crashNext("afterClaim");
+            yield* (yield* SubFollower.get("claimdie-follower")).Follow({ source: "claimdie-order" });
+            yield* drain;
+            expect(yield* sourceRows("claimdie-order")).toEqual([]);
+            yield* test.advance(CLAIM_LEASE);
+            yield* (yield* SubOrder.get("claimdie-order")).Place({ customerId: "c", amount: 1 });
+            yield* drain;
+            expect(yield* followerLog("claimdie-follower")).toEqual(["claimdie-order#1:OrderPlaced"]);
+            expect(yield* tagMismatches).toEqual([]);
+        })),
+    },
+];

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

@@ -0,0 +1,4 @@
+import type { ConformanceCase } from "../../conformance.ts";
+import { type SubscriptionsFixture } from "./actors.ts";
+/** Blocking, ordering, and backoff of failing subscription deliveries. */
+export declare const subscriptionFailureConformance: ReadonlyArray<ConformanceCase<SubscriptionsFixture>>;