@agentorg/cli 0.0.3 → 0.0.4

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

@@ -0,0 +1,64 @@
+/**
+ * The base stylesheet every view's frame gets first, before the view's own: the document fills the
+ * frame on a transparent background, and plain HTML looks like the shell, drawn with the theme's
+ * tokens (`--fg`, `--surface`, `--accent`, … as the shell sends them at mount). Every rule is in
+ * `:where()`, so it has no specificity: any selector a view writes wins, and a view that wants its
+ * own look draws it.
+ */
+export const FRAME_BASE = `
+:where(*, *::before, *::after) { box-sizing: border-box; }
+:where(html, body) { height: 100%; margin: 0; background: transparent; }
+:where(body) {
+  overflow: auto; scrollbar-width: none;
+  color: var(--fg); font: 14px/1.45 var(--font, ui-sans-serif, system-ui, sans-serif);
+  -webkit-font-smoothing: antialiased;
+}
+:where(body)::-webkit-scrollbar { display: none; }
+:where(body > :only-child) { min-height: 100%; }
+:where(h1, h2, h3, h4) { margin: 0 0 8px; font-weight: 600; letter-spacing: -0.01em; }
+:where(h1) { font-size: 20px; }
+:where(h2) { font-size: 16px; }
+:where(h3, h4) { font-size: 14px; }
+:where(p) { margin: 0 0 8px; }
+:where(small) { color: var(--muted); font-size: 12.5px; }
+:where(a) { color: inherit; text-underline-offset: 2px; }
+:where(hr) { border: 0; border-top: 1px solid var(--line); margin: 10px 0; }
+:where(ul, ol) { margin: 0 0 10px; padding: 0; list-style: none; display: flex; flex-direction: column; gap: 6px; }
+:where(li) { display: flex; align-items: center; gap: 10px; padding: 8px 10px; border-radius: 10px; background: var(--raised); }
+:where(button) {
+  height: 34px; padding: 0 12px; border: 0; border-radius: 9px; cursor: pointer;
+  background: var(--hover); color: var(--fg); font: inherit; font-weight: 500;
+}
+:where(button:hover) { background: var(--selected); }
+:where(button:disabled) { opacity: 0.5; cursor: default; }
+:where(button[type="submit"], button.primary) { background: var(--accent); color: var(--accent-fg); font-weight: 600; }
+:where(input:not([type]), input[type="text"], input[type="search"], input[type="number"], input[type="url"], input[type="email"], select) {
+  height: 34px; padding: 0 10px; border: 0; border-radius: 9px; outline: 0;
+  background: var(--raised); color: var(--fg); font: inherit;
+}
+:where(textarea) { padding: 8px 10px; border: 0; border-radius: 9px; outline: 0; resize: none; background: var(--raised); color: var(--fg); font: inherit; }
+:where(input:focus-visible, textarea:focus-visible, select:focus-visible, button:focus-visible) { box-shadow: 0 0 0 1.5px var(--ring); outline: 0; }
+:where(input[type="checkbox"]) {
+  appearance: none; width: 16px; height: 16px; margin: 0; flex: none; display: grid; place-items: center;
+  border: 1.5px solid var(--faint); border-radius: 5px; cursor: pointer;
+}
+:where(input[type="checkbox"]:checked) { background: var(--ok); border-color: var(--ok); }
+:where(input[type="checkbox"]:checked)::after {
+  content: ""; width: 4px; height: 8px; border: solid white; border-width: 0 2px 2px 0;
+  transform: translateY(-1px) rotate(45deg);
+}
+:where(li:has(> input[type="checkbox"]:checked) > span) { color: var(--faint); text-decoration: line-through; }
+:where(form) { display: flex; gap: 6px; }
+:where(form > input, form > textarea) { flex: 1; min-width: 0; }
+:where(table) { width: 100%; border-collapse: collapse; font-size: 13px; }
+:where(th) { padding: 0 8px 6px; text-align: left; color: var(--faint); font-weight: 500; font-size: 12px; }
+:where(td) { padding: 7px 8px; border-top: 1px solid var(--line); }
+:where(code, pre) { font: 12.5px/1.5 ui-monospace, SFMono-Regular, Menlo, monospace; }
+:where(code) { padding: 1px 5px; border-radius: 5px; background: var(--raised); }
+:where(pre) { margin: 0 0 10px; padding: 10px 12px; border-radius: 10px; background: var(--raised); overflow: auto; }
+:where(pre code) { padding: 0; background: none; }
+:where(progress) { appearance: none; width: 100%; height: 4px; border: 0; border-radius: 2px; background: var(--raised); }
+:where(progress)::-webkit-progress-bar { background: var(--raised); border-radius: 2px; }
+:where(progress)::-webkit-progress-value { background: var(--ok); border-radius: 2px; }
+:where(progress)::-moz-progress-bar { background: var(--ok); border-radius: 2px; }
+`;

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

@@ -7,9 +7,13 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import { runFrame } from "./frame.js";
+import { FRAME_BASE } from "./frame-base.js";
 import { FRAME_HELLO } from "./frame-protocol.js";
 const self = globalThis;
 let frame;
+const base = self.document.createElement("style");
+base.textContent = FRAME_BASE;
+self.document.head.prepend(base);
 self.addEventListener("message", (event) => {
     const port = event.ports[0];
     if (frame || event.source !== self.parent || event.data !== FRAME_HELLO || !port)
@@ -25,10 +29,6 @@ self.addEventListener("message", (event) => {
                     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));

package/{node_modules → dist/node_modules}/@agentorg/sdk/dist/src/frame-host.d.ts

@@ -17,21 +17,11 @@ export interface FrameHandlers {
     };
     /** A line for the view's Actor's log. */
     log(level: "info" | "warn" | "error", message: string, fields?: Record<string, unknown>): void;
-    /**
-     * The view's content height, within 120–2,000 px and at most once per 100 ms (the latest one
-     * wins), for a shell that sizes the frame to its content. Without it, sizes are dropped.
-     */
-    size?(height: number): void;
 }
 type Size = {
     width: number;
     height: number;
 };
-/** The heights a view's frame may take from its content, and how often it may change. */
-export declare const FRAME_HEIGHT: {
-    min: number;
-    max: number;
-};
 /**
  * Hand a frame its port: post the hello with the other end to the frame's window, which has an
  * opaque origin, so the target origin is `*`; the frame accepts it only from its parent.
@@ -47,6 +37,7 @@ export declare function openFrame(frameWindow: {
  */
 export declare class FrameHost {
     #private;
+    /** The latest height not yet passed on, and the wait before the next may be. */
     constructor(port: PortLike, handlers: FrameHandlers);
     /** Import the view's bundle in the frame and run its `start`; `slots` says which are bound. */
     load(options: {

package/{node_modules → dist/node_modules}/@agentorg/sdk/dist/src/frame-host.js

@@ -16,9 +16,6 @@ const LOG_WINDOW_MS = 10_000;
 const MAX_SUBSCRIPTIONS = 64;
 /** Calls on its slots one frame may have in flight; past it, `busy`. */
 const MAX_CALLS = 64;
-/** The heights a view's frame may take from its content, and how often it may change. */
-export const FRAME_HEIGHT = { min: 120, max: 2000 };
-const SIZE_MS = 100;
 /**
  * A frame's log fields, rebuilt: a fresh object of at most `MAX_FIELDS` plain keys (no prototype
  * keys), each value a primitive or JSON text, cut to `MAX_FIELD`.
@@ -110,7 +107,6 @@ export class FrameHost {
     #calls = 0;
     #closed = false;
     /** The latest height not yet passed on, and the wait before the next may be. */
-    #sizing = {};
     constructor(port, handlers) {
         this.#port = port;
         this.#handlers = handlers;
@@ -144,7 +140,6 @@ export class FrameHost {
         if (this.#closed)
             return;
         this.#closed = true;
-        clearTimeout(this.#sizing.timer);
         this.#port.onmessage = null;
         for (const { stop } of this.#subscriptions.values())
             stop();
@@ -155,14 +150,6 @@ export class FrameHost {
         this.#pending.clear();
         this.#port.close();
     }
-    #flushSize() {
-        const { height } = this.#sizing;
-        this.#sizing = {};
-        if (height === undefined || this.#closed)
-            return;
-        this.#handlers.size?.(height);
-        this.#sizing.timer = setTimeout(() => this.#flushSize(), SIZE_MS);
-    }
     #post(message) {
         if (!this.#closed)
             this.#port.postMessage(message);
@@ -267,16 +254,6 @@ export class FrameHost {
                 }
                 return;
             }
-            case "size": {
-                const { height } = message;
-                if (typeof height !== "number" || !Number.isFinite(height) || !this.#handlers.size)
-                    return;
-                this.#sizing.height = Math.round(Math.min(FRAME_HEIGHT.max, Math.max(FRAME_HEIGHT.min, height)));
-                // The first at once, then at most one per window: the latest at its end.
-                if (!this.#sizing.timer)
-                    this.#flushSize();
-                return;
-            }
             case "unsubscribe": {
                 const live = isId(message.sub) ? this.#subscriptions.get(message.sub) : undefined;
                 if (!live)

package/{node_modules → dist/node_modules}/@agentorg/sdk/dist/src/frame-protocol.d.ts

@@ -98,14 +98,6 @@ export type FromFrame =
     message: string;
     fields?: Record<string, unknown>;
 }
-/**
- * The mounted view's content height in CSS pixels, each time it changes: the frame runtime's
- * own, not `ui.view@1`'s. The shell may size the frame to it.
- */
- | {
-    op: "size";
-    height: number;
-}
 /** The answer to one of the shell's requests. */
  | {
     op: "reply";

package/{node_modules → dist/node_modules}/@agentorg/sdk/dist/src/frame.d.ts

@@ -14,8 +14,6 @@ export interface FrameOptions {
 export interface Frame {
     /** An error the view didn't catch, for its Actor's log. */
     failed(error: unknown): void;
-    /** The root's content height changed: the shell hears it while the view is mounted. */
-    size(height: number): void;
     close(): void;
 }
 /**

package/{node_modules → dist/node_modules}/@agentorg/sdk/dist/src/frame.js

@@ -231,15 +231,7 @@ export function runFrame(options) {
             log.error("The frame couldn't handle a message from the shell.", { error: String(error) });
         }
     };
-    let told;
     return {
-        size(height) {
-            // Empty before mount and after unmount: those aren't the view's size.
-            if (!mounted || height === told)
-                return;
-            told = height;
-            send({ op: "size", height });
-        },
         failed(error) {
             log.error(error instanceof Error ? error.message : String(error), {
                 ...(error instanceof Error && error.stack ? { stack: error.stack } : {}),

package/{node_modules → dist/node_modules}/@agentorg/sdk/dist/src/host.js

@@ -62,6 +62,11 @@ export async function runHost(options) {
             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);

package/{node_modules → dist/node_modules}/@agentorg/sdk/dist/src/index.d.ts

@@ -1,4 +1,4 @@
 export { canonicalJson, hashOf, sha256 } from "./canonical.js";
 export { NotConnected, OutcomeUnknown, Refused, type RefusedCode } from "./errors.js";
 export { compareInterfaces, type DescribedInterface, defineInterface, describeInterface, type EventSpec, type Events, event, type HttpInterface, hashInterface, type Interface, type InterfaceSchemas, interfaceId, type JsonSchema, type MethodSpec, type Methods, method, normalizeSchema, type RpcInterface, type StreamInterface, } from "./interface.js";
-export { type CallInfo, type Context, type Duplex, defineActor, defineWidget, type EmitOptions, type Export, type ExportMap, type FrameRoot, type Handlers, type HttpExport, type HttpSlot, type InterfaceMap, isFrameInterface, isModuleDefinition, type Log, MODULE, type ModuleDefinition, type ModuleSpec, type Placement, type RpcExport, type RpcSlot, type Slot, type StreamExport, type StreamSlot, type ViewExport, } from "./module.js";
+export { type CallInfo, type Context, type Duplex, defineActor, defineWidget, type EmitOptions, type Export, type ExportMap, type ExposedSlot, type FrameRoot, type Handlers, type HttpExport, type HttpSlot, type InterfaceMap, isFrameInterface, isModuleDefinition, type Log, MODULE, type ModuleDefinition, type ModuleSpec, type Placement, type RpcExport, type RpcSlot, type Slot, type StreamExport, type StreamSlot, type ViewExport, } from "./module.js";

package/{node_modules → dist/node_modules}/@agentorg/sdk/dist/src/module-host.d.ts

@@ -1,4 +1,4 @@
-import type { Channel, Serve, ServeHandlers } from "./client.js";
+import type { Channel, ChannelExposure, Serve, ServeHandlers } from "./client.js";
 import { Refused } from "./errors.js";
 import type { InterfaceMap, Log } from "./module.js";
 import type { ModuleRuntime, RuntimeOptions } from "./runtime.js";
@@ -21,6 +21,11 @@ export declare class ModuleHost {
      * slot already bound) usable again because its provider came back.
      */
     onSlot(slot: string, isBound: boolean): void;
+    /**
+     * A notice for a slot made at run time: bound (or usable again) with its exposure, or gone. Its
+     * name is the Actor's, with no module prefix: every module of the Actor has it.
+     */
+    onExposed(slot: string, exposure: ChannelExposure | undefined): void;
     /** How this module serves the Hub's streams, by its local export names. */
     readonly serve: ServeHandlers;
     /**

package/{node_modules → dist/node_modules}/@agentorg/sdk/dist/src/module-host.js

@@ -168,6 +168,25 @@ export class ModuleHost {
         }));
         this.#resubscribe(slot);
     }
+    /**
+     * A notice for a slot made at run time: bound (or usable again) with its exposure, or gone. Its
+     * name is the Actor's, with no module prefix: every module of the Actor has it.
+     */
+    onExposed(slot, exposure) {
+        if (!this.#channel)
+            return;
+        if (!exposure) {
+            this.runtime.unexpose(slot);
+            return;
+        }
+        const open = this.#channel;
+        this.runtime.expose(slot, {
+            described: exposure.interface,
+            provider: exposure.provider,
+            call: (method, value) => open.call(slot, method, value),
+            subscribe: (event, onEvent, onEnd) => open.subscribe(slot, event, onEvent, () => onEnd()),
+        });
+    }
     /** How this module serves the Hub's streams, by its local export names. */
     serve = {
         call: (serve, value) => this.runtime.call(serve.export, serve.method ?? "", value, serve.caller),
@@ -210,11 +229,15 @@ export class ModuleHost {
         for (const [name, { handle, iface }] of this.#added)
             this.#offer(channel, name, iface, handle);
         for (const name of channel.bound)
-            if (name.startsWith(this.#prefix))
+            if (name.startsWith(this.#prefix) && !channel.exposed.has(name))
                 this.onSlot(name.slice(this.#prefix.length), true);
+        for (const [name, exposure] of channel.exposed)
+            this.onExposed(name, exposure);
         void channel.closed.then(() => {
             for (const slot of [...this.#bindings.keys()])
                 this.onSlot(slot, false);
+            for (const { slot } of this.runtime.ctx.exposed())
+                this.runtime.unexpose(slot);
             for (const ends of this.#subscribers.values())
                 for (const end of [...ends])
                     end();

package/{node_modules → dist/node_modules}/@agentorg/sdk/dist/src/module.d.ts

@@ -1,5 +1,5 @@
 import type { z } from "zod";
-import type { Events, Interface, Methods, RpcInterface, StreamInterface } from "./interface.js";
+import type { DescribedInterface, Events, Interface, Methods, RpcInterface, StreamInterface } from "./interface.js";
 /** Where a module runs: `host` in its own process, `view` in a sandboxed frame. */
 export type Placement = "host" | "view";
 /** A byte stream both ways, the same in a host process and in a view. */
@@ -108,6 +108,28 @@ export type ExportMap = InterfaceMap & {
 };
 /** Whether an interface is `ui.view@1`, the one in-frame interface, with its own export handle. */
 export declare function isFrameInterface(iface: Interface): boolean;
+/**
+ * A slot made at run time: another Actor's export, exposed to this Actor with `hub.grants.expose`
+ * rather than declared by its package. It is here exactly while it is bound. Its values are JSON,
+ * checked against `described` by the Hub both ways, not here, so a misfit comes back as
+ * `Refused` (code `invalid`). A call on a slot that's gone, or whose provider isn't running, throws
+ * `NotConnected`, as a declared slot's does.
+ */
+export interface ExposedSlot {
+    /** Its name on this Actor. */
+    readonly slot: string;
+    /** The export's interface: its methods' input and output JSON Schemas, and its events'. */
+    readonly described: DescribedInterface;
+    /** Whose export it is. */
+    readonly provider: {
+        readonly actor: string;
+        readonly export: string;
+    };
+    /** One function per method of an `rpc` interface; none for another kind. */
+    readonly call: Readonly<Record<string, (input: unknown) => Promise<unknown>>>;
+    /** Live events from the export while the slot is here; returns a function that unsubscribes. */
+    on(event: string, fn: (payload: unknown) => void): () => void;
+}
 /** Everything a module gets. There are no files, network, environment or Hub access besides. */
 export interface Context<S extends InterfaceMap, X extends InterfaceMap> {
     readonly slots: {
@@ -124,6 +146,13 @@ export interface Context<S extends InterfaceMap, X extends InterfaceMap> {
         readonly module: string;
     };
     readonly log: Log;
+    /**
+     * The slots made for this Actor at run time and bound now, in the order they came. Every host
+     * module of the Actor sees them all; a view module sees none.
+     */
+    exposed(): readonly ExposedSlot[];
+    /** Runs after one is added or removed, so `exposed()` is read again; returns how to stop it. */
+    onExposed(fn: () => void): () => void;
 }
 /** The marker the build looks for on a module's default export. */
 export declare const MODULE = "agentorg.module/1";

package/{node_modules → dist/node_modules}/@agentorg/sdk/dist/src/package.js

@@ -2,7 +2,7 @@ import { execFile, spawn } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { mkdir, mkdtemp, readFile, realpath, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { pathToFileURL } from "node:url";
 import { context as esbuildContext, } from "esbuild";
 import { compareInterfaces } from "./interface.js";
@@ -140,9 +140,9 @@ async function bundle(root, input, packages) {
             ...input,
             // A limited build reads no tsconfig or jsconfig (one could name any file to read), and
             // loads only what its plugin resolved.
-            ...(packages
-                ? { plugins: [limitImports(root, packages, loadable)], tsconfigRaw: "{}", metafile: true }
-                : {}),
+            ...(packages ? { plugins: [limitImports(root, packages, loadable)], tsconfigRaw: "{}" } : {}),
+            // Its inputs, by the names the bundle gives them: a library's are renamed after.
+            metafile: true,
             absWorkingDir: root,
             bundle: true,
             format: "esm",
@@ -150,6 +150,11 @@ async function bundle(root, input, packages) {
             mainFields: ["module", "main"],
             conditions: ["import", "module", "default"],
             target: "es2023",
+            // A view may be written in JSX with React (the kit's components): the automatic runtime,
+            // so no file needs React in scope, and React's production build, since a frame has no
+            // `process` for React to read its mode from.
+            jsx: "automatic",
+            define: { "process.env.NODE_ENV": '"production"' },
             minifyWhitespace: true,
             legalComments: "none",
             write: false,
@@ -174,7 +179,8 @@ async function bundle(root, input, packages) {
                 if (input !== (input_.stdin?.sourcefile ?? "<stdin>") &&
                     !loadable.has(resolve(root, input)))
                     throw new BuildError("The bundle reached a file the package didn't import.");
-        return ((result.outputFiles ?? [])[0]?.contents ?? new Uint8Array());
+        const code = (result.outputFiles ?? [])[0]?.contents ?? new Uint8Array();
+        return nameLibraries(code, Object.keys(result.metafile?.inputs ?? {}), root);
     }
     catch (error) {
         if (error instanceof BuildError)
@@ -212,6 +218,95 @@ function inPackage(path, name) {
             return false;
     }
 }
+/** The name a library's file is given in the bundle, after this prefix. */
+const LIBRARY = "agentorg-library:";
+/**
+ * A library's file as the bundle names it: its package's name and version and its path in that
+ * package, never where it is installed. Undefined for a file in no named, versioned package.
+ */
+function libraryName(path, packageOfFolder) {
+    const seen = [];
+    let found = null;
+    for (let dir = dirname(path); dirname(dir) !== dir; dir = dirname(dir)) {
+        const known = packageOfFolder.get(dir);
+        if (known !== undefined) {
+            found = known;
+            break;
+        }
+        seen.push(dir);
+        let manifest;
+        try {
+            manifest = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+        }
+        catch {
+            // No package.json here, or not one to read.
+        }
+        if (typeof manifest?.name === "string" && typeof manifest.version === "string") {
+            found = { name: manifest.name, version: manifest.version, dir };
+            break;
+        }
+    }
+    for (const dir of seen)
+        packageOfFolder.set(dir, found);
+    return found
+        ? `${found.name}@${found.version}/${relative(found.dir, path).split(sep).join("/")}`
+        : undefined;
+}
+/**
+ * The bundle with each wrapped library module named by its library, not by where it sits.
+ * esbuild names each CommonJS (and lazily run ESM) module it wraps by its path from the build's
+ * folder, which for an installed library spells out the machine's folders and changes with them:
+ * React's, for one, would carry the builder's home into every package built with it. Only those
+ * names change, and only for a library's files: in a named, versioned package, outside the
+ * package's folder or in a node_modules within it.
+ */
+function nameLibraries(code, inputs, root) {
+    const names = new Map();
+    const packages = new Map();
+    for (const input of inputs) {
+        const path = resolve(root, input);
+        // The package's own files keep their paths; a library is named, even one installed inside.
+        if (within(path, root) && !path.slice(root.length).split(sep).includes("node_modules"))
+            continue;
+        const name = libraryName(path, packages);
+        if (name)
+            names.set(input, `${LIBRARY}${name}`);
+    }
+    if (!names.size)
+        return code;
+    const text = new TextDecoder().decode(code);
+    // A wrapper's key: the method name after `__commonJS({` or `__esm({` (`async` before it for a
+    // module with top-level await), in either quote, followed by its parameter list.
+    const named = text.replace(/(\b__(?:commonJS|esm)\d*\(\{(?:async\s*)?)("(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*')(?=\()/g, (whole, call, literal) => {
+        const name = names.get(stringOf(literal));
+        return name ? `${call}${JSON.stringify(name)}` : whole;
+    });
+    return new TextEncoder().encode(named);
+}
+/** A JavaScript string literal's value, as esbuild prints one: its escapes read, never thrown. */
+function stringOf(literal) {
+    return literal
+        .slice(1, -1)
+        .replace(/\\(u\{([0-9a-fA-F]+)\}|u([0-9a-fA-F]{4})|x([0-9a-fA-F]{2})|([0-7]{1,3})|\r\n|[\s\S])/g, (_, sequence, point, unit, byte, octal) => {
+        const code = point ?? unit ?? byte;
+        if (code !== undefined)
+            return String.fromCodePoint(Number.parseInt(code, 16));
+        if (octal !== undefined)
+            return String.fromCharCode(Number.parseInt(octal, 8));
+        const simple = {
+            n: "\n",
+            r: "\r",
+            t: "\t",
+            b: "\b",
+            f: "\f",
+            v: "\v",
+        };
+        // A line continuation is nothing; any other escaped character is itself.
+        return sequence === "\n" || sequence === "\r\n" || sequence === "\r"
+            ? ""
+            : (simple[sequence] ?? sequence);
+    });
+}
 /**
  * Imports from the package's own files (and its module entries): by name, only an allowed
  * package, found from `from`, and only a file inside it; by relative path, only inside the
@@ -262,7 +357,17 @@ function limitImports(root, packages, loadable) {
                 // A library's own import is its business, but only what was resolved here is loaded.
                 if (found.namespace === "file")
                     loadable.add(found.path);
-                return { path: found.path, namespace: found.namespace, external: found.external };
+                // A library's own import is resolved again by esbuild itself, to the same file, so it
+                // keeps what only esbuild's resolution carries: the module type ("type": "module").
+                if (!ours)
+                    return undefined;
+                // As resolved, with what tree-shaking reads.
+                return {
+                    path: found.path,
+                    namespace: found.namespace,
+                    external: found.external,
+                    sideEffects: found.sideEffects,
+                };
             });
             // A file esbuild found any other way (a pattern in a template-string import or require
             // matches files without resolving them) is never read.

package/{node_modules → dist/node_modules}/@agentorg/sdk/dist/src/runtime.d.ts

@@ -1,4 +1,4 @@
-import type { Interface } from "./interface.js";
+import type { DescribedInterface, Interface } from "./interface.js";
 import { type Context, type Duplex, type FrameRoot, type InterfaceMap, type Log, type ModuleDefinition } from "./module.js";
 /**
  * What serves a bound slot, as the host side sees it: one function per kind. The runtime validates
@@ -13,6 +13,20 @@ export interface SlotProvider {
 export interface Binding {
     emit(event: string, payload: unknown): void;
 }
+/**
+ * A slot made at run time, as the host side gives it: the export's interface as described, whose
+ * it is, and how to reach it. Values pass as they are: the Hub checks them.
+ */
+export interface ExposedProvider {
+    described: DescribedInterface;
+    provider: {
+        actor: string;
+        export: string;
+    };
+    call(method: string, input: unknown): Promise<unknown>;
+    /** Deliver an event's payloads until it ends (`onEnd`); returns how to stop. */
+    subscribe(event: string, onEvent: (payload: unknown) => void, onEnd: () => void): () => void;
+}
 /** A mounted view, seen from the frame runtime's side. */
 export interface MountedView {
     resize(size: unknown): void;
@@ -32,6 +46,13 @@ export interface ModuleRuntime<S extends InterfaceMap, X extends InterfaceMap> {
     unbind(slot: string): void;
     /** A bound slot's provider came back after going away: its `onBind` handlers run again. */
     usable(slot: string): void;
+    /**
+     * A slot made at run time is bound. Given again for one already here, it is usable again (its
+     * provider came back): its events resume.
+     */
+    expose(slot: string, provider: ExposedProvider): void;
+    /** A slot made at run time is gone with its binding. */
+    unexpose(slot: string): void;
     /** Call an export's method for `caller`, the calling Actor as the Hub names it. */
     call(exportName: string, method: string, input: unknown, caller: string): Promise<unknown>;
     open(exportName: string, params: unknown, stream: Duplex): Promise<void>;