@rikalabs/akter 0.1.0-alpha.0

package/dist/testing/conformance/statements.js

@@ -0,0 +1,108 @@
+/**
+ * Tables that hold one row per deployment, per actor type, or per runner
+ * rather than per actor, so no `routing_key` names them. Cluster's own
+ * `cluster_*` tables are the same: they stay together in one shard group.
+ */
+export const REGISTRY_TABLES = new Set([
+    "actor_deployment",
+    "actor_placements",
+    "actor_migrations",
+    "actor_payload_versions",
+    "actor_payload_writers",
+    "actor_routed_subscriptions",
+    "actor_content_types",
+    "actor_tables",
+]);
+const collapse = (sql) => sql.replace(/\s+/g, " ").trim();
+/**
+ * The tables a statement names: `INTO t (columns)` and `UPDATE t SET` name a
+ * table, while `FROM f(...)` names a function.
+ */
+const tablesOf = (sql) => {
+    const defined = new Set(Array.from(sql.matchAll(/(?:\bwith\b|,)\s*([a-z_]\w*)\s*(?:\([^)]*\))?\s+as\s*\(/gi), (match) => match[1].toLowerCase()));
+    const named = [
+        ...sql.matchAll(/\b(?:into|update)\s+"?([a-z_]\w*)"?(?![\w"])/gi),
+        ...sql.matchAll(/\b(?:from|join)\s+"?([a-z_]\w*)"?(?![\w"]|\s*\()/gi),
+    ];
+    return new Set(named.flatMap((match) => {
+        const name = match[1].toLowerCase();
+        return defined.has(name) || name === "only" ? [] : [name];
+    }));
+};
+export const scopeOf = (sql) => {
+    const tables = tablesOf(sql);
+    if (tables.size === 0)
+        return "table-free";
+    if (/\bbucket"?\s*(?:=|<|>|between\b|in\b)/i.test(sql))
+        return "scan";
+    if (/\brouting_key"?\s*(?:=|<|>|in\b|between\b|any\b)/i.test(sql))
+        return "keyed";
+    if (/\(\s*"?routing_key"?\s*,/i.test(sql))
+        return "keyed";
+    if (Array.from(tables).every((table) => REGISTRY_TABLES.has(table) || table.startsWith("cluster_")))
+        return "registry";
+    return "unkeyed";
+};
+export const statementLog = () => {
+    const log = {
+        recording: false,
+        seen: new Map(),
+        observe: (statement) => {
+            if (!log.recording)
+                return;
+            const [text, params] = statement.compile();
+            const sql = collapse(text);
+            if (!log.seen.has(sql))
+                log.seen.set(sql, { sql, params });
+        },
+    };
+    return log;
+};
+const SSL_REQUEST = 80877103;
+const GSS_REQUEST = 80877104;
+const SYNC = 0x53;
+const QUERY = 0x51;
+/**
+ * Counts the statements a client sends on one Postgres connection from its
+ * protocol messages, for a relay that sees every byte the client writes:
+ * every extended-protocol statement ends its cycle with one Sync, and a
+ * simple query is one Query message. The startup and encryption requests
+ * that open a connection carry no type byte and are skipped.
+ */
+export const wireStatements = () => {
+    let started = false;
+    let pending = Buffer.alloc(0);
+    return (chunk) => {
+        let statements = 0;
+        pending = pending.length === 0 ? chunk : Buffer.concat([pending, chunk]);
+        while (true) {
+            if (!started) {
+                if (pending.length < 8 || pending.length < pending.readInt32BE(0))
+                    return statements;
+                const code = pending.readInt32BE(4);
+                started = code !== SSL_REQUEST && code !== GSS_REQUEST;
+                pending = pending.subarray(pending.readInt32BE(0));
+                continue;
+            }
+            if (pending.length < 5 || pending.length < 1 + pending.readInt32BE(1))
+                return statements;
+            if (pending[0] === SYNC || pending[0] === QUERY)
+                statements += 1;
+            pending = pending.subarray(1 + pending.readInt32BE(1));
+        }
+    };
+};
+/**
+ * What one external command to a warm activation costs across every pool,
+ * derived from the turn's two groups rather than measured. The admission
+ * flight sends `BEGIN`, the timeout `set_config`, and the fenced read that
+ * resolves the receipt. A command that runs its handler and dirties one key
+ * then sends the state upsert, the receipt insert, `COMMIT`, and the read of
+ * the commit version and the clock its expiry recheck uses: 2 flights and 7
+ * statements. A replay sends `ROLLBACK` and that same read instead: 2 flights
+ * and 5 statements. Nothing is read before delivery or after the turn.
+ */
+export const SERVED_COMMAND = {
+    warm: { flights: 2, statements: 7 },
+    replay: { flights: 2, statements: 5 },
+};

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

@@ -0,0 +1,7 @@
+import { Layer } from "effect";
+import type { ConformanceCase, ConformanceSuite } from "../conformance.ts";
+export declare const streamsLayer: Layer.Layer<never, never, import("../index.ts").InternalActors>;
+/** Stream cases: follows from a cursor have no gap or repeat, refuse unknown cursors, and complete when the handler's stream ends. */
+export declare const streamsConformance: ReadonlyArray<ConformanceCase>;
+/** The stream actor. */
+export declare const streamsSuite: ConformanceSuite;

package/dist/testing/conformance/streams.js

@@ -0,0 +1,280 @@
+import { Cause, Effect, Exit, Fiber, Layer, Option, Schema, Scope, Stream } from "effect";
+import { Actor } from "../../index.js";
+import { ActorError, RunnerAtCapacity, SessionEnded, Unauthorized } from "../../errors/actor.js";
+import { RetentionGap, UnknownCursor } from "../../errors/events.js";
+import { ActorTest } from "../actor-test.js";
+import { ActorCluster } from "../cluster.js";
+const Noted = Actor.event("Noted", { text: Schema.String });
+class Entry extends Schema.TaggedClass()("Entry", {
+    cursor: Schema.String,
+    text: Schema.String,
+}) {
+}
+const Note = Actor.command("Note", { payload: Schema.String });
+/** Committed notes after `after`, then each new one as it commits. */
+const Notes = Actor.stream("Notes", {
+    payload: Schema.Struct({ after: Schema.optional(Schema.String) }),
+    success: Entry,
+    error: Schema.Union([UnknownCursor, RetentionGap]),
+});
+/** Emits `count` elements, then ends by itself. */
+const Count = Actor.stream("Count", { payload: Schema.Finite, success: Schema.Finite });
+/** Emits forever, as fast as the subscriber takes it. */
+const Flood = Actor.stream("Flood", { success: Schema.Finite });
+const Journal = Actor.make("StreamJournal", {
+    key: Schema.String,
+    events: [Noted],
+    api: { Note, Notes, Count, Flood },
+    policy: { hibernateAfter: "1 second" },
+});
+export const streamsLayer = Journal.toLayer(Effect.succeed({
+    Note: Effect.fnUntraced(function* (text) {
+        const turn = yield* Journal.Turn;
+        yield* turn.emit(Noted.make({ text }));
+    }),
+    Notes: ({ after }) => Stream.unwrap(Effect.gen(function* () {
+        const read = yield* Journal.Read;
+        return read
+            .follow(Noted, { after })
+            .pipe(Stream.map((entry) => Entry.make({ cursor: entry.cursor, text: entry.event.text })));
+    })),
+    Count: (count) => Stream.range(1, count),
+    Flood: () => Stream.iterate(0, (index) => index + 1),
+}));
+const WAIT = "20 seconds";
+const take = (stream, count) => stream.pipe(Stream.take(count), Stream.runCollect, Effect.map((chunk) => [...chunk]), Effect.timeoutOrElse({
+    duration: WAIT,
+    orElse: () => Effect.die(new Error("No stream element arrived")),
+}));
+/** The error a subscription ended with, after draining it. */
+const endOf = (stream) => stream.pipe(Stream.runDrain, Effect.exit, Effect.timeoutOrElse({
+    duration: WAIT,
+    orElse: () => Effect.die(new Error("The stream did not end")),
+}), Effect.map((exit) => Exit.isFailure(exit) ? Option.getOrUndefined(Cause.findErrorOption(exit.cause)) : undefined));
+const reasonOf = (error) => Schema.is(ActorError)(error) ? error.reason : undefined;
+/** A running subscription whose elements arrive in order on `next`. */
+const open = (stream) => Effect.gen(function* () {
+    const pull = yield* Stream.toPull(stream);
+    return {
+        next: pull.pipe(Effect.map((chunk) => [...chunk]), Effect.timeoutOrElse({
+            duration: WAIT,
+            orElse: () => Effect.die(new Error("No stream element arrived")),
+        })),
+    };
+});
+/** Reads `count` elements from a pull, however they are chunked. */
+const read = (pull, count) => Effect.gen(function* () {
+    const read = [];
+    while (read.length < count)
+        read.push(...(yield* pull.next));
+    return read;
+});
+const texts = (entries) => entries.map((entry) => entry.text);
+const EXPIRATION_SECONDS = 3;
+const withCluster = (environment, runners, body) => environment.run(Effect.gen(function* () {
+    const database = yield* environment.freshDatabase;
+    const context = yield* Layer.build(ActorTest.cluster({
+        database,
+        runners,
+        shardLockExpiration: `${EXPIRATION_SECONDS} seconds`,
+        actors: streamsLayer,
+    }));
+    return yield* body.pipe(Effect.scoped, Effect.provideContext(context));
+}));
+/** An actor id that `runner` owns, probed through runner 0. */
+const ownedBy = (runner, prefix) => Effect.gen(function* () {
+    const cluster = yield* ActorCluster;
+    for (let index = 0; index < 200; index++) {
+        const candidate = (yield* cluster.on(0)(Journal.get(`${prefix}-${index}`))).ref;
+        if ((yield* cluster.owner(candidate)) === runner)
+            return candidate;
+    }
+    return yield* Effect.die(new Error(`Runner ${runner} owns no probed actor`));
+});
+/** Stream cases: follows from a cursor have no gap or repeat, refuse unknown cursors, and complete when the handler's stream ends. */
+export const streamsConformance = [
+    {
+        name: "follows events from a cursor with no gap or repeat between replay and live",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const journal = yield* Journal.get("streams-follow");
+            yield* journal.Note("one");
+            yield* journal.Note("two");
+            yield* journal.Note("three");
+            const [first] = yield* take(journal.Notes({}), 1);
+            expect(first?.text).toBe("one");
+            const pull = yield* open(journal.Notes({ after: first.cursor }));
+            const replayed = yield* read(pull, 2);
+            const writer = yield* Effect.forEach(["four", "five", "six"], journal.Note, {
+                discard: true,
+            }).pipe(Effect.forkChild);
+            const live = yield* read(pull, 3);
+            yield* Fiber.join(writer);
+            const entries = [...replayed, ...live];
+            expect(texts(entries)).toEqual(["two", "three", "four", "five", "six"]);
+            const cursors = entries.map((entry) => BigInt(entry.cursor));
+            expect(cursors.every((cursor, index) => index === 0 || cursor > cursors[index - 1])).toBe(true);
+        })),
+    },
+    {
+        name: "fails a follow from a cursor the actor never issued with its declared UnknownCursor",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const journal = yield* Journal.get("streams-unknown");
+            yield* journal.Note("one");
+            expect(yield* endOf(journal.Notes({ after: "99" }))).toMatchObject(UnknownCursor.make({ cursor: "99" }));
+        })),
+    },
+    {
+        name: "completes a subscription whose handler's stream ends by itself",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const journal = yield* Journal.get("streams-count");
+            const counted = yield* journal.Count(3).pipe(Stream.runCollect, Effect.timeout(WAIT));
+            expect([...counted]).toEqual([1, 2, 3]);
+        })),
+    },
+    {
+        name: "ends a stream with ActivationEnded when its activation stops, and keeps the activation resident while subscribed",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const journal = yield* Journal.get("streams-resident");
+            yield* journal.Note("one");
+            const seen = [];
+            const ending = yield* journal.Notes({}).pipe(Stream.tap((entry) => Effect.sync(() => seen.push(entry))), endOf, Effect.forkChild);
+            yield* Effect.sleep("100 millis").pipe(Effect.repeat({ until: () => seen.length === 1 }), Effect.timeout(WAIT));
+            const generation = (yield* test.inspect(journal.ref)).generation;
+            yield* Effect.sleep("3500 millis");
+            yield* journal.Note("two");
+            yield* Effect.sleep("100 millis").pipe(Effect.repeat({ until: () => seen.length === 2 }), Effect.timeout(WAIT));
+            expect((yield* test.inspect(journal.ref)).generation).toBe(generation);
+            yield* test.hibernate(journal.ref);
+            const reason = reasonOf(yield* Fiber.join(ending));
+            expect(Schema.is(SessionEnded)(reason)).toBe(true);
+            expect(reason).toMatchObject({ cause: "ActivationEnded", resync: false });
+            expect(Schema.is(SessionEnded)(reason) && reason.isRetryable).toBe(true);
+            yield* journal.Note("three");
+            const [resumed] = yield* take(journal.Notes({ after: seen.at(-1).cursor }), 1);
+            expect(resumed?.text).toBe("three");
+        })),
+    },
+    {
+        name: "rejects a subscription its caller may not open, and ends one whose reauthorization is denied",
+        run: ({ expect, environment, access }) => environment.run(Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const journal = yield* Journal.get("streams-revoked");
+            access.allowed = false;
+            const refused = yield* endOf(journal.Count(1)).pipe(Effect.ensuring(Effect.sync(() => (access.allowed = true))));
+            expect(reasonOf(refused)).toMatchObject(Unauthorized.make({ code: "access_denied" }));
+            const pull = yield* open(journal.Flood());
+            yield* read(pull, 1);
+            access.allowed = false;
+            yield* test.advance("55 seconds");
+            const revoked = yield* Effect.gen(function* () {
+                for (;;)
+                    yield* pull.next;
+            }).pipe(Effect.flip, Effect.timeout(WAIT), Effect.ensuring(Effect.sync(() => (access.allowed = true))));
+            expect(revoked).toMatchObject({ reason: Unauthorized.make({ code: "access_denied" }) });
+        })),
+    },
+    {
+        name: "ends a subscription with reauthorization_unavailable at its bound",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const journal = yield* Journal.get("streams-bound");
+            const pull = yield* open(journal.Notes({}));
+            yield* journal.Note("one");
+            yield* read(pull, 1);
+            yield* test.advance("61 seconds");
+            const lapsed = yield* Effect.gen(function* () {
+                for (;;)
+                    yield* pull.next;
+            }).pipe(Effect.flip, Effect.timeout(WAIT));
+            expect(lapsed).toMatchObject({
+                reason: Unauthorized.make({ code: "reauthorization_unavailable" }),
+            });
+        })),
+    },
+    {
+        name: "ends a stream with SlowConsumer after its window stays full for 30 seconds",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const journal = yield* Journal.get("streams-slow");
+            const pull = yield* open(journal.Flood());
+            yield* read(pull, 1);
+            yield* Effect.sleep("1 second");
+            yield* test.advance("31 seconds");
+            yield* Effect.sleep("500 millis");
+            const slow = yield* Effect.gen(function* () {
+                for (;;)
+                    yield* pull.next;
+            }).pipe(Effect.flip, Effect.timeout(WAIT));
+            expect(reasonOf(slow)).toMatchObject({ cause: "SlowConsumer", resync: true });
+        })),
+    },
+    {
+        name: "refuses a subscription past 256 open on one actor with RunnerAtCapacity",
+        timeoutMs: 60_000,
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const journal = yield* Journal.get("streams-limit");
+            const opened = yield* Effect.forEach(Array.from({ length: 260 }), () => Effect.flatMap(open(journal.Flood()), (pull) => read(pull, 1)).pipe(Effect.exit), { concurrency: "unbounded" });
+            const refused = opened.filter(Exit.isFailure);
+            expect(opened.filter(Exit.isSuccess).length).toBe(256);
+            expect(refused.length).toBe(4);
+            expect(refused.map((exit) => reasonOf(Option.getOrUndefined(Cause.findErrorOption(exit.cause))))).toEqual(Array.from({ length: 4 }, () => RunnerAtCapacity.make({})));
+            expect(reasonOf(yield* endOf(journal.Count(1)))).toMatchObject(RunnerAtCapacity.make({}));
+        })),
+    },
+    {
+        name: "delivers a stream from an owner on another runner and ends it with ActivationEnded when that runner is killed",
+        requiresFreshDatabase: true,
+        requiresIndependentConnections: true,
+        timeoutMs: 90_000,
+        run: ({ expect, environment }) => withCluster(environment, 2, Effect.gen(function* () {
+            const cluster = yield* ActorCluster;
+            yield* cluster.ready;
+            const ref = yield* ownedBy(1, "streams-kill");
+            const journal = yield* cluster.on(0)(Journal.get(ref.id));
+            const pull = yield* journal.Notes({}).pipe(open, cluster.on(0));
+            yield* cluster.on(0)(journal.Note("before"));
+            const [before] = yield* read(pull, 1);
+            expect(before?.text).toBe("before");
+            yield* cluster.kill(1);
+            const lost = yield* Effect.gen(function* () {
+                for (;;)
+                    yield* pull.next;
+            }).pipe(Effect.flip, Effect.timeout(WAIT));
+            expect(reasonOf(lost)).toMatchObject({ cause: "ActivationEnded" });
+            yield* cluster.on(0)(journal.Note("after"));
+            const [after] = yield* cluster.on(0)(take(journal.Notes({ after: before.cursor }), 1));
+            expect(after?.text).toBe("after");
+            expect(yield* cluster.owner(ref)).toBe(0);
+        })),
+    },
+    {
+        name: "keeps cursor order in a followed stream written through turns on different runners over time",
+        requiresFreshDatabase: true,
+        requiresIndependentConnections: true,
+        timeoutMs: 120_000,
+        run: ({ expect, environment }) => withCluster(environment, 3, Effect.gen(function* () {
+            const cluster = yield* ActorCluster;
+            yield* cluster.ready;
+            const ref = yield* ownedBy(1, "streams-order");
+            const written = [];
+            const note = (via) => (text) => Effect.andThen(cluster.on(via)(Journal.get(ref.id).pipe(Effect.flatMap((j) => j.Note(text)))), Effect.sync(() => written.push(text)));
+            yield* Effect.forEach(["a1", "a2", "a3"], note(0), { discard: true });
+            yield* cluster.kill(1);
+            yield* Effect.forEach(["b1", "b2", "b3"], note(0), { discard: true });
+            const second = (yield* cluster.owner(ref));
+            const survivor = second === 0 ? 2 : 0;
+            yield* cluster.kill(second);
+            yield* Effect.forEach(["c1", "c2", "c3"], note(survivor), { discard: true });
+            expect(yield* cluster.owner(ref)).toBe(survivor);
+            const followed = yield* cluster.on(survivor)(Journal.get(ref.id).pipe(Effect.flatMap((j) => take(j.Notes({}), written.length))));
+            expect(texts(followed)).toEqual(written);
+            const cursors = followed.map((entry) => BigInt(entry.cursor));
+            expect(cursors).toEqual(cursors.map((_, index) => BigInt(index + 1)));
+        })),
+    },
+];
+/** The stream actor. */
+export const streamsSuite = {
+    layer: () => streamsLayer,
+};

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

@@ -0,0 +1,4 @@
+import type { ConformanceCase } from "../../conformance.ts";
+import { type SubscriptionsFixture } from "./actors.ts";
+/** Tenant isolation, System attribution, and handler access of event subscriptions. */
+export declare const subscriptionAccessConformance: ReadonlyArray<ConformanceCase<SubscriptionsFixture>>;

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

@@ -0,0 +1,98 @@
+import { Cause, Effect, Exit } from "effect";
+import { Tenant } from "../../../index.js";
+import { System } from "../../../identity/caller.js";
+import { ActorTest } from "../../actor-test.js";
+import { OrderDelivery, SubFollower, SubOrder, THROWING_ROUTE, } from "./actors.js";
+import { drain, followerLog, handlerRuns, logOf, run, sourceRows } from "./harness.js";
+import { CLAIM_LEASE } from "../outbox.js";
+/** Tenant isolation, System attribution, and handler access of event subscriptions. */
+export const subscriptionAccessConformance = [
+    {
+        name: "backs a routed row off with last_error when route throws, and holds its later events",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const order = yield* SubOrder.get("throwroute-order");
+            yield* order.Place({ customerId: THROWING_ROUTE, amount: 1 });
+            yield* order.Place({ customerId: "throwroute-ok", amount: 1 });
+            yield* drain;
+            const [summary] = yield* sourceRows("throwroute-order", "SubSummary");
+            expect(summary.delivered).toBe("0");
+            expect(summary.last_error).toContain("Route failed");
+            expect(summary.last_error).toContain("route threw");
+            expect(yield* logOf("SubSummary", "throwroute-ok")).toEqual([]);
+            yield* test.advance(CLAIM_LEASE);
+            expect(yield* logOf("SubSummary", "throwroute-ok")).toEqual([]);
+            expect(yield* logOf("SubAuditor", "throwroute-ok")).toEqual([
+                "throwroute-order#2:OrderPlaced",
+            ]);
+        })),
+    },
+    {
+        name: "keeps equal source ids in two tenants apart",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            yield* (yield* SubFollower.get("tenant-follower")).Follow({ source: "tenant-order" });
+            yield* drain;
+            const other = `${test.tenant}-other`;
+            yield* Effect.gen(function* () {
+                yield* (yield* SubOrder.get("tenant-order")).Place({
+                    customerId: "tenant-c",
+                    amount: 1,
+                });
+            }).pipe(Effect.provideService(Tenant, other));
+            yield* drain;
+            expect(yield* followerLog("tenant-follower")).toEqual([]);
+            const { state } = yield* test.inspect({
+                tenant: other,
+                actor: "SubSummary",
+                id: "tenant-c",
+            });
+            expect(state).toEqual({ log: ["tenant-order#1:OrderPlaced"] });
+            yield* (yield* SubOrder.get("tenant-order")).Place({ customerId: "tenant-c", amount: 2 });
+            yield* drain;
+            expect(yield* followerLog("tenant-follower")).toEqual(["tenant-order#1:OrderPlaced"]);
+        })),
+    },
+    {
+        name: "dies when a non-subscription System caller reaches a handler, and hides handlers from X.intents",
+        run: ({ expect, environment, fixture }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const { system } = yield* test.actor(SubFollower, "forged-follower");
+            const forged = yield* system
+                .OnOrder(OrderDelivery.members[2].make({
+                subscription: "FollowedOrders",
+                source: { tenant: test.tenant, actor: "SubOrder", id: "forged" },
+                reason: "UnknownCursor",
+                cursor: "1",
+            }))
+                .pipe(Effect.exit);
+            expect(Exit.isFailure(forged) &&
+                Cause.pretty(forged.cause).includes("Subscription handlers accept only subscription deliveries")).toBe(true);
+            expect(handlerRuns(fixture, "SubFollower/forged-follower")).toBe(0);
+            expect(yield* (yield* SubFollower.get("forged-follower")).IntentKeys()).toEqual([
+                "Follow",
+                "FollowJournal",
+                "FollowThenRefuse",
+                "IntentKeys",
+                "Touch",
+                "Unfollow",
+            ]);
+        })),
+    },
+    {
+        name: "records System subscription attribution on the delivery, and continues after the subscribing caller's access is revoked",
+        run: ({ expect, environment, fixture, access }) => run(environment, fixture, Effect.gen(function* () {
+            const test = yield* ActorTest;
+            yield* (yield* SubFollower.get("revoked-follower")).Follow({ source: "revoked-order" });
+            yield* drain;
+            yield* (yield* SubOrder.get("revoked-order")).Place({ customerId: "v", amount: 1 });
+            access.allowed = false;
+            yield* drain.pipe(Effect.ensuring(Effect.sync(() => (access.allowed = true))));
+            expect(yield* followerLog("revoked-follower")).toEqual(["revoked-order#1:OrderPlaced"]);
+            expect(fixture.callers.get("revoked-order#1:OrderPlaced")).toEqual(System.make({
+                source: "subscription",
+                ref: { tenant: test.tenant, actor: "SubOrder", id: "revoked-order" },
+            }));
+        })),
+    },
+];