@idleware/ringi 0.6.0 → 0.7.0

package/target/esm/core/agents/turns/messages.js

@@ -1,32 +0,0 @@
-// messages: what wakes the watcher: new messages for its agent and retries of failed turns, grouped by grant and work.
-import { isOpen, taskFor, taskOf } from '../../hub/work/index.js';
-import { HIDDEN } from '../../hub/rooms/index.js';
-import { note, short } from '../../../lib/index.js';
-import { unread, wakes } from '../../hub/protocol/index.js';
-export const collectMessages = (c, R, logs, st, all) => {
-    const { msgs: fresh, cursors } = unread(logs, c.me, st.watched ?? st.seen ?? {}, Infinity, HIDDEN);
-    const retry = (st.pending ?? []).flatMap(id => {
-        const m = all.get(id);
-        if (!m)
-            return [];
-        const task = taskFor(all, m, R.profile);
-        return !task || isOpen(taskOf(all, task, R.profile), R.profile) ? [m] : [];
-    });
-    const msgs = [...new Map([...retry, ...fresh].map(m => [m.id, m])).values()];
-    const go = msgs.filter(m => wakes(m, c.me, HIDDEN) && m.hopEff < c.maxHop && (!c.allow || c.allow.has(m.from)));
-    for (const m of msgs)
-        if (!go.includes(m))
-            note(`watch: not waking for ${short(m.id)} from ${m.from} (to ${m.to.join(',')}, hop ${m.hopEff})`);
-    return { retry, cursors, go };
-};
-export const groupMessages = (R, all, go) => {
-    const groups = new Map();
-    for (const m of go) {
-        const task = taskFor(all, m, R.profile), g = task ? taskOf(all, task, R.profile).grant : null;
-        if (!groups.has(g))
-            groups.set(g, { grant: g, msgs: [], task });
-        groups.get(g).msgs.push(m);
-    }
-    return groups;
-};
-//# sourceMappingURL=messages.js.map

package/target/esm/core/agents/turns/pings.js

@@ -1,30 +0,0 @@
-// pings: the watcher answers pings for its agent without waking a model.
-import { append, pongText } from '../../hub/rooms/index.js';
-import { note, short } from '../../../lib/index.js';
-const allowed = (c, m, answered) => {
-    const ping = !m.bad && m.kind === 'ping' && m.to.includes(c.me);
-    const wake = m.hopEff < c.maxHop && (!c.allow || c.allow.has(m.from));
-    return ping && !answered.has(m.id) && wake;
-};
-const answerAuthor = (c, R, msgs, last, answered) => {
-    const at = msgs.findIndex(m => m.id === last);
-    for (const m of msgs.slice(at + 1)) {
-        if (!allowed(c, m, answered))
-            continue;
-        append(R, c.me, pongText(c.me, m, 'has a watcher'));
-        note(`watch: answered heartbeat ${short(m.id)} from ${m.from}`);
-    }
-};
-export const answerWatchPings = (c, R, logs, st) => {
-    const heartbeatSeen = { ...st.heartbeatSeen };
-    const answered = new Set((logs.get(c.me) ?? []).filter(m => m.kind === 'pong').map(m => m.reId));
-    for (const [id, msgs] of logs) {
-        if (id === c.me)
-            continue;
-        answerAuthor(c, R, msgs, heartbeatSeen[id], answered);
-        if (msgs.length)
-            heartbeatSeen[id] = msgs.at(-1).id;
-    }
-    return heartbeatSeen;
-};
-//# sourceMappingURL=pings.js.map

package/target/esm/core/agents/turns/plan.js

@@ -1,29 +0,0 @@
-// plan: one loop's turns: what arrived, grouped and reserved; planning and dispatch take locks in the order grant,
-// reader, sessions.
-import { locked } from '../../hub/ports/index.js';
-import { link } from '../../hub/protocol/index.js';
-import { loadRoomUnlocked, loadState, readerLock, saveState } from '../../hub/history/index.js';
-import { reserveGroups } from './budgets.js';
-import { collectMessages, groupMessages } from './messages.js';
-import { answerWatchPings } from './pings.js';
-const planUnlocked = (c, R) => {
-    const { logs, st } = loadRoomUnlocked(R, c.me);
-    if (st.inflight) {
-        st.seen = st.inflight.seen;
-        st.inflight = undefined;
-        saveState(R, c.me, st);
-    }
-    const all = link(logs), heartbeatSeen = answerWatchPings(c, R, logs, st);
-    const { retry, cursors, go } = collectMessages(c, R, logs, st, all);
-    const p = reserveGroups(c, R, all, groupMessages(R, all, go), st);
-    if (p.lost)
-        return { runs: [], hold: true, lost: true };
-    const pending = [...new Set([...retry.map(m => m.id), ...p.runs.flatMap(r => r.msgs.map(m => m.id))])];
-    saveState(R, c.me, {
-        ...loadState(R, c.me), heartbeatSeen, exhausted: p.exhausted, pending, runs: p.ownRuns,
-        ...(p.hold ? {} : { watched: cursors })
-    });
-    return { runs: p.runs, hold: p.hold, lost: false };
-};
-export const planTurns = (c, R) => locked(`grant-${R.hub.name}`, () => readerLock(R, c.me, () => planUnlocked(c, R)));
-//# sourceMappingURL=plan.js.map

package/target/esm/core/agents/turns/poll.js

@@ -1,48 +0,0 @@
-// poll: each loop renews the watcher's seat and finds its room still there, the same, with its agent a member.
-import { locked } from '../../hub/ports/index.js';
-import { openHub, openRoom, start } from '../../hub/rooms/index.js';
-import { stamp } from '../../../lib/index.js';
-import { dropSession, readSession, saveSession } from '../sessions/index.js';
-const refreshSeat = (c) => locked('sessions', () => {
-    const cur = readSession(c.handle);
-    if (cur?.state === 'active')
-        saveSession({ ...cur, lastSeen: stamp(), pid: process.pid });
-    return cur;
-});
-const currentRoom = (c) => {
-    const H = openHub(c.H0.name, { refresh: true }), R = openRoom(H, c.R0.name, { quiet: true });
-    if (!R || R.genesis !== c.R0.genesis) {
-        locked('sessions', () => { if (readSession(c.handle)?.genesis === c.R0.genesis)
-            dropSession(c.handle); });
-        c.log(`watch: ${c.R0.name} is gone, recreated or archived; ${c.me} left it`);
-        return null;
-    }
-    if (!R.members[c.me]) {
-        c.log(`watch: ${c.me} was removed from ${c.R0.name}; stopping`);
-        return null;
-    }
-    return R;
-};
-const quorum = (c, R) => {
-    const st = start(R);
-    if (st.started)
-        return { done: false, R };
-    if (c.w.once)
-        c.log(`watch: ${c.R0.name} waits for a quorum of ${st.quorum} agents and has ${st.agents}; nothing to do yet`);
-    return { done: !!c.w.once };
-};
-export const pollWatcher = (c) => {
-    const s = refreshSeat(c);
-    if (!s) {
-        c.log(`watch: the seat of ${c.me} was released or taken over; stopping`);
-        return { done: true };
-    }
-    if (s.state === 'stopped') {
-        if (c.w.once)
-            c.log('watch: stopped by the operator');
-        return { done: !!c.w.once };
-    }
-    const R = currentRoom(c);
-    return R ? quorum(c, R) : { done: true };
-};
-//# sourceMappingURL=poll.js.map

package/target/esm/core/agents/turns/results.js

@@ -1,40 +0,0 @@
-// results: a turn's end: its usage receipt settled, and its messages delivered or kept for a retry.
-import { OPERATOR, append } from '../../hub/rooms/index.js';
-import { note } from '../../../lib/index.js';
-import { compose } from '../../hub/protocol/index.js';
-import { loadState, readerLock, saveState } from '../../hub/history/index.js';
-import { dispatch } from './dispatch.js';
-const settle = (c, R, run, result) => append(R, c.me, compose(`usage: settle a run of ${c.me}${result.why ? ` (${result.why})` : ''}`, [['To', OPERATOR], ['Kind', 'usage'], ['Grant', run.grant], ['Usage', 'settle'], ['Run', run.run], ['Seconds', String(result.seconds)], ['Exit', String(result.exit)]]));
-const delivered = (c, R, run, r) => readerLock(R, c.me, () => {
-    const st = loadState(R, c.me), ids = new Set(run.msgs.map(m => m.id));
-    const success = r.code === 0 || r.timedOut;
-    saveState(R, c.me, {
-        ...st, inflight: undefined, ...(success
-            ? { pending: (st.pending ?? []).filter(id => !ids.has(id)) }
-            : { seen: st.inflight?.seen ?? st.seen })
-    });
-});
-const ended = (c, R, run, r) => {
-    note(`watch: exit ${r.code ?? r.signal}${r.timedOut ? ' (stopped at the grant\'s run-seconds)' : ''} after ${r.seconds}s`);
-    if (run.run)
-        settle(c, R, run, { seconds: r.seconds, exit: r.code ?? 128 });
-    delivered(c, R, run, r);
-};
-export const runTurns = async (c, R, runs) => {
-    let exitCode = 0;
-    for (const run of runs) {
-        const next = dispatch(c, R, run);
-        if (next.why) {
-            note(`watch: not starting the next turn: ${next.why}`);
-            if (run.run)
-                settle(c, R, run, { seconds: 0, exit: 125, why: `not started: ${next.why}` });
-            continue;
-        }
-        const r = await next.done;
-        ended(c, R, run, r);
-        if (r.code !== 0 || r.timedOut)
-            exitCode ||= r.code || 128;
-    }
-    return exitCode;
-};
-//# sourceMappingURL=results.js.map

package/target/esm/core/agents/turns/seat.js

@@ -1,44 +0,0 @@
-// seat: the watcher takes its agent's seat, from a dead watcher or by an explicit handoff from the agent's own chat.
-import { locked } from '../../hub/ports/index.js';
-import { config, openHub, openRoom } from '../../hub/rooms/index.js';
-import { fail, stamp } from '../../../lib/index.js';
-import { dropSession, liveness, parseSelector, pidAlive, saveSession, seatHolder, whoAmI } from '../sessions/index.js';
-import { validateWatch } from './limits.js';
-const handoff = (c, holder) => {
-    const own = c.w.handoff && holder?.product !== 'watch' && holder?.handle === whoAmI().handle;
-    if (c.w.handoff && !own)
-        fail('watch --handoff needs the invoking chat to own this seat');
-    if (own && holder.state === 'stopped')
-        fail('this chat is stopped; continue it before a handoff');
-    const live = holder && (holder.product !== 'watch' || (holder.pid && pidAlive(holder.pid)));
-    if (holder && !own && live)
-        fail(`${c.R0.name}/${c.me} is held by session ${holder.handle} (${liveness(holder)}); one seat per agent. Its chat may use watch --handoff`);
-    return !!own;
-};
-const claim = (c) => locked('sessions', () => {
-    const { w, H0, R0, me, handle } = c;
-    const holder = seatHolder(H0.name, R0.genesis, me, handle), handed = handoff(c, holder);
-    if (holder)
-        dropSession(holder.handle);
-    saveSession({
-        handle, product: 'watch', hub: H0.name, room: R0.name, genesis: R0.genesis, agent: me, scope: w.scope ?? holder?.scope ?? null,
-        state: holder?.state === 'stopped' ? 'stopped' : 'active', since: stamp(), lastSeen: stamp(), pid: process.pid,
-        takenFrom: handed ? holder.handle : holder?.takenFrom
-    });
-});
-export const createWatcher = (w, log) => {
-    validateWatch(w);
-    const sel = parseSelector(w.seat), H0 = openHub(sel.hub ?? w.hub ?? config().hub), R0 = openRoom(H0, sel.room), me = sel.agent;
-    if (R0.archived)
-        fail(`${R0.name} is archived`);
-    if (!R0.members[me])
-        fail(`${me} is not a member of ${R0.name}; the operator adds it with a join, or watch another agent`);
-    const raw = `watch-${H0.name}-${R0.genesis.slice(0, 8)}-${me}-${process.pid}`, handle = `env:${raw}`;
-    const c = {
-        w, H0, R0, me, raw, handle, cmd: w.exec, log, interval: (w.interval ?? 5) * 1000,
-        allow: w.from ? new Set(w.from) : null, maxHop: w.maxHop ?? 8, maxRuns: w.maxRuns ?? 10, span: w.window ?? 86400, runSeq: 0
-    };
-    claim(c);
-    return c;
-};
-//# sourceMappingURL=seat.js.map

package/target/esm/core/agents/turns/types.js

@@ -1,3 +0,0 @@
-// types: what the watcher's modules share: its options and context, groups of messages, runs and reservations.
-export {};
-//# sourceMappingURL=types.js.map

package/target/esm/core/hub/decisions/budget.js

@@ -1,40 +0,0 @@
-// budget: what a decision grants (a budget), until when a proposal waits (its due time), and who may decide it.
-import { fail } from '../../../lib/index.js';
-export const ROOT = 'operator';
-const BUDGET_KEYS = ['runs', 'run-seconds', 'concurrency'];
-export const ids = (v) => v === null ? [] : [...new Set(v.split(',').map(x => x.trim()).filter(Boolean))];
-const PART = /^([a-z][a-z-]*)=(\d{1,9})$/;
-// `runs=5, run-seconds=600, concurrency=1`; undefined if malformed. `runs` is required: a budget without a run count
-// bounds nothing; a zero run time or concurrency would disable the bound it names.
-export const parseBudget = (s) => {
-    if (s === null || s === undefined)
-        return null;
-    const b = {};
-    for (const part of String(s).split(',').map(x => x.trim()).filter(Boolean)) {
-        const m = PART.exec(part);
-        if (!m || !BUDGET_KEYS.includes(m[1]) || m[1] in b)
-            return undefined;
-        b[m[1]] = Number(m[2]);
-    }
-    return bounded(b) ? { 'run-seconds': 1800, concurrency: 1, ...b } : undefined;
-};
-const bounded = (b) => 'runs' in b && b['run-seconds'] !== 0 && b.concurrency !== 0;
-export const budgetText = (b) => BUDGET_KEYS.map(k => `${k}=${b[k]}`).join(', ');
-const UNIT = { m: 60e3, h: 3600e3, d: 86400e3 };
-// Relative (`90m`, `2h`, `3d`) or an ISO 8601 time → ISO UTC to the second.
-export const parseDue = (s) => {
-    const rel = /^(\d{1,6})([mhd])$/.exec(s);
-    const t = rel ? Date.now() + Number(rel[1]) * UNIT[rel[2]] : Date.parse(s);
-    if (!Number.isFinite(t))
-        fail(`--due takes 90m, 2h, 3d or an ISO time, not ${s}`);
-    return new Date(t).toISOString().slice(0, 19) + 'Z';
-};
-const within = (cap, budget) => BUDGET_KEYS.every(k => Number.isFinite(cap[k]) && budget[k] <= cap[k]);
-// The root always may; anyone else only within the authority table, and never on their own proposal.
-export const mayDecide = (authority, decider, proposer, budget) => {
-    if (decider === ROOT)
-        return true;
-    const cap = decider === proposer ? undefined : authority?.decide?.[decider];
-    return !!cap && (!budget || within(cap, budget));
-};
-//# sourceMappingURL=budget.js.map

package/target/esm/core/hub/decisions/check.js

@@ -1,43 +0,0 @@
-// check: the extension's trailers are part of a record's validity; a malformed decision record routes nowhere.
-import { ID_RE, one } from '../protocol/index.js';
-import { ids, parseBudget } from './budget.js';
-export const STAMPS = ['approve', 'object', 'abstain'];
-export const DECISIONS = ['approved', 'rejected', 'revoked'];
-const SINGLE = ['decider', 'reviewers', 'due', 'budget', 'supersedes', 'stamp', 'decision', 'control', 'grant', 'usage', 'run', 'seconds', 'exit'];
-const RUN = /^[A-Za-z0-9._:-]{1,128}$/;
-// A trailer absent, or a message id.
-const refOk = (m, k, isRef) => one(m, k) === null || isRef(one(m, k));
-const answers = (m, values, k) => !!m.re && values.includes(one(m, k) ?? '');
-const receipt = (m, isRef) => isRef(one(m, 'grant') ?? '') && ['reserve', 'settle'].includes(one(m, 'usage') ?? '') && RUN.test(one(m, 'run') ?? '');
-const dueOk = (v) => v === null || Number.isFinite(Date.parse(v));
-// What each kind of record must carry, as (wrong, why) in the order the reasons are reported.
-const BY_KIND = {
-    proposal: (m, isRef) => [
-        [() => !ID_RE.test(one(m, 'decider') ?? ''), 'proposal without a valid Decider'],
-        [() => !ids(one(m, 'reviewers')).every(x => ID_RE.test(x)), 'malformed Reviewers'],
-        [() => !dueOk(one(m, 'due')), 'malformed Due'],
-        [() => !refOk(m, 'supersedes', isRef), 'malformed Supersedes'],
-    ],
-    stamp: m => [[() => !answers(m, STAMPS, 'stamp'), 'stamp without Re or a valid Stamp']],
-    decision: m => [[() => !answers(m, DECISIONS, 'decision'), 'decision without Re or a valid Decision']],
-    usage: (m, isRef) => [
-        [() => !receipt(m, isRef), 'malformed usage receipt'],
-        [() => one(m, 'usage') === 'settle' && !/^\d{1,9}$/.test(one(m, 'seconds') ?? ''), 'usage settle without Seconds'],
-    ],
-};
-// Why a record is malformed for this extension, or null.
-export const check = (m, isRef) => {
-    if (m.bad)
-        return null;
-    const twice = SINGLE.find(k => (m.trailers[k]?.length ?? 0) > 1);
-    if (twice)
-        return `duplicate ${twice}`;
-    const rules = [
-        [() => !refOk(m, 'grant', isRef), 'malformed Grant'],
-        [() => !refOk(m, 'control', isRef), 'malformed Control'],
-        [() => one(m, 'budget') !== null && !parseBudget(one(m, 'budget')), 'malformed Budget'],
-        ...BY_KIND[m.kind ?? '']?.(m, isRef) ?? [],
-    ];
-    return rules.find(([wrong]) => wrong())?.[1] ?? null;
-};
-//# sourceMappingURL=check.js.map

package/target/esm/core/hub/decisions/index.js

@@ -1,10 +0,0 @@
-// decide: the extension for decisions and budgets (capability `decisions/1`, docs/spec/decisions-1.md). A proposal circulates
-// to named reviewers, who stamp it; only the named decider, holding authority from the hub's contract, decides. An
-// approval that carries a budget is a grant; work spends against it, and the runner that starts model runs writes
-// the usage receipts. Everything here is a pure fold over messages; nothing trusts a model's own report.
-export const CAPABILITY = 'decisions/1';
-export * from './budget.js';
-export * from './check.js';
-export * from './proposal.js';
-export * from './usage.js';
-//# sourceMappingURL=index.js.map

package/target/esm/core/hub/decisions/proposal.js

@@ -1,73 +0,0 @@
-// proposal: one proposal folded over the messages that answer it, in thread order: its stamps, its decision, a
-// revocation, a superseding revision; and the grant an approval with a budget makes.
-import { one, ordered } from '../protocol/index.js';
-import { ROOT, ids, mayDecide, parseBudget } from './budget.js';
-const byOwner = (m, p) => m.from === p.from || m.from === ROOT;
-// A revision supersedes only when its author is the proposer or the root.
-const revises = (m, p) => m.kind === 'proposal' && one(m, 'supersedes') === p.id && byOwner(m, p);
-const answers = (m, p) => m.reId === p.id && (m.kind === 'stamp' || m.kind === 'decision');
-const among = (all, keep) => ordered([...all.values()].filter(m => !m.bad && keep(m)));
-// A decision names the room's control commit it was made under (`Control`); its authority is the table in effect
-// there. A commit that does not exist yet cannot be named, so a later contract never promotes or demotes a decision.
-const authorized = (c, m) => {
-    if (m.from === ROOT)
-        return true;
-    const table = c.authorityAt(one(m, 'control'));
-    return !!table && mayDecide(table, c.decider, c.p.from, c.budget);
-};
-const decides = (c, m) => one(m, 'decision') !== 'revoked' && m.from === c.decider && authorized(c, m);
-const revokes = (c, m) => one(m, 'decision') === 'revoked' && (m.from === c.decider || m.from === ROOT);
-const approved = (f) => f.decision?.decision === 'approved';
-// One answer applied: a reviewer's latest stamp counts (its position relative to the decision is only a same-second
-// tie); the first decision of the decider with authority; then the first revocation of an approval.
-const take = (c, f, m) => {
-    if (m.kind === 'stamp' && c.reviewers.includes(m.from))
-        f.stamps[m.from] = { stamp: one(m, 'stamp'), id: m.id, reason: m.subject };
-    if (m.kind !== 'decision')
-        return;
-    if (!f.decision && decides(c, m))
-        f.decision = { decision: one(m, 'decision'), id: m.id, by: m.from, time: m.time };
-    else if (approved(f) && !f.revoked && revokes(c, m))
-        f.revoked = { id: m.id, by: m.from, time: m.time };
-};
-// The answers in thread order; one after the superseding revision no longer applies to this revision, except a
-// revocation of an earlier approval.
-const fold = (c, list, superseded) => {
-    const f = { stamps: {}, decision: null, revoked: null };
-    for (const m of ordered([...list, ...(superseded ? [superseded] : [])])) {
-        if (m === superseded)
-            break;
-        take(c, f, m);
-    }
-    const late = superseded && approved(f) && !f.revoked ? list.find(m => revokes(c, m)) : undefined;
-    if (late)
-        f.revoked = { id: late.id, by: late.from, time: late.time };
-    return f;
-};
-const stateOf = (f, superseded, due, now) => {
-    if (f.revoked)
-        return 'revoked';
-    if (f.decision)
-        return f.decision.decision;
-    if (superseded)
-        return 'superseded';
-    return due && now > due ? 'overdue' : 'open';
-};
-export const proposalOf = (all, p, authorityAt, now = Date.now() / 1000) => {
-    const c = { p, decider: one(p, 'decider'), reviewers: ids(one(p, 'reviewers')), budget: parseBudget(one(p, 'budget')) ?? null, authorityAt };
-    const due = one(p, 'due') ? Date.parse(one(p, 'due')) / 1000 : null;
-    const superseded = among(all, m => revises(m, p))[0] ?? null;
-    const f = fold(c, among(all, m => answers(m, p)), superseded);
-    const grant = approved(f) && c.budget ? { id: f.decision.id, budget: c.budget, proposal: p, revoked: !!f.revoked } : null;
-    return { proposal: p, decider: c.decider, reviewers: c.reviewers, budget: c.budget, due, ...f,
-        missing: c.reviewers.filter(r => !f.stamps[r]), superseded, state: stateOf(f, superseded, due, now), grant };
-};
-export const proposals = (all, authorityAt) => [...all.values()].filter(m => !m.bad && m.kind === 'proposal').map(p => proposalOf(all, p, authorityAt));
-const decision = (d) => !!d && !d.bad && d.kind === 'decision';
-export const grantOf = (all, authorityAt, id) => {
-    const d = all.get(id);
-    const p = decision(d) && d.reId ? all.get(d.reId) : undefined;
-    const g = p ? proposalOf(all, p, authorityAt).grant : null;
-    return g?.id === id ? g : null;
-};
-//# sourceMappingURL=proposal.js.map

package/target/esm/core/hub/decisions/usage.js

@@ -1,39 +0,0 @@
-// usage: what a grant's runs spent, from the usage receipts the runners write.
-import { one, ordered } from '../protocol/index.js';
-import { grantOf } from './proposal.js';
-// The receipts a grant's ledger counts, in thread order: every reservation, and for each run (its runner and Run id)
-// the first settlement after its reservation, as the first decision counts. A settlement of no reserved run counts
-// nothing.
-const ledger = (all, grant) => {
-    const reserves = [], settled = new Map(), reserved = new Set();
-    for (const m of ordered([...all.values()].filter(m => !m.bad && m.kind === 'usage' && one(m, 'grant') === grant.id))) {
-        const run = `${m.from}/${one(m, 'run')}`;
-        if (one(m, 'usage') === 'reserve') {
-            reserves.push(m);
-            reserved.add(run);
-        }
-        else if (reserved.has(run) && !settled.has(run))
-            settled.set(run, m);
-    }
-    return { reserves, settled };
-};
-// Whether a receipt counts: its Grant names a grant, and that grant's ledger holds it.
-export const counted = (all, authorityAt, m) => {
-    const g = !m.bad && m.kind === 'usage' ? grantOf(all, authorityAt, one(m, 'grant') ?? '') : null;
-    if (!g)
-        return false;
-    const { reserves, settled } = ledger(all, g);
-    return reserves.includes(m) || [...settled.values()].includes(m);
-};
-// Usage from the runners' receipts: every reservation is a run, settled or not; an unsettled one is open while its
-// run could still be going, and uncertain after that.
-export const usageOf = (all, grant, now = Date.now() / 1000) => {
-    const { reserves, settled } = ledger(all, grant);
-    let seconds = 0;
-    for (const m of settled.values())
-        seconds += Number(one(m, 'seconds'));
-    const unsettled = reserves.filter(m => !settled.has(`${m.from}/${one(m, 'run')}`));
-    const open = unsettled.filter(m => now - m.time <= grant.budget['run-seconds'] + 60);
-    return { runs: reserves.length, open: open.length, uncertain: unsettled.length - open.length, seconds, left: Math.max(0, grant.budget.runs - reserves.length) };
-};
-//# sourceMappingURL=usage.js.map

package/target/esm/core/hub/usecases/budget.js

@@ -1,78 +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 '../decisions/index.js';
-import { locked } from '../ports/index.js';
-import { OPERATOR, append } from '../rooms/index.js';
-import { fail, note, short } from '../../../lib/index.js';
-import { checkOutgoing, compose, lookup } from '../protocol/index.js';
-import { linked } from '../history/index.js';
-import { isRef } from './actor.js';
-import { grantView, proposalView } from './view.js';
-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) };
-};
-// Why the actor may not revoke the proposal's approval: only its decider or the operator revokes, and only an approval.
-const revokeProblem = (info, p, me) => {
-    if (info.state !== 'approved')
-        return `${short(p.id)} is ${info.state}; only an approval can be revoked`;
-    return me !== info.decider && me !== OPERATOR ? `only ${info.decider} or the operator revokes it` : null;
-};
-// Why the actor may not decide the proposal: only its named decider with authority, once, on its latest revision.
-const decideProblem = ({ R, me }, info, p) => {
-    if (me !== info.decider)
-        return `only the named decider, ${info.decider}, decides ${short(p.id)}`;
-    if (!D.mayDecide(R.contract.authority, me, p.from, info.budget))
-        return `${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)
-        return `${short(p.id)} is already ${info.decision.decision}`;
-    return info.superseded ? `${short(p.id)} was superseded by ${short(info.superseded.id)}; decide that revision` : null;
-};
-// 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);
-    const why = d === 'revoked' ? revokeProblem(info, p, me) : decideProblem({ R, me }, info, p);
-    if (why)
-        fail(why);
-    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);
-    const approved = d === 'approved';
-    if (approved && info.missing.length)
-        note(`decided without stamps from ${info.missing.join(', ')}`);
-    return { proposal: p, id, budget: 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 { propose } from './propose.js';
-export { DECISIONS, STAMPS, budgetText } from '../decisions/index.js';
-//# sourceMappingURL=budget.js.map

package/target/esm/core/hub/usecases/propose.js

@@ -1,39 +0,0 @@
-// propose: a proposal for the decider and its reviewers, its budget and revision checked before it is written
-// (decisions/1).
-import * as D from '../decisions/index.js';
-import { OPERATOR, append } from '../rooms/index.js';
-import { fail, note, short } from '../../../lib/index.js';
-import { ID_RE, checkOutgoing, compose, lookup } from '../protocol/index.js';
-import { linked } from '../history/index.js';
-import { isRef } from './actor.js';
-// Named reviewers, the proposer never among them.
-const reviewersOf = (me, x) => {
-    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}`);
-    return reviewers;
-};
-const budgetOf = (x) => x.budget ? D.parseBudget(x.budget) ?? fail('--budget takes runs=<n>[, run-seconds=<n>][, concurrency=<n>]') : null;
-// A revision supersedes the actor's own proposal; the operator may revise anyone's.
-const supersededOf = (all, me, ref) => {
-    const sup = ref ? lookup(all, ref) : null;
-    const mine = sup?.kind === 'proposal' && (sup.from === me || me === OPERATOR);
-    return !sup || mine ? sup : fail(`${short(sup.id)} is not your proposal`);
-};
-export const propose = ({ R, me }, x) => {
-    const { all } = linked(R, me);
-    const reviewers = reviewersOf(me, x), budget = budgetOf(x), sup = supersededOf(all, me, x.supersedes);
-    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 };
-};
-//# sourceMappingURL=propose.js.map