@xandreed/plugin-render 0.8.0-next.0

package/dist/render-surface.conformance.d.ts

@@ -0,0 +1,18 @@
+import { Effect } from "effect";
+import { ConformanceFailure } from "./domain/conformance.entity.js";
+import type { RenderError } from "./domain/render-surface.entity.js";
+import type { UiOutputAdmission } from "./ports/render-output.port.js";
+import type { Render, RenderStore } from "./ports/render.port.js";
+export interface ConformanceCheck {
+    readonly name: string;
+    readonly run: Effect.Effect<void, ConformanceFailure | RenderError>;
+}
+/** A fresh surface implementation and its store for each check, built over the given admission. */
+export interface SurfaceSubject {
+    readonly make: (admission: typeof UiOutputAdmission.Service) => Effect.Effect<{
+        readonly render: typeof Render.Service;
+        readonly store: typeof RenderStore.Service;
+    }, RenderError>;
+}
+/** The contract every Render/RenderStore pair must keep, run against any implementation. */
+export declare const renderSurfaceConformance: (subject: SurfaceSubject) => ReadonlyArray<ConformanceCheck>;

package/dist/render-surface.conformance.js

@@ -0,0 +1,173 @@
+import { Effect, Option, Ref, Schema, Stream } from "effect";
+import { canonicalJson } from "@xandreed/core";
+import { ConformanceFailure } from "./domain/conformance.entity.js";
+import { UiOutputError } from "./domain/render-output.entity.js";
+import { SurfaceCommitted, SurfaceCompleted, SurfaceFrozen, SurfacePlanned } from "./domain/render-surface.entity.js";
+const release = (component) => ({
+  component,
+  version: "1",
+  definitionHash: "a".repeat(64),
+  rendererRelease: "1",
+  tokensHash: "b".repeat(64),
+  layoutVersion: "1"
+}), node = (nodeId, component = "card") => ({ nodeId, release: release(component), props: { title: nodeId }, evidence: [`${nodeId}-fact`] }), snapshot = (nodes, phase = "partial", placeholders = []) => ({
+  phase,
+  spec: { layout: "stack", order: nodes.map((entry) => entry.nodeId) },
+  nodes,
+  placeholders
+}), scopeOf = (messageId = "message-1") => ({
+  threadId: "thread",
+  runId: `run-${messageId}`,
+  messageId,
+  principalId: "guest",
+  fence: 1,
+  surfaceId: "page",
+  baseVersion: Option.none()
+}), detached = { fork: (_tag, work) => Effect.forkDetach(work).pipe(Effect.asVoid) }, allow = { validate: () => Effect.void }, holds = (check) => (condition, message) => condition ? Effect.void : Effect.fail(new ConformanceFailure({ check, message })), failureOf = (check) => (effect) => Effect.matchEffect(effect, {
+  onFailure: (error) => Effect.succeed(error),
+  onSuccess: () => Effect.fail(new ConformanceFailure({ check, message: "expected a failure" }))
+}), isPlanned = Schema.is(SurfacePlanned), isCommitted = Schema.is(SurfaceCommitted), isCompleted = Schema.is(SurfaceCompleted), planned = (records) => records.filter(isPlanned);
+export const renderSurfaceConformance = (subject) => [
+  {
+    name: "identical content opens no new generation",
+    run: Effect.gen(function* () {
+      const expect = holds("identical content opens no new generation"), { render } = yield* subject.make(allow), surface = yield* render.open(scopeOf(), detached), first = yield* surface.publish(snapshot([node("a")])), second = yield* surface.publish(snapshot([node("a")]));
+      yield* expect(first.changed && Option.contains(first.version, "message-1:v1"), "the first publish opens message-1:v1");
+      yield* expect(!second.changed && second.generation === 1, "the same content keeps generation 1");
+    })
+  },
+  {
+    name: "changed content opens the next generation with its own operation ids",
+    run: Effect.gen(function* () {
+      const expect = holds("changed content opens the next generation with its own operation ids"), operations = yield* Ref.make([]), { render } = yield* subject.make({ validate: (_scope, proposal) => Ref.update(operations, (all) => [...all, proposal.operationId]) }), surface = yield* render.open(scopeOf(), detached);
+      yield* surface.publish(snapshot([node("a")]));
+      const second = yield* surface.publish(snapshot([node("a"), node("b")]));
+      yield* expect(Option.contains(second.version, "message-1:v2") && second.generation === 2, "the changed content opens message-1:v2");
+      const ids = yield* Ref.get(operations);
+      yield* expect(canonicalJson(ids) === canonicalJson(["run-message-1:render:1:a", "run-message-1:render:2:a", "run-message-1:render:2:b"]), `operation ids are per generation and node, got ${canonicalJson(ids)}`);
+    })
+  },
+  {
+    name: "completion is recorded once per version",
+    run: Effect.gen(function* () {
+      const expect = holds("completion is recorded once per version"), { render, store } = yield* subject.make(allow), scope = scopeOf(), surface = yield* render.open(scope, detached);
+      yield* surface.publish(snapshot([node("a")], "partial"));
+      const done = yield* surface.publish(snapshot([node("a")], "complete"));
+      yield* surface.publish(snapshot([node("a")], "complete"));
+      const records = yield* store.hydrate(scope);
+      yield* expect(!done.changed, "completing the same content opens no generation");
+      yield* expect(records.filter((record) => isCompleted(record) && !record.frozen).length === 1, "one completion for the version");
+      yield* expect((yield* surface.state).completed, "the state reports completion");
+    })
+  },
+  {
+    name: "a surface frozen elsewhere records a frozen partial completion instead of failing",
+    run: Effect.gen(function* () {
+      const expect = holds("a surface frozen elsewhere records a frozen partial completion instead of failing"), { render, store } = yield* subject.make(allow), scope = scopeOf(), surface = yield* render.open(scope, detached);
+      yield* surface.publish(snapshot([node("a")]));
+      yield* store.freeze(scope, SurfaceFrozen.make({ surfaceId: "page", messageId: "message-1", versionId: "message-1:v1", reason: "interaction" }));
+      const late = yield* surface.publish(snapshot([node("b")]));
+      yield* surface.publish(snapshot([node("c")]));
+      const records = yield* store.hydrate(scope);
+      yield* expect(late.frozen && !late.changed && Option.contains(late.version, "message-1:v1"), "the publish reports the frozen version");
+      yield* expect(planned(records).length === 1, "no generation is planned after the freeze");
+      yield* expect(records.filter((record) => isCompleted(record) && record.frozen && record.phase === "partial").length === 1, "one frozen, partial completion");
+    })
+  },
+  {
+    name: "fill commits into a declared placeholder after freezing",
+    run: Effect.gen(function* () {
+      const expect = holds("fill commits into a declared placeholder after freezing"), { render } = yield* subject.make(allow), surface = yield* render.open(scopeOf(), detached);
+      yield* surface.publish(snapshot([node("a")], "complete", ["media"]));
+      yield* surface.freeze("completion");
+      const receipt = yield* surface.fill("media", node("media", "image")), unknown = yield* failureOf("fill")(surface.fill("other", node("other", "image")));
+      yield* expect(receipt.nodeId === "media", "the fill commits the placeholder node");
+      yield* expect(unknown.code === "invalid", "an undeclared placeholder is rejected");
+      yield* expect((yield* surface.state).components.includes("image"), "the filled component is part of the state");
+    })
+  },
+  {
+    name: "preparations run one at a time and settled waits for them",
+    run: Effect.gen(function* () {
+      const expect = holds("preparations run one at a time and settled waits for them"), { render, store } = yield* subject.make(allow), scope = scopeOf(), surface = yield* render.open(scope, detached), slowly = (snapshots) => Stream.fromIterable(snapshots).pipe(Stream.tap(() => Effect.sleep("5 millis")));
+      yield* surface.prepare(slowly([snapshot([node("first")]), snapshot([node("first"), node("second")])]), () => Effect.void);
+      yield* surface.prepare(slowly([snapshot([node("third")], "complete")]), () => Effect.void);
+      const during = yield* surface.state;
+      yield* surface.settled;
+      const after = yield* surface.state, order = planned(yield* store.hydrate(scope)).map((record) => record.nodes.join("+"));
+      yield* expect(during.pending && !after.pending, "pending while preparing, not after settled");
+      yield* expect(canonicalJson(order) === canonicalJson(["first", "first+second", "third"]), `preparations did not interleave, got ${canonicalJson(order)}`);
+      yield* expect(after.completed && after.generation === 3, "the last preparation completed generation 3");
+    })
+  },
+  {
+    name: "a failed preparation is recovered and settles",
+    run: Effect.gen(function* () {
+      const expect = holds("a failed preparation is recovered and settles"), { render } = yield* subject.make(allow), surface = yield* render.open(scopeOf(), detached), recovered = yield* Ref.make(!1);
+      yield* surface.prepare(Stream.fail("composer unavailable"), () => Ref.set(recovered, !0));
+      yield* surface.settled;
+      yield* expect(yield* Ref.get(recovered), "recover runs with the failure");
+      yield* expect(!(yield* surface.state).pending, "nothing is pending afterwards");
+    })
+  },
+  {
+    name: "reopening resumes the generation and deduplication",
+    run: Effect.gen(function* () {
+      const expect = holds("reopening resumes the generation and deduplication"), { render } = yield* subject.make(allow);
+      yield* (yield* render.open(scopeOf(), detached)).publish(snapshot([node("a")]));
+      const again = yield* render.open(scopeOf(), detached), state = yield* again.state, repeat = yield* again.publish(snapshot([node("a")]));
+      yield* expect(state.generation === 1 && Option.contains(state.version, "message-1:v1"), "the reopened surface is at message-1:v1");
+      yield* expect(!repeat.changed, "republishing the same content is deduplicated after reopening");
+      yield* expect(again.records.length > 0, "the hydrated records are exposed");
+    })
+  },
+  {
+    name: "a rejected component is never committed",
+    run: Effect.gen(function* () {
+      const expect = holds("a rejected component is never committed"), { render, store } = yield* subject.make({ validate: () => Effect.fail(new UiOutputError({ code: "forbidden", message: "Release revoked" })) }), scope = scopeOf(), surface = yield* render.open(scope, detached), failure = yield* failureOf("rejected")(surface.publish(snapshot([node("a")])));
+      yield* expect(failure.code === "forbidden", "admission failures keep their code");
+      yield* expect(!(yield* store.hydrate(scope)).some(isCommitted), "nothing was committed");
+    })
+  },
+  {
+    name: "the store commits idempotently and conflicts on different content",
+    run: Effect.gen(function* () {
+      const expect = holds("the store commits idempotently and conflicts on different content"), { store } = yield* subject.make(allow), scope = scopeOf(), proposal = { operationId: "op-1", nodeId: "a", release: release("card"), props: { title: "a" }, evidence: ["a-fact"] }, first = yield* store.commit(scope, { versionId: "message-1:v1", proposal }), retry = yield* store.commit(scope, { versionId: "message-1:v1", proposal }), conflict = yield* failureOf("conflict")(store.commit(scope, { versionId: "message-1:v1", proposal: { ...proposal, props: { title: "b" } } }));
+      yield* expect(canonicalJson(first) === canonicalJson(retry), "a retried commit returns the same receipt");
+      yield* expect(conflict.code === "conflict", "a different proposal under the same operation id conflicts");
+    })
+  },
+  {
+    name: "the store refuses to plan a frozen surface",
+    run: Effect.gen(function* () {
+      const expect = holds("the store refuses to plan a frozen surface"), { store } = yield* subject.make(allow), scope = scopeOf();
+      yield* store.freeze(scope, SurfaceFrozen.make({ surfaceId: "page", messageId: "message-1", versionId: "message-1:v1", reason: "interaction" }));
+      const failure = yield* failureOf("frozen plan")(store.plan(scope, SurfacePlanned.make({
+        surfaceId: "page",
+        messageId: "message-1",
+        versionId: "message-1:v2",
+        generation: 2,
+        baseVersionId: Option.none(),
+        phase: "partial",
+        spec: {},
+        nodes: [],
+        placeholders: [],
+        signature: "x"
+      })));
+      yield* expect(failure.code === "frozen", "planning a frozen surface fails with frozen");
+      const other = yield* store.plan(scopeOf("message-2"), SurfacePlanned.make({
+        surfaceId: "page",
+        messageId: "message-2",
+        versionId: "message-2:v1",
+        generation: 1,
+        baseVersionId: Option.none(),
+        phase: "partial",
+        spec: {},
+        nodes: [],
+        placeholders: [],
+        signature: "y"
+      })).pipe(Effect.result);
+      yield* expect(other._tag === "Success", "a freeze only binds its own message");
+    })
+  }
+];

package/dist/render-surface.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/render-tail.sessions.adapter.d.ts

@@ -0,0 +1,12 @@
+import { Layer } from "effect";
+import { Sessions } from "@xandreed/core";
+import { JournalTail } from "./ports/render.port.js";
+/**
+ * The feed's journal is a session: `threadId` names it and `principalId` is
+ * its owner (another owner reads nothing); each record carries its turn. Reads never write, so following
+ * a session runs nothing. `changes` wakes the feed after each commit this
+ * instance makes; polling covers the others.
+ */
+export declare const SessionsJournalTailLive: (options?: {
+    readonly page: number;
+}) => Layer.Layer<JournalTail, never, Sessions>;

package/dist/render-tail.sessions.adapter.js

@@ -0,0 +1,15 @@
+import { Effect, Layer, Option, Schema, Stream } from "effect";
+import { ConversationId, Sessions } from "@xandreed/core";
+import { RenderError } from "./domain/render-surface.entity.js";
+import { JournalTail } from "./ports/render.port.js";
+const decodeId = Schema.decodeUnknownEffect(ConversationId);
+export const SessionsJournalTailLive = (options = { page: 500 }) => Layer.effect(JournalTail, Effect.gen(function* () {
+  const sessions = yield* Sessions, address = (feed) => decodeId(feed.threadId).pipe(Effect.map((id) => ({ id, owner: feed.principalId })), Effect.mapError(() => new RenderError({ code: "invalid", message: `not a session id: ${feed.threadId}` })));
+  return JournalTail.of({
+    read: (feed, after) => address(feed).pipe(Effect.flatMap((session) => sessions.read(session, { after, limit: options.page }).pipe(Effect.mapError((error) => error._tag === "SessionMissing" ? new RenderError({ code: "forbidden", message: "no such session" }) : new RenderError({ code: "storage", message: error.message })))), Effect.map((events) => events.map((event) => ({ sequence: event.seq, kind: event.kind, data: event.data, turn: Option.getOrNull(event.turn) })))),
+    changes: (feed) => Stream.unwrap(Effect.match(address(feed), {
+      onFailure: () => Stream.empty,
+      onSuccess: (session) => sessions.changes(session)
+    }))
+  });
+}));

package/dist/render-tail.sessions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/render-transport.adapter.d.ts

@@ -0,0 +1,15 @@
+import { Effect } from "effect";
+import type { ServerResponse } from "node:http";
+import type { RenderTransport, SocketPeer, SsePeer } from "./ports/render.port.js";
+export declare const sseHeaders: {
+    readonly "content-type": "text/event-stream; charset=utf-8";
+    readonly "cache-control": "no-store";
+    readonly connection: "keep-alive";
+    readonly "x-accel-buffering": "no";
+};
+/** Server-Sent Events: a retry preamble, then one block per frame until the feed ends or the client leaves. */
+export declare const SseTransport: RenderTransport<SsePeer>;
+/** One JSON text frame per feed frame. Clients resume by sending `{"after": <sequence>}` or the host's equivalent. */
+export declare const WebSocketTransport: RenderTransport<SocketPeer>;
+/** An SSE peer over a Node HTTP response: writes the SSE headers and completes `closed` on disconnect. */
+export declare const sseNodePeer: (response: ServerResponse, headers?: Readonly<Record<string, string>>) => Effect.Effect<SsePeer>;

package/dist/render-transport.adapter.js

@@ -0,0 +1,27 @@
+import { Effect, Stream } from "effect";
+import { encodeSocketFrame, encodeSse, ssePreamble } from "./domain/feed-frame.entity.functions.js";
+export const sseHeaders = {
+  "content-type": "text/event-stream; charset=utf-8",
+  "cache-control": "no-store",
+  connection: "keep-alive",
+  "x-accel-buffering": "no"
+}, SseTransport = {
+  id: "sse",
+  serve: (frames, peer) => peer.write(ssePreamble).pipe(Effect.andThen(Stream.runForEach(frames, (frame) => peer.write(encodeSse(frame)))), Effect.catch(() => Effect.void), Effect.raceFirst(peer.closed))
+}, WebSocketTransport = {
+  id: "websocket",
+  serve: (frames, peer) => Stream.runForEach(frames, (frame) => peer.send(encodeSocketFrame(frame))).pipe(Effect.catch(() => Effect.void), Effect.raceFirst(peer.closed))
+}, sseNodePeer = (response, headers = {}) => Effect.sync(() => {
+  response.writeHead(200, { ...sseHeaders, ...headers });
+  return {
+    write: (chunk) => Effect.callback((resume) => {
+      response.write(chunk, () => resume(Effect.void));
+    }),
+    closed: Effect.callback((resume) => {
+      if (response.closed)
+        resume(Effect.void);
+      else
+        response.once("close", () => resume(Effect.void));
+    })
+  };
+});

package/dist/render-transport.conformance.d.ts

@@ -0,0 +1,24 @@
+import { Effect, Stream } from "effect";
+import type { FeedOptions, JournalRecord } from "./domain/feed-frame.entity.js";
+import type { RenderError } from "./domain/render-surface.entity.js";
+import type { JournalTail, RenderFeed, RenderTransport, SocketPeer, SsePeer } from "./ports/render.port.js";
+import type { ConformanceCheck } from "./render-surface.conformance.js";
+/** The two shipped wires must carry the same frames. */
+export declare const renderTransportConformance: (transports: {
+    readonly sse: RenderTransport<SsePeer>;
+    readonly socket: RenderTransport<SocketPeer>;
+}) => ReadonlyArray<ConformanceCheck>;
+/** An appendable journal for feed checks: `tail` polls only, `wakingTail` also signals each append. */
+export declare const makeMemoryJournal: (initial: ReadonlyArray<JournalRecord>) => Effect.Effect<{
+    tail: {
+        readonly read: (feed: import("./index.js").FeedScope, after: number) => Effect.Effect<ReadonlyArray<JournalRecord>, RenderError>;
+        readonly changes?: (feed: import("./index.js").FeedScope) => Stream.Stream<void, RenderError>;
+    };
+    wakingTail: {
+        readonly read: (feed: import("./index.js").FeedScope, after: number) => Effect.Effect<ReadonlyArray<JournalRecord>, RenderError>;
+        readonly changes?: (feed: import("./index.js").FeedScope) => Stream.Stream<void, RenderError>;
+    };
+    append: (record: JournalRecord) => Effect.Effect<void, never, never>;
+}, never, never>;
+/** The contract of a RenderFeed built over a JournalTail with short intervals. */
+export declare const renderFeedConformance: (makeFeed: (tail: typeof JournalTail.Service, options: FeedOptions) => typeof RenderFeed.Service) => ReadonlyArray<ConformanceCheck>;

package/dist/render-transport.conformance.js

@@ -0,0 +1,71 @@
+import { Effect, Fiber, Option, PubSub, Ref, Stream } from "effect";
+import { canonicalJson } from "@xandreed/core";
+import { ConformanceFailure } from "./domain/conformance.entity.js";
+import { FeedHeartbeat, FeedReady, FeedRecord } from "./domain/feed-frame.entity.js";
+import { decodeSocketFrame, decodeSse } from "./domain/feed-frame.entity.functions.js";
+const holds = (check) => (condition, message) => condition ? Effect.void : Effect.fail(new ConformanceFailure({ check, message })), sample = [
+  FeedRecord.make({ sequence: 1, event: "surface.planned", data: { versionId: "m:v1", nested: { list: [1, 2], text: `line
+break` } } }),
+  FeedReady.make({}),
+  FeedHeartbeat.make({}),
+  FeedRecord.make({ sequence: 2, event: "message.updated", data: { text: "\xE9 \u2713" } })
+];
+export const renderTransportConformance = (transports) => [{
+  name: "SSE and WebSocket carry identical frames",
+  run: Effect.gen(function* () {
+    const expect = holds("SSE and WebSocket carry identical frames"), written = yield* Ref.make([]), sent = yield* Ref.make([]);
+    yield* transports.sse.serve(Stream.fromIterable(sample), { write: (chunk) => Ref.update(written, (all) => [...all, chunk]), closed: Effect.never });
+    yield* transports.socket.serve(Stream.fromIterable(sample), { send: (text) => Ref.update(sent, (all) => [...all, text]), closed: Effect.never });
+    const viaSse = decodeSse((yield* Ref.get(written)).join("")), viaSocket = (yield* Ref.get(sent)).flatMap((text) => Option.toArray(decodeSocketFrame(text)));
+    yield* expect(canonicalJson(viaSse) === canonicalJson(sample), `SSE frames differ: ${canonicalJson(viaSse)}`);
+    yield* expect(canonicalJson(viaSocket) === canonicalJson(sample), `WebSocket frames differ: ${canonicalJson(viaSocket)}`);
+  })
+}], makeMemoryJournal = (initial) => Effect.gen(function* () {
+  const records = yield* Ref.make(initial), appended = yield* PubSub.unbounded(), tail = {
+    read: (_feed, after) => Ref.get(records).pipe(Effect.map((all) => all.filter((record) => record.sequence > after)))
+  }, wakingTail = { ...tail, changes: () => Stream.fromPubSub(appended) };
+  return {
+    tail,
+    wakingTail,
+    append: (record) => Ref.update(records, (all) => [...all, record]).pipe(Effect.andThen(PubSub.publish(appended, void 0)), Effect.asVoid)
+  };
+});
+const project = (record) => Effect.succeed(record.kind === "hidden" ? Option.none() : Option.some({ event: record.kind, data: record.data })), feedScope = { threadId: "thread", principalId: "guest" }, record = (sequence, kind = "message.updated") => ({ sequence, kind, data: { sequence } }), collect = (stream) => Stream.runCollect(stream).pipe(Effect.map((chunk) => Array.from(chunk))), sequences = (frames) => frames.flatMap((frame) => frame._tag === "FeedRecord" ? [frame.sequence] : []);
+export const renderFeedConformance = (makeFeed) => {
+  const options = { pollMs: 5, maxPollMs: 10, heartbeatMs: 30, maxDurationMs: 150 };
+  return [
+    {
+      name: "the feed resumes after the cursor and sends one ready frame",
+      run: Effect.gen(function* () {
+        const expect = holds("the feed resumes after the cursor and sends one ready frame"), journal = yield* makeMemoryJournal([record(1), record(2), record(3)]), frames = yield* collect(makeFeed(journal.tail, options).frames(feedScope, 1, project));
+        yield* expect(canonicalJson(sequences(frames)) === canonicalJson([2, 3]), `records after cursor 1, got ${canonicalJson(sequences(frames))}`);
+        yield* expect(frames.filter((frame) => frame._tag === "FeedReady").length === 1, "exactly one ready frame");
+        yield* expect(frames.findIndex((frame) => frame._tag === "FeedReady") > frames.findIndex((frame) => frame._tag === "FeedRecord"), "ready follows the backlog");
+      })
+    },
+    {
+      name: "an idle feed sends heartbeats and later records in order",
+      run: Effect.gen(function* () {
+        const expect = holds("an idle feed sends heartbeats and later records in order"), journal = yield* makeMemoryJournal([record(1)]), running = yield* Effect.forkChild(collect(makeFeed(journal.tail, options).frames(feedScope, 0, project)));
+        yield* Effect.sleep("60 millis");
+        yield* journal.append(record(2));
+        yield* journal.append(record(3, "hidden"));
+        yield* journal.append(record(4));
+        const frames = yield* Fiber.join(running);
+        yield* expect(canonicalJson(sequences(frames)) === canonicalJson([1, 2, 4]), `in order, hidden records skipped, got ${canonicalJson(sequences(frames))}`);
+        yield* expect(frames.some((frame) => frame._tag === "FeedHeartbeat"), "a heartbeat while idle");
+      })
+    },
+    {
+      name: "a change signal polls at once instead of waiting out the interval",
+      run: Effect.gen(function* () {
+        const expect = holds("a change signal polls at once instead of waiting out the interval"), slow = { pollMs: 5000, maxPollMs: 5000, heartbeatMs: 1e4, maxDurationMs: 1e4 }, journal = yield* makeMemoryJournal([record(1)]), running = yield* Effect.forkChild(collect(makeFeed(journal.wakingTail, slow).frames(feedScope, 0, project).pipe(Stream.takeUntil((frame) => frame._tag === "FeedRecord" && frame.sequence === 2))));
+        yield* Effect.sleep("50 millis");
+        yield* journal.append(record(2));
+        const frames = yield* Fiber.join(running).pipe(Effect.timeout("1 second"), Effect.option);
+        yield* expect(Option.isSome(frames), "the appended record arrived long before the next poll");
+        yield* expect(canonicalJson(sequences(Option.getOrElse(frames, () => []))) === canonicalJson([1, 2]), `records in order, got ${canonicalJson(sequences(Option.getOrElse(frames, () => [])))}`);
+      })
+    }
+  ];
+};

package/dist/render-transport.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@xandreed/plugin-render",
+  "version": "0.8.0-next.0",
+  "type": "module",
+  "description": "Render surfaces, a journal feed and SSE/WebSocket transports for agent output.",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./output": {
+      "types": "./dist/output.d.ts",
+      "default": "./dist/output.js"
+    }
+  },
+  "dependencies": {
+    "@xandreed/core": "0.8.0-next.0",
+    "effect": "4.0.0-rc.118"
+  },
+  "private": false,
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "skills",
+    "profiles",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "license": "MIT"
+}