@spyglassmc/core 0.4.46 → 0.4.48

package/lib/common/Dev.d.ts

@@ -1,7 +1,7 @@
 export declare namespace Dev {
     function assertDefined<T>(value: T): asserts value is Exclude<T, undefined>;
     function assertNever(value: never): never;
-    function assertTrue(value: boolean, message: string): void;
+    function assertTrue(value: unknown, message: string): asserts value;
     /**
      * @returns An estimate of the memory taken by the given value, assuming objects are stored as array-like structures instead of dictionaries in the V8 engine.
      */

package/lib/common/EventDispatcher.d.ts

@@ -0,0 +1,6 @@
+export declare class EventDispatcher<TEvents extends Record<string, unknown>> {
+    #private;
+    emit<K extends keyof TEvents & string>(name: K, data: TEvents[K]): void;
+    on<K extends keyof TEvents & string>(name: K, listener: (data: TEvents[K]) => unknown, options?: AddEventListenerOptions): this;
+}
+//# sourceMappingURL=EventDispatcher.d.ts.map

package/lib/common/EventDispatcher.js

@@ -0,0 +1,15 @@
+import { Dev } from './Dev.js';
+export class EventDispatcher {
+    #target = new EventTarget();
+    emit(name, data) {
+        this.#target.dispatchEvent(new CustomEvent(name, { detail: data }));
+    }
+    on(name, listener, options) {
+        this.#target.addEventListener(name, (event) => {
+            Dev.assertTrue(event instanceof CustomEvent, 'event must be an instance of CustomEvent');
+            listener(event.detail);
+        }, options);
+        return this;
+    }
+}
+//# sourceMappingURL=EventDispatcher.js.map

package/lib/common/ReadonlyProxy.js

@@ -1,4 +1,4 @@
-import { emplaceMap, isObject } from './util.js';
+import { getOrInsertComputed, isObject } from './util.js';
 export var ReadonlyProxy;
 (function (ReadonlyProxy) {
     function create(obj) {
@@ -11,7 +11,7 @@ class ReadonlyProxyHandler {
     get(target, p, receiver) {
         const value = Reflect.get(target, p, receiver);
         if (p !== 'prototype' && isObject(value)) {
-            return emplaceMap(this.map, p, { insert: () => ReadonlyProxy.create(value) });
+            return getOrInsertComputed(this.map, p, () => ReadonlyProxy.create(value));
         }
         return value;
     }

package/lib/common/StateProxy.js

@@ -1,4 +1,4 @@
-import { emplaceMap, isObject } from '../common/index.js';
+import { getOrInsertComputed, isObject } from '../common/index.js';
 import { Operations } from './Operations.js';
 const BranchOff = Symbol('StateBranchOff');
 const Is = Symbol('IsStateProxy');
@@ -63,7 +63,7 @@ class StateProxyHandler {
         }
         const value = Reflect.get(target, p, receiver);
         if (p !== 'prototype' && isObject(value)) {
-            return emplaceMap(this.map, p, { insert: () => _createStateProxy(value, this.rootOps) });
+            return getOrInsertComputed(this.map, p, () => _createStateProxy(value, this.rootOps));
         }
         return value;
     }

package/lib/common/externals/BrowserExternals.d.ts

@@ -1,11 +1,3 @@
-import type { ExternalEventEmitter, Externals } from './index.js';
-type Listener = (...args: unknown[]) => unknown;
-export declare class BrowserEventEmitter implements ExternalEventEmitter {
-    #private;
-    emit(eventName: string, ...args: unknown[]): boolean;
-    on(eventName: string, listener: Listener): this;
-    once(eventName: string, listener: Listener): this;
-}
+import type { Externals } from './index.js';
 export declare const BrowserExternals: Externals;
-export {};
 //# sourceMappingURL=BrowserExternals.d.ts.map

package/lib/common/externals/BrowserExternals.js

@@ -1,40 +1,5 @@
 import { decode as arrayBufferFromBase64, encode as arrayBufferToBase64 } from 'base64-arraybuffer';
-import pako from 'pako';
 import { fileUtil } from '../../service/fileUtil.js';
-export class BrowserEventEmitter {
-    #listeners = new Map();
-    emit(eventName, ...args) {
-        const listeners = this.#listeners.get(eventName);
-        if (!listeners?.all?.size) {
-            return false;
-        }
-        for (const listener of listeners.all) {
-            listener(...args);
-            if (listeners.once.has(listener)) {
-                listeners.all.delete(listener);
-                listeners.once.delete(listener);
-            }
-        }
-        return false;
-    }
-    on(eventName, listener) {
-        if (!this.#listeners.has(eventName)) {
-            this.#listeners.set(eventName, { all: new Set(), once: new Set() });
-        }
-        const listeners = this.#listeners.get(eventName);
-        listeners.all.add(listener);
-        return this;
-    }
-    once(eventName, listener) {
-        if (!this.#listeners.has(eventName)) {
-            this.#listeners.set(eventName, { all: new Set(), once: new Set() });
-        }
-        const listeners = this.#listeners.get(eventName);
-        listeners.all.add(listener);
-        listeners.once.add(listener);
-        return this;
-    }
-}
 // TODO: Use Origin Private File System (OPFS) instead
 class BrowserFileSystem {
     static LocalStorageKey = 'spyglassmc-browser-fs';
@@ -113,21 +78,6 @@ export const BrowserExternals = {
         decompressBall(_buffer, _options) {
             throw new Error('decompressBall not supported on browser.');
         },
-        async gunzip(buffer) {
-            return pako.inflate(buffer);
-        },
-        async gzip(buffer) {
-            return pako.gzip(buffer);
-        },
-    },
-    crypto: {
-        async getSha1(data) {
-            if (typeof data === 'string') {
-                data = new TextEncoder().encode(data);
-            }
-            const hash = await crypto.subtle.digest('SHA-1', data.buffer);
-            return uint8ArrayToHex(new Uint8Array(hash));
-        },
     },
     error: {
         createKind(kind, message) {
@@ -137,19 +87,10 @@ export const BrowserExternals = {
             return e instanceof Error && e.message.startsWith(kind);
         },
     },
-    event: { EventEmitter: BrowserEventEmitter },
     fs: new BrowserFileSystem(),
     web: {
-        fetch,
         getCache: () => window.caches.open('spyglassmc'),
     },
 };
-function uint8ArrayToHex(array) {
-    let ans = '';
-    for (const v of array) {
-        ans += v.toString(16).padStart(2, '0');
-    }
-    return ans;
-}
 Object.freeze(BrowserExternals);
 //# sourceMappingURL=BrowserExternals.js.map

package/lib/common/externals/NodeJsExternals.d.ts

@@ -1,28 +1,22 @@
-import { EventEmitter } from 'node:events';
-import fs, { promises as fsp } from 'node:fs';
-import type { DecompressedFile, RootUriString } from '../../index.js';
+import type fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import { type DecompressedFile, type RootUriString } from '../../index.js';
+import { Logger } from '../Logger.js';
 import type { FsLocation } from './index.js';
-export declare function getNodeJsExternals({ cacheRoot, nodeFsp }?: {
+export declare function getNodeJsExternals({ cacheRoot, logger, nodeFsp }?: {
     cacheRoot?: RootUriString;
+    logger?: Logger;
     nodeFsp?: typeof fsp;
 }): Readonly<{
     archive: {
         decompressBall(buffer: Uint8Array<ArrayBuffer>, options: {
             stripLevel?: number;
         } | undefined): Promise<DecompressedFile[]>;
-        gunzip(buffer: Uint8Array<ArrayBuffer>): Promise<NonSharedBuffer>;
-        gzip(buffer: Uint8Array<ArrayBuffer>): Promise<NonSharedBuffer>;
-    };
-    crypto: {
-        getSha1(data: string | Uint8Array<ArrayBuffer>): Promise<string>;
     };
     error: {
         createKind(kind: import("./index.js").ExternalErrorKind, message: string): Error;
         isKind(e: unknown, kind: import("./index.js").ExternalErrorKind): boolean;
     };
-    event: {
-        EventEmitter: typeof EventEmitter;
-    };
     fs: {
         chmod(location: FsLocation, mode: number): Promise<void>;
         mkdir(location: FsLocation, options: {
@@ -42,7 +36,6 @@ export declare function getNodeJsExternals({ cacheRoot, nodeFsp }?: {
         } | undefined): Promise<void>;
     };
     web: {
-        fetch: typeof fetch;
         getCache: () => Promise<HttpCache>;
     };
 }>;
@@ -51,19 +44,11 @@ export declare const NodeJsExternals: Readonly<{
         decompressBall(buffer: Uint8Array<ArrayBuffer>, options: {
             stripLevel?: number;
         } | undefined): Promise<DecompressedFile[]>;
-        gunzip(buffer: Uint8Array<ArrayBuffer>): Promise<NonSharedBuffer>;
-        gzip(buffer: Uint8Array<ArrayBuffer>): Promise<NonSharedBuffer>;
-    };
-    crypto: {
-        getSha1(data: string | Uint8Array<ArrayBuffer>): Promise<string>;
     };
     error: {
         createKind(kind: import("./index.js").ExternalErrorKind, message: string): Error;
         isKind(e: unknown, kind: import("./index.js").ExternalErrorKind): boolean;
     };
-    event: {
-        EventEmitter: typeof EventEmitter;
-    };
     fs: {
         chmod(location: FsLocation, mode: number): Promise<void>;
         mkdir(location: FsLocation, options: {
@@ -83,7 +68,6 @@ export declare const NodeJsExternals: Readonly<{
         } | undefined): Promise<void>;
     };
     web: {
-        fetch: typeof fetch;
         getCache: () => Promise<HttpCache>;
     };
 }>;
@@ -93,7 +77,7 @@ export declare const NodeJsExternals: Readonly<{
  */
 declare class HttpCache implements Cache {
     #private;
-    constructor(cacheRoot: RootUriString | undefined);
+    constructor(cacheRoot: RootUriString | undefined, logger: Logger, nodeFsp: typeof fsp);
     match(request: RequestInfo | URL, _options?: CacheQueryOptions | undefined): Promise<Response | undefined>;
     put(request: RequestInfo | URL, response: Response): Promise<void>;
     add(): Promise<void>;

package/lib/common/externals/NodeJsExternals.js

@@ -1,18 +1,17 @@
 import decompress from 'decompress';
 import { Buffer } from 'node:buffer';
 import cp from 'node:child_process';
-import crypto from 'node:crypto';
-import { EventEmitter } from 'node:events';
-import fs, { promises as fsp } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import fsp from 'node:fs/promises';
 import os from 'node:os';
 import process from 'node:process';
 import stream from 'node:stream';
+import { pipeline } from 'node:stream/promises';
 import url from 'node:url';
 import { promisify } from 'node:util';
-import zlib from 'node:zlib';
-const gunzip = promisify(zlib.gunzip);
-const gzip = promisify(zlib.gzip);
-export function getNodeJsExternals({ cacheRoot, nodeFsp = fsp } = {}) {
+import { Dev, isObject } from '../../index.js';
+import { Logger } from '../Logger.js';
+export function getNodeJsExternals({ cacheRoot, logger = Logger.create(), nodeFsp = fsp } = {}) {
     return Object.freeze({
         archive: {
             decompressBall(buffer, options) {
@@ -21,19 +20,6 @@ export function getNodeJsExternals({ cacheRoot, nodeFsp = fsp } = {}) {
                 }
                 return decompress(buffer, { strip: options?.stripLevel });
             },
-            gunzip(buffer) {
-                return gunzip(buffer);
-            },
-            gzip(buffer) {
-                return gzip(buffer);
-            },
-        },
-        crypto: {
-            async getSha1(data) {
-                const hash = crypto.createHash('sha1');
-                hash.update(data);
-                return hash.digest('hex');
-            },
         },
         error: {
             createKind(kind, message) {
@@ -45,7 +31,6 @@ export function getNodeJsExternals({ cacheRoot, nodeFsp = fsp } = {}) {
                 return e instanceof Error && e.code === kind;
             },
         },
-        event: { EventEmitter },
         fs: {
             chmod(location, mode) {
                 return nodeFsp.chmod(toFsPathLike(location), mode);
@@ -92,9 +77,8 @@ export function getNodeJsExternals({ cacheRoot, nodeFsp = fsp } = {}) {
             },
         },
         web: {
-            fetch,
             getCache: async () => {
-                return new HttpCache(cacheRoot);
+                return new HttpCache(cacheRoot, logger, nodeFsp);
             },
         },
     });
@@ -116,55 +100,217 @@ function toPath(path) {
     return uriToPath(path);
 }
 const uriToPath = (uri) => url.fileURLToPath(uri);
+var CacheIndex;
+(function (CacheIndex) {
+    function assert(val) {
+        if (!isObject(val)) {
+            throw new Error('Expected an object');
+        }
+        if (!('index' in val && isObject(val.index))) {
+            throw new Error("Expected 'index' to exist as an object");
+        }
+        if (!(Object.values(val.index).every((i) => isObject(i)
+            && Object.values(i).every((v) => isObject(v)
+                && 'status' in v && typeof v.status === 'number'
+                && 'statusText' in v && typeof v.statusText === 'string'
+                && 'headers' in v && isObject(v.headers)
+                && Object.values(v.headers).every((s) => typeof s === 'string')
+                && 'sha1' in v && typeof v.sha1 === 'string' && /^[0-9a-f]{40}$/.test(v.sha1)
+                && 'cacheTime' in v && typeof v.cacheTime === 'number')))) {
+            throw new Error('Malformed index structure');
+        }
+    }
+    CacheIndex.assert = assert;
+})(CacheIndex || (CacheIndex = {}));
 /**
  * A non-spec-compliant, non-complete implementation of the Cache Web API for use in Spyglass.
  * This class stores the cached response on the file system under the cache root.
  */
 class HttpCache {
     #cacheRoot;
-    constructor(cacheRoot) {
+    #httpRoot;
+    #indexUri;
+    #objectsRoot;
+    #tempRoot;
+    #logger;
+    #fsp;
+    #index;
+    #loadIndexPromise;
+    constructor(cacheRoot, logger, nodeFsp) {
         if (cacheRoot) {
-            this.#cacheRoot = `${cacheRoot}http/`;
+            this.#cacheRoot = cacheRoot;
+            this.#httpRoot = `${this.#cacheRoot}http/`;
+            this.#indexUri = `${this.#httpRoot}index.json`;
+            this.#objectsRoot = `${this.#httpRoot}objects/`;
+            this.#tempRoot = `${this.#httpRoot}temp/`;
         }
+        this.#logger = logger;
+        this.#fsp = nodeFsp;
     }
     async match(request, _options) {
-        if (!this.#cacheRoot) {
+        if (!(this.#indexUri && this.#objectsRoot && this.#tempRoot)) {
+            return undefined;
+        }
+        const index = await this.#loadIndex(this.#indexUri);
+        const requestUri = request instanceof Request ? request.url : request.toString();
+        const requestRange = request instanceof Request ? request.headers.get('range') : undefined;
+        const indexEntry = index.index[requestUri]?.[requestRange ?? ''];
+        if (!indexEntry) {
             return undefined;
         }
-        const fileName = this.#getFileName(request);
         try {
-            const etag = (await fsp.readFile(new URL(`${fileName}.etag`, this.#cacheRoot), 'utf8'))
-                .trim();
-            const bodyStream = fs.createReadStream(new URL(`${fileName}.bin`, this.#cacheRoot));
-            return new Response(stream.Readable.toWeb(bodyStream), 
-            //              \___/
-            // stream Readable -> stream/web ReadableStream
-            //                                \_______________/
-            //                 stream/web ReadableStream -> DOM ReadableStream
-            { headers: { etag } });
+            const objectFileHandle = await this.#fsp.open(this.#getObjectUri(this.#objectsRoot, indexEntry.sha1));
+            const bodyStream = objectFileHandle.createReadStream({ autoClose: true });
+            return new Response(stream.Readable.toWeb(bodyStream), {
+                headers: indexEntry.headers,
+                status: indexEntry.status,
+                statusText: indexEntry.statusText,
+            });
         }
         catch (e) {
             if (e?.code === 'ENOENT') {
+                this.#logger.warn(`Object file for ${JSON.stringify(indexEntry)} does not exist`, e);
+                delete index.index[requestUri]?.[requestRange ?? ''];
+                if (Object.values(index.index[requestUri]).length === 0) {
+                    delete index.index[requestUri];
+                }
+                await this.#saveIndex(this.#indexUri, this.#tempRoot);
                 return undefined;
             }
             throw e;
         }
     }
     async put(request, response) {
+        if (!(this.#tempRoot && this.#objectsRoot && this.#indexUri && response.body)) {
+            return;
+        }
         const etag = response.headers.get('etag');
-        if (!(this.#cacheRoot && response.body && etag)) {
+        const lastModified = response.headers.get('last-modified');
+        if (!(etag || lastModified)) {
             return;
         }
-        const fileName = this.#getFileName(request);
-        await fsp.mkdir(new URL(this.#cacheRoot), { recursive: true });
-        await Promise.all([
-            fsp.writeFile(new URL(`${fileName}.bin`, this.#cacheRoot), stream.Readable.fromWeb(response.body)),
-            fsp.writeFile(new URL(`${fileName}.etag`, this.#cacheRoot), `${etag}${os.EOL}`),
-        ]);
+        const requestUri = request instanceof Request ? request.url : request.toString();
+        const requestRange = request instanceof Request ? request.headers.get('range') : undefined;
+        // Save response body in a temp file and computes its SHA-1 digest
+        const { bodySha1, bodyTempUri } = await this.#saveResponseBody(response.body, this.#tempRoot);
+        // Update the index
+        const index = await this.#loadIndex(this.#indexUri);
+        index.index[requestUri] ??= {};
+        const previousEntry = index.index[requestUri][requestRange ?? ''];
+        index.index[requestUri][requestRange ?? ''] = {
+            status: response.status,
+            statusText: response.statusText,
+            headers: Object.fromEntries(response.headers),
+            sha1: bodySha1,
+            cacheTime: Date.now(),
+        };
+        await this.#saveIndex(this.#indexUri, this.#tempRoot);
+        if (previousEntry) {
+            await this.#cleanUpDanglingObject(this.#objectsRoot, index, previousEntry.sha1);
+        }
+        // Rename the temp body file to its final location in the content-addressable object store
+        // match() would gracefully handle missing object if this step fails for any reason
+        const objectUri = this.#getObjectUri(this.#objectsRoot, bodySha1);
+        await this.#fsp.mkdir(new URL('.', objectUri), { recursive: true, mode: 0o755 });
+        await this.#fsp.rename(bodyTempUri, objectUri);
+    }
+    async #saveResponseBody(body, tempRoot) {
+        const bodyStream = stream.Readable.fromWeb(body);
+        const bodyHash = createHash('sha1');
+        // Tee the body stream to both a temporary file write stream and the SHA-1 hash stream
+        const tempUri = new URL(`body.${randomUUID()}.tmp`, tempRoot);
+        await this.#fsp.mkdir(new URL(tempRoot), { recursive: true, mode: 0o755 });
+        const tempHandle = await this.#fsp.open(tempUri, 'w', 0o644);
+        const writeStream = tempHandle.createWriteStream({ autoClose: true });
+        bodyStream.pipe(bodyHash);
+        await pipeline(bodyStream, writeStream);
+        const bodySha1 = bodyHash.digest('hex');
+        return { bodySha1, bodyTempUri: tempUri };
+    }
+    async #loadIndex(indexUri) {
+        await (this.#loadIndexPromise ??= (async () => {
+            try {
+                const parsedIndex = JSON.parse(await this.#fsp.readFile(new URL(indexUri), 'utf8'));
+                CacheIndex.assert(parsedIndex);
+                this.#index = parsedIndex;
+            }
+            catch (e) {
+                if (e.code === 'ENOENT') {
+                    // Triger legacy cache clean up if no index file for the new cache scheme exists.
+                    this.#logger.info('[HttpCache] No cache index found; cleaning up legacy cache files');
+                    await this.#cleanUpLegacyCache();
+                }
+                else {
+                    this.#logger.warn('[HttpCache] Corrupted cache index', e);
+                }
+                this.#index = { index: {} };
+            }
+        })());
+        return this.#index;
+    }
+    async #saveIndex(indexUri, tempRoot) {
+        try {
+            Dev.assertDefined(this.#index);
+            const tempUri = new URL(`index.${randomUUID()}.tmp`, tempRoot);
+            await this.#fsp.mkdir(new URL(tempRoot), { recursive: true, mode: 0o755 });
+            await this.#fsp.writeFile(tempUri, `${JSON.stringify(this.#index)}${os.EOL}`, {
+                mode: 0o644,
+            });
+            await this.#fsp.rename(tempUri, new URL(indexUri));
+        }
+        catch (e) {
+            this.#logger.warn('[HttpCache] Failed saving index', e);
+        }
+    }
+    /**
+     * Remove cache files used by older versions of Spyglass.
+     * - until v2026.5.8+8c7f6e, `${cacheRoot}downloader/`
+     * - until v2026.5.16+9c4fa2, `${cacheRoot}http/${base64UrlEncoded}.${'bin' | 'etag'}`
+     */
+    async #cleanUpLegacyCache() {
+        if (!this.#httpRoot) {
+            return;
+        }
+        try {
+            await this.#fsp.rm(new URL('downloader/', this.#cacheRoot), { recursive: true });
+        }
+        catch (e) {
+            if (e.code !== 'ENOENT') {
+                this.#logger.warn('[HttpCache] Failed cleaning up downloader/ dir', e);
+            }
+        }
+        try {
+            const httpDir = await this.#fsp.opendir(new URL(this.#httpRoot));
+            for await (const entry of httpDir) {
+                if (entry.isFile() && (entry.name.endsWith('.bin') || entry.name.endsWith('.etag'))) {
+                    await this.#fsp.rm(new URL(entry.name, this.#httpRoot));
+                }
+            }
+        }
+        catch (e) {
+            if (e.code !== 'ENOENT') {
+                this.#logger.warn('[HttpCache] Failed cleaning up legacy cache files', e);
+            }
+        }
+    }
+    async #cleanUpDanglingObject(objectsRoot, index, sha1) {
+        if (Object.values(index.index).some((i) => Object.values(i).some((v) => v.sha1 === sha1))) {
+            // The object is still referenced
+            return false;
+        }
+        try {
+            await this.#fsp.rm(this.#getObjectUri(objectsRoot, sha1));
+            return true;
+        }
+        catch (e) {
+            if (e.code !== 'ENOENT') {
+                this.#logger.warn('[HttpCache] Failed cleaning up dangling object', e);
+            }
+        }
+        return false;
     }
-    #getFileName(request) {
-        const uriString = request instanceof Request ? request.url : request.toString();
-        return Buffer.from(uriString, 'utf8').toString('base64url');
+    #getObjectUri(objectsRoot, sha1) {
+        return new URL(`${sha1.slice(0, 2)}/${sha1}`, objectsRoot);
     }
     async add() {
         throw new Error('Method not implemented.');

package/lib/common/externals/index.d.ts

@@ -4,14 +4,6 @@ export interface Externals {
         decompressBall: (buffer: Uint8Array<ArrayBuffer>, options?: {
             stripLevel?: number;
         }) => Promise<DecompressedFile[]>;
-        gzip: (buffer: Uint8Array<ArrayBuffer>) => Promise<Uint8Array<ArrayBuffer>>;
-        gunzip: (buffer: Uint8Array<ArrayBuffer>) => Promise<Uint8Array<ArrayBuffer>>;
-    };
-    crypto: {
-        /**
-         * @returns SHA-1 digest of the given data in hexadecimal format.
-         */
-        getSha1: (data: string | Uint8Array<ArrayBuffer>) => Promise<string>;
     };
     error: {
         /**
@@ -23,12 +15,8 @@ export interface Externals {
          */
         isKind: (e: unknown, kind: ExternalErrorKind) => boolean;
     };
-    event: {
-        EventEmitter: new () => ExternalEventEmitter;
-    };
     fs: ExternalFileSystem;
     web: {
-        fetch: typeof fetch;
         getCache: () => Promise<Cache>;
     };
 }
@@ -40,11 +28,6 @@ export interface DecompressedFile {
     type: string;
 }
 export type ExternalErrorKind = 'EEXIST' | 'EISDIR' | 'ENOENT';
-export interface ExternalEventEmitter {
-    emit(eventName: string, ...args: unknown[]): boolean;
-    on(eventName: string, listener: (...args: unknown[]) => unknown): this;
-    once(eventName: string, listener: (...args: unknown[]) => unknown): this;
-}
 export interface ExternalFileSystem {
     /**
      * @param mode File mode bit mask (e.g. `0o775`).

package/lib/common/index.d.ts

@@ -1,4 +1,5 @@
 export * from './Dev.js';
+export * from './EventDispatcher.js';
 export * from './externals/index.js';
 export * from './json.js';
 export * from './Logger.js';

package/lib/common/index.js

@@ -1,4 +1,5 @@
 export * from './Dev.js';
+export * from './EventDispatcher.js';
 export * from './externals/index.js';
 export * from './json.js';
 export * from './Logger.js';

package/lib/common/util.d.ts

@@ -1,7 +1,6 @@
 import externalBinarySearch from 'binary-search';
 import type { AstNode } from '../node/index.js';
 import type { ProcessorContext } from '../service/index.js';
-import type { Externals } from './externals/index.js';
 import type { DeepReadonly, ReadWrite } from './ReadonlyProxy.js';
 export declare const Uri: {
     new (url: string | URL, base?: string | URL): URL;
@@ -77,7 +76,7 @@ export declare namespace TypePredicates {
     function isString(value: unknown): value is string;
 }
 export declare function promisifyAsyncIterable<T, U>(iterable: AsyncIterable<T>, joiner: (chunks: T[]) => U): Promise<U>;
-export declare function parseGzippedJson(externals: Externals, buffer: Uint8Array<ArrayBuffer>): Promise<unknown>;
+export declare function parseGzippedJson(bytes: Uint8Array<ArrayBuffer>): Promise<unknown>;
 /**
  * @returns Is Plain Old JavaScript Object (POJO).
  */
@@ -110,17 +109,26 @@ export declare namespace Lazy {
 export declare function getStates(category: 'block' | 'fluid', ids: readonly string[], ctx: ProcessorContext): Record<string, string[]>;
 export declare const binarySearch: typeof externalBinarySearch;
 export declare function isIterable(value: unknown): value is Iterable<unknown>;
-export declare function atArray<T>(array: readonly T[] | undefined, index: number): T | undefined;
-export declare function emplaceMap<K, V>(map: Map<K, V>, key: K, handler: {
-    insert?: (key: K, map: Map<K, V>) => V;
-    update?: (existing: V, key: K, map: Map<K, V>) => V;
-}): V;
+export declare function getOrInsert<K, V>(map: Map<K, V>, key: K, defaultValue: V): V;
+export declare function getOrInsertComputed<K, V>(map: Map<K, V>, key: K, callbackFunction: (key: K) => V): V;
+/**
+ * TODO: replace with ESNext Uint8Array.prototype.toHex once it's widely supported
+ */
+export declare function bytesToHex(bytes: Uint8Array): string;
 /**
  * @returns If `val` is an non-null object or a callable object (i.e. function).
  */
 export declare function isObject(val: unknown): val is object;
 export declare function normalizeUriPathname(pathname: string): string;
 export declare function normalizeUri(uri: string): string;
+export declare function getSha1(data: string | Uint8Array<ArrayBuffer>): Promise<string>;
+export declare function compressBytes(bytes: Uint8Array<ArrayBuffer>, algorithm: CompressionFormat): Promise<Uint8Array<ArrayBuffer>>;
+export declare function compressStream(stream: ReadableStream<Uint8Array<ArrayBuffer>>, algorithm: CompressionFormat): ReadableStream<Uint8Array<ArrayBuffer>>;
+export declare function decompressBytes(bytes: Uint8Array<ArrayBuffer>, algorithm: CompressionFormat): Promise<Uint8Array<ArrayBuffer>>;
+export declare function decompressStream(stream: ReadableStream<Uint8Array<ArrayBuffer>>, algorithm: CompressionFormat): ReadableStream<Uint8Array<ArrayBuffer>>;
+export declare function bytesToStream(bytes: Uint8Array<ArrayBuffer>): ReadableStream<Uint8Array<ArrayBuffer>>;
+export declare function streamToBytes(stream: ReadableStream<Uint8Array<ArrayBuffer>>): Promise<Uint8Array<ArrayBuffer>>;
+export declare function sleep(delayMs: number): Promise<void>;
 /**
  * Return a read-write TARGET type if the INPUT type is read-write, and a
  * readonly TARGET type if the INPUT type is readonly, and `never` if the INPUT