@idleware/ringi 0.5.0 → 0.6.0

package/target/dts/app/session.d.ts

@@ -1,65 +0,0 @@
-import type { Session } from '../runtime/session.ts';
-import type { JoinKey } from '../store/index.ts';
-export { bound } from '../runtime/session.ts';
-export type { Session } from '../runtime/session.ts';
-export declare const briefing: (s: Session) => {
-    session: Session;
-    actor: import("../runtime/session.ts").Bound;
-    start: {
-        quorum: number | null;
-        agents: number;
-        started: boolean;
-    };
-    tasks: import("./view.ts").TaskView[];
-    inbox: {
-        rest: number;
-        cursors: {
-            [x: string]: string;
-        };
-        all: import("../protocol/index.ts").All;
-        msgs: {
-            id: string;
-            from: string;
-            trust: 'asserted' | 'verified';
-            time: number;
-            seq: number;
-            invalid: string | null;
-            subject: string;
-            body: string;
-            to: string[];
-            re: string | null;
-            kind: string | null;
-            state: string | null;
-            assign: string[] | null;
-            roles: Record<string, string> | null;
-            hop: number;
-            bad: string | null;
-            trailers: import("../protocol/index.ts").Trailers;
-            refused: import("../protocol/index.ts").Refused[];
-            reId: string | null;
-            hopEff: number;
-            files: import("../protocol/index.ts").FileRef[];
-        }[];
-    } | null;
-};
-export type JoinInput = {
-    hub: string;
-    room: string;
-    agent?: string;
-    scope?: string;
-};
-export type JoinResult = {
-    agent: string;
-    hub: string;
-    room: string;
-} & ({
-    session: Session;
-    key: null;
-} | {
-    session: null;
-    key: JoinKey;
-});
-export declare const join: ({ hub, room, agent: id, scope }: JoinInput) => JoinResult;
-export declare const resume: (selector?: string) => Session;
-export declare const stop: () => Session;
-export declare const leave: () => Session;

package/target/dts/cli/context.d.ts

@@ -1,6 +0,0 @@
-import * as Context from '../app/context.ts';
-import type { Opts } from './args.ts';
-export type { Ctx } from '../app/context.ts';
-export { isRef } from '../app/room.ts';
-export declare const parseTo: (v: unknown) => string[];
-export declare const operatorCtx: (o: Opts) => Context.Ctx;

package/target/dts/cli/operator.d.ts

@@ -1,10 +0,0 @@
-import type { SessionView } from '../app/overview.ts';
-import type { Opts } from './args.ts';
-export declare const sessionLine: (s: SessionView) => string;
-export declare const where: (o: Opts) => Promise<void>;
-export declare const heartbeats: (o: Opts) => Promise<void>;
-export declare const pulse: (o: Opts) => Promise<void>;
-export declare const sessions: (o: Opts) => void;
-export declare const forget: (o: Opts) => void;
-export declare const hub: (o: Opts) => void;
-export declare const roomCmd: (o: Opts) => void;

package/target/dts/cli/shared.d.ts

@@ -1,27 +0,0 @@
-import type { TaskView } from '../app/view.ts';
-import type { Opts } from './args.ts';
-import type { Ctx } from './context.ts';
-import type { Session } from '../app/session.ts';
-export declare const add: (a: Ctx, o: Opts) => void;
-export declare const send: (a: Ctx, o: Opts) => void;
-export declare const reply: (a: Ctx, o: Opts) => void;
-export declare const read: (a: Ctx, o: Opts) => void;
-export declare const thread: (a: Ctx, o: Opts) => void;
-export declare const taskLine: (t: TaskView) => string;
-export declare const tasks: (a: Ctx, o: Opts) => void;
-export declare const log: (a: Ctx, o: Opts) => void;
-export declare const cat: (a: Ctx, o: Opts) => void;
-export declare const get: (a: Ctx, o: Opts) => void;
-export declare const who: (a: Ctx) => void;
-export declare const signals: (a: Ctx, o: Opts) => void;
-export declare const profileCmd: ({ R }: Ctx, o: Opts) => void;
-export declare const propose: (a: Ctx, o: Opts) => void;
-export declare const stamp_: (a: Ctx, o: Opts) => void;
-export declare const decide: (a: Ctx, o: Opts) => void;
-export declare const proposals: (a: Ctx, o: Opts) => void;
-export declare const grants: (a: Ctx, o: Opts) => void;
-export declare const scopeLine: (s: Session, quorum?: boolean) => string;
-export declare const waiting: (room: string, st: {
-    quorum: number | null;
-    agents: number;
-}) => string;

package/target/dts/domain/decisions.d.ts

@@ -1,65 +0,0 @@
-import type { All, Message, Parsed } from '../protocol/index.ts';
-export declare const CAPABILITY = "decisions/1";
-export declare const ROOT = "operator";
-export declare const BUDGET_KEYS: readonly ['runs', 'run-seconds', 'concurrency'];
-export type Budget = {
-    runs: number;
-    'run-seconds': number;
-    concurrency: number;
-};
-export declare const STAMPS: string[];
-export declare const DECISIONS: string[];
-export type Authority = {
-    decide?: Record<string, Partial<Budget>>;
-};
-export type AuthorityAt = (control: string | null) => Authority | null;
-export declare const parseBudget: (s: string | null | undefined) => Budget | null | undefined;
-export declare const budgetText: (b: Budget) => string;
-export declare const parseDue: (s: string) => string;
-export declare const check: (m: Parsed, isRef: (s: string) => boolean) => string | null;
-export declare const mayDecide: (authority: Authority | null, decider: string, proposer: string, budget: Budget | null) => boolean;
-export type Grant = {
-    id: string;
-    budget: Budget;
-    proposal: Message;
-    revoked: boolean;
-};
-export type Proposal = {
-    proposal: Message;
-    decider: string;
-    reviewers: string[];
-    budget: Budget | null;
-    due: number | null;
-    stamps: Record<string, {
-        stamp: string;
-        id: string;
-        reason: string;
-    }>;
-    missing: string[];
-    decision: {
-        decision: string;
-        id: string;
-        by: string;
-        time: number;
-    } | null;
-    revoked: {
-        id: string;
-        by: string;
-        time: number;
-    } | null;
-    superseded: Message | null;
-    state: string;
-    grant: Grant | null;
-};
-export declare const proposalOf: (all: All, p: Message, authorityAt: AuthorityAt, now?: number) => Proposal;
-export declare const proposals: (all: All, authorityAt: AuthorityAt) => Proposal[];
-export declare const grantOf: (all: All, authorityAt: AuthorityAt, id: string) => Grant | null;
-export type Usage = {
-    runs: number;
-    open: number;
-    uncertain: number;
-    seconds: number;
-    left: number;
-};
-export declare const counted: (all: All, authorityAt: AuthorityAt, m: Message) => boolean;
-export declare const usageOf: (all: All, grant: Grant, now?: number) => Usage;

package/target/dts/domain/signals.d.ts

@@ -1,37 +0,0 @@
-import * as D from './decisions.ts';
-import type { Profile } from './profiles.ts';
-import type { All, Message } from '../protocol/index.ts';
-export type RoomModel = {
-    name: string;
-    genesis: string;
-    profile: Profile;
-    members: Record<string, unknown>;
-    authorityAt: D.AuthorityAt;
-};
-export type SignalRecord = {
-    ref: string;
-    object: string;
-    name: string;
-    actor: string;
-    target: string;
-    tagger: string;
-    text: string;
-};
-export declare const MARKS: string[];
-export declare const signalName: (id: string, signal: string) => string;
-export declare const markWhy: (R: RoomModel, actor: string, m: Message, mark: string) => string | undefined;
-export declare const marksOn: (checked: Checked[]) => Map<string, Record<string, string[]>>;
-export declare const effective: (R: RoomModel, all: All, m: Message) => string[];
-export type Checked = {
-    ref: string;
-    actor: string;
-    signal: string;
-    target: string;
-    ok: boolean;
-    why?: string;
-};
-export declare const check: (R: RoomModel, all: All, records: SignalRecord[]) => Checked[];
-export declare const pins: (records: SignalRecord[], checked: Checked[], accepted?: Record<string, string>) => {
-    accepted: Record<string, string>;
-    alarms: string[];
-};

package/target/dts/heartbeat/platform.d.ts

@@ -1,15 +0,0 @@
-export declare const SUPPORTED: boolean;
-export declare const alive: (pid: number) => boolean;
-export declare const seconds: (time: string) => number;
-export declare const procStat: (line: string) => {
-    ppid: number;
-    cpu: number;
-} | null;
-export declare const table: () => Map<number, {
-    ppid: number;
-    cpu: number;
-}> | null;
-export declare const treeCpu: (pid: number, rows?: Map<number, {
-    ppid: number;
-    cpu: number;
-}> | null) => number | null;

package/target/dts/heartbeat/tools.d.ts

@@ -1,11 +0,0 @@
-export declare const toolOf: (s: {
-    handle: string;
-    product: string | null;
-}) => {
-    tool: 'claude' | 'codex';
-    id: string;
-} | null;
-export declare const traceTime: (s: {
-    handle: string;
-    product: string | null;
-}) => number | null;

package/target/dts/home/index.d.ts

@@ -1,21 +0,0 @@
-export declare const ROOT: string;
-export declare const RESOURCES: string;
-export declare const VERSION: string;
-export declare const HOME: string;
-export declare const HOME_VERSION = 3;
-export declare const OPERATOR = "operator";
-export declare const guard: <T>(fn: () => T) => T;
-export declare const mkdir: (d: string) => void;
-export declare const writeJson: (f: string, v: unknown) => void;
-export declare const readJson: <T>(f: string, dflt: T) => T;
-export declare const hubsDir: () => string;
-export declare const hubHome: (name: string) => string;
-export declare const ensureHome: () => void;
-export declare const locked: <T>(name: string, fn: () => T) => T;
-export type Config = {
-    hub: string;
-    room: string | null;
-};
-export declare const configFile: () => string;
-export declare const config: () => Config;
-export declare const setConfig: (patch: Partial<Config>) => void;

package/target/dts/hub/index.d.ts

@@ -1,72 +0,0 @@
-import * as D from '../domain/decisions.ts';
-import { OPERATOR } from '../home/index.ts';
-import type { Profile } from '../domain/profiles.ts';
-import { HIDDEN } from '../protocol/index.ts';
-import type { All, FileRef, Message } from '../protocol/index.ts';
-import type { Descriptor, Member, Rev, Store, StoredMessage, StoredRoom } from '../store/index.ts';
-import type { Entry } from '../protocol/files.ts';
-export declare const HUB_MAJOR = 1;
-export declare const CAPS: Set<string>;
-export declare const RESERVED_ROOMS: Set<string>;
-export type Contract = {
-    schema: 'ringi-hub';
-    version: string;
-    protocol: number;
-    trust: 'asserted' | 'signed';
-    capabilities?: string[];
-    profile?: string;
-    root?: string;
-    authority: D.Authority;
-};
-export type Hub = {
-    name: string;
-    dir: string;
-    d: Descriptor;
-    store: Store;
-    main: Rev;
-    contract: Contract;
-    signed: boolean;
-};
-export type Room = {
-    hub: Hub;
-    s: StoredRoom;
-    name: string;
-    archived: boolean;
-    head: Rev;
-    genesis: Rev;
-    contractRev: Rev;
-    contract: Contract;
-    authorityAt: D.AuthorityAt;
-    profile: Profile;
-    members: Record<string, Member>;
-    quorum: number | null;
-};
-export declare const start: (R: Pick<Room, 'members' | 'quorum'>) => {
-    quorum: number | null;
-    agents: number;
-    started: boolean;
-};
-export declare const hubNames: () => string[];
-export declare const createHub: (name: string, { signed, url }?: {
-    signed?: boolean;
-    url?: string;
-}) => void;
-export declare const readDescriptor: (name: string) => Descriptor;
-export declare const contractAt: (store: Store, name: string, rev: Rev) => Contract;
-export declare const openHub: (name: string, { refresh }?: {
-    refresh?: boolean;
-}) => Hub;
-export declare const roomNames: (H: Hub, archived?: boolean) => string[];
-export declare const openRoom: (H: Hub, name: string | null | undefined, { quiet }?: {
-    quiet?: boolean;
-}) => Room | null;
-export declare const room: (H: Hub, name: string | null | undefined) => Room;
-export declare const ROOM_MD: (name: string) => string;
-export declare const profileText: (H: Hub, name: string) => string | null;
-export declare const controlChange: (R: Room, who: string, subject: string, mutate: (m: Record<string, Member>) => void, extra?: Array<[string, string]>) => void;
-export declare const toMessage: (R: Room, from: string, x: StoredMessage, seq: number) => Message;
-export declare const asStored: (R: Room) => All;
-export declare const append: (R: Room, who: string, text: string, entries?: Entry[]) => Rev;
-export declare const withSizes: (R: Room, m: Message) => FileRef[];
-export declare const pongText: (me: string, m: Message, what: string) => string;
-export { OPERATOR, HIDDEN };

package/target/dts/runtime/watch.d.ts

@@ -1,17 +0,0 @@
-import type { Room } from '../hub/index.ts';
-export type WatchOptions = {
-    seat: string;
-    exec: string;
-    hub?: string;
-    scope?: string;
-    handoff?: boolean;
-    once?: boolean;
-    requireGrant?: boolean;
-    interval?: number;
-    from?: string[];
-    maxHop?: number;
-    maxRuns?: number;
-    window?: number;
-};
-export declare const watch: (w: WatchOptions, log?: (line: string) => void) => Promise<number>;
-export type { Room };

package/target/dts/store/git/index.d.ts

@@ -1,92 +0,0 @@
-import * as Remote from './remote.ts';
-import type { Descriptor, JoinKey, Roster, SignalRecord, Store, StoredMessage, StoredRoom } from '../index.ts';
-import type { Entry } from '../../protocol/files.ts';
-type GitOpt = {
-    input?: string | Buffer;
-    env?: Record<string, string>;
-    where?: string;
-};
-export declare const runGit: (args: string[], o?: GitOpt) => string;
-export declare class GitStore implements Store {
-    readonly type = "git";
-    readonly trust: 'asserted' | 'signed';
-    readonly dir: string;
-    readonly d: Descriptor;
-    readonly home: string;
-    readonly h: Remote.Handle;
-    constructor(hubDir: string, d: Descriptor, home: string);
-    private openable;
-    private checkout;
-    private args;
-    private git;
-    private gitOk;
-    rev(ref: string): string | null;
-    isAncestor(a: string, b: string): boolean;
-    isRef(s: string): boolean;
-    extends(older: string, newer: string): boolean;
-    private tree;
-    private commit;
-    private advance;
-    static create(hubDir: string, d: Descriptor, home: string, contract: Record<string, string>, text: string): GitStore;
-    static rootFor(hubDir: string, d: Descriptor, home: string): string;
-    sync(): void;
-    contractHead(): string;
-    contractFile(rev: string, name: string): string | null;
-    contractFiles(rev: string): string[];
-    amendContract(who: string, text: string, files: Record<string, string | Buffer>): string;
-    private ref;
-    private transition;
-    private tip;
-    roomNames(archived: boolean): string[];
-    private isControl;
-    private scanned;
-    private entries;
-    private judged;
-    private scan;
-    room(name: string): StoredRoom | null;
-    controlFile(room: StoredRoom, name: string, rev?: string): string | null;
-    createRoom(name: string, who: string, text: string, files: Record<string, string>): string;
-    migrateRoom(name: string): string;
-    private migrateSignals;
-    updateControl(room: StoredRoom, who: string, text: string, files: Record<string, string>): string;
-    private refsUnder;
-    archiveRoom(room: StoredRoom, as: string): void;
-    deleteRoom(room: StoredRoom): void;
-    private remote;
-    roster(room: StoredRoom): Roster | null;
-    private live;
-    alarms(room: StoredRoom): string[];
-    logIds(room: StoredRoom): string[];
-    logHead(room: StoredRoom, id: string): string | null;
-    messages(room: StoredRoom, id: string, head: string): StoredMessage[];
-    blob(file: string): {
-        id: string;
-        size: number;
-    };
-    retain(room: StoredRoom, who: string, entries: Entry[]): void;
-    append(room: StoredRoom, who: string, text: string, entries: Entry[]): string;
-    private onTop;
-    verifyLog(room: StoredRoom, id: string, head: string): string | null;
-    pin(room: StoredRoom, reader: string, id: string, rev: string): void;
-    unpin(room: StoredRoom, reader: string, id: string): void;
-    file(rev: string, p: string): Buffer;
-    sizes(rev: string, paths: string[]): Map<string, number>;
-    heartbeat(room: StoredRoom, who: string, target: string, text: string): string;
-    heartbeats(room: StoredRoom): Array<{
-        agent: string;
-        target: string;
-        time: number;
-        text: string;
-    }>;
-    signal(room: StoredRoom, who: string, target: string, name: string): void;
-    private tags;
-    private tagObjects;
-    private commitsOf;
-    signals(room: StoredRoom): SignalRecord[];
-    admit(room: StoredRoom, who: string, key: string): string;
-    joinKey(room: StoredRoom, who: string): JoinKey;
-    forgetLog(room: StoredRoom, _id: string): void;
-    rootKey(): string;
-    rootRoster(): string;
-}
-export {};

package/target/dts/store/git/remote.d.ts

@@ -1,95 +0,0 @@
-import * as C from '../../lib/index.ts';
-import type { Descriptor, Member } from '../index.ts';
-export type Handle = {
-    name: string;
-    dir: string;
-    d: Descriptor;
-    main?: string;
-    remoteAlarms?: Record<string, string>;
-    heartbeatErrors?: Record<string, string>;
-    bootstrap?: boolean;
-};
-export type Room = {
-    name: string;
-    ref: string;
-    head: string;
-    genesis: string;
-    archived?: boolean;
-    members?: Record<string, Member>;
-};
-type Key = {
-    line: string;
-    fp: string;
-};
-type Signer = {
-    principal: string;
-    key: Key;
-};
-type VerifiedRoom = {
-    genesis: string;
-    entries: Signer[];
-    members: Record<string, Member>;
-};
-export type Branch = VerifiedRoom & {
-    subject: string;
-    control: string[];
-    authors: Map<string, string>;
-    skipped: Map<string, string>;
-};
-export declare const withVerification: <T>(H: Handle, fn: () => T) => T;
-declare const strictJson: typeof C.strictJson;
-export { strictJson };
-export declare const gitEnv: (extra?: NodeJS.ProcessEnv) => NodeJS.ProcessEnv;
-export declare const gitTimeout: () => number;
-export declare const checkGitTimeout: (error?: NodeJS.ErrnoException) => void;
-export declare const isRemote: (H: Handle) => boolean;
-export declare const parseKey: (value: unknown) => Key;
-export declare const setupSigned: (H: Handle, home: string, url?: string) => {
-    root: string;
-    allowedSigners: string;
-};
-export declare const sign: (H: Handle, who: string, home: string) => string[];
-export declare const rootRoster: (H: Handle) => string;
-export declare const verifyHub: (H: Handle) => {
-    head: string;
-    genesis: string;
-    commits: string[];
-} | null;
-type Raw = {
-    sha: string;
-    parents: string[];
-    author: string;
-    text: string;
-    body: Buffer;
-};
-export declare const readCommits: (H: Handle, shas: string[]) => Raw[];
-export declare const branch: (H: Handle, R: Pick<Room, 'name' | 'ref' | 'genesis'>, tip: string) => Branch;
-export declare const verifyRoom: (H: Handle, R: Room) => VerifiedRoom;
-export declare const verify: (H: Handle, R: Room, who: string, head: string) => string | null;
-export declare const heartbeatName: (ref: string) => {
-    actor: string;
-    genesis12: string;
-} | null;
-export declare const heartbeatRef: (who: string, genesis: string) => string;
-export declare const verifyHeartbeat: (H: Handle, R: Room, ref: string, sha: string) => string | null;
-export declare const makeHeartbeat: (H: Handle, R: Room, who: string, target: string, text: string, home: string) => string;
-export declare const verifySignal: (H: Handle, R: Room, ref: string, sha: string) => string | null;
-export declare const sync: (H: Handle) => Handle;
-export declare const hubAdd: ({ home, name, url, root, genesis }: {
-    home: string;
-    name: string;
-    url: string;
-    root?: string;
-    genesis?: string;
-}) => string;
-export declare const join: (H: Handle, R: Room, who: string, home: string) => {
-    publicKey: string;
-    fingerprint: string;
-    admitted: boolean;
-};
-export declare const roomAdmit: (H: Handle, R: Room, who: string, publicKey: string, home: string) => string;
-export declare const push: (H: Handle, ref: string, { behind }?: {
-    behind?: boolean;
-}) => boolean;
-export declare const pushHeartbeat: (H: Handle, R: Room, who: string, sha: string, expected: string | null) => boolean;
-export declare const forget: (H: Handle, R: Room) => void;

package/target/dts/store/kafka/index.d.ts

@@ -1,2 +0,0 @@
-import type { StoreFactory } from '../index.ts';
-export declare const kafka: StoreFactory;

package/target/dts/store/temporal/index.d.ts

@@ -1,2 +0,0 @@
-import type { StoreFactory } from '../index.ts';
-export declare const temporal: StoreFactory;

package/target/esm/app/budget.js

@@ -1,95 +0,0 @@
-// budget: proposals, reviewers' stamps, the decider's decision, and the grants it makes (decisions/1). Each operation
-// takes who acts and typed input, and returns data; interfaces print it.
-import * as D from '../domain/decisions.js';
-import { OPERATOR, locked } from '../home/index.js';
-import { append } from '../hub/index.js';
-import { fail, note, short } from '../lib/index.js';
-import { ID_RE, checkOutgoing, compose, lookup } from '../protocol/index.js';
-import { linked } from '../runtime/reader.js';
-import { isRef } from './room.js';
-import { grantView, proposalView } from './view.js';
-export const propose = ({ R, me }, x) => {
-    const { all } = linked(R, me);
-    if (!ID_RE.test(x.decider))
-        fail(`bad decider ${x.decider}`);
-    const reviewers = [...new Set(x.reviewers ?? [])].filter(r => r !== me);
-    for (const r of reviewers)
-        if (!ID_RE.test(r))
-            fail(`bad reviewer ${r}`);
-    const budget = x.budget ? D.parseBudget(x.budget) ?? fail('--budget takes runs=<n>[, run-seconds=<n>][, concurrency=<n>]') : null;
-    const sup = x.supersedes ? lookup(all, x.supersedes) : null;
-    if (sup && (sup.kind !== 'proposal' || (sup.from !== me && me !== OPERATOR)))
-        fail(`${short(sup.id)} is not your proposal`);
-    if (budget && !D.mayDecide(R.contract.authority, x.decider, me, budget))
-        note(`${x.decider} has no authority for this budget in hub ${R.hub.name}; only operator could approve it`);
-    const to = [...new Set([...reviewers, x.decider])].filter(t => t !== me);
-    const text = compose(x.text, [['To', to.join(', ') || '*'], ['Kind', 'proposal'], ['Decider', x.decider], ['Reviewers', reviewers.join(', ')],
-        ['Due', x.due && D.parseDue(x.due)], ['Budget', budget && D.budgetText(budget)], ['Supersedes', sup?.id]]);
-    const bad = D.check(checkOutgoing(text, isRef(R)), isRef(R));
-    if (bad)
-        fail(`refusing to send: ${bad}`);
-    return { id: append(R, me, text, x.files ?? []), to, budget };
-};
-const proposalAt = (all, ref) => {
-    const p = lookup(all, ref);
-    if (p.kind !== 'proposal' || p.bad)
-        fail(`${short(p.id)} is not a proposal`);
-    return p;
-};
-export const stamp = ({ R, me }, ref, s, text) => {
-    const { all } = linked(R, me);
-    const p = proposalAt(all, ref);
-    if (!D.STAMPS.includes(s))
-        fail(`usage: stamp <proposal> ${D.STAMPS.join('|')} -m <reason>`);
-    const info = D.proposalOf(all, p, R.authorityAt);
-    if (!info.reviewers.includes(me))
-        fail(`you are not a named reviewer of ${short(p.id)} (reviewers: ${info.reviewers.join(', ') || 'none'})`);
-    if (info.decision)
-        fail(`${short(p.id)} is already ${info.decision.decision}`);
-    const out = compose(text, [['To', [...new Set([p.from, info.decider])].filter(x => x !== me).join(', ') || p.from], ['Re', p.id], ['Kind', 'stamp'], ['Stamp', s], ['Hop', String(p.hopEff + 1)]]);
-    checkOutgoing(out, isRef(R));
-    return { proposal: p, id: append(R, me, out) };
-};
-// The decision names the control entry, and so the authority, it was made under (decisions/1).
-export const decide = ({ R, me }, ref, d, text) => locked(`grant-${R.hub.name}`, () => {
-    const { all } = linked(R, me);
-    const p = proposalAt(all, ref);
-    if (!D.DECISIONS.includes(d))
-        fail(`usage: decide <proposal> ${D.DECISIONS.join('|')} -m <reason>`);
-    const info = D.proposalOf(all, p, R.authorityAt);
-    if (d === 'revoked') {
-        if (info.state !== 'approved')
-            fail(`${short(p.id)} is ${info.state}; only an approval can be revoked`);
-        if (me !== info.decider && me !== OPERATOR)
-            fail(`only ${info.decider} or the operator revokes it`);
-    }
-    else {
-        if (me !== info.decider)
-            fail(`only the named decider, ${info.decider}, decides ${short(p.id)}`);
-        if (!D.mayDecide(R.contract.authority, me, p.from, info.budget))
-            fail(`${me} has no authority to decide this${info.budget ? ` budget (${D.budgetText(info.budget)})` : ''} in hub ${R.hub.name}, or it is your own proposal`);
-        if (info.decision)
-            fail(`${short(p.id)} is already ${info.decision.decision}`);
-        if (info.superseded)
-            fail(`${short(p.id)} was superseded by ${short(info.superseded.id)}; decide that revision`);
-    }
-    const to = [...new Set([p.from, ...info.reviewers])].filter(x => x !== me);
-    const out = compose(text, [['To', to.join(', ') || '*'], ['Re', p.id], ['Kind', 'decision'], ['Decision', d], ['Control', R.head], ['Hop', String(p.hopEff + 1)]]);
-    checkOutgoing(out, isRef(R));
-    const id = append(R, me, out);
-    if (d === 'approved' && info.missing.length)
-        note(`decided without stamps from ${info.missing.join(', ')}`);
-    return { proposal: p, id, budget: d === 'approved' ? info.budget : null };
-});
-// Open proposals (with `all`, every one).
-export const proposals = ({ R, me }, { all: everything = false } = {}) => {
-    const { all } = linked(R, me);
-    const ps = D.proposals(all, R.authorityAt).filter(x => everything || ['open', 'overdue'].includes(x.state));
-    return { proposals: ps, views: ps.map(proposalView) };
-};
-export const grants = ({ R, me }) => {
-    const { all } = linked(R, me);
-    return D.proposals(all, R.authorityAt).filter(x => x.grant).map(x => grantView(x, D.usageOf(all, x.grant)));
-};
-export { DECISIONS, STAMPS, budgetText } from '../domain/decisions.js';
-//# sourceMappingURL=budget.js.map

package/target/esm/app/context.js

@@ -1,16 +0,0 @@
-// context: who acts and where, as an interface asks for it (the operator in its terminal context, an agent through its
-// session's binding), and what this build is.
-import { HOME, OPERATOR, RESOURCES, VERSION, config } from '../home/index.js';
-import { CAPS, HUB_MAJOR, openHub, room as roomOf } from '../hub/index.js';
-import { bound } from '../runtime/session.js';
-// The operator, in the named hub and room, else in the terminal's current ones.
-export const operator = ({ hub, room } = {}) => {
-    const H = openHub(hub ?? config().hub);
-    const name = room ?? (hub && hub !== config().hub ? null : config().room);
-    return { R: roomOf(H, name), me: OPERATOR };
-};
-// The agent this session is bound to; refuses when it is not joined, is stopped, or its room is gone.
-export const agent = () => bound();
-export const about = () => ({ version: VERSION, home: HOME, resources: RESOURCES, contract: `${HUB_MAJOR}.x`, capabilities: [...CAPS] });
-export { config };
-//# sourceMappingURL=context.js.map