@rikalabs/akter 0.1.0-alpha.0 → 0.1.0-alpha.3

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

@@ -1,253 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,162 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,169 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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>>;