@agentorg/cli 0.0.5 → 0.0.6

package/dist/node_modules/@agentorg/interfaces/dist/src/hub.d.ts

@@ -1,52 +1,7 @@
 import { z } from "zod";
 export declare const Id: z.ZodString;
-/** A slot or export: `name` for an external Actor, `module.name` for a package Actor. */
+/** A slot or export: `name`, or `module.name`. */
 export declare const Name: z.ZodString;
-export declare const Package: z.ZodObject<{
-    hash: z.ZodString;
-    name: z.ZodString;
-    version: z.ZodString;
-}, z.core.$strip>;
-/** `hub.packages@1`: the content-addressed package store. */
-export declare const hubPackages: import("@agentorg/sdk").RpcInterface<"hub.packages", {
-    /** Add a `.agentorg` archive from a path on the Hub's machine; it is verified first. */
-    add: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        path: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        hash: z.ZodString;
-        manifest: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
-    }, z.core.$strip>>;
-    list: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
-        packages: z.ZodArray<z.ZodObject<{
-            hash: z.ZodString;
-            name: z.ZodString;
-            version: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    get: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        hash: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        hash: z.ZodString;
-        manifest: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
-    }, z.core.$strip>>;
-    /** Refused while an Actor runs the package. */
-    remove: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        hash: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
-    /**
-     * Build a package from its source, given as data (`package.json` and files under `src/`, up to
-     * 768 KiB), and add it as `add` does. It's `agentorg build`'s build, reading no tsconfig; its
-     * files import only `@agentorg/sdk`, `@agentorg/interfaces`, `zod`, `react`, `react-dom` and
-     * `@agentorg/kit` by name, and nothing outside the package's folder, never by a pattern. A build that fails is
-     * `Refused("build")` with the build's message, so the source can be fixed and built again.
-     */
-    build: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        files: z.ZodRecord<z.ZodString, z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        hash: z.ZodString;
-        manifest: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
-    }, z.core.$strip>>;
-}, {}, 1>;
 export declare const ActorState: z.ZodEnum<{
     closed: "closed";
     created: "created";
@@ -64,43 +19,15 @@ export declare const Actor: z.ZodObject<{
         stopped: "stopped";
     }>;
     connected: z.ZodBoolean;
-    restarts: z.ZodNumber;
-    lastExit: z.ZodOptional<z.ZodObject<{
-        code: z.ZodNullable<z.ZodNumber>;
-        signal: z.ZodNullable<z.ZodString>;
-        at: z.ZodString;
-    }, z.core.$strip>>;
-    host: z.ZodOptional<z.ZodObject<{
-        available: z.ZodBoolean;
-        reason: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    views: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    installedFor: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-/** One line of an Actor's log, from its `ctx.log` or its process's own output. */
-export declare const LogLine: z.ZodObject<{
-    level: z.ZodEnum<{
-        error: "error";
-        info: "info";
-        warn: "warn";
-    }>;
-    message: z.ZodString;
-    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
-    module: z.ZodOptional<z.ZodString>;
-    at: z.ZodString;
-}, z.core.$strip>;
-/** `hub.actors@1`: Actors and their lifecycle. */
+/** `hub.actors@1`: Actors: who may join the Hub. */
 export declare const hubActors: import("@agentorg/sdk").RpcInterface<"hub.actors", {
     /**
-     * With a package, an Actor that runs it; without, an external one, whose credential is returned
-     * once. `bindings` wire the new Actor's slots at once, with the caller's export-side authority
-     * (the creation is the slot side's yes), for example to its own `hub.grants@1`. `for` names
-     * the Actor it is made for, recorded as `installedFor`; only a manager may give it.
+     * An Actor for a program that connects itself, with a credential returned once. `bindings` wire the new Actor's slots at once, with the caller's export-side authority
+     * (the creation is the slot side's yes), for example to its own `hub.grants@1`.
      */
     create: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         name: z.ZodString;
-        package: z.ZodOptional<z.ZodString>;
-        for: z.ZodOptional<z.ZodString>;
         bindings: z.ZodOptional<z.ZodArray<z.ZodObject<{
             slot: z.ZodString;
             provider: z.ZodString;
@@ -108,7 +35,7 @@ export declare const hubActors: import("@agentorg/sdk").RpcInterface<"hub.actors
         }, z.core.$strip>>>;
     }, z.core.$strip>, z.ZodObject<{
         actorId: z.ZodString;
-        credential: z.ZodOptional<z.ZodString>;
+        credential: z.ZodString;
     }, z.core.$strip>>;
     list: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
         actors: z.ZodArray<z.ZodObject<{
@@ -122,18 +49,6 @@ export declare const hubActors: import("@agentorg/sdk").RpcInterface<"hub.actors
                 stopped: "stopped";
             }>;
             connected: z.ZodBoolean;
-            restarts: z.ZodNumber;
-            lastExit: z.ZodOptional<z.ZodObject<{
-                code: z.ZodNullable<z.ZodNumber>;
-                signal: z.ZodNullable<z.ZodString>;
-                at: z.ZodString;
-            }, z.core.$strip>>;
-            host: z.ZodOptional<z.ZodObject<{
-                available: z.ZodBoolean;
-                reason: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-            views: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            installedFor: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     get: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
@@ -149,69 +64,15 @@ export declare const hubActors: import("@agentorg/sdk").RpcInterface<"hub.actors
             stopped: "stopped";
         }>;
         connected: z.ZodBoolean;
-        restarts: z.ZodNumber;
-        lastExit: z.ZodOptional<z.ZodObject<{
-            code: z.ZodNullable<z.ZodNumber>;
-            signal: z.ZodNullable<z.ZodString>;
-            at: z.ZodString;
-        }, z.core.$strip>>;
-        host: z.ZodOptional<z.ZodObject<{
-            available: z.ZodBoolean;
-            reason: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        views: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        installedFor: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
-    start: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        actorId: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
-    stop: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        actorId: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
     /** Final: its bindings, both ways, are removed. */
     close: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         actorId: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
-    /**
-     * Run another package as the same package Actor: its id, its stores and every binding whose
-     * interfaces still match stay. A binding through a slot or export the new package drops, or
-     * declares as another interface, is dropped and listed in `dropped`; the new package's own
-     * wiring is made where its slot is unbound. A running Actor restarts on the new package.
-     * Only a manager may upgrade: the new package runs as the Actor and keeps what it was granted
-     * (its bindings and its store), which only a manager could grant anyway.
-     */
-    upgrade: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        actorId: z.ZodString;
-        package: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        dropped: z.ZodArray<z.ZodObject<{
-            consumer: z.ZodString;
-            slot: z.ZodString;
-            provider: z.ZodString;
-            export: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    /** Its newest log lines, oldest first. */
-    logs: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        actorId: z.ZodString;
-        limit: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>, z.ZodObject<{
-        lines: z.ZodArray<z.ZodObject<{
-            level: z.ZodEnum<{
-                error: "error";
-                info: "info";
-                warn: "warn";
-            }>;
-            message: z.ZodString;
-            data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
-            module: z.ZodOptional<z.ZodString>;
-            at: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
 }, {
     /**
-     * An Actor's record may differ: it was made, started, stopped or closed, its process exited,
-     * or it connected or went (`connected`). Read it again with `get` or `list`.
+     * An Actor's record may differ: it was made or closed, or it connected or went (`connected`).
+     * Read it again with `get` or `list`.
      */
     changed: import("@agentorg/sdk").EventSpec<z.ZodObject<{
         actor: z.ZodString;
@@ -229,41 +90,20 @@ export declare const Binding: z.ZodObject<{
     at: z.ZodString;
     exposed: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strip>;
-export declare const BindingRequest: z.ZodObject<{
-    consumer: z.ZodString;
-    slot: z.ZodString;
-    provider: z.ZodString;
-    export: z.ZodString;
-    requestId: z.ZodString;
-    needs: z.ZodEnum<{
-        export: "export";
-        slot: "slot";
-    }>;
-    reason: z.ZodString;
-    requestedBy: z.ZodString;
-    at: z.ZodString;
-    exposed: z.ZodOptional<z.ZodLiteral<true>>;
-}, z.core.$strip>;
 /**
  * `hub.grants@1`: binding with the caller's own authority, so it is safe to give any Actor. A
  * binding needs both ends: the export side (the provider, an Actor already bound to that export,
- * or a manager) and the slot side (the consumer itself, or a manager). With both, `bind` binds.
- * With one, it approves an open request from the other end, or becomes a request to that end's
- * approvers. With neither it is refused.
+ * or a manager) and the slot side (the consumer itself, or a manager). Without both it is refused.
  */
 export declare const hubGrants: import("@agentorg/sdk").RpcInterface<"hub.grants", {
-    /** A request made by `bind` has an empty reason; `request` gives one. */
     bind: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         consumer: z.ZodString;
         slot: z.ZodString;
         provider: z.ZodString;
         export: z.ZodString;
-    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
-        bound: z.ZodLiteral<true>;
     }, z.core.$strip>, z.ZodObject<{
-        bound: z.ZodLiteral<false>;
-        requestId: z.ZodString;
-    }, z.core.$strip>]>>;
+        bound: z.ZodLiteral<true>;
+    }, z.core.$strip>>;
     /** The consumer, the provider or a manager may unbind. */
     unbind: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         consumer: z.ZodString;
@@ -272,135 +112,27 @@ export declare const hubGrants: import("@agentorg/sdk").RpcInterface<"hub.grants
     /**
      * Expose an `rpc` export to one Actor: a slot made on `to`, typed by the export's interface,
      * named `as` (by default the provider's name camelCased, `_`, and the export's last part, made
-     * unique on `to`), and bound to the export, in one step. Its authority is a binding's: with
-     * both ends it is made; with one, it is a request to the other end's approvers, who approve it
-     * by calling `expose` with the request's fields. The same export already exposed to `to`
-     * gives that slot back.
+     * unique on `to`), and bound to the export, in one step. Its authority is a binding's. The same export already
+     * exposed to `to` gives that slot back.
      */
     expose: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         provider: z.ZodString;
         export: z.ZodString;
         to: z.ZodString;
         as: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
-        exposed: z.ZodLiteral<true>;
-        slot: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
-        exposed: z.ZodLiteral<false>;
+        exposed: z.ZodLiteral<true>;
         slot: z.ZodString;
-        requestId: z.ZodString;
-    }, z.core.$strip>]>>;
+    }, z.core.$strip>>;
     /** Remove a slot made by `expose`, with its binding: as `unbind`, the consumer, the provider or a manager may. */
     unexpose: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         to: z.ZodString;
         slot: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
-    request: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        consumer: z.ZodString;
-        slot: z.ZodString;
-        provider: z.ZodString;
-        export: z.ZodString;
-        reason: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        requestId: z.ZodString;
-    }, z.core.$strip>>;
-    /** The open requests the caller could approve. */
-    requests: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
-        requests: z.ZodArray<z.ZodObject<{
-            consumer: z.ZodString;
-            slot: z.ZodString;
-            provider: z.ZodString;
-            export: z.ZodString;
-            requestId: z.ZodString;
-            needs: z.ZodEnum<{
-                export: "export";
-                slot: "slot";
-            }>;
-            reason: z.ZodString;
-            requestedBy: z.ZodString;
-            at: z.ZodString;
-            exposed: z.ZodOptional<z.ZodLiteral<true>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    decline: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        requestId: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
-    /**
-     * The caller's own requests and how each stands, newest first: how a requester that missed
-     * `decided` learns the outcome.
-     */
-    mine: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        limit: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>, z.ZodObject<{
-        requests: z.ZodArray<z.ZodObject<{
-            consumer: z.ZodString;
-            slot: z.ZodString;
-            provider: z.ZodString;
-            export: z.ZodString;
-            requestId: z.ZodString;
-            needs: z.ZodEnum<{
-                export: "export";
-                slot: "slot";
-            }>;
-            reason: z.ZodString;
-            requestedBy: z.ZodString;
-            at: z.ZodString;
-            exposed: z.ZodOptional<z.ZodLiteral<true>>;
-            status: z.ZodEnum<{
-                approved: "approved";
-                closed: "closed";
-                declined: "declined";
-                open: "open";
-            }>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-}, {
-    /** A request the subscriber could approve. */
-    requested: import("@agentorg/sdk").EventSpec<z.ZodObject<{
-        consumer: z.ZodString;
-        slot: z.ZodString;
-        provider: z.ZodString;
-        export: z.ZodString;
-        requestId: z.ZodString;
-        needs: z.ZodEnum<{
-            export: "export";
-            slot: "slot";
-        }>;
-        reason: z.ZodString;
-        requestedBy: z.ZodString;
-        at: z.ZodString;
-        exposed: z.ZodOptional<z.ZodLiteral<true>>;
-    }, z.core.$strip>>;
-    /**
-     * A request the subscriber could approve, or made, was approved (its binding made), declined,
-     * or closed (its slot was bound to something else, or one end went away).
-     */
-    decided: import("@agentorg/sdk").EventSpec<z.ZodObject<{
-        request: z.ZodObject<{
-            consumer: z.ZodString;
-            slot: z.ZodString;
-            provider: z.ZodString;
-            export: z.ZodString;
-            requestId: z.ZodString;
-            needs: z.ZodEnum<{
-                export: "export";
-                slot: "slot";
-            }>;
-            reason: z.ZodString;
-            requestedBy: z.ZodString;
-            at: z.ZodString;
-            exposed: z.ZodOptional<z.ZodLiteral<true>>;
-        }, z.core.$strip>;
-        status: z.ZodEnum<{
-            approved: "approved";
-            closed: "closed";
-            declined: "declined";
-        }>;
-    }, z.core.$strip>>;
-}, 1>;
+}, {}, 1>;
 /**
  * `hub.bindings@1`: management scope. An Actor bound to it is a manager: it holds both ends of
- * every binding and is an approver of every request, acting through `hub.grants@1`, which it needs
+ * every binding, acting through `hub.grants@1`, which it needs
  * as well. Here, the manager-wide reads.
  */
 export declare const hubBindings: import("@agentorg/sdk").RpcInterface<"hub.bindings", {
@@ -424,7 +156,6 @@ export declare const ExportEntry: z.ZodObject<{
     export: z.ZodString;
     interface: z.ZodString;
     hash: z.ZodString;
-    dynamic: z.ZodBoolean;
 }, z.core.$strip>;
 /** `hub.exports@1`: what each Actor offers right now. */
 export declare const hubExports: import("@agentorg/sdk").RpcInterface<"hub.exports", {
@@ -436,7 +167,6 @@ export declare const hubExports: import("@agentorg/sdk").RpcInterface<"hub.expor
             export: z.ZodString;
             interface: z.ZodString;
             hash: z.ZodString;
-            dynamic: z.ZodBoolean;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, {

package/dist/node_modules/@agentorg/interfaces/dist/src/hub.js

@@ -6,144 +6,57 @@ import { z } from "zod";
  */
 const Hash = z.string().regex(/^sha256-[0-9a-f]{64}$/);
 export const Id = z.string().min(1).max(128);
-/** A slot or export: `name` for an external Actor, `module.name` for a package Actor. */
+/** A slot or export: `name`, or `module.name`. */
 export const Name = z
     .string()
     .regex(/^[a-z][A-Za-z0-9_]*(\.[a-z][A-Za-z0-9_]*)?$/)
     .max(129);
 const Empty = z.object({});
-export const Package = z.object({ hash: Hash, name: z.string(), version: z.string() });
-/** `hub.packages@1`: the content-addressed package store. */
-export const hubPackages = defineInterface({
-    name: "hub.packages",
-    major: 1,
-    kind: "rpc",
-    methods: {
-        /** Add a `.agentorg` archive from a path on the Hub's machine; it is verified first. */
-        add: method({
-            input: z.object({ path: z.string().min(1).max(4096) }),
-            output: z.object({ hash: Hash, manifest: z.record(z.string(), z.json()) }),
-        }),
-        list: method({ input: Empty, output: z.object({ packages: z.array(Package) }) }),
-        get: method({
-            input: z.object({ hash: Hash }),
-            output: z.object({ hash: Hash, manifest: z.record(z.string(), z.json()) }),
-        }),
-        /** Refused while an Actor runs the package. */
-        remove: method({ input: z.object({ hash: Hash }), output: Empty }),
-        /**
-         * Build a package from its source, given as data (`package.json` and files under `src/`, up to
-         * 768 KiB), and add it as `add` does. It's `agentorg build`'s build, reading no tsconfig; its
-         * files import only `@agentorg/sdk`, `@agentorg/interfaces`, `zod`, `react`, `react-dom` and
-         * `@agentorg/kit` by name, and nothing outside the package's folder, never by a pattern. A build that fails is
-         * `Refused("build")` with the build's message, so the source can be fixed and built again.
-         */
-        build: method({
-            input: z.object({ files: z.record(z.string().min(1).max(256), z.string()) }),
-            output: z.object({ hash: Hash, manifest: z.record(z.string(), z.json()) }),
-        }),
-    },
-});
 export const ActorState = z.enum(["created", "running", "stopped", "closed"]);
 export const Actor = z.object({
     actorId: Id,
     name: z.string(),
     /**
-     * The package it runs, by hash; `external` for a program that connects itself; `builtin` for
-     * the `hub` Actor, which is the core itself.
+     * `external` for a program that connects itself; `builtin` for the `hub` Actor, which is the
+     * core itself. An Actor an earlier release ran from a package keeps that package's hash.
      */
     package: z.union([Hash, z.literal("external"), z.literal("builtin")]),
     state: ActorState,
     /**
-     * Whether it has a channel to the Hub now: an external Actor while its program is connected (the
-     * person while the app runs: its gateway holds the person's channel), a package Actor while its
-     * process is. The built-in Actors are the Hub itself and have none. `state` is what was asked
-     * for and this is what is: a running package Actor isn't connected while its process starts or
-     * restarts, and a stopping one stays connected until its process has gone.
+     * Whether it has a channel to the Hub now: while its program is connected (the person while the
+     * app runs: its gateway holds the person's channel). The hub is the core itself and has none.
      */
     connected: z.boolean(),
-    /** Times the Hub restarted its process after a crash; 0 for Actors without one. */
-    restarts: z.number().int().min(0),
-    /** How its process last ended on its own, if it has: an exit code or a signal, and when. */
-    lastExit: z
-        .object({ code: z.number().int().nullable(), signal: z.string().nullable(), at: z.string() })
-        .optional(),
-    /**
-     * For a package Actor: whether this machine can run its host process now, and if not, why and
-     * what to do about it.
-     */
-    host: z.object({ available: z.boolean(), reason: z.string().optional() }).optional(),
-    /** For a package Actor: its view modules, which the person's shell can place. */
-    views: z.array(z.string()).optional(),
-    /**
-     * The Actor it was created for, when a manager created it on another's behalf (the installer
-     * names its caller). Provenance only: the Hub grants nothing from it; only a rule the person
-     * turned on may act on it.
-     */
-    installedFor: Id.optional(),
 });
-/** One line of an Actor's log, from its `ctx.log` or its process's own output. */
-export const LogLine = z.object({
-    level: z.enum(["info", "warn", "error"]),
-    message: z.string(),
-    data: z.record(z.string(), z.json()).optional(),
-    module: z.string().optional(),
-    at: z.string(),
-});
-/** `hub.actors@1`: Actors and their lifecycle. */
+/** `hub.actors@1`: Actors: who may join the Hub. */
 export const hubActors = defineInterface({
     name: "hub.actors",
     major: 1,
     kind: "rpc",
     methods: {
         /**
-         * With a package, an Actor that runs it; without, an external one, whose credential is returned
-         * once. `bindings` wire the new Actor's slots at once, with the caller's export-side authority
-         * (the creation is the slot side's yes), for example to its own `hub.grants@1`. `for` names
-         * the Actor it is made for, recorded as `installedFor`; only a manager may give it.
+         * An Actor for a program that connects itself, with a credential returned once. `bindings` wire the new Actor's slots at once, with the caller's export-side authority
+         * (the creation is the slot side's yes), for example to its own `hub.grants@1`.
          */
         create: method({
             input: z.object({
                 name: z.string().min(1).max(128),
-                package: Hash.optional(),
-                for: Id.optional(),
                 bindings: z
                     .array(z.object({ slot: Name, provider: Id, export: Name }))
                     .max(64)
                     .optional(),
             }),
-            output: z.object({ actorId: Id, credential: z.string().optional() }),
+            output: z.object({ actorId: Id, credential: z.string() }),
         }),
         list: method({ input: Empty, output: z.object({ actors: z.array(Actor) }) }),
         get: method({ input: z.object({ actorId: Id }), output: Actor }),
-        start: method({ input: z.object({ actorId: Id }), output: Empty }),
-        stop: method({ input: z.object({ actorId: Id }), output: Empty }),
         /** Final: its bindings, both ways, are removed. */
         close: method({ input: z.object({ actorId: Id }), output: Empty }),
-        /**
-         * Run another package as the same package Actor: its id, its stores and every binding whose
-         * interfaces still match stay. A binding through a slot or export the new package drops, or
-         * declares as another interface, is dropped and listed in `dropped`; the new package's own
-         * wiring is made where its slot is unbound. A running Actor restarts on the new package.
-         * Only a manager may upgrade: the new package runs as the Actor and keeps what it was granted
-         * (its bindings and its store), which only a manager could grant anyway.
-         */
-        upgrade: method({
-            input: z.object({ actorId: Id, package: Hash }),
-            output: z.object({
-                dropped: z.array(z.object({ consumer: Id, slot: Name, provider: Id, export: Name })),
-            }),
-        }),
-        /** Its newest log lines, oldest first. */
-        logs: method({
-            input: z.object({ actorId: Id, limit: z.number().int().min(1).max(1000).optional() }),
-            output: z.object({ lines: z.array(LogLine) }),
-        }),
     },
     events: {
         /**
-         * An Actor's record may differ: it was made, started, stopped or closed, its process exited,
-         * or it connected or went (`connected`). Read it again with `get` or `list`.
+         * An Actor's record may differ: it was made or closed, or it connected or went (`connected`).
+         * Read it again with `get` or `list`.
          */
         changed: event(z.object({ actor: Id })),
     },
@@ -162,90 +75,36 @@ export const Binding = z.object({
     /** A slot made at run time by `hub.grants.expose`: it goes with this binding. */
     exposed: z.literal(true).optional(),
 });
-export const BindingRequest = z.object({
-    requestId: Id,
-    ...Wiring,
-    /** The end the requester lacks: `export` (provider, holders, managers) or `slot` (consumer, managers). */
-    needs: z.enum(["export", "slot"]),
-    reason: z.string(),
-    requestedBy: Id,
-    at: z.string(),
-    /**
-     * A request to expose: `slot` is the name the slot will have on `consumer`, made when it is
-     * approved. Approve it with `expose({provider, export, to: consumer, as: slot})`.
-     */
-    exposed: z.literal(true).optional(),
-});
 /**
  * `hub.grants@1`: binding with the caller's own authority, so it is safe to give any Actor. A
  * binding needs both ends: the export side (the provider, an Actor already bound to that export,
- * or a manager) and the slot side (the consumer itself, or a manager). With both, `bind` binds.
- * With one, it approves an open request from the other end, or becomes a request to that end's
- * approvers. With neither it is refused.
+ * or a manager) and the slot side (the consumer itself, or a manager). Without both it is refused.
  */
 export const hubGrants = defineInterface({
     name: "hub.grants",
     major: 1,
     kind: "rpc",
     methods: {
-        /** A request made by `bind` has an empty reason; `request` gives one. */
-        bind: method({
-            input: z.object(Wiring),
-            output: z.union([
-                z.object({ bound: z.literal(true) }),
-                z.object({ bound: z.literal(false), requestId: Id }),
-            ]),
-        }),
+        bind: method({ input: z.object(Wiring), output: z.object({ bound: z.literal(true) }) }),
         /** The consumer, the provider or a manager may unbind. */
         unbind: method({ input: z.object({ consumer: Id, slot: Name }), output: Empty }),
         /**
          * Expose an `rpc` export to one Actor: a slot made on `to`, typed by the export's interface,
          * named `as` (by default the provider's name camelCased, `_`, and the export's last part, made
-         * unique on `to`), and bound to the export, in one step. Its authority is a binding's: with
-         * both ends it is made; with one, it is a request to the other end's approvers, who approve it
-         * by calling `expose` with the request's fields. The same export already exposed to `to`
-         * gives that slot back.
+         * unique on `to`), and bound to the export, in one step. Its authority is a binding's. The same export already
+         * exposed to `to` gives that slot back.
          */
         expose: method({
             input: z.object({ provider: Id, export: Name, to: Id, as: SlotName.optional() }),
-            output: z.union([
-                z.object({ exposed: z.literal(true), slot: SlotName }),
-                z.object({ exposed: z.literal(false), slot: SlotName, requestId: Id }),
-            ]),
+            output: z.object({ exposed: z.literal(true), slot: SlotName }),
         }),
         /** Remove a slot made by `expose`, with its binding: as `unbind`, the consumer, the provider or a manager may. */
         unexpose: method({ input: z.object({ to: Id, slot: SlotName }), output: Empty }),
-        request: method({
-            input: z.object({ ...Wiring, reason: z.string().min(1).max(1000) }),
-            output: z.object({ requestId: Id }),
-        }),
-        /** The open requests the caller could approve. */
-        requests: method({ input: Empty, output: z.object({ requests: z.array(BindingRequest) }) }),
-        decline: method({ input: z.object({ requestId: Id }), output: Empty }),
-        /**
-         * The caller's own requests and how each stands, newest first: how a requester that missed
-         * `decided` learns the outcome.
-         */
-        mine: method({
-            input: z.object({ limit: z.number().int().min(1).max(1000).optional() }),
-            output: z.object({
-                requests: z.array(BindingRequest.extend({ status: z.enum(["open", "approved", "declined", "closed"]) })),
-            }),
-        }),
-    },
-    events: {
-        /** A request the subscriber could approve. */
-        requested: event(BindingRequest),
-        /**
-         * A request the subscriber could approve, or made, was approved (its binding made), declined,
-         * or closed (its slot was bound to something else, or one end went away).
-         */
-        decided: event(z.object({ request: BindingRequest, status: z.enum(["approved", "declined", "closed"]) })),
     },
 });
 /**
  * `hub.bindings@1`: management scope. An Actor bound to it is a manager: it holds both ends of
- * every binding and is an approver of every request, acting through `hub.grants@1`, which it needs
+ * every binding, acting through `hub.grants@1`, which it needs
  * as well. Here, the manager-wide reads.
  */
 export const hubBindings = defineInterface({
@@ -264,7 +123,6 @@ export const ExportEntry = z.object({
     export: Name,
     interface: z.string(),
     hash: Hash,
-    dynamic: z.boolean(),
 });
 /** `hub.exports@1`: what each Actor offers right now. */
 export const hubExports = defineInterface({