Support for `import(blobUrls)`

[strogonoff]

What is the problem this feature will solve?

The same thing that vm.SourceTextModule(yourCodeString, { identifier, context }) does, but in a way compatible with other JS runtimes.

Useful for implementing extensions, for example.

What is the feature you are proposing to solve the problem?

Compatibilty with other JS runtimes when it comes to import() and blob URLs.

Example code:

code = 'console.log("hi")'
blob = new Blob([code], { type: 'text/javascript' })
url = URL.createObjectURL(blob)
import(url)

References:

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import
• https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL_static
• https://developer.mozilla.org/en-US/docs/Web/URI/Reference/Schemes/blob

What alternatives have you considered?

vm.SourceTextModule(yourCodeString, { identifier, context })

[TejasSathe010]

Investigation: Support for import(blobUrls)

Current state

I investigated the codebase and found that Node.js currently lacks ESM loader support for blob: URLs, even though most of the underlying infrastructure already exists.

---

What already works ✅

• URL.createObjectURL(blob) creates blob:nodedata:<uuid> URLs
• resolveObjectURL(url) retrieves the original Blob object
• URL.revokeObjectURL(url) properly revokes URLs
• Workers can load data: URLs (proving the loader pattern works end-to-end)

---

What’s missing ❌

The ESM loader explicitly rejects the blob: protocol in three places:

1) No format handler — get_format.js (lines 26–28)

• Only has handlers for data:, file:, and node: protocols
• Missing a blob: protocol handler

2) No source loader — load.js (lines 33–51)

• getSourceSync() throws ERR_UNSUPPORTED_ESM_URL_SCHEME for blob: URLs

3) Protocol validation blocks it — load.js (lines 179–197)

• throwIfUnsupportedURLScheme() explicitly rejects blob:

---

How data: URLs work (reference model)

Since data: URLs are already supported, they can be used as the blueprint:

Format detection

1. Extract MIME type from the URL
2. Map it via mimeToFormat() to determine the module type

Source loading

1. Parse the URL and extract the inline code
2. Return a Buffer containing the source

Reusable utility

mimeToFormat() in formats.js already handles:

• text/javascript or application/javascript → "module"
• application/json → "json"
• application/wasm → "wasm"
• anything else → null (falls back to source-based detection)

---

Technical implementation path

Files to modify

1) get_format.js

• Add a getBlobProtocolModuleFormat() handler similar to getDataProtocolModuleFormat()
• The handler should:
  1. Call resolveObjectURL() to retrieve the Blob
  2. Use mimeToFormat(blob.type) to determine module format
  3. Return null if the blob is revoked (so the loader falls back to source-based detection)
• Register the handler in the protocolHandlers object

2) load.js

• Update throwIfUnsupportedURLScheme() to allow the blob: protocol
• Extend getSourceSync() to handle blob: URLs:
  1. Call resolveObjectURL() to retrieve the Blob
  2. Synchronously read blob bytes and return them as a Buffer
  3. Throw ERR_INVALID_URL if the blob is revoked

3) blob.js (optional)

• Add a helper to synchronously get blob bytes
• Wrap the existing C++ GetDataObject() binding to extract raw bytes

---

Tests to add

• test/parallel/test-blob-import.js
  Basic: import(URL.createObjectURL(blob))

• test/parallel/test-blob-import-meta.js
  Verify import.meta.url equals the blob URL

• test/parallel/test-blob-revoke.js
  Validate revocation behavior

• test/parallel/test-blob-mime-detection.js
  Ensure MIME type → format detection works

• test/parallel/test-blob-worker.js
  Test Worker support with blob URLs

---

Documentation updates

• url.md
  Add a note that createObjectURL() URLs can be used with import()

• esm.md
  Document blob: as a supported ESM URL scheme

---

Implementation considerations

Synchronous reading

The ESM loader’s getSourceSync() is used in most load paths.

Recommended approach: support sync (and optionally async)

• Implement synchronous blob byte reading (minimal C++ addition)
• Works across all load paths
• Matches browser behavior closely
• Small performance cost

Revocation semantics

• Before import starts: throw (blob not found)
• During load: throw (blob no longer exists)
• After load completes: OK (module cached)

This matches the expected semantics of other URL schemes.

Module caching

• Each blob URL is unique → caching is naturally correct
• Same blob URL → same cached module instance
• Different blob URLs → different modules (even if contents match)

Edge cases

• File-backed blobs: decide whether sync read is allowed (possible blocking I/O)
• Ambiguous MIME types: fall back to source-based module detection (already exists)
• Import attributes: validation should work with existing infrastructure

---

Browser compatibility 🌐

This feature is already supported in:

• ✅ Chrome / Edge
• ✅ Firefox
• ✅ Safari

Supporting it in Node.js:

• Improves isomorphic JavaScript compatibility
• Aligns better with Web standards
• Enables existing browser code to run in Node.js without rewrites

---

Summary

All the infrastructure is already in place. The missing piece is an ESM loader protocol handler for blob: URLs. The implementation can follow the existing data: pattern, making it a clean, maintainable addition.

[jimmywarting]

Some related issues / PR are already lost in the void.

Summary: Blob URL Support in Node.js

This is all about bringing blob URL support to Node.js, particularly for dynamic module imports. Here's the complete picture:

The Core Request (#61013 - Current, Open)

You're asking for Node.js to support importing from blob URLs:

code = 'console.log("hi")'
blob = new Blob([code], { type: 'text/javascript' })
url = URL.createObjectURL(blob)
import(url)  // This should work!

This would enable:

• Runtime compatibility with browsers, Deno, and other JS runtimes
• Dynamic code loading (useful for extensions/plugins)
• A more standard alternative to vm.SourceTextModule()

It should also be supported for #43583

const webWorker = new Worker(blobUrl, { type: 'module' })

---

Related Issues:

1. #47573 - "Being able to do import(blobUrls)" (Closed, not planned)

• I filed this in April 2023 - same exact request!
• Node.js throws error: "Only URLs with a scheme in: file and data are supported by the default ESM loader. Received protocol 'blob:'"
• Workaround: Convert to data: URLs instead
• Status: Closed as "not planned", marked as blocked and stale

2. #46557 - "Cross-thread URL.createObjectURL" (Closed, not planned)

• Filed by @legendecas (February 2023)
• Problem: Blob URLs created in the main thread can't be accessed in Worker threads via buffer.resolveObjectURL()
• Web spec: Blob URL stores should be per-agent (shared across threads)
• Node.js: Currently documented as thread-local: "Blob objects registered within one Worker will not be available to other workers or the main thread"
• Status: Kept as-is for now, closed as stale

3. #54719 - "Reuse Blob Registry in Workers" (Closed, not planned)

• Filed by @avivkeller (September 2024)
• Requested sharing blob URLs between main thread and Workers
• Most browsers support this, but Deno doesn't
• Status: Closed as "not planned", marked stale

4. #54647 - "module: support import()-ing blob: urls" (Closed PR)

• This was a pull request by @avivkeller (August 2024) that actually implemented the feature!
• Allowed importing blob URLs with types: text/javascript, application/json, application/wasm
• Important limitation: "Blob URLs are registered within the current thread. Loaders will not be able to resolve Blob's from the main thread"
• Status: Closed September 6, 2024 (unclear if merged or rejected - the PR appears closed without merge)

---

Current State:

• My original request (Being able to do import(blobUrls) #47573) from April 2023 was closed as "not planned" (staled)
• A PR (module: support import()-ing blob: urls #54647) was created to implement it but was closed in September 2024
• Cross-thread blob URL support (Cross-thread URL.createObjectURL  #46557, Reuse Blob Registry in Workers #54719) has been repeatedly rejected
• You've now re-opened the discussion with Support for import(blobUrls) #61013

The main blockers seem to be: that blob urls are not shared across threads

another issue seems to be that not all blobs are transferable across threads (like disk blobs)

[jimmywarting]

for now, i got this userland solution going for me atm...

import { isMainThread } from 'node:worker_threads'
import { resolveObjectURL } from 'node:buffer'
import module from 'node:module'

/** @type {Map<string, Blob | PromiseWithResolvers<Blob>>} */
const map = new Map()

if (isMainThread) {
  const { port1, port2 } = new MessageChannel()

  module.registerHooks({
    resolve(specifier, context, nextResolve) {
      if (specifier.startsWith('blob:')) {
        const blob = resolveObjectURL(specifier)

        if (!['application/javascript', 'text/javascript'].includes(blob.type)) {
          throw new TypeError('Unsupported blob type: ' + blob.type + '. expected text/javascript MIME type.')
        }

        port1.postMessage({ blob, specifier })
      }
      return nextResolve(specifier, context, nextResolve)
    }
  })

  module.register(import.meta.url, {
    parentURL: import.meta.url,
    data: { port: port2 },
    transferList: [port2],
  })
}

async function resolve(specifier, context, nextResolve) {
  if (specifier.startsWith('blob:')) {
    return {
      url: specifier,
      shortCircuit: true,
      format: 'module',
    }
  }

  return nextResolve(specifier, context, nextResolve)
}

async function initialize({ port }) {
  port.addEventListener('message', evt => {
    const { blob, specifier } = evt.data
    const q = map.get(specifier)
    if (q) {
      q.resolve(blob)
    } else {
      map.set(specifier, blob)
    }
  })
  port.start()
}

async function load(specifier, context, nextLoad) {
  if (specifier.startsWith('blob:')) {
    let blob = map.get(specifier)

    if (!blob) {
      const q = Promise.withResolvers()
      map.set(specifier, q)
      blob = await q.promise
    }

    const source = await blob.text()
    map.delete(specifier)

    return {
      format: 'module',
      shortCircuit: true,
      source,
    }
  }

  return nextLoad(specifier, context, nextLoad)
}

export { initialize, load, resolve }

Works for me:

  const blob = new Blob(
    [`console.log('Hello from objectURL!');`],
    { type: 'application/javascript' }
  );
  const blobURL = URL.createObjectURL(blob);
  import(blobURL)

but not for disc blobs with openAsBlob