dumi 2.4.46 → 2.4.48-alpha.0

package/dist/loaders/markdown/index.js

@@ -29,9 +29,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/loaders/markdown/index.ts
 var markdown_exports = {};
 __export(markdown_exports, {
+  addDemoFileDependency: () => addDemoFileDependency,
+  createDependencyReader: () => createDependencyReader,
+  createStableTransform: () => createStableTransform,
   default: () => mdLoader,
+  emitDemo: () => emitDemo,
   getDemoSourceFiles: () => getDemoSourceFiles,
-  getMdLoaderCacheSync: () => getMdLoaderCacheSync
+  getDepsCacheKey: () => getDepsCacheKey,
+  getMdLoaderCacheResult: () => getMdLoaderCacheResult,
+  getMdLoaderCacheSync: () => getMdLoaderCacheSync,
+  getMdTransformCacheKeys: () => getMdTransformCacheKeys
 });
 module.exports = __toCommonJS(markdown_exports);
 var import_utoopackLoaders = require("../../features/compile/utoopackLoaders");
@@ -40,8 +47,61 @@ var import_utils = require("../../utils");
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_plugin_utils = require("umi/plugin-utils");
+var import_sharedCache = require("./sharedCache");
 var import_transformer = __toESM(require("./transformer"));
 var import_rehypeText = require("./transformer/rehypeText");
+var MD_LOADER_RUNTIME_OPTION_KEYS = [
+  "mode",
+  "builtins",
+  "onResolveDemos",
+  "onResolveAtomMeta",
+  "demoAssetsFile",
+  "cacheDirectory",
+  "cacheEpoch"
+];
+function getMdTransformCacheKeys({
+  resourcePath,
+  content,
+  useUtoopackDemoHMR,
+  opts
+}) {
+  const depsHintKey = [
+    resourcePath,
+    useUtoopackDemoHMR,
+    JSON.stringify(import_plugin_utils.lodash.omit(opts, MD_LOADER_RUNTIME_OPTION_KEYS))
+  ].join(":");
+  return {
+    depsHintKey,
+    baseCacheKey: [depsHintKey, (0, import_utils.getContentHash)(content)].join(":")
+  };
+}
+function getStatRevision(stat) {
+  return [stat.dev, stat.ino, stat.mode, stat.size, stat.mtimeNs, stat.ctimeNs].map(String).join(":");
+}
+async function getFileRevision(file) {
+  return getStatRevision(await import_fs.default.promises.stat(file, { bigint: true }));
+}
+function isMissingFsError(err) {
+  return (err == null ? void 0 : err.code) === "ENOENT" || (err == null ? void 0 : err.code) === "ENOTDIR";
+}
+async function getMissingParentRevision(file) {
+  let current = file;
+  while (true) {
+    try {
+      const revision = getStatRevision(
+        await import_fs.default.promises.stat(current, { bigint: true })
+      );
+      return `${import_path.default.normalize(current)}:${current === file ? "<appeared>:" : ""}${revision}`;
+    } catch (err) {
+      if (!isMissingFsError(err))
+        throw err;
+      const parent = import_path.default.dirname(current);
+      if (parent === current)
+        return `${current}:<missing>`;
+      current = parent;
+    }
+  }
+}
 function isMalformedCacheError(err) {
   return err instanceof SyntaxError || err instanceof Error && /Unexpected end of JSON input|Unterminated string in JSON/.test(
     err.message
@@ -56,25 +116,40 @@ function getMdLoaderCacheSync(cache, key, defaultValue) {
     throw err;
   }
 }
-function getDemoSidecarFiles(file) {
+function getDemoSidecarFile(file) {
   const { dir, name } = import_path.default.parse(file);
-  const mdFile = import_path.default.join(dir, `${name}.md`);
-  return import_fs.default.existsSync(mdFile) ? [mdFile] : [];
+  return import_path.default.join(dir, `${name}.md`);
 }
-function getDemoSourceFiles(demos = []) {
+function collectDemoSourceFiles(demos = [], includeMissingSidecars = false) {
   const files = /* @__PURE__ */ new Set();
   demos.forEach((demo) => {
     if ("resolveMap" in demo) {
       Object.values(demo.resolveMap).filter((p) => import_path.default.isAbsolute(p)).forEach((file) => {
         files.add(file);
-        getDemoSidecarFiles(file).forEach(
-          (sidecarFile) => files.add(sidecarFile)
-        );
+        const sidecarFile = getDemoSidecarFile(file);
+        if (includeMissingSidecars || import_fs.default.existsSync(sidecarFile)) {
+          files.add(sidecarFile);
+        }
       });
     }
   });
   return Array.from(files);
 }
+function getDemoSourceFiles(demos = []) {
+  return collectDemoSourceFiles(demos);
+}
+function getDemoCacheFiles(demos = []) {
+  return collectDemoSourceFiles(demos, true);
+}
+function addDemoFileDependency(loaderContext, opts, file) {
+  if (import_fs.default.existsSync(file) || import_utoopackLoaders.UTOOPACK_LOADER_CTX_KEY in opts) {
+    loaderContext.addDependency(file);
+  } else if (loaderContext.addMissingDependency) {
+    loaderContext.addMissingDependency(file);
+  } else {
+    loaderContext.addDependency(file);
+  }
+}
 function isRelativePath(path2) {
   return /^\.{1,2}(?!\w)/.test(path2);
 }
@@ -143,6 +218,21 @@ export default DumiMarkdownContent;`;
 }
 function emitDemo(opts, ret) {
   const { demos } = ret.meta;
+  const demoHMRVersions = Object.fromEntries(
+    (demos ?? []).flatMap((demo) => {
+      const hmrVersion = demo.__dumiUtoopackHMRVersion;
+      return typeof hmrVersion === "string" ? [[demo.id, hmrVersion]] : [];
+    })
+  );
+  const enableDemoHMR = opts.useUtoopackDemoHMR === true && Object.keys(demoHMRVersions).length > 0;
+  const demoHMRModuleId = JSON.stringify(
+    (0, import_plugin_utils.winPath)(`${this.resourcePath}?type=demo`)
+  );
+  const enableUtoopackSelfAccept = enableDemoHMR && import_utoopackLoaders.UTOOPACK_LOADER_CTX_KEY in opts;
+  const renderedDemos = demos == null ? void 0 : demos.map((demo) => ({
+    ...demo,
+    renderedPreviewerProps: "previewerProps" in demo && demo.previewerProps ? JSON.stringify(demo.previewerProps) : void 0
+  }));
   const shareDepsMap = {};
   const demoDepsMap = {};
   const relativeDepsMap = {};
@@ -185,6 +275,9 @@ function emitDemo(opts, ret) {
   return import_plugin_utils.Mustache.render(
     `import React from 'react';
 import '${(0, import_plugin_utils.winPath)(this.resourcePath)}?watch=parent';
+{{#enableDemoHMR}}
+import { registerDemoHMRModule } from 'dumi/dist/client/theme-api/DumiDemo/hmr';
+{{/enableDemoHMR}}
 {{#dedupedDemosDeps}}
 import * as {{{specifier}}} from '{{{key}}}';
 {{/dedupedDemosDeps}}
@@ -199,13 +292,29 @@ export const demos = {
     routeId: '{{{routeId}}}',
     {{/routeId}}
     context: {{{renderContext}}},
+    {{#previewerProps}}
+    previewerProps: {{{renderedPreviewerProps}}},
+    {{/previewerProps}}
     renderOpts: {{{renderRenderOpts}}},
   },
   {{/demos}}
-};`,
+};{{#enableUtoopackSelfAccept}}
+if (
+  typeof __turbopack_context__ !== 'undefined' &&
+  typeof __turbopack_context__.m?.hot?.accept === 'function'
+) {
+  __turbopack_context__.m.hot.accept();
+}
+{{/enableUtoopackSelfAccept}}{{#enableDemoHMR}}
+registerDemoHMRModule({{{demoHMRModuleId}}}, {{{demoHMRVersions}}});
+{{/enableDemoHMR}}`,
     {
-      demos,
+      demos: renderedDemos,
       dedupedDemosDeps,
+      demoHMRModuleId,
+      demoHMRVersions: JSON.stringify(demoHMRVersions),
+      enableDemoHMR,
+      enableUtoopackSelfAccept,
       routeId,
       renderAsset: function renderAsset() {
         if (!("asset" in this))
@@ -345,7 +454,9 @@ function emit(opts, ret) {
   const { demos, embeds } = ret.meta;
   embeds.forEach((file) => this.addDependency(file));
   if (opts.mode !== "demo-index") {
-    getDemoSourceFiles(demos).forEach((file) => this.addDependency(file));
+    getDemoCacheFiles(demos).forEach(
+      (file) => addDemoFileDependency(this, opts, file)
+    );
   }
   if (this.resourceQuery.includes("watch=parent"))
     return null;
@@ -362,20 +473,108 @@ function emit(opts, ret) {
       return emitDefault.call(this, opts, ret);
   }
 }
-function getDepsCacheKey(deps = []) {
+function normalizeDeps(deps = []) {
+  return Array.from(new Set(deps)).sort();
+}
+var readDependencyFromFs = (file) => import_fs.default.promises.readFile(file, "utf-8");
+async function getDepsCacheKey(deps = [], readDependency = readDependencyFromFs) {
   return JSON.stringify(
-    deps.map(
-      (file) => `${file}:${(0, import_utils.getContentHash)(import_fs.default.readFileSync(file, "utf-8"))}`
+    await Promise.all(
+      normalizeDeps(deps).map(async (file) => {
+        try {
+          const content = await readDependency(file);
+          return `${file}:${(0, import_utils.getContentHash)(content)}:${await getFileRevision(
+            file
+          )}`;
+        } catch (err) {
+          if (isMissingFsError(err)) {
+            return `${file}:<missing>:${await getMissingParentRevision(file)}`;
+          }
+          throw err;
+        }
+      })
     )
   );
 }
+function getMdLoaderCacheRecord(cache, key) {
+  const record = getMdLoaderCacheSync(
+    cache,
+    key,
+    void 0
+  );
+  return (record == null ? void 0 : record.version) === 2 ? record : void 0;
+}
+async function getValidMdLoaderCacheRecord(cache, key, readDependency = readDependencyFromFs) {
+  const record = getMdLoaderCacheRecord(cache, key);
+  if (!record)
+    return void 0;
+  if (record.depsKey === await getDepsCacheKey(record.deps, readDependency)) {
+    return record;
+  }
+  return void 0;
+}
+async function getMdLoaderCacheResult(cache, key, readDependency = readDependencyFromFs) {
+  var _a;
+  return (_a = await getValidMdLoaderCacheRecord(cache, key, readDependency)) == null ? void 0 : _a.result;
+}
+async function createStableTransform({
+  initialDeps,
+  createValue,
+  getDeps,
+  readDependency = readDependencyFromFs,
+  onDepsDiscovered,
+  maxAttempts = 3
+}) {
+  let expectedDeps = initialDeps && normalizeDeps(initialDeps);
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    const beforeKey = expectedDeps ? await getDepsCacheKey(expectedDeps, readDependency) : void 0;
+    const result = await createValue();
+    const deps = normalizeDeps(getDeps(result));
+    const depsKey = await getDepsCacheKey(deps, readDependency);
+    onDepsDiscovered == null ? void 0 : onDepsDiscovered(deps);
+    if (expectedDeps && JSON.stringify(expectedDeps) === JSON.stringify(deps) && beforeKey === depsKey) {
+      return { version: 2, deps, depsKey, result };
+    }
+    expectedDeps = deps;
+  }
+  throw Object.assign(
+    new Error("Markdown dependencies changed repeatedly while transforming"),
+    { code: "EDEPSUNSTABLE" }
+  );
+}
+function createDependencyReader(loaderContext, useUtoopack, mode) {
+  var _a;
+  if (useUtoopack && mode !== "demo-index" && ((_a = loaderContext.fs) == null ? void 0 : _a.readFile)) {
+    return (file) => new Promise((resolve, reject) => {
+      loaderContext.fs.readFile(
+        file,
+        (err, data) => {
+          if (err)
+            reject(err);
+          else
+            resolve(
+              Buffer.isBuffer(data) ? data.toString("utf-8") : String(data)
+            );
+        }
+      );
+    });
+  }
+  return readDependencyFromFs;
+}
+function getMdTransformDepsHint(cache, key) {
+  const hint = getMdLoaderCacheSync(
+    cache,
+    key,
+    void 0
+  );
+  return (hint == null ? void 0 : hint.version) === 1 ? normalizeDeps(hint.deps) : void 0;
+}
 var deferrer = {};
-var depsMapping = {};
 function mdLoader(content) {
   var _a, _b, _c;
   let opts = this.getOptions();
   const loaderContextPath = opts[import_utoopackLoaders.UTOOPACK_LOADER_CTX_KEY];
-  const useUtoopackDemoHMR = process.env.NODE_ENV !== "production" && Boolean(loaderContextPath);
+  const useUtoopackDemoHMR = opts.useUtoopackDemoHMR === true && Boolean(loaderContextPath);
   if (loaderContextPath) {
     const ctx = require(loaderContextPath);
     if (!((_a = opts.techStacks) == null ? void 0 : _a.length)) {
@@ -403,47 +602,119 @@ function mdLoader(content) {
   )) {
     this.cacheable(false);
   }
-  const cache = (0, import_utils.getCache)("md-loader");
-  const baseCacheKey = [
-    this.resourcePath,
-    (0, import_utils.getContentHash)(content),
+  const cacheEpoch = opts.cacheEpoch;
+  const cacheNamespace = useUtoopackDemoHMR && cacheEpoch ? (0, import_utoopackLoaders.getUtoopackMdCacheNamespace)(cacheEpoch) : "md-loader";
+  const cache = (0, import_utils.getCache)(cacheNamespace, opts.cacheDirectory);
+  const depsHintCache = (0, import_utils.getCache)("md-loader-deps", opts.cacheDirectory);
+  const readDependency = createDependencyReader(
+    this,
     useUtoopackDemoHMR,
-    JSON.stringify(import_plugin_utils.lodash.omit(opts, ["mode", "builtins", "onResolveDemos"]))
-  ].join(":");
-  const cacheKey = [
-    baseCacheKey,
-    getDepsCacheKey(depsMapping[this.resourcePath])
-  ].join(":");
-  const cacheRet = getMdLoaderCacheSync(cache, cacheKey, "");
-  if (cacheRet) {
-    cb(null, emit.call(this, opts, cacheRet));
-    return;
-  } else if (cacheKey in deferrer) {
-    deferrer[cacheKey].then((res) => {
-      cb(null, emit.call(this, opts, res));
-    }).catch(cb);
-    return;
-  }
-  deferrer[cacheKey] = (0, import_transformer.default)(content, {
-    ...import_plugin_utils.lodash.omit(opts, ["mode", "builtins", "onResolveDemos"]),
-    fileAbsPath: (0, import_plugin_utils.winPath)(this.resourcePath),
-    useUtoopackDemoHMR
+    opts.mode
+  );
+  const { baseCacheKey, depsHintKey } = getMdTransformCacheKeys({
+    resourcePath: this.resourcePath,
+    content,
+    useUtoopackDemoHMR,
+    opts
   });
-  deferrer[cacheKey].then((ret) => {
-    depsMapping[this.resourcePath] = ret.meta.embeds.concat(
-      getDemoSourceFiles(ret.meta.demos)
-    );
-    const finalCacheKey = [
+  const createTransform = async () => {
+    return (0, import_transformer.default)(content, {
+      ...import_plugin_utils.lodash.omit(opts, [
+        "mode",
+        "builtins",
+        "onResolveDemos",
+        "cacheDirectory",
+        "cacheEpoch"
+      ]),
+      fileAbsPath: (0, import_plugin_utils.winPath)(this.resourcePath),
+      useUtoopackDemoHMR
+    });
+  };
+  const getTransformDeps = (ret) => normalizeDeps(ret.meta.embeds.concat(getDemoCacheFiles(ret.meta.demos)));
+  const saveDepsHint = (deps) => {
+    depsHintCache.setSync(depsHintKey, {
+      version: 1,
+      deps: normalizeDeps(deps)
+    });
+  };
+  const cacheWithPath = cache;
+  const getTransform = async () => {
+    var _a2;
+    const cached = await getValidMdLoaderCacheRecord(
+      cache,
       baseCacheKey,
-      getDepsCacheKey(depsMapping[this.resourcePath])
-    ].join(":");
-    cache.setSync(finalCacheKey, ret);
-    cb(null, emit.call(this, opts, ret));
-    delete deferrer[cacheKey];
-  }).catch(cb);
+      readDependency
+    );
+    if (cached)
+      return cached;
+    const initialDeps = getMdTransformDepsHint(depsHintCache, depsHintKey) ?? ((_a2 = getMdLoaderCacheRecord(cache, baseCacheKey)) == null ? void 0 : _a2.deps);
+    const depsFingerprint = initialDeps ? await getDepsCacheKey(initialDeps, readDependency) : "<discover>";
+    const deferrerKey = [cacheNamespace, baseCacheKey, depsFingerprint].join(
+      ":"
+    );
+    if (deferrerKey in deferrer)
+      return deferrer[deferrerKey];
+    const createRecord = async () => {
+      if (useUtoopackDemoHMR) {
+        return createStableTransform({
+          initialDeps,
+          createValue: createTransform,
+          getDeps: getTransformDeps,
+          readDependency,
+          onDepsDiscovered: saveDepsHint
+        });
+      }
+      const result = await createTransform();
+      const deps = getTransformDeps(result);
+      const record = {
+        version: 2,
+        deps,
+        depsKey: await getDepsCacheKey(deps),
+        result
+      };
+      saveDepsHint(deps);
+      return record;
+    };
+    const saveRecord = (record) => {
+      cache.setSync(baseCacheKey, record);
+      saveDepsHint(record.deps);
+    };
+    const pending = useUtoopackDemoHMR && cacheWithPath.path ? (0, import_sharedCache.getOrCreateWithFileLock)({
+      lockPath: `${cacheWithPath.path(`transform:${baseCacheKey}`)}.lock`,
+      getValue: () => getValidMdLoaderCacheRecord(cache, baseCacheKey, readDependency),
+      createValue: createRecord,
+      setValue: saveRecord
+    }) : (async () => {
+      const current = await getValidMdLoaderCacheRecord(
+        cache,
+        baseCacheKey,
+        readDependency
+      );
+      if (current)
+        return current;
+      const created = await createRecord();
+      saveRecord(created);
+      return created;
+    })();
+    deferrer[deferrerKey] = pending;
+    try {
+      return await pending;
+    } finally {
+      if (deferrer[deferrerKey] === pending)
+        delete deferrer[deferrerKey];
+    }
+  };
+  getTransform().then((record) => cb(null, emit.call(this, opts, record.result))).catch(cb);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  addDemoFileDependency,
+  createDependencyReader,
+  createStableTransform,
+  emitDemo,
   getDemoSourceFiles,
-  getMdLoaderCacheSync
+  getDepsCacheKey,
+  getMdLoaderCacheResult,
+  getMdLoaderCacheSync,
+  getMdTransformCacheKeys
 });

package/dist/loaders/markdown/sharedCache.d.ts

@@ -0,0 +1,11 @@
+interface ISharedCacheOptions<T> {
+    lockPath: string;
+    getValue: () => T | undefined | Promise<T | undefined>;
+    createValue: () => Promise<T>;
+    setValue: (value: T) => void;
+    retryMs?: number;
+    staleMs?: number;
+    lockTimeoutMs?: number;
+}
+export declare function getOrCreateWithFileLock<T>({ lockPath, getValue, createValue, setValue, retryMs, staleMs, lockTimeoutMs, }: ISharedCacheOptions<T>): Promise<T>;
+export {};

package/dist/loaders/markdown/sharedCache.js

@@ -0,0 +1,131 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/loaders/markdown/sharedCache.ts
+var sharedCache_exports = {};
+__export(sharedCache_exports, {
+  getOrCreateWithFileLock: () => getOrCreateWithFileLock
+});
+module.exports = __toCommonJS(sharedCache_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_proper_lockfile = require("proper-lockfile");
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+async function acquireFileLock(lockPath, retryMs, staleMs, lockTimeoutMs, onCompromised) {
+  const deadline = Date.now() + lockTimeoutMs;
+  while (true) {
+    try {
+      return await (0, import_proper_lockfile.lock)(lockPath, {
+        lockfilePath: lockPath,
+        onCompromised,
+        realpath: false,
+        stale: staleMs,
+        update: Math.min(10 * 1e3, staleMs / 2)
+      });
+    } catch (err) {
+      if ((err == null ? void 0 : err.code) !== "ELOCKED")
+        throw err;
+      if (Date.now() >= deadline) {
+        throw Object.assign(
+          new Error(`Timed out waiting for cache lock: ${lockPath}`),
+          { cause: err, code: "ELOCKTIMEOUT" }
+        );
+      }
+      await delay(retryMs + Math.floor(Math.random() * retryMs));
+    }
+  }
+}
+async function getOrCreateWithFileLock({
+  lockPath,
+  getValue,
+  createValue,
+  setValue,
+  retryMs = 20,
+  staleMs = 5 * 60 * 1e3,
+  lockTimeoutMs = 10 * 60 * 1e3
+}) {
+  const cached = await getValue();
+  if (cached !== void 0)
+    return cached;
+  import_fs.default.mkdirSync(import_path.default.dirname(lockPath), { recursive: true });
+  let compromisedError;
+  const release = await acquireFileLock(
+    lockPath,
+    retryMs,
+    staleMs,
+    lockTimeoutMs,
+    (err) => {
+      compromisedError = err;
+    }
+  );
+  let result;
+  let operationError;
+  let hasOperationError = false;
+  try {
+    const lockedCache = await getValue();
+    if (lockedCache === void 0) {
+      const created = await createValue();
+      if (compromisedError)
+        throw compromisedError;
+      setValue(created);
+      result = created;
+    } else {
+      result = lockedCache;
+    }
+  } catch (err) {
+    operationError = err;
+    hasOperationError = true;
+  }
+  let releaseError;
+  let hasReleaseError = false;
+  try {
+    await release();
+  } catch (err) {
+    if (!compromisedError || (err == null ? void 0 : err.code) !== "ERELEASED") {
+      releaseError = err;
+      hasReleaseError = true;
+    }
+  }
+  if (compromisedError && !hasOperationError) {
+    operationError = compromisedError;
+    hasOperationError = true;
+  }
+  if (hasOperationError)
+    throw operationError;
+  if (hasReleaseError)
+    throw releaseError;
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getOrCreateWithFileLock
+});

package/dist/loaders/markdown/transformer/index.d.ts

@@ -1,4 +1,5 @@
 import type { IParsedBlockAsset } from '../../../assetParsers/block';
+import type { IDumiDemoProps } from '@/client/theme-api/DumiDemo';
 import type { ILocalesConfig, IRouteMeta } from '@/client/theme-api/types';
 import type { IApi, IDumiConfig, IDumiTechStack } from '../../../types';
 import { type ResolveOptions } from 'enhanced-resolve';
@@ -23,6 +24,9 @@ declare module 'vfile' {
             component: string;
             asset: IParsedBlockAsset['asset'];
             resolveMap: IParsedBlockAsset['resolveMap'];
+            previewerProps?: IDumiDemoProps['previewerProps'];
+            /** Internal semantic version used by the utoopack demo HMR runtime. */
+            __dumiUtoopackHMRVersion?: string;
             renderOpts: {
                 type?: string;
                 rendererPath?: string;