@scalar/workspace-store 0.49.2 → 0.51.0

package/dist/mutators/auth.js

@@ -3,6 +3,8 @@ import { getResolvedRef } from '../helpers/get-resolved-ref.js';
 import { isNonOptionalSecurityRequirement } from '../helpers/is-non-optional-security-requirement.js';
 import { mergeObjects } from '../helpers/merge-object.js';
 import { unpackProxyObject } from '../helpers/unpack-proxy.js';
+import { getSelectedSecurity } from '../request-example/context/security/get-selected-security.js';
+import { isOpenApiDocument } from '../schemas/type-guards.js';
 /**
  * Updates the selected security schemes for either the entire document or a specific operation.
  * - Adds newly created security schemes (if any) to the workspace document's components.
@@ -28,7 +30,10 @@ import { unpackProxyObject } from '../helpers/unpack-proxy.js';
  * ```
  */
 export const updateSelectedSecuritySchemes = async (store, document, { selectedRequirements, newSchemes, meta }) => {
-    const documentName = document?.['x-scalar-navigation']?.name;
+    if (!isOpenApiDocument(document)) {
+        return;
+    }
+    const documentName = document['x-scalar-navigation']?.name;
     if (!documentName) {
         return;
     }
@@ -88,7 +93,10 @@ export const updateSelectedSecuritySchemes = async (store, document, { selectedR
  * If the document name cannot be determined, nothing happens.
  */
 const clearSelectedSecuritySchemes = (store, document, { meta }) => {
-    const documentName = document?.['x-scalar-navigation']?.name;
+    if (!isOpenApiDocument(document)) {
+        return;
+    }
+    const documentName = document['x-scalar-navigation']?.name;
     if (!documentName) {
         return;
     }
@@ -121,7 +129,10 @@ const clearSelectedSecuritySchemes = (store, document, { meta }) => {
  * })
  */
 export const updateSecurityScheme = (document, { payload, name }) => {
-    const target = getResolvedRef(document?.components?.securitySchemes?.[name]);
+    if (!isOpenApiDocument(document)) {
+        return;
+    }
+    const target = getResolvedRef(document.components?.securitySchemes?.[name]);
     if (!target) {
         console.error(`Security scheme ${name} not found`);
         return;
@@ -133,7 +144,10 @@ export const updateSecurityScheme = (document, { payload, name }) => {
     return target;
 };
 const updateSecuritySchemeSecrets = (store, document, { payload, name, overwrite = false }) => {
-    const documentName = document?.['x-scalar-navigation']?.name;
+    if (!isOpenApiDocument(document)) {
+        return;
+    }
+    const documentName = document['x-scalar-navigation']?.name;
     if (!documentName) {
         return;
     }
@@ -147,7 +161,10 @@ const updateSecuritySchemeSecrets = (store, document, { payload, name, overwrite
     store?.auth.setAuthSecrets(documentName, name, result);
 };
 const clearSecuritySchemeSecrets = (store, document, { name }) => {
-    const documentName = document?.['x-scalar-navigation']?.name;
+    if (!isOpenApiDocument(document)) {
+        return;
+    }
+    const documentName = document['x-scalar-navigation']?.name;
     if (!documentName) {
         return;
     }
@@ -180,12 +197,15 @@ const clearSecuritySchemeSecrets = (store, document, { name }) => {
  * });
  */
 export const updateSelectedAuthTab = (store, document, { index, meta }) => {
-    const documentName = document?.['x-scalar-navigation']?.name;
+    if (!isOpenApiDocument(document)) {
+        return;
+    }
+    const documentName = document['x-scalar-navigation']?.name;
     if (!documentName) {
         return;
     }
     // Ensure the path/method exists in the document
-    if (meta.type === 'operation' && document?.paths?.[meta.path]?.[meta.method] === undefined) {
+    if (meta.type === 'operation' && document.paths?.[meta.path]?.[meta.method] === undefined) {
         return;
     }
     // Determine the target object for setting the auth tab index:
@@ -204,19 +224,33 @@ export const updateSelectedAuthTab = (store, document, { index, meta }) => {
         }
         return store?.auth.setAuthSelectedSchemas({ type: 'operation', documentName, path: meta.path, method: meta.method }, { selectedIndex: index, selectedSchemes: [] });
     }
-    // Set the selected index
-    target.selectedIndex = index;
+    store?.auth.setAuthSelectedSchemas(meta.type === 'document'
+        ? { type: 'document', documentName }
+        : { type: 'operation', documentName, path: meta.path, method: meta.method }, {
+        selectedIndex: index,
+        selectedSchemes: unpackProxyObject(target.selectedSchemes, { depth: null }) ?? [],
+    });
+};
+/**
+ * Returns whether `id` lists the same scheme names as `requirement` (OpenAPI security requirement keys),
+ * ignoring key order. UI payloads use `Object.keys(selectedSecuritySchemas)` which follows insertion order;
+ * stored copies may serialize with a different order.
+ */
+const securityRequirementIdsMatch = (requirement, id) => {
+    const sortedRequirementKeys = [...Object.keys(requirement)].sort((a, b) => a.localeCompare(b));
+    const sortedId = [...id].sort((a, b) => a.localeCompare(b));
+    return JSON.stringify(sortedRequirementKeys) === JSON.stringify(sortedId);
 };
 /**
  * Updates the scopes for a specific security requirement in the selected security schemes of
- * a document or operation. Also allow to add a new scope to the scheme.
+ * a document or operation. This mutator only touches selection state; managing the scope
+ * definitions on the OAuth flow is handled by `upsertScope` and `deleteScope`.
  *
  * @param document - The OpenAPI WorkspaceDocument to update.
  * @param id - An array of scheme names that uniquely identifies the target security requirement.
  *             For example: ['OAuth', 'ApiKeyAuth']
  * @param name - The security scheme name to update scopes for (e.g., 'OAuth').
  * @param scopes - The new list of scopes to set. For example: ['read:pets', 'write:pets']
- * @param newScopePayload - The payload to add a new scope with
  * @param meta - The context specifying whether the update is at the document-level or operation-level.
  *
  * Example usage:
@@ -240,8 +274,11 @@ export const updateSelectedAuthTab = (store, document, { index, meta }) => {
  * // After, the first scheme becomes: { "OAuth": ["write:pets"] }
  * ```
  */
-export const updateSelectedScopes = (store, document, { id, name, scopes, newScopePayload, meta }) => {
-    const documentName = document?.['x-scalar-navigation']?.name;
+export const updateSelectedScopes = (store, document, { id, name, scopes, meta }) => {
+    if (!isOpenApiDocument(document)) {
+        return;
+    }
+    const documentName = document['x-scalar-navigation']?.name;
     if (!documentName) {
         return;
     }
@@ -252,31 +289,160 @@ export const updateSelectedScopes = (store, document, { id, name, scopes, newSco
         }
         return store?.auth.getAuthSelectedSchemas({ type: 'operation', documentName, path: meta.path, method: meta.method });
     };
-    const target = getTarget();
-    if (!target) {
+    // Resolve the target lazily: only build a fallback selection when the store has none.
+    //
+    // We pass `[]` for security requirements because a `preferredSecurityScheme` is always
+    // supplied (derived from `id`), which makes `getSelectedSecurity` build the requirement
+    // from that scheme alone and never read the requirements array.
+    const target = getTarget() ??
+        getSelectedSecurity(undefined, undefined, [], (document.components?.securitySchemes ?? {}), id.length === 1 ? id[0] : id);
+    const nextSelectedSchemes = unpackProxyObject(target.selectedSchemes, { depth: 1 }) ?? [];
+    // Match the security requirement by scheme key names (order-insensitive: Object.keys order
+    // can differ between the store copy and the UI payload for the same requirement object).
+    const nextScheme = nextSelectedSchemes.find((candidate) => securityRequirementIdsMatch(candidate, id));
+    if (!isNonOptionalSecurityRequirement(nextScheme)) {
+        return;
+    }
+    nextScheme[name] = scopes;
+    store?.auth.setAuthSelectedSchemas(meta.type === 'document'
+        ? { type: 'document', documentName }
+        : { type: 'operation', documentName, path: meta.path, method: meta.method }, { selectedIndex: target.selectedIndex, selectedSchemes: nextSelectedSchemes });
+};
+/**
+ * Resolves the OAuth flow on a security scheme by name + flow type.
+ * Returns `null` when the scheme or flow cannot be found, or the scheme is not an OAuth2 / OpenID Connect scheme.
+ */
+const resolveOAuthFlow = (document, name, flowType) => {
+    if (!isOpenApiDocument(document)) {
+        return null;
+    }
+    const securityScheme = getResolvedRef(document.components?.securitySchemes?.[name]);
+    if (!securityScheme) {
+        return null;
+    }
+    if (securityScheme.type !== 'oauth2' && securityScheme.type !== 'openIdConnect') {
+        return null;
+    }
+    return securityScheme.flows?.[flowType] ?? null;
+};
+/**
+ * Walks every selection container that lives under a document (the document-level
+ * `x-scalar-selected-security` plus the equivalent on every path / method) and invokes
+ * `transform` on a plain copy of `selectedSchemes`, then writes back through
+ * `setAuthSelectedSchemas` so persistence hooks run.
+ */
+const walkSelectedSchemes = (store, document, transform) => {
+    if (!isOpenApiDocument(document) || !store) {
+        return;
+    }
+    const documentName = document['x-scalar-navigation']?.name;
+    if (!documentName) {
+        return;
+    }
+    const apply = (payload) => {
+        const target = store.auth.getAuthSelectedSchemas(payload);
+        if (!target) {
+            return;
+        }
+        const nextSchemes = unpackProxyObject(target.selectedSchemes, { depth: 1 }) ?? [];
+        transform(nextSchemes);
+        store.auth.setAuthSelectedSchemas(payload, {
+            selectedIndex: target.selectedIndex,
+            selectedSchemes: nextSchemes,
+        });
+    };
+    apply({ type: 'document', documentName });
+    Object.entries(document.paths ?? {}).forEach(([path, pathItemObject]) => {
+        Object.entries(pathItemObject).forEach(([method, operation]) => {
+            if (typeof operation !== 'object') {
+                return;
+            }
+            apply({ type: 'operation', documentName, path, method });
+        });
+    });
+};
+/**
+ * Adds a new scope to an OAuth flow, or renames / updates the description of an existing one.
+ *
+ * When `oldScope` differs from `scope`, this mutator also rewrites every selection entry
+ * that references the matching security scheme so consumers do not need a follow-up
+ * `auth:update:selected-scopes`.
+ *
+ * When `enable` is true, the resulting `scope` is additionally appended to every selection
+ * requirement that already references this security scheme, enabling an "add and select"
+ * flow without a separate selection mutation.
+ */
+export const upsertScope = (store, document, { name, flowType, scope, description, oldScope, enable }) => {
+    if (!isOpenApiDocument(document)) {
         return;
     }
-    // Find the security requirement that matches the given id (scheme key names)
-    // For example: if id = ["OAuth"], matches { OAuth: [...] }
-    const scheme = target.selectedSchemes.find((scheme) => JSON.stringify(Object.keys(scheme)) === JSON.stringify(id));
-    // If the scheme is optional, do nothing as it cannot have scopes
-    if (!isNonOptionalSecurityRequirement(scheme)) {
+    const flow = resolveOAuthFlow(document, name, flowType);
+    if (!flow) {
         return;
     }
-    // If we have a new scope payload, add it to the scheme
-    if (newScopePayload) {
-        const securityScheme = getResolvedRef(document.components?.securitySchemes?.[name]);
-        const flow = securityScheme?.flows?.[newScopePayload?.flowType];
-        if (!flow) {
+    flow.scopes ||= {};
+    const isRename = Boolean(oldScope) && oldScope !== scope;
+    // Rename: drop the previous key so iteration order stays predictable.
+    if (isRename) {
+        if (!(oldScope in flow.scopes)) {
             return;
         }
-        flow.scopes ||= {};
-        flow.scopes[newScopePayload.name] = newScopePayload.description;
-        scheme[name] = [...scopes, newScopePayload.name];
+        delete flow.scopes[oldScope];
+    }
+    flow.scopes[scope] = description;
+    if (!isRename && !enable) {
+        return;
+    }
+    // Mirror the rename and/or apply `enable` across selection entries that reference this scheme.
+    walkSelectedSchemes(store, document, (selectedSchemes) => {
+        selectedSchemes.forEach((requirement) => {
+            if (!isNonOptionalSecurityRequirement(requirement)) {
+                return;
+            }
+            const scopes = requirement[name];
+            if (!Array.isArray(scopes)) {
+                return;
+            }
+            let nextScopes = scopes;
+            // Rewrite the old key in place when this requirement had the renamed scope selected.
+            if (isRename && nextScopes.includes(oldScope)) {
+                nextScopes = nextScopes.map((current) => (current === oldScope ? scope : current));
+            }
+            // Append the resulting scope when the caller asked for "add and select".
+            if (enable && !nextScopes.includes(scope)) {
+                nextScopes = [...nextScopes, scope];
+            }
+            if (nextScopes !== scopes) {
+                requirement[name] = nextScopes;
+            }
+        });
+    });
+};
+/**
+ * Removes a scope from an OAuth flow and strips it from any selection state that references
+ * the matching security scheme.
+ */
+export const deleteScope = (store, document, { name, flowType, scope }) => {
+    if (!isOpenApiDocument(document)) {
         return;
     }
-    // Set the scopes array for the named security scheme within the found security requirement
-    scheme[name] = scopes;
+    const flow = resolveOAuthFlow(document, name, flowType);
+    if (!flow?.scopes) {
+        return;
+    }
+    delete flow.scopes[scope];
+    walkSelectedSchemes(store, document, (selectedSchemes) => {
+        selectedSchemes.forEach((requirement) => {
+            if (!isNonOptionalSecurityRequirement(requirement)) {
+                return;
+            }
+            const scopes = requirement[name];
+            if (!Array.isArray(scopes) || !scopes.includes(scope)) {
+                return;
+            }
+            requirement[name] = scopes.filter((current) => current !== scope);
+        });
+    });
 };
 /**
  * Deletes one or more security schemes from an OpenAPI WorkspaceDocument,
@@ -298,11 +464,14 @@ export const updateSelectedScopes = (store, document, { id, name, scopes, newSco
  * - Any extended x-scalar-selected-security references to those schemes are also removed.
  */
 export const deleteSecurityScheme = (store, document, { names }) => {
-    const documentName = document?.['x-scalar-navigation']?.name;
-    if (!documentName) {
+    if (!isOpenApiDocument(document)) {
         // Early exit if there is no document to modify
         return;
     }
+    const documentName = document['x-scalar-navigation']?.name;
+    if (!documentName) {
+        return;
+    }
     // Get the mutable reference to securitySchemes in components (may be a proxy/resolved reference)
     const target = getResolvedRef(document.components?.securitySchemes);
     if (!target) {
@@ -325,8 +494,11 @@ export const deleteSecurityScheme = (store, document, { names }) => {
     const documentSelectedSecurity = store?.auth.getAuthSelectedSchemas({ type: 'document', documentName });
     // -- Remove from document-level `x-scalar-selected-security` extension, if present
     if (documentSelectedSecurity) {
-        documentSelectedSecurity.selectedSchemes = filterSecuritySchemes(documentSelectedSecurity.selectedSchemes);
-        documentSelectedSecurity.selectedIndex = clampIndex(documentSelectedSecurity.selectedIndex, documentSelectedSecurity.selectedSchemes.length);
+        const filtered = filterSecuritySchemes(documentSelectedSecurity.selectedSchemes);
+        store?.auth.setAuthSelectedSchemas({ type: 'document', documentName }, {
+            selectedIndex: clampIndex(documentSelectedSecurity.selectedIndex, filtered.length),
+            selectedSchemes: filtered,
+        });
     }
     // -- Remove from document-level `security` property, if present
     if (document['security']) {
@@ -345,7 +517,6 @@ export const deleteSecurityScheme = (store, document, { names }) => {
             if ('security' in resolvedOperation && resolvedOperation['security']) {
                 resolvedOperation['security'] = filterSecuritySchemes(resolvedOperation['security']);
             }
-            // // Remove from operation-level x-scalar-selected-security array
             const operationSelectedSecurity = store?.auth.getAuthSelectedSchemas({
                 type: 'operation',
                 documentName,
@@ -353,8 +524,11 @@ export const deleteSecurityScheme = (store, document, { names }) => {
                 method,
             });
             if (operationSelectedSecurity) {
-                operationSelectedSecurity.selectedSchemes = filterSecuritySchemes(operationSelectedSecurity.selectedSchemes);
-                operationSelectedSecurity.selectedIndex = clampIndex(operationSelectedSecurity.selectedIndex, operationSelectedSecurity.selectedSchemes.length);
+                const filtered = filterSecuritySchemes(operationSelectedSecurity.selectedSchemes);
+                store?.auth.setAuthSelectedSchemas({ type: 'operation', documentName, path, method }, {
+                    selectedIndex: clampIndex(operationSelectedSecurity.selectedIndex, filtered.length),
+                    selectedSchemes: filtered,
+                });
             }
         });
     });
@@ -368,6 +542,8 @@ export const authMutatorsFactory = ({ document, store, }) => {
         clearSecuritySchemeSecrets: (payload) => clearSecuritySchemeSecrets(store, document, payload),
         updateSelectedAuthTab: (payload) => updateSelectedAuthTab(store, document, payload),
         updateSelectedScopes: (payload) => updateSelectedScopes(store, document, payload),
+        upsertScope: (payload) => upsertScope(store, document, payload),
+        deleteScope: (payload) => deleteScope(store, document, payload),
         deleteSecurityScheme: (payload) => deleteSecurityScheme(store, document, payload),
     };
 };

package/dist/mutators/cookie.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cookie.d.ts","sourceRoot":"","sources":["../../src/mutators/cookie.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAC7D,OAAO,EAAE,KAAK,aAAa,EAAuB,MAAM,+CAA+C,CAAA;AAGvG,KAAK,KAAK,CAAC,CAAC,SAAS,MAAM,YAAY,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAA;AAElF;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,GACvB,YAAY,iBAAiB,GAAG,SAAS,GAAG,IAAI,EAChD,oBAAoB,KAAK,CAAC,sBAAsB,CAAC,KAChD,aAAa,GAAG,SA8BlB,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,GACvB,YAAY,iBAAiB,GAAG,SAAS,GAAG,IAAI,EAChD,WAAW,KAAK,CAAC,sBAAsB,CAAC,KACvC,OAWF,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,gBAAgB;IAAE,UAAU,EAAE,iBAAiB,GAAG,SAAS,GAAG,IAAI,CAAA;CAAE;4BAE9E,KAAK,CAAC,sBAAsB,CAAC;4BAC7B,KAAK,CAAC,sBAAsB,CAAC;CAExD,CAAA"}
+{"version":3,"file":"cookie.d.ts","sourceRoot":"","sources":["../../src/mutators/cookie.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAC7D,OAAO,EAAE,KAAK,aAAa,EAAuB,MAAM,+CAA+C,CAAA;AAIvG,KAAK,KAAK,CAAC,CAAC,SAAS,MAAM,YAAY,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAA;AAElF;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,GACvB,YAAY,iBAAiB,GAAG,SAAS,GAAG,IAAI,EAChD,oBAAoB,KAAK,CAAC,sBAAsB,CAAC,KAChD,aAAa,GAAG,SA8BlB,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,GACvB,YAAY,iBAAiB,GAAG,SAAS,GAAG,IAAI,EAChD,WAAW,KAAK,CAAC,sBAAsB,CAAC,KACvC,OAWF,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,gBAAgB;IAAE,UAAU,EAAE,iBAAiB,GAAG,SAAS,GAAG,IAAI,CAAA;CAAE;4BAE9E,KAAK,CAAC,sBAAsB,CAAC;4BAC7B,KAAK,CAAC,sBAAsB,CAAC;CAExD,CAAA"}

package/dist/mutators/cookie.js

@@ -1,4 +1,5 @@
 import { xScalarCookieSchema } from '../schemas/extensions/general/x-scalar-cookies.js';
+import { isAsyncApiDocument } from '../schemas/type-guards.js';
 import { coerceValue } from '../schemas/typebox-coerce.js';
 /**
  * Adds OR updates a cookie to the document or workspace.
@@ -11,7 +12,7 @@ import { coerceValue } from '../schemas/typebox-coerce.js';
  * @returns the parsed cookie that was added or updated or undefined if the collection is not found
  */
 export const upsertCookie = (collection, { payload, index }) => {
-    if (!collection) {
+    if (!collection || isAsyncApiDocument(collection)) {
         return;
     }
     if (!collection['x-scalar-cookies']) {
@@ -46,7 +47,7 @@ export const upsertCookie = (collection, { payload, index }) => {
  * @returns true if the cookie was deleted, false otherwise
  */
 export const deleteCookie = (collection, { index }) => {
-    if (!collection || !collection['x-scalar-cookies']) {
+    if (!collection || isAsyncApiDocument(collection) || !collection['x-scalar-cookies']) {
         return false;
     }
     if (index < 0 || index >= collection['x-scalar-cookies'].length) {

package/dist/mutators/document.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../../src/mutators/document.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAElD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GAClC,UAAU,iBAAiB,GAAG,IAAI,EAClC,SAAS,cAAc,CAAC,2BAA2B,CAAC,SAMrD,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,UAAU,iBAAiB,GAAG,IAAI,EAAE,WAAW,OAAO,SAOrF,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,GAC7B,UAAU,iBAAiB,GAAG,IAAI,EAClC,SAAS,cAAc,CAAC,sBAAsB,CAAC,SAchD,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,UAAU,iBAAiB,GAAG,IAAI,EAAE,MAAM,MAAM,SASlF,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAC9B,OAAO,cAAc,GAAG,IAAI,EAC5B,SAAS,cAAc,CAAC,gCAAgC,CAAC,kBA8B1D,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,cAAc,GAAG,IAAI,EAAE,SAAS,cAAc,CAAC,0BAA0B,CAAC,SAM/G,CAAA;AAED,eAAO,MAAM,uBAAuB,GAAI,sBAGrC;IACD,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAA;IAClC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAA;CAC7B;uCAEsC,cAAc,CAAC,2BAA2B,CAAC;kCAEhD,cAAc,CAAC,sBAAsB,CAAC;+BACzC,cAAc,CAAC,4BAA4B,CAAC;kCACzC,cAAc,CAAC,sBAAsB,CAAC;mCACrC,cAAc,CAAC,gCAAgC,CAAC;8BAErD,cAAc,CAAC,0BAA0B,CAAC;CAEvE,CAAA"}
+{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../../src/mutators/document.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAGlD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GAClC,UAAU,iBAAiB,GAAG,IAAI,EAClC,SAAS,cAAc,CAAC,2BAA2B,CAAC,SAMrD,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,UAAU,iBAAiB,GAAG,IAAI,EAAE,WAAW,OAAO,SAOrF,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,GAC7B,UAAU,iBAAiB,GAAG,IAAI,EAClC,SAAS,cAAc,CAAC,sBAAsB,CAAC,SAchD,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,UAAU,iBAAiB,GAAG,IAAI,EAAE,MAAM,MAAM,SASlF,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAC9B,OAAO,cAAc,GAAG,IAAI,EAC5B,SAAS,cAAc,CAAC,gCAAgC,CAAC,kBA8B1D,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,cAAc,GAAG,IAAI,EAAE,SAAS,cAAc,CAAC,0BAA0B,CAAC,SAM/G,CAAA;AAED,eAAO,MAAM,uBAAuB,GAAI,sBAGrC;IACD,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAA;IAClC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAA;CAC7B;uCAEsC,cAAc,CAAC,2BAA2B,CAAC;kCAEhD,cAAc,CAAC,sBAAsB,CAAC;+BACzC,cAAc,CAAC,4BAA4B,CAAC;kCACzC,cAAc,CAAC,sBAAsB,CAAC;mCACrC,cAAc,CAAC,gCAAgC,CAAC;8BAErD,cAAc,CAAC,0BAA0B,CAAC;CAEvE,CAAA"}

package/dist/mutators/document.js

@@ -1,10 +1,11 @@
 import { mergeObjects } from '../helpers/merge-object.js';
+import { isOpenApiDocument } from '../schemas/type-guards.js';
 /**
  * Updates extension fields on the document (e.g. x-pre-request, x-post-response).
  * Merges the payload into the document root.
  */
 export const updateDocumentExtension = (document, payload) => {
-    if (!document) {
+    if (!isOpenApiDocument(document)) {
         return;
     }
     mergeObjects(document, payload);
@@ -18,7 +19,7 @@ export const updateDocumentExtension = (document, payload) => {
  * If document is null, does nothing.
  */
 export const updateWatchMode = (document, watchMode) => {
-    if (!document) {
+    if (!isOpenApiDocument(document)) {
         return;
     }
     // Set (or unset) the x-scalar-watch-mode property on the document
@@ -35,7 +36,7 @@ export const updateWatchMode = (document, watchMode) => {
  * If document is null, does nothing.
  */
 export const updateDocumentInfo = (document, payload) => {
-    if (!document) {
+    if (!isOpenApiDocument(document)) {
         return;
     }
     // Merge the given payload into the document's info object
@@ -53,7 +54,7 @@ export const updateDocumentInfo = (document, payload) => {
  * Does not perform a sidebar rebuild for performance benefit
  */
 export const updateDocumentIcon = (document, icon) => {
-    if (!document || !document['x-scalar-navigation']) {
+    if (!isOpenApiDocument(document) || !document['x-scalar-navigation']) {
         return;
     }
     // Update the document icon

package/dist/mutators/environment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../src/mutators/environment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAA;AAEzE,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAC7D,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,kBAAkB,EAGxB,MAAM,qDAAqD,CAAA;AAG5D,KAAK,KAAK,CAAC,CAAC,SAAS,MAAM,iBAAiB,IAAI,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAA;AAE5F;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,GAC5B,WAAW,SAAS,GAAG,IAAI,EAC3B,YAAY,iBAAiB,GAAG,SAAS,GAAG,IAAI,EAChD,kDAAkD,KAAK,CAAC,gCAAgC,CAAC,KACxF,kBAAkB,GAAG,SAoCvB,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAC5B,WAAW,SAAS,GAAG,IAAI,EAC3B,YAAY,iBAAiB,GAAG,SAAS,GAAG,IAAI,EAChD,qBAAqB,KAAK,CAAC,gCAAgC,CAAC,SAQ7D,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,GACpC,YAAY,iBAAiB,GAAG,SAAS,GAAG,IAAI,EAChD,sCAAsC,KAAK,CAAC,yCAAyC,CAAC,KACrF,aAAa,GAAG,SA0BlB,CAAA;AAED,eAAO,MAAM,yBAAyB,GACpC,YAAY,iBAAiB,GAAG,SAAS,GAAG,IAAI,EAChD,4BAA4B,KAAK,CAAC,yCAAyC,CAAC,SAO7E,CAAA;AAED,eAAO,MAAM,0BAA0B,GAAI,4BAGxC;IACD,SAAS,EAAE,SAAS,GAAG,IAAI,CAAA;IAC3B,UAAU,EAAE,iBAAiB,GAAG,SAAS,GAAG,IAAI,CAAA;CACjD;iCAEgC,KAAK,CAAC,gCAAgC,CAAC;iCAEvC,KAAK,CAAC,gCAAgC,CAAC;yCAE/B,KAAK,CAAC,yCAAyC,CAAC;yCAEhD,KAAK,CAAC,yCAAyC,CAAC;CAGxF,CAAA"}
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../src/mutators/environment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAA;AAEzE,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAC7D,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,kBAAkB,EAGxB,MAAM,qDAAqD,CAAA;AAI5D,KAAK,KAAK,CAAC,CAAC,SAAS,MAAM,iBAAiB,IAAI,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAA;AAE5F;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,GAC5B,WAAW,SAAS,GAAG,IAAI,EAC3B,YAAY,iBAAiB,GAAG,SAAS,GAAG,IAAI,EAChD,kDAAkD,KAAK,CAAC,gCAAgC,CAAC,KACxF,kBAAkB,GAAG,SAoCvB,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAC5B,WAAW,SAAS,GAAG,IAAI,EAC3B,YAAY,iBAAiB,GAAG,SAAS,GAAG,IAAI,EAChD,qBAAqB,KAAK,CAAC,gCAAgC,CAAC,SAQ7D,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,GACpC,YAAY,iBAAiB,GAAG,SAAS,GAAG,IAAI,EAChD,sCAAsC,KAAK,CAAC,yCAAyC,CAAC,KACrF,aAAa,GAAG,SA6BlB,CAAA;AAED,eAAO,MAAM,yBAAyB,GACpC,YAAY,iBAAiB,GAAG,SAAS,GAAG,IAAI,EAChD,4BAA4B,KAAK,CAAC,yCAAyC,CAAC,SAU7E,CAAA;AAED,eAAO,MAAM,0BAA0B,GAAI,4BAGxC;IACD,SAAS,EAAE,SAAS,GAAG,IAAI,CAAA;IAC3B,UAAU,EAAE,iBAAiB,GAAG,SAAS,GAAG,IAAI,CAAA;CACjD;iCAEgC,KAAK,CAAC,gCAAgC,CAAC;iCAEvC,KAAK,CAAC,gCAAgC,CAAC;yCAE/B,KAAK,CAAC,yCAAyC,CAAC;yCAEhD,KAAK,CAAC,yCAAyC,CAAC;CAGxF,CAAA"}

package/dist/mutators/environment.js

@@ -1,5 +1,6 @@
 import { unpackProxyObject } from '../helpers/unpack-proxy.js';
 import { xScalarEnvVarSchema, xScalarEnvironmentSchema, } from '../schemas/extensions/document/x-scalar-environments.js';
+import { isAsyncApiDocument } from '../schemas/type-guards.js';
 import { coerceValue } from '../schemas/typebox-coerce.js';
 /**
  * Adds OR updates an environment to the document or workspace.
@@ -13,7 +14,7 @@ import { coerceValue } from '../schemas/typebox-coerce.js';
  */
 export const upsertEnvironment = (workspace, collection, { environmentName, payload, oldEnvironmentName }) => {
     /** Discriminating between document and workspace */
-    if (!collection || !workspace) {
+    if (!collection || !workspace || isAsyncApiDocument(collection)) {
         return;
     }
     if (!collection['x-scalar-environments']) {
@@ -49,7 +50,7 @@ export const upsertEnvironment = (workspace, collection, { environmentName, payl
  * @param environmentName - The name of the environment to delete.
  */
 export const deleteEnvironment = (workspace, collection, { environmentName }) => {
-    if (!collection || !workspace) {
+    if (!collection || !workspace || isAsyncApiDocument(collection)) {
         return;
     }
     // Trigegr the change event for the active environment
@@ -65,8 +66,11 @@ export const deleteEnvironment = (workspace, collection, { environmentName }) =>
  * @returns the parsed variable that was added or updated or undefined if the collection is not found
  */
 export const upsertEnvironmentVariable = (collection, { environmentName, variable, index }) => {
+    if (!collection || isAsyncApiDocument(collection)) {
+        return;
+    }
     // The environment should exist by now if we are upserting a variable
-    if (!collection?.['x-scalar-environments']?.[environmentName]) {
+    if (!collection['x-scalar-environments']?.[environmentName]) {
         console.error('Environment not found', environmentName);
         return;
     }
@@ -88,11 +92,14 @@ export const upsertEnvironmentVariable = (collection, { environmentName, variabl
     return parsed;
 };
 export const deleteEnvironmentVariable = (collection, { environmentName, index }) => {
-    if (!collection?.['x-scalar-environments']?.[environmentName]) {
+    if (!collection || isAsyncApiDocument(collection)) {
+        return;
+    }
+    if (!collection['x-scalar-environments']?.[environmentName]) {
         console.error('Environment not found', environmentName);
         return;
     }
-    collection['x-scalar-environments']?.[environmentName]?.variables?.splice(index, 1);
+    collection['x-scalar-environments'][environmentName]?.variables?.splice(index, 1);
 };
 export const environmentMutatorsFactory = ({ workspace, collection, }) => {
     return {

package/dist/mutators/index.d.ts

@@ -70,6 +70,8 @@ export declare function generateClientMutators(store: WorkspaceStore | null): {
             clearSecuritySchemeSecrets: (payload: import("../events/definitions/auth.js").AuthEvents["auth:clear:security-scheme-secrets"]) => void;
             updateSelectedAuthTab: (payload: import("../events/definitions/auth.js").AuthEvents["auth:update:active-index"]) => void;
             updateSelectedScopes: (payload: import("../events/definitions/auth.js").AuthEvents["auth:update:selected-scopes"]) => void;
+            upsertScope: (payload: import("../events/definitions/auth.js").AuthEvents["auth:upsert:scopes"]) => void;
+            deleteScope: (payload: import("../events/definitions/auth.js").AuthEvents["auth:delete:scopes"]) => void;
             deleteSecurityScheme: (payload: import("../events/definitions/auth.js").AuthEvents["auth:delete:security-scheme"]) => void;
         };
         cookie: {
@@ -157,6 +159,8 @@ export declare function generateClientMutators(store: WorkspaceStore | null): {
             clearSecuritySchemeSecrets: (payload: import("../events/definitions/auth.js").AuthEvents["auth:clear:security-scheme-secrets"]) => void;
             updateSelectedAuthTab: (payload: import("../events/definitions/auth.js").AuthEvents["auth:update:active-index"]) => void;
             updateSelectedScopes: (payload: import("../events/definitions/auth.js").AuthEvents["auth:update:selected-scopes"]) => void;
+            upsertScope: (payload: import("../events/definitions/auth.js").AuthEvents["auth:upsert:scopes"]) => void;
+            deleteScope: (payload: import("../events/definitions/auth.js").AuthEvents["auth:delete:scopes"]) => void;
             deleteSecurityScheme: (payload: import("../events/definitions/auth.js").AuthEvents["auth:delete:security-scheme"]) => void;
         };
         cookie: {

package/dist/mutators/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mutators/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAa9C;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAqC/D;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;;;OAIG;gBACS,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAErB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mutators/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAa9C;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAqC/D;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;;;OAIG;gBACS,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAErB"}

package/dist/mutators/operation/body.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"body.d.ts","sourceRoot":"","sources":["../../../src/mutators/operation/body.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAGrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAgClD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qCAAqC,GAChD,UAAU,iBAAiB,GAAG,IAAI,EAClC,mBAAmB,eAAe,CAAC,0CAA0C,CAAC,SAwB/E,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iCAAiC,GAC5C,UAAU,iBAAiB,GAAG,IAAI,EAClC,gCAAgC,eAAe,CAAC,oCAAoC,CAAC,SAStF,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,mCAAmC,GAC9C,UAAU,iBAAiB,GAAG,IAAI,EAClC,gCAAgC,eAAe,CAAC,wCAAwC,CAAC,SAS1F,CAAA"}
+{"version":3,"file":"body.d.ts","sourceRoot":"","sources":["../../../src/mutators/operation/body.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAGrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAoClD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qCAAqC,GAChD,UAAU,iBAAiB,GAAG,IAAI,EAClC,mBAAmB,eAAe,CAAC,0CAA0C,CAAC,SAwB/E,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iCAAiC,GAC5C,UAAU,iBAAiB,GAAG,IAAI,EAClC,gCAAgC,eAAe,CAAC,oCAAoC,CAAC,SAStF,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,mCAAmC,GAC9C,UAAU,iBAAiB,GAAG,IAAI,EAClC,gCAAgC,eAAe,CAAC,wCAAwC,CAAC,SAS1F,CAAA"}

package/dist/mutators/operation/body.js

@@ -1,8 +1,12 @@
 import { getResolvedRef } from '../../helpers/get-resolved-ref.js';
 import { unpackProxyObject } from '../../helpers/unpack-proxy.js';
+import { isOpenApiDocument } from '../../schemas/type-guards.js';
 /** Ensure the json that we need exists up to the example object in the request body */
 const findOrCreateRequestBodyExample = (document, contentType, meta) => {
-    const operation = getResolvedRef(document?.paths?.[meta.path]?.[meta.method]);
+    if (!isOpenApiDocument(document)) {
+        return null;
+    }
+    const operation = getResolvedRef(document.paths?.[meta.path]?.[meta.method]);
     if (!operation) {
         return null;
     }
@@ -36,7 +40,7 @@ const findOrCreateRequestBodyExample = (document, contentType, meta) => {
  * ```
  */
 export const updateOperationRequestBodyContentType = (document, { meta, payload }) => {
-    if (!document) {
+    if (!isOpenApiDocument(document)) {
         return;
     }
     const operation = getResolvedRef(document.paths?.[meta.path]?.[meta.method]);

package/dist/mutators/operation/extensions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../../../src/mutators/operation/extensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAG/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAElD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,GACnC,UAAU,iBAAiB,GAAG,IAAI,EAClC,mBAAmB,eAAe,CAAC,4BAA4B,CAAC,SAQjE,CAAA"}
+{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../../../src/mutators/operation/extensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAG/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAGlD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,GACnC,UAAU,iBAAiB,GAAG,IAAI,EAClC,mBAAmB,eAAe,CAAC,4BAA4B,CAAC,SAWjE,CAAA"}

package/dist/mutators/operation/extensions.js

@@ -1,5 +1,6 @@
 import { getResolvedRef } from '../../helpers/get-resolved-ref.js';
 import { mergeObjects } from '../../helpers/merge-object.js';
+import { isOpenApiDocument } from '../../schemas/type-guards.js';
 /**
  * Updates an extension of the operation
  *
@@ -13,7 +14,10 @@ import { mergeObjects } from '../../helpers/merge-object.js';
  * ```
  */
 export const updateOperationExtension = (document, { meta, payload }) => {
-    const operation = getResolvedRef(document?.paths?.[meta.path]?.[meta.method]);
+    if (!isOpenApiDocument(document)) {
+        return;
+    }
+    const operation = getResolvedRef(document.paths?.[meta.path]?.[meta.method]);
     if (!operation) {
         return;
     }

package/dist/mutators/operation/history.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../../src/mutators/operation/history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAErE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAOlD,eAAO,MAAM,oBAAoB,GAC/B,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,mBAAmB,WAAW,CAAC,2BAA2B,CAAC,kBAyC5D,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,2BAA2B,eAAe,CAAC,0BAA0B,CAAC,SA4BvE,CAAA"}
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../../src/mutators/operation/history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAErE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAQlD,eAAO,MAAM,oBAAoB,GAC/B,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,mBAAmB,WAAW,CAAC,2BAA2B,CAAC,kBA4C5D,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,2BAA2B,eAAe,CAAC,0BAA0B,CAAC,SA4BvE,CAAA"}

package/dist/mutators/operation/history.js

@@ -1,11 +1,15 @@
 import { getResolvedRef } from '../../helpers/get-resolved-ref.js';
+import { isOpenApiDocument } from '../../schemas/type-guards.js';
 import { isContentTypeParameterObject } from '../../schemas/v3.1/strict/type-guards.js';
 import { fetchRequestToHar } from './helpers/fetch-request-to-har.js';
 import { fetchResponseToHar } from './helpers/fetch-response-to-har.js';
 import { harToOperation } from './helpers/har-to-operation.js';
 export const addResponseToHistory = async (store, document, { payload, meta }) => {
-    const documentName = document?.['x-scalar-navigation']?.name;
-    if (!document || !documentName || !payload) {
+    if (!isOpenApiDocument(document)) {
+        return;
+    }
+    const documentName = document['x-scalar-navigation']?.name;
+    if (!documentName || !payload) {
         return;
     }
     const operation = getResolvedRef(document.paths?.[meta.path]?.[meta.method]);
@@ -40,7 +44,7 @@ export const addResponseToHistory = async (store, document, { payload, meta }) =
     });
 };
 export const reloadOperationHistory = (store, document, { meta, index, callback }) => {
-    if (!document) {
+    if (!isOpenApiDocument(document)) {
         console.error('Document not found', meta.path, meta.method);
         return;
     }

package/dist/mutators/operation/operation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/mutators/operation/operation.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAOrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAElD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,eAAe,GAC1B,gBAAgB,cAAc,GAAG,IAAI,EACrC,SAAS,eAAe,CAAC,4BAA4B,CAAC,KACrD,MAAM,GAAG,SA0DX,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,GAC9B,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,mBAAmB,eAAe,CAAC,uBAAuB,CAAC,SAsB5D,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,yBAAyB,GACpC,UAAU,iBAAiB,GAAG,IAAI,EAClC,OAAO,cAAc,GAAG,IAAI,EAC5B,mEAAmE,eAAe,CAAC,6BAA6B,CAAC,KAChH,IAgGF,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,GAC1B,WAAW,cAAc,GAAG,IAAI,EAChC,wBAAwB,eAAe,CAAC,4BAA4B,CAAC,SAgBtE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,GACtC,WAAW,cAAc,GAAG,IAAI,EAChC,uDAAuD,eAAe,CAAC,gCAAgC,CAAC,SAuBzG,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,GACjC,WAAW,cAAc,GAAG,IAAI,EAChC,sDAAsD,eAAe,CAAC,0BAA0B,CAAC,SAiDlG,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,GACjC,WAAW,cAAc,GAAG,IAAI,EAChC,+DAA+D,eAAe,CAAC,0BAA0B,CAAC,SAuE3G,CAAA"}
+{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/mutators/operation/operation.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAOrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAGlD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,eAAe,GAC1B,gBAAgB,cAAc,GAAG,IAAI,EACrC,SAAS,eAAe,CAAC,4BAA4B,CAAC,KACrD,MAAM,GAAG,SA0DX,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,GAC9B,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,mBAAmB,eAAe,CAAC,uBAAuB,CAAC,SAsB5D,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,yBAAyB,GACpC,UAAU,iBAAiB,GAAG,IAAI,EAClC,OAAO,cAAc,GAAG,IAAI,EAC5B,mEAAmE,eAAe,CAAC,6BAA6B,CAAC,KAChH,IAqGF,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,GAC1B,WAAW,cAAc,GAAG,IAAI,EAChC,wBAAwB,eAAe,CAAC,4BAA4B,CAAC,SAgBtE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,GACtC,WAAW,cAAc,GAAG,IAAI,EAChC,uDAAuD,eAAe,CAAC,gCAAgC,CAAC,SAuBzG,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,GACjC,WAAW,cAAc,GAAG,IAAI,EAChC,sDAAsD,eAAe,CAAC,0BAA0B,CAAC,SAiDlG,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,GACjC,WAAW,cAAc,GAAG,IAAI,EAChC,+DAA+D,eAAe,CAAC,0BAA0B,CAAC,SAuE3G,CAAA"}