@idleware/ringi 0.7.2 → 0.8.1

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

@@ -1,44 +0,0 @@
-// heartbeat-push: a beat published with a lease on the object it replaces; a stale update loses.
-import * as C from '../../../lib/index.js';
-import { git, isRemote, locked, object, origin } from './git.js';
-import { checkHeartbeat, heartbeatRef } from './heartbeat.js';
-import { checkUrl } from './keys.js';
-import { SHA, TAG_ACCEPT, TAG_TRACK, TAGS } from './types.js';
-// Publish only the actor's exact heartbeat with an explicit old OID. A racing beat is ordinary contention, never a
-// signal rewrite alarm. Neither success nor failure changes immutable acceptance pins or history state.
-export const pushHeartbeat = (H, R, who, sha, expected) => {
-    const ref = heartbeatRef(who, R.genesis);
-    if (!SHA.test(sha) || (expected !== null && !SHA.test(expected)))
-        C.fail('heartbeat publication requires full object ids');
-    if (!isRemote(H))
-        return true;
-    return locked(H, () => publishHeartbeat({ H, R, ref, sha, expected }));
-};
-const publishHeartbeat = ({ H, R, ref, sha, expected }) => {
-    if (object(H, ref) !== sha)
-        return false;
-    if (object(H, TAG_ACCEPT + ref.slice(TAGS.length)))
-        C.fail('heartbeat namespace overlaps previously accepted signal history');
-    checkHeartbeat(H, R, ref, sha);
-    const url = origin(H);
-    if (!url)
-        return true;
-    checkUrl(url);
-    const r = git(H, ['push', '-q', '--porcelain', `--force-with-lease=${ref}:${expected ?? ''}`, url, `${sha}:${ref}`], { ok: true });
-    if (r.status !== 0 && !reconcileHeartbeat(H, { url, ref, sha, stdout: r.stdout, stderr: r.stderr }))
-        return false;
-    git(H, ['update-ref', TAG_TRACK + ref.slice(TAGS.length), sha]);
-    if (H.heartbeatErrors)
-        delete H.heartbeatErrors[ref];
-    return true;
-};
-const reconcileHeartbeat = (H, { url, ref, sha, stdout, stderr }) => {
-    const observed = git(H, ['ls-remote', '--refs', url, ref], { ok: true });
-    const got = observed.status === 0 ? observed.stdout.trim().split(/\s+/) : [];
-    if (got[0] === sha && got[1] === ref)
-        return true;
-    if (/\[rejected\].*\(stale info\)/.test(stdout))
-        return false;
-    return C.fail(`heartbeat push failed for ${ref.slice(TAGS.length)}: ${String(stderr || stdout || 'transport error').trim().split('\n').at(-1)}`);
-};
-//# sourceMappingURL=heartbeat-push.js.map

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

@@ -1,44 +0,0 @@
-// heartbeat: a signed heartbeat made and verified; it is published by heartbeat-push.ts.
-import * as C from '../../../lib/index.js';
-import { git, isRemote, reason } from './git.js';
-import { heartbeatBody } from './heartbeat-facts.js';
-import { heartbeatRef } from './heartbeat-name.js';
-import { checkHeartbeat } from './heartbeat-object.js';
-import { signBytes } from '../signing.js';
-import { SHA, TAGS } from './types.js';
-export { checkHeartbeat, heartbeatObject } from './heartbeat-object.js';
-export { heartbeatBody } from './heartbeat-facts.js';
-export { HEARTBEAT_NAME, heartbeatName, heartbeatRef } from './heartbeat-name.js';
-export const verifyHeartbeat = (H, R, ref, sha) => {
-    if (!isRemote(H))
-        return null;
-    if (H.remoteAlarms?.[ref])
-        return H.remoteAlarms[ref];
-    if (H.heartbeatErrors?.[ref])
-        return H.heartbeatErrors[ref];
-    try {
-        checkHeartbeat(H, R, ref, sha);
-        return null;
-    }
-    catch (e) {
-        return reason(e);
-    }
-};
-// Object construction has one named input; signing needs no custody path.
-export const makeHeartbeat = (...[H, R, who, target, text]) => createHeartbeat({ H, R, who, target, text });
-const createHeartbeat = ({ H, R, who, target, text }) => {
-    const ref = heartbeatRef(who, R.genesis);
-    if (!SHA.test(target))
-        C.fail('heartbeat target must be a full commit id');
-    if (/^Room:/m.test(text))
-        C.fail('heartbeat Room is transport metadata');
-    const body = `Room: ${R.genesis}\n${text.trimEnd()}\n`;
-    heartbeatBody(body);
-    const raw = `object ${target}\ntype commit\ntag ${ref.slice(TAGS.length)}\ntagger ${who} <${who}@ringi> ${Math.floor(Date.now() / 1000)} +0000\n\n${body}`;
-    const signature = signBytes(H, who, raw);
-    const sha = git(H, ['mktag'], { input: raw + signature }).trim();
-    if (isRemote(H))
-        checkHeartbeat(H, R, ref, sha);
-    return sha;
-};
-//# sourceMappingURL=heartbeat.js.map

package/target/esm/adapters/transport-git/remote/push-validate.js

@@ -1,39 +0,0 @@
-// push-validate: a ref checked before it is published: main, a room's branch, or an actor's signal on a message of a
-// verified room.
-import * as C from '../../../lib/index.js';
-import * as P from '../../../core/hub/protocol/index.js';
-import { branchData } from './branch.js';
-import { ancestor, refs } from './git.js';
-import { verifyMain } from './main.js';
-import { checkSignal, signalObject } from './signals.js';
-import { TAGS } from './types.js';
-export const validateRef = (H, ref, sha) => {
-    if (ref.startsWith(TAGS)) {
-        return validateSignalRef(H, ref, sha);
-    }
-    if (ref === 'refs/heads/main') {
-        verifyMain(H, sha);
-        return;
-    }
-    const room = /^refs\/heads\/([^/]+)$/.exec(ref) ?? C.fail('only explicit main, room or signal refs may be pushed');
-    if (!P.ID_RE.test(room[1]))
-        C.fail('only explicit main, room or signal refs may be pushed');
-    const why = branchData(H, room[1], sha).skipped.get(sha);
-    if (why)
-        C.fail(`${sha.slice(0, 12)} is no valid commit of room ${room[1]}: ${why}`);
-};
-const validateSignalRef = (H, ref, sha) => {
-    const s = signalObject(H, ref, sha);
-    for (const [branchRef, head] of refs(H, 'refs/heads/')) {
-        const name = branchRef.slice('refs/heads/'.length);
-        if (name === 'main' || name.includes('/') || !ancestor(H, s.message, head))
-            continue;
-        const b = branchData(H, name, head);
-        if (b.control.includes(s.message) || b.authors.has(s.message) || b.skipped.has(s.message)) {
-            checkSignal(H, { name, ref: branchRef, head: b.control.at(-1), genesis: b.genesis }, ref, sha);
-            return;
-        }
-    }
-    return C.fail('signal points at no verified room');
-};
-//# sourceMappingURL=push-validate.js.map

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

@@ -1,63 +0,0 @@
-// signals: a signal tag's name, object and target checked: its actor's own, on a message of the room's branch.
-import * as C from '../../../lib/index.js';
-import * as P from '../../../core/hub/protocol/index.js';
-import { branch } from './branch.js';
-import { git, isRemote, reason, rev } from './git.js';
-import { heartbeatName } from './heartbeat.js';
-import { checkSignature } from './signature.js';
-import { SHA, TAGS } from './types.js';
-export const SIGNAL_NAME = /^([a-z0-9]+(?:[_-][a-z0-9]+)*)\.([a-z][a-z0-9.-]*)\.([0-9a-f]{12})$/;
-export const signalName = (ref) => {
-    if (heartbeatName(ref))
-        C.fail('heartbeat is not an immutable signal');
-    const m = ref.startsWith(TAGS) && SIGNAL_NAME.exec(ref.slice(TAGS.length));
-    if (!m)
-        return C.fail('malformed signal tag namespace');
-    return { actor: m[1], id: m[3], signal: m[2] };
-};
-// The signed header carries the full target, tag name and actor; there is no message body.
-export const signalObject = (H, ref, sha) => {
-    const s = signalName(ref);
-    if (git(H, ['cat-file', '-t', sha]).trim() !== 'tag')
-        C.fail('signal must be an annotated tag');
-    const text = P.decodeText(git(H, ['cat-file', 'tag', sha], { raw: true }));
-    if (text.invalid)
-        C.fail(`signal tag is ${text.invalid}`);
-    const [header, ...rest] = text.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 signal tag headers');
-    if (!SHA.test(target[1]) || !target[1].startsWith(s.id) || target[2] !== ref.slice('refs/tags/'.length) || target[3].trim() !== s.actor)
-        C.fail('signal tag name, actor or target disagrees');
-    const body = rest.join('\n\n').split('-----BEGIN SSH SIGNATURE-----')[0];
-    if (body !== '')
-        C.fail('signal tag message must be empty');
-    return { ...s, message: target[1] };
-};
-// Derived signals belong to their message's author; read/taken marks may name another member's message.
-// The room is determined by the full target commit on its verified branch, never by a short name or a tag body.
-export const checkSignal = (H, R, ref, sha) => {
-    const s = signalObject(H, ref, sha);
-    const b = branch(H, R, rev(H, R.ref) ?? C.fail('signal room has no branch here'));
-    const signer = b.entries.find(e => e.principal === s.actor) ?? C.fail(`unadmitted signal principal ${s.actor}`);
-    checkSignature(H, sha, s.actor, signer.key, 'tag');
-    const mark = s.signal === 'read' || s.signal === 'taken';
-    if (s.message === R.genesis)
-        C.fail('signal points at no message of this room');
-    const author = b.authors.get(s.message);
-    if (!(mark ? author : author === s.actor))
-        C.fail(`signal points at no accepted message ${mark ? 'of this room' : 'of its actor'}`);
-};
-export const verifySignal = (H, R, ref, sha) => {
-    if (!isRemote(H))
-        return null;
-    const alarm = H.remoteAlarms?.[ref];
-    if (alarm)
-        return alarm;
-    try {
-        checkSignal(H, R, ref, sha);
-        return null;
-    }
-    catch (e) {
-        return reason(e);
-    }
-};
-//# sourceMappingURL=signals.js.map

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

@@ -1,26 +0,0 @@
-// sync-heartbeat: a fetched heartbeat verified and installed as the remote's current object; its errors stay apart
-// from signal alarms.
-import * as C from '../../../lib/index.js';
-import { git, reason } from './git.js';
-import { checkHeartbeat, heartbeatObject } from './heartbeat.js';
-import { TAGS, TAG_ACCEPT, TAG_TRACK } from './types.js';
-export const syncHeartbeat = ({ H, tags, pinned, byGenesis }, name) => {
-    const beatRef = TAGS + name;
-    if (pinned.has(TAG_ACCEPT + name)) {
-        H.remoteAlarms[beatRef] = 'heartbeat namespace overlaps a previously accepted signal; operator review required';
-        return;
-    }
-    try {
-        const sha = tags.get(TAG_TRACK + name) ?? C.fail('heartbeat is absent from the remote');
-        const b = heartbeatObject(H, beatRef, sha);
-        const R = byGenesis.get(b.genesis) ?? C.fail('heartbeat room is missing or quarantined');
-        checkHeartbeat(H, R, beatRef, sha);
-        git(H, ['update-ref', beatRef, sha]);
-    }
-    catch (e) {
-        H.heartbeatErrors[beatRef] = reason(e);
-        git(H, ['update-ref', '-d', beatRef]);
-        C.note(`heartbeat ${name}: ${reason(e)}; withheld`);
-    }
-};
-//# sourceMappingURL=sync-heartbeat.js.map

package/target/esm/adapters/transport-git/remote/sync-rooms.js

@@ -1,38 +0,0 @@
-// sync-rooms: the rooms' branches as fetched, verified, and indexed by genesis and by commit.
-import * as C from '../../../lib/index.js';
-import * as P from '../../../core/hub/protocol/index.js';
-import { branchData } from './branch.js';
-import { promote, reason, refs, rev } from './git.js';
-import { ACCEPT, TRACK } from './types.js';
-export const syncRooms = (H, fetched) => {
-    // Every other branch is a room.
-    const names = roomNames(H, fetched);
-    const byGenesis = new Map(), byTarget = new Map();
-    for (const name of names) {
-        const ref = 'refs/heads/' + name;
-        try {
-            if (!P.ID_RE.test(name))
-                C.fail('invalid room name');
-            const sha = fetched.get(TRACK + name) ?? C.fail(`${name} was deleted on the remote`);
-            const data = branchData(H, name, sha);
-            if (byGenesis.has(data.genesis))
-                C.fail('room genesis is already bound to another room');
-            promote(H, ref, sha);
-            // Local commits not yet published stay on top.
-            const local = branchData(H, name, rev(H, ref), data.genesis);
-            const R = { name, ref, head: local.control.at(-1), genesis: data.genesis };
-            byGenesis.set(data.genesis, R);
-            for (const target of [...local.control, ...local.authors.keys(), ...local.skipped.keys()])
-                byTarget.set(target, R);
-        }
-        catch (e) {
-            H.remoteAlarms[ref] = reason(e);
-        }
-    }
-    return { byGenesis, byTarget };
-};
-const roomNames = (H, fetched) => {
-    const names = new Set([...fetched.keys(), ...refs(H, ACCEPT).keys()].map(r => r.slice(r.startsWith(TRACK) ? TRACK.length : ACCEPT.length)).filter(r => r !== 'main' && !r.includes('/')));
-    return names;
-};
-//# sourceMappingURL=sync-rooms.js.map

package/target/esm/adapters/transport-git/remote/sync-tags.js

@@ -1,48 +0,0 @@
-// sync-tags: fetched tags sorted into signals (immutable, pinned) and heartbeats (replaced).
-import * as C from '../../../lib/index.js';
-import { git, object, reason, refs, zero } from './git.js';
-import { heartbeatName } from './heartbeat.js';
-import { SIGNAL_NAME, checkSignal, signalObject } from './signals.js';
-import { TAGS, TAG_ACCEPT, TAG_TRACK } from './types.js';
-import { syncHeartbeat } from './sync-heartbeat.js';
-const missingHeartbeats = (H, tags, pinned) => {
-    // Include local beats to remove disappeared remote telemetry; unlike signals, nothing is pinned.
-    for (const ref of refs(H, TAGS).keys())
-        if (heartbeatName(ref) && !tags.has(TAG_TRACK + ref.slice(TAGS.length))) {
-            if (pinned.has(TAG_ACCEPT + ref.slice(TAGS.length)))
-                continue; // never waive previously accepted history
-            git(H, ['update-ref', '-d', ref]);
-        }
-};
-const syncSignal = ({ H, tags, pinned, byTarget }, name) => {
-    const ref = TAGS + name;
-    try {
-        const sha = tags.get(TAG_TRACK + name) ?? C.fail('signal was deleted on the remote after acceptance');
-        const s = signalObject(H, ref, sha);
-        const R = byTarget.get(s.message) ?? C.fail('signal room is missing or quarantined');
-        checkSignal(H, R, ref, sha);
-        const acc = pinned.get(TAG_ACCEPT + name), cur = object(H, ref);
-        if (acc && acc !== sha)
-            C.fail('signal was replaced after transport acceptance');
-        if (cur && cur !== sha)
-            C.fail('signal diverges from the local tag object');
-        git(H, ['update-ref', ref, sha, cur ?? zero(H)]);
-        git(H, ['update-ref', TAG_ACCEPT + name, sha, acc ?? zero(H)]);
-    }
-    catch (e) {
-        H.remoteAlarms[ref] = reason(e);
-    }
-};
-export const syncTags = (H, rooms) => {
-    const tags = refs(H, TAG_TRACK), pinned = refs(H, TAG_ACCEPT);
-    missingHeartbeats(H, tags, pinned);
-    const state = { H, tags, pinned, ...rooms };
-    const names = new Set([...tags.keys()].map(r => r.slice(TAG_TRACK.length)).concat([...pinned.keys()].map(r => r.slice(TAG_ACCEPT.length))));
-    for (const name of names) {
-        if (heartbeatName(TAGS + name))
-            syncHeartbeat(state, name);
-        else if (SIGNAL_NAME.test(name))
-            syncSignal(state, name);
-    }
-};
-//# sourceMappingURL=sync-tags.js.map

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

@@ -1,38 +0,0 @@
-// sync: one fetch of a signed hub under its transport lock: contract, rooms, signals and heartbeats verified.
-import * as C from '../../../lib/index.js';
-import { pushAlarms } from './alarms.js';
-import { git, isRemote, locked, origin, promote, reason, refs, rev, suffix } from './git.js';
-import { checkUrl } from './keys.js';
-import { verifyHub, verifyMain } from './main.js';
-import { syncRooms } from './sync-rooms.js';
-import { syncTags } from './sync-tags.js';
-import { TAGS, TAG_TRACK, TRACK } from './types.js';
-const syncUnlocked = (H) => {
-    H.remoteAlarms = { ...pushAlarms(H) };
-    H.heartbeatErrors = {};
-    const url = origin(H);
-    if (!url) {
-        if (rev(H, 'refs/heads/main'))
-            verifyHub(H);
-        return H;
-    }
-    checkUrl(url);
-    git(H, ['-c', 'fetch.fsckObjects=true', 'fetch', '-q', '--no-tags', '--prune', url,
-        `+refs/heads/*:${TRACK}*`, `+${TAGS}*:${TAG_TRACK}*`]);
-    const fetched = refs(H, TRACK);
-    const main = fetched.get(TRACK + 'main') || C.fail('ALARM remote main was deleted or is missing; refusing authority from the hub');
-    try {
-        verifyMain(H, main);
-        promote(H, 'refs/heads/main', main);
-    }
-    catch (e) {
-        C.fail(`ALARM hub ${H.name}: ${reason(e)}; nothing is delivered`);
-    }
-    H.main = rev(H, 'refs/heads/main');
-    syncTags(H, syncRooms(H, fetched));
-    for (const [ref, why] of Object.entries(H.remoteAlarms))
-        C.note(`ALARM ${suffix(ref)}: ${why}; quarantined and withheld`);
-    return H;
-};
-export const sync = (H) => !isRemote(H) ? H : locked(H, () => syncUnlocked(H));
-//# sourceMappingURL=sync.js.map

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

@@ -1,21 +0,0 @@
-// tags: signal tags as git lists them, and an annotated tag object read whole.
-const SIGNAL_REF = /^refs\/tags\/([a-z0-9]+(?:[_-][a-z0-9]+)*)\.([a-z][a-z0-9.-]*\.[0-9a-f]{12})$/;
-// `for-each-ref` lines `<ref> <object> <type>` of tags named `<actor>.<signal>.<message12>`, but for heartbeats.
-export const signalTags = (listing, heartbeat) => listing.split('\n').flatMap(line => {
-    const [ref, object, type] = line.split(' ');
-    const m = SIGNAL_REF.exec(ref ?? '');
-    return m && !heartbeat(ref) ? [{ ref, actor: m[1], name: m[2], object, type }] : [];
-});
-// A tag object's target commit, tagger and time, and its text without a signature.
-export const tagObject = (body) => {
-    const split = body.indexOf('\n\n');
-    const hdr = body.subarray(0, split < 0 ? body.length : split).toString('utf8');
-    const tagger = /^tagger (.*?) <[^>\n]*> (\d+) [+-]\d{4}$/m.exec(hdr);
-    return {
-        target: /^object ([0-9a-f]+)\ntype commit$/m.exec(hdr)?.[1] ?? '',
-        tagger: tagger?.[1] ?? '',
-        time: Number(tagger?.[2] ?? NaN),
-        text: split < 0 ? '' : body.subarray(split + 2).toString('utf8').split('-----BEGIN SSH SIGNATURE-----')[0],
-    };
-};
-//# sourceMappingURL=tags.js.map

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

@@ -1,29 +0,0 @@
-// transport: the git store as a store type: a hub's repository is `store/.git` in the hub's directory; a signed hub's
-// root identity comes from Signer and a published hub is replicated by bootstrap (remote/bootstrap.ts).
-import { fail } from '../../lib/index.js';
-import { GitStore } from './index.js';
-import * as Remote from './remote.js';
-const context = (d, opt) => d.trust === 'signed'
-    ? (typeof opt.signer === 'function' ? opt.signer() : opt.signer) ?? fail('signed hubs require an injected Signer')
-    : undefined;
-// `home`: where this machine keeps its state and scratch indexes; Signer owns key custody.
-export const gitTransport = (home, opt = {}) => ({
-    // One branch per room with its messages and control records, signals as tags on them (hub-1, Layout).
-    layout: 'git/2',
-    // Before contracts named it: ringi 0.1 kept a room as branches under `<room>/` (git/1).
-    layoutOf: store => store.roomBranches().some(b => b.includes('/')) ? 'git/1' : 'git/2',
-    open: (at, d) => new GitStore(at, d, home, context(d, opt)),
-    create: (at, d, genesis) => {
-        const signing = context(d, opt);
-        if (signing)
-            d.root = GitStore.rootFor(at, d, home, signing);
-        const g = genesis(d);
-        const store = GitStore.create(at, d, { home, signing }, g.files, g.text);
-        if (d.trust === 'signed')
-            d.genesis = store.contractHead();
-        const custody = signing?.custody?.(d.name, 'operator') ?? null;
-        return { store, custody };
-    },
-    attach: (name, url, pins) => { Remote.hubAdd({ home, name, url, ...pins }); },
-});
-//# sourceMappingURL=transport.js.map

package/target/esm/clients/cli/skill/targets.js

@@ -1,20 +0,0 @@
-// targets: where the skill goes: each agent tool's skill directory under the user's home or the project.
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { about } from '../../../core/hub/usecases/context.js';
-import { skillDirs } from '../../../core/agents/sessions/context.js';
-export const SKILL = path.join(about().resources, 'skill', 'ringi');
-export const skillTargets = (project) => {
-    const base = project ? process.cwd() : os.homedir();
-    return skillDirs(base);
-};
-export const sameSkill = (dir) => {
-    try {
-        return fs.readFileSync(path.join(dir, 'SKILL.md'), 'utf8') === fs.readFileSync(path.join(SKILL, 'SKILL.md'), 'utf8');
-    }
-    catch {
-        return false;
-    }
-};
-//# sourceMappingURL=targets.js.map

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

@@ -1,60 +0,0 @@
-// staging, like git's index: add takes a file's content into the store now, and the actor's next message carries it,
-// whatever happens to the file meanwhile. Results and state travel only so, never through a shared directory. The store
-// keeps staged contents reachable (`retain`); it grows before the list does and shrinks after, so a crash in between
-// leaks an object rather than loses one.
-import fs from 'node:fs';
-import { fail } from '../../../lib/index.js';
-import { checkCollisions } from '../protocol/files.js';
-import { loadState, readerLock, saveState } from '../history/index.js';
-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`);
-// What retain keeps: each staged content once, named by its id, so two snapshots of one path both stay.
-const kept = (all) => [...new Set(all.map(s => s.blob))].map(blob => ({ path: blob, blob, mode: '100644' }));
-export const staged = ({ R, me }) => loadState(R, me).staged ?? [];
-export const stage = ({ R, me }, files) => {
-    const taken = files.map(e => {
-        if (!e.file)
-            fail(`${e.path}: add takes files`);
-        tooBig(e.path, fs.statSync(e.file).size);
-        const b = R.hub.store.blob(e.file);
-        tooBig(e.path, b.size);
-        return { path: e.path, blob: b.id, mode: e.mode, size: b.size };
-    });
-    return readerLock(R, me, () => {
-        const st = loadState(R, me);
-        const next = new Map((st.staged ?? []).map(s => [s.path, s]));
-        for (const s of taken)
-            next.set(s.path, s);
-        const all = [...next.values()];
-        checkCollisions(all.map(s => s.path));
-        R.hub.store.retain(R.s, me, kept([...all, ...st.staged ?? []]));
-        saveState(R, me, { ...st, staged: all });
-        R.hub.store.retain(R.s, me, kept(all));
-        return all;
-    });
-};
-export const shrink = ({ R, me }, keep) => {
-    const st = loadState(R, me);
-    const left = (st.staged ?? []).filter(keep);
-    saveState(R, me, { ...st, staged: left });
-    R.hub.store.retain(R.s, me, kept(left));
-    return left;
-};
-// Unstages the given paths, or everything.
-export const unstage = (a, paths) => readerLock(a.R, a.me, () => {
-    const missing = (paths ?? []).filter(p => !staged(a).some(s => s.path === p));
-    if (missing.length)
-        fail(`not staged: ${missing.join(', ')}`);
-    return shrink(a, s => paths !== null && !paths.includes(s.path));
-});
-// What the actor staged goes along, an explicit attachment of the same path in its place.
-export const outgoing = (stagedNow, explicit) => {
-    for (const e of explicit)
-        if (e.file)
-            tooBig(e.path, fs.statSync(e.file).size);
-    const named = new Set(explicit.map(e => e.path));
-    const entries = [...stagedNow.filter(s => !named.has(s.path)).map(s => ({ path: s.path, blob: s.blob, mode: s.mode })), ...explicit];
-    checkCollisions(entries.map(e => e.path));
-    return entries;
-};
-//# sourceMappingURL=staging.js.map