@agentorg/cli 0.0.5 → 0.0.7

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

@@ -26,17 +26,7 @@ export interface RpcInterface<N extends string = string, M extends Methods = Met
     readonly methods: M;
     readonly events: E;
 }
-/** Raw bytes in a named protocol, the L4 shape; opening a stream takes parameters. */
-export interface StreamInterface<N extends string = string, O extends z.ZodType = z.ZodType> extends Named<N> {
-    readonly kind: "stream";
-    readonly protocol: string;
-    readonly open: O;
-}
-/** HTTP/1.1 requests and responses on streams, the L7 shape. */
-export interface HttpInterface<N extends string = string> extends Named<N> {
-    readonly kind: "http";
-}
-export type Interface = RpcInterface | StreamInterface | HttpInterface;
+export type Interface = RpcInterface;
 /**
  * A named, versioned contract, identified by `name@major`. A slot binds only to an export of the
  * same `name@major` whose schemas hash the same.
@@ -48,36 +38,18 @@ export declare function defineInterface<const N extends string, M extends Method
     methods: M;
     events?: E;
 }): RpcInterface<N, M, E, V>;
-export declare function defineInterface<const N extends string, O extends z.ZodType>(spec: {
-    name: N;
-    major: number;
-    kind: "stream";
-    protocol: string;
-    open: O;
-}): StreamInterface<N, O>;
-export declare function defineInterface<const N extends string>(spec: {
-    name: N;
-    major: number;
-    kind: "http";
-}): HttpInterface<N>;
 export type JsonSchema = Record<string, unknown>;
-/** An interface's identity and JSON Schemas, as the manifest records them. */
+/** An interface's identity and JSON Schemas. */
 export type InterfaceSchemas = {
     id: string;
-} & ({
+} & {
     kind: "rpc";
     methods: Record<string, {
         input: JsonSchema;
         output: JsonSchema;
     }>;
     events: Record<string, JsonSchema>;
-} | {
-    kind: "stream";
-    protocol: string;
-    open: JsonSchema;
-} | {
-    kind: "http";
-});
+};
 /** An interface's identity, JSON Schemas and hash. */
 export type DescribedInterface = InterfaceSchemas & {
     hash: string;
@@ -94,10 +66,10 @@ export declare function normalizeSchema(schema: JsonSchema): JsonSchema;
 /**
  * The hash of an interface: SHA-256 over the canonical JSON of its identity and normalized JSON
  * Schemas. Everything in those schemas is contract, `.describe()` text included, so a reader can
- * recompute the hash from the manifest alone.
+ * recompute the hash from them alone.
  */
 export declare function hashInterface(schemas: InterfaceSchemas): string;
-/** The interface as the manifest records it: identity, JSON Schemas and hash. */
+/** The interface as it crosses the wire: identity, JSON Schemas and hash. */
 export declare function describeInterface(iface: Interface): DescribedInterface;
 /**
  * Whether a slot's interface and an export's can be bound: `same` is the same `name@major` with

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

@@ -26,20 +26,8 @@ export function defineInterface(spec) {
                     throw new TypeError(`${id}: ${name} is both a method and an event.`);
             return { name: spec.name, major: spec.major, kind: "rpc", methods, events };
         }
-        case "stream":
-            if (!spec.protocol || !spec.open)
-                throw new TypeError(`${id}: a stream interface names its protocol and its open schema.`);
-            return {
-                name: spec.name,
-                major: spec.major,
-                kind: "stream",
-                protocol: spec.protocol,
-                open: spec.open,
-            };
-        case "http":
-            return { name: spec.name, major: spec.major, kind: "http" };
         default:
-            throw new TypeError(`${id}: kind must be rpc, stream or http.`);
+            throw new TypeError(`${id}: kind must be rpc.`);
     }
 }
 /** `name@major`, the identity a slot and an export must share. */
@@ -135,26 +123,17 @@ function interfaceSchemas(iface) {
                     jsonSchema(id, `event ${name}`, e.payload, "output"),
                 ])),
             };
-        case "stream":
-            return {
-                id,
-                kind: "stream",
-                protocol: iface.protocol,
-                open: jsonSchema(id, "open", iface.open, "input"),
-            };
-        case "http":
-            return { id, kind: "http" };
     }
 }
 /**
  * The hash of an interface: SHA-256 over the canonical JSON of its identity and normalized JSON
  * Schemas. Everything in those schemas is contract, `.describe()` text included, so a reader can
- * recompute the hash from the manifest alone.
+ * recompute the hash from them alone.
  */
 export function hashInterface(schemas) {
     return hashOf(schemas);
 }
-/** The interface as the manifest records it: identity, JSON Schemas and hash. */
+/** The interface as it crosses the wire: identity, JSON Schemas and hash. */
 export function describeInterface(iface) {
     const schemas = interfaceSchemas(iface);
     return { ...schemas, hash: hashInterface(schemas) };

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

@@ -1,40 +1,31 @@
-import type { Channel, ChannelExposure, Serve, ServeHandlers } from "./client.js";
-import { Refused } from "./errors.js";
+import type { Channel, ChannelExposure, ServeHandlers } from "./client.js";
 import type { InterfaceMap, Log } from "./module.js";
 import type { ModuleRuntime, RuntimeOptions } from "./runtime.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 declare class ModuleHost {
     #private;
-    constructor(prefix: string, slots: InterfaceMap, log: Log);
+    constructor(slots: InterfaceMap, log: Log);
     get runtime(): ModuleRuntime<InterfaceMap, InterfaceMap>;
     set runtime(runtime: ModuleRuntime<InterfaceMap, InterfaceMap>);
     /** The runtime's hooks for this host: pass them to `createRuntime`. */
-    hooks(): Pick<RuntimeOptions, "onEmit" | "onListen" | "onAdd" | "onWithdraw">;
+    hooks(): Pick<RuntimeOptions, "onEmit" | "onListen">;
     /**
      * A slot notice for one of this module's slots, by its local name: unbound, bound, or (for a
      * slot already bound) usable again because its provider came back.
      */
     onSlot(slot: string, isBound: boolean): void;
     /**
-     * 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: string, exposure: ChannelExposure | undefined): void;
     /** How this module serves the Hub's streams, by its local export names. */
     readonly serve: ServeHandlers;
     /**
-     * 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: Channel): void;
 }
-/** A `serve` stream renamed to a module's local export name. */
-export declare const localServe: (serve: Serve, local: string) => Serve;
-/** A refusal for a name that names no module here. */
-export declare const noModule: (name: string) => Refused;

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