@agentorg/cli 0.0.1 → 0.0.3

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

@@ -0,0 +1,117 @@
+import { type Header, type WireError } from "@agentorg/wire";
+import { type DescribedInterface, type Interface } from "./interface.js";
+import { type Context, type Duplex, type ExportMap, type InterfaceMap, type Log } from "./module.js";
+/** A stream the Hub opens toward this Actor's exports, naming the export and who is calling. */
+export type Serve = Extract<Header, {
+    op: "serve";
+}>;
+/** How this Actor answers the Hub's `serve` streams. Each throws a refusal to refuse. */
+export interface ServeHandlers {
+    call(serve: Serve, input: unknown): Promise<unknown>;
+    /** Start sending an export's events; `end` stops them from this side. Returns how to stop. */
+    subscribe(serve: Serve, send: (payload: unknown) => void, end: (error?: unknown) => void): () => void;
+    /** Check that the export takes the stream (throwing a refusal if not), then return what runs it. */
+    accept(serve: Serve): (stream: Duplex) => Promise<void>;
+    /** The same for an `http` export: the stream carries HTTP/1.1 once accepted. */
+    serveHttp(serve: Serve): (stream: Duplex) => Promise<void>;
+}
+/**
+ * Where the channel goes: the Hub's WebSocket address with the Actor's credential, or a pipe the
+ * Hub made for this Actor's process, whose hello needs no credential.
+ */
+export type ChannelOptions = ChannelBase & ({
+    hubUrl: string;
+    credential: string;
+    channel?: never;
+} | {
+    channel: Duplex;
+    hubUrl?: never;
+    credential?: never;
+});
+interface ChannelBase {
+    actorId: string;
+    /**
+     * Whether this channel may replace one the Actor already has (the default). With `false`, a
+     * live channel makes the hello refused, code `connected`.
+     */
+    replace?: boolean;
+    /** The Actor's slots and static exports. Without it, the Actor keeps what it declared before. */
+    declares?: {
+        slots: Record<string, DescribedInterface>;
+        exports: Record<string, DescribedInterface>;
+    };
+    /** How to serve the Hub's streams; without it, they are refused. */
+    serve?: ServeHandlers;
+    /**
+     * Each slot notice after hello's snapshot, in order: `bound` false when unbound, true when bound
+     * or, for a slot already bound, when its provider came back.
+     */
+    onSlot?(name: string, bound: boolean): void;
+    /** Where a notice handler's own failure is reported. */
+    log?: Log;
+}
+/** A channel to the Hub as one Actor, at the wire's level: no local checks, no handles. */
+export interface Channel {
+    readonly actorId: string;
+    /** The Actor's slots bound now, from hello's snapshot and the Hub's notices; empty once closed. */
+    readonly bound: ReadonlySet<string>;
+    call(slot: string, method: string, value: unknown): Promise<unknown>;
+    /** Events from a slot's provider until it ends (`onEnd`) or is stopped; returns how to stop. */
+    subscribe(slot: string, event: string, onEvent: (payload: unknown) => void, onEnd?: (error?: Error) => void): () => void;
+    open(slot: string, params: unknown): Promise<Duplex>;
+    /** A stream to an `http` slot's provider, carrying HTTP/1.1 once it accepts. */
+    http(slot: string): Promise<Duplex>;
+    /** Offer and withdraw run-time exports; they reach the Hub in the order they were made. */
+    offer(name: string, iface: DescribedInterface): Promise<void>;
+    withdraw(name: string): Promise<void>;
+    close(): void;
+    /** Settles when the channel ends. */
+    readonly closed: Promise<void>;
+}
+/** A wire error as the SDK's error: `NotConnected`, `Refused(code)` or `OutcomeUnknown`. */
+export declare const errorOf: (error: WireError["error"], target: string) => Error;
+/**
+ * Open a channel to the Hub as one Actor: a WebSocket, a yamux session and `hello`. Refusals come
+ * back as the SDK's errors: a Hub that can't be reached is `NotConnected`, and a channel lost
+ * mid-call is `OutcomeUnknown`.
+ */
+export declare function openChannel(options: ChannelOptions): Promise<Channel>;
+export interface ConnectOptions<S extends InterfaceMap, X extends ExportMap> {
+    hubUrl: string;
+    actorId: string;
+    credential: string;
+    /** The slots this program uses, with their interfaces. */
+    slots?: S;
+    /** The exports it offers from the start. */
+    exports?: X;
+    /**
+     * Whether hello declares `slots` and `exports` (the default). With `false`, the Actor keeps what
+     * it declared before, and the handles here only shape and check calls locally.
+     */
+    declare?: boolean;
+    /**
+     * Runs and is awaited before the channel opens, as a module's start does: implement exports and
+     * register `onBind` and `on` handlers here. Every slot reads unbound meanwhile; each bound slot's
+     * `onBind` runs once the Hub admits the channel.
+     */
+    start?(ctx: Context<S, X>): void | Promise<void>;
+    log?: Log;
+}
+/** A program connected to the Hub as an Actor: a module's handles, and a way to leave. */
+export interface Client<S extends InterfaceMap, X extends InterfaceMap> extends Context<S, X> {
+    close(): void;
+    /** Settles when the channel ends; by then every slot reads unbound. */
+    readonly closed: Promise<void>;
+}
+type None = Record<never, Interface>;
+/**
+ * Connect a program outside the Hub as an Actor. It gets the same handles as a module's `ctx`, on
+ * the same runtime, so a call is checked here as the Hub checks it. As in a module: implement in
+ * `start`, and use slots from `onBind`. `start` runs before the channel opens, so the Hub never
+ * reaches an export before it is implemented. A slot is bound when the Hub says so; `onBind` runs
+ * when it becomes usable (bound, or its provider back), and `on` handlers subscribe while it is
+ * usable. `exports.add` and `withdraw()` offer and withdraw over the channel. `http` slots and
+ * exports speak HTTP/1.1 over the Hub's stream, one request per stream, with `node:http`.
+ */
+export declare function connect<const S extends InterfaceMap = None, const X extends ExportMap = None>(options: ConnectOptions<S, X>): Promise<Client<S, X>>;
+export {};

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

@@ -0,0 +1,332 @@
+import { encodeFrame, eventBody, FrameError, FrameReader, HeaderError, input, parseBody, parseHeader, result, Session, webSocketChannel, wireError, } from "@agentorg/wire";
+import { errorBodyOf, errorFromBody, NotConnected, OutcomeUnknown, Refused } from "./errors.js";
+import { describeInterface } from "./interface.js";
+import { defineActor, } from "./module.js";
+import { ModuleHost } from "./module-host.js";
+import { createRuntime } from "./runtime.js";
+/** A wire error as the SDK's error: `NotConnected`, `Refused(code)` or `OutcomeUnknown`. */
+export const errorOf = (error, target) => errorFromBody(error, target);
+/** Anything a handler throws, as one wire error body: a non-SDK error is the provider failing. */
+function bodyOf(error) {
+    const body = errorBodyOf(error);
+    return wireError(body.name, body.message, body.code);
+}
+/** Write bodies and close our side. Each is encoded first, so a frame too large fails cleanly. */
+async function send(stream, ...bodies) {
+    const frames = bodies.map((body) => encodeFrame(body));
+    const writer = stream.writable.getWriter();
+    try {
+        for (const frame of frames)
+            await writer.write(frame);
+        await writer.close();
+    }
+    finally {
+        writer.releaseLock();
+    }
+}
+/** Answer with one body; a body that can't go (too large) goes as a refusal instead. */
+async function answer(stream, body) {
+    try {
+        await send(stream, body);
+    }
+    catch (error) {
+        if (!(error instanceof FrameError))
+            return stream.reset();
+        await send(stream, wireError("Refused", error.message, "bad_output")).catch(() => stream.reset());
+    }
+}
+/** Read and drop what the other side still sends, so the stream can be forgotten. */
+const drain = (reader) => void reader
+    .rest()
+    .pipeTo(new WritableStream())
+    .catch(() => { });
+/**
+ * Open a channel to the Hub as one Actor: a WebSocket, a yamux session and `hello`. Refusals come
+ * back as the SDK's errors: a Hub that can't be reached is `NotConnected`, and a channel lost
+ * mid-call is `OutcomeUnknown`.
+ */
+export async function openChannel(options) {
+    let session;
+    const bound = new Set();
+    // Notices arrive as streams; their headers are read in arrival order, after hello's snapshot.
+    let ready;
+    let headers = new Promise((resolve) => {
+        ready = resolve;
+    });
+    try {
+        const bytes = options.channel !== undefined
+            ? options.channel
+            : await webSocketChannel(new WebSocket(options.hubUrl));
+        session = new Session(bytes, {
+            client: true,
+            onStream(stream) {
+                const reader = new FrameReader(stream.readable);
+                const header = headers.then(() => reader.next());
+                headers = header.then(() => { }, () => { });
+                void header
+                    .then((frame) => serveStream(parseHeader(frame), stream, reader))
+                    .catch(() => stream.reset());
+            },
+        });
+    }
+    catch {
+        throw new NotConnected(`the Hub at ${options.hubUrl ?? "its pipe"}`);
+    }
+    async function serveStream(header, stream, reader) {
+        if (header.op === "slot") {
+            if (header.bound)
+                bound.add(header.name);
+            else
+                bound.delete(header.name);
+            await stream.writable.close().catch(() => { });
+            try {
+                options.onSlot?.(header.name, header.bound);
+            }
+            catch (error) {
+                options.log?.error("A slot notice's handler threw.", {
+                    slot: header.name,
+                    error: String(error),
+                });
+            }
+            return;
+        }
+        if (header.op !== "serve")
+            return stream.reset();
+        const handlers = options.serve;
+        try {
+            if (!handlers)
+                throw new Refused("unimplemented", `${options.actorId} serves nothing.`);
+            if (header.kind === "call") {
+                const body = parseBody(await reader.next());
+                if (!("input" in body))
+                    throw new Refused("invalid", "A call's body is {input}.");
+                return await answer(stream, result(await handlers.call(header, body.input)));
+            }
+            if (header.kind === "subscribe")
+                return subscribeStream(handlers, header, stream);
+            if (header.kind === "open" || header.kind === "http") {
+                const run = header.kind === "open" ? handlers.accept(header) : handlers.serveHttp(header);
+                const writer = stream.writable.getWriter();
+                await writer.write(encodeFrame(result({})));
+                writer.releaseLock();
+                // Accepted: from here the stream is raw bytes, so a failing handler can only reset it.
+                return await run({ readable: reader.rest(), writable: stream.writable }).catch(() => stream.reset());
+            }
+            return stream.reset();
+        }
+        catch (error) {
+            await answer(stream, bodyOf(error));
+            drain(reader);
+        }
+    }
+    function subscribeStream(handlers, header, stream) {
+        const writer = stream.writable.getWriter();
+        let stopped = false;
+        let stop = () => { };
+        const halt = () => {
+            if (stopped)
+                return;
+            stopped = true;
+            stop();
+        };
+        const end = (error) => {
+            halt();
+            void (error ? writer.write(encodeFrame(bodyOf(error))) : Promise.resolve())
+                .then(() => writer.close())
+                .catch(() => { });
+        };
+        stop = handlers.subscribe(header, (payload) => {
+            if (stopped)
+                return;
+            let frame;
+            try {
+                frame = encodeFrame(eventBody(payload));
+            }
+            catch (error) {
+                // An event too large for a frame ends this subscription; the emitter isn't thrown at.
+                options.log?.error("An event was too large to send.", { export: header.export });
+                return end(new Refused("bad_output", error instanceof Error ? error.message : String(error)));
+            }
+            writer.write(frame).catch(halt);
+        }, end);
+        // The Hub resets the stream to unsubscribe, which errors our side of it.
+        writer.closed.catch(halt);
+        if (stopped)
+            stop();
+    }
+    /** Open a stream, send a header (and a body), and read the one body that answers. */
+    async function exchange(header, target, body) {
+        let sent = false;
+        try {
+            const stream = session.open();
+            await send(stream, ...(body ? [header, body] : [header]));
+            sent = true;
+            const reply = await new FrameReader(stream.readable).next();
+            if (reply === undefined)
+                throw new Error("no answer");
+            return parseBody(reply);
+        }
+        catch (error) {
+            // Too large to send: nothing ran. Malformed or too large to read: the answer broke.
+            if (!sent && error instanceof FrameError)
+                throw new Refused("invalid", error.message);
+            if (error instanceof HeaderError || error instanceof FrameError)
+                throw new Refused("bad_output", error.message);
+            throw sent
+                ? new OutcomeUnknown("The channel to the Hub dropped before the answer came.")
+                : new NotConnected(target);
+        }
+    }
+    const hello = await exchange({
+        op: "hello",
+        actorId: options.actorId,
+        ...(options.credential === undefined ? {} : { credential: options.credential }),
+        ...(options.declares ? { declares: options.declares } : {}),
+        ...(options.replace === false ? { replace: false } : {}),
+    }, "the Hub");
+    if ("error" in hello) {
+        session.close();
+        throw errorOf(hello.error, options.actorId);
+    }
+    for (const slot of hello.result.bound ?? [])
+        bound.add(slot);
+    ready();
+    const answered = (body, target) => {
+        if ("error" in body)
+            throw errorOf(body.error, target);
+        if (!("result" in body))
+            throw new Refused("bad_output", "The Hub's answer isn't a result.");
+        return body.result;
+    };
+    // Offers and withdrawals go one at a time, so the Hub sees them in the order they were made.
+    let changes = Promise.resolve();
+    const inOrder = (work) => {
+        const next = changes.then(work, work);
+        changes = next.catch(() => { });
+        return next;
+    };
+    const closed = session.closed.then(() => bound.clear());
+    return {
+        actorId: options.actorId,
+        bound,
+        async call(slot, method, value) {
+            return answered(await exchange({ op: "call", slot, method }, slot, input(value)), slot);
+        },
+        subscribe(slot, event, onEvent, onEnd) {
+            let ended = false;
+            const end = (error) => {
+                if (ended)
+                    return;
+                ended = true;
+                onEnd?.(error);
+            };
+            let stream;
+            try {
+                stream = session.open();
+            }
+            catch {
+                queueMicrotask(() => end(new NotConnected(slot)));
+                return () => { };
+            }
+            void (async () => {
+                try {
+                    const writer = stream.writable.getWriter();
+                    await writer.write(encodeFrame({ op: "subscribe", slot, event }));
+                    writer.releaseLock();
+                    const reader = new FrameReader(stream.readable);
+                    for (;;) {
+                        const frame = await reader.next();
+                        if (frame === undefined)
+                            return end();
+                        const body = parseBody(frame);
+                        if ("event" in body)
+                            onEvent(body.event);
+                        else if ("error" in body)
+                            return end(errorOf(body.error, slot));
+                    }
+                }
+                catch {
+                    end(new NotConnected(slot));
+                }
+            })();
+            return () => {
+                ended = true;
+                stream.reset();
+            };
+        },
+        open: (slot, params) => splice({ op: "open", slot, params }, slot),
+        http: (slot) => splice({ op: "http", slot }, slot),
+        offer: (name, iface) => inOrder(async () => {
+            answered(await exchange({ op: "offer", name, interface: iface }, name), name);
+        }),
+        withdraw: (name) => inOrder(async () => {
+            answered(await exchange({ op: "withdraw", name }, name), name);
+        }),
+        close: () => session.close(),
+        closed,
+    };
+    /** Open a raw stream: send its header, read the one body that answers, then hand over the bytes. */
+    async function splice(header, slot) {
+        let stream;
+        try {
+            stream = session.open();
+            const writer = stream.writable.getWriter();
+            await writer.write(encodeFrame(header));
+            writer.releaseLock();
+            const reader = new FrameReader(stream.readable);
+            const first = await reader.next();
+            if (first === undefined)
+                throw new NotConnected(slot);
+            answered(parseBody(first), slot);
+            return { readable: reader.rest(), writable: stream.writable };
+        }
+        catch (error) {
+            stream?.reset();
+            if (error instanceof Refused ||
+                error instanceof NotConnected ||
+                error instanceof OutcomeUnknown)
+                throw error;
+            throw new NotConnected(slot);
+        }
+    }
+}
+const quiet = { info() { }, warn() { }, error() { } };
+/**
+ * Connect a program outside the Hub as an Actor. It gets the same handles as a module's `ctx`, on
+ * the same runtime, so a call is checked here as the Hub checks it. As in a module: implement in
+ * `start`, and use slots from `onBind`. `start` runs before the channel opens, so the Hub never
+ * reaches an export before it is implemented. A slot is bound when the Hub says so; `onBind` runs
+ * when it becomes usable (bound, or its provider back), and `on` handlers subscribe while it is
+ * usable. `exports.add` and `withdraw()` offer and withdraw over the channel. `http` slots and
+ * exports speak HTTP/1.1 over the Hub's stream, one request per stream, with `node:http`.
+ */
+export async function connect(options) {
+    const slots = (options.slots ?? {});
+    const exports = (options.exports ?? {});
+    const log = options.log ?? quiet;
+    // defineActor checks the names, as it does for a module.
+    const definition = defineActor({ slots, exports, start: options.start ?? (() => { }) });
+    const host = new ModuleHost("", slots, log);
+    const runtime = createRuntime(definition, {
+        self: { actorId: options.actorId, module: "client" },
+        log,
+        ...host.hooks(),
+    });
+    host.runtime = runtime;
+    // A module's start: exports implemented and handlers registered before the Hub can reach them.
+    await runtime.start();
+    const describeAll = (map) => Object.fromEntries(Object.entries(map).map(([name, iface]) => [name, describeInterface(iface)]));
+    const channel = await openChannel({
+        hubUrl: options.hubUrl,
+        actorId: options.actorId,
+        credential: options.credential,
+        log,
+        ...(options.declare === false
+            ? {}
+            : { declares: { slots: describeAll(slots), exports: describeAll(exports) } }),
+        onSlot: (slot, bound) => host.onSlot(slot, bound),
+        serve: host.serve,
+    });
+    host.attach(channel);
+    return Object.assign(runtime.ctx, { close: () => channel.close(), closed: channel.closed });
+}

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

@@ -0,0 +1,13 @@
+import { type DescribedInterface } from "./interface.js";
+import { type Placement } from "./module.js";
+/** A module as the build reads it from its code. */
+export interface ModuleDescription {
+    placement: Placement;
+    slots: Record<string, DescribedInterface>;
+    exports: Record<string, DescribedInterface>;
+}
+/**
+ * Describe a module's default export. The build bundles this with the author's own module, so it
+ * uses the same SDK and zod copies as the module, and runs it in a permission-limited process.
+ */
+export declare function describeModule(definition: unknown): ModuleDescription;

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

@@ -0,0 +1,16 @@
+import { describeInterface } from "./interface.js";
+import { isModuleDefinition } from "./module.js";
+/**
+ * Describe a module's default export. The build bundles this with the author's own module, so it
+ * uses the same SDK and zod copies as the module, and runs it in a permission-limited process.
+ */
+export function describeModule(definition) {
+    if (!isModuleDefinition(definition))
+        throw new TypeError("The default export isn't a module: define it with defineActor or defineWidget.");
+    const describe = (interfaces) => Object.fromEntries(Object.entries(interfaces).map(([name, iface]) => [name, describeInterface(iface)]));
+    return {
+        placement: definition.placement,
+        slots: describe(definition.slots),
+        exports: describe(definition.exports),
+    };
+}

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

@@ -0,0 +1,37 @@
+/** A call on a slot that no export is bound to, or on an export that was withdrawn. */
+export declare class NotConnected extends Error {
+    static [Symbol.hasInstance](value: unknown): boolean;
+    readonly name = "NotConnected";
+    /** The slot or export that isn't connected. */
+    readonly target: string;
+    constructor(target: string);
+}
+/**
+ * Why a call was refused: `invalid` (the caller's input broke the schema; nothing ran),
+ * `bad_output` (the provider ran and its reply or event broke the contract; read state before
+ * retrying), `unimplemented` (no handler yet), or a policy's own code.
+ */
+export type RefusedCode = "invalid" | "bad_output" | "unimplemented" | (string & {});
+/** A call refused by validation or policy, with a stable code. */
+export declare class Refused extends Error {
+    static [Symbol.hasInstance](value: unknown): boolean;
+    readonly name = "Refused";
+    readonly code: RefusedCode;
+    constructor(code: RefusedCode, message: string);
+}
+/** The channel dropped mid-call, so whether it took effect is unknown; read state before retrying. */
+export declare class OutcomeUnknown extends Error {
+    static [Symbol.hasInstance](value: unknown): boolean;
+    readonly name = "OutcomeUnknown";
+    constructor(message?: string);
+}
+/** An error as it crosses a channel or a frame's port: one of the three names, a message, a code. */
+export interface ErrorBody {
+    name: "NotConnected" | "Refused" | "OutcomeUnknown";
+    message: string;
+    code?: string;
+}
+/** Anything thrown, as an error body: a non-SDK error is the other side failing, code `failed`. */
+export declare function errorBodyOf(error: unknown): ErrorBody;
+/** An error body as the SDK's error: `NotConnected`, `Refused(code)` or `OutcomeUnknown`. */
+export declare function errorFromBody(body: ErrorBody, target: string): Error;

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

@@ -0,0 +1,80 @@
+/**
+ * Marks an SDK error class's prototype with its name. A package's bundles and the runner each carry
+ * their own copy of the SDK, so `instanceof` on these three classes checks this mark rather than
+ * the class, and an error made by one copy is the same error to the other. A subclass is checked
+ * as usual.
+ */
+const BRAND = Symbol.for("@agentorg/sdk/error");
+const isBranded = (value, name) => typeof value === "object" && value !== null && value[BRAND] === name;
+/** `instanceof` for `asked`: the mark for one of the three classes, the usual check for a subclass. */
+const instanceOf = (asked, base, name, value) => 
+// The name is given, not read from the class: a bundler may rename a class.
+asked === base
+    ? isBranded(value, name)
+    : Function.prototype[Symbol.hasInstance].call(asked, value);
+/** A call on a slot that no export is bound to, or on an export that was withdrawn. */
+export class NotConnected extends Error {
+    static [Symbol.hasInstance](value) {
+        // biome-ignore lint/complexity/noThisInStatic: `this` is the class instanceof was asked about, a subclass included.
+        return instanceOf(this, NotConnected, "NotConnected", value);
+    }
+    name = "NotConnected";
+    /** The slot or export that isn't connected. */
+    target;
+    constructor(target) {
+        super(`${target} is not connected.`);
+        this.target = target;
+    }
+}
+/** A call refused by validation or policy, with a stable code. */
+export class Refused extends Error {
+    static [Symbol.hasInstance](value) {
+        // biome-ignore lint/complexity/noThisInStatic: `this` is the class instanceof was asked about, a subclass included.
+        return instanceOf(this, Refused, "Refused", value);
+    }
+    name = "Refused";
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+/** The channel dropped mid-call, so whether it took effect is unknown; read state before retrying. */
+export class OutcomeUnknown extends Error {
+    static [Symbol.hasInstance](value) {
+        // biome-ignore lint/complexity/noThisInStatic: `this` is the class instanceof was asked about, a subclass included.
+        return instanceOf(this, OutcomeUnknown, "OutcomeUnknown", value);
+    }
+    name = "OutcomeUnknown";
+    constructor(message = "The connection dropped before the call's outcome was known.") {
+        super(message);
+    }
+}
+for (const [error, name] of [
+    [NotConnected, "NotConnected"],
+    [Refused, "Refused"],
+    [OutcomeUnknown, "OutcomeUnknown"],
+])
+    Object.defineProperty(error.prototype, BRAND, { value: name });
+/** Anything thrown, as an error body: a non-SDK error is the other side failing, code `failed`. */
+export function errorBodyOf(error) {
+    if (error instanceof Refused)
+        return { name: "Refused", message: error.message, code: error.code };
+    if (error instanceof NotConnected)
+        return { name: "NotConnected", message: error.message };
+    if (error instanceof OutcomeUnknown)
+        return { name: "OutcomeUnknown", message: error.message };
+    return {
+        name: "Refused",
+        message: error instanceof Error ? error.message : String(error),
+        code: "failed",
+    };
+}
+/** An error body as the SDK's error: `NotConnected`, `Refused(code)` or `OutcomeUnknown`. */
+export function errorFromBody(body, target) {
+    if (body.name === "NotConnected")
+        return new NotConnected(target);
+    if (body.name === "OutcomeUnknown")
+        return new OutcomeUnknown(body.message);
+    return new Refused(body.code ?? "refused", body.message);
+}

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

@@ -0,0 +1,35 @@
+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 { runFrame } from "./frame.js";
+import { FRAME_HELLO } from "./frame-protocol.js";
+const self = globalThis;
+let frame;
+self.addEventListener("message", (event) => {
+    const port = event.ports[0];
+    if (frame || event.source !== self.parent || event.data !== FRAME_HELLO || !port)
+        return;
+    frame = runFrame({
+        port,
+        root: self.document.body,
+        // A computed specifier: the bundler leaves it to the browser.
+        load: (src) => import(__rewriteRelativeImportExtension(src)),
+        theme(tokens) {
+            for (const [name, value] of Object.entries(tokens))
+                if (name.startsWith("--"))
+                    self.document.documentElement.style.setProperty(name, value);
+        },
+    });
+    // The body's height is its content's (the frame's document sets no height): the shell hears each
+    // change while the view is mounted, and may size the frame to it.
+    const body = self.document.body;
+    new self.ResizeObserver(() => frame?.size(Math.ceil(body.getBoundingClientRect().height))).observe(body);
+});
+// What the view doesn't catch goes to its Actor's log.
+self.addEventListener("error", (event) => frame?.failed(event.error ?? event.message));
+self.addEventListener("unhandledrejection", (event) => frame?.failed(event.reason));