@agentorg/cli 0.0.5 → 0.0.6

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

@@ -1,753 +0,0 @@
-// src/errors.ts
-var BRAND = /* @__PURE__ */ Symbol.for("@agentorg/sdk/error");
-var isBranded = (value, name) => typeof value === "object" && value !== null && value[BRAND] === name;
-var instanceOf = (asked, base2, name, value) => (
-  // The name is given, not read from the class: a bundler may rename a class.
-  asked === base2 ? isBranded(value, name) : Function.prototype[Symbol.hasInstance].call(asked, value)
-);
-var NotConnected = class _NotConnected extends Error {
-  static [Symbol.hasInstance](value) {
-    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;
-  }
-};
-var Refused = class _Refused extends Error {
-  static [Symbol.hasInstance](value) {
-    return instanceOf(this, _Refused, "Refused", value);
-  }
-  name = "Refused";
-  code;
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-  }
-};
-var OutcomeUnknown = class _OutcomeUnknown extends Error {
-  static [Symbol.hasInstance](value) {
-    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 });
-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"
-  };
-}
-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);
-}
-
-// src/frame-protocol.ts
-var FRAME_HELLO = "frame/1";
-function isShellInterface(iface) {
-  return iface.kind === "rpc" && iface.name === "ui.shell" && iface.major === 1;
-}
-
-// src/module.ts
-function isFrameInterface(iface) {
-  return iface.kind === "rpc" && iface.name === "ui.view" && iface.major === 1;
-}
-var MODULE = "agentorg.module/1";
-function isModuleDefinition(value) {
-  return typeof value === "object" && value !== null && value.agentorg === MODULE;
-}
-
-// src/runtime.ts
-function check(schema, value, where, code = "invalid") {
-  const result = schema.safeParse(value);
-  if (result.success) return result.data;
-  const issue = result.error.issues[0];
-  throw new Refused(
-    code,
-    `${where}: ${issue ? `${issue.path.map(String).join(".") || "value"} ${issue.message}` : "invalid"}`
-  );
-}
-var NAME = /^[a-z][A-Za-z0-9_]*$/;
-var own = (record, key) => Object.hasOwn(record, key) ? record[key] : void 0;
-function createRuntime(definition, options) {
-  const slots = /* @__PURE__ */ new Map();
-  const exported = /* @__PURE__ */ new Map();
-  const slotHandle = (name, iface) => {
-    const state = { iface, binds: /* @__PURE__ */ new Set(), unbinds: /* @__PURE__ */ new Set(), listeners: /* @__PURE__ */ new Map() };
-    slots.set(name, state);
-    const provider = () => {
-      if (!state.binding) throw new NotConnected(name);
-      return state.binding.provider;
-    };
-    const base2 = {
-      get bound() {
-        return state.binding !== void 0;
-      },
-      onBind(fn) {
-        state.binds.add(fn);
-        return () => void state.binds.delete(fn);
-      },
-      onUnbind(fn) {
-        state.unbinds.add(fn);
-        return () => void state.unbinds.delete(fn);
-      }
-    };
-    switch (iface.kind) {
-      case "rpc":
-        return Object.assign(base2, {
-          call: Object.fromEntries(
-            Object.entries(iface.methods).map(([method, spec]) => [
-              method,
-              async (input) => {
-                const target2 = provider();
-                const parsed = check(spec.input, input, `${name}.${method} input`);
-                if (!target2.call)
-                  throw new Refused("unimplemented", `${name} isn't served by an rpc provider.`);
-                return check(
-                  spec.output,
-                  await target2.call(method, parsed),
-                  `${name}.${method} output`,
-                  "bad_output"
-                );
-              }
-            ])
-          ),
-          on(event, fn) {
-            if (!own(iface.events, event)) throw new TypeError(`${name} has no event ${event}.`);
-            const set = state.listeners.get(event) ?? /* @__PURE__ */ new Set();
-            state.listeners.set(event, set);
-            set.add(fn);
-            options.onListen?.(name, event);
-            return () => void set.delete(fn);
-          }
-        });
-      case "stream":
-        return Object.assign(base2, {
-          async open(params) {
-            const target2 = provider();
-            const parsed = check(iface.open, params, `${name} open`);
-            if (!target2.open)
-              throw new Refused("unimplemented", `${name} isn't served by a stream provider.`);
-            return target2.open(parsed);
-          }
-        });
-      case "http":
-        return Object.assign(base2, {
-          async fetch(request) {
-            const target2 = provider();
-            if (!target2.fetch)
-              throw new Refused("unimplemented", `${name} isn't served by an http provider.`);
-            return target2.fetch(request);
-          }
-        });
-    }
-  };
-  const exportHandle = (name, iface) => {
-    const state = { iface, withdrawn: false };
-    exported.set(name, state);
-    const live = () => {
-      if (state.withdrawn) throw new NotConnected(name);
-    };
-    const withdraw = () => {
-      if (state.withdrawn) return;
-      state.withdrawn = true;
-      options.onWithdraw?.(name);
-    };
-    const store = (impl) => {
-      live();
-      state.impl = impl;
-    };
-    if (isFrameInterface(iface)) return { implement: store, withdraw };
-    switch (iface.kind) {
-      case "rpc":
-        return {
-          implement: store,
-          emit(event, payload, emitting) {
-            live();
-            const spec = own(iface.events, event);
-            if (!spec) throw new TypeError(`${name} has no event ${event}.`);
-            options.onEmit(
-              name,
-              event,
-              check(spec.payload, payload, `${name}.${event} payload`),
-              emitting?.to
-            );
-          },
-          withdraw
-        };
-      case "stream":
-        return { accept: store, withdraw };
-      case "http":
-        return { serve: store, withdraw };
-    }
-  };
-  const target = (name, kind) => {
-    const state = exported.get(name);
-    if (!state || state.withdrawn) throw new NotConnected(name);
-    const frame2 = isFrameInterface(state.iface);
-    if (frame2 !== (kind === "frame") || !frame2 && state.iface.kind !== kind)
-      throw new TypeError(
-        `${name} isn't ${kind === "frame" ? "a ui.view@1" : `an ${kind}`} export.`
-      );
-    return state;
-  };
-  const implemented = (state, name) => {
-    if (state.impl === void 0)
-      throw new Refused("unimplemented", `${name} hasn't been implemented yet.`);
-    return state.impl;
-  };
-  const exposed = /* @__PURE__ */ new Map();
-  const exposedWatchers = /* @__PURE__ */ new Set();
-  const exposedChanged = () => {
-    const failed = (error) => options.log.error("An onExposed handler threw.", { error: String(error) });
-    for (const fn of [...exposedWatchers])
-      try {
-        const done = fn();
-        if (done instanceof Promise) done.catch(failed);
-      } catch (error) {
-        failed(error);
-      }
-  };
-  const listenExposed = (slot, state, event) => {
-    const entry = state.events.get(event);
-    if (state.gone || !entry || entry.stop || !entry.fns.size) return;
-    let ended = false;
-    let stop;
-    stop = state.source.subscribe(
-      event,
-      (payload) => {
-        for (const fn of [...entry.fns])
-          try {
-            fn(payload);
-          } catch (error) {
-            options.log.error("An event handler threw.", { slot, event, error: String(error) });
-          }
-      },
-      // Ended by the provider going: the interest stays for when it is usable again.
-      () => {
-        ended = true;
-        if (entry.stop === stop) entry.stop = void 0;
-      }
-    );
-    if (!ended) entry.stop = stop;
-  };
-  const exposedHandle = (slot, state) => {
-    const { described, provider } = state.source;
-    return Object.freeze({
-      slot,
-      described,
-      provider: Object.freeze({ actor: provider.actor, export: provider.export }),
-      call: Object.freeze(
-        Object.fromEntries(
-          (described.kind === "rpc" ? Object.keys(described.methods) : []).map((method) => [
-            method,
-            async (input) => {
-              if (state.gone) throw new NotConnected(slot);
-              return state.source.call(method, input);
-            }
-          ])
-        )
-      ),
-      on(event, fn) {
-        if (described.kind !== "rpc" || !own(described.events, event))
-          throw new TypeError(`${slot} has no event ${event}.`);
-        const entry = state.events.get(event) ?? { fns: /* @__PURE__ */ new Set() };
-        state.events.set(event, entry);
-        entry.fns.add(fn);
-        listenExposed(slot, state, event);
-        return () => {
-          entry.fns.delete(fn);
-          if (entry.fns.size) return;
-          entry.stop?.();
-          entry.stop = void 0;
-        };
-      }
-    });
-  };
-  const unexpose = (slot) => {
-    const state = exposed.get(slot);
-    if (!state) return;
-    exposed.delete(slot);
-    state.gone = true;
-    for (const entry of state.events.values()) {
-      entry.stop?.();
-      entry.stop = void 0;
-    }
-    exposedChanged();
-  };
-  const expose = (slot, source) => {
-    const here = exposed.get(slot);
-    if (here && here.source.described.hash === source.described.hash && here.source.provider.actor === source.provider.actor && here.source.provider.export === source.provider.export) {
-      here.source = source;
-      for (const [event, entry] of here.events) {
-        entry.stop?.();
-        entry.stop = void 0;
-        listenExposed(slot, here, event);
-      }
-      return;
-    }
-    if (here) unexpose(slot);
-    const state = { source, gone: false, events: /* @__PURE__ */ new Map() };
-    state.handle = exposedHandle(slot, state);
-    exposed.set(slot, state);
-    exposedChanged();
-  };
-  const ctx = {
-    slots: Object.fromEntries(
-      Object.entries(definition.slots).map(([name, iface]) => [name, slotHandle(name, iface)])
-    ),
-    exports: Object.assign(
-      Object.fromEntries(
-        Object.entries(definition.exports).map(([name, iface]) => [
-          name,
-          exportHandle(name, iface)
-        ])
-      ),
-      {
-        add(name, iface) {
-          if (!NAME.test(name) || name === "add")
-            throw new TypeError(`${JSON.stringify(name)} isn't a valid export name.`);
-          const existing = exported.get(name);
-          if (existing && !existing.withdrawn)
-            throw new TypeError(`An export named ${name} is already offered.`);
-          const handle = exportHandle(name, iface);
-          options.onAdd?.(name, iface, handle);
-          return handle;
-        }
-      }
-    ),
-    self: options.self,
-    log: options.log,
-    exposed: () => Object.freeze([...exposed.values()].map((state) => state.handle)),
-    onExposed(fn) {
-      exposedWatchers.add(fn);
-      return () => void exposedWatchers.delete(fn);
-    }
-  };
-  const serving = (exportName) => {
-    const state = target(exportName, "http");
-    const handler = implemented(
-      state,
-      exportName
-    );
-    return async (request) => handler(request);
-  };
-  const accepting = (exportName, params) => {
-    const state = target(exportName, "stream");
-    const parsed = check(state.iface.open, params, `${exportName} open`);
-    const handler = implemented(
-      state,
-      exportName
-    );
-    return async (stream) => {
-      await handler(parsed, stream);
-    };
-  };
-  const notify = (slot, handlers) => {
-    const failed = (error) => options.log.error("A slot handler threw.", { slot, error: String(error) });
-    for (const fn of [...handlers])
-      try {
-        const done = fn();
-        if (done instanceof Promise) done.catch(failed);
-      } catch (error) {
-        failed(error);
-      }
-  };
-  const unbind = (slot) => {
-    const state = slots.get(slot);
-    if (!state) throw new TypeError(`No slot ${slot}.`);
-    if (!state.binding) return;
-    state.binding = void 0;
-    notify(slot, state.unbinds);
-  };
-  return {
-    ctx,
-    async start() {
-      await definition.start(ctx);
-    },
-    bind(slot, provider) {
-      const state = slots.get(slot);
-      if (!state) throw new TypeError(`No slot ${slot}.`);
-      unbind(slot);
-      const binding = { provider };
-      state.binding = binding;
-      notify(slot, state.binds);
-      return {
-        emit(event, payload) {
-          const iface = state.iface;
-          const spec = iface.kind === "rpc" ? own(iface.events, event) : void 0;
-          if (!spec) throw new TypeError(`${slot} has no event ${event}.`);
-          const value = check(spec.payload, payload, `${slot}.${event}`, "bad_output");
-          if (state.binding !== binding) return;
-          for (const fn of [...state.listeners.get(event) ?? []]) fn(value);
-        }
-      };
-    },
-    unbind,
-    usable(slot) {
-      const state = slots.get(slot);
-      if (!state) throw new TypeError(`No slot ${slot}.`);
-      if (state.binding) notify(slot, state.binds);
-    },
-    expose,
-    unexpose,
-    async call(exportName, method, input, caller) {
-      const state = target(exportName, "rpc");
-      const spec = own(state.iface.methods, method);
-      if (!spec) throw new TypeError(`${exportName} has no method ${method}.`);
-      const parsed = check(spec.input, input, `${exportName}.${method} input`);
-      const handler = own(
-        implemented(state, exportName),
-        method
-      );
-      if (!handler)
-        throw new Refused("unimplemented", `${exportName}.${method} isn't implemented.`);
-      return check(
-        spec.output,
-        await handler(parsed, { caller }),
-        `${exportName}.${method} output`,
-        "bad_output"
-      );
-    },
-    accepting,
-    async open(exportName, params, stream) {
-      await accepting(exportName, params)(stream);
-    },
-    serving,
-    async fetch(exportName, request) {
-      return serving(exportName)(request);
-    },
-    mount(exportName, el, options2) {
-      const state = target(exportName, "frame");
-      const methods = state.iface.methods;
-      const parsed = check(methods.mount?.input, options2, `${exportName} mount`);
-      const view = implemented(state, exportName);
-      const cleanup = view.mount(el, parsed);
-      return {
-        resize(size) {
-          const { size: checked } = check(
-            methods.resize?.input,
-            { size },
-            `${exportName} resize`
-          );
-          view.resize?.(checked);
-        },
-        unmount() {
-          cleanup?.();
-        }
-      };
-    },
-    withdrawn(exportName) {
-      return exported.get(exportName)?.withdrawn ?? false;
-    }
-  };
-}
-
-// src/frame.ts
-function runFrame(options) {
-  const { port } = options;
-  const send = (message) => port.postMessage(message);
-  let nextId = 0;
-  const pending = /* @__PURE__ */ new Map();
-  const request = (message, target) => new Promise((resolve, reject) => {
-    const id = ++nextId;
-    pending.set(id, { resolve, reject, target });
-    send({ ...message, id });
-  });
-  let runtime;
-  let definition;
-  let loading = false;
-  let mounted;
-  const bindings = /* @__PURE__ */ new Map();
-  let early = /* @__PURE__ */ new Map();
-  const listened = /* @__PURE__ */ new Map();
-  const subscriptions = /* @__PURE__ */ 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) ?? /* @__PURE__ */ new Map();
-    listened.set(slot, events);
-    if (!events.has(event)) events.set(event, void 0);
-    if (!bindings.has(slot) || events.get(event) !== void 0) return;
-    const sub = ++nextId;
-    subscriptions.set(sub, { slot, event });
-    events.set(event, sub);
-    send({ op: "subscribe", sub, slot, event });
-  };
-  const stopAll = (slot, tell) => {
-    const events = listened.get(slot);
-    for (const [event, sub] of events ?? []) {
-      if (sub === void 0) continue;
-      subscriptions.delete(sub);
-      events?.set(event, void 0);
-      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] : void 0;
-    if (!runtime || !iface || isShellInterface(iface)) return;
-    if (!bound) {
-      bindings.delete(slot);
-      stopAll(slot, true);
-      return runtime.unbind(slot);
-    }
-    if (bindings.has(slot)) {
-      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
-            });
-            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 = void 0;
-            for (const [slot, isBound] of bound ?? []) if (isBound) onSlot(slot, true);
-          } catch (error) {
-            definition = void 0;
-            early = /* @__PURE__ */ 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 = void 0;
-          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": {
-        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, void 0);
-        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();
-    }
-  };
-}
-
-// src/frame-base.ts
-var 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; }
-`;
-
-// src/frame-entry.ts
-var self = globalThis;
-var frame;
-var 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) return;
-  frame = runFrame({
-    port,
-    root: self.document.body,
-    // A computed specifier: the bundler leaves it to the browser.
-    load: (src) => import(src),
-    theme(tokens) {
-      for (const [name, value] of Object.entries(tokens))
-        if (name.startsWith("--")) self.document.documentElement.style.setProperty(name, value);
-    }
-  });
-});
-self.addEventListener("error", (event) => frame?.failed(event.error ?? event.message));
-self.addEventListener("unhandledrejection", (event) => frame?.failed(event.reason));