@idleware/ringi 0.7.2 → 0.8.1

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

@@ -9,7 +9,7 @@ export const toMessage = (R, from, x, seq) => {
     if (d.invalid !== undefined) {
         return { ...base, invalid: d.invalid, subject: '', body: '', to: [], re: null, kind: null, state: null, assign: null, roles: null, hop: 0, bad: d.invalid, trailers: {} };
     }
-    const p = parse(d.text, s => R.hub.store.isRef(s));
+    const p = parse(d.text, s => R.store.isRef(s));
     // The room profile's states are part of a message's validity.
     const state = p.state && !p.bad && !R.profile.states.includes(p.state) ? `State ${p.state} is not in profile ${R.profile.name}` : null;
     return { ...base, invalid: null, ...p, bad: p.bad ?? state };
@@ -17,15 +17,15 @@ export const toMessage = (R, from, x, seq) => {
 // The room as stored, read without a reader's lock or state: for an author working out the signals of its own message
 // (append runs inside reader locks too). Readers check signals themselves.
 const asStored = (R) => {
-    const s = R.hub.store.room(R.name) ?? R.s;
-    return link(new Map(R.hub.store.logIds(s).map(id => [id, R.hub.store.messages(s, id, R.hub.store.logHead(s, id)).map((x, seq) => toMessage(R, id, x, seq))])));
+    const s = R.store.room(R.name) ?? R.s;
+    return link(new Map(R.store.logIds(s).map(id => [id, R.store.messages(s, id, R.store.logHead(s, id)).map((x, seq) => toMessage(R, id, x, seq))])));
 };
 // Whether a message can make signals: it opens, assigns or moves work.
 const CARRIES = (p, R) => !p.bad && (p.kind === R.profile.opens || !!p.assign || !!p.state);
 // A message on the author's log, and the signals it made (core/hub/signals/write.ts).
 export const append = (R, who, text, entries = []) => {
-    const id = R.hub.store.append(R.s, who, text, entries);
-    if (CARRIES(parse(text, s => R.hub.store.isRef(s)), R)) {
+    const id = R.store.append(R.s, who, text, entries);
+    if (CARRIES(parse(text, s => R.store.isRef(s)), R)) {
         const all = asStored(R);
         const m = all.get(id);
         if (m)
@@ -36,7 +36,7 @@ export const append = (R, who, text, entries = []) => {
 export const withSizes = (R, m) => {
     if (!m.files.length)
         return [];
-    const sizes = R.hub.store.sizes(m.id, m.files.map(f => f.path));
+    const sizes = R.store.sizes(m.id, m.files.map(f => f.path));
     return m.files.map(f => ({ ...f, size: sizes.get(f.path) ?? null }));
 };
 //# sourceMappingURL=messages.js.map

package/target/esm/core/hub/rooms/room-catalogue.js

@@ -0,0 +1,31 @@
+// Local endpoint addresses, independent store handles and machine-wide room names.
+import path from 'node:path';
+import { hubPorts } from '../ports/index.js';
+import { fail } from '../../../lib/index.js';
+import { ID_RE } from '../protocol/index.js';
+import { hubNames } from './hubs.js';
+import { storeOf, transportOf } from './address.js';
+export const endpointKey = (H, name) => ['hub', H.name, 'rooms', name, 'endpoint'];
+export const roomDir = (H, name) => path.join(H.dir, 'rooms', name);
+export const transportFor = (H, e) => transportOf(H.name, e.store.remote ? storeOf(e.store.remote).type : H.d.store.type);
+export const roomLock = (H, name) => ID_RE.test(name) ? `room-${H.d.genesis}-${name}` : fail(`bad room name ${name}`);
+export const uniqueName = (H, name) => {
+    for (const hub of hubNames())
+        if (hub !== H.name && hubPorts().state.list(['hub', hub, 'rooms']).includes(name))
+            fail(`room name ${name} already belongs to hub ${hub}; nothing is replaced`);
+};
+export const roomNames = (H) => hubPorts().state.list(['hub', H.name, 'rooms'])
+    .filter(name => ID_RE.test(name) && hubPorts().state.read(endpointKey(H, name), null) !== null);
+const stores = new Map();
+export const selectedStore = (H, endpoint) => {
+    const key = JSON.stringify([H.dir, H.d, endpoint]);
+    const cached = stores.get(key);
+    if (cached)
+        return cached;
+    const store = transportFor(H, endpoint).open(roomDir(H, endpoint.name), H.d, endpoint);
+    stores.set(key, store);
+    if (stores.size > 128)
+        stores.delete(stores.keys().next().value);
+    return store;
+};
+//# sourceMappingURL=room-catalogue.js.map

package/target/esm/core/hub/rooms/room-life.js

@@ -0,0 +1,59 @@
+// Explicit room creation, attachment and local purge. Every installation preserves existing pins on failure.
+import { hubPorts, locked } from '../ports/index.js';
+import { fail } from '../../../lib/index.js';
+import { ID_RE } from '../protocol/index.js';
+import { openContract } from './contracts.js';
+import { endpointRefusal } from './compat.js';
+import { openedRoom } from './room-view.js';
+import { endpointKey, roomDir, roomLock, transportFor, uniqueName } from './room-catalogue.js';
+const checkName = (H, name) => {
+    if (!ID_RE.test(name) || name === 'main' || name === 'chat')
+        fail(`bad room name ${name}`);
+    uniqueName(H, name);
+};
+const sameEndpoint = (name, old, next) => {
+    if (!old)
+        return;
+    const identity = old.genesis === next.genesis && old.hubGenesis === next.hubGenesis;
+    if (!identity || old.store.path !== next.store.path)
+        fail(`room ${name}: an endpoint already pins another history; nothing is replaced`);
+};
+export const createRoom = (H, name, { who, text, files, remote }) => locked('room-names', () => locked(roomLock(H, name), () => {
+    checkName(H, name);
+    if (remote && !H.signed)
+        fail('a remote room requires a signed hub');
+    const st = hubPorts().state;
+    if (st.list(['hub', H.name, 'rooms']).includes(name))
+        fail(`room ${name} exists; an unregistered repository is retained for review`);
+    const { store: source } = openContract(H);
+    const endpoint = { schema: 'ringi-room/1', name, hubGenesis: H.d.genesis, genesis: '', store: { path: 'store', ...(remote ? { remote } : {}) } };
+    const store = transportFor(H, endpoint).fork(roomDir(H, name), H.d, source, endpoint);
+    endpoint.genesis = store.createRoom(name, who, text, files);
+    const R = openedRoom(H, endpoint, store);
+    st.write(endpointKey(H, name), endpoint);
+    return R;
+}));
+export const attachRoom = (H, name, endpoint) => locked('room-names', () => locked(roomLock(H, name), () => {
+    checkName(H, name);
+    const why = endpointRefusal(H.d, name, endpoint);
+    if (why)
+        fail(why);
+    const st = hubPorts().state;
+    const old = st.read(endpointKey(H, name), null);
+    sameEndpoint(name, old, endpoint);
+    const t = transportFor(H, endpoint);
+    const store = old ? t.open(roomDir(H, name), H.d, endpoint) : t.attachRoom(roomDir(H, name), H.d, endpoint);
+    store.sync();
+    const R = openedRoom(H, endpoint, store);
+    st.write(endpointKey(H, name), endpoint);
+    return R;
+}));
+// The caller requires the operator's explicit local-purge confirmation. Missing remotes never invoke this.
+export const deleteRoom = (R) => locked(roomLock(R.hub, R.name), () => {
+    const current = hubPorts().state.read(endpointKey(R.hub, R.name), null);
+    if (!current || current.genesis !== R.genesis || current.hubGenesis !== R.hub.d.genesis)
+        fail('room endpoint moved before local purge; nothing is removed');
+    hubPorts().state.remove(['hub', R.hub.name, 'rooms', R.name]);
+    hubPorts().state.remove(['readers', R.hub.d.genesis, R.genesis]);
+});
+//# sourceMappingURL=room-life.js.map

package/target/esm/core/hub/rooms/room-view.js

@@ -0,0 +1,39 @@
+// A selected, verified repository interpreted as one room with its frozen contract and profile.
+import { DEFAULT_PROFILE, parseProfile } from '../work/index.js';
+import { fail, strictJson } from '../../../lib/index.js';
+import { checkedContract, readProfileResource } from './contracts.js';
+import { contractAt } from './compat.js';
+// The genesis names its room, in the root's hand: a history offered under another name is not that room.
+const checkNamed = (s, name) => {
+    const subject = s.control[0]?.rev === s.genesis ? s.control[0].text.split('\n')[0] : '(none)';
+    if (subject !== `room ${name}`)
+        fail(`room ${name}: its genesis is "${subject}"; refusing a room's history under another name`);
+};
+// The room's profile is fixed when the room is made: its content is copied into the genesis control entry, so no
+// later change of the hub's profiles or contract reinterprets the room's history. Rooms made before this carry none
+// and use the default profile of the contract they were created on.
+const profileOf = (H, store, s, name) => {
+    const base = contractAt(store, H.name, s.base).profile ?? DEFAULT_PROFILE;
+    const fallback = () => base === DEFAULT_PROFILE ? readProfileResource(DEFAULT_PROFILE) : fail(`room ${name}: unknown profile ${base}`);
+    return store.controlFile(s, 'profile.json', s.genesis) ?? store.contractFile(s.base, `profiles/${base}.json`) ?? fallback();
+};
+const membersOf = (store, s, name) => store.roster(s)?.members ?? strictJson(store.controlFile(s, 'members.json') ?? '{}', `room ${name}: members.json`);
+// The root's control records set the quorum; the latest one counts.
+const quorumOf = (s) => s.control.reduce((q, rec) => Number(/^Quorum: ([1-9][0-9]?)$/m.exec(rec.text)?.[1] ?? NaN) || q, null);
+export const openedRoom = (H, endpoint, store) => {
+    const { name } = endpoint;
+    checkedContract(H, store);
+    const s = store.room(name) ?? fail(`room ${name}: its endpoint has no chat branch`);
+    if (store.contractHead() !== s.base)
+        fail(`ALARM room ${name}: its frozen contract changed; nothing is delivered`);
+    if (s.genesis !== endpoint.genesis)
+        fail(`ALARM room ${name}: chat changes its pinned genesis`);
+    checkNamed(s, name);
+    const current = s.base;
+    if (!store.extends(current, store.contractHead()))
+        fail(`room ${name}: its applied contract is outside main`);
+    const contract = contractAt(store, H.name, current);
+    return { hub: H, endpoint, store, s, name, head: s.head, genesis: s.genesis, contractRev: current, contract,
+        profile: parseProfile(profileOf(H, store, s, name), `room ${name}: profile`), members: membersOf(store, s, name), quorum: quorumOf(s) };
+};
+//# sourceMappingURL=room-view.js.map

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

@@ -1,55 +1,44 @@
 // rooms: a room opened with its contract, profile, members and quorum; and the root's control changes.
-import { DEFAULT_PROFILE, parseProfile } from '../work/index.js';
-import { locked } from '../ports/index.js';
+import { DEFAULT_PROFILE } from '../work/index.js';
+import { hubPorts, locked } from '../ports/index.js';
 import { fail, strictJson } from '../../../lib/index.js';
 import { compose } from '../protocol/index.js';
-import { readProfileResource } from './hubs.js';
-import { contractAt } from './compat.js';
-export const roomNames = (H) => H.store.roomNames();
+import { openContract, readProfileResource } from './hubs.js';
+import { endpointRefusal } from './compat.js';
+import { ID_RE } from '../protocol/index.js';
+import { endpointKey, roomLock, roomNames, selectedStore } from './room-catalogue.js';
+import { openedRoom } from './room-view.js';
+export { roomNames } from './room-catalogue.js';
+export { createRoom, attachRoom, deleteRoom } from './room-life.js';
 const missing = (H, name, quiet) => quiet ? null : fail(`no room ${name} in hub ${H.name}; rooms: ${roomNames(H).join(', ') || 'none'}`);
-// The genesis names its room, in the root's hand: a history offered under another name is not that room.
-const checkNamed = (s, name) => {
-    const subject = s.control[0]?.rev === s.genesis ? s.control[0].text.split('\n')[0] : '(none)';
-    if (subject !== `room ${name}`)
-        fail(`room ${name}: its genesis is "${subject}"; refusing a room's history under another name`);
-};
-// The contract the room follows: the hub contract it was created on, or the last one the operator moved it to.
-const contractRev = (s) => s.control.reduce((current, rec) => /^Contract: ([0-9a-f]{40,64})$/m.exec(rec.text)?.[1] ?? current, s.base);
-// The room's profile is fixed when the room is made: its content is copied into the genesis control entry, so no
-// later change of the hub's profiles or contract reinterprets the room's history. Rooms made before this carry none
-// and use the default profile of the contract they were created on.
-const profileOf = (H, s, name) => {
-    const base = contractAt(H.store, H.name, s.base).profile ?? DEFAULT_PROFILE;
-    const fallback = () => base === DEFAULT_PROFILE ? readProfileResource(DEFAULT_PROFILE) : fail(`room ${name}: unknown profile ${base}`);
-    return H.store.controlFile(s, 'profile.json', s.genesis) ?? H.store.contractFile(s.base, `profiles/${base}.json`) ?? fallback();
-};
-const membersOf = (H, s, name) => H.store.roster(s)?.members ?? strictJson(H.store.controlFile(s, 'members.json') ?? '{}', `room ${name}: members.json`);
-// The root's control records set the quorum; the latest one counts.
-const quorumOf = (s) => s.control.reduce((q, rec) => Number(/^Quorum: ([1-9][0-9]?)$/m.exec(rec.text)?.[1] ?? NaN) || q, null);
-export const openRoom = (H, name, { quiet = false } = {}) => {
+export const openRoom = (H, name, { quiet = false, refresh = false } = {}) => {
     if (!name)
         return fail('no room: the operator creates one with ringi room create <id>, or picks one with ringi room switch <id>');
-    const s = H.store.room(name);
-    if (!s)
+    if (!ID_RE.test(name))
+        fail(`bad room name ${name}`);
+    const endpoint = hubPorts().state.read(endpointKey(H, name), null);
+    if (!endpoint)
         return missing(H, name, quiet);
-    checkNamed(s, name);
-    const current = contractRev(s);
-    const contract = current === H.main ? H.contract : contractAt(H.store, H.name, current);
-    return { hub: H, s, name, head: s.head, genesis: s.genesis, contractRev: current, contract,
-        profile: parseProfile(profileOf(H, s, name), `room ${name}: profile`), members: membersOf(H, s, name), quorum: quorumOf(s) };
+    const why = endpointRefusal(H.d, name, endpoint);
+    if (why)
+        fail(why);
+    const store = selectedStore(H, endpoint);
+    void refresh;
+    store.sync();
+    return openedRoom(H, endpoint, store);
 };
 export const room = (H, name) => openRoom(H, name);
 export const ROOM_MD = (name) => `# room ${name}\n\nA ringi room: members.json lists who takes part; profile.json is what a piece of work is here, fixed when the room was made.\n`;
-export const profileText = (H, name) => H.store.contractFile(H.main, `profiles/${name}.json`) ?? (name === DEFAULT_PROFILE ? readProfileResource(DEFAULT_PROFILE) : null);
+export const profileText = (H, name) => (() => { const { store, main } = openContract(H); return store.contractFile(main, `profiles/${name}.json`) ?? (name === DEFAULT_PROFILE ? readProfileResource(DEFAULT_PROFILE) : null); })();
 // A control change under the hub lock. In a signed room membership changes only through `room admit`.
-export const controlChange = (R, who, subject, mutate, extra = []) => locked(`hub-${R.hub.name}`, () => {
-    const s = R.hub.store.room(R.name) ?? fail(`room ${R.name} is gone`);
-    const members = strictJson(R.hub.store.controlFile(s, 'members.json') ?? '{}', `room ${R.name}: members.json`);
+export const controlChange = (R, who, subject, mutate, extra = []) => locked(roomLock(R.hub, R.name), () => {
+    const s = R.store.room(R.name) ?? fail(`room ${R.name} is gone`);
+    const members = strictJson(R.store.controlFile(s, 'members.json') ?? '{}', `room ${R.name}: members.json`);
     const before = JSON.stringify(members);
     mutate(members);
     if (R.hub.signed && JSON.stringify(members) !== before)
         fail('in a signed room, membership changes only by ringi room admit');
-    R.head = R.hub.store.updateControl(s, who, compose(subject, [['To', '*'], ['Kind', 'room'], ...extra]), { 'members.json': JSON.stringify(members, null, 2) + '\n' });
+    R.head = R.store.updateControl(s, who, compose(subject, [['To', '*'], ['Kind', 'room'], ...extra]), { 'members.json': JSON.stringify(members, null, 2) + '\n' });
     R.members = members;
 });
 //# sourceMappingURL=rooms.js.map

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

@@ -1,33 +1,28 @@
-// check: a signal holds when its author made it, it is named after and points at a message of its author in this room,
-// and that message made exactly this signal; a mark holds when it is possible.
 import { effective } from './effective.js';
 import { markWhy } from './marks.js';
 import { MARKS } from './model.js';
-const namedAfter = (id, target) => id.length === 12 && target.startsWith(id);
-const signalWhy = (R, all, actor, m, signal) => {
-    if (m.from !== actor)
+const meaning = (R, all, x, m) => {
+    if (x.roomGenesis !== R.genesis)
+        return 'names another room genesis';
+    if (MARKS.includes(x.signal))
+        return markWhy(R, x.actor, m, x.signal);
+    if (m.from !== x.actor)
         return `points at a message of ${m.from}`;
-    return effective(R, all, m).includes(signal) ? undefined : `its message did not make ${signal}`;
+    return effective(R, all, m).includes(x.signal) ? undefined : `its message did not make ${x.signal}`;
 };
-const whyNot = (R, all, x, id, signal) => {
-    const m = all.get(x.target);
-    const shape = [
-        [!x.target, 'is not an annotated tag on a message'],
-        [x.tagger !== x.actor, `was made by ${x.tagger}, not ${x.actor}`],
-        [!namedAfter(id, x.target), 'is named after another message'],
-        [!m, 'points at no accepted message of this room'],
-    ];
-    const wrong = shape.find(([bad]) => bad);
-    if (wrong)
-        return wrong[1];
-    const meaning = MARKS.includes(signal) ? markWhy(R, x.actor, m, signal) : signalWhy(R, all, x.actor, m, signal);
-    // A signal is its name and its target; any text besides a signature is not one.
-    return meaning ?? (x.text === '' ? undefined : 'carries text; a signal has none');
+export const check = (R, all, records) => {
+    const stopped = new Set(), tuples = new Set();
+    return records.map(x => {
+        const m = all.get(x.target), pending = stopped.has(x.actor) || !m;
+        const why = pending ? 'awaits an accepted stream prefix and message' : meaning(R, all, x, m);
+        if (why)
+            stopped.add(x.actor);
+        const tuple = JSON.stringify([x.actor, x.target, x.signal]);
+        const duplicate = tuples.has(tuple);
+        if (!why)
+            tuples.add(tuple);
+        return { ref: x.id, actor: x.actor, signal: x.signal, target: x.target, ok: !why && !duplicate, why,
+            ...((pending || duplicate) ? { pending: true } : {}) };
+    });
 };
-export const check = (R, all, records) => records.map(x => {
-    const dot = x.name.lastIndexOf('.');
-    const signal = x.name.slice(0, dot);
-    const why = whyNot(R, all, x, x.name.slice(dot + 1), signal);
-    return { ref: x.ref, actor: x.actor, signal, target: x.target, ok: !why, why };
-});
 //# sourceMappingURL=check.js.map

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

@@ -1,16 +1,16 @@
-// signals: explicit markers of what happens in a room, beside the messages that carry it. Every effective transition
-// (work opened, assigned, a state reached, a proposal, a counted stamp, the decision, a counted usage receipt) is also
-// a signal of its author on the message that made it: in a git store an annotated tag `<author>.<signal>.<message12>`
-// on that message's commit, with no text of its own, signed on a signed hub. The message's id keeps the name unique;
-// the name, target, author and time are the tag itself. Signals are visible and checkable with the store's own tools
-// (`git tag -v`, a forge's tag list and tag-push webhooks) and cheap to poll.
+// signals: explicit markers of what happens in a room, beside the messages that carry it (signals-2). Every effective
+// transition (work opened, assigned, a state reached) is also a signal of its author: a record of the author's own
+// stream naming the room, the control it writes under, the message and the signal; in a git store a commit on
+// `<author>/signals`, signed on a signed hub. The author, message and signal identify it, so writing it again adds
+// nothing. Signals are visible with the store's own tools (`git log`, a forge's branches and push webhooks) and cheap
+// to poll.
 //
 // The messages stay the truth. A signal is made only for a transition the fold actually counted (a State the author
-// had no right to makes none). A reader checks every signal against its message and pins the stored object it
-// accepted; a signal that disagrees, or an accepted one that changes or disappears, is an alarm. A signal missing
-// after a crash between message and tag changes nothing and is restored with `signals --repair`.
+// had no right to makes none). A reader checks every signal against its message and pins each stream's accepted
+// prefix; a signal that disagrees, or an accepted stream that changes or disappears, is an alarm. A signal missing
+// after a crash between message and signal changes nothing and is restored with `signals --repair`.
 //
-// Marks are the second layer, in the same namespace: where attention is, not what was decided. `read` says a message
+// Marks are the second layer, in the same stream: where attention is, not what was decided. `read` says a message
 // reached its reader (made on delivery); `taken` says a member took a piece of work. A mark changes no state
 // or assignment. It is checked only for being possible: its target is an accepted message of the room, its
 // actor a member; `read` only for a message addressed to the actor or to all, `taken` only for a message that opens

package/target/esm/core/hub/signals/model.js

@@ -1,5 +1,3 @@
 // model: what the folds need of a room, and a signal as a store returns it.
 export const MARKS = ['read', 'taken'];
-// A signal's name after its actor: the signal and the message's short id.
-export const signalName = (id, signal) => `${signal}.${id.slice(0, 12)}`;
 //# sourceMappingURL=model.js.map

package/target/esm/core/hub/signals/pins.js

@@ -1,21 +1,49 @@
-// pins: a reader's pins, the stored object of each signal it accepted. A changed or vanished one is an alarm.
-// A signal's identity in any store: its tag's name `<actor>.<signal>.<message12>`.
-const keyOf = (ref) => ref.split('/').at(-1);
+const grouped = (records) => {
+    const streams = new Map();
+    for (const x of records) {
+        const stream = streams.get(x.actor) ?? [];
+        stream.push(x);
+        streams.set(x.actor, stream);
+    }
+    return streams;
+};
+const suffix = (stream, pin) => {
+    if (!pin)
+        return stream;
+    const at = stream.findIndex(x => x.id === pin);
+    return at === -1 ? null : stream.slice(at + 1);
+};
+const advance = (stream, verdict, parent) => {
+    for (const x of stream) {
+        if (x.parent !== parent)
+            return { head: parent, alarm: `signal stream ${x.actor} is not a continuation of ${parent}` };
+        const c = verdict.get(x.id);
+        if (!c || (!c.ok && c.why))
+            break;
+        // Duplicate valid tuples extend the prefix, though they count only once in the fold.
+        parent = x.id;
+    }
+    return { head: parent };
+};
+const acceptActor = (actor, stream, verdict, pin) => {
+    const tail = suffix(stream, pin);
+    if (!tail)
+        return { head: pin, alarm: `signal stream ${actor} does not include its accepted prefix ${pin}` };
+    return advance(tail, verdict, pin ?? stream[0].roomGenesis);
+};
 export const pins = (records, checked, accepted = {}) => {
-    const now = new Map(records.map(x => [`${x.actor}.${x.name}`, x]));
-    const alarms = [];
-    const next = {};
-    for (const [k, object] of Object.entries(accepted)) {
-        const key = keyOf(k), x = now.get(key);
-        next[key] = object;
-        if (!x)
-            alarms.push(`signal ${key} was removed after it was accepted`);
-        else if (x.object !== object)
-            alarms.push(`signal ${x.ref} was replaced after it was accepted`);
+    const next = { ...accepted }, alarms = [], streams = grouped(records);
+    const verdict = new Map(checked.map(c => [c.ref, c]));
+    for (const actor of Object.keys(accepted))
+        if (!streams.has(actor))
+            alarms.push(`signal stream ${actor} was removed after it was accepted`);
+    for (const [actor, stream] of streams) {
+        const result = acceptActor(actor, stream, verdict, accepted[actor]);
+        if (result.head !== stream[0].roomGenesis)
+            next[actor] = result.head;
+        if (result.alarm)
+            alarms.push(result.alarm);
     }
-    for (const c of checked)
-        if (c.ok && !next[keyOf(c.ref)])
-            next[keyOf(c.ref)] = now.get(keyOf(c.ref)).object;
     return { accepted: next, alarms };
 };
 //# sourceMappingURL=pins.js.map

package/target/esm/core/hub/signals/write.js

@@ -1,26 +1,24 @@
 // signals (write side): an author stores the signals its message made and the marks it puts; readers check them
 // (index.ts).
-import { effective, markWhy, signalName } from './index.js';
+import { effective, markWhy } from './index.js';
 import { fail } from '../../../lib/index.js';
 // Puts one of the actor's marks on a message; false if it was already there.
 export const mark = (R, who, m, name) => {
     const why = markWhy(R, who, m, name);
     if (why)
         fail(`cannot mark ${m.id.slice(0, 12)} ${name}: ${why}`);
-    if (R.hub.store.signals(R.s).some(x => x.actor === who && x.name === signalName(m.id, name)))
-        return false;
-    R.hub.store.signal(R.s, who, m.id, signalName(m.id, name));
-    return true;
+    const exists = R.store.signals(R.s).some(x => x.actor === who && x.target === m.id && x.signal === name);
+    R.store.signal(R.s, who, m.id, name);
+    return !exists;
 };
 // Writes the signals of one of the author's own messages that are not stored yet.
 export const emit = (R, who, all, m) => {
-    const have = new Set(R.hub.store.signals(R.s).filter(x => x.actor === who).map(x => x.name));
+    const have = new Set(R.store.signals(R.s).filter(x => x.actor === who).map(x => JSON.stringify([x.target, x.signal])));
     let n = 0;
     for (const signal of effective(R, all, m)) {
-        if (have.has(signalName(m.id, signal)))
-            continue;
-        R.hub.store.signal(R.s, who, m.id, signalName(m.id, signal));
-        n++;
+        R.store.signal(R.s, who, m.id, signal);
+        if (!have.has(JSON.stringify([m.id, signal])))
+            n++;
     }
     return n;
 };

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

@@ -1,3 +1,3 @@
 // actor: who acts, and in which room; every operation of a participant takes one.
-export const isRef = (R) => (x) => R.hub.store.isRef(x);
+export const isRef = (R) => (x) => R.store.isRef(x);
 //# sourceMappingURL=actor.js.map

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

@@ -1,5 +1,5 @@
-// config: the operator's terminal context on this machine: the hub and the room a command means when it names none.
+// config: the operator's terminal context on this machine: the room a command means when it names none.
 import { hubPorts } from '../ports/index.js';
-export const config = () => ({ hub: 'local', room: null, ...hubPorts().state.read(['config'], {}) });
+export const config = () => ({ room: null, ...hubPorts().state.read(['config'], {}) });
 export const setConfig = (patch) => hubPorts().state.write(['config'], { ...config(), ...patch });
 //# sourceMappingURL=config.js.map

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

@@ -1,13 +1,10 @@
-// context: who acts as the operator and where (its terminal context, unless a command names a hub or a room), and what
+// context: who acts as the operator and in which room (its terminal context, unless a command names one), and what
 // this build is. An agent acts through its session (core/agents/sessions/context.ts).
 import { hubPorts } from '../ports/index.js';
-import { CAPS, HUB_MAJOR, OPERATOR, config, openHub, room as roomOf } from '../rooms/index.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 };
-};
+import { CAPS, HUB_MAJOR, OPERATOR, config } from '../rooms/index.js';
+import { roomNamed } from './rooms.js';
+// The operator, in the named room, else in the terminal's current one.
+export const operator = ({ room } = {}) => ({ R: roomNamed(room), me: OPERATOR });
 export const about = () => ({ version: hubPorts().build.version, home: hubPorts().state.root, resources: hubPorts().build.resources, contract: `${HUB_MAJOR}.x`, capabilities: [...CAPS] });
 export { config };
 //# sourceMappingURL=context.js.map

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

@@ -1,47 +1,30 @@
-// hubs: the operator's hubs on this machine: list, create, switch, add a signed replica, amend the shared contract.
+// hubs: the operator's hubs on this machine: list, create, amend the shared contract.
 import { DEFAULT_PROFILE, PROFILES_CAPABILITY, parseProfile } from '../work/index.js';
-import { OPERATOR, config, createHub, hubNames, openHub, roomNames, setConfig, transportOf } from '../rooms/index.js';
+import { OPERATOR, amendContract, createHub, hubNames, openContract, openHub, roomNames } from '../rooms/index.js';
 import { hubPorts } from '../ports/index.js';
 import { fail, strictJson, withoutCredentials, words } from '../../../lib/index.js';
 import { ID_RE, compose } from '../protocol/index.js';
 // A remote as shown and handed to other machines: never with a password or token in it; each machine has its own.
 const shown = (url) => url ? withoutCredentials(url) : null;
-// The operator's terminal context picks the hub unless one is named.
-export const hubOf = (name) => openHub(name ?? config().hub);
+// The named hub, or `local`.
+export const hubOf = (name) => openHub(name ?? 'local');
 export const hubs = () => {
     hubPorts().state.ensure();
     if (!hubNames().length)
         openHub('local');
-    const cur = config().hub;
     return hubNames().map(n => {
         const H = openHub(n);
-        return { name: H.name, current: H.name === cur, store: H.d.store.type, trust: H.contract.trust, contract: H.contract.version,
-            rooms: roomNames(H).length, remote: shown(H.d.store.remote), dir: H.dir };
+        return { name: H.name, store: H.d.store.type, trust: H.d.trust, contract: H.d.contract ? openContract(H).contract.version : null,
+            rooms: roomNames(H).length, remote: shown(H.d.contract?.remote), dir: H.dir };
     });
 };
-// A new hub; a signed one makes its root key here and returns what other machines need to pin it.
+// A new hub; a signed one makes its root key here. Agents elsewhere never attach the hub: each joins its room.
 export const create = (name, { signed = false, url } = {}) => {
     if (!ID_RE.test(name))
         fail('usage: ringi hub create <name> [--signed [--url <git url>]]');
     const { custody } = createHub(name, { signed, url });
-    const H = openHub(name), remote = shown(H.d.store.remote);
-    return { H, rootKey: custody, remote,
-        add: H.signed ? `ringi hub add ${name} ${remote ?? '<url>'} --root '${H.d.root}' --genesis ${H.d.genesis}` : null };
-};
-export const use = (name) => {
-    openHub(name);
-    setConfig({ hub: name, room: null });
-};
-// A replica of a signed hub. The root key comes from the operator, out of band: a key the hub advertises proves nothing.
-export const add = (name, url, { root, genesis }) => {
-    if (!ID_RE.test(name) || !url)
-        fail('usage: ringi hub add <name> <git url> --root <public key|file> [--genesis <sha>]');
-    hubPorts().state.ensure();
-    const t = transportOf(name, hubPorts().store);
-    if (!t.attach)
-        return fail(`a ${hubPorts().store} store cannot replicate a published hub`);
-    t.attach(name, url, { root, genesis });
-    return openHub(name);
+    const H = openHub(name);
+    return { H, rootKey: custody, remote: shown(H.d.contract?.remote) };
 };
 const SETTABLE = ['version', 'capabilities', 'protocol', 'profile'];
 const json = (x) => JSON.stringify(x, null, 2) + '\n';
@@ -65,11 +48,11 @@ const extraFiles = (x) => {
     return files;
 };
 // The default profile must be built in, or in the hub after this amendment.
-const checkDefault = (H, contract, files) => {
+const checkDefault = (source, contract, files) => {
     const p = contract.profile;
     if (typeof p !== 'string' || p === DEFAULT_PROFILE || files[`profiles/${p}.json`])
         return;
-    if (H.store.contractFile(H.main, `profiles/${p}.json`) === null)
+    if (source.store.contractFile(source.main, `profiles/${p}.json`) === null)
         fail(`the default profile ${p} is not in the hub; attach it: --attach <file>:profiles/${p}.json`);
 };
 // Profiles other than the built-in A2A rules need clients that read them: the contract says so.
@@ -80,15 +63,15 @@ const needsProfiles = (contract, files, set) => {
     if (!caps.includes(PROFILES_CAPABILITY))
         contract.capabilities = [...caps, PROFILES_CAPABILITY];
 };
-// A new version of the shared contract on `main`. Rooms keep their base until moved (rooms.rebase).
+// A new version of the shared contract on `main`. Rooms made from then on follow it; existing ones keep theirs.
 export const amend = (H, x) => {
-    const name = 'contract.json';
-    const contract = strictJson(H.store.contractFile(H.main, name), name);
+    const name = 'contract.json', source = openContract(H);
+    const contract = strictJson(source.store.contractFile(source.main, name), name);
     setKeys(contract, x.set ?? []);
     const files = extraFiles(x);
-    checkDefault(H, contract, files);
+    checkDefault(source, contract, files);
     needsProfiles(contract, files, x.set ?? []);
-    H.store.amendContract(OPERATOR, compose(x.text, [['To', '*'], ['Kind', 'hub']]), { [name]: json(contract), ...files });
+    amendContract(H, OPERATOR, compose(x.text, [['To', '*'], ['Kind', 'hub']]), { [name]: json(contract), ...files });
     return { version: String(contract.version) };
 };
 //# sourceMappingURL=hubs.js.map

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

@@ -0,0 +1,26 @@
+// invite: the one line an agent's machine joins a room by, like a VPN key: the room's address (a URI whose scheme names
+// its store: git+ssh://…), which history it must be and the root that signs it. Nothing secret: an address without
+// credentials, a public key.
+import { fail, strictJson, withoutCredentials } from '../../../lib/index.js';
+const PREFIX = 'ringi:';
+const OID = /^[0-9a-f]{40}$|^[0-9a-f]{64}$/;
+// The invitation to a room published at its endpoint's remote; a room that lives only here has none.
+export const invite = (R) => {
+    if (!R.hub.signed || !R.endpoint.store.remote || !R.hub.d.root)
+        return null;
+    const x = { schema: 'ringi-invite/1', room: R.name, address: withoutCredentials(R.endpoint.store.remote), genesis: R.genesis,
+        hubGenesis: R.hub.d.genesis, trust: 'signed', root: R.hub.d.root };
+    return PREFIX + Buffer.from(JSON.stringify(x)).toString('base64url');
+};
+// An invitation carries no credentials: an address with any it refuses rather than keeps.
+const valid = (x) => [x.schema === 'ringi-invite/1', x.trust === 'signed',
+    ...[x.room, x.address, x.root].map(v => typeof v === 'string'), ...[x.genesis, x.hubGenesis].map(v => OID.test(v ?? '')),
+    withoutCredentials(String(x.address)) === x.address].every(Boolean);
+// An invitation, if `s` is one; anything else is a room's name.
+export const readInvite = (s) => {
+    if (!s.startsWith(PREFIX))
+        return null;
+    const x = strictJson(Buffer.from(s.slice(PREFIX.length), 'base64url').toString('utf8'), 'the invitation');
+    return typeof x === 'object' && x !== null && valid(x) ? x : fail('this invitation is not one this ringi reads (ringi-invite/1); ask the operator for a new one');
+};
+//# sourceMappingURL=invite.js.map