@vzlentin/harness 0.3.0 → 0.4.0

package/dist/mirror.js

@@ -13,28 +13,46 @@ import { applyChange } from "./view-change.js";
 import { inboxOf, withdrawnTexts } from "./view-state.js";
 /** The `customType` of the session entry that holds the target of a mirror session. */
 export const MIRROR_ENTRY = "harness-mirror";
-/** The conversation that a mirror session shows: the child or project agent `handle` of the host of `project`. */
-export const MirrorTarget = Type.Object({ project: Type.String(), handle: Type.String() });
+/**
+ * The conversation that a mirror session shows, in the host of `project`: the child or project agent `handle`, or the
+ * conversation `conversation` that the children library opened. Each refuses the other key.
+ */
+export const MirrorTarget = Type.Union([
+    Type.Object({ project: Type.String(), handle: Type.String(), conversation: Type.Optional(Type.Never()) }),
+    Type.Object({ project: Type.String(), conversation: Type.String(), handle: Type.Optional(Type.Never()) }),
+]);
 /** Whether the data of a session entry is a mirror target. */
 export function isMirrorTarget(data) {
     return Value.Check(MirrorTarget, data);
 }
-/** The Pi flags that open a mirror session of a target: the project, and the child in place of the project agent. */
-export const PI_FLAGS = { project: "harness", child: "harness-child" };
+/**
+ * The Pi flags that open a mirror session of a target: the project, and the child or the conversation in place of the
+ * project agent.
+ */
+export const PI_FLAGS = { project: "harness", child: "harness-child", conversation: "harness-conversation" };
 /** The arguments of `pi` that open a mirror session of `target`. */
 export function piArgs(target) {
-    const child = target.handle === AGENT_HANDLE ? [] : [`--${PI_FLAGS.child}`, target.handle];
+    const child = target.conversation !== undefined
+        ? [`--${PI_FLAGS.conversation}`, target.conversation]
+        : target.handle === AGENT_HANDLE
+            ? []
+            : [`--${PI_FLAGS.child}`, target.handle];
     return [`--${PI_FLAGS.project}`, target.project, ...child];
 }
 /**
  * The arguments of the `harness` CLI that open `target` in Pi: `<project>` for the project agent, `--project <project>
- * attach <handle>` for a child.
+ * attach <handle>` for a child, and `--project <project> attach --conversation <id>` for a conversation.
  */
 export function harnessArgs(target) {
+    if (target.conversation !== undefined) {
+        return ["--project", target.project, "attach", "--conversation", target.conversation];
+    }
     return target.handle === AGENT_HANDLE ? [target.project] : ["--project", target.project, "attach", target.handle];
 }
-/** The title of the agent of `target` before the host gives its name. */
+/** The title of the agent of `target` before the host gives its name: the handle or the conversation ID of a child. */
 export function targetTitle(target) {
+    if (target.conversation !== undefined)
+        return target.conversation;
     return target.handle === AGENT_HANDLE ? `${target.project} agent` : target.handle;
 }
 const RETRY_DELAYS_MS = [0, 2000, 5000];
@@ -51,6 +69,8 @@ const HOST_CLOSED = "The harness host closed the connection";
  */
 export class Mirror {
     target;
+    /** The target of the requests: the handle or the conversation of `target`, without the project. */
+    #ref;
     #onChange;
     #retryDelaysMs;
     #start;
@@ -65,6 +85,7 @@ export class Mirror {
     #sending = false;
     constructor(target, onChange, options = {}) {
         this.target = target;
+        this.#ref = target.conversation === undefined ? { handle: target.handle } : { conversation: target.conversation };
         this.#onChange = onChange;
         this.#retryDelaysMs = options.retryDelaysMs ?? RETRY_DELAYS_MS;
         this.#start = options.start ?? true;
@@ -105,13 +126,20 @@ export class Mirror {
     async abort() {
         const { client, view } = this.#connection();
         const texts = withdrawnTexts(inboxOf(view));
-        this.#setChild(await client.request({ type: "abort", handle: this.target.handle }));
+        this.#setChild(await client.request({ type: "abort", ...this.#ref }));
         return texts;
     }
-    /** Changes the model or the thinking level. The host refuses a model it does not know and a level it does not have. */
+    /**
+     * Changes the model or the thinking level. The host refuses a model it does not know and a level it does not have. A
+     * conversation of the children library refuses it without a request.
+     */
     async configure(change) {
+        const { handle } = this.target;
+        if (handle === undefined) {
+            throw new Error("A conversation of the children library keeps its model and thinking level");
+        }
         const { client } = this.#connection();
-        this.#setChild(await client.request({ type: "configure", handle: this.target.handle, ...change }));
+        this.#setChild(await client.request({ type: "configure", handle, ...change }));
     }
     /** Closes the connection and stops connecting. The conversation keeps running in the host. */
     close() {
@@ -168,7 +196,7 @@ export class Mirror {
                 client = await connect({ start: this.#start, project: this.target.project, signal });
                 if (client === undefined)
                     throw new Error("Could not connect to the harness host");
-                const watched = await client.watch(this.target.handle);
+                const watched = await client.watch(this.#ref);
                 if (signal.aborted) {
                     client.close();
                     break;
@@ -210,7 +238,7 @@ export class Mirror {
                     const reply = await client.request({
                         type: "input",
                         requestId,
-                        handle: this.target.handle,
+                        ...this.#ref,
                         message,
                         followUp,
                     });

package/dist/protocol.d.ts

@@ -5,16 +5,20 @@ import type { ConversationView, TaskId, TaskOutcome, TaskState } from "@earendil
 import { type Static, Type } from "typebox";
 import type { ViewChange } from "./view-change.ts";
 /** The version of the protocol between the CLI and the host. A client refuses a host with another version. */
-export declare const PROTOCOL_VERSION = 8;
+export declare const PROTOCOL_VERSION = 9;
 /**
  * The handle of the project agent, the host's root conversation, in `watch`, `input`, `abort` and `configure`. It is not
  * hex, so no child has it.
  */
 export declare const AGENT_HANDLE = "agent";
 export type ChildState = "busy" | "idle" | "error";
-/** One child as the host reports it. Provider, model and thinking level come from the child's agent. */
+/**
+ * One child as the host reports it. Provider, model and thinking level come from the child's agent. For a `{ conversation }`
+ * target, `handle` and `conversation` are the conversation ID, and `name` is the child's lineage key.
+ */
 export type ChildInfo = {
     readonly handle: string;
+    readonly conversation?: string;
     readonly name?: string;
     readonly state: ChildState;
     readonly provider: string;
@@ -41,6 +45,17 @@ export type TaskInfo = {
 export declare const Json: Type.TCyclic<{
     Json: Type.TUnion<[Type.TNull, Type.TBoolean, Type.TNumber, Type.TString, Type.TArray<Type.TRef<"Json">>, Type.TRecord<"^.*$", Type.TRef<"Json">>]>;
 }, "Json">;
+/**
+ * The target of `watch`, `input` and `abort`: a handle, or the ID of a conversation that the children library opened,
+ * such as a child of a task.
+ */
+export type Target = {
+    readonly handle: string;
+    readonly conversation?: never;
+} | {
+    readonly conversation: string;
+    readonly handle?: never;
+};
 /** One request line. The caller is `PI_SESSION_ID`, or `cli` without one. */
 export type Request = {
     readonly type: "hello";
@@ -91,15 +106,13 @@ export type Request = {
  * after each commit to the child's conversation and after each rename. Every other line on the connection stays a
  * reply, in request order. A connection carries one watch.
  */
- | {
+ | ({
     readonly type: "watch";
-    readonly handle: string;
-}
+} & Target)
 /** Stops the child's current turn. A mirror session sends it. */
- | {
+ | ({
     readonly type: "abort";
-    readonly handle: string;
-}
+} & Target)
 /**
  * A mirror session's change of the child's model or thinking level. It has no caller. A new model keeps the thinking level
  * when the model has it, and takes the nearest level that it has otherwise. The host refuses a level that the model
@@ -112,14 +125,13 @@ export type Request = {
     readonly model?: string;
     readonly thinking?: ModelThinkingLevel;
 }
-/** A mirror session's message to the child. It has no caller. */
- | {
+/** A mirror session's message to the child. It has no caller. A conversation takes it only while it works, as a steer. */
+ | ({
     readonly type: "input";
     readonly requestId: string;
-    readonly handle: string;
     readonly message: string;
     readonly followUp: boolean;
-}
+} & Target)
 /**
  * Starts a background task of the kind `kind`, a task of an entry in `entries.json`, in the root conversation.
  * A repeated `key` gives the first task, and its new kind, version and input are ignored. With `version`, a host
@@ -190,25 +202,45 @@ export declare const RequestLine: Type.TUnion<[Type.TObject<{
     type: Type.TLiteral<"stop">;
     caller: Type.TString;
     handle: Type.TString;
-}>, Type.TObject<{
+}>, Type.TUnion<[Type.TObject<{
     type: Type.TLiteral<"watch">;
     handle: Type.TString;
+    conversation: Type.TOptional<Type.TNever>;
 }>, Type.TObject<{
+    type: Type.TLiteral<"watch">;
+    conversation: Type.TString;
+    handle: Type.TOptional<Type.TNever>;
+}>]>, Type.TUnion<[Type.TObject<{
     type: Type.TLiteral<"abort">;
     handle: Type.TString;
+    conversation: Type.TOptional<Type.TNever>;
 }>, Type.TObject<{
+    type: Type.TLiteral<"abort">;
+    conversation: Type.TString;
+    handle: Type.TOptional<Type.TNever>;
+}>]>, Type.TObject<{
     type: Type.TLiteral<"configure">;
     handle: Type.TString;
     provider: Type.TOptional<Type.TString>;
     model: Type.TOptional<Type.TString>;
     thinking: Type.TOptional<Type.TString>;
-}>, Type.TObject<{
-    type: Type.TLiteral<"input">;
+}>, Type.TUnion<[Type.TObject<{
     requestId: Type.TString;
-    handle: Type.TString;
     message: Type.TString;
     followUp: Type.TBoolean;
+} & {
+    type: Type.TLiteral<"input">;
+    handle: Type.TString;
+    conversation: Type.TOptional<Type.TNever>;
 }>, Type.TObject<{
+    requestId: Type.TString;
+    message: Type.TString;
+    followUp: Type.TBoolean;
+} & {
+    type: Type.TLiteral<"input">;
+    conversation: Type.TString;
+    handle: Type.TOptional<Type.TNever>;
+}>]>, Type.TObject<{
     type: Type.TLiteral<"start">;
     kind: Type.TString;
     input: Type.TCyclic<{
@@ -292,23 +324,26 @@ export type StatePaths = {
 };
 export declare function statePaths(project: string): StatePaths;
 export declare function isValidRunName(value: string): boolean;
-/** The label of a child: its name, or its handle when it has no name. */
-export declare function childLabel(child: {
+type Labeled = {
     readonly handle: string;
     readonly name?: string | undefined;
-}): string;
+    readonly conversation?: string | undefined;
+};
+/** The label of a child: its name, or its handle when it has no name. */
+export declare function childLabel(child: Labeled): string;
 export declare function runDisplayName(metadata: {
     readonly handle: string;
     readonly name?: string | undefined;
 }): string;
-/** The title of a child in a client: `<name> (<handle>)`, or only the name for the project agent, which says what it is. */
-export declare function childTitle(child: {
-    readonly handle: string;
-    readonly name?: string | undefined;
-}): string;
+/**
+ * The title of a child in a client: `<name> (<handle>)`, or only the name for the project agent, which says what it is,
+ * and for a conversation, whose name is its key.
+ */
+export declare function childTitle(child: Labeled): string;
 /** The message of a thrown value. */
 export declare function errorMessage(cause: unknown): string;
 /** The line of one child in a list. */
 export declare function childLine(child: ChildInfo): string;
 /** Calls `onLine` with each line that arrives on `socket`, without its newline. */
 export declare function onLines(socket: Socket, onLine: (line: string) => void): void;
+export {};

package/dist/protocol.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Type } from "typebox";
 /** The version of the protocol between the CLI and the host. A client refuses a host with another version. */
-export const PROTOCOL_VERSION = 8;
+export const PROTOCOL_VERSION = 9;
 /**
  * The handle of the project agent, the host's root conversation, in `watch`, `input`, `abort` and `configure`. It is not
  * hex, so no child has it.
@@ -20,6 +20,26 @@ export const Json = Type.Cyclic({
         Type.Record(Type.String(), Type.Ref("Json")),
     ]),
 }, "Json");
+/**
+ * The request objects of `type` with `fields` and a target: one with `handle`, one with `conversation`. Each refuses the
+ * other key, because an object schema accepts extra keys.
+ */
+function targeted(type, fields) {
+    return Type.Union([
+        Type.Object({
+            ...fields,
+            type: Type.Literal(type),
+            handle: Type.String(),
+            conversation: Type.Optional(Type.Never()),
+        }),
+        Type.Object({
+            ...fields,
+            type: Type.Literal(type),
+            conversation: Type.String(),
+            handle: Type.Optional(Type.Never()),
+        }),
+    ]);
+}
 /**
  * The check of a request line on the host. It is looser than `Request`, so the host answers a spawn without `cwd` and an
  * unknown thinking level with its own errors.
@@ -52,8 +72,8 @@ export const RequestLine = Type.Union([
     Type.Object({ type: Type.Literal("list"), caller: Type.String() }),
     Type.Object({ type: Type.Literal("rename"), caller: Type.String(), handle: Type.String(), name: Type.String() }),
     Type.Object({ type: Type.Literal("stop"), caller: Type.String(), handle: Type.String() }),
-    Type.Object({ type: Type.Literal("watch"), handle: Type.String() }),
-    Type.Object({ type: Type.Literal("abort"), handle: Type.String() }),
+    targeted("watch", {}),
+    targeted("abort", {}),
     Type.Object({
         type: Type.Literal("configure"),
         handle: Type.String(),
@@ -61,13 +81,7 @@ export const RequestLine = Type.Union([
         model: Type.Optional(Type.String()),
         thinking: Type.Optional(Type.String()),
     }),
-    Type.Object({
-        type: Type.Literal("input"),
-        requestId: Type.String(),
-        handle: Type.String(),
-        message: Type.String(),
-        followUp: Type.Boolean(),
-    }),
+    targeted("input", { requestId: Type.String(), message: Type.String(), followUp: Type.Boolean() }),
     Type.Object({
         type: Type.Literal("start"),
         kind: Type.String(),
@@ -106,9 +120,12 @@ export function childLabel(child) {
 export function runDisplayName(metadata) {
     return metadata.name ? `${metadata.name} (${metadata.handle})` : metadata.handle;
 }
-/** The title of a child in a client: `<name> (<handle>)`, or only the name for the project agent, which says what it is. */
+/**
+ * The title of a child in a client: `<name> (<handle>)`, or only the name for the project agent, which says what it is,
+ * and for a conversation, whose name is its key.
+ */
 export function childTitle(child) {
-    return child.handle === AGENT_HANDLE ? childLabel(child) : runDisplayName(child);
+    return child.handle === AGENT_HANDLE || child.conversation !== undefined ? childLabel(child) : runDisplayName(child);
 }
 /** The message of a thrown value. */
 export function errorMessage(cause) {

package/dist/setup.d.ts

@@ -1,14 +1,14 @@
 /**
- * Registers `<packageDir>/pi` in Pi when `packageDir` is a top-level global npm install. It writes its messages to
- * stderr, and it does not throw for a Pi failure: it writes a warning with the command to run. It writes the stamp
- * that `setupOnce` reads unless `pi` failed, so the next run tries again. Without `pi` on PATH it writes the stamp, so
- * a user without Pi gets the hint once per version.
+ * Registers `npm:<piPackage>@<version>` in Pi when `packageDir` is a top-level global npm install, with the version of
+ * `<packageDir>/package.json`. It writes its messages to stderr, and it does not throw for a Pi failure: it writes a
+ * warning with the command to run. It writes the stamp that `setupOnce` reads unless `pi` failed, so the next run
+ * tries again. Without `pi` on PATH it writes the stamp, so a user without Pi gets the hint once per version.
  */
-export declare function setup(packageDir: string): void;
+export declare function setup(packageDir: string, piPackage: string): void;
 /**
  * `setup` once per version and path of the package: it does nothing when the stamp of `setup` exists. It never
  * throws; an error is a warning.
  */
-export declare function setupOnce(packageDir: string): void;
+export declare function setupOnce(packageDir: string, piPackage: string): void;
 /** The `PATH` without the `node_modules/.bin` folders that npm adds: pi-coding-agent there has its own `pi`. */
 export declare function userPath(): string;

package/dist/setup.js

@@ -1,6 +1,7 @@
 /**
- * Registers the Pi extension of a globally installed package in Pi. The `postinstall` script and the CLI of the package
- * run it, since npm 12 does not run install scripts by default. workflows uses it too, as `@vzlentin/harness/setup`.
+ * Registers the Pi package of a globally installed package in Pi, as `npm:<piPackage>@<version>`. The `postinstall`
+ * script and the CLI of the package run it, since npm 12 does not run install scripts by default. workflows uses it
+ * too, as `@vzlentin/harness/setup`, with its own Pi package.
  */
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
@@ -18,28 +19,28 @@ const PiSettings = Type.Object({
 /** The prefixes of the Pi package sources that are not local paths, as Pi reads them. */
 const REMOTE = ["npm:", "git:", "github:", "http:", "https:", "ssh:", "builtin:"];
 /**
- * Registers `<packageDir>/pi` in Pi when `packageDir` is a top-level global npm install. It writes its messages to
- * stderr, and it does not throw for a Pi failure: it writes a warning with the command to run. It writes the stamp
- * that `setupOnce` reads unless `pi` failed, so the next run tries again. Without `pi` on PATH it writes the stamp, so
- * a user without Pi gets the hint once per version.
+ * Registers `npm:<piPackage>@<version>` in Pi when `packageDir` is a top-level global npm install, with the version of
+ * `<packageDir>/package.json`. It writes its messages to stderr, and it does not throw for a Pi failure: it writes a
+ * warning with the command to run. It writes the stamp that `setupOnce` reads unless `pi` failed, so the next run
+ * tries again. Without `pi` on PATH it writes the stamp, so a user without Pi gets the hint once per version.
  */
-export function setup(packageDir) {
+export function setup(packageDir, piPackage) {
     const installed = readInstalled(packageDir);
     if (installed === undefined || !isTopLevelGlobal(installed))
         return;
-    if (registerExtension(installed))
+    if (registerExtension(installed, piPackage))
         writeStamp(installed);
 }
 /**
  * `setup` once per version and path of the package: it does nothing when the stamp of `setup` exists. It never
  * throws; an error is a warning.
  */
-export function setupOnce(packageDir) {
+export function setupOnce(packageDir, piPackage) {
     try {
         const installed = readInstalled(packageDir);
         if (installed === undefined || !isTopLevelGlobal(installed) || existsSync(stampPath(installed)))
             return;
-        if (registerExtension(installed))
+        if (registerExtension(installed, piPackage))
             writeStamp(installed);
     }
     catch (error) {
@@ -76,15 +77,15 @@ function writeStamp(installed) {
     writeFileSync(path, `${installed.dir}\n${installed.json.version}\n`);
 }
 /**
- * False when `pi install` failed. It runs no `pi` when Pi already lists the extension, as `pi install` would write the
- * entry again in its own form, relative to the agent directory.
+ * Runs `pi install npm:<piPackage>@<version>` unless Pi already lists it. False when `pi install` failed. Pi replaces
+ * an entry with the same package name, so an older version or a range is updated in place.
  */
-function registerExtension({ dir, json }) {
+function registerExtension({ json }, piPackage) {
     const label = basename(json.name);
-    const extension = join(dir, "pi");
-    if (piLists(extension))
+    const source = `npm:${piPackage}@${json.version}`;
+    if (piLists(piPackage, source))
         return true;
-    return runPi(label, ["install", extension], `To add the Pi extension of ${label}, run: pi install ${extension}`);
+    return runPi(label, ["install", source], `To add the Pi extension of ${label}, run: pi install ${source}`);
 }
 /** Runs `pi`, with a warning when it is missing or fails. False when it failed; true when it worked or is missing. */
 function runPi(label, args, later) {
@@ -105,10 +106,11 @@ function runPi(label, args, later) {
     return true;
 }
 /**
- * Whether the `packages` of Pi's global settings list the folder `extension` as a local path, absolute or relative to
- * the agent directory, with `~` or as a `file:` URL, as Pi resolves them.
+ * Whether the `packages` of Pi's global settings list `source` exactly, or a local folder whose `package.json` has the
+ * name `piPackage`, at any version. A local path is absolute or relative to the agent directory, with `~` or as a
+ * `file:` URL, as Pi resolves it. Another remote source, such as another `npm:` spec, is not listed.
  */
-function piLists(extension) {
+function piLists(piPackage, source) {
     const env = process.env.PI_CODING_AGENT_DIR;
     const agentDir = env ? expandHome(env) : join(homedir(), ".pi", "agent");
     let settings;
@@ -121,12 +123,15 @@ function piLists(extension) {
     if (!Value.Check(PiSettings, settings))
         return false;
     return (settings.packages ?? []).some((item) => {
-        const source = (Value.Check(Type.String(), item) ? item : item.source).trim();
-        if (REMOTE.some((prefix) => source.startsWith(prefix)))
+        const entry = (Value.Check(Type.String(), item) ? item : item.source).trim();
+        if (entry === source)
+            return true;
+        if (REMOTE.some((prefix) => entry.startsWith(prefix)))
             return false;
-        const path = source.startsWith("file://") ? fileURLToPath(source) : resolve(agentDir, expandHome(source));
         try {
-            return realpathSync(path) === extension;
+            const path = entry.startsWith("file://") ? fileURLToPath(entry) : resolve(agentDir, expandHome(entry));
+            const json = JSON.parse(readFileSync(join(path, "package.json"), "utf8"));
+            return Value.Check(PackageJson, json) && json.name === piPackage;
         }
         catch {
             return false;

package/dist/targets.d.ts

@@ -0,0 +1,67 @@
+import * as durable from "@earendil-works/pi-durable";
+import { type Conversation, type ConversationId, type Harness } from "@earendil-works/pi-durable";
+import { type Child, type Input, type Owner, type Place } from "./children.ts";
+import { type ChildInfo, type Target } from "./protocol.ts";
+/** What the targets use of the host. */
+export type TargetHost = {
+    readonly harness: Harness;
+    /** The host's store, models and tools, for the children library. */
+    readonly place: Place;
+    readonly owner: Owner;
+    readonly project: string;
+    /** The project agent: the root conversation, with a model and the project directory from its first use. */
+    readonly agent: () => Promise<Conversation>;
+};
+export type ChildRecord = {
+    name?: string;
+    /** `PI_SESSION_ID` of the spawner: a Pi session, the conversation ID of another child, or `cli`. */
+    caller: string;
+    createdAt: string;
+    conversationId: ConversationId;
+    /** The request IDs of the spawn and of each `send` of the caller, in order. */
+    sent?: string[];
+    /** How many requests of `sent` a `wait` gave the answer of. */
+    read?: number;
+};
+export type ChildrenState = {
+    children: Record<string, ChildRecord>;
+    requests: Record<string, string>;
+};
+/**
+ * The children by handle, and the handle of each spawn request ID. Version 2 leaves each child's last request to the
+ * children library; a store with version 1 has children that the library does not know.
+ */
+export declare const Children: durable.SessionDocToken<ChildrenState>;
+/** The children library, on this process's pi-durable. */
+export declare const library: import("./children.ts").Children;
+/**
+ * The conversation of `ref`: a child or the project agent by handle, or a conversation of the children library by ID,
+ * with its info, its input, and the record of a child.
+ */
+export declare function target(handler: TargetHost, ref: Target): Promise<{
+    conversation: Conversation;
+    info: () => Promise<ChildInfo>;
+    send: (input: Input) => Promise<void>;
+    record: undefined;
+} | {
+    conversation: Conversation;
+    info: () => Promise<ChildInfo>;
+    send: (input: Input) => Promise<void>;
+    record: ChildRecord;
+}>;
+export type Found = Awaited<ReturnType<typeof target>>;
+/** The target of the child `handle`, whose record is `record`. */
+export declare function childTarget(handler: TargetHost, handle: string, record: ChildRecord): Promise<{
+    conversation: Conversation;
+    info: () => Promise<ChildInfo>;
+    send: (input: Input) => Promise<void>;
+    record: ChildRecord;
+}>;
+export declare function childRecord(harness: Harness, handle: string): Promise<ChildRecord>;
+/** The record of `handle`, which must belong to `caller`. */
+export declare function ownRecord(harness: Harness, handle: string, caller: string): Promise<ChildRecord>;
+export declare function childOf(handler: Pick<TargetHost, "place" | "owner">, record: ChildRecord): Promise<Child>;
+/** The info of `handle`. A caller that already has the record gives it as `record`. */
+export declare function childInfo(handler: Pick<TargetHost, "harness" | "place" | "owner">, handle: string, record?: ChildRecord): Promise<ChildInfo>;
+/** The record of `handle` in the `Children` value `state`. */
+export declare function recordOf(state: Readonly<ChildrenState> | null | undefined, handle: string): ChildRecord | undefined;