@vscode/component-explorer 0.2.1-17 → 0.2.1-171

package/dist/browserDaemonClient-AB8d4x2O.js

@@ -0,0 +1,3465 @@
+var Ut = Object.defineProperty;
+var Bt = (t, e, r) => e in t ? Ut(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var l = (t, e, r) => Bt(t, typeof e != "symbol" ? e + "" : e, r);
+import { object as v, optional as g, unknown as V, string as u, enum as B, union as K, number as P, void as Ge, array as T, int as Y, nonnegative as X, strictObject as pe, literal as ie, record as wt, boolean as se, positive as Kt } from "zod/mini";
+import { safeParse as z, toJSONSchema as Jt } from "zod/v4/core";
+import { z as d } from "zod";
+const Ft = /* @__PURE__ */ new Set([
+  "type",
+  "format",
+  "properties",
+  "required",
+  "additionalProperties",
+  "items",
+  "prefixItems",
+  "const",
+  "enum",
+  "anyOf",
+  "oneOf",
+  "discriminator",
+  "$ref",
+  "title",
+  "description"
+]);
+function C(t) {
+  if (t === !0 || t === !1) return t;
+  if (t === null || typeof t != "object") throw new Error(`normalizeJsonSchema: expected object, got ${typeof t}`);
+  if (Array.isArray(t)) throw new Error("normalizeJsonSchema: expected object, got array");
+  const e = t;
+  if ("not" in e && Vt(e.not)) return !1;
+  if (Array.isArray(e.type)) {
+    const s = e.type;
+    if (s.length === 0 || new Set(s).size !== s.length || s.some((a) => ![
+      "null",
+      "boolean",
+      "number",
+      "integer",
+      "string",
+      "array",
+      "object"
+    ].includes(a))) throw new Error("normalizeJsonSchema: type array must contain distinct JSON Schema type names");
+    const { title: n, description: o, ...i } = e;
+    return C({
+      title: n,
+      description: o,
+      anyOf: s.map((a) => {
+        const c = {
+          ...i,
+          type: a
+        };
+        return a !== "object" && (delete c.properties, delete c.required, delete c.additionalProperties), a !== "array" && (delete c.items, delete c.prefixItems), a !== "string" && a !== "number" && a !== "integer" && delete c.format, c;
+      })
+    });
+  }
+  const r = {};
+  for (const [s, n] of Object.entries(e)) {
+    if (!Ft.has(s)) continue;
+    const o = Gt(s, n);
+    o !== void 0 && (r[s] = o);
+  }
+  if (r.type === "object" && !("additionalProperties" in r) && (r.additionalProperties = !1), Array.isArray(r.oneOf) && !("discriminator" in r)) {
+    const s = Yt(r.oneOf);
+    s !== void 0 && (r.discriminator = s);
+  }
+  return "discriminator" in r && !Array.isArray(r.oneOf) && delete r.discriminator, Object.keys(r).length === 0 ? !0 : r;
+}
+function Gt(t, e) {
+  switch (t) {
+    case "properties": {
+      if (!Ie(e)) return {};
+      const r = {};
+      for (const [s, n] of Object.entries(e)) r[s] = C(n);
+      return r;
+    }
+    case "items":
+    case "additionalProperties":
+      return e === !1 ? !1 : C(e);
+    case "prefixItems":
+    case "anyOf":
+    case "oneOf":
+      return Array.isArray(e) ? e.map((r) => C(r)) : [];
+    case "discriminator": {
+      if (!Ie(e)) return;
+      const r = e.propertyName;
+      return typeof r != "string" || r.length === 0 ? void 0 : { propertyName: r };
+    }
+    case "enum":
+      return Array.isArray(e) ? e.slice() : [];
+    case "required":
+      return Array.isArray(e) ? e.slice().sort() : [];
+    default:
+      return e;
+  }
+}
+function Vt(t) {
+  return Ie(t) && Object.keys(t).length === 0;
+}
+function Ie(t) {
+  return t !== null && typeof t == "object" && !Array.isArray(t);
+}
+function Yt(t) {
+  if (t.length < 2) return;
+  const e = [];
+  for (const s of t) {
+    if (s === !0 || s === !1 || s.type !== "object") return;
+    const n = s.properties;
+    if (!n) return;
+    e.push(n);
+  }
+  let r = Ve(e[0]);
+  for (let s = 1; s < e.length; s++)
+    if (r = r.filter((n) => Ve(e[s]).includes(n)), r.length === 0) return;
+  for (const s of r) {
+    const n = /* @__PURE__ */ new Set();
+    let o = !0;
+    for (const i of e) {
+      const a = i[s], c = JSON.stringify(a.const);
+      if (n.has(c)) {
+        o = !1;
+        break;
+      }
+      n.add(c);
+    }
+    if (o) return { propertyName: s };
+  }
+}
+function Ve(t) {
+  const e = [];
+  for (const [r, s] of Object.entries(t))
+    s === !0 || s === !1 || "const" in s && e.push(r);
+  return e;
+}
+const Qt = Symbol("linkrpc.rpcFailure");
+var bt, Ye = (bt = Qt, class {
+  constructor(t) {
+    l(this, "error");
+    l(this, bt, !0);
+    this.error = t, Object.freeze(this);
+  }
+});
+const R = {
+  /** Default code for named LinkRPC application errors. */
+  applicationError: 1,
+  parseError: -32700,
+  invalidRequest: -32600,
+  methodNotFound: -32601,
+  invalidParams: -32602,
+  internalError: -32603,
+  /** Caller is authenticated but lacks a capability covering the call. */
+  permissionRequired: -32401,
+  /** The peer a request was routed to detached before it could respond. */
+  peerDisconnected: -32402,
+  /** The request exceeded the hub's idle timeout with no stream activity. */
+  requestTimeout: -32403,
+  /** The request was cancelled (by the caller, or by the hub on disconnect). */
+  cancelled: -32800
+};
+function yt(t) {
+  return typeof t.method == "string" && t.id !== void 0;
+}
+function Se(t) {
+  return typeof t.method == "string" && t.id === void 0;
+}
+function ke(t) {
+  return typeof t.method != "string";
+}
+const It = Symbol("linkrpc.applicationError");
+function Qe(t) {
+  return Object.freeze(Object.defineProperty(t, It, { value: !0 }));
+}
+const Xt = /* @__PURE__ */ new WeakMap();
+function Zt(t) {
+  return `/${String(t).replace(/~/g, "~0").replace(/\//g, "~1")}`;
+}
+const Xe = /* @__PURE__ */ new WeakMap();
+function St(t, e) {
+  return tr(t.bodySchema ?? er(t), e);
+}
+function er(t) {
+  let e = Xe.get(t);
+  if (e === void 0) {
+    const r = t.dataSchema === void 0 ? {} : { data: t.dataSchema };
+    e = t.type === void 0 ? pe({
+      message: ie(t.message),
+      ...r
+    }) : pe({
+      message: u(),
+      data: pe({
+        type: ie(t.type),
+        ...r
+      })
+    }), Xe.set(t, e);
+  }
+  return e;
+}
+function tr(t, e) {
+  const r = z(t, e);
+  return r.success ? typeof r.data != "object" || r.data === null || !("message" in r.data) || typeof r.data.message != "string" ? {
+    success: !1,
+    issues: [{
+      path: "/message",
+      message: "Expected a string message"
+    }]
+  } : {
+    success: !0,
+    data: {
+      ...r.data,
+      message: r.data.message
+    }
+  } : {
+    success: !1,
+    issues: kt(r.error.issues)
+  };
+}
+function kt(t, e = []) {
+  return t.flatMap((r) => {
+    const s = [...e, ...r.path];
+    return r.code === "invalid_union" ? r.errors.flatMap((n) => kt(n, s)) : r.code === "unrecognized_keys" ? r.keys.map((n) => ({
+      path: Ee([...s, n]),
+      message: "Unexpected property"
+    })) : [{
+      path: Ee(s),
+      message: r.message
+    }];
+  });
+}
+function Ee(t) {
+  return t.map(Zt).join("");
+}
+function Et(t, e = [], r = /* @__PURE__ */ new Set()) {
+  if (t === null || typeof t == "string" || typeof t == "boolean" || typeof t == "number" && Number.isFinite(t)) return [];
+  if (typeof t != "object" || r.has(t) || !Array.isArray(t) && Object.getPrototypeOf(t) !== Object.prototype && Object.getPrototypeOf(t) !== null) return [{
+    path: Ee(e),
+    message: "Expected a JSON value"
+  }];
+  r.add(t);
+  const s = (Array.isArray(t) ? Array.from(t.entries()) : Object.entries(t)).flatMap(([n, o]) => Et(o, [...e, n], r));
+  return r.delete(t), s;
+}
+function rr(t) {
+  return typeof t == "object" && t !== null && t[It] === !0;
+}
+function sr(t) {
+  if (Ot(t), t >= -32768 && t <= -32e3 || t === -32800) throw new Error(`Application error code ${t} is reserved by JSON-RPC or LinkRPC.`);
+}
+function Ot(t) {
+  if (!Number.isInteger(t) || t < -2147483648 || t > 2147483647) throw new Error(`Application error code ${t} must be a signed 32-bit integer.`);
+}
+var nr = class Oe {
+  constructor(e, r, s, n = {}, o, i, a = []) {
+    l(this, "paramsSchema");
+    l(this, "resultSchema");
+    l(this, "errorSchema");
+    l(this, "docs");
+    l(this, "clientStreamSchema");
+    l(this, "serverStreamSchema");
+    l(this, "applicationErrors");
+    l(this, "kind", "request");
+    /** Declared checked errors, retained as a tuple for generated-contract consumers. */
+    l(this, "errors");
+    this.paramsSchema = e, this.resultSchema = r, this.errorSchema = s, this.docs = n, this.clientStreamSchema = o, this.serverStreamSchema = i, this.applicationErrors = a;
+    const c = /* @__PURE__ */ new Set();
+    for (const f of a) {
+      if (a.some((p) => p !== f && p.code === f.code && (p.bodySchema !== void 0 || f.bodySchema !== void 0))) throw new Error(`Raw error code ${f.code} cannot be shared.`);
+      if (f.bodySchema !== void 0) {
+        Ot(f.code);
+        const p = `code:${f.code}`;
+        if (c.has(p)) throw new Error(`Duplicate application error ${p}.`);
+        c.add(p);
+        continue;
+      }
+      if (sr(f.code), typeof f.message != "string") throw new Error("Application error message must be a string.");
+      if (f.type !== void 0 && (typeof f.type != "string" || f.type.length === 0)) throw new Error("Application error type must be a nonempty string.");
+      const h = f.type === void 0 ? `code:${f.code}` : `type:${f.type}`;
+      if (c.has(h)) throw new Error(`Duplicate application error ${h}.`);
+      c.add(h);
+    }
+    this.applicationErrors = Object.freeze([...a]), this.errors = this.applicationErrors;
+  }
+  /**
+  * Return a copy of this request type with stream payload schemas
+  * attached. Pass `undefined` for either direction to leave it
+  * closed.
+  * `NoInfer` keeps a contextual MemberMap's `any` stream slots from
+  * widening undeclared directions; only the supplied schemas infer payloads.
+  */
+  withStream(e) {
+    return new Oe(this.paramsSchema, this.resultSchema, this.errorSchema, this.docs, e.client, e.server, this.applicationErrors);
+  }
+  /**
+  * Return a copy with an explicit, typed set of checked application errors.
+  * The legacy third `requestType` schema remains accepted for compatibility,
+  * but does not opt a method into checked errors.
+  */
+  withErrors(e) {
+    return new Oe(this.paramsSchema, this.resultSchema, this.errorSchema, this.docs, this.clientStreamSchema, this.serverStreamSchema, e);
+  }
+}, or = class {
+  constructor(t, e = {}) {
+    l(this, "paramsSchema");
+    l(this, "docs");
+    l(this, "kind", "notification");
+    this.paramsSchema = t, this.docs = e;
+  }
+};
+function w(t, e, r, s) {
+  const n = {};
+  return new nr(t, e ?? Ge(), Ge(), n);
+}
+function ir(t, e = {}) {
+  return new or(t, e);
+}
+function ar(t, e) {
+  var n, o;
+  const r = Xt.get(t);
+  if (r !== void 0) {
+    for (const [i, a] of Object.entries(r.components)) {
+      if (e === void 0) throw new Error("Imported schema references require a component destination");
+      Re(e.components, i, C(a));
+    }
+    return C(r.schema);
+  }
+  const s = (o = (n = t._zod) == null ? void 0 : n.def) == null ? void 0 : o.type;
+  return s === "void" || s === "undefined" ? !0 : cr(Jt(t, { override: (i) => {
+    var c;
+    const a = (c = e == null ? void 0 : e.parameterNames) == null ? void 0 : c.get(i.zodSchema);
+    if (a !== void 0) {
+      for (const f of Object.keys(i.jsonSchema)) delete i.jsonSchema[f];
+      i.jsonSchema.$ref = `linkrpc-parameter:${encodeURIComponent(a)}`;
+    } else if ((e == null ? void 0 : e.parameterNames) !== void 0) {
+      for (const f of [
+        "allOf",
+        "patternProperties",
+        "unevaluatedProperties",
+        "if",
+        "then",
+        "else",
+        "contains"
+      ]) if (f in i.jsonSchema) throw new Error(`Unsupported template JSON Schema keyword "${f}"`);
+    }
+  } }), e);
+}
+function cr(t, e) {
+  if (!ae(t)) return C(t);
+  const r = ae(t.$defs) ? t.$defs : {}, s = $e(t);
+  if (Object.keys(r).length === 0 && s.size === 0) return C(t);
+  if (e === void 0) throw new Error("zodToSvcJsonSchema: local references require a component destination");
+  const n = `method=${ue(e.methodName)}&schema=${ue(e.schemaPosition)}`, o = /* @__PURE__ */ new Map();
+  for (const f of Object.keys(r)) o.set(f, `${n}&def=${ue(f)}`);
+  const i = s.has("#") ? `${n}&root` : void 0, a = (f) => je(f, o, i);
+  for (const [f, h] of Object.entries(r)) {
+    const p = o.get(f);
+    if (p === void 0) throw new Error(`zodToSvcJsonSchema: missing component for "${f}"`);
+    Re(e.components, p, C(a(h)));
+  }
+  const c = a(t);
+  return i !== void 0 ? (Re(e.components, i, C(c)), { $ref: Pe(i) }) : C(c);
+}
+function $e(t, e = /* @__PURE__ */ new Set()) {
+  if (Array.isArray(t)) {
+    for (const r of t) $e(r, e);
+    return e;
+  }
+  if (!ae(t)) return e;
+  typeof t.$ref == "string" && t.$ref.startsWith("#") && e.add(t.$ref);
+  for (const r of Object.values(t)) $e(r, e);
+  return e;
+}
+function je(t, e, r) {
+  if (Array.isArray(t)) return t.map((n) => je(n, e, r));
+  if (!ae(t)) return t;
+  const s = {};
+  for (const [n, o] of Object.entries(t))
+    n !== "$defs" && (n === "$ref" && typeof o == "string" ? s[n] = dr(o, e, r) : s[n] = je(o, e, r));
+  return s;
+}
+function dr(t, e, r) {
+  if (t === "#") {
+    if (r === void 0) throw new Error("zodToSvcJsonSchema: root reference has no component destination");
+    return Pe(r);
+  }
+  if (t.startsWith("#/$defs/")) {
+    const s = t.slice(8), n = [...e.keys()].find((i) => $t(i) === s), o = n === void 0 ? void 0 : e.get(n);
+    if (o === void 0) throw new Error(`zodToSvcJsonSchema: dangling local reference "${t}"`);
+    return Pe(o);
+  }
+  if (t.startsWith("#") && !t.startsWith("#/components/schemas/")) throw new Error(`zodToSvcJsonSchema: unsupported local reference "${t}"`);
+  return t;
+}
+function Re(t, e, r) {
+  if (Object.hasOwn(t, e)) throw new Error(`zodToSvcJsonSchema: duplicate component name "${e}"`);
+  t[e] = r;
+}
+function Pe(t) {
+  return `#/components/schemas/${$t(t)}`;
+}
+function $t(t) {
+  return t.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function ue(t) {
+  return encodeURIComponent(t).replace(/~/g, "%7E");
+}
+function ae(t) {
+  return t !== null && typeof t == "object" && !Array.isArray(t);
+}
+var b = class extends Error {
+  constructor() {
+    super(...arguments);
+    l(this, "name", "SchemaValidationError");
+  }
+};
+const jt = "#/components/schemas/";
+function fr(t) {
+  return jt + t.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function U(t) {
+  if (!t.startsWith(jt)) throw new b(`Invalid component reference: ${t}`);
+  const e = t.slice(21);
+  if (e.includes("/") || /~(?:[^01]|$)/.test(e)) throw new b(`Invalid component reference token: ${t}`);
+  return e.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function hr(t) {
+  const e = oe(t);
+  if (e === void 0) throw new Error("jcsCanonicalize: value is not JSON-representable");
+  return e;
+}
+new TextEncoder();
+function oe(t, e = /* @__PURE__ */ new Set()) {
+  if (typeof t == "number" && Number.isNaN(t)) throw new Error("NaN is not allowed");
+  if (typeof t == "number" && !Number.isFinite(t)) throw new Error("Infinity is not allowed");
+  if (t === null || typeof t != "object") return JSON.stringify(t);
+  const r = t;
+  if (typeof r.toJSON == "function") {
+    if (e.has(r)) throw new Error("Circular reference detected");
+    e.add(r);
+    const n = oe(r.toJSON(), e);
+    return e.delete(r), n;
+  }
+  if (e.has(r)) throw new Error("Circular reference detected");
+  e.add(r);
+  let s;
+  if (Array.isArray(r)) s = `[${r.map((n) => oe(n === void 0 || typeof n == "symbol" ? null : n, e)).join(",")}]`;
+  else {
+    const n = [];
+    for (const o of Object.keys(r).sort()) {
+      const i = r[o];
+      i === void 0 || typeof i == "symbol" || n.push(`${JSON.stringify(o)}:${oe(i, e)}`);
+    }
+    s = `{${n.join(",")}}`;
+  }
+  return e.delete(r), s;
+}
+const lr = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+function q(t, e) {
+  return t >>> e | t << 32 - e;
+}
+function pr(t) {
+  const e = t.length, r = e * 8, s = e + 9 + 63 & -64, n = new Uint8Array(s);
+  n.set(t), n[e] = 128;
+  const o = new DataView(n.buffer);
+  o.setUint32(s - 8, Math.floor(r / 4294967296), !1), o.setUint32(s - 4, r >>> 0, !1);
+  const i = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]), a = /* @__PURE__ */ new Uint32Array(64);
+  for (let h = 0; h < s; h += 64) {
+    for (let E = 0; E < 16; E++) a[E] = o.getUint32(h + E * 4, !1);
+    for (let E = 16; E < 64; E++) {
+      const $ = a[E - 15], J = a[E - 2], O = q($, 7) ^ q($, 18) ^ $ >>> 3, L = q(J, 17) ^ q(J, 19) ^ J >>> 10;
+      a[E] = a[E - 16] + O + a[E - 7] + L >>> 0;
+    }
+    let p = i[0], m = i[1], y = i[2], _ = i[3], I = i[4], j = i[5], S = i[6], x = i[7];
+    for (let E = 0; E < 64; E++) {
+      const $ = q(I, 6) ^ q(I, 11) ^ q(I, 25), J = I & j ^ ~I & S, O = x + $ + J + lr[E] + a[E] >>> 0, L = (q(p, 2) ^ q(p, 13) ^ q(p, 22)) + (p & m ^ p & y ^ m & y) >>> 0;
+      x = S, S = j, j = I, I = _ + O >>> 0, _ = y, y = m, m = p, p = O + L >>> 0;
+    }
+    i[0] = i[0] + p >>> 0, i[1] = i[1] + m >>> 0, i[2] = i[2] + y >>> 0, i[3] = i[3] + _ >>> 0, i[4] = i[4] + I >>> 0, i[5] = i[5] + j >>> 0, i[6] = i[6] + S >>> 0, i[7] = i[7] + x >>> 0;
+  }
+  const c = /* @__PURE__ */ new Uint8Array(32), f = new DataView(c.buffer);
+  for (let h = 0; h < 8; h++) f.setUint32(h * 4, i[h], !1);
+  return c;
+}
+const ur = [
+  "params",
+  "result",
+  "clientStream",
+  "serverStream"
+];
+function Ce(t) {
+  const e = hr(Te(mr(t), !0)), r = pr(new TextEncoder().encode(e));
+  return Array.from(r.subarray(0, 8), (s) => s.toString(16).padStart(2, "0")).join("");
+}
+function mr(t) {
+  var n;
+  const e = Object.fromEntries(Object.entries(t.methods).map(([o, i]) => {
+    const a = { ...i };
+    for (const c of ur) {
+      const f = a[c];
+      f !== void 0 && (a[c] = C(f));
+    }
+    return i.errors !== void 0 && (a.errors = i.errors.map((c) => c.schema !== void 0 ? {
+      ...c,
+      schema: C(c.schema)
+    } : {
+      ...c,
+      ...c.data === void 0 ? {} : { data: C(c.data) }
+    })), [o, a];
+  })), r = (n = t.components) == null ? void 0 : n.schemas, s = r === void 0 ? t.components : {
+    ...t.components,
+    schemas: Object.fromEntries(Object.entries(r).map(([o, i]) => [o, C(i)]))
+  };
+  return {
+    ...t,
+    methods: e,
+    ...s === void 0 ? {} : { components: s }
+  };
+}
+function gr(t, e) {
+  return t === "comment" || t.startsWith("x-") || e && (t === "hash" || t === "tags");
+}
+function Te(t, e = !1) {
+  if (t === null || typeof t != "object") return t;
+  if (Array.isArray(t)) return t.map((s) => Te(s));
+  const r = {};
+  for (const s of Object.keys(t)) {
+    if (gr(s, e)) continue;
+    const n = t[s];
+    n !== void 0 && (r[s] = Te(n));
+  }
+  return r;
+}
+const re = "x-interface-templates";
+function vr(t, e) {
+  const r = /* @__PURE__ */ Object.create(null), s = [];
+  for (const [o, i] of Object.entries(e)) {
+    const a = r[i.template.id];
+    if (a !== void 0 && !Pt(a, i.template)) throw new Error(`Conflicting definitions for interface template "${i.template.id}"`);
+    r[i.template.id] = a === void 0 ? i.template : {
+      ...a,
+      tags: ce([...a.tags ?? [], ...i.template.tags ?? []])
+    }, s.push({
+      ...i.schema,
+      name: o
+    });
+  }
+  const n = ce([...t.tags ?? [], ...s.flatMap((o) => r[o.template].tags ?? [])]);
+  return {
+    ...t,
+    ...t.tags !== void 0 || n.length > 0 ? { tags: n } : {},
+    [re]: {
+      templates: r,
+      instances: s
+    }
+  };
+}
+function Ae(t) {
+  Ke(t);
+  const e = t[re];
+  return ce([...t.tags ?? [], ...((e == null ? void 0 : e.instances) ?? []).flatMap((r) => {
+    var s;
+    return ((s = e == null ? void 0 : e.templates[r.template]) == null ? void 0 : s.tags) ?? [];
+  })]);
+}
+function ce(t) {
+  return [...new Set(t)].sort();
+}
+function Ke(t) {
+  de(t.tags, `Interface "${t.id}"`);
+  const e = t[re];
+  if (e === void 0) return;
+  if (!k(e) || !k(e.templates) || !Array.isArray(e.instances)) throw new b(`${re} must contain templates and instances`);
+  const r = e.templates;
+  for (const [o, i] of Object.entries(r)) {
+    if (!k(i) || i.id !== o) throw new b(`Interface template key "${o}" must match its id`);
+    br(i);
+  }
+  const s = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Set();
+  for (const o of e.instances) {
+    if (!k(o)) throw new b("Interface template instance must be an object");
+    if (typeof o.name != "string") throw new b("Interface template instance name must be a string");
+    if (typeof o.template != "string") throw new b("Interface template reference must be a string");
+    if (o.prefix !== void 0) throw new b("Interface template instances require explicit member mappings, not prefixes");
+    if (!k(o.members)) throw new b("Interface template members must be an object");
+    if (!k(o.arguments)) throw new b("Interface template arguments must be an object");
+    const i = {
+      name: o.name,
+      template: o.template,
+      members: o.members,
+      arguments: o.arguments
+    };
+    if (Fe(i.name, "interface template instance name"), n.has(i.name)) throw new b(`Interface template instance name collision at "${i.name}"`);
+    n.add(i.name);
+    const a = r[i.template];
+    if (!Object.hasOwn(r, i.template)) throw new b(`Interface template instance "${i.name}" references unknown template "${i.template}"`);
+    if (wr(i, a), i.members !== void 0) {
+      for (const c of Object.keys(i.members)) if (!Object.hasOwn(a.methods, c)) throw new b(`Unknown mapped member "${c}"`);
+      for (const c of Object.keys(a.methods)) {
+        const f = i.members[c];
+        if (!Object.hasOwn(i.members, c) || typeof f != "string") throw new b(`Missing mapped member "${c}"`);
+      }
+    }
+    yr(t, i, a, s);
+  }
+}
+function _r(t, e) {
+  if (t.id !== e.id || t.hash !== e.hash || Ce(t) !== t.hash || Ce(e) !== e.hash) return t;
+  de(t.tags, `Interface "${t.id}"`), de(e.tags, `Interface "${e.id}"`);
+  const r = Ze(e), s = Ze(t);
+  if (e["x-interface-templates"] !== void 0 && r === void 0) return t;
+  if (t["x-interface-templates"] !== void 0 && s === void 0) return e;
+  if (s !== void 0 && r === void 0) return t;
+  if (r !== void 0 && s !== void 0) {
+    for (const [i, a] of Object.entries(s.templates)) if (!Object.hasOwn(r.templates, i) || !Pt(a, r.templates[i])) return t;
+    for (const i of s.instances) if (!r.instances.some((a) => D(i, a))) return t;
+    for (const [i, a] of Object.entries(s)) if (i !== "templates" && i !== "instances" && !D(a, r[i])) return t;
+  }
+  const n = Ae(t), o = Ae(e);
+  return n.some((i) => !o.includes(i)) ? t : s === void 0 && r !== void 0 || s !== void 0 && r !== void 0 && (Object.keys(r.templates).length > Object.keys(s.templates).length || r.instances.length > s.instances.length) || o.length > n.length ? e : t;
+}
+function Ze(t) {
+  if (t["x-interface-templates"] !== void 0) {
+    try {
+      Ke(t);
+    } catch (e) {
+      if (!(e instanceof b)) throw e;
+      return;
+    }
+    return t[re];
+  }
+}
+function br(t) {
+  if (!k(t) || typeof t.id != "string" || t.id.length === 0) throw new b("Interface template id must be a non-empty string");
+  if (!Array.isArray(t.parameters) || !k(t.methods)) throw new b(`Interface template "${t.id}" must contain parameters and methods`);
+  de(t.tags, `Interface template "${t.id}"`);
+  const e = /* @__PURE__ */ new Set();
+  for (const s of t.parameters) {
+    if (typeof s != "string" || s.length === 0) throw new b(`Interface template "${t.id}" has an invalid parameter name`);
+    if (e.has(s)) throw new b(`Interface template "${t.id}" repeats parameter "${s}"`);
+    e.add(s);
+  }
+  const r = Ct(t.components);
+  for (const [s, n] of Object.entries(t.methods)) {
+    if (Fe(s, `member of interface template "${t.id}"`), !k(n) || !Object.hasOwn(n, "params")) throw new b(`Interface template "${t.id}" member "${s}" has no params`);
+    for (const o of Je) {
+      const i = n[o];
+      (o === "params" || i !== void 0) && ee(i, e, r, /* @__PURE__ */ new Set());
+    }
+    if (n.errors !== void 0 && !Array.isArray(n.errors)) throw new b("Interface template method errors must be an array");
+    for (const o of n.errors ?? []) {
+      if (!k(o)) throw new b("Interface template method error must be an object");
+      o.schema !== void 0 && ee(o.schema, e, r, /* @__PURE__ */ new Set()), o.data !== void 0 && ee(o.data, e, r, /* @__PURE__ */ new Set());
+    }
+  }
+  for (const s of Object.values(r)) ee(s, e, r, /* @__PURE__ */ new Set());
+}
+function ee(t, e, r, s) {
+  if (typeof t != "boolean") {
+    if (!k(t)) throw new b("Interface template schema must be an object or boolean");
+    if (!s.has(t)) {
+      if (s.add(t), "$parameter" in t) {
+        if (Object.keys(t).length !== 1 || typeof t.$parameter != "string") throw new b("A schema parameter reference must contain only $parameter");
+        if (!e.has(t.$parameter)) throw new b(`Unknown schema parameter "${t.$parameter}"`);
+        return;
+      }
+      if ("$ref" in t) {
+        if (typeof t.$ref != "string") throw new b("Component reference must be a string");
+        const n = U(t.$ref);
+        if (!Object.hasOwn(r, n)) throw new b(`Unknown interface template component "${n}"`);
+      }
+      for (const n of Tt(t)) ee(n, e, r, s);
+    }
+  }
+}
+function wr(t, e) {
+  const r = new Set(e.parameters);
+  for (const s of Object.keys(t.arguments)) if (!r.has(s)) throw new b(`Interface template instance "${t.name}" supplies unknown parameter "${s}"`);
+  for (const s of r) {
+    const n = t.arguments[s];
+    if (!k(n) || !Object.hasOwn(n, "schema")) throw new b(`Interface template instance "${t.name}" is missing parameter "${s}"`);
+    const o = Ct(n.components);
+    Ne(n.schema, o, /* @__PURE__ */ new Set());
+    for (const i of Object.values(o)) Ne(i, o, /* @__PURE__ */ new Set());
+  }
+}
+function Ne(t, e, r) {
+  if (typeof t != "boolean") {
+    if (!k(t)) throw new b("Concrete schema argument must be an object or boolean");
+    if (!r.has(t)) {
+      if (r.add(t), "$parameter" in t) throw new b("Concrete schema arguments cannot contain $parameter");
+      if ("$ref" in t) {
+        if (typeof t.$ref != "string") throw new b("Component reference must be a string");
+        const s = U(t.$ref);
+        if (!Object.hasOwn(e, s)) throw new b(`Unknown schema argument component "${s}"`);
+      }
+      for (const s of Tt(t)) Ne(s, e, r);
+    }
+  }
+}
+function yr(t, e, r, s) {
+  var a;
+  const n = {}, o = Object.fromEntries(Object.entries(r.methods).map(([c, f]) => [c, Sr(f, r, e, n)])), i = ((a = t.components) == null ? void 0 : a.schemas) ?? {};
+  for (const [c, f] of Object.entries(o)) {
+    const h = Ir(e, c);
+    Fe(h, `mapped member of interface template instance "${e.name}"`);
+    const p = s.get(h);
+    if (p !== void 0) throw new b(`Interface template member collision at "${h}" between "${p}" and "${e.name}"`);
+    s.set(h, e.name);
+    const m = t.methods[h];
+    if (m === void 0) throw new b(`Interface template instance "${e.name}" is missing mapped member "${h}"`);
+    if (!Er(f, m, n, i)) throw new b(`Interface template instance "${e.name}" member "${h}" does not match its instantiated template`);
+  }
+}
+function Ir(t, e) {
+  const r = t.members[e];
+  if (r !== void 0) return r;
+  throw new Error(`Missing mapped member "${e}"`);
+}
+function Sr(t, e, r, s) {
+  const n = (i) => Me(i, e, r, s, /* @__PURE__ */ new Map()), o = {
+    ...t,
+    params: n(t.params)
+  };
+  for (const i of Je.slice(1)) {
+    const a = t[i];
+    a !== void 0 && (o[i] = n(a));
+  }
+  return t.errors !== void 0 && (o.errors = t.errors.map((i) => i.schema !== void 0 ? {
+    code: i.code,
+    schema: n(i.schema)
+  } : {
+    code: i.code,
+    message: i.message,
+    ...i.type === void 0 ? {} : { type: i.type },
+    ...i.data === void 0 ? {} : { data: n(i.data) }
+  })), o;
+}
+function Me(t, e, r, s, n) {
+  return typeof t == "boolean" ? t : "$parameter" in t ? kr(t.$parameter, r, s, n) : Rt(t, (o) => {
+    var a, c;
+    const i = `template:${e.id}:${o}`;
+    if (!Object.hasOwn(s, i)) {
+      const f = (c = (a = e.components) == null ? void 0 : a.schemas) == null ? void 0 : c[o];
+      if (f === void 0) throw new Error(`Unknown interface template component "${o}"`);
+      s[i] = !1, s[i] = Me(f, e, r, s, n);
+    }
+    return i;
+  }, (o) => Me(o, e, r, s, n));
+}
+function kr(t, e, r, s) {
+  const n = e.arguments[t];
+  if (n === void 0) throw new Error(`Missing schema argument "${t}"`);
+  const o = (i) => Rt(i, (a) => {
+    var m, y;
+    const c = `${t}:${a}`, f = s.get(c);
+    if (f !== void 0) return f;
+    const h = `argument:${e.name}:${t}:${a}`;
+    s.set(c, h);
+    const p = (y = (m = n.components) == null ? void 0 : m.schemas) == null ? void 0 : y[a];
+    if (p === void 0) throw new Error(`Unknown schema argument component "${a}"`);
+    return r[h] = !1, r[h] = o(p), h;
+  }, (a) => o(a));
+  return o(n.schema);
+}
+function Rt(t, e, r) {
+  if (typeof t == "boolean") return t;
+  const s = {};
+  for (const [n, o] of Object.entries(t)) n === "$ref" && typeof o == "string" ? s.$ref = fr(e(U(o))) : n === "properties" && k(o) ? s.properties = Object.fromEntries(Object.entries(o).map(([i, a]) => [i, r(a)])) : n === "additionalProperties" || n === "items" ? s[n] = typeof o == "boolean" ? o : r(o) : n === "prefixItems" || n === "anyOf" || n === "oneOf" ? s[n] = o.map(r) : s[n] = o;
+  return s;
+}
+function Er(t, e, r, s) {
+  const n = { ...t }, o = { ...e };
+  for (const c of Je) {
+    const f = t[c], h = e[c];
+    if (delete n[c], delete o[c], f === void 0 || h === void 0) {
+      if (f !== h) return !1;
+    } else if (!N(f, h, r, s)) return !1;
+  }
+  const i = n.errors, a = o.errors;
+  return delete n.errors, delete o.errors, D(n, o) ? i === void 0 || a === void 0 ? i === a : i.length !== a.length ? !1 : i.every((c, f) => {
+    const h = a[f];
+    return c.schema !== void 0 || h.schema !== void 0 ? c.schema !== void 0 && h.schema !== void 0 && c.code === h.code && N(c.schema, h.schema, r, s) : c.code === h.code && c.type === h.type && c.message === h.message && (c.data === void 0 || h.data === void 0 ? c.data === h.data : N(c.data, h.data, r, s));
+  }) : !1;
+}
+function Pt(t, e) {
+  const { tags: r, ...s } = t, { tags: n, ...o } = e;
+  return D(s, o);
+}
+function de(t, e) {
+  if (t !== void 0 && (!Array.isArray(t) || t.some((r) => typeof r != "string")))
+    throw new b(`${e} tags must be an array of strings`);
+}
+function N(t, e, r, s, n = /* @__PURE__ */ new WeakMap()) {
+  if (typeof t == "boolean" || typeof e == "boolean") return t === e;
+  let o = n.get(t);
+  if (o != null && o.has(e)) return !0;
+  o === void 0 && (o = /* @__PURE__ */ new WeakSet(), n.set(t, o)), o.add(e);
+  const i = "$ref" in t ? t.$ref : void 0, a = "$ref" in e ? e.$ref : void 0, c = i === void 0 ? qe(t) : et(t), f = a === void 0 ? qe(e) : et(e);
+  if (i !== void 0 && Object.keys(c).length === 0) {
+    const m = r[U(i)];
+    return m !== void 0 && N(m, e, r, s, n);
+  }
+  if (a !== void 0 && Object.keys(f).length === 0) {
+    const m = s[U(a)];
+    return m !== void 0 && N(t, m, r, s, n);
+  }
+  if (!Or(c, f, r, s, n)) return !1;
+  if (i === void 0 || a === void 0) {
+    if (i === a) return !0;
+    const m = i ?? a, y = i === void 0 ? s : r, _ = y[U(m)];
+    return _ === void 0 ? !1 : i === void 0 ? N(t, _, r, y, n) : N(_, e, y, s, n);
+  }
+  const h = r[U(i)], p = s[U(a)];
+  return h !== void 0 && p !== void 0 && N(h, p, r, s, n);
+}
+function Or(t, e, r, s, n) {
+  const o = Object.keys(t).sort();
+  if (!D(o, Object.keys(e).sort())) return !1;
+  for (const i of o) {
+    const a = t[i], c = e[i];
+    if (i === "properties" && k(a) && k(c)) {
+      const f = Object.keys(a).sort();
+      if (!D(f, Object.keys(c).sort()) || !f.every((h) => N(a[h], c[h], r, s, n))) return !1;
+    } else if ((i === "items" || i === "additionalProperties") && xe(a) && xe(c)) {
+      if (!N(a, c, r, s, n)) return !1;
+    } else if ((i === "prefixItems" || i === "anyOf" || i === "oneOf") && Array.isArray(a) && Array.isArray(c)) {
+      if (a.length !== c.length || !a.every((f, h) => N(f, c[h], r, s, n))) return !1;
+    } else if (!D(a, c)) return !1;
+  }
+  return !0;
+}
+function Ct(t) {
+  if (t === void 0) return {};
+  if (!k(t) || t.schemas !== void 0 && !k(t.schemas)) throw new b("Schema components and component schemas must be objects");
+  return t.schemas ?? {};
+}
+function Tt(t) {
+  const e = [];
+  if (t.properties !== void 0) {
+    if (!k(t.properties)) throw new b("Schema properties must be an object");
+    e.push(...Object.values(t.properties));
+  }
+  for (const r of ["items", "additionalProperties"]) {
+    const s = t[r];
+    if (s !== void 0) {
+      if (!xe(s)) throw new b(`Schema ${r} must be an object or boolean`);
+      e.push(s);
+    }
+  }
+  for (const r of [
+    "prefixItems",
+    "anyOf",
+    "oneOf"
+  ]) {
+    const s = t[r];
+    if (s !== void 0) {
+      if (!Array.isArray(s)) throw new b(`Schema ${r} must be an array`);
+      e.push(...s);
+    }
+  }
+  return e;
+}
+const Je = [
+  "params",
+  "result",
+  "clientStream",
+  "serverStream"
+], $r = /^[A-Za-z0-9!#$%&'()*+,\-;=?@\[\]^_`{|}~]+$/;
+function Fe(t, e) {
+  if (!$r.test(t)) throw new b(`Invalid ${e} "${t}"`);
+}
+function et(t) {
+  const e = qe(t);
+  return delete e.$ref, e;
+}
+function qe(t) {
+  return Object.fromEntries(Object.entries(t));
+}
+function xe(t) {
+  return typeof t == "boolean" || k(t);
+}
+function k(t) {
+  return t !== null && typeof t == "object" && !Array.isArray(t);
+}
+function D(t, e) {
+  if (t === e) return !0;
+  if (Array.isArray(t) || Array.isArray(e)) return Array.isArray(t) && Array.isArray(e) && t.length === e.length && t.every((n, o) => D(n, e[o]));
+  if (!k(t) || !k(e)) return !1;
+  const r = Object.keys(t).sort(), s = Object.keys(e).sort();
+  return r.length === s.length && r.every((n, o) => n === s[o] && D(t[n], e[n]));
+}
+function jr(t) {
+  if (t !== void 0)
+    for (const [e, r] of Object.entries(t.methods)) {
+      if (r.result === void 0 && r.errors !== void 0) throw new Error(`Notification "${e}" cannot declare application errors.`);
+      const s = /* @__PURE__ */ new Set(), n = r.errors ?? [];
+      for (const o of n) {
+        if (!Number.isInteger(o.code) || o.code < -2147483648 || o.code > 2147483647) throw new Error(`Application error code ${o.code} on "${e}" must be a signed 32-bit integer.`);
+        if (n.some((a) => a !== o && a.code === o.code && (a.schema !== void 0 || o.schema !== void 0))) throw new Error(`Raw error code ${o.code} on "${e}" cannot be shared.`);
+        if (o.schema !== void 0) {
+          if ([
+            "message",
+            "type",
+            "data"
+          ].some((a) => Object.hasOwn(o, a))) throw new Error(`Raw error ${o.code} on "${e}" must contain only code and schema.`);
+        } else {
+          if (typeof o.message != "string") throw new Error(`Application error message on "${e}" must be a string.`);
+          if (o.code >= -32768 && o.code <= -32e3 || o.code === -32800) throw new Error(`Application error code ${o.code} on "${e}" is reserved by JSON-RPC or LinkRPC.`);
+          if (o.type !== void 0 && (typeof o.type != "string" || o.type.length === 0)) throw new Error(`Application error type on "${e}" must be a nonempty string.`);
+        }
+        const i = o.type === void 0 ? `code:${o.code}` : `type:${o.type}`;
+        if (s.has(i)) throw new Error(`Duplicate application error ${i} on "${e}".`);
+        s.add(i);
+      }
+    }
+}
+const tt = Symbol.for("@hediet/linkrpc.interfaceTemplateGroup"), Q = /* @__PURE__ */ new WeakMap();
+var rt = class {
+  constructor(t, e, r = {}) {
+    l(this, "info");
+    l(this, "members");
+    /** Typed wire references for capability and access-request construction. */
+    l(this, "ref");
+    if (this.info = t, this.members = e, r.frozenSchema !== void 0 && r.templates !== void 0) throw new Error("Cannot combine frozenSchema with authored templates");
+    const s = r.templates === void 0 ? r.frozenSchema : vr(me(t, e, ""), r.templates);
+    jr(s), s !== void 0 && Ke(s);
+    const n = s === void 0 ? ce(t.tags ?? []) : Ae(s);
+    if ((t.tags !== void 0 || n.length > 0) && (this.info = {
+      ...t,
+      tags: n
+    }), Q.set(this, {
+      frozenSchema: s,
+      schemaCache: void 0,
+      hashCache: void 0,
+      declarationGroups: void 0
+    }), this.ref = Object.fromEntries(Object.keys(e).map((o) => [o, {
+      interfaceId: this.info.id,
+      interfaceHash: this.schemaHash,
+      member: o
+    }])), t.hash !== void 0 && this.schemaHash !== t.hash) throw new Error(`Interface hash mismatch for "${t.id}": expected "${t.hash}", got "${this.schemaHash}". The interface's wire contract changed — update the pinned hash to "${this.schemaHash}" after reviewing the change.`);
+  }
+  /** @internal Materialize authored groups using the existing wire call functions verbatim. */
+  nestClient(t) {
+    const e = Q.get(this).declarationGroups;
+    if (e === void 0) return t;
+    const r = new Set(Object.values(e).flatMap((n) => Object.values(n))), s = /* @__PURE__ */ Object.create(null);
+    for (const [n, o] of Object.entries(t)) r.has(n) || (s[n] = o);
+    for (const [n, o] of Object.entries(e)) {
+      const i = /* @__PURE__ */ Object.create(null);
+      for (const [a, c] of Object.entries(o)) i[a] = t[c];
+      s[n] = i;
+    }
+    return s;
+  }
+  /** Validate grouped implementations atomically, then lower them to wire handlers. */
+  flattenHandlers(t) {
+    const e = Q.get(this).declarationGroups;
+    if (e === void 0) return t;
+    const r = (f, h) => {
+      if (f === null || typeof f != "object" || Array.isArray(f)) throw new Error(`Expected handler group object at "${h}"`);
+      return f;
+    }, s = r(t, this.info.id), n = new Set(Object.values(e).flatMap((f) => Object.values(f))), o = Object.keys(this.members).filter((f) => !n.has(f)), i = /* @__PURE__ */ new Set([...Object.keys(e), ...o]);
+    for (const f of Reflect.ownKeys(s)) if (typeof f != "string" || !i.has(f)) throw new Error(`Unexpected handler "${String(f)}"; grouped members require grouped handlers`);
+    const a = /* @__PURE__ */ Object.create(null), c = (f, h, p) => {
+      if (!Object.hasOwn(f, h) || typeof f[h] != "function") throw new Error(`Missing or invalid handler "${p}"`);
+      return f[h];
+    };
+    for (const f of o) a[f] = c(s, f, f);
+    for (const [f, h] of Object.entries(e)) {
+      if (!Object.hasOwn(s, f)) throw new Error(`Missing handler group "${f}"`);
+      const p = r(s[f], f);
+      for (const m of Reflect.ownKeys(p)) if (typeof m != "string" || !Object.hasOwn(h, m)) throw new Error(`Unexpected handler "${f}.${String(m)}"`);
+      for (const [m, y] of Object.entries(h)) a[y] = c(p, m, `${f}.${m}`);
+    }
+    return a;
+  }
+  /** Content hash of this interface (see `computeInterfaceHash`). */
+  get schemaHash() {
+    const t = Q.get(this);
+    return t.hashCache === void 0 && (t.hashCache = Ce(t.frozenSchema ?? me(this.info, this.members, ""))), t.hashCache;
+  }
+  /** Lower the definition to a wire-format `LinkRpcInterfaceSchema`, hash filled in. */
+  toSchema() {
+    const t = Q.get(this);
+    return t.schemaCache === void 0 && (t.schemaCache = t.frozenSchema !== void 0 ? {
+      ...t.frozenSchema,
+      hash: this.schemaHash,
+      ...this.info.tags !== void 0 ? { tags: [...this.info.tags] } : {}
+    } : me(this.info, this.members, this.schemaHash)), t.schemaCache;
+  }
+};
+function me(t, e, r) {
+  const s = /* @__PURE__ */ Object.create(null), n = {};
+  for (const [i, a] of Object.entries(e)) s[i] = Rr(i, a, n);
+  const o = {
+    id: t.id,
+    hash: r,
+    methods: s
+  };
+  return Object.keys(n).length > 0 && (o.components = { schemas: n }), t.description !== void 0 && (o.description = t.description), t.comment !== void 0 && (o.comment = t.comment), t.tags !== void 0 && (o.tags = [...new Set(t.tags)]), o;
+}
+function Rr(t, e, r, s = (n, o) => Pr(t, o, n, r)) {
+  const n = e.docs;
+  if (e.kind === "request") {
+    const i = {
+      params: s(e.paramsSchema, "params"),
+      result: s(e.resultSchema, "result")
+    };
+    return e.clientStreamSchema !== void 0 && (i.clientStream = s(e.clientStreamSchema, "clientStream")), e.serverStreamSchema !== void 0 && (i.serverStream = s(e.serverStreamSchema, "serverStream")), e.applicationErrors.length > 0 && (i.errors = e.applicationErrors.map((a) => {
+      if (a.bodySchema !== void 0) return {
+        code: a.code,
+        schema: s(a.bodySchema, `error=${a.code}`)
+      };
+      const c = {
+        code: a.code,
+        message: a.message,
+        ...a.type === void 0 ? {} : { type: a.type }
+      };
+      return a.dataSchema !== void 0 && (c.data = s(a.dataSchema, `error=${a.code}`)), c;
+    })), n.description !== void 0 && (i.description = n.description), n.comment !== void 0 && (i.comment = n.comment), n.annotations !== void 0 && (i.annotations = n.annotations), i;
+  }
+  const o = { params: s(e.paramsSchema, "params") };
+  return n.description !== void 0 && (o.description = n.description), n.comment !== void 0 && (o.comment = n.comment), n.annotations !== void 0 && (o.annotations = n.annotations), o;
+}
+function Pr(t, e, r, s) {
+  return ar(r, {
+    methodName: t,
+    schemaPosition: e,
+    components: s
+  });
+}
+function M(t, e, r = {}) {
+  const s = Object.entries(e), n = (p) => p !== null && typeof p == "object" && tt in p && p[tt] === !0;
+  if (!s.some(([, p]) => n(p))) return new rt(t, e, r);
+  const o = /* @__PURE__ */ Object.create(null), i = /* @__PURE__ */ Object.create(null), a = Object.assign(/* @__PURE__ */ Object.create(null), r.templates), c = new Set(s.filter(([, p]) => n(p)).map(([p]) => p)), f = (p, m) => {
+    if (Object.hasOwn(o, p) || c.has(p)) throw new Error(`Interface member collision at "${p}"`);
+    o[p] = m;
+  };
+  for (const [p, m] of s) {
+    if (!n(m)) {
+      f(p, m);
+      continue;
+    }
+    if (Object.hasOwn(a, p)) throw new Error(`Interface template instance collision at "${p}"`);
+    const y = /* @__PURE__ */ Object.create(null);
+    if (m.mapping !== void 0) {
+      for (const _ of Object.keys(m.mapping)) if (!Object.hasOwn(m.members, _)) throw new Error(`Unknown mapped member "${_}"`);
+    }
+    for (const [_, I] of Object.entries(m.members)) {
+      if (m.mapping !== void 0 && !Object.hasOwn(m.mapping, _)) throw new Error(`Missing mapped member "${_}"`);
+      const j = m.mapping === void 0 ? `${p}$${_}` : m.mapping[_];
+      if (typeof j != "string" || j.length === 0) throw new Error(`Missing mapped member "${_}"`);
+      f(j, I), y[_] = j;
+    }
+    i[p] = Object.freeze(y), a[p] = {
+      template: m.template,
+      schema: {
+        template: m.template.id,
+        arguments: m.arguments,
+        members: y
+      }
+    };
+  }
+  const h = new rt(t, o, {
+    ...r,
+    templates: a
+  });
+  return Q.get(h).declarationGroups = Object.freeze(i), h;
+}
+const W = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function At(t) {
+  let e = "", r = 0;
+  for (; r + 3 <= t.length; r += 3) {
+    const n = t[r] << 16 | t[r + 1] << 8 | t[r + 2];
+    e += W[n >> 18 & 63] + W[n >> 12 & 63] + W[n >> 6 & 63] + W[n & 63];
+  }
+  const s = t.length - r;
+  if (s === 1) {
+    const n = t[r] << 16;
+    e += W[n >> 18 & 63] + W[n >> 12 & 63];
+  } else if (s === 2) {
+    const n = t[r] << 16 | t[r + 1] << 8;
+    e += W[n >> 18 & 63] + W[n >> 12 & 63] + W[n >> 6 & 63];
+  }
+  return e;
+}
+const Cr = v({
+  portId: u(),
+  label: g(u())
+}), Tr = v({
+  type: g(u()),
+  label: g(u()),
+  processId: g(P()),
+  processType: g(u()),
+  nodeStatusServiceId: g(u()),
+  metadata: g(wt(u(), K([
+    u(),
+    P(),
+    se()
+  ])))
+}), Nt = v({
+  source: B(["self", "attacher"]),
+  descriptor: Tr
+}), Ar = v({
+  nodeId: u(),
+  kind: g(B(["endpoint", "hub"])),
+  label: g(u()),
+  descriptors: g(T(Nt)),
+  ports: T(Cr)
+}), st = v({
+  nodeId: u(),
+  portId: u()
+}), nt = v({
+  address: g(u()),
+  port: g(P().check(Y(), X()))
+}), Nr = v({
+  type: u(),
+  local: g(nt),
+  remote: g(nt),
+  path: g(u()),
+  metadata: g(wt(u(), K([
+    u(),
+    P(),
+    se()
+  ])))
+}), Mr = v({
+  from: st,
+  to: st,
+  label: g(u()),
+  peerState: g(B([
+    "identified",
+    "pending",
+    "unsupported",
+    "error"
+  ])),
+  transport: g(Nr)
+}), qr = v({
+  serviceId: u(),
+  nodeId: u(),
+  portId: u(),
+  match: B(["exact", "prefix"])
+}), xr = v({
+  observerServiceId: u(),
+  entryNodeId: u(),
+  nodes: T(Ar),
+  links: T(Mr),
+  routes: T(qr)
+}), Lr = M({
+  id: "hubrpc.topology",
+  description: "Inspect the transport graph visible from a service. A watch emits invalidation ticks; consumers re-fetch getGraph after each tick."
+}, {
+  getGraph: w(v({}), xr).withStream({ client: v({}) }),
+  watchGraph: w(v({}), v({})).withStream({ server: v({}) })
+}), ot = v({
+  edgeId: u(),
+  portId: u(),
+  requestId: g(K([P(), u()]))
+}), Wr = v({
+  type: ie("transit"),
+  timeMs: P(),
+  nodeId: u(),
+  in: g(ot),
+  out: g(ot),
+  disposition: B([
+    "forwarded",
+    "consumed",
+    "dropped",
+    "unroutable"
+  ]),
+  kind: B([
+    "request",
+    "notification",
+    "response",
+    "stream"
+  ]),
+  method: g(u()),
+  params: g(V()),
+  result: g(V()),
+  error: g(v({
+    code: P(),
+    message: u(),
+    data: g(V())
+  }))
+}), zr = v({
+  type: ie("overflow"),
+  dropped: P().check(Y(), X())
+}), it = K([Wr, zr]), at = v({
+  delivered: P().check(Y(), X()),
+  dropped: P().check(Y(), X())
+}), Dr = v({
+  methodPrefix: g(u()),
+  trafficIgnoreKey: g(u()),
+  focusRequest: g(v({
+    portId: u(),
+    requestId: K([P(), u()])
+  }))
+}), Hr = v({
+  methodPrefix: g(u()),
+  trafficIgnoreKey: g(u()),
+  focusRequest: g(v({
+    portId: u(),
+    requestId: K([P(), u()])
+  })),
+  maxPayloadBytes: P().check(Y(), X())
+}), Ur = M({
+  id: "hubrpc.traffic",
+  description: "Stream raw message transits for the entire node hosting the addressed service. Payload-free and explicitly payload-bearing variants keep disclosure opt-in."
+}, {
+  watch: w(Dr, at).withStream({ server: it }),
+  watchWithPayloads: w(Hr, at).withStream({ server: it })
+}), Br = v({
+  /**
+  * Random identity of this connection's node. It is a topology-correlation
+  * label only and must not be used for authentication or authorization.
+  */
+  nodeId: u(),
+  /** Random identity of this connection's port on its node. */
+  portId: u(),
+  /** Optional diagnostic descriptors; never used for authorization. */
+  descriptors: g(T(Nt))
+}), Mt = M({
+  id: "hubrpc.node",
+  description: "Topology bootstrap: identify the node and port at this end of the direct connection."
+}, { getNodeId: w(v({}), Br) }), F = {
+  /** callee → caller: progress, partial results. Routes like a response. */
+  toCaller: "toCaller",
+  /** caller → callee: input, cancellation, keepalive ping. */
+  toCallee: "toCallee"
+}, H = {
+  /**
+  * Ask the callee to abort the in-flight request. Always {@link
+  * StreamDir.toCallee}. The callee surfaces this as an `AbortSignal`
+  * and is expected to settle the request (typically with a
+  * `cancelled` error response).
+  */
+  cancel: "cancel",
+  /**
+  * Keepalive / liveness probe. Resets the hub's per-request idle timer
+  * so a long-running call is not reaped, and lets either side actively
+  * probe the peer. Carries a `nonce` the peer echoes in its {@link
+  * StreamControlType.pong}. May travel in either direction. Emitted
+  * automatically (without awaiting a pong) by the channel for streaming
+  * calls; see {@link STREAM_METHOD}.
+  */
+  ping: "ping",
+  /**
+  * Reply to a {@link StreamControlType.ping}, echoing the ping's
+  * `nonce` so the prober can correlate it. Travels opposite the ping.
+  * Carries no app effect — purely a liveness acknowledgement.
+  */
+  pong: "pong"
+}, Kr = M({
+  id: "$stream",
+  description: "Reserved sub-protocol for in-flight stream messages correlated to a request by `requestId`."
+}, { send: ir(v({
+  /**
+  * Id of the in-flight request the message belongs to.
+  * The hub rewrites this across the forwarding boundary
+  * in the same way it rewrites response ids.
+  */
+  requestId: K([P(), u()]),
+  /**
+  * Which way this message travels relative to the request.
+  * Explicit so the hub can author messages (e.g. cancel on
+  * disconnect) without inferring direction from arrival.
+  */
+  dir: B(["toCaller", "toCallee"]),
+  /**
+  * Reserved control verb (cancel / ping / pong). Mutually
+  * exclusive with `payload` in practice: a control message
+  * is interpreted by the runtime, not the application.
+  */
+  control: g(v({
+    type: B([
+      "cancel",
+      "ping",
+      "pong"
+    ]),
+    /** Open-set human/diagnostic reason; see {@link StreamControlReason}. */
+    reason: g(u()),
+    /**
+    * Correlation token. A `ping` carries a fresh nonce;
+    * the matching `pong` echoes it back so the prober
+    * can resolve the right outstanding probe.
+    */
+    nonce: g(u())
+  })),
+  /** Opaque app payload — typed per call by the request's stream schema. */
+  payload: g(V())
+}), { description: "Emit a stream message tied to the request `requestId`." }) }), te = `${Kr.info.id}::send`;
+var Jr = class {
+  constructor(t) {
+    l(this, "_focused");
+    this._focused = t.focus !== void 0 ? new qt([t.focus]) : void 0;
+  }
+  shouldInclude(t) {
+    var e;
+    return ((e = this._focused) == null ? void 0 : e.accept(t).matches) ?? !0;
+  }
+}, Fr = class {
+  constructor() {
+    l(this, "_active", /* @__PURE__ */ new Set());
+    l(this, "_unclaimed", /* @__PURE__ */ new Map());
+  }
+  accept(t) {
+    if (t.kind === "request" && Vr(t.method)) {
+      const e = Yr(t.params);
+      let r = this._findFlow(t);
+      return r === void 0 ? (r = new qt(We(t), Gr(t)), Le(t) || this._active.add(r)) : r.accept(t), Le(t) ? (this._removeFlow(r), !0) : (e !== void 0 && this._unclaimed.set(e, r), !0);
+    }
+    for (const e of this._active) {
+      const r = e.accept(t);
+      if (r.matches)
+        return r.completed && this._removeFlow(e), !0;
+    }
+    return !1;
+  }
+  _findFlow(t) {
+    for (const e of this._active) if (e.matches(t)) return e;
+  }
+  _removeFlow(t) {
+    this._active.delete(t);
+    for (const [e, r] of this._unclaimed) r === t && this._unclaimed.delete(e);
+  }
+  claim(t) {
+    return this._unclaimed.delete(t);
+  }
+  clear() {
+    this._active.clear(), this._unclaimed.clear();
+  }
+  forgetPort(t) {
+    for (const e of this._active) e.hasPort(t) && this._removeFlow(e);
+  }
+}, qt = class {
+  constructor(t, e = t[0]) {
+    l(this, "_endpoints", /* @__PURE__ */ new Set());
+    l(this, "_ports", /* @__PURE__ */ new Set());
+    l(this, "_completionEndpoint");
+    for (const r of t)
+      this._endpoints.add(Z(r)), this._ports.add(r.portId);
+    this._completionEndpoint = e === void 0 ? void 0 : Z(e);
+  }
+  matches(t) {
+    return We(t).some((e) => this._endpoints.has(Z(e)));
+  }
+  hasPort(t) {
+    return this._ports.has(t);
+  }
+  accept(t) {
+    const e = We(t);
+    if (!this.matches(t)) return {
+      matches: !1,
+      completed: !1
+    };
+    for (const s of e)
+      this._endpoints.add(Z(s)), this._ports.add(s.portId);
+    const r = t.kind === "response" && (Le(t) || this._completionEndpoint !== void 0 && e.some((s) => Z(s) === this._completionEndpoint));
+    return r && this._endpoints.clear(), {
+      matches: !0,
+      completed: r
+    };
+  }
+};
+function Le(t) {
+  return t.disposition === "dropped" || t.disposition === "unroutable";
+}
+function We(t) {
+  var r, s;
+  const e = [];
+  return ((r = t.in) == null ? void 0 : r.requestId) !== void 0 && e.push(fe(t.in)), ((s = t.out) == null ? void 0 : s.requestId) !== void 0 && e.push(fe(t.out)), e;
+}
+function fe(t) {
+  return {
+    portId: t.portId,
+    requestId: t.requestId
+  };
+}
+function Gr(t) {
+  var e, r;
+  if (((e = t.in) == null ? void 0 : e.requestId) !== void 0) return fe(t.in);
+  if (((r = t.out) == null ? void 0 : r.requestId) !== void 0) return fe(t.out);
+}
+function Z(t) {
+  return JSON.stringify([
+    t.portId,
+    typeof t.requestId,
+    t.requestId
+  ]);
+}
+function Vr(t) {
+  return (t == null ? void 0 : t.endsWith("::hubrpc.traffic::watch")) === !0 || (t == null ? void 0 : t.endsWith("::hubrpc.traffic::watchWithPayloads")) === !0 || t === "hubrpc.traffic::watch" || t === "hubrpc.traffic::watchWithPayloads";
+}
+function Yr(t) {
+  if (t === null || Array.isArray(t) || typeof t != "object" || !("trafficIgnoreKey" in t)) return;
+  const e = t.trafficIgnoreKey;
+  return typeof e == "string" ? e : void 0;
+}
+const Qr = 256;
+var Xr = class {
+  constructor(t, e, r, s = Qr) {
+    l(this, "_options");
+    l(this, "_send");
+    l(this, "_onDispose");
+    l(this, "_queueLimit");
+    l(this, "_queue", []);
+    l(this, "_active", !0);
+    l(this, "_pumping", !1);
+    l(this, "_overflowPending", 0);
+    l(this, "_delivered", 0);
+    l(this, "_dropped", 0);
+    l(this, "_resolveClosed");
+    l(this, "_filter");
+    l(this, "closed");
+    this._options = t, this._send = e, this._onDispose = r, this._queueLimit = s;
+    let n;
+    this.closed = new Promise((o) => n = o), this._resolveClosed = n, this._filter = new Jr({ focus: t.focusRequest });
+  }
+  enqueue(t) {
+    var r;
+    if (!this._active || !this._filter.shouldInclude(t) || this._options.methodPrefix !== void 0 && !((r = t.method) != null && r.startsWith(this._options.methodPrefix))) return;
+    const e = this._options.maxPayloadBytes === void 0 ? Zr(t) : es(t, this._options.maxPayloadBytes);
+    this._queue.length >= this._queueLimit && (this._queue.shift(), this._dropped++, this._overflowPending++), this._queue.push(e), this._pumping || (this._pumping = !0, queueMicrotask(() => void this._pump()));
+  }
+  dispose() {
+    this._active && (this._active = !1, this._dropped += this._queue.length, this._queue.length = 0, this._overflowPending = 0, this._onDispose(), this._pumping || this._complete());
+  }
+  async _pump() {
+    try {
+      for (; this._active; ) {
+        if (this._overflowPending > 0) {
+          const e = this._overflowPending;
+          this._overflowPending = 0, await this._send({
+            type: "overflow",
+            dropped: e
+          });
+          continue;
+        }
+        const t = this._queue.shift();
+        if (t === void 0) break;
+        await this._send(t), this._delivered++;
+      }
+    } catch {
+      this.dispose();
+    } finally {
+      this._pumping = !1, this._active ? (this._queue.length > 0 || this._overflowPending > 0) && (this._pumping = !0, queueMicrotask(() => void this._pump())) : this._complete();
+    }
+  }
+  _complete() {
+    this._resolveClosed({
+      delivered: this._delivered,
+      dropped: this._dropped
+    });
+  }
+};
+function Zr(t) {
+  const { params: e, result: r, error: s, ...n } = t;
+  return s === void 0 ? n : {
+    ...n,
+    error: {
+      code: s.code,
+      message: s.message
+    }
+  };
+}
+function es(t, e) {
+  return {
+    ...t,
+    params: ge(t.params, e),
+    result: ge(t.result, e),
+    error: t.error === void 0 ? void 0 : {
+      ...t.error,
+      data: ge(t.error.data, e)
+    }
+  };
+}
+function ge(t, e) {
+  if (t === void 0) return;
+  if (e === Number.POSITIVE_INFINITY) return t;
+  const r = JSON.stringify(t);
+  if (r === void 0) return;
+  const s = new TextEncoder().encode(r);
+  if (s.byteLength <= e) return t;
+  const n = new TextEncoder();
+  let o = new TextDecoder().decode(s.slice(0, e));
+  for (; n.encode(o).byteLength > e; ) o = o.slice(0, -1);
+  return o;
+}
+const ts = 18e5, rs = 4096;
+var xt = class {
+  constructor(t, e, r, s) {
+    l(this, "_nodeId");
+    l(this, "_portId");
+    l(this, "_emit");
+    l(this, "_isObserved");
+    l(this, "_outboundRequests", /* @__PURE__ */ new Map());
+    l(this, "_inboundRequests", /* @__PURE__ */ new Map());
+    l(this, "observe", (t, e) => {
+      this._onMessage(t, e);
+    });
+    this._nodeId = t, this._portId = e, this._emit = r, this._isObserved = s;
+  }
+  dispose() {
+    this._outboundRequests.clear(), this._inboundRequests.clear();
+  }
+  _onMessage(t, e) {
+    const r = Date.now();
+    this._pruneRequestCorrelations(r);
+    const s = this._isObserved();
+    s || this.dispose();
+    let n;
+    const o = this._endpoint("id" in e ? e.id ?? void 0 : void 0), i = {
+      type: "transit",
+      timeMs: r,
+      nodeId: this._nodeId,
+      ...t === "inbound" ? { in: o } : { out: o },
+      disposition: t === "inbound" ? "consumed" : "forwarded"
+    };
+    if (yt(e)) {
+      const c = {
+        method: e.method,
+        timeMs: r
+      };
+      if (s) {
+        const f = this._requestMap(t), h = a(e.id);
+        f.delete(h), f.set(h, c);
+      }
+      n = {
+        ...i,
+        kind: "request",
+        method: e.method,
+        params: e.params
+      };
+    } else if (ke(e)) {
+      const c = t === "inbound" ? this._outboundRequests : this._inboundRequests, f = a(e.id), h = c.get(f);
+      c.delete(f), n = {
+        ...i,
+        kind: "response",
+        method: h == null ? void 0 : h.method,
+        result: "result" in e ? e.result : void 0,
+        error: "error" in e ? e.error : void 0
+      };
+    } else if (Se(e) && e.method === te) {
+      const c = e.params, f = this._endpoint(c == null ? void 0 : c.requestId);
+      n = {
+        ...i,
+        ...t === "inbound" ? { in: f } : { out: f },
+        kind: "stream",
+        method: te,
+        params: e.params
+      };
+    } else n = {
+      ...i,
+      kind: "notification",
+      method: e.method,
+      params: e.params
+    };
+    function a(c) {
+      return JSON.stringify([typeof c, c]);
+    }
+    this._emit(n);
+  }
+  _requestMap(t) {
+    return t === "outbound" ? this._outboundRequests : this._inboundRequests;
+  }
+  _endpoint(t) {
+    return {
+      edgeId: this._portId,
+      portId: this._portId,
+      ...t !== void 0 ? { requestId: t } : {}
+    };
+  }
+  _pruneRequestCorrelations(t) {
+    this._pruneRequestMap(this._outboundRequests, t), this._pruneRequestMap(this._inboundRequests, t);
+  }
+  _pruneRequestMap(t, e) {
+    for (; t.size !== 0; ) {
+      const r = t.entries().next().value;
+      if (r === void 0 || t.size <= rs && e - r[1].timeMs <= ts) return;
+      t.delete(r[0]);
+    }
+  }
+}, ss = class {
+  constructor(t, e, r, s) {
+    l(this, "_connection");
+    l(this, "_nodeId");
+    l(this, "_options");
+    l(this, "_isObserved");
+    this._connection = t, this._nodeId = e, this._options = r, this._isObserved = s;
+  }
+  snapshotTopology() {
+    const { portId: t, label: e, peer: r, transport: s } = this._options, n = [{
+      nodeId: this._nodeId,
+      ports: [{
+        portId: t,
+        ...e === void 0 ? {} : { label: e }
+      }]
+    }], o = [];
+    return r !== void 0 && (n.push({
+      nodeId: r.nodeId,
+      kind: "endpoint",
+      ...r.label === void 0 ? {} : { label: r.label },
+      ports: [{ portId: r.portId }]
+    }), o.push({
+      from: {
+        nodeId: this._nodeId,
+        portId: t
+      },
+      to: {
+        nodeId: r.nodeId,
+        portId: r.portId
+      },
+      peerState: "identified",
+      ...s === void 0 ? {} : { transport: s }
+    })), {
+      nodes: n,
+      links: o,
+      routes: []
+    };
+  }
+  onTopologyChanged(t) {
+    return { dispose: () => {
+    } };
+  }
+  observeTraffic(t) {
+    const e = new xt(this._nodeId, this._options.portId, t, this._isObserved), r = this._connection.observeWireMessages(e.observe);
+    return { dispose: () => {
+      r.dispose(), e.dispose();
+    } };
+  }
+}, ns = class {
+  constructor(t) {
+    l(this, "_options");
+    l(this, "_sources", /* @__PURE__ */ new Map());
+    l(this, "_trackedConnections", /* @__PURE__ */ new Set());
+    l(this, "_bindings", /* @__PURE__ */ new Set());
+    l(this, "_subscribers", /* @__PURE__ */ new Set());
+    l(this, "_observers", /* @__PURE__ */ new Set());
+    l(this, "_topologyListeners", /* @__PURE__ */ new Set());
+    l(this, "_trafficSources", /* @__PURE__ */ new Set());
+    l(this, "_trafficWatches", new Fr());
+    l(this, "_disposed", !1);
+    l(this, "nodeId");
+    this._options = t, this.nodeId = t.nodeId;
+  }
+  get observerCount() {
+    return this._subscribers.size + this._observers.size;
+  }
+  addSource(t) {
+    if (this._assertActive(), this._sources.has(t)) throw new Error("Inspection source is already registered");
+    const e = () => new Set(t.snapshotTopology().nodes.flatMap((i) => i.ports.map((a) => a.portId)));
+    let r = e();
+    const s = t.onTopologyChanged(() => {
+      const i = e(), a = [...r].filter((c) => !i.has(c));
+      r = i, this._forgetUnusedPorts(a), this._invalidateTopology();
+    });
+    let n;
+    try {
+      n = t.observeTraffic((i) => this.publishTransit(i));
+    } catch (i) {
+      throw s.dispose(), i;
+    }
+    const o = { dispose: () => {
+      this._sources.get(t) === o && (this._sources.delete(t), s.dispose(), n.dispose(), this._forgetUnusedPorts([...r]), this._invalidateTopology());
+    } };
+    return this._sources.set(t, o), this._invalidateTopology(), o;
+  }
+  trackConnection(t, e) {
+    if (this._assertActive(), this.getGraph("").nodes.some((i) => i.ports.some((a) => a.portId === e.portId))) throw new Error(`Inspection port "${e.portId}" is already registered`);
+    const r = new ss(t, this.nodeId, e, () => this.observerCount !== 0), s = this.addSource(r);
+    let n;
+    try {
+      n = t.onDidClose(() => o.dispose());
+    } catch (i) {
+      throw s.dispose(), i;
+    }
+    const o = { dispose: () => {
+      this._trackedConnections.delete(o), n.dispose(), s.dispose();
+    } };
+    return this._trackedConnections.add(o), o;
+  }
+  expose(t, e) {
+    this._assertActive();
+    const r = e.portId ?? is(), s = new os(r), n = [];
+    this._bindings.add(s);
+    const o = { serviceId: e.serviceId };
+    try {
+      const i = new xt(this.nodeId, r, (a) => this._trafficWatches.accept(a), () => !1);
+      n.push(t.observeWireMessages(i.observe)), n.push({ dispose: () => i.dispose() }), n.push(t.registerInspection(Mt, { getNodeId: () => ({
+        nodeId: this.nodeId,
+        portId: r,
+        ...(e.descriptors ?? this._options.descriptors) === void 0 ? {} : { descriptors: [...e.descriptors ?? this._options.descriptors ?? []] }
+      }) }, o)), n.push(t.registerInspection(Lr, {
+        getGraph: () => this.getGraph(e.serviceId, e.includeRoute === !1 ? void 0 : r),
+        watchGraph: (a, c, f) => this._watchGraph(s, f)
+      }, o)), n.push(t.registerInspection(Ur, {
+        watch: (a, c, f) => this._watchTraffic(s, a, f),
+        watchWithPayloads: (a, c, f) => this._watchTraffic(s, a, f)
+      }, o));
+    } catch (i) {
+      for (const a of n.reverse()) a.dispose();
+      throw this._bindings.delete(s), i;
+    }
+    return s.onDispose = () => {
+      this._bindings.delete(s);
+      for (const i of n.reverse()) i.dispose();
+      this._forgetUnusedPorts([r]), this._invalidateTopology();
+    }, n.push(t.onDidClose(() => s.dispose())), this._invalidateTopology(), s;
+  }
+  getGraph(t, e) {
+    this._assertActive();
+    const r = /* @__PURE__ */ new Map(), s = (i) => {
+      const a = r.get(i.nodeId), c = new Map(a == null ? void 0 : a.ports.map((f) => [f.portId, f]));
+      for (const f of i.ports) c.set(f.portId, {
+        ...c.get(f.portId),
+        ...f
+      });
+      r.set(i.nodeId, {
+        ...a,
+        ...i,
+        ports: [...c.values()]
+      });
+    };
+    s({
+      nodeId: this.nodeId,
+      kind: this._options.kind ?? "endpoint",
+      ...this._options.label === void 0 ? {} : { label: this._options.label },
+      ...this._options.descriptors === void 0 ? {} : { descriptors: [...this._options.descriptors] },
+      ports: []
+    });
+    const n = [], o = [];
+    for (const i of this._sources.keys()) {
+      const a = i.snapshotTopology();
+      for (const c of a.nodes) s(c);
+      n.push(...a.links), o.push(...a.routes);
+    }
+    for (const i of this._bindings) s({
+      nodeId: this.nodeId,
+      ports: [{ portId: i.portId }]
+    });
+    return e !== void 0 && o.push({
+      serviceId: t,
+      nodeId: this.nodeId,
+      portId: e,
+      match: "exact"
+    }), {
+      observerServiceId: t,
+      entryNodeId: this.nodeId,
+      nodes: [...r.values()],
+      links: n,
+      routes: o
+    };
+  }
+  publishTransit(t) {
+    if (!(this._disposed || this._trafficWatches.accept(t))) {
+      for (const e of [...this._observers]) try {
+        e(t);
+      } catch {
+      }
+      for (const e of this._subscribers) e.enqueue(t);
+    }
+  }
+  subscribe(t, e) {
+    if (this._assertActive(), t.trafficIgnoreKey !== void 0 && !this._trafficWatches.claim(t.trafficIgnoreKey)) throw new Error("Traffic watch request was not observed before subscription");
+    const r = new Xr(t, e, () => {
+      this._subscribers.delete(r), this._stopUnusedTrafficSources();
+    });
+    this._subscribers.add(r);
+    try {
+      this._startTrafficSources();
+    } catch (s) {
+      throw r.dispose(), s;
+    }
+    return r;
+  }
+  observeTraffic(t) {
+    this._assertActive(), this._observers.add(t);
+    const e = { dispose: () => {
+      this._observers.delete(t), this._stopUnusedTrafficSources();
+    } };
+    try {
+      this._startTrafficSources();
+    } catch (r) {
+      throw e.dispose(), r;
+    }
+    return e;
+  }
+  addTrafficSource(t) {
+    this._assertActive();
+    const e = { source: t };
+    this._trafficSources.add(e);
+    try {
+      this._startTrafficSources();
+    } catch (r) {
+      throw this._trafficSources.delete(e), r;
+    }
+    return { dispose: () => {
+      var r;
+      this._trafficSources.delete(e), (r = e.observation) == null || r.dispose(), e.observation = void 0;
+    } };
+  }
+  dispose() {
+    if (!this._disposed) {
+      this._disposed = !0;
+      for (const t of [...this._bindings]) t.dispose();
+      for (const t of [...this._subscribers]) t.dispose();
+      this._observers.clear(), this._stopUnusedTrafficSources(), this._trafficSources.clear();
+      for (const t of [...this._trackedConnections]) t.dispose();
+      for (const t of [...this._sources.values()]) t.dispose();
+      this._topologyListeners.clear(), this._trafficWatches.clear();
+    }
+  }
+  _startTrafficSources() {
+    if (this.observerCount !== 0)
+      for (const t of this._trafficSources) t.observation ?? (t.observation = t.source.observe((e) => this.publishTransit(e)));
+  }
+  _stopUnusedTrafficSources() {
+    var t;
+    if (this.observerCount === 0)
+      for (const e of this._trafficSources)
+        (t = e.observation) == null || t.dispose(), e.observation = void 0;
+  }
+  _invalidateTopology() {
+    if (!this._disposed)
+      for (const t of this._topologyListeners) t();
+  }
+  _forgetUnusedPorts(t) {
+    if (this._disposed) return;
+    const e = new Set(this.getGraph("").nodes.flatMap((r) => r.ports.map((s) => s.portId)));
+    for (const r of t) e.has(r) || this._trafficWatches.forgetPort(r);
+  }
+  _watchGraph(t, e) {
+    return new Promise((r, s) => {
+      let n = !1, o = !0;
+      const i = () => {
+        o = !1, this._topologyListeners.delete(a), e.signal.removeEventListener("abort", i), t.abort.signal.removeEventListener("abort", i), r({});
+      }, a = () => {
+        n || !o || (n = !0, queueMicrotask(() => {
+          n = !1, o && e.send({}).catch((c) => {
+            s(c), i();
+          });
+        }));
+      };
+      this._topologyListeners.add(a), e.signal.addEventListener("abort", i, { once: !0 }), t.abort.signal.addEventListener("abort", i, { once: !0 }), (e.signal.aborted || t.abort.signal.aborted) && i();
+    });
+  }
+  async _watchTraffic(t, e, r) {
+    const s = this.subscribe(e, (o) => r.send(o)), n = () => s.dispose();
+    r.signal.addEventListener("abort", n, { once: !0 }), t.abort.signal.addEventListener("abort", n, { once: !0 }), (r.signal.aborted || t.abort.signal.aborted) && n();
+    try {
+      return await s.closed;
+    } finally {
+      r.signal.removeEventListener("abort", n), t.abort.signal.removeEventListener("abort", n), s.dispose();
+    }
+  }
+  _assertActive() {
+    if (this._disposed) throw new Error("Inspection host is disposed");
+  }
+}, os = class {
+  constructor(t) {
+    l(this, "portId");
+    l(this, "abort", new AbortController());
+    l(this, "onDispose", () => {
+    });
+    this.portId = t;
+  }
+  dispose() {
+    this.abort.signal.aborted || (this.abort.abort(), this.onDispose());
+  }
+};
+function is() {
+  const t = /* @__PURE__ */ new Uint8Array(16);
+  return globalThis.crypto.getRandomValues(t), `port:${At(t)}`;
+}
+var ct = class extends Error {
+  constructor(e, r) {
+    super(`Server error ${e.code} does not match its declared schema: ${r.map((s) => `${s.path || "/"}: ${s.message}`).join("; ")}`);
+    l(this, "original");
+    l(this, "issues");
+    l(this, "kind", "nonCompliantServer");
+    this.original = e, this.issues = r, this.name = "NonCompliantServerError";
+  }
+};
+function dt(t) {
+  if (t.includes("::") || !/^[\x20-\x7e]*$/.test(t)) throw new Error('Bare interface prefix must contain only printable ASCII and must not contain "::".');
+}
+new Set("break case catch class const continue debugger default delete do else enum export extends false finally for function if import in instanceof new null return super switch this throw true try typeof var void while with implements interface let package private protected public static yield await".split(" "));
+function as(t) {
+  const e = t.split("::");
+  if (e.length === 3 && e[0].length === 0 && e[1].length > 0 && e[2].length > 0) return {
+    kind: "interface",
+    interfaceId: e[1],
+    member: e[2]
+  };
+  if (!e.some((r) => r.length === 0)) {
+    if (e.length === 1) return {
+      kind: "bare",
+      member: e[0]
+    };
+    if (e.length === 2) return {
+      kind: "interface",
+      interfaceId: e[0],
+      member: e[1]
+    };
+    if (e.length === 3) return {
+      kind: "full",
+      serviceId: e[0],
+      interfaceId: e[1],
+      member: e[2]
+    };
+  }
+}
+const cs = "$hubrpcSignature", ds = "$hubrpcUnsigned", fs = "$hubrpc";
+function ft(t) {
+  if (t === void 0) return;
+  if (t === null || typeof t != "object" || Array.isArray(t)) return t;
+  const e = t, r = [
+    fs,
+    cs,
+    ds
+  ];
+  if (!r.some((n) => n in e)) return e;
+  const s = {};
+  for (const n of Object.keys(e))
+    r.includes(n) || (s[n] = e[n]);
+  return s;
+}
+const ht = M({
+  id: "hubrpc.defaults",
+  description: "Reflection: preset default service / interface on this connection."
+}, {
+  get: w(v({}), v({
+    serviceId: g(u()),
+    interfaceId: g(u()),
+    /** Hash of the preset interface, if known. */
+    interfaceHash: g(u())
+  })),
+  listBindings: w(v({}), v({ bindings: T(v({
+    prefix: u(),
+    serviceId: g(u()),
+    interfaceId: u(),
+    interfaceHash: u()
+  })) }))
+}), hs = v({
+  principal: u(),
+  transitive: g(se())
+}), ls = T(hs), ze = K([v({ exact: u() }), v({ prefix: u() })]), ps = v({
+  serviceId: u(),
+  interfaceId: u(),
+  /** Hash of the interface as implemented by this service. */
+  interfaceHash: u(),
+  /** Optional, non-authoritative discovery labels of this implemented interface. */
+  tags: g(T(u())),
+  /** Optional non-normative description of the owning service. */
+  serviceDescription: g(u()),
+  /**
+  * Root principals required to access this service, in CNF: the caller must
+  * satisfy **every** set (AND), and a set is satisfied by **any one** of its
+  * principals (OR). Omitted/empty => no root-principal requirement.
+  */
+  rootPrincipalSets: g(T(ls)),
+  /**
+  * Service-id regions reachable through this referral. Meaningful only for
+  * `hubrpc.directory` entries; omission defaults to the referral service-id
+  * subtree.
+  */
+  reachableServiceIds: g(T(ze))
+}), lt = M({
+  id: "hubrpc.directory",
+  description: "Reflection: list services exposed by this endpoint. Can also list other directory services that can be explored."
+}, {
+  list: w(v({
+    /** Filter: only return services implementing this interface id. */
+    interfaceId: g(u()),
+    /** Filter: only return services whose interface id starts with this prefix. */
+    interfaceIdPrefix: g(u()),
+    /** Filter: only return entries for this service id. */
+    serviceId: g(u()),
+    /** Union filter used to constrain a transitive directory walk. */
+    serviceIdScopes: g(T(ze)),
+    /** Paging: opaque continuation token from a previous response. */
+    cursor: g(u()),
+    /** Paging: max items in this page. Server MAY return fewer. */
+    limit: g(P().check(Y(), Kt())),
+    /** Soft cap on time the server spends gathering this page, in ms. */
+    timeoutMs: g(P().check(Y(), X()))
+  }), v({
+    items: T(ps),
+    /** Omitted => no more pages. */
+    nextCursor: g(u()),
+    /** True if `timeoutMs` cut the page short before exhausting results. */
+    truncated: g(se())
+  })),
+  /**
+  * Coarse change tap on the directory.
+  *
+  * `watch` is a long-lived streaming request that emits an **empty tick**
+  * whenever the (optionally filtered) directory *might* have changed. The
+  * tick carries no delta and no payload — its only meaning is "re-`list`
+  * now". The consumer reconciles against its own last snapshot.
+  *
+  * This keeps the server stateless: it never computes or replays
+  * per-item deltas, never does an initial-sync replay. Over-emission is
+  * allowed (the consumer re-lists and finds nothing new); under-emission
+  * is not. Ticks are coalesced. The `interfaceId` / `serviceId` filters
+  * mirror `list` and are a relevance hint, not a guarantee.
+  *
+  * The request resolves when the caller cancels (or the connection
+  * drops); the runtime auto-detaches the stream when it settles.
+  */
+  watch: w(v({
+    /** Relevance hint: changes touching this interface id. */
+    interfaceId: g(u()),
+    /** Relevance hint: changes touching an interface id with this prefix. */
+    interfaceIdPrefix: g(u()),
+    /** Relevance hint: changes touching this service id. */
+    serviceId: g(u()),
+    /** Relevance hint: changes within any of these service-id regions. */
+    serviceIdScopes: g(T(ze))
+  }), v({})).withStream({
+    /** Empty tick: "the directory may have changed; re-list." */
+    server: v({})
+  })
+}), De = M({
+  id: "hubrpc.schemas",
+  description: "Reflection: fetch interface schemas by id (+ optional hash). Must serve the interfaces advertised in this endpoint's directory."
+}, { get: w(v({
+  interfaceId: u(),
+  /** Omit => server picks the version it exposes. */
+  hash: g(u())
+}), v({
+  /** A full `SvcInterfaceSchema`. */
+  schema: V()
+})) });
+function us(t, e) {
+  return "exact" in e ? t === e.exact : e.prefix === "" || t === e.prefix || t.startsWith(`${e.prefix}/`);
+}
+function Lt(t, e) {
+  return e === void 0 || e.some((r) => us(t, r));
+}
+var ms = class Wt {
+  constructor(e, r, s) {
+    l(this, "sender");
+    l(this, "_setHandler");
+    l(this, "_setWireObserver");
+    this.sender = e, this._setHandler = r, this._setWireObserver = s;
+  }
+  /** Bind the inbound request/notification handler. May be called before or after construction of {@link LinkRpcConnection}. */
+  setRequestHandler(e) {
+    this._setHandler(e);
+  }
+  /**
+  * Install the endpoint inspection observer at the JSON-RPC wire boundary.
+  * Intended for {@link LinkRpcConnection}; ordinary consumers should use the
+  * public `hubrpc.traffic` service instead.
+  */
+  setWireMessageObserver(e) {
+    var r;
+    (r = this._setWireObserver) == null || r.call(this, e);
+  }
+  /**
+  * Compose this channel with a sender-side decorator (typically the
+  * signing layer). The decorator wraps {@link sender} only; the
+  * {@link setRequestHandler} binding is shared with the original channel
+  * so the receive side is bound exactly once regardless of decoration depth.
+  */
+  withSender(e) {
+    return new Wt(e(this.sender), this._setHandler, this._setWireObserver);
+  }
+}, A = class extends Error {
+  constructor(e, r, s, n = "local", o = s !== void 0) {
+    super(e);
+    l(this, "code");
+    l(this, "origin");
+    l(this, "data");
+    l(this, "hasData");
+    this.code = r, this.origin = n, this.message = e, this.name = "RpcError", this.hasData = o, o && (this.data = s);
+  }
+};
+const gs = 6e5;
+var vs = class zt {
+  constructor(e, r) {
+    l(this, "_transport");
+    l(this, "_requestsDeferred");
+    l(this, "_nextId", 1);
+    l(this, "_pending", /* @__PURE__ */ new Map());
+    /**
+    * Per-request callbacks invoked when a {@link STREAM_METHOD}
+    * notification arrives with a matching `requestId`. Used in both
+    * directions: outgoing-request callers register here keyed by the
+    * id they sent; per-call incoming-request stream handles register
+    * keyed by the id they observed. Entries are removed when the
+    * corresponding request completes (response received for outgoing,
+    * response sent for incoming).
+    */
+    l(this, "_streamListeners", /* @__PURE__ */ new Map());
+    /**
+    * Per-incoming-request handlers for reserved `control` messages
+    * (cancel / ping / pong) arriving as stream notifications. Keyed
+    * by the id observed; removed when the request settles.
+    */
+    l(this, "_streamControl", /* @__PURE__ */ new Map());
+    l(this, "_incomingAborts", /* @__PURE__ */ new Map());
+    l(this, "_handler");
+    l(this, "_wireObserver");
+    l(this, "_closeError");
+    l(this, "_deferredMessages", []);
+    this._transport = e, this._requestsDeferred = r, this._transport.setListener((s) => this._onMessage(s));
+  }
+  /**
+  * Wrap a transport in a {@link Channel}. The channel's sender is live
+  * immediately; call {@link Channel.setRequestHandler} (or pass the channel
+  * to {@link LinkRpcConnection}) to bind the inbound handler.
+  */
+  static create(e) {
+    return this.createWithClose(e).channel;
+  }
+  /**
+  * Wrap a transport with lifecycle hooks. deferRequests queues requests,
+  * notifications, and their input streams until resumeRequests is called.
+  * Responses and output streams remain live for setup-time outbound calls.
+  */
+  static createWithClose(e, r = {}) {
+    const s = new zt(e, r.deferRequests === !0);
+    return {
+      channel: new ms(s, (n) => s.setRequestHandler(n), (n) => s.setWireMessageObserver(n)),
+      close: () => s.close(),
+      resumeRequests: () => s.resumeRequests()
+    };
+  }
+  setRequestHandler(e) {
+    this._handler = e;
+  }
+  setWireMessageObserver(e) {
+    this._wireObserver = e;
+  }
+  resumeRequests() {
+    for (; this._deferredMessages.length > 0; ) this._dispatchMessage(this._deferredMessages.shift());
+    this._requestsDeferred = !1;
+  }
+  async sendRequest(e, r, s) {
+    this._throwIfClosed();
+    const n = this._nextId++, o = {
+      jsonrpc: "2.0",
+      id: n,
+      method: e
+    };
+    r !== void 0 && (o.params = r);
+    const i = new Promise((a, c) => {
+      this._pending.set(String(n), {
+        resolve: a,
+        reject: c
+      });
+    });
+    this._observeOutbound(o, s);
+    try {
+      await this._transport.send(o);
+    } catch (a) {
+      throw this._pending.delete(String(n)), this._observeSendFailure(n, a), a;
+    }
+    return i;
+  }
+  async sendNotification(e, r, s) {
+    this._throwIfClosed();
+    const n = {
+      jsonrpc: "2.0",
+      method: e
+    };
+    r !== void 0 && (n.params = r), this._observeOutbound(n, s), await this._transport.send(n);
+  }
+  sendRequestWithStream(e, r, s) {
+    var y;
+    this._throwIfClosed();
+    const n = this._nextId++, o = String(n);
+    let i, a;
+    const c = new Promise((_, I) => {
+      i = _, a = I;
+    });
+    this._pending.set(o, {
+      resolve: i,
+      reject: a
+    }), s != null && s.onStreamMessage && this._streamListeners.set(o, s.onStreamMessage);
+    const f = this._makePinger(n, F.toCallee);
+    this._streamControl.set(o, f.onControl);
+    const h = setInterval(() => {
+      this._sendStream(n, F.toCallee, { control: { type: H.ping } });
+    }, gs);
+    (y = h.unref) == null || y.call(h);
+    const p = () => {
+      clearInterval(h), f.dispose(), this._streamControl.delete(o);
+    }, m = (_ = "streaming request disposed") => {
+      this._pending.delete(o) && (this._streamListeners.delete(o), p(), a(new A(_, R.cancelled)));
+    };
+    return c.then(p, p), (async () => {
+      const _ = {
+        jsonrpc: "2.0",
+        id: n,
+        method: e
+      };
+      r !== void 0 && (_.params = r), this._observeOutbound(_, s), await this._transport.send(_);
+    })().catch((_) => {
+      this._pending.delete(o), this._streamListeners.delete(o), this._observeSendFailure(n, _), p(), a(_ instanceof Error ? _ : new Error(String(_)));
+    }), {
+      result: c,
+      send: (_) => this._sendStream(n, F.toCallee, { payload: _ }),
+      cancel: (_) => this._sendStream(n, F.toCallee, { control: _ !== void 0 ? {
+        type: H.cancel,
+        reason: _
+      } : { type: H.cancel } }),
+      dispose: m,
+      ping: f.ping
+    };
+  }
+  /**
+  * Build the symmetric ping/pong machinery for one in-flight request.
+  *
+  * `outboundDir` is the direction *this* side emits controls in
+  * (`toCallee` for the caller, `toCaller` for the callee). A received
+  * ping is answered with a pong in that same direction, echoing the
+  * ping's nonce; a received pong resolves the matching outstanding
+  * {@link ping} probe.
+  */
+  _makePinger(e, r) {
+    const s = /* @__PURE__ */ new Map();
+    let n = 1;
+    return {
+      ping: () => {
+        const c = `${e}:${n++}`, f = new Promise((h, p) => s.set(c, {
+          resolve: h,
+          reject: p
+        }));
+        return this._sendStream(e, r, { control: {
+          type: H.ping,
+          nonce: c
+        } }), f;
+      },
+      onControl: (c) => {
+        if (c.type === H.ping) this._sendStream(e, r, { control: {
+          type: H.pong,
+          nonce: c.nonce
+        } });
+        else if (c.type === H.pong && c.nonce !== void 0) {
+          const f = s.get(c.nonce);
+          f && (s.delete(c.nonce), f.resolve());
+        }
+      },
+      dispose: () => {
+        const c = new A("Request settled before pong", R.cancelled);
+        for (const f of s.values()) f.reject(c);
+        s.clear();
+      }
+    };
+  }
+  /**
+  * Emit a stream notification ({@link STREAM_METHOD}) associated with
+  * an in-flight request. Internal: outgoing-side callers reach this
+  * via {@link RawStreamingCall.send} / `cancel`; incoming-side handlers
+  * reach it via {@link IncomingStream.send}.
+  */
+  async _sendStream(e, r, s) {
+    this._throwIfClosed();
+    const n = {
+      requestId: e,
+      dir: r,
+      ...s
+    }, o = {
+      jsonrpc: "2.0",
+      method: te,
+      params: n
+    };
+    this._observeOutbound(o), await this._transport.send(o);
+  }
+  close() {
+    if (this._closeError) return;
+    const e = new A("Connection closed", R.peerDisconnected);
+    this._closeError = e, this._deferredMessages.length = 0;
+    for (const r of this._incomingAborts.values()) r.abort(e);
+    this._incomingAborts.clear(), this._transport.dispose();
+    for (const r of this._pending.values()) r.reject(e);
+    this._pending.clear(), this._streamListeners.clear(), this._streamControl.clear();
+  }
+  _throwIfClosed() {
+    if (this._closeError) throw this._closeError;
+  }
+  _onMessage(e) {
+    var r;
+    if (this._observeInbound(e), this._requestsDeferred && !ke(e) && !(Se(e) && e.method === te && ((r = e.params) == null ? void 0 : r.dir) === F.toCaller)) {
+      this._deferredMessages.push(e);
+      return;
+    }
+    this._dispatchMessage(e);
+  }
+  _dispatchMessage(e) {
+    const r = e.context;
+    if (ke(e)) {
+      if (e.id === null) return;
+      const s = String(e.id), n = this._pending.get(s);
+      if (!n) return;
+      if (this._pending.delete(s), this._streamListeners.delete(s), "error" in e) {
+        const o = e.error, i = new A(o.message, o.code, o.data, "remote", Object.hasOwn(o, "data"));
+        n.reject(i);
+      } else n.resolve(e.result);
+      return;
+    }
+    if (yt(e)) {
+      this._handleRequest(e, r).catch(() => {
+      });
+      return;
+    }
+    if (Se(e)) {
+      if (e.method === te) {
+        this._handleStreamNotification(e);
+        return;
+      }
+      this._handleNotification(e, r);
+      return;
+    }
+  }
+  _handleStreamNotification(e) {
+    var i;
+    const r = e.params;
+    if (!r) return;
+    const s = r.requestId;
+    if (s === void 0) return;
+    const n = String(s);
+    if (r.control) {
+      (i = this._streamControl.get(n)) == null || i(r.control);
+      return;
+    }
+    const o = this._streamListeners.get(n);
+    o && o(r.payload);
+  }
+  async _handleRequest(e, r) {
+    const s = String(e.id), n = this._makePinger(e.id, F.toCaller), o = {
+      send: (c) => this._sendStream(e.id, F.toCaller, { payload: c }),
+      onMessage: (c) => {
+        c ? this._streamListeners.set(s, c) : this._streamListeners.delete(s);
+      },
+      ping: n.ping
+    }, i = new AbortController();
+    this._incomingAborts.set(s, i), this._streamControl.set(s, (c) => {
+      c.type === H.cancel ? i.abort(new A(c.reason ?? "cancelled", R.cancelled)) : n.onControl(c);
+    });
+    let a;
+    try {
+      if (!this._handler) a = { error: {
+        code: R.methodNotFound,
+        message: `No handler registered on this endpoint (method: ${e.method}).`
+      } };
+      else try {
+        a = await this._handler.handleRequest({
+          method: e.method,
+          params: e.params,
+          context: r,
+          stream: o,
+          signal: i.signal
+        });
+      } catch (c) {
+        a = { error: {
+          code: R.internalError,
+          message: c instanceof Error ? c.message : String(c)
+        } };
+      }
+    } finally {
+      this._streamListeners.delete(s), this._streamControl.delete(s), this._incomingAborts.delete(s), n.dispose();
+    }
+    if ("result" in a) {
+      const c = {
+        jsonrpc: "2.0",
+        id: e.id,
+        result: a.result
+      };
+      this._observeOutbound(c), await this._transport.send(c);
+    } else {
+      const c = {
+        jsonrpc: "2.0",
+        id: e.id,
+        error: a.error
+      };
+      this._observeOutbound(c), await this._transport.send(c);
+    }
+  }
+  _handleNotification(e, r) {
+    if (this._handler)
+      try {
+        this._handler.handleNotification({
+          method: e.method,
+          params: e.params,
+          context: r,
+          stream: _s,
+          signal: bs
+        });
+      } catch {
+      }
+  }
+  _observeInbound(e) {
+    const r = this._wireObserver;
+    r !== void 0 && r("inbound", e);
+  }
+  _observeOutbound(e, r) {
+    const s = this._wireObserver;
+    s !== void 0 && s("outbound", e);
+  }
+  _observeSendFailure(e, r) {
+    this._wireObserver !== void 0 && this._observeInbound({
+      jsonrpc: "2.0",
+      id: e,
+      error: {
+        code: R.peerDisconnected,
+        message: r instanceof Error ? r.message : String(r)
+      }
+    });
+  }
+};
+const _s = {
+  send: () => Promise.resolve(),
+  onMessage: () => {
+  },
+  ping: () => Promise.resolve()
+}, bs = new AbortController().signal;
+function pt(t) {
+  return typeof t == "object" && t !== null && "interface" in t && "mode" in t && (t.mode === "qualified" || t.mode === "default" || t.mode === "bare");
+}
+var ws = class Dt {
+  /**
+  * Construct from a {@link Channel} (binds the inbound handler and uses
+  * `channel.sender` for outbound calls) or from a bare
+  * {@link IRequestSender} (send-only — no inbound handler is registered,
+  * useful for bootstrap flows like `createManagedIdentity`).
+  */
+  constructor(e, r = {}) {
+    /** Underlying JSON-RPC sender — useful for callers that need raw access (e.g. to call hub-served methods that bypass the interface registry). */
+    l(this, "channel");
+    /** key = `${serviceId ?? ""}::${interfaceId}` */
+    l(this, "_registry", /* @__PURE__ */ new Map());
+    /** Descriptions for services that have been registered with a `serviceDescription`. */
+    l(this, "_serviceDescriptions", /* @__PURE__ */ new Map());
+    /** Root-node-id requirement sets recorded per serviceId. */
+    l(this, "_serviceRootPrincipalSets", /* @__PURE__ */ new Map());
+    l(this, "_directoryWatchers", /* @__PURE__ */ new Set());
+    l(this, "_directoryListeners", /* @__PURE__ */ new Set());
+    l(this, "_inspection");
+    l(this, "_inspectionHost");
+    l(this, "_serviceInspectionRegistrations", /* @__PURE__ */ new Map());
+    l(this, "_wireObservers", /* @__PURE__ */ new Set());
+    l(this, "_closeListeners", /* @__PURE__ */ new Set());
+    l(this, "_closed", !1);
+    l(this, "_wireChannel");
+    l(this, "_validateOutboundParams");
+    /** Bare-method bindings, keyed by their exact wire prefix. */
+    l(this, "_bareBindings", /* @__PURE__ */ new Map());
+    l(this, "_generateTopologyId");
+    this._validateOutboundParams = r.validateOutboundParams !== !1, this._generateTopologyId = r.generateTopologyId ?? ys, "sender" in e ? (this._wireChannel = e, this.channel = e.sender, e.setRequestHandler({
+      handleRequest: (s) => this._handleRequest(s),
+      handleNotification: (s) => this._handleNotification(s)
+    })) : (this._wireChannel = void 0, this.channel = e);
+  }
+  /**
+  * Convenience: build a {@link JsonRpcChannel} `Channel` from the
+  * given transport and wrap it in an `LinkRpcConnection`. Use this
+  * when you have a transport at hand and don't need a decorator
+  * stack (e.g. signing).
+  */
+  static fromTransport(e, r = {}) {
+    return new Dt(vs.create(e), r);
+  }
+  get(e, r) {
+    return this._getClient(e, r, !1);
+  }
+  _getClient(e, r, s) {
+    if (pt(e)) {
+      if (r !== void 0) throw new Error(`${s ? "getResultClient" : "get"}: ${e.mode === "bare" ? "bare " : ""}interface targets do not accept service or call options.`);
+      return e.mode === "bare" ? this._buildBareClient(e.interface, e.prefix, s) : this._buildClient(e.interface, e.mode === "qualified" ? { serviceId: e.serviceId } : {}, void 0, e.mode === "default", s);
+    }
+    return this._buildClient(e, r ?? {}, void 0, !1, s);
+  }
+  /**
+  * Get a typed client that emits foreign-protocol bare method names.
+  * Unlike {@link get}, these calls carry no LinkRPC interface metadata.
+  */
+  getBare(e, r = {}) {
+    return this._buildBareClient(e, r.prefix ?? "", !1);
+  }
+  _buildBareClient(e, r, s) {
+    dt(r);
+    for (const [n, o] of Object.entries(e.members)) if (o.kind === "request" && (o.clientStreamSchema !== void 0 || o.serverStreamSchema !== void 0)) throw new Error(`getBare: streaming method "${n}" is not supported on foreign wires.`);
+    return this._buildClient(e, {}, r, !1, s);
+  }
+  getResultClient(e, r) {
+    return this._getClient(e, r, !0);
+  }
+  /** Get a service-scoped handle; all interfaces obtained from it route via `serviceId` (form 3). */
+  service(e) {
+    return new Os(this, e);
+  }
+  /** Register handlers, adding preset routing when passed a default or bare target. */
+  register(e, r, s = {}) {
+    if (pt(e)) {
+      if (e.mode === "qualified") {
+        if (s.serviceId !== void 0 && s.serviceId !== e.serviceId) throw new Error("register: serviceId conflicts with interface target.");
+        return this._register(e.interface, r, {
+          ...s,
+          serviceId: e.serviceId || void 0
+        }, !1);
+      }
+      const n = e.mode === "bare" ? e.prefix : "";
+      return dt(n), this._register(e.interface, r, s, !1, n);
+    }
+    return this._register(e, r, s, !1);
+  }
+  /** Register inspection contracts without recursively enabling service inspection. */
+  registerInspection(e, r, s = {}) {
+    return this._register(e, r, s, !0);
+  }
+  /** Observe this connection without replacing another inspection scope's observer. */
+  observeWireMessages(e) {
+    if (this._closed) throw new Error("Connection is closed");
+    if (this._wireChannel === void 0) throw new Error("Connection has no observable wire channel");
+    return this._wireObservers.add(e), this._wireChannel.setWireMessageObserver((r, s) => {
+      for (const n of [...this._wireObservers]) try {
+        n(r, s);
+      } catch {
+      }
+    }), { dispose: () => {
+      var r;
+      this._wireObservers.delete(e), this._wireObservers.size === 0 && ((r = this._wireChannel) == null || r.setWireMessageObserver(void 0));
+    } };
+  }
+  onDidClose(e) {
+    if (this._closed) throw new Error("Connection is closed");
+    return this._closeListeners.add(e), { dispose: () => {
+      this._closeListeners.delete(e);
+    } };
+  }
+  _register(e, r, s, n, o) {
+    const i = s.serviceId, a = `${i ?? ""}::${e.info.id}`;
+    if (this._registry.has(a)) throw new Error(`Interface "${e.info.id}" already registered${i ? ` under service "${i}"` : ""}.`);
+    if (o !== void 0 && this._bareBindings.has(o)) throw new Error(`Bare interface prefix "${o}" is already registered.`);
+    let c = !1;
+    if (s.serviceDescription !== void 0) {
+      if (i === void 0) throw new Error("register: `serviceDescription` requires `serviceId`.");
+      const m = this._serviceDescriptions.get(i);
+      if (m !== void 0 && m !== s.serviceDescription) throw new Error(`register: conflicting descriptions for service "${i}".`);
+      c = m === void 0;
+    }
+    let f = !1;
+    if (s.rootPrincipalSets !== void 0) {
+      if (i === void 0) throw new Error("register: `rootPrincipalSets` requires `serviceId`.");
+      const m = this._serviceRootPrincipalSets.get(i);
+      if (m !== void 0 && !Is(m, s.rootPrincipalSets)) throw new Error(`register: conflicting rootPrincipalSets for service "${i}".`);
+      f = m === void 0;
+    }
+    const h = {
+      iface: e,
+      handlers: e.flattenHandlers(r),
+      serviceId: i,
+      internalInspection: n
+    };
+    if (c && this._serviceDescriptions.set(i, s.serviceDescription), f && this._serviceRootPrincipalSets.set(i, s.rootPrincipalSets), this._registry.set(a, h), o !== void 0 && this._bareBindings.set(o, {
+      prefix: o,
+      entry: h
+    }), this._notifyDirectoryWatchers(h, c || f), !n && i !== void 0 && this._inspection !== void 0 && !this._serviceInspectionRegistrations.has(i)) try {
+      this._installServiceInspection(i);
+    } catch (m) {
+      throw this._registry.delete(a), o !== void 0 && this._bareBindings.delete(o), c && this._serviceDescriptions.delete(i), f && this._serviceRootPrincipalSets.delete(i), this._notifyDirectoryWatchers(h), m;
+    }
+    let p = !1;
+    return { dispose: () => {
+      if (!p && (p = !0, this._registry.get(a) === h)) {
+        this._registry.delete(a);
+        for (const [m, y] of this._bareBindings) y.entry === h && this._bareBindings.delete(m);
+        this._notifyDirectoryWatchers(h), i !== void 0 && !this._hasBusinessServiceRegistration(i) && (this._removeServiceInspection(i), this._serviceDescriptions.delete(i), this._serviceRootPrincipalSets.delete(i));
+      }
+    } };
+  }
+  /** Snapshot of every interface currently registered on this connection. */
+  listRegisteredInterfaces() {
+    return Array.from(this._registry.values()).map((e) => {
+      const r = e.serviceId ?? "", s = {
+        serviceId: r,
+        interfaceId: e.iface.info.id,
+        interfaceHash: e.iface.schemaHash
+      };
+      e.iface.info.tags !== void 0 && (s.tags = e.iface.info.tags);
+      const n = r === "" ? void 0 : this._serviceDescriptions.get(r);
+      n !== void 0 && (s.serviceDescription = n);
+      const o = r === "" ? void 0 : this._serviceRootPrincipalSets.get(r);
+      return o !== void 0 && (s.rootPrincipalSets = o), s;
+    });
+  }
+  /** Subscribe to coarse local directory changes; listeners must re-list. */
+  onDidChangeDirectory(e) {
+    return this._directoryListeners.add(e), () => this._directoryListeners.delete(e);
+  }
+  /**
+  * Look up a registered interface definition by id (and optional content
+  * hash). Returns `undefined` if no registered interface matches.
+  */
+  findRegisteredInterface(e, r) {
+    let s;
+    for (const n of this._registry.values())
+      n.iface.info.id === e && (r !== void 0 && n.iface.schemaHash !== r || (s === void 0 || _r(s.toSchema(), n.iface.toSchema()) === n.iface.toSchema()) && (s = n.iface));
+    return s;
+  }
+  /**
+  * Register the three linkrpc reflection interfaces (`defaults`,
+  * `directory`, `schemas`), backed by this connection's live registry.
+  *
+  * By default they live under the root service (form-2 reachable as
+  * `hubrpc.directory::list`). Pass `serviceId` to additionally mount
+  * them under a specific service — useful for participants that live
+  * behind a hub, so callers can reach reflection via form-3
+  * `<serviceId>::hubrpc.directory::list`.
+  *
+  * Idempotent: re-registering the same `(serviceId, interfaceId)` pair
+  * is a no-op.
+  */
+  enableReflection(e = {}) {
+    const r = `${e.serviceId ?? ""}::${ht.info.id}`;
+    if (this._registry.has(r)) return { dispose() {
+    } };
+    const s = `${e.serviceId ?? ""}::`;
+    for (const a of [lt, De]) if (this._registry.has(`${s}${a.info.id}`)) throw new Error(`enableReflection: partial reflection registration for service "${e.serviceId ?? ""}".`);
+    const n = e.serviceId !== void 0 ? { serviceId: e.serviceId } : {}, o = [];
+    if (o.push(this.register(ht, {
+      get: () => {
+        const a = this._bareBindings.get("");
+        return a ? {
+          serviceId: a.entry.serviceId,
+          interfaceId: a.entry.iface.info.id,
+          interfaceHash: a.entry.iface.schemaHash
+        } : {};
+      },
+      listBindings: () => ({ bindings: Array.from(this._bareBindings.values()).sort((a, c) => a.prefix < c.prefix ? -1 : a.prefix > c.prefix ? 1 : 0).map((a) => ({
+        prefix: a.prefix,
+        serviceId: a.entry.serviceId,
+        interfaceId: a.entry.iface.info.id,
+        interfaceHash: a.entry.iface.schemaHash
+      })) })
+    }, n)), o.push(this.register(lt, {
+      list: ({ interfaceId: a, interfaceIdPrefix: c, serviceId: f, serviceIdScopes: h, cursor: p, limit: m }) => {
+        const y = this.listRegisteredInterfaces().filter((S) => e.serviceId === void 0 || S.serviceId === e.serviceId).filter((S) => a === void 0 || S.interfaceId === a).filter((S) => c === void 0 || S.interfaceId.startsWith(c)).filter((S) => f === void 0 || S.serviceId === f).filter((S) => Lt(S.serviceId, h)), _ = p === void 0 ? 0 : Number.parseInt(p, 10) || 0, I = m === void 0 ? y.length : Math.min(y.length, _ + m), j = y.slice(_, I).map((S) => {
+          var x;
+          return {
+            serviceId: S.serviceId,
+            interfaceId: S.interfaceId,
+            interfaceHash: S.interfaceHash,
+            tags: S.tags === void 0 ? void 0 : [...S.tags],
+            serviceDescription: S.serviceDescription,
+            rootPrincipalSets: (x = S.rootPrincipalSets) == null ? void 0 : x.map((E) => E.map(($) => ({ ...$ })))
+          };
+        });
+        return I < y.length ? {
+          items: j,
+          nextCursor: String(I)
+        } : { items: j };
+      },
+      watch: (a, c, f) => new Promise((h) => {
+        const p = {
+          interfaceId: a.interfaceId,
+          interfaceIdPrefix: a.interfaceIdPrefix,
+          serviceId: a.serviceId,
+          serviceIdScopes: a.serviceIdScopes,
+          send: () => f.send({})
+        };
+        this._directoryWatchers.add(p);
+        const m = () => {
+          this._directoryWatchers.delete(p), h({});
+        };
+        if (f.signal.aborted) {
+          m();
+          return;
+        }
+        f.signal.addEventListener("abort", m, { once: !0 });
+      })
+    }, n)), o.push(this.register(De, { get: ({ interfaceId: a, hash: c }) => {
+      const f = this.findRegisteredInterface(a, c);
+      if (!f) throw new A("Interface not found", R.methodNotFound, {
+        reason: "unknown-interface",
+        interfaceId: a,
+        hash: c
+      });
+      return { schema: f.toSchema() };
+    } }, n)), e.serviceId !== void 0) try {
+      this.enableReflection();
+    } catch (a) {
+      for (const c of o.reverse()) c.dispose();
+      throw a;
+    }
+    let i = !1;
+    return { dispose: () => {
+      if (!i) {
+        i = !0;
+        for (const a of o.reverse()) a.dispose();
+      }
+    } };
+  }
+  _notifyDirectoryWatchers(e, r = !1) {
+    for (const s of this._directoryListeners) try {
+      s();
+    } catch {
+    }
+    for (const s of this._directoryWatchers) {
+      if (s.pending) continue;
+      const n = ut(s, e), o = r && e.serviceId !== void 0 && [...this._registry.values()].some((i) => i.serviceId === e.serviceId && ut(s, i));
+      !n && !o || (s.pending = !0, queueMicrotask(() => {
+        s.pending = !1, this._directoryWatchers.has(s) && s.send();
+      }));
+    }
+  }
+  /**
+  * Enable the root `hubrpc.node::getNodeId` topology-bootstrap service.
+  *
+  * The generated ids are stable while this registration is active. They are
+  * unauthenticated correlation labels only; callers must not use them for
+  * identity, capability, or authorization decisions.
+  */
+  enableInspection(e) {
+    if (this._inspection !== void 0) return this._inspection;
+    const r = {
+      nodeId: this._generateTopologyId("node"),
+      portId: this._generateTopologyId("port"),
+      ...e !== void 0 ? { descriptors: [...e] } : {}
+    }, s = this._register(Mt, { getNodeId: () => r }, {}, !0), n = new ns({
+      nodeId: r.nodeId,
+      descriptors: e
+    });
+    try {
+      this._wireChannel !== void 0 && n.trackConnection(this, { portId: r.portId });
+    } catch (a) {
+      throw n.dispose(), s.dispose(), a;
+    }
+    this._inspectionHost = n;
+    let o = !1;
+    const i = {
+      ...r,
+      observeTraffic: (a) => n.observeTraffic(a),
+      dispose: () => {
+        if (!o) {
+          o = !0;
+          for (const a of [...this._serviceInspectionRegistrations.keys()]) this._removeServiceInspection(a);
+          n.dispose(), this._inspectionHost === n && (this._inspectionHost = void 0), s.dispose(), this._inspection === i && (this._inspection = void 0);
+        }
+      }
+    };
+    this._inspection = i;
+    try {
+      const a = new Set(Array.from(this._registry.values()).filter((c) => c.serviceId !== void 0 && !c.internalInspection).map((c) => c.serviceId));
+      for (const c of a) this._installServiceInspection(c);
+    } catch (a) {
+      throw i.dispose(), a;
+    }
+    return i;
+  }
+  /** Number of active endpoint traffic stream subscribers. */
+  get trafficObserverCount() {
+    var e;
+    return ((e = this._inspectionHost) == null ? void 0 : e.observerCount) ?? 0;
+  }
+  close() {
+    var e, r;
+    if (!this._closed) {
+      this._closed = !0;
+      for (const s of [...this._closeListeners]) s();
+      this._closeListeners.clear(), (e = this._inspection) == null || e.dispose(), this._wireObservers.clear(), (r = this._wireChannel) == null || r.setWireMessageObserver(void 0), this.channel.close();
+    }
+  }
+  _buildClient(e, r, s, n = !1, o = !1) {
+    const { serviceId: i, ...a } = r, c = s === void 0 ? {
+      ctx: a,
+      interfaceHash: e.schemaHash
+    } : void 0, f = s ?? (n ? "" : i ? `${i}::${e.info.id}::` : `${e.info.id}::`), h = /* @__PURE__ */ Object.create(null);
+    for (const [p, m] of Object.entries(e.members)) {
+      const y = `${f}${p}`;
+      if (m.kind === "request")
+        if (m.clientStreamSchema !== void 0 || m.serverStreamSchema !== void 0) {
+          const _ = m.serverStreamSchema;
+          h[p] = (I, j) => {
+            const S = j == null ? void 0 : j.onMessage, x = S !== void 0 ? (O) => {
+              if (_ !== void 0) {
+                const L = z(_, O);
+                if (!L.success) return;
+                S(L.data);
+                return;
+              }
+              S(O);
+            } : void 0, E = x !== void 0 ? {
+              ...c,
+              onStreamMessage: x
+            } : c;
+            let $;
+            try {
+              this._validateOutboundParamsFor(m, y, I), $ = this.channel.sendRequestWithStream(y, I, E);
+            } catch (O) {
+              if (!o) throw O;
+              $ = {
+                result: Promise.reject(O),
+                send: () => {
+                  throw O;
+                },
+                cancel: () => {
+                  throw O;
+                },
+                ping: async () => {
+                  throw O;
+                }
+              };
+            }
+            const J = mt($.result.then((O) => gt(m.resultSchema, O, y)), m, o);
+            return Object.assign(J, {
+              send: async (O) => $.send(O),
+              cancel: async (O) => $.cancel(O),
+              dispose: (O) => {
+                var L;
+                return (L = $.dispose) == null ? void 0 : L.call($, O);
+              },
+              ping: () => $.ping()
+            });
+          };
+        } else h[p] = (_) => mt((async () => {
+          this._validateOutboundParamsFor(m, y, _);
+          const I = await this.channel.sendRequest(y, _, c);
+          return gt(m.resultSchema, I, y);
+        })(), m, o);
+      else {
+        const _ = (I) => {
+          this._validateOutboundParamsFor(m, y, I), this.channel.sendNotification(y, I, c);
+        };
+        h[p] = s === void 0 ? async (I) => _(I) : _;
+      }
+    }
+    return e.nestClient(h);
+  }
+  _validateOutboundParamsFor(e, r, s) {
+    this._validateOutboundParams && He(e.paramsSchema, s, `Invalid params for ${r}`, R.invalidParams);
+  }
+  async _handleRequest(e) {
+    const r = this._parseRouted(e.method);
+    if (!r.ok) return ne(r.reason, e.method);
+    const { entry: s, memberName: n } = r, o = s.iface.members[n];
+    if (!o) return ne("unknown-method", e.method);
+    const i = s.handlers[n];
+    if (!i) return ne("unknown-method", e.method);
+    const a = ft(e.params), c = z(o.paramsSchema, a);
+    if (!c.success) return { error: {
+      code: R.invalidParams,
+      message: "Invalid params",
+      data: { issues: c.error.issues }
+    } };
+    if (o.kind !== "request") return ne("unknown-method", e.method);
+    const f = this._buildStreamApi(e.stream, e.signal, o);
+    try {
+      const h = await i(c.data, e.context, f), p = ks(o, h);
+      return p !== void 0 ? { error: p } : (He(o.resultSchema, h, `Invalid result for ${e.method}`, R.internalError), { result: h === void 0 ? null : h });
+    } catch (h) {
+      return h instanceof A ? { error: {
+        code: h.code,
+        message: h.message,
+        data: h.data
+      } } : { error: {
+        code: R.internalError,
+        message: h instanceof Error ? h.message : String(h)
+      } };
+    }
+  }
+  _buildStreamApi(e, r, s) {
+    return {
+      send: (n) => {
+        if (s.serverStreamSchema) {
+          const o = z(s.serverStreamSchema, n);
+          if (!o.success) throw new Error(`Server stream payload failed schema validation: ${o.error.message}`);
+        }
+        return e.send(n);
+      },
+      onMessage: (n) => {
+        e.onMessage((o) => {
+          if (s.clientStreamSchema) {
+            const i = z(s.clientStreamSchema, o);
+            if (!i.success) return;
+            n(i.data);
+            return;
+          }
+        });
+      },
+      ping: () => e.ping(),
+      signal: r
+    };
+  }
+  _handleNotification(e) {
+    const r = this._parseRouted(e.method);
+    if (!r.ok) return;
+    const { entry: s, memberName: n } = r, o = s.iface.members[n];
+    if ((o == null ? void 0 : o.kind) !== "notification") return;
+    const i = s.handlers[n];
+    if (!i) return;
+    const a = ft(e.params), c = z(o.paramsSchema, a);
+    c.success && i(c.data, e.context);
+  }
+  _parseRouted(e) {
+    const r = as(e);
+    if (!r) return {
+      ok: !1,
+      reason: "bad-method-grammar"
+    };
+    if (r.kind === "bare") {
+      let i;
+      for (const a of this._bareBindings.values()) r.member.startsWith(a.prefix) && (i === void 0 || a.prefix.length > i.prefix.length) && (i = a);
+      return i ? {
+        ok: !0,
+        entry: i.entry,
+        memberName: r.member.slice(i.prefix.length)
+      } : {
+        ok: !1,
+        reason: "no-preset"
+      };
+    }
+    const s = r.kind === "full" ? r.serviceId : void 0, n = `${s ?? ""}::${r.interfaceId}`, o = this._registry.get(n);
+    return o ? {
+      ok: !0,
+      entry: o,
+      memberName: r.member
+    } : {
+      ok: !1,
+      reason: s ? "unknown-service" : "unknown-interface"
+    };
+  }
+  _installServiceInspection(e) {
+    if (this._serviceInspectionRegistrations.has(e)) return;
+    const r = this._inspection, s = this._inspectionHost;
+    r === void 0 || s === void 0 || this._serviceInspectionRegistrations.set(e, [s.expose(this, {
+      serviceId: e,
+      portId: r.portId
+    })]);
+  }
+  _removeServiceInspection(e) {
+    const r = this._serviceInspectionRegistrations.get(e);
+    if (r !== void 0) {
+      this._serviceInspectionRegistrations.delete(e);
+      for (const s of r.reverse()) s.dispose();
+    }
+  }
+  _hasBusinessServiceRegistration(e) {
+    return Array.from(this._registry.values()).some((r) => r.serviceId === e && !r.internalInspection);
+  }
+};
+function ys(t) {
+  const e = /* @__PURE__ */ new Uint8Array(16);
+  return globalThis.crypto.getRandomValues(e), `${t}:${At(e)}`;
+}
+function Is(t, e) {
+  if (t.length !== e.length) return !1;
+  for (let r = 0; r < t.length; r++) {
+    const s = t[r], n = e[r];
+    if (s.length !== n.length) return !1;
+    for (let o = 0; o < s.length; o++)
+      if (s[o].principal !== n[o].principal || s[o].transitive === !0 != (n[o].transitive === !0)) return !1;
+  }
+  return !0;
+}
+function ut(t, e) {
+  const r = e.serviceId ?? "";
+  return (t.interfaceId === void 0 || t.interfaceId === e.iface.info.id) && (t.interfaceIdPrefix === void 0 || e.iface.info.id.startsWith(t.interfaceIdPrefix)) && (t.serviceId === void 0 || t.serviceId === r) && Lt(r, t.serviceIdScopes);
+}
+function mt(t, e, r = !1) {
+  const s = t.then((o) => ({
+    ok: !0,
+    value: o
+  }), (o) => ({
+    ok: !1,
+    error: Ss(o, e.applicationErrors),
+    cause: o
+  })), n = s.then((o) => {
+    if (o.ok) return o.value;
+    if (r) return new Ye(o.error.kind === "application" ? {
+      kind: "application",
+      error: o.error
+    } : {
+      kind: "generic",
+      error: o.error
+    });
+    if (o.error.kind === "application") return new Ye(o.error);
+    throw o.error.kind === "nonCompliantServer" ? o.error : o.cause;
+  });
+  return Object.assign(n, { result: async () => {
+    n.catch(() => {
+    });
+    const o = await s;
+    return o.ok ? o : {
+      ok: !1,
+      error: o.error
+    };
+  } });
+}
+function Ss(t, e) {
+  if (t instanceof ct) return t;
+  if (!(t instanceof A) || t.origin !== "remote") return {
+    kind: t instanceof A && t.origin === "transport" ? "transport" : "local",
+    cause: t
+  };
+  const r = {
+    code: t.code,
+    message: t.message,
+    ...t.hasData ? { data: t.data } : {}
+  }, s = e.filter((i) => i.code === t.code).sort((i, a) => +(a.type !== void 0) - +(i.type !== void 0)), n = {
+    message: t.message,
+    ...t.hasData ? { data: t.data } : {}
+  }, o = [];
+  for (const i of s) {
+    const a = St(i, n);
+    if (!a.success) {
+      o.push(...a.issues);
+      continue;
+    }
+    if (i.type === void 0) return Qe({
+      ...a.data,
+      kind: "application",
+      code: i.code
+    });
+    const c = a.data.data;
+    return Qe({
+      kind: "application",
+      code: i.code,
+      message: a.data.message,
+      type: i.type,
+      ...typeof c == "object" && c !== null && "data" in c ? { data: c.data } : {}
+    });
+  }
+  return s.length > 0 ? new ct(r, o) : {
+    kind: "remote",
+    ...r
+  };
+}
+function ks(t, e) {
+  if (!rr(e)) return;
+  const r = e, s = t.applicationErrors.find((c) => c.code === r.code && c.type === r.type && (c.bodySchema !== void 0 || c.type !== void 0 || c.message === r.message));
+  if (s === void 0) throw new A(`Undeclared application error ${String(r.code)}`, R.internalError);
+  const n = Object.hasOwn(e, "data") ? { data: e.data } : {}, o = {
+    message: e.message,
+    ...s.type === void 0 ? n : { data: {
+      type: s.type,
+      ...n
+    } }
+  }, i = St(s, o), a = i.success ? Et(o) : i.issues;
+  if (a.length > 0) throw new A(`Invalid data for application error ${s.code}`, R.internalError, { issues: a.map((c) => ({ ...c })) });
+  return {
+    code: s.code,
+    ...o
+  };
+}
+function gt(t, e, r) {
+  const s = Es(t, e);
+  return He(t, s, `Invalid result for ${r}`, R.internalError), s;
+}
+function He(t, e, r, s) {
+  const n = z(t, e);
+  if (!n.success) throw new A(r, s, { issues: n.error.issues });
+}
+function Es(t, e) {
+  if (e !== null) return e;
+  if (z(t, null).success) return null;
+  if (!z(t, void 0).success)
+    return null;
+}
+var Os = class {
+  constructor(t, e) {
+    l(this, "_connection");
+    l(this, "_serviceId");
+    this._connection = t, this._serviceId = e;
+  }
+  getResultClient(t, e = {}) {
+    return this._connection.getResultClient(t, {
+      ...e,
+      serviceId: this._serviceId
+    });
+  }
+  get(t, e = {}) {
+    return this._connection.get(t, {
+      ...e,
+      serviceId: this._serviceId
+    });
+  }
+  register(t, e, r = {}) {
+    return this._connection.register(t, e, {
+      ...r,
+      serviceId: this._serviceId
+    });
+  }
+};
+function ne(t, e) {
+  return { error: {
+    code: R.methodNotFound,
+    message: `Method not found: ${e}`,
+    data: {
+      reason: t,
+      method: e
+    }
+  } };
+}
+$s(globalThis, {});
+function $s(t, e) {
+  return new Proxy(t, {
+    get(r, s, n) {
+      return s in e ? e[s] : t[s];
+    },
+    set(r, s, n) {
+      return s in e && delete e[s], t[s] = n, !0;
+    },
+    deleteProperty(r, s) {
+      let n = !1;
+      return s in e && (delete e[s], n = !0), s in t && (delete t[s], n = !0), n;
+    },
+    ownKeys(r) {
+      const s = Reflect.ownKeys(t), n = Reflect.ownKeys(e), o = new Set(n);
+      return [...s.filter((i) => !o.has(i)), ...n];
+    },
+    defineProperty(r, s, n) {
+      return s in e && delete e[s], Reflect.defineProperty(t, s, n), !0;
+    },
+    getOwnPropertyDescriptor(r, s) {
+      return s in e ? Reflect.getOwnPropertyDescriptor(e, s) : Reflect.getOwnPropertyDescriptor(t, s);
+    },
+    has(r, s) {
+      return s in e || s in t;
+    }
+  });
+}
+const G = u();
+M({
+  id: "identity",
+  description: "Per-participant key oracle: exposes signing and HPKE-based wrap/unwrap for the identity the executor has attached to this participant's root overlay. Private keys never leave the executor."
+}, {
+  getPrincipal: w(v({}), v({ principal: u() })),
+  getWrapPublicKey: w(v({}), v({ wrapPublicKey: G })),
+  sign: w(v({ bytes: G }), v({ signature: G })),
+  wrap: w(v({
+    domain: u(),
+    bytes: G
+  }), v({ blob: G })),
+  unwrap: w(v({
+    domain: u(),
+    blob: G
+  }), v({ bytes: G }))
+});
+M({
+  id: "identity.storage",
+  description: "Per-identity persistent key/value store. Scope is the executor's managed-identity slot; lifecycle is tied to the identity itself. Backed by an at-rest-encrypted file in the executor."
+}, {
+  get: w(v({ key: u() }), v({ value: g(V()) })),
+  set: w(v({
+    key: u(),
+    value: V()
+  }), v({})),
+  delete: w(v({ key: u() }), v({ existed: se() })),
+  list: w(v({ prefix: g(u()) }), v({ keys: T(u()) }))
+});
+const ve = d.object({}).default({}), he = d.object({ message: d.string(), stack: d.string().optional() }), le = d.object({
+  type: d.enum(["console.error", "console.warn", "console.log", "window.error", "window.unhandledrejection"]),
+  message: d.string(),
+  stack: d.string().optional()
+}), vt = d.object({
+  hasError: d.boolean(),
+  errors: d.array(he).readonly(),
+  events: d.array(le).readonly()
+}), _e = d.object({
+  fixtureId: d.string(),
+  originalHash: d.string(),
+  modifiedHash: d.string(),
+  comment: d.string(),
+  approvedAt: d.string()
+}), be = d.object({
+  fixtureId: d.string(),
+  originalHash: d.string(),
+  modifiedHash: d.string()
+}), _t = d.object({
+  fixtureId: d.string(),
+  expectedVisualDescriptions: d.array(d.string()),
+  screenshotHash: d.string()
+}), js = d.union([
+  d.object({
+    name: d.string(),
+    sourceKind: d.enum(["current", "worktree"]),
+    isLoading: d.literal(!0)
+  }),
+  d.object({
+    name: d.string(),
+    sourceKind: d.enum(["current", "worktree"]),
+    isLoading: d.literal(!1).optional(),
+    serverUrl: d.string(),
+    sourceTreeId: d.string(),
+    worktreePath: d.string().optional(),
+    ref: d.string().optional()
+  })
+]), Rs = d.array(js), Ue = Rs, we = d.union([d.object({ sessions: Ue }), d.object({ error: d.string() })]), Ht = d.object({
+  hash: d.string().optional(),
+  image: d.string().optional(),
+  hasError: d.boolean(),
+  error: he.optional(),
+  events: d.array(le).optional(),
+  output: d.unknown().optional()
+}), Ps = Ht.extend({
+  sourceTreeId: d.string(),
+  isStable: d.boolean().optional(),
+  stabilityScreenshots: d.array(d.object({
+    hash: d.string(),
+    delayMs: d.number(),
+    image: d.string().optional()
+  })).optional(),
+  previousDispose: vt.optional(),
+  currentDispose: vt.optional()
+}), Cs = Ps, Ts = d.discriminatedUnion("type", [
+  d.object({ type: d.literal("source-change"), sessionName: d.string(), sourceTreeId: d.string() }),
+  d.object({ type: d.literal("ref-change"), sessionName: d.string(), newCommit: d.string() }),
+  d.object({ type: d.literal("session-change") }),
+  d.object({ type: d.literal("log"), level: d.enum(["info", "debug", "trace"]), message: d.string() })
+]), As = d.object({
+  clientName: d.string()
+}), ye = M({ id: "component-explorer.daemon-initialization" }, {
+  initialize: w(As, d.void())
+}), Ns = d.object({ sessionName: d.string(), sourceTreeId: d.string() }), Be = M({ id: "component-explorer.daemon" }, {
+  fixturesList: w(Ns, d.object({
+    fixtures: d.array(d.object({
+      fixtureId: d.string(),
+      fixtureName: d.string(),
+      groupPath: d.array(d.string()),
+      background: d.enum(["light", "dark"]),
+      labels: d.array(d.string()).readonly(),
+      expectedVisualDescriptions: d.array(d.string()).readonly(),
+      inputSchema: d.unknown().optional()
+    })),
+    loadError: d.string().optional()
+  })),
+  screenshotsTake: w(d.object({
+    fixtureId: d.string(),
+    sourceTreeId: d.string(),
+    sessionName: d.string(),
+    includeImage: d.boolean().optional(),
+    stabilityCheck: d.boolean().optional(),
+    reloadBeforeRender: d.boolean().optional(),
+    input: d.unknown().optional(),
+    disposeAfter: d.boolean().optional()
+  }), Cs),
+  screenshotsTakeBatch: w(d.object({
+    fixtureIds: d.array(d.string()),
+    sourceTreeId: d.string(),
+    sessionName: d.string(),
+    includeImages: d.boolean().optional(),
+    reloadBetweenFixtures: d.boolean().optional(),
+    input: d.unknown().optional()
+  }), d.object({ sourceTreeId: d.string(), screenshots: d.array(Ht.extend({ fixtureId: d.string() })) })),
+  screenshotsCompare: w(d.object({
+    fixtureId: d.string(),
+    baselineSessionName: d.string(),
+    baselineSourceTreeId: d.string(),
+    currentSessionName: d.string(),
+    currentSourceTreeId: d.string(),
+    includeImages: d.boolean().optional()
+  }), d.object({
+    match: d.boolean(),
+    baselineHash: d.string().optional(),
+    currentHash: d.string().optional(),
+    baselineImage: d.string().optional(),
+    currentImage: d.string().optional(),
+    baselineHasError: d.boolean(),
+    baselineError: he.optional(),
+    baselineEvents: d.array(le).optional(),
+    baselineOutput: d.unknown().optional(),
+    currentHasError: d.boolean(),
+    currentError: he.optional(),
+    currentEvents: d.array(le).optional(),
+    currentOutput: d.unknown().optional(),
+    labels: d.array(d.string()).readonly().optional(),
+    labelsBefore: d.array(d.string()).readonly().optional(),
+    approval: _e.optional()
+  })),
+  approvalsApprove: w(be.extend({ comment: d.string() }), d.void()),
+  approvalsRevoke: w(be, d.void()),
+  approvalsList: w(d.object({ fixtureId: d.string().optional() }), d.array(_e)),
+  approvalsLookup: w(be, d.union([_e, d.null()])),
+  visualReviewGetStatus: w(_t, d.union([
+    d.literal("no-expectations"),
+    d.object({
+      expectedVisualDescriptions: d.array(d.string()).readonly(),
+      status: d.enum(["approved", "needs-review"]),
+      approval: d.object({ approvedAt: d.string(), comment: d.string() }).optional()
+    })
+  ])),
+  visualReviewApprove: w(_t.extend({ comment: d.string() }), d.void()),
+  evaluate: w(d.object({
+    sessionName: d.string(),
+    sourceTreeId: d.string(),
+    expression: d.string(),
+    fixtureId: d.string().optional()
+  }), d.object({ result: d.unknown() })),
+  setBrowserVisibility: w(d.object({ visible: d.boolean() }), d.object({ visible: d.boolean() })),
+  events: w(ve, d.void()).withStream({ server: Ts }),
+  sessions: w(ve, Ue),
+  restartSession: w(d.object({ sessionName: d.string() }), Ue),
+  openSession: w(d.object({ name: d.string(), ref: d.string() }), we),
+  closeSession: w(d.object({ name: d.string() }), we),
+  updateSessionRef: w(d.object({ name: d.string(), ref: d.string() }), we),
+  shutdown: w(ve, d.void())
+});
+function Ms(t) {
+  const e = t.get(Be);
+  return {
+    fixtures: { list: e.fixturesList },
+    screenshots: { take: e.screenshotsTake, takeBatch: e.screenshotsTakeBatch, compare: e.screenshotsCompare },
+    approvals: { approve: e.approvalsApprove, revoke: e.approvalsRevoke, list: e.approvalsList, lookup: e.approvalsLookup },
+    visualReview: { getStatus: e.visualReviewGetStatus, approve: e.visualReviewApprove },
+    evaluate: e.evaluate,
+    setBrowserVisibility: e.setBrowserVisibility,
+    events: e.events,
+    sessions: e.sessions,
+    restartSession: e.restartSession,
+    openSession: e.openSession,
+    closeSession: e.closeSession,
+    updateSessionRef: e.updateSessionRef,
+    shutdown: e.shutdown
+  };
+}
+async function qs(t, e) {
+  const r = t.get(De);
+  return await r.get({ interfaceId: ye.info.id, hash: ye.schemaHash }), await t.get(ye).initialize({ clientName: e }), await r.get({ interfaceId: Be.info.id, hash: Be.schemaHash }), Ms(t);
+}
+const xs = "/__explorer/daemon-rpc";
+async function Us() {
+  const t = new URL(xs, location.href);
+  t.protocol = location.protocol === "https:" ? "wss:" : "ws:";
+  const e = new WebSocket(t);
+  let r, s = () => {
+  };
+  const n = new Promise((c, f) => {
+    s = f;
+  }), o = new Ls(e, () => {
+    r == null || r.close(), s(new Error("Daemon WebSocket closed"));
+  });
+  let i = !1;
+  const a = () => {
+    i || (i = !0, r == null || r.close(), o.dispose());
+  };
+  try {
+    if (await Promise.race([
+      new Promise((f, h) => {
+        if (e.readyState === WebSocket.OPEN) {
+          f();
+          return;
+        }
+        e.addEventListener("open", () => f(), { once: !0 }), e.addEventListener("error", () => h(new Error("Daemon WebSocket failed to open")), { once: !0 });
+      }),
+      n
+    ]), e.readyState !== WebSocket.OPEN)
+      throw new Error("Daemon WebSocket closed before initialization");
+    return r = ws.fromTransport(o), { methods: await qs(r, "explorer-ui"), dispose: a };
+  } catch (c) {
+    throw a(), c;
+  }
+}
+class Ls {
+  constructor(e, r) {
+    l(this, "_listener");
+    l(this, "_buffer", []);
+    l(this, "_disposed", !1);
+    l(this, "_handleMessage", (e) => {
+      try {
+        const r = JSON.parse(e.data);
+        if (!r || typeof r != "object" || !("jsonrpc" in r) || r.jsonrpc !== "2.0")
+          throw new Error("Invalid daemon RPC message");
+        this._listener ? this._listener(r) : this._buffer.push(r);
+      } catch {
+        this._socket.close(1003, "Invalid daemon RPC message"), this._onClose();
+      }
+    });
+    l(this, "_handleClose", () => this._onClose());
+    l(this, "_handleError", () => {
+      this._onClose(), this._socket.close();
+    });
+    this._socket = e, this._onClose = r, e.addEventListener("message", this._handleMessage), e.addEventListener("close", this._handleClose), e.addEventListener("error", this._handleError);
+  }
+  send(e) {
+    if (this._socket.readyState !== WebSocket.OPEN)
+      throw new Error("Daemon WebSocket is not open");
+    this._socket.send(JSON.stringify(e));
+  }
+  setListener(e) {
+    this._listener = e, e && queueMicrotask(() => {
+      for (; this._listener && this._buffer.length; )
+        this._listener(this._buffer.shift());
+    });
+  }
+  dispose() {
+    this._disposed || (this._disposed = !0, this._listener = void 0, this._buffer.length = 0, this._socket.removeEventListener("message", this._handleMessage), this._socket.removeEventListener("close", this._handleClose), this._socket.removeEventListener("error", this._handleError), this._socket.close());
+  }
+}
+export {
+  Us as createBrowserDaemonClient
+};
+//# sourceMappingURL=browserDaemonClient-AB8d4x2O.js.map