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

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

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

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

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

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

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

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

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