@@ -1446,6 +1446,90 @@ added:
 
 Returns true if the Node.js instance is run to build a snapshot.
 
+## Heap profile labels
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+Attach string labels to V8 sampling heap profiler allocation samples.
+Combined with [`AsyncLocalStorage`][], labels propagate through `await`
+boundaries for per-context memory attribution (e.g., per-HTTP-route).
+
+### `v8.withHeapProfileLabels(labels, fn)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `labels` {Object} Key-value string pairs (e.g., `{ route: '/users/:id' }`).
+* `fn` {Function} May be `async`.
+* Returns: {\*} Return value of `fn`.
+
+Runs `fn` with the given labels active. If `fn` returns a promise, labels
+remain active until the promise settles.
+
+```mjs
+const handle = v8.startHeapProfile({ sampleInterval: 64, labels: true });
+
+await v8.withHeapProfileLabels({ route: '/users' }, async () => {
+  const data = await fetchUsers();
+  return processData(data);
+});
+
+const profile = handle.getAllocationProfile();
+handle.stop();
+```
+
+### `v8.setHeapProfileLabels(labels)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `labels` {Object} Key-value string pairs.
+
+Sets labels for the current async scope using `enterWith` semantics.
+Useful for frameworks where the handler runs after the extension returns.
+
+Prefer [`v8.withHeapProfileLabels()`][] when possible for automatic cleanup.
+
+### Limitations — what is measured
+
+Heap samples cover V8 heap allocations (JS objects, strings, closures).
+`externalBytes` covers `Buffer`/`ArrayBuffer` backing stores.
+
+Not measured: native addon memory, JIT code space, OS-level allocations.
+
+**Native addon ABI.** The `v8::AllocationProfile::Sample` struct in
+`v8-profiler.h` includes the `label_id` field only when
+`V8_HEAP_PROFILER_SAMPLE_LABELS` is defined at compile time. Node.js sets
+this macro for its own builds and for addons compiled through node-gyp
+(via `common.gypi`). Addons built with other build systems (cmake, meson,
+Makefile) must define `-DV8_HEAP_PROFILER_SAMPLE_LABELS` themselves to match
+libnode. The `label_id` field is appended after the pre-existing fields, so
+their offsets never change. On the common 64-bit ABIs (and on 32-bit targets
+whose ABI 8-aligns `uint64_t`, such as Windows and ARM), it lands in existing
+tail padding, `sizeof(AllocationProfile::Sample)` is unchanged, and iterating
+`GetSamples()` strides correctly whether or not the macro is defined; an addon
+only needs the macro to name `label_id`. On i386 System V (32-bit x86 on
+Linux and the BSDs), `uint64_t` is 4-aligned and the field grows the struct by
+4 bytes, so an addon there must define the macro to stride `GetSamples()`
+correctly. A `static_assert` in V8 enforces the no-growth invariant on the
+ABIs that provide the padding. When the macro is not defined, the
+label APIs (`withHeapProfileLabels()`, `setHeapProfileLabels()`) are no-ops
+and `getAllocationProfile()` omits `samples[].labels` and `externalBytes`
+entirely.
+
+**Label availability.** Labels depend on async-context-frame, which propagates
+the `AsyncLocalStorage` map through continuation callbacks via
+`ContinuationPreservedEmbedderData`. The option is on by default; passing
+`--no-async-context-frame` disables it, leaving every sample's `labels` object
+empty. A one-time `process.emitWarning` fires at first label use when the
+option is off.
+
 ## Class: `v8.GCProfiler`
 
 <!-- YAML
@@ -1618,6 +1702,57 @@ added: v26.1.0
 
 > Stability: 1 - Experimental
 
+### `syncHeapProfileHandle.getAllocationProfile()`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Returns: {Object | undefined}
+
+Returns the current allocation profile without stopping the profiler, or
+`undefined` if the handle has already been stopped or if its session was
+superseded by a newer one started on the same binding (for example when
+an inspector `HeapProfiler.stopSampling` call ended the handle's V8
+session out of band and a new session was subsequently started). In the
+superseded case the handle carries a stale session identity and will never
+return a profile; call `stop()` on the new handle instead. The method is
+always available regardless of the `labels` option. For sessions started with
+`labels: true`, each sample's `labels` object is populated with the
+active label context at allocation time and `externalBytes` is included
+when labelled backing stores are live. For sessions started without
+`labels: true`, each sample carries an empty `labels` object and
+`externalBytes` is omitted.
+
+```json
+{
+  "samples": [
+    { "nodeId": 1, "size": 128, "count": 4, "sampleId": 42,
+      "labels": { "route": "/users/:id" } }
+  ],
+  "externalBytes": [
+    { "labels": { "route": "/users/:id" }, "bytes": 1048576 }
+  ]
+}
+```
+
+* `samples[].labels` — key-value string pairs from the active label context
+  at allocation time. Empty object if no labels were active. The object is
+  **frozen** and **shared** across all samples captured under the same
+  active label context — mutating it throws in strict mode.
+* `externalBytes[]` — live `Buffer`/`ArrayBuffer` backing-store bytes per
+  label context. Omitted when the profiling allocator is inactive, when no
+  labelled backing stores are live, or when all live stores were allocated
+  under an empty label set.
+
+**Label memory model.** The V8 heap profiler retains one copy of each
+distinct label set for the profiler's lifetime. In the default mode
+(`includeObjectsCollectedByMajorGC: false`) samples are dropped when their
+objects are GC'd. With `includeObjectsCollectedByMajorGC: true` or
+`includeObjectsCollectedByMinorGC: true`, dead samples are kept and each
+unique label set pins one internal array for the profiler's lifetime —
+label cardinality should be bounded to avoid unbounded growth.
+
 ### `syncHeapProfileHandle.stop()`
 
 <!-- YAML
@@ -1626,7 +1761,17 @@ added: v26.1.0
 
 * Returns: {string}
 
-Stopping collecting the profile and return the profile data.
+Stops the profiler and returns the profile as a DevTools-compatible JSON
+string. Each sample in the returned JSON contains `size`, `nodeId`, and
+`ordinal` fields. The returned string does not include `labels` or
+`externalBytes`; labelled allocation data is available mid-session through
+`syncHeapProfileHandle.getAllocationProfile()`.
+
+Returns `undefined` without stopping anything if `stop()` is called on a
+handle whose session was superseded (see `getAllocationProfile()` above).
+Throws `ERR_HEAP_PROFILE_NOT_STARTED` if `stop()` is called on a handle
+whose V8 session was ended out of band and no subsequent session has yet
+started.
 
 ### `syncHeapProfileHandle[Symbol.dispose]()`
 
@@ -1804,6 +1949,14 @@ added: v26.1.0
     by major GC. **Default:** `false`.
   * `includeObjectsCollectedByMinorGC` {boolean} Include objects collected
     by minor GC. **Default:** `false`.
+  * `labels` {boolean} Enable per-allocation label attribution via
+    [`v8.withHeapProfileLabels()`][] and [`v8.setHeapProfileLabels()`][].
+    When `true`, each sample's `labels` object in `getAllocationProfile()`
+    is populated with the active label context at allocation time, and
+    `externalBytes` entries are included when labelled backing stores are
+    live. Labelled data is only available through `getAllocationProfile()`;
+    `stop()` always returns the unlabelled DevTools JSON string.
+    **Default:** `false`.
 * Returns: {SyncHeapProfileHandle}
 
 Starting a heap profile then return a `SyncHeapProfileHandle` object.
@@ -1887,7 +2040,9 @@ console.log(profile);
 [`serializer.transferArrayBuffer()`]: #serializertransferarraybufferid-arraybuffer
 [`serializer.writeRawBytes()`]: #serializerwriterawbytesbuffer
 [`settled` callback]: #settledpromise
+[`v8.setHeapProfileLabels()`]: #v8setheapprofilelabelslabels
 [`v8.stopCoverage()`]: #v8stopcoverage
 [`v8.takeCoverage()`]: #v8takecoverage
+[`v8.withHeapProfileLabels()`]: #v8withheapprofilelabelslabels-fn
 [`vm.Script`]: vm.md#new-vmscriptcode-options
 [worker threads]: worker_threads.md
@@ -1999,6 +1999,12 @@ added:
 Starting a Heap profile then return a Promise that fulfills with an error
 or an `HeapProfileHandle` object. This API supports `await using` syntax.
 
+The `labels` option from [`v8.startHeapProfile()`][] is not supported
+when profiling a worker from the parent thread and throws
+`ERR_INVALID_ARG_VALUE`. To use labelled heap profiling inside a worker,
+call `v8.startHeapProfile({ labels: true })` from within the worker
+script itself.
+
 ```cjs
 const { Worker } = require('node:worker_threads');
 
@@ -2275,6 +2281,7 @@ thread spawned will spawn another until the application crashes.
 [`trace_events`]: tracing.md
 [`v8.getHeapSnapshot()`]: v8.md#v8getheapsnapshotoptions
 [`v8.getHeapStatistics()`]: v8.md#v8getheapstatistics
+[`v8.startHeapProfile()`]: v8.md#v8startheapprofileoptions
 [`vm`]: vm.md
 [`worker.SHARE_ENV`]: #worker_threadsshare_env
 [`worker.on('message')`]: #event-message_1