@rikalabs/akter 0.1.0-alpha.0

package/dist/testing/conformance/transports/actors.js

@@ -0,0 +1,163 @@
+import { DateTime, Effect, Layer, Option, Schema, Stream } from "effect";
+import { Actor, User } from "../../../index.js";
+import { Unauthorized } from "../../../errors/actor.js";
+import { bearerToken } from "../../../serve/auth.js";
+import { Auth } from "../../../runtime/index.js";
+export const Said = Actor.event("Said", { text: Schema.String });
+export class Hello extends Schema.TaggedClass()("Hello", {
+    name: Schema.String,
+    resumed: Schema.Boolean,
+}) {
+}
+export class Say extends Schema.TaggedClass()("Say", { text: Schema.String }) {
+}
+export class Banned extends Schema.TaggedError()("Banned", { name: Schema.String }) {
+}
+/** A member frame whose body looks like the holder's control message. */
+export const ForgedResync = Schema.TaggedStruct("Resync", { after: Schema.String });
+export const Chat = Actor.connection("Chat", {
+    payload: Schema.Struct({ name: Schema.String }),
+    server: Schema.Union([Said, Hello]),
+    client: Say,
+    session: Schema.Struct({ name: Schema.String }),
+    error: Banned,
+});
+const Blind = Actor.connection("Blind", { server: Said, stampCursor: false });
+const Post = Actor.command("Post", { payload: Schema.String });
+export const Percent = Schema.Struct({ percent: Schema.Finite });
+/** An effect whose executor reports how far it got, one step at a time. */
+const Render = Actor.job("Render", {
+    payload: { steps: Schema.Int },
+    progress: Percent,
+});
+const Start = Actor.command("Start", { payload: Schema.Int });
+/** Receives Render's progress on every open connection, and no member frames. */
+const Watch = Actor.connection("Watch", {
+    server: Said,
+    progress: { jobs: [Render], to: "all" },
+});
+/** The actor served over WebSocket; its short revocation bound keeps revocation cases fast. */
+export const SocketRoom = Actor.make("SocketRoom", {
+    key: Schema.String,
+    events: [Said],
+    jobs: { Render: { job: Render, retry: { times: 0 }, progressEvery: "50 millis" } },
+    api: { Chat, Blind, Post, Start, Watch },
+    policy: {
+        reauthorizeEvery: "2 seconds",
+    },
+});
+const socketLayer = SocketRoom.toLayer(Effect.succeed({
+    Post: Effect.fnUntraced(function* (text) {
+        const turn = yield* SocketRoom.Turn;
+        yield* turn.emit(Said.make({ text }));
+        yield* turn.broadcast(Chat, Said.make({ text }));
+        yield* turn.broadcast(Blind, Said.make({ text }));
+    }),
+    Chat: {
+        open: Effect.fnUntraced(function* ({ name }) {
+            const conn = yield* SocketRoom.Connection;
+            if (name === "mallory")
+                return yield* Banned.make({ name });
+            yield* conn.session.set({ name });
+            yield* conn.send(Hello.make({ name, resumed: conn.resumed }));
+        }),
+        frame: Effect.fnUntraced(function* (frame) {
+            const conn = yield* SocketRoom.Connection;
+            const session = Option.getOrElse(yield* conn.session.get, () => ({ name: "" }));
+            if (frame.text === "whoami")
+                return yield* conn.send(Hello.make({ name: session.name, resumed: conn.resumed }));
+            if (frame.text === "history") {
+                for (const entry of yield* conn.events(Said, { after: undefined }).pipe(Effect.orDie))
+                    yield* conn.send(entry);
+                return;
+            }
+            yield* (yield* SocketRoom.get(conn.id)).Post(frame.text).pipe(Effect.orDie);
+        }),
+        resync: Effect.fnUntraced(function* ({ after }) {
+            const conn = yield* SocketRoom.Connection;
+            for (const entry of yield* conn.events(Said, { after }).pipe(Effect.orDie))
+                yield* conn.send(entry);
+        }),
+    },
+    Blind: { open: () => Effect.void, frame: () => Effect.void },
+    Start: Effect.fnUntraced(function* (steps) {
+        yield* (yield* SocketRoom.Turn).enqueue(Render.make({ steps }));
+    }),
+    Watch: { open: () => Effect.void, frame: () => Effect.void },
+}));
+const renderLayer = SocketRoom.toJobLayer(Effect.succeed({
+    Render: Effect.fnUntraced(function* ({ steps }) {
+        const exec = yield* SocketRoom.Executor;
+        for (let step = 1; step <= steps; step++) {
+            yield* exec.progress(Render, { percent: (100 * step) / steps });
+            yield* Effect.sleep("50 millis");
+        }
+    }),
+}));
+const Noted = Actor.event("Noted", { text: Schema.String });
+const Tell = Actor.command("Tell", { payload: Schema.String });
+const Note = Actor.command("Note", { payload: Schema.String });
+const Burst = Actor.command("Burst", { payload: Schema.Int });
+export class Refused extends Schema.TaggedError()("Refused", { at: Schema.Finite }) {
+}
+/** `count` numbers, then its own end; a count over 100 is refused after the first element. */
+const Count = Actor.stream("Count", {
+    payload: Schema.Finite,
+    success: Schema.Finite,
+    error: Refused,
+});
+/** Committed `Said` texts after `after`, then each new one as it commits. */
+const Heard = Actor.stream("Heard", {
+    payload: Schema.Struct({ after: Schema.optional(Schema.String) }),
+    success: Schema.String,
+});
+/** The actor served as an event feed: `Said` is served, `Noted` is declared but not a feed. */
+export const FeedRoom = Actor.make("FeedRoom", {
+    key: Schema.String,
+    events: [Said, Noted],
+    feeds: [Said],
+    api: { Tell, Note, Burst, Count, Heard },
+    policy: { reauthorizeEvery: "2 seconds" },
+});
+const feedLayer = FeedRoom.toLayer(Effect.succeed({
+    Tell: Effect.fnUntraced(function* (text) {
+        yield* (yield* FeedRoom.Turn).emit(Said.make({ text }));
+    }),
+    Note: Effect.fnUntraced(function* (text) {
+        yield* (yield* FeedRoom.Turn).emit(Noted.make({ text }));
+    }),
+    Count: (count) => count > 100
+        ? Stream.concat(Stream.make(1), Stream.fail(Refused.make({ at: 1 })))
+        : Stream.range(1, count),
+    Heard: ({ after }) => Stream.unwrap(Effect.map(FeedRoom.Read, (read) => read.follow(Said, { after }).pipe(Stream.map((entry) => entry.event.text)))).pipe(Stream.orDie),
+    Burst: Effect.fnUntraced(function* (count) {
+        const turn = yield* FeedRoom.Turn;
+        for (let index = 0; index < count; index++)
+            yield* turn.emit(Said.make({ text: `burst-${index}` }));
+    }),
+}));
+/**
+ * `tenant:subject`, or `tenant:subject:expiresAtMs` for a credential with an
+ * expiry, which the holder enforces on its own clock; `expired` is refused.
+ * Read from `hello`, `reauthenticate`, or the upgrade's `authorization`.
+ */
+export const tokens = Auth.make((request) => Effect.gen(function* () {
+    const token = yield* bearerToken(request);
+    if (token === "expired")
+        return yield* Unauthorized.make({ code: "expired" });
+    const match = /^([^:]+):([^:]+)(?::(\d+))?$/.exec(token);
+    if (match === null)
+        return yield* Unauthorized.make({ code: "invalid_credentials" });
+    const authenticated = {
+        tenant: match[1],
+        caller: User.make({ subject: match[2] }),
+    };
+    return match[3] === undefined
+        ? authenticated
+        : { ...authenticated, expiresAt: DateTime.makeUnsafe(Number(match[3])) };
+}));
+export const transportsLayer = Layer.mergeAll(socketLayer, renderLayer, feedLayer);
+/** Transport actors. */
+export const transportsSuite = {
+    layer: () => transportsLayer,
+};

package/dist/testing/conformance/transports/client.d.ts

@@ -0,0 +1,3 @@
+import type { ConformanceCase } from "../../conformance.ts";
+/** The Promise client's feeds, connections, progress, and resync over served transports. */
+export declare const transportClientConformance: ReadonlyArray<ConformanceCase>;

package/dist/testing/conformance/transports/client.js

@@ -0,0 +1,237 @@
+import { Effect, Layer, Predicate, Schema, Stream } from "effect";
+import { FetchHttpClient } from "effect/http";
+import { SqlClient } from "effect/sql";
+import { User } from "../../../index.js";
+import { RetentionGap, UnknownCursor } from "../../../errors/events.js";
+import { InternalActors } from "../../../runtime/actors.js";
+import { ActorTest } from "../../actor-test.js";
+import { ActorCluster } from "../../cluster.js";
+import { Banned, FeedRoom, Hello, Percent, Said, Say, SocketRoom, transportsLayer, } from "./actors.js";
+import { asFailure, serveSockets, socket } from "./wire.js";
+import { setup } from "./harness.js";
+/** The Promise client's feeds, connections, progress, and resync over served transports. */
+export const transportClientConformance = [
+    {
+        name: "client reads an event feed as an AsyncIterable and resumes from its cursor after the response drops",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { host, token } = yield* setup(environment);
+            const room = yield* FeedRoom.get("client-feed");
+            yield* room.Tell("one");
+            yield* room.Tell("two");
+            const requests = [];
+            const send = yield* FetchHttpClient.Fetch;
+            let dropped = false;
+            const flaky = (input, init) => send(input, init).then((response) => {
+                requests.push(new Headers(init?.headers).get("last-event-id"));
+                if (dropped || response.body === null)
+                    return response;
+                dropped = true;
+                const reader = response.body.getReader();
+                const cut = new ReadableStream({
+                    pull: (controller) => reader.read().then((chunk) => {
+                        if (chunk.done)
+                            return controller.close();
+                        const text = new TextDecoder().decode(chunk.value);
+                        const end = text.indexOf("\n\n");
+                        if (end === -1)
+                            return controller.enqueue(chunk.value);
+                        controller.enqueue(new TextEncoder().encode(text.slice(0, end + 2)));
+                        void reader.cancel();
+                        controller.error(new Error("connection lost"));
+                    }),
+                });
+                return new Response(cut, { status: response.status, headers: response.headers });
+            });
+            const handle = FeedRoom.client({
+                baseUrl: `http://${host}/api`,
+                headers: () => ({ authorization: token() }),
+                fetch: flaky,
+            }).get("client-feed");
+            const iterated = Stream.fromAsyncIterable(handle.events(Said), asFailure).pipe(Stream.map((entry) => `${entry.cursor}:${entry.event.text}`));
+            const [first, second] = yield* iterated.pipe(Stream.take(2), Stream.runCollect);
+            const resumed = FeedRoom.client({
+                baseUrl: `http://${host}/api`,
+                headers: { authorization: token() },
+            })
+                .get("client-feed")
+                .events(Said, { after: "2" });
+            yield* room.Tell("three");
+            const [third] = yield* Stream.fromAsyncIterable(resumed, asFailure).pipe(Stream.map((entry) => `${entry.cursor}:${entry.event.text}`), Stream.take(1), Stream.runCollect);
+            const received = [first, second, third];
+            expect(received).toEqual(["1:one", "2:two", "3:three"]);
+            expect(requests.slice(0, 2)).toEqual([null, "1"]);
+        })),
+    },
+    {
+        name: "client feed reopens with fresh headers when its credential expires, and loses nothing",
+        timeoutMs: 40_000,
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { test, host } = yield* setup(environment);
+            const holder = (yield* InternalActors).holder;
+            const room = yield* FeedRoom.get("client-expiry");
+            yield* room.Tell("before");
+            const send = yield* FetchHttpClient.Fetch;
+            const services = yield* Effect.context();
+            let opened = 0;
+            const handle = FeedRoom.client({
+                baseUrl: `http://${host}/api`,
+                headers: () => Effect.runPromiseWith(services)(Effect.map(holder.now, (now) => ({
+                    authorization: `Bearer ${test.tenant}:alice:${now + 1_500}`,
+                }))),
+                fetch: (input, init) => send(input, init).then((response) => {
+                    if (response.ok)
+                        opened += 1;
+                    return response;
+                }),
+            }).get("client-expiry");
+            const entries = Stream.fromAsyncIterable(handle.events(Said), asFailure).pipe(Stream.map((entry) => entry.event.text));
+            const received = yield* entries.pipe(Stream.tap((text) => text === "before"
+                ? Effect.sleep("2500 millis").pipe(Effect.andThen(room.Tell("after expiry")))
+                : Effect.void), Stream.take(2), Stream.runCollect, Effect.timeout("20 seconds"), Effect.orDie);
+            expect([...received]).toEqual(["before", "after expiry"]);
+            expect(opened).toBe(2);
+        })),
+    },
+    {
+        name: "client feed fails with RetentionGap for a pruned cursor and UnknownCursor for one never issued",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { host, token } = yield* setup(environment);
+            const room = yield* FeedRoom.get("client-gap");
+            yield* room.Tell("a");
+            yield* room.Tell("b");
+            const sql = yield* SqlClient.SqlClient;
+            yield* sql `DELETE FROM actor_events WHERE tenant_id = ${room.ref.tenant}
+            AND actor_type = ${room.ref.actor} AND actor_id = ${room.ref.id} AND sequence = 1`.pipe(Effect.orDie);
+            const handle = FeedRoom.client({
+                baseUrl: `http://${host}/api`,
+                headers: { authorization: token() },
+            }).get("client-gap");
+            const first = (after) => Stream.fromAsyncIterable(handle.events(Said, { after }), asFailure).pipe(Stream.runHead, Effect.flip);
+            expect(yield* first("0")).toBeInstanceOf(RetentionGap);
+            expect(yield* first("99")).toBeInstanceOf(UnknownCursor);
+        })),
+    },
+    {
+        name: "client opens a connection with typed frames both ways, rejects a declared open failure or a failing headers provider, and ends on close",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { host, token } = yield* setup(environment);
+            const handle = SocketRoom.client({
+                baseUrl: `http://${host}/api`,
+                headers: () => ({ authorization: token() }),
+            }).get("client-socket");
+            const refused = yield* Effect.tryPromise({
+                try: () => handle.Chat.connect({ name: "mallory" }),
+                catch: asFailure,
+            }).pipe(Effect.flip);
+            expect(refused).toBeInstanceOf(Banned);
+            const connection = yield* Effect.promise(() => handle.Chat.connect({ name: "alice" }));
+            expect(connection.cursor).toBe("0");
+            const iterator = connection.frames[Symbol.asyncIterator]();
+            const next = Effect.promise(() => iterator.next());
+            expect((yield* next).value).toEqual(Hello.make({ name: "alice", resumed: false }));
+            yield* Effect.promise(() => connection.send(Say.make({ text: "hi" })));
+            expect((yield* next).value).toEqual(Said.make({ text: "hi" }));
+            yield* Effect.promise(() => connection.close());
+            expect((yield* next).done).toBe(true);
+            const refresh = new Error("token refresh failed");
+            const failing = SocketRoom.client({
+                baseUrl: `http://${host}/api`,
+                headers: () => Promise.reject(refresh),
+            }).get("client-socket");
+            const unsent = yield* Effect.promise(() => failing.Chat.connect({ name: "alice" }).then(() => "opened", (thrown) => thrown));
+            expect(unsent).toBe(refresh);
+        })),
+    },
+    {
+        name: "carries executor progress over WebSocket as its own progress message, and the client yields it decoded apart from frames",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { host, token } = yield* setup(environment);
+            const room = yield* SocketRoom.get("ws-progress");
+            const ws = yield* socket(host, "ws-progress", { member: "Watch" });
+            yield* ws.send({ t: "hello", authorization: token() });
+            yield* ws.until("open");
+            const client = SocketRoom.client({
+                baseUrl: `http://${host}/api`,
+                headers: () => ({ authorization: token() }),
+            }).get("ws-progress");
+            const connection = yield* Effect.promise(() => client.Watch.connect());
+            const iterator = connection.messages[Symbol.asyncIterator]();
+            yield* room.Start(10);
+            const [wire] = (yield* ws.until("progress")).filter((message) => message.t === "progress");
+            expect(wire).toMatchObject({ t: "progress", job: "Render", attempt: 1 });
+            expect(Predicate.hasProperty(wire, "cursor") || Predicate.hasProperty(wire, "event")).toBe(false);
+            expect(wire?.t === "progress" && wire.seq >= 1).toBe(true);
+            expect(Schema.is(Percent)(wire?.t === "progress" ? wire.frame : undefined)).toBe(true);
+            const received = yield* Effect.promise(() => iterator.next());
+            const progress = received.value?._tag === "Progress" ? received.value : undefined;
+            expect([progress?.job, progress?.attempt]).toEqual(["Render", 1]);
+            expect(Schema.is(Percent)(progress?.frame)).toBe(true);
+            yield* Effect.promise(() => connection.close());
+        })),
+    },
+    {
+        name: "client resyncs a connection in place after its owner dies: onResync runs, then live frames resume without duplicates",
+        requiresFreshDatabase: true,
+        requiresIndependentConnections: true,
+        timeoutMs: 120_000,
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const database = yield* environment.freshDatabase;
+            const context = yield* Layer.build(ActorTest.cluster({
+                database,
+                runners: 2,
+                shardLockExpiration: "3 seconds",
+                actors: transportsLayer,
+                as: User.make({ subject: "alice" }),
+                authorize: () => Effect.succeed(true),
+            }));
+            yield* Effect.gen(function* () {
+                const cluster = yield* ActorCluster;
+                yield* cluster.ready;
+                let target;
+                for (let index = 0; target === undefined && index < 200; index++) {
+                    const candidate = (yield* cluster.on(0)(SocketRoom.get(`client-crash-${index}`))).ref;
+                    if ((yield* cluster.owner(candidate)) === 1)
+                        target = candidate;
+                }
+                if (target === undefined)
+                    return yield* Effect.die(new Error("Runner 1 owns no probed actor"));
+                const ref = target;
+                const post = (text) => cluster.on(0)(SocketRoom.get(ref.id).pipe(Effect.flatMap((room) => room.Post(text))));
+                const host = yield* cluster.on(0)(serveSockets(environment));
+                const resyncs = [];
+                const handle = SocketRoom.client({
+                    baseUrl: `http://${host}/api`,
+                    headers: { authorization: `Bearer ${ref.tenant}:alice` },
+                }).get(ref.id);
+                const connection = yield* Effect.promise(() => handle.Chat.connect({ name: "alice" }, {
+                    onResync: ({ after }) => {
+                        resyncs.push(after);
+                        throw new Error("the page failed to reload");
+                    },
+                }));
+                const iterator = connection.messages[Symbol.asyncIterator]();
+                const next = Effect.promise(() => iterator.next()).pipe(Effect.map((result) => (result.done === true ? undefined : result.value)), Effect.timeoutOrElse({
+                    duration: "60 seconds",
+                    orElse: () => Effect.die(new Error("No connection message arrived")),
+                }));
+                const seen = next.pipe(Effect.map((message) => message === undefined
+                    ? undefined
+                    : Predicate.isTagged(message, "Frame")
+                        ? { tag: message._tag, frame: message.frame }
+                        : Predicate.isTagged(message, "Resync")
+                            ? { tag: message._tag, after: message.after, reason: message.reason }
+                            : { tag: message._tag }));
+                expect((yield* seen)?.tag).toBe("Frame");
+                yield* post("before");
+                expect(yield* seen).toEqual({ tag: "Frame", frame: Said.make({ text: "before" }) });
+                yield* cluster.kill(1);
+                expect(yield* seen).toEqual({ tag: "Resync", after: "1", reason: "OwnerLost" });
+                expect(yield* seen).toEqual({ tag: "ResyncReplayed" });
+                yield* post("after");
+                expect(yield* seen).toEqual({ tag: "Frame", frame: Said.make({ text: "after" }) });
+                expect(resyncs).toEqual(["1"]);
+                yield* Effect.promise(() => connection.close());
+            }).pipe(Effect.provideContext(context));
+        })),
+    },
+];

package/dist/testing/conformance/transports/feeds.d.ts

@@ -0,0 +1,3 @@
+import type { ConformanceCase } from "../../conformance.ts";
+/** Event feeds over SSE: resume, authorization, expiry, parking, catch-up, and resync. */
+export declare const transportFeedConformance: ReadonlyArray<ConformanceCase>;

package/dist/testing/conformance/transports/feeds.js

@@ -0,0 +1,232 @@
+import { Effect, Fiber, Layer } from "effect";
+import { SqlClient } from "effect/sql";
+import { User } from "../../../index.js";
+import { InternalActors } from "../../../runtime/actors.js";
+import { ActorTest } from "../../actor-test.js";
+import { ActorCluster } from "../../cluster.js";
+import { FeedRoom, transportsLayer } from "./actors.js";
+import { cursorError, decodeEntry, feed, feedReason, rows, setup, take, textOf } from "./harness.js";
+import { serveSockets } from "./wire.js";
+/** Event feeds over SSE: resume, authorization, expiry, parking, catch-up, and resync. */
+export const transportFeedConformance = [
+    {
+        name: "serves an event feed: committed events after the cursor, then live ones, with no gap or repeat through a commit race",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { host, token } = yield* setup(environment);
+            const room = yield* FeedRoom.get("sse-race");
+            yield* room.Tell("one");
+            yield* room.Note("not served");
+            yield* room.Tell("two");
+            const racing = yield* Effect.forEach(Array.from({ length: 20 }, (_, index) => index), (index) => room.Tell(`race-${index}`), { concurrency: 4 }).pipe(Effect.forkScoped);
+            const opened = yield* feed(host, "sse-race", "event=Said&after=0", {
+                authorization: token(),
+            });
+            expect(opened.status).toBe(200);
+            yield* Fiber.join(racing);
+            yield* room.Tell("live");
+            const received = yield* take(opened.messages, 23);
+            const cursors = received.map((message) => Number(message.id));
+            expect(cursors).toEqual([...cursors].sort((left, right) => left - right));
+            expect(new Set(cursors).size).toBe(23);
+            expect(cursors.includes(2)).toBe(false);
+            expect(received.every((message) => message.event === "Said")).toBe(true);
+            expect(yield* textOf(received[0])).toBe("one");
+            expect(yield* textOf(received.at(-1))).toBe("live");
+            const entry = yield* decodeEntry(received[0].data).pipe(Effect.orDie);
+            expect(entry.commandId.startsWith("v1.")).toBe(true);
+        })),
+    },
+    {
+        name: "resumes a feed from Last-Event-ID with no gap or repeat, and answers UnknownCursor and RetentionGap before streaming",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { host, token } = yield* setup(environment);
+            const room = yield* FeedRoom.get("sse-resume");
+            for (const text of ["a", "b", "c", "d"])
+                yield* room.Tell(text);
+            const after = yield* feed(host, "sse-resume", "event=Said&after=2", {
+                authorization: token(),
+            });
+            expect((yield* take(after.messages, 2)).map((message) => message.id)).toEqual(["3", "4"]);
+            const resumed = yield* feed(host, "sse-resume", "event=Said&after=0", {
+                authorization: token(),
+                "last-event-id": "3",
+            });
+            expect((yield* take(resumed.messages, 1)).map((message) => message.id)).toEqual(["4"]);
+            const future = yield* feed(host, "sse-resume", "event=Said&after=99", {
+                authorization: token(),
+            });
+            expect(future.status).toBe(404);
+            expect(yield* cursorError(future.body)).toEqual({ tag: "UnknownCursor", cursor: "99" });
+            const malformed = yield* feed(host, "sse-resume", "event=Said&after=abc", {
+                authorization: token(),
+            });
+            expect(malformed.status).toBe(404);
+            const sql = yield* SqlClient.SqlClient;
+            yield* sql `DELETE FROM actor_events WHERE tenant_id = ${room.ref.tenant}
+            AND actor_type = ${room.ref.actor} AND actor_id = ${room.ref.id} AND sequence <= 2`.pipe(Effect.orDie);
+            const pruned = yield* feed(host, "sse-resume", "event=Said&after=1", {
+                authorization: token(),
+            });
+            expect(pruned.status).toBe(410);
+            expect(yield* cursorError(pruned.body)).toEqual({ tag: "RetentionGap", cursor: "1" });
+            const kept = yield* feed(host, "sse-resume", "event=Said&after=2", {
+                authorization: token(),
+            });
+            expect((yield* take(kept.messages, 2)).map((message) => message.id)).toEqual(["3", "4"]);
+        })),
+    },
+    {
+        name: "answers a feed for a never-created actor with 404 NotCreated and writes no row, and refuses undeclared, missing, and too many event filters",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { host, token } = yield* setup(environment);
+            const headers = { authorization: token() };
+            const ref = (yield* FeedRoom.get("sse-nobody")).ref;
+            const missing = yield* feed(host, "sse-nobody", "event=Said", headers);
+            expect(missing.status).toBe(404);
+            expect(yield* feedReason(missing.body)).toMatchObject({ tag: "NotCreated" });
+            expect(yield* rows(ref)).toEqual({ connections: 0, generations: 0 });
+            yield* (yield* FeedRoom.get("sse-filters")).Tell("x");
+            for (const query of ["event=Noted", "event=Nope", "after=0"]) {
+                const refused = yield* feed(host, "sse-filters", query, headers);
+                expect(refused.status).toBe(404);
+                expect(yield* feedReason(refused.body)).toMatchObject({
+                    tag: "InvalidInput",
+                    code: "unknown_event",
+                });
+            }
+            const many = Array.from({ length: 17 }, () => "event=Said").join("&");
+            expect((yield* feed(host, "sse-filters", many, headers)).status).toBe(200);
+            const distinct = Array.from({ length: 17 }, (_, index) => `event=E${index}`).join("&");
+            const tooMany = yield* feed(host, "sse-filters", distinct, headers);
+            expect(tooMany.status).toBe(400);
+            expect(yield* feedReason(tooMany.body)).toMatchObject({ code: "too_many_filters" });
+            const anonymous = yield* feed(host, "sse-filters", "event=Said", {});
+            expect(anonymous.status).toBe(401);
+        })),
+    },
+    {
+        name: "authorizes a feed per event tag before reading, and revokes a live feed within reauthorizeEvery",
+        timeoutMs: 40_000,
+        run: ({ expect, environment, access }) => environment.run(Effect.gen(function* () {
+            const { host, token } = yield* setup(environment);
+            const room = yield* FeedRoom.get("sse-revoke");
+            yield* room.Tell("before");
+            yield* Effect.gen(function* () {
+                access.denied.add("Said");
+                const refused = yield* feed(host, "sse-revoke", "event=Said", {
+                    authorization: token(),
+                });
+                expect(refused.status).toBe(403);
+                expect(yield* feedReason(refused.body)).toMatchObject({
+                    tag: "Unauthorized",
+                    code: "access_denied",
+                });
+                access.denied.delete("Said");
+                const live = yield* feed(host, "sse-revoke", "event=Said", { authorization: token() });
+                expect(yield* textOf((yield* take(live.messages, 1))[0])).toBe("before");
+                access.denied.add("Said");
+                const [ended] = yield* take(live.messages, 1, 10_000);
+                expect(ended.event).toBe("end");
+                expect(yield* feedReason(ended.data)).toMatchObject({
+                    tag: "Unauthorized",
+                    code: "access_denied",
+                });
+            }).pipe(Effect.ensuring(Effect.sync(() => access.denied.delete("Said"))));
+        })),
+    },
+    {
+        name: "ends a feed at its credential's expiry with Unauthorized expired, and a reconnect from its last cursor loses nothing",
+        timeoutMs: 40_000,
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { test, host, token } = yield* setup(environment);
+            const holder = (yield* InternalActors).holder;
+            const room = yield* FeedRoom.get("sse-expiry");
+            yield* room.Tell("first");
+            const expiring = `Bearer ${test.tenant}:alice:${(yield* holder.now) + 1_500}`;
+            const opened = yield* feed(host, "sse-expiry", "event=Said", { authorization: expiring });
+            const [first] = yield* take(opened.messages, 1);
+            const [ended] = yield* take(opened.messages, 1, 10_000);
+            expect(ended.event).toBe("end");
+            expect(yield* feedReason(ended.data)).toMatchObject({
+                tag: "Unauthorized",
+                code: "expired",
+            });
+            yield* room.Tell("while away");
+            const again = yield* feed(host, "sse-expiry", "event=Said", {
+                authorization: token(),
+                "last-event-id": first.id,
+            });
+            expect(yield* textOf((yield* take(again.messages, 1))[0])).toBe("while away");
+        })),
+    },
+    {
+        name: "keeps an idle feed parked, and delivers an event committed by a command that woke its actor",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { test, host, token } = yield* setup(environment);
+            const room = yield* FeedRoom.get("sse-parked");
+            yield* room.Tell("before");
+            const opened = yield* feed(host, "sse-parked", "event=Said", { authorization: token() });
+            yield* take(opened.messages, 1);
+            yield* test.hibernate(room.ref);
+            yield* room.Tell("woken");
+            expect(yield* textOf((yield* take(opened.messages, 1))[0])).toBe("woken");
+        })),
+    },
+    {
+        name: "catches a lagging feed up from actor_events instead of ending it with SlowConsumer",
+        timeoutMs: 60_000,
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { host, token } = yield* setup(environment);
+            const room = yield* FeedRoom.get("sse-lag");
+            yield* room.Tell("first");
+            const opened = yield* feed(host, "sse-lag", "event=Said", { authorization: token() });
+            yield* take(opened.messages, 1);
+            yield* room.Burst(1_100);
+            const received = yield* take(opened.messages, 1_100);
+            expect(received.map((message) => Number(message.id))).toEqual(Array.from({ length: 1_100 }, (_, index) => index + 2));
+            expect(received.every((message) => message.event === "Said")).toBe(true);
+        })),
+    },
+    {
+        name: "resyncs a feed at its holder after an owner kill with no client-visible gap",
+        requiresFreshDatabase: true,
+        requiresIndependentConnections: true,
+        timeoutMs: 120_000,
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const database = yield* environment.freshDatabase;
+            const context = yield* Layer.build(ActorTest.cluster({
+                database,
+                runners: 2,
+                shardLockExpiration: "3 seconds",
+                actors: transportsLayer,
+                as: User.make({ subject: "alice" }),
+                authorize: () => Effect.succeed(true),
+            }));
+            yield* Effect.gen(function* () {
+                const cluster = yield* ActorCluster;
+                yield* cluster.ready;
+                let target;
+                for (let index = 0; target === undefined && index < 200; index++) {
+                    const candidate = (yield* cluster.on(0)(FeedRoom.get(`sse-crash-${index}`))).ref;
+                    if ((yield* cluster.owner(candidate)) === 1)
+                        target = candidate;
+                }
+                if (target === undefined)
+                    return yield* Effect.die(new Error("Runner 1 owns no probed actor"));
+                const ref = target;
+                const tell = (text) => cluster.on(0)(FeedRoom.get(ref.id).pipe(Effect.flatMap((room) => room.Tell(text))));
+                yield* tell("before");
+                const host = yield* cluster.on(0)(serveSockets(environment));
+                const opened = yield* feed(host, ref.id, "event=Said", {
+                    authorization: `Bearer ${ref.tenant}:alice`,
+                });
+                expect(yield* textOf((yield* take(opened.messages, 1))[0])).toBe("before");
+                yield* cluster.kill(1);
+                yield* tell("after");
+                const [next] = yield* take(opened.messages, 1, 60_000);
+                expect(next.id).toBe("2");
+                expect(yield* textOf(next)).toBe("after");
+            }).pipe(Effect.provideContext(context));
+        })),
+    },
+];