@agentorg/cli 0.0.4 → 0.0.6

package/dist/node_modules/@agentorg/sdk/dist/src/module-host.js

@@ -1,36 +1,24 @@
-import { NotConnected, OutcomeUnknown, Refused } from "./errors.js";
-import { describeInterface } from "./interface.js";
+import { NotConnected } from "./errors.js";
 /**
- * One module's runtime, joined to a channel. Its slots and exports are named on the wire with a
- * prefix: none for a program that connects itself, `<module>.` for a module in a package Actor's
- * process, where several share one channel. It binds slots as the Hub's notices say, subscribes
- * `on` handlers while a slot is usable, serves the Hub's streams to its exports, and offers and
- * withdraws run-time exports.
+ * A program's runtime, joined to its channel. It binds slots as the Hub's notices say, subscribes
+ * `on` handlers while a slot is usable, and serves the Hub's streams to its exports.
  */
 export class ModuleHost {
-    #prefix;
     #slots;
     #log;
     #runtime;
     #channel;
     /** The Hub's subscriptions to this module's exports, by export and event, each with its caller. */
     #senders = new Map();
-    /** The same subscriptions by export, each ended when its export is withdrawn. */
+    /** The same subscriptions by export, each ended when the channel goes. */
     #subscribers = new Map();
     /** Slot events the module listens to, each with its live subscription, if any. */
     #listened = new Map();
     #bindings = new Map();
-    /** Run-time exports by name, so a refused offer withdraws the right handle. */
-    #added = new Map();
-    constructor(prefix, slots, log) {
-        this.#prefix = prefix;
+    constructor(slots, log) {
         this.#slots = slots;
         this.#log = log;
     }
-    /** A local name as the Hub knows it. */
-    #wire(name) {
-        return `${this.#prefix}${name}`;
-    }
     get runtime() {
         if (!this.#runtime)
             throw new Error("The module host has no runtime yet.");
@@ -60,31 +48,8 @@ export class ModuleHost {
                 }
             },
             onListen: (slot, event) => this.#subscribeSlot(slot, event),
-            onAdd: (name, iface, handle) => {
-                this.#added.set(name, { handle, iface });
-                // Added during start, before the channel opens: offered once it does.
-                if (this.#channel)
-                    this.#offer(this.#channel, name, iface, handle);
-            },
-            onWithdraw: (name) => {
-                for (const end of [...(this.#subscribers.get(name) ?? [])])
-                    end();
-                // Only exports offered at run time can be withdrawn at the Hub; static ones just stop here.
-                if (!this.#added.has(name))
-                    return;
-                this.#added.delete(name);
-                void this.#channel?.withdraw(this.#wire(name)).catch(() => { });
-            },
         };
     }
-    /** Offer a run-time export; one the Hub refuses is withdrawn here too. */
-    #offer(channel, name, iface, handle) {
-        void channel.offer(this.#wire(name), describeInterface(iface)).catch((error) => {
-            this.#log.error("The Hub refused an export.", { export: name, error: String(error) });
-            if (this.#added.get(name)?.handle === handle)
-                handle.withdraw();
-        });
-    }
     #subscribeSlot(slot, event) {
         const events = this.#listened.get(slot) ?? new Map();
         this.#listened.set(slot, events);
@@ -93,7 +58,7 @@ export class ModuleHost {
         const binding = this.#bindings.get(slot);
         if (!this.#channel || !binding || events.get(event))
             return;
-        const stop = this.#channel.subscribe(this.#wire(slot), event, (payload) => {
+        const stop = this.#channel.subscribe(slot, event, (payload) => {
             try {
                 binding.emit(event, payload);
             }
@@ -142,35 +107,14 @@ export class ModuleHost {
             return;
         }
         const open = this.#channel;
-        const name = this.#wire(slot);
+        const name = slot;
         this.#bindings.set(slot, runtime.bind(slot, {
             call: (method, value) => open.call(name, method, value),
-            open: (params) => open.open(name, params),
-            fetch: async (request) => {
-                // HTTP/1.1 is spoken with node:http, loaded when an http slot is first used (a bundle
-                // such as the runner has it inlined).
-                const { fetchOver } = await import("./client-http.js");
-                const stream = await open.http(name);
-                try {
-                    return await fetchOver(stream, request, name);
-                }
-                catch (error) {
-                    // An abort keeps its own reason, and the provider's own SDK error is that error; a
-                    // stream lost mid-request may have reached the provider.
-                    if (request.signal.aborted ||
-                        error instanceof Refused ||
-                        error instanceof NotConnected ||
-                        error instanceof OutcomeUnknown)
-                        throw error;
-                    throw new OutcomeUnknown(`The http request on ${name} ended before its response: ${String(error)}`);
-                }
-            },
         }));
         this.#resubscribe(slot);
     }
     /**
-     * A notice for a slot made at run time: bound (or usable again) with its exposure, or gone. Its
-     * name is the Actor's, with no module prefix: every module of the Actor has it.
+     * A notice for a slot made at run time: bound (or usable again) with its exposure, or gone.
      */
     onExposed(slot, exposure) {
         if (!this.#channel)
@@ -191,8 +135,6 @@ export class ModuleHost {
     serve = {
         call: (serve, value) => this.runtime.call(serve.export, serve.method ?? "", value, serve.caller),
         subscribe: (serve, sendTo, end) => {
-            if (this.runtime.withdrawn(serve.export))
-                throw new NotConnected(serve.export);
             const key = `${serve.export}\0${serve.event ?? ""}`;
             const set = this.#senders.get(key) ?? new Set();
             this.#senders.set(key, set);
@@ -202,35 +144,25 @@ export class ModuleHost {
             this.#subscribers.set(serve.export, ends);
             const stop = () => {
                 set.delete(sender);
-                ends.delete(withdrawn);
+                ends.delete(ended);
             };
-            const withdrawn = () => {
+            const ended = () => {
                 stop();
                 end(new NotConnected(serve.export));
             };
-            ends.add(withdrawn);
+            ends.add(ended);
             return stop;
         },
-        accept: (serve) => this.runtime.accepting(serve.export, serve.params),
-        serveHttp: (serve) => {
-            const handle = this.runtime.serving(serve.export);
-            return async (stream) => {
-                const { serveOver } = await import("./client-http.js");
-                await serveOver(stream, handle, this.#log);
-            };
-        },
     };
     /**
-     * Join the opened channel: offer what was added during start, bind the slots the Hub's hello
-     * said are bound, and leave nothing usable once the channel goes.
+     * Join the opened channel: bind the slots the Hub's hello said are bound, and leave nothing
+     * usable once the channel goes.
      */
     attach(channel) {
         this.#channel = channel;
-        for (const [name, { handle, iface }] of this.#added)
-            this.#offer(channel, name, iface, handle);
         for (const name of channel.bound)
-            if (name.startsWith(this.#prefix) && !channel.exposed.has(name))
-                this.onSlot(name.slice(this.#prefix.length), true);
+            if (!channel.exposed.has(name))
+                this.onSlot(name, true);
         for (const [name, exposure] of channel.exposed)
             this.onExposed(name, exposure);
         void channel.closed.then(() => {
@@ -244,7 +176,3 @@ export class ModuleHost {
         });
     }
 }
-/** A `serve` stream renamed to a module's local export name. */
-export const localServe = (serve, local) => ({ ...serve, export: local });
-/** A refusal for a name that names no module here. */
-export const noModule = (name) => new Refused("unknown", `${name} names no host module of this Actor.`);

package/dist/node_modules/@agentorg/sdk/dist/src/module.d.ts

@@ -1,12 +1,5 @@
 import type { z } from "zod";
-import type { DescribedInterface, Events, Interface, Methods, RpcInterface, StreamInterface } from "./interface.js";
-/** Where a module runs: `host` in its own process, `view` in a sandboxed frame. */
-export type Placement = "host" | "view";
-/** A byte stream both ways, the same in a host process and in a view. */
-export interface Duplex {
-    readonly readable: ReadableStream<Uint8Array>;
-    readonly writable: WritableStream<Uint8Array>;
-}
+import type { DescribedInterface, Events, Interface, Methods, RpcInterface } from "./interface.js";
 interface SlotState {
     /** Whether an export is bound to this slot now; a slot may be unbound at any time. */
     readonly bound: boolean;
@@ -27,15 +20,7 @@ export interface RpcSlot<M extends Methods, E extends Events> extends SlotState
     /** Live events from the bound export, at most once; returns a function that unsubscribes. */
     on<K extends keyof E & string>(event: K, fn: (payload: z.output<E[K]["payload"]>) => void): () => void;
 }
-/** A slot of a `stream` interface: opening it gives a byte stream in the interface's protocol. */
-export interface StreamSlot<O extends z.ZodType> extends SlotState {
-    open(params: z.input<O>): Promise<Duplex>;
-}
-/** A slot of an `http` interface. */
-export interface HttpSlot extends SlotState {
-    fetch(request: Request): Promise<Response>;
-}
-export type Slot<I extends Interface> = I extends RpcInterface<string, infer M, infer E> ? RpcSlot<M, E> : I extends StreamInterface<string, infer O> ? StreamSlot<O> : HttpSlot;
+export type Slot<I extends Interface> = I extends RpcInterface<string, infer M, infer E> ? RpcSlot<M, E> : never;
 /** Who made a call: the calling Actor, as the Hub names it. */
 export interface CallInfo {
     readonly caller: string;
@@ -54,47 +39,12 @@ export type Handlers<M extends Methods> = {
 export interface EmitOptions {
     readonly to?: string;
 }
-interface Withdrawable {
-    /** Stop offering this export; bindings to it end. */
-    withdraw(): void;
-}
-export interface RpcExport<M extends Methods, E extends Events> extends Withdrawable {
+export interface RpcExport<M extends Methods, E extends Events> {
     implement(handlers: Handlers<M>): void;
     emit<K extends keyof E & string>(event: K, payload: z.input<E[K]["payload"]>, options?: EmitOptions): void;
 }
-export interface StreamExport<O extends z.ZodType> extends Withdrawable {
-    accept(handler: (params: z.output<O>, stream: Duplex) => void | Promise<void>): void;
-}
-export interface HttpExport extends Withdrawable {
-    serve(handler: (request: Request) => Response | Promise<Response>): void;
-}
-/**
- * The element a view renders into: the DOM's `Element` where the DOM library is in scope (a
- * widget's code), and `object` elsewhere, so host-only code needs no DOM types.
- */
-export type FrameRoot = typeof globalThis extends {
-    Element: {
-        prototype: infer E;
-    };
-} ? E : object;
-/**
- * The export handle of `ui.view@1`, the one in-frame interface, and so the one interface whose
- * handle isn't derived from its methods. A view renders into its own frame's DOM, which no wire
- * message can carry: the view implements `mount(el, options)` against its frame's root element,
- * and the frame runtime maps the wire methods `mount`, `resize` and `unmount` onto it. No other
- * interface should take this shape; anything else crosses the wire as schemas.
- */
-export interface ViewExport<MountOptions, Size> extends Withdrawable {
-    implement(view: {
-        /** Render into `el`; the function returned, if any, runs at unmount. */
-        mount(el: FrameRoot, options: MountOptions): (() => void) | void;
-        resize?(size: Size): void;
-    }): void;
-}
-export type Export<I extends Interface> = I extends RpcInterface<"ui.view", infer M, Events, 1> ? "mount" extends keyof M ? "resize" extends keyof M ? ViewExport<z.output<M["mount"]["input"]>, z.output<M["resize"]["input"]> extends {
-    size: infer Size;
-} ? Size : never> : RpcExport<M, Events> : RpcExport<M, Events> : I extends RpcInterface<string, infer M, infer E> ? RpcExport<M, E> : I extends StreamInterface<string, infer O> ? StreamExport<O> : HttpExport;
-/** Structured log lines, readable through the Hub by grant. */
+export type Export<I extends Interface> = I extends RpcInterface<string, infer M, infer E> ? RpcExport<M, E> : never;
+/** Structured log lines. */
 export interface Log {
     info(message: string, fields?: Record<string, unknown>): void;
     warn(message: string, fields?: Record<string, unknown>): void;
@@ -102,15 +52,10 @@ export interface Log {
 }
 /** Slots or exports: names to interfaces. */
 export type InterfaceMap = Record<string, Interface>;
-/** Exports may not be named `add`, which is `exports.add`. */
-export type ExportMap = InterfaceMap & {
-    add?: never;
-};
-/** Whether an interface is `ui.view@1`, the one in-frame interface, with its own export handle. */
-export declare function isFrameInterface(iface: Interface): boolean;
+export type ExportMap = InterfaceMap;
 /**
  * A slot made at run time: another Actor's export, exposed to this Actor with `hub.grants.expose`
- * rather than declared by its package. It is here exactly while it is bound. Its values are JSON,
+ * rather than declared by this Actor. It is here exactly while it is bound. Its values are JSON,
  * checked against `described` by the Hub both ways, not here, so a misfit comes back as
  * `Refused` (code `invalid`). A call on a slot that's gone, or whose provider isn't running, throws
  * `NotConnected`, as a declared slot's does.
@@ -130,16 +75,13 @@ export interface ExposedSlot {
     /** Live events from the export while the slot is here; returns a function that unsubscribes. */
     on(event: string, fn: (payload: unknown) => void): () => void;
 }
-/** Everything a module gets. There are no files, network, environment or Hub access besides. */
+/** Everything a program gets from the Hub. */
 export interface Context<S extends InterfaceMap, X extends InterfaceMap> {
     readonly slots: {
         readonly [K in keyof S]: Slot<S[K]>;
     };
     readonly exports: {
         readonly [K in keyof X]: Export<X[K]>;
-    } & {
-        /** Offer another export at run time; consumers still bind it explicitly. */
-        add<I extends Interface>(name: string, iface: I): Export<I>;
     };
     readonly self: {
         readonly actorId: string;
@@ -147,18 +89,13 @@ export interface Context<S extends InterfaceMap, X extends InterfaceMap> {
     };
     readonly log: Log;
     /**
-     * The slots made for this Actor at run time and bound now, in the order they came. Every host
-     * module of the Actor sees them all; a view module sees none.
+     * The slots made for this Actor at run time and bound now, in the order they came.
      */
     exposed(): readonly ExposedSlot[];
     /** Runs after one is added or removed, so `exposed()` is read again; returns how to stop it. */
     onExposed(fn: () => void): () => void;
 }
-/** The marker the build looks for on a module's default export. */
-export declare const MODULE = "agentorg.module/1";
 export interface ModuleDefinition<S extends InterfaceMap = InterfaceMap, X extends InterfaceMap = InterfaceMap> {
-    readonly agentorg: typeof MODULE;
-    readonly placement: Placement;
     readonly slots: S;
     readonly exports: X;
     start(ctx: Context<S, X>): void | Promise<void>;
@@ -171,9 +108,6 @@ export interface ModuleSpec<S extends InterfaceMap, X extends InterfaceMap> {
     exports?: X;
     start(ctx: Context<S, X>): void | Promise<void>;
 }
-/** A host module: the Actor's logic, in its own process. */
+/** A program's handles, by name: what `connect` runs. */
 export declare function defineActor<const S extends InterfaceMap = None, const X extends ExportMap = None>(spec: ModuleSpec<S, X>): ModuleDefinition<S, X>;
-/** A view module: a widget, in a sandboxed frame. Same shape as an Actor's module. */
-export declare function defineWidget<const S extends InterfaceMap = None, const X extends ExportMap = None>(spec: ModuleSpec<S, X>): ModuleDefinition<S, X>;
-export declare function isModuleDefinition(value: unknown): value is ModuleDefinition;
 export {};

package/dist/node_modules/@agentorg/sdk/dist/src/module.js

@@ -1,11 +1,6 @@
-/** Whether an interface is `ui.view@1`, the one in-frame interface, with its own export handle. */
-export function isFrameInterface(iface) {
-    return iface.kind === "rpc" && iface.name === "ui.view" && iface.major === 1;
-}
-/** The marker the build looks for on a module's default export. */
-export const MODULE = "agentorg.module/1";
 const NAME = /^[a-z][A-Za-z0-9_]*$/;
-function define(placement, spec) {
+/** A program's handles, by name: what `connect` runs. */
+export function defineActor(spec) {
     const slots = spec.slots ?? {};
     const exports = spec.exports ?? {};
     for (const [what, names] of [
@@ -15,20 +10,5 @@ function define(placement, spec) {
         for (const name of names)
             if (!NAME.test(name))
                 throw new TypeError(`${JSON.stringify(name)} isn't a valid ${what} name.`);
-    if ("add" in exports)
-        throw new TypeError(`"add" is reserved for exports.add; name the export differently.`);
-    return { agentorg: MODULE, placement, slots, exports, start: spec.start };
-}
-/** A host module: the Actor's logic, in its own process. */
-export function defineActor(spec) {
-    return define("host", spec);
-}
-/** A view module: a widget, in a sandboxed frame. Same shape as an Actor's module. */
-export function defineWidget(spec) {
-    return define("view", spec);
-}
-export function isModuleDefinition(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        value.agentorg === MODULE);
+    return { slots, exports, start: spec.start };
 }

package/dist/node_modules/@agentorg/sdk/dist/src/person-commands.js

@@ -22,11 +22,6 @@ function usage(message) {
 }
 /** Each person command: the person's hub slot and method it calls, and its input from the args. */
 const commands = {
-    add: {
-        slot: "packages",
-        method: "add",
-        input: ([file]) => (file ? { path: resolve(file) } : usage("add takes a .agentorg file.")),
-    },
     actors: { slot: "actors", method: "list", input: () => ({}) },
     bindings: { slot: "bindings", method: "list", input: () => ({}) },
     exports: { slot: "exports", method: "list", input: () => ({}) },

package/dist/node_modules/@agentorg/sdk/dist/src/runtime.d.ts

@@ -1,13 +1,11 @@
-import type { DescribedInterface, Interface } from "./interface.js";
-import { type Context, type Duplex, type FrameRoot, type InterfaceMap, type Log, type ModuleDefinition } from "./module.js";
+import type { DescribedInterface } from "./interface.js";
+import type { Context, InterfaceMap, Log, ModuleDefinition } from "./module.js";
 /**
- * What serves a bound slot, as the host side sees it: one function per kind. The runtime validates
+ * What serves a bound slot, as the host side sees it. The runtime validates
  * what goes in and comes out against the interface's schemas, as the Hub does.
  */
 export interface SlotProvider {
     call?(method: string, input: unknown): Promise<unknown>;
-    open?(params: unknown): Promise<Duplex>;
-    fetch?(request: Request): Promise<Response>;
 }
 /** A bound slot, seen from the host side: it delivers the provider's events to the module. */
 export interface Binding {
@@ -27,11 +25,6 @@ export interface ExposedProvider {
     /** Deliver an event's payloads until it ends (`onEnd`); returns how to stop. */
     subscribe(event: string, onEvent: (payload: unknown) => void, onEnd: () => void): () => void;
 }
-/** A mounted view, seen from the frame runtime's side. */
-export interface MountedView {
-    resize(size: unknown): void;
-    unmount(): void;
-}
 /**
  * One module's context and the host side of it: bind providers to its slots and drive its
  * exports. The test context and the real runtimes are both built on this, so a module behaves the
@@ -55,17 +48,6 @@ export interface ModuleRuntime<S extends InterfaceMap, X extends InterfaceMap> {
     unexpose(slot: string): void;
     /** Call an export's method for `caller`, the calling Actor as the Hub names it. */
     call(exportName: string, method: string, input: unknown, caller: string): Promise<unknown>;
-    open(exportName: string, params: unknown, stream: Duplex): Promise<void>;
-    /**
-     * The two halves of `open`: checks that the export takes the stream (throwing a refusal at
-     * once), then returns what runs it. A remote host answers accept or refuse in between.
-     */
-    accepting(exportName: string, params: unknown): (stream: Duplex) => Promise<void>;
-    fetch(exportName: string, request: Request): Promise<Response>;
-    /** The checking half of `fetch`: refuses at once, or returns what serves each request. */
-    serving(exportName: string): (request: Request) => Promise<Response>;
-    mount(exportName: string, el: FrameRoot, options: unknown): MountedView;
-    withdrawn(exportName: string): boolean;
 }
 export interface RuntimeOptions {
     self: {
@@ -77,12 +59,6 @@ export interface RuntimeOptions {
     onEmit(exportName: string, event: string, payload: unknown, to: string | undefined): void;
     /** Called when the module listens to a slot's event, so a remote host can subscribe. */
     onListen?(slot: string, event: string): void;
-    /** Called when the module offers an export at run time with `exports.add`, with its handle. */
-    onAdd?(name: string, iface: Interface, handle: {
-        withdraw(): void;
-    }): void;
-    /** Called when the module withdraws an export. */
-    onWithdraw?(name: string): void;
 }
 /**
  * A value checked against a schema. A caller's misfit is `Refused` with code `invalid`, and nothing

package/dist/node_modules/@agentorg/sdk/dist/src/runtime.js

@@ -1,5 +1,4 @@
 import { NotConnected, Refused } from "./errors.js";
-import { isFrameInterface, } from "./module.js";
 /**
  * A value checked against a schema. A caller's misfit is `Refused` with code `invalid`, and nothing
  * ran. A provider's is code `bad_output`: the provider ran and its reply or event broke the
@@ -12,7 +11,6 @@ export function check(schema, value, where, code = "invalid") {
     const issue = result.error.issues[0];
     throw new Refused(code, `${where}: ${issue ? `${issue.path.map(String).join(".") || "value"} ${issue.message}` : "invalid"}`);
 }
-const NAME = /^[a-z][A-Za-z0-9_]*$/;
 const own = (record, key) => Object.hasOwn(record, key) ? record[key] : undefined;
 export function createRuntime(definition, options) {
     const slots = new Map();
@@ -61,73 +59,34 @@ export function createRuntime(definition, options) {
                         return () => void set.delete(fn);
                     },
                 });
-            case "stream":
-                return Object.assign(base, {
-                    async open(params) {
-                        const target = provider();
-                        const parsed = check(iface.open, params, `${name} open`);
-                        if (!target.open)
-                            throw new Refused("unimplemented", `${name} isn't served by a stream provider.`);
-                        return target.open(parsed);
-                    },
-                });
-            case "http":
-                return Object.assign(base, {
-                    async fetch(request) {
-                        const target = provider();
-                        if (!target.fetch)
-                            throw new Refused("unimplemented", `${name} isn't served by an http provider.`);
-                        return target.fetch(request);
-                    },
-                });
         }
     };
     const exportHandle = (name, iface) => {
-        const state = { iface, withdrawn: false };
+        const state = { iface };
         exported.set(name, state);
-        const live = () => {
-            if (state.withdrawn)
-                throw new NotConnected(name);
-        };
-        const withdraw = () => {
-            if (state.withdrawn)
-                return;
-            state.withdrawn = true;
-            options.onWithdraw?.(name);
-        };
         const store = (impl) => {
-            live();
             state.impl = impl;
         };
-        if (isFrameInterface(iface))
-            return { implement: store, withdraw };
         switch (iface.kind) {
             case "rpc":
                 return {
                     implement: store,
                     emit(event, payload, emitting) {
-                        live();
                         const spec = own(iface.events, event);
                         if (!spec)
                             throw new TypeError(`${name} has no event ${event}.`);
                         options.onEmit(name, event, check(spec.payload, payload, `${name}.${event} payload`), emitting?.to);
                     },
-                    withdraw,
                 };
-            case "stream":
-                return { accept: store, withdraw };
-            case "http":
-                return { serve: store, withdraw };
         }
     };
     /** A connected export of the expected kind; implemented or not is checked after its input. */
     const target = (name, kind) => {
         const state = exported.get(name);
-        if (!state || state.withdrawn)
+        if (!state)
             throw new NotConnected(name);
-        const frame = isFrameInterface(state.iface);
-        if (frame !== (kind === "frame") || (!frame && state.iface.kind !== kind))
-            throw new TypeError(`${name} isn't ${kind === "frame" ? "a ui.view@1" : `an ${kind}`} export.`);
+        if (state.iface.kind !== kind)
+            throw new TypeError(`${name} isn't an ${kind} export.`);
         return state;
     };
     const implemented = (state, name) => {
@@ -244,21 +203,7 @@ export function createRuntime(definition, options) {
     };
     const ctx = {
         slots: Object.fromEntries(Object.entries(definition.slots).map(([name, iface]) => [name, slotHandle(name, iface)])),
-        exports: Object.assign(Object.fromEntries(Object.entries(definition.exports).map(([name, iface]) => [
-            name,
-            exportHandle(name, iface),
-        ])), {
-            add(name, iface) {
-                if (!NAME.test(name) || name === "add")
-                    throw new TypeError(`${JSON.stringify(name)} isn't a valid export name.`);
-                const existing = exported.get(name);
-                if (existing && !existing.withdrawn)
-                    throw new TypeError(`An export named ${name} is already offered.`);
-                const handle = exportHandle(name, iface);
-                options.onAdd?.(name, iface, handle);
-                return handle;
-            },
-        }),
+        exports: Object.fromEntries(Object.entries(definition.exports).map(([name, iface]) => [name, exportHandle(name, iface)])),
         self: options.self,
         log: options.log,
         exposed: () => Object.freeze([...exposed.values()].map((state) => state.handle)),
@@ -267,19 +212,6 @@ export function createRuntime(definition, options) {
             return () => void exposedWatchers.delete(fn);
         },
     };
-    const serving = (exportName) => {
-        const state = target(exportName, "http");
-        const handler = implemented(state, exportName);
-        return async (request) => handler(request);
-    };
-    const accepting = (exportName, params) => {
-        const state = target(exportName, "stream");
-        const parsed = check(state.iface.open, params, `${exportName} open`);
-        const handler = implemented(state, exportName);
-        return async (stream) => {
-            await handler(parsed, stream);
-        };
-    };
     /** Run a slot's bind or unbind handlers; one that throws is logged and the rest still run. */
     const notify = (slot, handlers) => {
         const failed = (error) => options.log.error("A slot handler threw.", { slot, error: String(error) });
@@ -351,32 +283,5 @@ export function createRuntime(definition, options) {
                 throw new Refused("unimplemented", `${exportName}.${method} isn't implemented.`);
             return check(spec.output, await handler(parsed, { caller }), `${exportName}.${method} output`, "bad_output");
         },
-        accepting,
-        async open(exportName, params, stream) {
-            await accepting(exportName, params)(stream);
-        },
-        serving,
-        async fetch(exportName, request) {
-            return serving(exportName)(request);
-        },
-        mount(exportName, el, options) {
-            const state = target(exportName, "frame");
-            const methods = state.iface.methods;
-            const parsed = check(methods.mount?.input, options, `${exportName} mount`);
-            const view = implemented(state, exportName);
-            const cleanup = view.mount(el, parsed);
-            return {
-                resize(size) {
-                    const { size: checked } = check(methods.resize?.input, { size }, `${exportName} resize`);
-                    view.resize?.(checked);
-                },
-                unmount() {
-                    cleanup?.();
-                },
-            };
-        },
-        withdrawn(exportName) {
-            return exported.get(exportName)?.withdrawn ?? false;
-        },
     };
 }

package/dist/node_modules/@agentorg/sdk/dist/src/testing.d.ts

@@ -1,9 +1,8 @@
-import type { z } from "zod";
-import { type Interface, type RpcInterface, type StreamInterface } from "./interface.js";
-import type { Duplex, Handlers, InterfaceMap, ModuleDefinition } from "./module.js";
+import { type Interface, type RpcInterface } from "./interface.js";
+import type { Handlers, InterfaceMap, ModuleDefinition } from "./module.js";
 import { type Binding, type ModuleRuntime } from "./runtime.js";
-/** A fake bound to a slot in a test: handlers for `rpc`, a function for `stream` and `http`. */
-export type Provider<I extends Interface> = I extends RpcInterface<string, infer M> ? Partial<Handlers<M>> : I extends StreamInterface<string, infer O> ? (params: z.output<O>) => Duplex | Promise<Duplex> : (request: Request) => Response | Promise<Response>;
+/** A fake bound to a slot in a test: its handlers. */
+export type Provider<I extends Interface> = I extends RpcInterface<string, infer M> ? Partial<Handlers<M>> : never;
 export interface Emitted {
     export: string;
     event: string;
@@ -19,8 +18,8 @@ export interface LogLine {
 /**
  * A module run without a Hub, for tests: bind fakes to its slots, drive its exports, and read what
  * it emitted and logged. It runs on the same runtime as a real module, so every call is validated
- * as the Hub validates it: bad input is `Refused` with code `invalid`, and an unbound slot or a
- * withdrawn export throws `NotConnected`.
+ * as the Hub validates it: bad input is `Refused` with code `invalid`, and an unbound slot throws
+ * `NotConnected`.
  */
 export interface TestContext<S extends InterfaceMap, X extends InterfaceMap> extends Omit<ModuleRuntime<S, X>, "bind" | "call" | "expose"> {
     bind<K extends keyof S & string>(slot: K, provider: Provider<S[K]>): Binding;
@@ -45,4 +44,4 @@ export declare function createTestContext<S extends InterfaceMap, X extends Inte
     actorId?: string;
     module?: string;
 }): TestContext<S, X>;
-export type { Binding, MountedView } from "./runtime.js";
+export type { Binding } from "./runtime.js";