@idleware/ringi 0.5.0 → 0.6.1

package/target/esm/heartbeat/platform.js

@@ -1,83 +0,0 @@
-// platform: what the operating system says about a process, on macOS and Linux (Ubuntu). Elsewhere every probe says
-// nothing (null) rather than guess.
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-export const SUPPORTED = process.platform === 'darwin' || process.platform === 'linux';
-// Whether the process exists; a process of another user that we may not signal still exists.
-export const alive = (pid) => {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (e) {
-        return e.code === 'EPERM';
-    }
-};
-// `ps` cumulative CPU time: `[DD-][HH:]MM:SS[.ss]` on both systems.
-export const seconds = (time) => {
-    const [days, rest] = time.includes('-') ? [Number(time.split('-')[0]), time.split('-')[1]] : [0, time];
-    return days * 86400 + rest.split(':').reduce((acc, part) => acc * 60 + Number(part), 0);
-};
-// One line of /proc/<pid>/stat: the parent and the CPU seconds (user + system, in clock ticks of 1/100 s). The command
-// name is in parentheses and may hold spaces, so the fields are counted after the last `)`.
-export const procStat = (line) => {
-    const f = line.slice(line.lastIndexOf(')') + 2).split(' ');
-    const ppid = Number(f[1]), cpu = (Number(f[11]) + Number(f[12])) / 100;
-    return Number.isFinite(ppid) && Number.isFinite(cpu) ? { ppid, cpu } : null;
-};
-// Linux: /proc gives CPU to the hundredth of a second, where `ps` rounds to whole seconds.
-const proc = () => {
-    let pids;
-    try {
-        pids = fs.readdirSync('/proc').filter(d => /^\d+$/.test(d));
-    }
-    catch {
-        return null;
-    }
-    const rows = new Map();
-    for (const pid of pids) {
-        try {
-            const row = procStat(fs.readFileSync(`/proc/${pid}/stat`, 'utf8'));
-            if (row)
-                rows.set(Number(pid), row);
-        }
-        catch { /* the process ended meanwhile */ }
-    }
-    return rows.size ? rows : null;
-};
-// Every process with its parent and CPU seconds: /proc on Linux, else one `ps` call.
-export const table = () => {
-    if (!SUPPORTED)
-        return null;
-    if (process.platform === 'linux') {
-        const rows = proc();
-        if (rows)
-            return rows;
-    }
-    const r = spawnSync('ps', ['-A', '-o', 'pid=,ppid=,time='], { encoding: 'utf8', timeout: 10000 });
-    if (r.status !== 0)
-        return null;
-    const rows = new Map();
-    for (const line of r.stdout.split('\n')) {
-        const [pid, ppid, time] = line.trim().split(/\s+/);
-        if (pid && time)
-            rows.set(Number(pid), { ppid: Number(ppid), cpu: seconds(time) });
-    }
-    return rows;
-};
-// CPU seconds the process and all its descendants used so far: a turn's model client, its tools and their children.
-export const treeCpu = (pid, rows = table()) => {
-    if (!rows?.has(pid))
-        return null;
-    const children = new Map();
-    for (const [p, { ppid }] of rows)
-        children.set(ppid, [...children.get(ppid) ?? [], p]);
-    let sum = 0;
-    for (const stack = [pid]; stack.length;) {
-        const p = stack.pop();
-        sum += rows.get(p)?.cpu ?? 0;
-        stack.push(...children.get(p) ?? []);
-    }
-    return sum;
-};
-//# sourceMappingURL=platform.js.map

package/target/esm/heartbeat/tools.js

@@ -1,68 +0,0 @@
-// tools: the trace each agent tool writes of a session while it works, found by the session's id. Its modification
-// time is the session's own activity, unlike the CPU of an app process that hosts many sessions.
-//   Claude Code   $CLAUDE_CONFIG_DIR (or ~/.claude)/projects/<dir>/<session id>.jsonl, the session's transcript
-//   Codex         $CODEX_HOME (or ~/.codex)/sessions/<yyyy>/<mm>/<dd>/rollout-<time>-<thread id>.jsonl
-// A ringi watcher writes no trace of its own: the CPU of its process tree speaks for its turn (platform.ts).
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-const UUID = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/;
-const dirs = (d) => { try {
-    return fs.readdirSync(d).sort().reverse();
-}
-catch {
-    return [];
-} };
-const mtime = (f) => { try {
-    return fs.statSync(f).mtimeMs / 1000;
-}
-catch {
-    return null;
-} };
-const claude = (id) => {
-    const root = path.join(process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), '.claude'), 'projects');
-    for (const d of dirs(root))
-        if (fs.existsSync(path.join(root, d, `${id}.jsonl`)))
-            return path.join(root, d, `${id}.jsonl`);
-    return null;
-};
-const codex = (id) => {
-    const root = path.join(process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex'), 'sessions');
-    for (const y of dirs(root))
-        for (const m of dirs(path.join(root, y)))
-            for (const d of dirs(path.join(root, y, m))) {
-                const f = dirs(path.join(root, y, m, d)).find(n => n.startsWith('rollout-') && n.endsWith(`-${id}.jsonl`));
-                if (f)
-                    return path.join(root, y, m, d, f);
-            }
-    return null;
-};
-// A trace once found keeps its path; only its time is read again.
-const found = new Map();
-// Which tool a session runs and the id its trace is named by: Claude Code sessions are `claude:<id>`; a Codex chat
-// names itself with RINGI_SESSION=codex-<thread id>.
-export const toolOf = (s) => {
-    const id = UUID.exec(s.handle)?.[1];
-    if (!id)
-        return null;
-    if (s.handle.startsWith('claude:') || s.product === 'claude')
-        return { tool: 'claude', id };
-    if (s.product === 'codex' || s.handle.startsWith('env:codex-'))
-        return { tool: 'codex', id };
-    return null;
-};
-// When the session's tool last wrote its trace (unix seconds), or null: no tool known, or no trace found.
-export const traceTime = (s) => {
-    const t = toolOf(s);
-    if (!t)
-        return null;
-    const key = `${t.tool}:${t.id}`;
-    if (!found.has(key)) {
-        const f = t.tool === 'claude' ? claude(t.id) : codex(t.id);
-        if (!f)
-            return null;
-        found.set(key, f);
-    }
-    return mtime(found.get(key));
-};
-//# sourceMappingURL=tools.js.map

package/target/esm/home/index.js

@@ -1,88 +0,0 @@
-// home: where ringi keeps its state on this machine. $RINGI_HOME holds hubs (each a descriptor and a store),
-// reader state, session records and locks. Reading state fails closed; a write the sandbox denies fails with one
-// fixed instruction.
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { errno, fail, guardWrite, locked as lockFile, mkdirIn, note, writeJsonAtomic } from '../lib/index.js';
-const HERE = path.dirname(fileURLToPath(import.meta.url));
-// This file sits in src/main/ts/home (source) or target/esm/home (build): three levels below the package root.
-export const ROOT = path.resolve(HERE, '..', '..', '..');
-export const RESOURCES = path.join(ROOT, 'src', 'main', 'resources');
-export const VERSION = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf8')).version;
-export const HOME = path.resolve(process.env.RINGI_HOME || path.join(os.homedir(), '.ringi'));
-export const HOME_VERSION = 3;
-export const OPERATOR = 'operator';
-// --- writing safely ---
-export const guard = (fn) => guardWrite(HOME, fn);
-export const mkdir = (d) => mkdirIn(HOME, d);
-export const writeJson = (f, v) => guard(() => {
-    mkdir(path.dirname(f));
-    writeJsonAtomic(f, v);
-});
-// State fails closed: unreadable JSON is an error, never a silent fresh start.
-export const readJson = (f, dflt) => {
-    let raw;
-    try {
-        raw = fs.readFileSync(f, 'utf8');
-    }
-    catch (e) {
-        if (errno(e) === 'ENOENT')
-            return dflt;
-        throw e;
-    }
-    try {
-        return JSON.parse(raw);
-    }
-    catch (e) {
-        return fail(`${f} is not valid JSON (${e.message}); refusing to continue with lost state`);
-    }
-};
-// --- the home ---
-export const hubsDir = () => path.join(HOME, 'hub');
-export const hubHome = (name) => path.join(hubsDir(), name);
-// The home is created on first use; anything else at that path is refused. A home of the previous layout (each hub a
-// bare repository `hub/<name>.git` with its settings in git config) is moved into descriptor and store.
-export const ensureHome = () => {
-    const marker = path.join(HOME, 'home.json');
-    if (fs.existsSync(marker)) {
-        const h = readJson(marker, {});
-        if (h.version === 2)
-            return migrate2(marker);
-        if (h.version !== HOME_VERSION)
-            fail(`${HOME} is a ringi home of version ${h.version}; this ringi ${VERSION} needs version ${HOME_VERSION}`);
-        return;
-    }
-    if (fs.existsSync(HOME) && fs.readdirSync(HOME).length)
-        fail(`${HOME} exists and is not a ringi home (no home.json); move it away or set RINGI_HOME`);
-    mkdir(HOME);
-    writeJson(marker, { version: HOME_VERSION });
-};
-const migrate2 = (marker) => {
-    for (const f of fs.existsSync(hubsDir()) ? fs.readdirSync(hubsDir()).filter(f => f.endsWith('.git')) : []) {
-        const name = f.slice(0, -4);
-        const old = path.join(hubsDir(), f);
-        const cfg = (k) => String(spawnSync('git', ['--git-dir', old, 'config', '--get', k], { encoding: 'utf8' }).stdout ?? '').trim();
-        const signed = cfg('ringi.type') === 'remote';
-        const descriptor = { schema: 'ringi-hub/2', name, trust: signed ? 'signed' : 'asserted',
-            ...(signed ? { root: cfg('ringi.rootKey') || undefined, genesis: cfg('ringi.genesis') || undefined } : {}),
-            store: { type: 'git', path: 'store', ...(cfg('remote.origin.url') ? { remote: cfg('remote.origin.url') } : {}) } };
-        mkdir(path.join(hubHome(name), 'store'));
-        guard(() => fs.renameSync(old, path.join(hubHome(name), 'store', '.git')));
-        writeJson(path.join(hubHome(name), 'hub.json'), descriptor);
-        note(`moved hub ${name} to ${hubHome(name)} (descriptor hub.json, store/.git)`);
-    }
-    writeJson(marker, { version: HOME_VERSION });
-};
-export const locked = (name, fn) => {
-    ensureHome();
-    const dir = path.join(HOME, 'locks');
-    mkdir(dir);
-    return guard(() => lockFile(path.join(dir, `${name}.lock`), fn));
-};
-export const configFile = () => path.join(HOME, 'config.json');
-export const config = () => ({ hub: 'local', room: null, ...readJson(configFile(), {}) });
-export const setConfig = (patch) => writeJson(configFile(), { ...config(), ...patch });
-//# sourceMappingURL=index.js.map

package/target/esm/hub/index.js

@@ -1,224 +0,0 @@
-// hub: hubs and rooms on top of any store. A hub is a directory with a descriptor (hub.json: which store, where,
-// what this machine pins) beside its store. Its shared contract lives in the store (contract.json, authority.json,
-// profiles/*.json). This file reads contracts, opens rooms with their profile and authority, and decides what a reader
-// accepts: only history that extends what it accepted before, from members the store verifies (docs/spec/hub-1.md, Trust).
-import fs from 'node:fs';
-import path from 'node:path';
-import * as D from '../domain/decisions.js';
-import { CAPABILITIES, unenforceable } from '../domain/index.js';
-import { GitStore } from '../store/git/index.js';
-import { HOME, OPERATOR, RESOURCES, VERSION, ensureHome, hubHome, hubsDir, locked, mkdir, writeJson } from '../home/index.js';
-import { DEFAULT_PROFILE, PROFILES_CAPABILITY, parseProfile } from '../domain/profiles.js';
-import { HIDDEN, compose, decodeText, link, parse } from '../protocol/index.js';
-import { emit } from './signals.js';
-import { STORES } from '../store/index.js';
-import { fail, short, strictJson } from '../lib/index.js';
-export const HUB_MAJOR = 1;
-export const CAPS = new Set(Object.keys(CAPABILITIES));
-export const RESERVED_ROOMS = new Set(['main', 'archive']);
-// Whether the room's work has started: it has the quorum of agents its genesis asked for (`Quorum`), or asked for none.
-export const start = (R) => {
-    const agents = Object.values(R.members).filter(m => m.role !== 'root').length;
-    return { quorum: R.quorum, agents, started: R.quorum === null || agents >= R.quorum };
-};
-// --- hubs ---
-export const hubNames = () => {
-    try {
-        return fs.readdirSync(hubsDir()).filter(n => fs.existsSync(path.join(hubsDir(), n, 'hub.json'))).sort();
-    }
-    catch {
-        return [];
-    }
-};
-const HUB_MD = `# ringi hub
-
-The shared contract of a ringi hub (docs/spec/hub-1.md): contract.json (schema, version, protocol, trust, capabilities, the
-default profile), authority.json (who may decide what, up to which budget; the root, \`operator\`, always may) and
-profiles/ (what a piece of work is in a room: its states, and who may move it). Use \`ringi\`; never edit by hand.
-`;
-const readProfileResource = (name) => fs.readFileSync(path.join(RESOURCES, 'profiles', `${name}.json`), 'utf8');
-// A new hub: local (asserted senders), or signed, with the operator's root key generated on this machine and pinned.
-export const createHub = (name, { signed = false, url } = {}) => {
-    ensureHome();
-    const dir = hubHome(name);
-    if (fs.existsSync(dir))
-        fail(`hub ${name} exists`);
-    if (url && !signed)
-        fail('--url publishes a hub; only a --signed hub may be published');
-    const d = { schema: 'ringi-hub/2', name, trust: signed ? 'signed' : 'asserted', store: { type: 'git', path: 'store', ...(url ? { remote: url } : {}) } };
-    try {
-        mkdir(dir);
-        if (signed)
-            d.root = GitStore.rootFor(dir, d, HOME);
-        const contract = { schema: 'ringi-hub', version: '1.1', protocol: 1, trust: d.trust, capabilities: [D.CAPABILITY, PROFILES_CAPABILITY], profile: DEFAULT_PROFILE, ...(d.root ? { root: d.root } : {}) };
-        const store = GitStore.create(dir, d, HOME, {
-            'contract.json': JSON.stringify(contract, null, 2) + '\n',
-            'authority.json': JSON.stringify({ decide: {} }, null, 2) + '\n',
-            'HUB.md': HUB_MD,
-            [`profiles/${DEFAULT_PROFILE}.json`]: readProfileResource(DEFAULT_PROFILE),
-        }, compose(`hub ${name}`, [['To', '*'], ['Kind', 'hub']]));
-        if (signed)
-            d.genesis = store.contractHead();
-        writeJson(path.join(dir, 'hub.json'), d);
-    }
-    catch (e) {
-        if (!fs.existsSync(path.join(dir, 'hub.json')))
-            fs.rmSync(dir, { recursive: true, force: true });
-        throw e;
-    }
-};
-export const readDescriptor = (name) => {
-    const f = path.join(hubHome(name), 'hub.json');
-    if (!fs.existsSync(f))
-        fail(`no hub ${name}; hubs: ${hubNames().join(', ') || 'none'}`);
-    const d = strictJson(fs.readFileSync(f, 'utf8'), f);
-    if (d.schema !== 'ringi-hub/2' || d.name !== name || !['signed', 'asserted'].includes(d.trust) || !d.store?.type || !d.store.path)
-        fail(`${f} is not a ringi hub descriptor this ringi ${VERSION} reads`);
-    return d;
-};
-// The contract a tool must understand before it touches a hub or a room: known schema, major and capabilities.
-export const contractAt = (store, name, rev) => {
-    const text = store.contractFile(rev, 'contract.json') ?? store.contractFile(rev, 'hub.json') ?? fail(`hub ${name} has no contract at ${short(rev)}`);
-    const c = strictJson(text, `hub ${name}: contract`);
-    if (c.schema !== 'ringi-hub')
-        fail(`hub ${name} declares schema ${String(c.schema)}, not ringi-hub`);
-    const major = Number(String(c.version).split('.')[0]);
-    if (major !== HUB_MAJOR)
-        fail(`hub ${name} follows contract version ${c.version}; this ringi ${VERSION} supports ${HUB_MAJOR}.x. Upgrade ringi`);
-    const why = unenforceable(c.capabilities ?? []);
-    if (why)
-        fail(`hub ${name} ${why}, which this ringi ${VERSION} cannot enforce. Upgrade ringi`);
-    const a = store.contractFile(rev, 'authority.json');
-    return { ...c, authority: a === null ? {} : strictJson(a, `hub ${name}: authority.json at ${short(rev)}`) };
-};
-// A hub is opened once per process; its store syncs then (a signed store fetches and verifies), and again on refresh.
-const opened = new Map();
-export const openHub = (name, { refresh = false } = {}) => {
-    ensureHome();
-    if (!/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/.test(name))
-        fail(`bad hub name ${name}`);
-    if (opened.has(name) && !refresh)
-        return opened.get(name);
-    if (name === 'local' && !fs.existsSync(path.join(hubHome(name), 'hub.json')))
-        createHub('local');
-    const d = readDescriptor(name);
-    const factory = STORES[d.store.type] ?? fail(`hub ${name} uses a ${d.store.type} store; this ringi ${VERSION} knows ${Object.keys(STORES).join(', ')}`);
-    const store = factory(hubHome(name), d, HOME);
-    store.sync();
-    const main = store.contractHead();
-    const H = { name, dir: hubHome(name), d, store, main, contract: contractAt(store, name, main), signed: d.trust === 'signed' };
-    opened.set(name, H);
-    return H;
-};
-// --- rooms ---
-export const roomNames = (H, archived = false) => H.store.roomNames(archived);
-export const openRoom = (H, name, { quiet = 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 (quiet)
-            return null;
-        const gone = roomNames(H, true).find(a => a.startsWith(`${name}@`));
-        return fail(gone ? `room ${name} is archived as ${gone}; read it with --room ${gone}` : `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 named = s.archived ? name.slice(0, name.lastIndexOf('@')) : name;
-    const subject = s.control[0]?.rev === s.genesis ? s.control[0].text.split('\n')[0] : '(none)';
-    if (subject !== `room ${named}` || (s.archived && name !== `${named}@${s.genesis.slice(0, 8)}`))
-        fail(`room ${name}: its genesis is "${subject}"; refusing a room's history under another name`);
-    // The contract in effect at each control entry: the hub contract the room was created on, then each `Contract:`
-    // the operator moved it to. A decision names the control entry it was made under (decide.ts).
-    const atControl = new Map();
-    let current = s.base;
-    for (const rec of s.control) {
-        const m = /^Contract: ([0-9a-f]{40,64})$/m.exec(rec.text);
-        if (m)
-            current = m[1];
-        atControl.set(rec.rev, current);
-    }
-    const contract = current === H.main ? H.contract : contractAt(H.store, H.name, current);
-    const tables = new Map();
-    const authorityAt = (control) => {
-        const rev = control ? atControl.get(control) : undefined;
-        if (!rev)
-            return null;
-        if (!tables.has(rev))
-            tables.set(rev, contractAt(H.store, H.name, rev).authority);
-        return tables.get(rev);
-    };
-    // 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 baseProfile = contractAt(H.store, H.name, s.base).profile ?? DEFAULT_PROFILE;
-    const profileText = H.store.controlFile(s, 'profile.json', s.genesis)
-        ?? H.store.contractFile(s.base, `profiles/${baseProfile}.json`)
-        ?? (baseProfile === DEFAULT_PROFILE ? readProfileResource(DEFAULT_PROFILE) : fail(`room ${name}: unknown profile ${baseProfile}`));
-    const roster = H.store.roster(s);
-    const members = roster?.members ?? strictJson(H.store.controlFile(s, 'members.json') ?? '{}', `room ${name}: members.json`);
-    // The root's control records set the quorum; the latest one counts.
-    let quorum = null;
-    for (const rec of s.control) {
-        const m = /^Quorum: ([1-9][0-9]?)$/m.exec(rec.text);
-        if (m)
-            quorum = Number(m[1]);
-    }
-    return { hub: H, s, name, archived: s.archived, head: s.head, genesis: s.genesis, contractRev: current, contract, authorityAt,
-        profile: parseProfile(profileText, `room ${name}: profile`), members, quorum };
-};
-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);
-// 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`);
-    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.members = members;
-});
-// --- messages and what a reader accepts ---
-export const toMessage = (R, from, x, seq) => {
-    const trust = R.hub.signed ? 'verified' : 'asserted';
-    const files = x.files.map(f => ({ path: f.path, size: null }));
-    const base = { id: x.id, from, trust, time: x.time, seq, files, refused: x.refused, reId: null, hopEff: 0 };
-    const d = decodeText(x.text);
-    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));
-    // An extension's trailers and the room profile's states are part of a message's validity.
-    const ext = D.check(p, s => R.hub.store.isRef(s));
-    const state = !p.bad && p.state && !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 ?? ext ?? state };
-};
-// 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.
-export 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 CARRIES = (p, R) => !p.bad && (p.kind === R.profile.opens || !!p.assign || !!p.state || ['proposal', 'stamp', 'decision', 'usage'].includes(p.kind ?? ''));
-// A message on the author's log, and the signals it made (signals.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 all = asStored(R);
-        const m = all.get(id);
-        if (m)
-            emit(R, who, all, m);
-    }
-    return id;
-};
-export const withSizes = (R, m) => {
-    if (!m.files.length)
-        return [];
-    const sizes = R.hub.store.sizes(m.id, m.files.map(f => f.path));
-    return m.files.map(f => ({ ...f, size: sizes.get(f.path) ?? null }));
-};
-export const pongText = (me, m, what) => compose(`pong: ${me} ${what}`, [['To', m.from], ['Re', m.id], ['Kind', 'pong'], ['Hop', String(m.hopEff + 1)]]);
-export { OPERATOR, HIDDEN };
-//# sourceMappingURL=index.js.map