nervur 0.23.0 → 0.24.0

package/dist/ground/dock.d.ts

@@ -1,1460 +0,0 @@
-import type { Json } from '../being/being.ts';
-import { type Args } from '../being/index.ts';
-import { ClassList } from '../bodies/class-list.ts';
-/** The dock's name: no house and no faculty takes it. */
-export declare const DOCK = "dock";
-/** The kinds of the dock's beings, which the ground's offers name. */
-export declare const KINDS: Readonly<{
-    steward: "org.nervur.dock";
-    faculty: "org.nervur.dock.faculty";
-    house: "org.nervur.dock.house";
-    secret: "org.nervur.dock.secret";
-    shell: "org.nervur.dock.shell";
-}>;
-/** The prefix of each dock being's id, before the name its entry gives. */
-export declare const IDS: Readonly<{
-    faculty: "faculty.";
-    house: "house.";
-    secret: "secret.";
-}>;
-/**
- * The ground's work, as its faculty offers it to the dock: a body raised
- * and lowered, a house opened, closed or held asleep, the terrain's
- * defaults, what an entry's faculty takes, the catalogue, a body's method
- * called, and a house's places moved out and in. Each is awaited.
- */
-export declare const GroundNeed: import("../being/need.ts").Need<{
-    readonly terrain: {
-        readonly result: Readonly<{}>;
-        readonly hints: {
-            readonly readOnly: true;
-        };
-    };
-    readonly check: {
-        readonly args: import("../being/schema.ts").Schema<{
-            entry: never;
-            name: string;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            why?: string | undefined;
-        }>;
-        readonly hints: {
-            readonly readOnly: true;
-        };
-    };
-    readonly raise: {
-        readonly args: import("../being/schema.ts").Schema<{
-            entry: never;
-            installed?: string | undefined;
-            name: string;
-        }>;
-        readonly result: Readonly<{}>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly lower: {
-        readonly args: import("../being/schema.ts").Schema<{
-            name: string;
-            why?: string | undefined;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly open: {
-        readonly args: import("../being/schema.ts").Schema<{
-            bound?: number | undefined;
-            entry: never;
-            name: string;
-            seed: string;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            ward?: string | undefined;
-            why?: string | undefined;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly close: {
-        readonly args: import("../being/schema.ts").Schema<{
-            name: string;
-            why?: string | undefined;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly sleep: {
-        readonly args: import("../being/schema.ts").Schema<{
-            entry: never;
-            name: string;
-            ward: string;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-    };
-    readonly catalog: {
-        readonly result: Readonly<{}>;
-        readonly hints: {
-            readonly readOnly: true;
-        };
-    };
-    readonly call: {
-        readonly args: import("../being/schema.ts").Schema<{
-            args?: undefined;
-            faculty: string;
-            method: string;
-        }>;
-        readonly result: Readonly<{}>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly placesOut: {
-        readonly args: import("../being/schema.ts").Schema<{
-            entry: never;
-            name: string;
-        }>;
-        readonly result: Readonly<{}>;
-        readonly hints: {
-            readonly readOnly: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly placesIn: {
-        readonly args: import("../being/schema.ts").Schema<{
-            entry: never;
-            name: string;
-            places: never;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-}>;
-/** A command run on the ground's machine, as its owner runs one: its exit code and what it printed. */
-export declare const ShellNeed: import("../being/need.ts").Need<{
-    readonly run: {
-        readonly args: import("../being/schema.ts").Schema<{
-            args?: string[] | undefined;
-            command: string;
-            cwd?: string | undefined;
-            stdin?: string | undefined;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            code: number;
-            stderr: string;
-            stdout: string;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-}>;
-/** The ground's one listener, as a body offers it: the handler of every body, chained. It has no method a being calls. */
-export declare const ListenerNeed: import("../being/need.ts").Need<{}>;
-/** One faculty's entry, whole: who makes it, what it is handed, the bodies it calls, and its grant. */
-export interface WholeFaculty {
-    readonly make?: string;
-    readonly from?: string;
-    readonly args?: Readonly<Record<string, Json>>;
-    readonly secrets?: readonly string[];
-    readonly faculties?: readonly string[];
-    readonly kinds?: readonly string[];
-}
-/** One body a house names, and the args it hands that house. */
-interface Named {
-    readonly faculty: string;
-    readonly [argument: string]: Json | undefined;
-}
-/** One house's entry, whole. */
-export interface WholeHouse {
-    readonly classes: Named;
-    readonly memory?: Named;
-    readonly faculties?: readonly string[];
-    readonly wait?: number;
-}
-/** A faculty's entry read from what the hand gave, or why it is no entry. */
-export declare const facultyEntryOf: (value: unknown) => WholeFaculty | string;
-/** A house's entry read from what the hand gave, or why it is no entry. */
-export declare const houseEntryOf: (value: unknown) => WholeHouse | string;
-/**
- * A ground's dock as a pilot holds it: the asks its steward answers for a
- * standing the owner minted with `pilotsInvite`. A being far or near
- * pilots a ground by `this.held(id, DockPilot)`.
- */
-export declare const DockPilot: import("../being/need.ts").Need<{
-    readonly housesAdd: {
-        args: import("../being/schema.ts").Schema<{
-            classes: never;
-            faculties?: string[] | undefined;
-            memory?: undefined;
-            name: string;
-            wait?: number | undefined;
-        }>;
-        result: import("../being/schema.ts").Schema<{
-            ward?: string | undefined;
-            why?: string | undefined;
-        }>;
-        hints: {
-            readonly idempotent: true;
-        };
-        wait: 300000;
-    };
-    readonly housesUpdate: {
-        args: import("../being/schema.ts").Schema<{
-            classes: never;
-            faculties?: string[] | undefined;
-            memory?: undefined;
-            name: string;
-            wait?: number | undefined;
-        }>;
-        result: import("../being/schema.ts").Schema<{
-            ward?: string | undefined;
-            why?: string | undefined;
-        }>;
-        hints: {
-            readonly idempotent: true;
-        };
-        wait: 300000;
-    };
-    readonly housesRemove: {
-        args: import("../being/schema.ts").Schema<{
-            name: string;
-        }>;
-        hints: {
-            readonly idempotent: true;
-        };
-        wait: 300000;
-    };
-    readonly housesList: {
-        result: import("../being/schema.ts").Schema<{
-            entry: never;
-            name: string;
-            ward?: string | undefined;
-            why?: string | undefined;
-        }[]>;
-        hints: {
-            readonly readOnly: true;
-            readonly idempotent: true;
-        };
-        wait: 300000;
-    };
-    readonly facultiesAdd: {
-        args: import("../being/schema.ts").Schema<{
-            args?: undefined;
-            faculties?: string[] | undefined;
-            from?: string | undefined;
-            kinds?: string[] | undefined;
-            make?: string | undefined;
-            name: string;
-            secrets?: string[] | undefined;
-        }>;
-        result: import("../being/schema.ts").Schema<{
-            why?: string | undefined;
-        }>;
-        hints: {
-            readonly idempotent: true;
-        };
-        wait: 300000;
-    };
-    readonly facultiesUpdate: {
-        args: import("../being/schema.ts").Schema<{
-            args?: undefined;
-            faculties?: string[] | undefined;
-            from?: string | undefined;
-            kinds?: string[] | undefined;
-            make?: string | undefined;
-            name: string;
-            secrets?: string[] | undefined;
-        }>;
-        result: import("../being/schema.ts").Schema<{
-            why?: string | undefined;
-        }>;
-        hints: {
-            readonly idempotent: true;
-        };
-        wait: 300000;
-    };
-    readonly facultiesRestart: {
-        args: import("../being/schema.ts").Schema<{
-            name: string;
-        }>;
-        result: import("../being/schema.ts").Schema<{
-            why?: string | undefined;
-        }>;
-        hints: {
-            readonly idempotent: true;
-        };
-        wait: 300000;
-    };
-    readonly facultiesRemove: {
-        args: import("../being/schema.ts").Schema<{
-            name: string;
-        }>;
-        hints: {
-            readonly idempotent: true;
-        };
-        wait: 300000;
-    };
-    readonly facultiesList: {
-        result: import("../being/schema.ts").Schema<{
-            entry: never;
-            name: string;
-            serves?: string | undefined;
-            terrain?: boolean | undefined;
-            why?: string | undefined;
-        }[]>;
-        hints: {
-            readonly readOnly: true;
-            readonly idempotent: true;
-        };
-        wait: 300000;
-    };
-    readonly facultiesCatalog: {
-        result: import("../being/schema.ts").Schema<{
-            faculties: {
-                make: string;
-                takes?: undefined;
-            }[];
-            from?: string | undefined;
-        }[]>;
-        hints: {
-            readonly readOnly: true;
-            readonly idempotent: true;
-        };
-    };
-}>;
-type Stood = {
-    ward?: string;
-    why?: string;
-};
-type Raised = {
-    installed?: string;
-    why?: string;
-    serves?: string;
-    port?: number;
-};
-declare const DockSteward_base: import("../being/being.ts").BeingClass<{
-    wait: number | null;
-}, {
-    readonly ground: import("../being/need.ts").Need<{
-        readonly terrain: {
-            readonly result: Readonly<{}>;
-            readonly hints: {
-                readonly readOnly: true;
-            };
-        };
-        readonly check: {
-            readonly args: import("../being/schema.ts").Schema<{
-                entry: never;
-                name: string;
-            }>;
-            readonly result: import("../being/schema.ts").Schema<{
-                why?: string | undefined;
-            }>;
-            readonly hints: {
-                readonly readOnly: true;
-            };
-        };
-        readonly raise: {
-            readonly args: import("../being/schema.ts").Schema<{
-                entry: never;
-                installed?: string | undefined;
-                name: string;
-            }>;
-            readonly result: Readonly<{}>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-        readonly lower: {
-            readonly args: import("../being/schema.ts").Schema<{
-                name: string;
-                why?: string | undefined;
-            }>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-        readonly open: {
-            readonly args: import("../being/schema.ts").Schema<{
-                bound?: number | undefined;
-                entry: never;
-                name: string;
-                seed: string;
-            }>;
-            readonly result: import("../being/schema.ts").Schema<{
-                ward?: string | undefined;
-                why?: string | undefined;
-            }>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-        readonly close: {
-            readonly args: import("../being/schema.ts").Schema<{
-                name: string;
-                why?: string | undefined;
-            }>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-        readonly sleep: {
-            readonly args: import("../being/schema.ts").Schema<{
-                entry: never;
-                name: string;
-                ward: string;
-            }>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-        };
-        readonly catalog: {
-            readonly result: Readonly<{}>;
-            readonly hints: {
-                readonly readOnly: true;
-            };
-        };
-        readonly call: {
-            readonly args: import("../being/schema.ts").Schema<{
-                args?: undefined;
-                faculty: string;
-                method: string;
-            }>;
-            readonly result: Readonly<{}>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-        readonly placesOut: {
-            readonly args: import("../being/schema.ts").Schema<{
-                entry: never;
-                name: string;
-            }>;
-            readonly result: Readonly<{}>;
-            readonly hints: {
-                readonly readOnly: true;
-            };
-            readonly wait: 300000;
-        };
-        readonly placesIn: {
-            readonly args: import("../being/schema.ts").Schema<{
-                entry: never;
-                name: string;
-                places: never;
-            }>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-    }>;
-}, {
-    readonly boot: {
-        readonly for: "root";
-        readonly description: "Stands the ladder from every entry, the terrain’s and the owner’s, and opens every house: each wake asks it once.";
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly housesAdd: {
-        readonly for: string[];
-        readonly description: "Opens a house on the bodies its entry names, and answers its ward, or why it stands closed; the same name and entry answer as it stands.";
-        readonly args: import("../being/schema.ts").Schema<{
-            classes: never;
-            faculties?: string[] | undefined;
-            memory?: undefined;
-            name: string;
-            wait?: number | undefined;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            ward?: string | undefined;
-            why?: string | undefined;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly housesUpdate: {
-        readonly for: string[];
-        readonly description: "Lands a new entry over a house’s in one write, and opens the house again on it.";
-        readonly args: import("../being/schema.ts").Schema<{
-            classes: never;
-            faculties?: string[] | undefined;
-            memory?: undefined;
-            name: string;
-            wait?: number | undefined;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            ward?: string | undefined;
-            why?: string | undefined;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly housesRemove: {
-        readonly for: string[];
-        readonly description: "Closes a house and drops its entry; its seed and its places stay.";
-        readonly args: import("../being/schema.ts").Schema<{
-            name: string;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly housesList: {
-        readonly for: string[];
-        readonly description: "Every house with its whole entry, open with its ward or closed with why.";
-        readonly result: import("../being/schema.ts").Schema<{
-            entry: never;
-            name: string;
-            ward?: string | undefined;
-            why?: string | undefined;
-        }[]>;
-        readonly hints: {
-            readonly readOnly: true;
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly facultiesAdd: {
-        readonly for: string[];
-        readonly description: "Raises a body from the registry its entry names, and answers why it is down where it is; the same name and entry answer as it stands.";
-        readonly args: import("../being/schema.ts").Schema<{
-            args?: undefined;
-            faculties?: string[] | undefined;
-            from?: string | undefined;
-            kinds?: string[] | undefined;
-            make?: string | undefined;
-            name: string;
-            secrets?: string[] | undefined;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            why?: string | undefined;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly facultiesUpdate: {
-        readonly for: string[];
-        readonly description: "Lands a new entry over a faculty’s in one write: its body goes down, installs where the entry moved, and goes up, and each house and body that uses it follows.";
-        readonly args: import("../being/schema.ts").Schema<{
-            args?: undefined;
-            faculties?: string[] | undefined;
-            from?: string | undefined;
-            kinds?: string[] | undefined;
-            make?: string | undefined;
-            name: string;
-            secrets?: string[] | undefined;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            why?: string | undefined;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly facultiesRestart: {
-        readonly for: string[];
-        readonly description: "Takes a body down and up again on its entry, and each house and body that uses it follows.";
-        readonly args: import("../being/schema.ts").Schema<{
-            name: string;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            why?: string | undefined;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly facultiesRemove: {
-        readonly for: string[];
-        readonly description: "Takes down a body no house and no body uses, and drops its entry.";
-        readonly args: import("../being/schema.ts").Schema<{
-            name: string;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly facultiesList: {
-        readonly for: string[];
-        readonly description: "Every faculty entry whole, the terrain’s marked so and the owner’s, standing, or down with why. An entry names its secrets and holds none.";
-        readonly result: import("../being/schema.ts").Schema<{
-            entry: never;
-            name: string;
-            serves?: string | undefined;
-            terrain?: boolean | undefined;
-            why?: string | undefined;
-        }[]>;
-        readonly hints: {
-            readonly readOnly: true;
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly facultiesCatalog: {
-        readonly for: string[];
-        readonly description: "Every registry of the ladder, the ground’s first and then each body’s that carries one, with each faculty it holds and what it takes: the schema its args meet and the secrets its entry names.";
-        readonly result: import("../being/schema.ts").Schema<{
-            faculties: {
-                make: string;
-                takes?: undefined;
-            }[];
-            from?: string | undefined;
-        }[]>;
-        readonly hints: {
-            readonly readOnly: true;
-            readonly idempotent: true;
-        };
-    };
-    readonly waitSet: {
-        readonly for: string[];
-        readonly description: "Sets the ground’s bound on every ask, in milliseconds, or drops it back to the terrain’s where none is given; every open house opens again on it.";
-        readonly args: import("../being/schema.ts").Schema<{
-            wait?: number | undefined;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            terrain: boolean;
-            wait?: number | undefined;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly waitShow: {
-        readonly for: string[];
-        readonly description: "The ground’s bound on every ask, and whether it is the terrain’s.";
-        readonly result: import("../being/schema.ts").Schema<{
-            terrain: boolean;
-            wait?: number | undefined;
-        }>;
-        readonly hints: {
-            readonly readOnly: true;
-            readonly idempotent: true;
-        };
-    };
-    readonly secretsSet: {
-        readonly for: "root";
-        readonly description: "Keeps a secret, for the faculties whose entries name it. It answers nothing, so no answer holds it.";
-        readonly args: import("../being/schema.ts").Schema<{
-            name: string;
-            value: string;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-    };
-    readonly secretsRemove: {
-        readonly for: "root";
-        readonly description: "Drops a secret.";
-        readonly args: import("../being/schema.ts").Schema<{
-            name: string;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-    };
-    readonly secretsList: {
-        readonly for: "root";
-        readonly description: "Every secret kept or named, whether it is kept, and the faculty entries that name it, and never a value.";
-        readonly result: import("../being/schema.ts").Schema<{
-            entries: string[];
-            kept: boolean;
-            name: string;
-        }[]>;
-        readonly hints: {
-            readonly readOnly: true;
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly movesOut: {
-        readonly for: "root";
-        readonly description: "Closes a house and drops its entry, and answers its seed and every place of its memory.";
-        readonly args: import("../being/schema.ts").Schema<{
-            name: string;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            places: never;
-            seed: string;
-        }>;
-        readonly hints: {
-            readonly destructive: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly movesIn: {
-        readonly for: "root";
-        readonly description: "Keeps a moved seed, writes its places into an empty memory, and opens the house on the bodies its entry names.";
-        readonly args: import("../being/schema.ts").Schema<{
-            classes: never;
-            faculties?: string[] | undefined;
-            memory?: undefined;
-            name: string;
-            places: never;
-            seed: string;
-            wait?: number | undefined;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            ward?: string | undefined;
-            why?: string | undefined;
-        }>;
-        readonly wait: 300000;
-    };
-    readonly callFaculty: {
-        readonly for: "root";
-        readonly description: "Calls a method of a body of the ladder by name, its args held to the method’s schema.";
-        readonly args: import("../being/schema.ts").Schema<{
-            args?: undefined;
-            faculty: string;
-            method: string;
-        }>;
-        readonly result: Readonly<{}>;
-        readonly wait: 300000;
-    };
-    readonly shellRun: {
-        readonly for: "root";
-        readonly description: "Runs a command on the ground’s machine, with nothing of the ground in its environment, and answers its exit code and what it printed.";
-        readonly args: import("../being/schema.ts").Schema<{
-            args?: string[] | undefined;
-            command: string;
-            cwd?: string | undefined;
-            stdin?: string | undefined;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            code: number;
-            stderr: string;
-            stdout: string;
-        }>;
-        readonly wait: 300000;
-    };
-    readonly pilotsInvite: {
-        readonly for: "root";
-        readonly description: "A new pilot: an occupant of hers that reaches the houses and faculties asks, as an invitation for the being that pilots.";
-        readonly args: import("../being/schema.ts").Schema<{
-            id: string;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            invitation: import("../being/schema.ts").HandleMark;
-        }>;
-    };
-    readonly pilotsDismiss: {
-        readonly for: "root";
-        readonly description: "Lets a pilot go.";
-        readonly args: import("../being/schema.ts").Schema<{
-            id: string;
-        }>;
-    };
-    readonly pilotsList: {
-        readonly for: "root";
-        readonly description: "Every pilot she holds.";
-        readonly result: import("../being/schema.ts").Schema<string[]>;
-        readonly hints: {
-            readonly readOnly: true;
-            readonly idempotent: true;
-        };
-    };
-    readonly grants: {
-        readonly for: "root";
-        readonly description: "Every body the dock is offered: the twins she stands on.";
-        readonly result: import("../being/schema.ts").Schema<string[]>;
-        readonly hints: {
-            readonly readOnly: true;
-            readonly idempotent: true;
-        };
-    };
-    readonly granted: {
-        readonly for: "root";
-        readonly description: "Bears the being that holds the shell’s offer, once the dock is offered it.";
-        readonly hints: {
-            readonly idempotent: true;
-        };
-    };
-}>;
-/** The dock's steward: every ask the hand makes of the ground. */
-export declare class DockSteward extends DockSteward_base {
-    #private;
-    boot(): Promise<void>;
-    grants(): Promise<string[]>;
-    granted(): Promise<void>;
-    housesAdd(given: Args<DockSteward, 'housesAdd'>): Promise<Stood>;
-    housesUpdate(given: Args<DockSteward, 'housesUpdate'>): Promise<Stood>;
-    housesRemove({ name }: Args<DockSteward, 'housesRemove'>): Promise<void>;
-    housesList(): Promise<never>;
-    facultiesAdd(given: Args<DockSteward, 'facultiesAdd'>): Promise<{
-        why: string;
-    } | {
-        why?: undefined;
-    }>;
-    facultiesUpdate(given: Args<DockSteward, 'facultiesUpdate'>): Promise<{
-        why: string;
-    } | {
-        why?: undefined;
-    }>;
-    facultiesRestart({ name }: Args<DockSteward, 'facultiesRestart'>): Promise<{
-        why?: undefined;
-    } | {
-        why: string;
-    }>;
-    facultiesRemove({ name }: Args<DockSteward, 'facultiesRemove'>): Promise<undefined>;
-    facultiesList(): Promise<never>;
-    facultiesCatalog(): Promise<never>;
-    waitSet({ wait }: Args<DockSteward, 'waitSet'>): Promise<{
-        wait?: number | undefined;
-        terrain: boolean;
-    }>;
-    waitShow(): Promise<{
-        wait?: number | undefined;
-        terrain: boolean;
-    }>;
-    secretsSet({ name, value }: Args<DockSteward, 'secretsSet'>): Promise<void>;
-    secretsRemove({ name }: Args<DockSteward, 'secretsRemove'>): Promise<void>;
-    secretsList(): Promise<{
-        name: string;
-        kept: boolean;
-        entries: string[];
-    }[]>;
-    movesOut({ name }: Args<DockSteward, 'movesOut'>): Promise<{
-        seed: string;
-        places: Record<string, Json>;
-    }>;
-    movesIn(given: Args<DockSteward, 'movesIn'>): Promise<Stood>;
-    callFaculty({ faculty, method, args }: Args<DockSteward, 'callFaculty'>): Promise<never>;
-    shellRun(args: Args<DockSteward, 'shellRun'>): Promise<{
-        code: number;
-        stdout: string;
-        stderr: string;
-    }>;
-    pilotsInvite({ id }: Args<DockSteward, 'pilotsInvite'>): {
-        invitation: import("../being/schema.ts").Handle;
-    };
-    pilotsDismiss({ id }: Args<DockSteward, 'pilotsDismiss'>): void;
-    pilotsList(): string[];
-}
-declare const DockFaculty_base: import("../being/being.ts").BeingClass<{
-    terrain: boolean;
-    entry: Record<string, Json> | null;
-    installed: string | null;
-    why: string | null;
-    serves: string | null;
-    port: number | null;
-}, {
-    readonly ground: import("../being/need.ts").Need<{
-        readonly terrain: {
-            readonly result: Readonly<{}>;
-            readonly hints: {
-                readonly readOnly: true;
-            };
-        };
-        readonly check: {
-            readonly args: import("../being/schema.ts").Schema<{
-                entry: never;
-                name: string;
-            }>;
-            readonly result: import("../being/schema.ts").Schema<{
-                why?: string | undefined;
-            }>;
-            readonly hints: {
-                readonly readOnly: true;
-            };
-        };
-        readonly raise: {
-            readonly args: import("../being/schema.ts").Schema<{
-                entry: never;
-                installed?: string | undefined;
-                name: string;
-            }>;
-            readonly result: Readonly<{}>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-        readonly lower: {
-            readonly args: import("../being/schema.ts").Schema<{
-                name: string;
-                why?: string | undefined;
-            }>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-        readonly open: {
-            readonly args: import("../being/schema.ts").Schema<{
-                bound?: number | undefined;
-                entry: never;
-                name: string;
-                seed: string;
-            }>;
-            readonly result: import("../being/schema.ts").Schema<{
-                ward?: string | undefined;
-                why?: string | undefined;
-            }>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-        readonly close: {
-            readonly args: import("../being/schema.ts").Schema<{
-                name: string;
-                why?: string | undefined;
-            }>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-        readonly sleep: {
-            readonly args: import("../being/schema.ts").Schema<{
-                entry: never;
-                name: string;
-                ward: string;
-            }>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-        };
-        readonly catalog: {
-            readonly result: Readonly<{}>;
-            readonly hints: {
-                readonly readOnly: true;
-            };
-        };
-        readonly call: {
-            readonly args: import("../being/schema.ts").Schema<{
-                args?: undefined;
-                faculty: string;
-                method: string;
-            }>;
-            readonly result: Readonly<{}>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-        readonly placesOut: {
-            readonly args: import("../being/schema.ts").Schema<{
-                entry: never;
-                name: string;
-            }>;
-            readonly result: Readonly<{}>;
-            readonly hints: {
-                readonly readOnly: true;
-            };
-            readonly wait: 300000;
-        };
-        readonly placesIn: {
-            readonly args: import("../being/schema.ts").Schema<{
-                entry: never;
-                name: string;
-                places: never;
-            }>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-    }>;
-}, {
-    readonly born: {
-        readonly for: "steward";
-        readonly args: import("../being/schema.ts").Schema<{
-            entry?: undefined;
-            installed?: string | undefined;
-            port?: number | undefined;
-            serves?: string | undefined;
-            terrain: boolean;
-            why?: string | undefined;
-        }>;
-    };
-    readonly shown: {
-        readonly for: readonly ['steward', 'root'];
-        readonly result: Readonly<{}>;
-        readonly hints: {
-            readonly readOnly: true;
-            readonly idempotent: true;
-        };
-    };
-    readonly up: {
-        readonly for: 'steward';
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-        readonly result: import("../being/schema.ts").Schema<{
-            why?: string | undefined;
-        }>;
-        readonly description: "Raises her body on her entry, installing where it moved.";
-    };
-    readonly stand: {
-        readonly for: "steward";
-        readonly result: import("../being/schema.ts").Schema<{
-            installed?: string | undefined;
-            port?: number | undefined;
-            serves?: string | undefined;
-            why?: string | undefined;
-        }>;
-        readonly hints: {
-            readonly readOnly: true;
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-        readonly description: "Raises her body on her entry and answers what came of it, writing nothing: a boot writes only what moved.";
-    };
-    readonly record: {
-        readonly for: 'steward';
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-        readonly args: import("../being/schema.ts").Schema<{
-            installed?: string | undefined;
-            port?: number | undefined;
-            serves?: string | undefined;
-            why?: string | undefined;
-        }>;
-        readonly description: "Keeps what came of raising her body.";
-    };
-    readonly down: {
-        readonly for: 'steward';
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-        readonly args: import("../being/schema.ts").Schema<{
-            why: string;
-        }>;
-        readonly description: "Takes her body down, and says why.";
-    };
-    readonly update: {
-        readonly for: 'steward';
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-        readonly args: import("../being/schema.ts").Schema<{
-            entry: never;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            why?: string | undefined;
-        }>;
-        readonly description: "Lands a new entry over hers, and raises her body on it.";
-    };
-    readonly restart: {
-        readonly for: 'steward';
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-        readonly result: import("../being/schema.ts").Schema<{
-            why?: string | undefined;
-        }>;
-        readonly description: "Takes her body down and up again.";
-    };
-    readonly remove: {
-        readonly for: 'steward';
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-        readonly description: "Takes her body down and drops the owner’s entry.";
-    };
-    readonly release: {
-        readonly for: 'steward';
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-        readonly args: import("../being/schema.ts").Schema<{
-            id: string;
-        }>;
-        readonly description: "Lets go of a being whose entry leaves her out.";
-    };
-}>;
-/**
- * A faculty's twin: her cells hold the owner's entry, or mark the
- * terrain's, what her body installed, and whether it stands or is down
- * with why. Going up and down is her state machine, and each change the
- * steward asks of her lands in her own write.
- */
-export declare class DockFaculty extends DockFaculty_base {
-    #private;
-    born({ terrain, entry, ...raised }: Args<DockFaculty, 'born'>): void;
-    stand(): Promise<Raised>;
-    record(raised: Args<DockFaculty, 'record'>): void;
-    shown(): never;
-    up(): Promise<{
-        why?: string;
-    }>;
-    down({ why }: Args<DockFaculty, 'down'>): Promise<void>;
-    update({ entry }: Args<DockFaculty, 'update'>): Promise<{
-        why?: string;
-    }>;
-    restart(): Promise<{
-        why?: string;
-    }>;
-    remove(): Promise<void>;
-    release({ id }: Args<DockFaculty, 'release'>): void;
-}
-declare const DockHouse_base: import("../being/being.ts").BeingClass<{
-    entry: Record<string, Json> | null;
-    seed: string;
-    ward: string | null;
-    why: string | null;
-}, {
-    readonly ground: import("../being/need.ts").Need<{
-        readonly terrain: {
-            readonly result: Readonly<{}>;
-            readonly hints: {
-                readonly readOnly: true;
-            };
-        };
-        readonly check: {
-            readonly args: import("../being/schema.ts").Schema<{
-                entry: never;
-                name: string;
-            }>;
-            readonly result: import("../being/schema.ts").Schema<{
-                why?: string | undefined;
-            }>;
-            readonly hints: {
-                readonly readOnly: true;
-            };
-        };
-        readonly raise: {
-            readonly args: import("../being/schema.ts").Schema<{
-                entry: never;
-                installed?: string | undefined;
-                name: string;
-            }>;
-            readonly result: Readonly<{}>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-        readonly lower: {
-            readonly args: import("../being/schema.ts").Schema<{
-                name: string;
-                why?: string | undefined;
-            }>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-        readonly open: {
-            readonly args: import("../being/schema.ts").Schema<{
-                bound?: number | undefined;
-                entry: never;
-                name: string;
-                seed: string;
-            }>;
-            readonly result: import("../being/schema.ts").Schema<{
-                ward?: string | undefined;
-                why?: string | undefined;
-            }>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-        readonly close: {
-            readonly args: import("../being/schema.ts").Schema<{
-                name: string;
-                why?: string | undefined;
-            }>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-        readonly sleep: {
-            readonly args: import("../being/schema.ts").Schema<{
-                entry: never;
-                name: string;
-                ward: string;
-            }>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-        };
-        readonly catalog: {
-            readonly result: Readonly<{}>;
-            readonly hints: {
-                readonly readOnly: true;
-            };
-        };
-        readonly call: {
-            readonly args: import("../being/schema.ts").Schema<{
-                args?: undefined;
-                faculty: string;
-                method: string;
-            }>;
-            readonly result: Readonly<{}>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-        readonly placesOut: {
-            readonly args: import("../being/schema.ts").Schema<{
-                entry: never;
-                name: string;
-            }>;
-            readonly result: Readonly<{}>;
-            readonly hints: {
-                readonly readOnly: true;
-            };
-            readonly wait: 300000;
-        };
-        readonly placesIn: {
-            readonly args: import("../being/schema.ts").Schema<{
-                entry: never;
-                name: string;
-                places: never;
-            }>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-    }>;
-}, {
-    readonly born: {
-        readonly for: "steward";
-        readonly args: import("../being/schema.ts").Schema<{
-            entry: never;
-            seed: string;
-            ward?: string | undefined;
-            why?: string | undefined;
-        }>;
-    };
-    readonly shown: {
-        readonly for: readonly ['steward', 'root'];
-        readonly result: Readonly<{}>;
-        readonly hints: {
-            readonly readOnly: true;
-            readonly idempotent: true;
-        };
-    };
-    readonly open: {
-        readonly for: readonly ["steward", "root"];
-        readonly description: "Opens the house on her entry where it is not open on it, and answers its ward or why it stays closed.";
-        readonly args: import("../being/schema.ts").Schema<{
-            bound?: number | undefined;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            ward?: string | undefined;
-            why?: string | undefined;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly opening: {
-        readonly for: "steward";
-        readonly description: "Opens the house as `open` does and answers what came of it, writing nothing: a boot writes only what moved.";
-        readonly args: import("../being/schema.ts").Schema<{
-            bound?: number | undefined;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            ward?: string | undefined;
-            why?: string | undefined;
-        }>;
-        readonly hints: {
-            readonly readOnly: true;
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-    readonly record: {
-        readonly for: 'steward';
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-        readonly args: import("../being/schema.ts").Schema<{
-            ward?: string | undefined;
-            why?: string | undefined;
-        }>;
-        readonly description: "Keeps what came of opening the house.";
-    };
-    readonly close: {
-        readonly for: 'steward';
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-        readonly args: import("../being/schema.ts").Schema<{
-            why: string;
-        }>;
-        readonly description: "Closes the house, and says why.";
-    };
-    readonly update: {
-        readonly for: 'steward';
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-        readonly args: import("../being/schema.ts").Schema<{
-            bound?: number | undefined;
-            entry: never;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            ward?: string | undefined;
-            why?: string | undefined;
-        }>;
-        readonly description: "Lands a new entry over hers, and opens the house on it.";
-    };
-    readonly remove: {
-        readonly for: 'steward';
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-        readonly description: "Closes the house and drops her entry; her seed stays.";
-    };
-}>;
-/**
- * A house's being: her cells hold its entry, its seed and its ward, and
- * whether it stands open or closed with why. The seed stays with her once
- * the entry is dropped, so the house added again is the same ward.
- */
-export declare class DockHouse extends DockHouse_base {
-    #private;
-    born({ entry, seed, ward, why }: Args<DockHouse, 'born'>): void;
-    shown(): never;
-    open({ bound }: Args<DockHouse, 'open'>): Promise<Stood>;
-    opening({ bound }: Args<DockHouse, 'opening'>): Promise<Stood>;
-    record({ ward, why }: Args<DockHouse, 'record'>): void;
-    close({ why }: Args<DockHouse, 'close'>): Promise<void>;
-    update({ entry, bound }: Args<DockHouse, 'update'>): Promise<Stood>;
-    remove(): Promise<void>;
-}
-declare const DockSecret_base: import("../being/being.ts").BeingClass<{
-    value: string;
-}, Record<never, never>, {
-    readonly born: {
-        readonly for: "steward";
-        readonly args: import("../being/schema.ts").Schema<{
-            value: string;
-        }>;
-    };
-    readonly set: {
-        readonly for: "steward";
-        readonly args: import("../being/schema.ts").Schema<{
-            value: string;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-    };
-    readonly release: {
-        readonly for: 'steward';
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-        readonly args: import("../being/schema.ts").Schema<{
-            id: string;
-        }>;
-    };
-}>;
-/**
- * A secret: her one cell holds its value. Her asks answer nothing, and the
- * hand never reads her cells, so only the bodies whose twins stand on her
- * receive it, when they go up.
- */
-export declare class DockSecret extends DockSecret_base {
-    born({ value }: Args<DockSecret, 'born'>): void;
-    set({ value }: Args<DockSecret, 'set'>): void;
-    release({ id }: Args<DockSecret, 'release'>): void;
-}
-declare const DockShell_base: import("../being/being.ts").BeingClass<Record<string, never>, {
-    readonly shell: import("../being/need.ts").Need<{
-        readonly run: {
-            readonly args: import("../being/schema.ts").Schema<{
-                args?: string[] | undefined;
-                command: string;
-                cwd?: string | undefined;
-                stdin?: string | undefined;
-            }>;
-            readonly result: import("../being/schema.ts").Schema<{
-                code: number;
-                stderr: string;
-                stdout: string;
-            }>;
-            readonly hints: {
-                readonly idempotent: true;
-            };
-            readonly wait: 300000;
-        };
-    }>;
-}, {
-    readonly run: {
-        readonly for: "steward";
-        readonly args: import("../being/schema.ts").Schema<{
-            args?: string[] | undefined;
-            command: string;
-            cwd?: string | undefined;
-            stdin?: string | undefined;
-        }>;
-        readonly result: import("../being/schema.ts").Schema<{
-            code: number;
-            stderr: string;
-            stdout: string;
-        }>;
-        readonly hints: {
-            readonly idempotent: true;
-        };
-        readonly wait: 300000;
-    };
-}>;
-/**
- * The being that holds the shell: the terrain's `shell` body, offered to
- * her kind alone as any body is offered to a house, where the dock's
- * steward stands on its twin. The steward's `shellRun` asks her.
- */
-export declare class DockShell extends DockShell_base {
-    run(args: Args<DockShell, 'run'>): Promise<{
-        code: number;
-        stderr: string;
-        stdout: string;
-    }>;
-}
-/** The dock's classes: the library's, the same on every ground. */
-export declare const dockClasses: () => ClassList;
-export {};