@standardagents/code 0.14.1-issue.650.d27328-linux-x64-gnu → 0.14.1-issue.650.d27328

package/lib/standard-plugin-runner/worker.mjs

@@ -1,1561 +0,0 @@
-import { createRequire as __standardCreateRequire } from 'node:module'; import { fileURLToPath as __standardFileURLToPath } from 'node:url'; import { dirname as __standardDirname } from 'node:path'; const require = __standardCreateRequire(import.meta.url); const __filename = __standardFileURLToPath(import.meta.url); const __dirname = __standardDirname(__filename);
-
-// src/worker.mjs
-import { parentPort, workerData } from "node:worker_threads";
-import { pathToFileURL } from "node:url";
-
-// ../plugin-sdk/src/manifest.mjs
-var CAPABILITIES = Object.freeze([
-  "surfaces",
-  "events",
-  "hooks",
-  "panes",
-  "projects",
-  "notifications",
-  "url",
-  "fetch",
-  "secrets",
-  "webhook"
-]);
-var SURFACE_KINDS = Object.freeze([
-  "section",
-  "card",
-  "slot",
-  "badge",
-  "panel",
-  "overlay",
-  "menu",
-  "command",
-  "key",
-  "link"
-]);
-var PRESENTATIONS = Object.freeze(["popover", "column", "pane"]);
-var ANCHORS = Object.freeze([
-  "plugins",
-  "machine.before",
-  "machine.after",
-  "project.before",
-  "project.after",
-  "pane.header",
-  "pane.footer",
-  "account",
-  "machine",
-  "project",
-  "pane",
-  "section"
-]);
-var LIMITS = Object.freeze({
-  manifestBytes: 65536,
-  frameBytes: 262144,
-  responseFrameBytes: 64 * 1024 * 1024,
-  pendingRequests: 128,
-  subscriptions: 256,
-  schedules: 128,
-  contributions: 256,
-  queuedBytes: 4 * 1024 * 1024,
-  hookTimeoutMs: 6e4,
-  requestTimeoutMs: 3e4,
-  canvasColumns: 512,
-  canvasRows: 256,
-  canvasHoverBytes: 512,
-  stateKeys: 256,
-  stateValueBytes: 64 * 1024
-});
-var PluginError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.name = "PluginError";
-    this.code = code;
-  }
-};
-function ensure(condition, code, message) {
-  if (!condition) throw new PluginError(code, message);
-}
-function object(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function identifier(value) {
-  return typeof value === "string" && /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(value);
-}
-function jsonBytes(value, limit = LIMITS.frameBytes) {
-  const seen = /* @__PURE__ */ new Set();
-  function visit(item, depth) {
-    ensure(depth <= 32, "invalid_payload", "JSON nesting exceeds 32 levels");
-    if (item === null || typeof item === "string" || typeof item === "boolean") return;
-    if (typeof item === "number") {
-      ensure(Number.isFinite(item), "invalid_payload", "JSON numbers must be finite");
-      return;
-    }
-    ensure(object(item) || Array.isArray(item), "invalid_payload", "Payload must contain JSON values");
-    ensure(!seen.has(item), "invalid_payload", "Payload contains a cycle");
-    ensure(Array.isArray(item) || [Object.prototype, null].includes(Object.getPrototypeOf(item)), "invalid_payload", "Payload must contain plain objects");
-    seen.add(item);
-    for (const child of Object.values(item)) visit(child, depth + 1);
-    seen.delete(item);
-  }
-  visit(value, 0);
-  const text2 = JSON.stringify(value);
-  ensure(Buffer.byteLength(text2) <= limit, "payload_too_large", `Payload exceeds ${limit} bytes`);
-  return text2;
-}
-function freeze(value) {
-  if (value && typeof value === "object") {
-    Object.values(value).forEach(freeze);
-    Object.freeze(value);
-  }
-  return value;
-}
-function validateManifest(value) {
-  ensure(object(value), "invalid_manifest", "package.json must contain a standardPlugin object");
-  jsonBytes(value, LIMITS.manifestBytes);
-  const allowed = [
-    "apiVersion",
-    "id",
-    "name",
-    "version",
-    "entry",
-    "singleton",
-    "order",
-    "capabilities",
-    "contributions",
-    "configSchema",
-    "hookTimeoutMs"
-  ];
-  ensure(Object.keys(value).every((key) => allowed.includes(key)), "invalid_manifest", "Unknown manifest field");
-  const manifest = structuredClone({ singleton: false, order: 0, capabilities: [], contributions: [], hookTimeoutMs: 5e3, ...value });
-  ensure(manifest.apiVersion === 1, "incompatible_version", "Plugin requires a different SDK API version");
-  ensure(identifier(manifest.id), "invalid_manifest", "Plugin id must be a stable identifier");
-  ensure(
-    typeof manifest.name === "string" && manifest.name.trim().length > 0 && manifest.name.length <= 128,
-    "invalid_manifest",
-    "Plugin name is required and bounded to 128 characters"
-  );
-  ensure(
-    typeof manifest.version === "string" && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?$/.test(manifest.version),
-    "invalid_manifest",
-    "Plugin version must be semantic"
-  );
-  ensure(
-    typeof manifest.entry === "string" && manifest.entry.length <= 512 && !/[\\\u0000?#]/.test(manifest.entry) && !manifest.entry.startsWith("/") && manifest.entry.split("/").every((part) => part && part !== "..") && /\.(?:mjs|cjs|js|mts|ts)$/.test(manifest.entry),
-    "invalid_manifest",
-    "Plugin entry must be a relative JavaScript or TypeScript file"
-  );
-  ensure(
-    typeof manifest.singleton === "boolean" && Number.isSafeInteger(manifest.order) && Math.abs(manifest.order) <= 2147483647,
-    "invalid_manifest",
-    "Invalid singleton or order"
-  );
-  ensure(
-    Number.isSafeInteger(manifest.hookTimeoutMs) && manifest.hookTimeoutMs > 0 && manifest.hookTimeoutMs <= LIMITS.hookTimeoutMs,
-    "invalid_manifest",
-    "Hook timeout must be between 1 and 60000 ms"
-  );
-  ensure(Array.isArray(manifest.capabilities) && manifest.capabilities.every((item) => CAPABILITIES.includes(item)) && new Set(manifest.capabilities).size === manifest.capabilities.length, "invalid_manifest", "Unknown or repeated capability");
-  ensure(
-    Array.isArray(manifest.contributions) && manifest.contributions.length <= LIMITS.contributions,
-    "invalid_manifest",
-    "Too many contributions"
-  );
-  const ids = /* @__PURE__ */ new Set();
-  for (const declaration of manifest.contributions) {
-    ensure(object(declaration) && identifier(declaration.id) && !ids.has(declaration.id) && SURFACE_KINDS.includes(declaration.kind) && ANCHORS.includes(declaration.anchor), "invalid_manifest", "Invalid contribution declaration");
-    ids.add(declaration.id);
-    ensure(
-      declaration.icon === void 0 || ["card", "panel"].includes(declaration.kind) && typeof declaration.icon === "string" && /^[\uE000-\uF8FF\u{F0000}-\u{FFFFD}\u{100000}-\u{10FFFD}]$/u.test(declaration.icon),
-      "invalid_manifest",
-      "Card or panel icon must be one Nerd Font private-use glyph"
-    );
-    ensure(
-      declaration.border === void 0 || typeof declaration.border === "boolean" && declaration.kind === "card",
-      "invalid_manifest",
-      "Only sidebar cards declare a boolean border preference"
-    );
-    for (const [key, choices] of Object.entries({
-      merge: ["by-machine", "by-identity"],
-      width: ["full", "half"],
-      position: ["top", "after-open", "before-danger", "bottom"],
-      presentation: PRESENTATIONS
-    })) {
-      ensure(declaration[key] === void 0 || choices.includes(declaration[key]), "invalid_manifest", `Invalid contribution ${key}`);
-    }
-    for (const key of ["title", "group", "chord", "pattern", "actionId"]) {
-      ensure(
-        declaration[key] === void 0 || typeof declaration[key] === "string" && declaration[key].length <= 512,
-        "invalid_manifest",
-        `Invalid contribution ${key}`
-      );
-    }
-    ensure(declaration.opens === void 0 || identifier(declaration.opens), "invalid_manifest", "Invalid contribution opens");
-    ensure(
-      declaration.presentation === void 0 || ["panel", "card", "command"].includes(declaration.kind),
-      "invalid_manifest",
-      "Only panels, cards, and commands declare a presentation"
-    );
-    ensure(declaration.kind !== "card" || declaration.anchor === "plugins", "invalid_manifest", "Cards use the plugins anchor");
-  }
-  for (const declaration of manifest.contributions) {
-    ensure(
-      declaration.opens === void 0 || manifest.contributions.some((item) => item.id === declaration.opens && item.kind === "panel"),
-      "invalid_manifest",
-      "Contribution opens must name a declared panel"
-    );
-  }
-  ensure(!manifest.contributions.length || manifest.capabilities.includes("surfaces"), "invalid_manifest", "Contributions require surfaces capability");
-  ensure(manifest.configSchema === void 0 || object(manifest.configSchema), "invalid_manifest", "Configuration schema must be an object");
-  return freeze(manifest);
-}
-
-// ../plugin-sdk/src/protocol.mjs
-var RUNNER_PROTOCOL_VERSION = 1;
-var OPERATIONS = Object.freeze({
-  "pane.create": "panes",
-  "pane.close": "panes",
-  "pane.restart": "panes",
-  "pane.input": "panes",
-  "pane.focus": "panes",
-  "pane.wait": "panes",
-  "project.create": "projects",
-  "project.remove": "projects",
-  "notification.show": "notifications",
-  "url.open": "url",
-  fetch: "fetch",
-  "secret.get": "secrets",
-  "config.get": null,
-  "state.get": null,
-  "state.set": null,
-  "state.keys": null,
-  "panel.open": "surfaces",
-  "context.get": null,
-  "popover.open": "surfaces",
-  "canvas.write": "surfaces",
-  "remote.request": "surfaces",
-  "canvas.focus": "surfaces",
-  "subscription.add": null,
-  "subscription.remove": null,
-  "health.set": null,
-  "webhook.ack": "webhook"
-});
-var HOST_OPERATIONS = Object.freeze([
-  "runner.start",
-  "runner.stop",
-  "runner.reload",
-  "runner.diagnose",
-  "runner.ping",
-  "runtime.invoke",
-  "runtime.visibility"
-]);
-function authorize(operation, capabilities) {
-  ensure(
-    object(operation) && Object.hasOwn(OPERATIONS, operation.op) && object(operation.args),
-    "unsupported_operation",
-    "Unknown SDK operation or invalid arguments"
-  );
-  let capability = OPERATIONS[operation.op];
-  if (operation.op === "subscription.add") {
-    const { id, kind, name } = operation.args;
-    ensure(
-      identifier(id) && typeof name === "string" && name.length <= 256 && ["event", "hook", "action", "input", "select", "resize", "activate", "deactivate", "visibility"].includes(kind),
-      "invalid_payload",
-      "Invalid subscription"
-    );
-    capability = kind === "hook" ? "hooks" : kind === "event" ? name === "webhook" ? "webhook" : "events" : "surfaces";
-  }
-  ensure(!capability || capabilities.includes(capability), "capability_denied", `Operation requires ${capability} capability`);
-  jsonBytes(operation);
-}
-function validateProducer(producer) {
-  ensure(
-    object(producer) && identifier(producer.pluginId) && typeof producer.machineId === "string" && producer.machineId.length > 0 && producer.machineId.length <= 128 && typeof producer.epoch === "string" && /^(0|[1-9]\d{0,19})$/.test(producer.epoch) && BigInt(producer.epoch) <= 18446744073709551615n,
-    "invalid_payload",
-    "Invalid plugin producer identity"
-  );
-  return producer;
-}
-function sameProducer(a, b) {
-  return a.pluginId === b.pluginId && a.machineId === b.machineId && a.epoch === b.epoch;
-}
-function frameLimit(frame, inbound) {
-  return inbound && object(frame) && frame.kind === "response" ? LIMITS.responseFrameBytes : LIMITS.frameBytes;
-}
-function validateEnvelope(frame, { inbound = false } = {}) {
-  jsonBytes(frame, frameLimit(frame, inbound));
-  ensure(object(frame) && frame.version === RUNNER_PROTOCOL_VERSION, "incompatible_version", "Daemon and runner protocol versions differ");
-  validateProducer(frame.producer);
-  ensure(["request", "response", "cancel", "surface", "report"].includes(frame.kind), "invalid_payload", "Unknown runner frame kind");
-  if (frame.kind === "report") {
-    ensure(
-      identifier(frame.name) && object(frame.entity) && typeof frame.sequence === "string" && /^(0|[1-9]\d{0,19})$/.test(frame.sequence) && BigInt(frame.sequence) <= 18446744073709551615n && Number.isInteger(frame.schemaVersion) && frame.schemaVersion > 0 && frame.schemaVersion <= 65535 && Object.hasOwn(frame, "value") && frame.value !== void 0,
-      "invalid_payload",
-      "Invalid report replacement"
-    );
-  } else if (frame.kind === "surface") {
-    ensure(object(frame.key) && identifier(frame.key.contributionId) && typeof frame.sequence === "string" && /^(0|[1-9]\d{0,19})$/.test(frame.sequence) && BigInt(frame.sequence) <= 18446744073709551615n && Object.hasOwn(frame, "content"), "invalid_payload", "Invalid surface replacement");
-  } else {
-    ensure(typeof frame.id === "string" && frame.id.length > 0 && frame.id.length <= 128, "invalid_payload", "Missing correlation id");
-    if (frame.kind === "request") {
-      ensure(
-        object(frame.operation) && (Object.hasOwn(OPERATIONS, frame.operation.op) || HOST_OPERATIONS.includes(frame.operation.op)) && object(frame.operation.args) && Number.isSafeInteger(frame.timeoutMs) && frame.timeoutMs > 0 && frame.timeoutMs <= LIMITS.hookTimeoutMs,
-        "invalid_payload",
-        "Invalid runner request"
-      );
-    }
-    if (frame.kind === "response") {
-      ensure(
-        object(frame.result) && typeof frame.result.ok === "boolean" && (frame.result.ok ? Object.hasOwn(frame.result, "value") : object(frame.result.error) && typeof frame.result.error.code === "string" && typeof frame.result.error.message === "string"),
-        "invalid_payload",
-        "Invalid runner response"
-      );
-    }
-  }
-  return frame;
-}
-function wireError(error) {
-  return {
-    code: error instanceof PluginError ? error.code : "plugin_error",
-    message: String(error?.message ?? "Plugin operation failed").slice(0, 1024)
-  };
-}
-var realClock = Object.freeze({ now: () => Date.now(), setTimeout: (fn, ms) => setTimeout(fn, ms), clearTimeout: (id) => clearTimeout(id) });
-var RpcPeer = class {
-  constructor({ producer, send, clock = realClock, onRequest, onSurface, onReport, onError = () => {
-  }, idPrefix = "host" }) {
-    this.producer = Object.freeze({ ...validateProducer(producer) });
-    this.send = send;
-    this.clock = clock;
-    this.onRequest = onRequest;
-    this.onSurface = onSurface;
-    this.onReport = onReport;
-    this.onError = onError;
-    this.pending = /* @__PURE__ */ new Map();
-    this.incoming = /* @__PURE__ */ new Map();
-    this.nextId = 0;
-    this.idPrefix = idPrefix;
-    this.closed = false;
-  }
-  frame(kind, values) {
-    return { version: RUNNER_PROTOCOL_VERSION, producer: this.producer, kind, ...values };
-  }
-  transmit(frame) {
-    validateEnvelope(frame);
-    this.send(frame);
-  }
-  request(operation, { signal, timeoutMs = LIMITS.requestTimeoutMs } = {}) {
-    if (this.closed) return Promise.reject(new PluginError("disposed", "Plugin runtime is disposed"));
-    if (signal?.aborted) return Promise.reject(new PluginError("cancelled", "Request was cancelled"));
-    if (this.pending.size >= LIMITS.pendingRequests) return Promise.reject(new PluginError("queue_full", "Too many pending requests"));
-    const id = `${this.idPrefix}-${++this.nextId}`;
-    return new Promise((resolve2, reject) => {
-      let timer;
-      const finish = (error, value) => {
-        if (!this.pending.delete(id)) return;
-        this.clock.clearTimeout(timer);
-        signal?.removeEventListener("abort", cancel);
-        error ? reject(error) : resolve2(value);
-      };
-      const cancelWith = (code) => {
-        finish(new PluginError(code, code === "timeout" ? "Request deadline elapsed" : "Request was cancelled"));
-        try {
-          this.transmit(this.frame("cancel", { id }));
-        } catch (error) {
-          this.onError(error);
-        }
-      };
-      const cancel = () => cancelWith("cancelled");
-      this.pending.set(id, { finish });
-      signal?.addEventListener("abort", cancel, { once: true });
-      timer = this.clock.setTimeout(() => cancelWith("timeout"), timeoutMs);
-      try {
-        this.transmit(this.frame("request", { id, operation, timeoutMs }));
-      } catch (error) {
-        finish(error);
-      }
-    });
-  }
-  receive(frame) {
-    if (this.closed) return;
-    validateEnvelope(frame, { inbound: true });
-    ensure(sameProducer(frame.producer, this.producer), "stale_producer", "Frame belongs to another plugin instance");
-    if (frame.kind === "surface") {
-      this.onSurface?.(frame);
-      return;
-    }
-    if (frame.kind === "report") {
-      this.onReport?.(frame);
-      return;
-    }
-    if (frame.kind === "response") {
-      const result = frame.result;
-      this.pending.get(frame.id)?.finish(result.ok ? null : new PluginError(result.error.code, result.error.message), result.value);
-      return;
-    }
-    if (frame.kind === "cancel") {
-      this.incoming.get(frame.id)?.cancel();
-      return;
-    }
-    ensure(!this.incoming.has(frame.id), "duplicate_request", "Request id is still in flight");
-    const respond = (result) => {
-      if (!this.closed) {
-        try {
-          this.transmit(this.frame("response", { id: frame.id, result }));
-        } catch (error) {
-          this.onError(error);
-        }
-      }
-    };
-    if (this.incoming.size >= LIMITS.pendingRequests) {
-      respond({ ok: false, error: { code: "queue_full", message: "Too many incoming requests" } });
-      return;
-    }
-    const controller = new AbortController();
-    const cancel = () => {
-      controller.abort();
-      this.clock.clearTimeout(timer);
-    };
-    const timer = this.clock.setTimeout(() => {
-      cancel();
-      respond({ ok: false, error: { code: "timeout", message: "Handler deadline elapsed" } });
-    }, frame.timeoutMs);
-    this.incoming.set(frame.id, { cancel });
-    Promise.resolve().then(() => {
-      ensure(!controller.signal.aborted, "cancelled", "Request was cancelled");
-      ensure(typeof this.onRequest === "function", "unsupported_operation", "No request handler");
-      return this.onRequest(frame.operation, { signal: controller.signal, timeoutMs: frame.timeoutMs });
-    }).then((value) => {
-      if (!controller.signal.aborted) respond({ ok: true, value: value ?? null });
-    }, (error) => {
-      if (!controller.signal.aborted) respond({ ok: false, error: wireError(error) });
-    }).finally(() => {
-      this.clock.clearTimeout(timer);
-      this.incoming.delete(frame.id);
-    });
-  }
-  dispose() {
-    if (this.closed) return;
-    for (const [id, request] of this.pending) {
-      request.finish(new PluginError("disposed", "Plugin runtime was disposed"));
-      try {
-        this.transmit(this.frame("cancel", { id }));
-      } catch (error) {
-        this.onError(error);
-      }
-    }
-    this.closed = true;
-    for (const request of this.incoming.values()) request.cancel();
-  }
-};
-
-// ../plugin-sdk/src/view.mjs
-var VIEW_LIMITS = Object.freeze({
-  depth: 8,
-  nodes: 4096,
-  tableRows: 512,
-  tableColumns: 12,
-  items: 512,
-  logLines: 2048,
-  cardLines: 6,
-  actionValueBytes: 512
-});
-var TONES = Object.freeze(["ok", "info", "warn", "error", "muted", "accent", "pending", "bright"]);
-var WEIGHTS = ["normal", "bold", "dim"];
-var ALIGNS = ["start", "center", "end"];
-var FORBIDDEN = /[\u0000-\u001f\u007f-\u009f\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/;
-var invalid = (message) => ensure(false, "invalid_payload", message);
-function text(value, field) {
-  if (typeof value !== "string") invalid(`Plugin view ${field} must be a string`);
-  ensure(!FORBIDDEN.test(value), "invalid_payload", "Plugin view text contains a control or bidirectional character");
-}
-function optionalText(value, field) {
-  if (value !== void 0) text(value, field);
-}
-function choice(value, choices, field) {
-  ensure(value === void 0 || choices.includes(value), "invalid_payload", `Invalid plugin view ${field}`);
-}
-function tone(value) {
-  choice(value, TONES, "tone");
-}
-function integer(value, max, field) {
-  ensure(value === void 0 || Number.isInteger(value) && value >= 0 && value <= max, "invalid_payload", `Invalid plugin view ${field}`);
-}
-function flag(value, field) {
-  ensure(value === void 0 || typeof value === "boolean", "invalid_payload", `Invalid plugin view ${field}`);
-}
-function number(value) {
-  ensure(typeof value === "number" && Number.isFinite(value), "invalid_payload", "Plugin view number is not finite");
-}
-function list(value, field, optional = false) {
-  if (optional && value === void 0) return [];
-  ensure(Array.isArray(value), "invalid_payload", `Plugin view ${field} must be an array`);
-  return value;
-}
-function entries(value, field, optional, check) {
-  for (const item of list(value, field, optional)) {
-    ensure(object(item), "invalid_payload", `Plugin view ${field} must contain objects`);
-    check(item);
-  }
-}
-function bounded(value, field, limit, optional = false) {
-  const values = list(value, field, optional);
-  ensure(values.length <= limit, "invalid_payload", `Plugin view ${field} has more than ${limit} entries`);
-  return values;
-}
-function boundedEntries(value, field, check) {
-  entries(bounded(value, field, VIEW_LIMITS.items), field, false, check);
-}
-function spans(value, optional) {
-  entries(value, "spans", optional, (span) => {
-    text(span.text, "span text");
-    tone(span.tone);
-    choice(span.weight, WEIGHTS, "weight");
-    flag(span.mono, "mono");
-  });
-}
-function action(value, optional = true) {
-  if (optional && value === void 0) return;
-  ensure(object(value), "invalid_payload", "Plugin view action must be an object");
-  text(value.actionId, "action id");
-  optionalText(value.value, "action value");
-  optionalText(value.opens, "action opens");
-  if (value.agentPicker !== void 0) {
-    ensure(object(value.agentPicker), "invalid_payload", "Agent picker needs a project and machine");
-    text(value.agentPicker.machineId, "agent picker machine");
-    text(value.agentPicker.projectId, "agent picker project");
-  }
-}
-function meter(item) {
-  number(item.value);
-  number(item.max);
-  tone(item.tone);
-  optionalText(item.label, "label");
-}
-function children(node2, depth, count) {
-  for (const child of list(node2.children, "children", true)) walk(child, depth + 1, count);
-}
-var NODES = {
-  stack(node2, depth, count) {
-    integer(node2.gap, 255, "gap");
-    children(node2, depth, count);
-  },
-  row(node2, depth, count) {
-    choice(node2.align, ALIGNS, "align");
-    children(node2, depth, count);
-  },
-  divider(node2) {
-    optionalText(node2.label, "label");
-  },
-  text(node2) {
-    optionalText(node2.text, "text");
-    spans(node2.spans, true);
-    tone(node2.tone);
-    choice(node2.weight, WEIGHTS, "weight");
-    flag(node2.mono, "mono");
-  },
-  badge(node2) {
-    text(node2.label, "label");
-    tone(node2.tone);
-  },
-  dot(node2) {
-    tone(node2.tone);
-  },
-  progress: meter,
-  segments(node2) {
-    boundedEntries(node2.items, "items", meter);
-  },
-  card(node2, depth, count) {
-    optionalText(node2.title, "title");
-    optionalText(node2.footer, "footer");
-    tone(node2.tone);
-    action(node2.action);
-    action(node2.externalAction);
-    boundedEntries(node2.tags ?? [], "tags", (tag) => {
-      text(tag.label, "tag label");
-      tone(tag.tone);
-    });
-    children(node2, depth, count);
-  },
-  input(node2) {
-    text(node2.id, "id");
-    text(node2.value, "value");
-    optionalText(node2.placeholder, "placeholder");
-    action(node2.action, false);
-    integer(node2.maxLength, 4096, "maxLength");
-  },
-  stat(node2) {
-    text(node2.label, "label");
-    text(node2.value, "value");
-    tone(node2.tone);
-    optionalText(node2.hint, "hint");
-  },
-  kv(node2) {
-    boundedEntries(node2.items, "items", (item) => {
-      text(item.label, "label");
-      text(item.value, "value");
-      flag(item.mono, "mono");
-      flag(item.copy, "copy");
-    });
-  },
-  tabs(node2) {
-    text(node2.id, "id");
-    optionalText(node2.filters, "filters");
-    action(node2.action);
-    boundedEntries(node2.items, "items", (item) => {
-      text(item.id, "id");
-      text(item.label, "label");
-      optionalText(item.sublabel, "sublabel");
-      tone(item.tone);
-      integer(item.count, 4294967295, "count");
-      optionalText(item.tag, "tag");
-    });
-  },
-  select(node2) {
-    text(node2.id, "id");
-    text(node2.label, "label");
-    optionalText(node2.filters, "filters");
-    action(node2.action);
-    boundedEntries(node2.options, "options", (option) => {
-      text(option.id, "id");
-      text(option.label, "label");
-      optionalText(option.group, "group");
-      integer(option.count, 4294967295, "count");
-      optionalText(option.tag, "tag");
-    });
-  },
-  table(node2, depth, count) {
-    const columns = list(node2.columns, "columns");
-    const rows = list(node2.rows, "rows", true);
-    ensure(columns.length <= VIEW_LIMITS.tableColumns, "invalid_payload", "Plugin table has more than 12 columns");
-    ensure(rows.length <= VIEW_LIMITS.tableRows, "invalid_payload", "Plugin table has more than 512 rows");
-    text(node2.id, "id");
-    entries(columns, "columns", false, (column) => {
-      text(column.id, "column id");
-      optionalText(column.label, "column label");
-      if (column.width !== "fill") integer(column.width, 65535, "column width");
-      integer(column.maxWidth, 65535, "column maxWidth");
-      choice(column.align, ALIGNS, "align");
-      integer(column.priority, 255, "column priority");
-    });
-    entries(rows, "rows", false, (row) => {
-      text(row.id, "row id");
-      tone(row.tone);
-      spans(row.note, true);
-      for (const tag of bounded(row.tags, "tags", VIEW_LIMITS.items, true)) text(tag, "tag");
-      action(row.action);
-      ensure(row.cells === void 0 || object(row.cells), "invalid_payload", "Plugin table cells must be an object");
-      for (const [column, cell] of Object.entries(row.cells ?? {})) {
-        text(column, "cell column");
-        walk(cell, depth + 1, count);
-      }
-    });
-  },
-  log(node2) {
-    for (const line of bounded(node2.lines, "lines", VIEW_LIMITS.logLines)) text(line, "log line");
-  },
-  button(node2) {
-    text(node2.label, "label");
-    action(node2.action, false);
-    flag(node2.sticky, "sticky");
-  }
-};
-function walk(node2, depth, count) {
-  ensure(depth <= VIEW_LIMITS.depth, "invalid_payload", "Plugin view nests deeper than 8 nodes");
-  ensure(++count.nodes <= VIEW_LIMITS.nodes, "invalid_payload", "Plugin view has more than 4096 nodes");
-  ensure(object(node2) && typeof node2.type === "string", "invalid_payload", "Plugin view node requires a type");
-  if (Object.hasOwn(NODES, node2.type)) NODES[node2.type](node2, depth, count);
-}
-function visitActions(node2, visit) {
-  switch (node2.type) {
-    case "stack":
-    case "row":
-    case "card":
-      if (node2.type === "card") {
-        if (node2.action !== void 0) visit(node2.action);
-        if (node2.externalAction !== void 0) visit(node2.externalAction);
-      }
-      for (const child of node2.children ?? []) visitActions(child, visit);
-      break;
-    case "button":
-    case "input":
-      visit(node2.action);
-      break;
-    case "tabs":
-    case "select":
-      if (node2.action !== void 0) visit(node2.action);
-      break;
-    case "table":
-      for (const row of node2.rows ?? []) {
-        if (row.action !== void 0) visit(row.action);
-        for (const cell of Object.values(row.cells ?? {})) visitActions(cell, visit);
-      }
-      break;
-  }
-}
-var ONE_LINE = ["text", "badge", "dot", "progress", "segments", "stat", "divider"];
-var PANEL_ONLY = ["card", "kv", "tabs", "select", "table", "log", "button", "input"];
-function cardLines(node2) {
-  if (node2.type === "stack") {
-    const children2 = node2.children ?? [];
-    return children2.reduce((total, child) => total + cardLines(child), (node2.gap ?? 0) * Math.max(children2.length - 1, 0));
-  }
-  if (node2.type === "row") return (node2.children ?? []).reduce((tallest, child) => Math.max(tallest, cardLines(child)), 0);
-  if (ONE_LINE.includes(node2.type)) return 1;
-  ensure(!PANEL_ONLY.includes(node2.type), "invalid_payload", `A card view cannot contain a ${node2.type} node`);
-  return 0;
-}
-function validateView(root, { kind, manifest } = {}) {
-  walk(root, 1, { nodes: 0 });
-  jsonBytes(root, LIMITS.frameBytes);
-  visitActions(root, (action2) => {
-    ensure(identifier(action2.actionId), "invalid_payload", "Plugin view action id must be a plugin identifier");
-    ensure(
-      action2.value === void 0 || Buffer.byteLength(action2.value) <= VIEW_LIMITS.actionValueBytes,
-      "payload_too_large",
-      "Plugin view action value exceeds 512 bytes"
-    );
-    ensure(action2.opens === void 0 || identifier(action2.opens), "invalid_payload", "Plugin view action opens must be a plugin identifier");
-    ensure(
-      action2.opens === void 0 || !manifest || manifest.contributions.some((item) => item.id === action2.opens && item.kind === "panel"),
-      "invalid_payload",
-      "Plugin view action opens must name a declared panel"
-    );
-  });
-  if (kind === "card") {
-    ensure(cardLines(root) <= VIEW_LIMITS.cardLines, "payload_too_large", "A card view is taller than 6 lines");
-  }
-}
-function compact(value) {
-  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0));
-}
-var node = (type, fields) => compact({ type, ...fields });
-var ui = Object.freeze({
-  view: (root, { title } = {}) => compact({ kind: "view", root, title }),
-  action: (actionId, { value, opens, agentPicker } = {}) => compact({ actionId, value, opens, agentPicker }),
-  span: (value, { tone: tone2, weight, mono } = {}) => compact({ text: value, tone: tone2, weight, mono }),
-  stack: (items, { gap } = {}) => node("stack", { gap, children: items }),
-  row: (items, { align } = {}) => node("row", { children: items, align }),
-  divider: (label) => node("divider", { label }),
-  /** A string sets `text`; an array of spans sets `spans`. */
-  text: (content, { tone: tone2, weight, mono } = {}) => node("text", { ...Array.isArray(content) ? { spans: content.map(compact) } : { text: content }, tone: tone2, weight, mono }),
-  badge: (label, tone2) => node("badge", { label, tone: tone2 }),
-  dot: (tone2) => node("dot", { tone: tone2 }),
-  progress: (value, max, { tone: tone2, label } = {}) => node("progress", { value, max, tone: tone2, label }),
-  segments: (items) => node("segments", { items: items.map(compact) }),
-  card: (items, { title, tone: tone2, tags, action: action2, externalAction, footer } = {}) => node("card", { title, tone: tone2, tags, action: action2, externalAction, footer, children: items }),
-  stat: (label, value, { tone: tone2, hint } = {}) => node("stat", { label, value, tone: tone2, hint }),
-  kv: (items) => node("kv", { items: items.map(compact) }),
-  tabs: (id, items, { filters, action: action2 } = {}) => node("tabs", { id, items: items.map(compact), filters, action: action2 }),
-  select: (id, label, options, { filters, action: action2 } = {}) => node("select", { id, label, options: options.map(compact), filters, action: action2 }),
-  table: (id, columns, rows = []) => node("table", { id, columns: columns.map(compact), rows: rows.map(compact) }),
-  log: (lines) => node("log", { lines }),
-  /** `action` is an action object or an action id. */
-  button: (label, action2) => node("button", { label, action: typeof action2 === "string" ? { actionId: action2 } : action2 }),
-  input: (id, value, action2, { placeholder, maxLength } = {}) => node("input", { id, value, placeholder, maxLength, action: typeof action2 === "string" ? { actionId: action2 } : action2 })
-});
-
-// ../plugin-sdk/src/row-layout.mjs
-var forbidden = /[\u0000-\u001f\u007f-\u009f\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/;
-var validText = (v, n) => typeof v === "string" && Buffer.byteLength(v) <= n && !forbidden.test(v);
-var only = (v, keys) => Object.keys(v).every((key) => keys.includes(key));
-function validateRowLayout(layout) {
-  const valid = object(layout) && only(layout, ["projectTint", "fields"]) && (layout.projectTint === void 0 || typeof layout.projectTint === "boolean") && Array.isArray(layout.fields) && layout.fields.length > 0 && layout.fields.length <= 32;
-  ensure(valid, "invalid_payload", "Invalid row layout");
-  let bytes = 0;
-  for (const f of layout.fields) {
-    ensure(
-      object(f) && only(f, ["text", "icon", "fallback", "tone", "surface", "bold", "gap", "flex", "shrink"]) && validText(f.text, 2048) && (f.icon === void 0 || typeof f.icon === "string" && /^[\uE000-\uF8FF\u{F0000}-\u{FFFFD}\u{100000}-\u{10FFFD}]$/u.test(f.icon)) && (f.fallback === void 0 || validText(f.fallback, 16) && /^[\x20-\x7e]*$/.test(f.fallback)) && (f.tone === void 0 || ["muted", "ok", "error", "info", "warning", "project"].includes(f.tone)) && ["surface", "bold", "flex"].every((k) => f[k] === void 0 || typeof f[k] === "boolean") && (f.gap === void 0 || Number.isInteger(f.gap) && f.gap >= 0 && f.gap <= 8),
-      "invalid_payload",
-      "Invalid row field"
-    );
-    bytes += Buffer.byteLength(f.text);
-    if (f.shrink !== void 0) {
-      const s = f.shrink;
-      ensure(
-        object(s) && only(s, ["priority", "min", "mode"]) && Number.isInteger(s.priority) && s.priority >= 0 && s.priority <= 255 && Number.isInteger(s.min) && s.min >= 0 && s.min <= 2048 && ["start", "middle", "end", "hide"].includes(s.mode),
-        "invalid_payload",
-        "Invalid row shrink policy"
-      );
-    }
-  }
-  ensure(bytes <= 8192, "payload_too_large", "Row layout text exceeds 8192 bytes");
-}
-
-// ../plugin-sdk/src/runtime.mjs
-var always = Object.freeze({ kind: "always" });
-var menuPositions = ["top", "after-open", "before-danger", "bottom"];
-var entityKinds = ["account", "machine", "project", "pane", "section"];
-function boundedText(value, label, limit = 512) {
-  ensure(typeof value === "string" && value.trim().length > 0 && value.length <= limit && !/[\u0000-\u001f\u007f]/.test(value), "invalid_payload", `Invalid ${label}`);
-  return value;
-}
-var HOVER_FORBIDDEN = /[\u0000-\u001f\u007f-\u009f\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/;
-function validatePassiveText(value, limit = LIMITS.canvasHoverBytes, label = "canvas hover") {
-  if (typeof value === "string") {
-    ensure(
-      value.trim().length > 0 && !HOVER_FORBIDDEN.test(value),
-      "invalid_payload",
-      `Invalid ${label} text`
-    );
-    ensure(
-      Buffer.byteLength(value) <= limit,
-      "payload_too_large",
-      `${label} text exceeds ${limit} bytes`
-    );
-    return;
-  }
-  ensure(Array.isArray(value), "invalid_payload", `Invalid ${label} spans`);
-  ensure(value.length > 0, "invalid_payload", `${label} spans must contain text`);
-  ensure(value.length <= 32, "payload_too_large", `${label} spans exceed 32 spans`);
-  let text2 = "";
-  for (const span of value) {
-    ensure(object(span), "invalid_payload", `Invalid ${label} span`);
-    ensure(
-      typeof span.text === "string" && !HOVER_FORBIDDEN.test(span.text),
-      "invalid_payload",
-      `Invalid ${label} span text`
-    );
-    for (const field of ["foreground", "background"]) {
-      if (span[field] !== void 0) {
-        ensure(typeof span[field] === "string" && span[field].trim().length > 0 && !HOVER_FORBIDDEN.test(span[field]), "invalid_payload", `Invalid ${label} span ${field}`);
-        ensure(
-          Buffer.byteLength(span[field]) <= 64,
-          "payload_too_large",
-          `${label} span ${field} exceeds 64 bytes`
-        );
-      }
-    }
-    for (const field of ["bold", "italic", "underline"]) {
-      ensure(
-        span[field] === void 0 || typeof span[field] === "boolean",
-        "invalid_payload",
-        `Invalid ${label} span ${field}`
-      );
-    }
-    ensure(span.actionId === void 0, "invalid_payload", `${label} spans cannot contain actionId`);
-    text2 += span.text;
-  }
-  ensure(
-    text2.trim().length > 0 && !HOVER_FORBIDDEN.test(text2),
-    "invalid_payload",
-    `Invalid ${label} text`
-  );
-  ensure(
-    Buffer.byteLength(text2) <= limit,
-    "payload_too_large",
-    `${label} text exceeds ${limit} bytes`
-  );
-}
-function validateEntity(entity) {
-  ensure(object(entity) && entityKinds.includes(entity.kind), "invalid_payload", "Invalid registration entity");
-  boundedText(entity.id, "entity id", 128);
-  if (entity.machineId !== void 0) boundedText(entity.machineId, "machine id", 128);
-  if (entity.generation !== void 0) {
-    ensure(typeof entity.generation === "string" && /^(0|[1-9]\d{0,19})$/.test(entity.generation) && BigInt(entity.generation) <= 18446744073709551615n, "invalid_payload", "Invalid entity generation");
-  }
-  return {
-    kind: entity.kind,
-    id: entity.id,
-    ...entity.machineId !== void 0 ? { machineId: entity.machineId } : {},
-    ...entity.generation !== void 0 ? { generation: entity.generation } : {}
-  };
-}
-function validateChord(chord) {
-  boundedText(chord, "key chord", 128);
-  const presses = chord.split(" ");
-  const namedKeys = ["space", "enter", "esc", "tab", "backspace", "left", "right", "up", "down", "pageup", "pagedown", "home", "end"];
-  ensure(presses.length <= 2 && presses.every((press) => {
-    const parts = press.split("+");
-    const modifiers = parts.filter((part) => ["shift", "alt", "ctrl"].includes(part));
-    const keys = parts.filter((part) => !["shift", "alt", "ctrl"].includes(part));
-    return new Set(modifiers).size === modifiers.length && keys.length === 1 && (namedKeys.includes(keys[0]) || Array.from(keys[0]).length === 1);
-  }), "invalid_payload", "Invalid native key chord");
-  return chord;
-}
-function conditionKey(condition) {
-  return JSON.stringify([condition.kind, condition.contributionId ?? null, condition.entity ?? null]);
-}
-function validateCondition(condition) {
-  ensure(condition && ["always", "section-visible", "slot-visible", "panel-open"].includes(condition.kind) && (condition.kind === "always" || identifier(condition.contributionId)), "invalid_payload", "Invalid schedule condition");
-  return structuredClone(condition);
-}
-var CONTENT_KINDS = ["rows", "text", "badge", "canvas", "view"];
-function acceptsContent(kind, content) {
-  if (["menu", "command", "key", "link"].includes(kind)) return false;
-  if (kind === "badge") return content.kind === "badge";
-  if (content.kind === "badge") return false;
-  return content.kind !== "view" || ["section", "card", "panel"].includes(kind);
-}
-function validateContent(content, declaration, manifest) {
-  const { kind } = declaration;
-  ensure(object(content) && CONTENT_KINDS.includes(content.kind), "invalid_payload", "Invalid surface content");
-  ensure(acceptsContent(kind, content), "invalid_payload", `A ${kind} contribution cannot show ${content.kind} content`);
-  if (content.kind === "view") {
-    validateView(content.root, { kind: declaration.kind, manifest });
-    if (content.title !== void 0) {
-      ensure(["card", "panel"].includes(kind) && Array.isArray(content.title), "invalid_payload", "Styled titles belong to card or panel views");
-      validatePassiveText(content.title, 512, "card title");
-    }
-  }
-  if (content.kind === "rows") {
-    for (const row of content.rows ?? []) if (row.layout !== void 0) {
-      ensure(["pane.header", "pane.footer"].includes(declaration.anchor), "invalid_payload", "Row layouts require a pane header or footer");
-      validateRowLayout(row.layout);
-    }
-  }
-  jsonBytes(content);
-  if (content.kind === "canvas") {
-    const { columns, rows, shade = 0, hover, themeColors, titleRight } = content.canvas ?? {};
-    ensure(Number.isSafeInteger(columns) && columns > 0 && columns <= LIMITS.canvasColumns && Number.isSafeInteger(rows) && rows > 0 && rows <= LIMITS.canvasRows && Number.isFinite(shade) && shade >= 0 && shade <= 1, "invalid_payload", "Invalid canvas dimensions or shade");
-    if (themeColors !== void 0) {
-      ensure(object(themeColors) && Object.keys(themeColors).length <= 32, "invalid_payload", "Invalid canvas theme colors");
-      for (const [index, recipe] of Object.entries(themeColors)) {
-        ensure(
-          /^(0|[1-9][0-9]{0,2})$/.test(index) && Number(index) <= 255 && object(recipe) && Object.keys(recipe).every((key) => ["source", "mix", "opacity"].includes(key)) && ["source", "mix"].every((key) => recipe[key] === void 0 || Number.isInteger(recipe[key]) && recipe[key] >= 0 && recipe[key] < 16) && Number.isFinite(recipe.opacity) && recipe.opacity >= 0 && recipe.opacity <= 1,
-          "invalid_payload",
-          "Invalid canvas theme color recipe"
-        );
-      }
-    }
-    if (titleRight !== void 0) {
-      ensure(declaration.kind === "card" && typeof titleRight === "string", "invalid_payload", "Canvas titleRight requires a card and string");
-      validatePassiveText(titleRight, 512, "card header");
-    }
-    if (hover !== void 0) validatePassiveText(hover);
-  }
-}
-function createRuntime({ manifest: input, producer, send, clock = realClock, onError = () => {
-}, instanceId = "0" }) {
-  const manifest = validateManifest(input);
-  ensure(producer.pluginId === manifest.id, "identity_mismatch", "Manifest and producer ids differ");
-  const lifetime = new AbortController();
-  const subscriptions = /* @__PURE__ */ new Map();
-  const schedules = /* @__PURE__ */ new Set();
-  const cleanups = /* @__PURE__ */ new Set();
-  const publishers = /* @__PURE__ */ new Map();
-  const reports = /* @__PURE__ */ new Map();
-  let visibility = /* @__PURE__ */ new Set();
-  let counter = 0;
-  let sequence = 0n;
-  let disposal;
-  ensure(identifier(instanceId), "invalid_payload", "Invalid runtime instance id");
-  const peer = new RpcPeer({ producer, send, clock, onError, idPrefix: "sdk", onRequest: async (operation, options) => {
-    if (operation.op === "runtime.visibility") {
-      ensure(
-        Array.isArray(operation.args.conditions) && operation.args.conditions.length <= LIMITS.contributions,
-        "invalid_payload",
-        "Invalid visibility snapshot"
-      );
-      visibility = new Set(operation.args.conditions.map((condition) => conditionKey(validateCondition(condition))));
-      for (const schedule2 of schedules) schedule2.visibilityChanged(visibility);
-      return null;
-    }
-    ensure(operation.op === "runtime.invoke", "unsupported_operation", "Unsupported worker operation");
-    const subscription = subscriptions.get(operation.args.subscriptionId);
-    ensure(subscription, "subscription_missing", "Subscription was disposed");
-    if (subscription.condition.kind !== "always" && !visibility.has(conditionKey(subscription.condition))) return null;
-    const result = await subscription.handler(operation.args.event, { signal: options.signal });
-    if (subscription.kind === "hook") {
-      ensure(result && ["proceed", "cancel"].includes(result.decision), "invalid_payload", "Hook must return proceed or cancel");
-    }
-    return result ?? null;
-  } });
-  function active() {
-    ensure(!lifetime.signal.aborted, "disposed", "Plugin runtime is disposed");
-  }
-  function request(op, args, options) {
-    try {
-      active();
-      authorize({ op, args }, manifest.capabilities);
-    } catch (error) {
-      onError(error);
-      return Promise.reject(error);
-    }
-    return peer.request({ op, args }, options);
-  }
-  function publish(kind, id, entity) {
-    active();
-    ensure(manifest.capabilities.includes("surfaces"), "capability_denied", "Publishing requires surfaces capability");
-    const declaration = manifest.contributions.find((item) => item.id === id);
-    ensure(
-      declaration && (!kind || declaration.kind === kind) && ANCHORS.includes(declaration.anchor),
-      "contribution_missing",
-      "Surface must match its static contribution declaration"
-    );
-    const key = { contributionId: id, anchor: declaration.anchor, ...entity ? { entity: structuredClone(entity) } : {} };
-    const identity = JSON.stringify(key);
-    ensure(!publishers.has(identity), "duplicate_contribution", "Contribution publisher exists");
-    ensure(publishers.size < LIMITS.contributions, "queue_full", "Too many contribution publishers");
-    let disposed = false;
-    const replace = (content) => {
-      active();
-      ensure(!disposed, "disposed", "Contribution publisher is disposed");
-      if (content !== null) validateContent(content, declaration, manifest);
-      peer.transmit(peer.frame("surface", { key, sequence: String(++sequence), content }));
-    };
-    const publisher = { replace, clear: () => replace(null), dispose() {
-      if (disposed) return;
-      try {
-        if (!lifetime.signal.aborted) replace(null);
-      } finally {
-        disposed = true;
-        publishers.delete(identity);
-      }
-    } };
-    publishers.set(identity, publisher);
-    return { publisher, key };
-  }
-  function report(name, entity) {
-    active();
-    ensure(
-      manifest.capabilities.includes("surfaces") && identifier(name),
-      "capability_denied",
-      "Reports require surfaces capability and a valid name"
-    );
-    const owner = validateEntity(entity);
-    ensure(
-      ["account", "machine", "project", "pane"].includes(owner.kind),
-      "invalid_payload",
-      "Reports need an owned entity"
-    );
-    if (owner.kind === "machine") {
-      ensure(
-        owner.id === producer.machineId && (owner.machineId === void 0 || owner.machineId === producer.machineId),
-        "invalid_payload",
-        "Report machine must be the local machine"
-      );
-    }
-    if (owner.kind === "project" || owner.kind === "pane") {
-      ensure(
-        owner.machineId === producer.machineId && owner.generation !== void 0 && owner.generation !== "0",
-        "invalid_payload",
-        "Report entity needs its local machine and generation"
-      );
-    }
-    const key = JSON.stringify([name, owner]);
-    ensure(
-      !reports.has(key) && reports.size < LIMITS.contributions,
-      "queue_full",
-      "Report publisher exists or capacity is full"
-    );
-    let disposed = false;
-    const sendReport = (value, schemaVersion) => {
-      active();
-      ensure(!disposed, "disposed", "Report publisher is disposed");
-      ensure(
-        Number.isInteger(schemaVersion) && schemaVersion > 0 && schemaVersion <= 65535,
-        "invalid_payload",
-        "Invalid report schema version"
-      );
-      if (value !== null) jsonBytes(value);
-      peer.transmit(peer.frame("report", {
-        name,
-        entity: owner,
-        sequence: String(++sequence),
-        schemaVersion,
-        value
-      }));
-    };
-    const publisher = {
-      replace: (value, schemaVersion = 1) => {
-        ensure(value !== null && value !== void 0, "invalid_payload", "Report value is required");
-        sendReport(value, schemaVersion);
-      },
-      clear: () => sendReport(null, 1),
-      dispose() {
-        if (disposed) return;
-        try {
-          if (!lifetime.signal.aborted) sendReport(null, 1);
-        } finally {
-          disposed = true;
-          reports.delete(key);
-        }
-      }
-    };
-    reports.set(key, publisher);
-    return publisher;
-  }
-  function subscribe(kind, name, handler, condition = always, registration) {
-    active();
-    ensure(typeof handler === "function", "invalid_payload", "Subscription requires a handler");
-    ensure(subscriptions.size < LIMITS.subscriptions, "queue_full", "Too many subscriptions");
-    condition = validateCondition(condition);
-    const id = `subscription-${instanceId}-${++counter}`;
-    const args = { id, kind, name, condition, ...registration ? { registration } : {} };
-    authorize({ op: "subscription.add", args }, manifest.capabilities);
-    const entry = { kind, handler, condition, registration };
-    subscriptions.set(id, entry);
-    let disposed = false;
-    let updating = false;
-    const remove = () => {
-      if (!lifetime.signal.aborted) request("subscription.remove", { id }).catch(onError);
-    };
-    const ready = request("subscription.add", args);
-    ready.then(() => {
-      if (disposed) remove();
-    }, (error) => {
-      disposed = true;
-      subscriptions.delete(id);
-      remove();
-      onError(error);
-    });
-    const subscription = { ready, dispose() {
-      if (disposed) return;
-      disposed = true;
-      subscriptions.delete(id);
-      remove();
-    } };
-    if (registration?.kind === "key") subscription.update = async (chord, options) => {
-      active();
-      ensure(!disposed, "disposed", "Key registration is disposed");
-      validateChord(chord);
-      ensure(!updating, "request_in_flight", "A key registration update is pending");
-      updating = true;
-      try {
-        await ready;
-        active();
-        ensure(!disposed, "disposed", "Key registration is disposed");
-        const next = { ...entry.registration, chord };
-        await request("subscription.add", { ...args, registration: next }, options);
-        if (!disposed) entry.registration = next;
-        return null;
-      } finally {
-        updating = false;
-        if (disposed) remove();
-      }
-    };
-    return subscription;
-  }
-  function prepareRegistration(kind, id, options, handler) {
-    active();
-    if (typeof options === "function" && handler === void 0) {
-      handler = options;
-      options = {};
-    }
-    ensure(identifier(id) && object(options) && typeof handler === "function", "invalid_payload", "Invalid contribution registration");
-    jsonBytes(options, LIMITS.manifestBytes);
-    const declaration = manifest.contributions.find((item) => item.id === id && item.kind === kind);
-    ensure(declaration, "contribution_missing", "Registration must match its static contribution declaration");
-    const actionId = options.actionId ?? declaration.actionId ?? id;
-    ensure(identifier(actionId), "invalid_payload", "Invalid registration action id");
-    const registration = {
-      contributionId: id,
-      kind,
-      anchor: declaration.anchor,
-      actionId,
-      title: boundedText(options.title ?? declaration.title ?? id, "registration title"),
-      ...options.entity !== void 0 ? { entity: validateEntity(options.entity) } : {}
-    };
-    if (kind === "menu") {
-      registration.position = options.position ?? declaration.position ?? "bottom";
-      ensure(menuPositions.includes(registration.position), "invalid_payload", "Invalid menu position");
-    } else if (kind === "command") {
-      const group = options.group ?? declaration.group;
-      if (group !== void 0) registration.group = boundedText(group, "command group");
-    } else if (kind === "key") {
-      registration.chord = validateChord(options.chord ?? declaration.chord);
-    } else if (kind === "link") {
-      registration.pattern = boundedText(options.pattern ?? declaration.pattern, "link pattern");
-    }
-    const condition = validateCondition(options.condition ?? always);
-    if (condition.entity !== void 0) condition.entity = validateEntity(condition.entity);
-    jsonBytes({ registration, condition }, LIMITS.manifestBytes);
-    const invoke = async (event, context2) => {
-      ensure(object(event) && event.actionId === actionId, "invalid_payload", "Invalid registered action selection");
-      if (event.entity !== void 0) validateEntity(event.entity);
-      if (kind === "link") boundedText(event.url, "link URL", 8192);
-      const result = await handler(event, context2);
-      if (kind === "link") ensure(typeof result === "boolean", "invalid_payload", "Link handlers must return a boolean");
-      return result;
-    };
-    return { registration, handler: invoke, condition };
-  }
-  const registrationKey = (registration) => JSON.stringify([registration.contributionId, registration.entity ?? null]);
-  function registerPrepared({ registration, handler, condition }) {
-    const identity = registrationKey(registration);
-    ensure(
-      ![...subscriptions.values()].some((entry) => entry.registration && registrationKey(entry.registration) === identity),
-      "duplicate_contribution",
-      "Contribution registration exists"
-    );
-    return subscribe("action", registration.actionId, handler, condition, registration);
-  }
-  function commandGroup(group, commands) {
-    active();
-    boundedText(group, "command group");
-    ensure(Array.isArray(commands) && commands.length > 0 && commands.length <= LIMITS.contributions && subscriptions.size + commands.length <= LIMITS.subscriptions, "queue_full", "Invalid or excessive group commands");
-    const prepared = commands.map((command) => {
-      ensure(object(command), "invalid_payload", "Invalid group command");
-      const { id, handler, ...options } = command;
-      return prepareRegistration("command", id, { ...options, group }, handler);
-    });
-    const identities = new Set([...subscriptions.values()].filter((entry) => entry.registration).map((entry) => registrationKey(entry.registration)));
-    for (const { registration } of prepared) {
-      const identity = registrationKey(registration);
-      ensure(!identities.has(identity), "duplicate_contribution", "Contribution registration exists");
-      identities.add(identity);
-    }
-    const members = [];
-    const dispose = () => {
-      for (const member of members) member.dispose();
-    };
-    try {
-      for (const item of prepared) members.push(registerPrepared(item));
-    } catch (error) {
-      dispose();
-      throw error;
-    }
-    const ready = Promise.all(members.map((member) => member.ready)).then(() => null);
-    ready.catch(dispose);
-    return { ready, dispose };
-  }
-  function schedule(intervalMs, handler, { condition = always, immediate = false } = {}) {
-    active();
-    ensure(
-      Number.isFinite(intervalMs) && intervalMs >= 1e3 / 30 && intervalMs <= 2147483647,
-      "invalid_payload",
-      "Schedule interval must be between 1000/30 and 2147483647 ms"
-    );
-    ensure(typeof handler === "function" && schedules.size < LIMITS.schedules, "queue_full", "Invalid or excessive schedules");
-    condition = validateCondition(condition);
-    const interest = condition.kind === "always" ? null : subscribe("visibility", condition.contributionId, () => {
-    }, condition);
-    const conditionIdentity = conditionKey(condition);
-    const controller = new AbortController();
-    let activeRun = null;
-    let timer;
-    const beginRun = () => {
-      const runController = new AbortController();
-      const cancelFromSchedule = () => runController.abort();
-      const cancelFromLifetime = () => runController.abort();
-      controller.signal.addEventListener("abort", cancelFromSchedule, { once: true });
-      lifetime.signal.addEventListener("abort", cancelFromLifetime, { once: true });
-      const run = {
-        controller: runController,
-        finish() {
-          controller.signal.removeEventListener("abort", cancelFromSchedule);
-          lifetime.signal.removeEventListener("abort", cancelFromLifetime);
-          if (activeRun?.controller === runController) activeRun = null;
-        }
-      };
-      activeRun = run;
-      return run;
-    };
-    const tick = async () => {
-      if (controller.signal.aborted || lifetime.signal.aborted) return;
-      const visible = condition.kind === "always" || visibility.has(conditionIdentity);
-      if (!visible) {
-        timer = clock.setTimeout(tick, intervalMs);
-        return;
-      }
-      const run = beginRun();
-      try {
-        await handler({ signal: run.controller.signal });
-      } catch (error) {
-        if (!run.controller.signal.aborted || condition.kind === "always") onError(error);
-      } finally {
-        run.finish();
-      }
-      if (!controller.signal.aborted && !lifetime.signal.aborted) timer = clock.setTimeout(tick, intervalMs);
-    };
-    const disposable = {
-      visibilityChanged(nextVisibility) {
-        if (condition.kind !== "always" && !nextVisibility.has(conditionIdentity)) activeRun?.controller.abort();
-      },
-      dispose() {
-        controller.abort();
-        activeRun?.controller.abort();
-        clock.clearTimeout(timer);
-        interest?.dispose();
-        schedules.delete(disposable);
-      }
-    };
-    schedules.add(disposable);
-    timer = clock.setTimeout(tick, immediate ? 0 : intervalMs);
-    return disposable;
-  }
-  const method = (op) => (args, options) => request(op, args, options);
-  const context = Object.freeze({
-    manifest,
-    producer: peer.producer,
-    signal: lifetime.signal,
-    request,
-    ...Object.fromEntries(["section", "card", "slot", "badge", "panel", "overlay"].map((kind) => [
-      kind,
-      (id, entity) => publish(kind, id, entity).publisher
-    ])),
-    report,
-    remote: Object.freeze({ request(remoteReport, operation, payload, options) {
-      active();
-      ensure(object(remoteReport) && object(remoteReport.source), "invalid_payload", "A current source report is required");
-      const source = validateProducer(remoteReport.source.producer);
-      ensure(
-        source.pluginId === manifest.id && identifier(remoteReport.name) && identifier(operation),
-        "invalid_payload",
-        "Invalid remote report request"
-      );
-      const entity = validateEntity(remoteReport.entity);
-      ensure(typeof remoteReport.sequence === "string" && /^(0|[1-9]\d{0,19})$/.test(remoteReport.sequence) && BigInt(remoteReport.sequence) > 0n, "invalid_payload", "Invalid report sequence");
-      jsonBytes(payload, 224 * 1024);
-      return request("remote.request", {
-        source,
-        name: remoteReport.name,
-        entity,
-        sequence: remoteReport.sequence,
-        operation,
-        payload
-      }, options);
-    } }),
-    canvas(id, spec, entity) {
-      const { publisher, key } = publish(null, id, entity);
-      try {
-        publisher.replace({ kind: "canvas", canvas: spec });
-      } catch (error) {
-        publisher.dispose();
-        throw error;
-      }
-      return {
-        ...publisher,
-        write: (ansi, options) => request("canvas.write", { key, ansi }, options),
-        focus: (capture, options) => request("canvas.focus", { key, capture }, options)
-      };
-    },
-    ...Object.fromEntries(["Event", "Hook", "Action", "Input", "Select", "Resize", "Activate", "Deactivate"].map((name) => [`on${name}`, (event, handler, condition) => subscribe(name.toLowerCase(), event, handler, condition)])),
-    ...Object.fromEntries(["menu", "command", "key", "link"].map((kind) => [
-      kind,
-      (id, options, handler) => registerPrepared(prepareRegistration(kind, id, options, handler))
-    ])),
-    commandGroup,
-    schedule,
-    onDispose(cleanup) {
-      active();
-      ensure(typeof cleanup === "function" && cleanups.size < LIMITS.subscriptions, "queue_full", "Invalid or excessive cleanup callbacks");
-      cleanups.add(cleanup);
-      return { dispose: () => {
-        cleanups.delete(cleanup);
-      } };
-    },
-    panes: Object.freeze(Object.fromEntries(["create", "close", "restart", "input", "focus", "wait"].map((name) => [name, method(`pane.${name}`)]))),
-    projects: Object.freeze({ create: method("project.create"), remove: method("project.remove") }),
-    notifications: Object.freeze({ show: method("notification.show") }),
-    panels: Object.freeze({ open: (contributionId, options) => request("panel.open", { contributionId }, options) }),
-    url: Object.freeze({ open: (url, options) => request("url.open", { url }, options) }),
-    fetch: method("fetch"),
-    secrets: Object.freeze({ get: (name, options) => request("secret.get", { name }, options) }),
-    config: Object.freeze({ get: (options) => request("config.get", {}, options) }),
-    state: Object.freeze({
-      get: (key, options) => request("state.get", { key }, options),
-      set: (key, value, options) => request("state.set", { key, value }, options),
-      keys: (options) => request("state.keys", {}, options)
-    }),
-    context: Object.freeze({ get: (options) => request("context.get", {}, options) }),
-    popover: Object.freeze({ open: method("popover.open") }),
-    health: Object.freeze({ set: method("health.set") }),
-    webhook: Object.freeze({ ack: (deliveryId, options) => request("webhook.ack", { deliveryId }, options) })
-  });
-  return {
-    context,
-    receive: (frame) => peer.receive(frame),
-    async activate(definition) {
-      active();
-      ensure(definition?.id === manifest.id && typeof definition.activate === "function", "identity_mismatch", "Runtime plugin must match static manifest id");
-      const cleanup = await definition.activate(context);
-      if (typeof cleanup === "function") {
-        if (lifetime.signal.aborted) await cleanup();
-        else context.onDispose(cleanup);
-      }
-    },
-    dispose() {
-      if (disposal) return disposal;
-      for (const publisher of publishers.values()) {
-        try {
-          publisher.dispose();
-        } catch (error) {
-          onError(error);
-        }
-      }
-      for (const publisher of reports.values()) {
-        try {
-          publisher.dispose();
-        } catch (error) {
-          onError(error);
-        }
-      }
-      lifetime.abort();
-      for (const disposable of schedules) disposable.dispose();
-      peer.dispose();
-      subscriptions.clear();
-      disposal = Promise.allSettled([...cleanups].reverse().map((cleanup) => Promise.resolve().then(cleanup))).then((results) => {
-        for (const result of results) if (result.status === "rejected") onError(result.reason);
-        cleanups.clear();
-      });
-      return disposal;
-    }
-  };
-}
-
-// src/prepare.mjs
-import { constants } from "node:fs";
-import { open, realpath, stat } from "node:fs/promises";
-import { createHash } from "node:crypto";
-import { isAbsolute, join, relative, resolve, sep } from "node:path";
-function contained(root, path) {
-  const part = relative(root, path);
-  return part !== ".." && !part.startsWith(`..${sep}`) && !isAbsolute(part);
-}
-async function inspectPlugin(root) {
-  ensure(typeof root === "string" && isAbsolute(root), "invalid_source", "Plugin root must be absolute");
-  root = await realpath(root);
-  const file = await open(join(root, "package.json"), constants.O_RDONLY | constants.O_NOFOLLOW);
-  let source;
-  try {
-    const metadata = await file.stat();
-    ensure(metadata.isFile() && metadata.size > 0 && metadata.size <= LIMITS.manifestBytes, "invalid_manifest", "Package metadata exceeds its size limit");
-    const buffer = Buffer.alloc(LIMITS.manifestBytes + 1);
-    let size = 0;
-    while (size < buffer.length) {
-      const read = await file.read(buffer, size, buffer.length - size, size);
-      if (!read.bytesRead) break;
-      size += read.bytesRead;
-    }
-    ensure(size <= LIMITS.manifestBytes, "invalid_manifest", "Package metadata exceeds its size limit");
-    source = buffer.subarray(0, size).toString("utf8");
-  } finally {
-    await file.close();
-  }
-  const packageMetadata = JSON.parse(source);
-  const manifest = validateManifest(packageMetadata.standardPlugin);
-  const entry = await realpath(resolve(root, manifest.entry));
-  ensure(contained(root, entry) && (await stat(entry)).isFile(), "invalid_source", "Plugin entry must remain inside its source directory");
-  const manifestDigest = createHash("sha256").update(source).digest("hex");
-  return Object.freeze({ root, entry, manifest, manifestDigest });
-}
-async function preparePlugin({ root, manifestDigest, capabilities }) {
-  const prepared = await inspectPlugin(root);
-  ensure(prepared.manifestDigest === manifestDigest, "manifest_changed", "Plugin metadata changed after preparation or consent");
-  ensure(
-    Array.isArray(capabilities) && prepared.manifest.capabilities.every((capability) => capabilities.includes(capability)),
-    "consent_required",
-    "Plugin capabilities require installation consent"
-  );
-  return prepared;
-}
-
-// src/channel.mjs
-var framed = (message) => message?.type === "frame" ? message.frame : message;
-var Outbox = class {
-  constructor(write) {
-    this.write = write;
-    this.queue = [];
-    this.bytes = 0;
-    this.closed = false;
-  }
-  push(message) {
-    ensure(!this.closed, "disposed", "Output channel is closed");
-    const frame = framed(message);
-    const serialized = jsonBytes(message, frameLimit(frame, true));
-    const size = Buffer.byteLength(serialized);
-    const key = frame.kind === "surface" ? JSON.stringify(["surface", frame.producer, frame.key]) : frame.kind === "report" ? JSON.stringify(["report", frame.producer, frame.name, frame.entity]) : null;
-    const previous = key === null ? -1 : this.queue.findIndex((item2) => item2.key === key);
-    const replaced = previous < 0 ? 0 : this.queue[previous].size;
-    const budget = LIMITS.queuedBytes + (frame.kind === "response" ? LIMITS.responseFrameBytes : 0);
-    ensure(
-      this.bytes - replaced + size <= budget && (previous >= 0 || this.queue.length < 256),
-      "queue_full",
-      "Runner output queue is full"
-    );
-    const item = { message: JSON.parse(serialized), size, key };
-    if (previous >= 0) this.queue.splice(previous, 1);
-    this.queue.push(item);
-    this.bytes += size - replaced;
-    this.flush();
-  }
-  flush() {
-    while (!this.closed && this.queue.length && this.write(this.queue[0].message)) {
-      this.bytes -= this.queue.shift().size;
-    }
-  }
-  dispose() {
-    this.closed = true;
-    this.queue.length = 0;
-    this.bytes = 0;
-  }
-};
-function portChannel(port, receive, onError) {
-  let credits = 16;
-  let closed = false;
-  const outbox = new Outbox((message) => {
-    if (!credits) return false;
-    port.postMessage({ type: "delivery", message });
-    credits--;
-    return true;
-  });
-  function listener(envelope) {
-    if (closed) return;
-    try {
-      if (envelope?.type === "credit") {
-        ensure(credits < 16, "invalid_payload", "Unexpected port credit");
-        credits++;
-        outbox.flush();
-      } else {
-        ensure(envelope?.type === "delivery", "invalid_payload", "Invalid port message");
-        jsonBytes(envelope.message, frameLimit(framed(envelope.message), true));
-        receive(envelope.message);
-        port.postMessage({ type: "credit" });
-      }
-    } catch (error) {
-      onError(error);
-    }
-  }
-  port.on("message", listener);
-  return { send: (message) => outbox.push(message), dispose() {
-    closed = true;
-    outbox.dispose();
-    port.off("message", listener);
-  } };
-}
-
-// src/worker.mjs
-var runtime;
-var stopping = false;
-function fatal(error) {
-  try {
-    channel.send({ type: "failure", error: wireError(error) });
-  } finally {
-    process.exitCode = 1;
-    void stop();
-  }
-}
-async function stop() {
-  if (stopping) return;
-  stopping = true;
-  try {
-    await runtime?.dispose();
-  } finally {
-    channel.send({ type: "stopped" });
-  }
-}
-var channel = portChannel(parentPort, (message) => {
-  if (message.type === "stop") {
-    void stop().catch(fatal);
-    return;
-  }
-  ensure(message.type === "frame" && runtime, "invalid_payload", "Worker runtime is unavailable");
-  runtime.receive(message.frame);
-}, fatal);
-try {
-  ensure(workerData.version === RUNNER_PROTOCOL_VERSION, "incompatible_version", "Daemon and runner protocol versions differ");
-  const prepared = await preparePlugin(workerData.source);
-  ensure(prepared.manifest.id === workerData.producer.pluginId, "identity_mismatch", "Prepared plugin identity differs from its producer");
-  runtime = createRuntime({
-    manifest: prepared.manifest,
-    producer: workerData.producer,
-    instanceId: String(workerData.generation),
-    send: (frame) => channel.send({ type: "frame", frame }),
-    onError: (error) => channel.send({ type: "diagnostic", error: wireError(error) })
-  });
-  ensure(!stopping, "cancelled", "Plugin loading was cancelled");
-  const module = await import(pathToFileURL(prepared.entry).href);
-  if (!stopping) {
-    await runtime.activate(module.default);
-    if (!stopping) channel.send({ type: "ready" });
-  }
-} catch (error) {
-  fatal(error);
-}