@4fu/arbor-plugin-http 0.0.0-stage → 2026.1106.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 4fuu
+
+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

@@ -1,3 +1,86 @@
-# Temporary Holding Version
+# @4fu/arbor-plugin-http
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The HTTP test channel: the first plugin that runs the whole host end to end
+([docs/architecture.md#plugins](../../docs/architecture.md#plugins)).
+
+A webhook in, a window's sends out, and a small page a person drives it from.
+Nothing here is specific to the plugin's own domain: a deployment that plugs a
+different channel in composes the same stack the same way.
+
+## Run it
+
+```sh
+DEEPSEEK_API_KEY=… JEV_API_KEY=… pnpm --filter @4fu/arbor-plugin-http start
+```
+
+Then open the address it prints (127.0.0.1:8787 by default), pick or create a
+conversation, and send a message. Replies arrive on the page as the window sends
+them. The board beside the conversation is read-only: which windows are live and
+what they are doing.
+
+| Name | What it names | Default |
+| --- | --- | --- |
+| `ARBOR_DATA_DIR` | the journal, notes, `/env` and the workspaces | a directory under the system temp dir |
+| `ARBOR_HOST` | the host the page binds | `127.0.0.1` |
+| `ARBOR_PORT` | the port the page binds | `8787` |
+| `ARBOR_MODEL` | the model the `chat` tier maps to | `deepseek-flash` |
+| `DEEPSEEK_API_KEY` | pi's key for DeepSeek | - |
+| `JEV_API_KEY` | Jev's key | - |
+
+A configuration names a secret and never holds its value: the two keys are
+environment variables pi and Jev read themselves, and the settings name them, so
+the host's scrub covers every string that leaves it
+([docs/architecture.md#data-placement](../../docs/architecture.md#data-placement)).
+
+The page is a local test tool, so it binds localhost by default. Visibility,
+permissions and auth are deferred.
+
+## The channel
+
+| Route | What it does |
+| --- | --- |
+| `GET /` | the page |
+| `GET /app.js` | the page's script |
+| `GET /api/state` | the connection, the conversations and the board |
+| `GET /api/messages?conversation=<name>` | one conversation, both directions |
+| `POST /webhook` | one inbound message |
+
+`POST /webhook` takes `{ "conversation": "demo", "id": "42", "from": "alice",
+"text": "部署流程是什么", "replyTo": "41" }`. The `id` is the sender's own id for
+the message, which the channel keeps as its native id: `http:42`. The journal's
+unique index on the native id is what stores a redelivered message once, so the
+channel forwards every delivery it is given and keeps one line per native id on
+the page. The answer says which happened: `redelivered`.
+
+A window answers with `send({ to: "http:demo", content: "…" })`. The host records
+the effect, the queue executes it exactly once, and this plugin's executor carries
+it out through the channel, which hands back the native id the outside world would
+have given it
+([docs/coordination.md#effects](../../docs/coordination.md#effects)).
+
+## What the plugin registers
+
+| Part | What it gives |
+| --- | --- |
+| `adapters.channels` | the `Channel`: `connections`, `get`, `send` and the push source |
+| `adapters.effectExecutors` | the executor that owns the sends to this channel's conversations |
+| `promptSection` | one block kind and its two fixed lines, so the model reads what the channel is and how to answer on it |
+| `judgeCriteria` | one extra criterion for the `route` decision |
+
+It adds no direct tool and no code mode module of its own: capabilities are MCP
+servers and skills in `/env`, which the model reads, changes and reinstalls with
+`reload` like any item.
+
+## Test it
+
+```sh
+pnpm --filter @4fu/arbor-plugin-http test
+```
+
+The test composes the whole stack - the SQLite journal and notes, the directory
+environment, the directory workspace, pi over its scripted faux provider and the
+default judge over a fake transport - so it needs no key and makes no network
+call. It proves the channel end to end: a webhook message reaches dispatch and
+opens a window; a second message in the same conversation is steered into that
+window; a reply comes back out through the channel; and a redelivered native id is
+stored once.

package/channel.d.ts

@@ -0,0 +1,135 @@
+/**
+ * The HTTP test channel: an outside source and sink over plain HTTP
+ * (packages/interfaces/src/channel.ts, docs/architecture.md#interfaces).
+ *
+ * It is the first real plugin's adapter, and it is a test tool: it holds a
+ * conversation per id, turns an inbound message into one `OutsideEvent` that
+ * carries its native id, records what a window sent, and serves the page a
+ * person drives it from. Nothing here knows the host; a deployment plugs the
+ * channel in and the host takes its push source
+ * (docs/architecture.md#plugins).
+ *
+ * An inbound message keeps the id the sender gave it, with the channel prefix:
+ * `http:42`. The journal's unique index on `external` is what makes a
+ * redelivered message stored once (docs/journal.md#external-ids), so this
+ * channel forwards every delivery it is given and keeps one line per native id
+ * on the page: the exactly-once guarantee is the host's, not the transport's.
+ *
+ * The page it serves is a local test tool, so the server binds `127.0.0.1` by
+ * default and a deployment that names another host says so explicitly.
+ * Visibility, permissions and auth are not part of the framework.
+ */
+import type { BoardLine, Channel, ChannelConnection, ExternalRef, OutsideEvent, OutsideMessage, SendRequest, SendResult, Target, Unsubscribe } from "@4fu/arbor-interfaces";
+/** Which way one message went. */
+export type HttpDirection = "in" | "out";
+/** One message this channel carries, in either direction. */
+export interface HttpMessage {
+    /** Its native id, with the channel prefix: `http:42`. */
+    external: ExternalRef;
+    /** The conversation it belongs to: `http:demo`. */
+    conversation: Target;
+    direction: HttpDirection;
+    /** Who sent it: the webhook's `from`, or `arbor` for a window's send. */
+    from: string;
+    text: string;
+    time: number;
+    /** The native id it answers, when it is a reply. */
+    replyTo?: ExternalRef;
+}
+/** What a deployment configures for the channel. */
+export interface HttpChannelOptions {
+    /** The channel prefix. `http`. */
+    id?: string;
+    /** The live board, for the page's read-only view. Absent when it has none. */
+    board?: () => readonly BoardLine[];
+    /** The host to bind. `127.0.0.1`, because the page is a local test tool. */
+    host?: string;
+    /** The port to bind. 0 picks a free one. */
+    port?: number;
+    /** The clock. */
+    now?: () => number;
+}
+/** One webhook message, as the page or an outside system posts it. */
+export interface WebhookBody {
+    /** The conversation it belongs to, without the channel prefix. */
+    conversation: string;
+    /** The sender's own id for it. Absent when the channel assigns one. */
+    id?: string;
+    text: string;
+    from?: string;
+    /** The native id it answers, when it is a reply. */
+    replyTo?: string;
+}
+/** What the webhook answers with: where the message landed, and whether it had. */
+export interface WebhookResult {
+    external: ExternalRef;
+    target: Target;
+    /** True when this native id had already arrived, so the host stored it once. */
+    redelivered: boolean;
+}
+/** One subscription to what arrives. */
+type Handler = (events: readonly OutsideEvent[]) => void | Promise<void>;
+export declare class HttpChannel implements Channel {
+    readonly id: string;
+    private readonly board;
+    private readonly host;
+    private readonly port;
+    private readonly clock;
+    private readonly messages;
+    private readonly handlers;
+    private server;
+    private address;
+    /** Every native id this channel has used, so an assigned one never collides. */
+    private readonly used;
+    private next;
+    constructor(options?: HttpChannelOptions);
+    /** What is connected: the one connection this channel has, and its state. */
+    connections(): Promise<readonly ChannelConnection[]>;
+    /**
+     * Look up a message by its native id. This channel is its own store, so the
+     * copy is the one it kept: `stored` says it came from the store rather than
+     * from a live source, which for this channel means the server is not up
+     * (packages/interfaces/src/channel.ts).
+     */
+    get(nativeId: ExternalRef): Promise<OutsideMessage | null>;
+    /**
+     * The sink. A window's `send` reaches here as an effect
+     * (docs/coordination.md#effects); the channel records it and hands back the
+     * native id the outside world would have given it, which the host records on
+     * the effect's result.
+     */
+    send(request: SendRequest): Promise<SendResult>;
+    /**
+     * Push source. The host takes it and ingests what arrives
+     * (docs/dispatch.md#tasks); a host that prefers polling ignores it.
+     */
+    subscribe(handler: Handler): Unsubscribe;
+    /** True once the server is listening. */
+    get online(): boolean;
+    /** Where the page is served, once it is up. */
+    get url(): string | undefined;
+    /** Every message this channel carries, oldest first. */
+    list(): readonly HttpMessage[];
+    /** The conversations this channel carries, most recent first. */
+    conversations(): readonly Target[];
+    /** Start serving the page and the webhook. Resolves with where it listens. */
+    listen(): Promise<string>;
+    /** Stop serving. What the channel recorded stays, for `get` and for the page. */
+    close(): Promise<void>;
+    /**
+     * One inbound message. The channel builds the outside event - its native id,
+     * the conversation as its target, the blocks a window reads - and hands it to
+     * every subscriber, which is the host (docs/dispatch.md#tasks). A native id
+     * that already arrived is forwarded anyway: the host's journal is what keeps
+     * it stored once, and the answer says so.
+     */
+    receive(body: WebhookBody): Promise<WebhookResult>;
+    /** One native id, with the channel prefix, and whether it had arrived before. */
+    private assign;
+    /** The page, its script, and the JSON reads the page polls. */
+    private route;
+    /** One file of the page, read on each request so a change needs no restart. */
+    private file;
+    private answer;
+}
+export {};

package/channel.js

@@ -0,0 +1,395 @@
+/**
+ * The HTTP test channel: an outside source and sink over plain HTTP
+ * (packages/interfaces/src/channel.ts, docs/architecture.md#interfaces).
+ *
+ * It is the first real plugin's adapter, and it is a test tool: it holds a
+ * conversation per id, turns an inbound message into one `OutsideEvent` that
+ * carries its native id, records what a window sent, and serves the page a
+ * person drives it from. Nothing here knows the host; a deployment plugs the
+ * channel in and the host takes its push source
+ * (docs/architecture.md#plugins).
+ *
+ * An inbound message keeps the id the sender gave it, with the channel prefix:
+ * `http:42`. The journal's unique index on `external` is what makes a
+ * redelivered message stored once (docs/journal.md#external-ids), so this
+ * channel forwards every delivery it is given and keeps one line per native id
+ * on the page: the exactly-once guarantee is the host's, not the transport's.
+ *
+ * The page it serves is a local test tool, so the server binds `127.0.0.1` by
+ * default and a deployment that names another host says so explicitly.
+ * Visibility, permissions and auth are not part of the framework.
+ */
+import { createServer } from "node:http";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { arborError } from "@4fu/arbor-errors";
+import { dataBlock } from "@4fu/arbor-prompt";
+/** How large a request body may be. 1 MiB is far more than a test message. */
+const MAX_BODY_BYTES = 1024 * 1024;
+/** Where the page's own files are, beside this module. */
+const WEB_DIRECTORY = join(dirname(fileURLToPath(import.meta.url)), "web");
+/** The channel prefix every native id and every conversation target carries. */
+const DEFAULT_CHANNEL_ID = "http";
+export class HttpChannel {
+    id;
+    board;
+    host;
+    port;
+    clock;
+    messages = [];
+    handlers = new Set();
+    server;
+    address;
+    /** Every native id this channel has used, so an assigned one never collides. */
+    used = new Set();
+    next = 1;
+    constructor(options = {}) {
+        this.id = options.id ?? DEFAULT_CHANNEL_ID;
+        this.board = options.board;
+        this.host = options.host ?? "127.0.0.1";
+        this.port = options.port ?? 0;
+        this.clock = options.now ?? (() => Date.now());
+    }
+    // ---- the interface ------------------------------------------------------
+    /** What is connected: the one connection this channel has, and its state. */
+    async connections() {
+        return [
+            {
+                id: this.id,
+                online: this.online,
+                ...(this.address === undefined ? {} : { detail: this.address }),
+            },
+        ];
+    }
+    /**
+     * Look up a message by its native id. This channel is its own store, so the
+     * copy is the one it kept: `stored` says it came from the store rather than
+     * from a live source, which for this channel means the server is not up
+     * (packages/interfaces/src/channel.ts).
+     */
+    async get(nativeId) {
+        const message = this.messages.find((one) => one.external === nativeId);
+        if (message === undefined)
+            return null;
+        return {
+            external: message.external,
+            source: this.id,
+            target: message.conversation,
+            time: message.time,
+            content: [dataBlock(message.text)],
+            ...(message.replyTo === undefined ? {} : { replyTo: message.replyTo }),
+            stored: !this.online,
+        };
+    }
+    /**
+     * The sink. A window's `send` reaches here as an effect
+     * (docs/coordination.md#effects); the channel records it and hands back the
+     * native id the outside world would have given it, which the host records on
+     * the effect's result.
+     */
+    async send(request) {
+        const external = this.assign().external;
+        const message = {
+            external,
+            conversation: request.target,
+            direction: "out",
+            from: "arbor",
+            text: textOfBlocks(request.content),
+            time: this.clock(),
+            ...(request.replyTo === undefined ? {} : { replyTo: request.replyTo }),
+        };
+        this.messages.push(message);
+        return { external: message.external, time: message.time };
+    }
+    /**
+     * Push source. The host takes it and ingests what arrives
+     * (docs/dispatch.md#tasks); a host that prefers polling ignores it.
+     */
+    subscribe(handler) {
+        this.handlers.add(handler);
+        return () => {
+            this.handlers.delete(handler);
+        };
+    }
+    // ---- what the page reads ------------------------------------------------
+    /** True once the server is listening. */
+    get online() {
+        return this.server !== undefined && this.address !== undefined;
+    }
+    /** Where the page is served, once it is up. */
+    get url() {
+        return this.address;
+    }
+    /** Every message this channel carries, oldest first. */
+    list() {
+        return [...this.messages];
+    }
+    /** The conversations this channel carries, most recent first. */
+    conversations() {
+        const seen = new Map();
+        for (const message of this.messages)
+            seen.set(message.conversation, message.time);
+        return [...seen.entries()].sort((left, right) => right[1] - left[1]).map(([target]) => target);
+    }
+    /** Start serving the page and the webhook. Resolves with where it listens. */
+    async listen() {
+        if (this.server !== undefined)
+            return this.address;
+        const server = createServer((request, response) => {
+            void this.route(request, response).catch((error) => {
+                void this.answer(response, 500, { ok: false, error: infoOf(error) });
+            });
+        });
+        this.server = server;
+        try {
+            await new Promise((resolve, reject) => {
+                server.once("error", reject);
+                server.listen(this.port, this.host, () => resolve());
+            });
+        }
+        catch (error) {
+            this.server = undefined;
+            throw error;
+        }
+        const bound = server.address();
+        const port = typeof bound === "object" && bound !== null ? bound.port : this.port;
+        this.address = `http://${this.host}:${port}`;
+        return this.address;
+    }
+    /** Stop serving. What the channel recorded stays, for `get` and for the page. */
+    async close() {
+        const server = this.server;
+        this.server = undefined;
+        this.address = undefined;
+        if (server === undefined)
+            return;
+        await new Promise((resolve) => {
+            server.close(() => resolve());
+            server.closeAllConnections();
+        });
+    }
+    // ---- the webhook ---------------------------------------------------------
+    /**
+     * One inbound message. The channel builds the outside event - its native id,
+     * the conversation as its target, the blocks a window reads - and hands it to
+     * every subscriber, which is the host (docs/dispatch.md#tasks). A native id
+     * that already arrived is forwarded anyway: the host's journal is what keeps
+     * it stored once, and the answer says so.
+     */
+    async receive(body) {
+        const conversation = typeof body.conversation === "string" ? body.conversation.trim() : "";
+        if (conversation === "") {
+            throw arborError({
+                code: "invalid_input",
+                rule: "http.webhook.conversation",
+                message: "webhook: 没有给出来源名",
+                nextAction: "在 body 里给 conversation，例如 {\"conversation\":\"demo\",\"text\":\"你好\"}。",
+            });
+        }
+        const text = typeof body.text === "string" ? body.text : "";
+        if (text.trim() === "") {
+            throw arborError({
+                code: "invalid_input",
+                rule: "http.webhook.text",
+                message: "webhook: 没有给出消息内容",
+                nextAction: "在 body 里给 text。",
+            });
+        }
+        const replyTo = typeof body.replyTo === "string" && body.replyTo.trim() !== ""
+            ? nativeId(this.id, body.replyTo.trim())
+            : undefined;
+        const target = `${this.id}:${conversation}`;
+        const assigned = this.assign(typeof body.id === "string" && body.id.trim() !== "" ? body.id.trim() : undefined);
+        const redelivered = assigned.seen;
+        // One line per native id on the page, even when a sender retries.
+        if (!redelivered) {
+            this.messages.push({
+                external: assigned.external,
+                conversation: target,
+                direction: "in",
+                from: typeof body.from === "string" && body.from.trim() !== "" ? body.from.trim() : "web",
+                text,
+                time: this.clock(),
+                ...(replyTo === undefined ? {} : { replyTo }),
+            });
+        }
+        const event = {
+            source: this.id,
+            external: assigned.external,
+            target,
+            time: this.clock(),
+            content: [dataBlock(text)],
+            ...(replyTo === undefined ? {} : { replyTo }),
+        };
+        for (const handler of [...this.handlers])
+            await handler([event]);
+        return { external: assigned.external, target, redelivered };
+    }
+    /** One native id, with the channel prefix, and whether it had arrived before. */
+    assign(wanted) {
+        if (wanted !== undefined) {
+            const external = nativeId(this.id, wanted);
+            const seen = this.used.has(external);
+            this.used.add(external);
+            return { external, seen };
+        }
+        for (;;) {
+            const external = nativeId(this.id, String(this.next));
+            this.next += 1;
+            if (this.used.has(external))
+                continue;
+            this.used.add(external);
+            return { external, seen: false };
+        }
+    }
+    // ---- the HTTP surface ----------------------------------------------------
+    /** The page, its script, and the JSON reads the page polls. */
+    async route(request, response) {
+        const url = new URL(request.url ?? "/", `http://${this.host}`);
+        if (request.method === "POST" && url.pathname === "/webhook") {
+            const received = await this.receive((await bodyOf(request)));
+            await this.answer(response, 200, { ok: true, ...received });
+            return;
+        }
+        if (request.method === "GET" && url.pathname === "/api/state") {
+            await this.answer(response, 200, {
+                ok: true,
+                channel: this.id,
+                online: this.online,
+                address: this.address ?? "",
+                conversations: this.conversations().map((target) => ({
+                    target,
+                    messages: this.messages.filter((message) => message.conversation === target).length,
+                })),
+                board: (this.board?.() ?? []).map((line) => ({
+                    window: line.window,
+                    state: line.state,
+                    doing: line.doing,
+                    targets: [...line.targets],
+                    expects: line.expects.map((one) => one.description ?? one.item ?? one.ref),
+                    usage: { used: line.usage.used, limit: line.usage.limit },
+                })),
+            });
+            return;
+        }
+        if (request.method === "GET" && url.pathname === "/api/messages") {
+            const wanted = url.searchParams.get("conversation") ?? "";
+            const target = wanted === "" ? undefined : wanted.includes(":") ? wanted : `${this.id}:${wanted}`;
+            await this.answer(response, 200, {
+                ok: true,
+                items: this.messages
+                    .filter((message) => target === undefined || message.conversation === target)
+                    .map((message) => ({
+                    external: message.external,
+                    conversation: message.conversation,
+                    direction: message.direction,
+                    from: message.from,
+                    text: message.text,
+                    time: message.time,
+                    ...(message.replyTo === undefined ? {} : { replyTo: message.replyTo }),
+                })),
+            });
+            return;
+        }
+        if (request.method === "GET" && (url.pathname === "/" || url.pathname === "/index.html")) {
+            await this.file(response, join(WEB_DIRECTORY, "index.html"), "text/html; charset=utf-8");
+            return;
+        }
+        if (request.method === "GET" && url.pathname === "/app.js") {
+            await this.file(response, join(WEB_DIRECTORY, "app.js"), "text/javascript; charset=utf-8");
+            return;
+        }
+        await this.answer(response, 404, {
+            ok: false,
+            error: {
+                code: "not_found",
+                rule: "http.route.unknown",
+                message: `没有 ${request.method ?? "GET"} ${url.pathname} 这个端点`,
+                nextAction: "用 GET / 打开页面，POST /webhook 收消息，GET /api/state 看现场板。",
+            },
+        });
+    }
+    /** One file of the page, read on each request so a change needs no restart. */
+    async file(response, path, type) {
+        let text;
+        try {
+            text = await readFile(path, "utf8");
+        }
+        catch {
+            await this.answer(response, 404, {
+                ok: false,
+                error: {
+                    code: "not_found",
+                    rule: "http.file.absent",
+                    message: `页面文件 ${path} 不存在`,
+                    nextAction: "检查这个插件的 src/web 目录。",
+                },
+            });
+            return;
+        }
+        response.writeHead(200, { "content-type": type, "cache-control": "no-store" });
+        response.end(text);
+    }
+    async answer(response, status, body) {
+        response.writeHead(status, {
+            "content-type": "application/json; charset=utf-8",
+            "cache-control": "no-store",
+        });
+        response.end(JSON.stringify(body));
+    }
+}
+/** The text of a send's blocks: what a window said, as one string. */
+function textOfBlocks(blocks) {
+    const lines = [];
+    for (const block of blocks) {
+        const content = block.fields.content;
+        if (typeof content === "string")
+            lines.push(content);
+    }
+    return lines.join("\n");
+}
+/** One native id: the channel prefix, then the sender's own id for the message. */
+function nativeId(channel, id) {
+    return `${channel}:${id}`;
+}
+/** One request body, read whole and parsed. */
+async function bodyOf(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        size += chunk.length;
+        if (size > MAX_BODY_BYTES) {
+            throw arborError({
+                code: "limit_reached",
+                rule: "http.body.too_large",
+                message: `请求体超过 ${MAX_BODY_BYTES} 字节`,
+                nextAction: "分条发送，或把这个插件的上限调大。",
+            });
+        }
+        chunks.push(chunk);
+    }
+    if (chunks.length === 0)
+        return {};
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    }
+    catch {
+        throw arborError({
+            code: "invalid_input",
+            rule: "http.body.json",
+            message: "请求体不是 JSON",
+            nextAction: "发送一个 JSON 对象：{\"conversation\":\"demo\",\"text\":\"你好\"}。",
+        });
+    }
+}
+/** Anything a route threw, in the core's error shape. */
+function infoOf(error) {
+    const info = error;
+    return {
+        code: typeof info.code === "string" ? info.code : "internal",
+        rule: typeof info.rule === "string" ? info.rule : "http.failed",
+        message: typeof info.message === "string" ? info.message : String(error),
+        ...(typeof info.nextAction === "string" ? { nextAction: info.nextAction } : {}),
+    };
+}

package/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @4fu/arbor-plugin-http - the HTTP test channel, and the first plugin the host
+ * runs end to end (docs/architecture.md#plugins).
+ *
+ * The channel is the adapter: a webhook in, a window's sends out, and a page a
+ * person drives it from. `httpPlugin` wraps it as a `Plugin`, and `src/server.ts`
+ * is the entry point that composes the default stack around it.
+ */
+export { HttpChannel, type HttpChannelOptions, type HttpDirection, type HttpMessage, type WebhookBody, type WebhookResult, } from "./channel.ts";
+export { HttpSendExecutor, httpPlugin, type HttpPluginOptions } from "./plugin.ts";

package/index.js

@@ -0,0 +1,10 @@
+/**
+ * @4fu/arbor-plugin-http - the HTTP test channel, and the first plugin the host
+ * runs end to end (docs/architecture.md#plugins).
+ *
+ * The channel is the adapter: a webhook in, a window's sends out, and a page a
+ * person drives it from. `httpPlugin` wraps it as a `Plugin`, and `src/server.ts`
+ * is the entry point that composes the default stack around it.
+ */
+export { HttpChannel, } from "./channel.js";
+export { HttpSendExecutor, httpPlugin } from "./plugin.js";