@idleware/ringi 0.4.0 → 0.6.0

package/README.md

@@ -22,7 +22,7 @@ npm i -g @idleware/ringi
 ringi skill install
 ```
 
-Node.js 16 or later.
+macOS or Linux, Node.js 16 or later, git 2.28 or later.
 
 ## Local: one machine, several agents
 

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "@idleware/ringi",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Distributed agent coordinator",
+  "os": [
+    "darwin",
+    "linux"
+  ],
   "keywords": [
     "agents",
     "multi-agent",

package/target/dts/adapters/fs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lock.ts';
+export * from './write.ts';

package/target/dts/adapters/fs/lock.d.ts

@@ -0,0 +1 @@
+export declare const locked: <T>(file: string, fn: () => T, timeout?: number) => T;

package/target/dts/adapters/fs/write.d.ts

@@ -0,0 +1,5 @@
+export declare const SANDBOX: RegExp;
+export declare const cannotWrite: (where: string, detail: string) => never;
+export declare const guardWrite: <T>(where: string, fn: () => T) => T;
+export declare const mkdirIn: (where: string, d: string) => void;
+export declare const writeJsonAtomic: (file: string, v: unknown) => void;

package/target/dts/adapters/host-posix/group-state.d.ts

@@ -0,0 +1,7 @@
+export type GroupMember = {
+    group: number;
+    state: string;
+};
+export declare const procMember: (text: string) => GroupMember | null;
+export declare const psMember: (text: string) => GroupMember | null;
+export declare const groupRunning: (group: number, members: Array<GroupMember | null>) => boolean | null;

package/target/dts/adapters/host-posix/groups.d.ts

@@ -0,0 +1 @@
+export declare const groupAlive: (group: number) => boolean;

package/target/dts/adapters/host-posix/index.d.ts

@@ -0,0 +1,2 @@
+import type { Clock, ProcessHost } from '../../core/agents/ports/host.ts';
+export declare const hostPosix: (clock?: Clock) => ProcessHost;

package/target/dts/adapters/host-posix/launch.d.ts

@@ -0,0 +1,7 @@
+import type { Clock, Ended, Launch } from '../../core/agents/ports/host.ts';
+type Running = {
+    done: Promise<Ended>;
+    stop(): void;
+};
+export declare const launch: (request: Launch, clock: Clock) => Running;
+export {};

package/target/dts/adapters/host-posix/probes.d.ts

@@ -0,0 +1,5 @@
+import type { Ancestor, ProcessRows } from '../../core/agents/ports/host.ts';
+export declare const supported: boolean;
+export declare const alive: (pid: number) => boolean;
+export declare const snapshot: () => ProcessRows | null;
+export declare const ancestors: (first: number) => Ancestor[];

package/target/dts/adapters/host-posix/stats.d.ts

@@ -0,0 +1,9 @@
+export declare const seconds: (time: string) => number;
+export declare const procStat: (line: string) => {
+    ppid: number;
+    cpu: number;
+} | null;
+export declare const treeCpu: (pid: number, rows: Map<number, {
+    ppid: number;
+    cpu: number;
+}> | null) => number | null;

package/target/dts/adapters/keys-file/index.d.ts

@@ -0,0 +1,2 @@
+import type { SigningContext } from '../../core/signing/index.ts';
+export declare const keysFile: (home: string) => SigningContext;

package/target/dts/adapters/state-fs/index.d.ts

@@ -0,0 +1,5 @@
+import type { Build, LocalState } from '../../core/hub/ports/index.ts';
+export declare const stateFs: ({ root, build }: {
+    root: string;
+    build: Build;
+}) => LocalState;

package/target/dts/adapters/tool-claude/index.d.ts

@@ -0,0 +1,2 @@
+import type { AgentTool } from '../../core/agents/ports/index.ts';
+export declare const claude: AgentTool;

package/target/dts/adapters/tool-codex/index.d.ts

@@ -0,0 +1,2 @@
+import type { AgentTool } from '../../core/agents/ports/index.ts';
+export declare const codex: AgentTool;

package/target/dts/adapters/tool-cursor/index.d.ts

@@ -0,0 +1,2 @@
+import type { AgentTool } from '../../core/agents/ports/index.ts';
+export declare const cursor: AgentTool;

package/target/dts/adapters/tool-traces/index.d.ts

@@ -0,0 +1,3 @@
+export declare const UUID: RegExp;
+export declare const newestFirst: (d: string) => string[];
+export declare const mtime: (f: string) => number | null;

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

@@ -0,0 +1,43 @@
+import * as Remote from './remote.ts';
+import { Repo } from './repo.ts';
+import type { Roster, StoredRoom } from '../../core/hub/ports/store.ts';
+import type { Entry } from '../../core/hub/protocol/files.ts';
+export declare const CONTROL_FILES: Set<string>;
+type Entry_ = {
+    sha: string;
+    author: string;
+    text: string;
+    control: boolean;
+    skipped?: string;
+};
+type Named = Pick<StoredRoom, 'name' | 'genesis' | 'archived'>;
+export declare class Branches extends Repo {
+    protected ref(name: string): string;
+    protected tip(name: string): string | null;
+    roomBranches(): string[];
+    roomNames(archived: boolean): string[];
+    protected isControl(room: Pick<StoredRoom, 'genesis'>, sha: string, author: string, text: string): boolean;
+    protected scanned: Map<string, {
+        tip: string;
+        entries: Entry_[];
+    }>;
+    protected entries(room: Named, tip: string): Entry_[];
+    protected judged(room: Named, tip: string, entries: Entry_[]): Entry_[];
+    protected scan(room: Pick<StoredRoom, 'genesis'>, tip: string, after?: string): Array<Entry_ & {
+        parent: string;
+    }>;
+    room(name: string): StoredRoom | null;
+    controlFile(room: StoredRoom, name: string, rev?: string): string | null;
+    createRoom(name: string, who: string, text: string, files: Record<string, string>): string;
+    updateControl(room: StoredRoom, who: string, text: string, files: Record<string, string>): string;
+    protected refsUnder(prefix: string): Array<[string, string]>;
+    archiveRoom(room: StoredRoom, as: string): void;
+    deleteRoom(room: StoredRoom): void;
+    protected remote(room: StoredRoom): Remote.Room;
+    roster(room: StoredRoom): Roster | null;
+    protected live(room: StoredRoom): Entry_[];
+    alarms(room: StoredRoom): string[];
+    protected onTop(room: StoredRoom, who: string, text: string, entries: Entry[], drop?: string[]): string;
+    protected commitsOf(room: StoredRoom): Set<string>;
+}
+export {};

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

@@ -0,0 +1,2 @@
+import type { StoredMessage } from '../../core/hub/ports/store.ts';
+export declare const messageFiles: (body: Buffer, rest: Buffer, sha: string, isRef: (s: string) => boolean, lsTree: (sha: string) => Buffer) => Pick<StoredMessage, 'files' | 'refused'>;

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

@@ -0,0 +1,32 @@
+import { Marks } from './marks.ts';
+export { runGit } from './run.ts';
+import type { Descriptor, JoinKey, Store, StoredMessage, StoredRoom } from '../../core/hub/ports/store.ts';
+import type { Entry } from '../../core/hub/protocol/files.ts';
+import type { SigningContext } from '../../core/signing/index.ts';
+export declare class GitStore extends Marks implements Store {
+    readonly type = "git";
+    static create(hubDir: string, d: Descriptor, connection: string | {
+        home: string;
+        signing?: SigningContext;
+    }, contract: Record<string, string>, text: string): GitStore;
+    static rootFor(hubDir: string, d: Descriptor, home: string, signing?: SigningContext): string;
+    logIds(room: StoredRoom): string[];
+    logHead(room: StoredRoom, id: string): string | null;
+    messages(room: StoredRoom, id: string, head: string): StoredMessage[];
+    blob(file: string): {
+        id: string;
+        size: number;
+    };
+    retain(room: StoredRoom, who: string, entries: Entry[]): void;
+    append(room: StoredRoom, who: string, text: string, entries: Entry[]): string;
+    verifyLog(room: StoredRoom, id: string, head: string): string | null;
+    pin(room: StoredRoom, reader: string, id: string, rev: string): void;
+    unpin(room: StoredRoom, reader: string, id: string): void;
+    file(rev: string, p: string): Buffer;
+    sizes(rev: string, paths: string[]): Map<string, number>;
+    admit(room: StoredRoom, who: string, key: string): string;
+    joinKey(room: StoredRoom, who: string): JoinKey;
+    forgetLog(room: StoredRoom, _id: string): void;
+    rootKey(): string;
+    rootRoster(): string;
+}

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

@@ -0,0 +1,20 @@
+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/admit.d.ts

@@ -0,0 +1,7 @@
+import type { Handle, Room } from './types.ts';
+export declare const join: (H: Handle, R: Room, who: string, home: string) => {
+    publicKey: string;
+    fingerprint: string;
+    admitted: boolean;
+};
+export declare const roomAdmit: (H: Handle, R: Room, who: string, publicKey: string, home: string) => string;

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

@@ -0,0 +1,3 @@
+import type { Handle } from './types.ts';
+export declare const savePushAlarms: (H: Handle, alarms: Record<string, string>) => void;
+export declare const pushAlarms: (H: Handle) => Record<string, string>;

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

@@ -0,0 +1,7 @@
+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/branch-commit.d.ts

@@ -0,0 +1,3 @@
+import type { Scan } from './branch-control.ts';
+import type { Raw } from './types.ts';
+export declare const visitCommit: (s: Scan, c: Raw) => void;

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

@@ -0,0 +1,15 @@
+import * as C from '../../../lib/index.ts';
+import type { Handle, Raw, VerifiedRoom } from './types.ts';
+export type Scan = {
+    H: Handle;
+    genesis: Raw;
+    touching: Set<string>;
+    parent: string;
+    roster: Omit<VerifiedRoom, 'genesis'>;
+    control: string[];
+    authors: Map<string, string>;
+    skipped: Map<string, string>;
+};
+export declare const broken: (why: string) => C.Fail;
+export declare const isControl: (s: Scan, c: Raw) => boolean;
+export declare const acceptControl: (s: Scan, c: Raw) => void;

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

@@ -0,0 +1,2 @@
+import type { Branch, Handle } from './types.ts';
+export declare const scanBranch: (H: Handle, name: string, tip: string) => Branch;

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

@@ -0,0 +1,5 @@
+import type { Branch, Handle, Room, VerifiedRoom } from './types.ts';
+export declare const branchData: (H: Handle, name: string, tip: string, expectedGenesis?: string) => Branch;
+export declare const branch: (H: Handle, R: Pick<Room, 'name' | 'ref' | 'genesis'>, tip: string) => Branch;
+export declare const verifyRoom: (H: Handle, R: Room) => VerifiedRoom;
+export declare const verify: (H: Handle, R: Room, who: string, head: string) => string | null;

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

@@ -0,0 +1,3 @@
+import type { Handle } from './types.ts';
+export declare const withVerification: <T>(H: Handle, fn: () => T) => T;
+export declare const memo: <T>(H: Handle, key: string, fn: () => T) => T;

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

@@ -0,0 +1,2 @@
+import type { Handle, Raw } from './types.ts';
+export declare const readCommits: (H: Handle, shas: string[]) => Raw[];

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

@@ -0,0 +1,2 @@
+import type { Handle, Room } from './types.ts';
+export declare const forget: (H: Handle, R: Room) => void;

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

@@ -0,0 +1,26 @@
+import type { SpawnSyncReturns } from 'node:child_process';
+import type { CommandOpt, Handle } from './types.ts';
+export declare const reason: (e: unknown) => string;
+export declare const mkdir: (d: string) => string | undefined;
+export declare const id: (s: string) => string;
+export declare const zero: (H: Handle) => string;
+export declare const ident: (who: string) => NodeJS.ProcessEnv;
+export declare function git(H: Handle, args: string[], opt: CommandOpt & {
+    ok: true;
+}): SpawnSyncReturns<string>;
+export declare function git(H: Handle, args: string[], opt: CommandOpt & {
+    raw: true;
+}): Buffer;
+export declare function git(H: Handle, args: string[], opt?: CommandOpt): string;
+export declare const config: (H: Handle, key: string, value?: string) => string;
+export declare const rev: (H: Handle, ref: string) => string | null;
+export declare const object: (H: Handle, ref: string) => string | null;
+export declare const ancestor: (H: Handle, a: string, b: string) => boolean;
+export declare const isRemote: (H: Handle) => boolean;
+export declare const origin: (H: Handle) => string | undefined;
+export declare const suffix: (ref: string) => string;
+export declare const accepted: (ref: string) => string;
+export declare const tracking: (ref: string) => string;
+export declare const locked: <T>(H: Handle, fn: () => T) => T;
+export declare const refs: (H: Handle, prefix: string) => Map<string, string>;
+export declare const promote: (H: Handle, ref: string, sha: string) => void;

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

@@ -0,0 +1 @@
+export declare const heartbeatBody: (text: string) => string;

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,7 @@
+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, home: string];
+export declare const makeHeartbeat: (...[H, R, who, target, text, home]: HeartbeatArgs) => string;

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

@@ -0,0 +1,13 @@
+import type { Handle, Key } from './types.ts';
+export declare const parseKey: (value: unknown) => Key;
+export declare const keyInput: (value: string) => Key;
+export declare const rootKey: (H: Handle) => Key;
+export declare const signerLine: (who: string, key: Key) => string;
+export declare const identityKey: (H: Handle, who: string, home: string, create?: boolean) => Key;
+export declare const setupSigned: (H: Handle, home: string, url?: string) => {
+    root: string;
+    allowedSigners: string;
+};
+export declare const sign: (H: Handle, who: string, home: string) => string[];
+export declare const rootRoster: (H: Handle) => string;
+export declare const checkUrl: (url: string) => void;

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

@@ -0,0 +1,11 @@
+import type { Handle } from './types.ts';
+export declare const verifyMain: (H: Handle, head: string) => {
+    head: string;
+    genesis: string;
+    commits: string[];
+};
+export declare const verifyHub: (H: Handle) => {
+    head: string;
+    genesis: string;
+    commits: string[];
+} | null;

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

@@ -0,0 +1,20 @@
+import type { SpawnSyncReturns } from 'node:child_process';
+import type { CommandOpt } from './types.ts';
+export declare const ENV: {
+    GIT_CONFIG_GLOBAL: string;
+    GIT_CONFIG_NOSYSTEM: string;
+    GIT_TERMINAL_PROMPT: string;
+    GIT_NO_REPLACE_OBJECTS: string;
+    LC_ALL: string;
+};
+export declare const BASE: string[];
+export declare const gitEnv: (extra?: NodeJS.ProcessEnv) => NodeJS.ProcessEnv;
+export declare const gitTimeout: () => number;
+export declare const checkGitTimeout: (error?: NodeJS.ErrnoException) => void;
+export declare function command(cmd: string, args: string[], opt: CommandOpt & {
+    ok: true;
+}): SpawnSyncReturns<string>;
+export declare function command(cmd: string, args: string[], opt: CommandOpt & {
+    raw: true;
+}): Buffer;
+export declare function command(cmd: string, args: string[], opt?: CommandOpt): string;

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

@@ -0,0 +1,2 @@
+import type { Publication } from './push.ts';
+export declare const recoverPublication: (p: Publication, stdout: string) => boolean | null;

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

@@ -0,0 +1,2 @@
+import type { Handle } from './types.ts';
+export declare const validateRef: (H: Handle, ref: string, sha: string) => void;

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

@@ -0,0 +1,16 @@
+import type { Handle } from './types.ts';
+export { validateRef } from './push-validate.ts';
+export type Publication = {
+    H: Handle;
+    ref: string;
+    alarms: Record<string, string>;
+    tag: boolean;
+    pin: string;
+    track: string;
+    sha: string;
+    acc: string | null;
+    url: string;
+};
+export declare const push: (H: Handle, ref: string, { behind }?: {
+    behind?: boolean;
+}) => boolean;

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

@@ -0,0 +1,7 @@
+import type { Member } from '../../../core/hub/ports/store.ts';
+import type { Handle, Signer } from './types.ts';
+export declare const blobText: (H: Handle, sha: string, name: string) => string;
+export declare const rosterAt: (H: Handle, sha: string) => {
+    entries: Signer[];
+    members: Record<string, Member>;
+};

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

@@ -0,0 +1,15 @@
+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/signature.d.ts

@@ -0,0 +1,5 @@
+import type { Commit, Handle, Key } from './types.ts';
+export declare const verified: Set<string>;
+export declare const checkSignature: (H: Handle, sha: string, who: string, key: Key, kind?: 'commit' | 'tag') => void;
+export declare const chain: (H: Handle, head: string, base?: string) => Commit[];
+export declare const linear: (commits: Commit[], initial: string | null, check: (sha: string) => void) => void;

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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,8 @@
+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/remote/sync.d.ts

@@ -0,0 +1,2 @@
+import type { Handle } from './types.ts';
+export declare const sync: (H: Handle) => Handle;

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

@@ -0,0 +1,64 @@
+import type { Descriptor, Member } from '../../../core/hub/ports/store.ts';
+import type { SigningContext } from '../../../core/signing/index.ts';
+export type Handle = {
+    name: string;
+    dir: string;
+    d: Descriptor;
+    signing?: SigningContext;
+    main?: string;
+    remoteAlarms?: Record<string, string>;
+    heartbeatErrors?: Record<string, string>;
+    bootstrap?: boolean;
+};
+export type Room = {
+    name: string;
+    ref: string;
+    head: string;
+    genesis: string;
+    archived?: boolean;
+    members?: Record<string, Member>;
+};
+export type Key = {
+    line: string;
+    fp: string;
+};
+export type Signer = {
+    principal: string;
+    key: Key;
+};
+export type VerifiedRoom = {
+    genesis: string;
+    entries: Signer[];
+    members: Record<string, Member>;
+};
+export type Branch = VerifiedRoom & {
+    subject: string;
+    control: string[];
+    authors: Map<string, string>;
+    skipped: Map<string, string>;
+};
+export declare const CONTROL_FILES: string[];
+export type CommandOpt = {
+    input?: string | Buffer;
+    env?: NodeJS.ProcessEnv;
+    ok?: boolean;
+    raw?: boolean;
+};
+export declare const SHA: RegExp;
+export declare const ROOT = "operator";
+export declare const TRACK = "refs/remotes/origin/";
+export declare const ACCEPT = "refs/ringi/remote-accepted/";
+export declare const TAGS = "refs/tags/";
+export declare const TAG_TRACK = "refs/ringi/remote-tags/";
+export declare const TAG_ACCEPT = "refs/ringi/remote-accepted-tags/";
+export type Commit = {
+    sha: string;
+    parents: string[];
+};
+export type Raw = {
+    sha: string;
+    parents: string[];
+    author: string;
+    text: string;
+    body: Buffer;
+};

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

@@ -0,0 +1,17 @@
+export type { Handle, Room, Branch } from './remote/types.ts';
+export { withVerification } from './remote/cache.ts';
+export { gitEnv, gitTimeout, checkGitTimeout } from './remote/process.ts';
+export { isRemote } from './remote/git.ts';
+export { parseKey, setupSigned, sign, rootRoster } from './remote/keys.ts';
+export { verifyHub } from './remote/main.ts';
+export { readCommits } from './remote/commits.ts';
+export { branch, verifyRoom, verify } from './remote/branch.ts';
+export { heartbeatName, heartbeatRef, verifyHeartbeat, makeHeartbeat } from './remote/heartbeat.ts';
+export { verifySignal } from './remote/signals.ts';
+export { sync } from './remote/sync.ts';
+export { hubAdd } from './remote/bootstrap.ts';
+export { join, roomAdmit } from './remote/admit.ts';
+export { push } from './remote/push.ts';
+export { pushHeartbeat } from './remote/heartbeat-push.ts';
+export { forget } from './remote/forget.ts';
+export { strictJson } from '../../lib/index.ts';

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

@@ -0,0 +1,31 @@
+import * as Remote from './remote.ts';
+import type { GitOpt } from './run.ts';
+import type { Descriptor } from '../../core/hub/ports/store.ts';
+import type { Entry } from '../../core/hub/protocol/files.ts';
+import type { SigningContext } from '../../core/signing/index.ts';
+export declare const init: (dir: string, home: string) => string;
+export declare class Repo {
+    readonly trust: 'asserted' | 'signed';
+    readonly dir: string;
+    readonly d: Descriptor;
+    readonly home: string;
+    readonly h: Remote.Handle;
+    constructor(hubDir: string, d: Descriptor, home: string, signing?: SigningContext);
+    protected openable(): void;
+    protected checkout(): void;
+    protected args(a: string[]): string[];
+    protected git(a: string[], o?: GitOpt): string;
+    protected gitOk(a: string[], o?: GitOpt): import("node:child_process").SpawnSyncReturns<string>;
+    rev(ref: string): string | null;
+    isAncestor(a: string, b: string): boolean;
+    isRef(s: string): boolean;
+    extends(older: string, newer: string): boolean;
+    protected tree(base: string | null, entries: Entry[], drop?: string[]): string;
+    protected commit(who: string, text: string, tree: string, parents: string[]): string;
+    protected advance(ref: string, sha: string, old: string | null): boolean;
+    sync(): void;
+    contractHead(): string;
+    contractFile(rev: string, name: string): string | null;
+    contractFiles(rev: string): string[];
+    amendContract(who: string, text: string, files: Record<string, string | Buffer>): string;
+}

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

@@ -0,0 +1,21 @@
+import type { SpawnSyncReturns } from 'node:child_process';
+export declare const ZERO: string;
+export declare const ident: (id: string) => {
+    GIT_AUTHOR_NAME: string;
+    GIT_AUTHOR_EMAIL: string;
+    GIT_COMMITTER_NAME: string;
+    GIT_COMMITTER_EMAIL: string;
+};
+export type GitOpt = {
+    input?: string | Buffer;
+    env?: Record<string, string>;
+    where?: string;
+};
+export declare const runGit: (args: string[], o?: GitOpt) => string;
+export declare const runGitOk: (args: string[], o?: GitOpt) => SpawnSyncReturns<string>;
+export declare const runGitRaw: (args: string[], where?: string, input?: Buffer) => Buffer;
+export declare const splitBuf: (b: Buffer, sep: number) => Buffer[];
+export declare const frames: (raw: Buffer, shas: string[]) => Map<string, {
+    type: string;
+    body: Buffer;
+}>;

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

@@ -0,0 +1,4 @@
+import type { Handle } from './remote/types.ts';
+export declare const signBytes: (H: Handle, who: string, payload: Buffer | string, home: string) => string;
+export declare const signCommit: (H: Handle, who: string, sha: string, home: string) => string;
+export declare const signedTag: (H: Handle, who: string, tag: string, target: string, home: string) => string;