@idleware/ringi 0.5.0 → 0.6.1

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

@@ -0,0 +1,7 @@
+import type { Transport } from '../../core/hub/ports/store.ts';
+import type { SigningContext } from '../../core/signing/index.ts';
+type Options = {
+    signer?: SigningContext | (() => SigningContext);
+};
+export declare const gitTransport: (home: string, opt?: Options) => Transport;
+export {};

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

@@ -0,0 +1,2 @@
+import type { Transport } from '../../core/hub/ports/store.ts';
+export declare const kafka: Transport;

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

@@ -0,0 +1,2 @@
+import type { Transport } from '../../core/hub/ports/store.ts';
+export declare const temporal: Transport;

package/target/dts/cli.d.ts

@@ -1,3 +1,4 @@
 #!/usr/bin/env node
-import { main } from './cli/index.ts';
+import './composition/index.ts';
+import { main } from './clients/cli/index.ts';
 export { main };

package/target/dts/{cli/agent.d.ts → clients/cli/agent/index.d.ts}

@@ -1,6 +1,6 @@
-import * as Agent from '../app/agent.ts';
-import type { Opts } from './args.ts';
-import type { Ctx } from './context.ts';
+import * as Agent from '../../../core/agents/sessions/agent.ts';
+import type { Opts } from '../args.ts';
+import type { Ctx } from '../context.ts';
 export declare const showInbox: ({ R, me, s }: Ctx, res: Agent.Inbox, o: Opts) => void;
 export declare const inbox: (a: Ctx, o: Opts) => void;
 export declare const take: (a: Ctx, o: Opts) => void;

package/target/dts/{cli → clients/cli/agent}/session.d.ts

@@ -1,5 +1,5 @@
-import * as Session from '../app/session.ts';
-import type { Opts } from './args.ts';
+import * as Session from '../../../core/agents/sessions/session.ts';
+import type { Opts } from '../args.ts';
 export declare const briefing: (s: Session.Session) => void;
 export declare const join: (o: Opts) => void;
 export declare const resume: (o: Opts) => void;

package/target/dts/clients/cli/arg-parse.d.ts

@@ -0,0 +1,2 @@
+import type { Opts } from './args.ts';
+export declare const parseArgs: (argv: string[]) => Opts;

package/target/dts/{cli → clients/cli}/args.d.ts

@@ -1,11 +1,11 @@
-import type { Entry } from '../protocol/files.ts';
+import type { Entry } from '../../core/hub/protocol/files.ts';
 export declare const out: (s?: string) => void;
 export declare const dump: (v: unknown) => void;
 export type Opts = {
     _: string[];
     [key: string]: string | string[] | boolean | undefined;
 };
-export declare const parseArgs: (argv: string[]) => Opts;
+export { parseArgs } from './arg-parse.ts';
 export declare const opt: (o: Opts, key: string) => string | undefined;
 export declare const list: (o: Opts, key: string) => string[];
 export declare const flag: (o: Opts, key: string) => boolean;

package/target/dts/clients/cli/commands.d.ts

@@ -0,0 +1,2 @@
+import type { Opts } from './args.ts';
+export declare const dispatch: (cmd: string, o: Opts, rest: string[]) => void | Promise<void>;

package/target/dts/clients/cli/context.d.ts

@@ -0,0 +1,4 @@
+import type { Opts } from './args.ts';
+export type { Ctx } from '../../core/agents/sessions/context.ts';
+export { isRef } from '../../core/hub/usecases/room.ts';
+export declare const operatorCtx: (o: Opts) => import("../../core/hub/usecases/actor.ts").Actor;

package/target/dts/{cli/index.d.ts → clients/cli/help.d.ts}

@@ -1,5 +1,3 @@
-import type { Profile } from '../domain/profiles.ts';
 export declare const TABLE: Array<[string, 'operator' | 'session' | 'agent' | 'both', string]>;
+export declare const helpText: () => string;
 export declare const helpMarkdown: () => string;
-export declare const main: (argv?: string[]) => Promise<void>;
-export type { Profile };

package/target/dts/clients/cli/index.d.ts

@@ -0,0 +1,4 @@
+export type { Profile } from '../../core/hub/work/index.ts';
+export { helpMarkdown, TABLE } from './help.ts';
+export declare const failure: (e: unknown) => string;
+export declare const main: (argv?: string[]) => Promise<void>;

package/target/dts/clients/cli/operator/heartbeat-format.d.ts

@@ -0,0 +1,5 @@
+import type { Pulse } from '../../../core/agents/heartbeat/pulse.ts';
+type Published = ReturnType<typeof import('../../../core/agents/heartbeat/pulse.ts').published>[number];
+export declare const publishedLine: (h: Published) => string;
+export declare const pulseLine: ({ session: s, tool, beat: b }: Pulse) => string;
+export {};

package/target/dts/clients/cli/operator/heartbeat.d.ts

@@ -0,0 +1,3 @@
+import type { Opts } from '../args.ts';
+export declare const heartbeats: (o: Opts) => Promise<void>;
+export declare const pulse: (o: Opts) => Promise<void>;

package/target/dts/clients/cli/operator/hub-commands.d.ts

@@ -0,0 +1,6 @@
+import type { Opts } from '../args.ts';
+export declare const listHub: (_: Opts) => void;
+export declare const createHub: (o: Opts) => void;
+export declare const switchHub: (o: Opts) => void;
+export declare const addHub: (o: Opts) => void;
+export declare const amendHub: (o: Opts) => void;

package/target/dts/clients/cli/operator/hub.d.ts

@@ -0,0 +1,2 @@
+import type { Opts } from '../args.ts';
+export declare const hub: (o: Opts) => void;

package/target/dts/clients/cli/operator/index.d.ts

@@ -0,0 +1,5 @@
+export { heartbeats, pulse } from './heartbeat.ts';
+export { hub } from './hub.ts';
+export { roomCmd } from './room.ts';
+export { forget, sessionLine, sessions } from './sessions.ts';
+export { where } from './where.ts';

package/target/dts/clients/cli/operator/room-lifecycle.d.ts

@@ -0,0 +1,5 @@
+import type { Hub } from '../../../core/hub/rooms/index.ts';
+import type { Opts } from '../args.ts';
+export declare const archiveRoom: (H: Hub, arg: string | undefined, o: Opts) => void;
+export declare const deleteRoom: (H: Hub, arg: string | undefined, o: Opts) => void;
+export declare const rebaseRoomContract: (H: Hub, arg: string | undefined, o: Opts) => void;

package/target/dts/clients/cli/operator/room-list.d.ts

@@ -0,0 +1,5 @@
+import type { Hub } from '../../../core/hub/rooms/index.ts';
+import type { Opts } from '../args.ts';
+export declare const listRoom: (H: Hub, arg: string | undefined, o: Opts) => void;
+export declare const createRoom: (H: Hub, arg: string | undefined, o: Opts) => void;
+export declare const switchRoom: (H: Hub, arg: string | undefined, o: Opts) => void;

package/target/dts/clients/cli/operator/room-members.d.ts

@@ -0,0 +1,4 @@
+import type { Hub } from '../../../core/hub/rooms/index.ts';
+import type { Opts } from '../args.ts';
+export declare const admitRoom: (H: Hub, arg: string | undefined, o: Opts) => void;
+export declare const removeRoom: (H: Hub, arg: string | undefined, o: Opts) => void;

package/target/dts/clients/cli/operator/room.d.ts

@@ -0,0 +1,2 @@
+import type { Opts } from '../args.ts';
+export declare const roomCmd: (o: Opts) => void;

package/target/dts/clients/cli/operator/sessions.d.ts

@@ -0,0 +1,5 @@
+import type { SessionView } from '../../../core/agents/overview.ts';
+import type { Opts } from '../args.ts';
+export declare const sessionLine: (s: SessionView) => string;
+export declare const sessions: (o: Opts) => void;
+export declare const forget: (o: Opts) => void;

package/target/dts/clients/cli/operator/watch.d.ts

@@ -0,0 +1,2 @@
+import type { Opts } from '../args.ts';
+export declare const watchCommand: (o: Opts) => Promise<void>;

package/target/dts/clients/cli/operator/where-format.d.ts

@@ -0,0 +1,7 @@
+import type { Where } from '../../../core/agents/overview.ts';
+import type { Room } from '../../../core/hub/rooms/index.ts';
+import type { All, Message } from '../../../core/hub/protocol/index.ts';
+import type { Opts } from '../args.ts';
+export declare const hubLine: (H: Where['hub']) => string;
+export declare const printOverview: (w: Where, R: Room) => void;
+export declare const showMessage: (R: Room, o: Opts, all: All, m: Message) => void;

package/target/dts/clients/cli/operator/where.d.ts

@@ -0,0 +1,2 @@
+import type { Opts } from '../args.ts';
+export declare const where: (o: Opts) => Promise<void>;

package/target/dts/clients/cli/shared/budget.d.ts

@@ -0,0 +1,7 @@
+import type { Opts } from '../args.ts';
+import type { Ctx } from '../context.ts';
+export declare const propose: (a: Ctx, o: Opts) => void;
+export declare const stamp_: (a: Ctx, o: Opts) => void;
+export declare const decide: (a: Ctx, o: Opts) => void;
+export declare const proposals: (a: Ctx, o: Opts) => void;
+export declare const grants: (a: Ctx, o: Opts) => void;

package/target/dts/clients/cli/shared/files.d.ts

@@ -0,0 +1,4 @@
+import type { Opts } from '../args.ts';
+import type { Ctx } from '../context.ts';
+export declare const cat: (a: Ctx, o: Opts) => void;
+export declare const get: (a: Ctx, o: Opts) => void;

package/target/dts/clients/cli/shared/index.d.ts

@@ -0,0 +1,7 @@
+export { decide, grants, proposals, propose, stamp_ } from './budget.ts';
+export { cat, get } from './files.ts';
+export { add, read, reply, send, thread } from './messages.ts';
+export { profileCmd, who } from './profile.ts';
+export { scopeLine, waiting } from './session.ts';
+export { signals } from './signals.ts';
+export { log, taskLine, tasks } from './work.ts';

package/target/dts/clients/cli/shared/messages.d.ts

@@ -0,0 +1,7 @@
+import type { Opts } from '../args.ts';
+import type { Ctx } from '../context.ts';
+export declare const add: (a: Ctx, o: Opts) => void;
+export declare const send: (a: Ctx, o: Opts) => void;
+export declare const reply: (a: Ctx, o: Opts) => void;
+export declare const read: (a: Ctx, o: Opts) => void;
+export declare const thread: (a: Ctx, o: Opts) => void;

package/target/dts/clients/cli/shared/profile.d.ts

@@ -0,0 +1,4 @@
+import type { Opts } from '../args.ts';
+import type { Ctx } from '../context.ts';
+export declare const profileCmd: ({ R }: Ctx, o: Opts) => void;
+export declare const who: (a: Ctx) => void;

package/target/dts/clients/cli/shared/session.d.ts

@@ -0,0 +1,6 @@
+import type { Session } from '../../../core/agents/sessions/session.ts';
+export declare const scopeLine: (s: Session, quorum?: boolean) => string;
+export declare const waiting: (room: string, st: {
+    quorum: number | null;
+    agents: number;
+}) => string;

package/target/dts/clients/cli/shared/signals.d.ts

@@ -0,0 +1,3 @@
+import type { Opts } from '../args.ts';
+import type { Ctx } from '../context.ts';
+export declare const signals: (a: Ctx, o: Opts) => void;

package/target/dts/clients/cli/shared/work.d.ts

@@ -0,0 +1,6 @@
+import type { TaskView } from '../../../core/hub/usecases/view.ts';
+import type { Opts } from '../args.ts';
+import type { Ctx } from '../context.ts';
+export declare const taskLine: (t: TaskView) => string;
+export declare const tasks: (a: Ctx, o: Opts) => void;
+export declare const log: (a: Ctx, o: Opts) => void;

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

@@ -0,0 +1,3 @@
+import type { Opts } from '../args.ts';
+export { SKILL, skillTargets } from './targets.ts';
+export declare const skill: (o: Opts) => void;

package/target/dts/{cli/skill.d.ts → clients/cli/skill/targets.d.ts}

@@ -1,4 +1,3 @@
-import type { Opts } from './args.ts';
 export declare const SKILL: string;
 export declare const skillTargets: (project: boolean) => string[];
-export declare const skill: (o: Opts) => void;
+export declare const sameSkill: (dir: string) => boolean;

package/target/dts/composition/index.d.ts

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

package/target/dts/{heartbeat → core/agents/heartbeat}/index.d.ts

@@ -1,3 +1,4 @@
+import type { ProcessRows } from '../ports/host.ts';
 export type Facts = {
     at: number;
     alive: boolean | null;
@@ -23,10 +24,7 @@ export type SessionLike = {
     lastSeen: string;
     state: string;
 };
-export declare const probe: (s: SessionLike, waits?: string | null, rows?: Map<number, {
-    ppid: number;
-    cpu: number;
-}> | null) => Facts;
+export declare const probe: (s: SessionLike, waits?: string | null, rows?: ProcessRows | null) => Facts;
 export declare const tracedBy: (s: Pick<SessionLike, 'handle' | 'product'>) => string;
 export declare const judge: (cur: Facts, prev?: Facts | null, { active, next }?: {
     active?: number;

package/target/dts/{app/heartbeat.d.ts → core/agents/heartbeat/pulse.d.ts}

@@ -1,6 +1,7 @@
-import * as HB from '../heartbeat/index.ts';
-import type { Room } from '../hub/index.ts';
-import type { Session } from '../runtime/session.ts';
+import * as HB from './index.ts';
+export { ensurePulse } from './singleton.ts';
+import type { Room } from '../../hub/rooms/index.ts';
+import type { Session } from '../sessions/index.ts';
 export type Pulse = {
     session: Session;
     tool: string;
@@ -9,13 +10,11 @@ export type Pulse = {
 export declare const heartbeats: ({ sample }?: {
     sample?: number;
 }) => Promise<Pulse[]>;
-export declare const ensurePulse: (cli: string) => void;
 export type Beaten = {
     session: Session;
     beat?: HB.Beat;
     error?: string;
 };
-export declare const beatAll: (prev: Map<string, HB.Facts>, next: number) => Beaten[];
 export declare const pulse: ({ every, once, log }: {
     every?: number;
     once?: boolean;
@@ -23,7 +22,7 @@ export declare const pulse: ({ every, once, log }: {
 }) => Promise<number>;
 export declare const published: (R: Room) => {
     agent: string;
-    target: import("../index.ts").Rev;
+    target: import("../../../index.ts").Rev;
     time: number;
     text: string;
     state: string;

package/target/dts/core/agents/heartbeat/singleton.d.ts

@@ -0,0 +1,3 @@
+export declare const ensurePulse: (cli: string) => void;
+export declare const claim: () => number | null;
+export declare const release: () => void;

package/target/dts/core/agents/heartbeat/tools.d.ts

@@ -0,0 +1,6 @@
+import type { SessionRef } from '../ports/index.ts';
+export declare const toolOf: (s: SessionRef) => {
+    tool: string;
+    id: string;
+} | null;
+export declare const traceTime: (s: SessionRef) => number | null;

package/target/dts/{app → core/agents}/overview.d.ts

@@ -1,9 +1,10 @@
-import * as D from '../domain/decisions.ts';
-import type { Hub, Room } from '../hub/index.ts';
-import type { All, Message } from '../protocol/index.ts';
-import { liveness } from '../runtime/session.ts';
-import type { Session } from '../runtime/session.ts';
-import type { TaskView } from './view.ts';
+import * as D from '../hub/decisions/index.ts';
+import type { Hub, Room } from '../hub/rooms/index.ts';
+import type { All, Message } from '../hub/protocol/index.ts';
+import { liveness } from './sessions/index.ts';
+import type { Session } from './sessions/index.ts';
+import type { RoomView } from '../hub/usecases/rooms.ts';
+import type { TaskView } from '../hub/usecases/view.ts';
 export type SessionView = Session & {
     liveness: ReturnType<typeof liveness>;
 };
@@ -21,5 +22,10 @@ export declare const arrived: (H: Hub, R: Room, seen: Set<string>) => {
     all: All;
     messages: Message[];
 };
+export declare const roomsActive: (H: Hub, o?: {
+    archived?: boolean;
+}) => Array<RoomView & {
+    active: number;
+}>;
 export declare const sessions: () => SessionView[];
 export declare const forgetSession: (handle: string) => void;

package/target/dts/core/agents/ports/host.d.ts

@@ -0,0 +1,47 @@
+export type Environment = Record<string, string | undefined>;
+export type ProcessRows = Map<number, {
+    ppid: number;
+    cpu: number;
+}>;
+export type Ancestor = {
+    pid: number;
+    name: string;
+};
+export type Ended = {
+    code: number | null;
+    signal: string | null;
+    timedOut: boolean;
+    seconds: number;
+};
+export type Clock = {
+    wall(): number;
+    monotonic(): number;
+};
+declare const handle: unique symbol;
+export type ProcessHandle = {
+    readonly [handle]: true;
+};
+export type Launch = {
+    env: Environment;
+} & ({
+    shell: string;
+    timeout: number | null;
+} | {
+    file: string;
+    args: readonly string[];
+});
+export interface ProcessHost {
+    readonly supported: boolean;
+    readonly clock: Clock;
+    alive(pid: number): boolean;
+    ancestors(pid: number): Ancestor[];
+    snapshot(): ProcessRows | null;
+    inspect(pid: number, rows?: ProcessRows | null): {
+        alive: boolean | null;
+        cpu: number | null;
+    };
+    start(request: Launch): ProcessHandle;
+    stop(process: ProcessHandle): void;
+    awaitQuiescence(process: ProcessHandle, deadline?: number): Promise<Ended | null>;
+}
+export {};

package/target/dts/core/agents/ports/index.d.ts

@@ -0,0 +1,9 @@
+import type { AgentTool } from './tools.ts';
+import type { ProcessHost } from './host.ts';
+export type { AgentTool, Env, SessionRef } from './tools.ts';
+export type AgentPorts = {
+    tools: readonly AgentTool[];
+    host: ProcessHost;
+};
+export declare const wireAgents: (p: AgentPorts) => void;
+export declare const agentPorts: () => AgentPorts;

package/target/dts/core/agents/ports/tools.d.ts

@@ -0,0 +1,18 @@
+export type Env = Record<string, string | undefined>;
+export type SessionRef = {
+    handle: string;
+    product: string | null;
+};
+export interface AgentTool {
+    readonly id: string;
+    detect(env: Env): boolean;
+    readonly processes?: readonly string[];
+    session?(env: Env): {
+        handle: string;
+        pid: number | null;
+    } | null;
+    traceId?(s: SessionRef): string | null;
+    traceTime?(id: string): number | null;
+    skillDirs?(base: string): string[];
+    sandboxHint?(where: string): string;
+}

package/target/dts/core/agents/sessions/agent.d.ts

@@ -0,0 +1,70 @@
+import type { Session } from './index.ts';
+import type { Actor } from '../../hub/usecases/room.ts';
+export { wait } from './wait.ts';
+export { bound } from './index.ts';
+export { watch } from '../turns/index.ts';
+export type { WatchOptions } from '../turns/index.ts';
+export type InboxOptions = {
+    peek?: boolean;
+    limit?: number;
+};
+export declare const started: ({ R }: Actor) => {
+    quorum: number | null;
+    agents: number;
+    started: boolean;
+};
+export declare const inbox: ({ R, me }: Actor, { peek, limit }?: InboxOptions) => {
+    rest: number;
+    cursors: Record<string, string>;
+    all: import("../../hub/protocol/model.ts").All;
+    msgs: {
+        id: string;
+        from: string;
+        trust: 'asserted' | 'verified';
+        time: number;
+        seq: number;
+        invalid: string | null;
+        subject: string;
+        body: string;
+        to: string[];
+        re: string | null;
+        kind: string | null;
+        state: string | null;
+        assign: string[] | null;
+        roles: Record<string, string> | null;
+        hop: number;
+        bad: string | null;
+        trailers: import("../../hub/protocol/model.ts").Trailers;
+        refused: import("../../hub/protocol/model.ts").Refused[];
+        reId: string | null;
+        hopEff: number;
+        files: import("../../hub/protocol/model.ts").FileRef[];
+    }[];
+};
+export type Inbox = ReturnType<typeof inbox>;
+export declare const take: ({ R, me }: Actor, ref: string) => {
+    m: import("../../hub/protocol/model.ts").Message;
+    made: boolean;
+};
+export declare const whoami: ({ s, R }: Actor & {
+    s?: Session;
+}) => {
+    session: Session;
+    profile: string;
+    members: string[];
+};
+export declare const card: ({ R, me }: Actor, text: string) => string;
+export type PingInput = {
+    to: string;
+    text?: string;
+    next?: number;
+    re?: string;
+};
+export declare const ping: ({ R, me }: Actor, { to, text, next, re }: PingInput) => {
+    id: string;
+    to: string;
+    previous: {
+        id: string;
+        answeredAt: number | null;
+    } | null;
+};

package/target/dts/core/agents/sessions/binding.d.ts

@@ -0,0 +1,9 @@
+import type { Hub, Room } from '../../hub/rooms/index.ts';
+import type { Session } from './index.ts';
+export type Bound = {
+    s: Session;
+    H: Hub;
+    R: Room;
+    me: string;
+};
+export declare const bound: () => Bound;

package/target/dts/core/agents/sessions/context.d.ts

@@ -0,0 +1,8 @@
+import type { Session } from './index.ts';
+import type { Actor } from '../../hub/usecases/actor.ts';
+export type Ctx = Actor & {
+    s?: Session;
+};
+export declare const agent: () => Ctx;
+export declare const skillDirs: (base: string) => string[];
+export declare const sandboxHints: (where: string) => string[];

package/target/dts/{runtime/session.d.ts → core/agents/sessions/index.d.ts}

@@ -1,5 +1,5 @@
-import type { Hub, Room } from '../hub/index.ts';
-export declare const LEASE: number;
+export { bound } from './binding.ts';
+export type { Bound } from './binding.ts';
 export type Session = {
     handle: string;
     product: string | null;
@@ -28,13 +28,6 @@ export declare const pidAlive: (pid: number) => boolean;
 export declare const liveness: (s: Session) => 'active' | 'stopped' | 'gone';
 export declare const seatHolder: (hub: string, genesis: string, agent: string, except: string) => Session | undefined;
 export declare const ownSession: (handle: string) => Session | null;
-export type Bound = {
-    s: Session;
-    H: Hub;
-    R: Room;
-    me: string;
-};
-export declare const bound: () => Bound;
 export declare const parseSelector: (sel: string | undefined) => {
     hub: string | null;
     room: string;

package/target/dts/core/agents/sessions/join.d.ts

@@ -0,0 +1,20 @@
+import type { Session } from './index.ts';
+import type { JoinKey } from '../../hub/ports/store.ts';
+export type JoinInput = {
+    hub: string;
+    room: string;
+    agent?: string;
+    scope?: string;
+};
+export type JoinResult = {
+    agent: string;
+    hub: string;
+    room: string;
+} & ({
+    session: Session;
+    key: null;
+} | {
+    session: null;
+    key: JoinKey;
+});
+export declare const join: ({ hub, room, agent: id, scope }: JoinInput) => JoinResult;

package/target/dts/core/agents/sessions/resume.d.ts

@@ -0,0 +1,2 @@
+import type { Session } from './index.ts';
+export declare const resume: (selector?: string) => Session;

package/target/dts/core/agents/sessions/session.d.ts

@@ -0,0 +1,46 @@
+import type { Session } from './index.ts';
+export { resume } from './resume.ts';
+export { join } from './join.ts';
+export type { JoinInput, JoinResult } from './join.ts';
+export { bound } from './index.ts';
+export type { Session } from './index.ts';
+export declare const briefing: (s: Session) => {
+    session: Session;
+    actor: import("./binding.ts").Bound;
+    start: {
+        quorum: number | null;
+        agents: number;
+        started: boolean;
+    };
+    tasks: import("../../hub/usecases/view.ts").TaskView[];
+    inbox: {
+        rest: number;
+        cursors: Record<string, string>;
+        all: import("../../../index.ts").All;
+        msgs: {
+            id: string;
+            from: string;
+            trust: 'asserted' | 'verified';
+            time: number;
+            seq: number;
+            invalid: string | null;
+            subject: string;
+            body: string;
+            to: string[];
+            re: string | null;
+            kind: string | null;
+            state: string | null;
+            assign: string[] | null;
+            roles: Record<string, string> | null;
+            hop: number;
+            bad: string | null;
+            trailers: import("../../../index.ts").Trailers;
+            refused: import("../../../index.ts").Refused[];
+            reId: string | null;
+            hopEff: number;
+            files: import("../../../index.ts").FileRef[];
+        }[];
+    } | null;
+};
+export declare const stop: () => Session;
+export declare const leave: () => Session;