@agentorg/cli 0.0.2 → 0.0.3

package/dist/src/domain/application.js

@@ -1,85 +0,0 @@
-/** Validation, invocation and write audit for the explicit Hub Tool operations. */
-import { descriptorsOf } from "./capabilities.js";
-import { Forbidden, invalid, NotFound, Refusal } from "./errors.js";
-import { privateOperation } from "./model/system.js";
-export function application(registry, capabilities, audit, connections, diagnostics) {
-    function available(actorId, connectionId) {
-        if (connectionId !== undefined)
-            connections.assertActor(connectionId, actorId);
-        return registry.found(actorId).closed_at === null ? descriptorsOf(capabilities.list()) : [];
-    }
-    async function invoke(actorId, name, input, how) {
-        const actor = registry.found(actorId);
-        let release;
-        let operationName;
-        try {
-            if (actor.closed_at !== null)
-                throw new Forbidden("the Actor is closed");
-            if (how.connectionId !== undefined)
-                connections.assertActor(how.connectionId, actorId);
-            const found = capabilities
-                .list()
-                .flatMap((tool) => tool.interfaces)
-                .find((each) => each.offer.call === name);
-            if (!found) {
-                audit.record(actor.id, "call", null, "not_found");
-                throw new NotFound(`there is no interface ${name}`);
-            }
-            const operation = found.operation;
-            operationName = operation.name;
-            const spec = operation.definition;
-            // A write holds its connection until it settles; a read, which may wait, ends with it.
-            if (how.connectionId !== undefined && spec.writes)
-                release = connections.beginInvocation(how.connectionId, actorId);
-            const parsed = spec.request.safeParse(input);
-            if (!parsed.success)
-                throw invalid(parsed.error.issues);
-            let result;
-            try {
-                result = (await operation.invoke(actor, parsed.data, how));
-            }
-            catch (error) {
-                if (spec.writes && error instanceof Refusal)
-                    audit.record(actor.id, name, targetOf(input), error.code);
-                throw error;
-            }
-            if (spec.writes)
-                audit.record(actor.id, name, targetOf(result), "ok");
-            return { state: "done", value: result };
-        }
-        catch (error) {
-            if (operationName !== undefined && !privateOperation(operationName))
-                diagnostics.record({
-                    code: "operation_failed",
-                    stage: "invocation",
-                    outcome: error instanceof Refusal ? "refused" : "unknown",
-                    actorId: actor.id,
-                    connectionId: how.connectionId,
-                    operation: operationName,
-                });
-            if (!(error instanceof Refusal))
-                throw new Error("Hub operation failed; a write outcome may be unknown");
-            return { state: "refused", code: error.code, message: error.message };
-        }
-        finally {
-            release?.();
-        }
-    }
-    return { available, invoke };
-}
-function targetOf(record) {
-    const { id, call, resource, actor, actorID, messageID, ticketID, formID, askID, close, connectionId, } = record;
-    // A refused ask write names its ask ahead of the Work it is on.
-    return (id ??
-        connectionId ??
-        messageID ??
-        askID ??
-        close?.askID ??
-        ticketID ??
-        formID ??
-        actorID ??
-        call ??
-        resource ??
-        (typeof actor === "string" ? actor : actor?.id) ??
-        null);
-}

package/dist/src/domain/attention.d.ts

@@ -1,18 +0,0 @@
-/**
- * What concerns an Actor, read from the audited writes after its position, by the next mover.
- * On its records: Work given to it or changed by its requester, an answer to its submission, an
- * answer to its ask, and a message to it. Routed to it: an ask on Work it requested while the ask
- * is open and still routed to it, and a submission of Work it requested while the submission
- * waits. The person also gets the asks on Work their asker requested itself or on no Work, and
- * stands in for closed Actors: closing one gives it an ask for each open ask the close re-routes
- * and a review_due for each waiting submission, from the Actor that closed it, or none when the
- * person closed it, as its own write. A read that finds nothing waits for the next audited write,
- * up to `wait` seconds.
- */
-import type { Audit } from "./audit.ts";
-import type { Registry } from "./registry.ts";
-import type { Workspace } from "./workspace.ts";
-export { ATTENTION as definition } from "./model/index.ts";
-export declare function attention(registry: Registry, audit: Audit, workspace: Workspace): {
-    tool: import("./tools.ts").FeatureTool;
-};

package/dist/src/domain/attention.js

@@ -1,330 +0,0 @@
-/**
- * What concerns an Actor, read from the audited writes after its position, by the next mover.
- * On its records: Work given to it or changed by its requester, an answer to its submission, an
- * answer to its ask, and a message to it. Routed to it: an ask on Work it requested while the ask
- * is open and still routed to it, and a submission of Work it requested while the submission
- * waits. The person also gets the asks on Work their asker requested itself or on no Work, and
- * stands in for closed Actors: closing one gives it an ask for each open ask the close re-routes
- * and a review_due for each waiting submission, from the Actor that closed it, or none when the
- * person closed it, as its own write. A read that finds nothing waits for the next audited write,
- * up to `wait` seconds.
- */
-import { Invalid, Refusal } from "./errors.js";
-import { ATTENTION } from "./model/index.js";
-import { bindTool } from "./tools.js";
-export { ATTENTION as definition } from "./model/index.js";
-/** A value worked out the first time it is asked for. */
-function once(make) {
-    let made;
-    return () => {
-        made ??= { value: make() };
-        return made.value;
-    };
-}
-/** The audit entries one read examines; a full batch returns at once and the next read goes on. */
-const BATCH = 500;
-/**
- * The operations earlier builds audited, as the writes that replace them, so a resumed read keeps
- * them.
- */
-const RENAMED = {
-    form_create: "work_update",
-    form_close: "work_update",
-    form_respond: "work_answer",
-    work_review: "work_answer",
-};
-export function attention(registry, audit, workspace) {
-    /** A record the caller can read, or undefined where it can't. */
-    function read(caller, operation) {
-        try {
-            return workspace.run(caller, operation);
-        }
-        catch (error) {
-            if (error instanceof Refusal)
-                return undefined;
-            throw error;
-        }
-    }
-    /**
-     * The Actor an open ask waits on: its Work's requester, or the person when its asker requested
-     * the Work itself or it names no Work. A closed requester's asks go to the person.
-     */
-    function routeOf(ask, reads) {
-        if (ask.status !== "open")
-            return undefined;
-        const requester = ask.workID === undefined ? undefined : reads.work(ask.workID)?.requesterID;
-        return requester !== undefined && requester !== ask.requesterID
-            ? registry.standIn(requester)
-            : registry.root()?.id;
-    }
-    /**
-     * Asks and Work as the caller reads them, with history, and what one read derives from them:
-     * each record, each writer's later writes on it, and each history's writers and owners, once.
-     */
-    function reader(caller) {
-        const asks = new Map();
-        const works = new Map();
-        const later = new Map();
-        const writers = new WeakMap();
-        const owners = new WeakMap();
-        /** A writer's events on a record, without the asks cancelled with their Work. */
-        function own(history, actor) {
-            let byWriter = writers.get(history);
-            if (!byWriter) {
-                byWriter = new Map();
-                for (const event of history) {
-                    if (event.action === "cancelled" && "reason" in event.detail)
-                        continue;
-                    const events = byWriter.get(event.actorID);
-                    if (events)
-                        events.push(event);
-                    else
-                        byWriter.set(event.actorID, [event]);
-                }
-                writers.set(history, byWriter);
-            }
-            return byWriter.get(actor) ?? [];
-        }
-        return {
-            /**
-             * The history event an entry wrote: the writer's events on its record, counted back from the
-             * newest by the writer's later Work and ask writes on it. Asks cancelled with their Work have
-             * an event but no entry of their own, so they are passed over. A counted event later than
-             * the entry, as when an earlier entry was lost, gives way to the writer's last event before it.
-             */
-            event(entry, history) {
-                // Entries come in order, so the writer's later writes from its first entry here serve all.
-                const pair = `${entry.actor}\n${entry.target}`;
-                let ids = later.get(pair);
-                if (!ids) {
-                    ids = audit.writesAfter(entry.id, entry.actor, entry.target);
-                    later.set(pair, ids);
-                }
-                let first = 0;
-                for (let last = ids.length; first < last;) {
-                    const middle = (first + last) >> 1;
-                    if (ids[middle] <= entry.id)
-                        first = middle + 1;
-                    else
-                        last = middle;
-                }
-                const events = own(history ?? [], entry.actor);
-                const counted = events.at(-1 - (ids.length - first));
-                return counted && counted.at <= entry.at
-                    ? counted
-                    : events.findLast((event) => event.at <= entry.at);
-            },
-            /** The Work's owner just before `event`: the last owner an earlier event gave it, else its creator. */
-            ownerBefore(work, event) {
-                let before = owners.get(work);
-                if (!before) {
-                    before = new Map();
-                    let owner;
-                    for (const each of work.history ?? []) {
-                        before.set(each, owner);
-                        const given = each.detail.ownerID;
-                        owner = typeof given === "string" ? given : (owner ?? each.actorID);
-                    }
-                    owners.set(work, before);
-                }
-                return before.get(event);
-            },
-            ask(id) {
-                if (!asks.has(id)) {
-                    const found = read(caller, (clients) => clients.work.get({ askID: id, history: true }));
-                    if (found && !("formID" in found))
-                        works.set(found.ticketID, found);
-                    asks.set(id, found && ("formID" in found ? found : found.asks?.find((each) => each.formID === id)));
-                }
-                return asks.get(id);
-            },
-            work(id) {
-                if (!works.has(id))
-                    works.set(id, read(caller, (clients) => {
-                        const found = clients.work.get({ ticketID: id, history: true });
-                        return "formID" in found ? undefined : found;
-                    }));
-                return works.get(id);
-            },
-            /** The open asks routed to the caller. */
-            routing: once(() => all(caller, (clients, after) => clients.work.asks({ routedTo: caller.id, limit: 100, after }))),
-        };
-    }
-    /** Every page of a list the caller reads; none where it can't read it. */
-    function all(caller, page) {
-        const items = [];
-        for (let after;;) {
-            const found = read(caller, (clients) => page(clients, after));
-            if (found === undefined)
-                return items;
-            items.push(...found.items);
-            if (found.next === null)
-                return items;
-            after = found.next;
-        }
-    }
-    /** What one entry did: the parties and records it touched, and the item it makes, if any. */
-    function factOf(caller, entry, reads) {
-        const touched = {
-            actorIDs: [],
-            workIDs: [],
-            conversationIDs: [],
-        };
-        let kind;
-        let title = "";
-        const items = [];
-        const id = entry.target;
-        if (entry.operation === "message_send") {
-            const message = read(caller, (clients) => clients.messages.get({ messageID: id }));
-            if (message) {
-                touched.actorIDs.push(message.senderID, message.recipientID);
-                touched.conversationIDs.push(message.conversationID);
-                if (message.recipientID === caller.id)
-                    kind = "message";
-                title = (message.text.split("\n")[0] ?? "").slice(0, 120);
-            }
-        }
-        else if (entry.operation === "actor_create" || entry.operation === "actor_close") {
-            touched.actorIDs.push(id);
-            // A closed Actor's part passes to the person: the asks on Work it requested, and the
-            // submissions of that Work, are the person's now.
-            if (entry.operation === "actor_close" && registry.standIn(id) === caller.id) {
-                for (const ask of reads.routing())
-                    if (ask.requesterID !== id &&
-                        ask.workID !== undefined &&
-                        reads.work(ask.workID)?.requesterID === id)
-                        items.push({ kind: "ask", title: ask.title, recordID: ask.formID });
-                const submitted = all(caller, (clients, after) => clients.work.list({ requesterID: id, status: ["submitted"], limit: 100, after }));
-                for (const work of submitted)
-                    items.push({ kind: "review_due", title: work.title, recordID: work.ticketID });
-            }
-        }
-        else if (entry.operation.startsWith("work_")) {
-            // An ask is written by work_update and work_answer with the ask as the entry's target.
-            const ask = entry.operation === "work_update" || entry.operation === "work_answer"
-                ? reads.ask(id)
-                : undefined;
-            const work = ask ? undefined : reads.work(id);
-            if (ask) {
-                touched.actorIDs.push(ask.requesterID);
-                if (ask.workID)
-                    touched.workIDs.push(ask.workID);
-                title = ask.title;
-                const asker = ask.requesterID === caller.id;
-                const routed = routeOf(ask, reads) === caller.id;
-                // Only its asker and the Actor it routes to get items from an ask.
-                const action = asker || routed ? reads.event(entry, ask.history)?.action : undefined;
-                if (action === "created" && routed)
-                    kind = "ask";
-                else if (action === "responded" && asker)
-                    kind = "answer";
-            }
-            else if (work) {
-                touched.workIDs.push(id);
-                touched.actorIDs.push(work.ownerID, work.requesterID);
-                title = work.title;
-                const owns = work.ownerID === caller.id;
-                if (entry.operation === "work_create" && owns)
-                    kind = "assigned";
-                // An edit may give the Work away and an answer follows its submitter, so their owner before
-                // is a party to them; other writes leave the owner as it is.
-                const event = entry.operation === "work_update" || entry.operation === "work_answer"
-                    ? reads.event(entry, work.history)
-                    : undefined;
-                const before = event && reads.ownerBefore(work, event);
-                touched.actorIDs.push(before);
-                // Only its requester, or the requester's stand-in, edits Work on another Actor: giving it
-                // to the caller is assigned, and an edit that leaves it the caller's is updated.
-                if (entry.operation === "work_update" && owns && event) {
-                    const given = event.detail.ownerID;
-                    if ((typeof given === "string" ? given : before) === caller.id)
-                        kind = before === caller.id ? "updated" : "assigned";
-                }
-                if (entry.operation === "work_submit" &&
-                    work.status === "submitted" &&
-                    registry.standIn(work.requesterID) === caller.id)
-                    kind = "review_due";
-                // Submitted Work stays as it is until answered, so its owner then made the submission.
-                if (entry.operation === "work_answer" && event && before === caller.id)
-                    kind = "reviewed";
-            }
-        }
-        if (kind)
-            items.push({ kind, title, recordID: id });
-        return { touched, items };
-    }
-    function examine(caller, entries) {
-        const items = new Map();
-        const actorIDs = new Set();
-        const workIDs = new Set();
-        const conversationIDs = new Set();
-        const reads = reader(caller);
-        for (const entry of entries) {
-            const { actor, target } = entry;
-            if (entry.outcome !== "ok" || actor === null || target === null)
-                continue;
-            const operation = RENAMED[entry.operation] ?? entry.operation;
-            const { touched, items: made } = factOf(caller, { ...entry, operation, actor, target }, reads);
-            for (const each of touched.actorIDs)
-                if (each)
-                    actorIDs.add(each);
-            for (const each of touched.workIDs)
-                workIDs.add(each);
-            for (const each of touched.conversationIDs)
-                conversationIDs.add(each);
-            if (actor === caller.id)
-                continue;
-            for (const item of made) {
-                // One item per kind and record; a collecting ask's answers, one per responder.
-                const key = `${item.kind}:${item.recordID}${item.kind === "answer" ? `:${actor}` : ""}`;
-                if (items.has(key))
-                    continue;
-                items.set(key, {
-                    kind: item.kind,
-                    recordID: item.recordID,
-                    from: { actorID: actor, name: registry.get(actor)?.name ?? actor },
-                    title: item.title,
-                    at: entry.at,
-                });
-            }
-        }
-        return {
-            items: [...items.values()],
-            changed: {
-                actorIDs: [...actorIDs],
-                workIDs: [...workIDs],
-                conversationIDs: [...conversationIDs],
-            },
-        };
-    }
-    return {
-        tool: bindTool(ATTENTION, {
-            attention: async (caller, request, how) => {
-                const head = audit.head();
-                if (request.since === undefined)
-                    return {
-                        items: [],
-                        changed: { actorIDs: [], workIDs: [], conversationIDs: [] },
-                        next: `${head}`,
-                    };
-                let position = Number(request.since);
-                if (position > head)
-                    throw new Invalid("since: beyond this Hub's position");
-                const deadline = Date.now() + request.wait * 1000;
-                for (;;) {
-                    const entries = audit.list(position, BATCH);
-                    position = entries.at(-1)?.id ?? position;
-                    const found = examine(caller, entries);
-                    const remaining = deadline - Date.now();
-                    const changed = Object.values(found.changed).some((ids) => ids.length > 0);
-                    if (found.items.length > 0 || changed || entries.length === BATCH || remaining <= 0)
-                        return { ...found, next: `${position}` };
-                    if (how.signal.aborted)
-                        return { ...found, next: `${position}` };
-                    // No await separates the read above from waiting here, so no write slips between.
-                    await audit.next(how.signal, remaining);
-                }
-            },
-        }),
-    };
-}

package/dist/src/domain/audit.d.ts

@@ -1,16 +0,0 @@
-/**
- * The audit trail: writes, interface refusals and preserved historical call outcomes, which every
- * Actor reads. Each entry wakes the reads waiting for the next one.
- */
-import type { AuditRow, Store } from "./ports.ts";
-export { ACTIVITY as definition } from "./model/index.ts";
-export declare function audit(entries: Store["audit"], now: () => string): {
-    record: (actor: string | null, operation: string, target: string | null, outcome: string) => void;
-    list: (since: number | undefined, limit: number) => AuditRow[];
-    next: (signal: AbortSignal, ms: number) => Promise<void>;
-    head: () => number;
-    lastWrite: (actor: string) => string | undefined;
-    writesAfter: (id: number, actor: string, target: string) => number[];
-    tool: import("./tools.ts").FeatureTool;
-};
-export type Audit = ReturnType<typeof audit>;

package/dist/src/domain/audit.js

@@ -1,46 +0,0 @@
-/**
- * The audit trail: writes, interface refusals and preserved historical call outcomes, which every
- * Actor reads. Each entry wakes the reads waiting for the next one.
- */
-import { ACTIVITY } from "./model/index.js";
-import { bindTool } from "./tools.js";
-export { ACTIVITY as definition } from "./model/index.js";
-export function audit(entries, now) {
-    const waiting = new Set();
-    function record(actor, operation, target, outcome) {
-        entries.append({ at: now(), actor, operation, target, outcome });
-        for (const wake of [...waiting])
-            wake();
-    }
-    /** The latest entries, or the earliest after `since`; oldest first. */
-    function list(since, limit) {
-        return entries.list(since, limit);
-    }
-    /** Resolves at the next entry, after `ms`, or when `signal` aborts, whichever comes first. */
-    function next(signal, ms) {
-        return new Promise((resolve) => {
-            const done = () => {
-                clearTimeout(timer);
-                signal.removeEventListener("abort", done);
-                waiting.delete(done);
-                resolve();
-            };
-            const timer = setTimeout(done, ms);
-            signal.addEventListener("abort", done);
-            waiting.add(done);
-            if (signal.aborted)
-                done();
-        });
-    }
-    return {
-        record,
-        list,
-        next,
-        head: () => list(undefined, 1)[0]?.id ?? 0,
-        lastWrite: (actor) => entries.lastWrite(actor),
-        writesAfter: (id, actor, target) => entries.writesAfter(id, actor, target),
-        tool: bindTool(ACTIVITY, {
-            activity: (_actor, request) => ({ entries: list(request.since, request.limit) }),
-        }),
-    };
-}

package/dist/src/domain/capabilities.d.ts

@@ -1,15 +0,0 @@
-/** Explicit Hub Tools shared by discovery and invocation, with operations kept private. */
-import { type ToolDescriptor } from "./model/index.ts";
-import type { FeatureTool, Operation } from "./tools.ts";
-interface ToolExposure extends Pick<ToolDescriptor, "id" | "name"> {
-    interfaces: {
-        operation: Operation;
-        offer: ToolDescriptor["interfaces"][number];
-    }[];
-}
-export declare function descriptorsOf(tools: ToolExposure[]): ToolDescriptor[];
-export declare function capabilities(tools: FeatureTool[]): {
-    list: () => ToolExposure[];
-};
-export type Capabilities = ReturnType<typeof capabilities>;
-export {};

package/dist/src/domain/capabilities.js

@@ -1,31 +0,0 @@
-/** Explicit Hub Tools shared by discovery and invocation, with operations kept private. */
-import { objectSchema } from "./model/index.js";
-export function descriptorsOf(tools) {
-    return tools.map(({ id, name, interfaces }) => ({
-        id,
-        name,
-        interfaces: interfaces.map((each) => each.offer),
-    }));
-}
-export function capabilities(tools) {
-    const exposed = tools.map((tool) => ({
-        id: tool.id,
-        name: tool.name,
-        interfaces: tool.interfaces.map((operation) => ({
-            operation,
-            offer: {
-                call: operation.name,
-                interface: {
-                    name: operation.name,
-                    description: operation.definition.description,
-                    input: objectSchema(operation.definition.request, "input"),
-                    output: objectSchema(operation.definition.response, "output"),
-                    one_way: false,
-                    long_running: false,
-                },
-                read_only: !operation.definition.writes,
-            },
-        })),
-    }));
-    return { list: () => exposed };
-}

package/dist/src/domain/claims.d.ts

@@ -1,17 +0,0 @@
-/**
- * Claims on shared resources, such as a release lane or a cluster: which actor holds each one now.
- *
- * A resource has at most one current claim. Claiming one another actor holds is refused, naming
- * the holder; claiming one the actor holds renews it. A claim ends when its holder releases it,
- * when its `until` passes, or when its holder is closed, so an ended claim needs no clearing up.
- */
-import { type RequestOf } from "./model/index.ts";
-import type { ClaimRow, Store } from "./ports.ts";
-import type { ActorRow, Registry } from "./registry.ts";
-export { CLAIMS as definition } from "./model/index.ts";
-export declare function claims(claimStore: Store["claims"], registry: Registry, now: () => string): {
-    claim: (actor: ActorRow, request: RequestOf<"claim">) => ClaimRow;
-    release: (actor: ActorRow, request: RequestOf<"release">) => ClaimRow;
-    tool: import("./tools.ts").FeatureTool;
-};
-export type Claims = ReturnType<typeof claims>;

package/dist/src/domain/claims.js

@@ -1,55 +0,0 @@
-/**
- * Claims on shared resources, such as a release lane or a cluster: which actor holds each one now.
- *
- * A resource has at most one current claim. Claiming one another actor holds is refused, naming
- * the holder; claiming one the actor holds renews it. A claim ends when its holder releases it,
- * when its `until` passes, or when its holder is closed, so an ended claim needs no clearing up.
- */
-import { Conflict, Forbidden, Invalid, NotFound } from "./errors.js";
-import { CLAIMS } from "./model/index.js";
-import { bindTool } from "./tools.js";
-export { CLAIMS as definition } from "./model/index.js";
-export function claims(claimStore, registry, now) {
-    function claim(actor, request) {
-        const at = now();
-        const until = request.until === undefined ? null : new Date(request.until).toISOString();
-        if (until !== null && until <= at)
-            throw new Invalid("until: it has already passed");
-        const held = heldClaim(request.resource);
-        if (held && held.holder !== actor.id)
-            throw new Conflict(heldMessage(held));
-        const claim = {
-            resource: request.resource,
-            holder: actor.id,
-            note: request.note,
-            until,
-            claimed_at: held?.claimed_at ?? at,
-        };
-        claimStore.put(claim);
-        return claim;
-    }
-    function release(actor, request) {
-        const held = heldClaim(request.resource);
-        if (!held)
-            throw new NotFound(`nobody holds ${request.resource}`);
-        if (held.holder !== actor.id && registry.root()?.id !== actor.id) {
-            throw new Forbidden(`${heldMessage(held)}; only it or the person releases it`);
-        }
-        claimStore.remove(request.resource);
-        return held;
-    }
-    function heldClaim(resource) {
-        const claim = claimStore.get(resource);
-        return claim && current(claim) ? claim : undefined;
-    }
-    function current(claim) {
-        const open = registry.get(claim.holder)?.closed_at === null;
-        return open && (claim.until === null || claim.until > now());
-    }
-    function heldMessage(claim) {
-        const holder = registry.names([claim.holder])[claim.holder] ?? claim.holder;
-        const until = claim.until === null ? "" : ` until ${claim.until}`;
-        return `${claim.resource} is held by ${holder}${until}: ${claim.note}`;
-    }
-    return { claim, release, tool: bindTool(CLAIMS, { claim, release }) };
-}

package/dist/src/domain/connections.d.ts

@@ -1,32 +0,0 @@
-import type { ConnectionPrincipal } from "./model/system.ts";
-export interface ConnectionControl {
-    detach(): void;
-    revoke(): void;
-    pendingFactoryRequests?(): number;
-    selectedForCreation?(): boolean;
-}
-export interface AdmittedConnection {
-    connectionId: string;
-    principal: ConnectionPrincipal;
-    admittedAt: string;
-    ordinal: number;
-    state: "admitted" | "closing";
-    activeInvocations: number;
-    activeCreations: number;
-    control: ConnectionControl;
-}
-export declare function connections(now: () => string): {
-    admit(connectionId: string, principal: ConnectionPrincipal, control: ConnectionControl): void;
-    remove: (id: string) => void;
-    get: (id: string) => AdmittedConnection | undefined;
-    entries: () => AdmittedConnection[];
-    head: () => number;
-    connected: (actorId: string) => boolean;
-    assertActor(id: string, actorId: string): void;
-    beginInvocation(id: string, actorId: string): () => void;
-    beginCreation(id: string): () => void;
-    busy: (entry: AdmittedConnection) => boolean;
-    detach(id: string): void;
-    disconnect(actorId: string): void;
-};
-export type Connections = ReturnType<typeof connections>;