@idleware/ringi 0.5.0 → 0.6.0

package/target/dts/core/hub/signals/model.d.ts

@@ -0,0 +1,28 @@
+import type { AuthorityAt } from '../decisions/index.ts';
+import type { Profile } from '../work/index.ts';
+export type RoomModel = {
+    name: string;
+    genesis: string;
+    profile: Profile;
+    members: Record<string, unknown>;
+    authorityAt: AuthorityAt;
+};
+export type SignalRecord = {
+    ref: string;
+    object: string;
+    name: string;
+    actor: string;
+    target: string;
+    tagger: string;
+    text: string;
+};
+export type Checked = {
+    ref: string;
+    actor: string;
+    signal: string;
+    target: string;
+    ok: boolean;
+    why?: string;
+};
+export declare const MARKS: string[];
+export declare const signalName: (id: string, signal: string) => string;

package/target/dts/core/hub/signals/pins.d.ts

@@ -0,0 +1,5 @@
+import type { Checked, SignalRecord } from './model.ts';
+export declare const pins: (records: SignalRecord[], checked: Checked[], accepted?: Record<string, string>) => {
+    accepted: Record<string, string>;
+    alarms: string[];
+};

package/target/dts/{hub/signals.d.ts → core/hub/signals/write.d.ts}

@@ -1,4 +1,4 @@
 import type { All, Message } from '../protocol/index.ts';
-import type { Room } from './index.ts';
+import type { Room } from '../rooms/index.ts';
 export declare const mark: (R: Room, who: string, m: Message, name: string) => boolean;
 export declare const emit: (R: Room, who: string, all: All, m: Message) => number;

package/target/dts/core/hub/usecases/actor.d.ts

@@ -0,0 +1,6 @@
+import type { Room } from '../rooms/index.ts';
+export type Actor = {
+    R: Room;
+    me: string;
+};
+export declare const isRef: (R: Room) => (x: string) => boolean;

package/target/dts/{app → core/hub/usecases}/budget.d.ts

@@ -1,22 +1,7 @@
-import * as D from '../domain/decisions.ts';
-import type { Entry } from '../protocol/files.ts';
+import * as D from '../decisions/index.ts';
 import type { Message } from '../protocol/index.ts';
-import type { Actor } from './room.ts';
+import type { Actor } from './actor.ts';
 import type { GrantView, ProposalView } from './view.ts';
-export type ProposeInput = {
-    text: string;
-    decider: string;
-    reviewers?: string[];
-    budget?: string;
-    due?: string;
-    supersedes?: string;
-    files?: Entry[];
-};
-export declare const propose: ({ R, me }: Actor, x: ProposeInput) => {
-    id: string;
-    to: string[];
-    budget: D.Budget | null;
-};
 export declare const stamp: ({ R, me }: Actor, ref: string, s: string, text: string) => {
     proposal: Message;
     id: string;
@@ -33,4 +18,6 @@ export declare const proposals: ({ R, me }: Actor, { all: everything }?: {
     views: ProposalView[];
 };
 export declare const grants: ({ R, me }: Actor) => GrantView[];
-export { DECISIONS, STAMPS, budgetText } from '../domain/decisions.ts';
+export { propose } from './propose.ts';
+export type { ProposeInput } from './propose.ts';
+export { DECISIONS, STAMPS, budgetText } from '../decisions/index.ts';

package/target/dts/core/hub/usecases/config.d.ts

@@ -0,0 +1,6 @@
+export type Config = {
+    hub: string;
+    room: string | null;
+};
+export declare const config: () => Config;
+export declare const setConfig: (patch: Partial<Config>) => void;

package/target/dts/{app → core/hub/usecases}/context.d.ts

@@ -1,14 +1,9 @@
-import { config } from '../home/index.ts';
-import type { Session } from '../runtime/session.ts';
-import type { Actor } from './room.ts';
-export type Ctx = Actor & {
-    s?: Session;
-};
+import { config } from '../rooms/index.ts';
+import type { Actor } from './actor.ts';
 export declare const operator: ({ hub, room }?: {
     hub?: string;
     room?: string;
-}) => Ctx;
-export declare const agent: () => Ctx;
+}) => Actor;
 export declare const about: () => {
     version: string;
     home: string;

package/target/dts/{app → core/hub/usecases}/hubs.d.ts

@@ -1,4 +1,4 @@
-import type { Hub } from '../hub/index.ts';
+import type { Hub } from '../rooms/index.ts';
 export declare const hubOf: (name?: string) => Hub;
 export type HubView = {
     name: string;

package/target/dts/core/hub/usecases/propose.d.ts

@@ -0,0 +1,17 @@
+import * as D from '../decisions/index.ts';
+import type { Entry } from '../protocol/files.ts';
+import type { Actor } from './actor.ts';
+export type ProposeInput = {
+    text: string;
+    decider: string;
+    reviewers?: string[];
+    budget?: string;
+    due?: string;
+    supersedes?: string;
+    files?: Entry[];
+};
+export declare const propose: ({ R, me }: Actor, x: ProposeInput) => {
+    id: string;
+    to: string[];
+    budget: D.Budget | null;
+};

package/target/dts/{app → core/hub/usecases}/room.d.ts

@@ -1,38 +1,12 @@
-import type { Task } from '../domain/profiles.ts';
-import * as Signals from '../domain/signals.ts';
-import type { Room } from '../hub/index.ts';
-import type { Entry } from '../protocol/files.ts';
+import * as Signals from '../signals/index.ts';
+import type { Task } from '../work/index.ts';
+import type { Room } from '../rooms/index.ts';
 import type { All, Message } from '../protocol/index.ts';
-import type { Staged } from '../runtime/reader.ts';
+import type { Actor } from './actor.ts';
 import type { TaskView } from './view.ts';
-export type Actor = {
-    R: Room;
-    me: string;
-};
-export declare const isRef: (R: Room) => (x: string) => boolean;
-export type SendInput = {
-    text: string;
-    to?: string[];
-    re?: string;
-    reply?: boolean;
-    all?: boolean;
-    task?: boolean;
-    state?: string;
-    assign?: string[];
-    roles?: string;
-    grant?: string;
-    files?: Entry[];
-};
-export type Sent = {
-    id: string;
-    to: string[];
-    files: number;
-};
-export declare const FILE_MAX: number;
-export declare const staged: ({ R, me }: Actor) => Staged[];
-export declare const stage: ({ R, me }: Actor, files: Entry[]) => Staged[];
-export declare const unstage: (a: Actor, paths: string[] | null) => Staged[];
-export declare const send: ({ R, me }: Actor, x: SendInput) => Sent;
+export * from './actor.ts';
+export * from './staging.ts';
+export * from './send.ts';
 export declare const marks: (R: Room, all: All) => Map<string, Record<string, string[]>>;
 export declare const message: ({ R, me }: Actor, ref: string) => {
     all: All;
@@ -77,5 +51,5 @@ export declare const signals: ({ R, me }: Actor, { repair }?: {
     alarms: string[];
     repaired: number | null;
 };
-export { withSizes } from '../hub/index.ts';
+export { withSizes } from '../rooms/index.ts';
 export { checkPath } from '../protocol/files.ts';

package/target/dts/{app → core/hub/usecases}/rooms.d.ts

@@ -1,11 +1,11 @@
-import type { Hub, Room } from '../hub/index.ts';
+import type { Hub, Room } from '../rooms/index.ts';
+export { admit, forgetLog, remove } from './roster.ts';
 export declare const roomIn: (H: Hub, name?: string | null) => Room;
 export type RoomView = {
     name: string;
     current: boolean;
     archived: boolean;
     members: number;
-    active: number;
     profile: string;
     genesis: string;
 };
@@ -19,10 +19,6 @@ export declare const create: (H: Hub, name: string, { profile, quorum }?: {
     profile: string;
 };
 export declare const use: (H: Hub, name: string) => Room;
-export declare const migrate: (H: Hub, name: string) => string;
-export declare const admit: (H: Hub, R: Room, who: string, key: string) => void;
-export declare const remove: (H: Hub, R: Room, who: string) => void;
 export declare const archive: (H: Hub, R: Room) => string;
 export declare const erase: (H: Hub, R: Room) => void;
 export declare const rebase: (H: Hub, R: Room) => void;
-export declare const forgetLog: (H: Hub, R: Room, id: string) => number;

package/target/dts/core/hub/usecases/roster.d.ts

@@ -0,0 +1,5 @@
+import type { Hub, Room } from '../rooms/index.ts';
+export declare const notSigned: (H: Hub, what: string) => void;
+export declare const admit: (H: Hub, R: Room, who: string, key: string) => void;
+export declare const remove: (H: Hub, R: Room, who: string) => void;
+export declare const forgetLog: (H: Hub, R: Room, id: string) => number;

package/target/dts/core/hub/usecases/send.d.ts

@@ -0,0 +1,21 @@
+import type { Entry } from '../protocol/files.ts';
+import type { Actor } from './actor.ts';
+export type SendInput = {
+    text: string;
+    to?: string[];
+    re?: string;
+    reply?: boolean;
+    all?: boolean;
+    task?: boolean;
+    state?: string;
+    assign?: string[];
+    roles?: string;
+    grant?: string;
+    files?: Entry[];
+};
+export type Sent = {
+    id: string;
+    to: string[];
+    files: number;
+};
+export declare const send: ({ R, me }: Actor, x: SendInput) => Sent;

package/target/dts/core/hub/usecases/staging.d.ts

@@ -0,0 +1,8 @@
+import type { Entry } from '../protocol/files.ts';
+import type { Staged } from '../history/index.ts';
+import type { Actor } from './actor.ts';
+export declare const staged: ({ R, me }: Actor) => Staged[];
+export declare const stage: ({ R, me }: Actor, files: Entry[]) => Staged[];
+export declare const shrink: ({ R, me }: Actor, keep: (s: Staged) => boolean) => Staged[];
+export declare const unstage: (a: Actor, paths: string[] | null) => Staged[];
+export declare const outgoing: (stagedNow: Staged[], explicit: Entry[]) => Entry[];

package/target/dts/{app → core/hub/usecases}/view.d.ts

@@ -1,5 +1,5 @@
-import type { Budget, Proposal, Usage } from '../domain/decisions.ts';
-import type { Task } from '../domain/profiles.ts';
+import type { Budget, Proposal, Usage } from '../decisions/index.ts';
+import type { Task } from '../work/index.ts';
 import type { All, FileRef, Message } from '../protocol/index.ts';
 export declare const render: (all: All, m: Message, { max, files }?: {
     max?: number;
@@ -26,8 +26,8 @@ export declare const asJson: (m: Message) => {
         path: string;
         size: number | null;
     }[];
-    refused: import("../protocol/index.ts").Refused[];
-    trailers: import("../protocol/index.ts").Trailers;
+    refused: import("../protocol/model.ts").Refused[];
+    trailers: import("../protocol/model.ts").Trailers;
 };
 export type TaskView = {
     id: string;

package/target/dts/{domain/profiles.d.ts → core/hub/work/index.d.ts}

@@ -1,4 +1,4 @@
-import type { All, Message } from '../protocol/index.ts';
+import type { Message } from '../protocol/index.ts';
 export declare const PROFILE_SCHEMA = "ringi-profile/1";
 export declare const DEFAULT_PROFILE = "a2a-1";
 export declare const PROFILES_CAPABILITY = "profiles/1";
@@ -31,9 +31,5 @@ export type Task = {
     grant: string | null;
     effects: Map<string, string[]>;
 };
-export declare const parseProfile: (text: string, label: string) => Profile;
-export declare const ruleFor: (profile: Profile, state: string) => string[] | undefined;
-export declare const taskFor: (all: All, m: Message, profile: Profile) => Message | null;
-export declare const taskOf: (all: All, root: Message, profile: Profile) => Task;
-export declare const tasksIn: (all: All, profile: Profile) => Task[];
-export declare const isOpen: (t: Task, profile: Profile) => boolean;
+export * from './parse.ts';
+export * from './task.ts';

package/target/dts/core/hub/work/parse.d.ts

@@ -0,0 +1,2 @@
+import type { Profile } from './index.ts';
+export declare const parseProfile: (text: string, label: string) => Profile;

package/target/dts/core/hub/work/task.d.ts

@@ -0,0 +1,6 @@
+import type { All, Message } from '../protocol/index.ts';
+import type { Profile, Task } from './index.ts';
+export declare const taskFor: (all: All, m: Message, profile: Profile) => Message | null;
+export declare const taskOf: (all: All, root: Message, profile: Profile) => Task;
+export declare const tasksIn: (all: All, profile: Profile) => Task[];
+export declare const isOpen: (t: Task, profile: Profile) => boolean;

package/target/dts/core/signing/index.d.ts

@@ -0,0 +1,35 @@
+declare const key: unique symbol;
+export type KeyRef = string & {
+    readonly [key]: true;
+};
+export type PublicIdentity = {
+    key: string;
+    fingerprint: string;
+};
+export type SignRequest = {
+    key: KeyRef;
+    payload: Uint8Array;
+    namespace: string;
+    interaction: 'allowed' | 'forbidden';
+    deadline: number;
+};
+export type Signature = {
+    format: string;
+    bytes: Uint8Array;
+    fingerprint: string;
+    namespace: string;
+};
+export type SigningReason = 'unavailable' | 'denied' | 'interaction-required' | 'timeout';
+export type SigningFault = Error & {
+    reason: SigningReason;
+};
+export interface Signer {
+    publicIdentity(key: KeyRef): PublicIdentity;
+    sign(request: SignRequest): Signature;
+}
+export type SigningContext = {
+    signer: Signer;
+    resolve(hub: string, principal: string, create?: boolean): KeyRef;
+    custody?(hub: string, principal: string): string | null;
+};
+export {};

package/target/dts/index.d.ts

@@ -1,8 +1,8 @@
-export * from './protocol/index.ts';
-export * from './domain/profiles.ts';
-export * as decide from './domain/decisions.ts';
-export * as signals from './domain/signals.ts';
-export type { Store, StoreFactory, Descriptor, StoredRoom, StoredMessage, SignalRecord, Rev } from './store/index.ts';
-export { STORES } from './store/index.ts';
-export { openHub, openRoom, createHub, contractAt } from './hub/index.ts';
-export type { Hub, Room, Contract } from './hub/index.ts';
+import './composition/index.ts';
+export * from './core/hub/protocol/index.ts';
+export * from './core/hub/work/index.ts';
+export * as decide from './core/hub/decisions/index.ts';
+export * as signals from './core/hub/signals/index.ts';
+export type { Store, Transport, Descriptor, StoredRoom, StoredMessage, SignalRecord, Rev } from './core/hub/ports/store.ts';
+export { openHub, openRoom, createHub, contractAt } from './core/hub/rooms/index.ts';
+export type { Hub, Room, Contract } from './core/hub/rooms/index.ts';

package/target/dts/lib/fail.d.ts

@@ -0,0 +1,8 @@
+export declare class Fail extends Error {
+}
+export declare const fail: (msg: string) => never;
+export declare const errno: (e: unknown) => string | undefined;
+export declare class WriteDenied extends Fail {
+    readonly where: string;
+    constructor(where: string, detail: string);
+}

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

@@ -1,6 +1,4 @@
-export declare class Fail extends Error {
-}
-export declare const fail: (msg: string) => never;
+export declare const notesTo: (fn: (line: string) => void) => void;
 export declare const note: (s: string) => void;
 export declare const sleep: (ms: number) => Promise<void>;
 export declare const when: (t: number) => string;
@@ -8,11 +6,5 @@ export declare const bytes: (n: number) => string;
 export declare const short: (id: string) => string;
 export declare const stamp: () => string;
 export declare const words: (v: unknown) => string[];
-export declare const errno: (e: unknown) => string | undefined;
-export declare const writeJsonAtomic: (file: string, v: unknown) => void;
-export declare const strictJson: <T = unknown>(text: string, label?: string) => T;
-export declare const locked: <T>(file: string, fn: () => T, timeout?: number) => T;
-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 * from './fail.ts';
+export * from './json.ts';

package/target/dts/lib/json.d.ts

@@ -0,0 +1 @@
+export declare const strictJson: <T = unknown>(text: string, label?: string) => T;

package/target/esm/adapters/fs/index.js

@@ -0,0 +1,5 @@
+// fs: files and locks for the adapters that keep state on this machine: the inter-process lock (lock.ts), writes a
+// sandbox may refuse and JSON written in one step (write.ts).
+export * from './lock.js';
+export * from './write.js';
+//# sourceMappingURL=index.js.map

package/target/esm/adapters/fs/lock.js

@@ -0,0 +1,83 @@
+// lock: the inter-process lock.
+import fs from 'node:fs';
+import { errno, fail } from '../../lib/fail.js';
+// A lock is a file holding its owner (pid and a random token), created by hard-linking a file already written: it
+// never exists without its owner and never replaces another lock. All acquisitions and the recovery of a dead
+// owner's lock pass one gate, so two contenders cannot both clear a lock just taken by a third. A lock is taken from
+// someone else only when that owner's process is gone, never by age; an unreadable owner is never taken over; only
+// the owner releases it. A gate abandoned by a dead process needs the operator: recovering the recoverer would need
+// yet another gate.
+const ownerAlive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return errno(e) !== 'ESRCH';
+    }
+};
+const ownerOf = (f) => {
+    try {
+        return fs.readFileSync(f, 'utf8');
+    }
+    catch {
+        return null;
+    }
+};
+const deadOwner = (t) => {
+    const pid = Number(String(t ?? '').split('.')[0]);
+    return Number.isInteger(pid) && pid > 0 && !ownerAlive(pid);
+};
+const claim = (f, token) => {
+    const tmp = `${f}.${token}.tmp`;
+    fs.writeFileSync(tmp, token, { flag: 'wx', mode: 0o600 });
+    try {
+        fs.linkSync(tmp, f);
+        return true;
+    }
+    catch (e) {
+        if (errno(e) === 'EEXIST')
+            return false;
+        throw e;
+    }
+    finally {
+        fs.rmSync(tmp, { force: true });
+    }
+};
+const release = (f, token) => {
+    if (ownerOf(f) === token)
+        fs.rmSync(f, { force: true });
+};
+const lockWait = new Int32Array(new SharedArrayBuffer(4));
+// One try through the gate: clear a dead owner's lock, then claim it.
+const attempt = (file, gate, token) => {
+    if (!claim(gate, token)) {
+        if (deadOwner(ownerOf(gate)))
+            fail(`${gate} was abandoned; if no ringi process runs, remove it`);
+        return false;
+    }
+    try {
+        if (deadOwner(ownerOf(file)))
+            fs.rmSync(file, { force: true });
+        return claim(file, token);
+    }
+    finally {
+        release(gate, token);
+    }
+};
+export const locked = (file, fn, timeout = 120000) => {
+    const token = `${process.pid}.${Math.random().toString(36).slice(2)}`;
+    const until = Date.now() + timeout;
+    while (!attempt(file, `${file}.recover`, token)) {
+        if (Date.now() >= until)
+            fail(`${file} is held by another process or an unknown owner; if no ringi process runs, remove it`);
+        Atomics.wait(lockWait, 0, 0, 25);
+    }
+    try {
+        return fn();
+    }
+    finally {
+        release(file, token);
+    }
+};
+//# sourceMappingURL=lock.js.map

package/target/esm/adapters/fs/write.js

@@ -0,0 +1,25 @@
+// write: writing where a sandbox may refuse, with the one message that says what to do.
+import fs from 'node:fs';
+import { Fail, WriteDenied, errno } from '../../lib/fail.js';
+export const SANDBOX = /Operation not permitted|Permission denied|Read-only file system|EPERM|EACCES|EROFS/;
+export const cannotWrite = (where, detail) => { throw new WriteDenied(where, detail); };
+export const guardWrite = (where, fn) => {
+    try {
+        return fn();
+    }
+    catch (e) {
+        if (e instanceof Fail)
+            throw e;
+        if (['EPERM', 'EACCES', 'EROFS'].includes(errno(e) ?? ''))
+            cannotWrite(where, `${errno(e)} on ${e.path ?? 'a file'}`);
+        throw e;
+    }
+};
+export const mkdirIn = (where, d) => { guardWrite(where, () => fs.mkdirSync(d, { recursive: true, mode: 0o700 })); };
+// A JSON file replaced in one step: a reader sees the old file or the new one.
+export const writeJsonAtomic = (file, v) => {
+    const tmp = `${file}.${process.pid}`;
+    fs.writeFileSync(tmp, JSON.stringify(v, null, 2));
+    fs.renameSync(tmp, file);
+};
+//# sourceMappingURL=write.js.map

package/target/esm/adapters/host-posix/group-state.js

@@ -0,0 +1,24 @@
+// group-state: process-group membership and whether its observed members have finished; only Z is a zombie.
+export const procMember = (text) => {
+    const close = text.lastIndexOf(')');
+    if (!/^\d+ \(/.test(text) || close < 0)
+        return null;
+    const fields = text.slice(close + 1).trim().split(/\s+/);
+    const group = Number(fields[2]), state = fields[0];
+    return /^[A-Za-z]$/.test(state) && Number.isSafeInteger(group) && group >= 0 ? { group, state } : null;
+};
+export const psMember = (text) => {
+    const match = /^\s*(\d+)\s+([A-Za-z][^\s]*)\s*$/.exec(text);
+    if (!match)
+        return null;
+    const group = Number(match[1]);
+    return Number.isSafeInteger(group) ? { group, state: match[2][0] } : null;
+};
+// No matching row, or an unreadable row that might belong to this group, cannot prove it is quiescent.
+export const groupRunning = (group, members) => {
+    const own = members.filter(m => m?.group === group);
+    if (own.some(m => m.state !== 'Z'))
+        return true;
+    return own.length && members.every(m => m !== null) ? false : null;
+};
+//# sourceMappingURL=group-state.js.map

package/target/esm/adapters/host-posix/groups.js

@@ -0,0 +1,43 @@
+// groups: a turn's POSIX group is settled once every observed member is a zombie; failed probes stay conservative.
+import fs from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { groupRunning, procMember, psMember } from './group-state.js';
+const exists = (group) => {
+    try {
+        process.kill(-group, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code !== 'ESRCH';
+    }
+};
+const procMembers = () => {
+    try {
+        return fs.readdirSync('/proc').filter(p => /^\d+$/.test(p)).flatMap(pid => {
+            try {
+                return [procMember(fs.readFileSync(`/proc/${pid}/stat`, 'utf8'))];
+            }
+            catch (e) {
+                return e.code === 'ENOENT' || e.code === 'ESRCH' ? [] : [null];
+            }
+        });
+    }
+    catch {
+        return null;
+    }
+};
+const psMembers = () => {
+    const result = spawnSync('ps', ['-A', '-o', 'pgid=,stat='], { encoding: 'utf8', timeout: 1000 });
+    return result.status === 0 ? result.stdout.split('\n').filter(line => line.trim()).map(psMember) : null;
+};
+export const groupAlive = (group) => {
+    if (!exists(group))
+        return false;
+    const proc = process.platform === 'linux' ? procMembers() : null;
+    const known = proc && groupRunning(group, proc);
+    if (known !== null)
+        return known;
+    const rows = psMembers(), observed = rows && groupRunning(group, rows);
+    return observed ?? exists(group);
+};
+//# sourceMappingURL=groups.js.map

package/target/esm/adapters/host-posix/index.js

@@ -0,0 +1,35 @@
+// host-posix: macOS/Linux process facts and launch control behind ProcessHost (core/agents/ports/host.ts). Its handles belong
+// only to this instance. A bounded observation never grants authority to stop an otherwise running process.
+import { fail } from '../../lib/fail.js';
+import { treeCpu } from './stats.js';
+import { launch } from './launch.js';
+import { alive, ancestors, snapshot, supported } from './probes.js';
+const systemClock = { wall: () => Date.now(), monotonic: () => performance.now() };
+const observe = (done, deadline, clock) => {
+    if (deadline !== undefined && !Number.isFinite(deadline))
+        fail('a process observation deadline must be finite');
+    const held = setInterval(() => { }, 1000);
+    if (deadline === undefined)
+        return done.finally(() => clearInterval(held));
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => { clearInterval(held); resolve(null); }, Math.max(0, deadline - clock.monotonic()));
+        const clear = () => { clearTimeout(timer); clearInterval(held); };
+        done.then(value => { clear(); resolve(value); }, error => { clear(); reject(error); });
+    });
+};
+export const hostPosix = (clock = systemClock) => {
+    const processes = new WeakMap();
+    const own = (handle) => processes.get(handle) ?? fail('this process handle belongs to another host');
+    return {
+        supported, clock, alive, ancestors, snapshot,
+        inspect: (pid, rows = snapshot()) => ({ alive: supported ? alive(pid) : null, cpu: treeCpu(pid, rows) }),
+        start: request => {
+            const handle = {};
+            processes.set(handle, launch(request, clock));
+            return handle;
+        },
+        stop: handle => own(handle).stop(),
+        awaitQuiescence: (handle, deadline) => observe(own(handle).done, deadline, clock),
+    };
+};
+//# sourceMappingURL=index.js.map