@idleware/ringi 0.6.1 → 0.7.1

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