nautobot 2.4.3__py3-none-any.whl → 2.4.4__py3-none-any.whl

nautobot/project-static/docs/user-guide/platform-functionality/rest-api/overview.html

@@ -9497,10 +9497,7 @@
 <p>Each attribute of the IP address is expressed as an attribute of the JSON object. Related objects are identified by their own URLs that may be accessed to retrieve more details of the related object, as in the case of the <code>role</code> and <code>status</code> fields above. Every object includes a primary key named <code>id</code> which uniquely identifies it in the database.</p>
 <h2 id="interactive-documentation">Interactive Documentation<a class="headerlink" href="#interactive-documentation" title="Permanent link">&para;</a></h2>
 <p>Comprehensive, interactive documentation of all REST API endpoints is available on a running Nautobot instance at <code>/api/docs/</code>. This interface provides a convenient sandbox for researching and experimenting with specific endpoints and request types. The API itself can also be explored using a web browser by navigating to its root at <code>/api/</code>.</p>
-<details class="version-added">
-<summary>Added in version 1.3.0</summary>
 <p>You can view or explore a specific REST API <a href="#versioning">version</a> by adding the API version as a query parameter, for example <code>/api/docs/?api_version=2.0</code> or <code>/api/?api_version=2.0</code></p>
-</details>
 <h2 id="endpoint-hierarchy">Endpoint Hierarchy<a class="headerlink" href="#endpoint-hierarchy" title="Permanent link">&para;</a></h2>
 <p>Nautobot's entire REST API is housed under the API root at <code>https://&lt;hostname&gt;/api/</code>. The URL structure is divided at the root level by application: circuits, DCIM, extras, IPAM, plugins, tenancy, users, and virtualization. Within each application exists a separate path for each model. For example, the provider and circuit objects are located under the "circuits" application:</p>
 <ul>
@@ -9524,9 +9521,6 @@
 </code></pre></div>
 <p>See the <a href="filtering.html">filtering documentation</a> for more details.</p>
 <h2 id="versioning">Versioning<a class="headerlink" href="#versioning" title="Permanent link">&para;</a></h2>
-<details class="version-added">
-<summary>Added in version 1.3.0</summary>
-</details>
 <p>As of Nautobot 1.3, the REST API supports multiple versions. A REST API client may request a given API version by including a <code>major.minor</code> Nautobot version number in its request in one of two ways:</p>
 <ol>
 <li>A client may include a <code>version</code> in its HTTP Accept header, for example <code>Accept: application/json; version=2.0</code></li>
@@ -9535,10 +9529,6 @@
 <p>Generally the former approach is recommended when writing automated API integrations, as it can be set as a general request header alongside the <a href="authentication.html">authentication token</a> and re-used across a series of REST API interactions, while the latter approach may be more convenient when initially exploring the REST API via the interactive documentation as described above.</p>
 <h3 id="default-versions">Default Versions<a class="headerlink" href="#default-versions" title="Permanent link">&para;</a></h3>
 <p>By default, a REST API request that does not specify an API version number will default to compatibility with the current Nautobot version.</p>
-<details class="version-added">
-<summary>Added in version 1.3.0</summary>
-<p>For Nautobot 1.x, the default API behavior is to be compatible with the REST API of Nautobot version 1.2, in other words, for all Nautobot 1.x versions (beginning with Nautobot 1.2.0), <code>Accept: application/json</code> is functionally equivalent to <code>Accept: application/json; version=1.2</code>.</p>
-</details>
 <details class="version-changed">
 <summary>Changed in version 2.0.0</summary>
 <p>As of Nautobot 2.0, the default API behavior is changed to use the latest available REST API version. In other words, the default REST API version for Nautobot 2.0.y will be <code>2.0</code>, for Nautobot 2.1.y will be <code>2.1</code>, etc. This means that REST API clients that do not explicitly request a particular REST API version may encounter potentially <a href="#breaking-changes">breaking changes</a> in the REST API when Nautobot is upgraded to a new minor or major version.</p>
@@ -9660,9 +9650,6 @@
 </tbody>
 </table>
 <h3 id="apiselect-with-versioning-capability">APISelect with versioning capability<a class="headerlink" href="#apiselect-with-versioning-capability" title="Permanent link">&para;</a></h3>
-<details class="version-added">
-<summary>Added in version 1.3.0</summary>
-</details>
 <p>The constructor for Nautobot's <code>APISelect</code>/<code>APISelectMultiple</code> UI widgets now includes an optional <code>api_version</code> argument which if set overrides the default API version of the request.</p>
 <h2 id="serialization">Serialization<a class="headerlink" href="#serialization" title="Permanent link">&para;</a></h2>
 <p>The REST API employs "serializers" to represent model data. The representation produced by a serializer typically includes all relevant database table fields which comprise the model, and may also include additional metadata such as information about other relevant objects in the database. Much like the database model itself, a serializer typically will represent information about "parent" objects (those objects that needed to exist in order to define the current object, such as <code>DeviceType</code> and <code>Location</code> for a <code>DeviceSerializer</code>) but typically will not include information about "child" objects (those objects that depend on the current object in order to be defined, such as <code>Interface</code> objects for a <code>DeviceSerializer</code>).</p>
@@ -10174,9 +10161,6 @@ This parameter is an positive integer value that can range from 0 to 10. In most
 <a id="__codelineno-23-79" name="__codelineno-23-79" href="#__codelineno-23-79"></a><span class="p">}</span>
 </code></pre></div>
 <h3 id="retrieving-object-relationships-and-relationship-associations">Retrieving Object Relationships and Relationship Associations<a class="headerlink" href="#retrieving-object-relationships-and-relationship-associations" title="Permanent link">&para;</a></h3>
-<details class="version-added">
-<summary>Added in version 1.4.0</summary>
-</details>
 <p>Objects that are associated with another object by a custom <a href="../relationship.html">Relationship</a> are also retrievable and modifiable via the REST API. Due to the additional processing overhead involved in retrieving and representing these relationships, they are <em>not</em> included in default REST API <code>GET</code> responses. To include relationships data, pass <code>include=relationships</code> as a query parameter; in this case an additional key, <code>"relationships"</code>, will be included in the API response, as seen below:</p>
 <div class="highlight"><pre><span></span><code><a id="__codelineno-24-1" name="__codelineno-24-1" href="#__codelineno-24-1"></a>GET /api/dcim/locations/f472bb77-7f56-4e79-ac25-2dc73eb63924/?include=relationships
 </code></pre></div>
@@ -10362,9 +10346,6 @@ This parameter is an positive integer value that can range from 0 to 10. In most
 <p>The Nautobot REST API support the use of either <code>PUT</code> or <code>PATCH</code> to modify an existing object. The difference is that a <code>PUT</code> request requires the user to specify a <em>complete</em> representation of the object being modified, whereas a <code>PATCH</code> request need include only the attributes that are being updated. For most purposes, using <code>PATCH</code> is recommended.</p>
 </div>
 <h4 id="updating-relationship-associations">Updating Relationship Associations<a class="headerlink" href="#updating-relationship-associations" title="Permanent link">&para;</a></h4>
-<details class="version-added">
-<summary>Added in version 1.4.0</summary>
-</details>
 <p>It is possible to modify the objects associated via Relationship with an object as part of a REST API <code>PATCH</code> request by specifying the <code>"relationships"</code> key, any or all of the relevant Relationships, and the list of desired related objects for each such Relationship. Since nested serializers are used for the related objects, they can be identified by ID (primary key) or by one or more attributes in a dictionary. For example, either of the following requests would be valid:</p>
 <div class="highlight"><pre><span></span><code><a id="__codelineno-33-1" name="__codelineno-33-1" href="#__codelineno-33-1"></a><span class="p">{</span>
 <a id="__codelineno-33-2" name="__codelineno-33-2" href="#__codelineno-33-2"></a><span class="w">    </span><span class="nt">&quot;relationships&quot;</span><span class="p">:</span><span class="w"> </span><span class="p">{</span>

nautobot/project-static/docs/user-guide/platform-functionality/secret.html

@@ -9296,16 +9296,10 @@
 
 
 <h1 id="secrets">Secrets<a class="headerlink" href="#secrets" title="Permanent link">&para;</a></h1>
-<details class="version-added">
-<summary>Added in version 1.2.0</summary>
-</details>
 <p>For security reasons, Nautobot generally does not store sensitive secrets (device access credentials, systems-integration API tokens, etc.) in its own database. There are other approaches and systems better suited to this purpose, ranging from simple solutions such as process-specific environment variables or restricted-access files on disk, all the way through to dedicated systems such as Hashicorp Vault or AWS Secrets Manager.</p>
 <p>However, any number of Nautobot features (including, but not limited to, device access via NAPALM, Git repository access, custom Jobs, and various Apps seeking to integrate with third-party systems) do need the ability to retrieve and make use of such secrets. Towards that end, Nautobot provides a <code>Secret</code> database model. This model does <strong>not</strong> store the secret value itself, but instead defines <strong>how</strong> Nautobot can retrieve the secret value as and when it is needed. By using this model as an abstraction of the underlying secrets storage implementation, this makes it possible for any Nautobot feature to make use of secret values without needing to know or care where or how the secret is actually stored.</p>
 <p>Secrets can be grouped and assigned a specific purpose as members of a Secrets Group, which can then be attached to a Git repository, device, or other data model as needed for a given purpose.</p>
 <h2 id="secrets-groups">Secrets Groups<a class="headerlink" href="#secrets-groups" title="Permanent link">&para;</a></h2>
-<details class="version-added">
-<summary>Added in version 1.2.0</summary>
-</details>
 <p>A Secrets Group provides a way to collect and assign a purpose to one or more Secrets. The Secrets Group can then be attached to any object that needs to reference and make use of these Secrets, such as a Git repository needing a username/token to authenticate to a private GitHub repository, or a device using a group of Secrets to drive its NAPALM integration.</p>
 <p>When creating or editing a Secrets Group, you can assign any number of defined Secrets to this group, assigning each secret an <em>access type</em> and a <em>secret type</em> that are unique within the context of this group. Some examples of how a Secrets Group might be populated for use by a given feature:</p>
 <table>
@@ -9336,10 +9330,10 @@
 <li><em>Environment Variable</em> - for retrieving a secret value defined in an environment variable; Secrets using this provider must specify the <code>variable</code> name to retrieve.</li>
 <li><em>Text File</em> - for retrieving a secret value stored in a text file; Secrets using this provider must specify the absolute <code>path</code> of the file to retrieve.</li>
 </ul>
-<details class="version-changed">
-<summary>Changed in version 1.4.3</summary>
+<div class="admonition tip">
+<p class="admonition-title">Tip</p>
 <p>When using the Text File secrets provider, any leading and trailing whitespace or newlines will be stripped.</p>
-</details>
+</div>
 <p>When defining a new Secret, you will need to select the desired secrets provider and then fill in the specific parameters required by that provider in order to have a completely specified, usable Secret record.</p>
 <div class="admonition tip">
 <p class="admonition-title">Tip</p>

nautobot/project-static/docs/user-guide/platform-functionality/status.html

@@ -9468,10 +9468,6 @@ own risk!</p>
 <li><code>nautobot.extras.forms.StatusModelFilterFormMixin</code> should be used to add a non-required, multiple-choice <code>status</code> filter field to UI filter forms. This multiple-choice field allows for multiple status values to be selected for filtering objects in list views in the web UI.</li>
 <li><code>nautobot.extras.forms.StatusModelBulkEditFormMixin</code> should be used to add a non-required <code>status</code> form field to a an object's model form. This field constrains status choices eligible to the object type being edited.</li>
 </ul>
-<details class="version-changed">
-<summary>Changed in version 1.4.0</summary>
-<p>In prior Nautobot versions these mixins were named <code>StatusFilterFormMixin</code> and <code>StatusBulkEditFormMixin</code>; the old names are still available as aliases but will be removed in a future major release.</p>
-</details>
 <h3 id="table-field">Table field<a class="headerlink" href="#table-field" title="Permanent link">&para;</a></h3>
 <p>If you wish for a table to include a <code>status</code> field, your table must inherit from <code>nautobot.extras.tables.StatusTableMixin</code>. This includes a <code>ColorColumn</code> on the table.</p>
 <h2 id="status-object-integrations">Status object integrations<a class="headerlink" href="#status-object-integrations" title="Permanent link">&para;</a></h2>
@@ -9487,10 +9483,6 @@ own risk!</p>
 <li>Bulk edit model forms must inherit from <code>nautobot.extras.forms.StatusModelBulkEditFormMixin</code></li>
 <li>Filter forms must inherit from <code>nautobot.extras.forms.StatusModelFilterFormMixin</code></li>
 </ul>
-<details class="version-changed">
-<summary>Changed in version 1.4.0</summary>
-<p>In prior Nautobot releases the latter two mixins were named <code>StatusBulkEditFormMixin</code> and <code>StatusFilterFormMixin</code> respectively; the old names are still available as aliases but will be removed in a future major release.</p>
-</details>
 <h3 id="filters">Filters<a class="headerlink" href="#filters" title="Permanent link">&para;</a></h3>
 <ul>
 <li>Filtersets for your model must inherit from <code>nautobot.extras.filters.StatusModelFilterSetMixin</code></li>

nautobot/project-static/docs/user-guide/platform-functionality/tag.html

@@ -9121,10 +9121,6 @@
 
 <h1 id="tags">Tags<a class="headerlink" href="#tags" title="Permanent link">&para;</a></h1>
 <p>Tags are user-defined labels which can be applied to a variety of objects within Nautobot. They can be used to establish dimensions of organization beyond the relationships built into Nautobot. For example, you might create a tag to identify a particular ownership or condition across several types of objects.</p>
-<details class="version-added">
-<summary>Added in version 1.3.0</summary>
-<p>When created, a <code>Tag</code> can be associated to one or more model content-types using a many-to-many relationship. The tag will then apply only to models belonging to those associated content-types.</p>
-</details>
 <p>Each tag has a name, label, color, and permitted content-types. Each tag can also be assigned a description indicating its purpose.</p>
 <p>Objects can be filtered by the tags they have applied. For example, the following API request will retrieve all devices tagged as "monitored":</p>
 <div class="highlight"><pre><span></span><code><a id="__codelineno-0-1" name="__codelineno-0-1" href="#__codelineno-0-1"></a>GET /api/dcim/devices/?tag=monitored

nautobot/project-static/docs/user-guide/platform-functionality/template-filters.html

@@ -9802,16 +9802,10 @@
 </div>
 <p>Both Django Template and Jinja2 can be extended with a library of functions, called <code>filters</code>, that apply formatting or transformations to a provided input. Nautobot provides many built-in <code>filters</code>, including network specific <code>filters</code> from the <a href="https://netutils.readthedocs.io/en/latest/">netutils library</a>.</p>
 <h2 id="netutils-filters">Netutils Filters<a class="headerlink" href="#netutils-filters" title="Permanent link">&para;</a></h2>
-<details class="version-added">
-<summary>Added in version 1.2.0</summary>
-</details>
 <p><a href="https://netutils.readthedocs.io/en/latest/">Netutils</a> is an external library, maintained by Network to Code, that is focusing on providing a collection of functions for common network automation tasks. Please <a href="https://netutils.readthedocs.io/en/latest/">check the netutils documentation</a> to see the list of available functions.</p>
 <p>These functions are available automatically in Jinja2 rendered by Nautobot. For example you could define a <a href="computedfield.html">computed field</a> on Circuit objects, using the Netutils <code>bits_to_name</code> function, to display the "Commit Rate" as a human-readable value by using the template code <code>{{ (obj.commit_rate * 1000) | bits_to_name }}</code>. (This particular example is contrived, as the Nautobot UI already humanizes the raw <code>commit_rate</code> value for display, but it demonstrates the kinds of things that these filters can be used for.)</p>
 <p>In general the syntax for using a netutils filter in a Jinja2 template is something like <code>{{ arg1 | function_name }}</code> for functions that take a single argument, and <code>{{ arg1 | function_name(arg_name2=arg2, arg_name3=arg3) }}</code> for functions that take multiple arguments.</p>
-<details class="version-added">
-<summary>Added in version 1.5.11</summary>
 <p>Netutils functions are also available in Django templates after using the <code>{% load netutils %}</code> directive in a template. The syntax to use these functions is then generally <code>{% function_name arg_name1=arg1 arg_name2=arg2 %}</code>.</p>
-</details>
 <h2 id="nautobot-built-in-filters">Nautobot Built-In Filters<a class="headerlink" href="#nautobot-built-in-filters" title="Permanent link">&para;</a></h2>
 <p>The Nautobot project also provides the following built-in <code>filters</code> that can be used in both Jinja2 and Django Template.</p>
 <h3 id="as_range">as_range<a class="headerlink" href="#as_range" title="Permanent link">&para;</a></h3>
@@ -9889,25 +9883,19 @@
 </details>
 <p>Render a phone number string, if any, as a <code>tel:</code> hyperlink, or render a placeholder if no phone number is given.</p>
 <h3 id="hyperlinked_object">hyperlinked_object<a class="headerlink" href="#hyperlinked_object" title="Permanent link">&para;</a></h3>
-<details class="version-added">
-<summary>Added in version 1.4.0</summary>
-</details>
 <p>Render and link to a Django model instance, if any, or render a placeholder if not.</p>
 <p>Uses <code>object.display</code> if available, otherwise uses the string representation of the object.
 If the object defines <code>get_absolute_url()</code> this will be used to hyperlink the displayed object;
 additionally if there is an <code>object.description</code> this will be used as the title of the hyperlink.</p>
 <div class="highlight"><pre><span></span><code><a id="__codelineno-10-1" name="__codelineno-10-1" href="#__codelineno-10-1"></a><span class="cp">{{</span> <span class="nv">device</span><span class="o">|</span><span class="nf">hyperlinked_object</span> <span class="cp">}}</span>
 </code></pre></div>
-<details class="version-added">
-<summary>Added in version 1.5.0</summary>
-<p>This filter now accepts an optional <code>field</code> parameter, which allows you to use a field other than <code>object.display</code> for the object representation if desired. For example, to display the object's <code>name</code> field instead:</p>
+<p>This filter also accepts an optional <code>field</code> parameter, which allows you to use a field other than <code>object.display</code> for the object representation if desired. For example, to display the object's <code>name</code> field instead:</p>
 <div class="highlight"><pre><span></span><code><a id="__codelineno-11-1" name="__codelineno-11-1" href="#__codelineno-11-1"></a><span class="x"># Django Template</span>
 <a id="__codelineno-11-2" name="__codelineno-11-2" href="#__codelineno-11-2"></a><span class="cp">{{</span> <span class="nv">location</span><span class="o">|</span><span class="nf">hyperlinked_object</span><span class="s2">:&quot;name&quot;</span> <span class="cp">}}</span>
 <a id="__codelineno-11-3" name="__codelineno-11-3" href="#__codelineno-11-3"></a>
 <a id="__codelineno-11-4" name="__codelineno-11-4" href="#__codelineno-11-4"></a><span class="x"># Jinja</span>
 <a id="__codelineno-11-5" name="__codelineno-11-5" href="#__codelineno-11-5"></a><span class="cp">{{</span> <span class="nv">location</span><span class="o">|</span><span class="nf">hyperlinked_object</span><span class="o">(</span><span class="s2">&quot;name&quot;</span><span class="o">)</span> <span class="cp">}}</span>
 </code></pre></div>
-</details>
 <h3 id="meta">meta<a class="headerlink" href="#meta" title="Permanent link">&para;</a></h3>
 <p>Return the specified Meta attribute of a model.</p>
 <div class="highlight"><pre><span></span><code><a id="__codelineno-12-1" name="__codelineno-12-1" href="#__codelineno-12-1"></a><span class="cp">{{</span> <span class="nv">obj</span> <span class="o">|</span> <span class="nf">meta</span><span class="o">(</span><span class="s1">&#39;app_label&#39;</span><span class="o">)</span> <span class="cp">}}</span>

nautobot/project-static/docs/user-guide/platform-functionality/webhook.html

@@ -9313,13 +9313,8 @@
 <li><code>username</code> - The name of the user account associated with the change.</li>
 <li><code>request_id</code> - The unique request ID. This may be used to correlate multiple changes associated with a single request.</li>
 <li><code>data</code> - A serialized representation of the object <em>after</em> the change was made. This is typically equivalent to the model's representation in Nautobot's REST API.</li>
-</ul>
-<details class="version-added">
-<summary>Added in version 1.3.0</summary>
-<ul>
 <li><code>snapshots</code> - snapshots of the serialized object state both before and after the change was made; provided as a dictionary with keys named <code>prechange</code>, <code>postchange</code> and <code>differences</code>.</li>
 </ul>
-</details>
 <h3 id="default-request-body">Default Request Body<a class="headerlink" href="#default-request-body" title="Permanent link">&para;</a></h3>
 <p>If no body template is specified, the request body will be populated with a JSON object containing the context data. For example, a newly created Location might appear as follows:</p>
 <div class="highlight"><pre><span></span><code><a id="__codelineno-0-1" name="__codelineno-0-1" href="#__codelineno-0-1"></a>{

nautobot/project-static/js/editor.js

@@ -0,0 +1,292 @@
+/**
+ * Monaco Editor wrapper for embedding in any page.
+ * 
+ * Configuration via data attributes:
+ * @param {string} data-mode - Set to 'diff' for diff viewer, omit for standard editor
+ * @param {string} data-lang - Language syntax (json, yaml, xml, text)
+ * @param {string} data-value - Initial content for standard editor
+ * @param {string} data-original - Original content for diff viewer (requires data-mode="diff")
+ * @param {string} data-modified - Modified content for diff viewer (requires data-mode="diff")
+ * @param {string} data-options - JSON string of Monaco editor options to merge with base config
+ * 
+ * Example Usage:
+ * 
+ * Diff Viewer:
+ * <div class="editor-container" 
+ *      data-mode="diff"
+ *      data-original="{{ diff_removed }}"
+ *      data-modified="{{ diff_added }}"
+ *      data-lang="json">
+ * </div>
+ * 
+ * Standard Editor:
+ * <div class="editor-container"
+ *      data-lang="yaml"
+ *      data-value="key: value"
+ *      data-options='{"readOnly": false}'>
+ * </div>
+ */
+;(function(window, document, undefined) {
+  'use strict';
+
+  const MONACO_BASE = window.nautobot_static_url + 'monaco-editor-0.52.2';
+
+  class Editor {
+      // Base configuration for all editor instances
+      static BASE_COMMON = {
+          automaticLayout: true,
+          scrollBeyondLastLine: false,
+          lineDecorationsWidth: 0,
+          lineNumbers: 'off',
+          wordWrap: 'off',
+          renderWhitespace: 'none',
+          guides: { 
+              indentation: false,
+              highlightActiveIndentation: false,
+              bracketPairs: false
+          },
+          readOnly: true,
+          contextmenu: false,
+          matchBrackets: 'never',
+          accessibilitySupport: 'auto',
+          minimap: { enabled: false },
+          renderLineHighlight: 'none',
+          hideCursorInOverviewRuler: true,
+          overviewRuler: {
+              border: false,
+              lanes: 0,
+              renderOverviewRuler: false
+          },
+          scrollbar: {
+              useShadows: false,
+              verticalScrollbarSize: 8,
+              horizontalScrollbarSize: 8,
+              alwaysConsumeMouseWheel: false,
+              arrowSize: 0,
+              handleMouseWheel: true
+          },
+      };
+
+      // Additional configuration for diff viewer mode
+      static BASE_DIFF = {
+          enableSplitViewResizing: false,
+          renderSideBySide: true,
+          useInlineViewWhenSpaceIsLimited: false
+      };
+
+      /** Creates a new Editor instance, ensuring Monaco is loaded before initialization. */
+      static async create(host) {
+          await Editor.loadMonaco();
+          return new Editor(host);
+      }
+
+      /** Initializes shared Monaco Editor environment, ensuring only one initialization occurs. */
+      static async loadMonaco() {
+          if (window.monaco) return;
+
+          // Create worker environment with blob URL wrapper for CORS
+          const createWorkerEnv = () => {
+              const workerPath = `${MONACO_BASE}/vs/base/worker/workerMain.js`;
+              const absoluteWorkerPath = new URL(workerPath, window.location.origin).href;
+
+              // Create cached blob URL for all workers
+              if (!window._monacoWorkerUrl) {
+                  const workerCode = `
+                      self.MonacoEnvironment = { 
+                          baseUrl: '${new URL(MONACO_BASE, window.location.origin).href}'
+                      };
+                      importScripts('${absoluteWorkerPath}');
+                  `;
+                  
+                  window._monacoWorkerUrl = URL.createObjectURL(
+                      new Blob([workerCode], { type: 'text/javascript' })
+                  );
+              }
+
+              return { 
+                  getWorkerUrl: () => window._monacoWorkerUrl
+              };
+          };
+
+          // Load Monaco via AMD, reusing existing promise if pending
+          window._monacoLoaderPromise ||= new Promise((resolve, reject) => {
+              const script = document.createElement('script');
+              script.src = `${MONACO_BASE}/vs/loader.js`;
+              script.crossOrigin = 'anonymous';
+              
+              script.onload = () => {
+                  require.config({
+                      paths: { 
+                          vs: `${MONACO_BASE}/vs`
+                      }
+                  });
+                  
+                  window.MonacoEnvironment = createWorkerEnv();
+                  require(['vs/editor/editor.main'], resolve, reject);
+              };
+              
+              script.onerror = reject;
+              document.head.appendChild(script);
+          });
+
+          await window._monacoLoaderPromise;
+      }
+
+      /** Constructs a new Editor instance with configuration from host element. */
+      constructor(host) {
+          this._host = host;
+          this._editor = null;
+          this._resizeObserver = null;
+
+          // Destructure with safety
+          const { mode, lang, value, original, modified, options } = host.dataset;
+          
+          this._config = {
+              isDiff: mode === 'diff',
+              language: lang || 'text',
+              theme: document.documentElement.dataset.theme === 'dark' ? 'vs-dark' : 'vs',
+              value: value || '',
+              original: original || '',
+              modified: modified || '',
+              options: {
+                  ...JSON.parse(options || '{}')  // User overrides
+              }
+          };
+
+          this.init();
+      }
+
+      /** Initializes editor with configured options and sets up event listeners. */
+      init() {
+          const { theme, language, isDiff, options } = this._config;
+          
+          const editorOptions = {
+              ...Editor.BASE_COMMON,  // Use static property
+              ...(isDiff ? Editor.BASE_DIFF : {}),  // Use static property
+              ...options
+          };
+          
+          if (this._config.isDiff) {
+              this._createDiffEditor({ theme, language, ...editorOptions });
+          } else {
+              this._createStandardEditor({ theme, language, ...editorOptions });
+          }
+
+          this._setupResize();
+          this._setupContentHeightListener();
+      }
+
+      /** Creates a standard Monaco editor with the configured value and options. */
+      _createStandardEditor(options) {
+          this._editor = monaco.editor.create(this._host, {
+              ...options,
+              value: this._config.value
+          });
+      }
+
+      /** Creates a Monaco diff editor with original and modified content models. */
+      _createDiffEditor(options) {
+          this._editor = monaco.editor.createDiffEditor(this._host, options);
+          const { language, original, modified } = this._config;
+          this._editor.setModel({
+              original: monaco.editor.createModel(original, language),
+              modified: monaco.editor.createModel(modified, language)
+          });
+      }
+
+      /** Sets up a debounced resize observer to update editor layout. */
+      _setupResize() {
+          let resizeTimeout;
+          this._resizeObserver = new ResizeObserver(() => {
+              // Add debouncing for better performance with multiple editors
+              if (resizeTimeout) clearTimeout(resizeTimeout);
+              resizeTimeout = setTimeout(() => {
+                  this._editor?.layout();
+                  this._updateEditorHeight();
+              }, 100);
+          });
+          this._resizeObserver.observe(this._host);
+      }
+
+      /** Registers listeners to update editor height when content size changes. */
+      _setupContentHeightListener() {
+          // Store listeners for cleanup
+          this._contentListeners = [];
+          const update = () => this._updateEditorHeight();
+
+          if (this._config.isDiff) {
+              this._contentListeners.push(
+                  this._editor.getOriginalEditor().onDidContentSizeChange(update),
+                  this._editor.getModifiedEditor().onDidContentSizeChange(update)
+              );
+          } else {
+              this._contentListeners.push(
+                  this._editor.onDidContentSizeChange(update)
+              );
+          }
+      }
+
+      /** Updates editor container height based on content and max-height constraints. */
+      _updateEditorHeight() {
+          if (!this._editor) return;
+
+          const getHeight = e => e.getContentHeight() + 5;
+          let contentHeight;
+
+          if (this._config.isDiff) {
+              contentHeight = Math.max(
+                  getHeight(this._editor.getOriginalEditor()),
+                  getHeight(this._editor.getModifiedEditor())
+              );
+          } else {
+              contentHeight = getHeight(this._editor);
+          }
+
+          // Get max-height from CSS (if set)
+          const maxHeight = parseInt(getComputedStyle(this._host).maxHeight, 10);
+          if (!isNaN(maxHeight)) {
+              contentHeight = Math.min(contentHeight, maxHeight);
+          }
+
+          this._host.style.height = `${contentHeight}px`;
+          this._editor.layout();
+      }
+
+      /** Cleans up editor instance, models, and event listeners. */
+      dispose() {
+          if (!this._editor) return;
+
+          // Dispose content size listeners
+          this._contentListeners?.forEach(listener => listener.dispose());
+          this._contentListeners = null;
+
+          // Dispose models safely
+          const model = this._editor.getModel();
+          if (this._config.isDiff) {
+              model?.original?.dispose();
+              model?.modified?.dispose();
+          } else {
+              model?.dispose();
+          }
+
+          // Cleanup editor
+          this._editor.dispose();
+          this._resizeObserver?.disconnect();
+
+          // Clear references
+          [this._editor, this._resizeObserver, this._host, this._config] = [];
+      }
+  }
+
+  // Initialize editors with error handling
+  document.addEventListener('DOMContentLoaded', () => {
+      const containers = Array.from(document.querySelectorAll('.editor-container'));
+      Promise.allSettled(containers.map(host => Editor.create(host)))
+          .then(results => results.forEach((result, i) => {
+              if (result.status === 'rejected') {
+                  containers[i].textContent = 'Editor initialization failed';
+                  console.error('Monaco error:', result.reason);
+              }
+          }));
+  });
+})(window, document);

nautobot/project-static/monaco-editor-0.52.2/README.md

@@ -0,0 +1,81 @@
+# Monaco Editor Custom Build
+
+Minimal Monaco Editor distribution optimized for JSON, YAML, and XML. Built for reduced bundle size while maintaining core functionality.
+
+## Install
+
+```bash
+nautobot/project-static/monaco-editor-[VERSION]/
+```
+
+## Features
+
+- Full Monaco editing experience
+- JSON with language server support
+- YAML and XML syntax support
+- Core UI components and Codicon font
+- Modern browser support
+
+## Build
+
+```bash
+# Get latest version
+VERSION=$(curl -s https://registry.npmjs.org/monaco-editor | jq -r '."dist-tags".latest')
+
+# Download and extract
+curl -O -L "https://registry.npmjs.org/monaco-editor/-/monaco-editor-$VERSION.tgz"
+tar -xzf monaco-editor-*.tgz
+
+# Setup directories
+mkdir -p nautobot/project-static/monaco-editor-$VERSION/vs/{editor,language,basic-languages}
+mkdir -p nautobot/project-static/monaco-editor-$VERSION/vs/base/{worker,browser/ui}
+
+# Copy core files
+cp package/min/vs/loader.js nautobot/project-static/monaco-editor-$VERSION/vs/
+cp package/min/vs/editor/editor.main.js nautobot/project-static/monaco-editor-$VERSION/vs/editor/
+cp package/min/vs/editor/editor.main.css nautobot/project-static/monaco-editor-$VERSION/vs/editor/
+
+# Copy language files
+mkdir -p nautobot/project-static/monaco-editor-$VERSION/vs/language/json
+mkdir -p nautobot/project-static/monaco-editor-$VERSION/vs/basic-languages/{yaml,xml}
+cp -r package/min/vs/language/json/* nautobot/project-static/monaco-editor-$VERSION/vs/language/json/
+cp -r package/min/vs/basic-languages/yaml/* nautobot/project-static/monaco-editor-$VERSION/vs/basic-languages/yaml/
+cp -r package/min/vs/basic-languages/xml/* nautobot/project-static/monaco-editor-$VERSION/vs/basic-languages/xml/
+
+# Copy worker and UI
+cp -r package/min/vs/base/worker nautobot/project-static/monaco-editor-$VERSION/vs/base/
+mkdir -p nautobot/project-static/monaco-editor-$VERSION/vs/base/browser/ui/codicons/codicon
+cp -r package/min/vs/base/browser/ui/codicons/codicon/* nautobot/project-static/monaco-editor-$VERSION/vs/base/browser/ui/codicons/codicon/
+```
+
+## Structure
+
+```bash
+nautobot/project-static/monaco-editor-0.52.2/
+├── vs/
+│   ├── base/
+│   │   ├── worker/
+│   │   │   └── workerMain.js
+│   │   └── browser/ui/codicons/
+│   ├── basic-languages/
+│   │   ├── xml/
+│   │   └── yaml/
+│   ├── editor/
+│   │   ├── editor.main.css
+│   │   └── editor.main.js
+│   ├── language/
+│   │   └── json/
+│   └── loader.js
+```
+
+## Development
+
+- MIT License
+- Supports Chrome, Firefox, Safari, Edge
+- Externally maintained build
+
+## Contributing
+
+1. Update version numbers in README and paths
+2. Test in target application
+3. Verify language services work