@agentorg/cli 0.0.4 → 0.0.6

package/dist/node_modules/@agentorg/sdk/dist/src/frame.js

@@ -1,248 +0,0 @@
-import { errorBodyOf, errorFromBody, OutcomeUnknown, Refused } from "./errors.js";
-import { isShellInterface } from "./frame-protocol.js";
-import { isFrameInterface, isModuleDefinition, } from "./module.js";
-import { createRuntime } from "./runtime.js";
-/**
- * Run a view module in a frame, on the same runtime as a host module, so a view behaves as it does
- * in tests. Every slot of `ui.shell@1` is served by the shell and always bound; every other slot is
- * served over the port while the shell says it is bound. The shell drives `ui.view@1`: `mount`,
- * `resize` and `unmount` reach the view's handle. Only `ui.view@1` is served among its exports.
- */
-export function runFrame(options) {
-    const { port } = options;
-    const send = (message) => port.postMessage(message);
-    let nextId = 0;
-    const pending = new Map();
-    const request = (message, target) => new Promise((resolve, reject) => {
-        const id = ++nextId;
-        pending.set(id, { resolve, reject, target });
-        send({ ...message, id });
-    });
-    /** The view's runtime, once its start has finished. */
-    let runtime;
-    let definition;
-    let loading = false;
-    let mounted;
-    const bindings = new Map();
-    /**
-     * Until the view has started, which slots are bound: from load's snapshot, then from any notice
-     * meanwhile, while its bundle imports and while start runs.
-     */
-    let early = new Map();
-    /** Slot events the view listens to, each with its live subscription's id, if any. */
-    const listened = new Map();
-    const subscriptions = new Map();
-    const log = {
-        info: (message, fields) => send({ op: "log", level: "info", message, ...(fields ? { fields } : {}) }),
-        warn: (message, fields) => send({ op: "log", level: "warn", message, ...(fields ? { fields } : {}) }),
-        error: (message, fields) => send({ op: "log", level: "error", message, ...(fields ? { fields } : {}) }),
-    };
-    const subscribe = (slot, event) => {
-        const events = listened.get(slot) ?? new Map();
-        listened.set(slot, events);
-        if (!events.has(event))
-            events.set(event, undefined);
-        if (!bindings.has(slot) || events.get(event) !== undefined)
-            return;
-        const sub = ++nextId;
-        subscriptions.set(sub, { slot, event });
-        events.set(event, sub);
-        send({ op: "subscribe", sub, slot, event });
-    };
-    /** Stop a slot's live subscriptions; the interest stays for when it is usable again. */
-    const stopAll = (slot, tell) => {
-        const events = listened.get(slot);
-        for (const [event, sub] of events ?? []) {
-            if (sub === undefined)
-                continue;
-            subscriptions.delete(sub);
-            events?.set(event, undefined);
-            if (tell)
-                send({ op: "unsubscribe", sub });
-        }
-    };
-    const resubscribe = (slot) => {
-        stopAll(slot, true);
-        for (const event of listened.get(slot)?.keys() ?? [])
-            subscribe(slot, event);
-    };
-    const bind = (slot) => {
-        if (!runtime)
-            return;
-        bindings.set(slot, runtime.bind(slot, {
-            call: (method, input) => request({ op: "call", slot, method, input }, slot),
-            open: async () => {
-                throw new Refused("unimplemented", `${slot}: a view's stream slots aren't served yet.`);
-            },
-            fetch: async () => {
-                throw new Refused("unimplemented", `${slot}: a view's http slots aren't served yet.`);
-            },
-        }));
-        resubscribe(slot);
-    };
-    const onSlot = (slot, bound) => {
-        if (early)
-            return void early.set(slot, bound);
-        const iface = definition && Object.hasOwn(definition.slots, slot) ? definition.slots[slot] : undefined;
-        // ui.shell@1 is the shell's, always bound; the shell never names it.
-        if (!runtime || !iface || isShellInterface(iface))
-            return;
-        if (!bound) {
-            bindings.delete(slot);
-            stopAll(slot, true);
-            return runtime.unbind(slot);
-        }
-        if (bindings.has(slot)) {
-            // Its provider came back: what was missed is read again in onBind, and events resume.
-            resubscribe(slot);
-            return runtime.usable(slot);
-        }
-        bind(slot);
-    };
-    const viewExport = () => {
-        for (const [name, iface] of Object.entries(definition?.exports ?? {}))
-            if (isFrameInterface(iface))
-                return name;
-        throw new Refused("unimplemented", "This module exports no ui.view@1.");
-    };
-    const answer = async (id, run) => {
-        try {
-            send({ op: "reply", id, result: (await run()) ?? {} });
-        }
-        catch (error) {
-            send({ op: "reply", id, error: errorBodyOf(error) });
-        }
-    };
-    const handle = (message) => {
-        switch (message.op) {
-            case "load":
-                return answer(message.id, async () => {
-                    if (runtime || loading)
-                        throw new Refused("state", "This frame has loaded a view already.");
-                    loading = true;
-                    for (const [slot, isBound] of Object.entries(message.slots))
-                        early?.set(slot, isBound);
-                    try {
-                        const loaded = (await options.load(message.src));
-                        const found = loaded?.default;
-                        if (!isModuleDefinition(found) || found.placement !== "view")
-                            throw new Refused("invalid", `${message.src} isn't a view module.`);
-                        definition = found;
-                        const created = createRuntime(found, {
-                            self: message.self,
-                            log,
-                            // A view serves only ui.view@1, which the shell drives directly; nothing reaches its
-                            // other exports, so their events go nowhere.
-                            onEmit: () => { },
-                            onListen: subscribe,
-                        });
-                        // As in a host module: start implements and registers handlers, then slots bind, so
-                        // each bound slot's onBind runs once it is usable.
-                        await created.start();
-                        runtime = created;
-                        for (const [slot, iface] of Object.entries(found.slots))
-                            if (isShellInterface(iface))
-                                bindings.set(slot, created.bind(slot, {
-                                    call: (method, input) => request({ op: "shell", method, input }, slot),
-                                }));
-                        const bound = early;
-                        early = undefined;
-                        for (const [slot, isBound] of bound ?? [])
-                            if (isBound)
-                                onSlot(slot, true);
-                    }
-                    catch (error) {
-                        // Nothing is half-loaded: the frame can be asked to load again.
-                        definition = undefined;
-                        early = new Map();
-                        throw error;
-                    }
-                    finally {
-                        loading = false;
-                    }
-                });
-            case "slot":
-                return onSlot(message.name, message.bound);
-            case "mount":
-                return answer(message.id, () => {
-                    if (!runtime)
-                        throw new Refused("state", "Nothing is loaded to mount.");
-                    if (mounted)
-                        throw new Refused("state", "The view is mounted already.");
-                    options.theme?.(message.theme);
-                    mounted = runtime.mount(viewExport(), options.root, {
-                        theme: message.theme,
-                        size: message.size,
-                    });
-                });
-            case "resize":
-                return answer(message.id, () => {
-                    if (!mounted)
-                        throw new Refused("state", "The view isn't mounted.");
-                    mounted.resize(message.size);
-                });
-            case "unmount":
-                return answer(message.id, () => {
-                    const view = mounted;
-                    mounted = undefined;
-                    view?.unmount();
-                });
-            case "event": {
-                const subscription = subscriptions.get(message.sub);
-                if (!subscription)
-                    return;
-                try {
-                    bindings.get(subscription.slot)?.emit(subscription.event, message.payload);
-                }
-                catch (error) {
-                    log.warn("An event didn't fit its schema.", { ...subscription, error: String(error) });
-                }
-                return;
-            }
-            case "end": {
-                // Ended by an unbind or the provider going: the interest stays for when it is usable again.
-                const subscription = subscriptions.get(message.sub);
-                if (!subscription)
-                    return;
-                subscriptions.delete(message.sub);
-                const events = listened.get(subscription.slot);
-                if (events?.get(subscription.event) === message.sub)
-                    events.set(subscription.event, undefined);
-                return;
-            }
-            case "reply": {
-                const waiting = pending.get(message.id);
-                if (!waiting)
-                    return;
-                pending.delete(message.id);
-                if ("error" in message)
-                    waiting.reject(errorFromBody(message.error, waiting.target));
-                else
-                    waiting.resolve(message.result);
-                return;
-            }
-        }
-    };
-    port.onmessage = (event) => {
-        try {
-            void handle(event.data);
-        }
-        catch (error) {
-            log.error("The frame couldn't handle a message from the shell.", { error: String(error) });
-        }
-    };
-    return {
-        failed(error) {
-            log.error(error instanceof Error ? error.message : String(error), {
-                ...(error instanceof Error && error.stack ? { stack: error.stack } : {}),
-            });
-        },
-        close() {
-            port.onmessage = null;
-            for (const [, waiting] of pending)
-                waiting.reject(new OutcomeUnknown("The frame closed."));
-            pending.clear();
-            port.close();
-        },
-    };
-}

package/dist/node_modules/@agentorg/sdk/dist/src/host-main.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/node_modules/@agentorg/sdk/dist/src/host-main.js

@@ -1,60 +0,0 @@
-// The program the Hub spawns for a package Actor: `runner.js <package dir> <actorId>`, with its
-// channel to the Hub on fd 3. It is bundled into one file, so the process needs to read only
-// that file and the package's folder.
-import { Socket } from "node:net";
-import { Duplex as NodeDuplex } from "node:stream";
-import { runHost } from "./host.js";
-const [packageDir, actorId] = process.argv.slice(2);
-if (!packageDir || !actorId) {
-    process.stderr.write("Usage: runner.js <package dir> <actorId>\n");
-    process.exit(2);
-}
-/** Anything as text, even what can't say itself (no prototype, a throwing `toString`). */
-const text = (value) => {
-    try {
-        return String(value);
-    }
-    catch {
-        return "[unprintable]";
-    }
-};
-/** What JSON can't hold, as text: an error by its name and message, a bigint by its digits. */
-const plain = (_key, value) => value instanceof Error
-    ? `${text(value.name)}: ${text(value.message)}`
-    : typeof value === "bigint"
-        ? String(value)
-        : value;
-/**
- * One JSON line per log call, on stderr, which the Hub keeps as the Actor's log: a module's
- * `ctx.log`, or the runner's own (no module). Logging never throws: data JSON can't hold (a cycle)
- * is written as text.
- */
-const logFor = (module) => {
-    const line = (level) => (message, data) => {
-        const entry = (fields) => JSON.stringify({
-            level,
-            message: text(message),
-            ...(fields === undefined ? {} : { data: fields }),
-            ...(module === undefined ? {} : { module }),
-            at: new Date().toISOString(),
-        }, plain);
-        let written;
-        try {
-            written = entry(data);
-        }
-        catch {
-            written = entry(text(data));
-        }
-        process.stderr.write(`${written}\n`);
-    };
-    return { info: line("info"), warn: line("warn"), error: line("error") };
-};
-// The Hub's stop. Handled, it reaches the process even as PID 1 of a PID namespace, where an
-// unhandled SIGTERM from outside is ignored.
-process.on("SIGTERM", () => process.exit(0));
-const pipe = new Socket({ fd: 3, readable: true, writable: true });
-const channel = NodeDuplex.toWeb(pipe);
-const host = await runHost({ packageDir, actorId, channel, log: logFor });
-// The Hub going away ends the process: there is nothing left to serve.
-await host.channel.closed;
-process.exit(0);

package/dist/node_modules/@agentorg/sdk/dist/src/host.d.ts

@@ -1,25 +0,0 @@
-import { type Channel } from "./client.js";
-import { type Duplex, type Log } from "./module.js";
-export interface RunHostOptions {
-    /** The package's folder: `agentorg.json` and `dist/<module>.js`. */
-    packageDir: string;
-    /** The Actor this process runs, as the Hub named it. */
-    actorId: string;
-    /** The pipe to the Hub. */
-    channel: Duplex;
-    /** Where each module's `ctx.log` lines go, and (with no module) the runner's own. */
-    log(module?: string): Log;
-}
-export interface Host {
-    readonly channel: Channel;
-    /** The host modules running, by name. */
-    readonly modules: readonly string[];
-}
-/**
- * Run a package Actor's host modules over the pipe the Hub made for its process. Each module gets
- * its own runtime, the same one `connect()` and the test context use, with its slots and exports
- * named `<module>.<name>` on the wire. Every module's `start` runs before the hello, so the Hub
- * never reaches an export before it is implemented; then slots are bound as the Hub says, and each
- * `serve` stream goes to the module its export names. A `start` that throws is thrown from here.
- */
-export declare function runHost(options: RunHostOptions): Promise<Host>;

package/dist/node_modules/@agentorg/sdk/dist/src/host.js

@@ -1,92 +0,0 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { openChannel } from "./client.js";
-import { isModuleDefinition } from "./module.js";
-import { localServe, ModuleHost, noModule } from "./module-host.js";
-import { createRuntime } from "./runtime.js";
-/**
- * Run a package Actor's host modules over the pipe the Hub made for its process. Each module gets
- * its own runtime, the same one `connect()` and the test context use, with its slots and exports
- * named `<module>.<name>` on the wire. Every module's `start` runs before the hello, so the Hub
- * never reaches an export before it is implemented; then slots are bound as the Hub says, and each
- * `serve` stream goes to the module its export names. A `start` that throws is thrown from here.
- */
-export async function runHost(options) {
-    const manifest = JSON.parse(await readFile(join(options.packageDir, "agentorg.json"), "utf8"));
-    const hosts = new Map();
-    for (const [name, module] of Object.entries(manifest.modules)) {
-        if (module.placement !== "host")
-            continue;
-        const loaded = (await import(__rewriteRelativeImportExtension(pathToFileURL(join(options.packageDir, "dist", `${name}.js`)).href)));
-        const definition = loaded.default;
-        if (!isModuleDefinition(definition))
-            throw new Error(`dist/${name}.js doesn't export a module definition.`);
-        const log = options.log(name);
-        const host = new ModuleHost(`${name}.`, definition.slots, log);
-        host.runtime = createRuntime(definition, {
-            self: { actorId: options.actorId, module: name },
-            log,
-            ...host.hooks(),
-        });
-        hosts.set(name, host);
-    }
-    // Every module's start, in the manifest's order, before the Hub can reach any of them.
-    for (const host of hosts.values())
-        await host.runtime.start();
-    /** The module a wire name belongs to, and the name within it. */
-    const route = (name) => {
-        const dot = name.indexOf(".");
-        const host = dot > 0 ? hosts.get(name.slice(0, dot)) : undefined;
-        return host && [host, name.slice(dot + 1)];
-    };
-    const routed = (serve) => {
-        const found = route(serve.export);
-        if (!found)
-            throw noModule(serve.export);
-        return [found[0].serve, localServe(serve, found[1])];
-    };
-    const channel = await openChannel({
-        channel: options.channel,
-        actorId: options.actorId,
-        log: options.log(),
-        onSlot(name, bound) {
-            const found = route(name);
-            found?.[0].onSlot(found[1], bound);
-        },
-        // A slot made at run time is the Actor's: every host module has it.
-        onExposed(name, exposure) {
-            for (const host of hosts.values())
-                host.onExposed(name, exposure);
-        },
-        serve: {
-            call: (serve, value) => {
-                const [handlers, local] = routed(serve);
-                return handlers.call(local, value);
-            },
-            subscribe: (serve, send, end) => {
-                const [handlers, local] = routed(serve);
-                return handlers.subscribe(local, send, end);
-            },
-            accept: (serve) => {
-                const [handlers, local] = routed(serve);
-                return handlers.accept(local);
-            },
-            serveHttp: (serve) => {
-                const [handlers, local] = routed(serve);
-                return handlers.serveHttp(local);
-            },
-        },
-    });
-    for (const host of hosts.values())
-        host.attach(channel);
-    return { channel, modules: [...hosts.keys()] };
-}

package/dist/node_modules/@agentorg/sdk/dist/src/manifest-api.d.ts

@@ -1,2 +0,0 @@
-export { checkManifest, FORMAT, type Manifest, type ManifestInterface, type ManifestModule, SIGNATURE, treeHash, type Verified, verifyArchive, } from "./manifest.js";
-export { readTar, writeTar } from "./tar.js";

package/dist/node_modules/@agentorg/sdk/dist/src/manifest-api.js

@@ -1,2 +0,0 @@
-export { checkManifest, FORMAT, SIGNATURE, treeHash, verifyArchive, } from "./manifest.js";
-export { readTar, writeTar } from "./tar.js";

package/dist/node_modules/@agentorg/sdk/dist/src/manifest.d.ts

@@ -1,56 +0,0 @@
-import { type DescribedInterface } from "./interface.js";
-import type { Placement } from "./module.js";
-export declare const FORMAT = "agentorg.package/1";
-/** An interface as `agentorg.json` records it, keyed by its `name@major`. */
-export type ManifestInterface = DescribedInterface extends infer D ? D extends unknown ? Omit<D, "id"> : never : never;
-export interface ManifestModule {
-    placement: Placement;
-    entry: string;
-    slots: Record<string, string>;
-    exports: Record<string, string>;
-}
-/** `agentorg.json`, generated from the package's code. */
-export interface Manifest {
-    format: typeof FORMAT;
-    name: string;
-    version: string;
-    description?: string;
-    modules: Record<string, ManifestModule>;
-    interfaces: Record<string, ManifestInterface>;
-    /** The package's own wiring: `[ "module.slot", "module.export" ]`. Other slots are the installer's. */
-    connections: [string, string][];
-    /**
-     * Optional initial state for state slots, keyed by `"module.slot"`: the only runtime state a
-     * package may carry. `null` when there is none.
-     */
-    seed: Record<string, unknown> | null;
-}
-/**
- * The reserved name of a package's signature. It is detached: a file beside the package that signs
- * the package hash, so it can never be inside what it signs.
- */
-export declare const SIGNATURE = "agentorg.sig";
-/** The canonical tree hash: SHA-256 over the sorted `[path, sha256(bytes)]` of every file. */
-export declare function treeHash(files: Map<string, Uint8Array>): string;
-/**
- * Everything wrong with a manifest, empty when it's sound: its shape, each module's entry and
- * interfaces, every interface's recorded hash against its schemas, and the package's connections,
- * each a slot joined to an export of the same interface, every slot at most once.
- */
-export declare function checkManifest(value: unknown): string[];
-export type Verified = {
-    ok: true;
-    hash: string;
-    manifest: Manifest;
-    files: Map<string, Uint8Array>;
-} | {
-    ok: false;
-    hash?: string;
-    problems: string[];
-};
-/**
- * Check a `.agentorg` archive's bytes: it reads as a package (exactly `agentorg.json` and each
- * module's entry), hashes to the expected hash, and its manifest is sound. Problems are returned,
- * never thrown, so a Hub can report them as they are.
- */
-export declare function verifyArchive(bytes: Uint8Array, expected: string): Verified;

package/dist/node_modules/@agentorg/sdk/dist/src/manifest.js

@@ -1,165 +0,0 @@
-import { hashOf, sha256 } from "./canonical.js";
-import { hashInterface } from "./interface.js";
-import { readTar } from "./tar.js";
-export const FORMAT = "agentorg.package/1";
-/**
- * The reserved name of a package's signature. It is detached: a file beside the package that signs
- * the package hash, so it can never be inside what it signs.
- */
-export const SIGNATURE = "agentorg.sig";
-const NAME = /^[a-z][A-Za-z0-9_]*$/;
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const own = (record, key) => Object.hasOwn(record, key) ? record[key] : undefined;
-/** The canonical tree hash: SHA-256 over the sorted `[path, sha256(bytes)]` of every file. */
-export function treeHash(files) {
-    return hashOf([...files.keys()].sort().map((path) => [path, sha256(files.get(path))]));
-}
-/**
- * Everything wrong with a manifest, empty when it's sound: its shape, each module's entry and
- * interfaces, every interface's recorded hash against its schemas, and the package's connections,
- * each a slot joined to an export of the same interface, every slot at most once.
- */
-export function checkManifest(value) {
-    if (!isRecord(value))
-        return ["The manifest isn't a JSON object."];
-    const problems = [];
-    if (value.format !== FORMAT)
-        problems.push(`Unknown format ${JSON.stringify(value.format)}.`);
-    for (const field of ["name", "version"])
-        if (typeof value[field] !== "string" || !value[field])
-            problems.push(`The manifest needs a ${field}.`);
-    if ("signature" in value)
-        problems.push(`A signature is detached, in ${SIGNATURE} beside the package, not in the manifest.`);
-    const interfaces = isRecord(value.interfaces) ? value.interfaces : {};
-    if (!isRecord(value.interfaces))
-        problems.push("interfaces must be an object.");
-    for (const [id, entry] of Object.entries(interfaces)) {
-        if (!isRecord(entry) || typeof entry.hash !== "string") {
-            problems.push(`${id} has no recorded hash.`);
-            continue;
-        }
-        const { hash, ...schemas } = entry;
-        let recomputed;
-        try {
-            recomputed = hashInterface({ id, ...schemas });
-        }
-        catch {
-            recomputed = undefined;
-        }
-        if (recomputed !== hash)
-            problems.push(`${id}'s recorded hash doesn't match its schemas.`);
-    }
-    const modules = isRecord(value.modules) ? value.modules : {};
-    if (!isRecord(value.modules) || !Object.keys(modules).length)
-        problems.push("The manifest needs at least one module.");
-    const ids = {};
-    for (const [name, module] of Object.entries(modules)) {
-        if (!NAME.test(name))
-            problems.push(`${JSON.stringify(name)} isn't a valid module name.`);
-        if (!isRecord(module)) {
-            problems.push(`Module ${name} isn't an object.`);
-            continue;
-        }
-        if (module.placement !== "host" && module.placement !== "view")
-            problems.push(`Module ${name} has no placement of host or view.`);
-        if (module.entry !== `dist/${name}.js`)
-            problems.push(`Module ${name}'s entry must be dist/${name}.js.`);
-        for (const side of ["slots", "exports"]) {
-            const members = module[side];
-            if (!isRecord(members)) {
-                problems.push(`Module ${name} needs ${side}.`);
-                continue;
-            }
-            for (const [member, id] of Object.entries(members)) {
-                if (!NAME.test(member))
-                    problems.push(`${name}.${member} isn't a valid name.`);
-                if (typeof id !== "string" || !own(interfaces, id))
-                    problems.push(`${name}.${member} uses ${JSON.stringify(id)}, which isn't recorded.`);
-                else {
-                    const recorded = ids[`${side}:${name}`] ?? {};
-                    recorded[member] = id;
-                    ids[`${side}:${name}`] = recorded;
-                }
-            }
-        }
-    }
-    if (!Array.isArray(value.connections))
-        problems.push("connections must be a list.");
-    const wired = new Set();
-    for (const connection of Array.isArray(value.connections) ? value.connections : []) {
-        const label = JSON.stringify(connection);
-        if (!Array.isArray(connection) ||
-            connection.length !== 2 ||
-            !connection.every((end) => typeof end === "string")) {
-            problems.push(`Connection ${label} must be ["module.slot", "module.export"].`);
-            continue;
-        }
-        const [from, to] = connection;
-        const end = (path, side) => {
-            const parts = path.split(".");
-            const id = parts.length === 2 ? own(ids[`${side}:${parts[0]}`] ?? {}, parts[1]) : undefined;
-            if (typeof id !== "string")
-                problems.push(`Connection ${label}: ${JSON.stringify(path)} isn't a${side === "slots" ? " slot" : "n export"} of a module here, as "module.${side === "slots" ? "slot" : "export"}".`);
-            return id;
-        };
-        const slot = end(from, "slots");
-        const exported = end(to, "exports");
-        if (slot && exported && slot !== exported)
-            problems.push(`Connection ${label} joins ${slot} to ${exported}.`);
-        if (wired.has(from))
-            problems.push(`${from} is connected twice.`);
-        wired.add(from);
-    }
-    if (value.seed !== null && !isRecord(value.seed))
-        problems.push(`seed must be null or an object keyed by "module.slot".`);
-    for (const key of isRecord(value.seed) ? Object.keys(value.seed) : []) {
-        const parts = key.split(".");
-        if (parts.length !== 2 ||
-            typeof own(ids[`slots:${parts[0]}`] ?? {}, parts[1]) !== "string")
-            problems.push(`seed ${JSON.stringify(key)} isn't a slot of a module here, as "module.slot".`);
-    }
-    return problems;
-}
-/**
- * Check a `.agentorg` archive's bytes: it reads as a package (exactly `agentorg.json` and each
- * module's entry), hashes to the expected hash, and its manifest is sound. Problems are returned,
- * never thrown, so a Hub can report them as they are.
- */
-export function verifyArchive(bytes, expected) {
-    let files;
-    try {
-        files = readTar(bytes);
-    }
-    catch (error) {
-        return { ok: false, problems: [error instanceof Error ? error.message : String(error)] };
-    }
-    const hash = treeHash(files);
-    const problems = [];
-    if (hash !== expected)
-        problems.push(`The package hashes to ${hash}, not ${expected}.`);
-    let manifest;
-    try {
-        manifest = JSON.parse(new TextDecoder().decode(files.get("agentorg.json")));
-    }
-    catch {
-        return {
-            ok: false,
-            hash,
-            problems: [...problems, "The package has no readable agentorg.json."],
-        };
-    }
-    problems.push(...checkManifest(manifest));
-    const expectedFiles = new Set([
-        "agentorg.json",
-        ...Object.keys(isRecord(manifest?.modules) ? manifest.modules : {}).map((name) => `dist/${name}.js`),
-    ]);
-    for (const path of expectedFiles)
-        if (!files.has(path))
-            problems.push(`${path} is missing from the package.`);
-    for (const path of files.keys())
-        if (!expectedFiles.has(path))
-            problems.push(`${path} doesn't belong in the package.`);
-    return problems.length
-        ? { ok: false, hash, problems }
-        : { ok: true, hash, manifest: manifest, files };
-}