nervur 0.22.0 → 0.22.2-3

package/dist/core/ward/house.d.ts

@@ -1,67 +0,0 @@
-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 BeingLike, type JsonObject } from '../being/index.ts';
-import { Partition, type BeingRow } from './partition.ts';
-import { type Inside } from './stance.ts';
-import { Ward } from './ward.ts';
-export interface Classes {
-    classOf(kind: string, registry?: string): BeingClass | undefined;
-}
-export type HouseParts = {
-    readonly seed: Uint8Array | string;
-    readonly memory: Rows;
-    readonly classes: Classes;
-    readonly entropy: Entropy;
-    readonly clock: Clock;
-    readonly carrier: Carrier;
-    readonly ward: WardClass;
-    readonly carries?: Readonly<Record<string, unknown>>;
-    readonly dock?: Invitation;
-    readonly routes?: Routes;
-    readonly stands?: boolean;
-};
-export interface Routes {
-    reach(): readonly string[];
-    learn(ward: string, at: readonly string[]): Promise<void>;
-}
-export type WardClass = {
-    readonly genesis: string;
-    readonly contract: string;
-    fits(C: BeingClass): boolean;
-    readonly fallback?: BeingClass;
-};
-export declare const DOCK = "dock";
-export interface Lender {
-    offer(contract: string): Promise<Invitation | null>;
-    withdraw(contract: string, heir: string): Promise<void>;
-}
-type Birth = 'booted' | 'key taken' | 'no such class' | 'threw at birth';
-export declare class House implements Behind, Inside {
-    #private;
-    readonly key: WardKey;
-    readonly partition: Partition;
-    readonly door: Door;
-    readonly clock: Clock;
-    private constructor();
-    static unpack(parts: HouseParts): Promise<House>;
-    standWard(): Promise<void>;
-    stand(key: string): 'booted' | 'stands' | 'no such being' | 'no such class' | 'threw at birth';
-    make(key: string, className: string): Promise<Birth>;
-    get pk(): string;
-    get draw(): import("../quo/keys.ts").Draw;
-    get ward(): Ward;
-    get fault(): string | null;
-    being(key: string): BeingLike | undefined;
-    renew(): void;
-    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>;
-    reach(): readonly string[];
-    learn(ward: string, at: readonly string[]): Promise<void>;
-    live(key: string, row: BeingRow): boolean;
-    boot(maker: string, className: string, key: string, id?: string): Promise<string | null>;
-}
-export {};

package/dist/core/ward/house.js

@@ -1,473 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The house: the plumbing behind Quo's door. It keeps Quo's ward, its seed
-// and keys, one door, one partition and its head, and the beings behind the
-// door. It unpacks from its seed, its memory and the classes it resolves
-// kinds through, and stands what is behind its door for `quo/`. It brings
-// no being to life on its own: whoever unpacks it stands its ward. In the
-// box ward the dock stands each faculty, and it stands from then on. In
-// every other ward a being is born from her row when an ask reaches her,
-// once for every ask in flight on her, and is dropped when the last one
-// ends: her cells, occupants and standings are her ward's rows, kept by
-// the ward's memory, so nothing of her lives between asks. No author sees
-// or extends it.
-import { readValue, writeValue } from '../crypto/index.js';
-import { Door, readInvitation, WardKey } from '../quo/index.js';
-import { digest, Faculty, isSilence, isWord, OWNER, ownKind, silence, WARD, word } from '../being/index.js';
-import { Partition, PartitionRelations } from './partition.js';
-import { DEPTH, HouseStance } from './stance.js';
-import { Ward } from './ward.js';
-// The standing every hosted ward holds on the dock.
-export const DOCK = 'dock';
-const lends = (being) => typeof being.offer === 'function';
-class RootStance extends HouseStance {
-    steward;
-    constructor(inside, row, steward, carries) {
-        super(inside, WARD, row, carries);
-        this.steward = steward;
-    }
-}
-export class House {
-    key;
-    partition;
-    door;
-    clock;
-    #parts;
-    #residents = new Map();
-    #visits = new Map();
-    #birthing = new Set();
-    #fault = null;
-    constructor(parts, key) {
-        this.#parts = parts;
-        this.key = key;
-        this.clock = parts.clock;
-        this.partition = new Partition(parts.memory);
-        this.door = new Door(key, new PartitionRelations(this.partition), this, parts.entropy.drawer);
-    }
-    // The house of a seed and its memory, its ward's row written with the
-    // genesis kind where the row is new. No being stands yet.
-    static async unpack(parts) {
-        const ward = new House(parts, await WardKey.from(parts.seed));
-        if (!ward.partition.being(WARD)) {
-            ward.partition.beings[WARD] = { class: ward.#class.genesis, cells: {}, occupants: {}, standings: {} };
-            ward.partition.told(WARD);
-            ward.partition.toldHead();
-        }
-        return ward;
-    }
-    // The ward, of the class her row's kind resolves. A ward class that does
-    // not resolve or fits no ward here stands the fallback, with why, or the
-    // ward does not stand and this throws. The ward stands once.
-    async standWard() {
-        if (this.#residents.has(WARD))
-            return;
-        const own = this.partition.being(WARD);
-        const stance = new RootStance(this, own, this.#steward, this.#parts.carries ?? {});
-        const found = this.#wardOf(own.class, own.registry);
-        let being;
-        if (typeof found === 'string')
-            this.#fault = found;
-        else {
-            try {
-                being = new found(stance);
-            }
-            catch (e) {
-                this.#fault = `${own.class} threw at birth: ${e instanceof Error ? e.message : String(e)}`;
-            }
-        }
-        if (!being) {
-            const { fallback } = this.#class;
-            if (!fallback)
-                throw new Error(this.#fault);
-            being = new fallback(stance);
-        }
-        this.#residents.set(WARD, { being, row: own, stance });
-        // The standing on the dock is kept at once: its heir is spent, so a
-        // restart before the ward's first keep would find no way back.
-        const { dock } = this.#parts;
-        if (dock && !Object.hasOwn(own.standings, DOCK) && (await stance.standings.take(DOCK, dock)) !== null && !(await this.partition.kept())) {
-            throw new Error('the standing on the dock was not kept');
-        }
-    }
-    // One being of a house whose beings stand, from her row, where she does
-    // not stand yet: a class nothing resolves, or one that throws, leaves her
-    // absent and her row as it stands. In any other house no being stands.
-    stand(key) {
-        if (this.#residents.has(key))
-            return 'stands';
-        const row = key === WARD || !this.#parts.stands ? undefined : this.partition.being(key);
-        if (!row)
-            return 'no such being';
-        const C = this.#classOf(row);
-        if (!C)
-            return 'no such class';
-        return this.#bear(key, row, C) ? 'booted' : 'threw at birth';
-    }
-    // A being of a kind the core ships, written and stood where her key holds
-    // none: how the harbor stands the catalogue on empty memory, before any
-    // ward being stands to boot her.
-    make(key, className) {
-        return this.#make(key, className);
-    }
-    #classOf(row) {
-        return this.#parts.classes.classOf(row.class, row.registry);
-    }
-    get pk() {
-        return this.key.pk;
-    }
-    get draw() {
-        return this.#parts.entropy.drawer;
-    }
-    get ward() {
-        return this.#residents.get(WARD).being;
-    }
-    // Why the ward stands the fallback and not her row's class, or null.
-    get fault() {
-        return this.#fault;
-    }
-    get #class() {
-        return this.#parts.ward;
-    }
-    // The class of a ward kind, or why none may be this house's ward.
-    #wardOf(kind, registry) {
-        const C = this.#parts.classes.classOf(kind, registry);
-        if (!C)
-            return `no class of kind ${kind} runs`;
-        return this.#class.fits(C) ? C : `${kind} is no ${this.#class.contract}`;
-    }
-    // The ward born again of her row's class where it resolves now and is
-    // not the class she stands as, on the stance she holds.
-    #wardAnew() {
-        const resident = this.#residents.get(WARD);
-        if (!resident)
-            return;
-        const found = this.#wardOf(resident.row.class, resident.row.registry);
-        if (typeof found === 'string') {
-            if (ownKind(resident.being.constructor) !== resident.row.class)
-                this.#fault = found;
-            return;
-        }
-        if (resident.being.constructor === found)
-            return;
-        try {
-            resident.being = new found(resident.stance);
-            this.#fault = null;
-        }
-        catch (e) {
-            this.#fault = `${resident.row.class} threw at birth: ${e instanceof Error ? e.message : String(e)}`;
-        }
-    }
-    // The being standing under a key, for the harbor's own faculties.
-    being(key) {
-        return this.#residents.get(key)?.being;
-    }
-    // Every standing being whose kind now resolves to another class, born
-    // again of it on the stance she holds, so her relations and their lanes
-    // stay hers. A new class that throws at birth leaves her as she was. The
-    // ward is one of them. A being born for an ask needs none of this: the
-    // next ask that reaches her is born of the class that runs then.
-    renew() {
-        this.#wardAnew();
-        for (const [key, resident] of this.#residents) {
-            if (key === WARD)
-                continue;
-            const C = this.#classOf(resident.row);
-            if (!C || resident.being.constructor === C)
-                continue;
-            try {
-                resident.being = new C(resident.stance);
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    // The unsealed ask: the ward, asked by whoever holds this house.
-    // It reaches every being of the house through the ward, so every
-    // row is put back where the memory refuses.
-    async root(method, args = {}) {
-        return this.#kept(Object.keys(this.partition.beings), () => this.#answer(WARD, { id: OWNER }, method, args));
-    }
-    // An answer, kept. Where the memory refuses, what the beings wrote is put
-    // back and the answer is silence. What their relations stand on is not
-    // put back: a relation's keys move only as far as its standing follows.
-    async #kept(keys, work) {
-        const before = keys.flatMap((key) => {
-            const row = this.partition.being(key);
-            return row ? [[key, row.cells, JSON.stringify(row.cells)]] : [];
-        });
-        const out = await work();
-        if (await this.partition.kept())
-            return out;
-        for (const [key, cells, was] of before) {
-            if (JSON.stringify(cells) === was)
-                continue;
-            for (const k of Object.keys(cells))
-                delete cells[k];
-            for (const [k, v] of Object.entries(JSON.parse(was)))
-                Object.defineProperty(cells, k, { value: v, enumerable: true, writable: true, configurable: true });
-            this.partition.told(key);
-        }
-        return silence;
-    }
-    // Behind: the zero head reaches the public being, an heir the being that
-    // invited it.
-    get zero() {
-        const key = this.partition.head.public;
-        return key !== null && this.#reachable(key);
-    }
-    // Whether an ask reaches the being under a key: she stands, or she is
-    // born for it, her class resolving.
-    #reachable(key) {
-        if (this.#residents.has(key))
-            return true;
-        const row = key === WARD || this.#parts.stands ? undefined : this.partition.being(key);
-        return row !== undefined && this.#classOf(row) !== undefined;
-    }
-    async answer(heir, p) {
-        const bound = heir === null ? undefined : this.partition.head.bind[heir];
-        const key = heir === null ? this.partition.head.public : bound?.being;
-        const asker = bound ? { id: bound.id } : {};
-        const args = p.args === undefined ? {} : readValue(p.args, DEPTH + 1);
-        if (key === null || key === undefined || typeof args !== 'object' || args === null || Array.isArray(args))
-            return { silence: true };
-        let seen = null;
-        const out = await this.#kept([key], () => this.#with(key, silence, async (being) => {
-            const reply = await this.#reply(being, asker, p.method, args);
-            if (p.method !== undefined && !isSilence(reply) && !isWord(reply) && being.describe)
-                seen = await digest(being.describe(asker));
-            return reply;
-        }));
-        const object = isSilence(out) || isWord(out) ? undefined : writeValue(out, DEPTH);
-        return object === undefined ? { silence: true } : { object, seen };
-    }
-    // Every path that reaches a being's answer. A throw, a word out of her,
-    // or nothing at all is silence.
-    #answer(key, asker, method, args) {
-        return this.#with(key, silence, (being) => this.#reply(being, asker, method, args));
-    }
-    async #reply(being, asker, method, args) {
-        let out;
-        try {
-            out = await being.answer(asker, method, args);
-        }
-        catch {
-            return silence;
-        }
-        return out === undefined || isWord(out) ? silence : out;
-    }
-    // The being under a key for the length of `work`: the one that stands,
-    // or, in a house whose beings do not stand, one born from her row for
-    // it, the same one for every ask in flight on her, so her relations keep
-    // one lane each, dropped when the last ends. A being nothing resolves, or
-    // one that throws at birth, is none.
-    async #with(key, none, work) {
-        const standing = this.#residents.get(key);
-        if (standing)
-            return work(standing.being);
-        const visit = this.#visit(key);
-        if (!visit)
-            return none;
-        try {
-            return await work(visit.being);
-        }
-        finally {
-            visit.asks -= 1;
-            if (visit.asks === 0 && this.#visits.get(key) === visit)
-                this.#visits.delete(key);
-        }
-    }
-    #visit(key) {
-        const held = this.#visits.get(key);
-        if (held) {
-            held.asks += 1;
-            return held;
-        }
-        const row = key === WARD || this.#parts.stands ? undefined : this.partition.being(key);
-        const C = row && this.#classOf(row);
-        if (!row || !C)
-            return undefined;
-        const stance = new HouseStance(this, key, row, this.#parts.carries ?? {});
-        try {
-            const visit = { being: new C(stance), row, stance, asks: 1 };
-            this.#visits.set(key, visit);
-            return visit;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    // The stance a being of this house acts on: hers where she stands or is
-    // in flight, else one made on her row for what her ward does with it.
-    #stanceOf(key) {
-        const held = this.#residents.get(key) ?? this.#visits.get(key);
-        if (held)
-            return held.stance;
-        const row = key === WARD ? undefined : this.partition.being(key);
-        return row ? new HouseStance(this, key, row, this.#parts.carries ?? {}) : undefined;
-    }
-    // Inside: what every stance of this ward stands on.
-    // One path through a door for every ask, this ward's own included.
-    async send(pk, bytes) {
-        if (pk === this.pk)
-            return (await this.door.arrive(bytes)).bytes;
-        return this.#parts.carrier.carry(pk, bytes);
-    }
-    // A lend: the ward lends herself, as the dock does, or asks the dock
-    // through her standing.
-    async offer(contract) {
-        const own = this.#residents.get(WARD);
-        if (lends(own.being))
-            return own.being.offer(contract);
-        const out = await own.stance.standings.get(DOCK)?.ask('lend', { contract });
-        return readInvitation(out?.invitation);
-    }
-    async retract(contract, heir) {
-        const own = this.#residents.get(WARD);
-        if (lends(own.being))
-            return own.being.withdraw(contract, heir);
-        await own.stance.standings.get(DOCK)?.ask('retract', { contract, heir });
-    }
-    reach() {
-        return this.#parts.routes?.reach() ?? [];
-    }
-    learn(ward, at) {
-        return this.#parts.routes?.learn(ward, at) ?? Promise.resolve();
-    }
-    // A stance speaks for a being while her row is the one her ward keeps.
-    live(key, row) {
-        return this.partition.being(key) === row;
-    }
-    // A being boots another of this ward. With an id, the new being invites
-    // her maker under the maker's key, and the maker takes it under id; a
-    // relation that could not be made unmakes the new being.
-    async boot(maker, className, key, id) {
-        if ((await this.#make(key, className)) !== 'booted')
-            return null;
-        if (id === undefined)
-            return key;
-        const invitation = await this.#stanceOf(key).occupants.invite(maker);
-        const taken = invitation ? await this.#stanceOf(maker)?.standings.take(id, invitation) : null;
-        if (taken)
-            return key;
-        this.#unboot(key);
-        return null;
-    }
-    // A new row and her first birth, which writes her cells' defaults: she
-    // stands from then on in a house whose beings stand, and is dropped at
-    // once in any other, to be born again for the asks that reach her.
-    async #make(key, className, registry) {
-        if (key === '' || key === WARD || this.partition.being(key) || this.#birthing.has(key))
-            return 'key taken';
-        // A house whose beings stand, the box, holds faculties alone, and every
-        // other house holds beings that are no faculty. A ward is no being of
-        // any house.
-        const C = this.#parts.classes.classOf(className, registry);
-        if (!C || Ward.fulfils(C) || Faculty.fulfils(C) !== (this.#parts.stands === true))
-            return 'no such class';
-        this.#birthing.add(key);
-        try {
-            const row = { class: className, ...(registry === undefined ? {} : { registry }), cells: {}, occupants: {}, standings: {} };
-            this.partition.beings[key] = row;
-            if (!(this.#parts.stands ? this.#bear(key, row, C) : this.#born(key, row, C) !== undefined)) {
-                delete this.partition.beings[key];
-                return 'threw at birth';
-            }
-            this.partition.told(key);
-            return 'booted';
-        }
-        finally {
-            this.#birthing.delete(key);
-        }
-    }
-    #born(key, row, C) {
-        try {
-            return new C(new HouseStance(this, key, row, this.#parts.carries ?? {}));
-        }
-        catch {
-            return undefined;
-        }
-    }
-    #bear(key, row, C) {
-        const stance = new HouseStance(this, key, row, this.#parts.carries ?? {});
-        try {
-            this.#residents.set(key, { being: new C(stance), row, stance });
-            return true;
-        }
-        catch {
-            this.#residents.delete(key);
-            return false;
-        }
-    }
-    #unboot(key) {
-        const row = key === WARD ? undefined : this.partition.being(key);
-        if (!row)
-            return false;
-        for (const { heir } of Object.values(row.occupants)) {
-            this.door.remove(heir);
-            delete this.partition.head.bind[heir];
-        }
-        if (this.partition.head.public === key)
-            this.partition.head.public = null;
-        delete this.partition.beings[key];
-        this.#residents.delete(key);
-        this.partition.toldHead();
-        this.partition.told(key);
-        return true;
-    }
-    // What the ward asks of her house.
-    #steward = {
-        pk: () => this.pk,
-        classOf: (name, registry) => this.#parts.classes.classOf(name, registry),
-        beings: () => {
-            const out = {};
-            // A being is absent where no ask would reach her: in a house whose
-            // beings stand, one that does not stand; in any other, one whose
-            // class does not resolve.
-            for (const [key, row] of Object.entries(this.partition.beings)) {
-                if (key !== WARD)
-                    out[key] = { class: row.class, ...(row.registry === undefined ? {} : { registry: row.registry }), public: this.partition.head.public === key, absent: !this.#reachable(key) };
-            }
-            return out;
-        },
-        boot: (key, className, registry) => this.#make(key, className, registry),
-        stand: (key) => this.stand(key),
-        unboot: (key) => this.#unboot(key),
-        publish: (key) => {
-            if (key !== null && (key === WARD || !this.partition.being(key)))
-                return false;
-            this.partition.head.public = key;
-            this.partition.toldHead();
-            return true;
-        },
-        invite: (being, id, notes) => {
-            const stance = being === WARD || !this.#reachable(being) ? undefined : this.#stanceOf(being);
-            return stance ? stance.occupants.invite(id, notes) : Promise.resolve(null);
-        },
-        ask: (being, method, args) => {
-            const key = being ?? this.partition.head.public;
-            if (key === null || key === WARD)
-                return Promise.resolve(word('unreached'));
-            return this.#answer(key, being === null ? {} : { id: OWNER }, method, args);
-        },
-        become: (kind, registry) => {
-            const found = this.#wardOf(kind, registry);
-            if (typeof found === 'string')
-                return found;
-            const resident = this.#residents.get(WARD);
-            try {
-                resident.being = new found(resident.stance);
-            }
-            catch {
-                return `${kind} threw at birth`;
-            }
-            resident.row.class = kind;
-            if (registry === undefined)
-                delete resident.row.registry;
-            else
-                resident.row.registry = registry;
-            this.partition.told(WARD);
-            this.#fault = null;
-            return null;
-        },
-    };
-}

package/dist/core/ward/index.d.ts

@@ -1,5 +0,0 @@
-export { allow, CEILING, DEFAULT } from './allowance.ts';
-export { HEAD_ROW, Partition, type BeingRow, type Head, type StandingRow } from './partition.ts';
-export { DEPTH } from './stance.ts';
-export { DOCK, House, type Classes, type HouseParts, type Lender, type Routes, type WardClass } from './house.ts';
-export { HELD, ownerAsk, pilots, rootAsk, Ward, type Steward, type WardStance } from './ward.ts';

package/dist/core/ward/index.js

@@ -1,7 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The ward and its house: the partition, the stances, the ward, and the house.
-export { allow, CEILING, DEFAULT } from './allowance.js';
-export { HEAD_ROW, Partition } from './partition.js';
-export { DEPTH } from './stance.js';
-export { DOCK, House } from './house.js';
-export { HELD, ownerAsk, pilots, rootAsk, Ward } from './ward.js';

package/dist/core/ward/partition.d.ts

@@ -1,50 +0,0 @@
-import type { Lock } from '../crypto/index.ts';
-import { type HeirRecord, type Invitation, type KeptLock, type Relations, type StandingState } from '../quo/index.ts';
-import type { Rows } from '../contract/index.ts';
-import type { JsonObject } from '../being/index.ts';
-export declare const HEAD_ROW = "";
-export type Head = {
-    lock?: KeptLock;
-    heirs: Record<string, HeirRecord>;
-    gone: string[];
-    bind: Record<string, {
-        being: string;
-        id: string;
-    }>;
-    public: string | null;
-};
-export type StandingRow = {
-    invitation: Invitation;
-    state: StandingState;
-    seen: string | null;
-};
-export type BeingRow = {
-    class: string;
-    registry?: string;
-    cells: JsonObject;
-    occupants: Record<string, {
-        heir: string;
-        notes: JsonObject;
-    }>;
-    standings: Record<string, StandingRow>;
-};
-export declare class Partition {
-    readonly memory: Rows;
-    constructor(memory: Rows);
-    get head(): Head;
-    get beings(): Record<string, BeingRow>;
-    being(key: string): BeingRow | undefined;
-    told(key: string): void;
-    toldHead(): void;
-    kept(): Promise<boolean>;
-}
-export declare class PartitionRelations implements Relations {
-    #private;
-    constructor(partition: Partition);
-    lock(): Lock | undefined;
-    setLock(lock: Lock): void;
-    get(heir: string): HeirRecord | undefined;
-    set(heir: string, record: HeirRecord): void;
-    delete(heir: string): void;
-    kept(): Promise<boolean>;
-}

package/dist/core/ward/partition.js

@@ -1,66 +0,0 @@
-import { GONE, keptLock, lockOf } from '../quo/index.js';
-export const HEAD_ROW = '';
-export class Partition {
-    memory;
-    constructor(memory) {
-        this.memory = memory;
-        const rows = memory.rows;
-        rows.ward ??= { heirs: {}, gone: [], bind: {}, public: null };
-        rows.beings ??= {};
-    }
-    get head() {
-        return this.memory.rows.ward;
-    }
-    get beings() {
-        return this.memory.rows.beings;
-    }
-    being(key) {
-        return Object.hasOwn(this.beings, key) ? this.beings[key] : undefined;
-    }
-    told(key) {
-        this.memory.told(key);
-    }
-    toldHead() {
-        this.memory.told(HEAD_ROW);
-    }
-    kept() {
-        return this.memory.kept().catch(() => false);
-    }
-}
-// The door's memory, written into the head.
-export class PartitionRelations {
-    #partition;
-    constructor(partition) {
-        this.#partition = partition;
-    }
-    get #head() {
-        return this.#partition.head;
-    }
-    lock() {
-        return lockOf(this.#head.lock);
-    }
-    setLock(lock) {
-        this.#head.lock = keptLock(lock);
-        this.#partition.toldHead();
-    }
-    get(heir) {
-        return Object.hasOwn(this.#head.heirs, heir) ? this.#head.heirs[heir] : undefined;
-    }
-    set(heir, record) {
-        const head = this.#head;
-        head.heirs[heir] = record;
-        if (record.state === 'kept') {
-            head.gone.push(heir);
-            while (head.gone.length > GONE)
-                delete head.heirs[head.gone.shift()];
-        }
-        this.#partition.toldHead();
-    }
-    delete(heir) {
-        delete this.#head.heirs[heir];
-        this.#partition.toldHead();
-    }
-    kept() {
-        return this.#partition.kept();
-    }
-}