@github/copilot-language-server 1.542.0 → 1.544.0

package/dist/node_modules/@github/copilot-sdk/dist/cjs/runtimeArtifacts.js

@@ -0,0 +1,254 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runtimeArtifacts_exports = {};
+__export(runtimeArtifacts_exports, {
+  RUNTIME_PLATFORMS: () => RUNTIME_PLATFORMS,
+  defaultRuntimeCacheRoot: () => defaultRuntimeCacheRoot,
+  ensureRuntimeBundle: () => ensureRuntimeBundle,
+  getRuntimePackageName: () => getRuntimePackageName,
+  getRuntimePlatform: () => getRuntimePlatform,
+  getRuntimeReleaseAssetName: () => getRuntimeReleaseAssetName,
+  materializeRuntimeBundle: () => materializeRuntimeBundle,
+  resolvePackageRoot: () => resolvePackageRoot,
+  validateFile: () => validateFile
+});
+module.exports = __toCommonJS(runtimeArtifacts_exports);
+var import_node_fs = require("node:fs");
+var import_node_crypto = require("node:crypto");
+var import_node_module = require("node:module");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var import_cliVersion = require("./cliVersion.js");
+const import_meta = {};
+const require2 = (0, import_node_module.createRequire)(typeof __filename === "string" ? __filename : import_meta.url);
+const RUNTIME_PLATFORMS = [
+  "darwin-arm64",
+  "darwin-x64",
+  "linux-arm64",
+  "linux-x64",
+  "linuxmusl-arm64",
+  "linuxmusl-x64",
+  "win32-arm64",
+  "win32-x64"
+];
+const EXCLUDED_TOP_LEVEL = /* @__PURE__ */ new Set([
+  "app.js",
+  "assets",
+  "changelog.json",
+  "copilot",
+  "copilot.exe",
+  "foundry-local-sdk",
+  "index.js",
+  "LICENSE.md",
+  "napi-oop-runtime",
+  "npm-loader.js",
+  "package.json",
+  "pvrecorder",
+  "queries",
+  "README.md",
+  "sea-loader.js",
+  "webview"
+]);
+function validateFile(path, label) {
+  if (!(0, import_node_fs.existsSync)(path)) {
+    throw new Error(`${label} not found at ${path}.`);
+  }
+  if ((0, import_node_fs.statSync)(path).size === 0) {
+    throw new Error(`${label} at ${path} is empty.`);
+  }
+}
+function validateRuntimeBundle(wrapper, runtimeNode) {
+  validateFile(wrapper, "Copilot runtime wrapper");
+  validateFile(runtimeNode, "Copilot runtime.node");
+}
+function isExcluded(relativePath) {
+  const parts = relativePath.split(import_node_path.sep);
+  const topLevel = parts[0];
+  const fileName = parts.at(-1) ?? "";
+  return EXCLUDED_TOP_LEVEL.has(topLevel) || /^tree-sitter.*\.wasm$/.test(topLevel) || /^voice-.*\.js$/.test(topLevel) || fileName === "cli-native.node" || parts.includes("mediaremote-adapter") || fileName.startsWith("copilot-runtime-bin");
+}
+function collectRuntimeAssets(sources) {
+  const assets = [];
+  const visit = (directory) => {
+    for (const entry of (0, import_node_fs.readdirSync)(directory, { withFileTypes: true })) {
+      const source = (0, import_node_path.join)(directory, entry.name);
+      const sourceRelative = (0, import_node_path.relative)(sources.packageRoot, source);
+      if (isExcluded(sourceRelative)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        visit(source);
+        continue;
+      }
+      if (!entry.isFile() && !entry.isSymbolicLink()) {
+        continue;
+      }
+      const parts = sourceRelative.split(import_node_path.sep);
+      if (parts[0] === "prebuilds") {
+        if (parts[1] !== sources.platform || parts.length < 3) {
+          continue;
+        }
+      }
+      assets.push({ source, relativePath: sourceRelative });
+    }
+  };
+  visit(sources.packageRoot);
+  return assets.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+function sourceFingerprint(assets) {
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  for (const asset of assets) {
+    const stat = (0, import_node_fs.lstatSync)(asset.source);
+    hash.update(asset.relativePath).update("\0");
+    hash.update(`${stat.size}:${stat.mtimeMs}`).update("\0");
+  }
+  return hash.digest("hex").slice(0, 20);
+}
+function makeExecutable(path) {
+  if (process.platform === "win32") {
+    return;
+  }
+  const mode = (0, import_node_fs.statSync)(path).mode;
+  if ((mode & 73) === 0) {
+    (0, import_node_fs.chmodSync)(path, mode | 73);
+  }
+}
+function defaultRuntimeCacheRoot(platform = process.platform, home = (0, import_node_os.homedir)(), environment = process.env) {
+  const cacheDirectory = platform === "win32" ? environment.LOCALAPPDATA ?? (0, import_node_path.join)(home, "AppData", "Local") : platform === "darwin" ? (0, import_node_path.join)(home, "Library", "Caches") : environment.XDG_CACHE_HOME ?? (0, import_node_path.join)(home, ".cache");
+  return (0, import_node_path.join)(cacheDirectory, "github-copilot-sdk", "runtime");
+}
+function materializeRuntimeBundle(sources, cacheRoot = defaultRuntimeCacheRoot(), cacheKey = `${sources.platform}-${sourceFingerprint(collectRuntimeAssets(sources))}`) {
+  const assets = collectRuntimeAssets(sources);
+  const wrapperName = sources.platform.startsWith("win32") ? "copilot-runtime.exe" : "copilot-runtime";
+  const prebuildDir = (0, import_node_path.join)("prebuilds", sources.platform);
+  const wrapperRelative = (0, import_node_path.join)(prebuildDir, wrapperName);
+  const runtimeNodeRelative = (0, import_node_path.join)(prebuildDir, "runtime.node");
+  const sourceWrapper = assets.find((asset) => asset.relativePath === wrapperRelative)?.source;
+  const sourceRuntimeNode = assets.find(
+    (asset) => asset.relativePath === runtimeNodeRelative
+  )?.source;
+  validateRuntimeBundle(sourceWrapper ?? "", sourceRuntimeNode ?? "");
+  const installDir = (0, import_node_path.join)(cacheRoot, cacheKey);
+  const installedWrapper = (0, import_node_path.join)(installDir, wrapperRelative);
+  const installedRuntimeNode = (0, import_node_path.join)(installDir, runtimeNodeRelative);
+  if ((0, import_node_fs.existsSync)(installDir)) {
+    validateRuntimeBundle(installedWrapper, installedRuntimeNode);
+    makeExecutable(installedWrapper);
+    return installedWrapper;
+  }
+  (0, import_node_fs.mkdirSync)(cacheRoot, { recursive: true });
+  const stagingDir = (0, import_node_fs.mkdtempSync)((0, import_node_path.join)(cacheRoot, ".runtime-"));
+  try {
+    for (const asset of assets) {
+      const destination = (0, import_node_path.join)(stagingDir, asset.relativePath);
+      (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(destination), { recursive: true });
+      (0, import_node_fs.copyFileSync)(asset.source, destination);
+    }
+    const stagedWrapper = (0, import_node_path.join)(stagingDir, wrapperRelative);
+    makeExecutable(stagedWrapper);
+    (0, import_node_fs.renameSync)(stagingDir, installDir);
+  } catch (error) {
+    if (!(0, import_node_fs.existsSync)(installDir)) {
+      throw error;
+    }
+    validateRuntimeBundle(installedWrapper, installedRuntimeNode);
+  } finally {
+    (0, import_node_fs.rmSync)(stagingDir, { recursive: true, force: true });
+  }
+  return installedWrapper;
+}
+function isMusl() {
+  if (process.platform !== "linux") {
+    return false;
+  }
+  const report = process.report?.getReport();
+  return report?.header?.glibcVersionRuntime === void 0;
+}
+function getRuntimePlatform(platform = process.platform, arch = process.arch, musl = isMusl()) {
+  if (arch !== "x64" && arch !== "arm64") {
+    throw new Error(`Unsupported Copilot CLI architecture: ${arch}.`);
+  }
+  if (platform === "linux") {
+    return `${musl ? "linuxmusl" : "linux"}-${arch}`;
+  }
+  if (platform === "darwin" || platform === "win32") {
+    return `${platform}-${arch}`;
+  }
+  throw new Error(`Unsupported Copilot CLI platform: ${platform}-${arch}.`);
+}
+function getRuntimeReleaseAssetName(version, platform) {
+  return `github-copilot-${version}-${platform}.tgz`;
+}
+function getRuntimePackageName(platform) {
+  return `@github/copilot-sdk-${platform}`;
+}
+function resolvePackageRoot(packageName, searchPaths = require2.resolve.paths(packageName) ?? []) {
+  return searchPaths.map((base) => (0, import_node_path.join)(base, ...packageName.split("/"))).find((candidate) => (0, import_node_fs.existsSync)((0, import_node_path.join)(candidate, "package.json")));
+}
+async function ensureRuntimeBundle(version, options = {}) {
+  const platform = options.platform ?? getRuntimePlatform();
+  if (import_cliVersion.COPILOT_CLI_USE_NPM_PACKAGE) {
+    const packageName2 = `@github/copilot-${platform}`;
+    const packageRoot2 = resolvePackageRoot(packageName2, options.packageSearchPaths);
+    if (!packageRoot2) {
+      throw new Error(`Could not resolve ${packageName2} for Copilot CLI ${version}.`);
+    }
+    validateFile(
+      (0, import_node_path.join)(packageRoot2, "prebuilds", platform, "runtime.node"),
+      "Copilot runtime.node"
+    );
+    return materializeRuntimeBundle(
+      { packageRoot: packageRoot2, platform },
+      options.cacheRoot,
+      `${version}-${platform}`
+    );
+  }
+  const packageName = getRuntimePackageName(platform);
+  const packageRoot = resolvePackageRoot(packageName, options.packageSearchPaths);
+  if (!packageRoot) {
+    throw new Error(
+      `Could not resolve ${packageName}. Reinstall @github/copilot-sdk so its platform package is installed.`
+    );
+  }
+  const wrapperName = platform.startsWith("win32") ? "copilot-runtime.exe" : "copilot-runtime";
+  const prebuildDir = (0, import_node_path.join)(packageRoot, "prebuilds", platform);
+  const wrapper = (0, import_node_path.join)(prebuildDir, wrapperName);
+  try {
+    validateRuntimeBundle(wrapper, (0, import_node_path.join)(prebuildDir, "runtime.node"));
+  } catch (error) {
+    throw new Error(
+      `${packageName} is missing required Copilot CLI runtime files. Reinstall @github/copilot-sdk.`,
+      { cause: error }
+    );
+  }
+  makeExecutable(wrapper);
+  return wrapper;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RUNTIME_PLATFORMS,
+  defaultRuntimeCacheRoot,
+  ensureRuntimeBundle,
+  getRuntimePackageName,
+  getRuntimePlatform,
+  getRuntimeReleaseAssetName,
+  materializeRuntimeBundle,
+  resolvePackageRoot,
+  validateFile
+});

package/dist/node_modules/@github/copilot-sdk/dist/cjs/session.js

@@ -241,6 +241,7 @@ class CopilotSession {
     this.traceContextProvider = traceContextProvider;
     this.mcpAuthHandler = options?.mcpAuthHandler;
     this.managedSettingsEnabled = options?.managedSettingsEnabled === true;
+    this.onDisconnected = options?.onDisconnected;
   }
   sessionId;
   connection;
@@ -248,6 +249,7 @@ class CopilotSession {
   eventHandlers = /* @__PURE__ */ new Set();
   typedEventHandlers = /* @__PURE__ */ new Map();
   toolHandlers = /* @__PURE__ */ new Map();
+  pendingExternalTools = /* @__PURE__ */ new Map();
   canvases = /* @__PURE__ */ new Map();
   bearerTokenProviders = /* @__PURE__ */ new Map();
   commandHandlers = /* @__PURE__ */ new Map();
@@ -267,6 +269,8 @@ class CopilotSession {
   _capabilities = {};
   openCanvasInstances = [];
   disconnected = false;
+  disconnecting = false;
+  onDisconnected;
   /** @internal Client session API handlers, populated by CopilotClient during create/resume. */
   clientSessionApis = {};
   /**
@@ -281,14 +285,18 @@ class CopilotSession {
       const name = typeof nameOrHandle === "string" ? nameOrHandle : (0, import_factory.getFactoryDefinition)(nameOrHandle).meta.name;
       if (options?.resumeFromRunId !== void 0) {
         return this.factory.resume(options.resumeFromRunId, {
-          limits: options.limits
+          limits: options.limits,
+          notifyOnComplete: options.notifyOnComplete,
+          logPhaseNames: options.logPhaseNames
         });
       }
       const envelope = await this.rpc.factory.run({
         name,
         args: options?.args === void 0 ? {} : options.args,
         options: {
-          limits: options?.limits
+          limits: options?.limits,
+          notifyOnComplete: options?.notifyOnComplete,
+          logPhaseNames: options?.logPhaseNames
         }
       });
       return this.settleFactoryRun(envelope);
@@ -299,7 +307,9 @@ class CopilotSession {
       try {
         response = await this.rpc.factory.resume({
           runId,
-          limits: options?.limits
+          limits: options?.limits,
+          notifyOnComplete: options?.notifyOnComplete,
+          logPhaseNames: options?.logPhaseNames
         });
       } catch (error) {
         if (error instanceof import_node.ResponseError && typeof error.data === "object" && error.data !== null) {
@@ -314,7 +324,10 @@ class CopilotSession {
     }),
     getRun: async (runId) => this.rpc.factory.getRun({ runId }),
     waitForRun: (runId, options) => this.waitForFactoryRun(runId, options?.signal),
-    listRuns: async () => (await this.rpc.factory.listRuns({})).runs,
+    listRuns: (async (options) => {
+      const page = await this.rpc.factory.listRuns(options ?? {});
+      return options === void 0 ? page.runs : page;
+    }),
     getRunDetail: (runId) => this.rpc.factory.getRunDetail({ runId }),
     getRunProgress: (runId, options = {}) => this.rpc.factory.getRunProgress({ runId, ...options }),
     cancel: async (runId) => this.rpc.factory.cancel({ runId })
@@ -475,7 +488,7 @@ class CopilotSession {
     const unsubscribe = this.on((event) => {
       if (event.type === "assistant.message") {
         lastAssistantMessage = event;
-      } else if (event.type === "session.idle") {
+      } else if (event.type === "session.idle" && event.data.mode !== "autopilot") {
         resolveOutcome({ kind: "idle" });
       } else if (event.type === "session.error") {
         const error = new Error(event.data.message);
@@ -510,7 +523,15 @@ class CopilotSession {
   }
   /** @internal */
   _markDisconnected() {
+    if (this.disconnected) {
+      return;
+    }
     this.disconnected = true;
+    for (const controller of this.pendingExternalTools.values()) {
+      controller.abort();
+    }
+    this.pendingExternalTools.clear();
+    this._runOnDisconnected();
     this.eventHandlers.clear();
     this.typedEventHandlers.clear();
     this.toolHandlers.clear();
@@ -530,6 +551,15 @@ class CopilotSession {
     this.factoryAbortControllers.clear();
     this.transformCallbacks?.clear();
   }
+  /** @internal */
+  _runOnDisconnected() {
+    this.onDisconnected?.();
+    this.onDisconnected = void 0;
+  }
+  /** @internal */
+  _setOnDisconnected(callback) {
+    this.onDisconnected = callback;
+  }
   on(eventTypeOrHandler, handler) {
     if (typeof eventTypeOrHandler === "string" && handler) {
       const eventType = eventTypeOrHandler;
@@ -604,6 +634,15 @@ class CopilotSession {
           tracestate
         );
       }
+    } else if (event.type === "external_tool.completed") {
+      const { requestId } = event.data;
+      if (requestId) {
+        const controller = this.pendingExternalTools.get(requestId);
+        if (controller) {
+          this.pendingExternalTools.delete(requestId);
+          controller.abort();
+        }
+      }
     } else if (event.type === "permission.requested") {
       const { requestId, permissionRequest, resolvedByHook } = event.data;
       if (resolvedByHook) {
@@ -684,16 +723,35 @@ class CopilotSession {
    * @internal
    */
   async _executeToolAndRespond(requestId, toolName, toolCallId, args, handler, traceparent, tracestate) {
+    const controller = new AbortController();
+    if (this.disconnected || this.pendingExternalTools.has(requestId)) {
+      return;
+    }
+    this.pendingExternalTools.set(requestId, controller);
     try {
       let availableTools;
       if (toolName === TOOL_SEARCH_TOOL_NAME) {
+        if (controller.signal.aborted) {
+          return;
+        }
+        const aborted = new Promise((resolve) => {
+          controller.signal.addEventListener("abort", () => resolve(void 0), {
+            once: true
+          });
+        });
         try {
-          const metadata = await this.rpc.tools.getCurrentMetadata();
-          availableTools = metadata.tools ?? void 0;
+          const metadata = await Promise.race([
+            this.rpc.tools.getCurrentMetadata(),
+            aborted
+          ]);
+          availableTools = metadata?.tools ?? void 0;
         } catch {
           availableTools = void 0;
         }
       }
+      if (controller.signal.aborted) {
+        return;
+      }
       const rawResult = await handler(args, {
         sessionId: this.sessionId,
         toolCallId,
@@ -701,7 +759,8 @@ class CopilotSession {
         arguments: args,
         availableTools,
         traceparent,
-        tracestate
+        tracestate,
+        signal: controller.signal
       });
       let result;
       if (rawResult == null) {
@@ -713,12 +772,12 @@ class CopilotSession {
       } else {
         result = JSON.stringify(rawResult);
       }
-      if (this.disconnected) {
+      if (!this._claimExternalTool(requestId, controller)) {
         return;
       }
       await this.rpc.tools.handlePendingToolCall({ requestId, result });
     } catch (error) {
-      if (this.disconnected) {
+      if (!this._claimExternalTool(requestId, controller)) {
         return;
       }
       const message = error instanceof Error ? error.message : String(error);
@@ -729,7 +788,19 @@ class CopilotSession {
           throw rpcError;
         }
       }
+    } finally {
+      if (this.pendingExternalTools.get(requestId) === controller) {
+        this.pendingExternalTools.delete(requestId);
+      }
+      controller.abort();
+    }
+  }
+  _claimExternalTool(requestId, controller) {
+    if (this.disconnected || this.pendingExternalTools.get(requestId) !== controller) {
+      return false;
     }
+    this.pendingExternalTools.delete(requestId);
+    return true;
   }
   /**
    * Executes a permission handler and sends the result back via RPC.
@@ -1174,7 +1245,13 @@ class CopilotSession {
     }
     try {
       const result = await this.elicitationHandler(context);
-      await this.rpc.ui.handlePendingElicitation({ requestId, result });
+      await this.rpc.ui.handlePendingElicitation({
+        requestId,
+        result: {
+          action: result.action,
+          ...result.content ? { content: result.content } : {}
+        }
+      });
     } catch {
       try {
         await this.rpc.ui.handlePendingElicitation({
@@ -1477,13 +1554,27 @@ class CopilotSession {
    * ```
    */
   async disconnect() {
-    if (this.disconnected) {
+    if (this.disconnected || this.disconnecting) {
       return;
     }
-    await this.connection.sendRequest("session.destroy", {
-      sessionId: this.sessionId
-    });
-    this._markDisconnected();
+    this.disconnecting = true;
+    try {
+      let response = { success: false };
+      for (let attempt = 0; attempt < 2 && !response.success; attempt++) {
+        response = await this.connection.sendRequest("session.detach", {
+          sessionId: this.sessionId
+        });
+      }
+      if (!response.success) {
+        throw new Error(
+          `Failed to disconnect session ${this.sessionId}: ${response.error || "Unknown error"}`
+        );
+      }
+      this._markDisconnected();
+    } catch (error) {
+      this.disconnecting = false;
+      throw error;
+    }
   }
   /** Enables `await using session = ...` syntax for automatic cleanup. */
   async [Symbol.asyncDispose]() {
@@ -1525,11 +1616,48 @@ class CopilotSession {
    * ```typescript
    * await session.setModel("gpt-5.4");
    * await session.setModel("claude-sonnet-4.6", { reasoningEffort: "high" });
+   *
+   * // Select the Auto model and its routing preference in one call.
+   * await session.setModel("auto", { autoTier: "intelligence" });
    * ```
    */
   async setModel(model, options) {
     await this.rpc.model.switchTo({ modelId: model, ...options });
   }
+  /**
+   * Change the Auto routing preference without changing the selected model.
+   *
+   * The runtime does not apply the preference immediately. It records the
+   * request and commits it only when a later user turn using the `auto` model
+   * successfully obtains a usable model from the provider. A `pending` status
+   * therefore confirms that the request was accepted, not that it took effect.
+   *
+   * Watch for the outcome through the `session.model_change` event on success,
+   * or the ephemeral `session.auto_tier_switch_failed` event on failure. You
+   * can also read the current committed and in-flight state at any time with
+   * `session.rpc.model.getCurrent()`.
+   *
+   * Only the most recent request survives: issuing a new request replaces any
+   * earlier one that has not yet been claimed by a turn.
+   *
+   * @param autoTier - Routing preference to activate, or `null` to return to
+   *   the provider's default Auto routing
+   * @returns The runtime's immediate acknowledgement and Auto preference snapshot
+   *
+   * @experimental Part of an experimental Auto routing surface and may change
+   * or be removed in a future release.
+   *
+   * @example
+   * ```typescript
+   * const result = await session.setAutoTier("intelligence");
+   * if (result.status === "pending") {
+   *     // Takes effect on a later turn that uses the `auto` model.
+   * }
+   * ```
+   */
+  async setAutoTier(autoTier) {
+    return await this.rpc.model.switchAutoTier({ autoTier });
+  }
   /**
    * Log a message to the session timeline.
    * The message appears in the session event stream and is visible to SDK consumers

package/dist/node_modules/@github/copilot-sdk/dist/cjs/types.js

@@ -22,6 +22,7 @@ __export(types_exports, {
   CopilotWebSocketCloseStatus: () => import_copilotRequestHandler.CopilotWebSocketCloseStatus,
   CopilotWebSocketForwarder: () => import_copilotRequestHandler.CopilotWebSocketForwarder,
   CopilotWebSocketHandler: () => import_copilotRequestHandler.CopilotWebSocketHandler,
+  DisableBypassPermissionsModes: () => DisableBypassPermissionsModes,
   RuntimeConnection: () => RuntimeConnection,
   SYSTEM_MESSAGE_SECTIONS: () => SYSTEM_MESSAGE_SECTIONS,
   SessionFsSqliteTransactionFailure: () => import_sessionFsProvider2.SessionFsSqliteTransactionFailure,
@@ -165,12 +166,19 @@ const approveAll = (request, invocation) => {
 const defaultJoinSessionPermissionHandler = () => ({
   kind: "no-result"
 });
+const DisableBypassPermissionsModes = {
+  /** Turn off bypass-permissions mode entirely. */
+  Disable: "disable",
+  /** Permit automatic bypass but block full allow-all. */
+  AllowAutoOnly: "allow-auto-only"
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CopilotRequestHandler,
   CopilotWebSocketCloseStatus,
   CopilotWebSocketForwarder,
   CopilotWebSocketHandler,
+  DisableBypassPermissionsModes,
   RuntimeConnection,
   SYSTEM_MESSAGE_SECTIONS,
   SessionFsSqliteTransactionFailure,