@scalar/json-magic 0.8.0 → 0.8.2

package/.turbo/turbo-build.log

@@ -1,10 +1,10 @@
 
-> @scalar/json-magic@0.8.0 build /home/runner/work/scalar/scalar/packages/json-magic
+> @scalar/json-magic@0.8.2 build /home/runner/work/scalar/scalar/packages/json-magic
 > scalar-build-esbuild
 
-@scalar/json-magic: Build completed in 31.84ms
+@scalar/json-magic: Build completed in 42.51ms
 
-> @scalar/json-magic@0.8.0 types:build /home/runner/work/scalar/scalar/packages/json-magic
+> @scalar/json-magic@0.8.2 types:build /home/runner/work/scalar/scalar/packages/json-magic
 > scalar-types-build
 
-Types build completed in 1.68s
+Types build completed in 2.81s

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @scalar/json-magic
 
+## 0.8.2
+
+### Patch Changes
+
+- [#7392](https://github.com/scalar/scalar/pull/7392) [`d86f1d6`](https://github.com/scalar/scalar/commit/d86f1d6911ecbca70b011a2a0efb6d6e0eca59bb) Thanks [@amritk](https://github.com/amritk)! - fix: move away from wasm hashing algo
+
+- Updated dependencies [[`d86f1d6`](https://github.com/scalar/scalar/commit/d86f1d6911ecbca70b011a2a0efb6d6e0eca59bb), [`cded2d6`](https://github.com/scalar/scalar/commit/cded2d6c087418c3c44731d344d0827a87b78b74)]:
+  - @scalar/helpers@0.1.2
+
+## 0.8.1
+
+### Patch Changes
+
+- Updated dependencies [[`9c9dbba`](https://github.com/scalar/scalar/commit/9c9dbbaa940667303f0ace59469fd78c2a741937), [`4bec1ba`](https://github.com/scalar/scalar/commit/4bec1ba332e919c4ee32dcfbfb07bd8ee42c4d74)]:
+  - @scalar/helpers@0.1.1
+
 ## 0.8.0
 
 ### Minor Changes

package/dist/bundle/value-generator.d.ts

@@ -11,9 +11,9 @@
  * @returns A Promise that resolves to a 7-character hexadecimal hash with at least one letter
  * @example
  * // Returns "2ae91d7"
- * await getHash("https://example.com/schema.json")
+ * getHash("https://example.com/schema.json")
  */
-export declare function getHash(value: string): Promise<string>;
+export declare function getHash(value: string): string;
 /**
  * Generates a unique compressed value for a string, handling collisions by recursively compressing
  * until a unique value is found. This is used to create unique identifiers for external

package/dist/bundle/value-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"value-generator.d.ts","sourceRoot":"","sources":["../../src/bundle/value-generator.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAO5D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,EACrD,KAAK,EAAE,MAAM,EACb,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACzC,mBAAmB,CAAC,EAAE,MAAM,EAC5B,KAAK,SAAI,mBAoBV;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,2BAA2B,GACtC,UAAU,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,EACrD,mBAAmB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMvC;;;;;;;;;;;;OAYG;sBACqB,MAAM;CAqBjC,CAAA"}
+{"version":3,"file":"value-generator.d.ts","sourceRoot":"","sources":["../../src/bundle/value-generator.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAO7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,EACrD,KAAK,EAAE,MAAM,EACb,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACzC,mBAAmB,CAAC,EAAE,MAAM,EAC5B,KAAK,SAAI,mBAoBV;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,2BAA2B,GACtC,UAAU,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,EACrD,mBAAmB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMvC;;;;;;;;;;;;OAYG;sBACqB,MAAM;CAqBjC,CAAA"}

package/dist/bundle/value-generator.js

@@ -1,6 +1,6 @@
-import { generateHash } from "../helpers/generate-hash.js";
-async function getHash(value) {
-  const hashHex = await generateHash(value);
+import { generateHash } from "@scalar/helpers/string/generate-hash";
+function getHash(value) {
+  const hashHex = generateHash(value);
   const hash = hashHex.substring(0, 7);
   return hash.match(/^\d+$/) ? "a" + hash.substring(1) : hash;
 }

package/dist/bundle/value-generator.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/bundle/value-generator.ts"],
-  "sourcesContent": ["import { generateHash } from '@/helpers/generate-hash'\n\n/**\n * Generates a short hash from a string value using xxhash.\n *\n * This function is used to create unique identifiers for external references\n * while keeping the hash length manageable. It uses xxhash-wasm instead of\n * crypto.subtle because crypto.subtle is only available in secure contexts (HTTPS) or on localhost.\n * Returns the first 7 characters of the hash string.\n * If the hash would be all numbers, it ensures at least one letter is included.\n *\n * @param value - The string to hash\n * @returns A Promise that resolves to a 7-character hexadecimal hash with at least one letter\n * @example\n * // Returns \"2ae91d7\"\n * await getHash(\"https://example.com/schema.json\")\n */\nexport async function getHash(value: string): Promise<string> {\n  // Hash the data using xxhash\n  const hashHex = await generateHash(value)\n\n  // Return first 7 characters of the hash, ensuring at least one letter\n  const hash = hashHex.substring(0, 7)\n  return hash.match(/^\\d+$/) ? 'a' + hash.substring(1) : hash\n}\n\n/**\n * Generates a unique compressed value for a string, handling collisions by recursively compressing\n * until a unique value is found. This is used to create unique identifiers for external\n * references in the bundled OpenAPI document.\n *\n * @param compress - Function that generates a compressed value from a string\n * @param value - The original string value to compress\n * @param compressedToValue - Object mapping compressed values to their original values\n * @param prevCompressedValue - Optional previous compressed value to use as input for generating a new value\n * @param depth - Current recursion depth to prevent infinite loops\n * @returns A unique compressed value that doesn't conflict with existing values\n *\n * @example\n * const valueMap = {}\n * // First call generates compressed value for \"example.com/schema.json\"\n * const value1 = await generateUniqueValue(compress, \"example.com/schema.json\", valueMap)\n * // Returns something like \"2ae91d7\"\n *\n * // Second call with same value returns same compressed value\n * const value2 = await generateUniqueValue(compress, \"example.com/schema.json\", valueMap)\n * // Returns same value as value1\n *\n * // Call with different value generates new unique compressed value\n * const value3 = await generateUniqueValue(compress, \"example.com/other.json\", valueMap)\n * // Returns different value like \"3bf82e9\"\n */\nexport async function generateUniqueValue(\n  compress: (value: string) => Promise<string> | string,\n  value: string,\n  compressedToValue: Record<string, string>,\n  prevCompressedValue?: string,\n  depth = 0,\n) {\n  // Prevent infinite recursion by limiting depth\n  const MAX_DEPTH = 100\n\n  if (depth >= MAX_DEPTH) {\n    throw 'Can not generate unique compressed values'\n  }\n\n  // Compress the value, using previous compressed value if provided\n  const compressedValue = await compress(prevCompressedValue ?? value)\n\n  // Handle collision by recursively trying with compressed value as input\n  if (compressedToValue[compressedValue] !== undefined && compressedToValue[compressedValue] !== value) {\n    return generateUniqueValue(compress, value, compressedToValue, compressedValue, depth + 1)\n  }\n\n  // Store mapping and return unique compressed value\n  compressedToValue[compressedValue] = value\n  return compressedValue\n}\n\n/**\n * Factory function that creates a value generator with caching capabilities.\n * The generator maintains a bidirectional mapping between original values and their compressed forms.\n *\n * @param compress - Function that generates a compressed value from a string\n * @param compressedToValue - Initial mapping of compressed values to their original values\n * @returns An object with a generate method that produces unique compressed values\n *\n * @example\n * const compress = (value) => value.substring(0, 6) // Simple compression example\n * const initialMap = { 'abc123': 'example.com/schema.json' }\n * const generator = uniqueValueGeneratorFactory(compress, initialMap)\n *\n * // Generate compressed value for new string\n * const compressed = await generator.generate('example.com/other.json')\n * // Returns something like 'example'\n *\n * // Generate compressed value for existing string\n * const cached = await generator.generate('example.com/schema.json')\n * // Returns 'abc123' from cache\n */\nexport const uniqueValueGeneratorFactory = (\n  compress: (value: string) => Promise<string> | string,\n  compressedToValue: Record<string, string>,\n) => {\n  // Create a reverse mapping from original values to their compressed forms\n  const valueToCompressed = Object.fromEntries(Object.entries(compressedToValue).map(([key, value]) => [value, key]))\n\n  return {\n    /**\n     * Generates a unique compressed value for the given input string.\n     * First checks if a compressed value already exists in the cache.\n     * If not, generates a new unique compressed value and stores it in the cache.\n     *\n     * @param value - The original string value to compress\n     * @returns A Promise that resolves to the compressed string value\n     *\n     * @example\n     * const generator = uniqueValueGeneratorFactory(compress, {})\n     * const compressed = await generator.generate('example.com/schema.json')\n     * // Returns a unique compressed value like 'example'\n     */\n    generate: async (value: string) => {\n      // Check if we already have a compressed value for this input\n      const cache = valueToCompressed[value]\n      if (cache) {\n        return cache\n      }\n\n      // Generate a new unique compressed value\n      const generatedValue = await generateUniqueValue(compress, value, compressedToValue)\n\n      // Ensure the generated string contains at least one non-numeric character\n      // This prevents the `setValueAtPath` function from interpreting the value as an array index\n      // by forcing it to be treated as an object property name\n      const compressedValue = generatedValue.match(/^\\d+$/) ? `a${generatedValue}` : generatedValue\n\n      // Store the new mapping in our cache\n      valueToCompressed[value] = compressedValue\n\n      return compressedValue\n    },\n  }\n}\n"],
-  "mappings": "AAAA,SAAS,oBAAoB;AAiB7B,eAAsB,QAAQ,OAAgC;AAE5D,QAAM,UAAU,MAAM,aAAa,KAAK;AAGxC,QAAM,OAAO,QAAQ,UAAU,GAAG,CAAC;AACnC,SAAO,KAAK,MAAM,OAAO,IAAI,MAAM,KAAK,UAAU,CAAC,IAAI;AACzD;AA4BA,eAAsB,oBACpB,UACA,OACA,mBACA,qBACA,QAAQ,GACR;AAEA,QAAM,YAAY;AAElB,MAAI,SAAS,WAAW;AACtB,UAAM;AAAA,EACR;AAGA,QAAM,kBAAkB,MAAM,SAAS,uBAAuB,KAAK;AAGnE,MAAI,kBAAkB,eAAe,MAAM,UAAa,kBAAkB,eAAe,MAAM,OAAO;AACpG,WAAO,oBAAoB,UAAU,OAAO,mBAAmB,iBAAiB,QAAQ,CAAC;AAAA,EAC3F;AAGA,oBAAkB,eAAe,IAAI;AACrC,SAAO;AACT;AAuBO,MAAM,8BAA8B,CACzC,UACA,sBACG;AAEH,QAAM,oBAAoB,OAAO,YAAY,OAAO,QAAQ,iBAAiB,EAAE,IAAI,CAAC,CAAC,KAAK,KAAK,MAAM,CAAC,OAAO,GAAG,CAAC,CAAC;AAElH,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAcL,UAAU,OAAO,UAAkB;AAEjC,YAAM,QAAQ,kBAAkB,KAAK;AACrC,UAAI,OAAO;AACT,eAAO;AAAA,MACT;AAGA,YAAM,iBAAiB,MAAM,oBAAoB,UAAU,OAAO,iBAAiB;AAKnF,YAAM,kBAAkB,eAAe,MAAM,OAAO,IAAI,IAAI,cAAc,KAAK;AAG/E,wBAAkB,KAAK,IAAI;AAE3B,aAAO;AAAA,IACT;AAAA,EACF;AACF;",
+  "sourcesContent": ["import { generateHash } from '@scalar/helpers/string/generate-hash'\n\n/**\n * Generates a short hash from a string value using xxhash.\n *\n * This function is used to create unique identifiers for external references\n * while keeping the hash length manageable. It uses xxhash-wasm instead of\n * crypto.subtle because crypto.subtle is only available in secure contexts (HTTPS) or on localhost.\n * Returns the first 7 characters of the hash string.\n * If the hash would be all numbers, it ensures at least one letter is included.\n *\n * @param value - The string to hash\n * @returns A Promise that resolves to a 7-character hexadecimal hash with at least one letter\n * @example\n * // Returns \"2ae91d7\"\n * getHash(\"https://example.com/schema.json\")\n */\nexport function getHash(value: string): string {\n  // Hash the data using xxhash\n  const hashHex = generateHash(value)\n\n  // Return first 7 characters of the hash, ensuring at least one letter\n  const hash = hashHex.substring(0, 7)\n  return hash.match(/^\\d+$/) ? 'a' + hash.substring(1) : hash\n}\n\n/**\n * Generates a unique compressed value for a string, handling collisions by recursively compressing\n * until a unique value is found. This is used to create unique identifiers for external\n * references in the bundled OpenAPI document.\n *\n * @param compress - Function that generates a compressed value from a string\n * @param value - The original string value to compress\n * @param compressedToValue - Object mapping compressed values to their original values\n * @param prevCompressedValue - Optional previous compressed value to use as input for generating a new value\n * @param depth - Current recursion depth to prevent infinite loops\n * @returns A unique compressed value that doesn't conflict with existing values\n *\n * @example\n * const valueMap = {}\n * // First call generates compressed value for \"example.com/schema.json\"\n * const value1 = await generateUniqueValue(compress, \"example.com/schema.json\", valueMap)\n * // Returns something like \"2ae91d7\"\n *\n * // Second call with same value returns same compressed value\n * const value2 = await generateUniqueValue(compress, \"example.com/schema.json\", valueMap)\n * // Returns same value as value1\n *\n * // Call with different value generates new unique compressed value\n * const value3 = await generateUniqueValue(compress, \"example.com/other.json\", valueMap)\n * // Returns different value like \"3bf82e9\"\n */\nexport async function generateUniqueValue(\n  compress: (value: string) => Promise<string> | string,\n  value: string,\n  compressedToValue: Record<string, string>,\n  prevCompressedValue?: string,\n  depth = 0,\n) {\n  // Prevent infinite recursion by limiting depth\n  const MAX_DEPTH = 100\n\n  if (depth >= MAX_DEPTH) {\n    throw 'Can not generate unique compressed values'\n  }\n\n  // Compress the value, using previous compressed value if provided\n  const compressedValue = await compress(prevCompressedValue ?? value)\n\n  // Handle collision by recursively trying with compressed value as input\n  if (compressedToValue[compressedValue] !== undefined && compressedToValue[compressedValue] !== value) {\n    return generateUniqueValue(compress, value, compressedToValue, compressedValue, depth + 1)\n  }\n\n  // Store mapping and return unique compressed value\n  compressedToValue[compressedValue] = value\n  return compressedValue\n}\n\n/**\n * Factory function that creates a value generator with caching capabilities.\n * The generator maintains a bidirectional mapping between original values and their compressed forms.\n *\n * @param compress - Function that generates a compressed value from a string\n * @param compressedToValue - Initial mapping of compressed values to their original values\n * @returns An object with a generate method that produces unique compressed values\n *\n * @example\n * const compress = (value) => value.substring(0, 6) // Simple compression example\n * const initialMap = { 'abc123': 'example.com/schema.json' }\n * const generator = uniqueValueGeneratorFactory(compress, initialMap)\n *\n * // Generate compressed value for new string\n * const compressed = await generator.generate('example.com/other.json')\n * // Returns something like 'example'\n *\n * // Generate compressed value for existing string\n * const cached = await generator.generate('example.com/schema.json')\n * // Returns 'abc123' from cache\n */\nexport const uniqueValueGeneratorFactory = (\n  compress: (value: string) => Promise<string> | string,\n  compressedToValue: Record<string, string>,\n) => {\n  // Create a reverse mapping from original values to their compressed forms\n  const valueToCompressed = Object.fromEntries(Object.entries(compressedToValue).map(([key, value]) => [value, key]))\n\n  return {\n    /**\n     * Generates a unique compressed value for the given input string.\n     * First checks if a compressed value already exists in the cache.\n     * If not, generates a new unique compressed value and stores it in the cache.\n     *\n     * @param value - The original string value to compress\n     * @returns A Promise that resolves to the compressed string value\n     *\n     * @example\n     * const generator = uniqueValueGeneratorFactory(compress, {})\n     * const compressed = await generator.generate('example.com/schema.json')\n     * // Returns a unique compressed value like 'example'\n     */\n    generate: async (value: string) => {\n      // Check if we already have a compressed value for this input\n      const cache = valueToCompressed[value]\n      if (cache) {\n        return cache\n      }\n\n      // Generate a new unique compressed value\n      const generatedValue = await generateUniqueValue(compress, value, compressedToValue)\n\n      // Ensure the generated string contains at least one non-numeric character\n      // This prevents the `setValueAtPath` function from interpreting the value as an array index\n      // by forcing it to be treated as an object property name\n      const compressedValue = generatedValue.match(/^\\d+$/) ? `a${generatedValue}` : generatedValue\n\n      // Store the new mapping in our cache\n      valueToCompressed[value] = compressedValue\n\n      return compressedValue\n    },\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB;AAiBtB,SAAS,QAAQ,OAAuB;AAE7C,QAAM,UAAU,aAAa,KAAK;AAGlC,QAAM,OAAO,QAAQ,UAAU,GAAG,CAAC;AACnC,SAAO,KAAK,MAAM,OAAO,IAAI,MAAM,KAAK,UAAU,CAAC,IAAI;AACzD;AA4BA,eAAsB,oBACpB,UACA,OACA,mBACA,qBACA,QAAQ,GACR;AAEA,QAAM,YAAY;AAElB,MAAI,SAAS,WAAW;AACtB,UAAM;AAAA,EACR;AAGA,QAAM,kBAAkB,MAAM,SAAS,uBAAuB,KAAK;AAGnE,MAAI,kBAAkB,eAAe,MAAM,UAAa,kBAAkB,eAAe,MAAM,OAAO;AACpG,WAAO,oBAAoB,UAAU,OAAO,mBAAmB,iBAAiB,QAAQ,CAAC;AAAA,EAC3F;AAGA,oBAAkB,eAAe,IAAI;AACrC,SAAO;AACT;AAuBO,MAAM,8BAA8B,CACzC,UACA,sBACG;AAEH,QAAM,oBAAoB,OAAO,YAAY,OAAO,QAAQ,iBAAiB,EAAE,IAAI,CAAC,CAAC,KAAK,KAAK,MAAM,CAAC,OAAO,GAAG,CAAC,CAAC;AAElH,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAcL,UAAU,OAAO,UAAkB;AAEjC,YAAM,QAAQ,kBAAkB,KAAK;AACrC,UAAI,OAAO;AACT,eAAO;AAAA,MACT;AAGA,YAAM,iBAAiB,MAAM,oBAAoB,UAAU,OAAO,iBAAiB;AAKnF,YAAM,kBAAkB,eAAe,MAAM,OAAO,IAAI,IAAI,cAAc,KAAK;AAG/E,wBAAkB,KAAK,IAAI;AAE3B,aAAO;AAAA,IACT;AAAA,EACF;AACF;",
   "names": []
 }

package/package.json

@@ -10,7 +10,7 @@
     "url": "git+https://github.com/scalar/scalar.git",
     "directory": "packages/json-magic"
   },
-  "version": "0.8.0",
+  "version": "0.8.2",
   "engines": {
     "node": ">=20"
   },
@@ -58,14 +58,13 @@
     }
   },
   "dependencies": {
-    "xxhash-wasm": "^1.1.0",
     "yaml": "2.8.0",
-    "@scalar/helpers": "0.1.0"
+    "@scalar/helpers": "0.1.2"
   },
   "devDependencies": {
     "fastify": "^5.3.3",
     "vite": "7.1.11",
-    "@scalar/build-tooling": "0.2.8"
+    "@scalar/build-tooling": "0.3.0"
   },
   "scripts": {
     "build": "scalar-build-esbuild",

package/src/bundle/bundle.test.ts

@@ -1,6 +1,5 @@
 import { randomUUID } from 'node:crypto'
 import fs from 'node:fs/promises'
-import { setTimeout } from 'node:timers/promises'
 
 import { consoleWarnSpy, resetConsoleSpies } from '@scalar/helpers/testing/console-spies'
 import fastify, { type FastifyInstance } from 'fastify'
@@ -35,7 +34,6 @@ describe('bundle', () => {
 
       return async () => {
         await server.close()
-        await setTimeout(100)
       }
     })
 
@@ -69,7 +67,7 @@ describe('bundle', () => {
 
       expect(input).toEqual({
         'x-ext': {
-          [await getHash(url)]: {
+          [getHash(url)]: {
             ...external,
           },
         },
@@ -79,7 +77,7 @@ describe('bundle', () => {
           },
         },
         d: {
-          $ref: `#/x-ext/${await getHash(url)}/prop`,
+          $ref: `#/x-ext/${getHash(url)}/prop`,
         },
       })
     })
@@ -126,13 +124,13 @@ describe('bundle', () => {
 
       expect(input).toEqual({
         'x-ext': {
-          [await getHash(`${url}/chunk1`)]: {
+          [getHash(`${url}/chunk1`)]: {
             ...chunk1,
             b: {
-              $ref: `#/x-ext/${await getHash(`${url}/chunk2`)}`,
+              $ref: `#/x-ext/${getHash(`${url}/chunk2`)}`,
             },
           },
-          [await getHash(`${url}/chunk2`)]: {
+          [getHash(`${url}/chunk2`)]: {
             ...chunk2,
             internal: '#/nested/key',
           },
@@ -140,7 +138,7 @@ describe('bundle', () => {
         a: {
           b: {
             c: {
-              $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}`,
+              $ref: `#/x-ext/${getHash(`${url}/chunk1`)}`,
             },
           },
         },
@@ -170,13 +168,13 @@ describe('bundle', () => {
 
       expect(input).toEqual({
         'x-ext': {
-          [await getHash(url)]: {
+          [getHash(url)]: {
             a: 'a',
           },
         },
         a: {
           b: {
-            $ref: `#/x-ext/${await getHash(url)}`,
+            $ref: `#/x-ext/${getHash(url)}`,
           },
         },
       })
@@ -209,16 +207,16 @@ describe('bundle', () => {
 
       expect(input).toEqual({
         'x-ext': {
-          [await getHash(url)]: {
+          [getHash(url)]: {
             a: 'a',
             b: 'b',
           },
         },
         a: {
-          $ref: `#/x-ext/${await getHash(url)}/a`,
+          $ref: `#/x-ext/${getHash(url)}/a`,
         },
         b: {
-          $ref: `#/x-ext/${await getHash(url)}/b`,
+          $ref: `#/x-ext/${getHash(url)}/b`,
         },
       })
 
@@ -255,17 +253,17 @@ describe('bundle', () => {
 
       expect(input).toEqual({
         'x-ext': {
-          [await getHash(`${url}/nested/another-file.json`)]: {
+          [getHash(`${url}/nested/another-file.json`)]: {
             c: 'c',
           },
-          [await getHash(`${url}/nested/chunk1.json`)]: {
+          [getHash(`${url}/nested/chunk1.json`)]: {
             b: {
-              $ref: `#/x-ext/${await getHash(`${url}/nested/another-file.json`)}`,
+              $ref: `#/x-ext/${getHash(`${url}/nested/another-file.json`)}`,
             },
           },
         },
         a: {
-          $ref: `#/x-ext/${await getHash(`${url}/nested/chunk1.json`)}`,
+          $ref: `#/x-ext/${getHash(`${url}/nested/chunk1.json`)}`,
         },
       })
     })
@@ -299,17 +297,17 @@ describe('bundle', () => {
 
       expect(input).toEqual({
         'x-ext': {
-          [await getHash(`${url}/top-level`)]: {
+          [getHash(`${url}/top-level`)]: {
             c: 'c',
           },
-          [await getHash(`${url}/nested/chunk1.json`)]: {
+          [getHash(`${url}/nested/chunk1.json`)]: {
             b: {
-              $ref: `#/x-ext/${await getHash(`${url}/top-level`)}`,
+              $ref: `#/x-ext/${getHash(`${url}/top-level`)}`,
             },
           },
         },
         a: {
-          $ref: `#/x-ext/${await getHash(`${url}/nested/chunk1.json`)}`,
+          $ref: `#/x-ext/${getHash(`${url}/nested/chunk1.json`)}`,
         },
       })
     })
@@ -345,17 +343,17 @@ describe('bundle', () => {
 
       expect(output).toEqual({
         'x-ext': {
-          [await getHash(`${url}/top-level`)]: {
+          [getHash(`${url}/top-level`)]: {
             c: 'c',
           },
-          [await getHash(`${url}/nested/chunk1.json`)]: {
+          [getHash(`${url}/nested/chunk1.json`)]: {
             b: {
-              $ref: `#/x-ext/${await getHash(`${url}/top-level`)}`,
+              $ref: `#/x-ext/${getHash(`${url}/top-level`)}`,
             },
           },
         },
         a: {
-          $ref: `#/x-ext/${await getHash(`${url}/nested/chunk1.json`)}`,
+          $ref: `#/x-ext/${getHash(`${url}/nested/chunk1.json`)}`,
         },
       })
     })
@@ -395,21 +393,21 @@ describe('bundle', () => {
 
       expect(output).toEqual({
         'x-ext': {
-          [await getHash(`${url}/top-level`)]: {
+          [getHash(`${url}/top-level`)]: {
             c: 'c',
           },
-          [await getHash(`${url}/nested/chunk1.json`)]: {
+          [getHash(`${url}/nested/chunk1.json`)]: {
             b: {
-              $ref: `#/x-ext/${await getHash(`${url}/top-level`)}`,
+              $ref: `#/x-ext/${getHash(`${url}/top-level`)}`,
             },
           },
         },
         'x-ext-urls': {
-          [await getHash(`${url}/top-level`)]: `${url}/top-level`,
-          [await getHash(`${url}/nested/chunk1.json`)]: `${url}/nested/chunk1.json`,
+          [getHash(`${url}/top-level`)]: `${url}/top-level`,
+          [getHash(`${url}/nested/chunk1.json`)]: `${url}/nested/chunk1.json`,
         },
         a: {
-          $ref: `#/x-ext/${await getHash(`${url}/nested/chunk1.json`)}`,
+          $ref: `#/x-ext/${getHash(`${url}/nested/chunk1.json`)}`,
         },
       })
     })
@@ -466,13 +464,13 @@ describe('bundle', () => {
         a: {
           b: {
             c: {
-              $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}`,
+              $ref: `#/x-ext/${getHash(`${url}/chunk1`)}`,
             },
             d: {
               e: {
                 f: {
                   g: {
-                    $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}`,
+                    $ref: `#/x-ext/${getHash(`${url}/chunk1`)}`,
                   },
                 },
               },
@@ -480,18 +478,18 @@ describe('bundle', () => {
           },
         },
         'x-ext': {
-          [await getHash(`${url}/chunk1`)]: {
+          [getHash(`${url}/chunk1`)]: {
             a: {
               hello: 'hello',
             },
             b: {
-              $ref: `#/x-ext/${await getHash(`${url}/chunk2`)}`,
+              $ref: `#/x-ext/${getHash(`${url}/chunk2`)}`,
             },
           },
-          [await getHash(`${url}/chunk2`)]: {
+          [getHash(`${url}/chunk2`)]: {
             a: 'a',
             b: {
-              $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}`,
+              $ref: `#/x-ext/${getHash(`${url}/chunk1`)}`,
             },
           },
         },
@@ -528,11 +526,11 @@ describe('bundle', () => {
       expect(input).toEqual({
         a: [
           {
-            $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}`,
+            $ref: `#/x-ext/${getHash(`${url}/chunk1`)}`,
           },
         ],
         'x-ext': {
-          [await getHash(`${url}/chunk1`)]: {
+          [getHash(`${url}/chunk1`)]: {
             a: {
               hello: 'hello',
             },
@@ -586,20 +584,20 @@ describe('bundle', () => {
           $ref: `${url}/chunk1#`,
         },
         b: {
-          $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}`,
+          $ref: `#/x-ext/${getHash(`${url}/chunk1`)}`,
         },
         c: {
           $ref: `${url}/chunk1#`,
         },
         'x-ext': {
-          [await getHash(`${url}/chunk1`)]: {
+          [getHash(`${url}/chunk1`)]: {
             a: {
               hello: 'hello',
             },
           },
         },
         'x-ext-urls': {
-          [await getHash(`${url}/chunk1`)]: `${url}/chunk1`,
+          [getHash(`${url}/chunk1`)]: `${url}/chunk1`,
         },
       })
 
@@ -616,20 +614,20 @@ describe('bundle', () => {
           $ref: `${url}/chunk1#`,
         },
         b: {
-          $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}`,
+          $ref: `#/x-ext/${getHash(`${url}/chunk1`)}`,
         },
         c: {
-          $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}`,
+          $ref: `#/x-ext/${getHash(`${url}/chunk1`)}`,
         },
         'x-ext': {
-          [await getHash(`${url}/chunk1`)]: {
+          [getHash(`${url}/chunk1`)]: {
             a: {
               hello: 'hello',
             },
           },
         },
         'x-ext-urls': {
-          [await getHash(`${url}/chunk1`)]: `${url}/chunk1`,
+          [getHash(`${url}/chunk1`)]: `${url}/chunk1`,
         },
       })
 
@@ -679,13 +677,13 @@ describe('bundle', () => {
           $ref: `${url}/chunk1#`,
         },
         b: {
-          $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}`,
+          $ref: `#/x-ext/${getHash(`${url}/chunk1`)}`,
         },
         c: {
           $ref: `${url}/chunk1#`,
         },
         'x-ext': {
-          [await getHash(`${url}/chunk1`)]: {
+          [getHash(`${url}/chunk1`)]: {
             a: {
               hello: 'hello',
             },
@@ -693,7 +691,7 @@ describe('bundle', () => {
         },
         // It should still inject the mappings on the output document
         'x-ext-urls': {
-          [await getHash(`${url}/chunk1`)]: `${url}/chunk1`,
+          [getHash(`${url}/chunk1`)]: `${url}/chunk1`,
         },
       })
     })
@@ -733,14 +731,14 @@ describe('bundle', () => {
 
       expect(input).toEqual({
         a: {
-          $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}/a/b`,
+          $ref: `#/x-ext/${getHash(`${url}/chunk1`)}/a/b`,
         },
         'x-ext': {
-          [await getHash(`${url}/chunk1`)]: {
+          [getHash(`${url}/chunk1`)]: {
             a: {
               b: {
                 g: {
-                  $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}/d/e`,
+                  $ref: `#/x-ext/${getHash(`${url}/chunk1`)}/d/e`,
                 },
                 hello: 'hello',
               },
@@ -804,20 +802,20 @@ describe('bundle', () => {
 
       expect(input).toEqual({
         a: {
-          $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}/a`,
+          $ref: `#/x-ext/${getHash(`${url}/chunk1`)}/a`,
         },
         'x-ext': {
-          [await getHash(`${url}/chunk1`)]: {
+          [getHash(`${url}/chunk1`)]: {
             a: {
               b: {
                 g: {
-                  $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}/d/e`,
+                  $ref: `#/x-ext/${getHash(`${url}/chunk1`)}/d/e`,
                 },
                 hello: 'hello',
               },
               c: 'c',
               'external': {
-                $ref: `#/x-ext/${await getHash(`${url}/chunk2`)}/a/b`,
+                $ref: `#/x-ext/${getHash(`${url}/chunk2`)}/a/b`,
               },
             },
             d: {
@@ -826,7 +824,7 @@ describe('bundle', () => {
               },
             },
           },
-          [await getHash(`${url}/chunk2`)]: {
+          [getHash(`${url}/chunk2`)]: {
             a: {
               b: {
                 hello: 'hello',
@@ -871,20 +869,20 @@ describe('bundle', () => {
 
       expect(input).toEqual({
         a: {
-          $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}/a`,
+          $ref: `#/x-ext/${getHash(`${url}/chunk1`)}/a`,
         },
         'x-ext': {
-          [await getHash(`${url}/chunk1`)]: {
+          [getHash(`${url}/chunk1`)]: {
             a: {
               b: {
                 g: {
-                  $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}/a/external`,
+                  $ref: `#/x-ext/${getHash(`${url}/chunk1`)}/a/external`,
                 },
                 hello: 'hello',
               },
               c: 'c',
               external: {
-                $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}/a/b`,
+                $ref: `#/x-ext/${getHash(`${url}/chunk1`)}/a/b`,
               },
             },
           },
@@ -951,11 +949,11 @@ describe('bundle', () => {
       expect(input).toEqual({
         a: {
           $global: true,
-          $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}`,
+          $ref: `#/x-ext/${getHash(`${url}/chunk1`)}`,
         },
         b: {
           $global: true,
-          $ref: `#/x-ext/${await getHash(`${url}/chunk2`)}`,
+          $ref: `#/x-ext/${getHash(`${url}/chunk2`)}`,
         },
         c: {
           $global: true,
@@ -973,19 +971,19 @@ describe('bundle', () => {
           },
         },
         'x-ext': {
-          [await getHash(`${url}/chunk1`)]: {
+          [getHash(`${url}/chunk1`)]: {
             description: 'Chunk 1',
             someRef: {
               $ref: '#/components/User',
             },
           },
-          [await getHash(`${url}/chunk2`)]: {
+          [getHash(`${url}/chunk2`)]: {
             description: 'Chunk 2',
           },
         },
         'x-ext-urls': {
-          [await getHash(`${url}/chunk2`)]: `${url}/chunk2`,
-          [await getHash(`${url}/chunk1`)]: `${url}/chunk1`,
+          [getHash(`${url}/chunk2`)]: `${url}/chunk2`,
+          [getHash(`${url}/chunk1`)]: `${url}/chunk1`,
         },
       })
     })
@@ -1031,7 +1029,7 @@ describe('bundle', () => {
 
       expect(input).toEqual({
         a: {
-          $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}`,
+          $ref: `#/x-ext/${getHash(`${url}/chunk1`)}`,
         },
         b: {
           a: 'a',
@@ -1043,14 +1041,14 @@ describe('bundle', () => {
           $ref: `${url}/chunk2#`,
         },
         'x-ext': {
-          [await getHash(`${url}/chunk1`)]: {
+          [getHash(`${url}/chunk1`)]: {
             a: {
               hello: 'hello',
             },
           },
         },
         'x-ext-urls': {
-          [await getHash(`${url}/chunk1`)]: 'http://localhost:7289/chunk1',
+          [getHash(`${url}/chunk1`)]: 'http://localhost:7289/chunk1',
         },
       })
     })
@@ -1134,14 +1132,14 @@ describe('bundle', () => {
       expect(input).toEqual({
         a: {
           $global: true,
-          $ref: `#/x-ext/${await getHash(`${url}/chunk1`)}`,
+          $ref: `#/x-ext/${getHash(`${url}/chunk1`)}`,
         },
         b: {
           $global: true,
-          $ref: `#/x-ext/${await getHash(`${url}/chunk2`)}`,
+          $ref: `#/x-ext/${getHash(`${url}/chunk2`)}`,
         },
         c: {
-          $ref: `#/x-ext/${await getHash(`${url}/external/document.json`)}`,
+          $ref: `#/x-ext/${getHash(`${url}/external/document.json`)}`,
         },
 
         entry: {
@@ -1151,34 +1149,34 @@ describe('bundle', () => {
           $ref: `http://localhost:${port}/chunk1`,
         },
         'x-ext': {
-          [await getHash(`${url}/external/document.json`)]: {
+          [getHash(`${url}/external/document.json`)]: {
             external: 'external',
             someChunk: {
-              $ref: `#/x-ext/${await getHash(`${url}/chunk3`)}`,
+              $ref: `#/x-ext/${getHash(`${url}/chunk3`)}`,
               $global: true,
             },
           },
-          [await getHash(`${url}/chunk1`)]: {
+          [getHash(`${url}/chunk1`)]: {
             chunk1: 'chunk1',
             someRef: {
               $ref: '#/b',
             },
           },
-          [await getHash(`${url}/chunk2`)]: {
+          [getHash(`${url}/chunk2`)]: {
             chunk2: 'chunk2',
             someRef: {
               $ref: '#/c',
             },
           },
-          [await getHash(`${url}/chunk3`)]: {
+          [getHash(`${url}/chunk3`)]: {
             chunk3: 'chunk3',
           },
         },
         'x-ext-urls': {
-          [await getHash(`${url}/chunk1`)]: `${url}/chunk1`,
-          [await getHash(`${url}/chunk2`)]: `${url}/chunk2`,
-          [await getHash(`${url}/chunk3`)]: `${url}/chunk3`,
-          [await getHash(`${url}/external/document.json`)]: `${url}/external/document.json`,
+          [getHash(`${url}/chunk1`)]: `${url}/chunk1`,
+          [getHash(`${url}/chunk2`)]: `${url}/chunk2`,
+          [getHash(`${url}/chunk3`)]: `${url}/chunk3`,
+          [getHash(`${url}/external/document.json`)]: `${url}/external/document.json`,
         },
       })
     })
@@ -1296,10 +1294,10 @@ describe('bundle', () => {
 
       expect(result).toEqual({
         'a': {
-          '$ref': '#/x-ext/8706c8f',
+          '$ref': '#/x-ext/814f1d7',
         },
         'x-ext': {
-          '8706c8f': {
+          '814f1d7': {
             'message': 'some resolved external reference',
           },
         },
@@ -1324,8 +1322,8 @@ describe('bundle', () => {
       })
 
       expect(result).toEqual({
-        a: { '$ref': '#/x-ext/6b07652' },
-        'x-ext': { '6b07652': { message: 'some resolved external reference' } },
+        a: { '$ref': '#/x-ext/220f104' },
+        'x-ext': { '220f104': { message: 'some resolved external reference' } },
       })
     })
 
@@ -1543,12 +1541,12 @@ describe('bundle', () => {
         'a': {
           'b': {
             'c': {
-              '$ref': '#/x-ext/1c26e20',
+              '$ref': '#/x-ext/ce08d76',
             },
           },
         },
         'x-ext': {
-          '1c26e20': {
+          'ce08d76': {
             'message': 'resolved value',
           },
         },
@@ -1599,12 +1597,12 @@ describe('bundle', () => {
         'a': {
           'b': {
             'c': {
-              '$ref': '#/x-ext/19ac1c5',
+              '$ref': '#/x-ext/b9d44e3',
             },
           },
         },
         'x-ext': {
-          '19ac1c5': {
+          'b9d44e3': {
             'message': 'resolved value',
           },
         },
@@ -1665,12 +1663,12 @@ describe('bundle', () => {
         'a': {
           'b': {
             'c': {
-              '$ref': '#/x-ext/8f7df4f',
+              '$ref': '#/x-ext/c3654f1',
             },
           },
         },
         'x-ext': {
-          '8f7df4f': {
+          'c3654f1': {
             'message': 'resolved value',
           },
         },
@@ -1744,16 +1742,16 @@ describe('bundle', () => {
             '$ref': '#my-anchor',
           },
           'g': {
-            '$ref': '#/x-ext/0a9e8c9',
+            '$ref': '#/x-ext/e71bf65',
           },
         },
         'x-ext': {
-          '0a9e8c9': {
+          'e71bf65': {
             'message': 'resolved value',
           },
         },
         'x-ext-urls': {
-          '0a9e8c9': 'http://example.com',
+          'e71bf65': 'http://example.com',
         },
       })
     })
@@ -1798,12 +1796,12 @@ describe('bundle', () => {
 
       expect(input).toEqual({
         'x-ext': {
-          [await getHash(chunk1Path)]: {
+          [getHash(chunk1Path)]: {
             ...chunk1,
           },
         },
         a: {
-          $ref: `#/x-ext/${await getHash(chunk1Path)}/a`,
+          $ref: `#/x-ext/${getHash(chunk1Path)}/a`,
         },
       })
     })
@@ -1831,15 +1829,15 @@ describe('bundle', () => {
 
       expect(input).toEqual({
         'x-ext': {
-          [await getHash(chunk1Path)]: {
+          [getHash(chunk1Path)]: {
             ...chunk1,
           },
-          [await getHash(chunk2Path)]: {
-            a: { $ref: `#/x-ext/${await getHash(chunk1Path)}` },
+          [getHash(chunk2Path)]: {
+            a: { $ref: `#/x-ext/${getHash(chunk1Path)}` },
           },
         },
         a: {
-          $ref: `#/x-ext/${await getHash(chunk2Path)}`,
+          $ref: `#/x-ext/${getHash(chunk2Path)}`,
         },
       })
     })
@@ -1877,15 +1875,15 @@ describe('bundle', () => {
 
       expect(input).toEqual({
         'x-ext': {
-          [await getHash(`nested/${cName}`)]: {
+          [getHash(`nested/${cName}`)]: {
             c: 'c',
           },
-          [await getHash(`nested/${bName}`)]: {
-            b: { $ref: `#/x-ext/${await getHash(`nested/${cName}`)}` },
+          [getHash(`nested/${bName}`)]: {
+            b: { $ref: `#/x-ext/${getHash(`nested/${cName}`)}` },
           },
         },
         a: {
-          $ref: `#/x-ext/${await getHash(`nested/${bName}`)}`,
+          $ref: `#/x-ext/${getHash(`nested/${bName}`)}`,
         },
       })
     })
@@ -1926,10 +1924,10 @@ describe('bundle', () => {
 
       expect(result).toEqual({
         'b': {
-          '$ref': `#/x-ext/${await getHash(`nested/${cName}`)}`,
+          '$ref': `#/x-ext/${getHash(`nested/${cName}`)}`,
         },
         'x-ext': {
-          [await getHash(`nested/${cName}`)]: {
+          [getHash(`nested/${cName}`)]: {
             'c': 'c',
           },
         },
@@ -1971,12 +1969,12 @@ describe('bundle', () => {
 
       expect(result).toEqual({
         'x-ext': {
-          [await getHash(chunk1Path)]: {
+          [getHash(chunk1Path)]: {
             ...chunk1,
           },
         },
         a: {
-          $ref: `#/x-ext/${await getHash(chunk1Path)}/a`,
+          $ref: `#/x-ext/${getHash(chunk1Path)}/a`,
         },
       })
     })
@@ -1992,7 +1990,6 @@ describe('bundle', () => {
 
       return async () => {
         await server.close()
-        await setTimeout(100)
       }
     })
 
@@ -2029,12 +2026,12 @@ describe('bundle', () => {
 
       expect(result).toEqual({
         'x-ext': {
-          [await getHash(chunk1Path)]: {
+          [getHash(chunk1Path)]: {
             ...chunk1,
           },
         },
         a: {
-          $ref: `#/x-ext/${await getHash(chunk1Path)}/a`,
+          $ref: `#/x-ext/${getHash(chunk1Path)}/a`,
         },
       })
     })
@@ -2071,7 +2068,6 @@ describe('bundle', () => {
 
       return async () => {
         await server.close()
-        await setTimeout(100)
       }
     })
 
@@ -2113,12 +2109,12 @@ describe('bundle', () => {
 
       expect(input).toEqual({
         'x-ext': {
-          [await getHash(url)]: {
+          [getHash(url)]: {
             ...external,
           },
         },
         'x-ext-urls': {
-          [await getHash(url)]: url,
+          [getHash(url)]: url,
         },
         a: {
           b: {
@@ -2133,7 +2129,7 @@ describe('bundle', () => {
         },
         d: {
           e: {
-            $ref: `#/x-ext/${await getHash(url)}/prop`,
+            $ref: `#/x-ext/${getHash(url)}/prop`,
           },
         },
       })
@@ -2180,12 +2176,12 @@ describe('bundle', () => {
 
       expect(input).toEqual({
         'x-ext': {
-          [await getHash(url)]: {
+          [getHash(url)]: {
             ...external,
           },
         },
         'x-ext-urls': {
-          [await getHash(url)]: url,
+          [getHash(url)]: url,
         },
         a: {
           b: {
@@ -2200,7 +2196,7 @@ describe('bundle', () => {
         },
         d: {
           e: {
-            $ref: `#/x-ext/${await getHash(url)}/prop`,
+            $ref: `#/x-ext/${getHash(url)}/prop`,
           },
         },
       })
@@ -2217,12 +2213,12 @@ describe('bundle', () => {
       // because we are reusing the same hash set
       expect(input).toEqual({
         'x-ext': {
-          [await getHash(url)]: {
+          [getHash(url)]: {
             ...external,
           },
         },
         'x-ext-urls': {
-          [await getHash(url)]: url,
+          [getHash(url)]: url,
         },
         a: {
           b: {
@@ -2237,7 +2233,7 @@ describe('bundle', () => {
         },
         d: {
           e: {
-            $ref: `#/x-ext/${await getHash(url)}/prop`,
+            $ref: `#/x-ext/${getHash(url)}/prop`,
           },
         },
       })
@@ -2251,19 +2247,19 @@ describe('bundle', () => {
 
       expect(input).toEqual({
         'x-ext': {
-          [await getHash(url)]: {
+          [getHash(url)]: {
             ...external,
           },
         },
         'x-ext-urls': {
-          [await getHash(url)]: url,
+          [getHash(url)]: url,
         },
         a: {
           b: {
             c: {
               d: {
                 e: {
-                  $ref: `#/x-ext/${await getHash(url)}/prop`,
+                  $ref: `#/x-ext/${getHash(url)}/prop`,
                 },
               },
             },
@@ -2271,7 +2267,7 @@ describe('bundle', () => {
         },
         d: {
           e: {
-            $ref: `#/x-ext/${await getHash(url)}/prop`,
+            $ref: `#/x-ext/${getHash(url)}/prop`,
           },
         },
       })
@@ -2439,9 +2435,9 @@ describe('bundle', () => {
       expect(exec).toHaveBeenLastCalledWith('hello')
 
       expect(result).toEqual({
-        $ref: '#/x-ext/26c7827',
+        $ref: '#/x-ext/f265832',
         'x-ext': {
-          '26c7827': {
+          'f265832': {
             message: 'Resolved document',
           },
         },
@@ -2638,13 +2634,13 @@ describe('bundle', () => {
 
       expect(onResolveStart).toHaveBeenCalledTimes(2)
       expect(onResolveStart).nthCalledWith(1, { $ref: 'some-value' })
-      expect(onResolveStart).nthCalledWith(2, { $ref: '#/x-ext/2a57507' })
+      expect(onResolveStart).nthCalledWith(2, { $ref: '#/x-ext/908a515' })
 
       expect(onResolveError).toHaveBeenCalledTimes(1)
       expect(onResolveError).lastCalledWith({ $ref: 'some-value' })
 
       expect(onResolveSuccess).toHaveBeenCalledTimes(1)
-      expect(onResolveSuccess).lastCalledWith({ $ref: '#/x-ext/2a57507' })
+      expect(onResolveSuccess).lastCalledWith({ $ref: '#/x-ext/908a515' })
     })
 
     it('correctly provides the parent node in different levels', async () => {

package/src/bundle/plugins/fetch-urls/index.test.ts

@@ -1,5 +1,3 @@
-import { setTimeout } from 'node:timers/promises'
-
 import { type FastifyInstance, fastify } from 'fastify'
 import { assert, beforeEach, describe, expect, it, vi } from 'vitest'
 
@@ -16,7 +14,6 @@ describe('fetchUrl', () => {
 
     return async () => {
       await server.close()
-      await setTimeout(100)
     }
   })
 

package/src/bundle/value-generator.ts

@@ -1,4 +1,4 @@
-import { generateHash } from '@/helpers/generate-hash'
+import { generateHash } from '@scalar/helpers/string/generate-hash'
 
 /**
  * Generates a short hash from a string value using xxhash.
@@ -13,11 +13,11 @@ import { generateHash } from '@/helpers/generate-hash'
  * @returns A Promise that resolves to a 7-character hexadecimal hash with at least one letter
  * @example
  * // Returns "2ae91d7"
- * await getHash("https://example.com/schema.json")
+ * getHash("https://example.com/schema.json")
  */
-export async function getHash(value: string): Promise<string> {
+export function getHash(value: string): string {
   // Hash the data using xxhash
-  const hashHex = await generateHash(value)
+  const hashHex = generateHash(value)
 
   // Return first 7 characters of the hash, ensuring at least one letter
   const hash = hashHex.substring(0, 7)

package/src/dereference/dereference.test.ts

@@ -1,7 +1,5 @@
-import { setTimeout } from 'node:timers/promises'
-
 import { type FastifyInstance, fastify } from 'fastify'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { beforeEach, describe, expect, it } from 'vitest'
 
 import { dereference } from '@/dereference/dereference'
 
@@ -68,11 +66,10 @@ describe('dereference', () => {
 
     beforeEach(() => {
       server = fastify({ logger: false })
-    })
 
-    afterEach(async () => {
-      await server.close()
-      await setTimeout(100)
+      return async () => {
+        await server.close()
+      }
     })
 
     it('should dereference JSON pointers asynchronously', async () => {
@@ -101,7 +98,7 @@ describe('dereference', () => {
         success: true,
         data: {
           profile: {
-            '$ref': '#/x-ext/f87db7e',
+            '$ref': '#/x-ext/f053c6d',
             '$ref-value': {
               name: 'Jane Doe',
               age: 25,
@@ -112,17 +109,17 @@ describe('dereference', () => {
             },
           },
           address: {
-            '$ref': '#/x-ext/f87db7e/address',
+            '$ref': '#/x-ext/f053c6d/address',
             '$ref-value': {
               city: 'Los Angeles',
               street: 'Sunset Boulevard',
             },
           },
           'x-ext': {
-            'f87db7e': userProfile,
+            'f053c6d': userProfile,
           },
           'x-ext-urls': {
-            'f87db7e': `${url}/users`,
+            'f053c6d': `${url}/users`,
           },
         },
       })

package/vite.config.ts

@@ -1,4 +1,4 @@
-import { alias } from '@scalar/build-tooling'
+import { alias } from '@scalar/build-tooling/vite'
 import { defineConfig } from 'vite'
 
 export default defineConfig({

package/dist/helpers/generate-hash.d.ts

@@ -1,11 +0,0 @@
-/**
- * Generate a hash from a string using the xxhash algorithm
- *
- * We cannot use crypto.subtle because it is only available in secure contexts (HTTPS) or on localhost.
- * So this is just a wrapper around the xxhash-wasm library instead.
- *
- * @param input - The string to hash
- * @returns A Promise that resolves to the hash of the input string
- */
-export declare const generateHash: (input: string) => Promise<string>;
-//# sourceMappingURL=generate-hash.d.ts.map

package/dist/helpers/generate-hash.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-hash.d.ts","sourceRoot":"","sources":["../../src/helpers/generate-hash.ts"],"names":[],"mappings":"AAgBA;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,GAAU,OAAO,MAAM,KAAG,OAAO,CAAC,MAAM,CAGhE,CAAA"}

package/dist/helpers/generate-hash.js

@@ -1,16 +0,0 @@
-import xxhash from "xxhash-wasm";
-let hasherInstance = null;
-const getHasher = async () => {
-  if (!hasherInstance) {
-    hasherInstance = await xxhash();
-  }
-  return hasherInstance;
-};
-const generateHash = async (input) => {
-  const { h64ToString } = await getHasher();
-  return h64ToString(input);
-};
-export {
-  generateHash
-};
-//# sourceMappingURL=generate-hash.js.map

package/dist/helpers/generate-hash.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/helpers/generate-hash.ts"],
-  "sourcesContent": ["import xxhash from 'xxhash-wasm'\n\nlet hasherInstance: Awaited<ReturnType<typeof xxhash>> | null = null\n\n/**\n * Initialize the xxhash hasher instance lazily\n *\n * This is just a workaround because we cannot use top level await in a UMD module (standalone references)\n */\nconst getHasher = async () => {\n  if (!hasherInstance) {\n    hasherInstance = await xxhash()\n  }\n  return hasherInstance\n}\n\n/**\n * Generate a hash from a string using the xxhash algorithm\n *\n * We cannot use crypto.subtle because it is only available in secure contexts (HTTPS) or on localhost.\n * So this is just a wrapper around the xxhash-wasm library instead.\n *\n * @param input - The string to hash\n * @returns A Promise that resolves to the hash of the input string\n */\nexport const generateHash = async (input: string): Promise<string> => {\n  const { h64ToString } = await getHasher()\n  return h64ToString(input)\n}\n"],
-  "mappings": "AAAA,OAAO,YAAY;AAEnB,IAAI,iBAA4D;AAOhE,MAAM,YAAY,YAAY;AAC5B,MAAI,CAAC,gBAAgB;AACnB,qBAAiB,MAAM,OAAO;AAAA,EAChC;AACA,SAAO;AACT;AAWO,MAAM,eAAe,OAAO,UAAmC;AACpE,QAAM,EAAE,YAAY,IAAI,MAAM,UAAU;AACxC,SAAO,YAAY,KAAK;AAC1B;",
-  "names": []
-}

package/src/helpers/generate-hash.test.ts

@@ -1,74 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { generateHash } from './generate-hash'
-
-describe('generateHash', () => {
-  it('generates a hash from a simple string', async () => {
-    const result = await generateHash('hello world')
-
-    // Should return a non-empty string
-    expect(result).toBeTruthy()
-    expect(typeof result).toBe('string')
-    expect(result.length).toBeGreaterThan(0)
-  })
-
-  it('produces consistent hashes for the same input', async () => {
-    const input = 'consistent-test-string'
-    const hash1 = await generateHash(input)
-    const hash2 = await generateHash(input)
-    const hash3 = await generateHash(input)
-
-    // Same input should always produce the same hash
-    expect(hash1).toBe(hash2)
-    expect(hash2).toBe(hash3)
-  })
-
-  it('produces different hashes for different inputs', async () => {
-    const hash1 = await generateHash('first string')
-    const hash2 = await generateHash('second string')
-    const hash3 = await generateHash('first strinG') // Case-sensitive
-
-    // Different inputs should produce different hashes
-    expect(hash1).not.toBe(hash2)
-    expect(hash1).not.toBe(hash3)
-    expect(hash2).not.toBe(hash3)
-  })
-
-  it('handles empty string', async () => {
-    const result = await generateHash('')
-
-    // Should handle empty strings without throwing
-    expect(result).toBeTruthy()
-    expect(typeof result).toBe('string')
-
-    // Empty string should produce a consistent hash
-    const result2 = await generateHash('')
-    expect(result).toBe(result2)
-  })
-
-  it('handles special characters and unicode', async () => {
-    const inputs = [
-      '🚀 emoji test',
-      'special chars: !@#$%^&*()',
-      'unicode: こんにちは世界',
-      'newlines\nand\ttabs',
-      'mixed: 👾 special!@# unicode: 你好',
-    ]
-
-    const hashes = await Promise.all(inputs.map((input) => generateHash(input)))
-
-    // All should produce valid hashes
-    hashes.forEach((hash) => {
-      expect(hash).toBeTruthy()
-      expect(typeof hash).toBe('string')
-    })
-
-    // All should be unique
-    const uniqueHashes = new Set(hashes)
-    expect(uniqueHashes.size).toBe(inputs.length)
-
-    // Should be consistent on repeated calls
-    const repeatedHash = await generateHash('🚀 emoji test')
-    expect(repeatedHash).toBe(hashes[0])
-  })
-})

package/src/helpers/generate-hash.ts

@@ -1,29 +0,0 @@
-import xxhash from 'xxhash-wasm'
-
-let hasherInstance: Awaited<ReturnType<typeof xxhash>> | null = null
-
-/**
- * Initialize the xxhash hasher instance lazily
- *
- * This is just a workaround because we cannot use top level await in a UMD module (standalone references)
- */
-const getHasher = async () => {
-  if (!hasherInstance) {
-    hasherInstance = await xxhash()
-  }
-  return hasherInstance
-}
-
-/**
- * Generate a hash from a string using the xxhash algorithm
- *
- * We cannot use crypto.subtle because it is only available in secure contexts (HTTPS) or on localhost.
- * So this is just a wrapper around the xxhash-wasm library instead.
- *
- * @param input - The string to hash
- * @returns A Promise that resolves to the hash of the input string
- */
-export const generateHash = async (input: string): Promise<string> => {
-  const { h64ToString } = await getHasher()
-  return h64ToString(input)
-}