nervur 0.23.0 → 0.24.0

package/dist/ground/ground.d.ts

@@ -1,239 +0,0 @@
-import type { Json } from '../being/being.ts';
-import { type Schema } from '../being/schema.ts';
-import type { Handler } from '../bodies/web-carry.ts';
-import type { Carry, Memory } from '../foundation.ts';
-import { type Answer, type OpenedContext } from '../house/house.ts';
-/** A door, as a carry hooks it. */
-export type Door = (box: Uint8Array) => Promise<Uint8Array | null>;
-/** The ground's one key, kept outside it by its host. */
-export interface Unlock {
-    /** Sixty-four lowercase hex digits: drawn and kept where none is kept yet. */
-    key(): Promise<string>;
-}
-/** A carry the ground hooks doors to, and unhooks them from. */
-export interface Hooked extends Carry {
-    listen(options: {
-        ward: string;
-        door: Door;
-    }): void | Promise<void>;
-    unlisten(options: {
-        ward: string;
-    }): void;
-}
-/**
- * The contract a body fills: the primordial, the unlock, the memory,
- * crypto, tools, the ground's work and the hand, then what every house
- * receives.
- */
-export type Serves = 'unlock' | 'memory' | 'crypto' | 'tools' | 'ground' | 'hand' | 'carry' | 'clock' | 'classes';
-/** What a faculty's `up` and `install` receive: its name, its args, its secrets, its sealed memory, and the bodies it calls. */
-export interface Up {
-    readonly name: string;
-    readonly args: Readonly<Record<string, Json>>;
-    readonly secrets: Readonly<Record<string, string>>;
-    readonly memory: Memory;
-    /** The object of each body its entry names in `faculties`. */
-    readonly faculties: Readonly<Record<string, object>>;
-}
-/** What one house receives of a foundation body: the house's name, and the args its entry holds. */
-export interface ForHouse {
-    readonly house: string;
-    readonly args: Readonly<Record<string, Json>>;
-}
-/**
- * A faculty stood: the living instance houses and bodies use. Each part
- * where it has one: an offer to beings, a handler for the listener, a
- * registry for the rungs above it, the contract it serves, and what it
- * lets go of when it goes down.
- */
-export interface Body {
-    readonly blueprint?: unknown;
-    readonly object?: object;
-    /** How long the body remembers a call id, in milliseconds. */
-    readonly window?: number;
-    readonly handler?: Handler;
-    readonly registry?: Registry;
-    readonly serves?: Serves;
-    /** The schemes of the addresses a carry body speaks. */
-    readonly schemes?: readonly string[];
-    /** The port its listener holds once it is up, which its twin keeps as a cell. */
-    readonly port?: number;
-    /** What one house receives of a body serving `memory` or `classes`. */
-    house?(options: ForHouse): unknown;
-    /** Told when a house it is offered to opens, with the context that calls its tokens there. */
-    opened?(context: OpenedContext): void | Promise<void>;
-    down?(): void | Promise<void>;
-}
-/**
- * What a faculty takes: the args of its entry, held to a schema in the
- * house's subset, and each secret its entry must name, by name with what
- * it holds. An entry that fails it is refused at the hand and stays down
- * at the boot.
- */
-export interface Takes {
-    readonly args?: Schema;
-    readonly secrets?: Readonly<Record<string, string>>;
-}
-/** Code a registry holds by name: what it takes, `up` raising it into a body, and `install` doing the slow work once for each entry. */
-export interface Faculty {
-    readonly takes?: Takes;
-    install?(made: Up): void | Promise<void>;
-    up(made: Up): Body | Promise<Body>;
-}
-/** Code that holds faculties by name. */
-export interface Registry {
-    readonly faculties?: Readonly<Record<string, Faculty>>;
-}
-/**
- * Registries joined as one rung, the first first. A name one holds is
- * refused to the next, never replaced. No entry exports it; every shipped
- * ground joins its first rung with it.
- */
-export declare const joinedRegistry: (...registries: readonly Registry[]) => Registry;
-/** One foundation body a house names: the faculty that serves it, and the args it hands this house. */
-export interface BodyNamed {
-    readonly faculty: string;
-    readonly [argument: string]: Json | undefined;
-}
-/** One house's entry: its code, its memory where it takes one, its faculties, and its bound on every ask. */
-export interface Entry {
-    readonly classes: BodyNamed;
-    readonly memory?: BodyNamed;
-    readonly faculties?: readonly string[];
-    readonly wait?: number;
-}
-/** One faculty's entry: where it stands, what it is handed, the bodies it calls, and its grant. */
-export interface FacultyEntry {
-    readonly make?: string;
-    readonly from?: string;
-    readonly args?: Readonly<Record<string, Json>>;
-    readonly secrets?: readonly string[];
-    readonly faculties?: readonly string[];
-    readonly kinds?: readonly string[];
-}
-/** A house as the ground holds it: open with its ward, or closed and why. */
-export interface Standing {
-    readonly name: string;
-    readonly entry: Entry;
-    readonly ward?: string;
-    readonly why?: string;
-}
-/**
- * What the ground's hand takes, as every terrain serves it: `describe`, or
- * an ask as `root` of a being, in the house it names or in the dock where
- * it names none. With no id, the house's steward is asked.
- */
-export interface HandAsk {
-    readonly describe?: true;
-    readonly house?: string;
-    readonly id?: string;
-    readonly method?: string;
-    readonly args?: Json;
-    /** The answer the owner holds, which makes a `readOnly` ask a watch. */
-    readonly after?: Answer;
-    /** Her cells read, and nothing asked. */
-    readonly cells?: true;
-    /** The call's id: the same id asked again answers what the first answered, and runs nothing twice. */
-    readonly call?: string;
-}
-/** What the ground's hand shows its owner: the dock's asks, every body of the ladder, and every house. */
-export interface Described {
-    readonly dock: Json;
-    readonly faculties: Readonly<Record<string, Json>>;
-    readonly houses: readonly Standing[];
-}
-/** The entries the host names, raised on the terrain's args around the dock: the memory, the unlock, crypto, tools and the clock before it, and the hand after it. */
-export interface Primordial {
-    readonly unlock: FacultyEntry;
-    readonly memory: FacultyEntry;
-    readonly crypto: FacultyEntry;
-    readonly tools: FacultyEntry;
-    /** The ground's one clock, which the dock and every house receive. */
-    readonly clock: FacultyEntry;
-    /** Where the owner reaches the hand: a socket, a key, a channel. It names `ground` in its faculties. */
-    readonly hand?: FacultyEntry;
-}
-/** What `Ground.open` takes, all of it the host's. */
-export interface GroundOptions {
-    /** The ladder's first rung: the terrain's faculties, and whatever the host installs beside them. */
-    readonly registry: Registry;
-    readonly primordial: Primordial;
-    /** The terrain's default entries; an entry the owner lands under the same name stands in its place. */
-    readonly entries?: Readonly<Record<string, FacultyEntry>>;
-    /** The terrain's bound on every ask of every house, in milliseconds; the one the owner sets through the dock stands in its place. */
-    readonly wait?: number;
-    /**
-     * A ground woken per event opens a house only when something reaches it:
-     * a box for its ward, or the hand. A house whose ward it never learned
-     * opens at the boot. `wake()` opens every one. The dock opens at every
-     * boot all the same.
-     */
-    readonly lazy?: boolean;
-}
-export declare class Ground {
-    #private;
-    private constructor();
-    /**
-     * A ground opened on its host's registry and entries: the primordial
-     * bodies go up, the dock opens on them and stands the ladder and every
-     * house, and the hand goes up.
-     */
-    static open(options: GroundOptions): Promise<Ground>;
-    /** Every house that stands closed until reached, opened now, as a wake by alarm needs: each arms its own times again. */
-    wake(): Promise<void>;
-    /** Every house of the dock, open with its ward, or closed and why. The dock is none of them. */
-    list(): readonly Standing[];
-    /** A house added through the dock and opened, as the hand adds one. */
-    add(name: string, entry: Entry): Promise<Standing>;
-    /** A new entry landed over a house's through the dock, and the house opened again on it. */
-    update(name: string, entry: Entry): Promise<Standing>;
-    /** A house closed and its entry dropped through the dock. Its seed and its places stay. */
-    remove(name: string): Promise<void>;
-    /** A body raised through the dock on its entry, answering why it is down where it is. */
-    stand(name: string, entry: FacultyEntry): Promise<{
-        readonly why?: string;
-    }>;
-    /** A new entry landed over a faculty's through the dock. */
-    restand(name: string, entry: FacultyEntry): Promise<{
-        readonly why?: string;
-    }>;
-    /** A body taken down and up again through the dock. */
-    restart(name: string): Promise<{
-        readonly why?: string;
-    }>;
-    /** A body taken down and its entry dropped through the dock, where no house and no body uses it. */
-    unstand(name: string): Promise<void>;
-    /** A being in a house asked as `root`, by her id, or the house's steward where none is named. */
-    ask({ house, ...request }: Omit<HandAsk, 'describe' | 'house'> & {
-        readonly house: string;
-    }): Promise<Answer | {
-        readonly describe: Json;
-    }>;
-    /**
-     * The ground's hand, one request at a time, as every terrain serves it:
-     * `describe`, or an ask as `root` of a being in the house it names, or of
-     * a being of the dock where it names none. It is the one road into the
-     * ground: every change is an ask of the dock. A secret's cells are read
-     * by no one through it.
-     */
-    hand({ describe, house, ...request }: HandAsk): Promise<Answer | {
-        readonly describe: Json;
-    }>;
-    /**
-     * What the ground's hand shows its owner: the asks the dock's steward
-     * shows `root`, every body of the ladder with its methods, what it serves,
-     * or why it is down, each method's description, args, result and hints,
-     * and every house. A face reads it and needs no code of its own for any
-     * of them.
-     */
-    describe(): Promise<Described>;
-    /**
-     * The one handler the ground's listener chains: the hand's where it
-     * serves one, then each standing body's in the ladder's order, read as
-     * each request arrives, so a body raised while the ground runs is served
-     * at once.
-     */
-    readonly handler: Handler;
-    /** The hand down first, then every house closed through its views, the dock, every body in the reverse of the ladder, and the primordial last. */
-    close(): Promise<void>;
-}