@spyglassmc/core 0.4.46 → 0.4.48

package/lib/common/util.js

@@ -146,8 +146,8 @@ export function promisifyAsyncIterable(iterable, joiner) {
         return joiner(chunks);
     })();
 }
-export async function parseGzippedJson(externals, buffer) {
-    return JSON.parse(bufferToString(await externals.archive.gunzip(buffer)));
+export async function parseGzippedJson(bytes) {
+    return JSON.parse(bufferToString(await decompressBytes(bytes, 'gzip')));
 }
 /**
  * @returns Is Plain Old JavaScript Object (POJO).
@@ -218,26 +218,33 @@ export function isIterable(value) {
     return !!value[Symbol.iterator];
 }
 // #region ESNext functions polyfill
-export function atArray(array, index) {
-    return index >= 0 ? array?.[index] : array?.[array.length + index];
+export function getOrInsert(map, key, defaultValue) {
+    if (!map.has(key)) {
+        map.set(key, defaultValue);
+    }
+    return map.get(key);
 }
-export function emplaceMap(map, key, handler) {
-    if (map.has(key)) {
-        let value = map.get(key);
-        if (handler.update) {
-            value = handler.update(value, key, map);
-            map.set(key, value);
-        }
-        return value;
+export function getOrInsertComputed(map, key, callbackFunction) {
+    if (!map.has(key)) {
+        map.set(key, callbackFunction(key));
+    }
+    return map.get(key);
+}
+/**
+ * TODO: replace with ESNext Uint8Array.prototype.toHex once it's widely supported
+ */
+export function bytesToHex(bytes) {
+    if ('Buffer' in globalThis && bytes instanceof Buffer) {
+        return bytes.toString('hex');
     }
-    else if (handler.insert) {
-        const value = handler.insert(key, map);
-        map.set(key, value);
-        return value;
+    else if ('toHex' in Uint8Array.prototype && typeof Uint8Array.prototype.toHex === 'function') {
+        return Uint8Array.prototype.toHex.call(bytes);
     }
-    else {
-        throw new Error(`No key ${key} in map and no insert handler provided`);
+    let ans = '';
+    for (const v of bytes) {
+        ans += v.toString(16).padStart(2, '0');
     }
+    return ans;
 }
 // #endregion
 /**
@@ -267,6 +274,34 @@ export function normalizeUri(uri) {
     obj.pathname = normalizeUriPathname(obj.pathname);
     return obj.toString();
 }
+export async function getSha1(data) {
+    if (typeof data === 'string') {
+        data = new TextEncoder().encode(data);
+    }
+    const hash = await crypto.subtle.digest('SHA-1', data.buffer);
+    return bytesToHex(new Uint8Array(hash));
+}
+export function compressBytes(bytes, algorithm) {
+    return streamToBytes(compressStream(bytesToStream(bytes), algorithm));
+}
+export function compressStream(stream, algorithm) {
+    return stream.pipeThrough(new CompressionStream(algorithm));
+}
+export function decompressBytes(bytes, algorithm) {
+    return streamToBytes(decompressStream(bytesToStream(bytes), algorithm));
+}
+export function decompressStream(stream, algorithm) {
+    return stream.pipeThrough(new DecompressionStream(algorithm));
+}
+export function bytesToStream(bytes) {
+    return new Blob([bytes]).stream();
+}
+export function streamToBytes(stream) {
+    return new Response(stream).bytes();
+}
+export function sleep(delayMs) {
+    return new Promise(resolve => setTimeout(resolve, delayMs));
+}
 /**
  * Checks if the numeric value of a number or bigint is the same. Undefined is **not** the same as
  * 0 for this function.

package/lib/node/StringNode.d.ts

@@ -2,7 +2,7 @@ import type { Parser } from '../parser/index.js';
 import type { ColorTokenType } from '../processor/index.js';
 import type { IndexMap, RangeLike } from '../source/index.js';
 import type { AstNode } from './AstNode.js';
-export declare const EscapeChars: readonly ["\"", "'", "\\", "b", "f", "n", "r", "s", "t"];
+export declare const EscapeChars: readonly ['"', "'", '\\', 'b', 'f', 'n', 'r', 's', 't'];
 export type EscapeChar = (typeof EscapeChars)[number];
 export declare namespace EscapeChar {
     function is(expected: EscapeChar[] | undefined, c: string): c is EscapeChar;

package/lib/parser/string.d.ts

@@ -6,11 +6,11 @@ import type { Parser, Result, Returnable } from './Parser.js';
 export declare function string(options: StringOptions): InfallibleParser<StringNode>;
 export declare function parseStringValue<T extends Returnable>(parser: Parser<T>, value: string, map: IndexMap, ctx: ParserContext): Result<T>;
 export declare const BrigadierUnquotableCharacters: readonly ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "_", ".", "+", "-"];
-export declare const BrigadierUnquotableCharacterSet: Set<"0" | "k" | "v" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "." | "e" | "E" | "i" | "p" | "-" | "+" | "a" | "b" | "c" | "d" | "f" | "g" | "h" | "j" | "l" | "m" | "n" | "o" | "q" | "r" | "s" | "t" | "u" | "w" | "x" | "y" | "z" | "_" | "A" | "B" | "C" | "D" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z">;
+export declare const BrigadierUnquotableCharacterSet: Set<"+" | "-" | "." | "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" | "_" | "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z">;
 export declare const BrigadierUnquotablePattern: RegExp;
 export declare const BrigadierUnquotableOption: {
     allowEmpty: boolean;
-    allowList: Set<"0" | "k" | "v" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "." | "e" | "E" | "i" | "p" | "-" | "+" | "a" | "b" | "c" | "d" | "f" | "g" | "h" | "j" | "l" | "m" | "n" | "o" | "q" | "r" | "s" | "t" | "u" | "w" | "x" | "y" | "z" | "_" | "A" | "B" | "C" | "D" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z">;
+    allowList: Set<"+" | "-" | "." | "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" | "_" | "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z">;
 };
 export declare const BrigadierStringOptions: StringOptions;
 export declare const brigadierString: InfallibleParser<StringNode>;

package/lib/processor/colorizer/Colorizer.d.ts

@@ -18,7 +18,7 @@ export declare namespace ColorToken {
     function fillGap(tokens: readonly ColorToken[], targetRange: Range, type: ColorTokenType, modifiers?: ColorTokenModifier[]): ColorToken[];
 }
 export declare const ColorTokenTypes: readonly ["comment", "enum", "enumMember", "escape", "function", "keyword", "modifier", "number", "property", "string", "struct", "type", "variable", "error", "literal", "operator", "resourceLocation", "vector"];
-export type ColorTokenType = typeof ColorTokenTypes[number];
+export type ColorTokenType = (typeof ColorTokenTypes)[number];
 export declare const ColorTokenModifiers: readonly ["declaration", "defaultLibrary", "definition", "deprecated", "documentation", "modification", "readonly"];
-export type ColorTokenModifier = typeof ColorTokenModifiers[number];
+export type ColorTokenModifier = (typeof ColorTokenModifiers)[number];
 //# sourceMappingURL=Colorizer.d.ts.map

package/lib/service/CacheService.js

@@ -1,4 +1,4 @@
-import { bigintJsonLosslessReplacer, bigintJsonLosslessReviver, Uri } from '../common/index.js';
+import { bigintJsonLosslessReplacer, bigintJsonLosslessReviver, getSha1, Uri, } from '../common/index.js';
 import { SymbolTable } from '../symbol/index.js';
 import { ArchiveUriSupporter } from './FileService.js';
 import { fileUtil } from './fileUtil.js';
@@ -36,7 +36,7 @@ export class CacheService {
             }
             try {
                 // TODO: Don't update this for every single change.
-                this.checksums.files[doc.uri] = await this.project.externals.crypto.getSha1(doc.getText());
+                this.checksums.files[doc.uri] = await getSha1(doc.getText());
             }
             catch (e) {
                 if (!this.project.externals.error.isKind(e, 'EISDIR')) {
@@ -72,7 +72,7 @@ export class CacheService {
     async getCacheFileUri() {
         if (!this.#cacheFilePath) {
             const sortedRoots = [...this.project.projectRoots].sort();
-            const hash = await this.project.externals.crypto.getSha1(sortedRoots.join(':'));
+            const hash = await getSha1(sortedRoots.join(':'));
             this.#cacheFilePath = new Uri(`symbols/${hash}.json.gz`, this.cacheRoot).toString();
         }
         return this.#cacheFilePath;
@@ -196,8 +196,7 @@ export class CacheService {
         return false;
     }
     async hasFileChangedSinceCache(doc) {
-        return (this.checksums.files[doc.uri]
-            !== (await this.project.externals.crypto.getSha1(doc.getText())));
+        return (this.checksums.files[doc.uri] !== (await getSha1(doc.getText())));
     }
     reset() {
         this.#hasValidatedFiles = false;

package/lib/service/Config.d.ts

@@ -1,5 +1,5 @@
-import type { DeepPartial, ExternalEventEmitter } from '../common/index.js';
-import { Arrayable } from '../common/index.js';
+import type { DeepPartial } from '../common/index.js';
+import { Arrayable, EventDispatcher } from '../common/index.js';
 import { ErrorSeverity } from '../source/index.js';
 import type { Project } from './Project.js';
 export interface Config {
@@ -239,19 +239,15 @@ type ErrorEvent = {
     error: unknown;
     uri: string;
 };
-export declare class ConfigService implements ExternalEventEmitter {
-    #private;
+export declare class ConfigService extends EventDispatcher<{
+    changed: ConfigEvent;
+    error: ErrorEvent;
+}> {
     private readonly project;
     private readonly defaultConfig;
     static readonly ConfigFileNames: readonly ["spyglass.json", ".spyglassrc", ".spyglassrc.json"];
     private currentEditorConfiguration;
     constructor(project: Project, defaultConfig?: Config);
-    on(event: 'changed', callbackFn: (data: ConfigEvent) => void): this;
-    on(event: 'error', callbackFn: (data: ErrorEvent) => void): this;
-    once(event: 'changed', callbackFn: (data: ConfigEvent) => void): this;
-    once(event: 'error', callbackFn: (data: ErrorEvent) => void): this;
-    emit(event: 'changed', data: ConfigEvent): boolean;
-    emit(event: 'error', data: ErrorEvent): boolean;
     onEditorConfigurationUpdate(editorConfiguration: PartialConfig): Promise<void>;
     load(): Promise<Config>;
     static isConfigFile(this: void, uri: string): boolean;

package/lib/service/Config.js

@@ -1,5 +1,5 @@
 import rfdc from 'rfdc';
-import { Arrayable, bufferToString, merge, TypePredicates } from '../common/index.js';
+import { Arrayable, bufferToString, EventDispatcher, merge, TypePredicates, } from '../common/index.js';
 import { ErrorSeverity } from '../source/index.js';
 import { DataFileCategories, RegistryCategories } from '../symbol/index.js';
 export var LinterSeverity;
@@ -296,16 +296,15 @@ export var PartialConfig;
     }
     PartialConfig.buildConfigFromEditorSettingsSafe = buildConfigFromEditorSettingsSafe;
 })(PartialConfig || (PartialConfig = {}));
-export class ConfigService {
+export class ConfigService extends EventDispatcher {
     project;
     defaultConfig;
     static ConfigFileNames = Object.freeze(['spyglass.json', '.spyglassrc', '.spyglassrc.json']);
-    #eventEmitter;
     currentEditorConfiguration = {};
     constructor(project, defaultConfig = VanillaConfig) {
+        super();
         this.project = project;
         this.defaultConfig = defaultConfig;
-        this.#eventEmitter = new project.externals.event.EventEmitter();
         const handler = async ({ uri }) => {
             if (ConfigService.isConfigFile(uri)) {
                 this.emit('changed', { config: await this.load() });
@@ -315,17 +314,6 @@ export class ConfigService {
         project.on('fileModified', handler);
         project.on('fileDeleted', handler);
     }
-    on(event, callbackFn) {
-        this.#eventEmitter.on(event, callbackFn);
-        return this;
-    }
-    once(event, callbackFn) {
-        this.#eventEmitter.once(event, callbackFn);
-        return this;
-    }
-    emit(event, ...args) {
-        return this.#eventEmitter.emit(event, ...args);
-    }
     async onEditorConfigurationUpdate(editorConfiguration) {
         this.currentEditorConfiguration = editorConfiguration;
         this.emit('changed', { config: await this.load() });

package/lib/service/FileService.js

@@ -1,5 +1,5 @@
 /* istanbul ignore file */
-import { Uri } from '../common/index.js';
+import { getSha1, Uri } from '../common/index.js';
 import { TwoWayMap } from '../common/TwoWayMap.js';
 import { fileUtil } from './fileUtil.js';
 export var FileService;
@@ -77,7 +77,7 @@ export class FileServiceImpl {
         try {
             let mappedUri = this.map.getKey(virtualUri);
             if (mappedUri === undefined) {
-                mappedUri = `${this.virtualUrisRoot}${await this.externals.crypto.getSha1(virtualUri)}/${fileUtil.basename(virtualUri)}`;
+                mappedUri = `${this.virtualUrisRoot}${await getSha1(virtualUri)}/${fileUtil.basename(virtualUri)}`;
                 // Delete old mapped file if it exists. This makes sure the
                 // readonly permission on the file is not removed by it being
                 // overwritten.
@@ -183,7 +183,7 @@ export class ArchiveUriSupporter {
         }
         else {
             // Hash the corresponding file.
-            return this.externals.crypto.getSha1(this.getDataInArchive(archiveName, pathInArchive));
+            return getSha1(this.getDataInArchive(archiveName, pathInArchive));
         }
     }
     async readFile(uri) {
@@ -258,7 +258,7 @@ export class ArchiveUriSupporter {
                 const files = await externals.archive.decompressBall(bytes, { stripLevel: dependency.stripLevel ?? 0 });
                 /// Debug message for #1609
                 logger.info(`[ArchiveUriSupporter#create] Extracted ${files.length} files from ${archiveName}`);
-                const hash = await externals.crypto.getSha1(bytes);
+                const hash = await getSha1(bytes);
                 archiveHashes.set(archiveName, hash);
                 entries.set(archiveName, new Map(files.map((f) => [f.path.replace(/\\/g, '/'), f])));
             }
@@ -270,6 +270,6 @@ export class ArchiveUriSupporter {
     }
 }
 async function hashFile(externals, uri) {
-    return externals.crypto.getSha1(await externals.fs.readFile(uri));
+    return getSha1(await externals.fs.readFile(uri));
 }
 //# sourceMappingURL=FileService.js.map

package/lib/service/FileWatcher.d.ts

@@ -1,21 +1,18 @@
-import type { UriStore } from '../common/index.js';
+import type { EventDispatcher, UriStore } from '../common/index.js';
+export type FileWatcherEventMap = {
+    ready: void;
+    add: string;
+    change: string;
+    unlink: string;
+    error: Error;
+};
 /**
  * A file watcher that reports additions, changes, and deletions of files.
  * Changes to directories should not be reported.
  */
-export interface FileWatcher {
+export interface FileWatcher extends EventDispatcher<FileWatcherEventMap> {
     get watchedFiles(): UriStore;
     ready(): Promise<void>;
-    on(eventName: 'ready', listener: () => unknown): this;
-    once(eventName: 'ready', listener: () => unknown): this;
-    on(eventName: 'add', listener: (uri: string) => unknown): this;
-    once(eventName: 'add', listener: (uri: string) => unknown): this;
-    on(eventName: 'change', listener: (uri: string) => unknown): this;
-    once(eventName: 'change', listener: (uri: string) => unknown): this;
-    on(eventName: 'unlink', listener: (uri: string) => unknown): this;
-    once(eventName: 'unlink', listener: (uri: string) => unknown): this;
-    on(eventName: 'error', listener: (error: Error) => unknown): this;
-    once(eventName: 'error', listener: (error: Error) => unknown): this;
     close(): Promise<void>;
 }
 //# sourceMappingURL=FileWatcher.d.ts.map

package/lib/service/Project.d.ts

@@ -1,7 +1,7 @@
 import type { TextDocumentContentChangeEvent } from 'vscode-languageserver-textdocument';
 import { TextDocument } from 'vscode-languageserver-textdocument';
-import type { ExternalEventEmitter, Externals } from '../common/index.js';
-import { Logger, UriStore } from '../common/index.js';
+import type { Externals } from '../common/index.js';
+import { EventDispatcher, Logger, UriStore } from '../common/index.js';
 import type { AstNode } from '../node/index.js';
 import { FileNode } from '../node/index.js';
 import type { PosRangeLanguageError } from '../source/index.js';
@@ -100,7 +100,18 @@ export type ProjectData = Pick<Project, 'cacheRoot' | 'config' | 'ensureBindingS
  *
  * After the READY process is complete, editing text documents as signaled by the client or the file watcher results in the file being re-processed.
  */
-export declare class Project implements ExternalEventEmitter {
+export declare class Project extends EventDispatcher<{
+    documentErrored: DocumentErrorEvent;
+    documentUpdated: DocumentEvent;
+    documentRemoved: FileEvent;
+    fileCreated: FileEvent;
+    fileModified: FileEvent;
+    fileDeleted: FileEvent;
+    ready: EmptyEvent;
+    rootsUpdated: RootsEvent;
+    symbolRegistrarExecuted: SymbolRegistrarEvent;
+    configChanged: ConfigChangeEvent;
+}> {
     #private;
     private static readonly RootSuffix;
     readonly cacheService: CacheService;
@@ -134,30 +145,6 @@ export declare class Project implements ExternalEventEmitter {
      */
     get cacheRoot(): RootUriString;
     private updateRoots;
-    on(event: 'documentErrored', callbackFn: (data: DocumentErrorEvent) => void): this;
-    on(event: 'documentUpdated', callbackFn: (data: DocumentEvent) => void): this;
-    on(event: 'documentRemoved', callbackFn: (data: FileEvent) => void): this;
-    on(event: `file${'Created' | 'Modified' | 'Deleted'}`, callbackFn: (data: FileEvent) => void): this;
-    on(event: 'ready', callbackFn: (data: EmptyEvent) => void): this;
-    on(event: 'rootsUpdated', callbackFn: (data: RootsEvent) => void): this;
-    on(event: 'symbolRegistrarExecuted', callbackFn: (data: SymbolRegistrarEvent) => void): this;
-    on(event: 'configChanged', callbackFn: (data: ConfigChangeEvent) => void): this;
-    once(event: 'documentErrored', callbackFn: (data: DocumentErrorEvent) => void): this;
-    once(event: 'documentUpdated', callbackFn: (data: DocumentEvent) => void): this;
-    once(event: 'documentRemoved', callbackFn: (data: FileEvent) => void): this;
-    once(event: `file${'Created' | 'Modified' | 'Deleted'}`, callbackFn: (data: FileEvent) => void): this;
-    once(event: 'ready', callbackFn: (data: EmptyEvent) => void): this;
-    once(event: 'rootsUpdated', callbackFn: (data: RootsEvent) => void): this;
-    once(event: 'symbolRegistrarExecuted', callbackFn: (data: SymbolRegistrarEvent) => void): this;
-    once(event: 'configChanged', callbackFn: (data: ConfigChangeEvent) => void): this;
-    emit(event: 'documentErrored', data: DocumentErrorEvent): boolean;
-    emit(event: 'documentUpdated', data: DocumentEvent): boolean;
-    emit(event: 'documentRemoved', data: FileEvent): boolean;
-    emit(event: `file${'Created' | 'Modified' | 'Deleted'}`, data: FileEvent): boolean;
-    emit(event: 'ready', data: EmptyEvent): boolean;
-    emit(event: 'rootsUpdated', data: RootsEvent): boolean;
-    emit(event: 'symbolRegistrarExecuted', data: SymbolRegistrarEvent): boolean;
-    emit(event: 'configChanged', data: ConfigChangeEvent): boolean;
     /**
      * Get all files that are tracked and supported.
      *

package/lib/service/Project.js

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import picomatch from 'picomatch';
 import { TextDocument } from 'vscode-languageserver-textdocument';
-import { bufferToString, Logger, normalizeUri, SingletonPromise, StateProxy, UriStore, } from '../common/index.js';
+import { bufferToString, EventDispatcher, Logger, normalizeUri, SingletonPromise, StateProxy, UriStore, } from '../common/index.js';
 import { FileNode } from '../node/index.js';
 import { file } from '../parser/index.js';
 import { traversePreOrder } from '../processor/index.js';
@@ -60,7 +60,7 @@ const CacheAutoSaveInterval = 600_000; // 10 Minutes.
  *
  * After the READY process is complete, editing text documents as signaled by the client or the file watcher results in the file being re-processed.
  */
-export class Project {
+export class Project extends EventDispatcher {
     static RootSuffix = '/pack.mcmeta';
     /** Prevent circular binding. */
     #bindingInProgressUris = new Set();
@@ -71,7 +71,6 @@ export class Project {
     #clientManagedDocAndNodes = new Map();
     #configService;
     #symbolUpToDateUris = new Set();
-    #eventEmitter;
     #initializers;
     #watcher;
     get watchedFiles() {
@@ -134,17 +133,6 @@ export class Project {
         this.#roots = [...ans].sort((a, b) => b.length - a.length);
         this.emit('rootsUpdated', { roots: this.#roots });
     }
-    on(event, callbackFn) {
-        this.#eventEmitter.on(event, callbackFn);
-        return this;
-    }
-    once(event, callbackFn) {
-        this.#eventEmitter.once(event, callbackFn);
-        return this;
-    }
-    emit(event, ...args) {
-        return this.#eventEmitter.emit(event, ...args);
-    }
     /**
      * Get all files that are tracked and supported.
      *
@@ -157,8 +145,8 @@ export class Project {
         return supportedFiles;
     }
     constructor({ cacheRoot, defaultConfig, externals, fs = FileService.create(externals, cacheRoot), initializers = [], isDebugging = false, logger = Logger.create(), profilers = ProfilerFactory.noop(), projectRoots, }) {
+        super();
         this.#cacheRoot = cacheRoot;
-        this.#eventEmitter = new externals.event.EventEmitter();
         this.externals = externals;
         this.fs = fs;
         this.#initializers = initializers;
@@ -168,7 +156,7 @@ export class Project {
         this.projectRoots = projectRoots;
         this.cacheService = new CacheService(cacheRoot, this);
         this.#configService = new ConfigService(this, defaultConfig);
-        this.symbols = new SymbolUtil({}, externals.event.EventEmitter);
+        this.symbols = new SymbolUtil({});
         this.#ctx = {};
         this.logger.info(`[Project] [init] cacheRoot = ${cacheRoot}`);
         this.logger.info(`[Project] [init] projectRoots = ${projectRoots.join(' ')}`);
@@ -250,7 +238,7 @@ export class Project {
         };
         const __profiler = this.profilers.get('project#init');
         const { symbols } = await this.cacheService.load();
-        this.symbols = new SymbolUtil(symbols, this.externals.event.EventEmitter);
+        this.symbols = new SymbolUtil(symbols);
         this.symbols.buildCache();
         __profiler.task('Load Cache');
         this.config = await this.#configService.load();
@@ -425,7 +413,7 @@ export class Project {
         }
         // Reset cache.
         const { symbols } = this.cacheService.reset();
-        this.symbols = new SymbolUtil(symbols, this.externals.event.EventEmitter);
+        this.symbols = new SymbolUtil(symbols);
         this.symbols.buildCache();
         return this.restart();
     }

package/lib/service/fetcher.d.ts

@@ -1,3 +1,10 @@
 import type { Externals, Logger } from '../common/index.js';
-export declare function fetchWithCache({ web }: Externals, logger: Logger, input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+export interface FetcherOptions {
+    retryBaseMs?: number;
+    retryMaxAttempts?: number;
+    perTryTimeoutMs?: number;
+    totalTimeoutMs?: number;
+}
+export declare function fetchWithCache({ web }: Externals, logger: Logger, input: RequestInfo | URL, init?: RequestInit, options?: FetcherOptions): Promise<Response>;
+export declare function isStaleFetcherResponse(response: Response): boolean;
 //# sourceMappingURL=fetcher.d.ts.map

package/lib/service/fetcher.js

@@ -1,16 +1,24 @@
-import { Dev } from '../common/index.js';
-const FETCH_TIMEOUT_MS = 30_000;
-export async function fetchWithCache({ web }, logger, input, init) {
+import { Dev, sleep } from '../common/index.js';
+const FETCH_RETRY_BASE_MS = 1_000;
+const FETCH_RETRY_MAX_ATTEMPTS = 3;
+const FETCH_PER_TRY_TIMEOUT_MS = 10_000;
+const FETCH_TOTAL_TIMEOUT_MS = 15_000;
+const STALE_HEADER = 'spyglassmc-is-stale';
+export async function fetchWithCache({ web }, logger, input, init, options) {
     const cache = await web.getCache();
     const request = new Request(input, init);
     const cachedResponse = await cache.match(request);
-    const cachedEtag = cachedResponse?.headers.get('ETag');
+    const cachedEtag = cachedResponse?.headers.get('etag');
+    const cachedLastModified = cachedResponse?.headers.get('last-modified');
     if (cachedEtag) {
-        request.headers.set('If-None-Match', cachedEtag);
+        request.headers.set('if-none-match', cachedEtag);
     }
-    request.headers.set('User-Agent', 'SpyglassMC (+https://spyglassmc.com)');
+    else if (cachedLastModified) {
+        request.headers.set('if-modified-since', cachedLastModified);
+    }
+    request.headers.set('user-agent', 'SpyglassMC (+https://spyglassmc.com)');
     try {
-        const response = await web.fetch(request, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+        const response = await fetchWithRetries(request, options);
         if (response.status === 304) {
             Dev.assertDefined(cachedResponse);
             logger.info(`[fetchWithCache] reusing cache for ${request.url}`);
@@ -19,7 +27,7 @@ export async function fetchWithCache({ web }, logger, input, init) {
         else if (!response.ok) {
             let message = response.statusText;
             try {
-                message = (await response.json()).message;
+                message = await response.text();
             }
             catch { }
             throw new TypeError(`${response.status} ${message}`);
@@ -32,6 +40,12 @@ export async function fetchWithCache({ web }, logger, input, init) {
             catch (e) {
                 logger.warn('[fetchWithCache] put cache', e);
             }
+            try {
+                await cachedResponse?.body?.cancel();
+            }
+            catch (e) {
+                logger.warn('[fetchWithCache] failed cancelling cachedResponse body stream', e);
+            }
             return response;
         }
     }
@@ -39,10 +53,49 @@ export async function fetchWithCache({ web }, logger, input, init) {
         logger.warn('[fetchWithCache] fetch', e);
         if (cachedResponse) {
             logger.info(`[fetchWithCache] falling back to cache for ${request.url}`);
-            return cachedResponse;
+            // Set the stale header when fallback is used
+            const newHeaders = new Headers(cachedResponse.headers);
+            newHeaders.set(STALE_HEADER, '1');
+            return new Response(cachedResponse.body, {
+                status: cachedResponse.status,
+                statusText: cachedResponse.statusText,
+                headers: newHeaders,
+            });
         }
         throw e;
     }
 }
+export function isStaleFetcherResponse(response) {
+    return response.headers.has(STALE_HEADER);
+}
+async function fetchWithRetries(request, { perTryTimeoutMs = FETCH_PER_TRY_TIMEOUT_MS, retryBaseMs = FETCH_RETRY_BASE_MS, retryMaxAttempts = FETCH_RETRY_MAX_ATTEMPTS, totalTimeoutMs = FETCH_TOTAL_TIMEOUT_MS, } = {}) {
+    let lastResult;
+    const totalSignal = AbortSignal.timeout(totalTimeoutMs);
+    Dev.assertTrue(retryMaxAttempts > 0, 'Number of attempts must be greater than 0');
+    for (let i = 0; i < retryMaxAttempts; i++) {
+        const isLastAttempt = i === retryMaxAttempts - 1;
+        try {
+            lastResult = await fetch(request.clone(), {
+                signal: AbortSignal.any([
+                    totalSignal,
+                    AbortSignal.timeout(perTryTimeoutMs),
+                ]),
+            });
+            if (lastResult.status < 500) {
+                return lastResult;
+            }
+        }
+        catch (e) {
+            lastResult = e;
+        }
+        if (!isLastAttempt) {
+            await sleep(Math.round(Math.random() * (2 ** i) * retryBaseMs));
+        }
+    }
+    if (lastResult instanceof Response) {
+        return lastResult;
+    }
+    throw lastResult;
+}
 // Fetchr? I hardly know her: https://github.com/NeunEinser/bingo
 //# sourceMappingURL=fetcher.js.map

package/lib/service/fileUtil.js

@@ -1,4 +1,4 @@
-import { bigintJsonNumberReplacer, bigintJsonNumberReviver, bufferToString, Uri, } from '../common/index.js';
+import { bigintJsonNumberReplacer, bigintJsonNumberReviver, bufferToString, compressBytes, decompressBytes, Uri, } from '../common/index.js';
 export var fileUtil;
 (function (fileUtil) {
     /**
@@ -245,7 +245,7 @@ export var fileUtil;
      * @throws
      */
     async function readGzippedFile(externals, path) {
-        return externals.archive.gunzip(await readFile(externals, path));
+        return decompressBytes(await readFile(externals, path), 'gzip');
     }
     fileUtil.readGzippedFile = readGzippedFile;
     /**
@@ -255,7 +255,7 @@ export var fileUtil;
         if (typeof buffer === 'string') {
             buffer = new TextEncoder().encode(buffer);
         }
-        return writeFile(externals, path, await externals.archive.gzip(buffer));
+        return writeFile(externals, path, await compressBytes(buffer, 'gzip'));
     }
     fileUtil.writeGzippedFile = writeGzippedFile;
     /**