@scalar/workspace-store 0.54.2 → 0.54.4

package/dist/request-example/builder/body/build-request-body.js

@@ -1,7 +1,7 @@
 // import { replaceEnvVariables } from '@scalar/helpers/regex/replace-variables'
 import { isObject } from '@scalar/helpers/object/is-object';
 import { setValueAtPath } from '@scalar/helpers/object/set-value-at-path';
-import { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref';
+import { getResolvedRef, mergeSiblingReferences } from '@scalar/workspace-store/helpers/get-resolved-ref';
 import { unpackProxyObject } from '@scalar/workspace-store/helpers/unpack-proxy';
 import { isObjectSchema } from '@scalar/workspace-store/schemas/v3.1/strict/type-guards';
 import { getExampleFromBody } from './get-request-body-example.js';
@@ -16,13 +16,15 @@ const getMultipartEncodingContentType = (requestBody, bodyContentType, fieldName
  * by `get-form-body-rows.ts` are folded back via `foldDottedRowsToObject`.
  */
 const buildDottedNestedRowPredicate = (schema) => {
-    const resolved = schema ? getResolvedRef(schema) : undefined;
+    const resolved = schema ? getResolvedRef(schema, mergeSiblingReferences) : undefined;
     if (!resolved || !isObjectSchema(resolved) || !resolved.properties) {
         return (_name, _value) => false;
     }
     const nestedTopKeys = new Set();
     for (const [key, child] of Object.entries(resolved.properties)) {
-        const childResolved = child ? getResolvedRef(child) : undefined;
+        const childResolved = child
+            ? getResolvedRef(child, mergeSiblingReferences)
+            : undefined;
         if (childResolved && isObjectSchema(childResolved) && childResolved.properties) {
             nestedTopKeys.add(key);
         }
@@ -35,6 +37,75 @@ const buildDottedNestedRowPredicate = (schema) => {
         return !!head && nestedTopKeys.has(head);
     };
 };
+/** Normalize a schema's `type` (string | string[] | absent) into a plain string array. */
+const normalizeSchemaTypes = (schema) => {
+    const type = 'type' in schema ? schema.type : undefined;
+    return Array.isArray(type) ? [...type] : type == null ? [] : [type];
+};
+/**
+ * Walk an object schema along a dotted-row path and return the resolved leaf schema,
+ * or undefined when any segment is not a declared object property.
+ */
+const resolveLeafSchema = (schema, segments) => {
+    let current = schema;
+    for (const segment of segments) {
+        if (!current || !isObjectSchema(current) || !current.properties) {
+            return undefined;
+        }
+        current = getResolvedRef(current.properties[segment], mergeSiblingReferences);
+    }
+    return current;
+};
+/** True when a JSON-parsed value's runtime type is allowed by the schema's declared types. */
+const parsedValueMatchesSchemaType = (value, types) => {
+    if (value === null) {
+        return types.includes('null');
+    }
+    if (Array.isArray(value)) {
+        return types.includes('array');
+    }
+    if (typeof value === 'object') {
+        return types.includes('object');
+    }
+    if (typeof value === 'boolean') {
+        return types.includes('boolean');
+    }
+    if (typeof value === 'number') {
+        // A fractional value only satisfies `number`; `integer` requires a whole number so a
+        // string like "3.14" against an integer-only leaf stays untouched instead of being coerced.
+        return types.includes('number') || (types.includes('integer') && Number.isInteger(value));
+    }
+    if (typeof value === 'string') {
+        return types.includes('string');
+    }
+    return false;
+};
+/**
+ * The form table stringifies every value for display, so an edited nested field comes back
+ * as a string (`false` -> "false", `[]` -> "[]"). When the leaf schema declares a non-string
+ * type, parse the string back to that type so the regrouped JSON part keeps its original
+ * shape instead of becoming string-typed (issue #9416).
+ *
+ * Coercion is deliberately conservative: schemas that allow `string` keep the raw text, and a
+ * value that does not parse as its declared type is left untouched so user input is never lost.
+ */
+const coerceLeafValueToSchemaType = (value, schema) => {
+    if (typeof value !== 'string' || !schema) {
+        return value;
+    }
+    const types = normalizeSchemaTypes(schema);
+    // No declared type, or a string is allowed: keep the user's text as-is.
+    if (types.length === 0 || types.includes('string')) {
+        return value;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return parsedValueMatchesSchemaType(parsed, types) ? parsed : value;
+    }
+    catch {
+        return value;
+    }
+};
 /**
  * Create the fetch request body
  */
@@ -81,9 +152,10 @@ requestBodyCompositionSelection) => {
         // lazily allocate the regrouped object for its top-level key and push it into
         // `entries` at the position of the *first* matching row, then keep folding leaves
         // into the same live object reference so interleaved flat rows keep their order.
-        const isDottedNestedRow = result.mode === 'formdata'
-            ? buildDottedNestedRowPredicate(requestBody.content[bodyContentType]?.schema)
-            : () => false;
+        const multipartSchema = result.mode === 'formdata'
+            ? getResolvedRef(requestBody.content[bodyContentType]?.schema, mergeSiblingReferences)
+            : undefined;
+        const isDottedNestedRow = result.mode === 'formdata' ? buildDottedNestedRowPredicate(multipartSchema) : () => false;
         const entries = [];
         const regroupedByTopKey = new Map();
         for (const row of exampleValue) {
@@ -102,7 +174,9 @@ requestBodyCompositionSelection) => {
                 regroupedByTopKey.set(topKey, target);
                 entries.push({ name: topKey, value: target });
             }
-            setValueAtPath(target, segments.slice(1), row.value);
+            // The form table stringifies leaf values; restore the schema-declared type so the
+            // regrouped JSON part keeps booleans/numbers/arrays instead of string-typing them.
+            setValueAtPath(target, segments.slice(1), coerceLeafValueToSchemaType(row.value, resolveLeafSchema(multipartSchema, segments)));
         }
         // Loop over all entries and add them to the form
         entries.forEach(({ name, value }) => {

package/dist/request-example/builder/header/de-serialize-parameter.js

@@ -29,6 +29,40 @@ const deSerializeContentExample = (example, contentType) => {
 };
 /** Schema types that must become arrays/objects — serializers branch on `Array.isArray` / objects. */
 const structuredSchemaTypes = new Set(['array', 'object']);
+/**
+ * Find the structured (`array` or `object`) type a schema represents, looking through
+ * `anyOf`/`oneOf`/`allOf` composition.
+ *
+ * Optional array/object parameters are commonly described as `anyOf: [{ type: 'array' }, { type: 'null' }]`
+ * (e.g. FastAPI/Pydantic `Optional[List[str]]`). Without unwrapping these we would treat the value as a
+ * plain string and send a single `id=a,b` query parameter instead of repeating `id=a&id=b`.
+ */
+const getStructuredType = (schema) => {
+    const resolved = getResolvedRef(schema);
+    if (!resolved || typeof resolved !== 'object') {
+        return undefined;
+    }
+    if ('type' in resolved && resolved.type) {
+        const type = Array.isArray(resolved.type)
+            ? resolved.type.find((t) => structuredSchemaTypes.has(t))
+            : resolved.type;
+        if (type === 'array' || type === 'object') {
+            return type;
+        }
+    }
+    for (const key of ['anyOf', 'oneOf', 'allOf']) {
+        const subSchemas = resolved[key];
+        if (Array.isArray(subSchemas)) {
+            for (const subSchema of subSchemas) {
+                const type = getStructuredType(subSchema);
+                if (type) {
+                    return type;
+                }
+            }
+        }
+    }
+    return undefined;
+};
 /**
  * Schema-based parameters from the request editor.
  *
@@ -36,10 +70,9 @@ const structuredSchemaTypes = new Set(['array', 'object']);
  * Only `array` and `object` values are parsed so OpenAPI style serialization can expand them.
  */
 const deSerializeSchemaExample = (example, schema) => {
-    const resolvedSchema = getResolvedRef(schema);
-    if (typeof example === 'string' && resolvedSchema && 'type' in resolvedSchema) {
-        const type = Array.isArray(resolvedSchema.type) ? resolvedSchema.type[0] : resolvedSchema.type;
-        if (type && structuredSchemaTypes.has(type)) {
+    if (typeof example === 'string') {
+        const type = getStructuredType(schema);
+        if (type) {
             try {
                 return JSON.parse(example);
             }

package/dist/request-example/builder/helpers/get-example-from-schema.d.ts

@@ -1,3 +1,4 @@
+import { type DynamicScope } from '../../../helpers/dynamic-ref.js';
 import type { SchemaObject } from '../../../schemas/v3.1/strict/openapi-document.js';
 type GetExampleFromSchemaOptions = {
     /** Fallback string for empty string values. */
@@ -28,13 +29,15 @@ type GetExampleFromSchemaOptions = {
  * @param name - The name of the property being processed.
  * @returns An example value for the given schema.
  */
-export declare const getExampleFromSchema: (schema: SchemaObject, options?: GetExampleFromSchemaOptions, { level, parentSchema, name, seen, schemaPath, }?: Partial<{
+export declare const getExampleFromSchema: (schema: SchemaObject, options?: GetExampleFromSchemaOptions, { level, parentSchema, name, seen, schemaPath, dynamicScope, }?: Partial<{
     level: number;
     parentSchema: SchemaObject;
     name: string;
     seen: WeakSet<object>;
     /** Internal traversal path used to resolve nested composition selections. */
     schemaPath: string[];
+    /** Chain of schema resources entered so far, used to resolve `$dynamicRef` (JSON Schema 2020-12). */
+    dynamicScope: DynamicScope;
 }>) => unknown;
 export {};
 //# sourceMappingURL=get-example-from-schema.d.ts.map

package/dist/request-example/builder/helpers/get-example-from-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-example-from-schema.d.ts","sourceRoot":"","sources":["../../../../src/request-example/builder/helpers/get-example-from-schema.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAA;AAypB1E,KAAK,2BAA2B,GAAG;IACjC,+CAA+C;IAC/C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4CAA4C;IAC5C,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IACvB,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACnC,qDAAqD;IACrD,8BAA8B,CAAC,EAAE,OAAO,CAAA;IACxC,0DAA0D;IAC1D,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC9C,CAAA;AAeD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,YAAY,EACpB,UAAU,2BAA2B,EACrC,mDAMG,OAAO,CAAC;IACT,KAAK,EAAE,MAAM,CAAA;IACb,YAAY,EAAE,YAAY,CAAA;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;IACrB,6EAA6E;IAC7E,UAAU,EAAE,MAAM,EAAE,CAAA;CACrB,CAAM,KACN,OAqKF,CAAA"}
+{"version":3,"file":"get-example-from-schema.d.ts","sourceRoot":"","sources":["../../../../src/request-example/builder/helpers/get-example-from-schema.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAqD,MAAM,uBAAuB,CAAA;AAG5G,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAA;AAisB1E,KAAK,2BAA2B,GAAG;IACjC,+CAA+C;IAC/C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4CAA4C;IAC5C,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IACvB,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACnC,qDAAqD;IACrD,8BAA8B,CAAC,EAAE,OAAO,CAAA;IACxC,0DAA0D;IAC1D,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC9C,CAAA;AAeD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,YAAY,EACpB,UAAU,2BAA2B,EACrC,iEAOG,OAAO,CAAC;IACT,KAAK,EAAE,MAAM,CAAA;IACb,YAAY,EAAE,YAAY,CAAA;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;IACrB,6EAA6E;IAC7E,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,qGAAqG;IACrG,YAAY,EAAE,YAAY,CAAA;CAC3B,CAAM,KACN,OAmMF,CAAA"}

package/dist/request-example/builder/helpers/get-example-from-schema.js

@@ -1,4 +1,5 @@
 import { isDefined } from '@scalar/helpers/array/is-defined';
+import { isDynamicRef, pushDynamicScope, resolveDynamicRef } from '../../../helpers/dynamic-ref.js';
 import { unpackProxyObject } from '../../../helpers/unpack-proxy.js';
 import { resolve } from '../../../resolve.js';
 /** Maximum recursion depth to prevent infinite loops in circular references */
@@ -108,9 +109,13 @@ const getRequiredNames = (parentSchema) => {
  * Cache the result for a schema if it is an object type.
  * Primitive values are not cached to avoid unnecessary WeakMap operations.
  * Stores a map of cacheKey strings which is made up of the options object.
+ *
+ * Skips the cache while a dynamic scope is active: the same shared schema node can resolve to
+ * different examples depending on the dynamic scope it was reached through, so caching it by object
+ * identity would leak one scope's result into another.
  */
-const cache = (schema, result, cacheKey) => {
-    if (typeof result !== 'object' || result === null) {
+const cache = (schema, result, cacheKey, skip = false) => {
+    if (skip || typeof result !== 'object' || result === null) {
         return result;
     }
     const rawSchema = getSchemaCacheTarget(schema);
@@ -313,8 +318,11 @@ const sortPropertyNamesByXOrder = (properties) => Object.keys(properties).sort((
  * Build an example for an object schema, including properties, patternProperties,
  * additionalProperties, and composition (allOf/oneOf/anyOf) merging.
  */
-const handleObjectSchema = (schema, options, level, seen, cacheKey, schemaPath) => {
+const handleObjectSchema = (schema, options, level, seen, cacheKey, schemaPath, dynamicScope) => {
     const response = {};
+    // Children are evaluated with this schema added to the dynamic scope so nested `$dynamicRef`s bind here.
+    const childScope = pushDynamicScope(dynamicScope, schema);
+    const skipCache = dynamicScope.length > 0;
     if ('properties' in schema && schema.properties) {
         const properties = schema.properties;
         const propertyNames = sortPropertyNamesByXOrder(properties);
@@ -332,6 +340,7 @@ const handleObjectSchema = (schema, options, level, seen, cacheKey, schemaPath)
                 name: propertyName,
                 schemaPath: [...schemaPath, propertyName],
                 seen,
+                dynamicScope: childScope,
             });
             if (typeof value !== 'undefined') {
                 response[propertyXmlName ?? propertyName] = value;
@@ -350,6 +359,7 @@ const handleObjectSchema = (schema, options, level, seen, cacheKey, schemaPath)
                 name: pattern,
                 schemaPath: [...schemaPath, pattern],
                 seen,
+                dynamicScope: childScope,
             });
         }
     }
@@ -376,6 +386,7 @@ const handleObjectSchema = (schema, options, level, seen, cacheKey, schemaPath)
                     level: level + 1,
                     schemaPath: [...schemaPath, additionalName],
                     seen,
+                    dynamicScope: childScope,
                 })
                 : 'anything';
         if (propertyNamesEnum && propertyNamesEnum.length > 0) {
@@ -396,6 +407,7 @@ const handleObjectSchema = (schema, options, level, seen, cacheKey, schemaPath)
                 level: level + 1,
                 schemaPath,
                 seen,
+                dynamicScope: childScope,
             }));
         }
     }
@@ -407,6 +419,7 @@ const handleObjectSchema = (schema, options, level, seen, cacheKey, schemaPath)
                 level: level + 1,
                 parentSchema: schema,
                 seen,
+                dynamicScope: childScope,
             });
             merged = mergeExamples(merged, ex);
         }
@@ -417,18 +430,33 @@ const handleObjectSchema = (schema, options, level, seen, cacheKey, schemaPath)
     if (options?.xml && 'xml' in schema && schema.xml?.name && level === 0) {
         const wrapped = {};
         wrapped[schema.xml.name] = response;
-        return cache(schema, wrapped, cacheKey);
+        return cache(schema, wrapped, cacheKey, skipCache);
     }
-    return cache(schema, response, cacheKey);
+    return cache(schema, response, cacheKey, skipCache);
 };
 /** Build an example for an array schema, including items, allOf, oneOf/anyOf, and XML wrapping */
-const handleArraySchema = (schema, options, level, seen, cacheKey, schemaPath) => {
-    const items = 'items' in schema ? resolve.schema(schema.items) : undefined;
+const handleArraySchema = (schema, options, level, seen, cacheKey, schemaPath, dynamicScope) => {
+    const childScope = pushDynamicScope(dynamicScope, schema);
+    const skipCache = dynamicScope.length > 0;
+    let items = 'items' in schema ? resolve.schema(schema.items) : undefined;
+    // Bind a dynamic item type (e.g. the generic `PaginatedResponse<T>` pattern) before inspecting it.
+    // Crossing a `$dynamicRef` leaves the static schema graph, so the cycle guard built up by the outer
+    // walk no longer applies to the bound type. Restart `seen` for the item recursion so recursive trees
+    // (e.g. a category whose children reference the same anchor) render their nested levels instead of
+    // tripping the shared guard. Depth stays bounded by `MAX_LEVELS_DEEP`.
+    let itemsSeen = seen;
+    if (items && isDynamicRef(items)) {
+        const resolvedDynamic = resolveDynamicRef(items.$dynamicRef, childScope);
+        if (resolvedDynamic) {
+            items = resolvedDynamic;
+            itemsSeen = new WeakSet();
+        }
+    }
     const itemsSchemaPath = [...schemaPath, 'items'];
     const itemsXmlTagName = items && typeof items === 'object' && 'xml' in items ? items.xml?.name : undefined;
     const wrapItems = !!(options?.xml && 'xml' in schema && schema.xml?.wrapped && itemsXmlTagName);
     if (schema.example !== undefined) {
-        return cache(schema, wrapItems ? { [itemsXmlTagName]: schema.example } : schema.example, cacheKey);
+        return cache(schema, wrapItems ? { [itemsXmlTagName]: schema.example } : schema.example, cacheKey, skipCache);
     }
     if (items && typeof items === 'object') {
         if (Array.isArray(items.allOf) && items.allOf.length > 0) {
@@ -440,19 +468,21 @@ const handleArraySchema = (schema, options, level, seen, cacheKey, schemaPath) =
                     level: level + 1,
                     parentSchema: schema,
                     schemaPath: itemsSchemaPath,
-                    seen,
+                    seen: itemsSeen,
+                    dynamicScope: childScope,
                 });
-                return cache(schema, wrapItems ? [{ [itemsXmlTagName]: merged }] : [merged], cacheKey);
+                return cache(schema, wrapItems ? [{ [itemsXmlTagName]: merged }] : [merged], cacheKey, skipCache);
             }
             const examples = allOf
                 .map((s) => getExampleFromSchema(resolve.schema(s), options, {
                 level: level + 1,
                 parentSchema: schema,
                 schemaPath: itemsSchemaPath,
-                seen,
+                seen: itemsSeen,
+                dynamicScope: childScope,
             }))
                 .filter(isDefined);
-            return cache(schema, wrapItems ? examples.map((e) => ({ [itemsXmlTagName]: e })) : examples, cacheKey);
+            return cache(schema, wrapItems ? examples.map((e) => ({ [itemsXmlTagName]: e })) : examples, cacheKey, skipCache);
         }
         const compositionKeyword = items.oneOf ? 'oneOf' : items.anyOf ? 'anyOf' : undefined;
         const union = compositionKeyword ? items[compositionKeyword] : undefined;
@@ -463,9 +493,10 @@ const handleArraySchema = (schema, options, level, seen, cacheKey, schemaPath) =
                 level: level + 1,
                 parentSchema: schema,
                 schemaPath: itemsSchemaPath,
-                seen,
+                seen: itemsSeen,
+                dynamicScope: childScope,
             });
-            return cache(schema, wrapItems ? [{ [itemsXmlTagName]: ex }] : [ex], cacheKey);
+            return cache(schema, wrapItems ? [{ [itemsXmlTagName]: ex }] : [ex], cacheKey, skipCache);
         }
     }
     const isObject = items && typeof items === 'object' && (('type' in items && items.type === 'object') || 'properties' in items);
@@ -474,11 +505,12 @@ const handleArraySchema = (schema, options, level, seen, cacheKey, schemaPath) =
         const ex = getExampleFromSchema(items, options, {
             level: level + 1,
             schemaPath: itemsSchemaPath,
-            seen,
+            seen: itemsSeen,
+            dynamicScope: childScope,
         });
-        return cache(schema, wrapItems ? [{ [itemsXmlTagName]: ex }] : [ex], cacheKey);
+        return cache(schema, wrapItems ? [{ [itemsXmlTagName]: ex }] : [ex], cacheKey, skipCache);
     }
-    return cache(schema, [], cacheKey);
+    return cache(schema, [], cacheKey, skipCache);
 };
 /** Return primitive example value for single-type schemas, or undefined if not primitive */
 const getPrimitiveValue = (schema, makeUpRandomData, emptyString) => {
@@ -552,12 +584,35 @@ const createOptionsCacheKey = (options) => JSON.stringify({
  * @param name - The name of the property being processed.
  * @returns An example value for the given schema.
  */
-export const getExampleFromSchema = (schema, options, { level = 0, parentSchema, name, seen = new WeakSet(), schemaPath = [], } = {}) => {
+export const getExampleFromSchema = (schema, options, { level = 0, parentSchema, name, seen = new WeakSet(), schemaPath = [], dynamicScope = [], } = {}) => {
     // Resolve any $ref references to get the actual schema
     const _schema = resolve.schema(schema);
     if (!isDefined(_schema)) {
         return undefined;
     }
+    // Resolve a `$dynamicRef` against the active dynamic scope, then continue with the bound schema.
+    // When nothing matches, fall through and render the reference as before (no regression).
+    if (isDynamicRef(_schema)) {
+        const resolvedDynamic = resolveDynamicRef(_schema.$dynamicRef, dynamicScope);
+        if (resolvedDynamic) {
+            // The `seen` set guards against cycles in the static schema graph, but a `$dynamicRef` is resolved
+            // per evaluation path and intentionally points outside that graph. Re-entering the bound type with a
+            // fresh `seen` lets recursive examples (e.g. a category tree) render their nested levels instead of
+            // bailing out on the shared cycle guard. Depth stays bounded by `MAX_LEVELS_DEEP`.
+            return getExampleFromSchema(resolvedDynamic, options, {
+                level: level + 1,
+                parentSchema,
+                name,
+                seen: new WeakSet(),
+                schemaPath,
+                dynamicScope,
+            });
+        }
+    }
+    // Grow the scope with this schema so nested references can bind to its `$dynamicAnchor`s.
+    const childScope = pushDynamicScope(dynamicScope, _schema);
+    // The same shared node can resolve differently per scope, so skip the result cache under a scope.
+    const skipCache = dynamicScope.length > 0;
     // Unpack from all proxies to get the raw schema object for cycle detection
     const targetValue = getSchemaCacheTarget(_schema);
     if (seen.has(targetValue)) {
@@ -566,11 +621,13 @@ export const getExampleFromSchema = (schema, options, { level = 0, parentSchema,
     seen.add(targetValue);
     /** Make the cache key unique per options and schema path */
     const cacheKey = createOptionsCacheKey(options) + (schemaPath.length > 0 ? `:path:${schemaPath.join('.')}` : '');
-    // Check cache first for performance - avoid recomputing the same schema
-    const cached = resultCache.get(targetValue)?.get(cacheKey);
-    if (typeof cached !== 'undefined') {
-        seen.delete(targetValue);
-        return cached;
+    // Check cache first for performance - avoid recomputing the same schema (skipped under a dynamic scope)
+    if (!skipCache) {
+        const cached = resultCache.get(targetValue)?.get(cacheKey);
+        if (typeof cached !== 'undefined') {
+            seen.delete(targetValue);
+            return cached;
+        }
     }
     // Prevent infinite recursion in circular references
     if (level > MAX_LEVELS_DEEP) {
@@ -591,45 +648,45 @@ export const getExampleFromSchema = (schema, options, { level = 0, parentSchema,
             // Type coercion for numeric types
             if ('type' in _schema && (_schema.type === 'number' || _schema.type === 'integer')) {
                 seen.delete(targetValue);
-                return cache(_schema, Number(value), cacheKey);
+                return cache(_schema, Number(value), cacheKey, skipCache);
             }
             seen.delete(targetValue);
-            return cache(_schema, value, cacheKey);
+            return cache(_schema, value, cacheKey, skipCache);
         }
     }
     // Priority order: examples > example > default > const > enum
     if (Array.isArray(_schema.examples) && _schema.examples.length > 0) {
         seen.delete(targetValue);
-        return cache(_schema, _schema.examples[0], cacheKey);
+        return cache(_schema, _schema.examples[0], cacheKey, skipCache);
     }
     if (_schema.example !== undefined) {
         seen.delete(targetValue);
-        return cache(_schema, _schema.example, cacheKey);
+        return cache(_schema, _schema.example, cacheKey, skipCache);
     }
     if (_schema.default !== undefined) {
         const normalizedDefault = normalizeSchemaDefault(_schema);
         if (normalizedDefault !== INVALID_DEFAULT) {
             seen.delete(targetValue);
-            return cache(_schema, normalizedDefault, cacheKey);
+            return cache(_schema, normalizedDefault, cacheKey, skipCache);
         }
     }
     if (_schema.const !== undefined) {
         seen.delete(targetValue);
-        return cache(_schema, _schema.const, cacheKey);
+        return cache(_schema, _schema.const, cacheKey, skipCache);
     }
     if (Array.isArray(_schema.enum) && _schema.enum.length > 0) {
         seen.delete(targetValue);
-        return cache(_schema, _schema.enum[0], cacheKey);
+        return cache(_schema, _schema.enum[0], cacheKey, skipCache);
     }
     // Handle object types - check for properties to identify objects
     if ('properties' in _schema || ('type' in _schema && _schema.type === 'object')) {
-        const result = handleObjectSchema(_schema, options, level, seen, cacheKey, schemaPath);
+        const result = handleObjectSchema(_schema, options, level, seen, cacheKey, schemaPath, dynamicScope);
         seen.delete(targetValue);
         return result;
     }
     // Handle array types
     if (('type' in _schema && _schema.type === 'array') || 'items' in _schema) {
-        const result = handleArraySchema(_schema, options, level, seen, cacheKey, schemaPath);
+        const result = handleArraySchema(_schema, options, level, seen, cacheKey, schemaPath, dynamicScope);
         seen.delete(targetValue);
         return result;
     }
@@ -637,7 +694,7 @@ export const getExampleFromSchema = (schema, options, { level = 0, parentSchema,
     const primitive = getPrimitiveValue(_schema, makeUpRandomData, options?.emptyString);
     if (primitive !== undefined) {
         seen.delete(targetValue);
-        return cache(_schema, primitive, cacheKey);
+        return cache(_schema, primitive, cacheKey, skipCache);
     }
     // Handle composition schemas (oneOf, anyOf)
     const compositionKeyword = _schema.oneOf ? 'oneOf' : _schema.anyOf ? 'anyOf' : undefined;
@@ -658,11 +715,12 @@ export const getExampleFromSchema = (schema, options, { level = 0, parentSchema,
                     level: level + 1,
                     schemaPath,
                     seen,
-                }), cacheKey);
+                    dynamicScope: childScope,
+                }), cacheKey, skipCache);
             }
         }
         seen.delete(targetValue);
-        return cache(_schema, null, cacheKey);
+        return cache(_schema, null, cacheKey, skipCache);
     }
     // Handle allOf at root level (non-object/array schemas)
     if (Array.isArray(_schema.allOf) && _schema.allOf.length > 0) {
@@ -674,6 +732,7 @@ export const getExampleFromSchema = (schema, options, { level = 0, parentSchema,
                 parentSchema: _schema,
                 schemaPath,
                 seen,
+                dynamicScope: childScope,
             });
             if (merged === undefined) {
                 merged = ex;
@@ -687,15 +746,15 @@ export const getExampleFromSchema = (schema, options, { level = 0, parentSchema,
             }
         }
         seen.delete(targetValue);
-        return cache(_schema, merged ?? null, cacheKey);
+        return cache(_schema, merged ?? null, cacheKey, skipCache);
     }
     // Handle union types (array of types)
     const unionPrimitive = getUnionPrimitiveValue(_schema, makeUpRandomData, options?.emptyString);
     if (unionPrimitive !== undefined) {
         seen.delete(targetValue);
-        return cache(_schema, unionPrimitive, cacheKey);
+        return cache(_schema, unionPrimitive, cacheKey, skipCache);
     }
     // Default fallback
     seen.delete(targetValue);
-    return cache(_schema, null, cacheKey);
+    return cache(_schema, null, cacheKey, skipCache);
 };

package/dist/request-example/builder/security/build-request-security.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-request-security.d.ts","sourceRoot":"","sources":["../../../../src/request-example/builder/security/build-request-security.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,iDAAiD,CAAA;AAEjG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC,8DAA8D;IAC9D,EAAE,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAA;IACjC,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAA;IACZ,2EAA2E;IAC3E,MAAM,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAA;IAC3B;;OAEG;IACH,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB;AAC/B,4DAA4D;AAC5D,yBAAyB,0BAA0B,EAAE;AACrD,qEAAqE;AACrE,8BAA0B,KACzB,0BAA0B,EAuF5B,CAAA"}
+{"version":3,"file":"build-request-security.d.ts","sourceRoot":"","sources":["../../../../src/request-example/builder/security/build-request-security.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,iDAAiD,CAAA;AAEjG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC,8DAA8D;IAC9D,EAAE,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAA;IACjC,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAA;IACZ,2EAA2E;IAC3E,MAAM,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAA;IAC3B;;OAEG;IACH,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB;AAC/B,4DAA4D;AAC5D,yBAAyB,0BAA0B,EAAE;AACrD,qEAAqE;AACrE,8BAA0B,KACzB,0BAA0B,EA6F5B,CAAA"}

package/dist/request-example/builder/security/build-request-security.js

@@ -39,14 +39,19 @@ emptyTokenPlaceholder = '') => {
         // HTTP
         if (scheme.type === 'http') {
             if (scheme.scheme === 'basic') {
-                const username = scheme['x-scalar-secret-username'];
-                const password = scheme['x-scalar-secret-password'];
-                const value = `${username}:${password}`;
+                const username = scheme['x-scalar-secret-username'] || '';
+                const password = scheme['x-scalar-secret-password'] || '';
+                // When the user has cleared both fields we must not send any credentials.
+                // Falling back to placeholder values here would emit `Basic username:password`,
+                // which some servers accept as a valid (but bogus) credential instead of returning 401.
+                if (username === '' && password === '') {
+                    return null;
+                }
                 return result.push({
                     in: 'header',
                     name: 'Authorization',
                     // We encode the value when we build the request since we want to be able to replace the variables in the value
-                    value: value === ':' ? 'username:password' : value,
+                    value: `${username}:${password}`,
                     format: 'basic',
                 });
             }

package/dist/request-example/context/get-request-example-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-request-example-context.d.ts","sourceRoot":"","sources":["../../../src/request-example/context/get-request-example-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAA;AAE9E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAEpD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,iDAAiD,CAAA;AAIjG,OAAO,EAAE,KAAK,MAAM,EAAqB,MAAM,iCAAiC,CAAA;AAIhF,OAAO,EAAE,KAAK,qBAAqB,EAAiB,MAAM,mDAAmD,CAAA;AAE7G,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qDAAqD,CAAA;AAC7F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+CAA+C,CAAA;AAElF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AACtE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAA;AAC3F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAE5D,MAAM,MAAM,0BAA0B,GAAG;IACvC,SAAS,EAAE,eAAe,CAAA;IAC1B,WAAW,EAAE;QACX,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;QACnB,WAAW,EAAE,kBAAkB,CAAA;KAChC,CAAA;IACD,OAAO,EAAE;QACP,SAAS,EAAE,aAAa,EAAE,CAAA;QAC1B,QAAQ,EAAE,aAAa,EAAE,CAAA;KAC1B,CAAA;IACD,OAAO,EAAE;QACP,IAAI,EAAE,YAAY,EAAE,CAAA;QACpB,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAA;QAC7B,IAAI,EAAE,UAAU,CAAA;KACjB,CAAA;IACD,KAAK,EAAE;QACL,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;KACnB,CAAA;IACD,OAAO,EAAE;QACP,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAChC,CAAA;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,qBAAqB,CAAA;QAC9B,YAAY,EAAE,yBAAyB,EAAE,CAAA;QACzC,QAAQ,EAAE,gBAAgB,CAAA;QAC1B,eAAe,EAAE,0BAA0B,EAAE,CAAA;QAC7C,IAAI,EAAE,QAAQ,CAAA;KACf,CAAA;CACF,CAAA;AAED,eAAO,MAAM,wBAAwB,GACnC,gBAAgB,cAAc,EAC9B,cAAc,MAAM,EACpB,oBAAoB,kBAAkB,EACtC,UAAS,OAAO,CAAC;IACf,OAAO,EAAE,YAAY,EAAE,CAAA;IACvB,aAAa,EAAE,MAAM,CAAA;IACrB,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,+CAA+C;IAC/C,cAAc,EAAE,2BAA2B,CAAA;IAC3C;;;;OAIG;IACH,gBAAgB,EAAE,iBAAiB,GAAG,IAAI,CAAA;CAC3C,CAAM,KACN,MAAM,CAAC,0BAA0B,CA6InC,CAAA"}
+{"version":3,"file":"get-request-example-context.d.ts","sourceRoot":"","sources":["../../../src/request-example/context/get-request-example-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAA;AAE9E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAGpD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,iDAAiD,CAAA;AAIjG,OAAO,EAAE,KAAK,MAAM,EAAqB,MAAM,iCAAiC,CAAA;AAIhF,OAAO,EAAE,KAAK,qBAAqB,EAAiB,MAAM,mDAAmD,CAAA;AAE7G,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qDAAqD,CAAA;AAC7F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+CAA+C,CAAA;AAElF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AACtE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAA;AAC3F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAE5D,MAAM,MAAM,0BAA0B,GAAG;IACvC,SAAS,EAAE,eAAe,CAAA;IAC1B,WAAW,EAAE;QACX,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;QACnB,WAAW,EAAE,kBAAkB,CAAA;KAChC,CAAA;IACD,OAAO,EAAE;QACP,SAAS,EAAE,aAAa,EAAE,CAAA;QAC1B,QAAQ,EAAE,aAAa,EAAE,CAAA;KAC1B,CAAA;IACD,OAAO,EAAE;QACP,IAAI,EAAE,YAAY,EAAE,CAAA;QACpB,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAA;QAC7B,IAAI,EAAE,UAAU,CAAA;KACjB,CAAA;IACD,KAAK,EAAE;QACL,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;KACnB,CAAA;IACD,OAAO,EAAE;QACP,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAChC,CAAA;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,qBAAqB,CAAA;QAC9B,YAAY,EAAE,yBAAyB,EAAE,CAAA;QACzC,QAAQ,EAAE,gBAAgB,CAAA;QAC1B,eAAe,EAAE,0BAA0B,EAAE,CAAA;QAC7C,IAAI,EAAE,QAAQ,CAAA;KACf,CAAA;CACF,CAAA;AAED,eAAO,MAAM,wBAAwB,GACnC,gBAAgB,cAAc,EAC9B,cAAc,MAAM,EACpB,oBAAoB,kBAAkB,EACtC,UAAS,OAAO,CAAC;IACf,OAAO,EAAE,YAAY,EAAE,CAAA;IACvB,aAAa,EAAE,MAAM,CAAA;IACrB,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,+CAA+C;IAC/C,cAAc,EAAE,2BAA2B,CAAA;IAC3C;;;;OAIG;IACH,gBAAgB,EAAE,iBAAiB,GAAG,IAAI,CAAA;CAC3C,CAAM,KACN,MAAM,CAAC,0BAA0B,CA6InC,CAAA"}

package/dist/request-example/context/get-request-example-context.js

@@ -1,3 +1,4 @@
+import { getPathItemOperation, getResolvedPathItem } from '../../helpers/for-each-path-item-operation.js';
 import { getResolvedRef } from '../../helpers/get-resolved-ref.js';
 import { getActiveEnvironment } from '../../request-example/context/environment.js';
 import { getDefaultHeaders } from '../../request-example/context/headers.js';
@@ -24,14 +25,14 @@ export const getRequestExampleContext = (workspaceStore, documentName, requestEx
             error: `Document ${documentName} is not an OpenAPI document`,
         };
     }
-    const pathItem = getResolvedRef(document.paths?.[path]);
+    const pathItem = getResolvedPathItem(document.paths?.[path]);
     if (!pathItem) {
         return {
             ok: false,
             error: `Path ${path} not found`,
         };
     }
-    const resolvedOperation = getResolvedRef(pathItem[method]);
+    const resolvedOperation = getResolvedRef(getPathItemOperation(document.paths?.[path], method));
     if (!resolvedOperation) {
         return {
             ok: false,