nervur 0.19.2 → 0.20.0

package/dist/ward/ward-being.js

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: Apache-2.0
+// The ward-being: the first being of every ward, the ward itself. Her asks
+// are the root's, shown and answered to `OWNER` alone.
+import { Being, isSilence, isWord, OWNER, told } from '../being/index.js';
+// Whoever pilots a ward: the root, holding its unsealed ask, or an owner,
+// an occupant of the ward-being the root invited as one.
+export const pilots = (asker, notes) => asker.id === OWNER || notes?.owner === true;
+// An ask whoever pilots the ward may make.
+export const ownerAsk = (description, input = {}) => ({ description, input: { type: 'object', ...input }, for: pilots });
+// An ask the root alone may make, so a carried key pilots but never hands
+// piloting on.
+const rootAsk = (description, input = {}) => ({ description, input: { type: 'object', ...input }, for: (asker) => asker.id === OWNER });
+const text = (v) => typeof v === 'string';
+const object = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+export class WardBeing extends Being {
+    static asks = {
+        boot: ownerAsk('a new being of this ward', { required: ['key', 'class'] }),
+        unboot: ownerAsk('a being out, with every relation she holds', { required: ['being'] }),
+        public: ownerAsk('the being a stranger reaches, or none', { required: ['key'] }),
+        invite: ownerAsk('an invitation on a being of this ward', { required: ['being', 'id'] }),
+        ask: ownerAsk('a being of this ward, asked as the owner; with no being, the public being asked as nobody'),
+        own: rootAsk('an invitation for an owner of this ward, under an id', { required: ['id'] }),
+        disown: rootAsk('an owner no more', { required: ['id'] }),
+    };
+    steward;
+    constructor(stance) {
+        super(stance);
+        this.steward = stance.steward;
+    }
+    describe(asker) {
+        const { asks } = super.describe(asker);
+        return { asks, notes: pilots(asker, this.notes(asker)) ? { pk: this.steward.pk(), beings: this.steward.beings() } : {} };
+    }
+    async own(args) {
+        if (!text(args.id))
+            return { error: 'id is text' };
+        return (await this.stance.occupants.invite(args.id, { owner: true })) ?? { error: 'id taken' };
+    }
+    disown(args) {
+        if (!text(args.id) || this.stance.occupants.notes(args.id)?.owner !== true)
+            return { error: 'no such owner' };
+        this.stance.occupants.remove(args.id);
+        return { disowned: args.id };
+    }
+    async boot(args) {
+        if (!text(args.key) || !text(args.class))
+            return { error: 'key and class are text' };
+        const out = await this.steward.boot(args.key, args.class);
+        return out === 'booted' ? { booted: args.key } : { error: out };
+    }
+    unboot(args) {
+        return text(args.being) && this.steward.unboot(args.being) ? { unbooted: args.being } : { error: 'no such being' };
+    }
+    public(args) {
+        if (args.key !== null && !text(args.key))
+            return { error: 'key is text or null' };
+        return this.steward.publish(args.key) ? { public: args.key } : { error: 'no such being' };
+    }
+    async invite(args) {
+        if (!text(args.being) || !text(args.id) || (args.notes !== undefined && !object(args.notes)))
+            return { error: 'being and id are text, notes an object' };
+        const invitation = await this.steward.invite(args.being, args.id, args.notes ?? {});
+        return invitation ?? { error: 'not invited' };
+    }
+    async ask(args) {
+        if ((args.being !== undefined && !text(args.being)) || (args.method !== undefined && !text(args.method)) || (args.args !== undefined && !object(args.args))) {
+            return { error: 'being and method are text, args an object' };
+        }
+        const out = await this.steward.ask(args.being ?? null, args.method, args.args ?? {});
+        if (isSilence(out))
+            return { error: 'silence' };
+        if (isWord(out))
+            return { error: told(out) };
+        return { answer: out };
+    }
+}

package/dist/ward/ward.d.ts

@@ -1,12 +1,44 @@
-import type { Cells, Stance } from '../being/types.ts';
-import { type Ground, type WardPointers } from './ground.ts';
-import { type Bind } from './partition.ts';
-import { type Door } from './door.ts';
-export type Resident = Door & {
-    bind: Bind;
-    stance: Stance;
-    cells: Cells & {
-        class?: string;
-    };
+import { Door, WardKey, type Behind, type Choice, type Invitation, type Payload } from '../quo/index.ts';
+import type { Carrier, Clock, Entropy, Rows } from '../contract/index.ts';
+import { type Answer, type BeingClass, type JsonObject } from '../being/index.ts';
+import { Partition, type BeingRow } from './partition.ts';
+import { type Inside } from './stance.ts';
+import { WardBeing, type WardBeingStance } from './ward-being.ts';
+export interface Catalogue {
+    classOf(name: string): BeingClass | undefined;
+}
+export type WardParts = {
+    readonly seed: Uint8Array | string;
+    readonly memory: Rows;
+    readonly catalogue: Catalogue;
+    readonly entropy: Entropy;
+    readonly clock: Clock;
+    readonly carrier: Carrier;
+    readonly root?: (stance: WardBeingStance) => WardBeing;
+    readonly dock?: Invitation;
 };
-export declare function Ward(ground: Ground): Promise<WardPointers>;
+export declare const DOCK = "dock";
+export interface Lender {
+    offer(contract: string): Promise<Invitation | null>;
+    withdraw(contract: string, heir: string): Promise<void>;
+}
+export declare class Ward implements Behind, Inside {
+    #private;
+    readonly key: WardKey;
+    readonly partition: Partition;
+    readonly door: Door;
+    readonly clock: Clock;
+    private constructor();
+    static unpack(parts: WardParts): Promise<Ward>;
+    get pk(): string;
+    get draw(): import("../quo/keys.ts").Draw;
+    get wardBeing(): WardBeing;
+    root(method?: string, args?: JsonObject): Promise<Answer>;
+    get zero(): boolean;
+    answer(heir: string | null, p: Payload): Promise<Choice>;
+    send(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
+    offer(contract: string): Promise<Invitation | null>;
+    retract(contract: string, heir: string): Promise<void>;
+    live(key: string, row: BeingRow): boolean;
+    boot(maker: string, className: string, key: string, id?: string): Promise<string | null>;
+}