@idleware/ringi 0.7.1 → 0.8.0

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

@@ -1,15 +1,20 @@
-// rooms: the operator's rooms in a hub: list, create, switch, admit and remove members, delete, move to a
-// newer contract, and accept a new baseline for a log after reviewing an alarm.
+// rooms: the rooms on this machine, each named uniquely whatever hub keeps it: list, create, switch, admit a member,
+// delete, and accept a new baseline for a log after reviewing an alarm.
 import crypto from 'node:crypto';
 import { DEFAULT_PROFILE, parseProfile } from '../work/index.js';
-import { hubPorts, locked } from '../ports/index.js';
-import { OPERATOR, RESERVED_ROOMS, ROOM_MD, config, controlChange, profileText, room as roomOf, roomNames, setConfig } from '../rooms/index.js';
+import { hubPorts } from '../ports/index.js';
+import { OPERATOR, RESERVED_ROOMS, ROOM_MD, config, createRoom, deleteRoom, hubNames, openContract, openHub, profileText, room as roomOf, roomNames, setConfig } from '../rooms/index.js';
 import { Fail, fail, note } from '../../../lib/index.js';
+import { invite } from './invite.js';
 import { ID_RE, compose } from '../protocol/index.js';
-import { notSigned } from './roster.js';
-export { admit, forgetLog, remove } from './roster.js';
-// The operator's terminal context picks the room unless one is named.
-export const roomIn = (H, name) => roomOf(H, name ?? config().room);
+export { admit, forgetLog } from './roster.js';
+// A room by its name, unique on this machine whatever hub keeps it; without one, the terminal's current room.
+export const roomNamed = (name) => {
+    hubPorts().state.ensure();
+    const n = name ?? config().room ?? fail('no current room: ringi room create <id> | ringi room switch <id>');
+    const hub = hubNames().find(h => roomNames(openHub(h)).includes(n)) ?? fail(`no room ${n} on this machine`);
+    return roomOf(openHub(hub), n);
+};
 // A room the store offers but that does not open (a history under another name) is an alarm, not a row.
 const opens = (H, n) => {
     try {
@@ -22,47 +27,47 @@ const opens = (H, n) => {
         return null;
     }
 };
-export const rooms = (H) => {
+export const rooms = () => {
+    hubPorts().state.ensure();
     const cur = config().room;
-    const view = (n, R) => ({ name: n, current: n === cur, members: Object.keys(R.members).length, profile: R.profile.name, genesis: R.genesis });
-    return roomNames(H).flatMap(n => { const R = opens(H, n); return R ? [view(n, R)] : []; });
+    const view = (H, n, R) => ({ name: n, hub: H.name, current: n === cur, members: Object.keys(R.members).length, profile: R.profile.name, genesis: R.genesis });
+    return hubNames().map(h => openHub(h)).flatMap(H => roomNames(H).flatMap(n => { const R = opens(H, n); return R ? [view(H, n, R)] : []; }));
 };
 // A room carries its profile from the start: later changes to the hub's profiles do not reach it.
 // `quorum`: the room's work starts by itself once it has that many agents; until then a join waits.
-export const create = (H, name, { profile, quorum } = {}) => {
+// `url`: a signed hub publishes the room's repository there; the result says how an agent elsewhere joins it.
+export const create = (H, name, { profile, quorum, url } = {}) => {
     if (!ID_RE.test(name) || RESERVED_ROOMS.has(name))
         fail(`usage: ringi room create <id> [--profile <name>] [--quorum <agents>] (an id like fix-badge; not ${[...RESERVED_ROOMS].join(', ')})`);
     if (quorum !== undefined && !(Number.isSafeInteger(quorum) && quorum >= 1 && quorum <= 99))
         fail('--quorum takes a number of agents, 1 to 99');
-    const p = profile ?? H.contract.profile ?? DEFAULT_PROFILE;
+    const contract = openContract(H);
+    const p = profile ?? contract.contract.profile ?? DEFAULT_PROFILE;
     const text = profileText(H, p) ?? fail(`hub ${H.name} carries no profile ${p}; add it with ringi hub amend -m "<why>" --attach <file>:profiles/${p}.json`);
     parseProfile(text, `profile ${p}`);
-    locked(`hub-${H.name}`, () => {
-        const files = { 'ROOM.md': ROOM_MD(name), 'members.json': JSON.stringify({ [OPERATOR]: { role: 'root' } }, null, 2) + '\n', 'profile.json': text };
-        // A signed room's roster: who may sign its logs, starting with the root.
-        if (H.signed)
-            files.allowed_signers = H.store.rootRoster?.() ?? fail(`hub ${H.name}: its store cannot start a signed roster`);
-        // The genesis names the room; a random id makes it unique, so a room deleted and created again is a different room.
-        H.store.createRoom(name, OPERATOR, compose(`room ${name}`, [['To', '*'], ['Kind', 'room'], ['Room-Id', crypto.randomBytes(16).toString('hex')],
-            ...(quorum ? [['Quorum', String(quorum)]] : [])]), files);
-    });
-    setConfig({ hub: H.name, room: name });
-    return { profile: p };
+    const files = { 'ROOM.md': ROOM_MD(name), 'members.json': JSON.stringify({ [OPERATOR]: { role: 'root' } }, null, 2) + '\n', 'profile.json': text };
+    // A signed room's roster: who may sign its logs, starting with the root.
+    if (H.signed)
+        files.allowed_signers = contract.store.rootRoster?.() ?? fail(`hub ${H.name}: its store cannot start a signed roster`);
+    // The genesis names the room; a random id makes it unique, so a room deleted and created again is a different room.
+    const genesis = compose(`room ${name}`, [['To', '*'], ['Kind', 'room'], ['Room-Id', crypto.randomBytes(16).toString('hex')],
+        ...(quorum ? [['Quorum', String(quorum)]] : [])]);
+    const R = createRoom(H, name, { who: OPERATOR, text: genesis, files, remote: url });
+    setConfig({ room: name });
+    const line = invite(R);
+    return { profile: p, join: line ? `ringi join ${line} --as <agent>` : null };
 };
-export const use = (H, name) => {
-    const R = roomOf(H, name);
-    setConfig({ hub: H.name, room: R.name });
+export const use = (name) => {
+    const R = roomNamed(name);
+    setConfig({ room: R.name });
     return R;
 };
-// The room and everything kept for it: in the store (deleteRoom) and its readers' state. The sessions bound to it,
-// on this machine or another, leave it on their own when they find its branch gone (core/agents/sessions).
-export const erase = (H, R) => {
-    notSigned(H, 'delete');
-    locked(`hub-${H.name}`, () => H.store.deleteRoom(R.s));
-    hubPorts().state.remove(['readers', H.name, R.genesis]);
+// The room's store on this machine and everything kept for it: its endpoint and its readers' state. Sessions bound to
+// it, here or elsewhere, leave it on their own when they find it gone (core/agents/sessions); a forge's copy is the
+// access adapter's to delete.
+export const erase = (R) => {
+    deleteRoom(R);
     if (config().room === R.name)
         setConfig({ room: null });
 };
-// The room follows the hub's current contract from now on; nothing written before is reinterpreted.
-export const rebase = (H, R) => controlChange(R, OPERATOR, `contract ${H.contract.version}`, () => { }, [['Contract', H.main]]);
 //# sourceMappingURL=rooms.js.map

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

@@ -1,27 +1,18 @@
-// roster: who belongs to a room and whose history its readers accept: admit a signed member, remove one, and accept a
-// new baseline for a log after an alarm.
+// roster: who belongs to a room and whose history its readers accept: admit a signed member, and accept a new
+// baseline for a log after an alarm.
 import { hubPorts, locked } from '../ports/index.js';
-import { OPERATOR, controlChange } from '../rooms/index.js';
+import { OPERATOR } from '../rooms/index.js';
 import { fail } from '../../../lib/index.js';
 import { AGENT_RE, ID_RE } from '../protocol/index.js';
 import { loadState, readerLock, saveState } from '../history/index.js';
-// Removing or deleting in a signed hub needs revocation published to every replica: not in this version.
-export const notSigned = (H, what) => { if (H.signed)
-    fail(`room ${what} is not supported on signed hubs yet: a local change would come back with the next fetch`); };
+// An agent's id in a room: `operator` is the root, `main` and `chat` name a room's own branches (hub-2).
+const RESERVED = new Set([OPERATOR, 'main', 'chat']);
+export const agentId = (who) => AGENT_RE.test(who) && !RESERVED.has(who) ? who : fail(`bad agent id ${who}: lowercase letters, digits, - and _, no dot; not ${[...RESERVED].join(', ')}`);
 export const admit = (H, R, who, key) => {
-    if (!H.signed || !H.store.admit)
+    if (!H.signed || !R.store.admit)
         fail('room admit is for signed hubs; on a local hub the operator\'s join adds members');
-    if (!AGENT_RE.test(who))
-        fail(`bad agent id ${who}: lowercase letters, digits, - and _, no dot`);
-    locked(`hub-${H.name}`, () => H.store.admit(R.s, who, key));
-};
-export const remove = (H, R, who) => {
-    notSigned(H, 'remove');
-    if (!R.members[who])
-        fail(`${who} is not a member of ${R.name}`);
-    if (who === OPERATOR)
-        fail('the operator stays in every room');
-    controlChange(R, OPERATOR, `remove ${who}`, m => { delete m[who]; });
+    agentId(who);
+    locked(`hub-${H.name}`, () => R.store.admit(R.s, who, key));
 };
 // One reader forgets the log's accepted head and the alarms about it; whether it had accepted any.
 const forgetIn = (R, reader, id) => readerLock(R, reader, () => {
@@ -32,7 +23,7 @@ const forgetIn = (R, reader, id) => readerLock(R, reader, () => {
         st.alarms = (st.alarms ?? []).filter(a => !a.startsWith(`log ${id} `) && !a.startsWith(`log ${id}:`));
         saveState(R, reader, st);
     }
-    R.hub.store.unpin(R.s, reader, id);
+    R.store.unpin(R.s, reader, id);
     return had;
 });
 // The operator accepts a new baseline for one log, for every reader of the room, after reviewing an alarm. A signed
@@ -41,7 +32,7 @@ export const forgetLog = (H, R, id) => {
     if (!ID_RE.test(id))
         fail('usage: ringi forget <room>/<log>');
     if (H.signed)
-        H.store.forgetLog?.(R.s, id);
-    return hubPorts().state.list(['readers', H.name, R.genesis]).filter(reader => forgetIn(R, reader, id)).length;
+        R.store.forgetLog?.(R.s, id);
+    return hubPorts().state.list(['readers', H.d.genesis, R.genesis]).filter(reader => forgetIn(R, reader, id)).length;
 };
 //# sourceMappingURL=roster.js.map

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

@@ -1,10 +1,11 @@
 // send: a message from the actor, its recipients, trailers and files checked before it is written.
 import { OPERATOR, append } from '../rooms/index.js';
+import fs from 'node:fs';
 import { fail, note } from '../../../lib/index.js';
+import { checkCollisions } from '../protocol/files.js';
 import { ID_RE, TOKEN_RE, checkOutgoing, compose, lookup } from '../protocol/index.js';
-import { linked, readerLock } from '../history/index.js';
+import { linked } from '../history/index.js';
 import { isRef } from './actor.js';
-import { outgoing, shrink, staged } from './staging.js';
 // A reply without `to` goes back to the sender (with `all`, to everyone the message named); one's own, to its recipients.
 const replyTo = (me, x, re) => {
     if (!x.reply || !re)
@@ -43,6 +44,8 @@ const checkTrailers = (P, x, to, assign, re) => {
     if (x.roles && !x.roles.split(',').every(role))
         fail('--roles takes "<id>=<label>, …"; labels mean what the room profile says');
 };
+const FILE_MAX = 64 << 20;
+const tooBig = (path, size) => size > FILE_MAX && fail(`${path} is ${Math.ceil(size / (1 << 20))} MiB; an attachment is at most ${FILE_MAX >> 20} MiB`);
 // A message from the actor. The operator may omit `to`: the room, or the assignees when there are any.
 export const send = ({ R, me }, x) => {
     const P = R.profile;
@@ -51,16 +54,17 @@ export const send = ({ R, me }, x) => {
     const assign = x.assign ? [...new Set(x.assign)] : null;
     const to = recipients(me, x, re, assign);
     checkTrailers(P, x, to, assign, re);
-    const stagedNow = staged({ R, me });
-    const entries = outgoing(stagedNow, x.files ?? []);
+    const entries = x.files ?? [];
+    for (const e of entries)
+        if (e.file)
+            tooBig(e.path, fs.statSync(e.file).size);
+    checkCollisions(entries.map(e => e.path));
     const text = compose(x.text, [
         ['To', to.join(', ')], ['Re', re?.id], ['Kind', x.task && P.opens], ['State', x.state], ['Assign', assign?.join(', ')],
         ['Roles', x.roles], ['Hop', re && String(re.hopEff + 1)],
     ]);
     checkOutgoing(text, isRef(R));
     const id = append(R, me, text, entries);
-    if (stagedNow.length)
-        readerLock(R, me, () => shrink({ R, me }, s => !stagedNow.some(t => t.path === s.path && t.blob === s.blob)));
     if (to.length === 1 && to[0] === '*')
         note(`addressed to the whole room: this ${x.task ? P.opens : 'message'} wakes nobody; name recipients (--to or --assign) to start work`);
     return { id, to, files: entries.length };

package/target/esm/core/hub/work/parse.js

@@ -3,7 +3,7 @@ import { ID_RE, TOKEN_RE } from '../protocol/index.js';
 import { fail, strictJson } from '../../../lib/index.js';
 import { PROFILE_SCHEMA } from './index.js';
 const PRINCIPAL_RE = /^(?:requester|assignee|member|role:[a-z][a-z0-9-]*|agent:[a-z0-9]+(?:[._-][a-z0-9]+)*)$/;
-const RULE_RE = /^(?:assign|roles|grant|state:(?:\*|[a-z][a-z0-9-]*))$/;
+const RULE_RE = /^(?:assign|roles|state:(?:\*|[a-z][a-z0-9-]*))$/;
 const distinctTokens = (xs) => Array.isArray(xs) && xs.length > 0 && xs.every(s => TOKEN_RE.test(s)) && new Set(xs).size === xs.length;
 const principals = (v) => Array.isArray(v) && v.length <= 64 && v.every(x => PRINCIPAL_RE.test(x));
 const waitingOk = (p) => p.waiting === undefined || (p.states.includes(p.waiting) && !p.terminal.includes(p.waiting));

package/target/esm/lib/fail.js

@@ -1,7 +1,12 @@
 // fail: a refusal ringi explains (Fail, shown as its message), apart from a bug (any other error, shown with its stack).
+// A URL's credentials never shown, however git or a person wrote them: everything before its host goes, up to the last
+// `@` (a token may be the whole user, or hold an `@`), except an SSH login name (ssh://, git+ssh://), which is no secret.
+const USERINFO = /\b([a-z][a-z0-9+.-]*:\/\/)([^\s/?#'"]*)@/gi;
+export const withoutCredentials = (text) => text.replace(USERINFO, (_, scheme, user) => /(?:^|\+)ssh:/i.test(scheme) && !user.includes(':') ? `${scheme}${user}@` : scheme);
 export class Fail extends Error {
 }
-export const fail = (msg) => { throw new Fail(msg); };
+// Every refusal passes here, git's own diagnostics included, so none shows a URL's credentials.
+export const fail = (msg) => { throw new Fail(withoutCredentials(msg)); };
 export const errno = (e) => e?.code;
 // A write the host refused: what to do is the same for every host; a tool's own way (its sandbox settings) is added
 // by the interface that knows the tools (cli.ts).

package/target/esm/lib/index.js

@@ -1,7 +1,8 @@
 // lib: helpers that know nothing of ringi and touch no host: failing (fail.ts), notes, formatting, strict JSON
 // (json.ts). Files and locks are the adapters' (adapters/fs).
-// Notes and alarms go where the program sends them (composition/: stderr). Those written before it says where wait
-// for it, so none is lost to the order modules load in.
+import { withoutCredentials } from './fail.js';
+// Notes and alarms go where the program sends them (composition/: stderr), never with a URL's credentials. Those
+// written before it says where wait for it, so none is lost to the order modules load in.
 const notes = [];
 let sink = null;
 export const notesTo = (fn) => {
@@ -10,7 +11,7 @@ export const notesTo = (fn) => {
         fn(line);
 };
 export const note = (s) => {
-    const line = `ringi: ${s}\n`;
+    const line = `ringi: ${withoutCredentials(s)}\n`;
     if (sink)
         sink(line);
     else

package/target/dts/adapters/transport-git/marks.d.ts

@@ -1,20 +0,0 @@
-import { Branches } from './branches.ts';
-import type { SignalRecord, StoredRoom } from '../../core/hub/ports/store.ts';
-export declare class Marks extends Branches {
-    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;
-    protected tags(): import("./tags.ts").TagRef[];
-    protected tagObjects(shas: string[]): Map<string, {
-        target: string;
-        tagger: string;
-        time: number;
-        text: string;
-    }>;
-    signals(room: StoredRoom): SignalRecord[];
-}

package/target/dts/adapters/transport-git/remote/bootstrap.d.ts

@@ -1,7 +0,0 @@
-export declare const hubAdd: ({ home, name, url, root, genesis }: {
-    home: string;
-    name: string;
-    url: string;
-    root?: string;
-    genesis?: string;
-}) => string;

package/target/dts/adapters/transport-git/remote/heartbeat-name.d.ts

@@ -1,6 +0,0 @@
-export declare const HEARTBEAT_NAME: RegExp;
-export declare const heartbeatName: (ref: string) => {
-    actor: string;
-    genesis12: string;
-} | null;
-export declare const heartbeatRef: (who: string, genesis: string) => string;

package/target/dts/adapters/transport-git/remote/heartbeat-object.d.ts

@@ -1,10 +0,0 @@
-import type { Handle, Room } from './types.ts';
-export declare const heartbeatObject: (H: Handle, ref: string, sha: string) => {
-    actor: string;
-    genesis12: string;
-    genesis: string;
-    target: string;
-    time: number;
-    text: string;
-};
-export declare const checkHeartbeat: (H: Handle, R: Room, ref: string, sha: string) => void;

package/target/dts/adapters/transport-git/remote/heartbeat-push.d.ts

@@ -1,2 +0,0 @@
-import type { Handle, Room } from './types.ts';
-export declare const pushHeartbeat: (H: Handle, R: Room, who: string, sha: string, expected: string | null) => boolean;

package/target/dts/adapters/transport-git/remote/heartbeat.d.ts

@@ -1,7 +0,0 @@
-import type { Handle, Room } from './types.ts';
-export { checkHeartbeat, heartbeatObject } from './heartbeat-object.ts';
-export { heartbeatBody } from './heartbeat-facts.ts';
-export { HEARTBEAT_NAME, heartbeatName, heartbeatRef } from './heartbeat-name.ts';
-export declare const verifyHeartbeat: (H: Handle, R: Room, ref: string, sha: string) => string | null;
-type HeartbeatArgs = [H: Handle, R: Room, who: string, target: string, text: string];
-export declare const makeHeartbeat: (...[H, R, who, target, text]: HeartbeatArgs) => string;

package/target/dts/adapters/transport-git/remote/signals.d.ts

@@ -1,15 +0,0 @@
-import type { Handle, Room } from './types.ts';
-export declare const SIGNAL_NAME: RegExp;
-export declare const signalName: (ref: string) => {
-    actor: string;
-    id: string;
-    signal: string;
-};
-export declare const signalObject: (H: Handle, ref: string, sha: string) => {
-    actor: string;
-    id: string;
-    signal: string;
-    message: string;
-};
-export declare const checkSignal: (H: Handle, R: Room, ref: string, sha: string) => void;
-export declare const verifySignal: (H: Handle, R: Room, ref: string, sha: string) => string | null;

package/target/dts/adapters/transport-git/remote/sync-heartbeat.d.ts

@@ -1,2 +0,0 @@
-import type { TagSync } from './sync-tags.ts';
-export declare const syncHeartbeat: ({ H, tags, pinned, byGenesis }: TagSync, name: string) => void;

package/target/dts/adapters/transport-git/remote/sync-rooms.d.ts

@@ -1,6 +0,0 @@
-import type { Handle, Room } from './types.ts';
-export type RoomsIndex = {
-    byGenesis: Map<string, Room>;
-    byTarget: Map<string, Room>;
-};
-export declare const syncRooms: (H: Handle, fetched: Map<string, string>) => RoomsIndex;

package/target/dts/adapters/transport-git/remote/sync-tags.d.ts

@@ -1,8 +0,0 @@
-import type { Handle } from './types.ts';
-import type { RoomsIndex } from './sync-rooms.ts';
-export type TagSync = RoomsIndex & {
-    H: Handle;
-    tags: Map<string, string>;
-    pinned: Map<string, string>;
-};
-export declare const syncTags: (H: Handle, rooms: RoomsIndex) => void;

package/target/dts/adapters/transport-git/tags.d.ts

@@ -1,15 +0,0 @@
-export type TagRef = {
-    ref: string;
-    actor: string;
-    name: string;
-    object: string;
-    type: string;
-};
-export type TagObject = {
-    target: string;
-    tagger: string;
-    time: number;
-    text: string;
-};
-export declare const signalTags: (listing: string, heartbeat: (ref: string) => boolean) => TagRef[];
-export declare const tagObject: (body: Buffer) => TagObject;

package/target/dts/clients/cli/skill/targets.d.ts

@@ -1,3 +0,0 @@
-export declare const SKILL: string;
-export declare const skillTargets: (project: boolean) => string[];
-export declare const sameSkill: (dir: string) => boolean;

package/target/dts/core/hub/usecases/staging.d.ts

@@ -1,8 +0,0 @@
-import type { Entry } from '../protocol/files.ts';
-import type { Staged } from '../history/index.ts';
-import type { Actor } from './actor.ts';
-export declare const staged: ({ R, me }: Actor) => Staged[];
-export declare const stage: ({ R, me }: Actor, files: Entry[]) => Staged[];
-export declare const shrink: ({ R, me }: Actor, keep: (s: Staged) => boolean) => Staged[];
-export declare const unstage: (a: Actor, paths: string[] | null) => Staged[];
-export declare const outgoing: (stagedNow: Staged[], explicit: Entry[]) => Entry[];

package/target/esm/adapters/transport-git/marks.js

@@ -1,82 +0,0 @@
-// marks: tags on a room's commits. Signals are immutable annotated tags `<agent>.<signal>.<message12>`; a heartbeat is
-// one mutable tag `<agent>.heartbeat.<genesis12>` per agent and room, replaced on every beat.
-import * as Remote from './remote.js';
-import { signedTag } from './signing.js';
-import { ZERO, frames, runGitRaw } from './run.js';
-import { signalTags, tagObject } from './tags.js';
-import { Branches } from './branches.js';
-import { fail, note } from '../../lib/index.js';
-export class Marks extends Branches {
-    // The heartbeat of `who` in the room: a tag `<who>.heartbeat.<genesis12>` on the room's last commit here, its text the
-    // facts of the beat (core/agents/heartbeat). Each beat replaces the object under the same name, compare-and-swap on the one it
-    // read, so two writers do not overwrite each other blindly. No reader pins it; its replacement is no alarm.
-    // On a signed hub the object is signed by `who` and published with the OID it replaced; a newer beat there wins, and
-    // this one is taken back here (remote.ts).
-    heartbeat(room, who, target, text) {
-        const ref = Remote.heartbeatRef(who, room.genesis), name = ref.slice('refs/tags/'.length);
-        const old = this.rev(`${ref}^{tag}`) ? this.git(['rev-parse', ref]).trim() : null;
-        const obj = this.trust === 'signed' ? Remote.makeHeartbeat(this.h, this.remote(room), who, target, text)
-            : this.git(['mktag'], { input: `object ${target}\ntype commit\ntag ${name}\ntagger ${who} <${who}@ringi> ${Math.floor(Date.now() / 1000)} +0000\n\n${text}` }).trim();
-        if (this.gitOk(['update-ref', ref, obj, old ?? ZERO]).status !== 0)
-            fail(`${name} moved meanwhile; the next beat writes it`);
-        if (this.trust === 'signed' && !Remote.pushHeartbeat(this.h, this.remote(room), who, obj, old))
-            this.gitOk(['update-ref', ...(old ? [ref, old, obj] : ['-d', ref, obj])]);
-        return obj;
-    }
-    // The room's heartbeats as they stand: whose, on which commit, when, and what they say.
-    heartbeats(room) {
-        const g12 = room.genesis.slice(0, 12);
-        const tags = this.git(['for-each-ref', '--format=%(refname) %(objectname) %(objecttype)', 'refs/tags/']).split('\n')
-            .map(l => l.split(' ')).filter(([ref, , type]) => type === 'tag' && Remote.heartbeatName(ref ?? '')?.genesis12 === g12);
-        const objects = this.tagObjects(tags.map(([, object]) => object));
-        // On a signed hub only a verified beat shows.
-        const ok = (ref, object) => this.trust !== 'signed' || !Remote.verifyHeartbeat(this.h, this.remote(room), ref, object);
-        return tags.flatMap(([ref, object]) => {
-            const o = objects.get(object);
-            return o && ok(ref, object) ? [{ agent: Remote.heartbeatName(ref).actor, target: o.target, time: o.time, text: o.text }] : [];
-        });
-    }
-    // An annotated tag without text in its author's namespace, on the message's commit, signed on a signed hub. The
-    // message's id in the name keeps it unique, so writing the same signal twice is a no-op.
-    signal(room, who, target, name) {
-        const tag = `${who}.${name}`;
-        const ref = `refs/tags/${tag}`;
-        if (this.gitOk(['rev-parse', '-q', '--verify', ref]).status === 0) {
-            Remote.push(this.h, ref);
-            return;
-        }
-        this.git(['update-ref', ref, signedTag(this.h, who, tag, target), ZERO]);
-        Remote.push(this.h, ref);
-    }
-    // The tags named `<actor>.<signal>.<message12>`, with the objects they name; a heartbeat is no signal (heartbeats()).
-    tags() {
-        return signalTags(this.git(['for-each-ref', '--format=%(refname) %(objectname) %(objecttype)', 'refs/tags/']), ref => !!Remote.heartbeatName(ref));
-    }
-    // Annotated tag objects read whole (run.ts frames): their target, tagger and text are never split on bytes they hold.
-    tagObjects(shas) {
-        if (!shas.length)
-            return new Map();
-        const raw = runGitRaw(this.args(['cat-file', '--batch']), this.home, Buffer.from(shas.join('\n') + '\n'));
-        return new Map([...frames(raw, shas)].filter(([, f]) => f.type === 'tag').map(([sha, f]) => [sha, tagObject(f.body)]));
-    }
-    signals(room) {
-        const tags = this.tags(), objects = this.tagObjects(tags.filter(t => t.type === 'tag').map(t => t.object));
-        const mine = this.commitsOf(room);
-        const records = tags.flatMap(t => {
-            const o = objects.get(t.object);
-            // Only an annotated tag on a commit is a signal; anything else points nowhere.
-            if (!mine.has(o?.target || t.object))
-                return [];
-            return [{ ref: t.ref, object: t.object, name: t.name, actor: t.actor, target: o?.target ?? '', tagger: o?.tagger ?? '', text: o?.text ?? '' }];
-        });
-        if (this.trust !== 'signed')
-            return records;
-        return Remote.withVerification(this.h, () => records.filter(s => {
-            const why = Remote.verifySignal(this.h, this.remote(room), s.ref, s.object);
-            if (why)
-                note(`ALARM signal ${s.ref}: ${why}; quarantined and withheld`);
-            return !why;
-        }));
-    }
-}
-//# sourceMappingURL=marks.js.map

package/target/esm/adapters/transport-git/remote/bootstrap.js

@@ -1,47 +0,0 @@
-// bootstrap: a replica of a published signed hub, verified against the root and genesis the operator gives out of
-// band before its descriptor is written.
-import crypto from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-import * as C from '../../../lib/index.js';
-import { id, mkdir } from './git.js';
-import { checkUrl, keyInput } from './keys.js';
-import { command } from './process.js';
-import { sync } from './sync.js';
-import { SHA } from './types.js';
-export const hubAdd = ({ home, name, url, root, genesis }) => {
-    id(name);
-    checkUrl(url);
-    if (!root)
-        C.fail('hub add requires --root <public-key|file> from the operator; a key advertised by the hub is not a trust anchor');
-    const key = keyInput(root ?? C.fail('hub add requires --root <public-key|file>'));
-    if (genesis && !SHA.test(genesis))
-        C.fail('--genesis must be a full commit id');
-    // A hub is a descriptor (hub.json) beside its store; for a git store the repository is store/.git.
-    const hubDir = path.join(home, 'hub', name);
-    const dir = path.join(hubDir, 'store', '.git');
-    if (fs.existsSync(hubDir))
-        C.fail(`hub ${name} exists`);
-    mkdir(path.dirname(dir));
-    const stage = path.join(home, 'hub', `.${name}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.git`);
-    try {
-        command('git', ['init', '--bare', '-q', '-b', 'main', stage]);
-        const descriptor = {
-            schema: 'ringi-hub/2', name, trust: 'signed', root: key.line, genesis,
-            store: { type: 'git', path: 'store', remote: url }
-        };
-        const H = { name, dir: stage, d: descriptor, bootstrap: !genesis };
-        sync(H);
-        fs.renameSync(stage, dir);
-        fs.writeFileSync(path.join(hubDir, 'hub.json'), JSON.stringify(descriptor, null, 2) + '\n', { mode: 0o600 });
-        return dir;
-    }
-    finally {
-        if (fs.existsSync(stage))
-            fs.rmSync(stage, { recursive: true, force: true });
-        // A failed add leaves no half-made hub behind (the directory did not exist before).
-        if (!fs.existsSync(dir))
-            fs.rmSync(hubDir, { recursive: true, force: true });
-    }
-};
-//# sourceMappingURL=bootstrap.js.map

package/target/esm/adapters/transport-git/remote/heartbeat-name.js

@@ -1,19 +0,0 @@
-// heartbeat-name: the one mutable tag name, `<actor>.heartbeat.<genesis12>`; every other tag is a signal.
-import * as C from '../../../lib/index.js';
-import { SHA, TAGS } from './types.js';
-// Heartbeats deliberately share the tag transport, but never the immutable signal acceptance.
-// Only this exact namespace is mutable; e.g. `actor.opened.heartbeat.<id>` is still a signal.
-export const HEARTBEAT_NAME = /^([a-z0-9]+(?:[_-][a-z0-9]+)*)\.heartbeat\.([0-9a-f]{12})$/;
-export const heartbeatName = (ref) => {
-    const m = ref.startsWith(TAGS) && HEARTBEAT_NAME.exec(ref.slice(TAGS.length));
-    return m ? { actor: m[1], genesis12: m[2] } : null;
-};
-export const heartbeatRef = (who, genesis) => {
-    if (!SHA.test(genesis))
-        C.fail('heartbeat requires a full room genesis');
-    const ref = `${TAGS}${who}.heartbeat.${genesis.slice(0, 12)}`;
-    if (!heartbeatName(ref))
-        C.fail('malformed heartbeat actor');
-    return ref;
-};
-//# sourceMappingURL=heartbeat-name.js.map

package/target/esm/adapters/transport-git/remote/heartbeat-object.js

@@ -1,40 +0,0 @@
-// heartbeat-object: a heartbeat tag object read and checked: its target in the room, its tagger, its signature.
-import * as C from '../../../lib/index.js';
-import * as P from '../../../core/hub/protocol/index.js';
-import { branch } from './branch.js';
-import { git, rev } from './git.js';
-import { heartbeatBody } from './heartbeat-facts.js';
-import { heartbeatName } from './heartbeat-name.js';
-import { checkSignature } from './signature.js';
-import { SHA, TAGS } from './types.js';
-export const heartbeatObject = (H, ref, sha) => {
-    const s = heartbeatName(ref) ?? C.fail('malformed heartbeat namespace');
-    if (!SHA.test(sha) || git(H, ['cat-file', '-t', sha]).trim() !== 'tag')
-        C.fail('heartbeat must be an annotated tag');
-    if (Number(git(H, ['cat-file', '-s', sha])) > 32768)
-        C.fail('heartbeat object exceeds 32 KiB');
-    const decoded = P.decodeText(git(H, ['cat-file', 'tag', sha], { raw: true }));
-    if (decoded.invalid)
-        C.fail(`heartbeat tag is ${decoded.invalid}`);
-    const [header, ...rest] = decoded.text.split('\n\n');
-    const target = /^object ([0-9a-f]+)\ntype commit\ntag ([^\n]+)\ntagger ([^<\n]+) <[^\n]*> (\d+) [+-]\d{4}\n?$/.exec(header) ?? C.fail('malformed heartbeat tag headers');
-    if (!SHA.test(target[1]) || target[2] !== ref.slice(TAGS.length) || target[3].trim() !== s.actor)
-        C.fail('heartbeat tag name or actor disagrees');
-    const text = rest.join('\n\n').split('-----BEGIN SSH SIGNATURE-----')[0];
-    const genesis = heartbeatBody(text);
-    if (!genesis.startsWith(s.genesis12))
-        C.fail('heartbeat tag name and room genesis disagree');
-    return { ...s, genesis, target: target[1], time: Number(target[4]), text };
-};
-export const checkHeartbeat = (H, R, ref, sha) => {
-    const s = heartbeatObject(H, ref, sha);
-    if (s.genesis !== R.genesis)
-        C.fail('heartbeat belongs to another room genesis');
-    const b = branch(H, R, rev(H, R.ref) ?? C.fail('heartbeat room has no branch here'));
-    // It is a replica's sync position, not a claim to author or execute the target message.
-    if (!b.control.includes(s.target) && !b.authors.has(s.target) && !b.skipped.has(s.target))
-        C.fail('heartbeat target is not on this room branch');
-    const signer = b.entries.find(e => e.principal === s.actor) ?? C.fail(`unadmitted heartbeat principal ${s.actor}`);
-    checkSignature(H, sha, s.actor, signer.key, 'tag');
-};
-//# sourceMappingURL=heartbeat-object.js.map