modern-monaco 0.2.0 → 0.2.2

package/dist/lsp/json/setup.mjs

@@ -111,7 +111,8 @@ var schemas = [
 ];
 
 // src/lsp/json/setup.ts
-import * as ls from "../language-service.mjs";
+import { walk } from "../../workspace.mjs";
+import * as client from "../client.mjs";
 async function setup(monaco, languageId, languageSettings, formattingOptions, workspace) {
   const { editor, languages } = monaco;
   const createData = {
@@ -132,11 +133,11 @@ async function setup(monaco, languageId, languageSettings, formattingOptions, wo
       trimFinalNewlines: true,
       ...formattingOptions
     },
-    workspace: !!workspace
+    fs: workspace ? await walk(workspace.fs, "/") : void 0
   };
   const worker = editor.createWebWorker({
     worker: getWorker(createData),
-    host: ls.createHost(workspace)
+    host: client.createHost(workspace)
   });
   const resetSchema = async (uri) => {
     (await worker.getProxy()).resetSchema(uri.toString());
@@ -151,9 +152,9 @@ async function setup(monaco, languageId, languageSettings, formattingOptions, wo
       resetSchema(event.model.uri);
     }
   });
-  ls.registerBasicFeatures(languageId, worker, [" ", ":", '"'], workspace);
-  ls.registerColorPresentation(languageId, worker);
-  ls.registerDocumentLinks(languageId, worker);
+  client.registerBasicFeatures(languageId, worker, [" ", ":", '"'], workspace);
+  client.registerColorPresentation(languageId, worker);
+  client.registerDocumentLinks(languageId, worker);
   languages.registerCodeLensProvider(languageId, {
     provideCodeLenses: function(model, _token) {
       const isImportMap = model.uri.scheme == "file" && ["importmap.json", "import_map.json", "import-map.json", "importMap.json"].some((name) => model.uri.path === "/" + name);
@@ -249,10 +250,10 @@ function createWebWorker() {
   if (workerUrl.origin !== location.origin) {
     return new Worker(
       URL.createObjectURL(new Blob([`import "${workerUrl.href}"`], { type: "application/javascript" })),
-      { type: "module" }
+      { type: "module", name: "json-worker" }
     );
   }
-  return new Worker(new URL("./worker.mjs", import.meta.url), { type: "module" });
+  return new Worker(workerUrl, { type: "module", name: "json-worker" });
 }
 function getWorker(createData) {
   const worker = createWebWorker();

package/dist/lsp/json/worker.mjs

@@ -7682,21 +7682,36 @@ function getLanguageService(params) {
 
 // src/lsp/worker-base.ts
 var WorkerBase = class {
-  constructor(_ctx, _createData, _createLanguageDocument) {
-    this._ctx = _ctx;
-    this._createData = _createData;
-    this._createLanguageDocument = _createLanguageDocument;
-  }
-  #documentCache = /* @__PURE__ */ new Map();
+  #ctx;
   #fs;
+  #documentCache = /* @__PURE__ */ new Map();
+  #createLanguageDocument;
+  constructor(ctx, createData, createLanguageDocument) {
+    this.#ctx = ctx;
+    if (createData.fs) {
+      const dirs = /* @__PURE__ */ new Set(["/"]);
+      this.#fs = new Map(createData.fs.map((path) => {
+        const dir = path.slice(0, path.lastIndexOf("/"));
+        if (dir) {
+          dirs.add(dir);
+        }
+        return ["file://" + path, 1];
+      }));
+      for (const dir of dirs) {
+        this.#fs.set("file://" + dir, 2);
+      }
+      createData.fs.length = 0;
+    }
+    this.#createLanguageDocument = createLanguageDocument;
+  }
   get hasFileSystemProvider() {
-    return !!this._createData.workspace;
+    return !!this.#fs;
   }
   get host() {
-    return this._ctx.host;
+    return this.#ctx.host;
   }
   getMirrorModels() {
-    return this._ctx.getMirrorModels();
+    return this.#ctx.getMirrorModels();
   }
   hasModel(fileName) {
     const models = this.getMirrorModels();
@@ -7737,10 +7752,10 @@ var WorkerBase = class {
     if (cached && cached[0] === version && cached[2]) {
       return cached[2];
     }
-    if (!this._createLanguageDocument) {
+    if (!this.#createLanguageDocument) {
       throw new Error("createLanguageDocument is not provided");
     }
-    const languageDocument = this._createLanguageDocument(document);
+    const languageDocument = this.#createLanguageDocument(document);
     this.#documentCache.set(uri, [version, document, languageDocument]);
     return languageDocument;
   }
@@ -7751,10 +7766,12 @@ var WorkerBase = class {
         if (path.startsWith(uri)) {
           const name = path.slice(uri.length);
           if (!name.includes("/")) {
-            if (type === 2) {
-              entries.push([name, 2 /* Directory */]);
-            } else if (!extensions || extensions.some((ext) => name.endsWith(ext))) {
-              entries.push([name, 1 /* File */]);
+            if (type === 1) {
+              if (!extensions || extensions.some((ext) => name.endsWith(ext))) {
+                entries.push([name, 1]);
+              }
+            } else if (type === 2) {
+              entries.push([name, 2]);
             }
           }
         }
@@ -7763,8 +7780,8 @@ var WorkerBase = class {
     return entries;
   }
   getFileSystemProvider() {
-    if (this.hasFileSystemProvider) {
-      const host = this._ctx.host;
+    if (this.#fs) {
+      const host = this.#ctx.host;
       return {
         readDirectory: (uri) => {
           return Promise.resolve(this.readDir(uri));
@@ -7781,29 +7798,27 @@ var WorkerBase = class {
   }
   // resolveReference implementes the `DocumentContext` interface
   resolveReference(ref, baseUrl) {
-    const url = new URL(ref, baseUrl);
-    const href = url.href;
-    if (url.protocol === "file:" && url.pathname !== "/" && this.#fs && !this.#fs.has(href.endsWith("/") ? href.slice(0, -1) : href)) {
+    const { protocol, pathname, href } = new URL(ref, baseUrl);
+    if (protocol === "file:" && pathname !== "/" && this.#fs && !this.#fs.has(href.endsWith("/") ? href.slice(0, -1) : href)) {
       return void 0;
     }
     return href;
   }
   // #region methods used by the host
-  async removeDocumentCache(uri) {
+  async releaseDocument(uri) {
     this.#documentCache.delete(uri);
   }
   async fsNotify(kind, path, type) {
-    const url = "file://" + path;
-    const entries = this.#fs ?? (this.#fs = /* @__PURE__ */ new Map());
+    const fs = this.#fs ?? (this.#fs = /* @__PURE__ */ new Map());
     if (kind === "create") {
       if (type) {
-        entries.set(url, type);
+        fs.set(path, type);
       }
     } else if (kind === "remove") {
-      if (entries.get(url) === 1 /* File */) {
-        this.#documentCache.delete(url);
+      if (fs.get(path) === 1) {
+        this.#documentCache.delete(path);
       }
-      entries.delete(url);
+      fs.delete(path);
     }
   }
   // #endregion

package/dist/lsp/typescript/setup.mjs

@@ -95,8 +95,8 @@ function isSameImports(a, b) {
 
 // src/lsp/typescript/setup.ts
 import { cache } from "../../cache.mjs";
-import { ErrorNotFound } from "../../workspace.mjs";
-import * as ls from "../language-service.mjs";
+import { ErrorNotFound, walk } from "../../workspace.mjs";
+import * as client from "../client.mjs";
 var worker = null;
 async function setup(monaco, languageId, languageSettings, formattingOptions, workspace) {
   if (!worker) {
@@ -105,10 +105,10 @@ async function setup(monaco, languageId, languageSettings, formattingOptions, wo
   if (worker instanceof Promise) {
     worker = await worker;
   }
-  ls.registerBasicFeatures(languageId, worker, [".", "/", '"', "'", "<"], workspace);
-  ls.registerAutoComplete(languageId, worker, [">", "/"]);
-  ls.registerSignatureHelp(languageId, worker, ["(", ","]);
-  ls.registerCodeAction(languageId, worker);
+  client.registerBasicFeatures(languageId, worker, [".", "/", '"', "'", "<"], workspace);
+  client.registerAutoComplete(languageId, worker, [">", "/"]);
+  client.registerSignatureHelp(languageId, worker, ["(", ","]);
+  client.registerCodeAction(languageId, worker);
 }
 async function createWorker(monaco, workspace, languageSettings, formattingOptions) {
   const fs = workspace?.fs;
@@ -168,7 +168,7 @@ async function createWorker(monaco, workspace, languageSettings, formattingOptio
     },
     importMap,
     types: typesStore.types,
-    workspace: !!workspace
+    fs: workspace ? await walk(workspace.fs, "/") : void 0
   };
   const worker2 = monaco.editor.createWebWorker({
     worker: getWorker(createData),
@@ -282,10 +282,10 @@ function createWebWorker() {
   if (workerUrl.origin !== location.origin) {
     return new Worker(
       URL.createObjectURL(new Blob([`import "${workerUrl.href}"`], { type: "application/javascript" })),
-      { type: "module" }
+      { type: "module", name: "typescript-worker" }
     );
   }
-  return new Worker(new URL("./worker.mjs", import.meta.url), { type: "module" });
+  return new Worker(workerUrl, { type: "module", name: "typescript-worker" });
 }
 function getWorker(createData) {
   const worker2 = createWebWorker();

package/dist/lsp/typescript/worker.mjs

@@ -1466,21 +1466,36 @@ function getWellformedEdit(textEdit) {
 
 // src/lsp/worker-base.ts
 var WorkerBase = class {
-  constructor(_ctx, _createData, _createLanguageDocument) {
-    this._ctx = _ctx;
-    this._createData = _createData;
-    this._createLanguageDocument = _createLanguageDocument;
-  }
-  #documentCache = /* @__PURE__ */ new Map();
+  #ctx;
   #fs;
+  #documentCache = /* @__PURE__ */ new Map();
+  #createLanguageDocument;
+  constructor(ctx, createData, createLanguageDocument) {
+    this.#ctx = ctx;
+    if (createData.fs) {
+      const dirs = /* @__PURE__ */ new Set(["/"]);
+      this.#fs = new Map(createData.fs.map((path) => {
+        const dir = path.slice(0, path.lastIndexOf("/"));
+        if (dir) {
+          dirs.add(dir);
+        }
+        return ["file://" + path, 1];
+      }));
+      for (const dir of dirs) {
+        this.#fs.set("file://" + dir, 2);
+      }
+      createData.fs.length = 0;
+    }
+    this.#createLanguageDocument = createLanguageDocument;
+  }
   get hasFileSystemProvider() {
-    return !!this._createData.workspace;
+    return !!this.#fs;
   }
   get host() {
-    return this._ctx.host;
+    return this.#ctx.host;
   }
   getMirrorModels() {
-    return this._ctx.getMirrorModels();
+    return this.#ctx.getMirrorModels();
   }
   hasModel(fileName) {
     const models = this.getMirrorModels();
@@ -1521,10 +1536,10 @@ var WorkerBase = class {
     if (cached && cached[0] === version && cached[2]) {
       return cached[2];
     }
-    if (!this._createLanguageDocument) {
+    if (!this.#createLanguageDocument) {
       throw new Error("createLanguageDocument is not provided");
     }
-    const languageDocument = this._createLanguageDocument(document2);
+    const languageDocument = this.#createLanguageDocument(document2);
     this.#documentCache.set(uri, [version, document2, languageDocument]);
     return languageDocument;
   }
@@ -1535,10 +1550,12 @@ var WorkerBase = class {
         if (path.startsWith(uri)) {
           const name = path.slice(uri.length);
           if (!name.includes("/")) {
-            if (type === 2) {
-              entries.push([name, 2 /* Directory */]);
-            } else if (!extensions || extensions.some((ext) => name.endsWith(ext))) {
-              entries.push([name, 1 /* File */]);
+            if (type === 1) {
+              if (!extensions || extensions.some((ext) => name.endsWith(ext))) {
+                entries.push([name, 1]);
+              }
+            } else if (type === 2) {
+              entries.push([name, 2]);
             }
           }
         }
@@ -1547,8 +1564,8 @@ var WorkerBase = class {
     return entries;
   }
   getFileSystemProvider() {
-    if (this.hasFileSystemProvider) {
-      const host = this._ctx.host;
+    if (this.#fs) {
+      const host = this.#ctx.host;
       return {
         readDirectory: (uri) => {
           return Promise.resolve(this.readDir(uri));
@@ -1565,29 +1582,27 @@ var WorkerBase = class {
   }
   // resolveReference implementes the `DocumentContext` interface
   resolveReference(ref, baseUrl) {
-    const url = new URL(ref, baseUrl);
-    const href = url.href;
-    if (url.protocol === "file:" && url.pathname !== "/" && this.#fs && !this.#fs.has(href.endsWith("/") ? href.slice(0, -1) : href)) {
+    const { protocol, pathname, href } = new URL(ref, baseUrl);
+    if (protocol === "file:" && pathname !== "/" && this.#fs && !this.#fs.has(href.endsWith("/") ? href.slice(0, -1) : href)) {
       return void 0;
     }
     return href;
   }
   // #region methods used by the host
-  async removeDocumentCache(uri) {
+  async releaseDocument(uri) {
     this.#documentCache.delete(uri);
   }
   async fsNotify(kind, path, type) {
-    const url = "file://" + path;
-    const entries = this.#fs ?? (this.#fs = /* @__PURE__ */ new Map());
+    const fs = this.#fs ?? (this.#fs = /* @__PURE__ */ new Map());
     if (kind === "create") {
       if (type) {
-        entries.set(url, type);
+        fs.set(path, type);
       }
     } else if (kind === "remove") {
-      if (entries.get(url) === 1 /* File */) {
-        this.#documentCache.delete(url);
+      if (fs.get(path) === 1) {
+        this.#documentCache.delete(path);
       }
-      entries.delete(url);
+      fs.delete(path);
     }
   }
   // #endregion
@@ -1639,14 +1654,14 @@ var TypeScriptWorker = class extends WorkerBase {
       const dirname = path.slice("file:///node_modules/".length);
       return Object.keys(this.#importMap.imports).filter((key) => key !== "@jsxRuntime" && (dirname.length === 0 || key.startsWith(dirname))).map((key) => dirname.length > 0 ? key.slice(dirname.length) : key).filter((key) => key !== "/" && key.includes("/")).map((key) => key.split("/")[0]);
     }
-    return this.readDir(path).filter(([_, type]) => type === 2 /* Directory */).map(([name, _]) => name);
+    return this.readDir(path).filter(([_, type]) => type === 2).map(([name, _]) => name);
   }
   readDirectory(path, extensions, exclude, include, depth) {
     if (path.startsWith("file:///node_modules/")) {
       const dirname = path.slice("file:///node_modules/".length);
       return Object.keys(this.#importMap.imports).filter((key) => key !== "@jsxRuntime" && (dirname.length === 0 || key.startsWith(dirname))).map((key) => dirname.length > 0 ? key.slice(dirname.length) : key).filter((key) => !key.includes("/"));
     }
-    return this.readDir(path, extensions).filter(([_, type]) => type === 1 /* File */).map(([name, _]) => name);
+    return this.readDir(path, extensions).filter(([_, type]) => type === 1).map(([name, _]) => name);
   }
   fileExists(filename) {
     if (filename.startsWith("/node_modules/")) return false;
@@ -2298,7 +2313,7 @@ var TypeScriptWorker = class extends WorkerBase {
     if (types) {
       for (const uri of Object.keys(this.#types)) {
         if (!(uri in types)) {
-          this.removeDocumentCache(uri);
+          this.releaseDocument(uri);
         }
       }
       this.#types = types;

package/dist/shiki.mjs

@@ -7917,7 +7917,7 @@ function hashCode(s) {
   return [...s].reduce((hash, c) => Math.imul(31, hash) + c.charCodeAt(0) | 0, 0);
 }
 function normalizeFontFamily(fontFamily) {
-  return fontFamily.split(",").map((f) => f.replace(/['"]+/g, "").trim()).filter(Boolean).map((f) => f.includes(" ") ? `'${f}'` : f).join(", ");
+  return fontFamily.split(",").map((f) => f.trim().replace(/['"]+/g, "")).filter(Boolean).map((f) => f.includes(" ") ? `'${f}'` : f).join(", ");
 }
 
 // src/shiki-monaco.ts
@@ -8117,7 +8117,7 @@ function loadTMTheme(src, cdn = "https://esm.sh") {
     return cache.fetch(url2).then((res) => res.json());
   }
   const url = typeof src === "string" ? new URL(src, globalThis.location?.href) : src;
-  if (url.protocol === "http" || url.protocol === "https") {
+  if (url.protocol === "http:" || url.protocol === "https:") {
     return cache.fetch(url).then((res) => res.json());
   }
   throw new Error(`Unsupported theme source: ${src}`);
@@ -8131,7 +8131,7 @@ function loadTMGrammar(src, cdn = "https://esm.sh") {
     }
   }
   const url = typeof src === "string" ? new URL(src, globalThis.location?.href) : src;
-  if (url.protocol === "http" || url.protocol === "https") {
+  if (url.protocol === "http:" || url.protocol === "https:") {
     return cache.fetch(url).then((res) => res.json());
   }
   throw new Error(`Unsupported grammar source: ${src}`);

package/dist/util.mjs

@@ -10,7 +10,7 @@ function decode(data) {
 function defineProperty(obj, prop, value) {
   Object.defineProperty(obj, prop, { value });
 }
-function toURL(uri) {
+function normalizeURL(uri) {
   return uri instanceof URL ? uri : new URL(uri, "file:///");
 }
 function filenameToURL(filename) {
@@ -131,10 +131,10 @@ function promisifyIDBRequest(req) {
   });
 }
 async function openIDB(name, version = 1, ...stores) {
-  const req = indexedDB.open(name, version);
+  const openRequest = indexedDB.open(name, version);
   const promises = [];
-  req.onupgradeneeded = () => {
-    const db2 = req.result;
+  openRequest.onupgradeneeded = () => {
+    const db2 = openRequest.result;
     for (const { name: name2, keyPath, onCreate } of stores) {
       if (!db2.objectStoreNames.contains(name2)) {
         const store = db2.createObjectStore(name2, { keyPath });
@@ -144,15 +144,15 @@ async function openIDB(name, version = 1, ...stores) {
       }
     }
   };
-  const db = await promisifyIDBRequest(req);
+  const db = await promisifyIDBRequest(openRequest);
   await Promise.all(promises);
   return db;
 }
 function openIDBCursor(store, range, callback, direction) {
   return new Promise((resolve, reject) => {
-    const ocr = store.openCursor(range, direction);
-    ocr.onsuccess = () => {
-      const cursor = ocr.result;
+    const corsor = store.openCursor(range, direction);
+    corsor.onsuccess = () => {
+      const cursor = corsor.result;
       if (cursor) {
         if (callback(cursor) !== false) {
           cursor.continue();
@@ -161,12 +161,15 @@ function openIDBCursor(store, range, callback, direction) {
       }
       resolve();
     };
-    ocr.onerror = () => {
-      reject(ocr.error);
+    corsor.onerror = () => {
+      reject(corsor.error);
     };
   });
 }
 function promiseWithResolvers() {
+  if (Promise.withResolvers) {
+    return Promise.withResolvers();
+  }
   let resolve;
   let reject;
   const promise = new Promise((res, rej) => {
@@ -187,10 +190,10 @@ export {
   filenameToURL,
   isDigital,
   isPlainObject,
+  normalizeURL,
   openIDB,
   openIDBCursor,
   promiseWithResolvers,
   promisifyIDBRequest,
-  supportLocalStorage,
-  toURL
+  supportLocalStorage
 };

package/dist/workspace.mjs

@@ -5,12 +5,12 @@ import {
   decode,
   encode,
   filenameToURL,
+  normalizeURL,
   openIDB,
   openIDBCursor,
   promiseWithResolvers,
   promisifyIDBRequest,
-  supportLocalStorage,
-  toURL
+  supportLocalStorage
 } from "./util.mjs";
 var Workspace = class {
   _monaco;
@@ -21,14 +21,14 @@ var Workspace = class {
   constructor(options = {}) {
     const { name = "default", browserHistory, initialFiles, entryFile, customFS } = options;
     this._monaco = promiseWithResolvers();
-    this._fs = customFS ?? new FS("modern-monaco-workspace(" + name + ")");
+    this._fs = customFS ?? new IndexedDBFileSystem("modern-monaco-workspace(" + name + ")");
     this._viewState = new WorkspaceStateStorage("modern-monaco-state(" + name + ")");
     this._entryFile = entryFile;
     if (initialFiles) {
       for (const [name2, data] of Object.entries(initialFiles)) {
         void this._fs.stat(name2).catch(async (err) => {
           if (err instanceof ErrorNotFound) {
-            const { pathname, href: url } = filenameToURL(name2);
+            const { pathname } = filenameToURL(name2);
             const dir = pathname.slice(0, pathname.lastIndexOf("/"));
             if (dir) {
               await this._fs.createDirectory(dir);
@@ -68,11 +68,10 @@ var Workspace = class {
     const monaco = await this._monaco.promise;
     return this._openTextDocument(uri, monaco.editor.getEditors()[0], void 0, content);
   }
-  // @internal
   async _openTextDocument(uri, editor, selectionOrPosition, readonlyContent) {
     const monaco = await this._monaco.promise;
     const fs = this._fs;
-    const href = toURL(uri).href;
+    const href = normalizeURL(uri).href;
     const content = readonlyContent ?? await fs.readTextFile(href);
     const viewState = await this.viewState.get(href);
     const modelUri = monaco.Uri.parse(href);
@@ -137,7 +136,7 @@ var Workspace = class {
     return monaco.showQuickPick(items, options, token);
   }
 };
-var FS = class {
+var IndexedDBFileSystem = class {
   _watchers = /* @__PURE__ */ new Set();
   _db;
   constructor(scope) {
@@ -155,13 +154,6 @@ var FS = class {
     const transaction = (await this._db.open()).transaction(["fs-meta", "fs-blob"], readwrite ? "readwrite" : "readonly");
     return [transaction.objectStore("fs-meta"), transaction.objectStore("fs-blob")];
   }
-  async *walk() {
-    const metaStore = await this._getIdbObjectStore("fs-meta");
-    const entries = await promisifyIDBRequest(metaStore.getAll());
-    for (const entry of entries) {
-      yield [new URL(entry.url).pathname, entry.type];
-    }
-  }
   async stat(name) {
     const url = filenameToURL(name).href;
     if (url === "file:///") {
@@ -428,6 +420,18 @@ var ErrorNotFound = class extends Error {
     super("No such file or directory: " + name);
   }
 };
+async function walk(fs, dir = "/") {
+  const entries = [];
+  for (const [name, type] of await fs.readDirectory(dir || "/")) {
+    const path = (dir.endsWith("/") ? dir.slice(0, -1) : dir) + "/" + name;
+    if (type === 2) {
+      entries.push(...await walk(fs, path));
+    } else {
+      entries.push(path);
+    }
+  }
+  return entries;
+}
 var WorkspaceDatabase = class {
   _db;
   constructor(name, ...stores) {
@@ -455,12 +459,12 @@ var WorkspaceStateStorage = class {
     );
   }
   async get(uri) {
-    const url = toURL(uri).href;
+    const url = normalizeURL(uri).href;
     const store = (await this.#db.open()).transaction("store", "readonly").objectStore("store");
     return promisifyIDBRequest(store.get(url)).then((result) => result?.state);
   }
   async save(uri, state) {
-    const url = toURL(uri).href;
+    const url = normalizeURL(uri).href;
     const store = (await this.#db.open()).transaction("store", "readwrite").objectStore("store");
     await promisifyIDBRequest(store.put({ url, state }));
   }
@@ -584,5 +588,6 @@ var BrowserHistory = class {
 };
 export {
   ErrorNotFound,
-  Workspace
+  Workspace,
+  walk
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modern-monaco",
   "description": "A modern version of Monaco Editor",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
@@ -31,6 +31,9 @@
     "./editor-worker": {
       "import": "./dist/editor-worker.mjs"
     },
+    "./editor-worker-main": {
+      "import": "./dist/editor-worker-main.mjs"
+    },
     "./cache": {
       "import": "./dist/cache.mjs"
     },
@@ -40,6 +43,9 @@
     "./util": {
       "import": "./dist/util.mjs"
     },
+    "./lsp": {
+      "import": "./dist/lsp/index.mjs"
+    },
     "./lsp/*": {
       "import": "./dist/lsp/*.mjs"
     }

package/types/workspace.d.ts

@@ -43,9 +43,23 @@ export interface WorkspaceHistory {
   onChange(callback: (state: WorkspaceHistoryState) => void): () => void;
 }
 
-/** 0: unknown, 1: file, 2: directory, 64: symlink */
+/**
+ * The type of a file system entry.
+ * - `0`: unknown
+ * - `1`: file
+ * - `2`: directory
+ * - `64`: symlink
+ */
 export type FileSystemEntryType = 0 | 1 | 2 | 64;
 
+export interface FileSystemWatchContext {
+  isModelContentChange?: boolean;
+}
+
+export interface FileSystemWatchHandle {
+  (kind: "create" | "modify" | "remove", filename: string, type?: number, context?: FileSystemWatchContext): void;
+}
+
 export interface FileStat {
   readonly type: FileSystemEntryType;
   readonly ctime: number;
@@ -63,14 +77,9 @@ export interface FileSystem {
   readTextFile(filename: string): Promise<string>;
   rename(oldName: string, newName: string, options?: { overwrite: boolean }): Promise<void>;
   stat(filename: string): Promise<FileStat>;
-  writeFile(filename: string, content: string | Uint8Array, context?: { isModelContentChange: boolean }): Promise<void>;
+  writeFile(filename: string, content: string | Uint8Array, context?: FileSystemWatchContext): Promise<void>;
   watch(filename: string, options: { recursive: boolean }, handle: FileSystemWatchHandle): () => void;
   watch(filename: string, handle: FileSystemWatchHandle): () => void;
-  walk(): AsyncIterable<[string, FileSystemEntryType]>;
-}
-
-export interface FileSystemWatchHandle {
-  (kind: "create" | "modify" | "remove", filename: string, type?: number, context?: { isModelContentChange: boolean }): void;
 }
 
 export class ErrorNotFound extends Error {}