@agentorg/cli 0.0.4 → 0.0.6

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

@@ -1,194 +0,0 @@
-import { chmodSync } from "node:fs";
-import { join } from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import { Refused } from "@agentorg/sdk";
-export const STORAGE_LIMITS = {
-    maxValue: 256 * 1024,
-    maxPerConsumer: 64 * 1024 * 1024,
-};
-/** Bytes of a key, as UTF-8. */
-const MAX_KEY = 1024;
-const LONE_SURROGATE = /[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/;
-/** A key is well-formed text: half a surrogate pair would be stored as U+FFFD, merging keys. */
-function checkKey(key) {
-    if (LONE_SURROGATE.test(key))
-        throw new Refused("invalid", "A key is well-formed text.");
-}
-/**
- * The built-in `storage` Actor's `kv@1`: one store per consumer slot, kept in `<home>/storage.db`
- * (0600), apart from the Hub's own database. The store is chosen by the consumer and slot the
- * router names, never by the caller. Stores outlive unbinding; a closed Actor's go with it.
- */
-export class Storage {
-    #db;
-    #limits;
-    constructor(home, limits = STORAGE_LIMITS) {
-        this.#limits = limits;
-        const file = join(home, "storage.db");
-        // A lock held elsewhere is waited for a while rather than failing at once.
-        this.#db = new DatabaseSync(file, { timeout: 5000 });
-        chmodSync(file, 0o600);
-        this.#db.exec(`PRAGMA journal_mode = WAL;
-      CREATE TABLE IF NOT EXISTS store (
-        consumer TEXT NOT NULL, slot TEXT NOT NULL, key TEXT NOT NULL,
-        value TEXT NOT NULL, size INTEGER NOT NULL,
-        PRIMARY KEY (consumer, slot, key));
-      CREATE TABLE IF NOT EXISTS usage (consumer TEXT PRIMARY KEY, used INTEGER NOT NULL);`);
-        for (const suffix of ["-wal", "-shm"])
-            try {
-                chmodSync(file + suffix, 0o600);
-            }
-            catch {
-                // Not created yet.
-            }
-    }
-    /** One `kv@1` call on the store of (consumer, slot). Inputs were already checked. */
-    call(consumer, slot, method, input) {
-        const key = String(input.key ?? "");
-        switch (method) {
-            case "get": {
-                const row = this.#db
-                    .prepare("SELECT value FROM store WHERE consumer = ? AND slot = ? AND key = ?")
-                    .get(consumer, slot, key);
-                return row ? { value: JSON.parse(row.value) } : {};
-            }
-            case "set":
-                return this.#set(consumer, slot, key, input.value);
-            case "delete":
-                return this.#delete(consumer, slot, key);
-            case "list":
-                return this.#list(consumer, slot, input);
-            default:
-                throw new Refused("unimplemented", `kv@1 has no method ${method}.`);
-        }
-    }
-    /** Run work in one write transaction. */
-    #transaction(work) {
-        this.#db.exec("BEGIN IMMEDIATE");
-        try {
-            const out = work();
-            this.#db.exec("COMMIT");
-            return out;
-        }
-        catch (error) {
-            this.#db.exec("ROLLBACK");
-            throw error;
-        }
-    }
-    /** Add `delta` bytes to what a consumer's stores hold; the total is kept, never summed. */
-    #use(consumer, delta) {
-        this.#db
-            .prepare("INSERT INTO usage (consumer, used) VALUES (?, ?) ON CONFLICT (consumer) DO UPDATE SET used = used + excluded.used")
-            .run(consumer, delta);
-    }
-    #sizeOf(consumer, slot, key) {
-        const row = this.#db
-            .prepare("SELECT size FROM store WHERE consumer = ? AND slot = ? AND key = ?")
-            .get(consumer, slot, key);
-        return row && Number(row.size);
-    }
-    #set(consumer, slot, key, value) {
-        checkKey(key);
-        if (Buffer.byteLength(key) > MAX_KEY)
-            throw new Refused("quota", `A key is at most ${MAX_KEY} bytes.`);
-        const json = JSON.stringify(value);
-        const valueBytes = Buffer.byteLength(json);
-        if (valueBytes > this.#limits.maxValue)
-            throw new Refused("quota", `A value is at most ${this.#limits.maxValue} bytes.`);
-        const size = valueBytes + Buffer.byteLength(key);
-        this.#transaction(() => {
-            const used = this.#db.prepare("SELECT used FROM usage WHERE consumer = ?").get(consumer);
-            const replaced = this.#sizeOf(consumer, slot, key) ?? 0;
-            if (Number(used?.used ?? 0) - replaced + size > this.#limits.maxPerConsumer)
-                throw new Refused("quota", `An Actor's stores hold at most ${this.#limits.maxPerConsumer} bytes.`);
-            this.#db
-                .prepare("INSERT INTO store (consumer, slot, key, value, size) VALUES (?, ?, ?, ?, ?) ON CONFLICT (consumer, slot, key) DO UPDATE SET value = excluded.value, size = excluded.size")
-                .run(consumer, slot, key, json, size);
-            this.#use(consumer, size - replaced);
-        });
-        return {};
-    }
-    #delete(consumer, slot, key) {
-        return this.#transaction(() => {
-            const size = this.#sizeOf(consumer, slot, key);
-            if (size === undefined)
-                return { deleted: false };
-            this.#db
-                .prepare("DELETE FROM store WHERE consumer = ? AND slot = ? AND key = ?")
-                .run(consumer, slot, key);
-            this.#use(consumer, -size);
-            return { deleted: true };
-        });
-    }
-    /** Keys with the prefix, in order, after `after`, a page at a time. */
-    #list(consumer, slot, input) {
-        const prefix = typeof input.prefix === "string" ? input.prefix : "";
-        const after = typeof input.after === "string" ? input.after : "";
-        const limit = typeof input.limit === "number" ? input.limit : 100;
-        const rows = this.#db
-            .prepare(
-        // The scan starts at the prefix (or after `after`) and stops past the prefix's range; instr
-        // keeps exactly the keys that start with it.
-        `SELECT key FROM store WHERE consumer = ? AND slot = ? AND key > ? AND key >= ? AND key < ?
-         AND instr(key, ?) = 1 ORDER BY key LIMIT ?`)
-            .all(consumer, slot, after, prefix, `${prefix}\u{10FFFF}`, prefix, limit + 1);
-        const keys = rows.slice(0, limit).map((row) => row.key);
-        return { keys, next: rows.length > limit ? (keys.at(-1) ?? null) : null };
-    }
-    /**
-     * Seed the store of (consumer, slot), all or none, if it holds nothing: `storage.admin@1`'s
-     * `seed`. Each entry has kv@1's limits, and together they count toward the consumer's quota.
-     */
-    /** `named` is the consumer as a refusal names it: "Name (id)". */
-    seed(consumer, slot, entries, named = consumer) {
-        const keys = new Set();
-        const rows = entries.map(({ key, value }) => {
-            checkKey(key);
-            if (keys.has(key))
-                throw new Refused("invalid", `The key ${JSON.stringify(key)} is given twice.`);
-            keys.add(key);
-            if (Buffer.byteLength(key) > MAX_KEY)
-                throw new Refused("quota", `A key is at most ${MAX_KEY} bytes.`);
-            const json = JSON.stringify(value);
-            const valueBytes = Buffer.byteLength(json);
-            if (valueBytes > this.#limits.maxValue)
-                throw new Refused("quota", `A value is at most ${this.#limits.maxValue} bytes.`);
-            return { key, json, size: valueBytes + Buffer.byteLength(key) };
-        });
-        const total = rows.reduce((sum, row) => sum + row.size, 0);
-        this.#transaction(() => {
-            if (this.#db
-                .prepare("SELECT 1 FROM store WHERE consumer = ? AND slot = ? LIMIT 1")
-                .get(consumer, slot))
-                throw new Refused("not_empty", `The store of ${named}'s ${slot} isn't empty.`);
-            const used = this.#db.prepare("SELECT used FROM usage WHERE consumer = ?").get(consumer);
-            if (Number(used?.used ?? 0) + total > this.#limits.maxPerConsumer)
-                throw new Refused("quota", `An Actor's stores hold at most ${this.#limits.maxPerConsumer} bytes.`);
-            const insert = this.#db.prepare("INSERT INTO store (consumer, slot, key, value, size) VALUES (?, ?, ?, ?, ?)");
-            for (const row of rows)
-                insert.run(consumer, slot, row.key, row.json, row.size);
-            this.#use(consumer, total);
-        });
-    }
-    /** Every store of an Actor, gone: it was closed for good. */
-    deleteConsumer(consumer) {
-        this.#transaction(() => {
-            this.#db.prepare("DELETE FROM store WHERE consumer = ?").run(consumer);
-            this.#db.prepare("DELETE FROM usage WHERE consumer = ?").run(consumer);
-        });
-    }
-    /**
-     * Keep only the stores of these Actors. Run when the Hub opens, it catches up on deletes a crash
-     * or a lock kept from happening when an Actor was closed.
-     */
-    keepOnly(live) {
-        const consumers = this.#db.prepare("SELECT consumer FROM usage").all();
-        for (const { consumer } of consumers)
-            if (!live.has(consumer))
-                this.deleteConsumer(consumer);
-    }
-    close() {
-        if (this.#db.isOpen)
-            this.#db.close();
-    }
-}

package/dist/node_modules/@agentorg/interfaces/dist/src/http-egress.d.ts

@@ -1,6 +0,0 @@
-/**
- * `http.egress@1`: HTTPS requests to the public internet, made for the caller by the provider.
- * A request names its destination by its absolute `https:` URL. A slot of it is a host module's
- * whole network.
- */
-export declare const httpEgress: import("@agentorg/sdk").HttpInterface<"http.egress">;

package/dist/node_modules/@agentorg/interfaces/dist/src/http-egress.js

@@ -1,7 +0,0 @@
-import { defineInterface } from "@agentorg/sdk";
-/**
- * `http.egress@1`: HTTPS requests to the public internet, made for the caller by the provider.
- * A request names its destination by its absolute `https:` URL. A slot of it is a host module's
- * whole network.
- */
-export const httpEgress = defineInterface({ name: "http.egress", major: 1, kind: "http" });

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

@@ -1,191 +0,0 @@
-import { z } from "zod";
-/**
- * `agentorg.system/1`: a system as data, by names, never by ids. Its Actors and the packages
- * they run (`name@version#hash`), its connections, and the person's layout. Built-in Actors
- * (`hub`, `storage`, `net`) are named by their ids. No credentials, tokens, stores or logs.
- */
-export declare const Composition: z.ZodObject<{
-    format: z.ZodLiteral<"agentorg.system/1">;
-    actors: z.ZodRecord<z.ZodString, z.ZodObject<{
-        package: z.ZodString;
-        running: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    connections: z.ZodArray<z.ZodObject<{
-        consumer: z.ZodString;
-        slot: z.ZodString;
-        provider: z.ZodString;
-        export: z.ZodString;
-    }, z.core.$strip>>;
-    layout: z.ZodObject<{
-        home: z.ZodArray<z.ZodObject<{
-            actor: z.ZodString;
-            module: z.ZodString;
-            title: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-/**
- * `installer@1`: how a package becomes a working Actor. The installer is a package Actor the
- * person binds to the Hub's management (packages, Actors, grants, exports) and to
- * `storage.admin@1`; it proposes what each slot could connect to, and installs with the
- * connections it is given. It never picks a connection itself.
- */
-export declare const installer: import("@agentorg/sdk").RpcInterface<"installer", {
-    /**
-     * For each of the package's slots that it doesn't wire itself (`module.slot`): its interface
-     * (`name@major`) and the exports that could serve it now, those of exactly that interface and
-     * schema hash on Actors that aren't stopped or closed. And its view modules, which a shell
-     * can place.
-     */
-    plan: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        package: z.ZodString;
-        expose: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            export: z.ZodString;
-            to: z.ZodString;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>, z.ZodObject<{
-        slots: z.ZodArray<z.ZodObject<{
-            slot: z.ZodString;
-            interface: z.ZodString;
-            candidates: z.ZodArray<z.ZodObject<{
-                actor: z.ZodString;
-                export: z.ZodString;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        views: z.ZodArray<z.ZodString>;
-        exposes: z.ZodArray<z.ZodObject<{
-            export: z.ZodString;
-            to: z.ZodString;
-            settles: z.ZodEnum<{
-                granted: "granted";
-                request: "request";
-            }>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    /**
-     * Create an Actor of the package named `name`, with exactly these connections, all or none.
-     * The installer grants nothing its caller couldn't: each connection's export side must be the
-     * caller's (it is the provider, is bound to that export, or is a manager), else the whole
-     * install is refused (`forbidden`, listing every such connection) and nothing is created. A
-     * slot bound to `storage`'s `kv` gets the package's seed for it (an object of key to value);
-     * a seed whose slot isn't is listed in `unseeded`. Then it is started if `start`. If a seed or
-     * the start fails, the new Actor is closed. Slots left out stay unbound, listed in `unbound`.
-     * The Actor is recorded as made for the caller (`installedFor`), which grants nothing.
-     *
-     * `expose` lists the new Actor's exports to expose (`rpc` exports of its host modules), each to one Actor, all or none like the
-     * connections: a manager's are made now (`granted`, with the slot); one to the caller itself
-     * is left for the caller to file (`request`, with the exact `hub.grants.expose` call); any
-     * other is refused, and nothing is created. Nothing is exposed that isn't listed.
-     */
-    install: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        package: z.ZodString;
-        name: z.ZodString;
-        connections: z.ZodRecord<z.ZodString, z.ZodObject<{
-            actor: z.ZodString;
-            export: z.ZodString;
-        }, z.core.$strip>>;
-        start: z.ZodOptional<z.ZodBoolean>;
-        expose: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            export: z.ZodString;
-            to: z.ZodString;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>, z.ZodObject<{
-        actorId: z.ZodString;
-        unbound: z.ZodArray<z.ZodString>;
-        unseeded: z.ZodArray<z.ZodString>;
-        exposures: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-            export: z.ZodString;
-            to: z.ZodString;
-            settles: z.ZodLiteral<"granted">;
-            slot: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            export: z.ZodString;
-            to: z.ZodString;
-            settles: z.ZodLiteral<"request">;
-            call: z.ZodObject<{
-                provider: z.ZodString;
-                export: z.ZodString;
-                to: z.ZodString;
-            }, z.core.$strip>;
-        }, z.core.$strip>]>>;
-    }, z.core.$strip>>;
-    /**
-     * The system as it is, as a composition: every package Actor that isn't closed, the
-     * connections among them and to the built-in Actors, and the layout. External Actors (a
-     * program that connects itself, the person) and connections to them are listed in
-     * `unresolved`, not exported. Only a manager (an Actor bound to `hub.bindings`, as the person
-     * is) may export: a caller that isn't is refused `forbidden`.
-     */
-    exportSystem: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
-        composition: z.ZodObject<{
-            format: z.ZodLiteral<"agentorg.system/1">;
-            actors: z.ZodRecord<z.ZodString, z.ZodObject<{
-                package: z.ZodString;
-                running: z.ZodOptional<z.ZodBoolean>;
-            }, z.core.$strip>>;
-            connections: z.ZodArray<z.ZodObject<{
-                consumer: z.ZodString;
-                slot: z.ZodString;
-                provider: z.ZodString;
-                export: z.ZodString;
-            }, z.core.$strip>>;
-            layout: z.ZodObject<{
-                home: z.ZodArray<z.ZodObject<{
-                    actor: z.ZodString;
-                    module: z.ZodString;
-                    title: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>;
-        }, z.core.$strip>;
-        unresolved: z.ZodArray<z.ZodObject<{
-            what: z.ZodString;
-            why: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    /**
-     * Make a composition's system here, with the caller's authority: every connection's export
-     * side must be the caller's, as in `install`, or nothing is made (`forbidden`, listing them).
-     * Its packages must already be added (a composition travels with them; whoever holds the
-     * files adds them). An Actor whose package isn't here (or is another version) isn't made, and
-     * is listed in `unresolved` with what depends on it; so is an Actor that needs a sign-in, a
-     * seed that can't land, and the placements, unless the caller holds the person's layout.
-     * A connection to the Hub's management (`hub`) or to `storage.admin` is never made by an
-     * import, even a manager's: a composition may come from anyone, so those are listed in
-     * `ungranted`, for the person to grant one by one. A name already taken gets a suffix. Seeds land as in `install`; what was running is
-     * started; the layout is placed. If anything else fails, what this import made is closed.
-     */
-    importSystem: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        composition: z.ZodObject<{
-            format: z.ZodLiteral<"agentorg.system/1">;
-            actors: z.ZodRecord<z.ZodString, z.ZodObject<{
-                package: z.ZodString;
-                running: z.ZodOptional<z.ZodBoolean>;
-            }, z.core.$strip>>;
-            connections: z.ZodArray<z.ZodObject<{
-                consumer: z.ZodString;
-                slot: z.ZodString;
-                provider: z.ZodString;
-                export: z.ZodString;
-            }, z.core.$strip>>;
-            layout: z.ZodObject<{
-                home: z.ZodArray<z.ZodObject<{
-                    actor: z.ZodString;
-                    module: z.ZodString;
-                    title: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>;
-        }, z.core.$strip>;
-    }, z.core.$strip>, z.ZodObject<{
-        created: z.ZodRecord<z.ZodString, z.ZodString>;
-        unresolved: z.ZodArray<z.ZodObject<{
-            what: z.ZodString;
-            why: z.ZodString;
-        }, z.core.$strip>>;
-        ungranted: z.ZodArray<z.ZodObject<{
-            consumer: z.ZodString;
-            slot: z.ZodString;
-            provider: z.ZodString;
-            export: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-}, {}, 1>;

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

@@ -1,136 +0,0 @@
-import { defineInterface, method } from "@agentorg/sdk";
-import { z } from "zod";
-import { Id, Name, SlotName } from "./hub.js";
-const Hash = z.string().regex(/^sha256-[0-9a-f]{64}$/);
-/** An export of a running Actor, by its id and the export's name. */
-const Target = z.object({ actor: Id, export: Name });
-/** One of the new Actor's `rpc` exports (`module.export`), to expose to the Actor `to`. */
-const Exposure = z.object({ export: Name, to: Id });
-/**
- * How an exposure settles, by the caller's own authority: `granted`, made now (the caller holds
- * both sides: it is a manager), or `request`, which the caller files itself with
- * `hub.grants.expose` (it holds `to`'s side: it is `to`). Nothing else is exposed.
- */
-const Settles = z.enum(["granted", "request"]);
-/** An Actor of a composition, by the name it has there. */
-const ActorName = z.string().min(1).max(128);
-/**
- * `agentorg.system/1`: a system as data, by names, never by ids. Its Actors and the packages
- * they run (`name@version#hash`), its connections, and the person's layout. Built-in Actors
- * (`hub`, `storage`, `net`) are named by their ids. No credentials, tokens, stores or logs.
- */
-export const Composition = z.object({
-    format: z.literal("agentorg.system/1"),
-    actors: z.record(ActorName, z.object({ package: z.string(), running: z.boolean().optional() })),
-    connections: z.array(z.object({ consumer: ActorName, slot: Name, provider: ActorName, export: Name })),
-    layout: z.object({
-        home: z.array(z.object({
-            actor: ActorName,
-            module: z
-                .string()
-                .regex(/^[a-z][A-Za-z0-9_]*$/)
-                .max(64),
-            title: z.string().max(200).optional(),
-        })),
-    }),
-});
-/** What a system's export or import couldn't carry over, and why: listed, never guessed. */
-const Unresolved = z.array(z.object({ what: z.string(), why: z.string() }));
-/**
- * `installer@1`: how a package becomes a working Actor. The installer is a package Actor the
- * person binds to the Hub's management (packages, Actors, grants, exports) and to
- * `storage.admin@1`; it proposes what each slot could connect to, and installs with the
- * connections it is given. It never picks a connection itself.
- */
-export const installer = defineInterface({
-    name: "installer",
-    major: 1,
-    kind: "rpc",
-    methods: {
-        /**
-         * For each of the package's slots that it doesn't wire itself (`module.slot`): its interface
-         * (`name@major`) and the exports that could serve it now, those of exactly that interface and
-         * schema hash on Actors that aren't stopped or closed. And its view modules, which a shell
-         * can place.
-         */
-        plan: method({
-            input: z.object({ package: Hash, expose: z.array(Exposure).max(64).optional() }),
-            output: z.object({
-                slots: z.array(z.object({ slot: Name, interface: z.string(), candidates: z.array(Target) })),
-                views: z.array(z.string()),
-                /**
-                 * Each `expose` entry given, with how `install` would settle it for this caller; an entry
-                 * `install` would refuse is refused here the same way.
-                 */
-                exposes: z.array(Exposure.extend({ settles: Settles })),
-            }),
-        }),
-        /**
-         * Create an Actor of the package named `name`, with exactly these connections, all or none.
-         * The installer grants nothing its caller couldn't: each connection's export side must be the
-         * caller's (it is the provider, is bound to that export, or is a manager), else the whole
-         * install is refused (`forbidden`, listing every such connection) and nothing is created. A
-         * slot bound to `storage`'s `kv` gets the package's seed for it (an object of key to value);
-         * a seed whose slot isn't is listed in `unseeded`. Then it is started if `start`. If a seed or
-         * the start fails, the new Actor is closed. Slots left out stay unbound, listed in `unbound`.
-         * The Actor is recorded as made for the caller (`installedFor`), which grants nothing.
-         *
-         * `expose` lists the new Actor's exports to expose (`rpc` exports of its host modules), each to one Actor, all or none like the
-         * connections: a manager's are made now (`granted`, with the slot); one to the caller itself
-         * is left for the caller to file (`request`, with the exact `hub.grants.expose` call); any
-         * other is refused, and nothing is created. Nothing is exposed that isn't listed.
-         */
-        install: method({
-            input: z.object({
-                package: Hash,
-                name: z.string().min(1).max(128),
-                connections: z.record(Name, Target),
-                start: z.boolean().optional(),
-                expose: z.array(Exposure).max(64).optional(),
-            }),
-            output: z.object({
-                actorId: Id,
-                unbound: z.array(Name),
-                unseeded: z.array(Name),
-                exposures: z.array(z.union([
-                    Exposure.extend({ settles: z.literal("granted"), slot: SlotName }),
-                    Exposure.extend({
-                        settles: z.literal("request"),
-                        call: z.object({ provider: Id, export: Name, to: Id }),
-                    }),
-                ])),
-            }),
-        }),
-        /**
-         * The system as it is, as a composition: every package Actor that isn't closed, the
-         * connections among them and to the built-in Actors, and the layout. External Actors (a
-         * program that connects itself, the person) and connections to them are listed in
-         * `unresolved`, not exported. Only a manager (an Actor bound to `hub.bindings`, as the person
-         * is) may export: a caller that isn't is refused `forbidden`.
-         */
-        exportSystem: method({
-            input: z.object({}),
-            output: z.object({ composition: Composition, unresolved: Unresolved }),
-        }),
-        /**
-         * Make a composition's system here, with the caller's authority: every connection's export
-         * side must be the caller's, as in `install`, or nothing is made (`forbidden`, listing them).
-         * Its packages must already be added (a composition travels with them; whoever holds the
-         * files adds them). An Actor whose package isn't here (or is another version) isn't made, and
-         * is listed in `unresolved` with what depends on it; so is an Actor that needs a sign-in, a
-         * seed that can't land, and the placements, unless the caller holds the person's layout.
-         * A connection to the Hub's management (`hub`) or to `storage.admin` is never made by an
-         * import, even a manager's: a composition may come from anyone, so those are listed in
-         * `ungranted`, for the person to grant one by one. A name already taken gets a suffix. Seeds land as in `install`; what was running is
-         * started; the layout is placed. If anything else fails, what this import made is closed.
-         */
-        importSystem: method({
-            input: z.object({ composition: Composition }),
-            output: z.object({
-                created: z.record(ActorName, Id),
-                unresolved: Unresolved,
-                ungranted: z.array(z.object({ consumer: ActorName, slot: Name, provider: ActorName, export: Name })),
-            }),
-        }),
-    },
-});

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

@@ -1,47 +0,0 @@
-import { z } from "zod";
-/** One view on the dashboard: a `view` module of a running package Actor. */
-export declare const Placement: z.ZodObject<{
-    id: z.ZodString;
-    actor: z.ZodString;
-    module: z.ZodString;
-    title: z.ZodOptional<z.ZodString>;
-    by: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-/**
- * `layout@1`: the person's dashboard, the views placed on it and their order. The person's Actor
- * exports it, so a program bound to it places a widget as the person does.
- */
-export declare const layout: import("@agentorg/sdk").RpcInterface<"layout", {
-    get: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
-        home: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            actor: z.ZodString;
-            module: z.ZodString;
-            title: z.ZodOptional<z.ZodString>;
-            by: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    /**
-     * Place a view, after the placement `after`, or last. Refused unless `module` is a `view`
-     * module of that Actor's package.
-     */
-    place: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        actor: z.ZodString;
-        module: z.ZodString;
-        title: z.ZodOptional<z.ZodString>;
-        after: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        id: z.ZodString;
-    }, z.core.$strip>>;
-    remove: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        id: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
-    /** Move a placement after `after`, or first. */
-    move: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        id: z.ZodString;
-        after: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
-}, {
-    /** The layout changed; read it again with `get`. */
-    changed: import("@agentorg/sdk").EventSpec<z.ZodObject<{}, z.core.$strip>>;
-}, 1>;

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

@@ -1,52 +0,0 @@
-import { defineInterface, event, method } from "@agentorg/sdk";
-import { z } from "zod";
-const Id = z.string().min(1).max(128);
-/** A module of a package, by its name in the manifest. */
-const ModuleName = z
-    .string()
-    .regex(/^[a-z][A-Za-z0-9_]*$/)
-    .max(64);
-/** One view on the dashboard: a `view` module of a running package Actor. */
-export const Placement = z.object({
-    id: Id,
-    actor: Id,
-    module: ModuleName,
-    title: z.string().max(200).optional(),
-    /**
-     * The Actor that placed it, as the layout's provider saw the call: the person, or an agent bound
-     * to `layout@1`. The provider records it; `place` takes no such input.
-     */
-    by: Id.optional(),
-});
-/**
- * `layout@1`: the person's dashboard, the views placed on it and their order. The person's Actor
- * exports it, so a program bound to it places a widget as the person does.
- */
-export const layout = defineInterface({
-    name: "layout",
-    major: 1,
-    kind: "rpc",
-    methods: {
-        get: method({ input: z.object({}), output: z.object({ home: z.array(Placement) }) }),
-        /**
-         * Place a view, after the placement `after`, or last. Refused unless `module` is a `view`
-         * module of that Actor's package.
-         */
-        place: method({
-            input: z.object({
-                actor: Id,
-                module: ModuleName,
-                title: z.string().max(200).optional(),
-                after: Id.optional(),
-            }),
-            output: z.object({ id: Id }),
-        }),
-        remove: method({ input: z.object({ id: Id }), output: z.object({}) }),
-        /** Move a placement after `after`, or first. */
-        move: method({ input: z.object({ id: Id, after: Id.optional() }), output: z.object({}) }),
-    },
-    events: {
-        /** The layout changed; read it again with `get`. */
-        changed: event(z.object({})),
-    },
-});

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

@@ -1,35 +0,0 @@
-import { z } from "zod";
-/**
- * One named rule: a convenience the person turns on, off unless they do. `says` is what it does,
- * in the person's words.
- */
-export declare const Rule: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    says: z.ZodString;
-    on: z.ZodBoolean;
-}, z.core.$strip>;
-/**
- * `app.rules@1`: the person's named rules. Each is held by the person's Actor (the app's gateway),
- * which acts on a rule that is on as the person, a manager, and only within what the person could
- * grant. A rule is the only thing that may act on provenance such as an Actor's `installedFor`.
- */
-export declare const appRules: import("@agentorg/sdk").RpcInterface<"app.rules", {
-    /** Every rule the app knows, each with whether it is on. */
-    list: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
-        rules: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            name: z.ZodString;
-            says: z.ZodString;
-            on: z.ZodBoolean;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    /** Turn a rule on or off. Turning one on settles what already waits for it. */
-    set: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        id: z.ZodString;
-        on: z.ZodBoolean;
-    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
-}, {
-    /** A rule was turned on or off; read them again with `list`. */
-    changed: import("@agentorg/sdk").EventSpec<z.ZodObject<{}, z.core.$strip>>;
-}, 1>;