@xandreed/plugin-render 0.8.0-next.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Xand Reed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# @xandreed/plugin-render
+
+Efferent composable agent framework, 0.8.0-next.0. Bun on Linux.
+
+Documentation: https://github.com/xandreeddev/efferent

package/dist/domain/conformance.entity.d.ts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+declare const ConformanceFailure_base: Schema.Class<ConformanceFailure, Schema.TaggedStruct<"ConformanceFailure", {
+    readonly check: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A conformance check that did not hold, naming the check. */
+export declare class ConformanceFailure extends ConformanceFailure_base {
+}
+export {};

package/dist/domain/conformance.entity.js

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+
+export class ConformanceFailure extends Schema.TaggedError()("ConformanceFailure", {
+  check: Schema.String,
+  message: Schema.String
+}) {
+}

package/dist/domain/feed-frame.entity.d.ts

@@ -0,0 +1,63 @@
+import { Schema } from "effect";
+/** Whose journal a feed reads. The host authorizes the principal before opening one. */
+export declare const FeedScope: Schema.Struct<{
+    readonly threadId: Schema.Trimmed;
+    readonly principalId: Schema.Trimmed;
+}>;
+export type FeedScope = typeof FeedScope.Type;
+/** One durable journal record, as the host's tail returns it, in sequence order. */
+export declare const JournalRecord: Schema.Struct<{
+    readonly sequence: Schema.Int;
+    readonly kind: Schema.Trimmed;
+    readonly data: Schema.$Record<Schema.String, Schema.Unknown>;
+    /** The turn the record belongs to, when the journal has turns (a session's does; null outside a turn). */
+    readonly turn: Schema.optional<Schema.NullOr<Schema.Int>>;
+}>;
+export type JournalRecord = typeof JournalRecord.Type;
+/** What a projection makes of a record: the event name and payload a client receives. */
+export declare const FeedPayload: Schema.Struct<{
+    readonly event: Schema.Trimmed;
+    readonly data: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+export type FeedPayload = typeof FeedPayload.Type;
+export declare const FeedRecord: Schema.TaggedStruct<"FeedRecord", {
+    readonly sequence: Schema.Int;
+    readonly event: Schema.Trimmed;
+    readonly data: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+/** Sent once, after the first poll finds nothing new: the client has caught up. */
+export declare const FeedReady: Schema.TaggedStruct<"FeedReady", {}>;
+/** Sent when the feed has been idle for the heartbeat interval. */
+export declare const FeedHeartbeat: Schema.TaggedStruct<"FeedHeartbeat", {}>;
+export declare const FeedFrame: Schema.Union<readonly [Schema.TaggedStruct<"FeedRecord", {
+    readonly sequence: Schema.Int;
+    readonly event: Schema.Trimmed;
+    readonly data: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, Schema.TaggedStruct<"FeedReady", {}>, Schema.TaggedStruct<"FeedHeartbeat", {}>]>;
+export type FeedFrame = typeof FeedFrame.Type;
+export declare const FeedOptions: Schema.Struct<{
+    /** Poll interval after new records. */
+    readonly pollMs: Schema.Int;
+    /** Upper bound the idle interval backs off to. */
+    readonly maxPollMs: Schema.Int;
+    readonly heartbeatMs: Schema.Int;
+    /** The feed ends after this long; clients reconnect with their cursor. */
+    readonly maxDurationMs: Schema.Int;
+}>;
+export type FeedOptions = typeof FeedOptions.Type;
+/** WebSocket text frames: one JSON object per frame. */
+export declare const SocketFrame: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"record">;
+    readonly sequence: Schema.Int;
+    readonly event: Schema.Trimmed;
+    readonly data: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"ready">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"heartbeat">;
+}>]>;
+export type SocketFrame = typeof SocketFrame.Type;
+/** The first message a WebSocket client may send to resume after a cursor. */
+export declare const SocketResume: Schema.Struct<{
+    readonly after: Schema.Int;
+}>;

package/dist/domain/feed-frame.entity.functions.d.ts

@@ -0,0 +1,20 @@
+import { Option } from "effect";
+import type { FeedFrame, FeedOptions } from "./feed-frame.entity.js";
+/**
+ * SSE wire format, one block per frame:
+ * - once per connection: `retry: 1000`
+ * - record:    `id: <sequence>` `event: <event>` `data: <json>`
+ * - ready:     `event: ready` `data: {}`
+ * - heartbeat: `: heartbeat` (a comment)
+ * Clients resume by sending `Last-Event-ID: <sequence>`.
+ */
+export declare const ssePreamble = "retry: 1000\n\n";
+export declare const encodeSse: (frame: FeedFrame) => string;
+/** The inverse of `encodeSse` over a whole stream, for clients and tests. */
+export declare const decodeSse: (text: string) => ReadonlyArray<FeedFrame>;
+export declare const encodeSocketFrame: (frame: FeedFrame) => string;
+export declare const decodeSocketFrame: (text: string) => Option.Option<FeedFrame>;
+/** The cursor a WebSocket client asks to resume after (`{"after": n}`). */
+export declare const socketResumeOf: (text: string) => Option.Option<number>;
+/** Back off while idle; poll promptly again once records arrive. */
+export declare const nextPollMs: (current: number, options: FeedOptions, received: boolean) => number;

package/dist/domain/feed-frame.entity.functions.js

@@ -0,0 +1,38 @@
+import { Result, Match, Option, Schema } from "effect";
+import { FeedHeartbeat, FeedReady, FeedRecord, SocketFrame, SocketResume } from "./feed-frame.entity.js";
+export const ssePreamble = `retry: 1000
+
+`, encodeSse = (frame) => Match.valueTags(frame, {
+  FeedRecord: (record) => `id: ${record.sequence}
+event: ${record.event}
+data: ${JSON.stringify(record.data)}
+
+`,
+  FeedReady: () => `event: ready
+data: {}
+
+`,
+  FeedHeartbeat: () => `: heartbeat
+
+`
+});
+const fieldsOf = (block) => new Map(block.split(`
+`).flatMap((line) => {
+  const colon = line.indexOf(":");
+  return colon <= 0 ? [] : [[line.slice(0, colon), line.slice(colon + 1).trimStart()]];
+})), parseObject = (text) => Result.getSuccess(Schema.decodeUnknownResult(Schema.fromJsonString(Schema.Record(Schema.String, Schema.Unknown)))(text)), decodeSseBlock = (block) => {
+  if (block.startsWith(": heartbeat"))
+    return [FeedHeartbeat.make({})];
+  const fields = fieldsOf(block), event = fields.get("event");
+  if (event === "ready")
+    return [FeedReady.make({})];
+  const id = Number(fields.get("id")), data = parseObject(fields.get("data") ?? "");
+  return event === void 0 || !Number.isInteger(id) || Option.isNone(data) ? [] : [FeedRecord.make({ sequence: id, event, data: data.value })];
+};
+export const decodeSse = (text) => text.split(`
+
+`).filter((block) => block.length > 0).flatMap(decodeSseBlock), encodeSocketFrame = (frame) => JSON.stringify(Match.valueTags(frame, {
+  FeedRecord: (record) => ({ type: "record", sequence: record.sequence, event: record.event, data: record.data }),
+  FeedReady: () => ({ type: "ready" }),
+  FeedHeartbeat: () => ({ type: "heartbeat" })
+})), decodeSocketFrame = (text) => Result.getSuccess(Schema.decodeUnknownResult(Schema.fromJsonString(SocketFrame))(text)).pipe(Option.map((frame) => Match.value(frame).pipe(Match.when({ type: "record" }, (record) => FeedRecord.make({ sequence: record.sequence, event: record.event, data: record.data })), Match.when({ type: "ready" }, () => FeedReady.make({})), Match.orElse(() => FeedHeartbeat.make({}))))), socketResumeOf = (text) => Result.getSuccess(Schema.decodeUnknownResult(Schema.fromJsonString(SocketResume))(text)).pipe(Option.map((resume) => resume.after)), nextPollMs = (current, options, received) => received ? options.pollMs : Math.min(options.maxPollMs, Math.max(options.pollMs, current * 2));

package/dist/domain/feed-frame.entity.js

@@ -0,0 +1,21 @@
+import { Schema } from "effect";
+const Id = Schema.Trimmed.check(Schema.isNonEmpty()), Json = Schema.Record(Schema.String, Schema.Unknown);
+export const FeedScope = Schema.Struct({ threadId: Id, principalId: Id }), JournalRecord = Schema.Struct({
+  sequence: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))),
+  kind: Id,
+  data: Json,
+  turn: Schema.optional(Schema.NullOr(Schema.Int))
+}), FeedPayload = Schema.Struct({ event: Id, data: Json }), FeedRecord = Schema.TaggedStruct("FeedRecord", {
+  sequence: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))),
+  event: Id,
+  data: Json
+}), FeedReady = Schema.TaggedStruct("FeedReady", {}), FeedHeartbeat = Schema.TaggedStruct("FeedHeartbeat", {}), FeedFrame = Schema.Union([FeedRecord, FeedReady, FeedHeartbeat]), FeedOptions = Schema.Struct({
+  pollMs: Schema.Int.pipe(Schema.check(Schema.isGreaterThan(0))),
+  maxPollMs: Schema.Int.pipe(Schema.check(Schema.isGreaterThan(0))),
+  heartbeatMs: Schema.Int.pipe(Schema.check(Schema.isGreaterThan(0))),
+  maxDurationMs: Schema.Int.pipe(Schema.check(Schema.isGreaterThan(0)))
+}), SocketFrame = Schema.Union([
+  Schema.Struct({ type: Schema.Literal("record"), sequence: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))), event: Id, data: Json }),
+  Schema.Struct({ type: Schema.Literal("ready") }),
+  Schema.Struct({ type: Schema.Literal("heartbeat") })
+]), SocketResume = Schema.Struct({ after: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))) });

package/dist/domain/render-output.entity.d.ts

@@ -0,0 +1,51 @@
+import { Schema } from "effect";
+/** Immutable references: a release is never resolved through a latest alias. */
+export declare const UiRelease: Schema.Struct<{
+    readonly component: Schema.Trimmed;
+    readonly version: Schema.Trimmed;
+    readonly definitionHash: Schema.String;
+    readonly rendererRelease: Schema.Trimmed;
+    readonly tokensHash: Schema.String;
+    readonly layoutVersion: Schema.Trimmed;
+}>;
+export type UiRelease = typeof UiRelease.Type;
+/** IDs of facts/artifacts are resolved by the host, never executable content. */
+export declare const UiOutputProposal: Schema.Struct<{
+    readonly operationId: Schema.Trimmed;
+    readonly nodeId: Schema.Trimmed;
+    readonly release: Schema.Struct<{
+        readonly component: Schema.Trimmed;
+        readonly version: Schema.Trimmed;
+        readonly definitionHash: Schema.String;
+        readonly rendererRelease: Schema.Trimmed;
+        readonly tokensHash: Schema.String;
+        readonly layoutVersion: Schema.Trimmed;
+    }>;
+    readonly props: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly evidence: Schema.$Array<Schema.Trimmed>;
+}>;
+export type UiOutputProposal = typeof UiOutputProposal.Type;
+/** The host supplies these fields; the model cannot choose another principal/run. */
+export declare const UiOutputScope: Schema.Struct<{
+    readonly threadId: Schema.Trimmed;
+    readonly runId: Schema.Trimmed;
+    readonly messageId: Schema.Trimmed;
+    readonly principalId: Schema.Trimmed;
+    readonly fence: Schema.Int;
+}>;
+export type UiOutputScope = typeof UiOutputScope.Type;
+export declare const UiOutputReceipt: Schema.Struct<{
+    readonly threadId: Schema.Trimmed;
+    readonly messageId: Schema.Trimmed;
+    readonly revisionId: Schema.Trimmed;
+    readonly sequence: Schema.Int;
+    readonly nodeId: Schema.Trimmed;
+}>;
+export type UiOutputReceipt = typeof UiOutputReceipt.Type;
+declare const UiOutputError_base: Schema.Class<UiOutputError, Schema.TaggedStruct<"UiOutputError", {
+    readonly code: Schema.Literals<readonly ["invalid", "forbidden", "unavailable", "conflict", "storage"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class UiOutputError extends UiOutputError_base {
+}
+export {};

package/dist/domain/render-output.entity.js

@@ -0,0 +1,33 @@
+import { Schema } from "effect";
+export const UiRelease = Schema.Struct({
+  component: Schema.Trimmed.check(Schema.isNonEmpty()),
+  version: Schema.Trimmed.check(Schema.isNonEmpty()),
+  definitionHash: Schema.String.pipe(Schema.check(Schema.isPattern(/^[a-f0-9]{64}$/))),
+  rendererRelease: Schema.Trimmed.check(Schema.isNonEmpty()),
+  tokensHash: Schema.String.pipe(Schema.check(Schema.isPattern(/^[a-f0-9]{64}$/))),
+  layoutVersion: Schema.Trimmed.check(Schema.isNonEmpty())
+}), UiOutputProposal = Schema.Struct({
+  operationId: Schema.Trimmed.check(Schema.isNonEmpty()),
+  nodeId: Schema.Trimmed.check(Schema.isNonEmpty()),
+  release: UiRelease,
+  props: Schema.Record(Schema.String, Schema.Unknown),
+  evidence: Schema.Array(Schema.Trimmed.check(Schema.isNonEmpty()))
+}), UiOutputScope = Schema.Struct({
+  threadId: Schema.Trimmed.check(Schema.isNonEmpty()),
+  runId: Schema.Trimmed.check(Schema.isNonEmpty()),
+  messageId: Schema.Trimmed.check(Schema.isNonEmpty()),
+  principalId: Schema.Trimmed.check(Schema.isNonEmpty()),
+  fence: Schema.Int.pipe(Schema.check(Schema.isGreaterThan(0)))
+}), UiOutputReceipt = Schema.Struct({
+  threadId: Schema.Trimmed.check(Schema.isNonEmpty()),
+  messageId: Schema.Trimmed.check(Schema.isNonEmpty()),
+  revisionId: Schema.Trimmed.check(Schema.isNonEmpty()),
+  sequence: Schema.Int.pipe(Schema.check(Schema.isGreaterThan(0))),
+  nodeId: Schema.Trimmed.check(Schema.isNonEmpty())
+});
+
+export class UiOutputError extends Schema.TaggedError()("UiOutputError", {
+  code: Schema.Literals(["invalid", "forbidden", "unavailable", "conflict", "storage"]),
+  message: Schema.String
+}) {
+}

package/dist/domain/render-surface.entity.d.ts

@@ -0,0 +1,164 @@
+import { Schema } from "effect";
+/** One addressable visual region a host renders into (a page, a canvas, a panel). */
+export declare const SurfaceScope: Schema.Struct<{
+    readonly surfaceId: Schema.Trimmed;
+    /** The version this render builds on, e.g. the page the user was looking at. */
+    readonly baseVersion: Schema.OptionFromNullOr<Schema.String>;
+    readonly threadId: Schema.Trimmed;
+    readonly runId: Schema.Trimmed;
+    readonly messageId: Schema.Trimmed;
+    readonly principalId: Schema.Trimmed;
+    readonly fence: Schema.Int;
+}>;
+export type SurfaceScope = typeof SurfaceScope.Type;
+/** One node of a snapshot: an exact component release, JSON props and the evidence ids behind them. */
+export declare const RenderNode: Schema.Struct<{
+    readonly nodeId: Schema.Trimmed;
+    readonly release: Schema.Struct<{
+        readonly component: Schema.Trimmed;
+        readonly version: Schema.Trimmed;
+        readonly definitionHash: Schema.String;
+        readonly rendererRelease: Schema.Trimmed;
+        readonly tokensHash: Schema.String;
+        readonly layoutVersion: Schema.Trimmed;
+    }>;
+    readonly props: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly evidence: Schema.$Array<Schema.Trimmed>;
+}>;
+export type RenderNode = typeof RenderNode.Type;
+/**
+ * The host's whole visual representation at one moment. `spec` is opaque JSON
+ * (a layout, a tree, sections); `nodes` are committed one by one; placeholders
+ * are node ids a later `fill` may commit even after the surface is frozen.
+ */
+export declare const RenderSnapshot: Schema.Struct<{
+    readonly phase: Schema.Literals<readonly ["partial", "complete"]>;
+    readonly spec: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly nodes: Schema.$Array<Schema.Struct<{
+        readonly nodeId: Schema.Trimmed;
+        readonly release: Schema.Struct<{
+            readonly component: Schema.Trimmed;
+            readonly version: Schema.Trimmed;
+            readonly definitionHash: Schema.String;
+            readonly rendererRelease: Schema.Trimmed;
+            readonly tokensHash: Schema.String;
+            readonly layoutVersion: Schema.Trimmed;
+        }>;
+        readonly props: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly evidence: Schema.$Array<Schema.Trimmed>;
+    }>>;
+    readonly placeholders: Schema.withConstructorDefault<Schema.withDecodingDefaultType<Schema.$Array<Schema.Trimmed>, never>>;
+}>;
+export type RenderSnapshot = typeof RenderSnapshot.Type;
+export type RenderSnapshotInput = typeof RenderSnapshot.Encoded;
+export declare const FreezeReason: Schema.Literals<readonly ["interaction", "completion"]>;
+export type FreezeReason = typeof FreezeReason.Type;
+/** What a store persists and hydrates. Every record names its surface and the message it was rendered for. */
+export declare const SurfacePlanned: Schema.TaggedStruct<"SurfacePlanned", {
+    readonly surfaceId: Schema.Trimmed;
+    readonly messageId: Schema.Trimmed;
+    readonly versionId: Schema.Trimmed;
+    readonly generation: Schema.Int;
+    readonly baseVersionId: Schema.OptionFromNullOr<Schema.String>;
+    readonly phase: Schema.Literals<readonly ["partial", "complete"]>;
+    readonly spec: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly nodes: Schema.$Array<Schema.Trimmed>;
+    readonly placeholders: Schema.$Array<Schema.Trimmed>;
+    readonly signature: Schema.String;
+}>;
+export type SurfacePlanned = typeof SurfacePlanned.Type;
+export declare const SurfaceCommitted: Schema.TaggedStruct<"SurfaceCommitted", {
+    readonly surfaceId: Schema.Trimmed;
+    readonly messageId: Schema.Trimmed;
+    readonly versionId: Schema.Trimmed;
+    readonly nodeId: Schema.Trimmed;
+    readonly component: Schema.Trimmed;
+    readonly receipt: Schema.Struct<{
+        readonly threadId: Schema.Trimmed;
+        readonly messageId: Schema.Trimmed;
+        readonly revisionId: Schema.Trimmed;
+        readonly sequence: Schema.Int;
+        readonly nodeId: Schema.Trimmed;
+    }>;
+}>;
+export type SurfaceCommitted = typeof SurfaceCommitted.Type;
+export declare const SurfaceCompleted: Schema.TaggedStruct<"SurfaceCompleted", {
+    readonly surfaceId: Schema.Trimmed;
+    readonly messageId: Schema.Trimmed;
+    readonly versionId: Schema.Trimmed;
+    readonly generation: Schema.Int;
+    readonly phase: Schema.Literals<readonly ["partial", "complete"]>;
+    readonly frozen: Schema.Boolean;
+}>;
+export type SurfaceCompleted = typeof SurfaceCompleted.Type;
+export declare const SurfaceFrozen: Schema.TaggedStruct<"SurfaceFrozen", {
+    readonly surfaceId: Schema.Trimmed;
+    readonly messageId: Schema.Trimmed;
+    readonly versionId: Schema.Trimmed;
+    readonly reason: Schema.Literals<readonly ["interaction", "completion"]>;
+}>;
+export type SurfaceFrozen = typeof SurfaceFrozen.Type;
+export declare const SurfaceRecord: Schema.Union<readonly [Schema.TaggedStruct<"SurfacePlanned", {
+    readonly surfaceId: Schema.Trimmed;
+    readonly messageId: Schema.Trimmed;
+    readonly versionId: Schema.Trimmed;
+    readonly generation: Schema.Int;
+    readonly baseVersionId: Schema.OptionFromNullOr<Schema.String>;
+    readonly phase: Schema.Literals<readonly ["partial", "complete"]>;
+    readonly spec: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly nodes: Schema.$Array<Schema.Trimmed>;
+    readonly placeholders: Schema.$Array<Schema.Trimmed>;
+    readonly signature: Schema.String;
+}>, Schema.TaggedStruct<"SurfaceCommitted", {
+    readonly surfaceId: Schema.Trimmed;
+    readonly messageId: Schema.Trimmed;
+    readonly versionId: Schema.Trimmed;
+    readonly nodeId: Schema.Trimmed;
+    readonly component: Schema.Trimmed;
+    readonly receipt: Schema.Struct<{
+        readonly threadId: Schema.Trimmed;
+        readonly messageId: Schema.Trimmed;
+        readonly revisionId: Schema.Trimmed;
+        readonly sequence: Schema.Int;
+        readonly nodeId: Schema.Trimmed;
+    }>;
+}>, Schema.TaggedStruct<"SurfaceCompleted", {
+    readonly surfaceId: Schema.Trimmed;
+    readonly messageId: Schema.Trimmed;
+    readonly versionId: Schema.Trimmed;
+    readonly generation: Schema.Int;
+    readonly phase: Schema.Literals<readonly ["partial", "complete"]>;
+    readonly frozen: Schema.Boolean;
+}>, Schema.TaggedStruct<"SurfaceFrozen", {
+    readonly surfaceId: Schema.Trimmed;
+    readonly messageId: Schema.Trimmed;
+    readonly versionId: Schema.Trimmed;
+    readonly reason: Schema.Literals<readonly ["interaction", "completion"]>;
+}>]>;
+export type SurfaceRecord = typeof SurfaceRecord.Type;
+/** The current message's view of a surface. `frozen` is advisory: the store's guard is authoritative. */
+export declare const SurfaceState: Schema.Struct<{
+    readonly surfaceId: Schema.Trimmed;
+    readonly version: Schema.OptionFromNullOr<Schema.String>;
+    readonly generation: Schema.Int;
+    readonly frozen: Schema.Boolean;
+    readonly completed: Schema.Boolean;
+    readonly components: Schema.$Array<Schema.String>;
+    readonly placeholders: Schema.$Array<Schema.String>;
+    readonly pending: Schema.Boolean;
+}>;
+export type SurfaceState = typeof SurfaceState.Type;
+export declare const PublishResult: Schema.Struct<{
+    readonly version: Schema.OptionFromNullOr<Schema.String>;
+    readonly generation: Schema.Int;
+    readonly changed: Schema.Boolean;
+    readonly frozen: Schema.Boolean;
+}>;
+export type PublishResult = typeof PublishResult.Type;
+declare const RenderError_base: Schema.Class<RenderError, Schema.TaggedStruct<"RenderError", {
+    readonly code: Schema.Literals<readonly ["invalid", "frozen", "conflict", "forbidden", "storage", "unavailable"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class RenderError extends RenderError_base {
+}
+export {};

package/dist/domain/render-surface.entity.functions.d.ts

@@ -0,0 +1,22 @@
+import { Option } from "effect";
+import type { UiOutputError, UiOutputProposal, UiOutputScope } from "./render-output.entity.js";
+import { RenderError } from "./render-surface.entity.js";
+import type { RenderNode, RenderSnapshot, SurfaceRecord, SurfaceScope, SurfaceState } from "./render-surface.entity.js";
+/** A surface's durable progress for the current message, rebuilt from its records. */
+export type SurfaceProgress = {
+    readonly state: Omit<SurfaceState, "pending">;
+    readonly signature: Option.Option<string>;
+    readonly frozenRecorded: boolean;
+};
+/** Identical content has an identical signature, whatever the phase or key order. */
+export declare const signatureOf: (snapshot: RenderSnapshot) => string;
+export declare const versionIdOf: (messageId: string, generation: number) => string;
+/** Stable per generation and node: a retried publish reuses the id, a new generation never collides. */
+export declare const operationIdOf: (runId: string, generation: number, nodeId: string) => string;
+export declare const fillOperationIdOf: (runId: string, placeholder: string) => string;
+export declare const outputScopeOf: (scope: SurfaceScope) => UiOutputScope;
+export declare const proposalOf: (operationId: string, node: RenderNode) => UiOutputProposal;
+export declare const fromOutputError: (error: UiOutputError) => RenderError;
+/** Fold the records of one surface into the current message's progress. */
+export declare const progressOf: (surfaceId: string, messageId: string, records: ReadonlyArray<SurfaceRecord>) => SurfaceProgress;
+export declare const describeError: (error: unknown) => string;

package/dist/domain/render-surface.entity.functions.js

@@ -0,0 +1,36 @@
+import { Option, Schema } from "effect";
+import { canonicalJson, fingerprintOf } from "@xandreed/core";
+import { RenderError, SurfaceCommitted, SurfaceCompleted, SurfaceFrozen, SurfacePlanned } from "./render-surface.entity.js";
+export const signatureOf = (snapshot) => fingerprintOf(canonicalJson({ spec: snapshot.spec, nodes: snapshot.nodes, placeholders: snapshot.placeholders })), versionIdOf = (messageId, generation) => `${messageId}:v${generation}`, operationIdOf = (runId, generation, nodeId) => `${runId}:render:${generation}:${nodeId}`, fillOperationIdOf = (runId, placeholder) => `${runId}:render:fill:${placeholder}`, outputScopeOf = (scope) => ({
+  threadId: scope.threadId,
+  runId: scope.runId,
+  messageId: scope.messageId,
+  principalId: scope.principalId,
+  fence: scope.fence
+}), proposalOf = (operationId, node) => ({
+  operationId,
+  nodeId: node.nodeId,
+  release: node.release,
+  props: node.props,
+  evidence: node.evidence
+}), fromOutputError = (error) => new RenderError({ code: error.code, message: error.message });
+const isPlanned = Schema.is(SurfacePlanned), isCommitted = Schema.is(SurfaceCommitted), isCompleted = Schema.is(SurfaceCompleted), isFrozen = Schema.is(SurfaceFrozen), latestPlanned = (records) => records.reduce((best, record) => isPlanned(record) && Option.match(best, {
+  onNone: () => !0,
+  onSome: (current) => record.generation > current.generation
+}) ? Option.some(record) : best, Option.none());
+export const progressOf = (surfaceId, messageId, records) => {
+  const mine = records.filter((record) => record.surfaceId === surfaceId && record.messageId === messageId), latest = latestPlanned(mine), version = Option.map(latest, (planned) => planned.versionId), ofVersion = (versionId) => mine.filter((record) => record.versionId === versionId), current = Option.match(version, { onNone: () => [], onSome: ofVersion });
+  return {
+    state: {
+      surfaceId,
+      version,
+      generation: Option.match(latest, { onNone: () => 0, onSome: (planned) => planned.generation }),
+      frozen: mine.some(isFrozen),
+      completed: current.some((record) => isCompleted(record) && !record.frozen),
+      components: [...new Set(current.flatMap((record) => isCommitted(record) ? [record.component] : []))],
+      placeholders: Option.match(latest, { onNone: () => [], onSome: (planned) => planned.placeholders })
+    },
+    signature: Option.map(latest, (planned) => planned.signature),
+    frozenRecorded: mine.some((record) => isCompleted(record) && record.frozen)
+  };
+}, describeError = (error) => typeof error === "object" && error !== null && ("message" in error) && typeof error.message === "string" ? error.message : String(error);

package/dist/domain/render-surface.entity.js

@@ -0,0 +1,63 @@
+import { Schema, Effect } from "effect";
+import { UiOutputReceipt, UiOutputScope, UiRelease } from "./render-output.entity.js";
+const Id = Schema.Trimmed.check(Schema.isNonEmpty()), Json = Schema.Record(Schema.String, Schema.Unknown), Generation = Schema.Int.pipe(Schema.check(Schema.isGreaterThan(0)));
+export const SurfaceScope = Schema.Struct({
+  ...UiOutputScope.fields,
+  surfaceId: Id,
+  baseVersion: Schema.OptionFromNullOr(Schema.String)
+}), RenderNode = Schema.Struct({ nodeId: Id, release: UiRelease, props: Json, evidence: Schema.Array(Id) }), RenderSnapshot = Schema.Struct({
+  phase: Schema.Literals(["partial", "complete"]),
+  spec: Json,
+  nodes: Schema.Array(RenderNode),
+  placeholders: Schema.Array(Id).pipe(Schema.withDecodingDefaultType(Effect.sync(() => [])), Schema.withConstructorDefault(Effect.sync(() => [])))
+}), FreezeReason = Schema.Literals(["interaction", "completion"]), SurfacePlanned = Schema.TaggedStruct("SurfacePlanned", {
+  surfaceId: Id,
+  messageId: Id,
+  versionId: Id,
+  generation: Generation,
+  baseVersionId: Schema.OptionFromNullOr(Schema.String),
+  phase: Schema.Literals(["partial", "complete"]),
+  spec: Json,
+  nodes: Schema.Array(Id),
+  placeholders: Schema.Array(Id),
+  signature: Schema.String
+}), SurfaceCommitted = Schema.TaggedStruct("SurfaceCommitted", {
+  surfaceId: Id,
+  messageId: Id,
+  versionId: Id,
+  nodeId: Id,
+  component: Id,
+  receipt: UiOutputReceipt
+}), SurfaceCompleted = Schema.TaggedStruct("SurfaceCompleted", {
+  surfaceId: Id,
+  messageId: Id,
+  versionId: Id,
+  generation: Generation,
+  phase: Schema.Literals(["partial", "complete"]),
+  frozen: Schema.Boolean
+}), SurfaceFrozen = Schema.TaggedStruct("SurfaceFrozen", {
+  surfaceId: Id,
+  messageId: Id,
+  versionId: Id,
+  reason: FreezeReason
+}), SurfaceRecord = Schema.Union([SurfacePlanned, SurfaceCommitted, SurfaceCompleted, SurfaceFrozen]), SurfaceState = Schema.Struct({
+  surfaceId: Id,
+  version: Schema.OptionFromNullOr(Schema.String),
+  generation: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))),
+  frozen: Schema.Boolean,
+  completed: Schema.Boolean,
+  components: Schema.Array(Schema.String),
+  placeholders: Schema.Array(Schema.String),
+  pending: Schema.Boolean
+}), PublishResult = Schema.Struct({
+  version: Schema.OptionFromNullOr(Schema.String),
+  generation: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))),
+  changed: Schema.Boolean,
+  frozen: Schema.Boolean
+});
+
+export class RenderError extends Schema.TaggedError()("RenderError", {
+  code: Schema.Literals(["invalid", "frozen", "conflict", "forbidden", "storage", "unavailable"]),
+  message: Schema.String
+}) {
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export * from "./output.js";
+export * from "./domain/render-surface.entity.js";
+export * from "./domain/render-surface.entity.functions.js";
+export * from "./domain/feed-frame.entity.js";
+export * from "./domain/feed-frame.entity.functions.js";
+export * from "./domain/conformance.entity.js";
+export * from "./ports/render.port.js";
+export { openSurface, RenderLive } from "./render-surface.adapter.js";
+export { makeMemoryRenderStore, MemoryRenderStoreLive } from "./render-store.memory.adapter.js";
+export type { MemoryAnnotation } from "./render-store.memory.adapter.js";
+export { makeRenderFeed, RenderFeedLive } from "./render-feed.adapter.js";
+export { SessionsJournalTailLive } from "./render-tail.sessions.adapter.js";
+export { SseTransport, sseHeaders, sseNodePeer, WebSocketTransport } from "./render-transport.adapter.js";
+export { renderFeedDefaults, renderFeedPlugin, renderSurfaceDefaults, renderSurfacePlugin } from "./plugin.adapter.js";
+export { renderSurfaceConformance } from "./render-surface.conformance.js";
+export type { ConformanceCheck, SurfaceSubject } from "./render-surface.conformance.js";
+export { makeMemoryJournal, renderFeedConformance, renderTransportConformance } from "./render-transport.conformance.js";

package/dist/index.js

@@ -0,0 +1,15 @@
+export * from "./output.js";
+export * from "./domain/render-surface.entity.js";
+export * from "./domain/render-surface.entity.functions.js";
+export * from "./domain/feed-frame.entity.js";
+export * from "./domain/feed-frame.entity.functions.js";
+export * from "./domain/conformance.entity.js";
+export * from "./ports/render.port.js";
+export { openSurface, RenderLive } from "./render-surface.adapter.js";
+export { makeMemoryRenderStore, MemoryRenderStoreLive } from "./render-store.memory.adapter.js";
+export { makeRenderFeed, RenderFeedLive } from "./render-feed.adapter.js";
+export { SessionsJournalTailLive } from "./render-tail.sessions.adapter.js";
+export { SseTransport, sseHeaders, sseNodePeer, WebSocketTransport } from "./render-transport.adapter.js";
+export { renderFeedDefaults, renderFeedPlugin, renderSurfaceDefaults, renderSurfacePlugin } from "./plugin.adapter.js";
+export { renderSurfaceConformance } from "./render-surface.conformance.js";
+export { makeMemoryJournal, renderFeedConformance, renderTransportConformance } from "./render-transport.conformance.js";

package/dist/output.d.ts

@@ -0,0 +1,5 @@
+/** The per-component output layer: exact releases, admission, durable commit and the render_component tool. */
+export * from "./domain/render-output.entity.js";
+export * from "./ports/render-output.port.js";
+export * from "./render-output.tools.js";
+export * from "./render-output.adapter.js";

package/dist/output.js

@@ -0,0 +1,4 @@
+export * from "./domain/render-output.entity.js";
+export * from "./ports/render-output.port.js";
+export * from "./render-output.tools.js";
+export * from "./render-output.adapter.js";

package/dist/plugin.adapter.d.ts

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+import { FeedOptions } from "./domain/feed-frame.entity.js";
+import { UiOutputAdmission } from "./ports/render-output.port.js";
+import { JournalTail, Render, RenderFeed, RenderStore } from "./ports/render.port.js";
+declare const SurfaceConfig: Schema.Struct<{
+    readonly maxBytes: Schema.Int;
+}>;
+export declare const renderSurfaceDefaults: typeof SurfaceConfig.Type;
+/** Surfaces over the host's RenderStore, with the host's admission rules. */
+export declare const renderSurfacePlugin: import("@xandreed/core").TypedPlugin<{
+    readonly maxBytes: number;
+}, {
+    readonly maxBytes: number;
+}, Render, never, UiOutputAdmission | RenderStore>;
+export declare const renderFeedDefaults: typeof FeedOptions.Type;
+/** The journal as client frames; pair it with SseTransport or WebSocketTransport at the host's HTTP edge. */
+export declare const renderFeedPlugin: import("@xandreed/core").TypedPlugin<{
+    readonly pollMs: number;
+    readonly maxPollMs: number;
+    readonly heartbeatMs: number;
+    readonly maxDurationMs: number;
+}, {
+    readonly pollMs: number;
+    readonly maxPollMs: number;
+    readonly heartbeatMs: number;
+    readonly maxDurationMs: number;
+}, RenderFeed, never, JournalTail>;
+export {};