nervur 0.19.2 → 0.20.1

package/dist/ward/cells.js

@@ -1,186 +1,74 @@
-// How deep a value may nest. Every walk over a value in the kit recurses,
-// and a peer chooses the depth of what she answers; a bound keeps a hostile
-// reply from ending a walk in a stack overflow instead of a refusal.
-export const DEPTH = 64;
-// How many values one written out may come to. Depth alone does not bound
-// what a value costs to keep: one subvalue may sit under two keys, and
-// nesting that forty levels deep is inside the depth bound and is a trillion
-// values once written down. What is walked here is the object graph, which is
-// small; what a harbor keeps is the tree it expands to, which is not. So the
-// walk counts the tree while it proves the graph, and refuses a value nobody
-// could write down. This is a bound on what a being holds, so it is this
-// kit's number and no word of the spec.
-export const BREADTH = 1 << 20;
-// Text a harbor can write down: every surrogate in a pair. A lone one is a
-// code unit with no character, which JSON escapes and UTF-8 cannot encode at
-// all, so a harbor that keeps strings as bytes loses it and one that keeps
-// the object does not. I-JSON says a string is text, and this is that rule
-// where the value is written rather than where it is read.
-const WELL_FORMED = /^(?:[^\uD800-\uDFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF])*$/;
-// I-JSON, all the way down. A number that JSON cannot write is not a number
-// a harbor can keep, a key on the prototype is not a key she wrote, and a
-// hole in a list, or a key named `__proto__`, is a thing JSON writes one way
-// and a runtime reads another.
+// SPDX-License-Identifier: Apache-2.0
+// A being's cells, guarded. Her cells are kept by whatever memory her
+// terrain gives, and a memory that writes JSON would hand back something
+// other than what she wrote if she wrote anything JSON cannot hold. So a
+// write that is not a value throws where she wrote it, in her own frame,
+// and her answer becomes silence like any throw.
 //
-// A fault is a sentence; anything else is the count of values under this one,
-// itself included. A value already counted is a value already proven, so a
-// graph that shares is walked once per node rather than once per path.
-function walk(v, path, seen, sized, depth) {
-    if (v === null || typeof v === 'boolean')
-        return 1;
-    if (typeof v === 'string')
-        return WELL_FORMED.test(v) ? 1 : `${path} carries a lone surrogate, which is no text a harbor can write down`;
-    if (typeof v === 'number') {
-        if (!Number.isFinite(v))
-            return `${path} is ${String(v)}, which no harbor can write down`;
-        // Minus zero is a number JSON writes as `0` and reads back as `0`. A
-        // harbor that keeps values would hand her the sign she wrote and one that
-        // writes JSON would not, and she is never told which she is standing in.
-        return Object.is(v, -0) ? `${path} is minus zero, which comes back as zero from every harbor that writes JSON` : 1;
-    }
-    if (typeof v !== 'object')
-        return `${path} is a ${typeof v}, which is not a value`;
-    if (seen.has(v))
-        return `${path} refers back to itself`;
-    const counted = sized.get(v);
-    if (counted !== undefined)
-        return counted;
-    if (depth >= DEPTH)
-        return `${path} is nested past ${DEPTH} levels, which no harbor can keep`;
-    seen.add(v);
-    try {
-        let size = 1;
-        const under = (where, x) => {
-            const r = walk(x, where, seen, sized, depth + 1);
-            if (typeof r === 'string')
-                return r;
-            size += r;
-            return size > BREADTH ? `${path} writes out to more than ${BREADTH} values, which no harbor can keep` : null;
-        };
-        if (Array.isArray(v)) {
-            for (let i = 0; i < v.length; i += 1) {
-                if (!(i in v))
-                    return `${path}[${i}] is a hole, which no harbor can write down`;
-                const f = under(`${path}[${i}]`, v[i]);
-                if (f)
-                    return f;
-            }
-            sized.set(v, size);
-            return size;
-        }
-        const proto = Object.getPrototypeOf(v);
-        if (proto !== Object.prototype && proto !== null)
-            return `${path} is a ${(v).constructor?.name ?? 'object'}, which is not a value`;
-        for (const k of Object.keys(v)) {
-            if (k === '__proto__')
-                return `${path}.__proto__ is a key no harbor can keep`;
-            const f = under(`${path}.${k}`, v[k]);
-            if (f)
-                return f;
-        }
-        sized.set(v, size);
-        return size;
-    }
-    finally {
-        seen.delete(v);
-    }
-}
-export const cellFault = (v, path) => {
-    const out = walk(v, path, new Set(), new Map(), 0);
-    return typeof out === 'string' ? out : null;
-};
-// The three keys at the root of her cells that are the ward's: it writes
-// them, she reads them, and a write of hers there is refused like a non-value.
-const WARDS = new Set(['standings', 'occupants', 'class']);
-// The guard is one proxy at the root and one for every container read through
-// it, so a write nested three deep is refused the same way a write at the top
-// is. Wrappers are remembered, so reading the same array twice is the same
-// object twice and a being may still compare what she holds.
-const wrapped = new WeakMap();
-const targets = new WeakMap();
-const guards = new WeakSet();
-// A name no partition can hold, wherever it appears. It is here beside the
-// guard that refuses it, because the ward refuses it too: a relation named
-// this one would be written into the bind table and then throw on her cells,
-// which is half a relation and a throw where a null is promised. One rule,
-// one place, read by the guard and by the stance.
-export const unkeepable = (k) => k === '__proto__';
-// A key a write may land on: a string that is not `__proto__`, and not one
-// of the ward's at the root. A symbol key is a thing JSON never writes.
+// What passes is stored as a fresh copy of its JSON text, so a reference
+// she kept to what she wrote is not a way around the guard. Every key lands
+// as an own key, `__proto__` included. A list grows at its end: a slot or a
+// length past it would leave a hole.
+import { writeValue } from '../crypto/index.js';
+export const DEPTH = 64;
 const refuse = (why) => {
     throw new TypeError(`cells hold values: ${why}`);
 };
-function keyFault(t, k, v, path, root) {
-    if (typeof k !== 'string')
-        refuse(`${path} takes no symbol key`);
-    if (unkeepable(k))
-        refuse(`${path}.__proto__ is a key no harbor can keep`);
-    if (root && WARDS.has(k))
-        refuse(`${path}.${k} is the ward's to write`);
-    // A list grows by one at its end, or it has holes JSON cannot write. A
-    // push sets the slot at its length and then the length: both pass. A
-    // length set past what she wrote, or a slot beyond it, would leave holes.
-    if (Array.isArray(t)) {
-        if (k === 'length') {
-            if (typeof v !== 'number' || v > t.length)
-                refuse(`${path}.length set past what she wrote would leave holes`);
-            return;
-        }
-        const i = Number(k);
-        if (Number.isInteger(i) && i > t.length)
-            refuse(`${path}[${i}] would leave a hole`);
+const copy = (value, room, where) => {
+    const text = writeValue(value, room);
+    return text === undefined ? refuse(`${where} is not a value JSON keeps, within ${room} levels`) : JSON.parse(text);
+};
+export class Cells {
+    #guards = new WeakMap();
+    #wrote;
+    constructor(wrote) {
+        this.#wrote = wrote;
     }
-}
-function guard(target, path, wrote, root = false) {
-    if (guards.has(target))
-        return target;
-    const had = wrapped.get(target);
-    if (had)
-        return had;
-    const p = new Proxy(target, {
-        get(t, k, r) {
-            const v = Reflect.get(t, k, r);
-            // A container reached through her cells is part of her cells.
-            return v !== null && typeof v === 'object' && !ArrayBuffer.isView(v) ? guard(v, `${path}.${String(k)}`, wrote) : v;
-        },
-        set(t, k, v, r) {
-            keyFault(t, k, v, path, root);
-            const f = cellFault(v, `${path}.${String(k)}`);
-            if (f)
-                refuse(f);
-            const ok = Reflect.set(t, k, v, r);
-            wrote();
-            return ok;
-        },
-        defineProperty(t, k, d) {
-            if (!('value' in d))
-                refuse(`${path}.${String(k)} is an accessor, which no harbor can keep`);
-            keyFault(t, k, d.value, path, root);
-            const f = cellFault(d.value, `${path}.${String(k)}`);
-            if (f)
-                refuse(f);
-            const ok = Reflect.defineProperty(t, k, d);
-            wrote();
-            return ok;
-        },
-        deleteProperty(t, k) {
-            if (root && typeof k === 'string' && WARDS.has(k))
-                refuse(`${path}.${k} is the ward's to keep`);
-            const ok = Reflect.deleteProperty(t, k);
-            wrote();
+    // The guarded view of a being's cells.
+    guard(cells) {
+        return this.#guard(cells, 'cells', 1);
+    }
+    #guard(target, path, level) {
+        const had = this.#guards.get(target);
+        if (had)
+            return had;
+        const room = DEPTH - level;
+        const place = (t, k, value) => {
+            if (typeof k !== 'string')
+                return refuse(`${path} takes no symbol key`);
+            const where = `${path}.${k}`;
+            if (Array.isArray(t)) {
+                if (k === 'length') {
+                    if (typeof value !== 'number' || value > t.length)
+                        refuse(`${where} past its end would leave a hole`);
+                    t.length = value;
+                    this.#wrote();
+                    return true;
+                }
+                if (!/^(0|[1-9]\d*)$/.test(k))
+                    refuse(`${where} is not a slot of a list`);
+                if (Number(k) > t.length)
+                    refuse(`${where} would leave a hole`);
+            }
+            const ok = Reflect.defineProperty(t, k, { value: copy(value, room, where), enumerable: true, writable: true, configurable: true });
+            this.#wrote();
             return ok;
-        },
-    });
-    wrapped.set(target, p);
-    targets.set(p, target);
-    guards.add(p);
-    return p;
+        };
+        const proxy = new Proxy(target, {
+            get: (t, k, r) => {
+                const v = Reflect.get(t, k, r);
+                return typeof k === 'string' && Object.hasOwn(t, k) && typeof v === 'object' && v !== null ? this.#guard(v, `${path}.${k}`, level + 1) : v;
+            },
+            set: (t, k, v) => place(t, k, v),
+            defineProperty: (t, k, d) => ('value' in d ? place(t, k, d.value) : refuse(`${path}.${String(k)} is an accessor`)),
+            deleteProperty: (t, k) => {
+                const ok = Reflect.deleteProperty(t, k);
+                this.#wrote();
+                return ok;
+            },
+            setPrototypeOf: () => refuse(`${path} keeps its prototype`),
+        });
+        this.#guards.set(target, proxy);
+        return proxy;
+    }
 }
-// Her cells, guarded. Called once per being at boot; the guarded object is
-// what goes into the partition and what the stance hands her, so there is no
-// second door onto the same cells. Every write that passes says so to the
-// ward, which says so to its harbor.
-export const guardCells = (cells, wrote = () => { }) => guard(cells, 'cells', wrote, true);
-// The cells behind the guard, for the ward alone: the one writer of the
-// three keys that are its own.
-export const unguarded = (cells) => (targets.get(cells) ?? cells);

package/dist/ward/index.d.ts

@@ -1,10 +1,6 @@
-export { Ward } from './ward.ts';
-export type { Ground, WardPointers, Memory } from './ground.ts';
-export { BOX, OFFER, RETRACT, volatile } from './ground.ts';
-export type { Partition, Heir, Bind, StandingKeys } from './partition.ts';
-export { GONE, MINTED, KNOCKS } from './partition.ts';
-export type { AskPayload, ReplyPayload } from './seal.ts';
-export * as seal from './seal.ts';
-export * as arithmetic from './arithmetic.ts';
-export { allow, spent, DEFAULT, CEILING } from './allowance.ts';
-export type { Allowance } from './allowance.ts';
+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, Ward, type Catalogue, type Lender, type WardParts } from './ward.ts';
+export { ownerAsk, pilots, WardBeing, type Steward, type WardBeingStance } from './ward-being.ts';
+export { Pilot } from './pilot.ts';

package/dist/ward/index.js

@@ -1,14 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
-// nervur/ward — one function. Every ward is the same ward.
-export { Ward } from './ward.js';
-export { BOX, OFFER, RETRACT, volatile } from './ground.js';
-// The three bounds on what a partition may hold, for a kit that must keep
-// the same ones and for a test that pins them.
-export { GONE, MINTED, KNOCKS } from './partition.js';
-// The seal and the arithmetic, for a kit in another language to check its
-// bytes against, and for tests that speak to a door directly.
-export * as seal from './seal.js';
-export * as arithmetic from './arithmetic.js';
-// The allowance every ask carries, for a kit in another language and for
-// tests that speak to a door directly.
-export { allow, spent, DEFAULT, CEILING } from './allowance.js';
+// The ward: its partition, its stances, its ward-being, and the ward.
+export { allow, CEILING, DEFAULT } from './allowance.js';
+export { HEAD_ROW, Partition } from './partition.js';
+export { DEPTH } from './stance.js';
+export { DOCK, Ward } from './ward.js';
+export { ownerAsk, pilots, WardBeing } from './ward-being.js';
+export { Pilot } from './pilot.js';

package/dist/ward/partition.d.ts

@@ -1,65 +1,49 @@
-import type { Cells } from '../being/types.ts';
-export declare const VERSION = "pre-1.0.0";
-export declare const READS: readonly string[];
-export type Heir = {
-    being: string;
-    id: string;
-    current: string;
-    announced: string | null;
-    fresh: boolean;
-    mark: number;
-    spent: number[];
-    last?: {
-        seq: number;
-        reply: string;
-    };
-};
-export type StandingKeys = {
-    ward: string;
-    heir: string | null;
-    current: string;
-    next: string | null;
-    seq: number;
-};
-export type Bind = {
-    standings: Record<string, StandingKeys>;
-    occupants: Record<string, string>;
-    knocks: Record<string, {
-        current: string;
-        next: string | null;
-        spoke: boolean;
-        sent: boolean;
-        seq: number;
+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;
     }>;
-    answered: Record<string, true>;
-    minted: string[];
+    public: string | null;
 };
-export type Gone = {
-    current: string;
-    announced: string | null;
+export type StandingRow = {
+    invitation: Invitation;
+    state: StandingState;
+    seen: string | null;
 };
-export declare const GONE = 256;
-export declare const MINTED = 8;
-export declare const KNOCKS = 64;
-export declare const prune: (knocks: Record<string, unknown>, answered: Record<string, true>) => void;
-export type Partition = {
-    version: string;
-    beings: Record<string, Cells & {
-        class?: string;
+export type BeingRow = {
+    class: string;
+    cells: JsonObject;
+    occupants: Record<string, {
+        heir: string;
+        notes: JsonObject;
     }>;
-    bind: Record<string, Bind>;
-    heirs: Record<string, Heir>;
-    gone: Record<string, Gone>;
-    public: string | null;
+    standings: Record<string, StandingRow>;
 };
-export declare function open(memory: Record<string, unknown>): Partition;
-export declare const at: <T>(rec: Record<string, T>, key: string) => T | undefined;
-export declare const put: <T>(rec: Record<string, T>, key: string, value: T) => T;
-export declare const drop: (rec: Record<string, unknown>, key: string) => void;
-export declare const emptyCells: () => Cells;
-export declare const emptyBind: () => Bind;
-export declare const HEAD = "";
-export declare const rowOf: (p: Partition, row: string) => Record<string, unknown> | undefined;
-export declare const rowsIn: (p: Record<string, unknown>) => string[];
-export declare const restoreRow: (p: Partition, row: string, value: Record<string, unknown> | undefined) => void;
-export declare const fromRows: (rows: Record<string, Record<string, unknown>>) => Record<string, unknown>;
+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>;
+}