@agentorg/cli 0.0.1 → 0.0.3

package/node_modules/@agentorg/hub/dist/src/storage.d.ts

@@ -0,0 +1,37 @@
+/** How much a store may hold. */
+export interface StorageLimits {
+    /** Bytes of one value, as JSON. */
+    maxValue: number;
+    /** Bytes of keys and values across all of one consumer's stores. */
+    maxPerConsumer: number;
+}
+export declare const STORAGE_LIMITS: StorageLimits;
+type Input = Record<string, unknown>;
+/**
+ * The built-in `storage` Actor's `kv@1`: one store per consumer slot, kept in `<home>/storage.db`
+ * (0600), apart from the Hub's own database. The store is chosen by the consumer and slot the
+ * router names, never by the caller. Stores outlive unbinding; a closed Actor's go with it.
+ */
+export declare class Storage {
+    #private;
+    constructor(home: string, limits?: StorageLimits);
+    /** One `kv@1` call on the store of (consumer, slot). Inputs were already checked. */
+    call(consumer: string, slot: string, method: string, input: Input): unknown;
+    /**
+     * Seed the store of (consumer, slot), all or none, if it holds nothing: `storage.admin@1`'s
+     * `seed`. Each entry has kv@1's limits, and together they count toward the consumer's quota.
+     */
+    seed(consumer: string, slot: string, entries: {
+        key: string;
+        value: unknown;
+    }[]): void;
+    /** Every store of an Actor, gone: it was closed for good. */
+    deleteConsumer(consumer: string): void;
+    /**
+     * Keep only the stores of these Actors. Run when the Hub opens, it catches up on deletes a crash
+     * or a lock kept from happening when an Actor was closed.
+     */
+    keepOnly(live: ReadonlySet<string>): void;
+    close(): void;
+}
+export {};

package/node_modules/@agentorg/hub/dist/src/storage.js

@@ -0,0 +1,193 @@
+import { chmodSync } from "node:fs";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { Refused } from "@agentorg/sdk";
+export const STORAGE_LIMITS = {
+    maxValue: 256 * 1024,
+    maxPerConsumer: 64 * 1024 * 1024,
+};
+/** Bytes of a key, as UTF-8. */
+const MAX_KEY = 1024;
+const LONE_SURROGATE = /[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/;
+/** A key is well-formed text: half a surrogate pair would be stored as U+FFFD, merging keys. */
+function checkKey(key) {
+    if (LONE_SURROGATE.test(key))
+        throw new Refused("invalid", "A key is well-formed text.");
+}
+/**
+ * The built-in `storage` Actor's `kv@1`: one store per consumer slot, kept in `<home>/storage.db`
+ * (0600), apart from the Hub's own database. The store is chosen by the consumer and slot the
+ * router names, never by the caller. Stores outlive unbinding; a closed Actor's go with it.
+ */
+export class Storage {
+    #db;
+    #limits;
+    constructor(home, limits = STORAGE_LIMITS) {
+        this.#limits = limits;
+        const file = join(home, "storage.db");
+        // A lock held elsewhere is waited for a while rather than failing at once.
+        this.#db = new DatabaseSync(file, { timeout: 5000 });
+        chmodSync(file, 0o600);
+        this.#db.exec(`PRAGMA journal_mode = WAL;
+      CREATE TABLE IF NOT EXISTS store (
+        consumer TEXT NOT NULL, slot TEXT NOT NULL, key TEXT NOT NULL,
+        value TEXT NOT NULL, size INTEGER NOT NULL,
+        PRIMARY KEY (consumer, slot, key));
+      CREATE TABLE IF NOT EXISTS usage (consumer TEXT PRIMARY KEY, used INTEGER NOT NULL);`);
+        for (const suffix of ["-wal", "-shm"])
+            try {
+                chmodSync(file + suffix, 0o600);
+            }
+            catch {
+                // Not created yet.
+            }
+    }
+    /** One `kv@1` call on the store of (consumer, slot). Inputs were already checked. */
+    call(consumer, slot, method, input) {
+        const key = String(input.key ?? "");
+        switch (method) {
+            case "get": {
+                const row = this.#db
+                    .prepare("SELECT value FROM store WHERE consumer = ? AND slot = ? AND key = ?")
+                    .get(consumer, slot, key);
+                return row ? { value: JSON.parse(row.value) } : {};
+            }
+            case "set":
+                return this.#set(consumer, slot, key, input.value);
+            case "delete":
+                return this.#delete(consumer, slot, key);
+            case "list":
+                return this.#list(consumer, slot, input);
+            default:
+                throw new Refused("unimplemented", `kv@1 has no method ${method}.`);
+        }
+    }
+    /** Run work in one write transaction. */
+    #transaction(work) {
+        this.#db.exec("BEGIN IMMEDIATE");
+        try {
+            const out = work();
+            this.#db.exec("COMMIT");
+            return out;
+        }
+        catch (error) {
+            this.#db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    /** Add `delta` bytes to what a consumer's stores hold; the total is kept, never summed. */
+    #use(consumer, delta) {
+        this.#db
+            .prepare("INSERT INTO usage (consumer, used) VALUES (?, ?) ON CONFLICT (consumer) DO UPDATE SET used = used + excluded.used")
+            .run(consumer, delta);
+    }
+    #sizeOf(consumer, slot, key) {
+        const row = this.#db
+            .prepare("SELECT size FROM store WHERE consumer = ? AND slot = ? AND key = ?")
+            .get(consumer, slot, key);
+        return row && Number(row.size);
+    }
+    #set(consumer, slot, key, value) {
+        checkKey(key);
+        if (Buffer.byteLength(key) > MAX_KEY)
+            throw new Refused("quota", `A key is at most ${MAX_KEY} bytes.`);
+        const json = JSON.stringify(value);
+        const valueBytes = Buffer.byteLength(json);
+        if (valueBytes > this.#limits.maxValue)
+            throw new Refused("quota", `A value is at most ${this.#limits.maxValue} bytes.`);
+        const size = valueBytes + Buffer.byteLength(key);
+        this.#transaction(() => {
+            const used = this.#db.prepare("SELECT used FROM usage WHERE consumer = ?").get(consumer);
+            const replaced = this.#sizeOf(consumer, slot, key) ?? 0;
+            if (Number(used?.used ?? 0) - replaced + size > this.#limits.maxPerConsumer)
+                throw new Refused("quota", `An Actor's stores hold at most ${this.#limits.maxPerConsumer} bytes.`);
+            this.#db
+                .prepare("INSERT INTO store (consumer, slot, key, value, size) VALUES (?, ?, ?, ?, ?) ON CONFLICT (consumer, slot, key) DO UPDATE SET value = excluded.value, size = excluded.size")
+                .run(consumer, slot, key, json, size);
+            this.#use(consumer, size - replaced);
+        });
+        return {};
+    }
+    #delete(consumer, slot, key) {
+        return this.#transaction(() => {
+            const size = this.#sizeOf(consumer, slot, key);
+            if (size === undefined)
+                return { deleted: false };
+            this.#db
+                .prepare("DELETE FROM store WHERE consumer = ? AND slot = ? AND key = ?")
+                .run(consumer, slot, key);
+            this.#use(consumer, -size);
+            return { deleted: true };
+        });
+    }
+    /** Keys with the prefix, in order, after `after`, a page at a time. */
+    #list(consumer, slot, input) {
+        const prefix = typeof input.prefix === "string" ? input.prefix : "";
+        const after = typeof input.after === "string" ? input.after : "";
+        const limit = typeof input.limit === "number" ? input.limit : 100;
+        const rows = this.#db
+            .prepare(
+        // The scan starts at the prefix (or after `after`) and stops past the prefix's range; instr
+        // keeps exactly the keys that start with it.
+        `SELECT key FROM store WHERE consumer = ? AND slot = ? AND key > ? AND key >= ? AND key < ?
+         AND instr(key, ?) = 1 ORDER BY key LIMIT ?`)
+            .all(consumer, slot, after, prefix, `${prefix}\u{10FFFF}`, prefix, limit + 1);
+        const keys = rows.slice(0, limit).map((row) => row.key);
+        return { keys, next: rows.length > limit ? (keys.at(-1) ?? null) : null };
+    }
+    /**
+     * Seed the store of (consumer, slot), all or none, if it holds nothing: `storage.admin@1`'s
+     * `seed`. Each entry has kv@1's limits, and together they count toward the consumer's quota.
+     */
+    seed(consumer, slot, entries) {
+        const keys = new Set();
+        const rows = entries.map(({ key, value }) => {
+            checkKey(key);
+            if (keys.has(key))
+                throw new Refused("invalid", `The key ${JSON.stringify(key)} is given twice.`);
+            keys.add(key);
+            if (Buffer.byteLength(key) > MAX_KEY)
+                throw new Refused("quota", `A key is at most ${MAX_KEY} bytes.`);
+            const json = JSON.stringify(value);
+            const valueBytes = Buffer.byteLength(json);
+            if (valueBytes > this.#limits.maxValue)
+                throw new Refused("quota", `A value is at most ${this.#limits.maxValue} bytes.`);
+            return { key, json, size: valueBytes + Buffer.byteLength(key) };
+        });
+        const total = rows.reduce((sum, row) => sum + row.size, 0);
+        this.#transaction(() => {
+            if (this.#db
+                .prepare("SELECT 1 FROM store WHERE consumer = ? AND slot = ? LIMIT 1")
+                .get(consumer, slot))
+                throw new Refused("not_empty", `The store of ${consumer}.${slot} isn't empty.`);
+            const used = this.#db.prepare("SELECT used FROM usage WHERE consumer = ?").get(consumer);
+            if (Number(used?.used ?? 0) + total > this.#limits.maxPerConsumer)
+                throw new Refused("quota", `An Actor's stores hold at most ${this.#limits.maxPerConsumer} bytes.`);
+            const insert = this.#db.prepare("INSERT INTO store (consumer, slot, key, value, size) VALUES (?, ?, ?, ?, ?)");
+            for (const row of rows)
+                insert.run(consumer, slot, row.key, row.json, row.size);
+            this.#use(consumer, total);
+        });
+    }
+    /** Every store of an Actor, gone: it was closed for good. */
+    deleteConsumer(consumer) {
+        this.#transaction(() => {
+            this.#db.prepare("DELETE FROM store WHERE consumer = ?").run(consumer);
+            this.#db.prepare("DELETE FROM usage WHERE consumer = ?").run(consumer);
+        });
+    }
+    /**
+     * Keep only the stores of these Actors. Run when the Hub opens, it catches up on deletes a crash
+     * or a lock kept from happening when an Actor was closed.
+     */
+    keepOnly(live) {
+        const consumers = this.#db.prepare("SELECT consumer FROM usage").all();
+        for (const { consumer } of consumers)
+            if (!live.has(consumer))
+                this.deleteConsumer(consumer);
+    }
+    close() {
+        if (this.#db.isOpen)
+            this.#db.close();
+    }
+}

package/node_modules/@agentorg/hub/dist/src/validate-worker.d.ts

@@ -0,0 +1,28 @@
+/** One schema of an interface, keyed by the interface's hash and the part's name. */
+export interface SchemaPart {
+    key: string;
+    schema: unknown;
+}
+/** Compile the parts this worker doesn't have yet; then, with `check`, validate one value. */
+export interface Job {
+    id: number;
+    parts: SchemaPart[];
+    check?: {
+        key: string;
+        value: unknown;
+    };
+}
+export type Reply = {
+    id: number;
+    ok: true;
+} | {
+    id: number;
+    ok: false;
+    stage: "compile" | "check";
+    message: string;
+};
+/** Sent once a job's schemas are compiled, before its value is checked: the check's budget starts. */
+export interface Compiled {
+    id: number;
+    compiled: true;
+}

package/node_modules/@agentorg/hub/dist/src/validate-worker.js

@@ -0,0 +1,57 @@
+import { parentPort } from "node:worker_threads";
+import { Ajv2020 } from "ajv/dist/2020.js";
+/** Parts kept compiled; past this the oldest are dropped and compiled again on use. */
+const MAX_COMPILED = 4096;
+// addUsedSchema off: a schema's `$id` stays its own, so one Actor's can't clash with another's.
+// allowMatchingProperties: strict mode would otherwise test each patternProperties regex against the
+// property names while compiling, running an Actor's regex on its own strings outside any check.
+const ajv = new Ajv2020({ strict: true, addUsedSchema: false, allowMatchingProperties: true });
+const compiled = new Map();
+function compile(part) {
+    const known = compiled.get(part.key);
+    if (known)
+        return known.validate;
+    const validate = ajv.compile(part.schema);
+    compiled.set(part.key, { validate, schema: part.schema });
+    for (const [key, entry] of compiled) {
+        if (compiled.size <= MAX_COMPILED)
+            break;
+        compiled.delete(key);
+        // ajv keeps object schemas only; `true` and `false` aren't cached and can't be removed.
+        if (typeof entry.schema === "object" && entry.schema !== null)
+            ajv.removeSchema(entry.schema);
+    }
+    return validate;
+}
+function run(job, compiled) {
+    let validate;
+    for (const part of job.parts)
+        try {
+            const fn = compile(part);
+            if (part.key === job.check?.key)
+                validate = fn;
+        }
+        catch (error) {
+            return {
+                id: job.id,
+                ok: false,
+                stage: "compile",
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
+    if (!job.check || !validate)
+        return { id: job.id, ok: true };
+    compiled();
+    if (validate(job.check.value))
+        return { id: job.id, ok: true };
+    const issue = validate.errors?.[0];
+    return {
+        id: job.id,
+        ok: false,
+        stage: "check",
+        message: issue ? `${issue.instancePath || "value"} ${issue.message}` : "invalid",
+    };
+}
+parentPort?.on("message", (job) => parentPort?.postMessage(run(job, () => parentPort?.postMessage({ id: job.id, compiled: true }))));
+// ajv is loaded: from here, jobs and their budgets.
+parentPort?.postMessage("ready");

package/node_modules/@agentorg/hub/dist/src/validate.d.ts

@@ -0,0 +1,48 @@
+import type { DescribedInterface } from "@agentorg/sdk";
+/** A part of an interface with its own schema: a method's input or output, an event, or `open`. */
+export type Part = {
+    method: string;
+    side: "input" | "output";
+} | {
+    event: string;
+} | {
+    open: true;
+};
+/** How long checking one value may take, once compiled, before it is refused and its worker replaced. */
+export declare const CHECK_BUDGET_MS = 250;
+/**
+ * How long compiling an interface's schemas may take, per schema, before the check is refused and
+ * its worker replaced. Kept apart from the check's budget, so a first call on a loaded machine
+ * isn't refused for compiling.
+ */
+export declare const COMPILE_BUDGET_MS = 2000;
+/**
+ * JSON Schema validation in the 2020-12 dialect, with ajv in strict mode, run in a pool of worker
+ * threads: schemas come from Actors, and none may run on the router's thread. Each check has a
+ * time budget; past it the check is refused and its worker replaced. Each worker keeps what it has
+ * compiled, keyed by the interface's hash.
+ */
+export declare class Validators {
+    #private;
+    constructor(options?: {
+        budgetMs?: number;
+        compileBudgetMs?: number;
+        size?: number;
+        workerUrl?: URL;
+    });
+    /**
+     * Compile every schema of an interface, on behalf of the Actor that declared it; one that won't
+     * compile, or compiles too slowly, is `invalid`.
+     */
+    prepare(actor: string, iface: DescribedInterface): Promise<void>;
+    /** Whether the part exists on the interface. */
+    has(iface: DescribedInterface, part: Part): boolean;
+    /**
+     * Check a value against a part's schema, in the turn of `actor`, the Actor the work is for. A
+     * caller's misfit is `invalid` (nothing ran); a provider's is `bad_output` (it ran and broke the
+     * contract). A check over the budget is refused the same way.
+     */
+    check(actor: string, iface: DescribedInterface, part: Part, value: unknown, code: "invalid" | "bad_output"): Promise<void>;
+    /** Stop every worker; checks in flight or waiting fail. */
+    close(error?: Error): void;
+}

package/node_modules/@agentorg/hub/dist/src/validate.js

@@ -0,0 +1,240 @@
+import { availableParallelism } from "node:os";
+import { Worker } from "node:worker_threads";
+import { Refused } from "@agentorg/sdk";
+const describe = (part) => "method" in part
+    ? `${part.method} ${part.side}`
+    : "event" in part
+        ? `${part.event} event`
+        : "open";
+function schemaOf(iface, part) {
+    if ("method" in part)
+        return iface.kind === "rpc" && Object.hasOwn(iface.methods, part.method)
+            ? iface.methods[part.method]?.[part.side]
+            : undefined;
+    if ("event" in part)
+        return iface.kind === "rpc" && Object.hasOwn(iface.events, part.event)
+            ? iface.events[part.event]
+            : undefined;
+    return iface.kind === "stream" ? iface.open : undefined;
+}
+const keyOf = (iface, part) => `${iface.hash} ${describe(part)}`;
+function partsOf(iface) {
+    if (iface.kind === "stream")
+        return [{ open: true }];
+    if (iface.kind !== "rpc")
+        return [];
+    return [
+        ...Object.keys(iface.methods).flatMap((method) => [
+            { method, side: "input" },
+            { method, side: "output" },
+        ]),
+        ...Object.keys(iface.events).map((event) => ({ event })),
+    ];
+}
+/** How long checking one value may take, once compiled, before it is refused and its worker replaced. */
+export const CHECK_BUDGET_MS = 250;
+/**
+ * How long compiling an interface's schemas may take, per schema, before the check is refused and
+ * its worker replaced. Kept apart from the check's budget, so a first call on a loaded machine
+ * isn't refused for compiling.
+ */
+export const COMPILE_BUDGET_MS = 2000;
+/** Workers in the pool: about one per spare core, at least two so one stuck check can't stall all. */
+const POOL_SIZE = Math.max(2, Math.min(4, availableParallelism() - 1));
+const isLate = (outcome) => typeof outcome === "object" && outcome !== null && "late" in outcome;
+/**
+ * JSON Schema validation in the 2020-12 dialect, with ajv in strict mode, run in a pool of worker
+ * threads: schemas come from Actors, and none may run on the router's thread. Each check has a
+ * time budget; past it the check is refused and its worker replaced. Each worker keeps what it has
+ * compiled, keyed by the interface's hash.
+ */
+export class Validators {
+    #budgetMs;
+    #compileBudgetMs;
+    #slots = [];
+    /**
+     * Waiting jobs, one queue per Actor the work is for, served in turn. An Actor flooding slow
+     * checks delays mostly itself; another Actor's check waits for the jobs already running: about
+     * one check budget with two or more workers, longer if one of them is compiling (up to the
+     * compile budget per part).
+     */
+    #queues = new Map();
+    #nextId = 1;
+    /** Set when a worker can't even start: every check fails with it rather than respawning forever. */
+    #broken;
+    #workerUrl;
+    constructor(options = {}) {
+        this.#budgetMs = options.budgetMs ?? CHECK_BUDGET_MS;
+        this.#compileBudgetMs = options.compileBudgetMs ?? COMPILE_BUDGET_MS;
+        this.#workerUrl = options.workerUrl ?? new URL("./validate-worker.js", import.meta.url);
+        for (let i = 0; i < (options.size ?? POOL_SIZE); i++)
+            this.#slots.push(this.#spawn());
+    }
+    #spawn() {
+        const worker = new Worker(this.#workerUrl);
+        const slot = { worker, ready: false };
+        worker.on("message", (reply) => {
+            if (reply === "ready") {
+                slot.ready = true;
+                // An idle pool doesn't keep the process alive; a worker with a job does (see #pump).
+                worker.unref();
+                return this.#pump();
+            }
+            const busy = slot.busy;
+            if (!busy || busy.job.id !== reply.id)
+                return;
+            if ("compiled" in reply) {
+                // Compiled: from here the check's own, shorter budget runs.
+                clearTimeout(busy.timer);
+                busy.phase = "check";
+                busy.timer = setTimeout(() => this.#replace(slot), this.#budgetMs);
+                return;
+            }
+            clearTimeout(busy.timer);
+            slot.busy = undefined;
+            worker.unref();
+            busy.settle(reply);
+            this.#pump();
+        });
+        // A worker that dies on its own is replaced like one that ran over; one that dies before it
+        // is ready means none can start.
+        const died = (error) => {
+            if (slot.ready)
+                return this.#replace(slot);
+            if (!this.#slots.includes(slot))
+                return;
+            this.#fail(new Error(`The schema workers can't start: ${error?.message ?? "the worker exited"}`));
+        };
+        worker.on("error", died);
+        worker.on("exit", () => died());
+        return slot;
+    }
+    #fail(error) {
+        this.#broken = error;
+        this.close(error);
+    }
+    #replace(slot) {
+        const index = this.#slots.indexOf(slot);
+        if (index < 0)
+            return;
+        const busy = slot.busy;
+        slot.busy = undefined;
+        if (busy)
+            clearTimeout(busy.timer);
+        this.#slots[index] = this.#spawn();
+        void slot.worker.terminate();
+        busy?.settle({ late: busy.phase });
+        this.#pump();
+    }
+    /** Hand waiting jobs to idle ready workers, until either runs out. */
+    #pump() {
+        for (;;) {
+            const slot = this.#slots.find((candidate) => candidate.ready && !candidate.busy);
+            if (!slot)
+                return;
+            const next = this.#next();
+            if (!next)
+                return;
+            // The budget runs from when a ready worker takes the job, not while it waits. Compiling gets
+            // its own budget, per schema; the check's starts when the worker says it has compiled.
+            const budget = this.#compileBudgetMs * Math.max(1, next.job.parts.length);
+            const timer = setTimeout(() => this.#replace(slot), budget);
+            slot.busy = { ...next, timer, phase: "compile" };
+            slot.worker.ref();
+            try {
+                slot.worker.postMessage(next.job);
+            }
+            catch (error) {
+                // A value too deep to copy to a worker fails its check; the worker never saw it and is
+                // free again for the next job.
+                clearTimeout(timer);
+                slot.busy = undefined;
+                slot.worker.unref();
+                next.settle({
+                    id: next.job.id,
+                    ok: false,
+                    stage: "check",
+                    message: `it can't be checked (${error instanceof Error ? error.message : String(error)})`,
+                });
+            }
+        }
+    }
+    /** The next job in turn: the first Actor's oldest, after which that Actor goes to the back. */
+    #next() {
+        for (const [actor, queue] of this.#queues) {
+            this.#queues.delete(actor);
+            const next = queue.shift();
+            if (queue.length)
+                this.#queues.set(actor, queue);
+            if (next)
+                return next;
+        }
+        return undefined;
+    }
+    #run(actor, parts, check) {
+        if (this.#broken)
+            return Promise.resolve(this.#broken);
+        if (!this.#slots.length)
+            return Promise.resolve(new Error("The validators are closed."));
+        return new Promise((settle) => {
+            const queue = this.#queues.get(actor) ?? [];
+            this.#queues.set(actor, queue);
+            queue.push({ job: { id: this.#nextId++, parts, ...(check ? { check } : {}) }, settle });
+            this.#pump();
+        });
+    }
+    /**
+     * Compile every schema of an interface, on behalf of the Actor that declared it; one that won't
+     * compile, or compiles too slowly, is `invalid`.
+     */
+    async prepare(actor, iface) {
+        const reply = await this.#run(actor, partsOf(iface).map((part) => ({ key: keyOf(iface, part), schema: schemaOf(iface, part) })));
+        if (reply instanceof Error)
+            throw reply;
+        if (isLate(reply))
+            throw new Refused("invalid", `${iface.id}'s schemas took over ${this.#compileBudgetMs} ms each to compile.`);
+        if (!reply.ok)
+            throw new Refused("invalid", `${iface.id}: ${reply.message}`);
+    }
+    /** Whether the part exists on the interface. */
+    has(iface, part) {
+        return schemaOf(iface, part) !== undefined;
+    }
+    /**
+     * Check a value against a part's schema, in the turn of `actor`, the Actor the work is for. A
+     * caller's misfit is `invalid` (nothing ran); a provider's is `bad_output` (it ran and broke the
+     * contract). A check over the budget is refused the same way.
+     */
+    async check(actor, iface, part, value, code) {
+        const schema = schemaOf(iface, part);
+        if (schema === undefined)
+            throw new Refused("invalid", `${iface.id} has no ${describe(part)}.`);
+        const key = keyOf(iface, part);
+        const reply = await this.#run(actor, [{ key, schema }], { key, value });
+        if (reply instanceof Error)
+            throw reply;
+        if (isLate(reply))
+            throw new Refused(code, reply.late === "compile"
+                ? `${iface.id} ${describe(part)}: its schema took over ${this.#compileBudgetMs} ms to compile.`
+                : `${iface.id} ${describe(part)}: the check took over ${this.#budgetMs} ms.`);
+        if (reply.ok)
+            return;
+        if (reply.stage === "compile")
+            throw new Refused("invalid", `${iface.id} ${describe(part)}: ${reply.message}`);
+        throw new Refused(code, `${iface.id} ${describe(part)}: ${reply.message}`);
+    }
+    /** Stop every worker; checks in flight or waiting fail. */
+    close(error = new Error("The validators are closed.")) {
+        const slots = this.#slots.splice(0);
+        for (const slot of slots) {
+            if (slot.busy)
+                clearTimeout(slot.busy.timer);
+            slot.busy?.settle(error);
+            void slot.worker.terminate();
+        }
+        const waiting = [...this.#queues.values()].flat();
+        this.#queues.clear();
+        for (const job of waiting)
+            job.settle(error);
+    }
+}

package/node_modules/@agentorg/hub/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@agentorg/hub",
+  "version": "0.0.0",
+  "private": true,
+  "description": "AgentOrg's core: an interface router with bindings as grants.",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=22.15"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "files": [
+    "dist/src"
+  ],
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json",
+    "test": "node --test --test-timeout=60000 \"dist/test/**/*.test.js\""
+  },
+  "dependencies": {
+    "@agentorg/interfaces": "0.0.0",
+    "@agentorg/sdk": "0.0.0",
+    "@agentorg/wire": "0.0.0",
+    "ajv": "^8.20.0",
+    "ws": "^8.22.1",
+    "zod": "^4.6.7"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.18.2"
+  }
+}