fauna-api 0.0.0-stage → 1.0.676

package/dist/src/shared/server.js

@@ -0,0 +1,302 @@
+export class Presence {
+    constructor(room, id, profile) {
+        Object.defineProperty(this, "room", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "profile", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_position", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.room = room;
+        this.id = id;
+        this.profile = profile;
+        this._position = [0, 0, 0];
+        this._status = undefined;
+    }
+    get position() {
+        return this._position;
+    }
+    get status() {
+        return this._status ?? '';
+    }
+    move(position) {
+        this._position = position;
+        this.room.post({
+            event: 'update-client',
+            client: this.toJSON()
+        });
+    }
+    setStatus(status) {
+        this._status = status;
+        this.room.post({
+            event: 'update-client',
+            client: this.toJSON()
+        });
+    }
+    update(patch) {
+        this._position = patch.position ?? this._position;
+        this._status = patch.status ?? this._status;
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            profile: this.profile,
+            position: this._position,
+            status: this.status
+        };
+    }
+}
+export class Room {
+    constructor(endpoint, ws, authorization, id) {
+        Object.defineProperty(this, "endpoint", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ws", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "authorization", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "presences", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.endpoint = endpoint;
+        this.ws = ws;
+        this.authorization = authorization;
+        this.id = id;
+        this.presences = [];
+    }
+    getPresences() {
+        return this.presences;
+    }
+    /** The caller's Credentials or ApiKey from the live authorization pack. */
+    getAuthorization() {
+        return this.authorization.authorization;
+    }
+    // Send a raw frame to the room edge.
+    post(packet) {
+        if (this.ws.readyState !== WebSocket.OPEN)
+            return;
+        this.ws.send(JSON.stringify(packet));
+    }
+    disconnect() {
+        this.presences.length = 0;
+        this.ws.close();
+    }
+    async generateAccessCode() {
+        const auth = this.authorization;
+        const response = await fetch(`${this.endpoint.endsWith('/') ? this.endpoint.slice(0, -1) : this.endpoint}/access-code`, {
+            method: "POST",
+            headers: {
+                ...('email' in auth.authorization ? {
+                    Authorization: `Token ${auth.authorization.token}`
+                } : {
+                    Authorization: `ApiKey ${auth.authorization.id}`
+                }),
+                // Mint resolves the room the same way live connect does: Server
+                // (+ optional Group for group-hosted rooms).
+                ...('server' in auth ? { Server: auth.server } : {}),
+                ...('server' in auth && auth.group ? { Group: auth.group } : {}),
+            }
+        });
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        return (await response.text());
+    }
+}
+export async function connect(authorization, endpoint, hooks = {}) {
+    // Build WebSocket URL
+    const authParam = encodeURIComponent(JSON.stringify({
+        Authorization: 'email' in authorization.authorization ? `Token ${authorization.authorization.token}` : `ApiKey ${authorization.authorization.id}`,
+        ...('server' in authorization ? {
+            Server: authorization.server,
+            ...('group' in authorization ? {
+                Group: authorization.group
+            } : {})
+        } : {
+            AccessCode: authorization.accessCode
+        })
+    }));
+    const wsURL = endpoint.replace(/^http:\/\//, 'ws://').replace(/^https:\/\//, 'wss://').replace(/\/$/, '');
+    const ws = new WebSocket(`${wsURL}?authorization=${authParam}`);
+    var room = undefined;
+    var selfId = undefined;
+    // Wait for connection
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            fn();
+        };
+        const fail = (message) => {
+            settle(() => {
+                try {
+                    ws.close();
+                }
+                catch { /* noop */ }
+                reject(new Error(message));
+            });
+        };
+        const timer = setTimeout(() => fail(`Timed out waiting for the room (${wsURL}).`), 15000);
+        ws.onmessage = (msg) => {
+            try {
+                const json = JSON.parse(typeof msg.data === 'string' ? msg.data : String(msg.data));
+                if (json.event === 'error') {
+                    fail(typeof json.message === 'string' && json.message ? json.message : 'Room connection failed');
+                    return;
+                }
+                switch (json.event) {
+                    case 'connection': {
+                        const client = json.data?.client;
+                        if (!client?.id) {
+                            fail('Room connection missing self.');
+                            return;
+                        }
+                        selfId = client.id;
+                        const id = json.data.server.id;
+                        const state = json.data.state;
+                        room = hooks.createRoom ? hooks.createRoom(endpoint, ws, authorization, id, state) : new Room(endpoint, ws, authorization, id);
+                        const self = hooks.createPresence ? hooks.createPresence(room, client) : new Presence(room, client.id, client.profile);
+                        self.update(client);
+                        for (const presence of json.data.clients ?? []) {
+                            if (presence.id === client.id) {
+                                continue;
+                            }
+                            const other = hooks.createPresence ? hooks.createPresence(room, presence) : new Presence(room, presence.id, presence.profile);
+                            other.update(presence);
+                            room.getPresences().push(other);
+                        }
+                        if (hooks.onConnection) {
+                            hooks.onConnection(room, state);
+                        }
+                        settle(() => resolve(self));
+                        break;
+                    }
+                    case 'add-client': {
+                        if (!room) {
+                            fail('Room not found');
+                            return;
+                        }
+                        if (json.data.client.id === selfId) {
+                            break;
+                        }
+                        const presence = hooks.createPresence ? hooks.createPresence(room, json.data.client) : new Presence(room, json.data.client.id, json.data.client.profile);
+                        presence.update(json.data.client);
+                        room.getPresences().push(presence);
+                        hooks.onPresence?.(room);
+                        break;
+                    }
+                    case 'update-client': {
+                        if (!room) {
+                            fail('Room not found');
+                            return;
+                        }
+                        if (json.data.client.id === selfId) {
+                            break;
+                        }
+                        const presence = room.getPresences().find(p => p.id === json.data.client.id);
+                        if (!presence) {
+                            fail('Presence not found');
+                            return;
+                        }
+                        presence.update(json.data.client);
+                        hooks.onPresence?.(room);
+                        break;
+                    }
+                    case 'remove-client': {
+                        if (!room) {
+                            fail('Room not found');
+                            return;
+                        }
+                        const id = json.data.client.id;
+                        const presence = room.getPresences().find(p => p.id === id);
+                        if (hooks.removePresence && presence) {
+                            hooks.removePresence(room, presence);
+                        }
+                        if (presence) {
+                            room.getPresences().splice(room.getPresences().indexOf(presence), 1);
+                        }
+                        hooks.onPresence?.(room);
+                        break;
+                    }
+                    case 'server-closed': {
+                        if (!room) {
+                            fail('Room closed before connect');
+                            return;
+                        }
+                        const reason = typeof json.data?.reason === 'string' ? json.data.reason : undefined;
+                        room.getPresences().length = 0;
+                        hooks.onClosed?.(room, reason ? { reason } : undefined);
+                        try {
+                            ws.close();
+                        }
+                        catch { /* noop */ }
+                        break;
+                    }
+                    default: {
+                        if (hooks.onEvent && room) {
+                            hooks.onEvent(room, json);
+                        }
+                        break;
+                    }
+                }
+            }
+            catch (err) {
+                if (!settled) {
+                    fail(err instanceof Error ? err.message : 'Room connection failed');
+                }
+            }
+        };
+        ws.onerror = () => {
+            fail(`WebSocket connection failed (${wsURL})`);
+        };
+        ws.onclose = () => {
+            fail(`WebSocket closed before the room connected (${wsURL})`);
+        };
+    });
+}

package/dist/src/termite/environment.d.ts

@@ -0,0 +1,110 @@
+import { Text } from "../parrot/generative.js";
+import type { Content } from "../parrot/generative.js";
+import { Authorization, Room } from "../shared/server.js";
+import { Repository, type Route } from "./versioning.js";
+export type Terms = number | {
+    total: number;
+    upfront: number;
+    duration: number;
+    interval: number;
+};
+export type Ticket = {
+    id: number;
+    date: Date;
+    issue: string;
+    status: 'ACTIVE' | 'REJECTED' | 'FULFILLED';
+};
+export declare class Constitution {
+    readonly text: string;
+    readonly articles: string[];
+    private readonly room;
+    constructor(room: RuntimeRoom, text: string, articles?: string[]);
+    amend(article: string): Promise<void>;
+}
+export declare class RuntimeRoom extends Room {
+    readonly name: string;
+    readonly constitution: Constitution;
+    readonly model: Text;
+    readonly agents: Map<string, Agent>;
+    constructor(endpoint: string, ws: WebSocket, authorization: Authorization, id: string, state?: any);
+    update(json: unknown): void;
+}
+export declare class Agent {
+    readonly parent: Agent | null;
+    readonly id: string;
+    readonly children: Agent[];
+    readonly bible: string;
+    private _status;
+    readonly repository: Repository;
+    constructor(parent: Agent | null, id: string, bible: string, repository: Repository, status?: 'ACTIVE' | 'IDLE' | 'DELETED');
+    get status(): 'ACTIVE' | 'IDLE' | 'DELETED';
+    ticket(_issue: string): Promise<Ticket>;
+    delete(): Promise<void>;
+    balance(_query: {
+        start: Date;
+        end: Date;
+        max: number;
+    } | {
+        cursor: number;
+        max: number;
+    }): Promise<{
+        balanceMicros: number;
+        date: Date;
+    }[]>;
+    contracts(_query: {
+        start: Date;
+        end: Date;
+    } | {
+        cursor: number;
+        max: number;
+    }): Promise<Contract[]>;
+    loans(_query: {
+        start: Date;
+        end: Date;
+    } | {
+        cursor: number;
+        max: number;
+    }): Promise<Loan[]>;
+    tickets(_query: {
+        start: Date;
+        end: Date;
+    } | {
+        cursor: number;
+        max: number;
+    }): Promise<Ticket[]>;
+}
+export declare class Contract {
+    readonly parent: RuntimeRoom;
+    readonly id: string;
+    principal: Agent;
+    contractor: Agent;
+    description: string;
+    settlement: Terms;
+    status: 'PROPOSED' | 'ACTIVE' | 'REJECTED' | 'COUNTERED' | 'DEFAULTED' | 'FULFILLED';
+    content: (Content | Contract)[];
+    validation: {
+        repository: Repository;
+        route: Route;
+    };
+    date: Date;
+    constructor(parent: RuntimeRoom, id: string, principal: Agent, contractor: Agent, description: string, settlement: Terms, validation: {
+        repository: Repository;
+        route: Route;
+    }, date?: Date);
+}
+export declare class Loan {
+    readonly parent: RuntimeRoom;
+    readonly id: string;
+    lender: Agent;
+    borrower: Agent;
+    terms: {
+        lender: Terms;
+        borrower: Terms;
+    };
+    status: 'PROPOSED' | 'ACTIVE' | 'REJECTED' | 'DEFAULTED' | 'FULFILLED';
+    date: Date;
+    constructor(parent: RuntimeRoom, id: string, lender: Agent, borrower: Agent, terms: {
+        lender: Terms;
+        borrower: Terms;
+    }, date?: Date);
+}

package/dist/src/termite/environment.js

@@ -0,0 +1,263 @@
+import { Text } from "../parrot/generative.js";
+import { Room } from "../shared/server.js";
+export class Constitution {
+    constructor(room, text, articles = []) {
+        Object.defineProperty(this, "text", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "articles", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "room", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.room = room;
+        this.text = text;
+        this.articles = [...articles];
+    }
+    async amend(article) {
+        this.articles.push(article);
+        this.room.update({ event: 'amend-constitution', article });
+    }
+}
+export class RuntimeRoom extends Room {
+    constructor(endpoint, ws, authorization, id, state) {
+        super(endpoint, ws, authorization, id);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "constitution", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "agents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = typeof state?.name === "string" ? state.name : "";
+        this.model = state?.model ?? Text.AUTO;
+        this.constitution = new Constitution(this, typeof state?.constitution?.text === "string" ? state.constitution.text : "", Array.isArray(state?.constitution?.articles) ? state.constitution.articles : []);
+        this.agents = new Map();
+    }
+    update(json) {
+        this.post(json);
+    }
+}
+export class Agent {
+    constructor(parent, id, bible, repository, status = 'IDLE') {
+        Object.defineProperty(this, "parent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "children", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "bible", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "repository", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.parent = parent;
+        this.id = id;
+        this.children = [];
+        this.bible = bible;
+        this._status = status;
+        this.repository = repository;
+        if (parent)
+            parent.children.push(this);
+    }
+    get status() {
+        return this._status;
+    }
+    async ticket(_issue) {
+        throw new Error("Termite routes are not implemented.");
+    }
+    async delete() {
+        throw new Error("Termite routes are not implemented.");
+    }
+    async balance(_query) {
+        throw new Error("Termite routes are not implemented.");
+    }
+    async contracts(_query) {
+        throw new Error("Termite routes are not implemented.");
+    }
+    async loans(_query) {
+        throw new Error("Termite routes are not implemented.");
+    }
+    async tickets(_query) {
+        throw new Error("Termite routes are not implemented.");
+    }
+}
+export class Contract {
+    constructor(parent, id, principal, contractor, description, settlement, validation, date = new Date()) {
+        Object.defineProperty(this, "parent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "principal", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "contractor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "settlement", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "content", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "validation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "date", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.parent = parent;
+        this.id = id;
+        this.principal = principal;
+        this.contractor = contractor;
+        this.description = description;
+        this.settlement = settlement;
+        this.status = 'PROPOSED';
+        this.content = [];
+        this.validation = validation;
+        this.date = date;
+    }
+}
+export class Loan {
+    constructor(parent, id, lender, borrower, terms, date = new Date()) {
+        Object.defineProperty(this, "parent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lender", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "borrower", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "terms", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "date", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.parent = parent;
+        this.id = id;
+        this.lender = lender;
+        this.borrower = borrower;
+        this.terms = terms;
+        this.status = 'PROPOSED';
+        this.date = date;
+    }
+}

package/dist/src/termite/index.d.ts

@@ -0,0 +1,14 @@
+import * as EnvironmentAPI from "./environment.js";
+import * as OSAPI from "./os.js";
+import * as VersioningAPI from "./versioning.js";
+export declare namespace Termite {
+    function setRoute(route: string): void;
+    function getIP(): string;
+    function getPort(): number;
+    function getRoute(): string;
+    function getURL(): string;
+    function ping(): Promise<number>;
+    export import Environment = EnvironmentAPI;
+    export import OS = OSAPI;
+    export import Versioning = VersioningAPI;
+}