@scalar/workspace-store 0.68.2 → 0.68.3

package/dist/helpers/resolve-security-requirements.js

@@ -25,8 +25,9 @@ const absoluteReference = (reference, base) => {
  * Relative keys in referenced documents become absolute to keep distinct document bases apart.
  */
 export const resolveSecurityRequirements = async (document, { origin = '/', loaders }) => {
-    if (typeof document.openapi !== 'string' || !/^3\.2\.\d+$/.test(document.openapi))
+    if (typeof document.openapi !== 'string' || !/^3\.2\.\d+$/.test(document.openapi)) {
         return;
+    }
     const originalKeys = isObject(document[ORIGINAL_KEYS]) ? document[ORIGINAL_KEYS] : {};
     const components = isObject(document.components) ? document.components : {};
     const schemes = isObject(components.securitySchemes) ? components.securitySchemes : {};
@@ -44,8 +45,9 @@ export const resolveSecurityRequirements = async (document, { origin = '/', load
     const processedDocuments = new Set();
     const cache = new Map();
     const visit = async (node, path, base, external) => {
-        if (node === null || typeof node !== 'object' || visited.has(node) || isSchemaPath(path))
+        if (node === null || typeof node !== 'object' || visited.has(node) || isSchemaPath(path)) {
             return;
+        }
         visited.add(node);
         // Security is a fixed field on document and operation objects, not arbitrary example payloads.
         const operationKey = path.at(-1) ?? '';
@@ -53,11 +55,13 @@ export const resolveSecurityRequirements = async (document, { origin = '/', load
         const isDocument = path.length === 0 || (path[0] === 'x-ext' && path.length === 2);
         if (isObject(node) && (isDocument || isOperation) && Array.isArray(node.security)) {
             for (const [index, requirement] of node.security.entries()) {
-                if (!isObject(requirement))
+                if (!isObject(requirement)) {
                     continue;
+                }
                 for (const [name, scopes] of Object.entries(requirement)) {
-                    if (namedSchemes.has(name) || !Array.isArray(scopes))
+                    if (namedSchemes.has(name) || !Array.isArray(scopes)) {
                         continue;
+                    }
                     const uri = (() => {
                         try {
                             return Object.hasOwn(aliases, name) && typeof aliases[name] === 'string'
@@ -68,8 +72,9 @@ export const resolveSecurityRequirements = async (document, { origin = '/', load
                             return undefined;
                         }
                     })();
-                    if (uri === undefined)
+                    if (uri === undefined) {
                         continue;
+                    }
                     const key = await generateUniqueValue({
                         defaultValue: external ? uri : name,
                         validation: (candidate) => !namedSchemes.has(candidate) &&
@@ -77,8 +82,9 @@ export const resolveSecurityRequirements = async (document, { origin = '/', load
                             (!external || candidate === name || !Object.hasOwn(requirement, candidate)),
                         maxRetries: Object.keys(schemes).length + 1,
                     });
-                    if (key === undefined)
+                    if (key === undefined) {
                         continue;
+                    }
                     if (!Object.hasOwn(aliases, key)) {
                         const reference = { $ref: uri };
                         await bundle({ components: { securitySchemes: { target: reference } } }, {
@@ -106,8 +112,9 @@ export const resolveSecurityRequirements = async (document, { origin = '/', load
                                 ])),
                             }
                             : target;
-                        if (!Value.Check(SecuritySchemeObjectSchema, validationTarget))
+                        if (!Value.Check(SecuritySchemeObjectSchema, validationTarget)) {
                             continue;
+                        }
                         Object.defineProperty(schemes, key, {
                             value: reference,
                             enumerable: true,
@@ -125,8 +132,9 @@ export const resolveSecurityRequirements = async (document, { origin = '/', load
                         Object.defineProperty(mapping, name, { value: key, enumerable: true, writable: true, configurable: true });
                         originalKeys[location] = mapping;
                         document[ORIGINAL_KEYS] = originalKeys;
-                        if (key === name)
+                        if (key === name) {
                             continue;
+                        }
                         const previous = Object.hasOwn(requirement, key) ? requirement[key] : [];
                         Object.defineProperty(requirement, key, {
                             value: [...new Set([...(Array.isArray(previous) ? previous : []), ...scopes])],
@@ -140,8 +148,9 @@ export const resolveSecurityRequirements = async (document, { origin = '/', load
             }
         }
         for (const [key, child] of Object.entries(node)) {
-            if (key.startsWith('x-') || key === 'example' || key === 'examples' || key === 'security')
+            if (key.startsWith('x-') || key === 'example' || key === 'examples' || key === 'security') {
                 continue;
+            }
             await visit(child, [...path, key], base, external);
         }
     };
@@ -150,14 +159,17 @@ export const resolveSecurityRequirements = async (document, { origin = '/', load
     // URI-only dependencies can load further documents, so process newly embedded documents too.
     while (isObject(document['x-ext'])) {
         const next = Object.entries(document['x-ext']).find(([key]) => !processedDocuments.has(key));
-        if (!next)
+        if (!next) {
             break;
+        }
         const [key, external] = next;
         processedDocuments.add(key);
-        if (!isObject(external))
+        if (!isObject(external)) {
             continue;
-        if (typeof external.openapi === 'string' && !/^3\.2\.\d+$/.test(external.openapi))
+        }
+        if (typeof external.openapi === 'string' && !/^3\.2\.\d+$/.test(external.openapi)) {
             continue;
+        }
         const mappings = document['x-ext-urls'];
         const retrieval = isObject(mappings) && typeof mappings[key] === 'string' ? mappings[key] : key;
         const retrievalUri = resolveReferencePath(entryBase, retrieval);
@@ -179,20 +191,24 @@ export const restoreSecurityRequirements = (document) => {
             })();
             if (!Array.isArray(path) ||
                 !path.every((segment) => typeof segment === 'string' && !isPollutionKey(segment)) ||
-                !isObject(mapping))
+                !isObject(mapping)) {
                 continue;
+            }
             const requirement = path.reduce((parent, segment) => {
-                if (parent === null || typeof parent !== 'object' || !Object.hasOwn(parent, segment))
+                if (parent === null || typeof parent !== 'object' || !Object.hasOwn(parent, segment)) {
                     return undefined;
+                }
                 return Reflect.get(parent, segment);
             }, document);
-            if (!isObject(requirement))
+            if (!isObject(requirement)) {
                 continue;
+            }
             const entries = Object.entries(mapping).flatMap(([original, rewritten]) => typeof rewritten === 'string' && Object.hasOwn(requirement, rewritten)
                 ? [{ original, rewritten, scopes: requirement[rewritten] }]
                 : []);
-            for (const { rewritten } of entries)
+            for (const { rewritten } of entries) {
                 delete requirement[rewritten];
+            }
             for (const { original, scopes } of entries) {
                 Object.defineProperty(requirement, original, {
                     value: scopes,
@@ -210,12 +226,15 @@ export const restoreSecurityRequirements = (document) => {
         isObject(components) &&
         Object.hasOwn(components, 'securitySchemes') &&
         isObject(components.securitySchemes)) {
-        for (const key of Object.keys(metadata.schemes))
+        for (const key of Object.keys(metadata.schemes)) {
             delete components.securitySchemes[key];
-        if (!metadata.hadSecuritySchemes && Object.keys(components.securitySchemes).length === 0)
+        }
+        if (!metadata.hadSecuritySchemes && Object.keys(components.securitySchemes).length === 0) {
             delete components.securitySchemes;
-        if (!metadata.hadComponents && Object.keys(components).length === 0)
+        }
+        if (!metadata.hadComponents && Object.keys(components).length === 0) {
             delete document.components;
+        }
     }
     delete document[ALIASES];
     delete document[ORIGINAL_KEYS];

package/dist/helpers/resolve-traits.d.ts

@@ -0,0 +1,3 @@
+/** Merge traits in order, then apply the target's own fields with highest priority. */
+export declare const resolveTraits: <T extends object>(target: T, traits: readonly object[]) => T;
+//# sourceMappingURL=resolve-traits.d.ts.map

package/dist/helpers/resolve-traits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-traits.d.ts","sourceRoot":"","sources":["../../src/helpers/resolve-traits.ts"],"names":[],"mappings":"AAoEA,uFAAuF;AACvF,eAAO,MAAM,aAAa,GAAI,CAAC,SAAS,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,SAAS,MAAM,EAAE,KAAG,CAetF,CAAA"}

package/dist/helpers/resolve-traits.js

@@ -0,0 +1,68 @@
+import { isObject } from '@scalar/helpers/object/is-object';
+import { getResolvedRef } from './get-resolved-ref.js';
+const schemaMaps = new Set(['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas']);
+const dataFields = new Set(['example', 'examples', 'default', 'enum', 'const', 'value', 'dataValue']);
+/**
+ * Apply JSON Merge Patch to resolved trait fields. Unlike mergeObjects, null removes a key.
+ * Resolve schema references before merging so a message can extend referenced trait headers.
+ */
+const mergeTraitFields = (target, patch, context = 'object', ancestors = new WeakMap()) => {
+    // Reply channels identify a location in the document, so retain their reference wrappers.
+    if (context === 'reference') {
+        return patch;
+    }
+    const resolvedPatch = context === 'object' && isObject(patch) && typeof patch.$ref === 'string' ? getResolvedRef(patch) : patch;
+    if (!isObject(resolvedPatch)) {
+        return resolvedPatch;
+    }
+    // Resolved schemas can be recursive. Keep their cycles without changing the source document.
+    if (ancestors.has(resolvedPatch)) {
+        return ancestors.get(resolvedPatch);
+    }
+    const resolvedTarget = context === 'object' && isObject(target) && typeof target.$ref === 'string' ? getResolvedRef(target) : target;
+    const result = isObject(resolvedTarget) ? { ...resolvedTarget } : {};
+    ancestors.set(resolvedPatch, result);
+    for (const [key, value] of Object.entries(resolvedPatch)) {
+        if (value === null) {
+            delete result[key];
+        }
+        else if (value !== undefined) {
+            // Schema names and example data can contain literal $ref keys without being references.
+            const childContext = context === 'data'
+                ? 'data'
+                : context === 'map'
+                    ? 'object'
+                    : key === 'channel'
+                        ? 'reference'
+                        : dataFields.has(key) || key.startsWith('x-')
+                            ? 'data'
+                            : schemaMaps.has(key)
+                                ? 'map'
+                                : 'object';
+            // Define an own property even for schema properties named __proto__.
+            Object.defineProperty(result, key, {
+                value: mergeTraitFields(Object.hasOwn(result, key) ? result[key] : undefined, value, childContext, ancestors),
+                enumerable: true,
+                configurable: true,
+                writable: true,
+            });
+        }
+    }
+    ancestors.delete(resolvedPatch);
+    return result;
+};
+/** Merge traits in order, then apply the target's own fields with highest priority. */
+export const resolveTraits = (target, traits) => {
+    if (traits.length === 0) {
+        return target;
+    }
+    const inherited = traits.reduce((fields, trait) => {
+        const resolved = getResolvedRef(trait);
+        return resolved ? mergeTraitFields(fields, resolved) : fields;
+    }, {});
+    // Only overlay fields supplied by traits. Unrelated fields keep their references and identity.
+    const overrides = Object.fromEntries(Object.entries(target).filter(([key]) => Object.hasOwn(inherited, key)));
+    const merged = mergeTraitFields(inherited, overrides);
+    const ownFields = Object.fromEntries(Object.entries(target).filter(([key]) => !Object.hasOwn(inherited, key)));
+    return { ...ownFields, ...merged };
+};

package/dist/helpers/serialize-stream-example.js

@@ -11,7 +11,7 @@ export const serializeStreamExample = (value, contentType, singleItem) => {
         return undefined;
     }
     const format = getStreamFormat(contentType);
-    const items = singleItem ? [value] : Array.isArray(value) ? value : [value];
+    const items = !singleItem && Array.isArray(value) ? value : [value];
     if (format === 'json-lines') {
         return items.map((item) => `${JSON.stringify(item)}\n`).join('');
     }

package/dist/helpers/use-external-examples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-external-examples.d.ts","sourceRoot":"","sources":["../../src/helpers/use-external-examples.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,GAAG,EAOT,MAAM,KAAK,CAAA;AAEZ,OAAO,EAAE,KAAK,uBAAuB,EAAiC,MAAM,6BAA6B,CAAA;AACzG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAA;AAE3E,4FAA4F;AAC5F,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,MAAM,uBAAuB,CAA+B,CAAA;AAEzG,0GAA0G;AAC1G,eAAO,MAAM,oBAAoB,GAAI,QAAQ,GAAG,CAAC,OAAO,GAAG,uBAAuB,GAAG,IAAI,CAAC,KAAG,GAAG,CAAC,OAAO,CAuBvG,CAAA;AAED,gGAAgG;AAChG,eAAO,MAAM,mBAAmB,GAC9B,UAAU,MAAM,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,EAC7C,UAAS,MAAM,OAAoB,EACnC,WAAW,MAAM,uBAAuB,KACvC;IACD,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC7B,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC5B,OAAO,EAAE,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,KAAK,aAAa,GAAG,SAAS,CAAA;IAC1E,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAsC3B,CAAA"}
+{"version":3,"file":"use-external-examples.d.ts","sourceRoot":"","sources":["../../src/helpers/use-external-examples.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,GAAG,EAOT,MAAM,KAAK,CAAA;AAEZ,OAAO,EAAE,KAAK,uBAAuB,EAAiC,MAAM,6BAA6B,CAAA;AACzG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAA;AAE3E,4FAA4F;AAC5F,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,MAAM,uBAAuB,CAA+B,CAAA;AAEzG,0GAA0G;AAC1G,eAAO,MAAM,oBAAoB,GAAI,QAAQ,GAAG,CAAC,OAAO,GAAG,uBAAuB,GAAG,IAAI,CAAC,KAAG,GAAG,CAAC,OAAO,CAyBvG,CAAA;AAED,gGAAgG;AAChG,eAAO,MAAM,mBAAmB,GAC9B,UAAU,MAAM,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,EAC7C,UAAS,MAAM,OAAoB,EACnC,WAAW,MAAM,uBAAuB,KACvC;IACD,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC7B,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC5B,OAAO,EAAE,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,KAAK,aAAa,GAAG,SAAS,CAAA;IAC1E,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CA8C3B,CAAA"}

package/dist/helpers/use-external-examples.js

@@ -10,8 +10,9 @@ export const useExampleVisibility = (target) => {
         observer?.disconnect();
         visible.value = false;
         const node = element && ('$el' in element ? element.$el : element);
-        if (typeof Element === 'undefined' || !(node instanceof Element))
+        if (typeof Element === 'undefined' || !(node instanceof Element)) {
             return;
+        }
         if (typeof IntersectionObserver === 'undefined') {
             visible.value = true;
             return;
@@ -32,22 +33,26 @@ export const useExternalExamples = (examples, enabled = () => true, resolver) =>
         .filter((example) => example !== undefined && example.value === undefined && !!example.externalValue)
         .map((example) => getResolver()(example)));
     watchEffect(() => {
-        if (!enabled())
+        if (!enabled()) {
             return;
+        }
         for (const state of states.value) {
-            if (state.status === 'idle')
+            if (state.status === 'idle') {
                 void state.load();
+            }
         }
     });
     return {
         pending: computed(() => states.value.some((state) => state.status !== 'loaded')),
         failed: computed(() => states.value.some((state) => state.status === 'error')),
         resolve: (example) => {
-            if (!example || example.value !== undefined || !example.externalValue)
+            if (!example || example.value !== undefined || !example.externalValue) {
                 return example;
+            }
             const state = getResolver()(example);
-            if (state.status !== 'loaded')
+            if (state.status !== 'loaded') {
                 return example;
+            }
             // A 3.2 example can pair structured data with external wire text. Keep both in the
             // resolved view so raw consumers display the download and form editors retain the data.
             if (example.dataValue !== undefined && state.serializedValue !== undefined) {

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

@@ -1 +1 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/mutators/auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAU3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAGlD,OAAO,KAAK,EAAgB,oBAAoB,EAAE,MAAM,uCAAuC,CAAA;AAuC/F;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,6BAA6B,GACxC,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,4CAA4C,UAAU,CAAC,uCAAuC,CAAC,kBAgFhG,CAAA;AAwBD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,UAAU,iBAAiB,GAAG,IAAI,EAClC,mBAAmB,UAAU,CAAC,6BAA6B,CAAC,qCAwB7D,CAAA;AAqED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,qBAAqB,GAChC,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,iBAAiB,UAAU,CAAC,0BAA0B,CAAC,SAgDxD,CAAA;AAaD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,6CAA6C,UAAU,CAAC,6BAA6B,CAAC,SA0EvF,CAAA;AAqED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,0DAA0D,UAAU,CAAC,oBAAoB,CAAC,SA2D3F,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,2BAA2B,UAAU,CAAC,oBAAoB,CAAC,SAwB5D,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,WAAW,UAAU,CAAC,6BAA6B,CAAC,SAoFrD,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,sBAGjC;IACD,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAA;IAClC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAA;CAC7B;6CAE4C,UAAU,CAAC,uCAAuC,CAAC;4CAEpD,UAAU,CAAC,sCAAsC,CAAC;oCAE1D,UAAU,CAAC,6BAA6B,CAAC;2CAElC,UAAU,CAAC,qCAAqC,CAAC;yCAEnD,UAAU,CAAC,mCAAmC,CAAC;0CAE9C,UAAU,CAAC,oCAAoC,CAAC;qCAErD,UAAU,CAAC,0BAA0B,CAAC;oCAEvC,UAAU,CAAC,6BAA6B,CAAC;2BAElD,UAAU,CAAC,oBAAoB,CAAC;2BAChC,UAAU,CAAC,oBAAoB,CAAC;oCACvB,UAAU,CAAC,6BAA6B,CAAC;CAG5E,CAAA"}
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/mutators/auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAU3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAGlD,OAAO,KAAK,EAAgB,oBAAoB,EAAE,MAAM,uCAAuC,CAAA;AAuC/F;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,6BAA6B,GACxC,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,4CAA4C,UAAU,CAAC,uCAAuC,CAAC,kBAgFhG,CAAA;AAwBD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,UAAU,iBAAiB,GAAG,IAAI,EAClC,mBAAmB,UAAU,CAAC,6BAA6B,CAAC,qCAwB7D,CAAA;AAqED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,qBAAqB,GAChC,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,iBAAiB,UAAU,CAAC,0BAA0B,CAAC,SAgDxD,CAAA;AAaD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,6CAA6C,UAAU,CAAC,6BAA6B,CAAC,SA0EvF,CAAA;AAqED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,0DAA0D,UAAU,CAAC,oBAAoB,CAAC,SA2D3F,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,2BAA2B,UAAU,CAAC,oBAAoB,CAAC,SAwB5D,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,WAAW,UAAU,CAAC,6BAA6B,CAAC,SAsFrD,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,sBAGjC;IACD,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAA;IAClC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAA;CAC7B;6CAE4C,UAAU,CAAC,uCAAuC,CAAC;4CAEpD,UAAU,CAAC,sCAAsC,CAAC;oCAE1D,UAAU,CAAC,6BAA6B,CAAC;2CAElC,UAAU,CAAC,qCAAqC,CAAC;yCAEnD,UAAU,CAAC,mCAAmC,CAAC;0CAE9C,UAAU,CAAC,oCAAoC,CAAC;qCAErD,UAAU,CAAC,0BAA0B,CAAC;oCAEvC,UAAU,CAAC,6BAA6B,CAAC;2BAElD,UAAU,CAAC,oBAAoB,CAAC;2BAChC,UAAU,CAAC,oBAAoB,CAAC;oCACvB,UAAU,CAAC,6BAA6B,CAAC;CAG5E,CAAA"}

package/dist/mutators/auth.js

@@ -590,8 +590,9 @@ export const deleteSecurityScheme = (store, document, { names }) => {
         forEachPathItemOperation(pathItemRef, (method, operationRef) => {
             // Get mutable reference for the operation (could resolve $ref proxies)
             const resolvedOperation = getResolvedRef(operationRef);
-            if (!resolvedOperation)
+            if (!resolvedOperation) {
                 return;
+            }
             // Remove from operation-level security array
             if ('security' in resolvedOperation && resolvedOperation['security']) {
                 resolvedOperation['security'] = filterSecuritySchemes(resolvedOperation['security']);

package/dist/mutators/operation/helpers/har-to-operation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"har-to-operation.d.ts","sourceRoot":"","sources":["../../../../src/mutators/operation/helpers/har-to-operation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,OAAO,KAAK,EAAE,eAAe,EAAmB,MAAM,8DAA8D,CAAA;AAKpH,KAAK,mBAAmB,GAAG;IACzB,6BAA6B;IAC7B,UAAU,EAAE,UAAU,CAAA;IACtB,oEAAoE;IACpE,UAAU,EAAE,MAAM,CAAA;IAClB,4CAA4C;IAC5C,aAAa,CAAC,EAAE,eAAe,CAAA;IAC/B,4CAA4C;IAC5C,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACvC,CAAA;AAyBD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,cAAc,GAAI,2DAK5B,mBAAmB,KAAG,eA0HxB,CAAA"}
+{"version":3,"file":"har-to-operation.d.ts","sourceRoot":"","sources":["../../../../src/mutators/operation/helpers/har-to-operation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,OAAO,KAAK,EAAE,eAAe,EAAmB,MAAM,8DAA8D,CAAA;AAKpH,KAAK,mBAAmB,GAAG;IACzB,6BAA6B;IAC7B,UAAU,EAAE,UAAU,CAAA;IACtB,oEAAoE;IACpE,UAAU,EAAE,MAAM,CAAA;IAClB,4CAA4C;IAC5C,aAAa,CAAC,EAAE,eAAe,CAAA;IAC/B,4CAA4C;IAC5C,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACvC,CAAA;AAyBD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,cAAc,GAAI,2DAK5B,mBAAmB,KAAG,eA4HxB,CAAA"}

package/dist/mutators/operation/helpers/har-to-operation.js

@@ -98,8 +98,9 @@ export const harToOperation = ({ harRequest, exampleKey, baseOperation = {}, pat
         }
         // Resolve the request body in case it is a reference
         const requestBody = getResolvedRef(baseOperation.requestBody);
-        if (!requestBody)
+        if (!requestBody) {
             return baseOperation;
+        }
         // Ensure the content type exists in the requestBody
         if (!requestBody.content[mimeType]) {
             requestBody.content[mimeType] = {
@@ -150,8 +151,9 @@ const setParameterDisabled = (param, exampleKey, disabled) => {
         return;
     }
     const example = getResolvedRef(param.examples[exampleKey]);
-    if (example)
+    if (example) {
         example['x-disabled'] = disabled;
+    }
 };
 /**
  * Finds an existing parameter in the parameters array or creates a new one.

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":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAarE,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,IAkGF,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,SAkDlG,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,GACjC,WAAW,cAAc,GAAG,IAAI,EAChC,+DAA+D,eAAe,CAAC,0BAA0B,CAAC,SAwE3G,CAAA"}
+{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/mutators/operation/operation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAarE,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,IAkGF,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,SAoDlG,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,GACjC,WAAW,cAAc,GAAG,IAAI,EAChC,+DAA+D,eAAe,CAAC,0BAA0B,CAAC,SA0E3G,CAAA"}

package/dist/mutators/operation/operation.js

@@ -274,8 +274,9 @@ export const deleteOperationExample = (workspace, { meta: { path, method, exampl
     // Remove the example from all operation parameters
     operation.parameters?.forEach((parameter) => {
         const resolvedParameter = getResolvedRef(parameter);
-        if (!resolvedParameter)
+        if (!resolvedParameter) {
             return;
+        }
         // Remove from content-level examples (if parameter uses content)
         if ('content' in resolvedParameter && resolvedParameter.content) {
             Object.values(resolvedParameter.content).forEach((mediaType) => {
@@ -325,8 +326,9 @@ export const renameOperationExample = (workspace, { meta: { path, method, exampl
     const records = [];
     operation.parameters?.forEach((parameter) => {
         const resolvedParameter = getResolvedRef(parameter);
-        if (!resolvedParameter)
+        if (!resolvedParameter) {
             return;
+        }
         if ('examples' in resolvedParameter && resolvedParameter.examples) {
             records.push(resolvedParameter.examples);
         }

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

@@ -1 +1 @@
-{"version":3,"file":"parameters.d.ts","sourceRoot":"","sources":["../../../src/mutators/operation/parameters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAMrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAmClD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,wBAAwB,GACnC,UAAU,iBAAiB,GAAG,IAAI,EAClC,4CAA4C,eAAe,CAAC,4BAA4B,CAAC,SAyG1F,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,8BAA8B,GACzC,UAAU,iBAAiB,GAAG,IAAI,EAClC,uCAAuC,eAAe,CAAC,mCAAmC,CAAC,SA8C5F,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,GACnC,UAAU,iBAAiB,GAAG,IAAI,EAClC,6BAA6B,eAAe,CAAC,4BAA4B,CAAC,SAkC3E,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,4BAA4B,GACvC,UAAU,iBAAiB,GAAG,IAAI,EAClC,gBAAgB,eAAe,CAAC,iCAAiC,CAAC,SAgBnE,CAAA"}
+{"version":3,"file":"parameters.d.ts","sourceRoot":"","sources":["../../../src/mutators/operation/parameters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAOrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAmClD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,wBAAwB,GACnC,UAAU,iBAAiB,GAAG,IAAI,EAClC,4CAA4C,eAAe,CAAC,4BAA4B,CAAC,SA4H1F,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,8BAA8B,GACzC,UAAU,iBAAiB,GAAG,IAAI,EAClC,uCAAuC,eAAe,CAAC,mCAAmC,CAAC,SA8C5F,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,GACnC,UAAU,iBAAiB,GAAG,IAAI,EAClC,6BAA6B,eAAe,CAAC,4BAA4B,CAAC,SAkC3E,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,4BAA4B,GACvC,UAAU,iBAAiB,GAAG,IAAI,EAClC,gBAAgB,eAAe,CAAC,iCAAiC,CAAC,SAgBnE,CAAA"}

package/dist/mutators/operation/parameters.js

@@ -3,6 +3,7 @@ import { getParameterExample } from '../../helpers/get-parameter-example.js';
 import { getResolvedRef } from '../../helpers/get-resolved-ref.js';
 import { getQuerystringParameter, serializeQuerystringParameter } from '../../helpers/querystring-parameter.js';
 import { unpackProxyObject } from '../../helpers/unpack-proxy.js';
+import { isParamDisabled } from '../../request-example/builder/header/is-param-disabled.js';
 import { isOpenApiDocument } from '../../schemas/type-guards.js';
 import { isContentTypeParameterObject } from '../../schemas/v3.2/strict/type-guards.js';
 const getPathItemsForParameterMutation = (pathItemRef) => {
@@ -47,6 +48,7 @@ export const upsertOperationParameter = (document, { meta, type, payload, origin
         const preserveQuerystringValue = querystring && payload.value === serializeQuerystringParameter(querystring);
         const param = originalParameter;
         const selected = getParameterExample(param, meta.exampleKey);
+        const inheritedDisabled = isParamDisabled(param, selected.example);
         const target = param.in !== 'querystring' && !selected.serialized && isContentTypeParameterObject(param)
             ? Object.values(param.content ?? {})[0]
             : param;
@@ -117,7 +119,27 @@ export const upsertOperationParameter = (document, { meta, type, payload, origin
                 example.value = payload.value;
             }
         }
-        example['x-disabled'] = payload.isDisabled;
+        if (payload.propertyState) {
+            // Freeze the inherited state before changing values: adding the first populated field
+            // must not implicitly enable every untouched sibling.
+            const states = { '[]': inheritedDisabled, ...example['x-scalar-disabled-properties'] };
+            const { path, previousPath, isDisabled } = payload.propertyState;
+            if (previousPath) {
+                delete states[JSON.stringify(previousPath)];
+            }
+            const key = JSON.stringify(path);
+            if (isDisabled === undefined) {
+                delete states[key];
+            }
+            else {
+                states[key] = isDisabled;
+            }
+            example['x-scalar-disabled-properties'] = states;
+        }
+        else {
+            example['x-disabled'] = payload.isDisabled;
+            delete example['x-scalar-disabled-properties'];
+        }
         return;
     }
     // We are adding a new parameter

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

@@ -1 +1 @@
-{"version":3,"file":"tag.d.ts","sourceRoot":"","sources":["../../src/mutators/tag.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AASzD;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,cAAc,GAAG,IAAI,EAAE,SAAS,SAAS,CAAC,gBAAgB,CAAC,SAe3F,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,OAAO,GAAI,OAAO,cAAc,GAAG,IAAI,EAAE,SAAS,SAAS,CAAC,cAAc,CAAC,SAqEvF,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,GAAI,WAAW,cAAc,GAAG,IAAI,EAAE,SAAS,SAAS,CAAC,gBAAgB,CAAC,SAiC/F,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,WAAW;IAAE,KAAK,EAAE,cAAc,GAAG,IAAI,CAAA;CAAE;yBAErD,SAAS,CAAC,gBAAgB,CAAC;uBAC7B,SAAS,CAAC,cAAc,CAAC;yBACvB,SAAS,CAAC,gBAAgB,CAAC;CAEnD,CAAA"}
+{"version":3,"file":"tag.d.ts","sourceRoot":"","sources":["../../src/mutators/tag.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AASzD;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,cAAc,GAAG,IAAI,EAAE,SAAS,SAAS,CAAC,gBAAgB,CAAC,SAe3F,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,OAAO,GAAI,OAAO,cAAc,GAAG,IAAI,EAAE,SAAS,SAAS,CAAC,cAAc,CAAC,SAqEvF,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,GAAI,WAAW,cAAc,GAAG,IAAI,EAAE,SAAS,SAAS,CAAC,gBAAgB,CAAC,SAqC/F,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,WAAW;IAAE,KAAK,EAAE,cAAc,GAAG,IAAI,CAAA;CAAE;yBAErD,SAAS,CAAC,gBAAgB,CAAC;uBAC7B,SAAS,CAAC,cAAc,CAAC;yBACvB,SAAS,CAAC,gBAAgB,CAAC;CAEnD,CAAA"}

package/dist/mutators/tag.js

@@ -112,8 +112,9 @@ export const deleteTag = (workspace, payload) => {
     Object.values(document.paths ?? {}).forEach((pathItemRef) => {
         forEachPathItemOperation(pathItemRef, (_method, operationRef) => {
             const resolvedOperation = getResolvedRef(operationRef);
-            if (!resolvedOperation)
+            if (!resolvedOperation) {
                 return;
+            }
             if ('tags' in resolvedOperation) {
                 const plainTags = unpackProxyObject(resolvedOperation.tags, { depth: 1 });
                 resolvedOperation.tags = plainTags?.filter((tag) => tag !== payload.name);
@@ -124,8 +125,9 @@ export const deleteTag = (workspace, payload) => {
     Object.values(document.webhooks ?? {}).forEach((pathItemRef) => {
         forEachPathItemOperation(pathItemRef, (_method, operationRef) => {
             const resolvedOperation = getResolvedRef(operationRef);
-            if (!resolvedOperation)
+            if (!resolvedOperation) {
                 return;
+            }
             const plainTags = unpackProxyObject(resolvedOperation.tags, { depth: 1 });
             resolvedOperation.tags = plainTags?.filter((tag) => tag !== payload.name);
         });

package/dist/navigation/get-navigation-options.js

@@ -6,11 +6,12 @@ import { DEFAULT_MODELS_SECTION_LABEL } from '@scalar/types/api-reference';
  * Extension methods retain exact case because HTTP method tokens are case-sensitive.
  * Normalizing COPY and copy would collapse distinct operations onto the same anchor.
  */
-const getMethodId = (method) => isHttpMethod(method)
-    ? method === method.toLowerCase()
-        ? method.toUpperCase()
-        : `additionalOperations/${method}`
-    : method;
+const getMethodId = (method) => {
+    if (!isHttpMethod(method)) {
+        return method;
+    }
+    return method === method.toLowerCase() ? method.toUpperCase() : `additionalOperations/${method}`;
+};
 /**
  * Returns options for traversing an OpenAPI document, allowing customization of
  * how IDs and slugs are generated for tags, headings, models, operations, and webhooks.

package/dist/navigation/helpers/traverse-asyncapi-document.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"traverse-asyncapi-document.d.ts","sourceRoot":"","sources":["../../../src/navigation/helpers/traverse-asyncapi-document.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAyB,gBAAgB,EAA2B,MAAM,4BAA4B,CAAA;AAKlH,OAAO,EAAE,KAAK,iBAAiB,EAAwB,MAAM,qCAAqC,CAAA;AAOlG,OAAO,KAAK,EAKV,iBAAiB,EAGlB,MAAM,sBAAsB,CAAA;AAM7B,oFAAoF;AACpF,KAAK,wCAAwC,GAAG,gBAAgB,GAAG;IACjE,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA;AAiiBD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,GACnC,cAAc,MAAM,EACpB,UAAU,wCAAwC,EAClD,UAAU,iBAAiB,KAC1B,iBA+HF,CAAA"}
+{"version":3,"file":"traverse-asyncapi-document.d.ts","sourceRoot":"","sources":["../../../src/navigation/helpers/traverse-asyncapi-document.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAyB,gBAAgB,EAA2B,MAAM,4BAA4B,CAAA;AAOlH,OAAO,EAAE,KAAK,iBAAiB,EAAwB,MAAM,qCAAqC,CAAA;AAOlG,OAAO,KAAK,EAKV,iBAAiB,EAGlB,MAAM,sBAAsB,CAAA;AAM7B,oFAAoF;AACpF,KAAK,wCAAwC,GAAG,gBAAgB,GAAG;IACjE,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA;AA0iBD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,GACnC,cAAc,MAAM,EACpB,UAAU,wCAAwC,EAClD,UAAU,iBAAiB,KAC1B,iBA+HF,CAAA"}

package/dist/navigation/helpers/traverse-asyncapi-document.js

@@ -1,5 +1,7 @@
 import { sortByOrder } from '@scalar/helpers/array/sort-by-order';
 import { objectKeys } from '@scalar/helpers/object/object-keys';
+import { resolveOperationWithTraits } from '../../channel-example/resolve-operation-with-traits.js';
+import { getNameFromRef } from '../../helpers/get-name-from-ref.js';
 import { getResolvedRef, mergeSiblingReferences } from '../../helpers/get-resolved-ref.js';
 import { isHidden } from '../../helpers/is-hidden.js';
 import { unpackProxyObject } from '../../helpers/unpack-proxy.js';
@@ -40,7 +42,7 @@ const getMessageTitle = (message, messageName) => pickNonEmpty(message.title, me
 /**
  * Parses a channel JSON pointer (`#/channels/<name>`) into the key used in `document.channels`.
  */
-const getChannelNameFromRef = (ref) => ref.match(/^#\/channels\/([^/]+)$/)?.[1];
+const getChannelNameFromRef = (ref) => getNameFromRef(ref, ['channels']);
 /**
  * Resolves the channel referenced by an operation.
  *
@@ -81,19 +83,16 @@ const resolveOperationMessageNames = (operation, channel, channelName) => {
     if (operation.messages.length === 0) {
         return [];
     }
-    const channelScopePrefix = `#/channels/${channelName}/messages/`;
     const names = new Set();
     for (const messageRef of operation.messages) {
         if (!('$ref' in messageRef)) {
             continue;
         }
         // Common case: a channel-scoped reference like `#/channels/<name>/messages/<id>`.
-        if (messageRef.$ref.startsWith(channelScopePrefix)) {
-            const candidate = messageRef.$ref.slice(channelScopePrefix.length);
-            if (channelMessages[candidate]) {
-                names.add(candidate);
-                continue;
-            }
+        const candidate = getNameFromRef(messageRef.$ref, ['channels', channelName, 'messages']);
+        if (candidate && channelMessages[candidate]) {
+            names.add(candidate);
+            continue;
         }
         // Fallback: a channel-level message that points to the same target.
         for (const [name, entry] of Object.entries(channelMessages)) {
@@ -137,10 +136,10 @@ const sortMessages = (entries) => {
     entries.sort((a, b) => a.title.localeCompare(b.title));
 };
 /**
- * Builds nested message entries for one operation.
+ * Builds message entries beneath a channel or operation.
  * Resolves each message ref, skips hidden messages, and sorts the result by title.
  */
-const createMessageEntries = ({ channelName, channel, operationId, messageNames, generateId, }) => {
+const createMessageEntries = ({ channelName, channel, parentId, messageNames, generateId, }) => {
     const messages = messageNames.flatMap((messageName) => {
         const messageNode = channel.messages?.[messageName];
         if (!messageNode) {
@@ -157,7 +156,7 @@ const createMessageEntries = ({ channelName, channel, operationId, messageNames,
                     type: 'asyncapi-message',
                     messageName,
                     channelName,
-                    parentId: operationId,
+                    parentId,
                 }),
                 title: getMessageTitle(message, messageName),
                 messageName,
@@ -185,7 +184,7 @@ const createOperationEntry = ({ operationName, operation, channel, channelName,
     const messageEntries = createMessageEntries({
         channelName,
         channel,
-        operationId,
+        parentId: operationId,
         messageNames: resolveOperationMessageNames(operation, channel, channelName),
         generateId,
     });
@@ -204,7 +203,7 @@ const createOperationEntry = ({ operationName, operation, channel, channelName,
  * Builds a channel navigation entry from a bucket and the operations to render under it.
  * The same channel may appear at the document root and under each of its channel-level tags.
  * Writes `x-scalar-order` on the source channel (when it is not a bare `$ref`) so other code can reuse the order.
- * Returns `undefined` when the channel is hidden or every requested operation was filtered out.
+ * Returns `undefined` when the channel is hidden or all its declared operations are hidden.
  */
 const createChannelEntry = ({ bucket, operationEntries, generateId, parentId, parentTag, operationsSorter, document, }) => {
     if (isHidden(bucket.channel)) {
@@ -229,15 +228,26 @@ const createChannelEntry = ({ bucket, operationEntries, generateId, parentId, pa
         return entry ? [entry] : [];
     });
     sortOperations(operations, operationsSorter);
-    if (operations.length === 0) {
+    // A channel with hidden operations must not expose their messages through the fallback.
+    if (operations.length === 0 && bucket.operations.length > 0) {
         return undefined;
     }
+    // Keep channel-only messages reachable without duplicating messages already owned by an operation.
+    const operationMessageNames = new Set(bucket.operations.flatMap(({ operation }) => resolveOperationMessageNames(operation, bucket.channel, bucket.channelName)));
+    const messages = createMessageEntries({
+        channelName: bucket.channelName,
+        channel: bucket.channel,
+        parentId: channelId,
+        messageNames: objectKeys(bucket.channel.messages ?? {}).filter((name) => !operationMessageNames.has(name)),
+        generateId,
+    });
+    const children = [...operations, ...messages];
     // Persist the rendered order back onto the source channel for downstream consumers.
     // We skip channels that are stored as references, since the order should live on the target.
     const channelNode = document.channels?.[bucket.channelName];
     if (channelNode && !('$ref' in channelNode)) {
         const orderedChannel = channelNode;
-        orderedChannel['x-scalar-order'] = operations.map((child) => child.id);
+        orderedChannel['x-scalar-order'] = children.map((child) => child.id);
     }
     return {
         type: 'asyncapi-channel',
@@ -245,7 +255,7 @@ const createChannelEntry = ({ bucket, operationEntries, generateId, parentId, pa
         title: getChannelTitle(bucket.channel, bucket.channelName),
         channelName: bucket.channelName,
         channelAddress: bucket.channelAddress,
-        children: operations,
+        children,
     };
 };
 /**
@@ -344,10 +354,7 @@ const collectChannelBuckets = (document) => {
         if (!operationNode) {
             continue;
         }
-        const operation = getResolvedRef(operationNode, mergeSiblingReferences);
-        if (isHidden(operation)) {
-            continue;
-        }
+        const operation = resolveOperationWithTraits(getResolvedRef(operationNode, mergeSiblingReferences));
         const resolved = resolveOperationChannel(document, operation);
         if (!resolved) {
             continue;

package/dist/navigation/helpers/traverse-paths.js

@@ -30,7 +30,7 @@ const createOperationEntry = ({ ref, operation, method, path, generateId, parent
         path: path,
         parentId: parentId,
     });
-    const title = operationTitleSource === 'path' ? path : operation.summary?.trim() ? operation.summary : path;
+    const title = operationTitleSource !== 'path' && operation.summary?.trim() ? operation.summary : path;
     const isDeprecated = isDeprecatedOperation(operation);
     const examples = traverseOperationExamples(operation).map((example) => ({
         type: 'example',

package/dist/navigation/helpers/traverse-schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"traverse-schemas.d.ts","sourceRoot":"","sources":["../../../src/navigation/helpers/traverse-schemas.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AACtE,OAAO,KAAK,EAAa,eAAe,EAAE,MAAM,sBAAsB,CAAA;AACtE,OAAO,KAAK,EAAE,eAAe,EAAgB,MAAM,wCAAwC,CAAA;AA2C3F;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAI,gDAK7B;IACD,QAAQ,EAAE,eAAe,CAAA;IACzB,wCAAwC;IACxC,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,EAAE,mBAAmB,CAAC,YAAY,CAAC,CAAA;IAC7C,UAAU,EAAE,MAAM,CAAA;CACnB,KAAG,eAAe,EAmDlB,CAAA"}
+{"version":3,"file":"traverse-schemas.d.ts","sourceRoot":"","sources":["../../../src/navigation/helpers/traverse-schemas.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AACtE,OAAO,KAAK,EAAa,eAAe,EAAE,MAAM,sBAAsB,CAAA;AACtE,OAAO,KAAK,EAAE,eAAe,EAAgB,MAAM,wCAAwC,CAAA;AA2C3F;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAI,gDAK7B;IACD,QAAQ,EAAE,eAAe,CAAA;IACzB,wCAAwC;IACxC,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,EAAE,mBAAmB,CAAC,YAAY,CAAC,CAAA;IAC7C,UAAU,EAAE,MAAM,CAAA;CACnB,KAAG,eAAe,EAmDlB,CAAA"}